arch/alpha/include/asm/elf.h

113

struct thread_info *ti);

arch/alpha/kernel/process.c

286

dump_elf_thread(elf_greg_t *dest, struct pt_regs *pt, struct thread_info *ti)

arch/alpha/kernel/process.c

321

dest[30] = ti == current_thread_info() ? rdusp() : ti->pcb.usp;

arch/alpha/kernel/process.c

327

dest[32] = ti->pcb.unique;

arch/arm/include/asm/assembler.h

229

.macro inc_preempt_count, ti, tmp

arch/arm/include/asm/assembler.h

235

.macro dec_preempt_count, ti, tmp

arch/arm/include/asm/assembler.h

241

.macro inc_preempt_count, ti, tmp

arch/arm/include/asm/assembler.h

244

.macro dec_preempt_count, ti, tmp

arch/arm/include/asm/thread_info.h

84

static inline struct task_struct *thread_task(struct thread_info* ti)

arch/arm/include/asm/thread_info.h

86

return (struct task_struct *)ti;

arch/arm/kernel/kgdb.c

100

gdb_regs[_PC] = ti->cpu_context.pc;

arch/arm/kernel/kgdb.c

78

struct thread_info *ti;

arch/arm/kernel/kgdb.c

90

ti = task_thread_info(task);

arch/arm/kernel/kgdb.c

91

gdb_regs[_R4] = ti->cpu_context.r4;

arch/arm/kernel/kgdb.c

92

gdb_regs[_R5] = ti->cpu_context.r5;

arch/arm/kernel/kgdb.c

93

gdb_regs[_R6] = ti->cpu_context.r6;

arch/arm/kernel/kgdb.c

94

gdb_regs[_R7] = ti->cpu_context.r7;

arch/arm/kernel/kgdb.c

95

gdb_regs[_R8] = ti->cpu_context.r8;

arch/arm/kernel/kgdb.c

96

gdb_regs[_R9] = ti->cpu_context.r9;

arch/arm/kernel/kgdb.c

97

gdb_regs[_R10] = ti->cpu_context.sl;

arch/arm/kernel/kgdb.c

98

gdb_regs[_FP] = ti->cpu_context.fp;

arch/arm/kernel/kgdb.c

99

gdb_regs[_SPT] = ti->cpu_context.sp;

arch/arm/vfp/vfpmodule.c

482

struct thread_info *ti = current_thread_info();

arch/arm/vfp/vfpmodule.c

488

vfp_save_state(&ti->vfpstate, fpexc);

arch/arm/vfp/vfpmodule.c

492

} else if (vfp_current_hw_state[ti->cpu]) {

arch/arm/vfp/vfpmodule.c

495

vfp_save_state(vfp_current_hw_state[ti->cpu], fpexc);

arch/arm/vfp/vfpmodule.c

501

vfp_current_hw_state[ti->cpu] = NULL;

arch/arm/vfp/vfpmodule.c

708

struct thread_info *ti = current_thread_info();

arch/arm/vfp/vfpmodule.c

742

if (!vfp_state_in_hw(ti->cpu, ti)) {

arch/arm/vfp/vfpmodule.c

744

vfp_current_hw_state[ti->cpu] != NULL) {

arch/arm/vfp/vfpmodule.c

750

vfp_save_state(vfp_current_hw_state[ti->cpu],

arch/arm/vfp/vfpmodule.c

758

fpexc = vfp_load_state(&ti->vfpstate);

arch/arm/vfp/vfpmodule.c

759

vfp_current_hw_state[ti->cpu] = &ti->vfpstate;

arch/arm/vfp/vfpmodule.c

765

ti->vfpstate.hard.cpu = ti->cpu;

arch/arm64/include/asm/preempt.h

60

struct thread_info *ti = current_thread_info();

arch/arm64/include/asm/preempt.h

61

u64 pc = READ_ONCE(ti->preempt_count);

arch/arm64/include/asm/preempt.h

64

WRITE_ONCE(ti->preempt.count, --pc);

arch/arm64/include/asm/preempt.h

73

return !pc || !READ_ONCE(ti->preempt_count);

arch/arm64/kernel/debug-monitors.c

384

struct thread_info *ti = task_thread_info(task);

arch/arm64/kernel/debug-monitors.c

386

if (!test_and_set_ti_thread_flag(ti, TIF_SINGLESTEP))

arch/arm64/kernel/process.c

629

struct thread_info *ti = task_thread_info(next);

arch/arm64/kernel/process.c

631

if (test_ti_thread_flag(ti, TIF_TSC_SIGSEGV) ||

arch/arm64/kernel/process.c

635

is_compat_thread(ti)))

arch/arm64/kernel/process.c

887

struct thread_info *ti = task_thread_info(task);

arch/arm64/kernel/process.c

889

if (is_compat_thread(ti))

arch/arm64/kernel/process.c

913

update_ti_thread_flag(ti, TIF_TAGGED_ADDR, arg & PR_TAGGED_ADDR_ENABLE);

arch/arm64/kernel/process.c

921

struct thread_info *ti = task_thread_info(task);

arch/arm64/kernel/process.c

923

if (is_compat_thread(ti))

arch/arm64/kernel/process.c

926

if (test_ti_thread_flag(ti, TIF_TAGGED_ADDR))

arch/csky/kernel/syscall.c

12

ti->tp_value = addr;

arch/csky/kernel/syscall.c

8

struct thread_info *ti = task_thread_info(current);

arch/hexagon/kernel/process.c

58

struct thread_info *ti = task_thread_info(p);

arch/hexagon/kernel/process.c

63

childregs = (struct pt_regs *) (((unsigned long) ti + THREAD_SIZE) -

arch/hexagon/kernel/process.c

66

ti->regs = childregs;

arch/loongarch/kernel/ptrace.c

1084

struct thread_info *ti = task_thread_info(task);

arch/loongarch/kernel/ptrace.c

1088

set_ti_thread_flag(ti, TIF_SINGLESTEP);

arch/loongarch/kernel/ptrace.c

592

struct thread_info *ti = task_thread_info(tsk);

arch/loongarch/kernel/ptrace.c

617

set_ti_thread_flag(ti, TIF_LOAD_WATCH);

arch/loongarch/kernel/ptrace.c

620

clear_ti_thread_flag(ti, TIF_LOAD_WATCH);

arch/m68k/include/asm/thread_info.h

46

struct thread_info *ti;

arch/m68k/include/asm/thread_info.h

50

: "=&d"(ti)

arch/m68k/include/asm/thread_info.h

53

return ti;

arch/microblaze/kernel/process.c

101

ti->cpu_context.msr = (childregs->msr|MSR_VM);

arch/microblaze/kernel/process.c

102

ti->cpu_context.msr &= ~MSR_UMS; /* switch_to to kernel mode */

arch/microblaze/kernel/process.c

103

ti->cpu_context.msr &= ~MSR_IE;

arch/microblaze/kernel/process.c

104

ti->cpu_context.r15 = (unsigned long)ret_from_fork - 8;

arch/microblaze/kernel/process.c

61

struct thread_info *ti = task_thread_info(p);

arch/microblaze/kernel/process.c

67

memset(&ti->cpu_context, 0, sizeof(struct cpu_context));

arch/microblaze/kernel/process.c

68

ti->cpu_context.r1 = (unsigned long)childregs;

arch/microblaze/kernel/process.c

69

ti->cpu_context.r20 = (unsigned long)args->fn;

arch/microblaze/kernel/process.c

70

ti->cpu_context.r19 = (unsigned long)args->fn_arg;

arch/microblaze/kernel/process.c

73

ti->cpu_context.msr = childregs->msr & ~MSR_IE;

arch/microblaze/kernel/process.c

74

ti->cpu_context.r15 = (unsigned long)ret_from_kernel_thread - 8;

arch/microblaze/kernel/process.c

81

memset(&ti->cpu_context, 0, sizeof(struct cpu_context));

arch/microblaze/kernel/process.c

82

ti->cpu_context.r1 = (unsigned long)childregs;

arch/mips/kernel/mips-mt-fpaff.c

122

ti = task_thread_info(p);

arch/mips/kernel/mips-mt-fpaff.c

123

if (test_ti_thread_flag(ti, TIF_FPUBOUND) &&

arch/mips/kernel/mips-mt-fpaff.c

129

clear_ti_thread_flag(ti, TIF_FPUBOUND);

arch/mips/kernel/mips-mt-fpaff.c

70

struct thread_info *ti;

arch/mips/kernel/process.c

113

struct thread_info *ti = task_thread_info(p);

arch/mips/kernel/process.c

172

ti->tp_value = tls;

arch/mips/kernel/syscall.c

89

struct thread_info *ti = task_thread_info(current);

arch/mips/kernel/syscall.c

91

ti->tp_value = addr;

arch/mips/kernel/traps.c

639

struct thread_info *ti = task_thread_info(current);

arch/mips/kernel/traps.c

665

regs->regs[rt] = ti->tp_value;

arch/mips/lib/libgcc.h

39

ti_type ti;

arch/mips/lib/multi3.c

37

aa.ti = a;

arch/mips/lib/multi3.c

38

bb.ti = b;

arch/mips/lib/multi3.c

50

return res.ti;

arch/openrisc/include/asm/thread_info.h

75

#define get_thread_info(ti) get_task_struct((ti)->task)

arch/openrisc/include/asm/thread_info.h

76

#define put_thread_info(ti) put_task_struct((ti)->task)

arch/powerpc/include/asm/thread_info.h

168

struct thread_info *ti = current_thread_info();

arch/powerpc/include/asm/thread_info.h

169

ti->local_flags &= ~flags;

arch/powerpc/include/asm/thread_info.h

174

struct thread_info *ti = current_thread_info();

arch/powerpc/include/asm/thread_info.h

175

return (ti->local_flags & flags) != 0;

arch/powerpc/kernel/process.c

2363

struct thread_info *ti = current_thread_info();

arch/powerpc/kernel/process.c

2384

ti->local_flags |= _TLF_RUNLATCH;

arch/powerpc/kernel/process.c

2390

struct thread_info *ti = current_thread_info();

arch/powerpc/kernel/process.c

2392

ti->local_flags &= ~_TLF_RUNLATCH;

arch/powerpc/kernel/syscalls.c

113

struct thread_info *ti;

arch/powerpc/kernel/syscalls.c

123

ti = current_thread_info();

arch/powerpc/kernel/syscalls.c

124

ti->flags |= _TIF_RESTOREALL;

arch/powerpc/mm/book3s64/slb.c

292

static bool preload_hit(struct thread_info *ti, unsigned long esid)

arch/powerpc/mm/book3s64/slb.c

296

for (i = 0; i < ti->slb_preload_nr; i++) {

arch/powerpc/mm/book3s64/slb.c

299

idx = (ti->slb_preload_tail + i) % SLB_PRELOAD_NR;

arch/powerpc/mm/book3s64/slb.c

300

if (esid == ti->slb_preload_esid[idx])

arch/powerpc/mm/book3s64/slb.c

306

static void preload_add(struct thread_info *ti, unsigned long ea)

arch/powerpc/mm/book3s64/slb.c

322

if (preload_hit(ti, esid))

arch/powerpc/mm/book3s64/slb.c

325

idx = (ti->slb_preload_tail + ti->slb_preload_nr) % SLB_PRELOAD_NR;

arch/powerpc/mm/book3s64/slb.c

326

ti->slb_preload_esid[idx] = esid;

arch/powerpc/mm/book3s64/slb.c

327

if (ti->slb_preload_nr == SLB_PRELOAD_NR)

arch/powerpc/mm/book3s64/slb.c

328

ti->slb_preload_tail = (ti->slb_preload_tail + 1) % SLB_PRELOAD_NR;

arch/powerpc/mm/book3s64/slb.c

330

ti->slb_preload_nr++;

arch/powerpc/mm/book3s64/slb.c

333

static void preload_age(struct thread_info *ti)

arch/powerpc/mm/book3s64/slb.c

335

if (!ti->slb_preload_nr)

arch/powerpc/mm/book3s64/slb.c

337

ti->slb_preload_nr--;

arch/powerpc/mm/book3s64/slb.c

338

ti->slb_preload_tail = (ti->slb_preload_tail + 1) % SLB_PRELOAD_NR;

arch/powerpc/mm/book3s64/slb.c

369

struct thread_info *ti = task_thread_info(tsk);

arch/powerpc/mm/book3s64/slb.c

440

preload_age(ti);

arch/powerpc/mm/book3s64/slb.c

441

preload_add(ti, pc);

arch/powerpc/mm/book3s64/slb.c

444

for (i = 0; i < ti->slb_preload_nr; i++) {

arch/powerpc/mm/book3s64/slb.c

448

idx = (ti->slb_preload_tail + i) % SLB_PRELOAD_NR;

arch/powerpc/mm/book3s64/slb.c

449

ea = (unsigned long)ti->slb_preload_esid[idx] << SID_SHIFT;

arch/riscv/kernel/process.c

313

struct thread_info *ti = task_thread_info(task);

arch/riscv/kernel/process.c

321

if (is_compat_thread(ti))

arch/riscv/kernel/process.c

375

struct thread_info *ti = task_thread_info(task);

arch/riscv/kernel/process.c

381

if (is_compat_thread(ti))

arch/s390/kernel/cache.c

100

return __ecag(ECAG_CACHE_ATTRIBUTE, ai << 4 | li << 1 | ti);

arch/s390/kernel/cache.c

106

int ti, num_sets;

arch/s390/kernel/cache.c

109

ti = CACHE_TI_INSTRUCTION;

arch/s390/kernel/cache.c

111

ti = CACHE_TI_UNIFIED;

arch/s390/kernel/cache.c

114

this_leaf->coherency_line_size = ecag(EXTRACT_LINE_SIZE, level, ti);

arch/s390/kernel/cache.c

115

this_leaf->ways_of_associativity = ecag(EXTRACT_ASSOCIATIVITY, level, ti);

arch/s390/kernel/cache.c

116

this_leaf->size = ecag(EXTRACT_SIZE, level, ti);

arch/s390/kernel/cache.c

98

static inline unsigned long ecag(int ai, int li, int ti)

arch/s390/lib/tishift.c

17

union ti ti = { .val = a };

arch/s390/lib/tishift.c

20

return ti.val;

arch/s390/lib/tishift.c

22

ti.high = (ti.high << shift) | (ti.low >> (64 - shift));

arch/s390/lib/tishift.c

23

ti.low = ti.low << shift;

arch/s390/lib/tishift.c

25

ti.high = ti.low << (shift - 64);

arch/s390/lib/tishift.c

26

ti.low = 0;

arch/s390/lib/tishift.c

28

return ti.val;

arch/s390/lib/tishift.c

34

union ti ti = { .val = a };

arch/s390/lib/tishift.c

37

return ti.val;

arch/s390/lib/tishift.c

39

ti.low = (ti.low >> shift) | (ti.high << (64 - shift));

arch/s390/lib/tishift.c

40

ti.high = (int64_t)ti.high >> shift;

arch/s390/lib/tishift.c

42

ti.low = (int64_t)ti.high >> (shift - 64);

arch/s390/lib/tishift.c

43

ti.high = (int64_t)ti.high >> 63;

arch/s390/lib/tishift.c

45

return ti.val;

arch/s390/lib/tishift.c

51

union ti ti = { .val = a };

arch/s390/lib/tishift.c

54

return ti.val;

arch/s390/lib/tishift.c

56

ti.low = (ti.low >> shift) | (ti.high << (64 - shift));

arch/s390/lib/tishift.c

57

ti.high = ti.high >> shift;

arch/s390/lib/tishift.c

59

ti.low = ti.high >> (shift - 64);

arch/s390/lib/tishift.c

60

ti.high = 0;

arch/s390/lib/tishift.c

62

return ti.val;

arch/sh/include/asm/thread_info.h

156

struct thread_info *ti = current_thread_info();

arch/sh/include/asm/thread_info.h

157

ti->flags = (ti->flags & (~0 >> (32 - TI_FLAG_FAULT_CODE_SHIFT)))

arch/sh/include/asm/thread_info.h

163

struct thread_info *ti = current_thread_info();

arch/sh/include/asm/thread_info.h

164

return ti->flags >> TI_FLAG_FAULT_CODE_SHIFT;

arch/sh/include/asm/thread_info.h

68

struct thread_info *ti;

arch/sh/include/asm/thread_info.h

70

__asm__ __volatile__ ("stc r7_bank, %0" : "=r" (ti));

arch/sh/include/asm/thread_info.h

77

: "=&r" (ti), "=r" (__dummy)

arch/sh/include/asm/thread_info.h

82

return ti;

arch/sh/kernel/process_32.c

123

ti->status &= ~TS_USEDFPU;

arch/sh/kernel/process_32.c

95

struct thread_info *ti = task_thread_info(p);

arch/sparc/include/asm/thread_info_64.h

137

#define __thread_flag_byte_ptr(ti) \

arch/sparc/include/asm/thread_info_64.h

138

((unsigned char *)(&((ti)->flags)))

arch/sparc/kernel/process_32.c

267

struct thread_info *ti = task_thread_info(p);

arch/sparc/kernel/process_32.c

299

ti->ksp = (unsigned long) new_stack;

arch/sparc/kernel/process_32.c

306

ti->kpc = (((unsigned long) ret_from_kernel_thread) - 0x8);

arch/sparc/kernel/process_32.c

310

ti->kpsr = psr | PSR_PIL;

arch/sparc/kernel/process_32.c

311

ti->kwim = 1 << (((psr & PSR_CWP) + 1) % nwindows);

arch/sparc/kernel/process_32.c

316

ti->kpc = (((unsigned long) ret_from_fork) - 0x8);

arch/sparc/kernel/process_32.c

317

ti->kpsr = current->thread.fork_kpsr | PSR_PIL;

arch/sparc/kernel/process_32.c

318

ti->kwim = current->thread.fork_kwim;

arch/x86/kernel/cpu/bugs.c

189

struct thread_info *ti = current_thread_info();

arch/x86/kernel/cpu/bugs.c

207

hostval = ssbd_tif_to_spec_ctrl(ti->flags);

arch/x86/kernel/uprobes.c

1840

struct thread_info *ti = current_thread_info();

arch/x86/kernel/uprobes.c

1853

ti->status |= TS_COMPAT;

arch/x86/kernel/uprobes.c

1855

ti->status &= ~TS_COMPAT;

arch/x86/xen/time.c

450

struct pvclock_vsyscall_time_info *ti;

arch/x86/xen/time.c

453

ti = (struct pvclock_vsyscall_time_info *)get_zeroed_page(GFP_KERNEL);

arch/x86/xen/time.c

454

if (!ti)

arch/x86/xen/time.c

457

t.addr.v = &ti->pvti;

arch/x86/xen/time.c

462

free_page((unsigned long)ti);

arch/x86/xen/time.c

471

if (!(ti->pvti.flags & PVCLOCK_TSC_STABLE_BIT)) {

arch/x86/xen/time.c

476

free_page((unsigned long)ti);

arch/x86/xen/time.c

482

xen_clock = ti;

arch/xtensa/include/asm/coprocessor.h

146

void coprocessor_flush(struct thread_info *ti, int cp_index);

arch/xtensa/include/asm/coprocessor.h

147

void coprocessor_release_all(struct thread_info *ti);

arch/xtensa/include/asm/coprocessor.h

148

void coprocessor_flush_all(struct thread_info *ti);

arch/xtensa/include/asm/coprocessor.h

149

void coprocessor_flush_release_all(struct thread_info *ti);

arch/xtensa/include/asm/thread_info.h

96

struct thread_info *ti;

arch/xtensa/include/asm/thread_info.h

98

"xor %0, a1, %0" : "=&r" (ti) : );

arch/xtensa/include/asm/thread_info.h

99

return ti;

arch/xtensa/kernel/process.c

103

struct thread_info *ti = info;

arch/xtensa/kernel/process.c

112

if (coprocessor_owner[i] == ti)

arch/xtensa/kernel/process.c

117

ti->cpenable = 0;

arch/xtensa/kernel/process.c

118

if (ti == current_thread_info())

arch/xtensa/kernel/process.c

122

void coprocessor_release_all(struct thread_info *ti)

arch/xtensa/kernel/process.c

124

if (ti->cpenable) {

arch/xtensa/kernel/process.c

127

smp_call_function_single(ti->cp_owner_cpu,

arch/xtensa/kernel/process.c

129

ti, true);

arch/xtensa/kernel/process.c

135

struct thread_info *ti = info;

arch/xtensa/kernel/process.c

141

old_cpenable = xtensa_xsr(ti->cpenable, cpenable);

arch/xtensa/kernel/process.c

144

if (coprocessor_owner[i] == ti)

arch/xtensa/kernel/process.c

145

coprocessor_flush(ti, i);

arch/xtensa/kernel/process.c

150

void coprocessor_flush_all(struct thread_info *ti)

arch/xtensa/kernel/process.c

152

if (ti->cpenable) {

arch/xtensa/kernel/process.c

155

smp_call_function_single(ti->cp_owner_cpu,

arch/xtensa/kernel/process.c

157

ti, true);

arch/xtensa/kernel/process.c

167

void coprocessor_flush_release_all(struct thread_info *ti)

arch/xtensa/kernel/process.c

169

if (ti->cpenable) {

arch/xtensa/kernel/process.c

172

smp_call_function_single(ti->cp_owner_cpu,

arch/xtensa/kernel/process.c

174

ti, true);

arch/xtensa/kernel/process.c

207

struct thread_info *ti = current_thread_info();

arch/xtensa/kernel/process.c

208

coprocessor_flush_release_all(ti);

arch/xtensa/kernel/process.c

276

struct thread_info *ti;

arch/xtensa/kernel/process.c

363

ti = task_thread_info(p);

arch/xtensa/kernel/process.c

364

ti->cpenable = 0;

arch/xtensa/kernel/process.c

79

struct thread_info *ti = coprocessor_owner[i];

arch/xtensa/kernel/process.c

81

if (ti) {

arch/xtensa/kernel/process.c

82

coprocessor_flush(ti, i);

arch/xtensa/kernel/process.c

85

if (unique_owner[j] == ti)

arch/xtensa/kernel/process.c

88

unique_owner[n++] = ti;

arch/xtensa/kernel/ptrace.c

125

struct thread_info *ti = task_thread_info(target);

arch/xtensa/kernel/ptrace.c

132

newregs->user = ti->xtregs_user;

arch/xtensa/kernel/ptrace.c

136

coprocessor_flush_all(ti);

arch/xtensa/kernel/ptrace.c

137

newregs->cp0 = ti->xtregs_cp.cp0;

arch/xtensa/kernel/ptrace.c

138

newregs->cp1 = ti->xtregs_cp.cp1;

arch/xtensa/kernel/ptrace.c

139

newregs->cp2 = ti->xtregs_cp.cp2;

arch/xtensa/kernel/ptrace.c

140

newregs->cp3 = ti->xtregs_cp.cp3;

arch/xtensa/kernel/ptrace.c

141

newregs->cp4 = ti->xtregs_cp.cp4;

arch/xtensa/kernel/ptrace.c

142

newregs->cp5 = ti->xtregs_cp.cp5;

arch/xtensa/kernel/ptrace.c

143

newregs->cp6 = ti->xtregs_cp.cp6;

arch/xtensa/kernel/ptrace.c

144

newregs->cp7 = ti->xtregs_cp.cp7;

arch/xtensa/kernel/ptrace.c

158

struct thread_info *ti = task_thread_info(target);

arch/xtensa/kernel/ptrace.c

170

ti->xtregs_user = newregs->user;

arch/xtensa/kernel/ptrace.c

174

coprocessor_flush_release_all(ti);

arch/xtensa/kernel/ptrace.c

175

ti->xtregs_cp.cp0 = newregs->cp0;

arch/xtensa/kernel/ptrace.c

176

ti->xtregs_cp.cp1 = newregs->cp1;

arch/xtensa/kernel/ptrace.c

177

ti->xtregs_cp.cp2 = newregs->cp2;

arch/xtensa/kernel/ptrace.c

178

ti->xtregs_cp.cp3 = newregs->cp3;

arch/xtensa/kernel/ptrace.c

179

ti->xtregs_cp.cp4 = newregs->cp4;

arch/xtensa/kernel/ptrace.c

180

ti->xtregs_cp.cp5 = newregs->cp5;

arch/xtensa/kernel/ptrace.c

181

ti->xtregs_cp.cp6 = newregs->cp6;

arch/xtensa/kernel/ptrace.c

182

ti->xtregs_cp.cp7 = newregs->cp7;

arch/xtensa/kernel/signal.c

147

struct thread_info *ti = current_thread_info();

arch/xtensa/kernel/signal.c

167

coprocessor_flush_release_all(ti);

arch/xtensa/kernel/signal.c

168

err |= __copy_to_user(&frame->xtregs.cp, &ti->xtregs_cp,

arch/xtensa/kernel/signal.c

173

err |= __copy_to_user(&frame->xtregs.user, &ti->xtregs_user,

arch/xtensa/kernel/signal.c

185

struct thread_info *ti = current_thread_info();

arch/xtensa/kernel/signal.c

231

coprocessor_release_all(ti);

arch/xtensa/kernel/signal.c

232

err |= __copy_from_user(&ti->xtregs_cp, &frame->xtregs.cp,

arch/xtensa/kernel/signal.c

235

err |= __copy_from_user(&ti->xtregs_user, &frame->xtregs.user,

block/blk-settings.c

1001

ti->flags = BLK_INTEGRITY_STACKED;

block/blk-settings.c

1002

ti->flags |= (bi->flags & BLK_INTEGRITY_DEVICE_CAPABLE) |

block/blk-settings.c

1005

ti->csum_type = bi->csum_type;

block/blk-settings.c

1006

ti->pi_tuple_size = bi->pi_tuple_size;

block/blk-settings.c

1007

ti->metadata_size = bi->metadata_size;

block/blk-settings.c

1008

ti->pi_offset = bi->pi_offset;

block/blk-settings.c

1009

ti->interval_exp = bi->interval_exp;

block/blk-settings.c

1010

ti->tag_size = bi->tag_size;

block/blk-settings.c

1015

memset(ti, 0, sizeof(*ti));

block/blk-settings.c

977

struct blk_integrity *ti = &t->integrity;

block/blk-settings.c

983

if (ti->flags & BLK_INTEGRITY_STACKED) {

block/blk-settings.c

984

if (ti->metadata_size != bi->metadata_size)

block/blk-settings.c

986

if (ti->interval_exp != bi->interval_exp)

block/blk-settings.c

988

if (ti->tag_size != bi->tag_size)

block/blk-settings.c

990

if (ti->csum_type != bi->csum_type)

block/blk-settings.c

992

if (ti->pi_tuple_size != bi->pi_tuple_size)

block/blk-settings.c

994

if ((ti->flags & BLK_INTEGRITY_REF_TAG) !=

block/blk-settings.c

997

if ((ti->flags & BLK_SPLIT_INTERVAL_CAPABLE) &&

block/blk-settings.c

999

ti->flags &= ~BLK_SPLIT_INTERVAL_CAPABLE;

drivers/cdrom/cdrom.c

2700

struct cdrom_ti ti;

drivers/cdrom/cdrom.c

2707

if (copy_from_user(&ti, argp, sizeof(ti)))

drivers/cdrom/cdrom.c

2713

return cdi->ops->audio_ioctl(cdi, CDROMPLAYTRKIND, &ti);

drivers/cdrom/cdrom.c

2794

__u16 track, __u8 type, track_information *ti)

drivers/cdrom/cdrom.c

2800

init_cdrom_command(&cgc, ti, 8, CGC_DATA_READ);

drivers/cdrom/cdrom.c

2812

buflen = be16_to_cpu(ti->track_information_length) +

drivers/cdrom/cdrom.c

2813

sizeof(ti->track_information_length);

drivers/cdrom/cdrom.c

2833

track_information ti;

drivers/cdrom/cdrom.c

2847

ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);

drivers/cdrom/cdrom.c

2848

if (ti_size < (int)offsetof(typeof(ti), track_start))

drivers/cdrom/cdrom.c

2852

if (ti.blank) {

drivers/cdrom/cdrom.c

2856

ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);

drivers/cdrom/cdrom.c

2859

if (ti_size < (int)(offsetof(typeof(ti), track_size)

drivers/cdrom/cdrom.c

2860

+ sizeof(ti.track_size)))

drivers/cdrom/cdrom.c

2864

if (ti.lra_v && ti_size >= (int)(offsetof(typeof(ti), last_rec_address)

drivers/cdrom/cdrom.c

2865

+ sizeof(ti.last_rec_address))) {

drivers/cdrom/cdrom.c

2866

*last_written = be32_to_cpu(ti.last_rec_address);

drivers/cdrom/cdrom.c

2869

*last_written = be32_to_cpu(ti.track_start) +

drivers/cdrom/cdrom.c

2870

be32_to_cpu(ti.track_size);

drivers/cdrom/cdrom.c

2871

if (ti.free_blocks)

drivers/cdrom/cdrom.c

2872

*last_written -= (be32_to_cpu(ti.free_blocks) + 7);

drivers/cdrom/cdrom.c

2899

track_information ti;

drivers/cdrom/cdrom.c

2913

ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);

drivers/cdrom/cdrom.c

2914

if (ti_size < 0 || ti_size < offsetof(typeof(ti), track_start))

drivers/cdrom/cdrom.c

2918

if (ti.blank) {

drivers/cdrom/cdrom.c

2922

ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);

drivers/cdrom/cdrom.c

2928

if (ti.nwa_v && ti_size >= offsetof(typeof(ti), next_writable)

drivers/cdrom/cdrom.c

2929

+ sizeof(ti.next_writable)) {

drivers/cdrom/cdrom.c

2930

*next_writable = be32_to_cpu(ti.next_writable);

drivers/clocksource/timer-ti-32k.c

60

struct ti_32k *ti = to_ti_32k(cs);

drivers/clocksource/timer-ti-32k.c

62

return (u64)readl_relaxed(ti->counter);

drivers/crypto/ccp/sev-dev-tio.c

728

struct sev_data_tio_init ti = { .length = sizeof(ti) };

drivers/crypto/ccp/sev-dev-tio.c

730

ret = __sev_do_cmd_locked(SEV_CMD_TIO_INIT, &ti, &psp_ret);

drivers/gpu/drm/amd/amdgpu/amdgpu_debugfs.c

1874

struct amdgpu_task_info *ti;

drivers/gpu/drm/amd/amdgpu/amdgpu_debugfs.c

1876

ti = amdgpu_vm_get_task_info_vm(vm);

drivers/gpu/drm/amd/amdgpu/amdgpu_debugfs.c

1877

if (ti) {

drivers/gpu/drm/amd/amdgpu/amdgpu_debugfs.c

1878

seq_printf(m, "pid:%d\tProcess:%s ----------\n", ti->task.pid, ti->process_name);

drivers/gpu/drm/amd/amdgpu/amdgpu_debugfs.c

1879

amdgpu_vm_put_task_info(ti);

drivers/gpu/drm/amd/amdgpu/amdgpu_dev_coredump.c

564

struct amdgpu_task_info *ti;

drivers/gpu/drm/amd/amdgpu/amdgpu_dev_coredump.c

566

ti = amdgpu_vm_get_task_info_pasid(adev, job->pasid);

drivers/gpu/drm/amd/amdgpu/amdgpu_dev_coredump.c

567

if (ti) {

drivers/gpu/drm/amd/amdgpu/amdgpu_dev_coredump.c

568

coredump->reset_task_info = *ti;

drivers/gpu/drm/amd/amdgpu/amdgpu_dev_coredump.c

569

amdgpu_vm_put_task_info(ti);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c

5920

struct amdgpu_task_info *ti = NULL;

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c

5927

ti = amdgpu_vm_get_task_info_pasid(adev, pasid);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c

5930

ti ? &ti->task : NULL);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c

5932

amdgpu_vm_put_task_info(ti);

drivers/gpu/drm/amd/amdgpu/amdgpu_gem.c

297

struct amdgpu_task_info *ti = amdgpu_vm_get_task_info_vm(vm);

drivers/gpu/drm/amd/amdgpu/amdgpu_gem.c

300

if (ti) {

drivers/gpu/drm/amd/amdgpu/amdgpu_gem.c

301

dev_warn(adev->dev, "pid %d\n", ti->task.pid);

drivers/gpu/drm/amd/amdgpu/amdgpu_gem.c

302

amdgpu_vm_put_task_info(ti);

drivers/gpu/drm/amd/amdgpu/amdgpu_job.c

126

ti = amdgpu_vm_get_task_info_pasid(ring->adev, job->pasid);

drivers/gpu/drm/amd/amdgpu/amdgpu_job.c

127

if (ti) {

drivers/gpu/drm/amd/amdgpu/amdgpu_job.c

128

amdgpu_vm_print_task_info(adev, ti);

drivers/gpu/drm/amd/amdgpu/amdgpu_job.c

129

info = &ti->task;

drivers/gpu/drm/amd/amdgpu/amdgpu_job.c

182

amdgpu_vm_put_task_info(ti);

drivers/gpu/drm/amd/amdgpu/amdgpu_job.c

93

struct amdgpu_task_info *ti = NULL;

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c

2456

struct amdgpu_task_info *ti = container_of(kref, struct amdgpu_task_info, refcount);

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c

2458

kfree(ti);

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c

2485

struct amdgpu_task_info *ti = NULL;

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c

2488

ti = vm->task_info;

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c

2492

return ti;

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c

2507

struct amdgpu_task_info *ti;

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c

2513

ti = amdgpu_vm_get_task_info_vm(vm);

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c

2516

return ti;

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c

2815

struct amdgpu_task_info *ti = vm->task_info;

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c

2819

ti->process_name, ti->task.pid, ti->task.comm, ti->tgid);

drivers/gpu/drm/amd/amdkfd/kfd_events.c

1300

struct amdgpu_task_info *ti;

drivers/gpu/drm/amd/amdkfd/kfd_events.c

1309

ti = amdgpu_vm_get_task_info_vm(&drv_priv->vm);

drivers/gpu/drm/amd/amdkfd/kfd_events.c

1310

if (ti) {

drivers/gpu/drm/amd/amdkfd/kfd_events.c

1313

ti->process_name, ti->tgid, ti->task.comm, ti->task.pid);

drivers/gpu/drm/amd/amdkfd/kfd_events.c

1314

amdgpu_vm_put_task_info(ti);

drivers/gpu/drm/gma500/mid_bios.c

225

struct gct_r10_timing_info *ti;

drivers/gpu/drm/gma500/mid_bios.c

246

ti = &gct[vbt.primary_panel_idx].DTD;

drivers/gpu/drm/gma500/mid_bios.c

247

dp_ti->pixel_clock = ti->pixel_clock;

drivers/gpu/drm/gma500/mid_bios.c

248

dp_ti->hactive_hi = ti->hactive_hi;

drivers/gpu/drm/gma500/mid_bios.c

249

dp_ti->hactive_lo = ti->hactive_lo;

drivers/gpu/drm/gma500/mid_bios.c

250

dp_ti->hblank_hi = ti->hblank_hi;

drivers/gpu/drm/gma500/mid_bios.c

251

dp_ti->hblank_lo = ti->hblank_lo;

drivers/gpu/drm/gma500/mid_bios.c

252

dp_ti->hsync_offset_hi = ti->hsync_offset_hi;

drivers/gpu/drm/gma500/mid_bios.c

253

dp_ti->hsync_offset_lo = ti->hsync_offset_lo;

drivers/gpu/drm/gma500/mid_bios.c

254

dp_ti->hsync_pulse_width_hi = ti->hsync_pulse_width_hi;

drivers/gpu/drm/gma500/mid_bios.c

255

dp_ti->hsync_pulse_width_lo = ti->hsync_pulse_width_lo;

drivers/gpu/drm/gma500/mid_bios.c

256

dp_ti->vactive_hi = ti->vactive_hi;

drivers/gpu/drm/gma500/mid_bios.c

257

dp_ti->vactive_lo = ti->vactive_lo;

drivers/gpu/drm/gma500/mid_bios.c

258

dp_ti->vblank_hi = ti->vblank_hi;

drivers/gpu/drm/gma500/mid_bios.c

259

dp_ti->vblank_lo = ti->vblank_lo;

drivers/gpu/drm/gma500/mid_bios.c

260

dp_ti->vsync_offset_hi = ti->vsync_offset_hi;

drivers/gpu/drm/gma500/mid_bios.c

261

dp_ti->vsync_offset_lo = ti->vsync_offset_lo;

drivers/gpu/drm/gma500/mid_bios.c

262

dp_ti->vsync_pulse_width_hi = ti->vsync_pulse_width_hi;

drivers/gpu/drm/gma500/mid_bios.c

263

dp_ti->vsync_pulse_width_lo = ti->vsync_pulse_width_lo;

drivers/gpu/drm/gma500/oaktrail_lvds.c

220

struct oaktrail_timing_info *ti = &dev_priv->gct_data.DTD;

drivers/gpu/drm/gma500/oaktrail_lvds.c

230

mode->hdisplay = (ti->hactive_hi << 8) | ti->hactive_lo;

drivers/gpu/drm/gma500/oaktrail_lvds.c

231

mode->vdisplay = (ti->vactive_hi << 8) | ti->vactive_lo;

drivers/gpu/drm/gma500/oaktrail_lvds.c

233

((ti->hsync_offset_hi << 8) | \

drivers/gpu/drm/gma500/oaktrail_lvds.c

234

ti->hsync_offset_lo);

drivers/gpu/drm/gma500/oaktrail_lvds.c

236

((ti->hsync_pulse_width_hi << 8) | \

drivers/gpu/drm/gma500/oaktrail_lvds.c

237

ti->hsync_pulse_width_lo);

drivers/gpu/drm/gma500/oaktrail_lvds.c

238

mode->htotal = mode->hdisplay + ((ti->hblank_hi << 8) | \

drivers/gpu/drm/gma500/oaktrail_lvds.c

239

ti->hblank_lo);

drivers/gpu/drm/gma500/oaktrail_lvds.c

241

mode->vdisplay + ((ti->vsync_offset_hi << 4) | \

drivers/gpu/drm/gma500/oaktrail_lvds.c

242

ti->vsync_offset_lo);

drivers/gpu/drm/gma500/oaktrail_lvds.c

244

mode->vsync_start + ((ti->vsync_pulse_width_hi << 4) | \

drivers/gpu/drm/gma500/oaktrail_lvds.c

245

ti->vsync_pulse_width_lo);

drivers/gpu/drm/gma500/oaktrail_lvds.c

247

((ti->vblank_hi << 8) | ti->vblank_lo);

drivers/gpu/drm/gma500/oaktrail_lvds.c

248

mode->clock = ti->pixel_clock * 10;

drivers/md/dm-audit.c

37

struct dm_target *ti, int result)

drivers/md/dm-audit.c

40

struct mapped_device *md = dm_table_get_md(ti->table);

drivers/md/dm-audit.c

51

dev_minor, !result ? ti->error : "success");

drivers/md/dm-audit.h

25

struct dm_target *ti, int result);

drivers/md/dm-audit.h

28

struct dm_target *ti, int result)

drivers/md/dm-audit.h

30

dm_audit_log_ti(AUDIT_DM_CTRL, dm_msg_prefix, "ctr", ti, result);

drivers/md/dm-audit.h

34

struct dm_target *ti, int result)

drivers/md/dm-audit.h

36

dm_audit_log_ti(AUDIT_DM_CTRL, dm_msg_prefix, "dtr", ti, result);

drivers/md/dm-audit.h

40

struct dm_target *ti, int result)

drivers/md/dm-audit.h

42

dm_audit_log_ti(AUDIT_DM_EVENT, dm_msg_prefix, op, ti, result);

drivers/md/dm-audit.h

51

const char *op, struct dm_target *ti,

drivers/md/dm-audit.h

56

struct dm_target *ti, int result)

drivers/md/dm-audit.h

61

struct dm_target *ti, int result)

drivers/md/dm-cache-target.c

1975

dm_put_device(cache->ti, cache->metadata_dev);

drivers/md/dm-cache-target.c

1978

dm_put_device(cache->ti, cache->origin_dev);

drivers/md/dm-cache-target.c

1981

dm_put_device(cache->ti, cache->cache_dev);

drivers/md/dm-cache-target.c

2004

static void cache_dtr(struct dm_target *ti)

drivers/md/dm-cache-target.c

2006

struct cache *cache = ti->private;

drivers/md/dm-cache-target.c

2048

struct dm_target *ti;

drivers/md/dm-cache-target.c

2069

dm_put_device(ca->ti, ca->metadata_dev);

drivers/md/dm-cache-target.c

2072

dm_put_device(ca->ti, ca->cache_dev);

drivers/md/dm-cache-target.c

2075

dm_put_device(ca->ti, ca->origin_dev);

drivers/md/dm-cache-target.c

2099

r = dm_get_device(ca->ti, dm_shift_arg(as),

drivers/md/dm-cache-target.c

2122

r = dm_get_device(ca->ti, dm_shift_arg(as),

drivers/md/dm-cache-target.c

2141

r = dm_get_device(ca->ti, dm_shift_arg(as),

drivers/md/dm-cache-target.c

2417

char **error = &ca->ti->error;

drivers/md/dm-cache-target.c

2419

struct dm_target *ti = ca->ti;

drivers/md/dm-cache-target.c

2428

cache->ti = ca->ti;

drivers/md/dm-cache-target.c

2429

ti->private = cache;

drivers/md/dm-cache-target.c

2430

ti->accounts_remapped_io = true;

drivers/md/dm-cache-target.c

2431

ti->num_flush_bios = 2;

drivers/md/dm-cache-target.c

2432

ti->flush_supported = true;

drivers/md/dm-cache-target.c

2434

ti->num_discard_bios = 1;

drivers/md/dm-cache-target.c

2435

ti->discards_supported = true;

drivers/md/dm-cache-target.c

2437

ti->per_io_data_size = sizeof(struct per_bio_data);

drivers/md/dm-cache-target.c

2453

origin_blocks = cache->origin_sectors = ti->len;

drivers/md/dm-cache-target.c

2458

if (dm_set_target_max_io_len(ti, cache->sectors_per_block)) {

drivers/md/dm-cache-target.c

2628

static int cache_ctr(struct dm_target *ti, unsigned int argc, char **argv)

drivers/md/dm-cache-target.c

2636

ti->error = "Error allocating memory for cache";

drivers/md/dm-cache-target.c

2639

ca->ti = ti;

drivers/md/dm-cache-target.c

2641

r = parse_cache_args(ca, argc, argv, &ti->error);

drivers/md/dm-cache-target.c

2655

ti->private = cache;

drivers/md/dm-cache-target.c

2663

static int cache_map(struct dm_target *ti, struct bio *bio)

drivers/md/dm-cache-target.c

2665

struct cache *cache = ti->private;

drivers/md/dm-cache-target.c

2695

static int cache_end_io(struct dm_target *ti, struct bio *bio, blk_status_t *error)

drivers/md/dm-cache-target.c

2697

struct cache *cache = ti->private;

drivers/md/dm-cache-target.c

2805

static void cache_postsuspend(struct dm_target *ti)

drivers/md/dm-cache-target.c

2807

struct cache *cache = ti->private;

drivers/md/dm-cache-target.c

298

struct dm_target *ti;

drivers/md/dm-cache-target.c

3053

static int cache_preresume(struct dm_target *ti)

drivers/md/dm-cache-target.c

3056

struct cache *cache = ti->private;

drivers/md/dm-cache-target.c

3127

static void cache_resume(struct dm_target *ti)

drivers/md/dm-cache-target.c

3129

struct cache *cache = ti->private;

drivers/md/dm-cache-target.c

3180

static void cache_status(struct dm_target *ti, status_type_t type,

drivers/md/dm-cache-target.c

3189

struct cache *cache = ti->private;

drivers/md/dm-cache-target.c

3201

if (!(status_flags & DM_STATUS_NOFLUSH_FLAG) && !dm_suspended(ti))

drivers/md/dm-cache-target.c

3276

DMEMIT_TARGET_NAME_VERSION(ti->type);

drivers/md/dm-cache-target.c

3448

static int cache_message(struct dm_target *ti, unsigned int argc, char **argv,

drivers/md/dm-cache-target.c

3451

struct cache *cache = ti->private;

drivers/md/dm-cache-target.c

3471

static int cache_iterate_devices(struct dm_target *ti,

drivers/md/dm-cache-target.c

3475

struct cache *cache = ti->private;

drivers/md/dm-cache-target.c

3477

r = fn(ti, cache->cache_dev, 0, get_dev_size(cache->cache_dev), data);

drivers/md/dm-cache-target.c

3479

r = fn(ti, cache->origin_dev, 0, ti->len, data);

drivers/md/dm-cache-target.c

3532

static void cache_io_hints(struct dm_target *ti, struct queue_limits *limits)

drivers/md/dm-cache-target.c

3534

struct cache *cache = ti->private;

drivers/md/dm-cache-target.c

641

dm_table_event(cache->ti->table);

drivers/md/dm-cache-target.c

862

return dm_table_device_name(cache->ti->table);

drivers/md/dm-cache-target.c

873

dm_table_event(cache->ti->table);

drivers/md/dm-clone-target.c

1168

dm_table_event(clone->ti->table);

drivers/md/dm-clone-target.c

1314

static int clone_map(struct dm_target *ti, struct bio *bio)

drivers/md/dm-clone-target.c

1316

struct clone *clone = ti->private;

drivers/md/dm-clone-target.c

1336

bio->bi_iter.bi_sector = dm_target_offset(ti, bio->bi_iter.bi_sector);

drivers/md/dm-clone-target.c

1373

static int clone_endio(struct dm_target *ti, struct bio *bio, blk_status_t *error)

drivers/md/dm-clone-target.c

1375

struct clone *clone = ti->private;

drivers/md/dm-clone-target.c

1422

static void clone_status(struct dm_target *ti, status_type_t type,

drivers/md/dm-clone-target.c

1432

struct clone *clone = ti->private;

drivers/md/dm-clone-target.c

1442

if (!(status_flags & DM_STATUS_NOFLUSH_FLAG) && !dm_suspended(ti))

drivers/md/dm-clone-target.c

1542

struct dm_target *ti = clone->ti;

drivers/md/dm-clone-target.c

1554

r = dm_read_arg_group(&args, as, &argc, &ti->error);

drivers/md/dm-clone-target.c

1567

ti->error = "Invalid feature argument";

drivers/md/dm-clone-target.c

1581

struct dm_target *ti = clone->ti;

drivers/md/dm-clone-target.c

159

return dm_table_device_name(clone->ti->table);

drivers/md/dm-clone-target.c

1597

r = dm_read_arg_group(&args, as, &argc, &ti->error);

drivers/md/dm-clone-target.c

1602

ti->error = "Number of core arguments must be even";

drivers/md/dm-clone-target.c

1612

ti->error = "Invalid value for argument `hydration_threshold'";

drivers/md/dm-clone-target.c

1618

ti->error = "Invalid value for argument `hydration_batch_size'";

drivers/md/dm-clone-target.c

1623

ti->error = "Invalid core argument";

drivers/md/dm-clone-target.c

1682

r = dm_get_device(clone->ti, dm_shift_arg(as),

drivers/md/dm-clone-target.c

1701

r = dm_get_device(clone->ti, dm_shift_arg(as),

drivers/md/dm-clone-target.c

1715

r = dm_get_device(clone->ti, dm_shift_arg(as), BLK_OPEN_READ,

drivers/md/dm-clone-target.c

1754

static int clone_ctr(struct dm_target *ti, unsigned int argc, char **argv)

drivers/md/dm-clone-target.c

1762

ti->error = "Invalid number of arguments";

drivers/md/dm-clone-target.c

1771

ti->error = "Failed to allocate clone structure";

drivers/md/dm-clone-target.c

1775

clone->ti = ti;

drivers/md/dm-clone-target.c

1782

r = parse_metadata_dev(clone, &as, &ti->error);

drivers/md/dm-clone-target.c

1786

r = parse_dest_dev(clone, &as, &ti->error);

drivers/md/dm-clone-target.c

1790

r = parse_source_dev(clone, &as, &ti->error);

drivers/md/dm-clone-target.c

1794

r = parse_region_size(clone, &as, &ti->error);

drivers/md/dm-clone-target.c

1799

nr_regions = dm_sector_div_up(ti->len, clone->region_size);

drivers/md/dm-clone-target.c

1803

ti->error = "Too many regions. Consider increasing the region size";

drivers/md/dm-clone-target.c

1810

r = validate_nr_regions(clone->nr_regions, &ti->error);

drivers/md/dm-clone-target.c

1814

r = dm_set_target_max_io_len(ti, clone->region_size);

drivers/md/dm-clone-target.c

1816

ti->error = "Failed to set max io len";

drivers/md/dm-clone-target.c

1829

clone->cmd = dm_clone_metadata_open(clone->metadata_dev->bdev, ti->len,

drivers/md/dm-clone-target.c

1832

ti->error = "Failed to load metadata";

drivers/md/dm-clone-target.c

1840

ti->error = "Unable to get write access to metadata, please check/repair metadata";

drivers/md/dm-clone-target.c

1850

ti->error = "Failed to allocate hydration hash table";

drivers/md/dm-clone-target.c

1867

ti->error = "Failed to allocate workqueue";

drivers/md/dm-clone-target.c

1884

ti->error = "Failed to create dm_clone_region_hydration memory pool";

drivers/md/dm-clone-target.c

1889

r = copy_ctr_args(clone, argc - 3, (const char **)argv + 3, &ti->error);

drivers/md/dm-clone-target.c

1896

ti->num_flush_bios = 1;

drivers/md/dm-clone-target.c

1897

ti->flush_supported = true;

drivers/md/dm-clone-target.c

190

dm_table_event(clone->ti->table);

drivers/md/dm-clone-target.c

1900

ti->discards_supported = true;

drivers/md/dm-clone-target.c

1901

ti->num_discard_bios = 1;

drivers/md/dm-clone-target.c

1903

ti->private = clone;

drivers/md/dm-clone-target.c

1918

dm_put_device(ti, clone->source_dev);

drivers/md/dm-clone-target.c

1920

dm_put_device(ti, clone->dest_dev);

drivers/md/dm-clone-target.c

1922

dm_put_device(ti, clone->metadata_dev);

drivers/md/dm-clone-target.c

1929

static void clone_dtr(struct dm_target *ti)

drivers/md/dm-clone-target.c

1932

struct clone *clone = ti->private;

drivers/md/dm-clone-target.c

1946

dm_put_device(ti, clone->source_dev);

drivers/md/dm-clone-target.c

1947

dm_put_device(ti, clone->dest_dev);

drivers/md/dm-clone-target.c

1948

dm_put_device(ti, clone->metadata_dev);

drivers/md/dm-clone-target.c

1955

static void clone_postsuspend(struct dm_target *ti)

drivers/md/dm-clone-target.c

1957

struct clone *clone = ti->private;

drivers/md/dm-clone-target.c

1993

static void clone_resume(struct dm_target *ti)

drivers/md/dm-clone-target.c

1995

struct clone *clone = ti->private;

drivers/md/dm-clone-target.c

2050

static void clone_io_hints(struct dm_target *ti, struct queue_limits *limits)

drivers/md/dm-clone-target.c

2052

struct clone *clone = ti->private;

drivers/md/dm-clone-target.c

2069

static int clone_iterate_devices(struct dm_target *ti,

drivers/md/dm-clone-target.c

2073

struct clone *clone = ti->private;

drivers/md/dm-clone-target.c

2077

ret = fn(ti, source_dev, 0, ti->len, data);

drivers/md/dm-clone-target.c

2079

ret = fn(ti, dest_dev, 0, ti->len, data);

drivers/md/dm-clone-target.c

2114

static int clone_message(struct dm_target *ti, unsigned int argc, char **argv,

drivers/md/dm-clone-target.c

2117

struct clone *clone = ti->private;

drivers/md/dm-clone-target.c

70

struct dm_target *ti;

drivers/md/dm-clone-target.c

814

tail_size = clone->ti->len & (region_size - 1);

drivers/md/dm-core.h

246

struct dm_target *ti;

drivers/md/dm-crypt.c

109

int (*ctr)(struct crypt_config *cc, struct dm_target *ti,

drivers/md/dm-crypt.c

1126

static int crypt_integrity_ctr(struct crypt_config *cc, struct dm_target *ti)

drivers/md/dm-crypt.c

1130

struct mapped_device *md = dm_table_get_md(ti->table);

drivers/md/dm-crypt.c

1134

ti->error = "Integrity profile not supported.";

drivers/md/dm-crypt.c

1139

ti->error = "Integrity profile tag size mismatch.";

drivers/md/dm-crypt.c

1144

ti->error = "Integrity profile sector size mismatch.";

drivers/md/dm-crypt.c

1154

ti->error = "Integrity AEAD auth tag size is not supported.";

drivers/md/dm-crypt.c

1162

ti->error = "Not enough space for integrity tag in the profile.";

drivers/md/dm-crypt.c

1168

ti->error = "Integrity profile not supported.";

drivers/md/dm-crypt.c

259

static unsigned get_max_request_sectors(struct dm_target *ti, struct bio *bio, bool no_split)

drivers/md/dm-crypt.c

261

struct crypt_config *cc = ti->private;

drivers/md/dm-crypt.c

2694

static void crypt_dtr(struct dm_target *ti)

drivers/md/dm-crypt.c

2696

struct crypt_config *cc = ti->private;

drivers/md/dm-crypt.c

2698

ti->private = NULL;

drivers/md/dm-crypt.c

2729

dm_put_device(ti, cc->dev);

drivers/md/dm-crypt.c

2747

dm_audit_log_dtr(DM_MSG_PREFIX, ti, 1);

drivers/md/dm-crypt.c

2750

static int crypt_ctr_ivmode(struct dm_target *ti, const char *ivmode)

drivers/md/dm-crypt.c

2752

struct crypt_config *cc = ti->private;

drivers/md/dm-crypt.c

2813

ti->error = "Invalid IV mode";

drivers/md/dm-crypt.c

2859

static int crypt_ctr_cipher_new(struct dm_target *ti, char *cipher_in, char *key,

drivers/md/dm-crypt.c

2862

struct crypt_config *cc = ti->private;

drivers/md/dm-crypt.c

2893

ti->error = "Invalid AEAD cipher spec";

drivers/md/dm-crypt.c

2903

ti->error = "Digest algorithm missing for ESSIV mode";

drivers/md/dm-crypt.c

2909

ti->error = "Cannot allocate cipher string";

drivers/md/dm-crypt.c

2920

ti->error = "Error allocating crypto tfm";

drivers/md/dm-crypt.c

2932

static int crypt_ctr_cipher_old(struct dm_target *ti, char *cipher_in, char *key,

drivers/md/dm-crypt.c

2935

struct crypt_config *cc = ti->private;

drivers/md/dm-crypt.c

2942

ti->error = "Bad cipher specification";

drivers/md/dm-crypt.c

2958

ti->error = "Bad cipher key count specification";

drivers/md/dm-crypt.c

2977

ti->error = "IV mechanism required";

drivers/md/dm-crypt.c

2987

ti->error = "Digest algorithm missing for ESSIV mode";

drivers/md/dm-crypt.c

3005

ti->error = "Error allocating crypto tfm";

drivers/md/dm-crypt.c

3013

ti->error = "Cannot allocate cipher strings";

drivers/md/dm-crypt.c

3017

static int crypt_ctr_cipher(struct dm_target *ti, char *cipher_in, char *key)

drivers/md/dm-crypt.c

3019

struct crypt_config *cc = ti->private;

drivers/md/dm-crypt.c

3025

ti->error = "Cannot allocate cipher strings";

drivers/md/dm-crypt.c

3030

ret = crypt_ctr_cipher_new(ti, cipher_in, key, &ivmode, &ivopts);

drivers/md/dm-crypt.c

3032

ret = crypt_ctr_cipher_old(ti, cipher_in, key, &ivmode, &ivopts);

drivers/md/dm-crypt.c

3037

ret = crypt_ctr_ivmode(ti, ivmode);

drivers/md/dm-crypt.c

3044

ti->error = "Error decoding and setting key";

drivers/md/dm-crypt.c

3050

ret = cc->iv_gen_ops->ctr(cc, ti, ivopts);

drivers/md/dm-crypt.c

3052

ti->error = "Error creating IV";

drivers/md/dm-crypt.c

3061

ti->error = "Error initialising IV";

drivers/md/dm-crypt.c

3073

static int crypt_ctr_optional(struct dm_target *ti, unsigned int argc, char **argv)

drivers/md/dm-crypt.c

3075

struct crypt_config *cc = ti->private;

drivers/md/dm-crypt.c

3089

ret = dm_read_arg_group(_args, &as, &opt_params, &ti->error);

drivers/md/dm-crypt.c

3096

ti->error = "Not enough feature arguments";

drivers/md/dm-crypt.c

3101

ti->num_discard_bios = 1;

drivers/md/dm-crypt.c

3116

ti->error = "Invalid integrity arguments";

drivers/md/dm-crypt.c

3124

ti->error = "Unknown integrity profile";

drivers/md/dm-crypt.c

3133

ti->error = "Invalid integrity_key_size argument";

drivers/md/dm-crypt.c

3142

ti->error = "Invalid feature value for sector_size";

drivers/md/dm-crypt.c

3145

if (ti->len & ((cc->sector_size >> SECTOR_SHIFT) - 1)) {

drivers/md/dm-crypt.c

3146

ti->error = "Device size is not multiple of sector_size feature";

drivers/md/dm-crypt.c

3153

ti->error = "Invalid feature arguments";

drivers/md/dm-crypt.c

3162

static int crypt_report_zones(struct dm_target *ti,

drivers/md/dm-crypt.c

3165

struct crypt_config *cc = ti->private;

drivers/md/dm-crypt.c

3168

cc->start + dm_target_offset(ti, args->next_sector),

drivers/md/dm-crypt.c

3179

static int crypt_ctr(struct dm_target *ti, unsigned int argc, char **argv)

drivers/md/dm-crypt.c

3182

const char *devname = dm_table_device_name(ti->table);

drivers/md/dm-crypt.c

3192

ti->error = "Not enough arguments";

drivers/md/dm-crypt.c

3198

ti->error = "Cannot parse key size";

drivers/md/dm-crypt.c

3204

ti->error = "Cannot allocate encryption context";

drivers/md/dm-crypt.c

3211

ti->private = cc;

drivers/md/dm-crypt.c

3224

ret = crypt_ctr_optional(ti, argc - 5, &argv[5]);

drivers/md/dm-crypt.c

3229

ret = crypt_ctr_cipher(ti, argv[0], argv[1]);

drivers/md/dm-crypt.c

3266

ti->error = "Cannot allocate crypt request mempool";

drivers/md/dm-crypt.c

3270

cc->per_bio_data_size = ti->per_io_data_size =

drivers/md/dm-crypt.c

3276

ti->error = "Cannot allocate page mempool";

drivers/md/dm-crypt.c

3282

ti->error = "Cannot allocate crypt bioset";

drivers/md/dm-crypt.c

3291

ti->error = "Invalid iv_offset sector";

drivers/md/dm-crypt.c

3296

ret = dm_get_device(ti, argv[3], dm_table_get_mode(ti->table), &cc->dev);

drivers/md/dm-crypt.c

3298

ti->error = "Device lookup failed";

drivers/md/dm-crypt.c

3304

ti->error = "Invalid device sector";

drivers/md/dm-crypt.c

3330

ti->emulate_zone_append = true;

drivers/md/dm-crypt.c

3334

ret = crypt_integrity_ctr(cc, ti);

drivers/md/dm-crypt.c

3345

ti->error = "Cannot allocate integrity tags mempool";

drivers/md/dm-crypt.c

3354

ti->error = "Couldn't get workqueue id";

drivers/md/dm-crypt.c

3369

ti->error = "Couldn't create kcryptd io queue";

drivers/md/dm-crypt.c

3387

ti->error = "Couldn't create kcryptd queue";

drivers/md/dm-crypt.c

3398

ti->error = "Couldn't spawn write thread";

drivers/md/dm-crypt.c

3404

ti->num_flush_bios = 1;

drivers/md/dm-crypt.c

3405

ti->limit_swap_bios = true;

drivers/md/dm-crypt.c

3406

ti->accounts_remapped_io = true;

drivers/md/dm-crypt.c

3408

dm_audit_log_ctr(DM_MSG_PREFIX, ti, 1);

drivers/md/dm-crypt.c

3412

dm_audit_log_ctr(DM_MSG_PREFIX, ti, 0);

drivers/md/dm-crypt.c

3413

crypt_dtr(ti);

drivers/md/dm-crypt.c

3417

static int crypt_map(struct dm_target *ti, struct bio *bio)

drivers/md/dm-crypt.c

3420

struct crypt_config *cc = ti->private;

drivers/md/dm-crypt.c

3434

dm_target_offset(ti, bio->bi_iter.bi_sector);

drivers/md/dm-crypt.c

3446

no_split = (ti->emulate_zone_append && op_is_write(bio_op(bio))) ||

drivers/md/dm-crypt.c

3448

max_sectors = get_max_request_sectors(ti, bio, no_split);

drivers/md/dm-crypt.c

3466

crypt_io_init(io, cc, bio, dm_target_offset(ti, bio->bi_iter.bi_sector));

drivers/md/dm-crypt.c

3503

static void crypt_status(struct dm_target *ti, status_type_t type,

drivers/md/dm-crypt.c

3506

struct crypt_config *cc = ti->private;

drivers/md/dm-crypt.c

3533

num_feature_args += !!ti->num_discard_bios;

drivers/md/dm-crypt.c

3545

if (ti->num_discard_bios)

drivers/md/dm-crypt.c

3569

DMEMIT_TARGET_NAME_VERSION(ti->type);

drivers/md/dm-crypt.c

3570

DMEMIT(",allow_discards=%c", ti->num_discard_bios ? 'y' : 'n');

drivers/md/dm-crypt.c

3599

static void crypt_postsuspend(struct dm_target *ti)

drivers/md/dm-crypt.c

3601

struct crypt_config *cc = ti->private;

drivers/md/dm-crypt.c

3606

static int crypt_preresume(struct dm_target *ti)

drivers/md/dm-crypt.c

3608

struct crypt_config *cc = ti->private;

drivers/md/dm-crypt.c

3618

static void crypt_resume(struct dm_target *ti)

drivers/md/dm-crypt.c

3620

struct crypt_config *cc = ti->private;

drivers/md/dm-crypt.c

3629

static int crypt_message(struct dm_target *ti, unsigned int argc, char **argv,

drivers/md/dm-crypt.c

3632

struct crypt_config *cc = ti->private;

drivers/md/dm-crypt.c

3670

static int crypt_iterate_devices(struct dm_target *ti,

drivers/md/dm-crypt.c

3673

struct crypt_config *cc = ti->private;

drivers/md/dm-crypt.c

3675

return fn(ti, cc->dev, cc->start, ti->len, data);

drivers/md/dm-crypt.c

3678

static void crypt_io_hints(struct dm_target *ti, struct queue_limits *limits)

drivers/md/dm-crypt.c

3680

struct crypt_config *cc = ti->private;

drivers/md/dm-crypt.c

3692

if (ti->emulate_zone_append)

drivers/md/dm-crypt.c

403

static int crypt_iv_benbi_ctr(struct crypt_config *cc, struct dm_target *ti,

drivers/md/dm-crypt.c

420

ti->error = "cypher blocksize is not a power of 2";

drivers/md/dm-crypt.c

425

ti->error = "cypher blocksize is > 512";

drivers/md/dm-crypt.c

467

static int crypt_iv_lmk_ctr(struct crypt_config *cc, struct dm_target *ti,

drivers/md/dm-crypt.c

473

ti->error = "Unsupported sector size for LMK";

drivers/md/dm-crypt.c

478

ti->error = "LMK support is disabled due to FIPS";

drivers/md/dm-crypt.c

491

ti->error = "Error kmallocing seed storage in LMK";

drivers/md/dm-crypt.c

591

static int crypt_iv_tcw_ctr(struct crypt_config *cc, struct dm_target *ti,

drivers/md/dm-crypt.c

597

ti->error = "Unsupported sector size for TCW";

drivers/md/dm-crypt.c

602

ti->error = "Wrong key size for TCW";

drivers/md/dm-crypt.c

610

ti->error = "Error allocating seed storage in TCW";

drivers/md/dm-crypt.c

710

static int crypt_iv_eboiv_ctr(struct crypt_config *cc, struct dm_target *ti,

drivers/md/dm-crypt.c

714

ti->error = "AEAD transforms not supported for EBOIV";

drivers/md/dm-crypt.c

719

ti->error = "Block size of EBOIV cipher does not match IV size of block cipher";

drivers/md/dm-crypt.c

768

static int crypt_iv_elephant_ctr(struct crypt_config *cc, struct dm_target *ti,

drivers/md/dm-crypt.c

778

r = crypt_iv_eboiv_ctr(cc, ti, NULL);

drivers/md/dm-delay.c

159

static void delay_dtr(struct dm_target *ti)

drivers/md/dm-delay.c

161

struct delay_c *dc = ti->private;

drivers/md/dm-delay.c

169

dm_put_device(ti, dc->read.dev);

drivers/md/dm-delay.c

171

dm_put_device(ti, dc->write.dev);

drivers/md/dm-delay.c

173

dm_put_device(ti, dc->flush.dev);

drivers/md/dm-delay.c

182

static int delay_class_ctr(struct dm_target *ti, struct delay_class *c, char **argv)

drivers/md/dm-delay.c

189

ti->error = "Invalid device sector";

drivers/md/dm-delay.c

195

ti->error = "Invalid delay";

drivers/md/dm-delay.c

199

ret = dm_get_device(ti, argv[0], dm_table_get_mode(ti->table), &c->dev);

drivers/md/dm-delay.c

201

ti->error = "Device lookup failed";

drivers/md/dm-delay.c

216

static int delay_ctr(struct dm_target *ti, unsigned int argc, char **argv)

drivers/md/dm-delay.c

223

ti->error = "Requires exactly 3, 6 or 9 arguments";

drivers/md/dm-delay.c

229

ti->error = "Cannot allocate context";

drivers/md/dm-delay.c

233

ti->private = dc;

drivers/md/dm-delay.c

240

ret = delay_class_ctr(ti, &dc->read, argv);

drivers/md/dm-delay.c

246

ret = delay_class_ctr(ti, &dc->write, argv);

drivers/md/dm-delay.c

249

ret = delay_class_ctr(ti, &dc->flush, argv);

drivers/md/dm-delay.c

255

ret = delay_class_ctr(ti, &dc->write, argv + 3);

drivers/md/dm-delay.c

262

ret = delay_class_ctr(ti, &dc->flush, argv + 3);

drivers/md/dm-delay.c

268

ret = delay_class_ctr(ti, &dc->flush, argv + 6);

drivers/md/dm-delay.c

303

ti->num_flush_bios = 1;

drivers/md/dm-delay.c

304

ti->num_discard_bios = 1;

drivers/md/dm-delay.c

305

ti->accounts_remapped_io = true;

drivers/md/dm-delay.c

306

ti->per_io_data_size = sizeof(struct dm_delay_info);

drivers/md/dm-delay.c

310

delay_dtr(ti);

drivers/md/dm-delay.c

344

static void delay_presuspend(struct dm_target *ti)

drivers/md/dm-delay.c

346

struct delay_c *dc = ti->private;

drivers/md/dm-delay.c

357

static void delay_resume(struct dm_target *ti)

drivers/md/dm-delay.c

359

struct delay_c *dc = ti->private;

drivers/md/dm-delay.c

364

static int delay_map(struct dm_target *ti, struct bio *bio)

drivers/md/dm-delay.c

366

struct delay_c *dc = ti->private;

drivers/md/dm-delay.c

380

bio->bi_iter.bi_sector = c->start + dm_target_offset(ti, bio->bi_iter.bi_sector);

drivers/md/dm-delay.c

386

static int delay_report_zones(struct dm_target *ti,

drivers/md/dm-delay.c

389

struct delay_c *dc = ti->private;

drivers/md/dm-delay.c

393

c->start + dm_target_offset(ti, args->next_sector),

drivers/md/dm-delay.c

403

static void delay_status(struct dm_target *ti, status_type_t type,

drivers/md/dm-delay.c

406

struct delay_c *dc = ti->private;

drivers/md/dm-delay.c

432

static int delay_iterate_devices(struct dm_target *ti,

drivers/md/dm-delay.c

435

struct delay_c *dc = ti->private;

drivers/md/dm-delay.c

438

ret = fn(ti, dc->read.dev, dc->read.start, ti->len, data);

drivers/md/dm-delay.c

441

ret = fn(ti, dc->write.dev, dc->write.start, ti->len, data);

drivers/md/dm-delay.c

444

ret = fn(ti, dc->flush.dev, dc->flush.start, ti->len, data);

drivers/md/dm-dust.c

224

static int dust_map(struct dm_target *ti, struct bio *bio)

drivers/md/dm-dust.c

226

struct dust_device *dd = ti->private;

drivers/md/dm-dust.c

230

bio->bi_iter.bi_sector = dd->start + dm_target_offset(ti, bio->bi_iter.bi_sector);

drivers/md/dm-dust.c

321

static int dust_ctr(struct dm_target *ti, unsigned int argc, char **argv)

drivers/md/dm-dust.c

329

sector_t max_block_sectors = min(ti->len, DUST_MAX_BLKSZ_SECTORS);

drivers/md/dm-dust.c

332

ti->error = "Invalid argument count";

drivers/md/dm-dust.c

337

ti->error = "Invalid block size parameter";

drivers/md/dm-dust.c

342

ti->error = "Block size must be at least 512";

drivers/md/dm-dust.c

347

ti->error = "Block size must be a power of 2";

drivers/md/dm-dust.c

352

ti->error = "Block size is too large";

drivers/md/dm-dust.c

359

ti->error = "Invalid device offset sector";

drivers/md/dm-dust.c

365

ti->error = "Cannot allocate context";

drivers/md/dm-dust.c

369

if (dm_get_device(ti, argv[0], dm_table_get_mode(ti->table), &dd->dev)) {

drivers/md/dm-dust.c

370

ti->error = "Device lookup failed";

drivers/md/dm-dust.c

396

BUG_ON(dm_set_target_max_io_len(ti, dd->sect_per_block) != 0);

drivers/md/dm-dust.c

398

ti->num_discard_bios = 1;

drivers/md/dm-dust.c

399

ti->num_flush_bios = 1;

drivers/md/dm-dust.c

400

ti->private = dd;

drivers/md/dm-dust.c

405

static void dust_dtr(struct dm_target *ti)

drivers/md/dm-dust.c

407

struct dust_device *dd = ti->private;

drivers/md/dm-dust.c

410

dm_put_device(ti, dd->dev);

drivers/md/dm-dust.c

414

static int dust_message(struct dm_target *ti, unsigned int argc, char **argv,

drivers/md/dm-dust.c

417

struct dust_device *dd = ti->private;

drivers/md/dm-dust.c

513

static void dust_status(struct dm_target *ti, status_type_t type,

drivers/md/dm-dust.c

516

struct dust_device *dd = ti->private;

drivers/md/dm-dust.c

537

static int dust_prepare_ioctl(struct dm_target *ti, struct block_device **bdev,

drivers/md/dm-dust.c

541

struct dust_device *dd = ti->private;

drivers/md/dm-dust.c

549

if (dd->start || ti->len != bdev_nr_sectors(dev->bdev))

drivers/md/dm-dust.c

555

static int dust_iterate_devices(struct dm_target *ti, iterate_devices_callout_fn fn,

drivers/md/dm-dust.c

558

struct dust_device *dd = ti->private;

drivers/md/dm-dust.c

560

return fn(ti, dd->dev, dd->start, ti->len, data);

drivers/md/dm-ebs-target.c

20

static void ebs_dtr(struct dm_target *ti);

drivers/md/dm-ebs-target.c

247

static int ebs_ctr(struct dm_target *ti, unsigned int argc, char **argv)

drivers/md/dm-ebs-target.c

256

ti->error = "Invalid argument count";

drivers/md/dm-ebs-target.c

260

ec = ti->private = kzalloc_obj(*ec);

drivers/md/dm-ebs-target.c

262

ti->error = "Cannot allocate ebs context";

drivers/md/dm-ebs-target.c

269

(sector_t)tmp >= ti->len) {

drivers/md/dm-ebs-target.c

270

ti->error = "Invalid device offset sector";

drivers/md/dm-ebs-target.c

278

ti->error = "Invalid emulated block size";

drivers/md/dm-ebs-target.c

285

ti->error = "Invalid underlying block size";

drivers/md/dm-ebs-target.c

293

r = dm_get_device(ti, argv[0], dm_table_get_mode(ti->table), &ec->dev);

drivers/md/dm-ebs-target.c

295

ti->error = "Device lookup failed";

drivers/md/dm-ebs-target.c

304

ti->error = "Invalid retrieved underlying block size";

drivers/md/dm-ebs-target.c

313

ti->error = "Device offset must be multiple of underlying block size";

drivers/md/dm-ebs-target.c

320

ti->error = "Cannot create dm bufio client";

drivers/md/dm-ebs-target.c

328

ti->error = "Cannot create dm-" DM_MSG_PREFIX " workqueue";

drivers/md/dm-ebs-target.c

338

ti->num_flush_bios = 1;

drivers/md/dm-ebs-target.c

339

ti->num_discard_bios = 1;

drivers/md/dm-ebs-target.c

340

ti->num_secure_erase_bios = 0;

drivers/md/dm-ebs-target.c

341

ti->num_write_zeroes_bios = 0;

drivers/md/dm-ebs-target.c

344

ebs_dtr(ti);

drivers/md/dm-ebs-target.c

348

static void ebs_dtr(struct dm_target *ti)

drivers/md/dm-ebs-target.c

350

struct ebs_c *ec = ti->private;

drivers/md/dm-ebs-target.c

357

dm_put_device(ti, ec->dev);

drivers/md/dm-ebs-target.c

361

static int ebs_map(struct dm_target *ti, struct bio *bio)

drivers/md/dm-ebs-target.c

363

struct ebs_c *ec = ti->private;

drivers/md/dm-ebs-target.c

366

bio->bi_iter.bi_sector = ec->start + dm_target_offset(ti, bio->bi_iter.bi_sector);

drivers/md/dm-ebs-target.c

393

static void ebs_postsuspend(struct dm_target *ti)

drivers/md/dm-ebs-target.c

395

struct ebs_c *ec = ti->private;

drivers/md/dm-ebs-target.c

399

static void ebs_status(struct dm_target *ti, status_type_t type,

drivers/md/dm-ebs-target.c

402

struct ebs_c *ec = ti->private;

drivers/md/dm-ebs-target.c

418

static int ebs_prepare_ioctl(struct dm_target *ti, struct block_device **bdev,

drivers/md/dm-ebs-target.c

421

struct ebs_c *ec = ti->private;

drivers/md/dm-ebs-target.c

428

return !!(ec->start || ti->len != bdev_nr_sectors(dev->bdev));

drivers/md/dm-ebs-target.c

431

static void ebs_io_hints(struct dm_target *ti, struct queue_limits *limits)

drivers/md/dm-ebs-target.c

433

struct ebs_c *ec = ti->private;

drivers/md/dm-ebs-target.c

441

static int ebs_iterate_devices(struct dm_target *ti,

drivers/md/dm-ebs-target.c

444

struct ebs_c *ec = ti->private;

drivers/md/dm-ebs-target.c

446

return fn(ti, ec->dev, ec->start, ti->len, data);

drivers/md/dm-era-target.c

1175

struct dm_target *ti;

drivers/md/dm-era-target.c

1234

bio->bi_iter.bi_sector = dm_target_offset(era->ti, bio->bi_iter.bi_sector);

drivers/md/dm-era-target.c

1443

dm_put_device(era->ti, era->origin_dev);

drivers/md/dm-era-target.c

1446

dm_put_device(era->ti, era->metadata_dev);

drivers/md/dm-era-target.c

1453

return dm_sector_div_up(era->ti->len, era->sectors_per_block);

drivers/md/dm-era-target.c

1467

static int era_ctr(struct dm_target *ti, unsigned int argc, char **argv)

drivers/md/dm-era-target.c

1475

ti->error = "Invalid argument count";

drivers/md/dm-era-target.c

1481

ti->error = "Error allocating era structure";

drivers/md/dm-era-target.c

1485

era->ti = ti;

drivers/md/dm-era-target.c

1487

r = dm_get_device(ti, argv[0], BLK_OPEN_READ | BLK_OPEN_WRITE,

drivers/md/dm-era-target.c

1490

ti->error = "Error opening metadata device";

drivers/md/dm-era-target.c

1495

r = dm_get_device(ti, argv[1], BLK_OPEN_READ | BLK_OPEN_WRITE,

drivers/md/dm-era-target.c

1498

ti->error = "Error opening data device";

drivers/md/dm-era-target.c

1505

ti->error = "Error parsing block size";

drivers/md/dm-era-target.c

1510

r = dm_set_target_max_io_len(ti, era->sectors_per_block);

drivers/md/dm-era-target.c

1512

ti->error = "could not set max io len";

drivers/md/dm-era-target.c

1518

ti->error = "Invalid block size";

drivers/md/dm-era-target.c

1529

ti->error = "Error reading metadata";

drivers/md/dm-era-target.c

1537

ti->error = "could not create workqueue for metadata object";

drivers/md/dm-era-target.c

1549

ti->private = era;

drivers/md/dm-era-target.c

1550

ti->num_flush_bios = 1;

drivers/md/dm-era-target.c

1551

ti->flush_supported = true;

drivers/md/dm-era-target.c

1553

ti->num_discard_bios = 1;

drivers/md/dm-era-target.c

1558

static void era_dtr(struct dm_target *ti)

drivers/md/dm-era-target.c

1560

era_destroy(ti->private);

drivers/md/dm-era-target.c

1563

static int era_map(struct dm_target *ti, struct bio *bio)

drivers/md/dm-era-target.c

1565

struct era *era = ti->private;

drivers/md/dm-era-target.c

1589

static void era_postsuspend(struct dm_target *ti)

drivers/md/dm-era-target.c

1592

struct era *era = ti->private;

drivers/md/dm-era-target.c

1609

static int era_preresume(struct dm_target *ti)

drivers/md/dm-era-target.c

1612

struct era *era = ti->private;

drivers/md/dm-era-target.c

1648

static void era_status(struct dm_target *ti, status_type_t type,

drivers/md/dm-era-target.c

1652

struct era *era = ti->private;

drivers/md/dm-era-target.c

1693

static int era_message(struct dm_target *ti, unsigned int argc, char **argv,

drivers/md/dm-era-target.c

1696

struct era *era = ti->private;

drivers/md/dm-era-target.c

1721

static int era_iterate_devices(struct dm_target *ti,

drivers/md/dm-era-target.c

1724

struct era *era = ti->private;

drivers/md/dm-era-target.c

1726

return fn(ti, era->origin_dev, 0, get_dev_size(era->origin_dev), data);

drivers/md/dm-era-target.c

1729

static void era_io_hints(struct dm_target *ti, struct queue_limits *limits)

drivers/md/dm-era-target.c

1731

struct era *era = ti->private;

drivers/md/dm-exception-store.c

192

int dm_exception_store_create(struct dm_target *ti, int argc, char **argv,

drivers/md/dm-exception-store.c

203

ti->error = "Insufficient exception store arguments";

drivers/md/dm-exception-store.c

209

ti->error = "Exception store allocation failed";

drivers/md/dm-exception-store.c

219

ti->error = "Exception store type is not P or N";

drivers/md/dm-exception-store.c

225

ti->error = "Exception store type not recognised";

drivers/md/dm-exception-store.c

233

r = set_chunk_size(tmp_store, argv[1], &ti->error);

drivers/md/dm-exception-store.c

239

ti->error = "Exception store type constructor failed";

drivers/md/dm-exception-store.h

188

int dm_exception_store_create(struct dm_target *ti, int argc, char **argv,

drivers/md/dm-flakey.c

101

ti->error = "Feature drop_writes duplicated";

drivers/md/dm-flakey.c

104

ti->error = "Feature drop_writes conflicts with feature error_writes";

drivers/md/dm-flakey.c

116

ti->error = "Feature error_writes duplicated";

drivers/md/dm-flakey.c

120

ti->error = "Feature error_writes conflicts with feature drop_writes";

drivers/md/dm-flakey.c

132

ti->error = "Feature corrupt_bio_byte duplicated";

drivers/md/dm-flakey.c

135

ti->error = "Feature corrupt_bio_byte requires 4 parameters";

drivers/md/dm-flakey.c

139

r = dm_read_arg(_args + 1, as, &fc->corrupt_bio_byte, &ti->error);

drivers/md/dm-flakey.c

153

ti->error = "Invalid corrupt bio direction (r or w)";

drivers/md/dm-flakey.c

161

r = dm_read_arg(_args + 2, as, &fc->corrupt_bio_value, &ti->error);

drivers/md/dm-flakey.c

173

&ti->error);

drivers/md/dm-flakey.c

183

ti->error = "Feature random_read_corrupt duplicated";

drivers/md/dm-flakey.c

186

ti->error = "Feature random_read_corrupt requires a parameter";

drivers/md/dm-flakey.c

189

r = dm_read_arg(_args + 4, as, &fc->random_read_corrupt, &ti->error);

drivers/md/dm-flakey.c

199

ti->error = "Feature random_write_corrupt duplicated";

drivers/md/dm-flakey.c

202

ti->error = "Feature random_write_corrupt requires a parameter";

drivers/md/dm-flakey.c

205

r = dm_read_arg(_args + 4, as, &fc->random_write_corrupt, &ti->error);

drivers/md/dm-flakey.c

213

ti->error = "Unrecognised flakey feature requested";

drivers/md/dm-flakey.c

220

ti->error = "drop_writes is incompatible with random_write_corrupt or corrupt_bio_byte with the WRITE flag set";

drivers/md/dm-flakey.c

226

ti->error = "error_writes is incompatible with random_write_corrupt or corrupt_bio_byte with the WRITE flag set";

drivers/md/dm-flakey.c

231

ti->error = "error_reads is incompatible with random_read_corrupt or corrupt_bio_byte with the READ flag set";

drivers/md/dm-flakey.c

258

static int flakey_ctr(struct dm_target *ti, unsigned int argc, char **argv)

drivers/md/dm-flakey.c

276

ti->error = "Invalid argument count";

drivers/md/dm-flakey.c

282

ti->error = "Cannot allocate context";

drivers/md/dm-flakey.c

291

ti->error = "Invalid device sector";

drivers/md/dm-flakey.c

296

r = dm_read_arg(_args, &as, &fc->up_interval, &ti->error);

drivers/md/dm-flakey.c

300

r = dm_read_arg(_args + 1, &as, &fc->down_interval, &ti->error);

drivers/md/dm-flakey.c

305

ti->error = "Total (up + down) interval is zero";

drivers/md/dm-flakey.c

311

ti->error = "Interval overflow";

drivers/md/dm-flakey.c

316

r = parse_features(&as, fc, ti);

drivers/md/dm-flakey.c

320

r = dm_get_device(ti, devname, dm_table_get_mode(ti->table), &fc->dev);

drivers/md/dm-flakey.c

322

ti->error = "Device lookup failed";

drivers/md/dm-flakey.c

326

ti->num_flush_bios = 1;

drivers/md/dm-flakey.c

327

ti->num_discard_bios = 1;

drivers/md/dm-flakey.c

328

ti->per_io_data_size = sizeof(struct per_bio_data);

drivers/md/dm-flakey.c

329

ti->private = fc;

drivers/md/dm-flakey.c

337

static void flakey_dtr(struct dm_target *ti)

drivers/md/dm-flakey.c

339

struct flakey_c *fc = ti->private;

drivers/md/dm-flakey.c

341

dm_put_device(ti, fc->dev);

drivers/md/dm-flakey.c

345

static sector_t flakey_map_sector(struct dm_target *ti, sector_t bi_sector)

drivers/md/dm-flakey.c

347

struct flakey_c *fc = ti->private;

drivers/md/dm-flakey.c

349

return fc->start + dm_target_offset(ti, bi_sector);

drivers/md/dm-flakey.c

352

static void flakey_map_bio(struct dm_target *ti, struct bio *bio)

drivers/md/dm-flakey.c

354

struct flakey_c *fc = ti->private;

drivers/md/dm-flakey.c

357

bio->bi_iter.bi_sector = flakey_map_sector(ti, bio->bi_iter.bi_sector);

drivers/md/dm-flakey.c

428

static struct bio *clone_bio(struct dm_target *ti, struct flakey_c *fc, struct bio *bio)

drivers/md/dm-flakey.c

446

clone->bi_iter.bi_sector = flakey_map_sector(ti, bio->bi_iter.bi_sector);

drivers/md/dm-flakey.c

493

static int flakey_map(struct dm_target *ti, struct bio *bio)

drivers/md/dm-flakey.c

495

struct flakey_c *fc = ti->private;

drivers/md/dm-flakey.c

55

struct dm_target *ti)

drivers/md/dm-flakey.c

553

struct bio *clone = clone_bio(ti, fc, bio);

drivers/md/dm-flakey.c

568

flakey_map_bio(ti, bio);

drivers/md/dm-flakey.c

573

static int flakey_end_io(struct dm_target *ti, struct bio *bio,

drivers/md/dm-flakey.c

576

struct flakey_c *fc = ti->private;

drivers/md/dm-flakey.c

603

static void flakey_status(struct dm_target *ti, status_type_t type,

drivers/md/dm-flakey.c

607

struct flakey_c *fc = ti->private;

drivers/md/dm-flakey.c

654

static int flakey_prepare_ioctl(struct dm_target *ti, struct block_device **bdev,

drivers/md/dm-flakey.c

658

struct flakey_c *fc = ti->private;

drivers/md/dm-flakey.c

665

if (fc->start || ti->len != bdev_nr_sectors((*bdev)))

drivers/md/dm-flakey.c

671

static int flakey_report_zones(struct dm_target *ti,

drivers/md/dm-flakey.c

674

struct flakey_c *fc = ti->private;

drivers/md/dm-flakey.c

677

flakey_map_sector(ti, args->next_sector),

drivers/md/dm-flakey.c

684

static int flakey_iterate_devices(struct dm_target *ti, iterate_devices_callout_fn fn, void *data)

drivers/md/dm-flakey.c

686

struct flakey_c *fc = ti->private;

drivers/md/dm-flakey.c

688

return fn(ti, fc->dev, fc->start, ti->len, data);

drivers/md/dm-flakey.c

69

if (as->argc && (r = dm_read_arg_group(_args, as, &argc, &ti->error)))

drivers/md/dm-flakey.c

81

ti->error = "Insufficient feature arguments";

drivers/md/dm-flakey.c

90

ti->error = "Feature error_reads duplicated";

drivers/md/dm-ima.c

228

struct dm_target *ti = dm_table_get_target(table, i);

drivers/md/dm-ima.c

237

i, ti->begin, ti->len);

drivers/md/dm-ima.c

242

if (ti->type->status)

drivers/md/dm-ima.c

243

ti->type->status(ti, type, 0, target_data_buf,

drivers/md/dm-inlinecrypt.c

233

static int inlinecrypt_ctr_optional(struct dm_target *ti,

drivers/md/dm-inlinecrypt.c

236

struct inlinecrypt_ctx *ctx = ti->private;

drivers/md/dm-inlinecrypt.c

250

err = dm_read_arg_group(_args, &as, &opt_params, &ti->error);

drivers/md/dm-inlinecrypt.c

257

ti->error = "Not enough feature arguments";

drivers/md/dm-inlinecrypt.c

264

ti->error = "Invalid block key type";

drivers/md/dm-inlinecrypt.c

273

ti->error = "Invalid block key type";

drivers/md/dm-inlinecrypt.c

277

ti->num_discard_bios = 1;

drivers/md/dm-inlinecrypt.c

283

ti->error = "Invalid sector_size";

drivers/md/dm-inlinecrypt.c

289

ti->error = "Invalid feature arguments";

drivers/md/dm-inlinecrypt.c

296

ti->error = "iv_large_sectors must be specified";

drivers/md/dm-inlinecrypt.c

310

static int inlinecrypt_ctr(struct dm_target *ti, unsigned int argc, char **argv)

drivers/md/dm-inlinecrypt.c

321

ti->error = "Not enough arguments";

drivers/md/dm-inlinecrypt.c

327

ti->error = "Out of memory";

drivers/md/dm-inlinecrypt.c

330

ti->private = ctx;

drivers/md/dm-inlinecrypt.c

335

ti->error = "Out of memory";

drivers/md/dm-inlinecrypt.c

341

ti->error = "Unsupported cipher";

drivers/md/dm-inlinecrypt.c

349

ti->error = "Cannot parse key size";

drivers/md/dm-inlinecrypt.c

357

ti->error = "Malformed key string";

drivers/md/dm-inlinecrypt.c

363

ti->error = "Invalid iv_offset sector";

drivers/md/dm-inlinecrypt.c

369

err = dm_get_device(ti, argv[3], dm_table_get_mode(ti->table),

drivers/md/dm-inlinecrypt.c

372

ti->error = "Device lookup failed";

drivers/md/dm-inlinecrypt.c

379

ti->error = "Invalid start sector";

drivers/md/dm-inlinecrypt.c

389

err = inlinecrypt_ctr_optional(ti, argc - 5, &argv[5]);

drivers/md/dm-inlinecrypt.c

394

if (ti->len & ((ctx->sector_size >> SECTOR_SHIFT) - 1)) {

drivers/md/dm-inlinecrypt.c

395

ti->error = "Device size is not a multiple of sector_size";

drivers/md/dm-inlinecrypt.c

400

ti->error = "Wrong alignment of iv_offset sector";

drivers/md/dm-inlinecrypt.c

405

ctx->max_dun = (ctx->iv_offset + ti->len - 1) >>

drivers/md/dm-inlinecrypt.c

413

ti->error = "Error initializing blk-crypto key";

drivers/md/dm-inlinecrypt.c

419

ti->error = "Error starting to use blk-crypto";

drivers/md/dm-inlinecrypt.c

423

ti->num_flush_bios = 1;

drivers/md/dm-inlinecrypt.c

429

inlinecrypt_dtr(ti);

drivers/md/dm-inlinecrypt.c

435

static int inlinecrypt_map(struct dm_target *ti, struct bio *bio)

drivers/md/dm-inlinecrypt.c

437

const struct inlinecrypt_ctx *ctx = ti->private;

drivers/md/dm-inlinecrypt.c

459

sector_in_target = dm_target_offset(ti, bio->bi_iter.bi_sector);

drivers/md/dm-inlinecrypt.c

505

static void inlinecrypt_status(struct dm_target *ti, status_type_t type,

drivers/md/dm-inlinecrypt.c

509

const struct inlinecrypt_ctx *ctx = ti->private;

drivers/md/dm-inlinecrypt.c

529

num_feature_args += !!ti->num_discard_bios;

drivers/md/dm-inlinecrypt.c

534

if (ti->num_discard_bios)

drivers/md/dm-inlinecrypt.c

545

static int inlinecrypt_prepare_ioctl(struct dm_target *ti,

drivers/md/dm-inlinecrypt.c

549

const struct inlinecrypt_ctx *ctx = ti->private;

drivers/md/dm-inlinecrypt.c

555

return ctx->start != 0 || ti->len != bdev_nr_sectors(dev->bdev);

drivers/md/dm-inlinecrypt.c

558

static int inlinecrypt_iterate_devices(struct dm_target *ti,

drivers/md/dm-inlinecrypt.c

562

const struct inlinecrypt_ctx *ctx = ti->private;

drivers/md/dm-inlinecrypt.c

564

return fn(ti, ctx->dev, ctx->start, ti->len, data);

drivers/md/dm-inlinecrypt.c

568

static int inlinecrypt_report_zones(struct dm_target *ti,

drivers/md/dm-inlinecrypt.c

572

const struct inlinecrypt_ctx *ctx = ti->private;

drivers/md/dm-inlinecrypt.c

575

ctx->start + dm_target_offset(ti, args->next_sector),

drivers/md/dm-inlinecrypt.c

582

static void inlinecrypt_io_hints(struct dm_target *ti,

drivers/md/dm-inlinecrypt.c

585

const struct inlinecrypt_ctx *ctx = ti->private;

drivers/md/dm-inlinecrypt.c

65

static void inlinecrypt_dtr(struct dm_target *ti)

drivers/md/dm-inlinecrypt.c

67

struct inlinecrypt_ctx *ctx = ti->private;

drivers/md/dm-inlinecrypt.c

72

dm_put_device(ti, ctx->dev);

drivers/md/dm-integrity.c

2047

static int dm_integrity_map(struct dm_target *ti, struct bio *bio)

drivers/md/dm-integrity.c

2049

struct dm_integrity_c *ic = ti->private;

drivers/md/dm-integrity.c

2061

bio->bi_iter.bi_sector = dm_target_offset(ic->ti, bio->bi_iter.bi_sector);

drivers/md/dm-integrity.c

2069

if (ti->max_io_len) {

drivers/md/dm-integrity.c

2070

sector_t sec = dm_target_offset(ti, bio->bi_iter.bi_sector);

drivers/md/dm-integrity.c

2071

unsigned int log2_max_io_len = __fls(ti->max_io_len);

drivers/md/dm-integrity.c

2076

sector_t len = ti->max_io_len - (sec & (ti->max_io_len - 1));

drivers/md/dm-integrity.c

2088

dio->range.logical_sector = dm_target_offset(ti, bio->bi_iter.bi_sector);

drivers/md/dm-integrity.c

231

struct dm_target *ti;

drivers/md/dm-integrity.c

2746

static int dm_integrity_end_io(struct dm_target *ti, struct bio *bio, blk_status_t *status)

drivers/md/dm-integrity.c

2748

struct dm_integrity_c *ic = ti->private;

drivers/md/dm-integrity.c

3035

dm_audit_log_target(DM_MSG_PREFIX, "integrity-replay-journal", ic->ti, 0);

drivers/md/dm-integrity.c

3155

if (unlikely(dm_post_suspending(ic->ti)))

drivers/md/dm-integrity.c

3317

if (unlikely(dm_post_suspending(ic->ti)))

drivers/md/dm-integrity.c

3734

static void dm_integrity_postsuspend(struct dm_target *ti)

drivers/md/dm-integrity.c

3736

struct dm_integrity_c *ic = ti->private;

drivers/md/dm-integrity.c

378

static void dm_integrity_dtr(struct dm_target *ti);

drivers/md/dm-integrity.c

3783

static void dm_integrity_resume(struct dm_target *ti)

drivers/md/dm-integrity.c

3785

struct dm_integrity_c *ic = ti->private;

drivers/md/dm-integrity.c

3918

static void dm_integrity_status(struct dm_target *ti, status_type_t type,

drivers/md/dm-integrity.c

3921

struct dm_integrity_c *ic = ti->private;

drivers/md/dm-integrity.c

4004

DMEMIT_TARGET_NAME_VERSION(ti->type);

drivers/md/dm-integrity.c

4030

static int dm_integrity_iterate_devices(struct dm_target *ti,

drivers/md/dm-integrity.c

4033

struct dm_integrity_c *ic = ti->private;

drivers/md/dm-integrity.c

4036

return fn(ti, ic->dev, ic->start + ic->initial_sectors + ic->metadata_run, ti->len, data);

drivers/md/dm-integrity.c

4038

return fn(ti, ic->dev, 0, ti->len, data);

drivers/md/dm-integrity.c

4041

static void dm_integrity_io_hints(struct dm_target *ti, struct queue_limits *limits)

drivers/md/dm-integrity.c

4043

struct dm_integrity_c *ic = ti->private;

drivers/md/dm-integrity.c

4670

static int dm_integrity_ctr(struct dm_target *ti, unsigned int argc, char **argv)

drivers/md/dm-integrity.c

4692

ti->error = "Invalid argument count";

drivers/md/dm-integrity.c

4698

ti->error = "Cannot allocate integrity context";

drivers/md/dm-integrity.c

4701

ti->private = ic;

drivers/md/dm-integrity.c

4702

ti->per_io_data_size = sizeof(struct dm_integrity_io);

drivers/md/dm-integrity.c

4703

ic->ti = ti;

drivers/md/dm-integrity.c

4714

r = dm_get_device(ti, argv[0], dm_table_get_mode(ti->table), &ic->dev);

drivers/md/dm-integrity.c

4716

ti->error = "Device lookup failed";

drivers/md/dm-integrity.c

4721

ti->error = "Invalid starting offset";

drivers/md/dm-integrity.c

4729

ti->error = "Invalid tag size";

drivers/md/dm-integrity.c

4740

ti->error = "Invalid mode (expecting J, B, D, R, I)";

drivers/md/dm-integrity.c

4754

r = dm_read_arg_group(_args, &as, &extra_args, &ti->error);

drivers/md/dm-integrity.c

4766

ti->error = "Not enough feature arguments";

drivers/md/dm-integrity.c

4781

dm_put_device(ti, ic->meta_dev);

drivers/md/dm-integrity.c

4784

r = dm_get_device(ti, strchr(opt_string, ':') + 1,

drivers/md/dm-integrity.c

4785

dm_table_get_mode(ti->table), &ic->meta_dev);

drivers/md/dm-integrity.c

4787

ti->error = "Device lookup failed";

drivers/md/dm-integrity.c

4795

ti->error = "Invalid block_size argument";

drivers/md/dm-integrity.c

4804

ti->error = "Invalid bitmap_flush_interval argument";

drivers/md/dm-integrity.c

4809

r = get_alg_and_key(opt_string, &ic->internal_hash_alg, &ti->error,

drivers/md/dm-integrity.c

4814

r = get_alg_and_key(opt_string, &ic->journal_crypt_alg, &ti->error,

drivers/md/dm-integrity.c

4819

r = get_alg_and_key(opt_string, &ic->journal_mac_alg, &ti->error,

drivers/md/dm-integrity.c

4838

ti->error = "Invalid argument";

drivers/md/dm-integrity.c

4858

r = get_mac(&ic->internal_shash, &ic->internal_ahash, &ic->internal_hash_alg, &ti->error,

drivers/md/dm-integrity.c

4872

ti->error = "Cannot allocate mempool";

drivers/md/dm-integrity.c

4877

r = get_mac(&ic->journal_mac, NULL, &ic->journal_mac_alg, &ti->error,

drivers/md/dm-integrity.c

4884

ti->error = "Unknown tag size";

drivers/md/dm-integrity.c

4891

ti->error = "Too big tag size";

drivers/md/dm-integrity.c

4904

ti->error = "Metadata device not supported in inline mode";

drivers/md/dm-integrity.c

4909

ti->error = "Internal hash not set in inline mode";

drivers/md/dm-integrity.c

4914

ti->error = "Journal crypt not supported in inline mode";

drivers/md/dm-integrity.c

4919

ti->error = "Discards not supported in inline mode";

drivers/md/dm-integrity.c

4925

ti->error = "Integrity profile not supported";

drivers/md/dm-integrity.c

4931

ti->error = "The integrity profile is smaller than tag size";

drivers/md/dm-integrity.c

4936

ti->error = "Too big tuple size";

drivers/md/dm-integrity.c

4942

ti->error = "Integrity profile sector size mismatch";

drivers/md/dm-integrity.c

4949

ti->error = "Bitmap mode can be only used with internal hash";

drivers/md/dm-integrity.c

4955

ti->error = "Discard can be only used with internal hash";

drivers/md/dm-integrity.c

4967

ti->error = "Cannot allocate dm io";

drivers/md/dm-integrity.c

4973

ti->error = "Cannot allocate mempool";

drivers/md/dm-integrity.c

4979

ti->error = "Cannot allocate mempool";

drivers/md/dm-integrity.c

4986

ti->error = "Cannot allocate bio set";

drivers/md/dm-integrity.c

4991

ti->error = "Cannot allocate bio set";

drivers/md/dm-integrity.c

5000

ti->error = "Cannot allocate workqueue";

drivers/md/dm-integrity.c

5011

ti->error = "Cannot allocate workqueue";

drivers/md/dm-integrity.c

5020

ti->error = "Cannot allocate workqueue";

drivers/md/dm-integrity.c

5028

ti->error = "Cannot allocate workqueue";

drivers/md/dm-integrity.c

5038

ti->error = "Cannot allocate workqueue";

drivers/md/dm-integrity.c

5048

ti->error = "Cannot allocate superblock area";

drivers/md/dm-integrity.c

5054

ti->error = "Error reading superblock";

drivers/md/dm-integrity.c

5062

ti->error = "The device is not initialized";

drivers/md/dm-integrity.c

5069

ti->error = "Could not initialize superblock";

drivers/md/dm-integrity.c

5078

ti->error = "Unknown version";

drivers/md/dm-integrity.c

5083

ti->error = "Inline flag mismatch";

drivers/md/dm-integrity.c

5088

ti->error = "Tag size doesn't match the information in superblock";

drivers/md/dm-integrity.c

5093

ti->error = "Block size doesn't match the information in superblock";

drivers/md/dm-integrity.c

5099

ti->error = "Corrupted superblock, journal_sections is 0";

drivers/md/dm-integrity.c

5105

ti->error = "Corrupted superblock, journal_sections is not 0";

drivers/md/dm-integrity.c

5114

ti->error = "Invalid interleave_sectors in the superblock";

drivers/md/dm-integrity.c

5120

ti->error = "Invalid interleave_sectors in the superblock";

drivers/md/dm-integrity.c

5126

ti->error = "Journal mac mismatch";

drivers/md/dm-integrity.c

5140

ti->error = "fix_hmac is on the command line but not in the superblock";

drivers/md/dm-integrity.c

5147

ti->error = "The device is too small";

drivers/md/dm-integrity.c

5160

ti->error = "The device is too small";

drivers/md/dm-integrity.c

5188

if (ti->len > ic->provided_data_sectors) {

drivers/md/dm-integrity.c

5190

ti->error = "Not enough provided sectors for requested mapping size";

drivers/md/dm-integrity.c

5225

ti->error = "Cannot allocate workqueue";

drivers/md/dm-integrity.c

5232

ti->error = "Recalculate can only be specified with internal_hash";

drivers/md/dm-integrity.c

5241

ti->error = "Recalculating with HMAC is disabled for security reasons - if you really need it, use the argument \"legacy_recalculate\"";

drivers/md/dm-integrity.c

5250

ti->error = "Cannot initialize dm-bufio";

drivers/md/dm-integrity.c

5257

r = create_journal(ic, &ti->error);

drivers/md/dm-integrity.c

5269

ti->error = "Could not allocate memory for bitmap";

drivers/md/dm-integrity.c

5275

ti->error = "Could not allocate memory for bitmap";

drivers/md/dm-integrity.c

5282

ti->error = "Could not allocate memory for bitmap";

drivers/md/dm-integrity.c

5309

ti->error = "Error initializing journal";

drivers/md/dm-integrity.c

5314

ti->error = "Error initializing superblock";

drivers/md/dm-integrity.c

532

dm_audit_log_target(DM_MSG_PREFIX, "mac-superblock", ic->ti, 0);

drivers/md/dm-integrity.c

5321

r = dm_set_target_max_io_len(ti, 1U << ic->sb->log2_interleave_sectors);

drivers/md/dm-integrity.c

5331

DEBUG_print("max_io_len: old %u, new %u\n", ti->max_io_len, max_io_len);

drivers/md/dm-integrity.c

5332

if (!ti->max_io_len || ti->max_io_len > max_io_len) {

drivers/md/dm-integrity.c

5333

r = dm_set_target_max_io_len(ti, max_io_len);

drivers/md/dm-integrity.c

5339

ti->num_flush_bios = 1;

drivers/md/dm-integrity.c

5340

ti->flush_supported = true;

drivers/md/dm-integrity.c

5342

ti->num_discard_bios = 1;

drivers/md/dm-integrity.c

5345

ti->mempool_needs_integrity = true;

drivers/md/dm-integrity.c

5347

dm_audit_log_ctr(DM_MSG_PREFIX, ti, 1);

drivers/md/dm-integrity.c

5351

dm_audit_log_ctr(DM_MSG_PREFIX, ti, 0);

drivers/md/dm-integrity.c

5352

dm_integrity_dtr(ti);

drivers/md/dm-integrity.c

5356

static void dm_integrity_dtr(struct dm_target *ti)

drivers/md/dm-integrity.c

5358

struct dm_integrity_c *ic = ti->private;

drivers/md/dm-integrity.c

5389

dm_put_device(ti, ic->dev);

drivers/md/dm-integrity.c

5391

dm_put_device(ti, ic->meta_dev);

drivers/md/dm-integrity.c

5434

dm_audit_log_dtr(DM_MSG_PREFIX, ti, 1);

drivers/md/dm-integrity.c

875

dm_audit_log_target(DM_MSG_PREFIX, "mac-journal", ic->ti, 0);

drivers/md/dm-ioctl.c

1428

struct dm_target *ti = dm_table_get_target(table, i);

drivers/md/dm-ioctl.c

1440

spec->sector_start = ti->begin;

drivers/md/dm-ioctl.c

1441

spec->length = ti->len;

drivers/md/dm-ioctl.c

1442

strscpy_pad(spec->target_type, ti->type->name,

drivers/md/dm-ioctl.c

1453

if (ti->type->status) {

drivers/md/dm-ioctl.c

1456

ti->type->status(ti, type, status_flags, outptr, remaining);

drivers/md/dm-ioctl.c

1907

struct dm_target *ti;

drivers/md/dm-ioctl.c

1952

ti = dm_table_find_target(table, tmsg->sector);

drivers/md/dm-ioctl.c

1953

if (!ti) {

drivers/md/dm-ioctl.c

1956

} else if (ti->type->message)

drivers/md/dm-ioctl.c

1957

r = ti->type->message(ti, argc, argv, result, maxlen);

drivers/md/dm-linear.c

102

struct linear_c *lc = ti->private;

drivers/md/dm-linear.c

115

DMEMIT_TARGET_NAME_VERSION(ti->type);

drivers/md/dm-linear.c

122

static int linear_prepare_ioctl(struct dm_target *ti, struct block_device **bdev,

drivers/md/dm-linear.c

126

struct linear_c *lc = ti->private;

drivers/md/dm-linear.c

134

if (lc->start || ti->len != bdev_nr_sectors(dev->bdev))

drivers/md/dm-linear.c

140

static int linear_report_zones(struct dm_target *ti,

drivers/md/dm-linear.c

143

struct linear_c *lc = ti->private;

drivers/md/dm-linear.c

146

linear_map_sector(ti, args->next_sector),

drivers/md/dm-linear.c

153

static int linear_iterate_devices(struct dm_target *ti,

drivers/md/dm-linear.c

156

struct linear_c *lc = ti->private;

drivers/md/dm-linear.c

158

return fn(ti, lc->dev, lc->start, ti->len, data);

drivers/md/dm-linear.c

162

static struct dax_device *linear_dax_pgoff(struct dm_target *ti, pgoff_t *pgoff)

drivers/md/dm-linear.c

164

struct linear_c *lc = ti->private;

drivers/md/dm-linear.c

165

sector_t sector = linear_map_sector(ti, *pgoff << PAGE_SECTORS_SHIFT);

drivers/md/dm-linear.c

171

static long linear_dax_direct_access(struct dm_target *ti, pgoff_t pgoff,

drivers/md/dm-linear.c

175

struct dax_device *dax_dev = linear_dax_pgoff(ti, &pgoff);

drivers/md/dm-linear.c

180

static int linear_dax_zero_page_range(struct dm_target *ti, pgoff_t pgoff,

drivers/md/dm-linear.c

183

struct dax_device *dax_dev = linear_dax_pgoff(ti, &pgoff);

drivers/md/dm-linear.c

188

static size_t linear_dax_recovery_write(struct dm_target *ti, pgoff_t pgoff,

drivers/md/dm-linear.c

191

struct dax_device *dax_dev = linear_dax_pgoff(ti, &pgoff);

drivers/md/dm-linear.c

30

static int linear_ctr(struct dm_target *ti, unsigned int argc, char **argv)

drivers/md/dm-linear.c

38

ti->error = "Invalid argument count";

drivers/md/dm-linear.c

44

ti->error = "Cannot allocate linear context";

drivers/md/dm-linear.c

50

ti->error = "Invalid device sector";

drivers/md/dm-linear.c

55

ret = dm_get_device(ti, argv[0], dm_table_get_mode(ti->table), &lc->dev);

drivers/md/dm-linear.c

57

ti->error = "Device lookup failed";

drivers/md/dm-linear.c

61

ti->num_flush_bios = 1;

drivers/md/dm-linear.c

62

ti->num_discard_bios = 1;

drivers/md/dm-linear.c

63

ti->num_secure_erase_bios = 1;

drivers/md/dm-linear.c

64

ti->num_write_zeroes_bios = 1;

drivers/md/dm-linear.c

65

ti->flush_bypasses_map = true;

drivers/md/dm-linear.c

66

ti->private = lc;

drivers/md/dm-linear.c

74

static void linear_dtr(struct dm_target *ti)

drivers/md/dm-linear.c

76

struct linear_c *lc = ti->private;

drivers/md/dm-linear.c

78

dm_put_device(ti, lc->dev);

drivers/md/dm-linear.c

82

static sector_t linear_map_sector(struct dm_target *ti, sector_t bi_sector)

drivers/md/dm-linear.c

84

struct linear_c *lc = ti->private;

drivers/md/dm-linear.c

86

return lc->start + dm_target_offset(ti, bi_sector);

drivers/md/dm-linear.c

89

int linear_map(struct dm_target *ti, struct bio *bio)

drivers/md/dm-linear.c

91

struct linear_c *lc = ti->private;

drivers/md/dm-linear.c

94

bio->bi_iter.bi_sector = linear_map_sector(ti, bio->bi_iter.bi_sector);

drivers/md/dm-linear.c

99

static void linear_status(struct dm_target *ti, status_type_t type,

drivers/md/dm-log-userspace-base.c

126

static int build_constructor_string(struct dm_target *ti,

drivers/md/dm-log-userspace-base.c

149

str_size = sprintf(str, "%llu", (unsigned long long)ti->len);

drivers/md/dm-log-userspace-base.c

167

dm_table_event(lc->ti->table);

drivers/md/dm-log-userspace-base.c

191

static int userspace_ctr(struct dm_dirty_log *log, struct dm_target *ti,

drivers/md/dm-log-userspace-base.c

217

lc->ti = ti;

drivers/md/dm-log-userspace-base.c

240

str_size = build_constructor_string(ti, argc, argv, &ctr_str);

drivers/md/dm-log-userspace-base.c

286

lc->region_count = dm_sector_div_up(ti->len, lc->region_size);

drivers/md/dm-log-userspace-base.c

294

r = dm_get_device(ti, devices_rdata,

drivers/md/dm-log-userspace-base.c

295

dm_table_get_mode(ti->table), &lc->log_dev);

drivers/md/dm-log-userspace-base.c

344

dm_put_device(lc->ti, lc->log_dev);

drivers/md/dm-log-userspace-base.c

38

struct dm_target *ti;

drivers/md/dm-log-userspace-base.c

637

dm_table_event(lc->ti->table);

drivers/md/dm-log-writes.c

507

static int log_writes_ctr(struct dm_target *ti, unsigned int argc, char **argv)

drivers/md/dm-log-writes.c

518

ti->error = "Invalid argument count";

drivers/md/dm-log-writes.c

524

ti->error = "Cannot allocate context";

drivers/md/dm-log-writes.c

536

ret = dm_get_device(ti, devname, dm_table_get_mode(ti->table), &lc->dev);

drivers/md/dm-log-writes.c

538

ti->error = "Device lookup failed";

drivers/md/dm-log-writes.c

543

ret = dm_get_device(ti, logdevname, dm_table_get_mode(ti->table),

drivers/md/dm-log-writes.c

546

ti->error = "Log device lookup failed";

drivers/md/dm-log-writes.c

547

dm_put_device(ti, lc->dev);

drivers/md/dm-log-writes.c

556

ti->error = "Couldn't alloc kthread";

drivers/md/dm-log-writes.c

557

dm_put_device(ti, lc->dev);

drivers/md/dm-log-writes.c

558

dm_put_device(ti, lc->logdev);

drivers/md/dm-log-writes.c

572

ti->num_flush_bios = 1;

drivers/md/dm-log-writes.c

573

ti->flush_supported = true;

drivers/md/dm-log-writes.c

574

ti->num_discard_bios = 1;

drivers/md/dm-log-writes.c

575

ti->discards_supported = true;

drivers/md/dm-log-writes.c

576

ti->per_io_data_size = sizeof(struct per_bio_data);

drivers/md/dm-log-writes.c

577

ti->private = lc;

drivers/md/dm-log-writes.c

612

static void log_writes_dtr(struct dm_target *ti)

drivers/md/dm-log-writes.c

614

struct log_writes_c *lc = ti->private;

drivers/md/dm-log-writes.c

632

dm_put_device(ti, lc->dev);

drivers/md/dm-log-writes.c

633

dm_put_device(ti, lc->logdev);

drivers/md/dm-log-writes.c

637

static void normal_map_bio(struct dm_target *ti, struct bio *bio)

drivers/md/dm-log-writes.c

639

struct log_writes_c *lc = ti->private;

drivers/md/dm-log-writes.c

644

static int log_writes_map(struct dm_target *ti, struct bio *bio)

drivers/md/dm-log-writes.c

646

struct log_writes_c *lc = ti->private;

drivers/md/dm-log-writes.c

763

normal_map_bio(ti, bio);

drivers/md/dm-log-writes.c

767

static int normal_end_io(struct dm_target *ti, struct bio *bio,

drivers/md/dm-log-writes.c

770

struct log_writes_c *lc = ti->private;

drivers/md/dm-log-writes.c

796

static void log_writes_status(struct dm_target *ti, status_type_t type,

drivers/md/dm-log-writes.c

801

struct log_writes_c *lc = ti->private;

drivers/md/dm-log-writes.c

821

static int log_writes_prepare_ioctl(struct dm_target *ti,

drivers/md/dm-log-writes.c

826

struct log_writes_c *lc = ti->private;

drivers/md/dm-log-writes.c

833

if (ti->len != bdev_nr_sectors(dev->bdev))

drivers/md/dm-log-writes.c

838

static int log_writes_iterate_devices(struct dm_target *ti,

drivers/md/dm-log-writes.c

842

struct log_writes_c *lc = ti->private;

drivers/md/dm-log-writes.c

844

return fn(ti, lc->dev, 0, ti->len, data);

drivers/md/dm-log-writes.c

851

static int log_writes_message(struct dm_target *ti, unsigned int argc, char **argv,

drivers/md/dm-log-writes.c

855

struct log_writes_c *lc = ti->private;

drivers/md/dm-log-writes.c

870

static void log_writes_io_hints(struct dm_target *ti, struct queue_limits *limits)

drivers/md/dm-log-writes.c

872

struct log_writes_c *lc = ti->private;

drivers/md/dm-log-writes.c

886

static struct dax_device *log_writes_dax_pgoff(struct dm_target *ti,

drivers/md/dm-log-writes.c

889

struct log_writes_c *lc = ti->private;

drivers/md/dm-log-writes.c

895

static long log_writes_dax_direct_access(struct dm_target *ti, pgoff_t pgoff,

drivers/md/dm-log-writes.c

899

struct dax_device *dax_dev = log_writes_dax_pgoff(ti, &pgoff);

drivers/md/dm-log-writes.c

904

static int log_writes_dax_zero_page_range(struct dm_target *ti, pgoff_t pgoff,

drivers/md/dm-log-writes.c

907

struct dax_device *dax_dev = log_writes_dax_pgoff(ti, &pgoff);

drivers/md/dm-log-writes.c

912

static size_t log_writes_dax_recovery_write(struct dm_target *ti,

drivers/md/dm-log-writes.c

915

struct dax_device *dax_dev = log_writes_dax_pgoff(ti, &pgoff);

drivers/md/dm-log.c

149

struct dm_target *ti,

drivers/md/dm-log.c

150

int (*flush_callback_fn)(struct dm_target *ti),

drivers/md/dm-log.c

168

if (type->ctr(log, ti, argc, argv)) {

drivers/md/dm-log.c

221

struct dm_target *ti;

drivers/md/dm-log.c

349

static int _check_region_size(struct dm_target *ti, uint32_t region_size)

drivers/md/dm-log.c

351

if (region_size < 2 || region_size > ti->len)

drivers/md/dm-log.c

368

static int create_log_context(struct dm_dirty_log *log, struct dm_target *ti,

drivers/md/dm-log.c

398

!_check_region_size(ti, region_size)) {

drivers/md/dm-log.c

403

region_count = dm_sector_div_up(ti->len, region_size);

drivers/md/dm-log.c

415

lc->ti = ti;

drivers/md/dm-log.c

525

static int core_ctr(struct dm_dirty_log *log, struct dm_target *ti,

drivers/md/dm-log.c

528

return create_log_context(log, ti, argc, argv, NULL);

drivers/md/dm-log.c

553

static int disk_ctr(struct dm_dirty_log *log, struct dm_target *ti,

drivers/md/dm-log.c

564

r = dm_get_device(ti, argv[0], dm_table_get_mode(ti->table), &dev);

drivers/md/dm-log.c

568

r = create_log_context(log, ti, argc - 1, argv + 1, dev);

drivers/md/dm-log.c

570

dm_put_device(ti, dev);

drivers/md/dm-log.c

581

dm_put_device(lc->ti, lc->log_dev);

drivers/md/dm-log.c

593

dm_table_event(lc->ti->table);

drivers/md/dm-log.c

705

log->flush_callback_fn(lc->ti)) {

drivers/md/dm-mpath.c

1002

ti->error = "not enough priority group arguments";

drivers/md/dm-mpath.c

1008

ti->error = "couldn't allocate priority group";

drivers/md/dm-mpath.c

1013

r = parse_path_selector(as, pg, ti);

drivers/md/dm-mpath.c

1020

r = dm_read_arg(_args, as, &pg->nr_pgpaths, &ti->error);

drivers/md/dm-mpath.c

1024

r = dm_read_arg(_args + 1, as, &nr_selector_args, &ti->error);

drivers/md/dm-mpath.c

1034

ti->error = "not enough path parameters";

drivers/md/dm-mpath.c

1042

pgpath = parse_path(&path_args, &pg->ps, ti);

drivers/md/dm-mpath.c

1056

free_priority_group(pg, ti);

drivers/md/dm-mpath.c

1064

struct dm_target *ti = m->ti;

drivers/md/dm-mpath.c

1070

if (dm_read_arg_group(_args, as, &hw_argc, &ti->error))

drivers/md/dm-mpath.c

1094

ti->error = "memory allocation failed";

drivers/md/dm-mpath.c

1115

struct dm_target *ti = m->ti;

drivers/md/dm-mpath.c

1124

r = dm_read_arg_group(_args, as, &argc, &ti->error);

drivers/md/dm-mpath.c

1147

r = dm_read_arg(_args + 1, as, &m->pg_init_retries, &ti->error);

drivers/md/dm-mpath.c

1154

r = dm_read_arg(_args + 2, as, &m->pg_init_delay_msecs, &ti->error);

drivers/md/dm-mpath.c

1169

ti->error = "Unknown 'queue_mode' requested";

drivers/md/dm-mpath.c

1176

ti->error = "Unrecognised multipath feature request";

drivers/md/dm-mpath.c

1183

static int multipath_ctr(struct dm_target *ti, unsigned int argc, char **argv)

drivers/md/dm-mpath.c

1200

m = alloc_multipath(ti);

drivers/md/dm-mpath.c

1202

ti->error = "can't allocate multipath";

drivers/md/dm-mpath.c

1210

r = alloc_multipath_stage2(ti, m);

drivers/md/dm-mpath.c

1218

r = dm_read_arg(_args, &as, &m->nr_priority_groups, &ti->error);

drivers/md/dm-mpath.c

1222

r = dm_read_arg(_args + 1, &as, &next_pg_num, &ti->error);

drivers/md/dm-mpath.c

1228

ti->error = "invalid initial priority group";

drivers/md/dm-mpath.c

1255

ti->error = "priority group count mismatch";

drivers/md/dm-mpath.c

1264

ti->num_flush_bios = 1;

drivers/md/dm-mpath.c

1265

ti->num_discard_bios = 1;

drivers/md/dm-mpath.c

1266

ti->num_write_zeroes_bios = 1;

drivers/md/dm-mpath.c

1268

ti->per_io_data_size = multipath_per_bio_data_size();

drivers/md/dm-mpath.c

1270

ti->per_io_data_size = sizeof(struct dm_mpath_io);

drivers/md/dm-mpath.c

1319

static void multipath_dtr(struct dm_target *ti)

drivers/md/dm-mpath.c

1321

struct multipath *m = ti->private;

drivers/md/dm-mpath.c

1342

dm_table_device_name(m->ti->table),

drivers/md/dm-mpath.c

1354

dm_path_uevent(DM_UEVENT_PATH_FAILED, m->ti,

drivers/md/dm-mpath.c

1382

dm_table_device_name(m->ti->table),

drivers/md/dm-mpath.c

1400

dm_path_uevent(DM_UEVENT_PATH_REINSTATED, m->ti,

drivers/md/dm-mpath.c

1408

dm_table_run_md_queue_async(m->ti->table);

drivers/md/dm-mpath.c

1646

static int multipath_end_io(struct dm_target *ti, struct request *clone,

drivers/md/dm-mpath.c

1665

struct multipath *m = ti->private;

drivers/md/dm-mpath.c

1695

static int multipath_end_io_bio(struct dm_target *ti, struct bio *clone,

drivers/md/dm-mpath.c

1698

struct multipath *m = ti->private;

drivers/md/dm-mpath.c

1747

static void multipath_presuspend(struct dm_target *ti)

drivers/md/dm-mpath.c

1749

struct multipath *m = ti->private;

drivers/md/dm-mpath.c

1752

if (m->queue_mode == DM_TYPE_BIO_BASED || !dm_noflush_suspending(m->ti))

drivers/md/dm-mpath.c

1756

static void multipath_postsuspend(struct dm_target *ti)

drivers/md/dm-mpath.c

1758

struct multipath *m = ti->private;

drivers/md/dm-mpath.c

1768

static void multipath_resume(struct dm_target *ti)

drivers/md/dm-mpath.c

1770

struct multipath *m = ti->private;

drivers/md/dm-mpath.c

1779

dm_table_device_name(m->ti->table), __func__,

drivers/md/dm-mpath.c

1802

static void multipath_status(struct dm_target *ti, status_type_t type,

drivers/md/dm-mpath.c

1806

struct multipath *m = ti->private;

drivers/md/dm-mpath.c

189

static void free_pgpaths(struct list_head *pgpaths, struct dm_target *ti)

drivers/md/dm-mpath.c

1919

DMEMIT_TARGET_NAME_VERSION(ti->type);

drivers/md/dm-mpath.c

195

dm_put_device(ti, pgpath->path.dev);

drivers/md/dm-mpath.c

1958

static int multipath_message(struct dm_target *ti, unsigned int argc, char **argv,

drivers/md/dm-mpath.c

1963

struct multipath *m = ti->private;

drivers/md/dm-mpath.c

1968

if (dm_suspended(ti)) {

drivers/md/dm-mpath.c

201

struct dm_target *ti)

drivers/md/dm-mpath.c

2096

if (!m->current_pg || dm_suspended(m->ti) ||

drivers/md/dm-mpath.c

210

free_pgpaths(&pg->pgpaths, ti);

drivers/md/dm-mpath.c

2105

dm_suspended(m->ti))

drivers/md/dm-mpath.c

2131

static int multipath_prepare_ioctl(struct dm_target *ti,

drivers/md/dm-mpath.c

2136

struct multipath *m = ti->private;

drivers/md/dm-mpath.c

214

static struct multipath *alloc_multipath(struct dm_target *ti)

drivers/md/dm-mpath.c

2180

dm_table_run_md_queue_async(m->ti->table);

drivers/md/dm-mpath.c

2187

if (!r && ti->len != bdev_nr_sectors((*bdev)))

drivers/md/dm-mpath.c

2192

static int multipath_iterate_devices(struct dm_target *ti,

drivers/md/dm-mpath.c

2195

struct multipath *m = ti->private;

drivers/md/dm-mpath.c

2202

ret = fn(ti, p->path.dev, ti->begin, ti->len, data);

drivers/md/dm-mpath.c

2227

static int multipath_busy(struct dm_target *ti)

drivers/md/dm-mpath.c

2230

struct multipath *m = ti->private;

drivers/md/dm-mpath.c

229

m->ti = ti;

drivers/md/dm-mpath.c

230

ti->private = m;

drivers/md/dm-mpath.c

238

static int alloc_multipath_stage2(struct dm_target *ti, struct multipath *m)

drivers/md/dm-mpath.c

245

dm_table_set_type(ti->table, m->queue_mode);

drivers/md/dm-mpath.c

266

free_priority_group(pg, m->ti);

drivers/md/dm-mpath.c

476

dm_table_device_name((m)->ti->table), \

drivers/md/dm-mpath.c

479

dm_noflush_suspending((m)->ti))

drivers/md/dm-mpath.c

487

return dm_noflush_suspending(m->ti);

drivers/md/dm-mpath.c

505

static int multipath_clone_and_map(struct dm_target *ti, struct request *rq,

drivers/md/dm-mpath.c

509

struct multipath *m = ti->private;

drivers/md/dm-mpath.c

668

static int multipath_map_bio(struct dm_target *ti, struct bio *bio)

drivers/md/dm-mpath.c

670

struct multipath *m = ti->private;

drivers/md/dm-mpath.c

680

dm_mq_kick_requeue_list(dm_table_get_md(m->ti->table));

drivers/md/dm-mpath.c

742

const char *dm_dev_name = dm_table_device_name(m->ti->table);

drivers/md/dm-mpath.c

768

dm_noflush_suspending(m->ti));

drivers/md/dm-mpath.c

773

dm_table_run_md_queue_async(m->ti->table);

drivers/md/dm-mpath.c

789

dm_table_device_name(m->ti->table));

drivers/md/dm-mpath.c

826

dm_table_event(m->ti->table);

drivers/md/dm-mpath.c

842

struct dm_target *ti)

drivers/md/dm-mpath.c

854

ti->error = "unknown path selector type";

drivers/md/dm-mpath.c

858

r = dm_read_arg_group(_args, as, &ps_argc, &ti->error);

drivers/md/dm-mpath.c

867

ti->error = "path selector constructor failed";

drivers/md/dm-mpath.c

925

struct dm_target *ti)

drivers/md/dm-mpath.c

929

struct multipath *m = ti->private;

drivers/md/dm-mpath.c

935

ti->error = "no device given";

drivers/md/dm-mpath.c

943

r = dm_get_device(ti, dm_shift_arg(as), dm_table_get_mode(ti->table),

drivers/md/dm-mpath.c

946

ti->error = "error getting device";

drivers/md/dm-mpath.c

962

ti->error = "error allocating handler name";

drivers/md/dm-mpath.c

968

r = setup_scsi_dh(p->path.dev->bdev, m, &attached_handler_name, &ti->error);

drivers/md/dm-mpath.c

974

r = ps->type->add_path(ps, &p->path, as->argc, as->argv, &ti->error);

drivers/md/dm-mpath.c

981

dm_put_device(ti, p->path.dev);

drivers/md/dm-mpath.c

99

struct dm_target *ti;

drivers/md/dm-mpath.c

998

struct dm_target *ti = m->ti;

drivers/md/dm-pcache/dm_pcache.c

111

ret = dm_get_device(pcache->ti, dm_shift_arg(as),

drivers/md/dm-pcache/dm_pcache.c

130

ret = dm_get_device(pcache->ti, dm_shift_arg(as),

drivers/md/dm-pcache/dm_pcache.c

241

dm_put_device(pcache->ti, pcache->cache_dev.dm_dev);

drivers/md/dm-pcache/dm_pcache.c

243

dm_put_device(pcache->ti, pcache->backing_dev.dm_dev);

drivers/md/dm-pcache/dm_pcache.c

280

static int dm_pcache_ctr(struct dm_target *ti, unsigned int argc, char **argv)

drivers/md/dm-pcache/dm_pcache.c

282

struct mapped_device *md = ti->table->md;

drivers/md/dm-pcache/dm_pcache.c

287

ti->error = "Don't support table loading for live md";

drivers/md/dm-pcache/dm_pcache.c

306

pcache->ti = ti;

drivers/md/dm-pcache/dm_pcache.c

308

ret = pcache_parse_args(pcache, argc, argv, &ti->error);

drivers/md/dm-pcache/dm_pcache.c

312

ret = pcache_start(pcache, &ti->error);

drivers/md/dm-pcache/dm_pcache.c

316

ti->num_flush_bios = 1;

drivers/md/dm-pcache/dm_pcache.c

317

ti->flush_supported = true;

drivers/md/dm-pcache/dm_pcache.c

318

ti->per_io_data_size = sizeof(struct pcache_request);

drivers/md/dm-pcache/dm_pcache.c

319

ti->private = pcache;

drivers/md/dm-pcache/dm_pcache.c

354

static void dm_pcache_dtr(struct dm_target *ti)

drivers/md/dm-pcache/dm_pcache.c

358

pcache = ti->private;

drivers/md/dm-pcache/dm_pcache.c

376

static int dm_pcache_map_bio(struct dm_target *ti, struct bio *bio)

drivers/md/dm-pcache/dm_pcache.c

379

struct dm_pcache *pcache = ti->private;

drivers/md/dm-pcache/dm_pcache.c

400

static void dm_pcache_status(struct dm_target *ti, status_type_t type,

drivers/md/dm-pcache/dm_pcache.c

404

struct dm_pcache *pcache = ti->private;

drivers/md/dm-pcache/dm_pcache.c

438

static int dm_pcache_message(struct dm_target *ti, unsigned int argc,

drivers/md/dm-pcache/dm_pcache.c

441

struct dm_pcache *pcache = ti->private;

drivers/md/dm-pcache/dm_pcache.h

20

struct dm_target *ti;

drivers/md/dm-pcache/dm_pcache.h

43

pcache_err("%s " fmt, pcache->ti->table->md->name, ##__VA_ARGS__)

drivers/md/dm-pcache/dm_pcache.h

45

pcache_info("%s " fmt, pcache->ti->table->md->name, ##__VA_ARGS__)

drivers/md/dm-pcache/dm_pcache.h

47

pcache_debug("%s " fmt, pcache->ti->table->md->name, ##__VA_ARGS__)

drivers/md/dm-raid.c

1146

rs->ti->error = "Bad numerical argument given for chunk_size";

drivers/md/dm-raid.c

1159

rs->ti->error = "Chunk size must be a power of 2";

drivers/md/dm-raid.c

1162

rs->ti->error = "Chunk size value is too small";

drivers/md/dm-raid.c

1196

rs->ti->error = "Not enough raid parameters given";

drivers/md/dm-raid.c

1202

rs->ti->error = "Only one 'nosync' argument allowed";

drivers/md/dm-raid.c

1209

rs->ti->error = "Only one 'sync' argument allowed";

drivers/md/dm-raid.c

1216

rs->ti->error = "Only one 'raid10_use_new_sets' argument allowed";

drivers/md/dm-raid.c

1225

rs->ti->error = "Wrong number of raid parameters given";

drivers/md/dm-raid.c

1235

rs->ti->error = "Only one 'raid10_format' argument pair allowed";

drivers/md/dm-raid.c

1239

rs->ti->error = "'raid10_format' is an invalid parameter for this RAID type";

drivers/md/dm-raid.c

1244

rs->ti->error = "Invalid 'raid10_format' value given";

drivers/md/dm-raid.c

1256

rs->ti->error = "Only one raid4/5/6 set journaling device allowed";

drivers/md/dm-raid.c

1260

rs->ti->error = "'journal_dev' is an invalid parameter for this RAID type";

drivers/md/dm-raid.c

1263

r = dm_get_device(rs->ti, arg, dm_table_get_mode(rs->ti->table),

drivers/md/dm-raid.c

1266

rs->ti->error = "raid4/5/6 journal device lookup failure";

drivers/md/dm-raid.c

1275

rs->ti->error = "No space for raid4/5/6 journal";

drivers/md/dm-raid.c

1288

rs->ti->error = "raid4/5/6 'journal_mode' is invalid without 'journal_dev'";

drivers/md/dm-raid.c

1292

rs->ti->error = "Only one raid4/5/6 'journal_mode' argument allowed";

drivers/md/dm-raid.c

1297

rs->ti->error = "Invalid 'journal_mode' argument";

drivers/md/dm-raid.c

1308

rs->ti->error = "Bad numerical argument given in raid params";

drivers/md/dm-raid.c

1319

rs->ti->error = "Invalid rebuild index given";

drivers/md/dm-raid.c

1324

rs->ti->error = "rebuild for this index already given";

drivers/md/dm-raid.c

1335

rs->ti->error = "write_mostly option is only valid for RAID1";

drivers/md/dm-raid.c

1340

rs->ti->error = "Invalid write_mostly index given";

drivers/md/dm-raid.c

1349

rs->ti->error = "max_write_behind option is only valid for RAID1";

drivers/md/dm-raid.c

1354

rs->ti->error = "Only one max_write_behind argument pair allowed";

drivers/md/dm-raid.c

1359

rs->ti->error = "Max write-behind limit out of range";

drivers/md/dm-raid.c

1366

rs->ti->error = "Only one daemon_sleep argument pair allowed";

drivers/md/dm-raid.c

1370

rs->ti->error = "daemon sleep period out of range";

drivers/md/dm-raid.c

1377

rs->ti->error = "Only one data_offset argument pair allowed";

drivers/md/dm-raid.c

1383

rs->ti->error = "Bogus data_offset value";

drivers/md/dm-raid.c

1390

rs->ti->error = "Only one delta_disks argument pair allowed";

drivers/md/dm-raid.c

1395

rs->ti->error = "Too many delta_disk requested";

drivers/md/dm-raid.c

1402

rs->ti->error = "Only one stripe_cache argument pair allowed";

drivers/md/dm-raid.c

1407

rs->ti->error = "Inappropriate argument: stripe_cache";

drivers/md/dm-raid.c

1412

rs->ti->error = "Bogus stripe cache entries value";

drivers/md/dm-raid.c

1418

rs->ti->error = "Only one min_recovery_rate argument pair allowed";

drivers/md/dm-raid.c

1423

rs->ti->error = "min_recovery_rate out of range";

drivers/md/dm-raid.c

1429

rs->ti->error = "Only one max_recovery_rate argument pair allowed";

drivers/md/dm-raid.c

1434

rs->ti->error = "max_recovery_rate out of range";

drivers/md/dm-raid.c

1440

rs->ti->error = "Only one region_size argument pair allowed";

drivers/md/dm-raid.c

1448

rs->ti->error = "Only one raid10_copies argument pair allowed";

drivers/md/dm-raid.c

1453

rs->ti->error = "Bad value for 'raid10_copies'";

drivers/md/dm-raid.c

1460

rs->ti->error = "Unable to parse RAID parameter";

drivers/md/dm-raid.c

1467

rs->ti->error = "sync and nosync are mutually exclusive";

drivers/md/dm-raid.c

1474

rs->ti->error = "sync/nosync and rebuild are mutually exclusive";

drivers/md/dm-raid.c

1479

rs->ti->error = "Can't set all raid1 devices to write_mostly";

drivers/md/dm-raid.c

1485

rs->ti->error = "Bogus recovery rates";

drivers/md/dm-raid.c

1497

if (dm_set_target_max_io_len(rs->ti, max_io_len))

drivers/md/dm-raid.c

1502

rs->ti->error = "Not enough devices to satisfy specification";

drivers/md/dm-raid.c

1508

rs->ti->error = "Error getting raid10 format";

drivers/md/dm-raid.c

1514

rs->ti->error = "Failed to recognize new raid10 layout";

drivers/md/dm-raid.c

1521

rs->ti->error = "RAID10 format 'near' and 'raid10_use_near_sets' are incompatible";

drivers/md/dm-raid.c

1546

rs->ti->error = "Inappropriate raid level; cannot change stripe_cache size";

drivers/md/dm-raid.c

1558

rs->ti->error = "Cannot change stripe_cache size on inactive RAID set";

drivers/md/dm-raid.c

1566

rs->ti->error = "Failed to set raid4/5/6 stripe cache size";

drivers/md/dm-raid.c

1617

rs->ti->error = "Component device(s) too small";

drivers/md/dm-raid.c

1664

rs->ti->error = "Bogus raid10 data copies or delta disks";

drivers/md/dm-raid.c

1689

rs->ti->error = "Target length not divisible by number of data devices";

drivers/md/dm-raid.c

1734

dm_table_event(rs->ti->table);

drivers/md/dm-raid.c

1749

rs->ti->error = "Can't takeover degraded raid set";

drivers/md/dm-raid.c

1754

rs->ti->error = "Can't takeover reshaping raid set";

drivers/md/dm-raid.c

1893

rs->ti->error = "takeover not possible";

drivers/md/dm-raid.c

2046

rs->ti->error = "Reshape not supported";

drivers/md/dm-raid.c

2048

rs->ti->error = "Can't reshape degraded raid set";

drivers/md/dm-raid.c

2050

rs->ti->error = "Convert request on recovering raid set prohibited";

drivers/md/dm-raid.c

2052

rs->ti->error = "raid set already reshaping!";

drivers/md/dm-raid.c

2054

rs->ti->error = "Reshaping only supported for raid1/4/5/6/10";

drivers/md/dm-raid.c

231

struct dm_target *ti;

drivers/md/dm-raid.c

2430

rs->ti->error =

drivers/md/dm-raid.c

2440

rs->ti->error = "Cannot change device positions in raid set";

drivers/md/dm-raid.c

2478

rs->ti->error = "Unable to assemble array: Unknown flag(s) in compatible feature flags";

drivers/md/dm-raid.c

2483

rs->ti->error = "Unable to assemble array: No incompatible feature flags supported yet";

drivers/md/dm-raid.c

2530

static int analyse_superblocks(struct dm_target *ti, struct raid_set *rs)

drivers/md/dm-raid.c

2605

rs->ti->error = "Unable to assemble array: Invalid superblocks";

drivers/md/dm-raid.c

2610

rs->ti->error = "Insufficient redundancy to activate array";

drivers/md/dm-raid.c

2699

rs->ti->error = data_offset ? "No space for forward reshape" :

drivers/md/dm-raid.c

2801

rs->ti->error = "Can't reshape raid10 mirror groups";

drivers/md/dm-raid.c

2828

rs->ti->error = "Called with bogus raid type";

drivers/md/dm-raid.c

2911

r = rs_set_dev_and_array_sectors(rs, rs->ti->len, true);

drivers/md/dm-raid.c

2974

struct dm_target *ti = rs->ti;

drivers/md/dm-raid.c

2995

ti->num_discard_bios = 1;

drivers/md/dm-raid.c

3011

static int raid_ctr(struct dm_target *ti, unsigned int argc, char **argv)

drivers/md/dm-raid.c

3029

ti->error = "No arguments";

drivers/md/dm-raid.c

3035

ti->error = "Unrecognised raid_type";

drivers/md/dm-raid.c

3040

if (dm_read_arg_group(_args, &as, &num_raid_params, &ti->error))

drivers/md/dm-raid.c

3047

if (dm_read_arg(_args + 1, &as_nrd, &num_raid_devs, &ti->error))

drivers/md/dm-raid.c

3051

ti->error = "Invalid number of supplied raid devices";

drivers/md/dm-raid.c

3055

rs = raid_set_alloc(ti, rt, num_raid_devs);

drivers/md/dm-raid.c

3075

r = rs_set_dev_and_array_sectors(rs, rs->ti->len, false);

drivers/md/dm-raid.c

3090

r = analyse_superblocks(ti, rs);

drivers/md/dm-raid.c

3098

ti->error = "Invalid rdev size";

drivers/md/dm-raid.c

3112

ti->private = rs;

drivers/md/dm-raid.c

3113

ti->num_flush_bios = 1;

drivers/md/dm-raid.c

3114

ti->needs_bio_set_dev = true;

drivers/md/dm-raid.c

3129

ti->error = "'nosync' not allowed for new raid6 set";

drivers/md/dm-raid.c

3142

ti->error = "Can't resize a reshaping raid set";

drivers/md/dm-raid.c

3149

ti->error = "Can't takeover a reshaping raid set";

drivers/md/dm-raid.c

3156

ti->error = "Can't takeover a journaled raid4/5/6 set";

drivers/md/dm-raid.c

3192

ti->error = "Can't reshape a journaled raid4/5/6 set";

drivers/md/dm-raid.c

3233

r = rs_set_dev_and_array_sectors(rs, rs->ti->len, false);

drivers/md/dm-raid.c

3264

ti->error = "Failed to run raid array";

drivers/md/dm-raid.c

3271

ti->error = "Failed to start raid array";

drivers/md/dm-raid.c

3279

ti->error = "Failed to set raid4/5/6 journal mode";

drivers/md/dm-raid.c

3305

ti->error = "Reshape check failed";

drivers/md/dm-raid.c

3313

rs->md.dm_gendisk = dm_disk(dm_table_get_md(ti->table));

drivers/md/dm-raid.c

3327

static void raid_dtr(struct dm_target *ti)

drivers/md/dm-raid.c

3329

struct raid_set *rs = ti->private;

drivers/md/dm-raid.c

3341

static int raid_map(struct dm_target *ti, struct bio *bio)

drivers/md/dm-raid.c

3343

struct raid_set *rs = ti->private;

drivers/md/dm-raid.c

3526

static void raid_status(struct dm_target *ti, status_type_t type,

drivers/md/dm-raid.c

3529

struct raid_set *rs = ti->private;

drivers/md/dm-raid.c

3697

DMEMIT_TARGET_NAME_VERSION(ti->type);

drivers/md/dm-raid.c

3732

static int raid_message(struct dm_target *ti, unsigned int argc, char **argv,

drivers/md/dm-raid.c

3735

struct raid_set *rs = ti->private;

drivers/md/dm-raid.c

3795

static int raid_iterate_devices(struct dm_target *ti,

drivers/md/dm-raid.c

3798

struct raid_set *rs = ti->private;

drivers/md/dm-raid.c

3804

r = fn(ti, rs->dev[i].data_dev,

drivers/md/dm-raid.c

3813

static void raid_io_hints(struct dm_target *ti, struct queue_limits *limits)

drivers/md/dm-raid.c

3815

struct raid_set *rs = ti->private;

drivers/md/dm-raid.c

3824

static void raid_presuspend(struct dm_target *ti)

drivers/md/dm-raid.c

3826

struct raid_set *rs = ti->private;

drivers/md/dm-raid.c

3848

static void raid_presuspend_undo(struct dm_target *ti)

drivers/md/dm-raid.c

3850

struct raid_set *rs = ti->private;

drivers/md/dm-raid.c

3857

static void raid_postsuspend(struct dm_target *ti)

drivers/md/dm-raid.c

3859

struct raid_set *rs = ti->private;

drivers/md/dm-raid.c

4016

rs->ti->error = "pers->check_reshape() failed";

drivers/md/dm-raid.c

4027

rs->ti->error = "pers->start_reshape() failed";

drivers/md/dm-raid.c

4042

static int raid_preresume(struct dm_target *ti)

drivers/md/dm-raid.c

4045

struct raid_set *rs = ti->private;

drivers/md/dm-raid.c

4117

static void raid_resume(struct dm_target *ti)

drivers/md/dm-raid.c

4119

struct raid_set *rs = ti->private;

drivers/md/dm-raid.c

516

rs->ti->error = "Invalid flags combination";

drivers/md/dm-raid.c

703

struct gendisk *gendisk = dm_disk(dm_table_get_md(rs->ti->table));

drivers/md/dm-raid.c

736

static struct raid_set *raid_set_alloc(struct dm_target *ti, struct raid_type *raid_type,

drivers/md/dm-raid.c

743

ti->error = "Insufficient number of devices";

drivers/md/dm-raid.c

749

ti->error = "Cannot allocate raid context";

drivers/md/dm-raid.c

755

ti->error = "Cannot initialize raid context";

drivers/md/dm-raid.c

762

rs->ti = ti;

drivers/md/dm-raid.c

795

dm_put_device(rs->ti, rs->journal_dev.dev);

drivers/md/dm-raid.c

800

dm_put_device(rs->ti, rs->dev[i].meta_dev);

drivers/md/dm-raid.c

803

dm_put_device(rs->ti, rs->dev[i].data_dev);

drivers/md/dm-raid.c

858

r = dm_get_device(rs->ti, arg, dm_table_get_mode(rs->ti->table),

drivers/md/dm-raid.c

861

rs->ti->error = "RAID metadata device lookup failure";

drivers/md/dm-raid.c

867

rs->ti->error = "Failed to allocate superblock page";

drivers/md/dm-raid.c

879

rs->ti->error = "Drive designated for rebuild not specified";

drivers/md/dm-raid.c

884

rs->ti->error = "No data device supplied with metadata device";

drivers/md/dm-raid.c

891

r = dm_get_device(rs->ti, arg, dm_table_get_mode(rs->ti->table),

drivers/md/dm-raid.c

894

rs->ti->error = "RAID device lookup failure";

drivers/md/dm-raid.c

927

rs->ti->error = "Unable to rebuild drive while array is not in-sync";

drivers/md/dm-raid.c

946

unsigned long min_region_size = rs->ti->len / (1 << 21);

drivers/md/dm-raid.c

968

if (region_size > rs->ti->len) {

drivers/md/dm-raid.c

969

rs->ti->error = "Supplied region size is too large";

drivers/md/dm-raid.c

976

rs->ti->error = "Supplied region size is too small";

drivers/md/dm-raid.c

981

rs->ti->error = "Region size is not a power of 2";

drivers/md/dm-raid.c

986

rs->ti->error = "Region size is smaller than the chunk size";

drivers/md/dm-raid1.c

1003

dl = dm_dirty_log_create(argv[0], ti, mirror_flush, param_count,

drivers/md/dm-raid1.c

1006

ti->error = "Error creating mirror dirty log";

drivers/md/dm-raid1.c

1017

struct dm_target *ti = ms->ti;

drivers/md/dm-raid1.c

1027

ti->error = "Invalid number of features";

drivers/md/dm-raid1.c

1036

ti->error = "Not enough arguments to support feature count";

drivers/md/dm-raid1.c

1046

ti->error = "Unrecognised feature requested";

drivers/md/dm-raid1.c

1055

ti->error = "keep_log feature requires the handle_errors feature";

drivers/md/dm-raid1.c

1074

static int mirror_ctr(struct dm_target *ti, unsigned int argc, char **argv)

drivers/md/dm-raid1.c

1082

dl = create_dirty_log(ti, argc, argv, &args_used);

drivers/md/dm-raid1.c

1091

ti->error = "Invalid number of mirrors";

drivers/md/dm-raid1.c

1099

ti->error = "Too few mirror arguments";

drivers/md/dm-raid1.c

1104

ms = alloc_context(nr_mirrors, dl->type->get_region_size(dl), ti, dl);

drivers/md/dm-raid1.c

1112

r = get_mirror(ms, ti, m, argv);

drivers/md/dm-raid1.c

1114

free_context(ms, ti, m);

drivers/md/dm-raid1.c

1121

ti->private = ms;

drivers/md/dm-raid1.c

1123

r = dm_set_target_max_io_len(ti, dm_rh_get_region_size(ms->rh));

drivers/md/dm-raid1.c

1127

ti->num_flush_bios = 1;

drivers/md/dm-raid1.c

1128

ti->num_discard_bios = 1;

drivers/md/dm-raid1.c

1129

ti->per_io_data_size = sizeof(struct dm_raid1_bio_record);

drivers/md/dm-raid1.c

1160

ti->error = "Too many mirror arguments";

drivers/md/dm-raid1.c

1177

free_context(ms, ti, ms->nr_mirrors);

drivers/md/dm-raid1.c

1181

static void mirror_dtr(struct dm_target *ti)

drivers/md/dm-raid1.c

1183

struct mirror_set *ms = ti->private;

drivers/md/dm-raid1.c

1190

free_context(ms, ti, ms->nr_mirrors);

drivers/md/dm-raid1.c

1196

static int mirror_map(struct dm_target *ti, struct bio *bio)

drivers/md/dm-raid1.c

1200

struct mirror_set *ms = ti->private;

drivers/md/dm-raid1.c

1245

static int mirror_end_io(struct dm_target *ti, struct bio *bio,

drivers/md/dm-raid1.c

1249

struct mirror_set *ms = ti->private;

drivers/md/dm-raid1.c

1312

static void mirror_presuspend(struct dm_target *ti)

drivers/md/dm-raid1.c

1314

struct mirror_set *ms = ti->private;

drivers/md/dm-raid1.c

1358

static void mirror_postsuspend(struct dm_target *ti)

drivers/md/dm-raid1.c

1360

struct mirror_set *ms = ti->private;

drivers/md/dm-raid1.c

1368

static void mirror_resume(struct dm_target *ti)

drivers/md/dm-raid1.c

1370

struct mirror_set *ms = ti->private;

drivers/md/dm-raid1.c

1405

static void mirror_status(struct dm_target *ti, status_type_t type,

drivers/md/dm-raid1.c

1410

struct mirror_set *ms = ti->private;

drivers/md/dm-raid1.c

1452

DMEMIT_TARGET_NAME_VERSION(ti->type);

drivers/md/dm-raid1.c

1470

static int mirror_iterate_devices(struct dm_target *ti,

drivers/md/dm-raid1.c

1473

struct mirror_set *ms = ti->private;

drivers/md/dm-raid1.c

1478

ret = fn(ti, ms->mirror[i].dev,

drivers/md/dm-raid1.c

1479

ms->mirror[i].offset, ti->len, data);

drivers/md/dm-raid1.c

258

static int mirror_flush(struct dm_target *ti)

drivers/md/dm-raid1.c

260

struct mirror_set *ms = ti->private;

drivers/md/dm-raid1.c

352

from.count = ms->ti->len & (region_size - 1);

drivers/md/dm-raid1.c

411

dm_table_event(ms->ti->table);

drivers/md/dm-raid1.c

462

return m->offset + dm_target_offset(m->ms->ti, bio->bi_iter.bi_sector);

drivers/md/dm-raid1.c

493

if (dm_noflush_suspending(ms->ti))

drivers/md/dm-raid1.c

59

struct dm_target *ti;

drivers/md/dm-raid1.c

851

dm_table_event(ms->ti->table);

drivers/md/dm-raid1.c

889

struct dm_target *ti,

drivers/md/dm-raid1.c

896

ti->error = "Cannot allocate mirror context";

drivers/md/dm-raid1.c

906

ms->ti = ti;

drivers/md/dm-raid1.c

908

ms->nr_regions = dm_sector_div_up(ti->len, region_size);

drivers/md/dm-raid1.c

917

ti->error = "Error creating dm_io client";

drivers/md/dm-raid1.c

924

ms->ti->begin, MAX_RECOVERY,

drivers/md/dm-raid1.c

927

ti->error = "Error creating dirty region hash";

drivers/md/dm-raid1.c

936

static void free_context(struct mirror_set *ms, struct dm_target *ti,

drivers/md/dm-raid1.c

940

dm_put_device(ti, ms->mirror[m].dev);

drivers/md/dm-raid1.c

947

static int get_mirror(struct mirror_set *ms, struct dm_target *ti,

drivers/md/dm-raid1.c

956

ti->error = "Invalid offset";

drivers/md/dm-raid1.c

960

ret = dm_get_device(ti, argv[0], dm_table_get_mode(ti->table),

drivers/md/dm-raid1.c

963

ti->error = "Device lookup failure";

drivers/md/dm-raid1.c

978

static struct dm_dirty_log *create_dirty_log(struct dm_target *ti,

drivers/md/dm-raid1.c

987

ti->error = "Insufficient mirror log arguments";

drivers/md/dm-raid1.c

992

ti->error = "Invalid mirror log argument count";

drivers/md/dm-raid1.c

997

ti->error = "Insufficient mirror log arguments";

drivers/md/dm-rq.c

171

tio->ti->type->release_clone_rq(clone, NULL);

drivers/md/dm-rq.c

20

struct dm_target *ti;

drivers/md/dm-rq.c

204

tio->ti->type->release_clone_rq(tio->clone, NULL);

drivers/md/dm-rq.c

217

if (tio->ti) {

drivers/md/dm-rq.c

218

rq_end_io = tio->ti->type->rq_end_io;

drivers/md/dm-rq.c

221

r = rq_end_io(tio->ti, clone, error, &tio->info);

drivers/md/dm-rq.c

349

tio->ti = NULL;

drivers/md/dm-rq.c

372

struct dm_target *ti = tio->ti;

drivers/md/dm-rq.c

378

r = ti->type->clone_and_map_rq(ti, rq, &tio->info, &clone);

drivers/md/dm-rq.c

386

ti->type->release_clone_rq(clone, &tio->info);

drivers/md/dm-rq.c

401

tio->ti->type->release_clone_rq(clone, &tio->info);

drivers/md/dm-rq.c

490

struct dm_target *ti = md->immutable_target;

drivers/md/dm-rq.c

500

if (unlikely(!ti)) {

drivers/md/dm-rq.c

511

ti = dm_table_find_target(map, 0);

drivers/md/dm-rq.c

515

if (ti->type->busy && ti->type->busy(ti))

drivers/md/dm-rq.c

526

tio->ti = ti;

drivers/md/dm-snap.c

1177

struct dm_target *ti)

drivers/md/dm-snap.c

1193

r = dm_read_arg_group(_args, as, &argc, &ti->error);

drivers/md/dm-snap.c

1208

ti->error = "Unrecognised feature requested";

drivers/md/dm-snap.c

1219

ti->error = "discard_passdown_origin feature depends on discard_zeroes_cow";

drivers/md/dm-snap.c

1230

static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv)

drivers/md/dm-snap.c

1241

ti->error = "requires 4 or more arguments";

drivers/md/dm-snap.c

1246

if (dm_target_is_snapshot_merge(ti)) {

drivers/md/dm-snap.c

1253

ti->error = "Cannot allocate private snapshot structure";

drivers/md/dm-snap.c

1261

r = parse_snapshot_features(&as, s, ti);

drivers/md/dm-snap.c

1269

r = dm_get_device(ti, origin_path, origin_mode, &s->origin);

drivers/md/dm-snap.c

1271

ti->error = "Cannot get origin device";

drivers/md/dm-snap.c

1279

r = dm_get_device(ti, cow_path, dm_table_get_mode(ti->table), &s->cow);

drivers/md/dm-snap.c

1281

ti->error = "Cannot get COW device";

drivers/md/dm-snap.c

1285

ti->error = "COW device cannot be the same as origin device";

drivers/md/dm-snap.c

1290

r = dm_exception_store_create(ti, argc, argv, s, &args_used, &s->store);

drivers/md/dm-snap.c

1292

ti->error = "Couldn't create exception store";

drivers/md/dm-snap.c

1300

s->ti = ti;

drivers/md/dm-snap.c

1320

ti->error = "Unable to allocate hash table space";

drivers/md/dm-snap.c

1330

ti->error = "Could not create kcopyd client";

drivers/md/dm-snap.c

1336

ti->error = "Could not allocate mempool for pending exceptions";

drivers/md/dm-snap.c

1345

ti->private = s;

drivers/md/dm-snap.c

1346

ti->num_flush_bios = num_flush_bios;

drivers/md/dm-snap.c

1348

ti->num_discard_bios = (s->discard_passdown_origin ? 2 : 1);

drivers/md/dm-snap.c

1349

ti->per_io_data_size = sizeof(struct dm_snap_tracked_chunk);

drivers/md/dm-snap.c

1355

ti->error = "Snapshot origin struct allocation failed";

drivers/md/dm-snap.c

1376

ti->error = "Failed to read snapshot metadata";

drivers/md/dm-snap.c

1384

ti->error = "Chunk size not set";

drivers/md/dm-snap.c

1389

r = dm_set_target_max_io_len(ti, s->store->chunk_size);

drivers/md/dm-snap.c

1407

dm_put_device(ti, s->cow);

drivers/md/dm-snap.c

1409

dm_put_device(ti, s->origin);

drivers/md/dm-snap.c

1449

snap_dest->ti->max_io_len = snap_dest->store->chunk_size;

drivers/md/dm-snap.c

1459

static void snapshot_dtr(struct dm_target *ti)

drivers/md/dm-snap.c

1464

struct dm_snapshot *s = ti->private;

drivers/md/dm-snap.c

1478

if (dm_target_is_snapshot_merge(ti))

drivers/md/dm-snap.c

1504

dm_put_device(ti, s->cow);

drivers/md/dm-snap.c

1506

dm_put_device(ti, s->origin);

drivers/md/dm-snap.c

1624

dm_table_event(s->ti->table);

drivers/md/dm-snap.c

1939

static int snapshot_map(struct dm_target *ti, struct bio *bio)

drivers/md/dm-snap.c

1942

struct dm_snapshot *s = ti->private;

drivers/md/dm-snap.c

2107

static int snapshot_merge_map(struct dm_target *ti, struct bio *bio)

drivers/md/dm-snap.c

2110

struct dm_snapshot *s = ti->private;

drivers/md/dm-snap.c

2173

static int snapshot_end_io(struct dm_target *ti, struct bio *bio,

drivers/md/dm-snap.c

2176

struct dm_snapshot *s = ti->private;

drivers/md/dm-snap.c

2184

static void snapshot_merge_presuspend(struct dm_target *ti)

drivers/md/dm-snap.c

2186

struct dm_snapshot *s = ti->private;

drivers/md/dm-snap.c

2191

static int snapshot_preresume(struct dm_target *ti)

drivers/md/dm-snap.c

2194

struct dm_snapshot *s = ti->private;

drivers/md/dm-snap.c

2204

} else if (!dm_suspended(snap_src->ti)) {

drivers/md/dm-snap.c

2215

static void snapshot_resume(struct dm_target *ti)

drivers/md/dm-snap.c

2217

struct dm_snapshot *s = ti->private;

drivers/md/dm-snap.c

2227

origin_md = dm_table_get_md(o->ti->table);

drivers/md/dm-snap.c

2231

origin_md = dm_table_get_md(snap_merging->ti->table);

drivers/md/dm-snap.c

2233

if (origin_md == dm_table_get_md(ti->table))

drivers/md/dm-snap.c

2289

static void snapshot_merge_resume(struct dm_target *ti)

drivers/md/dm-snap.c

2291

struct dm_snapshot *s = ti->private;

drivers/md/dm-snap.c

2296

snapshot_resume(ti);

drivers/md/dm-snap.c

2301

ti->max_io_len = get_origin_minimum_chunksize(s->origin->bdev);

drivers/md/dm-snap.c

2306

static void snapshot_status(struct dm_target *ti, status_type_t type,

drivers/md/dm-snap.c

2310

struct dm_snapshot *snap = ti->private;

drivers/md/dm-snap.c

2364

DMEMIT_TARGET_NAME_VERSION(ti->type);

drivers/md/dm-snap.c

2375

static int snapshot_iterate_devices(struct dm_target *ti,

drivers/md/dm-snap.c

2378

struct dm_snapshot *snap = ti->private;

drivers/md/dm-snap.c

2381

r = fn(ti, snap->origin, 0, ti->len, data);

drivers/md/dm-snap.c

2384

r = fn(ti, snap->cow, 0, get_dev_size(snap->cow->bdev), data);

drivers/md/dm-snap.c

2389

static void snapshot_io_hints(struct dm_target *ti, struct queue_limits *limits)

drivers/md/dm-snap.c

2391

struct dm_snapshot *snap = ti->private;

drivers/md/dm-snap.c

2443

if (dm_target_is_snapshot_merge(snap->ti))

drivers/md/dm-snap.c

2447

if (sector >= dm_table_get_size(snap->ti->table))

drivers/md/dm-snap.c

2597

for (n = 0; n < size; n += merging_snap->ti->max_io_len)

drivers/md/dm-snap.c

2615

static int origin_ctr(struct dm_target *ti, unsigned int argc, char **argv)

drivers/md/dm-snap.c

2621

ti->error = "origin: incorrect number of arguments";

drivers/md/dm-snap.c

2627

ti->error = "Cannot allocate private origin structure";

drivers/md/dm-snap.c

2632

r = dm_get_device(ti, argv[0], dm_table_get_mode(ti->table), &o->dev);

drivers/md/dm-snap.c

2634

ti->error = "Cannot get target device";

drivers/md/dm-snap.c

2638

o->ti = ti;

drivers/md/dm-snap.c

2639

ti->private = o;

drivers/md/dm-snap.c

2640

ti->num_flush_bios = 1;

drivers/md/dm-snap.c

2650

static void origin_dtr(struct dm_target *ti)

drivers/md/dm-snap.c

2652

struct dm_origin *o = ti->private;

drivers/md/dm-snap.c

2654

dm_put_device(ti, o->dev);

drivers/md/dm-snap.c

2658

static int origin_map(struct dm_target *ti, struct bio *bio)

drivers/md/dm-snap.c

2660

struct dm_origin *o = ti->private;

drivers/md/dm-snap.c

2685

static void origin_resume(struct dm_target *ti)

drivers/md/dm-snap.c

2687

struct dm_origin *o = ti->private;

drivers/md/dm-snap.c

2696

static void origin_postsuspend(struct dm_target *ti)

drivers/md/dm-snap.c

2698

struct dm_origin *o = ti->private;

drivers/md/dm-snap.c

2705

static void origin_status(struct dm_target *ti, status_type_t type,

drivers/md/dm-snap.c

2708

struct dm_origin *o = ti->private;

drivers/md/dm-snap.c

2724

static int origin_iterate_devices(struct dm_target *ti,

drivers/md/dm-snap.c

2727

struct dm_origin *o = ti->private;

drivers/md/dm-snap.c

2729

return fn(ti, o->dev, 0, ti->len, data);

drivers/md/dm-snap.c

31

#define dm_target_is_snapshot_merge(ti) \

drivers/md/dm-snap.c

32

((ti)->type->name == dm_snapshot_merge_target_name)

drivers/md/dm-snap.c

334

struct dm_target *ti;

drivers/md/dm-snap.c

465

if (dm_target_is_snapshot_merge(s->ti) && snap_merge)

drivers/md/dm-snap.c

500

snap->ti->error = "Snapshot cow pairing for exception table handover failed";

drivers/md/dm-snap.c

514

if (!dm_target_is_snapshot_merge(snap->ti))

drivers/md/dm-snap.c

521

snap->ti->error = "A snapshot is already merging.";

drivers/md/dm-snap.c

527

snap->ti->error = "Snapshot exception store does not support snapshot-merge.";

drivers/md/dm-snap.c

60

struct dm_target *ti;

drivers/md/dm-stripe.c

103

ti->error = "Invalid stripe count";

drivers/md/dm-stripe.c

108

ti->error = "Invalid chunk_size";

drivers/md/dm-stripe.c

112

width = ti->len;

drivers/md/dm-stripe.c

114

ti->error = "Target length not divisible by number of stripes";

drivers/md/dm-stripe.c

120

ti->error = "Target length not divisible by chunk size";

drivers/md/dm-stripe.c

128

ti->error = "Not enough destinations specified";

drivers/md/dm-stripe.c

134

ti->error = "Memory allocation for striped context failed";

drivers/md/dm-stripe.c

141

sc->ti = ti;

drivers/md/dm-stripe.c

150

r = dm_set_target_max_io_len(ti, chunk_size);

drivers/md/dm-stripe.c

156

ti->num_flush_bios = stripes;

drivers/md/dm-stripe.c

157

ti->num_discard_bios = stripes;

drivers/md/dm-stripe.c

158

ti->num_secure_erase_bios = stripes;

drivers/md/dm-stripe.c

159

ti->num_write_zeroes_bios = stripes;

drivers/md/dm-stripe.c

160

ti->flush_bypasses_map = true;

drivers/md/dm-stripe.c

174

r = get_stripe(ti, sc, i, argv);

drivers/md/dm-stripe.c

176

ti->error = "Couldn't parse stripe destination";

drivers/md/dm-stripe.c

178

dm_put_device(ti, sc->stripe[i].dev);

drivers/md/dm-stripe.c

185

ti->private = sc;

drivers/md/dm-stripe.c

190

static void stripe_dtr(struct dm_target *ti)

drivers/md/dm-stripe.c

193

struct stripe_c *sc = ti->private;

drivers/md/dm-stripe.c

196

dm_put_device(ti, sc->stripe[i].dev);

drivers/md/dm-stripe.c

205

sector_t chunk = dm_target_offset(sc->ti, sector);

drivers/md/dm-stripe.c

272

int stripe_map(struct dm_target *ti, struct bio *bio)

drivers/md/dm-stripe.c

274

struct stripe_c *sc = ti->private;

drivers/md/dm-stripe.c

302

static struct dax_device *stripe_dax_pgoff(struct dm_target *ti, pgoff_t *pgoff)

drivers/md/dm-stripe.c

304

struct stripe_c *sc = ti->private;

drivers/md/dm-stripe.c

317

static long stripe_dax_direct_access(struct dm_target *ti, pgoff_t pgoff,

drivers/md/dm-stripe.c

321

struct dax_device *dax_dev = stripe_dax_pgoff(ti, &pgoff);

drivers/md/dm-stripe.c

326

static int stripe_dax_zero_page_range(struct dm_target *ti, pgoff_t pgoff,

drivers/md/dm-stripe.c

329

struct dax_device *dax_dev = stripe_dax_pgoff(ti, &pgoff);

drivers/md/dm-stripe.c

334

static size_t stripe_dax_recovery_write(struct dm_target *ti, pgoff_t pgoff,

drivers/md/dm-stripe.c

337

struct dax_device *dax_dev = stripe_dax_pgoff(ti, &pgoff);

drivers/md/dm-stripe.c

361

static void stripe_status(struct dm_target *ti, status_type_t type,

drivers/md/dm-stripe.c

364

struct stripe_c *sc = ti->private;

drivers/md/dm-stripe.c

388

DMEMIT_TARGET_NAME_VERSION(ti->type);

drivers/md/dm-stripe.c

404

static int stripe_end_io(struct dm_target *ti, struct bio *bio,

drivers/md/dm-stripe.c

409

struct stripe_c *sc = ti->private;

drivers/md/dm-stripe.c

42

struct dm_target *ti;

drivers/md/dm-stripe.c

439

static int stripe_iterate_devices(struct dm_target *ti,

drivers/md/dm-stripe.c

442

struct stripe_c *sc = ti->private;

drivers/md/dm-stripe.c

447

ret = fn(ti, sc->stripe[i].dev,

drivers/md/dm-stripe.c

455

static void stripe_io_hints(struct dm_target *ti,

drivers/md/dm-stripe.c

458

struct stripe_c *sc = ti->private;

drivers/md/dm-stripe.c

58

dm_table_event(sc->ti->table);

drivers/md/dm-stripe.c

64

static int get_stripe(struct dm_target *ti, struct stripe_c *sc,

drivers/md/dm-stripe.c

74

ret = dm_get_device(ti, argv[0], dm_table_get_mode(ti->table),

drivers/md/dm-stripe.c

88

static int stripe_ctr(struct dm_target *ti, unsigned int argc, char **argv)

drivers/md/dm-stripe.c

98

ti->error = "Not enough arguments";

drivers/md/dm-switch.c

103

ti->error = "Region table too large";

drivers/md/dm-switch.c

113

ti->error = "Region table too large";

drivers/md/dm-switch.c

120

ti->error = "Cannot allocate region table";

drivers/md/dm-switch.c

205

static int parse_path(struct dm_arg_set *as, struct dm_target *ti)

drivers/md/dm-switch.c

207

struct switch_ctx *sctx = ti->private;

drivers/md/dm-switch.c

211

r = dm_get_device(ti, dm_shift_arg(as), dm_table_get_mode(ti->table),

drivers/md/dm-switch.c

214

ti->error = "Device lookup failed";

drivers/md/dm-switch.c

219

ti->error = "Invalid device starting offset";

drivers/md/dm-switch.c

220

dm_put_device(ti, sctx->path_list[sctx->nr_paths].dmdev);

drivers/md/dm-switch.c

234

static void switch_dtr(struct dm_target *ti)

drivers/md/dm-switch.c

236

struct switch_ctx *sctx = ti->private;

drivers/md/dm-switch.c

239

dm_put_device(ti, sctx->path_list[sctx->nr_paths].dmdev);

drivers/md/dm-switch.c

253

static int switch_ctr(struct dm_target *ti, unsigned int argc, char **argv)

drivers/md/dm-switch.c

269

r = dm_read_arg(_args, &as, &nr_paths, &ti->error);

drivers/md/dm-switch.c

273

r = dm_read_arg(_args + 1, &as, &region_size, &ti->error);

drivers/md/dm-switch.c

277

r = dm_read_arg_group(_args + 2, &as, &nr_optional_args, &ti->error);

drivers/md/dm-switch.c

283

ti->error = "Incorrect number of path arguments";

drivers/md/dm-switch.c

287

sctx = alloc_switch_ctx(ti, nr_paths, region_size);

drivers/md/dm-switch.c

289

ti->error = "Cannot allocate redirection context";

drivers/md/dm-switch.c

293

r = dm_set_target_max_io_len(ti, region_size);

drivers/md/dm-switch.c

298

r = parse_path(&as, ti);

drivers/md/dm-switch.c

303

r = alloc_region_table(ti, nr_paths);

drivers/md/dm-switch.c

310

ti->num_discard_bios = 1;

drivers/md/dm-switch.c

315

switch_dtr(ti);

drivers/md/dm-switch.c

320

static int switch_map(struct dm_target *ti, struct bio *bio)

drivers/md/dm-switch.c

322

struct switch_ctx *sctx = ti->private;

drivers/md/dm-switch.c

323

sector_t offset = dm_target_offset(ti, bio->bi_iter.bi_sector);

drivers/md/dm-switch.c

40

struct dm_target *ti;

drivers/md/dm-switch.c

470

static int switch_message(struct dm_target *ti, unsigned int argc, char **argv,

drivers/md/dm-switch.c

475

struct switch_ctx *sctx = ti->private;

drivers/md/dm-switch.c

490

static void switch_status(struct dm_target *ti, status_type_t type,

drivers/md/dm-switch.c

493

struct switch_ctx *sctx = ti->private;

drivers/md/dm-switch.c

520

static int switch_prepare_ioctl(struct dm_target *ti, struct block_device **bdev,

drivers/md/dm-switch.c

524

struct switch_ctx *sctx = ti->private;

drivers/md/dm-switch.c

534

if (ti->len + sctx->path_list[path_nr].start !=

drivers/md/dm-switch.c

540

static int switch_iterate_devices(struct dm_target *ti,

drivers/md/dm-switch.c

543

struct switch_ctx *sctx = ti->private;

drivers/md/dm-switch.c

548

r = fn(ti, sctx->path_list[path_nr].dmdev,

drivers/md/dm-switch.c

549

sctx->path_list[path_nr].start, ti->len, data);

drivers/md/dm-switch.c

60

static struct switch_ctx *alloc_switch_ctx(struct dm_target *ti, unsigned int nr_paths,

drivers/md/dm-switch.c

69

sctx->ti = ti;

drivers/md/dm-switch.c

72

ti->private = sctx;

drivers/md/dm-switch.c

77

static int alloc_region_table(struct dm_target *ti, unsigned int nr_paths)

drivers/md/dm-switch.c

79

struct switch_ctx *sctx = ti->private;

drivers/md/dm-switch.c

80

sector_t nr_regions = ti->len;

drivers/md/dm-table.c

1023

struct dm_target *ti = dm_table_get_target(t, i);

drivers/md/dm-table.c

1025

if (dm_target_is_wildcard(ti->type))

drivers/md/dm-table.c

1026

return ti;

drivers/md/dm-table.c

1064

struct dm_target *ti = dm_table_get_target(t, i);

drivers/md/dm-table.c

1066

per_io_data_size = max(per_io_data_size, ti->per_io_data_size);

drivers/md/dm-table.c

1067

min_pool_size = max(min_pool_size, ti->num_flush_bios);

drivers/md/dm-table.c

1144

static int dm_keyslot_evict_callback(struct dm_target *ti, struct dm_dev *dev,

drivers/md/dm-table.c

1170

struct dm_target *ti = dm_table_get_target(t, i);

drivers/md/dm-table.c

1172

if (!ti->type->iterate_devices)

drivers/md/dm-table.c

1174

ti->type->iterate_devices(ti, dm_keyslot_evict_callback,

drivers/md/dm-table.c

1215

static int dm_wrappedkey_op_callback(struct dm_target *ti, struct dm_dev *dev,

drivers/md/dm-table.c

1258

struct dm_target *ti;

drivers/md/dm-table.c

1279

ti = dm_table_get_target(t, i);

drivers/md/dm-table.c

1280

if (!ti->type->iterate_devices)

drivers/md/dm-table.c

1282

if (ti->type->iterate_devices(ti, dm_wrappedkey_op_callback, args) != 0)

drivers/md/dm-table.c

1348

device_intersect_crypto_capabilities(struct dm_target *ti, struct dm_dev *dev,

drivers/md/dm-table.c

1408

struct dm_target *ti = dm_table_get_target(t, i);

drivers/md/dm-table.c

1410

if (!dm_target_passes_crypto(ti->type)) {

drivers/md/dm-table.c

1414

if (!ti->type->iterate_devices)

drivers/md/dm-table.c

1416

ti->type->iterate_devices(ti,

drivers/md/dm-table.c

1612

struct dm_target *ti = dm_table_get_target(t, i);

drivers/md/dm-table.c

1614

if (ti->type->iterate_devices &&

drivers/md/dm-table.c

1615

ti->type->iterate_devices(ti, func, data))

drivers/md/dm-table.c

1622

static int count_device(struct dm_target *ti, struct dm_dev *dev,

drivers/md/dm-table.c

1641

struct dm_target *ti = dm_table_get_target(t, i);

drivers/md/dm-table.c

1644

if (!ti->type->iterate_devices)

drivers/md/dm-table.c

1647

ti->type->iterate_devices(ti, count_device, &num_devices);

drivers/md/dm-table.c

1658

struct dm_target *ti = dm_table_get_target(t, i);

drivers/md/dm-table.c

1660

if (!dm_target_is_wildcard(ti->type))

drivers/md/dm-table.c

1667

static int device_not_zoned(struct dm_target *ti, struct dm_dev *dev,

drivers/md/dm-table.c

1675

static int device_is_zoned_model(struct dm_target *ti, struct dm_dev *dev,

drivers/md/dm-table.c

1691

struct dm_target *ti = dm_table_get_target(t, i);

drivers/md/dm-table.c

1701

if (dm_target_is_wildcard(ti->type) &&

drivers/md/dm-table.c

1702

!ti->type->iterate_devices(ti, device_is_zoned_model, NULL))

drivers/md/dm-table.c

1705

if (dm_target_supports_zoned_hm(ti->type)) {

drivers/md/dm-table.c

1706

if (!ti->type->iterate_devices ||

drivers/md/dm-table.c

1707

ti->type->iterate_devices(ti, device_not_zoned,

drivers/md/dm-table.c

1710

} else if (!dm_target_supports_mixed_zoned_model(ti->type)) {

drivers/md/dm-table.c

1719

static int device_not_matches_zone_sectors(struct dm_target *ti, struct dm_dev *dev,

drivers/md/dm-table.c

1773

struct dm_target *ti = dm_table_get_target(t, i);

drivers/md/dm-table.c

1775

if (!dm_target_passes_integrity(ti->type))

drivers/md/dm-table.c

1780

struct dm_target *ti = dm_table_get_target(t, i);

drivers/md/dm-table.c

1784

if (!ti->type->iterate_devices) {

drivers/md/dm-table.c

1786

if (ti->type->io_hints)

drivers/md/dm-table.c

1787

ti->type->io_hints(ti, &ti_limits);

drivers/md/dm-table.c

1794

ti->type->iterate_devices(ti, dm_set_device_limits,

drivers/md/dm-table.c

1807

if (ti->type->io_hints)

drivers/md/dm-table.c

1808

ti->type->io_hints(ti, &ti_limits);

drivers/md/dm-table.c

1814

if (ti->type->iterate_devices(ti, device_area_is_invalid,

drivers/md/dm-table.c

1827

(unsigned long long) ti->begin,

drivers/md/dm-table.c

1828

(unsigned long long) ti->len);

drivers/md/dm-table.c

1831

dm_target_has_integrity(ti->type)) {

drivers/md/dm-table.c

1836

(unsigned long long) ti->begin,

drivers/md/dm-table.c

1837

(unsigned long long) ti->len);

drivers/md/dm-table.c

1871

struct dm_target *ti = dm_table_get_target(t, i);

drivers/md/dm-table.c

1873

if (ti->num_flush_bios && ti->flush_supported)

drivers/md/dm-table.c

1880

static int device_dax_write_cache_enabled(struct dm_target *ti,

drivers/md/dm-table.c

1894

static int device_not_write_zeroes_capable(struct dm_target *ti, struct dm_dev *dev,

drivers/md/dm-table.c

1909

struct dm_target *ti = dm_table_get_target(t, i);

drivers/md/dm-table.c

1911

if (!ti->num_write_zeroes_bios)

drivers/md/dm-table.c

1914

if (!ti->type->iterate_devices ||

drivers/md/dm-table.c

1915

ti->type->iterate_devices(ti, device_not_write_zeroes_capable, NULL))

drivers/md/dm-table.c

1925

struct dm_target *ti = dm_table_get_target(t, i);

drivers/md/dm-table.c

1927

if (!dm_target_supports_nowait(ti->type))

drivers/md/dm-table.c

193

struct dm_target *ti = dm_table_get_target(t, i);

drivers/md/dm-table.c

1934

static int device_not_discard_capable(struct dm_target *ti, struct dm_dev *dev,

drivers/md/dm-table.c

1943

struct dm_target *ti = dm_table_get_target(t, i);

drivers/md/dm-table.c

1945

if (!ti->num_discard_bios)

drivers/md/dm-table.c

195

if (ti->type->dtr)

drivers/md/dm-table.c

1953

if (!ti->discards_supported &&

drivers/md/dm-table.c

1954

(!ti->type->iterate_devices ||

drivers/md/dm-table.c

1955

ti->type->iterate_devices(ti, device_not_discard_capable, NULL)))

drivers/md/dm-table.c

196

ti->type->dtr(ti);

drivers/md/dm-table.c

1962

static int device_not_secure_erase_capable(struct dm_target *ti,

drivers/md/dm-table.c

1972

struct dm_target *ti = dm_table_get_target(t, i);

drivers/md/dm-table.c

1974

if (!ti->num_secure_erase_bios)

drivers/md/dm-table.c

1977

if (!ti->type->iterate_devices ||

drivers/md/dm-table.c

1978

ti->type->iterate_devices(ti, device_not_secure_erase_capable, NULL))

drivers/md/dm-table.c

198

dm_put_target_type(ti->type);

drivers/md/dm-table.c

1985

static int device_not_atomic_write_capable(struct dm_target *ti,

drivers/md/dm-table.c

1995

struct dm_target *ti = dm_table_get_target(t, i);

drivers/md/dm-table.c

1997

if (!dm_target_supports_atomic_writes(ti->type))

drivers/md/dm-table.c

2000

if (!ti->type->iterate_devices)

drivers/md/dm-table.c

2003

if (ti->type->iterate_devices(ti,

drivers/md/dm-table.c

2136

struct dm_target *ti = dm_table_get_target(t, i);

drivers/md/dm-table.c

2140

if (ti->type->presuspend)

drivers/md/dm-table.c

2141

ti->type->presuspend(ti);

drivers/md/dm-table.c

2144

if (ti->type->presuspend_undo)

drivers/md/dm-table.c

2145

ti->type->presuspend_undo(ti);

drivers/md/dm-table.c

2148

if (ti->type->postsuspend)

drivers/md/dm-table.c

2149

ti->type->postsuspend(ti);

drivers/md/dm-table.c

2187

struct dm_target *ti = dm_table_get_target(t, i);

drivers/md/dm-table.c

2189

if (!ti->type->preresume)

drivers/md/dm-table.c

2192

r = ti->type->preresume(ti);

drivers/md/dm-table.c

2195

dm_device_name(t->md), ti->type->name, r);

drivers/md/dm-table.c

2201

struct dm_target *ti = dm_table_get_target(t, i);

drivers/md/dm-table.c

2203

if (ti->type->resume)

drivers/md/dm-table.c

2204

ti->type->resume(ti);

drivers/md/dm-table.c

230

static int device_area_is_invalid(struct dm_target *ti, struct dm_dev *dev,

drivers/md/dm-table.c

244

dm_device_name(ti->table->md), bdev,

drivers/md/dm-table.c

260

dm_device_name(ti->table->md),

drivers/md/dm-table.c

277

dm_device_name(ti->table->md),

drivers/md/dm-table.c

289

dm_device_name(ti->table->md),

drivers/md/dm-table.c

297

dm_device_name(ti->table->md),

drivers/md/dm-table.c

365

int dm_get_device(struct dm_target *ti, const char *path, blk_mode_t mode,

drivers/md/dm-table.c

371

struct dm_table *t = ti->table;

drivers/md/dm-table.c

410

static int dm_set_device_limits(struct dm_target *ti, struct dm_dev *dev,

drivers/md/dm-table.c

419

dm_device_name(ti->table->md), bdev);

drivers/md/dm-table.c

435

dm_device_name(ti->table->md), bdev,

drivers/md/dm-table.c

445

if (!dm_target_has_integrity(ti->type))

drivers/md/dm-table.c

454

void dm_put_device(struct dm_target *ti, struct dm_dev *d)

drivers/md/dm-table.c

457

struct list_head *devices = &ti->table->devices;

drivers/md/dm-table.c

468

dm_device_name(ti->table->md), d->name);

drivers/md/dm-table.c

472

dm_put_table_device(ti->table->md, d);

drivers/md/dm-table.c

482

static int adjoin(struct dm_table *t, struct dm_target *ti)

drivers/md/dm-table.c

487

return !ti->begin;

drivers/md/dm-table.c

490

return (ti->begin == (prev->begin + prev->len));

drivers/md/dm-table.c

624

struct dm_target *ti;

drivers/md/dm-table.c

632

ti = dm_table_get_target(t, i);

drivers/md/dm-table.c

637

if (ti->type->iterate_devices)

drivers/md/dm-table.c

638

ti->type->iterate_devices(ti, dm_set_device_limits,

drivers/md/dm-table.c

645

if (remaining < ti->len &&

drivers/md/dm-table.c

651

(unsigned short) ((next_target_start + ti->len) &

drivers/md/dm-table.c

661

(unsigned long long) ti->begin,

drivers/md/dm-table.c

662

(unsigned long long) ti->len,

drivers/md/dm-table.c

675

struct dm_target *ti;

drivers/md/dm-table.c

685

ti = t->targets + t->num_targets;

drivers/md/dm-table.c

686

memset(ti, 0, sizeof(*ti));

drivers/md/dm-table.c

697

ti->type = dm_get_target_type(type);

drivers/md/dm-table.c

698

if (!ti->type) {

drivers/md/dm-table.c

703

if (dm_target_needs_singleton(ti->type)) {

drivers/md/dm-table.c

705

ti->error = "singleton target type must appear alone in table";

drivers/md/dm-table.c

711

if (dm_target_always_writeable(ti->type) &&

drivers/md/dm-table.c

713

ti->error = "target type may not be included in a read-only table";

drivers/md/dm-table.c

718

if (t->immutable_target_type != ti->type) {

drivers/md/dm-table.c

719

ti->error = "immutable target type cannot be mixed with other target types";

drivers/md/dm-table.c

722

} else if (dm_target_is_immutable(ti->type)) {

drivers/md/dm-table.c

724

ti->error = "immutable target type cannot be mixed with other target types";

drivers/md/dm-table.c

727

t->immutable_target_type = ti->type;

drivers/md/dm-table.c

730

ti->table = t;

drivers/md/dm-table.c

731

ti->begin = start;

drivers/md/dm-table.c

732

ti->len = len;

drivers/md/dm-table.c

733

ti->error = "Unknown error";

drivers/md/dm-table.c

738

if (!adjoin(t, ti)) {

drivers/md/dm-table.c

739

ti->error = "Gap in table";

drivers/md/dm-table.c

745

ti->error = "couldn't split parameters";

drivers/md/dm-table.c

749

r = ti->type->ctr(ti, argc, argv);

drivers/md/dm-table.c

754

t->highs[t->num_targets++] = ti->begin + ti->len - 1;

drivers/md/dm-table.c

756

if (!ti->num_discard_bios && ti->discards_supported)

drivers/md/dm-table.c

760

if (ti->limit_swap_bios && !static_key_enabled(&swap_bios_enabled.key))

drivers/md/dm-table.c

763

if (!ti->flush_bypasses_map)

drivers/md/dm-table.c

769

DMERR("%s: %s: %s (%pe)", dm_device_name(t->md), type, ti->error, ERR_PTR(r));

drivers/md/dm-table.c

770

dm_put_target_type(ti->type);

drivers/md/dm-table.c

850

static int device_not_dax_capable(struct dm_target *ti, struct dm_dev *dev,

drivers/md/dm-table.c

861

static int device_not_dax_synchronous_capable(struct dm_target *ti, struct dm_dev *dev,

drivers/md/dm-table.c

872

struct dm_target *ti = dm_table_get_target(t, i);

drivers/md/dm-table.c

874

if (!ti->type->direct_access)

drivers/md/dm-table.c

877

if (dm_target_is_wildcard(ti->type) ||

drivers/md/dm-table.c

878

!ti->type->iterate_devices ||

drivers/md/dm-table.c

879

ti->type->iterate_devices(ti, iterate_fn, NULL))

drivers/md/dm-table.c

886

static int device_is_not_rq_stackable(struct dm_target *ti, struct dm_dev *dev,

drivers/md/dm-table.c

902

struct dm_target *ti;

drivers/md/dm-table.c

917

ti = dm_table_get_target(t, i);

drivers/md/dm-table.c

918

if (dm_target_hybrid(ti))

drivers/md/dm-table.c

920

else if (dm_target_request_based(ti))

drivers/md/dm-table.c

981

ti = dm_table_get_immutable_target(t);

drivers/md/dm-table.c

982

if (!ti) {

drivers/md/dm-table.c

985

} else if (ti->max_io_len) {

drivers/md/dm-table.c

991

if (!ti->type->iterate_devices ||

drivers/md/dm-table.c

992

ti->type->iterate_devices(ti, device_is_not_rq_stackable, NULL)) {

drivers/md/dm-target.c

199

static int io_err_clone_and_map_rq(struct dm_target *ti, struct request *rq,

drivers/md/dm-target.c

212

static sector_t io_err_map_sector(struct dm_target *ti, sector_t bi_sector)

drivers/md/dm-target.c

214

struct io_err_c *ioec = ti->private;

drivers/md/dm-target.c

216

return ioec->start + dm_target_offset(ti, bi_sector);

drivers/md/dm-target.c

219

static int io_err_report_zones(struct dm_target *ti,

drivers/md/dm-target.c

222

struct io_err_c *ioec = ti->private;

drivers/md/dm-target.c

232

io_err_map_sector(ti, args->next_sector),

drivers/md/dm-target.c

239

static int io_err_iterate_devices(struct dm_target *ti,

drivers/md/dm-target.c

242

struct io_err_c *ioec = ti->private;

drivers/md/dm-target.c

247

return fn(ti, ioec->dev, ioec->start, ti->len, data);

drivers/md/dm-target.c

250

static void io_err_io_hints(struct dm_target *ti, struct queue_limits *limits)

drivers/md/dm-target.c

256

static long io_err_dax_direct_access(struct dm_target *ti, pgoff_t pgoff,

drivers/md/dm-thin.c

1509

dm_table_event(pool->ti->table);

drivers/md/dm-thin.c

234

struct dm_target *ti; /* Only set if a pool target is bound */

drivers/md/dm-thin.c

2528

struct pool_c *pt = pool->ti->private;

drivers/md/dm-thin.c

2542

struct pool_c *pt = pool->ti->private;

drivers/md/dm-thin.c

2719

static int thin_bio_map(struct dm_target *ti, struct bio *bio)

drivers/md/dm-thin.c

2722

struct thin_c *tc = ti->private;

drivers/md/dm-thin.c

2861

static int bind_control_target(struct pool *pool, struct dm_target *ti)

drivers/md/dm-thin.c

2863

struct pool_c *pt = ti->private;

drivers/md/dm-thin.c

2878

pool->ti = ti;

drivers/md/dm-thin.c

2887

static void unbind_control_target(struct pool *pool, struct dm_target *ti)

drivers/md/dm-thin.c

2889

if (pool->ti == ti)

drivers/md/dm-thin.c

2890

pool->ti = NULL;

drivers/md/dm-thin.c

3126

static void pool_dtr(struct dm_target *ti)

drivers/md/dm-thin.c

3128

struct pool_c *pt = ti->private;

drivers/md/dm-thin.c

3132

unbind_control_target(pt->pool, ti);

drivers/md/dm-thin.c

3134

dm_put_device(ti, pt->metadata_dev);

drivers/md/dm-thin.c

3135

dm_put_device(ti, pt->data_dev);

drivers/md/dm-thin.c

3142

struct dm_target *ti)

drivers/md/dm-thin.c

3158

r = dm_read_arg_group(_args, as, &argc, &ti->error);

drivers/md/dm-thin.c

316

dm_table_event(pool->ti->table);

drivers/md/dm-thin.c

3182

ti->error = "Unrecognised pool feature requested";

drivers/md/dm-thin.c

3198

dm_table_event(pool->ti->table);

drivers/md/dm-thin.c

326

struct dm_target *ti;

drivers/md/dm-thin.c

3283

static int pool_ctr(struct dm_target *ti, unsigned int argc, char **argv)

drivers/md/dm-thin.c

3302

ti->error = "Invalid argument count";

drivers/md/dm-thin.c

3312

ti->error = "Error setting metadata or data device";

drivers/md/dm-thin.c

3323

r = parse_pool_features(&as, &pf, ti);

drivers/md/dm-thin.c

3329

r = dm_get_device(ti, argv[0], metadata_mode, &metadata_dev);

drivers/md/dm-thin.c

3331

ti->error = "Error opening metadata block device";

drivers/md/dm-thin.c

3336

r = dm_get_device(ti, argv[1], BLK_OPEN_READ | BLK_OPEN_WRITE, &data_dev);

drivers/md/dm-thin.c

3338

ti->error = "Error getting data device";

drivers/md/dm-thin.c

3346

ti->error = "Invalid block size";

drivers/md/dm-thin.c

3352

ti->error = "Invalid low water mark";

drivers/md/dm-thin.c

3363

pool = __pool_find(dm_table_get_md(ti->table), metadata_dev->bdev, data_dev->bdev,

drivers/md/dm-thin.c

3364

block_size, pf.mode == PM_READ_ONLY, &ti->error, &pool_created);

drivers/md/dm-thin.c

3377

ti->error = "Discard support cannot be disabled once enabled";

drivers/md/dm-thin.c

3383

pt->ti = ti;

drivers/md/dm-thin.c

3388

ti->num_flush_bios = 1;

drivers/md/dm-thin.c

3389

ti->limit_swap_bios = true;

drivers/md/dm-thin.c

3397

ti->num_discard_bios = 1;

drivers/md/dm-thin.c

3403

ti->discards_supported = true;

drivers/md/dm-thin.c

3404

ti->max_discard_granularity = true;

drivers/md/dm-thin.c

3406

ti->private = pt;

drivers/md/dm-thin.c

3413

ti->error = "Error registering metadata threshold";

drivers/md/dm-thin.c

3429

dm_put_device(ti, data_dev);

drivers/md/dm-thin.c

3431

dm_put_device(ti, metadata_dev);

drivers/md/dm-thin.c

3438

static int pool_map(struct dm_target *ti, struct bio *bio)

drivers/md/dm-thin.c

3440

struct pool_c *pt = ti->private;

drivers/md/dm-thin.c

3453

static int maybe_resize_data_dev(struct dm_target *ti, bool *need_commit)

drivers/md/dm-thin.c

3456

struct pool_c *pt = ti->private;

drivers/md/dm-thin.c

3458

sector_t data_size = ti->len;

drivers/md/dm-thin.c

3501

static int maybe_resize_metadata_dev(struct dm_target *ti, bool *need_commit)

drivers/md/dm-thin.c

3504

struct pool_c *pt = ti->private;

drivers/md/dm-thin.c

3563

static int pool_preresume(struct dm_target *ti)

drivers/md/dm-thin.c

3567

struct pool_c *pt = ti->private;

drivers/md/dm-thin.c

3573

r = bind_control_target(pool, ti);

drivers/md/dm-thin.c

3577

r = maybe_resize_data_dev(ti, &need_commit1);

drivers/md/dm-thin.c

3581

r = maybe_resize_metadata_dev(ti, &need_commit2);

drivers/md/dm-thin.c

3623

static void pool_resume(struct dm_target *ti)

drivers/md/dm-thin.c

3625

struct pool_c *pt = ti->private;

drivers/md/dm-thin.c

3643

static void pool_presuspend(struct dm_target *ti)

drivers/md/dm-thin.c

3645

struct pool_c *pt = ti->private;

drivers/md/dm-thin.c

3655

static void pool_presuspend_undo(struct dm_target *ti)

drivers/md/dm-thin.c

3657

struct pool_c *pt = ti->private;

drivers/md/dm-thin.c

3667

static void pool_postsuspend(struct dm_target *ti)

drivers/md/dm-thin.c

3669

struct pool_c *pt = ti->private;

drivers/md/dm-thin.c

3842

static int pool_message(struct dm_target *ti, unsigned int argc, char **argv,

drivers/md/dm-thin.c

3846

struct pool_c *pt = ti->private;

drivers/md/dm-thin.c

3912

static void pool_status(struct dm_target *ti, status_type_t type,

drivers/md/dm-thin.c

3926

struct pool_c *pt = ti->private;

drivers/md/dm-thin.c

3937

if (!(status_flags & DM_STATUS_NOFLUSH_FLAG) && !dm_suspended(ti))

drivers/md/dm-thin.c

4042

static int pool_iterate_devices(struct dm_target *ti,

drivers/md/dm-thin.c

4045

struct pool_c *pt = ti->private;

drivers/md/dm-thin.c

4047

return fn(ti, pt->data_dev, 0, ti->len, data);

drivers/md/dm-thin.c

4050

static void pool_io_hints(struct dm_target *ti, struct queue_limits *limits)

drivers/md/dm-thin.c

4052

struct pool_c *pt = ti->private;

drivers/md/dm-thin.c

4145

static void thin_dtr(struct dm_target *ti)

drivers/md/dm-thin.c

4147

struct thin_c *tc = ti->private;

drivers/md/dm-thin.c

4161

dm_put_device(ti, tc->pool_dev);

drivers/md/dm-thin.c

4163

dm_put_device(ti, tc->origin_dev);

drivers/md/dm-thin.c

4181

static int thin_ctr(struct dm_target *ti, unsigned int argc, char **argv)

drivers/md/dm-thin.c

4191

ti->error = "Invalid argument count";

drivers/md/dm-thin.c

4196

tc = ti->private = kzalloc_obj(*tc);

drivers/md/dm-thin.c

4198

ti->error = "Out of memory";

drivers/md/dm-thin.c

4202

tc->thin_md = dm_table_get_md(ti->table);

drivers/md/dm-thin.c

4211

ti->error = "Error setting origin device";

drivers/md/dm-thin.c

4216

r = dm_get_device(ti, argv[2], BLK_OPEN_READ, &origin_dev);

drivers/md/dm-thin.c

4218

ti->error = "Error opening origin device";

drivers/md/dm-thin.c

4224

r = dm_get_device(ti, argv[0], dm_table_get_mode(ti->table), &pool_dev);

drivers/md/dm-thin.c

4226

ti->error = "Error opening pool device";

drivers/md/dm-thin.c

4232

ti->error = "Invalid device id";

drivers/md/dm-thin.c

4239

ti->error = "Couldn't get pool mapped device";

drivers/md/dm-thin.c

4246

ti->error = "Couldn't find pool object";

drivers/md/dm-thin.c

4253

ti->error = "Couldn't open thin device, Pool is in fail mode";

drivers/md/dm-thin.c

4260

ti->error = "Couldn't open thin internal device";

drivers/md/dm-thin.c

4264

r = dm_set_target_max_io_len(ti, tc->pool->sectors_per_block);

drivers/md/dm-thin.c

4268

ti->num_flush_bios = 1;

drivers/md/dm-thin.c

4269

ti->limit_swap_bios = true;

drivers/md/dm-thin.c

4270

ti->flush_supported = true;

drivers/md/dm-thin.c

4271

ti->accounts_remapped_io = true;

drivers/md/dm-thin.c

4272

ti->per_io_data_size = sizeof(struct dm_thin_endio_hook);

drivers/md/dm-thin.c

4276

ti->discards_supported = true;

drivers/md/dm-thin.c

4277

ti->num_discard_bios = 1;

drivers/md/dm-thin.c

4278

ti->max_discard_granularity = true;

drivers/md/dm-thin.c

4287

ti->error = "Unable to activate thin device while pool is suspended";

drivers/md/dm-thin.c

4314

dm_put_device(ti, tc->pool_dev);

drivers/md/dm-thin.c

4317

dm_put_device(ti, tc->origin_dev);

drivers/md/dm-thin.c

4326

static int thin_map(struct dm_target *ti, struct bio *bio)

drivers/md/dm-thin.c

4328

bio->bi_iter.bi_sector = dm_target_offset(ti, bio->bi_iter.bi_sector);

drivers/md/dm-thin.c

4330

return thin_bio_map(ti, bio);

drivers/md/dm-thin.c

4333

static int thin_endio(struct dm_target *ti, struct bio *bio,

drivers/md/dm-thin.c

4372

static void thin_presuspend(struct dm_target *ti)

drivers/md/dm-thin.c

4374

struct thin_c *tc = ti->private;

drivers/md/dm-thin.c

4376

if (dm_noflush_suspending(ti))

drivers/md/dm-thin.c

4380

static void thin_postsuspend(struct dm_target *ti)

drivers/md/dm-thin.c

4382

struct thin_c *tc = ti->private;

drivers/md/dm-thin.c

4384

if (dm_noflush_suspending(ti))

drivers/md/dm-thin.c

4388

static int thin_preresume(struct dm_target *ti)

drivers/md/dm-thin.c

4390

struct thin_c *tc = ti->private;

drivers/md/dm-thin.c

4401

static void thin_status(struct dm_target *ti, status_type_t type,

drivers/md/dm-thin.c

4408

struct thin_c *tc = ti->private;

drivers/md/dm-thin.c

4460

static int thin_iterate_devices(struct dm_target *ti,

drivers/md/dm-thin.c

4464

struct thin_c *tc = ti->private;

drivers/md/dm-thin.c

4471

if (!pool->ti)

drivers/md/dm-thin.c

4474

blocks = pool->ti->len;

drivers/md/dm-thin.c

4477

return fn(ti, tc->pool_dev, 0, pool->sectors_per_block * blocks, data);

drivers/md/dm-thin.c

4482

static void thin_io_hints(struct dm_target *ti, struct queue_limits *limits)

drivers/md/dm-thin.c

4484

struct thin_c *tc = ti->private;

drivers/md/dm-uevent.c

170

void dm_path_uevent(enum dm_uevent_type event_type, struct dm_target *ti,

drivers/md/dm-uevent.c

173

struct mapped_device *md = dm_table_get_md(ti->table);

drivers/md/dm-uevent.c

181

event = dm_build_path_uevent(md, ti,

drivers/md/dm-uevent.c

59

struct dm_target *ti,

drivers/md/dm-uevent.c

75

if (add_uevent_var(&event->ku_env, "DM_TARGET=%s", ti->type->name)) {

drivers/md/dm-uevent.h

22

struct dm_target *ti, const char *path,

drivers/md/dm-uevent.h

39

struct dm_target *ti, const char *path,

drivers/md/dm-unstripe.c

103

ti->private = uc;

drivers/md/dm-unstripe.c

106

cleanup_unstripe(uc, ti);

drivers/md/dm-unstripe.c

110

static void unstripe_dtr(struct dm_target *ti)

drivers/md/dm-unstripe.c

112

struct unstripe_c *uc = ti->private;

drivers/md/dm-unstripe.c

114

cleanup_unstripe(uc, ti);

drivers/md/dm-unstripe.c

117

static sector_t map_to_core(struct dm_target *ti, struct bio *bio)

drivers/md/dm-unstripe.c

119

struct unstripe_c *uc = ti->private;

drivers/md/dm-unstripe.c

120

sector_t sector = dm_target_offset(ti, bio->bi_iter.bi_sector);

drivers/md/dm-unstripe.c

135

static int unstripe_map(struct dm_target *ti, struct bio *bio)

drivers/md/dm-unstripe.c

137

struct unstripe_c *uc = ti->private;

drivers/md/dm-unstripe.c

140

bio->bi_iter.bi_sector = map_to_core(ti, bio) + uc->physical_start;

drivers/md/dm-unstripe.c

145

static void unstripe_status(struct dm_target *ti, status_type_t type,

drivers/md/dm-unstripe.c

148

struct unstripe_c *uc = ti->private;

drivers/md/dm-unstripe.c

167

static int unstripe_iterate_devices(struct dm_target *ti,

drivers/md/dm-unstripe.c

170

struct unstripe_c *uc = ti->private;

drivers/md/dm-unstripe.c

172

return fn(ti, uc->dev, uc->physical_start, ti->len, data);

drivers/md/dm-unstripe.c

175

static void unstripe_io_hints(struct dm_target *ti,

drivers/md/dm-unstripe.c

178

struct unstripe_c *uc = ti->private;

drivers/md/dm-unstripe.c

28

static void cleanup_unstripe(struct unstripe_c *uc, struct dm_target *ti)

drivers/md/dm-unstripe.c

31

dm_put_device(ti, uc->dev);

drivers/md/dm-unstripe.c

39

static int unstripe_ctr(struct dm_target *ti, unsigned int argc, char **argv)

drivers/md/dm-unstripe.c

47

ti->error = "Invalid number of arguments";

drivers/md/dm-unstripe.c

53

ti->error = "Memory allocation for unstriped context failed";

drivers/md/dm-unstripe.c

58

ti->error = "Invalid stripe count";

drivers/md/dm-unstripe.c

63

ti->error = "Invalid chunk_size";

drivers/md/dm-unstripe.c

68

ti->error = "Invalid stripe number";

drivers/md/dm-unstripe.c

73

ti->error = "Please provide stripe between [0, # of stripes]";

drivers/md/dm-unstripe.c

77

if (dm_get_device(ti, argv[3], dm_table_get_mode(ti->table), &uc->dev)) {

drivers/md/dm-unstripe.c

78

ti->error = "Couldn't get striped device";

drivers/md/dm-unstripe.c

83

ti->error = "Invalid striped device offset";

drivers/md/dm-unstripe.c

92

tmp_len = ti->len;

drivers/md/dm-unstripe.c

94

ti->error = "Target length not divisible by chunk size";

drivers/md/dm-unstripe.c

98

if (dm_set_target_max_io_len(ti, uc->chunk_size)) {

drivers/md/dm-unstripe.c

99

ti->error = "Failed to set max io len";

drivers/md/dm-vdo/dm-vdo-target.c

1019

static void vdo_io_hints(struct dm_target *ti, struct queue_limits *limits)

drivers/md/dm-vdo/dm-vdo-target.c

1021

struct vdo *vdo = get_vdo_for_target(ti);

drivers/md/dm-vdo/dm-vdo-target.c

1054

static int vdo_iterate_devices(struct dm_target *ti, iterate_devices_callout_fn fn,

drivers/md/dm-vdo/dm-vdo-target.c

1057

struct device_config *config = get_vdo_for_target(ti)->device_config;

drivers/md/dm-vdo/dm-vdo-target.c

1059

return fn(ti, config->owned_device, 0,

drivers/md/dm-vdo/dm-vdo-target.c

1069

static void vdo_status(struct dm_target *ti, status_type_t status_type,

drivers/md/dm-vdo/dm-vdo-target.c

1072

struct vdo *vdo = get_vdo_for_target(ti);

drivers/md/dm-vdo/dm-vdo-target.c

1097

device_config = (struct device_config *) ti->private;

drivers/md/dm-vdo/dm-vdo-target.c

1181

static int vdo_message(struct dm_target *ti, unsigned int argc, char **argv,

drivers/md/dm-vdo/dm-vdo-target.c

1193

vdo = get_vdo_for_target(ti);

drivers/md/dm-vdo/dm-vdo-target.c

1216

static void configure_target_capabilities(struct dm_target *ti)

drivers/md/dm-vdo/dm-vdo-target.c

1218

ti->discards_supported = 1;

drivers/md/dm-vdo/dm-vdo-target.c

1219

ti->flush_supported = true;

drivers/md/dm-vdo/dm-vdo-target.c

1220

ti->num_discard_bios = 1;

drivers/md/dm-vdo/dm-vdo-target.c

1221

ti->num_flush_bios = 1;

drivers/md/dm-vdo/dm-vdo-target.c

1227

BUG_ON(dm_set_target_max_io_len(ti, VDO_SECTORS_PER_BLOCK) != 0);

drivers/md/dm-vdo/dm-vdo-target.c

1560

static void set_device_config(struct dm_target *ti, struct vdo *vdo,

drivers/md/dm-vdo/dm-vdo-target.c

1566

ti->private = config;

drivers/md/dm-vdo/dm-vdo-target.c

1567

configure_target_capabilities(ti);

drivers/md/dm-vdo/dm-vdo-target.c

1570

static int vdo_initialize(struct dm_target *ti, unsigned int instance,

drivers/md/dm-vdo/dm-vdo-target.c

1576

u64 logical_size = to_bytes(ti->len);

drivers/md/dm-vdo/dm-vdo-target.c

1579

vdo_log_info("loading device '%s'", vdo_get_device_name(ti));

drivers/md/dm-vdo/dm-vdo-target.c

1596

ti->error = "Cannot share storage device with already-running VDO";

drivers/md/dm-vdo/dm-vdo-target.c

1600

result = vdo_make(instance, config, &ti->error, &vdo);

drivers/md/dm-vdo/dm-vdo-target.c

1603

result, ti->error);

drivers/md/dm-vdo/dm-vdo-target.c

1611

ti->error = ((result == VDO_INVALID_ADMIN_STATE) ?

drivers/md/dm-vdo/dm-vdo-target.c

1615

result, ti->error);

drivers/md/dm-vdo/dm-vdo-target.c

1620

set_device_config(ti, vdo, config);

drivers/md/dm-vdo/dm-vdo-target.c

1628

struct dm_target *ti = vdo->device_config->owning_target;

drivers/md/dm-vdo/dm-vdo-target.c

1629

const char *device_name = vdo_get_device_name(ti);

drivers/md/dm-vdo/dm-vdo-target.c

1717

static int construct_new_vdo_registered(struct dm_target *ti, unsigned int argc,

drivers/md/dm-vdo/dm-vdo-target.c

1723

result = parse_device_config(argc, argv, ti, &config);

drivers/md/dm-vdo/dm-vdo-target.c

1725

vdo_log_error_strerror(result, "parsing failed: %s", ti->error);

drivers/md/dm-vdo/dm-vdo-target.c

1731

result = vdo_initialize(ti, instance, config);

drivers/md/dm-vdo/dm-vdo-target.c

1741

static int construct_new_vdo(struct dm_target *ti, unsigned int argc, char **argv)

drivers/md/dm-vdo/dm-vdo-target.c

1754

result = construct_new_vdo_registered(ti, argc, argv, instance);

drivers/md/dm-vdo/dm-vdo-target.c

1940

static int prepare_to_modify(struct dm_target *ti, struct device_config *config,

drivers/md/dm-vdo/dm-vdo-target.c

1947

&ti->error);

drivers/md/dm-vdo/dm-vdo-target.c

1962

ti->error = "Device vdo_prepare_to_grow_logical failed";

drivers/md/dm-vdo/dm-vdo-target.c

1981

ti->error = "Device vdo_prepare_to_grow_physical failed (specified physical size too big based on formatted slab size)";

drivers/md/dm-vdo/dm-vdo-target.c

1983

ti->error = "Device vdo_prepare_to_grow_physical failed";

drivers/md/dm-vdo/dm-vdo-target.c

2000

static int update_existing_vdo(const char *device_name, struct dm_target *ti,

drivers/md/dm-vdo/dm-vdo-target.c

2006

result = parse_device_config(argc, argv, ti, &config);

drivers/md/dm-vdo/dm-vdo-target.c

2011

result = prepare_to_modify(ti, config, vdo);

drivers/md/dm-vdo/dm-vdo-target.c

2017

set_device_config(ti, vdo, config);

drivers/md/dm-vdo/dm-vdo-target.c

2021

static int vdo_ctr(struct dm_target *ti, unsigned int argc, char **argv)

drivers/md/dm-vdo/dm-vdo-target.c

2029

device_name = vdo_get_device_name(ti);

drivers/md/dm-vdo/dm-vdo-target.c

2032

result = construct_new_vdo(ti, argc, argv);

drivers/md/dm-vdo/dm-vdo-target.c

2035

result = update_existing_vdo(device_name, ti, argc, argv, vdo);

drivers/md/dm-vdo/dm-vdo-target.c

2043

static void vdo_dtr(struct dm_target *ti)

drivers/md/dm-vdo/dm-vdo-target.c

2045

struct device_config *config = ti->private;

drivers/md/dm-vdo/dm-vdo-target.c

2059

device_name = vdo_get_device_name(ti);

drivers/md/dm-vdo/dm-vdo-target.c

2079

ti->private = NULL;

drivers/md/dm-vdo/dm-vdo-target.c

2082

static void vdo_presuspend(struct dm_target *ti)

drivers/md/dm-vdo/dm-vdo-target.c

2084

get_vdo_for_target(ti)->suspend_type =

drivers/md/dm-vdo/dm-vdo-target.c

2085

(dm_noflush_suspending(ti) ? VDO_ADMIN_STATE_SUSPENDING : VDO_ADMIN_STATE_SAVING);

drivers/md/dm-vdo/dm-vdo-target.c

2218

static void vdo_postsuspend(struct dm_target *ti)

drivers/md/dm-vdo/dm-vdo-target.c

2220

struct vdo *vdo = get_vdo_for_target(ti);

drivers/md/dm-vdo/dm-vdo-target.c

2857

static int vdo_preresume_registered(struct dm_target *ti, struct vdo *vdo)

drivers/md/dm-vdo/dm-vdo-target.c

2859

struct device_config *config = ti->private;

drivers/md/dm-vdo/dm-vdo-target.c

2860

const char *device_name = vdo_get_device_name(ti);

drivers/md/dm-vdo/dm-vdo-target.c

2953

static int vdo_preresume(struct dm_target *ti)

drivers/md/dm-vdo/dm-vdo-target.c

2956

struct vdo *vdo = get_vdo_for_target(ti);

drivers/md/dm-vdo/dm-vdo-target.c

2960

result = vdo_preresume_registered(ti, vdo);

drivers/md/dm-vdo/dm-vdo-target.c

2968

static void vdo_resume(struct dm_target *ti)

drivers/md/dm-vdo/dm-vdo-target.c

2973

&get_vdo_for_target(ti)->instance);

drivers/md/dm-vdo/dm-vdo-target.c

2974

vdo_log_info("device '%s' resumed", vdo_get_device_name(ti));

drivers/md/dm-vdo/dm-vdo-target.c

795

static int parse_device_config(int argc, char **argv, struct dm_target *ti,

drivers/md/dm-vdo/dm-vdo-target.c

799

size_t logical_bytes = to_bytes(ti->len);

drivers/md/dm-vdo/dm-vdo-target.c

801

char **error_ptr = &ti->error;

drivers/md/dm-vdo/dm-vdo-target.c

829

config->owning_target = ti;

drivers/md/dm-vdo/dm-vdo-target.c

967

result = dm_get_device(ti, config->parent_device_name,

drivers/md/dm-vdo/dm-vdo-target.c

968

dm_table_get_mode(ti->table), &config->owned_device);

drivers/md/dm-vdo/dm-vdo-target.c

986

static struct vdo *get_vdo_for_target(struct dm_target *ti)

drivers/md/dm-vdo/dm-vdo-target.c

988

return ((struct device_config *) ti->private)->vdo;

drivers/md/dm-vdo/dm-vdo-target.c

992

static int vdo_map_bio(struct dm_target *ti, struct bio *bio)

drivers/md/dm-vdo/dm-vdo-target.c

994

struct vdo *vdo = get_vdo_for_target(ti);

drivers/md/dm-verity-fec.c

186

struct bio *bio = dm_bio_from_per_bio_data(io, v->ti->per_io_data_size);

drivers/md/dm-verity-fec.c

477

dm_put_device(v->ti, f->dev);

drivers/md/dm-verity-fec.c

510

struct dm_target *ti = v->ti;

drivers/md/dm-verity-fec.c

517

ti->error = "FEC feature arguments require a value";

drivers/md/dm-verity-fec.c

526

ti->error = "FEC device already specified";

drivers/md/dm-verity-fec.c

529

r = dm_get_device(ti, arg_value, BLK_OPEN_READ, &v->fec->dev);

drivers/md/dm-verity-fec.c

531

ti->error = "FEC device lookup failed";

drivers/md/dm-verity-fec.c

539

ti->error = "Invalid " DM_VERITY_OPT_FEC_BLOCKS;

drivers/md/dm-verity-fec.c

548

ti->error = "Invalid " DM_VERITY_OPT_FEC_START;

drivers/md/dm-verity-fec.c

557

ti->error = "Invalid " DM_VERITY_OPT_FEC_ROOTS;

drivers/md/dm-verity-fec.c

563

ti->error = "Unrecognized verity FEC feature request";

drivers/md/dm-verity-fec.c

579

v->ti->error = "Cannot allocate FEC structure";

drivers/md/dm-verity-fec.c

594

struct dm_target *ti = v->ti;

drivers/md/dm-verity-fec.c

62

struct bio *bio = dm_bio_from_per_bio_data(io, v->ti->per_io_data_size);

drivers/md/dm-verity-fec.c

625

ti->error = "Block sizes must match to use FEC";

drivers/md/dm-verity-fec.c

631

ti->error = "Missing " DM_VERITY_OPT_FEC_ROOTS;

drivers/md/dm-verity-fec.c

637

ti->error = "Missing " DM_VERITY_OPT_FEC_BLOCKS;

drivers/md/dm-verity-fec.c

650

ti->error = "Invalid " DM_VERITY_OPT_FEC_BLOCKS;

drivers/md/dm-verity-fec.c

661

ti->error = "Hash device is too small for "

drivers/md/dm-verity-fec.c

669

ti->error = "Cannot initialize FEC bufio client";

drivers/md/dm-verity-fec.c

676

ti->error = "FEC device is too small";

drivers/md/dm-verity-fec.c

683

ti->error = "Cannot initialize FEC data bufio client";

drivers/md/dm-verity-fec.c

688

ti->error = "Data device is too small";

drivers/md/dm-verity-fec.c

697

ti->error = "Cannot allocate FEC IO pool";

drivers/md/dm-verity-fec.c

705

ti->error = "Cannot allocate RS pool";

drivers/md/dm-verity-fec.c

713

ti->error = "Cannot create FEC buffer cache";

drivers/md/dm-verity-fec.c

721

ti->error = "Cannot allocate FEC buffer prealloc pool";

drivers/md/dm-verity-fec.c

729

ti->error = "Cannot allocate FEC output pool";

drivers/md/dm-verity-loadpin.c

15

static bool is_trusted_verity_target(struct dm_target *ti)

drivers/md/dm-verity-loadpin.c

23

if (!dm_is_verity_target(ti))

drivers/md/dm-verity-loadpin.c

26

verity_mode = dm_verity_get_mode(ti);

drivers/md/dm-verity-loadpin.c

33

if (dm_verity_get_root_digest(ti, &root_digest, &digest_size))

drivers/md/dm-verity-loadpin.c

57

struct dm_target *ti;

drivers/md/dm-verity-loadpin.c

76

ti = dm_table_get_target(table, 0);

drivers/md/dm-verity-loadpin.c

78

if (is_trusted_verity_target(ti))

drivers/md/dm-verity-target.c

1004

static int verity_iterate_devices(struct dm_target *ti,

drivers/md/dm-verity-target.c

1007

struct dm_verity *v = ti->private;

drivers/md/dm-verity-target.c

1009

return fn(ti, v->data_dev, 0, ti->len, data);

drivers/md/dm-verity-target.c

1012

static void verity_io_hints(struct dm_target *ti, struct queue_limits *limits)

drivers/md/dm-verity-target.c

1014

struct dm_verity *v = ti->private;

drivers/md/dm-verity-target.c

103

return dm_target_offset(v->ti, bi_sector);

drivers/md/dm-verity-target.c

1062

static void verity_dtr(struct dm_target *ti)

drivers/md/dm-verity-target.c

1064

struct dm_verity *v = ti->private;

drivers/md/dm-verity-target.c

1088

dm_put_device(ti, v->hash_dev);

drivers/md/dm-verity-target.c

1091

dm_put_device(ti, v->data_dev);

drivers/md/dm-verity-target.c

1102

dm_audit_log_dtr(DM_MSG_PREFIX, ti, 1);

drivers/md/dm-verity-target.c

1107

struct dm_target *ti = v->ti;

drivers/md/dm-verity-target.c

1114

ti->error = "device too large to use check_at_most_once";

drivers/md/dm-verity-target.c

1122

ti->error = "failed to allocate bitset for check_at_most_once";

drivers/md/dm-verity-target.c

1143

io = kmalloc(v->ti->per_io_data_size, GFP_KERNEL);

drivers/md/dm-verity-target.c

1210

struct dm_target *ti = v->ti;

drivers/md/dm-verity-target.c

1217

r = dm_read_arg_group(_args, as, &argc, &ti->error);

drivers/md/dm-verity-target.c

1233

ti->error = "Conflicting error handling parameters";

drivers/md/dm-verity-target.c

1243

ti->error = "Conflicting error handling parameters";

drivers/md/dm-verity-target.c

1253

ti->error = "Cannot allocate zero digest";

drivers/md/dm-verity-target.c

1302

ti->error = "Unrecognized verity feature request";

drivers/md/dm-verity-target.c

1311

struct dm_target *ti = v->ti;

drivers/md/dm-verity-target.c

1316

ti->error = "Cannot allocate algorithm name";

drivers/md/dm-verity-target.c

1322

ti->error = "Cannot initialize hash function";

drivers/md/dm-verity-target.c

1328

ti->error = "Digest size too big";

drivers/md/dm-verity-target.c

1339

ti->per_io_data_size =

drivers/md/dm-verity-target.c

1343

ti->per_io_data_size =

drivers/md/dm-verity-target.c

1352

struct dm_target *ti = v->ti;

drivers/md/dm-verity-target.c

1358

ti->error = "Cannot allocate salt";

drivers/md/dm-verity-target.c

1363

ti->error = "Invalid salt";

drivers/md/dm-verity-target.c

1372

ti->error = "Cannot allocate initial hash state";

drivers/md/dm-verity-target.c

1389

ti->error = "Cannot allocate initial hash state";

drivers/md/dm-verity-target.c

1397

ti->error = "Cannot set up initial hash state";

drivers/md/dm-verity-target.c

1418

static int verity_ctr(struct dm_target *ti, unsigned int argc, char **argv)

drivers/md/dm-verity-target.c

1433

ti->error = "Cannot allocate verity structure";

drivers/md/dm-verity-target.c

1436

ti->private = v;

drivers/md/dm-verity-target.c

1437

v->ti = ti;

drivers/md/dm-verity-target.c

1443

if ((dm_table_get_mode(ti->table) & ~BLK_OPEN_READ)) {

drivers/md/dm-verity-target.c

1444

ti->error = "Device must be readonly";

drivers/md/dm-verity-target.c

1450

ti->error = "Not enough arguments";

drivers/md/dm-verity-target.c

1466

ti->error = "Invalid version";

drivers/md/dm-verity-target.c

1472

r = dm_get_device(ti, argv[1], BLK_OPEN_READ, &v->data_dev);

drivers/md/dm-verity-target.c

1474

ti->error = "Data device lookup failed";

drivers/md/dm-verity-target.c

1478

r = dm_get_device(ti, argv[2], BLK_OPEN_READ, &v->hash_dev);

drivers/md/dm-verity-target.c

1480

ti->error = "Hash device lookup failed";

drivers/md/dm-verity-target.c

1488

ti->error = "Invalid data device block size";

drivers/md/dm-verity-target.c

1498

ti->error = "Invalid hash device block size";

drivers/md/dm-verity-target.c

1507

ti->error = "Invalid data blocks";

drivers/md/dm-verity-target.c

1513

if (ti->len > (v->data_blocks << (v->data_dev_block_bits - SECTOR_SHIFT))) {

drivers/md/dm-verity-target.c

1514

ti->error = "Data device is too small";

drivers/md/dm-verity-target.c

1522

ti->error = "Invalid hash start";

drivers/md/dm-verity-target.c

1534

ti->error = "Cannot allocate root digest";

drivers/md/dm-verity-target.c

1540

ti->error = "Invalid root digest";

drivers/md/dm-verity-target.c

1568

ti->error = "Root hash verification failed";

drivers/md/dm-verity-target.c

1574

ti->error = "Cannot allocate root digest signature";

drivers/md/dm-verity-target.c

1589

ti->error = "Too many tree levels";

drivers/md/dm-verity-target.c

1602

ti->error = "Hash device offset overflow";

drivers/md/dm-verity-target.c

1612

ti->error = "Cannot allocate mempool";

drivers/md/dm-verity-target.c

1620

ti->error = "Cannot allocate dm io";

drivers/md/dm-verity-target.c

1629

ti->error = "Cannot initialize dm-bufio";

drivers/md/dm-verity-target.c

1636

ti->error = "Hash device is too small";

drivers/md/dm-verity-target.c

1654

ti->error = "Cannot allocate workqueue";

drivers/md/dm-verity-target.c

1663

ti->per_io_data_size = roundup(ti->per_io_data_size,

drivers/md/dm-verity-target.c

1668

dm_audit_log_ctr(DM_MSG_PREFIX, ti, 1);

drivers/md/dm-verity-target.c

1675

dm_audit_log_ctr(DM_MSG_PREFIX, ti, 0);

drivers/md/dm-verity-target.c

1676

verity_dtr(ti);

drivers/md/dm-verity-target.c

1687

int dm_verity_get_mode(struct dm_target *ti)

drivers/md/dm-verity-target.c

1689

struct dm_verity *v = ti->private;

drivers/md/dm-verity-target.c

1691

if (!dm_is_verity_target(ti))

drivers/md/dm-verity-target.c

1703

int dm_verity_get_root_digest(struct dm_target *ti, u8 **root_digest, unsigned int *digest_size)

drivers/md/dm-verity-target.c

1705

struct dm_verity *v = ti->private;

drivers/md/dm-verity-target.c

1707

if (!dm_is_verity_target(ti))

drivers/md/dm-verity-target.c

1753

static int verity_preresume(struct dm_target *ti)

drivers/md/dm-verity-target.c

1760

v = ti->private;

drivers/md/dm-verity-target.c

1761

bdev = dm_disk(dm_table_get_md(ti->table))->part0;

drivers/md/dm-verity-target.c

182

struct mapped_device *md = dm_table_get_md(v->ti->table);

drivers/md/dm-verity-target.c

1833

bool dm_is_verity_target(struct dm_target *ti)

drivers/md/dm-verity-target.c

1835

return ti->type == &verity_target;

drivers/md/dm-verity-target.c

210

dm_audit_log_target(DM_MSG_PREFIX, "max-corrupted-errors", v->ti, 0);

drivers/md/dm-verity-target.c

252

struct bio *bio = dm_bio_from_per_bio_data(io, v->ti->per_io_data_size);

drivers/md/dm-verity-target.c

321

bio = dm_bio_from_per_bio_data(io, v->ti->per_io_data_size);

drivers/md/dm-verity-target.c

517

struct bio *bio = dm_bio_from_per_bio_data(io, v->ti->per_io_data_size);

drivers/md/dm-verity-target.c

618

struct bio *bio = dm_bio_from_per_bio_data(io, v->ti->per_io_data_size);

drivers/md/dm-verity-target.c

787

static int verity_map(struct dm_target *ti, struct bio *bio)

drivers/md/dm-verity-target.c

789

struct dm_verity *v = ti->private;

drivers/md/dm-verity-target.c

810

io = dm_per_bio_data(bio, ti->per_io_data_size);

drivers/md/dm-verity-target.c

830

static void verity_postsuspend(struct dm_target *ti)

drivers/md/dm-verity-target.c

832

struct dm_verity *v = ti->private;

drivers/md/dm-verity-target.c

840

static void verity_status(struct dm_target *ti, status_type_t type,

drivers/md/dm-verity-target.c

843

struct dm_verity *v = ti->private;

drivers/md/dm-verity-target.c

934

DMEMIT_TARGET_NAME_VERSION(ti->type);

drivers/md/dm-verity-target.c

991

static int verity_prepare_ioctl(struct dm_target *ti, struct block_device **bdev,

drivers/md/dm-verity-target.c

995

struct dm_verity *v = ti->private;

drivers/md/dm-verity-target.c

999

if (ti->len != bdev_nr_sectors(v->data_dev->bdev))

drivers/md/dm-verity-verify-sig.c

105

ti->error = DM_VERITY_VERIFY_ERR("Could not allocate memory for signature key");

drivers/md/dm-verity-verify-sig.c

80

struct dm_target *ti = v->ti;

drivers/md/dm-verity-verify-sig.c

85

ti->error = DM_VERITY_VERIFY_ERR("root_hash_sig_key_desc already specified");

drivers/md/dm-verity-verify-sig.c

90

ti->error = DM_VERITY_VERIFY_ERR("Signature key not specified");

drivers/md/dm-verity-verify-sig.c

99

ti->error = DM_VERITY_VERIFY_ERR("Invalid key specified");

drivers/md/dm-verity.h

143

extern bool dm_is_verity_target(struct dm_target *ti);

drivers/md/dm-verity.h

144

extern int dm_verity_get_mode(struct dm_target *ti);

drivers/md/dm-verity.h

145

extern int dm_verity_get_root_digest(struct dm_target *ti, u8 **root_digest,

drivers/md/dm-verity.h

40

struct dm_target *ti;

drivers/md/dm-writecache.c

1117

if (dm_suspended(wc->ti)) {

drivers/md/dm-writecache.c

1171

if (!dm_suspended(wc->ti))

drivers/md/dm-writecache.c

1190

static int writecache_message(struct dm_target *ti, unsigned int argc, char **argv,

drivers/md/dm-writecache.c

1194

struct dm_writecache *wc = ti->private;

drivers/md/dm-writecache.c

142

struct dm_target *ti;

drivers/md/dm-writecache.c

1540

static int writecache_map(struct dm_target *ti, struct bio *bio)

drivers/md/dm-writecache.c

1542

struct dm_writecache *wc = ti->private;

drivers/md/dm-writecache.c

1554

bio->bi_iter.bi_sector = dm_target_offset(ti, bio->bi_iter.bi_sector);

drivers/md/dm-writecache.c

1615

static int writecache_end_io(struct dm_target *ti, struct bio *bio, blk_status_t *status)

drivers/md/dm-writecache.c

1617

struct dm_writecache *wc = ti->private;

drivers/md/dm-writecache.c

1631

static int writecache_iterate_devices(struct dm_target *ti,

drivers/md/dm-writecache.c

1634

struct dm_writecache *wc = ti->private;

drivers/md/dm-writecache.c

1636

return fn(ti, wc->dev, 0, ti->len, data);

drivers/md/dm-writecache.c

1639

static void writecache_io_hints(struct dm_target *ti, struct queue_limits *limits)

drivers/md/dm-writecache.c

1641

struct dm_writecache *wc = ti->private;

drivers/md/dm-writecache.c

1953

unlikely(dm_suspended(wc->ti)))

drivers/md/dm-writecache.c

1993

if (likely(!dm_suspended(wc->ti)))

drivers/md/dm-writecache.c

2173

static void writecache_dtr(struct dm_target *ti)

drivers/md/dm-writecache.c

2175

struct dm_writecache *wc = ti->private;

drivers/md/dm-writecache.c

2194

dm_put_device(ti, wc->dev);

drivers/md/dm-writecache.c

2197

dm_put_device(ti, wc->ssd_dev);

drivers/md/dm-writecache.c

2219

static int writecache_ctr(struct dm_target *ti, unsigned int argc, char **argv)

drivers/md/dm-writecache.c

2242

ti->error = "Cannot allocate writecache structure";

drivers/md/dm-writecache.c

2246

ti->private = wc;

drivers/md/dm-writecache.c

2247

wc->ti = ti;

drivers/md/dm-writecache.c

2264

ti->error = "Unable to allocate dm-io client";

drivers/md/dm-writecache.c

2273

ti->error = "Could not allocate writeback workqueue";

drivers/md/dm-writecache.c

2287

ti->error = "Couldn't spawn endio thread";

drivers/md/dm-writecache.c

2311

ti->error = "Persistent memory or DAX not supported on this system";

drivers/md/dm-writecache.c

2323

ti->error = "Could not allocate bio set";

drivers/md/dm-writecache.c

2330

ti->error = "Could not allocate mempool";

drivers/md/dm-writecache.c

2341

r = dm_get_device(ti, string, dm_table_get_mode(ti->table), &wc->dev);

drivers/md/dm-writecache.c

2343

ti->error = "Origin data device lookup failed";

drivers/md/dm-writecache.c

2354

r = dm_get_device(ti, string, dm_table_get_mode(ti->table), &wc->ssd_dev);

drivers/md/dm-writecache.c

2356

ti->error = "Cache data device lookup failed";

drivers/md/dm-writecache.c

2371

ti->error = "Invalid block size";

drivers/md/dm-writecache.c

2377

ti->error = "Block size is smaller than device logical block size";

drivers/md/dm-writecache.c

2389

r = dm_read_arg_group(_args, &as, &opt_params, &ti->error);

drivers/md/dm-writecache.c

2487

ti->error = "Invalid optional argument";

drivers/md/dm-writecache.c

2494

ti->error = "High watermark must be greater than or equal to low watermark";

drivers/md/dm-writecache.c

2501

ti->error = "Asynchronous persistent memory not supported as pmem cache";

drivers/md/dm-writecache.c

2507

ti->error = "Unable to map persistent memory for cache";

drivers/md/dm-writecache.c

2521

ti->error = "Couldn't spawn flush thread";

drivers/md/dm-writecache.c

2528

ti->error = "Invalid device size";

drivers/md/dm-writecache.c

2537

ti->error = "Invalid device size";

drivers/md/dm-writecache.c

2544

ti->error = "Unable to allocate memory for metadata";

drivers/md/dm-writecache.c

2551

ti->error = "Unable to allocate dm-kcopyd client";

drivers/md/dm-writecache.c

2562

ti->error = "Unable to allocate dirty bitmap";

drivers/md/dm-writecache.c

2568

ti->error = "Unable to read first block of metadata";

drivers/md/dm-writecache.c

2575

ti->error = "Hardware memory error when reading superblock";

drivers/md/dm-writecache.c

2581

ti->error = "Unable to initialize device";

drivers/md/dm-writecache.c

2587

ti->error = "Hardware memory error when reading superblock";

drivers/md/dm-writecache.c

2593

ti->error = "Invalid magic in the superblock";

drivers/md/dm-writecache.c

2599

ti->error = "Invalid version in the superblock";

drivers/md/dm-writecache.c

2605

ti->error = "Block size does not match superblock";

drivers/md/dm-writecache.c

2615

ti->error = "Overflow in size calculation";

drivers/md/dm-writecache.c

2628

ti->error = "Memory area is too small";

drivers/md/dm-writecache.c

2650

ti->error = "Cannot allocate memory";

drivers/md/dm-writecache.c

2654

ti->num_flush_bios = WC_MODE_PMEM(wc) ? 1 : 2;

drivers/md/dm-writecache.c

2655

ti->flush_supported = true;

drivers/md/dm-writecache.c

2656

ti->num_discard_bios = 1;

drivers/md/dm-writecache.c

2665

ti->error = "Bad arguments";

drivers/md/dm-writecache.c

2667

writecache_dtr(ti);

drivers/md/dm-writecache.c

2671

static void writecache_status(struct dm_target *ti, status_type_t type,

drivers/md/dm-writecache.c

2674

struct dm_writecache *wc = ti->private;

drivers/md/dm-writecache.c

710

if (!dm_suspended(wc->ti) && !writecache_has_error(wc)) {

drivers/md/dm-writecache.c

924

static void writecache_suspend(struct dm_target *ti)

drivers/md/dm-writecache.c

926

struct dm_writecache *wc = ti->private;

drivers/md/dm-writecache.c

995

static void writecache_resume(struct dm_target *ti)

drivers/md/dm-writecache.c

997

struct dm_writecache *wc = ti->private;

drivers/md/dm-zero.c

19

static int zero_ctr(struct dm_target *ti, unsigned int argc, char **argv)

drivers/md/dm-zero.c

22

ti->error = "No arguments required";

drivers/md/dm-zero.c

29

ti->num_discard_bios = 1;

drivers/md/dm-zero.c

30

ti->discards_supported = true;

drivers/md/dm-zero.c

38

static int zero_map(struct dm_target *ti, struct bio *bio)

drivers/md/dm-zero.c

62

static void zero_io_hints(struct dm_target *ti, struct queue_limits *limits)

drivers/md/dm-zone.c

212

static int device_not_zone_append_capable(struct dm_target *ti,

drivers/md/dm-zone.c

222

struct dm_target *ti = dm_table_get_target(t, i);

drivers/md/dm-zone.c

224

if (ti->emulate_zone_append)

drivers/md/dm-zone.c

227

if (!ti->type->iterate_devices ||

drivers/md/dm-zone.c

228

ti->type->iterate_devices(ti, device_not_zone_append_capable, NULL))

drivers/md/dm-zone.c

281

static int device_get_zone_resource_limits(struct dm_target *ti,

drivers/md/dm-zone.c

320

ti->zone_reset_all_supported = false;

drivers/md/dm-zone.c

377

struct dm_target *ti = dm_table_get_target(t, i);

drivers/md/dm-zone.c

385

ti->zone_reset_all_supported = true;

drivers/md/dm-zone.c

387

if (!ti->type->iterate_devices ||

drivers/md/dm-zone.c

388

ti->type->iterate_devices(ti,

drivers/md/dm-zoned-target.c

1018

static int dmz_prepare_ioctl(struct dm_target *ti, struct block_device **bdev,

drivers/md/dm-zoned-target.c

1021

struct dmz_target *dmz = ti->private;

drivers/md/dm-zoned-target.c

1035

static void dmz_suspend(struct dm_target *ti)

drivers/md/dm-zoned-target.c

1037

struct dmz_target *dmz = ti->private;

drivers/md/dm-zoned-target.c

1049

static void dmz_resume(struct dm_target *ti)

drivers/md/dm-zoned-target.c

1051

struct dmz_target *dmz = ti->private;

drivers/md/dm-zoned-target.c

1059

static int dmz_iterate_devices(struct dm_target *ti,

drivers/md/dm-zoned-target.c

1062

struct dmz_target *dmz = ti->private;

drivers/md/dm-zoned-target.c

1069

r = fn(ti, dmz->ddev[i], 0, capacity, data);

drivers/md/dm-zoned-target.c

1076

static void dmz_status(struct dm_target *ti, status_type_t type,

drivers/md/dm-zoned-target.c

1080

struct dmz_target *dmz = ti->private;

drivers/md/dm-zoned-target.c

1123

static int dmz_message(struct dm_target *ti, unsigned int argc, char **argv,

drivers/md/dm-zoned-target.c

1126

struct dmz_target *dmz = ti->private;

drivers/md/dm-zoned-target.c

625

static int dmz_map(struct dm_target *ti, struct bio *bio)

drivers/md/dm-zoned-target.c

627

struct dmz_target *dmz = ti->private;

drivers/md/dm-zoned-target.c

688

static int dmz_get_zoned_device(struct dm_target *ti, char *path,

drivers/md/dm-zoned-target.c

691

struct dmz_target *dmz = ti->private;

drivers/md/dm-zoned-target.c

698

ret = dm_get_device(ti, path, dm_table_get_mode(ti->table), &ddev);

drivers/md/dm-zoned-target.c

700

ti->error = "Get target device failed";

drivers/md/dm-zoned-target.c

707

ti->error = "Invalid regular device";

drivers/md/dm-zoned-target.c

711

ti->error = "First device must be a regular device";

drivers/md/dm-zoned-target.c

715

ti->error = "Too many regular devices";

drivers/md/dm-zoned-target.c

722

ti->error = "Too many zoned devices";

drivers/md/dm-zoned-target.c

726

ti->error = "First device must be a regular device";

drivers/md/dm-zoned-target.c

735

if (ti->begin) {

drivers/md/dm-zoned-target.c

736

ti->error = "Partial mapping is not supported";

drivers/md/dm-zoned-target.c

744

dm_put_device(ti, ddev);

drivers/md/dm-zoned-target.c

751

static void dmz_put_zoned_devices(struct dm_target *ti)

drivers/md/dm-zoned-target.c

753

struct dmz_target *dmz = ti->private;

drivers/md/dm-zoned-target.c

758

dm_put_device(ti, dmz->ddev[i]);

drivers/md/dm-zoned-target.c

763

static int dmz_fixup_devices(struct dm_target *ti)

drivers/md/dm-zoned-target.c

765

struct dmz_target *dmz = ti->private;

drivers/md/dm-zoned-target.c

777

ti->error = "Primary disk is not a regular device";

drivers/md/dm-zoned-target.c

785

ti->error = "Secondary disk is not a zoned device";

drivers/md/dm-zoned-target.c

790

ti->error = "Zone nr sectors mismatch";

drivers/md/dm-zoned-target.c

802

ti->error = "Disk is not a zoned device";

drivers/md/dm-zoned-target.c

829

static int dmz_ctr(struct dm_target *ti, unsigned int argc, char **argv)

drivers/md/dm-zoned-target.c

836

ti->error = "Invalid argument count";

drivers/md/dm-zoned-target.c

843

ti->error = "Unable to allocate the zoned target descriptor";

drivers/md/dm-zoned-target.c

848

ti->error = "Unable to allocate the zoned device descriptors";

drivers/md/dm-zoned-target.c

854

ti->error = "Unable to allocate the dm device descriptors";

drivers/md/dm-zoned-target.c

860

ti->private = dmz;

drivers/md/dm-zoned-target.c

864

ret = dmz_get_zoned_device(ti, argv[i], i, argc);

drivers/md/dm-zoned-target.c

868

ret = dmz_fixup_devices(ti);

drivers/md/dm-zoned-target.c

874

dm_table_device_name(ti->table));

drivers/md/dm-zoned-target.c

876

ti->error = "Metadata initialization failed";

drivers/md/dm-zoned-target.c

881

ti->max_io_len = dmz_zone_nr_sectors(dmz->metadata);

drivers/md/dm-zoned-target.c

882

ti->num_flush_bios = 1;

drivers/md/dm-zoned-target.c

883

ti->num_discard_bios = 1;

drivers/md/dm-zoned-target.c

884

ti->num_write_zeroes_bios = 1;

drivers/md/dm-zoned-target.c

885

ti->per_io_data_size = sizeof(struct dmz_bioctx);

drivers/md/dm-zoned-target.c

886

ti->flush_supported = true;

drivers/md/dm-zoned-target.c

887

ti->discards_supported = true;

drivers/md/dm-zoned-target.c

890

ti->len = (sector_t)dmz_nr_chunks(dmz->metadata) <<

drivers/md/dm-zoned-target.c

896

ti->error = "Create BIO set failed";

drivers/md/dm-zoned-target.c

907

ti->error = "Create chunk workqueue failed";

drivers/md/dm-zoned-target.c

919

ti->error = "Create flush workqueue failed";

drivers/md/dm-zoned-target.c

929

ti->error = "Zone reclaim initialization failed";

drivers/md/dm-zoned-target.c

936

(unsigned long long)ti->len,

drivers/md/dm-zoned-target.c

937

(unsigned long long)dmz_sect2blk(ti->len));

drivers/md/dm-zoned-target.c

950

dmz_put_zoned_devices(ti);

drivers/md/dm-zoned-target.c

961

static void dmz_dtr(struct dm_target *ti)

drivers/md/dm-zoned-target.c

963

struct dmz_target *dmz = ti->private;

drivers/md/dm-zoned-target.c

980

dmz_put_zoned_devices(ti);

drivers/md/dm-zoned-target.c

991

static void dmz_io_hints(struct dm_target *ti, struct queue_limits *limits)

drivers/md/dm-zoned-target.c

993

struct dmz_target *dmz = ti->private;

drivers/md/dm.c

1087

static bool swap_bios_limit(struct dm_target *ti, struct bio *bio)

drivers/md/dm.c

1089

return unlikely((bio->bi_opf & REQ_SWAP) != 0) && unlikely(ti->limit_swap_bios);

drivers/md/dm.c

1096

struct dm_target *ti = tio->ti;

drivers/md/dm.c

1097

dm_endio_fn endio = likely(ti != NULL) ? ti->type->end_io : NULL;

drivers/md/dm.c

1115

int r = endio(ti, bio, &error);

drivers/md/dm.c

1144

likely(ti != NULL) && unlikely(swap_bios_limit(ti, bio)))

drivers/md/dm.c

1155

static inline sector_t max_io_len_target_boundary(struct dm_target *ti,

drivers/md/dm.c

1158

return ti->len - target_offset;

drivers/md/dm.c

1161

static sector_t __max_io_len(struct dm_target *ti, sector_t sector,

drivers/md/dm.c

1165

sector_t target_offset = dm_target_offset(ti, sector);

drivers/md/dm.c

1166

sector_t len = max_io_len_target_boundary(ti, target_offset);

drivers/md/dm.c

1177

min(max_sectors ? : queue_max_sectors(ti->table->md->queue),

drivers/md/dm.c

1181

static inline sector_t max_io_len(struct dm_target *ti, sector_t sector)

drivers/md/dm.c

1183

return __max_io_len(ti, sector, ti->max_io_len, 0);

drivers/md/dm.c

1186

int dm_set_target_max_io_len(struct dm_target *ti, sector_t len)

drivers/md/dm.c

1191

ti->error = "Maximum size of target IO is too large";

drivers/md/dm.c

1195

ti->max_io_len = (uint32_t) len;

drivers/md/dm.c

1206

struct dm_target *ti;

drivers/md/dm.c

1212

ti = dm_table_find_target(map, sector);

drivers/md/dm.c

1213

if (!ti)

drivers/md/dm.c

1216

return ti;

drivers/md/dm.c

1225

struct dm_target *ti;

drivers/md/dm.c

1229

ti = dm_dax_get_live_target(md, sector, &srcu_idx);

drivers/md/dm.c

1231

if (!ti)

drivers/md/dm.c

1233

if (!ti->type->direct_access)

drivers/md/dm.c

1235

len = max_io_len(ti, sector) / PAGE_SECTORS;

drivers/md/dm.c

1239

ret = ti->type->direct_access(ti, pgoff, nr_pages, mode, kaddr, pfn);

drivers/md/dm.c

1252

struct dm_target *ti;

drivers/md/dm.c

1256

ti = dm_dax_get_live_target(md, sector, &srcu_idx);

drivers/md/dm.c

1258

if (!ti)

drivers/md/dm.c

1260

if (WARN_ON(!ti->type->dax_zero_page_range)) {

drivers/md/dm.c

1267

ret = ti->type->dax_zero_page_range(ti, pgoff, nr_pages);

drivers/md/dm.c

1279

struct dm_target *ti;

drivers/md/dm.c

1283

ti = dm_dax_get_live_target(md, sector, &srcu_idx);

drivers/md/dm.c

1284

if (!ti || !ti->type->dax_recovery_write)

drivers/md/dm.c

1287

ret = ti->type->dax_recovery_write(ti, pgoff, addr, bytes, i);

drivers/md/dm.c

1409

struct dm_target *ti = tio->ti;

drivers/md/dm.c

1422

unlikely(swap_bios_limit(ti, clone))) {

drivers/md/dm.c

1430

if (likely(ti->type->map == linear_map))

drivers/md/dm.c

1431

r = linear_map(ti, clone);

drivers/md/dm.c

1432

else if (ti->type->map == stripe_map)

drivers/md/dm.c

1433

r = stripe_map(ti, clone);

drivers/md/dm.c

1435

r = ti->type->map(ti, clone);

drivers/md/dm.c

1440

if (!ti->accounts_remapped_io)

drivers/md/dm.c

1449

unlikely(swap_bios_limit(ti, clone)))

drivers/md/dm.c

1479

struct dm_target *ti, unsigned int num_bios,

drivers/md/dm.c

1491

bio = alloc_tio(ci, ti, bio_nr, len,

drivers/md/dm.c

1508

static unsigned int __send_duplicate_bios(struct clone_info *ci, struct dm_target *ti,

drivers/md/dm.c

1526

alloc_multiple_bios(&blist, ci, ti, num_bios, len);

drivers/md/dm.c

1561

struct dm_target *ti = dm_table_get_target(t, i);

drivers/md/dm.c

1563

if (unlikely(ti->num_flush_bios == 0))

drivers/md/dm.c

1566

atomic_add(ti->num_flush_bios, &ci->io->io_count);

drivers/md/dm.c

1567

bios = __send_duplicate_bios(ci, ti, ti->num_flush_bios,

drivers/md/dm.c

1569

atomic_sub(ti->num_flush_bios - bios, &ci->io->io_count);

drivers/md/dm.c

1606

static void __send_abnormal_io(struct clone_info *ci, struct dm_target *ti,

drivers/md/dm.c

1613

__max_io_len(ti, ci->sector, max_granularity, max_sectors));

drivers/md/dm.c

1616

bios = __send_duplicate_bios(ci, ti, num_bios, &len);

drivers/md/dm.c

1645

struct dm_target *ti)

drivers/md/dm.c

1650

struct queue_limits *limits = dm_get_queue_limits(ti->table->md);

drivers/md/dm.c

1654

num_bios = ti->num_discard_bios;

drivers/md/dm.c

1656

if (ti->max_discard_granularity)

drivers/md/dm.c

1660

num_bios = ti->num_secure_erase_bios;

drivers/md/dm.c

1664

num_bios = ti->num_write_zeroes_bios;

drivers/md/dm.c

1680

__send_abnormal_io(ci, ti, num_bios, max_granularity, max_sectors);

drivers/md/dm.c

1733

struct dm_target *ti;

drivers/md/dm.c

1736

ti = dm_table_find_target(ci->map, ci->sector);

drivers/md/dm.c

1737

if (unlikely(!ti))

drivers/md/dm.c

1741

return __process_abnormal_io(ci, ti);

drivers/md/dm.c

1749

len = min_t(sector_t, max_io_len(ti, ci->sector), ci->sector_count);

drivers/md/dm.c

1751

if (unlikely(!dm_target_supports_atomic_writes(ti->type)))

drivers/md/dm.c

1760

if (unlikely(!dm_target_supports_nowait(ti->type)))

drivers/md/dm.c

1763

clone = alloc_tio(ci, ti, 0, &len, GFP_NOWAIT);

drivers/md/dm.c

1767

clone = alloc_tio(ci, ti, 0, &len, GFP_NOIO);

drivers/md/dm.c

1827

struct dm_target *ti)

drivers/md/dm.c

1836

sector_t sector = ti->begin;

drivers/md/dm.c

1840

nr_zones = ti->len >> ilog2(zone_sectors);

drivers/md/dm.c

1845

ret = dm_zone_get_reset_bitmap(md, ci->map, ti->begin,

drivers/md/dm.c

1875

alloc_multiple_bios(&blist, ci, ti, min(nr_reset, 32),

drivers/md/dm.c

1903

struct dm_target *ti)

drivers/md/dm.c

1908

bios = __send_duplicate_bios(ci, ti, 1, NULL);

drivers/md/dm.c

1920

struct dm_target *ti = dm_table_get_target(t, i);

drivers/md/dm.c

1922

if (ti->zone_reset_all_supported) {

drivers/md/dm.c

1923

__send_zone_reset_all_native(ci, ti);

drivers/md/dm.c

1927

sts = __send_zone_reset_all_emulated(ci, ti);

drivers/md/dm.c

3397

int dm_suspended(struct dm_target *ti)

drivers/md/dm.c

3399

return dm_suspended_md(ti->table->md);

drivers/md/dm.c

3403

int dm_post_suspending(struct dm_target *ti)

drivers/md/dm.c

3405

return dm_post_suspending_md(ti->table->md);

drivers/md/dm.c

3409

int dm_noflush_suspending(struct dm_target *ti)

drivers/md/dm.c

3411

return __noflush_suspending(ti->table->md);

drivers/md/dm.c

3431

static int __dm_get_unique_id(struct dm_target *ti, struct dm_dev *dev,

drivers/md/dm.c

3453

struct dm_target *ti;

drivers/md/dm.c

3468

ti = dm_table_get_target(table, 0);

drivers/md/dm.c

3470

if (!ti->type->iterate_devices)

drivers/md/dm.c

3473

ret = ti->type->iterate_devices(ti, __dm_get_unique_id, &dm_id);

drivers/md/dm.c

3496

struct dm_target *ti;

drivers/md/dm.c

3506

ti = dm_table_get_target(table, 0);

drivers/md/dm.c

3514

if (!ti->type->iterate_devices)

drivers/md/dm.c

3517

ti->type->iterate_devices(ti, fn, pr);

drivers/md/dm.c

3527

static int __dm_pr_register(struct dm_target *ti, struct dm_dev *dev,

drivers/md/dm.c

3587

static int __dm_pr_reserve(struct dm_target *ti, struct dm_dev *dev,

drivers/md/dm.c

3630

static int __dm_pr_release(struct dm_target *ti, struct dm_dev *dev,

drivers/md/dm.c

3664

static int __dm_pr_preempt(struct dm_target *ti, struct dm_dev *dev,

drivers/md/dm.c

3724

static int __dm_pr_read_keys(struct dm_target *ti, struct dm_dev *dev,

drivers/md/dm.c

3756

static int __dm_pr_read_reservation(struct dm_target *ti, struct dm_dev *dev,

drivers/md/dm.c

417

struct dm_target *ti;

drivers/md/dm.c

431

ti = dm_table_get_target(map, 0);

drivers/md/dm.c

432

if (!ti->type->prepare_ioctl)

drivers/md/dm.c

438

r = ti->type->prepare_ioctl(ti, bdev, cmd, arg, forward);

drivers/md/dm.c

613

static struct bio *alloc_tio(struct clone_info *ci, struct dm_target *ti,

drivers/md/dm.c

640

tio->ti = ti;

drivers/md/dm.c

647

if (likely(ti != NULL) && unlikely(ti->needs_bio_set_dev))

drivers/md/dm.h

194

int linear_map(struct dm_target *ti, struct bio *bio);

drivers/md/dm.h

198

int stripe_map(struct dm_target *ti, struct bio *bio);

drivers/net/ethernet/amd/xgbe/xgbe-drv.c

372

bool per_ch_irq, ti, ri, rbu, fbe;

drivers/net/ethernet/amd/xgbe/xgbe-drv.c

399

ti = !!XGMAC_GET_BITS(dma_ch_isr, DMA_CH_SR, TI);

drivers/net/ethernet/amd/xgbe/xgbe-drv.c

416

if (!per_ch_irq && (ti || ri))

drivers/net/ethernet/amd/xgbe/xgbe-drv.c

885

unsigned int entry, struct udp_tunnel_info *ti)

drivers/net/ethernet/amd/xgbe/xgbe-drv.c

889

pdata->vxlan_port = be16_to_cpu(ti->port);

drivers/net/ethernet/amd/xgbe/xgbe-drv.c

896

unsigned int entry, struct udp_tunnel_info *ti)

drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c

10214

struct udp_tunnel_info ti;

drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c

10216

udp_tunnel_nic_get_port(netdev, table, 0, &ti);

drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c

10217

bp->udp_tunnel_ports[table] = be16_to_cpu(ti.port);

drivers/net/ethernet/broadcom/bnxt/bnxt.c

15947

unsigned int entry, struct udp_tunnel_info *ti)

drivers/net/ethernet/broadcom/bnxt/bnxt.c

15952

if (ti->type == UDP_TUNNEL_TYPE_VXLAN)

drivers/net/ethernet/broadcom/bnxt/bnxt.c

15954

else if (ti->type == UDP_TUNNEL_TYPE_GENEVE)

drivers/net/ethernet/broadcom/bnxt/bnxt.c

15959

return bnxt_hwrm_tunnel_dst_port_alloc(bp, ti->port, cmd);

drivers/net/ethernet/broadcom/bnxt/bnxt.c

15963

unsigned int entry, struct udp_tunnel_info *ti)

drivers/net/ethernet/broadcom/bnxt/bnxt.c

15968

if (ti->type == UDP_TUNNEL_TYPE_VXLAN)

drivers/net/ethernet/broadcom/bnxt/bnxt.c

15970

else if (ti->type == UDP_TUNNEL_TYPE_GENEVE)

drivers/net/ethernet/cavium/liquidio/lio_main.c

2677

struct udp_tunnel_info *ti)

drivers/net/ethernet/cavium/liquidio/lio_main.c

2681

htons(ti->port),

drivers/net/ethernet/cavium/liquidio/lio_main.c

2688

struct udp_tunnel_info *ti)

drivers/net/ethernet/cavium/liquidio/lio_main.c

2692

htons(ti->port),

drivers/net/ethernet/cavium/liquidio/lio_vf_main.c

1764

struct udp_tunnel_info *ti)

drivers/net/ethernet/cavium/liquidio/lio_vf_main.c

1768

htons(ti->port),

drivers/net/ethernet/cavium/liquidio/lio_vf_main.c

1775

struct udp_tunnel_info *ti)

drivers/net/ethernet/cavium/liquidio/lio_vf_main.c

1779

htons(ti->port),

drivers/net/ethernet/chelsio/cxgb3/cxgb3_offload.c

1076

struct tid_info *ti;

drivers/net/ethernet/chelsio/cxgb3/cxgb3_offload.c

1098

ti = &(T3C_DATA(tdev))->tid_maps;

drivers/net/ethernet/chelsio/cxgb3/cxgb3_offload.c

1099

for (tid = 0; tid < ti->ntids; tid++) {

drivers/net/ethernet/chelsio/cxgb3/cxgb3_offload.c

1100

te = lookup_tid(ti, tid);

drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c

3729

struct udp_tunnel_info *ti)

drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c

3736

switch (ti->type) {

drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c

3772

struct udp_tunnel_info *ti)

drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c

3779

switch (ti->type) {

drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c

3781

adapter->vxlan_port = ti->port;

drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c

3783

VXLAN_V(be16_to_cpu(ti->port)) | VXLAN_EN_F);

drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c

3786

adapter->geneve_port = ti->port;

drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c

3788

GENEVE_V(be16_to_cpu(ti->port)) | GENEVE_EN_F);

drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c

3810

be16_to_cpu(ti->port));

drivers/net/ethernet/cisco/enic/enic_main.c

182

struct udp_tunnel_info *ti)

drivers/net/ethernet/cisco/enic/enic_main.c

191

ntohs(ti->port));

drivers/net/ethernet/cisco/enic/enic_main.c

200

enic->vxlan.vxlan_udp_port_number = ntohs(ti->port);

drivers/net/ethernet/cisco/enic/enic_main.c

209

struct udp_tunnel_info *ti)

drivers/net/ethernet/emulex/benet/be_main.c

3985

unsigned int entry, struct udp_tunnel_info *ti)

drivers/net/ethernet/emulex/benet/be_main.c

3999

status = be_cmd_set_vxlan_port(adapter, ti->port);

drivers/net/ethernet/emulex/benet/be_main.c

4004

adapter->vxlan_port = ti->port;

drivers/net/ethernet/emulex/benet/be_main.c

4011

be16_to_cpu(ti->port));

drivers/net/ethernet/emulex/benet/be_main.c

4016

unsigned int entry, struct udp_tunnel_info *ti)

drivers/net/ethernet/intel/fm10k/fm10k_netdev.c

405

struct udp_tunnel_info ti;

drivers/net/ethernet/intel/fm10k/fm10k_netdev.c

407

udp_tunnel_nic_get_port(dev, table, 0, &ti);

drivers/net/ethernet/intel/fm10k/fm10k_netdev.c

409

interface->vxlan_port = ti.port;

drivers/net/ethernet/intel/fm10k/fm10k_netdev.c

411

interface->geneve_port = ti.port;

drivers/net/ethernet/intel/fm10k/fm10k_pci.c

1759

unsigned int ri = 0, ti = 0;

drivers/net/ethernet/intel/fm10k/fm10k_pci.c

1771

ti++;

drivers/net/ethernet/intel/fm10k/fm10k_pci.c

1777

"%s-tx-%u", dev->name, ti++);

drivers/net/ethernet/intel/i40e/i40e_common.c

5145

u32 ti;

drivers/net/ethernet/intel/i40e/i40e_common.c

5155

ti = le32_to_cpu(filters[i].element.tenant_id);

drivers/net/ethernet/intel/i40e/i40e_common.c

5156

filters[i].element.tenant_id = cpu_to_le32(ti << 8);

drivers/net/ethernet/intel/i40e/i40e_common.c

5238

u32 ti;

drivers/net/ethernet/intel/i40e/i40e_common.c

5248

ti = le32_to_cpu(filters[i].element.tenant_id);

drivers/net/ethernet/intel/i40e/i40e_common.c

5249

filters[i].element.tenant_id = cpu_to_le32(ti << 8);

drivers/net/ethernet/intel/i40e/i40e_main.c

12967

struct udp_tunnel_info *ti)

drivers/net/ethernet/intel/i40e/i40e_main.c

12974

type = ti->type == UDP_TUNNEL_TYPE_VXLAN ? I40E_AQC_TUNNEL_TYPE_VXLAN :

drivers/net/ethernet/intel/i40e/i40e_main.c

12977

ret = i40e_aq_add_udp_tunnel(hw, ntohs(ti->port), type, &filter_index,

drivers/net/ethernet/intel/i40e/i40e_main.c

12991

struct udp_tunnel_info *ti)

drivers/net/ethernet/intel/i40e/i40e_main.c

12997

ret = i40e_aq_del_udp_tunnel(hw, ti->hw_priv, NULL);

drivers/net/ethernet/intel/ice/ice_flex_pipe.c

575

unsigned int idx, struct udp_tunnel_info *ti)

drivers/net/ethernet/intel/ice/ice_flex_pipe.c

582

tnl_type = ti->type == UDP_TUNNEL_TYPE_VXLAN ? TNL_VXLAN : TNL_GENEVE;

drivers/net/ethernet/intel/ice/ice_flex_pipe.c

585

status = ice_create_tunnel(&pf->hw, index, tnl_type, ntohs(ti->port));

drivers/net/ethernet/intel/ice/ice_flex_pipe.c

597

unsigned int idx, struct udp_tunnel_info *ti)

drivers/net/ethernet/intel/ice/ice_flex_pipe.c

603

tnl_type = ti->type == UDP_TUNNEL_TYPE_VXLAN ? TNL_VXLAN : TNL_GENEVE;

drivers/net/ethernet/intel/ice/ice_flex_pipe.c

605

status = ice_destroy_tunnel(&pf->hw, ti->hw_priv, tnl_type,

drivers/net/ethernet/intel/ice/ice_flex_pipe.c

606

ntohs(ti->port));

drivers/net/ethernet/intel/ice/ice_flex_pipe.h

32

unsigned int idx, struct udp_tunnel_info *ti);

drivers/net/ethernet/intel/ice/ice_flex_pipe.h

34

unsigned int idx, struct udp_tunnel_info *ti);

drivers/net/ethernet/intel/ice/ice_parser.c

1327

struct ice_bst_tcam_item *ti = item;

drivers/net/ethernet/intel/ice/ice_parser.c

1331

ti->addr = *(u16 *)buf;

drivers/net/ethernet/intel/ice/ice_parser.c

1334

ti->key[i] = buf[ICE_BT_KEY_IDD + i];

drivers/net/ethernet/intel/ice/ice_parser.c

1335

ti->key_inv[i] = buf[ICE_BT_KIV_IDD + i];

drivers/net/ethernet/intel/ice/ice_parser.c

1337

ti->hit_idx_grp = buf[ICE_BT_HIG_IDD];

drivers/net/ethernet/intel/ice/ice_parser.c

1338

ti->pg_prio = buf[ICE_BT_PGP_IDD] & ICE_BT_PGP_M;

drivers/net/ethernet/intel/ice/ice_parser.c

1340

ice_bst_npkb_init(&ti->np_kb,

drivers/net/ethernet/intel/ice/ice_parser.c

1343

ice_bst_pgkb_init(&ti->pg_kb,

drivers/net/ethernet/intel/ice/ice_parser.c

1347

ice_bst_alu_init(&ti->alu0, &buf[ICE_BT_ALU0_IDD], ICE_BT_ALU0_OFF);

drivers/net/ethernet/intel/ice/ice_parser.c

1348

ice_bst_alu_init(&ti->alu1, &buf[ICE_BT_ALU1_IDD], ICE_BT_ALU1_OFF);

drivers/net/ethernet/intel/ice/ice_parser.c

1349

ice_bst_alu_init(&ti->alu2, &buf[ICE_BT_ALU2_IDD], ICE_BT_ALU2_OFF);

drivers/net/ethernet/intel/ice/ice_parser.c

1352

ice_bst_tcam_dump(hw, ti);

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

3649

unsigned int ri = 0, ti = 0;

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

3659

ti++;

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

3665

"%s-tx-%u", netdev->name, ti++);

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

5452

struct udp_tunnel_info ti;

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

5454

udp_tunnel_nic_get_port(dev, table, 0, &ti);

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

5455

if (ti.type == UDP_TUNNEL_TYPE_VXLAN)

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

5456

adapter->vxlan_port = ti.port;

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

5458

adapter->geneve_port = ti.port;

drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c

1568

unsigned int ri = 0, ti = 0;

drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c

1578

ti++;

drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c

1584

"%s-tx-%u", netdev->name, ti++);

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2642

struct udp_tunnel_info ti;

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2645

udp_tunnel_nic_get_port(dev, table, 0, &ti);

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2646

priv->vxlan_port = ti.port;

drivers/net/ethernet/mellanox/mlx5/core/en_main.c

5442

unsigned int entry, struct udp_tunnel_info *ti)

drivers/net/ethernet/mellanox/mlx5/core/en_main.c

5446

return mlx5_vxlan_add_port(priv->mdev->vxlan, ntohs(ti->port));

drivers/net/ethernet/mellanox/mlx5/core/en_main.c

5450

unsigned int entry, struct udp_tunnel_info *ti)

drivers/net/ethernet/mellanox/mlx5/core/en_main.c

5454

return mlx5_vxlan_del_port(priv->mdev->vxlan, ntohs(ti->port));

drivers/net/ethernet/qlogic/qede/qede_filter.c

961

struct udp_tunnel_info ti;

drivers/net/ethernet/qlogic/qede/qede_filter.c

967

udp_tunnel_nic_get_port(dev, table, 0, &ti);

drivers/net/ethernet/qlogic/qede/qede_filter.c

968

if (ti.type == UDP_TUNNEL_TYPE_VXLAN) {

drivers/net/ethernet/qlogic/qede/qede_filter.c

970

tunn_params.vxlan_port = ntohs(ti.port);

drivers/net/ethernet/qlogic/qede/qede_filter.c

974

tunn_params.geneve_port = ntohs(ti.port);

drivers/net/ethernet/qlogic/qede/qede_filter.c

984

*save_port = ntohs(ti.port);

drivers/net/ethernet/qlogic/qlcnic/qlcnic_main.c

474

struct udp_tunnel_info ti;

drivers/net/ethernet/qlogic/qlcnic/qlcnic_main.c

477

udp_tunnel_nic_get_port(dev, table, 0, &ti);

drivers/net/ethernet/qlogic/qlcnic/qlcnic_main.c

478

if (ti.port) {

drivers/net/ethernet/qlogic/qlcnic/qlcnic_main.c

479

err = qlcnic_set_vxlan_port(adapter, ntohs(ti.port));

drivers/net/ethernet/qlogic/qlcnic/qlcnic_main.c

484

return qlcnic_set_vxlan_parsing(adapter, ntohs(ti.port));

drivers/net/ethernet/sfc/ef10.c

3904

struct udp_tunnel_info *ti)

drivers/net/ethernet/sfc/ef10.c

3910

if (ti->type == UDP_TUNNEL_TYPE_VXLAN)

drivers/net/ethernet/sfc/ef10.c

3926

nic_data->udp_tunnels[entry].port = ti->port;

drivers/net/ethernet/sfc/ef10.c

3964

struct udp_tunnel_info *ti)

drivers/net/ethernet/synopsys/dwc-xlgmac-net.c

257

unsigned int i, ti, ri;

drivers/net/ethernet/synopsys/dwc-xlgmac-net.c

285

ti = XLGMAC_GET_REG_BITS(dma_ch_isr, DMA_CH_SR_TI_POS,

drivers/net/ethernet/synopsys/dwc-xlgmac-net.c

289

if (!pdata->per_channel_irq && (ti || ri)) {

drivers/net/ethernet/wangxun/txgbe/txgbe_main.c

622

struct udp_tunnel_info ti;

drivers/net/ethernet/wangxun/txgbe/txgbe_main.c

624

udp_tunnel_nic_get_port(dev, table, 0, &ti);

drivers/net/ethernet/wangxun/txgbe/txgbe_main.c

625

switch (ti.type) {

drivers/net/ethernet/wangxun/txgbe/txgbe_main.c

627

wr32(wx, TXGBE_CFG_VXLAN, ntohs(ti.port));

drivers/net/ethernet/wangxun/txgbe/txgbe_main.c

630

wr32(wx, TXGBE_CFG_VXLAN_GPE, ntohs(ti.port));

drivers/net/ethernet/wangxun/txgbe/txgbe_main.c

633

wr32(wx, TXGBE_CFG_GENEVE, ntohs(ti.port));

drivers/net/netdevsim/udp_tunnels.c

13

unsigned int entry, struct udp_tunnel_info *ti)

drivers/net/netdevsim/udp_tunnels.c

27

be16_to_cpu(ti->port) << 16 | ti->type;

drivers/net/netdevsim/udp_tunnels.c

32

table, entry, ti->type, ti->sa_family, ntohs(ti->port),

drivers/net/netdevsim/udp_tunnels.c

39

unsigned int entry, struct udp_tunnel_info *ti)

drivers/net/netdevsim/udp_tunnels.c

48

u32 val = be16_to_cpu(ti->port) << 16 | ti->type;

drivers/net/netdevsim/udp_tunnels.c

60

table, entry, ti->type, ti->sa_family, ntohs(ti->port),

drivers/net/netdevsim/udp_tunnels.c

69

struct udp_tunnel_info ti;

drivers/net/netdevsim/udp_tunnels.c

77

udp_tunnel_nic_get_port(dev, table, i, &ti);

drivers/net/netdevsim/udp_tunnels.c

79

be16_to_cpu(ti.port) << 16 | ti.type;

drivers/net/vmxnet3/vmxnet3_defs.h

171

u32 ti:1; /* VLAN Tag Insertion */

drivers/net/vmxnet3/vmxnet3_defs.h

183

u32 ti:1; /* VLAN Tag Insertion */

drivers/net/vmxnet3/vmxnet3_drv.c

1323

gdesc->txd.ti = 1;

drivers/net/vmxnet3/vmxnet3_xdp.c

175

gdesc->txd.ti = 0;

drivers/net/wireless/ath/ath11k/dp_tx.c

116

ti.ring_id = ring_selector % num_tx_rings;

drivers/net/wireless/ath/ath11k/dp_tx.c

117

ti.rbm_id = ab->hw_params.hal_params->tcl2wbm_rbm_map[ti.ring_id].rbm_id;

drivers/net/wireless/ath/ath11k/dp_tx.c

119

ring_map |= BIT(ti.ring_id);

drivers/net/wireless/ath/ath11k/dp_tx.c

121

tx_ring = &dp->tx_ring[ti.ring_id];

drivers/net/wireless/ath/ath11k/dp_tx.c

140

ti.desc_id = FIELD_PREP(DP_TX_DESC_ID_MAC_ID, ar->pdev_idx) |

drivers/net/wireless/ath/ath11k/dp_tx.c

143

ti.encap_type = ath11k_dp_tx_get_encap_type(arvif, skb);

drivers/net/wireless/ath/ath11k/dp_tx.c

148

ti.meta_data_flags = arsta->tcl_metadata;

drivers/net/wireless/ath/ath11k/dp_tx.c

149

ti.flags0 |= FIELD_PREP(HAL_TCL_DATA_CMD_INFO1_TO_FW, 1);

drivers/net/wireless/ath/ath11k/dp_tx.c

151

ti.meta_data_flags = arvif->tcl_metadata;

drivers/net/wireless/ath/ath11k/dp_tx.c

154

if (unlikely(ti.encap_type == HAL_TCL_ENCAP_TYPE_RAW)) {

drivers/net/wireless/ath/ath11k/dp_tx.c

156

ti.encrypt_type =

drivers/net/wireless/ath/ath11k/dp_tx.c

162

ti.encrypt_type = HAL_ENCRYPT_TYPE_OPEN;

drivers/net/wireless/ath/ath11k/dp_tx.c

166

ti.addr_search_flags = arvif->hal_addr_search_flags;

drivers/net/wireless/ath/ath11k/dp_tx.c

167

ti.search_type = arvif->search_type;

drivers/net/wireless/ath/ath11k/dp_tx.c

168

ti.type = HAL_TCL_DESC_TYPE_BUFFER;

drivers/net/wireless/ath/ath11k/dp_tx.c

169

ti.pkt_offset = 0;

drivers/net/wireless/ath/ath11k/dp_tx.c

170

ti.lmac_id = ar->lmac_id;

drivers/net/wireless/ath/ath11k/dp_tx.c

171

ti.bss_ast_hash = arvif->ast_hash;

drivers/net/wireless/ath/ath11k/dp_tx.c

172

ti.bss_ast_idx = arvif->ast_idx;

drivers/net/wireless/ath/ath11k/dp_tx.c

173

ti.dscp_tid_tbl_idx = 0;

drivers/net/wireless/ath/ath11k/dp_tx.c

176

ti.encap_type != HAL_TCL_ENCAP_TYPE_RAW)) {

drivers/net/wireless/ath/ath11k/dp_tx.c

177

ti.flags0 |= FIELD_PREP(HAL_TCL_DATA_CMD_INFO1_IP4_CKSUM_EN, 1) |

drivers/net/wireless/ath/ath11k/dp_tx.c

185

ti.enable_mesh = true;

drivers/net/wireless/ath/ath11k/dp_tx.c

187

ti.flags1 |= FIELD_PREP(HAL_TCL_DATA_CMD_INFO2_TID_OVERWRITE, 1);

drivers/net/wireless/ath/ath11k/dp_tx.c

189

ti.tid = ath11k_dp_tx_get_tid(skb);

drivers/net/wireless/ath/ath11k/dp_tx.c

191

switch (ti.encap_type) {

drivers/net/wireless/ath/ath11k/dp_tx.c

212

ti.paddr = dma_map_single(ab->dev, skb->data, skb->len, DMA_TO_DEVICE);

drivers/net/wireless/ath/ath11k/dp_tx.c

213

if (unlikely(dma_mapping_error(ab->dev, ti.paddr))) {

drivers/net/wireless/ath/ath11k/dp_tx.c

220

ti.data_len = skb->len;

drivers/net/wireless/ath/ath11k/dp_tx.c

221

skb_cb->paddr = ti.paddr;

drivers/net/wireless/ath/ath11k/dp_tx.c

238

ab->soc_stats.tx_err.desc_na[ti.ring_id]++;

drivers/net/wireless/ath/ath11k/dp_tx.c

257

sizeof(struct hal_tlv_hdr), &ti);

drivers/net/wireless/ath/ath11k/dp_tx.c

261

ath11k_dp_shadow_start_timer(ab, tcl_ring, &dp->tx_ring_timer[ti.ring_id]);

drivers/net/wireless/ath/ath11k/dp_tx.c

273

dma_unmap_single(ab->dev, ti.paddr, ti.data_len, DMA_TO_DEVICE);

drivers/net/wireless/ath/ath11k/dp_tx.c

278

FIELD_GET(DP_TX_DESC_ID_MSDU_ID, ti.desc_id));

drivers/net/wireless/ath/ath11k/dp_tx.c

87

struct hal_tx_info ti = {};

drivers/net/wireless/ath/ath11k/hal_tx.c

38

struct hal_tx_info *ti)

drivers/net/wireless/ath/ath11k/hal_tx.c

43

FIELD_PREP(BUFFER_ADDR_INFO0_ADDR, ti->paddr);

drivers/net/wireless/ath/ath11k/hal_tx.c

46

((uint64_t)ti->paddr >> HAL_ADDR_MSB_REG_SHIFT));

drivers/net/wireless/ath/ath11k/hal_tx.c

48

FIELD_PREP(BUFFER_ADDR_INFO1_RET_BUF_MGR, ti->rbm_id) |

drivers/net/wireless/ath/ath11k/hal_tx.c

49

FIELD_PREP(BUFFER_ADDR_INFO1_SW_COOKIE, ti->desc_id);

drivers/net/wireless/ath/ath11k/hal_tx.c

52

FIELD_PREP(HAL_TCL_DATA_CMD_INFO0_DESC_TYPE, ti->type) |

drivers/net/wireless/ath/ath11k/hal_tx.c

53

FIELD_PREP(HAL_TCL_DATA_CMD_INFO0_ENCAP_TYPE, ti->encap_type) |

drivers/net/wireless/ath/ath11k/hal_tx.c

55

ti->encrypt_type) |

drivers/net/wireless/ath/ath11k/hal_tx.c

57

ti->search_type) |

drivers/net/wireless/ath/ath11k/hal_tx.c

59

ti->addr_search_flags) |

drivers/net/wireless/ath/ath11k/hal_tx.c

61

ti->meta_data_flags);

drivers/net/wireless/ath/ath11k/hal_tx.c

63

tcl_cmd->info1 = ti->flags0 |

drivers/net/wireless/ath/ath11k/hal_tx.c

64

FIELD_PREP(HAL_TCL_DATA_CMD_INFO1_DATA_LEN, ti->data_len) |

drivers/net/wireless/ath/ath11k/hal_tx.c

65

FIELD_PREP(HAL_TCL_DATA_CMD_INFO1_PKT_OFFSET, ti->pkt_offset);

drivers/net/wireless/ath/ath11k/hal_tx.c

67

tcl_cmd->info2 = ti->flags1 |

drivers/net/wireless/ath/ath11k/hal_tx.c

68

FIELD_PREP(HAL_TCL_DATA_CMD_INFO2_TID, ti->tid) |

drivers/net/wireless/ath/ath11k/hal_tx.c

69

FIELD_PREP(HAL_TCL_DATA_CMD_INFO2_LMAC_ID, ti->lmac_id);

drivers/net/wireless/ath/ath11k/hal_tx.c

72

ti->dscp_tid_tbl_idx) |

drivers/net/wireless/ath/ath11k/hal_tx.c

74

ti->bss_ast_idx) |

drivers/net/wireless/ath/ath11k/hal_tx.c

76

ti->bss_ast_hash);

drivers/net/wireless/ath/ath11k/hal_tx.c

79

if (ti->enable_mesh)

drivers/net/wireless/ath/ath11k/hal_tx.h

67

struct hal_tx_info *ti);

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

118

ti.ring_id = ring_selector % dp->hw_params->max_tx_ring;

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

120

ring_map |= BIT(ti.ring_id);

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

121

ti.rbm_id = hal->tcl_to_wbm_rbm_map[ti.ring_id].rbm_id;

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

123

tx_ring = &dp->tx_ring[ti.ring_id];

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

131

ti.bank_id = dp_link_vif->bank_id;

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

132

ti.meta_data_flags = dp_link_vif->tcl_metadata;

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

133

ti.bss_ast_hash = dp_link_vif->ast_hash;

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

134

ti.bss_ast_idx = dp_link_vif->ast_idx;

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

137

ti.meta_data_flags = arsta->tcl_metadata;

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

138

ti.bss_ast_hash = arsta->ast_hash & ATH12K_AST_HASH_MASK;

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

139

ti.bss_ast_idx = arsta->ast_idx;

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

140

ti.lookup_override = true;

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

143

ti.meta_data_flags = arsta->tcl_metadata;

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

144

ti.flags0 |= u32_encode_bits(1, HAL_TCL_DATA_CMD_INFO2_TO_FW);

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

150

ti.encrypt_type =

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

156

ti.encrypt_type = HAL_ENCRYPT_TYPE_OPEN;

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

162

if (gsn_valid && !ti.lookup_override) {

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

166

ti.meta_data_flags =

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

175

ti.meta_data_flags |=

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

180

ti.encap_type = ath12k_dp_tx_get_encap_type(ab, skb);

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

181

ti.addr_search_flags = dp_link_vif->hal_addr_search_flags;

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

182

ti.search_type = dp_link_vif->search_type;

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

183

ti.type = HAL_TCL_DESC_TYPE_BUFFER;

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

184

ti.pkt_offset = 0;

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

185

ti.lmac_id = dp_link_vif->lmac_id;

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

187

ti.vdev_id = dp_link_vif->vdev_id;

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

189

if (gsn_valid && !ti.lookup_override)

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

19

struct hal_tx_info *ti)

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

190

ti.vdev_id += HTT_TX_MLO_MCAST_HOST_REINJECT_BASE_VDEV_ID;

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

191

else if (arvif->nawds_enabled && is_mcast && !ti.lookup_override)

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

192

ti.meta_data_flags |=

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

195

ti.dscp_tid_tbl_idx = 0;

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

198

ti.encap_type != HAL_TCL_ENCAP_TYPE_RAW) {

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

199

ti.flags0 |= u32_encode_bits(1, HAL_TCL_DATA_CMD_INFO2_IP4_CKSUM_EN) |

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

206

ti.flags1 |= u32_encode_bits(1, HAL_TCL_DATA_CMD_INFO3_TID_OVERWRITE);

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

208

ti.tid = ath12k_dp_tx_get_tid(skb);

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

21

tcl_ext_cmd->info0 = le32_encode_bits(ti->paddr,

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

210

switch (ti.encap_type) {

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

25

le32_encode_bits(ti->data_len,

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

260

ti.paddr = dma_map_single(dp->dev, skb->data, skb->len, DMA_TO_DEVICE);

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

261

if (dma_mapping_error(dp->dev, ti.paddr)) {

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

284

ti.meta_data_flags |= HTT_TCL_META_DATA_VALID_HTT;

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

286

ti.flags0 |= u32_encode_bits(1, HAL_TCL_DATA_CMD_INFO2_TO_FW);

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

287

ti.encap_type = HAL_TCL_ENCAP_TYPE_RAW;

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

288

ti.encrypt_type = HAL_ENCRYPT_TYPE_OPEN;

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

29

le32_encode_bits(ti->encap_type,

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

293

ti.desc_id = tx_desc->desc_id;

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

294

ti.data_len = skb->len;

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

295

skb_cb->paddr = ti.paddr;

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

308

ath12k_wifi7_hal_tx_cmd_ext_desc_setup(ab, msg, &ti);

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

31

le32_encode_bits(ti->encrypt_type,

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

319

ti.paddr = dma_map_single(dp->dev, skb_ext_desc->data,

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

321

ret = dma_mapping_error(dp->dev, ti.paddr);

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

325

ti.data_len = skb_ext_desc->len;

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

326

ti.type = HAL_TCL_DESC_TYPE_EXT_DESC;

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

328

skb_cb->paddr_ext_desc = ti.paddr;

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

345

dp->device_stats.tx_err.desc_na[ti.ring_id]++;

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

364

arvif->link_stats.tx_encap_type[ti.encap_type]++;

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

365

arvif->link_stats.tx_encrypt_type[ti.encrypt_type]++;

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

366

arvif->link_stats.tx_desc_type[ti.type]++;

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

374

dp->device_stats.tx_enqueued[ti.ring_id]++;

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

376

ath12k_wifi7_hal_tx_cmd_desc_setup(ab, hal_tcl_desc, &ti);

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

398

dma_unmap_single(dp->dev, ti.paddr, ti.data_len, DMA_TO_DEVICE);

drivers/net/wireless/ath/ath12k/wifi7/dp_tx.c

70

struct hal_tx_info ti = {};

drivers/net/wireless/ath/ath12k/wifi7/hal_tx.c

34

struct hal_tx_info *ti)

drivers/net/wireless/ath/ath12k/wifi7/hal_tx.c

37

le32_encode_bits(ti->paddr, BUFFER_ADDR_INFO0_ADDR);

drivers/net/wireless/ath/ath12k/wifi7/hal_tx.c

39

le32_encode_bits(((uint64_t)ti->paddr >> HAL_ADDR_MSB_REG_SHIFT),

drivers/net/wireless/ath/ath12k/wifi7/hal_tx.c

42

le32_encode_bits((ti->rbm_id), BUFFER_ADDR_INFO1_RET_BUF_MGR) |

drivers/net/wireless/ath/ath12k/wifi7/hal_tx.c

43

le32_encode_bits(ti->desc_id, BUFFER_ADDR_INFO1_SW_COOKIE);

drivers/net/wireless/ath/ath12k/wifi7/hal_tx.c

46

le32_encode_bits(ti->type, HAL_TCL_DATA_CMD_INFO0_DESC_TYPE) |

drivers/net/wireless/ath/ath12k/wifi7/hal_tx.c

47

le32_encode_bits(ti->bank_id, HAL_TCL_DATA_CMD_INFO0_BANK_ID);

drivers/net/wireless/ath/ath12k/wifi7/hal_tx.c

50

le32_encode_bits(ti->meta_data_flags,

drivers/net/wireless/ath/ath12k/wifi7/hal_tx.c

53

tcl_cmd->info2 = cpu_to_le32(ti->flags0) |

drivers/net/wireless/ath/ath12k/wifi7/hal_tx.c

54

le32_encode_bits(ti->data_len, HAL_TCL_DATA_CMD_INFO2_DATA_LEN) |

drivers/net/wireless/ath/ath12k/wifi7/hal_tx.c

55

le32_encode_bits(ti->pkt_offset, HAL_TCL_DATA_CMD_INFO2_PKT_OFFSET);

drivers/net/wireless/ath/ath12k/wifi7/hal_tx.c

57

tcl_cmd->info3 = cpu_to_le32(ti->flags1) |

drivers/net/wireless/ath/ath12k/wifi7/hal_tx.c

58

le32_encode_bits(ti->tid, HAL_TCL_DATA_CMD_INFO3_TID) |

drivers/net/wireless/ath/ath12k/wifi7/hal_tx.c

59

le32_encode_bits(ti->lmac_id, HAL_TCL_DATA_CMD_INFO3_PMAC_ID) |

drivers/net/wireless/ath/ath12k/wifi7/hal_tx.c

60

le32_encode_bits(ti->vdev_id, HAL_TCL_DATA_CMD_INFO3_VDEV_ID);

drivers/net/wireless/ath/ath12k/wifi7/hal_tx.c

62

tcl_cmd->info4 = le32_encode_bits(ti->lookup_override,

drivers/net/wireless/ath/ath12k/wifi7/hal_tx.c

64

le32_encode_bits(ti->bss_ast_idx,

drivers/net/wireless/ath/ath12k/wifi7/hal_tx.c

66

le32_encode_bits(ti->bss_ast_hash,

drivers/net/wireless/ath/ath12k/wifi7/hal_tx.h

188

struct hal_tx_info *ti);

drivers/scsi/sr_ioctl.c

117

static int sr_fake_playtrkind(struct cdrom_device_info *cdi, struct cdrom_ti *ti)

drivers/scsi/sr_ioctl.c

130

if (ti->cdti_trk1 == ntracks)

drivers/scsi/sr_ioctl.c

131

ti->cdti_trk1 = CDROM_LEADOUT;

drivers/scsi/sr_ioctl.c

132

else if (ti->cdti_trk1 != CDROM_LEADOUT)

drivers/scsi/sr_ioctl.c

133

ti->cdti_trk1 ++;

drivers/scsi/sr_ioctl.c

135

trk0_te.cdte_track = ti->cdti_trk0;

drivers/scsi/sr_ioctl.c

137

trk1_te.cdte_track = ti->cdti_trk1;

drivers/scsi/sr_ioctl.c

161

struct cdrom_ti *ti)

drivers/scsi/sr_ioctl.c

171

cgc.cmd[4] = ti->cdti_trk0;

drivers/scsi/sr_ioctl.c

172

cgc.cmd[5] = ti->cdti_ind0;

drivers/scsi/sr_ioctl.c

173

cgc.cmd[7] = ti->cdti_trk1;

drivers/scsi/sr_ioctl.c

174

cgc.cmd[8] = ti->cdti_ind1;

drivers/scsi/sr_ioctl.c

179

result = sr_fake_playtrkind(cdi, ti);

drivers/thermal/thermal_core.c

1159

struct thermal_instance *ti;

drivers/thermal/thermal_core.c

1185

list_for_each_entry(ti, &cdev->thermal_instances, cdev_node) {

drivers/thermal/thermal_core.c

1186

if (ti->upper == cdev->max_state)

drivers/thermal/thermal_core.c

1189

if (ti->upper < cdev->max_state) {

drivers/thermal/thermal_core.c

1190

if (ti->upper_no_limit)

drivers/thermal/thermal_core.c

1191

ti->upper = cdev->max_state;

drivers/thermal/thermal_core.c

1196

ti->upper = cdev->max_state;

drivers/thermal/thermal_core.c

1197

if (ti->lower > ti->upper)

drivers/thermal/thermal_core.c

1198

ti->lower = ti->upper;

drivers/thermal/thermal_core.c

1200

if (ti->target == THERMAL_NO_TARGET)

drivers/thermal/thermal_core.c

1203

if (ti->target > ti->upper)

drivers/thermal/thermal_core.c

1204

ti->target = ti->upper;

drivers/thermal/thermal_helpers.c

47

struct thermal_instance *ti;

drivers/thermal/thermal_helpers.c

49

list_for_each_entry(ti, &td->thermal_instances, trip_node) {

drivers/thermal/thermal_helpers.c

50

if (ti->cdev == cdev)

fs/afs/dir.c

777

struct inode *inode = NULL, *ti;

fs/afs/dir.c

848

ti = ilookup5_nowait(dir->i_sb, vp->fid.vnode,

fs/afs/dir.c

850

if (!IS_ERR_OR_NULL(ti)) {

fs/afs/dir.c

851

vnode = AFS_FS_I(ti);

fs/jfs/jfs_dmap.c

1403

int rc, ti, i, k, m, n, agperlev;

fs/jfs/jfs_dmap.c

1477

ti = bmp->db_agstart + bmp->db_agwidth * (agno & (agperlev - 1));

fs/jfs/jfs_dmap.c

1479

if (ti < 0 || ti >= le32_to_cpu(dcp->nleafs)) {

fs/jfs/jfs_dmap.c

1491

for (i = 0; i < bmp->db_agwidth; i++, ti++) {

fs/jfs/jfs_dmap.c

1494

if (l2nb > dcp->stree[ti])

fs/jfs/jfs_dmap.c

1502

for (n = 0, m = (ti << 2) + 1; n < 4; n++) {

fs/jfs/jfs_dmap.c

1504

ti = m + n;

fs/jfs/jfs_dmap.c

1527

((s64) (ti - le32_to_cpu(dcp->leafidx))) << budmin;

fs/jfs/jfs_dmap.c

2564

int rc, leafno, ti;

fs/jfs/jfs_dmap.c

2585

ti = leafno + le32_to_cpu(dcp->leafidx);

fs/jfs/jfs_dmap.c

2590

oldval = dcp->stree[ti];

fs/jfs/jfs_dmap.c

2618

oldval = dcp->stree[ti];

fs/jfs/jfs_dmap.c

2661

if (dcp->stree[ti] == NOFREE)

fs/jfs/jfs_dmap.c

3036

int ti, n = 0, k, x = 0;

fs/jfs/jfs_dmap.c

3052

for (k = le32_to_cpu(tp->dmt_height), ti = 1;

fs/jfs/jfs_dmap.c

3053

k > 0; k--, ti = ((ti + n) << 2) + 1) {

fs/jfs/jfs_dmap.c

3057

for (x = ti, n = 0; n < 4; n++) {

fs/jfs/jfs_dtree.c

179

static void dtTruncateEntry(dtpage_t * p, int ti, struct dt_lock ** dtlock);

fs/jfs/jfs_dtree.c

4081

static void dtTruncateEntry(dtpage_t * p, int ti, struct dt_lock ** dtlock)

fs/jfs/jfs_dtree.c

4093

tsi = stbl[ti];

fs/nilfs2/file.c

51

struct nilfs_transaction_info ti;

fs/nilfs2/file.c

96

ret = nilfs_transaction_begin(inode->i_sb, &ti, 1);

fs/nilfs2/inode.c

1084

struct nilfs_transaction_info ti;

fs/nilfs2/inode.c

1097

nilfs_transaction_begin(inode->i_sb, &ti, 0);

fs/nilfs2/inode.c

800

struct nilfs_transaction_info ti;

fs/nilfs2/inode.c

811

nilfs_transaction_begin(sb, &ti, 0); /* never fails */

fs/nilfs2/inode.c

856

struct nilfs_transaction_info ti;

fs/nilfs2/inode.c

868

nilfs_transaction_begin(sb, &ti, 0); /* never fails */

fs/nilfs2/inode.c

912

struct nilfs_transaction_info ti;

fs/nilfs2/inode.c

921

err = nilfs_transaction_begin(sb, &ti, 0);

fs/nilfs2/inode.c

94

struct nilfs_transaction_info ti;

fs/nilfs2/inode.c

97

err = nilfs_transaction_begin(inode->i_sb, &ti, 1);

fs/nilfs2/ioctl.c

1180

struct nilfs_transaction_info ti;

fs/nilfs2/ioctl.c

1219

nilfs_transaction_begin(inode->i_sb, &ti, 0);

fs/nilfs2/ioctl.c

142

struct nilfs_transaction_info ti;

fs/nilfs2/ioctl.c

151

ret = nilfs_transaction_begin(inode->i_sb, &ti, 0);

fs/nilfs2/ioctl.c

199

struct nilfs_transaction_info ti;

fs/nilfs2/ioctl.c

216

nilfs_transaction_begin(inode->i_sb, &ti, 0);

fs/nilfs2/ioctl.c

251

struct nilfs_transaction_info ti;

fs/nilfs2/ioctl.c

266

nilfs_transaction_begin(inode->i_sb, &ti, 0);

fs/nilfs2/mdt.c

76

struct nilfs_transaction_info ti;

fs/nilfs2/mdt.c

80

nilfs_transaction_begin(sb, &ti, 0);

fs/nilfs2/namei.c

120

struct nilfs_transaction_info ti;

fs/nilfs2/namei.c

123

err = nilfs_transaction_begin(dir->i_sb, &ti, 1);

fs/nilfs2/namei.c

144

struct nilfs_transaction_info ti;

fs/nilfs2/namei.c

153

err = nilfs_transaction_begin(dir->i_sb, &ti, 1);

fs/nilfs2/namei.c

197

struct nilfs_transaction_info ti;

fs/nilfs2/namei.c

200

err = nilfs_transaction_begin(dir->i_sb, &ti, 1);

fs/nilfs2/namei.c

225

struct nilfs_transaction_info ti;

fs/nilfs2/namei.c

228

err = nilfs_transaction_begin(dir->i_sb, &ti, 1);

fs/nilfs2/namei.c

313

struct nilfs_transaction_info ti;

fs/nilfs2/namei.c

316

err = nilfs_transaction_begin(dir->i_sb, &ti, 0);

fs/nilfs2/namei.c

335

struct nilfs_transaction_info ti;

fs/nilfs2/namei.c

338

err = nilfs_transaction_begin(dir->i_sb, &ti, 0);

fs/nilfs2/namei.c

372

struct nilfs_transaction_info ti;

fs/nilfs2/namei.c

379

err = nilfs_transaction_begin(old_dir->i_sb, &ti, 1);

fs/nilfs2/namei.c

92

struct nilfs_transaction_info ti;

fs/nilfs2/namei.c

95

err = nilfs_transaction_begin(dir->i_sb, &ti, 1);

fs/nilfs2/nilfs.h

190

struct nilfs_transaction_info *ti = current->journal_info;

fs/nilfs2/nilfs.h

192

ti->ti_flags |= flag;

fs/nilfs2/nilfs.h

197

struct nilfs_transaction_info *ti = current->journal_info;

fs/nilfs2/nilfs.h

199

if (ti == NULL || ti->ti_magic != NILFS_TI_MAGIC)

fs/nilfs2/nilfs.h

201

return !!(ti->ti_flags & flag);

fs/nilfs2/segment.c

142

struct nilfs_transaction_info *ti)

fs/nilfs2/segment.c

159

if (!ti) {

fs/nilfs2/segment.c

160

ti = kmem_cache_alloc(nilfs_transaction_cachep, GFP_NOFS);

fs/nilfs2/segment.c

161

if (!ti)

fs/nilfs2/segment.c

163

ti->ti_flags = NILFS_TI_DYNAMIC_ALLOC;

fs/nilfs2/segment.c

165

ti->ti_flags = 0;

fs/nilfs2/segment.c

167

ti->ti_count = 0;

fs/nilfs2/segment.c

168

ti->ti_save = save;

fs/nilfs2/segment.c

169

ti->ti_magic = NILFS_TI_MAGIC;

fs/nilfs2/segment.c

170

current->journal_info = ti;

fs/nilfs2/segment.c

200

struct nilfs_transaction_info *ti,

fs/nilfs2/segment.c

204

int ret = nilfs_prepare_segment_lock(sb, ti);

fs/nilfs2/segment.c

2318

struct nilfs_transaction_info *ti;

fs/nilfs2/segment.c

2324

BUG_ON((ti = current->journal_info) && ti->ti_magic == NILFS_TI_MAGIC);

fs/nilfs2/segment.c

235

ti = current->journal_info;

fs/nilfs2/segment.c

2350

struct nilfs_transaction_info ti;

fs/nilfs2/segment.c

2356

nilfs_transaction_lock(sb, &ti, 0);

fs/nilfs2/segment.c

236

current->journal_info = ti->ti_save;

fs/nilfs2/segment.c

237

if (ti->ti_flags & NILFS_TI_DYNAMIC_ALLOC)

fs/nilfs2/segment.c

238

kmem_cache_free(nilfs_transaction_cachep, ti);

fs/nilfs2/segment.c

2513

struct nilfs_transaction_info ti;

fs/nilfs2/segment.c

2521

nilfs_transaction_lock(sb, &ti, 1);

fs/nilfs2/segment.c

258

struct nilfs_transaction_info *ti = current->journal_info;

fs/nilfs2/segment.c

2589

struct nilfs_transaction_info ti;

fs/nilfs2/segment.c

2591

nilfs_transaction_lock(sci->sc_super, &ti, 0);

fs/nilfs2/segment.c

262

BUG_ON(ti == NULL || ti->ti_magic != NILFS_TI_MAGIC);

fs/nilfs2/segment.c

263

ti->ti_flags |= NILFS_TI_COMMIT;

fs/nilfs2/segment.c

264

if (ti->ti_count > 0) {

fs/nilfs2/segment.c

265

ti->ti_count--;

fs/nilfs2/segment.c

266

trace_nilfs2_transaction_transition(sb, ti, ti->ti_count,

fs/nilfs2/segment.c

267

ti->ti_flags, TRACE_NILFS2_TRANSACTION_COMMIT);

fs/nilfs2/segment.c

273

if (ti->ti_flags & NILFS_TI_COMMIT)

fs/nilfs2/segment.c

2765

struct nilfs_transaction_info ti;

fs/nilfs2/segment.c

2767

nilfs_transaction_lock(sci->sc_super, &ti, 0);

fs/nilfs2/segment.c

279

trace_nilfs2_transaction_transition(sb, ti, ti->ti_count,

fs/nilfs2/segment.c

280

ti->ti_flags, TRACE_NILFS2_TRANSACTION_COMMIT);

fs/nilfs2/segment.c

282

current->journal_info = ti->ti_save;

fs/nilfs2/segment.c

284

if (ti->ti_flags & NILFS_TI_SYNC)

fs/nilfs2/segment.c

286

if (ti->ti_flags & NILFS_TI_DYNAMIC_ALLOC)

fs/nilfs2/segment.c

287

kmem_cache_free(nilfs_transaction_cachep, ti);

fs/nilfs2/segment.c

294

struct nilfs_transaction_info *ti = current->journal_info;

fs/nilfs2/segment.c

297

BUG_ON(ti == NULL || ti->ti_magic != NILFS_TI_MAGIC);

fs/nilfs2/segment.c

298

if (ti->ti_count > 0) {

fs/nilfs2/segment.c

299

ti->ti_count--;

fs/nilfs2/segment.c

300

trace_nilfs2_transaction_transition(sb, ti, ti->ti_count,

fs/nilfs2/segment.c

301

ti->ti_flags, TRACE_NILFS2_TRANSACTION_ABORT);

fs/nilfs2/segment.c

306

trace_nilfs2_transaction_transition(sb, ti, ti->ti_count,

fs/nilfs2/segment.c

307

ti->ti_flags, TRACE_NILFS2_TRANSACTION_ABORT);

fs/nilfs2/segment.c

309

current->journal_info = ti->ti_save;

fs/nilfs2/segment.c

310

if (ti->ti_flags & NILFS_TI_DYNAMIC_ALLOC)

fs/nilfs2/segment.c

311

kmem_cache_free(nilfs_transaction_cachep, ti);

fs/nilfs2/segment.c

329

struct nilfs_transaction_info *ti = current->journal_info;

fs/nilfs2/segment.c

331

ti->ti_flags |= NILFS_TI_WRITER;

fs/nilfs2/segment.c

333

ti->ti_flags &= ~NILFS_TI_WRITER;

fs/nilfs2/segment.c

339

struct nilfs_transaction_info *ti,

fs/nilfs2/segment.c

347

ti->ti_flags = NILFS_TI_WRITER;

fs/nilfs2/segment.c

348

ti->ti_count = 0;

fs/nilfs2/segment.c

349

ti->ti_save = cur_ti;

fs/nilfs2/segment.c

350

ti->ti_magic = NILFS_TI_MAGIC;

fs/nilfs2/segment.c

351

current->journal_info = ti;

fs/nilfs2/segment.c

354

trace_nilfs2_transaction_transition(sb, ti, ti->ti_count,

fs/nilfs2/segment.c

355

ti->ti_flags, TRACE_NILFS2_TRANSACTION_TRYLOCK);

fs/nilfs2/segment.c

367

ti->ti_flags |= NILFS_TI_GC;

fs/nilfs2/segment.c

369

trace_nilfs2_transaction_transition(sb, ti, ti->ti_count,

fs/nilfs2/segment.c

370

ti->ti_flags, TRACE_NILFS2_TRANSACTION_LOCK);

fs/nilfs2/segment.c

375

struct nilfs_transaction_info *ti = current->journal_info;

fs/nilfs2/segment.c

378

BUG_ON(ti == NULL || ti->ti_magic != NILFS_TI_MAGIC);

fs/nilfs2/segment.c

379

BUG_ON(ti->ti_count > 0);

fs/nilfs2/segment.c

382

current->journal_info = ti->ti_save;

fs/nilfs2/segment.c

384

trace_nilfs2_transaction_transition(sb, ti, ti->ti_count,

fs/nilfs2/segment.c

385

ti->ti_flags, TRACE_NILFS2_TRANSACTION_UNLOCK);

fs/tracefs/event_inode.c

288

void eventfs_remount(struct tracefs_inode *ti, bool update_uid, bool update_gid)

fs/tracefs/event_inode.c

290

struct eventfs_inode *ei = ti->private;

fs/tracefs/event_inode.c

296

eventfs_set_attrs(ei, update_uid, ti->vfs_inode.i_uid,

fs/tracefs/event_inode.c

297

update_gid, ti->vfs_inode.i_gid, 0);

fs/tracefs/event_inode.c

324

struct tracefs_inode *ti;

fs/tracefs/event_inode.c

331

ti = get_tracefs(inode);

fs/tracefs/event_inode.c

332

ti->private = ei;

fs/tracefs/event_inode.c

333

ti->flags |= TRACEFS_EVENT_INODE;

fs/tracefs/event_inode.c

522

struct tracefs_inode *ti;

fs/tracefs/event_inode.c

526

ti = get_tracefs(dir);

fs/tracefs/event_inode.c

527

if (WARN_ON_ONCE(!(ti->flags & TRACEFS_EVENT_INODE)))

fs/tracefs/event_inode.c

532

ei = ti->private;

fs/tracefs/event_inode.c

573

struct tracefs_inode *ti;

fs/tracefs/event_inode.c

583

ti = get_tracefs(f_inode);

fs/tracefs/event_inode.c

584

if (!(ti->flags & TRACEFS_EVENT_INODE))

fs/tracefs/event_inode.c

592

ei = READ_ONCE(ti->private);

fs/tracefs/event_inode.c

738

struct tracefs_inode *ti;

fs/tracefs/event_inode.c

780

ti = get_tracefs(inode);

fs/tracefs/event_inode.c

781

ti->flags |= TRACEFS_EVENT_INODE;

fs/tracefs/event_inode.c

782

ti->private = ei;

fs/tracefs/inode.c

101

struct tracefs_inode *ti;

fs/tracefs/inode.c

110

ti = get_tracefs(inode);

fs/tracefs/inode.c

111

ti->flags |= TRACEFS_INSTANCE_INODE;

fs/tracefs/inode.c

112

ti->private = inode;

fs/tracefs/inode.c

155

struct tracefs_inode *ti = get_tracefs(inode);

fs/tracefs/inode.c

156

struct inode *root_inode = ti->private;

fs/tracefs/inode.c

185

if (!(ti->flags & TRACEFS_UID_PERM_SET))

fs/tracefs/inode.c

188

if (!(ti->flags & TRACEFS_GID_PERM_SET))

fs/tracefs/inode.c

215

struct tracefs_inode *ti = get_tracefs(inode);

fs/tracefs/inode.c

218

ti->flags |= TRACEFS_UID_PERM_SET;

fs/tracefs/inode.c

221

ti->flags |= TRACEFS_GID_PERM_SET;

fs/tracefs/inode.c

314

struct tracefs_inode *ti;

fs/tracefs/inode.c

343

list_for_each_entry_rcu(ti, &tracefs_inodes, list) {

fs/tracefs/inode.c

345

ti->flags &= ~TRACEFS_UID_PERM_SET;

fs/tracefs/inode.c

346

ti->vfs_inode.i_uid = fsi->uid;

fs/tracefs/inode.c

350

ti->flags &= ~TRACEFS_GID_PERM_SET;

fs/tracefs/inode.c

351

ti->vfs_inode.i_gid = fsi->gid;

fs/tracefs/inode.c

359

if (ti->flags & TRACEFS_EVENT_INODE)

fs/tracefs/inode.c

360

eventfs_remount(ti, update_uid, update_gid);

fs/tracefs/inode.c

403

struct tracefs_inode *ti = get_tracefs(inode);

fs/tracefs/inode.c

412

ti->flags &= ~TRACEFS_EVENT_INODE;

fs/tracefs/inode.c

42

struct tracefs_inode *ti;

fs/tracefs/inode.c

45

ti = alloc_inode_sb(sb, tracefs_inode_cachep, GFP_KERNEL);

fs/tracefs/inode.c

46

if (!ti)

fs/tracefs/inode.c

50

list_add_rcu(&ti->list, &tracefs_inodes);

fs/tracefs/inode.c

53

return &ti->vfs_inode;

fs/tracefs/inode.c

569

struct tracefs_inode *ti;

fs/tracefs/inode.c

577

ti = get_tracefs(d_inode(parent));

fs/tracefs/inode.c

578

if (ti->flags & TRACEFS_INSTANCE_INODE)

fs/tracefs/inode.c

58

struct tracefs_inode *ti = get_tracefs(inode);

fs/tracefs/inode.c

60

kmem_cache_free(tracefs_inode_cachep, ti);

fs/tracefs/inode.c

616

struct tracefs_inode *ti;

fs/tracefs/inode.c

635

ti = get_tracefs(inode);

fs/tracefs/inode.c

636

ti->private = instance_inode(parent, inode);

fs/tracefs/inode.c

65

struct tracefs_inode *ti = get_tracefs(inode);

fs/tracefs/inode.c

653

struct tracefs_inode *ti;

fs/tracefs/inode.c

671

ti = get_tracefs(inode);

fs/tracefs/inode.c

672

ti->private = instance_inode(parent, inode);

fs/tracefs/inode.c

69

list_del_rcu(&ti->list);

fs/tracefs/inode.c

778

struct tracefs_inode *ti = (struct tracefs_inode *) foo;

fs/tracefs/inode.c

781

inode_init_once(&ti->vfs_inode);

fs/tracefs/inode.c

784

memset_after(ti, 0, vfs_inode);

fs/tracefs/internal.h

76

void eventfs_remount(struct tracefs_inode *ti, bool update_uid, bool update_gid);

fs/unicode/mkutf8data.c

2452

unsigned int ti = si % tc;

fs/unicode/mkutf8data.c

2457

if (ti)

fs/unicode/mkutf8data.c

2458

mapping[i++] = tb + ti;

fs/unicode/mkutf8data.c

2667

unsigned int ti;

fs/unicode/mkutf8data.c

2674

ti = si % TC;

fs/unicode/mkutf8data.c

2689

if (ti)

fs/unicode/mkutf8data.c

2690

h += utf8encode((char *)h, ti + TB);

fs/unicode/utf8-norm.c

263

unsigned int ti;

fs/unicode/utf8-norm.c

270

ti = si % TC;

fs/unicode/utf8-norm.c

285

if (ti)

fs/unicode/utf8-norm.c

286

h += utf8encode3((char *)h, ti + TB);

fs/xfs/scrub/tempexch.h

15

xfs_fileoff_t off, xfs_filblks_t len, struct xrep_tempexch *ti);

fs/xfs/scrub/tempexch.h

17

struct xrep_tempexch *ti);

fs/xfs/scrub/tempexch.h

19

int xrep_tempexch_contents(struct xfs_scrub *sc, struct xrep_tempexch *ti);

include/linux/device-mapper.h

101

typedef int (*dm_prepare_ioctl_fn) (struct dm_target *ti, struct block_device **bdev,

include/linux/device-mapper.h

106

typedef int (*dm_report_zones_fn) (struct dm_target *ti,

include/linux/device-mapper.h

128

typedef int (*iterate_devices_callout_fn) (struct dm_target *ti,

include/linux/device-mapper.h

138

typedef int (*dm_iterate_devices_fn) (struct dm_target *ti,

include/linux/device-mapper.h

142

typedef void (*dm_io_hints_fn) (struct dm_target *ti,

include/linux/device-mapper.h

150

typedef int (*dm_busy_fn) (struct dm_target *ti);

include/linux/device-mapper.h

157

typedef long (*dm_dax_direct_access_fn) (struct dm_target *ti, pgoff_t pgoff,

include/linux/device-mapper.h

160

typedef int (*dm_dax_zero_page_range_fn)(struct dm_target *ti, pgoff_t pgoff,

include/linux/device-mapper.h

168

typedef size_t (*dm_dax_recovery_write_fn)(struct dm_target *ti, pgoff_t pgoff,

include/linux/device-mapper.h

185

int dm_get_device(struct dm_target *ti, const char *path, blk_mode_t mode,

include/linux/device-mapper.h

187

void dm_put_device(struct dm_target *ti, struct dm_dev *d);

include/linux/device-mapper.h

53

typedef void (*dm_dtr_fn) (struct dm_target *ti);

include/linux/device-mapper.h

532

int dm_suspended(struct dm_target *ti);

include/linux/device-mapper.h

533

int dm_post_suspending(struct dm_target *ti);

include/linux/device-mapper.h

534

int dm_noflush_suspending(struct dm_target *ti);

include/linux/device-mapper.h

613

int __must_check dm_set_target_max_io_len(struct dm_target *ti, sector_t len);

include/linux/device-mapper.h

62

typedef int (*dm_map_fn) (struct dm_target *ti, struct bio *bio);

include/linux/device-mapper.h

63

typedef int (*dm_clone_and_map_request_fn) (struct dm_target *ti,

include/linux/device-mapper.h

746

#define dm_target_offset(ti, sector) ((sector) - (ti)->begin)

include/linux/device-mapper.h

78

typedef int (*dm_endio_fn) (struct dm_target *ti,

include/linux/device-mapper.h

80

typedef int (*dm_request_endio_fn) (struct dm_target *ti,

include/linux/device-mapper.h

84

typedef void (*dm_presuspend_fn) (struct dm_target *ti);

include/linux/device-mapper.h

85

typedef void (*dm_presuspend_undo_fn) (struct dm_target *ti);

include/linux/device-mapper.h

86

typedef void (*dm_postsuspend_fn) (struct dm_target *ti);

include/linux/device-mapper.h

87

typedef int (*dm_preresume_fn) (struct dm_target *ti);

include/linux/device-mapper.h

88

typedef void (*dm_resume_fn) (struct dm_target *ti);

include/linux/device-mapper.h

90

typedef void (*dm_status_fn) (struct dm_target *ti, status_type_t status_type,

include/linux/device-mapper.h

93

typedef int (*dm_message_fn) (struct dm_target *ti, unsigned int argc, char **argv,

include/linux/dm-dirty-log.h

141

struct dm_target *ti,

include/linux/dm-dirty-log.h

142

int (*flush_callback_fn)(struct dm_target *ti),

include/linux/dm-dirty-log.h

25

int (*flush_callback_fn)(struct dm_target *ti);

include/linux/dm-dirty-log.h

36

int (*ctr)(struct dm_dirty_log *log, struct dm_target *ti,

include/linux/thread_info.h

102

static inline void set_ti_thread_flag(struct thread_info *ti, int flag)

include/linux/thread_info.h

104

set_bit(flag, (unsigned long *)&ti->flags);

include/linux/thread_info.h

107

static inline void clear_ti_thread_flag(struct thread_info *ti, int flag)

include/linux/thread_info.h

109

clear_bit(flag, (unsigned long *)&ti->flags);

include/linux/thread_info.h

112

static inline void update_ti_thread_flag(struct thread_info *ti, int flag,

include/linux/thread_info.h

116

set_ti_thread_flag(ti, flag);

include/linux/thread_info.h

118

clear_ti_thread_flag(ti, flag);

include/linux/thread_info.h

121

static inline int test_and_set_ti_thread_flag(struct thread_info *ti, int flag)

include/linux/thread_info.h

123

return test_and_set_bit(flag, (unsigned long *)&ti->flags);

include/linux/thread_info.h

126

static inline int test_and_clear_ti_thread_flag(struct thread_info *ti, int flag)

include/linux/thread_info.h

128

return test_and_clear_bit(flag, (unsigned long *)&ti->flags);

include/linux/thread_info.h

131

static inline int test_ti_thread_flag(struct thread_info *ti, int flag)

include/linux/thread_info.h

133

return test_bit(flag, (unsigned long *)&ti->flags);

include/linux/thread_info.h

140

static __always_inline unsigned long read_ti_thread_flags(struct thread_info *ti)

include/linux/thread_info.h

142

return READ_ONCE(ti->flags);

include/net/udp_tunnel.h

301

struct udp_tunnel_info *ti);

include/net/udp_tunnel.h

304

struct udp_tunnel_info *ti);

include/net/udp_tunnel.h

331

unsigned int idx, struct udp_tunnel_info *ti);

include/net/udp_tunnel.h

334

void (*add_port)(struct net_device *dev, struct udp_tunnel_info *ti);

include/net/udp_tunnel.h

335

void (*del_port)(struct net_device *dev, struct udp_tunnel_info *ti);

include/net/udp_tunnel.h

354

unsigned int idx, struct udp_tunnel_info *ti)

include/net/udp_tunnel.h

362

memset(ti, 0, sizeof(*ti));

include/net/udp_tunnel.h

365

udp_tunnel_nic_ops->get_port(dev, table, idx, ti);

include/net/udp_tunnel.h

397

udp_tunnel_nic_add_port(struct net_device *dev, struct udp_tunnel_info *ti)

include/net/udp_tunnel.h

402

udp_tunnel_nic_ops->add_port(dev, ti);

include/net/udp_tunnel.h

406

udp_tunnel_nic_del_port(struct net_device *dev, struct udp_tunnel_info *ti)

include/net/udp_tunnel.h

411

udp_tunnel_nic_ops->del_port(dev, ti);

include/sound/timer.h

88

void (*private_free) (struct snd_timer_instance *ti);

include/trace/events/nilfs2.h

68

struct nilfs_transaction_info *ti,

include/trace/events/nilfs2.h

73

TP_ARGS(sb, ti, count, flags, state),

include/trace/events/nilfs2.h

77

__field(void *, ti)

include/trace/events/nilfs2.h

85

__entry->ti = ti;

include/trace/events/nilfs2.h

93

__entry->ti,

kernel/bpf/liveness.c

1703

int ti;

kernel/bpf/liveness.c

1708

ti = target - start;

kernel/bpf/liveness.c

1712

&at_in[ti][r], at_out[r]);

kernel/bpf/liveness.c

1716

&at_stack_in[ti][r], at_stack_out[r]);

kernel/locking/mutex.h

74

# define debug_mutex_add_waiter(lock, waiter, ti) do { } while (0)

kernel/locking/mutex.h

75

# define debug_mutex_remove_waiter(lock, waiter, ti) do { } while (0)

kernel/sched/core.c

1052

static inline bool set_nr_and_not_polling(struct thread_info *ti, int tif)

kernel/sched/core.c

1054

return !(fetch_or(&ti->flags, 1 << tif) & _TIF_POLLING_NRFLAG);

kernel/sched/core.c

1065

struct thread_info *ti = task_thread_info(p);

kernel/sched/core.c

1066

typeof(ti->flags) val = READ_ONCE(ti->flags);

kernel/sched/core.c

1073

} while (!try_cmpxchg(&ti->flags, &val, val | _TIF_NEED_RESCHED));

kernel/sched/core.c

1079

static inline bool set_nr_and_not_polling(struct thread_info *ti, int tif)

kernel/sched/core.c

1081

set_ti_thread_flag(ti, tif);

lib/lzo/lzo1x_compress.c

125

ii -= ti;

lib/lzo/lzo1x_compress.c

126

ti = 0;

lib/lzo/lzo1x_compress.c

328

*tp = in_end - (ii - ti);

lib/lzo/lzo1x_compress.c

44

size_t ti = *tp;

lib/lzo/lzo1x_compress.c

49

ip += ti < 4 ? 4 - ti : 0;

mm/damon/core.c

1987

unsigned int ti = 0; /* target's index */

mm/damon/core.c

2002

trace_damon_aggregated(ti, r, damon_nr_regions(t));

mm/damon/core.c

2003

trace_damon_region_aggregated(ti, r,

mm/damon/core.c

2012

ti++;

mm/damon/core.c

2194

struct damon_target *ti;

mm/damon/core.c

2200

damon_for_each_target(ti, ctx) {

mm/damon/core.c

2201

if (ti == t)

mm/damon/vaddr.c

194

struct damon_target *ti;

mm/damon/vaddr.c

199

damon_for_each_target(ti, ctx) {

mm/damon/vaddr.c

200

if (ti == t)

net/ipv4/udp_tunnel_core.c

103

struct udp_tunnel_info ti;

net/ipv4/udp_tunnel_core.c

105

ti.type = type;

net/ipv4/udp_tunnel_core.c

106

ti.sa_family = sk->sk_family;

net/ipv4/udp_tunnel_core.c

107

ti.port = inet_sk(sk)->inet_sport;

net/ipv4/udp_tunnel_core.c

109

udp_tunnel_nic_add_port(dev, &ti);

net/ipv4/udp_tunnel_core.c

116

struct udp_tunnel_info ti;

net/ipv4/udp_tunnel_core.c

118

ti.type = type;

net/ipv4/udp_tunnel_core.c

119

ti.sa_family = sk->sk_family;

net/ipv4/udp_tunnel_core.c

120

ti.port = inet_sk(sk)->inet_sport;

net/ipv4/udp_tunnel_core.c

122

udp_tunnel_nic_del_port(dev, &ti);

net/ipv4/udp_tunnel_core.c

130

struct udp_tunnel_info ti;

net/ipv4/udp_tunnel_core.c

135

ti.type = type;

net/ipv4/udp_tunnel_core.c

136

ti.sa_family = sk->sk_family;

net/ipv4/udp_tunnel_core.c

137

ti.port = inet_sk(sk)->inet_sport;

net/ipv4/udp_tunnel_core.c

141

udp_tunnel_nic_add_port(dev, &ti);

net/ipv4/udp_tunnel_core.c

151

struct udp_tunnel_info ti;

net/ipv4/udp_tunnel_core.c

156

ti.type = type;

net/ipv4/udp_tunnel_core.c

157

ti.sa_family = sk->sk_family;

net/ipv4/udp_tunnel_core.c

158

ti.port = inet_sk(sk)->inet_sport;

net/ipv4/udp_tunnel_core.c

162

udp_tunnel_nic_del_port(dev, &ti);

net/ipv4/udp_tunnel_nic.c

124

struct udp_tunnel_info *ti)

net/ipv4/udp_tunnel_nic.c

126

memset(ti, 0, sizeof(*ti));

net/ipv4/udp_tunnel_nic.c

127

ti->port = entry->port;

net/ipv4/udp_tunnel_nic.c

128

ti->type = entry->type;

net/ipv4/udp_tunnel_nic.c

129

ti->hw_priv = entry->hw_priv;

net/ipv4/udp_tunnel_nic.c

169

unsigned int idx, struct udp_tunnel_info *ti)

net/ipv4/udp_tunnel_nic.c

178

udp_tunnel_nic_ti_from_entry(entry, ti);

net/ipv4/udp_tunnel_nic.c

217

struct udp_tunnel_info ti;

net/ipv4/udp_tunnel_nic.c

224

udp_tunnel_nic_ti_from_entry(entry, &ti);

net/ipv4/udp_tunnel_nic.c

226

err = dev->udp_tunnel_nic_info->set_port(dev, table, idx, &ti);

net/ipv4/udp_tunnel_nic.c

229

&ti);

net/ipv4/udp_tunnel_nic.c

313

struct udp_tunnel_info *ti)

net/ipv4/udp_tunnel_nic.c

315

return table->tunnel_types & ti->type;

net/ipv4/udp_tunnel_nic.c

320

struct udp_tunnel_info *ti)

net/ipv4/udp_tunnel_nic.c

327

ti->sa_family != AF_INET)

net/ipv4/udp_tunnel_nic.c

331

if (udp_tunnel_nic_table_is_capable(&info->tables[i], ti))

net/ipv4/udp_tunnel_nic.c

338

struct udp_tunnel_info *ti)

net/ipv4/udp_tunnel_nic.c

349

entry->port == ti->port &&

net/ipv4/udp_tunnel_nic.c

350

entry->type != ti->type) {

net/ipv4/udp_tunnel_nic.c

399

struct udp_tunnel_info *ti, int use_cnt_adj)

net/ipv4/udp_tunnel_nic.c

404

entry->port != ti->port ||

net/ipv4/udp_tunnel_nic.c

405

entry->type != ti->type)

net/ipv4/udp_tunnel_nic.c

422

struct udp_tunnel_info *ti, int use_cnt_adj)

net/ipv4/udp_tunnel_nic.c

429

if (!udp_tunnel_nic_table_is_capable(table, ti))

net/ipv4/udp_tunnel_nic.c

433

if (udp_tunnel_nic_entry_try_adj(utn, i, j, ti,

net/ipv4/udp_tunnel_nic.c

443

struct udp_tunnel_info *ti)

net/ipv4/udp_tunnel_nic.c

445

return udp_tunnel_nic_try_existing(dev, utn, ti, +1);

net/ipv4/udp_tunnel_nic.c

450

struct udp_tunnel_info *ti)

net/ipv4/udp_tunnel_nic.c

452

return udp_tunnel_nic_try_existing(dev, utn, ti, -1);

net/ipv4/udp_tunnel_nic.c

457

struct udp_tunnel_info *ti)

net/ipv4/udp_tunnel_nic.c

464

if (!udp_tunnel_nic_table_is_capable(table, ti))

net/ipv4/udp_tunnel_nic.c

474

entry->port = ti->port;

net/ipv4/udp_tunnel_nic.c

475

entry->type = ti->type;

net/ipv4/udp_tunnel_nic.c

493

__udp_tunnel_nic_add_port(struct net_device *dev, struct udp_tunnel_info *ti)

net/ipv4/udp_tunnel_nic.c

504

ti->port == htons(IANA_VXLAN_UDP_PORT)) {

net/ipv4/udp_tunnel_nic.c

505

if (ti->type != UDP_TUNNEL_TYPE_VXLAN)

net/ipv4/udp_tunnel_nic.c

510

if (!udp_tunnel_nic_is_capable(dev, utn, ti))

net/ipv4/udp_tunnel_nic.c

517

if (udp_tunnel_nic_has_collision(dev, utn, ti))

net/ipv4/udp_tunnel_nic.c

520

if (!udp_tunnel_nic_add_existing(dev, utn, ti))

net/ipv4/udp_tunnel_nic.c

521

udp_tunnel_nic_add_new(dev, utn, ti);

net/ipv4/udp_tunnel_nic.c

527

__udp_tunnel_nic_del_port(struct net_device *dev, struct udp_tunnel_info *ti)

net/ipv4/udp_tunnel_nic.c

535

if (!udp_tunnel_nic_is_capable(dev, utn, ti))

net/ipv4/udp_tunnel_nic.c

538

udp_tunnel_nic_del_existing(dev, utn, ti);

net/mac80211/mlme.c

3131

const struct ieee80211_tbtt_info_ge_11 *ti;

net/mac80211/mlme.c

3139

if (tbtt_info_len < sizeof(*ti))

net/mac80211/mlme.c

3142

ti = (const void *)tbtt_info;

net/mac80211/mlme.c

3144

if (ti->mld_params.mld_id != data->mld_id)

net/mac80211/mlme.c

3147

link_id = le16_get_bits(ti->mld_params.params,

net/mac80211/mlme.c

3525

const struct ieee80211_tbtt_info_ge_11 *ti;

net/mac80211/mlme.c

3532

if (tbtt_info_len < sizeof(*ti))

net/mac80211/mlme.c

3535

ti = (const void *)tbtt_info;

net/mac80211/mlme.c

3537

if (ti->mld_params.mld_id != data->mld_id)

net/mac80211/mlme.c

3540

link_id = le16_get_bits(ti->mld_params.params,

net/mac80211/mlme.c

3543

le16_get_bits(ti->mld_params.params,

net/netfilter/ipvs/ip_vs_sync.c

1741

struct ip_vs_sync_thread_data *ti = NULL, *tinfo;

net/netfilter/ipvs/ip_vs_sync.c

1866

ti = kzalloc_objs(struct ip_vs_sync_thread_data, count);

net/netfilter/ipvs/ip_vs_sync.c

1867

if (!ti)

net/netfilter/ipvs/ip_vs_sync.c

1871

tinfo = &ti[id];

net/netfilter/ipvs/ip_vs_sync.c

1899

ipvs->master_tinfo = ti;

net/netfilter/ipvs/ip_vs_sync.c

1901

ipvs->backup_tinfo = ti;

net/netfilter/ipvs/ip_vs_sync.c

1917

if (ti) {

net/netfilter/ipvs/ip_vs_sync.c

1918

for (tinfo = ti + id; tinfo >= ti; tinfo--) {

net/netfilter/ipvs/ip_vs_sync.c

1930

if (ti) {

net/netfilter/ipvs/ip_vs_sync.c

1931

for (tinfo = ti + id; tinfo >= ti; tinfo--) {

net/netfilter/ipvs/ip_vs_sync.c

1936

kfree(ti);

net/netfilter/ipvs/ip_vs_sync.c

1956

struct ip_vs_sync_thread_data *ti, *tinfo;

net/netfilter/ipvs/ip_vs_sync.c

1967

ti = ipvs->master_tinfo;

net/netfilter/ipvs/ip_vs_sync.c

1986

tinfo = &ti[id];

net/netfilter/ipvs/ip_vs_sync.c

2001

ti = ipvs->backup_tinfo;

net/netfilter/ipvs/ip_vs_sync.c

2008

tinfo = &ti[id];

net/netfilter/ipvs/ip_vs_sync.c

2023

for (tinfo = ti + id; tinfo >= ti; tinfo--) {

net/netfilter/ipvs/ip_vs_sync.c

2028

kfree(ti);

net/openvswitch/datapath.c

1491

struct table_instance *ti;

net/openvswitch/datapath.c

1509

ti = rcu_dereference(dp->table.ti);

net/openvswitch/datapath.c

1516

flow = ovs_flow_tbl_dump_next(ti, &bucket, &obj);

net/openvswitch/datapath.c

1950

table_instance_flow_flush(table, ovsl_dereference(table->ti),

net/openvswitch/flow_table.c

1036

struct table_instance *ti;

net/openvswitch/flow_table.c

1039

ti = ovsl_dereference(table->ti);

net/openvswitch/flow_table.c

1040

table_instance_insert(ti, flow);

net/openvswitch/flow_table.c

1044

if (table->count > ti->n_buckets)

net/openvswitch/flow_table.c

1045

new_ti = table_instance_expand(ti, false);

net/openvswitch/flow_table.c

1047

new_ti = table_instance_rehash(ti, ti->n_buckets, false);

net/openvswitch/flow_table.c

1050

rcu_assign_pointer(table->ti, new_ti);

net/openvswitch/flow_table.c

1051

call_rcu(&ti->rcu, flow_tbl_destroy_rcu_cb);

net/openvswitch/flow_table.c

1059

struct table_instance *ti;

net/openvswitch/flow_table.c

1062

ti = ovsl_dereference(table->ufid_ti);

net/openvswitch/flow_table.c

1063

ufid_table_instance_insert(ti, flow);

net/openvswitch/flow_table.c

1067

if (table->ufid_count > ti->n_buckets) {

net/openvswitch/flow_table.c

1070

new_ti = table_instance_expand(ti, true);

net/openvswitch/flow_table.c

1073

call_rcu(&ti->rcu, flow_tbl_destroy_rcu_cb);

net/openvswitch/flow_table.c

145

static void __table_instance_destroy(struct table_instance *ti)

net/openvswitch/flow_table.c

147

kvfree(ti->buckets);

net/openvswitch/flow_table.c

148

kfree(ti);

net/openvswitch/flow_table.c

153

struct table_instance *ti = kmalloc_obj(*ti);

net/openvswitch/flow_table.c

156

if (!ti)

net/openvswitch/flow_table.c

159

ti->buckets = kvmalloc_objs(struct hlist_head, new_size);

net/openvswitch/flow_table.c

160

if (!ti->buckets) {

net/openvswitch/flow_table.c

161

kfree(ti);

net/openvswitch/flow_table.c

166

INIT_HLIST_HEAD(&ti->buckets[i]);

net/openvswitch/flow_table.c

168

ti->n_buckets = new_size;

net/openvswitch/flow_table.c

169

ti->node_ver = 0;

net/openvswitch/flow_table.c

170

ti->hash_seed = get_random_u32();

net/openvswitch/flow_table.c

172

return ti;

net/openvswitch/flow_table.c

411

struct table_instance *ti, *ufid_ti;

net/openvswitch/flow_table.c

423

ti = table_instance_alloc(TBL_MIN_BUCKETS);

net/openvswitch/flow_table.c

424

if (!ti)

net/openvswitch/flow_table.c

431

rcu_assign_pointer(table->ti, ti);

net/openvswitch/flow_table.c

441

__table_instance_destroy(ti);

net/openvswitch/flow_table.c

451

struct table_instance *ti;

net/openvswitch/flow_table.c

453

ti = container_of(rcu, struct table_instance, rcu);

net/openvswitch/flow_table.c

454

__table_instance_destroy(ti);

net/openvswitch/flow_table.c

458

struct table_instance *ti,

net/openvswitch/flow_table.c

462

hlist_del_rcu(&flow->flow_table.node[ti->node_ver]);

net/openvswitch/flow_table.c

475

struct table_instance *ti,

net/openvswitch/flow_table.c

480

for (i = 0; i < ti->n_buckets; i++) {

net/openvswitch/flow_table.c

481

struct hlist_head *head = &ti->buckets[i];

net/openvswitch/flow_table.c

486

flow_table.node[ti->node_ver]) {

net/openvswitch/flow_table.c

488

table_instance_flow_free(table, ti, ufid_ti,

net/openvswitch/flow_table.c

501

static void table_instance_destroy(struct table_instance *ti,

net/openvswitch/flow_table.c

504

call_rcu(&ti->rcu, flow_tbl_destroy_rcu_cb);

net/openvswitch/flow_table.c

513

struct table_instance *ti = rcu_dereference_raw(table->ti);

net/openvswitch/flow_table.c

520

table_instance_destroy(ti, ufid_ti);

net/openvswitch/flow_table.c

523

struct sw_flow *ovs_flow_tbl_dump_next(struct table_instance *ti,

net/openvswitch/flow_table.c

531

ver = ti->node_ver;

net/openvswitch/flow_table.c

532

while (*bucket < ti->n_buckets) {

net/openvswitch/flow_table.c

534

head = &ti->buckets[*bucket];

net/openvswitch/flow_table.c

550

static struct hlist_head *find_bucket(struct table_instance *ti, u32 hash)

net/openvswitch/flow_table.c

552

hash = jhash_1word(hash, ti->hash_seed);

net/openvswitch/flow_table.c

553

return &ti->buckets[hash & (ti->n_buckets - 1)];

net/openvswitch/flow_table.c

556

static void table_instance_insert(struct table_instance *ti,

net/openvswitch/flow_table.c

561

head = find_bucket(ti, flow->flow_table.hash);

net/openvswitch/flow_table.c

562

hlist_add_head_rcu(&flow->flow_table.node[ti->node_ver], head);

net/openvswitch/flow_table.c

565

static void ufid_table_instance_insert(struct table_instance *ti,

net/openvswitch/flow_table.c

570

head = find_bucket(ti, flow->ufid_table.hash);

net/openvswitch/flow_table.c

571

hlist_add_head_rcu(&flow->ufid_table.node[ti->node_ver], head);

net/openvswitch/flow_table.c

601

static struct table_instance *table_instance_rehash(struct table_instance *ti,

net/openvswitch/flow_table.c

610

flow_table_copy_flows(ti, new_ti, ufid);

net/openvswitch/flow_table.c

627

old_ti = ovsl_dereference(flow_table->ti);

net/openvswitch/flow_table.c

630

rcu_assign_pointer(flow_table->ti, new_ti);

net/openvswitch/flow_table.c

696

static struct sw_flow *masked_flow_lookup(struct table_instance *ti,

net/openvswitch/flow_table.c

708

head = find_bucket(ti, hash);

net/openvswitch/flow_table.c

711

hlist_for_each_entry_rcu(flow, head, flow_table.node[ti->node_ver],

net/openvswitch/flow_table.c

726

struct table_instance *ti,

net/openvswitch/flow_table.c

741

flow = masked_flow_lookup(ti, key, mask, n_mask_hit);

net/openvswitch/flow_table.c

761

flow = masked_flow_lookup(ti, key, mask, n_mask_hit);

net/openvswitch/flow_table.c

789

struct table_instance *ti = rcu_dereference(tbl->ti);

net/openvswitch/flow_table.c

801

return flow_lookup(tbl, ti, ma, key, n_mask_hit, &cache,

net/openvswitch/flow_table.c

822

flow = flow_lookup(tbl, ti, ma, key, n_mask_hit,

net/openvswitch/flow_table.c

836

flow = flow_lookup(tbl, ti, ma, key, n_mask_hit, n_cache_hit,

net/openvswitch/flow_table.c

848

struct table_instance *ti = rcu_dereference_ovsl(tbl->ti);

net/openvswitch/flow_table.c

860

flow = flow_lookup(tbl, ti, ma, key, &n_mask_hit, &n_cache_hit, &index);

net/openvswitch/flow_table.c

873

struct table_instance *ti = rcu_dereference_ovsl(tbl->ti);

net/openvswitch/flow_table.c

882

flow = masked_flow_lookup(ti, match->key, mask, &n_mask_hit);

net/openvswitch/flow_table.c

918

struct table_instance *ti = rcu_dereference_ovsl(tbl->ufid_ti);

net/openvswitch/flow_table.c

924

head = find_bucket(ti, hash);

net/openvswitch/flow_table.c

925

hlist_for_each_entry_rcu(flow, head, ufid_table.node[ti->node_ver],

net/openvswitch/flow_table.c

947

static struct table_instance *table_instance_expand(struct table_instance *ti,

net/openvswitch/flow_table.c

950

return table_instance_rehash(ti, ti->n_buckets * 2, ufid);

net/openvswitch/flow_table.c

956

struct table_instance *ti = ovsl_dereference(table->ti);

net/openvswitch/flow_table.c

960

table_instance_flow_free(table, ti, ufid_ti, flow);

net/openvswitch/flow_table.h

112

struct table_instance *ti,

net/openvswitch/flow_table.h

63

struct table_instance __rcu *ti;

net/openvswitch/meter.c

107

if (rcu_dereference_ovsl(ti->dp_meters[i]))

net/openvswitch/meter.c

108

new_ti->dp_meters[i] = ti->dp_meters[i];

net/openvswitch/meter.c

110

rcu_assign_pointer(tbl->ti, new_ti);

net/openvswitch/meter.c

111

call_rcu(&ti->rcu, dp_meter_instance_free_rcu);

net/openvswitch/meter.c

116

static void dp_meter_instance_insert(struct dp_meter_instance *ti,

net/openvswitch/meter.c

121

hash = meter_hash(ti, meter->id);

net/openvswitch/meter.c

122

rcu_assign_pointer(ti->dp_meters[hash], meter);

net/openvswitch/meter.c

125

static void dp_meter_instance_remove(struct dp_meter_instance *ti,

net/openvswitch/meter.c

130

hash = meter_hash(ti, meter->id);

net/openvswitch/meter.c

131

RCU_INIT_POINTER(ti->dp_meters[hash], NULL);

net/openvswitch/meter.c

136

struct dp_meter_instance *ti = rcu_dereference_ovsl(tbl->ti);

net/openvswitch/meter.c

137

u32 hash = meter_hash(ti, meter->id);

net/openvswitch/meter.c

143

if (unlikely(rcu_dereference_ovsl(ti->dp_meters[hash])))

net/openvswitch/meter.c

146

dp_meter_instance_insert(ti, meter);

net/openvswitch/meter.c

155

if (tbl->count >= ti->n_meters &&

net/openvswitch/meter.c

156

dp_meter_instance_realloc(tbl, ti->n_meters * 2)) {

net/openvswitch/meter.c

164

dp_meter_instance_remove(ti, meter);

net/openvswitch/meter.c

171

struct dp_meter_instance *ti;

net/openvswitch/meter.c

177

ti = rcu_dereference_ovsl(tbl->ti);

net/openvswitch/meter.c

178

dp_meter_instance_remove(ti, meter);

net/openvswitch/meter.c

183

if (ti->n_meters > DP_METER_ARRAY_SIZE_MIN &&

net/openvswitch/meter.c

184

tbl->count <= (ti->n_meters / 4)) {

net/openvswitch/meter.c

185

int half_size = ti->n_meters / 2;

net/openvswitch/meter.c

192

for (i = half_size; i < ti->n_meters; i++)

net/openvswitch/meter.c

193

if (rcu_dereference_ovsl(ti->dp_meters[i]))

net/openvswitch/meter.c

204

dp_meter_instance_insert(ti, meter);

net/openvswitch/meter.c

40

static u32 meter_hash(struct dp_meter_instance *ti, u32 id)

net/openvswitch/meter.c

42

return id % ti->n_meters;

net/openvswitch/meter.c

57

struct dp_meter_instance *ti = rcu_dereference_ovsl(tbl->ti);

net/openvswitch/meter.c

58

u32 hash = meter_hash(ti, meter_id);

net/openvswitch/meter.c

61

meter = rcu_dereference_ovsl(ti->dp_meters[hash]);

net/openvswitch/meter.c

70

struct dp_meter_instance *ti;

net/openvswitch/meter.c

72

ti = kvzalloc_flex(*ti, dp_meters, size);

net/openvswitch/meter.c

73

if (!ti)

net/openvswitch/meter.c

732

struct dp_meter_instance *ti;

net/openvswitch/meter.c

735

ti = dp_meter_instance_alloc(DP_METER_ARRAY_SIZE_MIN);

net/openvswitch/meter.c

736

if (!ti)

net/openvswitch/meter.c

746

rcu_assign_pointer(tbl->ti, ti);

net/openvswitch/meter.c

752

dp_meter_instance_free(ti);

net/openvswitch/meter.c

759

struct dp_meter_instance *ti = rcu_dereference_raw(tbl->ti);

net/openvswitch/meter.c

76

ti->n_meters = size;

net/openvswitch/meter.c

762

for (i = 0; i < ti->n_meters; i++)

net/openvswitch/meter.c

763

ovs_meter_free(rcu_dereference_raw(ti->dp_meters[i]));

net/openvswitch/meter.c

765

dp_meter_instance_free(ti);

net/openvswitch/meter.c

78

return ti;

net/openvswitch/meter.c

81

static void dp_meter_instance_free(struct dp_meter_instance *ti)

net/openvswitch/meter.c

83

kvfree(ti);

net/openvswitch/meter.c

88

struct dp_meter_instance *ti;

net/openvswitch/meter.c

90

ti = container_of(rcu, struct dp_meter_instance, rcu);

net/openvswitch/meter.c

91

kvfree(ti);

net/openvswitch/meter.c

97

struct dp_meter_instance *ti = rcu_dereference_ovsl(tbl->ti);

net/openvswitch/meter.c

98

int n_meters = min(size, ti->n_meters);

net/openvswitch/meter.h

51

struct dp_meter_instance __rcu *ti;

net/xfrm/xfrm_policy.c

3799

int ti = 0;

net/xfrm/xfrm_policy.c

3811

if (ti + pols[pi]->xfrm_nr >= XFRM_MAX_DEPTH) {

net/xfrm/xfrm_policy.c

3816

tpp[ti++] = &pols[pi]->xfrm_vec[i];

net/xfrm/xfrm_policy.c

3818

xfrm_nr = ti;

scripts/asn1_compiler.c

733

const struct type *const *ti = _ti;

scripts/asn1_compiler.c

734

const struct type *type = *ti;

sound/aoa/codecs/onyx.c

679

struct transfer_info *ti,

sound/aoa/codecs/onyx.c

694

switch (ti->tag) {

sound/aoa/codecs/tas.c

632

struct transfer_info *ti,

sound/aoa/codecs/toonie.c

54

struct transfer_info *ti,

sound/aoa/soundbus/i2sbus/pcm.c

102

while (ti->formats && ti->rates) {

sound/aoa/soundbus/i2sbus/pcm.c

103

v = *ti;

sound/aoa/soundbus/i2sbus/pcm.c

104

if (ti->transfer_in == in

sound/aoa/soundbus/i2sbus/pcm.c

105

&& cii->codec->usable(cii, ti, &v)) {

sound/aoa/soundbus/i2sbus/pcm.c

115

ti++;

sound/aoa/soundbus/i2sbus/pcm.c

99

struct transfer_info *ti = cii->codec->transfers;

sound/aoa/soundbus/soundbus.h

100

struct transfer_info *ti,

sound/core/seq/seq_timer.c

455

struct snd_timer_instance *ti;

sound/core/seq/seq_timer.c

467

ti = tmr->timeri;

sound/core/seq/seq_timer.c

468

if (!ti)

sound/core/seq/seq_timer.c

472

snd_timeri_timer_get(ti);

sound/core/seq/seq_timer.c

476

resolution = snd_timer_resolution(ti) * tmr->ticks;

sound/core/seq/seq_timer.c

64

struct snd_timer_instance *ti;

sound/core/seq/seq_timer.c

72

ti = t->timeri;

sound/core/seq/seq_timer.c

75

if (ti) {

sound/core/seq/seq_timer.c

76

snd_timer_close(ti);

sound/core/seq/seq_timer.c

77

snd_timer_instance_free(ti);

sound/core/timer.c

1046

struct snd_timer_instance *ti, *n;

sound/core/timer.c

1053

list_for_each_entry_safe(ti, n, &timer->open_list_head, open_list) {

sound/core/timer.c

1056

snd_timer_close_locked(ti, &card_dev_to_put);

sound/core/timer.c

1125

struct snd_timer_instance *ti;

sound/core/timer.c

1130

list_for_each_entry(ti, &timer->open_list_head, open_list) {

sound/core/timer.c

1131

if (ti->disconnect)

sound/core/timer.c

1132

ti->disconnect(ti);

sound/core/timer.c

1140

struct snd_timer_instance *ti, *ts;

sound/core/timer.c

1154

list_for_each_entry(ti, &timer->active_list_head, active_list) {

sound/core/timer.c

1155

if (ti->ccallback)

sound/core/timer.c

1156

ti->ccallback(ti, event, tstamp, resolution);

sound/core/timer.c

1157

list_for_each_entry(ts, &ti->slave_active_head, active_list)

sound/core/timer.c

1310

struct snd_timer_instance *ti;

sound/core/timer.c

1345

list_for_each_entry(ti, &timer->open_list_head, open_list)

sound/core/timer.c

1347

ti->owner ? ti->owner : "unknown",

sound/core/timer.c

1348

(ti->flags & (SNDRV_TIMER_IFLG_START |

sound/core/timer.c

571

static void snd_timer_notify1(struct snd_timer_instance *ti, int event)

sound/core/timer.c

573

struct snd_timer *timer = ti->timer;

sound/core/timer.c

589

if (ti->ccallback)

sound/core/timer.c

590

ti->ccallback(ti, event, &tstamp, resolution);

sound/core/timer.c

591

if (ti->flags & SNDRV_TIMER_IFLG_SLAVE)

sound/core/timer.c

598

list_for_each_entry(ts, &ti->slave_active_head, active_list)

sound/core/timer.c

805

struct snd_timer_instance *ti;

sound/core/timer.c

808

list_for_each_entry(ti, &timer->active_list_head, active_list) {

sound/core/timer.c

809

if (ti->flags & SNDRV_TIMER_IFLG_START) {

sound/core/timer.c

810

ti->flags &= ~SNDRV_TIMER_IFLG_START;

sound/core/timer.c

811

ti->flags |= SNDRV_TIMER_IFLG_RUNNING;

sound/core/timer.c

814

if (ti->flags & SNDRV_TIMER_IFLG_RUNNING) {

sound/core/timer.c

815

if (ticks > ti->cticks)

sound/core/timer.c

816

ticks = ti->cticks;

sound/core/timer.c

834

struct snd_timer_instance *ti;

sound/core/timer.c

838

ti = list_first_entry(head, struct snd_timer_instance,

sound/core/timer.c

842

list_del_init(&ti->ack_list);

sound/core/timer.c

844

if (!(ti->flags & SNDRV_TIMER_IFLG_DEAD)) {

sound/core/timer.c

845

ticks = ti->pticks;

sound/core/timer.c

846

ti->pticks = 0;

sound/core/timer.c

847

resolution = ti->resolution;

sound/core/timer.c

848

ti->flags |= SNDRV_TIMER_IFLG_CALLBACK;

sound/core/timer.c

850

if (ti->callback)

sound/core/timer.c

851

ti->callback(ti, resolution, ticks);

sound/core/timer.c

853

ti->flags &= ~SNDRV_TIMER_IFLG_CALLBACK;

sound/core/timer.c

892

struct snd_timer_instance *ti, *ts, *tmp;

sound/core/timer.c

914

list_for_each_entry_safe(ti, tmp, &timer->active_list_head,

sound/core/timer.c

916

if (ti->flags & SNDRV_TIMER_IFLG_DEAD)

sound/core/timer.c

918

if (!(ti->flags & SNDRV_TIMER_IFLG_RUNNING))

sound/core/timer.c

920

ti->pticks += ticks_left;

sound/core/timer.c

921

ti->resolution = resolution;

sound/core/timer.c

922

if (ti->cticks < ticks_left)

sound/core/timer.c

923

ti->cticks = 0;

sound/core/timer.c

925

ti->cticks -= ticks_left;

sound/core/timer.c

926

if (ti->cticks) /* not expired */

sound/core/timer.c

928

if (ti->flags & SNDRV_TIMER_IFLG_AUTO) {

sound/core/timer.c

929

ti->cticks = ti->ticks;

sound/core/timer.c

931

ti->flags &= ~SNDRV_TIMER_IFLG_RUNNING;

sound/core/timer.c

933

list_del_init(&ti->active_list);

sound/core/timer.c

936

(ti->flags & SNDRV_TIMER_IFLG_FAST))

sound/core/timer.c

941

if (list_empty(&ti->ack_list) &&

sound/core/timer.c

942

!(ti->flags & SNDRV_TIMER_IFLG_CALLBACK))

sound/core/timer.c

943

list_add_tail(&ti->ack_list, ack_list_head);

sound/core/timer.c

944

list_for_each_entry(ts, &ti->slave_active_head, active_list) {

sound/core/timer.c

945

ts->pticks = ti->pticks;

sound/pci/ctxfi/cttimer.c

100

mod_timer(&ti->timer,

sound/pci/ctxfi/cttimer.c

105

static void ct_systimer_stop(struct ct_timer_instance *ti)

sound/pci/ctxfi/cttimer.c

107

guard(spinlock_irqsave)(&ti->lock);

sound/pci/ctxfi/cttimer.c

108

ti->running = 0;

sound/pci/ctxfi/cttimer.c

109

timer_delete(&ti->timer);

sound/pci/ctxfi/cttimer.c

112

static void ct_systimer_prepare(struct ct_timer_instance *ti)

sound/pci/ctxfi/cttimer.c

114

ct_systimer_stop(ti);

sound/pci/ctxfi/cttimer.c

115

timer_delete_sync_try(&ti->timer);

sound/pci/ctxfi/cttimer.c

174

struct ct_timer_instance *ti;

sound/pci/ctxfi/cttimer.c

188

list_for_each_entry(ti, &atimer->running_head, running_list) {

sound/pci/ctxfi/cttimer.c

189

if (ti->frag_count > diff)

sound/pci/ctxfi/cttimer.c

190

ti->frag_count -= diff;

sound/pci/ctxfi/cttimer.c

195

period_size = ti->substream->runtime->period_size;

sound/pci/ctxfi/cttimer.c

196

rate = ti->substream->runtime->rate;

sound/pci/ctxfi/cttimer.c

197

pos = ti->substream->ops->pointer(ti->substream);

sound/pci/ctxfi/cttimer.c

198

if (pos / period_size != ti->position / period_size) {

sound/pci/ctxfi/cttimer.c

199

ti->need_update = 1;

sound/pci/ctxfi/cttimer.c

200

ti->position = pos;

sound/pci/ctxfi/cttimer.c

205

ti->frag_count = div_u64((u64)pos * CT_TIMER_FREQ +

sound/pci/ctxfi/cttimer.c

208

if (ti->need_update && !can_update)

sound/pci/ctxfi/cttimer.c

210

if (ti->frag_count < min_intr)

sound/pci/ctxfi/cttimer.c

211

min_intr = ti->frag_count;

sound/pci/ctxfi/cttimer.c

224

struct ct_timer_instance *ti;

sound/pci/ctxfi/cttimer.c

227

list_for_each_entry(ti, &atimer->instance_head, instance_list) {

sound/pci/ctxfi/cttimer.c

228

if (ti->running && ti->need_update) {

sound/pci/ctxfi/cttimer.c

229

ti->need_update = 0;

sound/pci/ctxfi/cttimer.c

230

ti->apcm->interrupt(ti->apcm);

sound/pci/ctxfi/cttimer.c

252

static void ct_xfitimer_prepare(struct ct_timer_instance *ti)

sound/pci/ctxfi/cttimer.c

254

ti->frag_count = ti->substream->runtime->period_size;

sound/pci/ctxfi/cttimer.c

255

ti->running = 0;

sound/pci/ctxfi/cttimer.c

256

ti->need_update = 0;

sound/pci/ctxfi/cttimer.c

274

static void ct_xfitimer_start(struct ct_timer_instance *ti)

sound/pci/ctxfi/cttimer.c

276

struct ct_timer *atimer = ti->timer_base;

sound/pci/ctxfi/cttimer.c

279

if (list_empty(&ti->running_list))

sound/pci/ctxfi/cttimer.c

281

ti->running = 1;

sound/pci/ctxfi/cttimer.c

282

ti->need_update = 0;

sound/pci/ctxfi/cttimer.c

283

list_add(&ti->running_list, &atimer->running_head);

sound/pci/ctxfi/cttimer.c

288

static void ct_xfitimer_stop(struct ct_timer_instance *ti)

sound/pci/ctxfi/cttimer.c

290

struct ct_timer *atimer = ti->timer_base;

sound/pci/ctxfi/cttimer.c

293

list_del_init(&ti->running_list);

sound/pci/ctxfi/cttimer.c

294

ti->running = 0;

sound/pci/ctxfi/cttimer.c

319

struct ct_timer_instance *ti;

sound/pci/ctxfi/cttimer.c

321

ti = kzalloc(sizeof(*ti), GFP_KERNEL);

sound/pci/ctxfi/cttimer.c

322

if (!ti)

sound/pci/ctxfi/cttimer.c

324

spin_lock_init(&ti->lock);

sound/pci/ctxfi/cttimer.c

325

INIT_LIST_HEAD(&ti->instance_list);

sound/pci/ctxfi/cttimer.c

326

INIT_LIST_HEAD(&ti->running_list);

sound/pci/ctxfi/cttimer.c

327

ti->timer_base = atimer;

sound/pci/ctxfi/cttimer.c

328

ti->apcm = apcm;

sound/pci/ctxfi/cttimer.c

329

ti->substream = apcm->substream;

sound/pci/ctxfi/cttimer.c

331

atimer->ops->init(ti);

sound/pci/ctxfi/cttimer.c

334

list_add(&ti->instance_list, &atimer->instance_head);

sound/pci/ctxfi/cttimer.c

337

return ti;

sound/pci/ctxfi/cttimer.c

340

void ct_timer_prepare(struct ct_timer_instance *ti)

sound/pci/ctxfi/cttimer.c

342

if (ti->timer_base->ops->prepare)

sound/pci/ctxfi/cttimer.c

343

ti->timer_base->ops->prepare(ti);

sound/pci/ctxfi/cttimer.c

344

ti->position = 0;

sound/pci/ctxfi/cttimer.c

345

ti->running = 0;

sound/pci/ctxfi/cttimer.c

348

void ct_timer_start(struct ct_timer_instance *ti)

sound/pci/ctxfi/cttimer.c

350

struct ct_timer *atimer = ti->timer_base;

sound/pci/ctxfi/cttimer.c

351

atimer->ops->start(ti);

sound/pci/ctxfi/cttimer.c

354

void ct_timer_stop(struct ct_timer_instance *ti)

sound/pci/ctxfi/cttimer.c

356

struct ct_timer *atimer = ti->timer_base;

sound/pci/ctxfi/cttimer.c

357

atimer->ops->stop(ti);

sound/pci/ctxfi/cttimer.c

360

void ct_timer_instance_free(struct ct_timer_instance *ti)

sound/pci/ctxfi/cttimer.c

362

struct ct_timer *atimer = ti->timer_base;

sound/pci/ctxfi/cttimer.c

364

atimer->ops->stop(ti); /* to be sure */

sound/pci/ctxfi/cttimer.c

366

atimer->ops->free_instance(ti);

sound/pci/ctxfi/cttimer.c

369

list_del(&ti->instance_list);

sound/pci/ctxfi/cttimer.c

372

kfree(ti);

sound/pci/ctxfi/cttimer.c

65

struct ct_timer_instance *ti = timer_container_of(ti, t, timer);

sound/pci/ctxfi/cttimer.c

66

struct snd_pcm_substream *substream = ti->substream;

sound/pci/ctxfi/cttimer.c

68

struct ct_atc_pcm *apcm = ti->apcm;

sound/pci/ctxfi/cttimer.c

74

dist = (position + buffer_size - ti->position) % buffer_size;

sound/pci/ctxfi/cttimer.c

76

position / period_size != ti->position / period_size) {

sound/pci/ctxfi/cttimer.c

78

ti->position = position;

sound/pci/ctxfi/cttimer.c

84

guard(spinlock_irqsave)(&ti->lock);

sound/pci/ctxfi/cttimer.c

85

if (ti->running)

sound/pci/ctxfi/cttimer.c

86

mod_timer(&ti->timer, jiffies + interval);

sound/pci/ctxfi/cttimer.c

89

static void ct_systimer_init(struct ct_timer_instance *ti)

sound/pci/ctxfi/cttimer.c

91

timer_setup(&ti->timer, ct_systimer_callback, 0);

sound/pci/ctxfi/cttimer.c

94

static void ct_systimer_start(struct ct_timer_instance *ti)

sound/pci/ctxfi/cttimer.c

96

struct snd_pcm_runtime *runtime = ti->substream->runtime;

sound/pci/ctxfi/cttimer.c

98

guard(spinlock_irqsave)(&ti->lock);

sound/pci/ctxfi/cttimer.c

99

ti->running = 1;

sound/pci/ctxfi/cttimer.h

25

void ct_timer_instance_free(struct ct_timer_instance *ti);

sound/pci/ctxfi/cttimer.h

26

void ct_timer_start(struct ct_timer_instance *ti);

sound/pci/ctxfi/cttimer.h

27

void ct_timer_stop(struct ct_timer_instance *ti);

sound/pci/ctxfi/cttimer.h

28

void ct_timer_prepare(struct ct_timer_instance *ti);

tools/perf/tests/symbols.c

105

*map_p = map__new(ti->machine, 0x100000, 0xffffffff, 0, &dso_id_empty,

tools/perf/tests/symbols.c

106

PROT_EXEC, /*flags=*/0, filename, ti->thread);

tools/perf/tests/symbols.c

170

static int test_file(struct test_info *ti, char *filename)

tools/perf/tests/symbols.c

178

ret = create_map(ti, filename, &map);

tools/perf/tests/symbols.c

200

ret = process_subdivided_dso(ti->machine, dso);

tools/perf/tests/symbols.c

210

struct test_info ti;

tools/perf/tests/symbols.c

213

ret = init_test_info(&ti);

tools/perf/tests/symbols.c

219

ret = test_file(&ti, filename);

tools/perf/tests/symbols.c

22

static int init_test_info(struct test_info *ti)

tools/perf/tests/symbols.c

221

exit_test_info(&ti);

tools/perf/tests/symbols.c

24

perf_env__init(&ti->host_env);

tools/perf/tests/symbols.c

25

ti->machine = machine__new_host(&ti->host_env);

tools/perf/tests/symbols.c

26

if (!ti->machine) {

tools/perf/tests/symbols.c

28

perf_env__exit(&ti->host_env);

tools/perf/tests/symbols.c

33

ti->thread = machine__findnew_thread(ti->machine, 100, 100);

tools/perf/tests/symbols.c

34

if (!ti->thread) {

tools/perf/tests/symbols.c

36

perf_env__exit(&ti->host_env);

tools/perf/tests/symbols.c

43

static void exit_test_info(struct test_info *ti)

tools/perf/tests/symbols.c

45

thread__put(ti->thread);

tools/perf/tests/symbols.c

46

machine__delete(ti->machine);

tools/perf/tests/symbols.c

47

perf_env__exit(&ti->host_env);

tools/perf/tests/symbols.c

82

static int create_map(struct test_info *ti, char *filename, struct map **map_p)

tools/perf/tests/symbols.c

84

struct dso *dso = machine__findnew_dso(ti->machine, filename);

tools/perf/tests/symbols.c

91

*map_p = find_module_map(ti->machine, dso);

tools/perf/util/libunwind-arch/libunwind-arm.c

201

_di->segbase = di.u.ti.segbase;

tools/perf/util/libunwind-arch/libunwind-arm.c

202

_di->table_data = di.u.ti.table_data;

tools/perf/util/libunwind-arch/libunwind-arm.c

203

_di->table_len = di.u.ti.table_len;

tools/perf/util/libunwind-arch/libunwind-arm64.c

200

_di->segbase = di.u.ti.segbase;

tools/perf/util/libunwind-arch/libunwind-arm64.c

201

_di->table_data = di.u.ti.table_data;

tools/perf/util/libunwind-arch/libunwind-arm64.c

202

_di->table_len = di.u.ti.table_len;

tools/perf/util/libunwind-arch/libunwind-i386.c

223

_di->segbase = di.u.ti.segbase;

tools/perf/util/libunwind-arch/libunwind-i386.c

224

_di->table_data = di.u.ti.table_data;

tools/perf/util/libunwind-arch/libunwind-i386.c

225

_di->table_len = di.u.ti.table_len;

tools/perf/util/libunwind-arch/libunwind-loongarch.c

208

_di->segbase = di.u.ti.segbase;

tools/perf/util/libunwind-arch/libunwind-loongarch.c

209

_di->table_data = di.u.ti.table_data;

tools/perf/util/libunwind-arch/libunwind-loongarch.c

210

_di->table_len = di.u.ti.table_len;

tools/perf/util/libunwind-arch/libunwind-mips.c

210

_di->segbase = di.u.ti.segbase;

tools/perf/util/libunwind-arch/libunwind-mips.c

211

_di->table_data = di.u.ti.table_data;

tools/perf/util/libunwind-arch/libunwind-mips.c

212

_di->table_len = di.u.ti.table_len;

tools/perf/util/libunwind-arch/libunwind-ppc32.c

214

_di->segbase = di.u.ti.segbase;

tools/perf/util/libunwind-arch/libunwind-ppc32.c

215

_di->table_data = di.u.ti.table_data;

tools/perf/util/libunwind-arch/libunwind-ppc32.c

216

_di->table_len = di.u.ti.table_len;

tools/perf/util/libunwind-arch/libunwind-ppc64.c

214

_di->segbase = di.u.ti.segbase;

tools/perf/util/libunwind-arch/libunwind-ppc64.c

215

_di->table_data = di.u.ti.table_data;

tools/perf/util/libunwind-arch/libunwind-ppc64.c

216

_di->table_len = di.u.ti.table_len;

tools/perf/util/libunwind-arch/libunwind-riscv.c

208

_di->segbase = di.u.ti.segbase;

tools/perf/util/libunwind-arch/libunwind-riscv.c

209

_di->table_data = di.u.ti.table_data;

tools/perf/util/libunwind-arch/libunwind-riscv.c

210

_di->table_len = di.u.ti.table_len;

tools/perf/util/libunwind-arch/libunwind-s390.c

210

_di->segbase = di.u.ti.segbase;

tools/perf/util/libunwind-arch/libunwind-s390.c

211

_di->table_data = di.u.ti.table_data;

tools/perf/util/libunwind-arch/libunwind-s390.c

212

_di->table_len = di.u.ti.table_len;

tools/perf/util/libunwind-arch/libunwind-x86_64.c

232

_di->segbase = di.u.ti.segbase;

tools/perf/util/libunwind-arch/libunwind-x86_64.c

233

_di->table_data = di.u.ti.table_data;

tools/perf/util/libunwind-arch/libunwind-x86_64.c

234

_di->table_len = di.u.ti.table_len;

tools/testing/selftests/kvm/x86/xen_shinfo_test.c

1033

TEST_ASSERT(ti->version && !(ti->version & 1),

tools/testing/selftests/kvm/x86/xen_shinfo_test.c

1034

"Bad time_info version %x", ti->version);

tools/testing/selftests/kvm/x86/xen_shinfo_test.c

1036

"Bad time_info version %x", ti->version);

tools/testing/selftests/kvm/x86/xen_shinfo_test.c

986

struct pvclock_vcpu_time_info *ti, *ti2;

tools/testing/selftests/kvm/x86/xen_shinfo_test.c

991

ti = addr_gpa2hva(vm, SHINFO_REGION_GPA + 0x40 + 0x20);

tools/testing/selftests/kvm/x86/xen_shinfo_test.c

997

ti->version, ti->tsc_timestamp, ti->system_time, ti->tsc_to_system_mul,

tools/testing/selftests/kvm/x86/xen_shinfo_test.c

998

ti->tsc_shift, ti->flags);

tools/testing/selftests/membarrier/membarrier_rseq_stress.c

816

int ti = 0, ai = 0;

tools/testing/selftests/membarrier/membarrier_rseq_stress.c

820

r = pthread_create(&threads[ti], NULL, sentinel_thread_fn, NULL);

tools/testing/selftests/membarrier/membarrier_rseq_stress.c

830

ti++;

tools/testing/selftests/membarrier/membarrier_rseq_stress.c

833

r = pthread_create(&threads[ti], NULL, reporter_thread_fn, NULL);

tools/testing/selftests/membarrier/membarrier_rseq_stress.c

845

ti++;

tools/testing/selftests/membarrier/membarrier_rseq_stress.c

853

r = pthread_create(&threads[ti], NULL, hammer_thread_fn, &cpuargs[ai]);

tools/testing/selftests/membarrier/membarrier_rseq_stress.c

856

ti, strerror(r));

tools/testing/selftests/membarrier/membarrier_rseq_stress.c

863

for (int k = 2; k < ti; k++)

tools/testing/selftests/membarrier/membarrier_rseq_stress.c

879

ti++;

tools/testing/selftests/membarrier/membarrier_rseq_stress.c

913

for (int i = 2; i < ti; i++)

tools/testing/selftests/net/mptcp/mptcp_sockopt.c

386

struct tcp_info ti[2];

tools/testing/selftests/net/mptcp/mptcp_sockopt.c

387

} ti;

tools/testing/selftests/net/mptcp/mptcp_sockopt.c

392

memset(&ti, 0, sizeof(ti));

tools/testing/selftests/net/mptcp/mptcp_sockopt.c

394

ti.d.size_subflow_data = sizeof(struct mptcp_subflow_data);

tools/testing/selftests/net/mptcp/mptcp_sockopt.c

395

ti.d.size_user = sizeof(struct tcp_info);

tools/testing/selftests/net/mptcp/mptcp_sockopt.c

396

olen = sizeof(ti);

tools/testing/selftests/net/mptcp/mptcp_sockopt.c

398

ret = getsockopt(fd, SOL_MPTCP, MPTCP_TCPINFO, &ti, &olen);

tools/testing/selftests/net/mptcp/mptcp_sockopt.c

402

assert(olen <= sizeof(ti));

tools/testing/selftests/net/mptcp/mptcp_sockopt.c

403

assert(ti.d.size_kernel > 0);

tools/testing/selftests/net/mptcp/mptcp_sockopt.c

404

assert(ti.d.size_user ==

tools/testing/selftests/net/mptcp/mptcp_sockopt.c

405

MIN(ti.d.size_kernel, sizeof(struct tcp_info)));

tools/testing/selftests/net/mptcp/mptcp_sockopt.c

406

assert(ti.d.num_subflows == 1);

tools/testing/selftests/net/mptcp/mptcp_sockopt.c

410

assert(olen == ti.d.size_user);

tools/testing/selftests/net/mptcp/mptcp_sockopt.c

412

s->tcp_info = ti.ti[0];

tools/testing/selftests/net/mptcp/mptcp_sockopt.c

414

if (ti.ti[0].tcpi_bytes_sent == w &&

tools/testing/selftests/net/mptcp/mptcp_sockopt.c

415

ti.ti[0].tcpi_bytes_received == r)

tools/testing/selftests/net/mptcp/mptcp_sockopt.c

418

if (r == 0 && ti.ti[0].tcpi_bytes_sent == w &&

tools/testing/selftests/net/mptcp/mptcp_sockopt.c

419

ti.ti[0].tcpi_bytes_received) {

tools/testing/selftests/net/mptcp/mptcp_sockopt.c

420

s->tcpi_rcv_delta = ti.ti[0].tcpi_bytes_received;

tools/testing/selftests/net/mptcp/mptcp_sockopt.c

429

ti.ti[0].tcpi_bytes_sent, w, ti.ti[0].tcpi_bytes_received, r);