arch/arm/kernel/crash_dump.c

19

ssize_t copy_oldmem_page(struct iov_iter *iter, unsigned long pfn,

arch/arm/kernel/crash_dump.c

31

csize = copy_to_iter(vaddr + offset, csize, iter);

arch/arm64/kernel/crash_dump.c

15

ssize_t copy_oldmem_page(struct iov_iter *iter, unsigned long pfn,

arch/arm64/kernel/crash_dump.c

27

csize = copy_to_iter(vaddr + offset, csize, iter);

arch/arm64/kvm/vgic/vgic-debug.c

105

struct vgic_state_iter *iter;

arch/arm64/kvm/vgic/vgic-debug.c

107

iter = kmalloc_obj(*iter);

arch/arm64/kvm/vgic/vgic-debug.c

108

if (!iter)

arch/arm64/kvm/vgic/vgic-debug.c

111

iter_init(kvm, iter, *pos);

arch/arm64/kvm/vgic/vgic-debug.c

113

if (end_of_vgic(iter)) {

arch/arm64/kvm/vgic/vgic-debug.c

114

kfree(iter);

arch/arm64/kvm/vgic/vgic-debug.c

115

iter = NULL;

arch/arm64/kvm/vgic/vgic-debug.c

118

return iter;

arch/arm64/kvm/vgic/vgic-debug.c

124

struct vgic_state_iter *iter = v;

arch/arm64/kvm/vgic/vgic-debug.c

127

iter_next(kvm, iter);

arch/arm64/kvm/vgic/vgic-debug.c

128

if (end_of_vgic(iter)) {

arch/arm64/kvm/vgic/vgic-debug.c

129

kfree(iter);

arch/arm64/kvm/vgic/vgic-debug.c

130

iter = NULL;

arch/arm64/kvm/vgic/vgic-debug.c

132

return iter;

arch/arm64/kvm/vgic/vgic-debug.c

137

struct vgic_state_iter *iter = v;

arch/arm64/kvm/vgic/vgic-debug.c

142

kfree(iter);

arch/arm64/kvm/vgic/vgic-debug.c

146

struct vgic_state_iter *iter)

arch/arm64/kvm/vgic/vgic-debug.c

237

struct vgic_state_iter *iter = v;

arch/arm64/kvm/vgic/vgic-debug.c

242

if (iter->dist_id == 0) {

arch/arm64/kvm/vgic/vgic-debug.c

243

print_dist_state(s, &kvm->arch.vgic, iter);

arch/arm64/kvm/vgic/vgic-debug.c

250

if (iter->vcpu_id < iter->nr_cpus)

arch/arm64/kvm/vgic/vgic-debug.c

251

vcpu = kvm_get_vcpu(kvm, iter->vcpu_id);

arch/arm64/kvm/vgic/vgic-debug.c

253

if (iter->intid < VGIC_NR_PRIVATE_IRQS)

arch/arm64/kvm/vgic/vgic-debug.c

254

irq = vgic_get_vcpu_irq(vcpu, iter->intid);

arch/arm64/kvm/vgic/vgic-debug.c

256

irq = vgic_get_irq(kvm, iter->intid);

arch/arm64/kvm/vgic/vgic-debug.c

313

static inline bool end_of_iter(struct vgic_its_iter *iter)

arch/arm64/kvm/vgic/vgic-debug.c

315

return !iter->dev && !iter->ite;

arch/arm64/kvm/vgic/vgic-debug.c

328

static void vgic_its_iter_next(struct vgic_its *its, struct vgic_its_iter *iter)

arch/arm64/kvm/vgic/vgic-debug.c

33

static void iter_next(struct kvm *kvm, struct vgic_state_iter *iter)

arch/arm64/kvm/vgic/vgic-debug.c

330

struct its_device *dev = iter->dev;

arch/arm64/kvm/vgic/vgic-debug.c

331

struct its_ite *ite = iter->ite;

arch/arm64/kvm/vgic/vgic-debug.c

347

iter->dev = dev;

arch/arm64/kvm/vgic/vgic-debug.c

348

iter->ite = ite;

arch/arm64/kvm/vgic/vgic-debug.c

367

struct vgic_its_iter *iter;

arch/arm64/kvm/vgic/vgic-debug.c

37

if (iter->dist_id == 0) {

arch/arm64/kvm/vgic/vgic-debug.c

378

iter = kmalloc_obj(*iter);

arch/arm64/kvm/vgic/vgic-debug.c

379

if (!iter)

arch/arm64/kvm/vgic/vgic-debug.c

38

iter->dist_id++;

arch/arm64/kvm/vgic/vgic-debug.c

382

iter->dev = dev;

arch/arm64/kvm/vgic/vgic-debug.c

383

iter->ite = list_first_entry_or_null(&dev->itt_head,

arch/arm64/kvm/vgic/vgic-debug.c

386

while (!end_of_iter(iter) && offset--)

arch/arm64/kvm/vgic/vgic-debug.c

387

vgic_its_iter_next(its, iter);

arch/arm64/kvm/vgic/vgic-debug.c

389

if (end_of_iter(iter)) {

arch/arm64/kvm/vgic/vgic-debug.c

390

kfree(iter);

arch/arm64/kvm/vgic/vgic-debug.c

394

return iter;

arch/arm64/kvm/vgic/vgic-debug.c

412

struct vgic_its_iter *iter = v;

arch/arm64/kvm/vgic/vgic-debug.c

415

vgic_its_iter_next(its, iter);

arch/arm64/kvm/vgic/vgic-debug.c

417

if (end_of_iter(iter)) {

arch/arm64/kvm/vgic/vgic-debug.c

418

kfree(iter);

arch/arm64/kvm/vgic/vgic-debug.c

421

return iter;

arch/arm64/kvm/vgic/vgic-debug.c

434

struct vgic_its_iter *iter = v;

arch/arm64/kvm/vgic/vgic-debug.c

436

if (!IS_ERR_OR_NULL(iter))

arch/arm64/kvm/vgic/vgic-debug.c

437

kfree(iter);

arch/arm64/kvm/vgic/vgic-debug.c

453

struct vgic_its_iter *iter = v;

arch/arm64/kvm/vgic/vgic-debug.c

454

struct its_device *dev = iter->dev;

arch/arm64/kvm/vgic/vgic-debug.c

455

struct its_ite *ite = iter->ite;

arch/arm64/kvm/vgic/vgic-debug.c

46

if (iter->intid >= (iter->nr_spis + VGIC_NR_PRIVATE_IRQS - 1)) {

arch/arm64/kvm/vgic/vgic-debug.c

47

if (iter->intid == VGIC_LPI_MAX_INTID + 1)

arch/arm64/kvm/vgic/vgic-debug.c

51

if (!xa_find_after(&dist->lpi_xa, &iter->intid,

arch/arm64/kvm/vgic/vgic-debug.c

53

iter->intid = VGIC_LPI_MAX_INTID + 1;

arch/arm64/kvm/vgic/vgic-debug.c

58

iter->intid++;

arch/arm64/kvm/vgic/vgic-debug.c

59

if (iter->intid == VGIC_NR_PRIVATE_IRQS &&

arch/arm64/kvm/vgic/vgic-debug.c

60

++iter->vcpu_id < iter->nr_cpus)

arch/arm64/kvm/vgic/vgic-debug.c

61

iter->intid = 0;

arch/arm64/kvm/vgic/vgic-debug.c

79

static void iter_init(struct kvm *kvm, struct vgic_state_iter *iter,

arch/arm64/kvm/vgic/vgic-debug.c

84

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

arch/arm64/kvm/vgic/vgic-debug.c

86

iter->nr_cpus = nr_cpus;

arch/arm64/kvm/vgic/vgic-debug.c

87

iter->nr_spis = kvm->arch.vgic.nr_spis;

arch/arm64/kvm/vgic/vgic-debug.c

91

iter_next(kvm, iter);

arch/arm64/kvm/vgic/vgic-debug.c

94

static bool end_of_vgic(struct vgic_state_iter *iter)

arch/arm64/kvm/vgic/vgic-debug.c

96

return iter->dist_id > 0 &&

arch/arm64/kvm/vgic/vgic-debug.c

97

iter->vcpu_id == iter->nr_cpus &&

arch/arm64/kvm/vgic/vgic-debug.c

98

iter->intid >= (iter->nr_spis + VGIC_NR_PRIVATE_IRQS) &&

arch/arm64/kvm/vgic/vgic-debug.c

99

iter->intid > VGIC_LPI_MAX_INTID;

arch/arm64/kvm/vgic/vgic-mmio-v3.c

323

struct vgic_redist_region *iter, *rdreg = vgic_cpu->rdreg;

arch/arm64/kvm/vgic/vgic-mmio-v3.c

338

list_for_each_entry(iter, rd_regions, list) {

arch/arm64/kvm/vgic/vgic-mmio-v3.c

339

if (iter->base == end && iter->free_index > 0)

arch/loongarch/kernel/crash_dump.c

18

csize = copy_to_iter(vaddr + offset, csize, iter);

arch/loongarch/kernel/crash_dump.c

6

ssize_t copy_oldmem_page(struct iov_iter *iter, unsigned long pfn,

arch/m68k/emu/nfblock.c

64

struct bvec_iter iter;

arch/m68k/emu/nfblock.c

70

bio_for_each_segment(bvec, bio, iter) {

arch/mips/kernel/crash_dump.c

15

csize = copy_to_iter(vaddr + offset, csize, iter);

arch/mips/kernel/crash_dump.c

6

ssize_t copy_oldmem_page(struct iov_iter *iter, unsigned long pfn,

arch/mips/kernel/jump_label.c

103

for (iter = iter_start; iter < iter_stop; iter++) {

arch/mips/kernel/jump_label.c

105

if (jump_label_init_type(iter) == JUMP_LABEL_NOP)

arch/mips/kernel/jump_label.c

106

arch_jump_label_transform(iter, JUMP_LABEL_NOP);

arch/mips/kernel/jump_label.c

97

struct jump_entry *iter;

arch/powerpc/kernel/cacheinfo.c

170

struct cache *iter;

arch/powerpc/kernel/cacheinfo.c

172

list_for_each_entry(iter, &cache_list, list)

arch/powerpc/kernel/cacheinfo.c

173

WARN_ONCE(iter->next_local == cache,

arch/powerpc/kernel/cacheinfo.c

175

iter->ofnode,

arch/powerpc/kernel/cacheinfo.c

176

cache_type_string(iter),

arch/powerpc/kernel/cacheinfo.c

308

struct cache *iter;

arch/powerpc/kernel/cacheinfo.c

314

list_for_each_entry(iter, &cache_list, list)

arch/powerpc/kernel/cacheinfo.c

315

if (iter->ofnode == cache->ofnode &&

arch/powerpc/kernel/cacheinfo.c

316

iter->group_id == cache->group_id &&

arch/powerpc/kernel/cacheinfo.c

317

iter->next_local == cache)

arch/powerpc/kernel/cacheinfo.c

318

return iter;

arch/powerpc/kernel/cacheinfo.c

328

struct cache *iter;

arch/powerpc/kernel/cacheinfo.c

330

list_for_each_entry(iter, &cache_list, list) {

arch/powerpc/kernel/cacheinfo.c

331

if (iter->ofnode != node ||

arch/powerpc/kernel/cacheinfo.c

332

iter->group_id != group_id)

arch/powerpc/kernel/cacheinfo.c

334

cache = cache_find_first_sibling(iter);

arch/powerpc/kernel/crash_dump.c

72

ssize_t copy_oldmem_page(struct iov_iter *iter, unsigned long pfn,

arch/powerpc/kernel/crash_dump.c

86

csize = copy_to_iter(vaddr + offset, csize, iter);

arch/powerpc/kernel/crash_dump.c

89

csize = copy_to_iter(vaddr + offset, csize, iter);

arch/powerpc/kernel/nvram_64.c

650

static struct kmsg_dump_iter iter;

arch/powerpc/kernel/nvram_64.c

685

kmsg_dump_rewind(&iter);

arch/powerpc/kernel/nvram_64.c

686

kmsg_dump_get_buffer(&iter, false,

arch/powerpc/kernel/nvram_64.c

691

kmsg_dump_rewind(&iter);

arch/powerpc/kernel/nvram_64.c

692

kmsg_dump_get_buffer(&iter, false,

arch/powerpc/kernel/trace/ftrace.c

393

struct ftrace_rec_iter *iter;

arch/powerpc/kernel/trace/ftrace.c

397

for_ftrace_rec_iter(iter) {

arch/powerpc/kernel/trace/ftrace.c

398

rec = ftrace_rec_iter_record(iter);

arch/powerpc/kvm/book3s_hv_uvmem.c

364

struct kvmppc_uvmem_slot *p = NULL, *iter;

arch/powerpc/kvm/book3s_hv_uvmem.c

368

list_for_each_entry(iter, &kvm->arch.uvmem_pfns, list)

arch/powerpc/kvm/book3s_hv_uvmem.c

369

if (*gfn >= iter->base_pfn && *gfn < iter->base_pfn + iter->nr_pfns) {

arch/powerpc/kvm/book3s_hv_uvmem.c

370

p = iter;

arch/powerpc/xmon/xmon.c

3057

struct kmsg_dump_iter iter;

arch/powerpc/xmon/xmon.c

3069

kmsg_dump_rewind(&iter);

arch/powerpc/xmon/xmon.c

3071

while (kmsg_dump_get_line(&iter, false, buf, sizeof(buf), &len)) {

arch/riscv/kernel/crash_dump.c

12

ssize_t copy_oldmem_page(struct iov_iter *iter, unsigned long pfn,

arch/riscv/kernel/crash_dump.c

24

csize = copy_to_iter(vaddr + offset, csize, iter);

arch/s390/include/asm/maccess.h

14

size_t memcpy_real_iter(struct iov_iter *iter, unsigned long src, size_t count);

arch/s390/include/asm/sclp.h

194

size_t memcpy_hsa_iter(struct iov_iter *iter, unsigned long src, size_t count);

arch/s390/kernel/crash_dump.c

118

static size_t copy_oldmem_iter(struct iov_iter *iter, unsigned long src, size_t count)

arch/s390/kernel/crash_dump.c

126

copied = memcpy_hsa_iter(iter, src, len);

arch/s390/kernel/crash_dump.c

138

copied = memcpy_real_iter(iter, src, len);

arch/s390/kernel/crash_dump.c

151

struct iov_iter iter;

arch/s390/kernel/crash_dump.c

156

iov_iter_kvec(&iter, ITER_DEST, &kvec, 1, count);

arch/s390/kernel/crash_dump.c

157

if (copy_oldmem_iter(&iter, src, count) < count)

arch/s390/kernel/crash_dump.c

165

ssize_t copy_oldmem_page(struct iov_iter *iter, unsigned long pfn, size_t csize,

arch/s390/kernel/crash_dump.c

171

return copy_oldmem_iter(iter, src, csize);

arch/s390/kvm/diag.c

23

struct kvm_memslot_iter iter;

arch/s390/kvm/diag.c

30

kvm_for_each_memslot_in_gfn_range(&iter, slots, gfn_start, gfn_end) {

arch/s390/kvm/diag.c

31

slot = iter.slot;

arch/s390/kvm/gmap.c

156

struct radix_tree_iter iter;

arch/s390/kvm/gmap.c

166

radix_tree_for_each_slot(slot, root, &iter, index) {

arch/s390/kvm/gmap.c

167

indices[nr] = iter.index;

arch/s390/kvm/interrupt.c

1668

struct kvm_s390_interrupt_info *iter;

arch/s390/kvm/interrupt.c

1674

list_for_each_entry(iter, isc_list, list) {

arch/s390/kvm/interrupt.c

1675

if (schid && (id != iter->io.subchannel_id ||

arch/s390/kvm/interrupt.c

1676

nr != iter->io.subchannel_nr))

arch/s390/kvm/interrupt.c

1679

list_del_init(&iter->list);

arch/s390/kvm/interrupt.c

1684

return iter;

arch/s390/mm/maccess.c

103

copied = copy_to_iter(chunk, len, iter);

arch/s390/mm/maccess.c

117

struct iov_iter iter;

arch/s390/mm/maccess.c

122

iov_iter_kvec(&iter, ITER_DEST, &kvec, 1, count);

arch/s390/mm/maccess.c

123

if (memcpy_real_iter(&iter, src, count) < count)

arch/s390/mm/maccess.c

83

size_t memcpy_real_iter(struct iov_iter *iter, unsigned long src, size_t count)

arch/sh/kernel/crash_dump.c

14

ssize_t copy_oldmem_page(struct iov_iter *iter, unsigned long pfn,

arch/sh/kernel/crash_dump.c

23

csize = copy_to_iter(vaddr + offset, csize, iter);

arch/sh/mm/asids-debugfs.c

29

static int asids_debugfs_show(struct seq_file *file, void *iter)

arch/sh/mm/cache-debugfs.c

25

static int cache_debugfs_show(struct seq_file *file, void *iter)

arch/sh/mm/pmb.c

145

struct pmb_entry *pmbe, *iter;

arch/sh/mm/pmb.c

175

for (iter = pmbe->link; iter; iter = iter->link)

arch/sh/mm/pmb.c

176

span += iter->size;

arch/sh/mm/pmb.c

815

static int pmb_debugfs_show(struct seq_file *file, void *iter)

arch/sh/mm/tlb-debugfs.c

39

static int tlb_seq_show(struct seq_file *file, void *iter)

arch/sparc/prom/bootstr_32.c

19

int iter;

arch/sparc/prom/bootstr_32.c

31

for (iter = 1; iter < 8; iter++) {

arch/sparc/prom/bootstr_32.c

32

arg = (*(romvec->pv_v0bootargs))->argv[iter];

arch/um/drivers/ubd_kern.c

1195

struct req_iterator iter;

arch/um/drivers/ubd_kern.c

1204

rq_for_each_segment(bvec, req, iter) {

arch/um/kernel/kmsg_dump.c

13

static struct kmsg_dump_iter iter;

arch/um/kernel/kmsg_dump.c

45

kmsg_dump_rewind(&iter);

arch/um/kernel/kmsg_dump.c

48

while (kmsg_dump_get_line(&iter, true, line, sizeof(line), &len)) {

arch/x86/events/intel/pt.c

1222

struct topa *topa, *iter;

arch/x86/events/intel/pt.c

1227

list_for_each_entry_safe(topa, iter, &buf->tables, list) {

arch/x86/kernel/cpu/microcode/intel.c

867

static enum ucode_state parse_microcode_blobs(int cpu, struct iov_iter *iter)

arch/x86/kernel/cpu/microcode/intel.c

875

while (iov_iter_count(iter)) {

arch/x86/kernel/cpu/microcode/intel.c

880

if (!copy_from_iter_full(&mc_header, sizeof(mc_header), iter)) {

arch/x86/kernel/cpu/microcode/intel.c

891

if (data_size > iov_iter_count(iter)) {

arch/x86/kernel/cpu/microcode/intel.c

907

if (!copy_from_iter_full(data, data_size, iter) ||

arch/x86/kernel/cpu/microcode/intel.c

928

if (iov_iter_count(iter))

arch/x86/kernel/cpu/microcode/intel.c

970

struct iov_iter iter;

arch/x86/kernel/cpu/microcode/intel.c

988

iov_iter_kvec(&iter, ITER_SOURCE, &kvec, 1, firmware->size);

arch/x86/kernel/cpu/microcode/intel.c

989

ret = parse_microcode_blobs(cpu, &iter);

arch/x86/kernel/crash_dump_32.c

31

ssize_t copy_oldmem_page(struct iov_iter *iter, unsigned long pfn, size_t csize,

arch/x86/kernel/crash_dump_32.c

43

csize = copy_to_iter(vaddr + offset, csize, iter);

arch/x86/kernel/crash_dump_64.c

15

static ssize_t __copy_oldmem_page(struct iov_iter *iter, unsigned long pfn,

arch/x86/kernel/crash_dump_64.c

32

csize = copy_to_iter(vaddr + offset, csize, iter);

arch/x86/kernel/crash_dump_64.c

38

ssize_t copy_oldmem_page(struct iov_iter *iter, unsigned long pfn, size_t csize,

arch/x86/kernel/crash_dump_64.c

41

return __copy_oldmem_page(iter, pfn, csize, offset, false);

arch/x86/kernel/crash_dump_64.c

49

ssize_t copy_oldmem_page_encrypted(struct iov_iter *iter, unsigned long pfn,

arch/x86/kernel/crash_dump_64.c

52

return __copy_oldmem_page(iter, pfn, csize, offset, true);

arch/x86/kernel/crash_dump_64.c

58

struct iov_iter iter;

arch/x86/kernel/crash_dump_64.c

60

iov_iter_kvec(&iter, ITER_DEST, &kvec, 1, count);

arch/x86/kernel/crash_dump_64.c

62

return read_from_oldmem(&iter, count, ppos,

arch/x86/kernel/ftrace.c

205

struct ftrace_rec_iter *iter;

arch/x86/kernel/ftrace.c

210

for_ftrace_rec_iter(iter) {

arch/x86/kernel/ftrace.c

211

rec = ftrace_rec_iter_record(iter);

arch/x86/kernel/ftrace.c

237

for_ftrace_rec_iter(iter) {

arch/x86/kernel/ftrace.c

238

rec = ftrace_rec_iter_record(iter);

arch/x86/kvm/mmu/mmu.c

1256

struct rmap_iterator *iter)

arch/x86/kvm/mmu/mmu.c

1264

iter->desc = NULL;

arch/x86/kvm/mmu/mmu.c

1268

iter->desc = (struct pte_list_desc *)(rmap_val & ~KVM_RMAP_MANY);

arch/x86/kvm/mmu/mmu.c

1269

iter->pos = 0;

arch/x86/kvm/mmu/mmu.c

1270

return iter->desc->sptes[iter->pos];

arch/x86/kvm/mmu/mmu.c

1278

static u64 *rmap_get_next(struct rmap_iterator *iter)

arch/x86/kvm/mmu/mmu.c

1280

if (iter->desc) {

arch/x86/kvm/mmu/mmu.c

1281

if (iter->pos < PTE_LIST_EXT - 1) {

arch/x86/kvm/mmu/mmu.c

1282

++iter->pos;

arch/x86/kvm/mmu/mmu.c

1283

if (iter->desc->sptes[iter->pos])

arch/x86/kvm/mmu/mmu.c

1284

return iter->desc->sptes[iter->pos];

arch/x86/kvm/mmu/mmu.c

1287

iter->desc = iter->desc->more;

arch/x86/kvm/mmu/mmu.c

1289

if (iter->desc) {

arch/x86/kvm/mmu/mmu.c

1290

iter->pos = 0;

arch/x86/kvm/mmu/mmu.c

1292

return iter->desc->sptes[iter->pos];

arch/x86/kvm/mmu/mmu.c

1351

struct rmap_iterator iter;

arch/x86/kvm/mmu/mmu.c

1354

for_each_rmap_spte(rmap_head, &iter, sptep)

arch/x86/kvm/mmu/mmu.c

1379

struct rmap_iterator iter;

arch/x86/kvm/mmu/mmu.c

1382

for_each_rmap_spte(rmap_head, &iter, sptep) {

arch/x86/kvm/mmu/mmu.c

1732

struct rmap_iterator iter;

arch/x86/kvm/mmu/mmu.c

1746

for_each_rmap_spte_lockless(rmap_head, &iter, sptep, spte) {

arch/x86/kvm/mmu/mmu.c

1878

struct rmap_iterator iter;

arch/x86/kvm/mmu/mmu.c

1880

for_each_rmap_spte(&sp->parent_ptes, &iter, sptep) {

arch/x86/kvm/mmu/mmu.c

2692

struct rmap_iterator iter;

arch/x86/kvm/mmu/mmu.c

2694

while ((sptep = rmap_get_first(&sp->parent_ptes, &iter)))

arch/x86/kvm/mmu/mmu.c

7010

struct kvm_memslot_iter iter;

arch/x86/kvm/mmu/mmu.c

7021

kvm_for_each_memslot_in_gfn_range(&iter, slots, gfn_start, gfn_end) {

arch/x86/kvm/mmu/mmu.c

7022

memslot = iter.slot;

arch/x86/kvm/mmu/mmu.c

7261

struct rmap_iterator iter;

arch/x86/kvm/mmu/mmu.c

7267

for_each_rmap_spte(rmap_head, &iter, huge_sptep) {

arch/x86/kvm/mmu/mmu.c

7377

struct rmap_iterator iter;

arch/x86/kvm/mmu/mmu.c

7382

for_each_rmap_spte(rmap_head, &iter, sptep) {

arch/x86/kvm/mmu/tdp_iter.c

100

tdp_iter_refresh_sptep(iter);

arch/x86/kvm/mmu/tdp_iter.c

112

static bool try_step_side(struct tdp_iter *iter)

arch/x86/kvm/mmu/tdp_iter.c

118

if (SPTE_INDEX((iter->gfn | iter->gfn_bits) << PAGE_SHIFT, iter->level) ==

arch/x86/kvm/mmu/tdp_iter.c

12

static void tdp_iter_refresh_sptep(struct tdp_iter *iter)

arch/x86/kvm/mmu/tdp_iter.c

122

iter->gfn += KVM_PAGES_PER_HPAGE(iter->level);

arch/x86/kvm/mmu/tdp_iter.c

123

iter->next_last_level_gfn = iter->gfn;

arch/x86/kvm/mmu/tdp_iter.c

124

iter->sptep++;

arch/x86/kvm/mmu/tdp_iter.c

125

iter->old_spte = kvm_tdp_mmu_read_spte(iter->sptep);

arch/x86/kvm/mmu/tdp_iter.c

135

static bool try_step_up(struct tdp_iter *iter)

arch/x86/kvm/mmu/tdp_iter.c

137

if (iter->level == iter->root_level)

arch/x86/kvm/mmu/tdp_iter.c

14

iter->sptep = iter->pt_path[iter->level - 1] +

arch/x86/kvm/mmu/tdp_iter.c

140

iter->level++;

arch/x86/kvm/mmu/tdp_iter.c

141

iter->gfn = gfn_round_for_level(iter->gfn, iter->level);

arch/x86/kvm/mmu/tdp_iter.c

142

tdp_iter_refresh_sptep(iter);

arch/x86/kvm/mmu/tdp_iter.c

15

SPTE_INDEX((iter->gfn | iter->gfn_bits) << PAGE_SHIFT, iter->level);

arch/x86/kvm/mmu/tdp_iter.c

16

iter->old_spte = kvm_tdp_mmu_read_spte(iter->sptep);

arch/x86/kvm/mmu/tdp_iter.c

163

void tdp_iter_next(struct tdp_iter *iter)

arch/x86/kvm/mmu/tdp_iter.c

165

if (iter->yielded) {

arch/x86/kvm/mmu/tdp_iter.c

166

tdp_iter_restart(iter);

arch/x86/kvm/mmu/tdp_iter.c

170

if (try_step_down(iter))

arch/x86/kvm/mmu/tdp_iter.c

174

if (try_step_side(iter))

arch/x86/kvm/mmu/tdp_iter.c

176

} while (try_step_up(iter));

arch/x86/kvm/mmu/tdp_iter.c

177

iter->valid = false;

arch/x86/kvm/mmu/tdp_iter.c

23

void tdp_iter_restart(struct tdp_iter *iter)

arch/x86/kvm/mmu/tdp_iter.c

25

iter->yielded = false;

arch/x86/kvm/mmu/tdp_iter.c

26

iter->yielded_gfn = iter->next_last_level_gfn;

arch/x86/kvm/mmu/tdp_iter.c

27

iter->level = iter->root_level;

arch/x86/kvm/mmu/tdp_iter.c

29

iter->gfn = gfn_round_for_level(iter->next_last_level_gfn, iter->level);

arch/x86/kvm/mmu/tdp_iter.c

30

tdp_iter_refresh_sptep(iter);

arch/x86/kvm/mmu/tdp_iter.c

32

iter->valid = true;

arch/x86/kvm/mmu/tdp_iter.c

39

void tdp_iter_start(struct tdp_iter *iter, struct kvm_mmu_page *root,

arch/x86/kvm/mmu/tdp_iter.c

45

iter->valid = false;

arch/x86/kvm/mmu/tdp_iter.c

49

iter->next_last_level_gfn = next_last_level_gfn;

arch/x86/kvm/mmu/tdp_iter.c

50

iter->gfn_bits = gfn_bits;

arch/x86/kvm/mmu/tdp_iter.c

51

iter->root_level = root->role.level;

arch/x86/kvm/mmu/tdp_iter.c

52

iter->min_level = min_level;

arch/x86/kvm/mmu/tdp_iter.c

53

iter->pt_path[iter->root_level - 1] = (tdp_ptep_t)root->spt;

arch/x86/kvm/mmu/tdp_iter.c

54

iter->as_id = kvm_mmu_page_as_id(root);

arch/x86/kvm/mmu/tdp_iter.c

56

tdp_iter_restart(iter);

arch/x86/kvm/mmu/tdp_iter.c

80

static bool try_step_down(struct tdp_iter *iter)

arch/x86/kvm/mmu/tdp_iter.c

84

if (iter->level == iter->min_level)

arch/x86/kvm/mmu/tdp_iter.c

91

iter->old_spte = kvm_tdp_mmu_read_spte(iter->sptep);

arch/x86/kvm/mmu/tdp_iter.c

93

child_pt = spte_to_child_pt(iter->old_spte, iter->level);

arch/x86/kvm/mmu/tdp_iter.c

97

iter->level--;

arch/x86/kvm/mmu/tdp_iter.c

98

iter->pt_path[iter->level - 1] = child_pt;

arch/x86/kvm/mmu/tdp_iter.c

99

iter->gfn = gfn_round_for_level(iter->next_last_level_gfn, iter->level);

arch/x86/kvm/mmu/tdp_iter.h

123

#define for_each_tdp_pte_min_level(iter, kvm, root, min_level, start, end) \

arch/x86/kvm/mmu/tdp_iter.h

124

for (tdp_iter_start(&iter, root, min_level, start, kvm_gfn_root_bits(kvm, root)); \

arch/x86/kvm/mmu/tdp_iter.h

125

iter.valid && iter.gfn < end; \

arch/x86/kvm/mmu/tdp_iter.h

126

tdp_iter_next(&iter))

arch/x86/kvm/mmu/tdp_iter.h

128

#define for_each_tdp_pte_min_level_all(iter, root, min_level) \

arch/x86/kvm/mmu/tdp_iter.h

129

for (tdp_iter_start(&iter, root, min_level, 0, 0); \

arch/x86/kvm/mmu/tdp_iter.h

130

iter.valid && iter.gfn < tdp_mmu_max_gfn_exclusive(); \

arch/x86/kvm/mmu/tdp_iter.h

131

tdp_iter_next(&iter))

arch/x86/kvm/mmu/tdp_iter.h

133

#define for_each_tdp_pte(iter, kvm, root, start, end) \

arch/x86/kvm/mmu/tdp_iter.h

134

for_each_tdp_pte_min_level(iter, kvm, root, PG_LEVEL_4K, start, end)

arch/x86/kvm/mmu/tdp_iter.h

138

void tdp_iter_start(struct tdp_iter *iter, struct kvm_mmu_page *root,

arch/x86/kvm/mmu/tdp_iter.h

140

void tdp_iter_next(struct tdp_iter *iter);

arch/x86/kvm/mmu/tdp_iter.h

141

void tdp_iter_restart(struct tdp_iter *iter);

arch/x86/kvm/mmu/tdp_mmu.c

1123

struct tdp_iter *iter)

arch/x86/kvm/mmu/tdp_mmu.c

1125

struct kvm_mmu_page *sp = sptep_to_sp(rcu_dereference(iter->sptep));

arch/x86/kvm/mmu/tdp_mmu.c

1133

if (is_shadow_present_pte(iter->old_spte) &&

arch/x86/kvm/mmu/tdp_mmu.c

1134

(fault->prefetch || is_access_allowed(fault, iter->old_spte)) &&

arch/x86/kvm/mmu/tdp_mmu.c

1135

is_last_spte(iter->old_spte, iter->level)) {

arch/x86/kvm/mmu/tdp_mmu.c

1136

WARN_ON_ONCE(fault->pfn != spte_to_pfn(iter->old_spte));

arch/x86/kvm/mmu/tdp_mmu.c

1141

new_spte = make_mmio_spte(vcpu, iter->gfn, sp->role.access);

arch/x86/kvm/mmu/tdp_mmu.c

1143

wrprot = make_spte(vcpu, sp, fault->slot, sp->role.access, iter->gfn,

arch/x86/kvm/mmu/tdp_mmu.c

1144

fault->pfn, iter->old_spte, fault->prefetch,

arch/x86/kvm/mmu/tdp_mmu.c

1147

if (new_spte == iter->old_spte)

arch/x86/kvm/mmu/tdp_mmu.c

1149

else if (tdp_mmu_set_spte_atomic(vcpu->kvm, iter, new_spte))

arch/x86/kvm/mmu/tdp_mmu.c

1151

else if (is_shadow_present_pte(iter->old_spte) &&

arch/x86/kvm/mmu/tdp_mmu.c

1152

(!is_last_spte(iter->old_spte, iter->level) ||

arch/x86/kvm/mmu/tdp_mmu.c

1153

WARN_ON_ONCE(leaf_spte_change_needs_tlb_flush(iter->old_spte, new_spte))))

arch/x86/kvm/mmu/tdp_mmu.c

1154

kvm_flush_remote_tlbs_gfn(vcpu->kvm, iter->gfn, iter->level);

arch/x86/kvm/mmu/tdp_mmu.c

1167

trace_mark_mmio_spte(rcu_dereference(iter->sptep), iter->gfn,

arch/x86/kvm/mmu/tdp_mmu.c

1171

trace_kvm_mmu_set_spte(iter->level, iter->gfn,

arch/x86/kvm/mmu/tdp_mmu.c

1172

rcu_dereference(iter->sptep));

arch/x86/kvm/mmu/tdp_mmu.c

1190

static int tdp_mmu_link_sp(struct kvm *kvm, struct tdp_iter *iter,

arch/x86/kvm/mmu/tdp_mmu.c

1197

ret = tdp_mmu_set_spte_atomic(kvm, iter, spte);

arch/x86/kvm/mmu/tdp_mmu.c

1201

tdp_mmu_iter_set_spte(kvm, iter, spte);

arch/x86/kvm/mmu/tdp_mmu.c

1209

static int tdp_mmu_split_huge_page(struct kvm *kvm, struct tdp_iter *iter,

arch/x86/kvm/mmu/tdp_mmu.c

1220

struct tdp_iter iter;

arch/x86/kvm/mmu/tdp_mmu.c

1232

for_each_tdp_pte(iter, kvm, root, fault->gfn, fault->gfn + 1) {

arch/x86/kvm/mmu/tdp_mmu.c

1236

disallowed_hugepage_adjust(fault, iter.old_spte, iter.level);

arch/x86/kvm/mmu/tdp_mmu.c

1242

if (is_frozen_spte(iter.old_spte))

arch/x86/kvm/mmu/tdp_mmu.c

1245

if (iter.level == fault->goal_level)

arch/x86/kvm/mmu/tdp_mmu.c

1249

if (is_shadow_present_pte(iter.old_spte) &&

arch/x86/kvm/mmu/tdp_mmu.c

1250

!is_large_pte(iter.old_spte))

arch/x86/kvm/mmu/tdp_mmu.c

1258

tdp_mmu_init_child_sp(sp, &iter);

arch/x86/kvm/mmu/tdp_mmu.c

1264

if (is_shadow_present_pte(iter.old_spte)) {

arch/x86/kvm/mmu/tdp_mmu.c

1266

KVM_BUG_ON(is_mirror_sptep(iter.sptep), vcpu->kvm);

arch/x86/kvm/mmu/tdp_mmu.c

1267

r = tdp_mmu_split_huge_page(kvm, &iter, sp, true);

arch/x86/kvm/mmu/tdp_mmu.c

1269

r = tdp_mmu_link_sp(kvm, &iter, sp, true);

arch/x86/kvm/mmu/tdp_mmu.c

1282

fault->req_level >= iter.level) {

arch/x86/kvm/mmu/tdp_mmu.c

1294

WARN_ON_ONCE(iter.level == fault->goal_level);

arch/x86/kvm/mmu/tdp_mmu.c

1298

ret = tdp_mmu_map_handle_target_level(vcpu, fault, &iter);

arch/x86/kvm/mmu/tdp_mmu.c

1329

static void kvm_tdp_mmu_age_spte(struct kvm *kvm, struct tdp_iter *iter)

arch/x86/kvm/mmu/tdp_mmu.c

1334

if (WARN_ON_ONCE(is_mirror_sptep(iter->sptep)))

arch/x86/kvm/mmu/tdp_mmu.c

1337

if (spte_ad_enabled(iter->old_spte)) {

arch/x86/kvm/mmu/tdp_mmu.c

1338

iter->old_spte = tdp_mmu_clear_spte_bits_atomic(iter->sptep,

arch/x86/kvm/mmu/tdp_mmu.c

1340

new_spte = iter->old_spte & ~shadow_accessed_mask;

arch/x86/kvm/mmu/tdp_mmu.c

1342

new_spte = mark_spte_for_access_track(iter->old_spte);

arch/x86/kvm/mmu/tdp_mmu.c

1347

if (__tdp_mmu_set_spte_atomic(kvm, iter, new_spte))

arch/x86/kvm/mmu/tdp_mmu.c

1351

trace_kvm_tdp_mmu_spte_changed(iter->as_id, iter->gfn, iter->level,

arch/x86/kvm/mmu/tdp_mmu.c

1352

iter->old_spte, new_spte);

arch/x86/kvm/mmu/tdp_mmu.c

1361

struct tdp_iter iter;

arch/x86/kvm/mmu/tdp_mmu.c

1376

tdp_root_for_each_leaf_pte(iter, kvm, root, range->start, range->end) {

arch/x86/kvm/mmu/tdp_mmu.c

1377

if (!is_accessed_spte(iter.old_spte))

arch/x86/kvm/mmu/tdp_mmu.c

1384

kvm_tdp_mmu_age_spte(kvm, &iter);

arch/x86/kvm/mmu/tdp_mmu.c

1409

struct tdp_iter iter;

arch/x86/kvm/mmu/tdp_mmu.c

1418

for_each_tdp_pte_min_level(iter, kvm, root, min_level, start, end) {

arch/x86/kvm/mmu/tdp_mmu.c

1420

if (tdp_mmu_iter_cond_resched(kvm, &iter, false, true))

arch/x86/kvm/mmu/tdp_mmu.c

1423

if (!is_shadow_present_pte(iter.old_spte) ||

arch/x86/kvm/mmu/tdp_mmu.c

1424

!is_last_spte(iter.old_spte, iter.level) ||

arch/x86/kvm/mmu/tdp_mmu.c

1425

!(iter.old_spte & PT_WRITABLE_MASK))

arch/x86/kvm/mmu/tdp_mmu.c

1428

new_spte = iter.old_spte & ~PT_WRITABLE_MASK;

arch/x86/kvm/mmu/tdp_mmu.c

1430

if (tdp_mmu_set_spte_atomic(kvm, &iter, new_spte))

arch/x86/kvm/mmu/tdp_mmu.c

1478

static int tdp_mmu_split_huge_page(struct kvm *kvm, struct tdp_iter *iter,

arch/x86/kvm/mmu/tdp_mmu.c

1481

const u64 huge_spte = iter->old_spte;

arch/x86/kvm/mmu/tdp_mmu.c

1482

const int level = iter->level;

arch/x86/kvm/mmu/tdp_mmu.c

1500

ret = tdp_mmu_link_sp(kvm, iter, sp, shared);

arch/x86/kvm/mmu/tdp_mmu.c

1512

trace_kvm_mmu_split_huge_page(iter->gfn, huge_spte, level, ret);

arch/x86/kvm/mmu/tdp_mmu.c

1522

struct tdp_iter iter;

arch/x86/kvm/mmu/tdp_mmu.c

1537

for_each_tdp_pte_min_level(iter, kvm, root, target_level + 1, start, end) {

arch/x86/kvm/mmu/tdp_mmu.c

1539

if (tdp_mmu_iter_cond_resched(kvm, &iter, false, shared))

arch/x86/kvm/mmu/tdp_mmu.c

1542

if (!is_shadow_present_pte(iter.old_spte) || !is_large_pte(iter.old_spte))

arch/x86/kvm/mmu/tdp_mmu.c

1561

trace_kvm_mmu_split_huge_page(iter.gfn,

arch/x86/kvm/mmu/tdp_mmu.c

1562

iter.old_spte,

arch/x86/kvm/mmu/tdp_mmu.c

1563

iter.level, -ENOMEM);

arch/x86/kvm/mmu/tdp_mmu.c

1569

iter.yielded = true;

arch/x86/kvm/mmu/tdp_mmu.c

1573

tdp_mmu_init_child_sp(sp, &iter);

arch/x86/kvm/mmu/tdp_mmu.c

1575

if (tdp_mmu_split_huge_page(kvm, &iter, sp, shared))

arch/x86/kvm/mmu/tdp_mmu.c

1631

struct tdp_iter iter;

arch/x86/kvm/mmu/tdp_mmu.c

1635

tdp_root_for_each_pte(iter, kvm, root, start, end) {

arch/x86/kvm/mmu/tdp_mmu.c

1637

if (!is_shadow_present_pte(iter.old_spte) ||

arch/x86/kvm/mmu/tdp_mmu.c

1638

!is_last_spte(iter.old_spte, iter.level))

arch/x86/kvm/mmu/tdp_mmu.c

1641

if (tdp_mmu_iter_cond_resched(kvm, &iter, false, true))

arch/x86/kvm/mmu/tdp_mmu.c

1645

spte_ad_need_write_protect(iter.old_spte));

arch/x86/kvm/mmu/tdp_mmu.c

1647

if (!(iter.old_spte & dbit))

arch/x86/kvm/mmu/tdp_mmu.c

1650

if (tdp_mmu_set_spte_atomic(kvm, &iter, iter.old_spte & ~dbit))

arch/x86/kvm/mmu/tdp_mmu.c

1677

struct tdp_iter iter;

arch/x86/kvm/mmu/tdp_mmu.c

1683

tdp_root_for_each_leaf_pte(iter, kvm, root, gfn + __ffs(mask),

arch/x86/kvm/mmu/tdp_mmu.c

1689

spte_ad_need_write_protect(iter.old_spte));

arch/x86/kvm/mmu/tdp_mmu.c

1691

if (iter.level > PG_LEVEL_4K ||

arch/x86/kvm/mmu/tdp_mmu.c

1692

!(mask & (1UL << (iter.gfn - gfn))))

arch/x86/kvm/mmu/tdp_mmu.c

1695

mask &= ~(1UL << (iter.gfn - gfn));

arch/x86/kvm/mmu/tdp_mmu.c

1697

if (!(iter.old_spte & dbit))

arch/x86/kvm/mmu/tdp_mmu.c

1700

iter.old_spte = tdp_mmu_clear_spte_bits(iter.sptep,

arch/x86/kvm/mmu/tdp_mmu.c

1701

iter.old_spte, dbit,

arch/x86/kvm/mmu/tdp_mmu.c

1702

iter.level);

arch/x86/kvm/mmu/tdp_mmu.c

1704

trace_kvm_tdp_mmu_spte_changed(iter.as_id, iter.gfn, iter.level,

arch/x86/kvm/mmu/tdp_mmu.c

1705

iter.old_spte,

arch/x86/kvm/mmu/tdp_mmu.c

1706

iter.old_spte & ~dbit);

arch/x86/kvm/mmu/tdp_mmu.c

1735

struct tdp_iter iter;

arch/x86/kvm/mmu/tdp_mmu.c

1737

tdp_root_for_each_leaf_pte(iter, kvm, root, start, end) {

arch/x86/kvm/mmu/tdp_mmu.c

1747

*huge_spte = make_huge_spte(kvm, iter.old_spte, parent->level);

arch/x86/kvm/mmu/tdp_mmu.c

1760

struct tdp_iter iter;

arch/x86/kvm/mmu/tdp_mmu.c

1771

for_each_tdp_pte_min_level(iter, kvm, root, PG_LEVEL_2M, start, end) {

arch/x86/kvm/mmu/tdp_mmu.c

1773

if (tdp_mmu_iter_cond_resched(kvm, &iter, flush, true)) {

arch/x86/kvm/mmu/tdp_mmu.c

1778

if (iter.level > KVM_MAX_HUGEPAGE_LEVEL ||

arch/x86/kvm/mmu/tdp_mmu.c

1779

!is_shadow_present_pte(iter.old_spte))

arch/x86/kvm/mmu/tdp_mmu.c

1787

if (is_last_spte(iter.old_spte, iter.level))

arch/x86/kvm/mmu/tdp_mmu.c

1797

if (iter.gfn < start || iter.gfn >= end)

arch/x86/kvm/mmu/tdp_mmu.c

1800

max_mapping_level = kvm_mmu_max_mapping_level(kvm, NULL, slot, iter.gfn);

arch/x86/kvm/mmu/tdp_mmu.c

1801

if (max_mapping_level < iter.level)

arch/x86/kvm/mmu/tdp_mmu.c

1804

r = tdp_mmu_make_huge_spte(kvm, &iter, &huge_spte);

arch/x86/kvm/mmu/tdp_mmu.c

1810

if (tdp_mmu_set_spte_atomic(kvm, &iter, huge_spte))

arch/x86/kvm/mmu/tdp_mmu.c

1844

struct tdp_iter iter;

arch/x86/kvm/mmu/tdp_mmu.c

1853

for_each_tdp_pte_min_level(iter, kvm, root, min_level, gfn, gfn + 1) {

arch/x86/kvm/mmu/tdp_mmu.c

1854

if (!is_shadow_present_pte(iter.old_spte) ||

arch/x86/kvm/mmu/tdp_mmu.c

1855

!is_last_spte(iter.old_spte, iter.level))

arch/x86/kvm/mmu/tdp_mmu.c

1858

new_spte = iter.old_spte &

arch/x86/kvm/mmu/tdp_mmu.c

1861

if (new_spte == iter.old_spte)

arch/x86/kvm/mmu/tdp_mmu.c

1864

tdp_mmu_iter_set_spte(kvm, &iter, new_spte);

arch/x86/kvm/mmu/tdp_mmu.c

1902

struct tdp_iter iter;

arch/x86/kvm/mmu/tdp_mmu.c

1908

for_each_tdp_pte(iter, vcpu->kvm, root, gfn, gfn + 1) {

arch/x86/kvm/mmu/tdp_mmu.c

1909

leaf = iter.level;

arch/x86/kvm/mmu/tdp_mmu.c

1910

sptes[leaf] = iter.old_spte;

arch/x86/kvm/mmu/tdp_mmu.c

1932

struct tdp_iter iter;

arch/x86/kvm/mmu/tdp_mmu.c

1935

for_each_tdp_pte(iter, vcpu->kvm, root, gfn, gfn + 1) {

arch/x86/kvm/mmu/tdp_mmu.c

1936

*spte = iter.old_spte;

arch/x86/kvm/mmu/tdp_mmu.c

1937

sptep = iter.sptep;

arch/x86/kvm/mmu/tdp_mmu.c

246

struct tdp_iter *iter)

arch/x86/kvm/mmu/tdp_mmu.c

251

parent_sp = sptep_to_sp(rcu_dereference(iter->sptep));

arch/x86/kvm/mmu/tdp_mmu.c

256

tdp_mmu_init_sp(child_sp, iter->sptep, iter->gfn, role);

arch/x86/kvm/mmu/tdp_mmu.c

594

struct tdp_iter *iter,

arch/x86/kvm/mmu/tdp_mmu.c

603

WARN_ON_ONCE(iter->yielded || is_frozen_spte(iter->old_spte));

arch/x86/kvm/mmu/tdp_mmu.c

612

if (!try_cmpxchg64(rcu_dereference(iter->sptep), &iter->old_spte, new_spte))

arch/x86/kvm/mmu/tdp_mmu.c

636

struct tdp_iter *iter,

arch/x86/kvm/mmu/tdp_mmu.c

639

struct kvm_mmu_page *sp = sptep_to_sp(rcu_dereference(iter->sptep));

arch/x86/kvm/mmu/tdp_mmu.c

653

if (is_mirror_sptep(iter->sptep))

arch/x86/kvm/mmu/tdp_mmu.c

654

ret = __tdp_mmu_set_spte_atomic(kvm, iter, FROZEN_SPTE);

arch/x86/kvm/mmu/tdp_mmu.c

656

ret = __tdp_mmu_set_spte_atomic(kvm, iter, new_spte);

arch/x86/kvm/mmu/tdp_mmu.c

669

ret = __handle_changed_spte(kvm, sp, iter->gfn, iter->old_spte,

arch/x86/kvm/mmu/tdp_mmu.c

670

new_spte, iter->level, true);

arch/x86/kvm/mmu/tdp_mmu.c

676

if (is_mirror_sptep(iter->sptep)) {

arch/x86/kvm/mmu/tdp_mmu.c

678

__kvm_tdp_mmu_write_spte(iter->sptep, iter->old_spte);

arch/x86/kvm/mmu/tdp_mmu.c

680

__kvm_tdp_mmu_write_spte(iter->sptep, new_spte);

arch/x86/kvm/mmu/tdp_mmu.c

726

static inline void tdp_mmu_iter_set_spte(struct kvm *kvm, struct tdp_iter *iter,

arch/x86/kvm/mmu/tdp_mmu.c

729

WARN_ON_ONCE(iter->yielded);

arch/x86/kvm/mmu/tdp_mmu.c

730

iter->old_spte = tdp_mmu_set_spte(kvm, iter->sptep, iter->old_spte,

arch/x86/kvm/mmu/tdp_mmu.c

731

new_spte, iter->gfn, iter->level);

arch/x86/kvm/mmu/tdp_mmu.c

745

struct tdp_iter *iter)

arch/x86/kvm/mmu/tdp_mmu.c

751

return iter->next_last_level_gfn != iter->yielded_gfn;

arch/x86/kvm/mmu/tdp_mmu.c

769

struct tdp_iter *iter,

arch/x86/kvm/mmu/tdp_mmu.c

772

KVM_MMU_WARN_ON(iter->yielded);

arch/x86/kvm/mmu/tdp_mmu.c

774

if (!tdp_mmu_iter_need_resched(kvm, iter))

arch/x86/kvm/mmu/tdp_mmu.c

789

WARN_ON_ONCE(iter->gfn > iter->next_last_level_gfn);

arch/x86/kvm/mmu/tdp_mmu.c

791

iter->yielded = true;

arch/x86/kvm/mmu/tdp_mmu.c

809

struct tdp_iter iter;

arch/x86/kvm/mmu/tdp_mmu.c

811

for_each_tdp_pte_min_level_all(iter, root, zap_level) {

arch/x86/kvm/mmu/tdp_mmu.c

813

if (tdp_mmu_iter_cond_resched(kvm, &iter, false, shared))

arch/x86/kvm/mmu/tdp_mmu.c

816

if (!is_shadow_present_pte(iter.old_spte))

arch/x86/kvm/mmu/tdp_mmu.c

819

if (iter.level > zap_level)

arch/x86/kvm/mmu/tdp_mmu.c

823

tdp_mmu_iter_set_spte(kvm, &iter, SHADOW_NONPRESENT_VALUE);

arch/x86/kvm/mmu/tdp_mmu.c

824

else if (tdp_mmu_set_spte_atomic(kvm, &iter, SHADOW_NONPRESENT_VALUE))

arch/x86/kvm/mmu/tdp_mmu.c

879

struct tdp_iter iter = {

arch/x86/kvm/mmu/tdp_mmu.c

907

if ((tdp_ptep_t)sp->spt != spte_to_child_pt(iter.old_spte, iter.level))

arch/x86/kvm/mmu/tdp_mmu.c

918

if (tdp_mmu_set_spte_atomic(kvm, &iter, SHADOW_NONPRESENT_VALUE)) {

arch/x86/kvm/mmu/tdp_mmu.c

919

WARN_ON_ONCE((tdp_ptep_t)sp->spt == spte_to_child_pt(iter.old_spte, iter.level));

arch/x86/kvm/mmu/tdp_mmu.c

936

struct tdp_iter iter;

arch/x86/kvm/mmu/tdp_mmu.c

944

for_each_tdp_pte_min_level(iter, kvm, root, PG_LEVEL_4K, start, end) {

arch/x86/kvm/mmu/tdp_mmu.c

946

tdp_mmu_iter_cond_resched(kvm, &iter, flush, false)) {

arch/x86/kvm/mmu/tdp_mmu.c

951

if (!is_shadow_present_pte(iter.old_spte) ||

arch/x86/kvm/mmu/tdp_mmu.c

952

!is_last_spte(iter.old_spte, iter.level))

arch/x86/kvm/mmu/tdp_mmu.c

955

tdp_mmu_iter_set_spte(kvm, &iter, SHADOW_NONPRESENT_VALUE);

arch/xtensa/platforms/iss/simdisk.c

108

struct bvec_iter iter;

arch/xtensa/platforms/iss/simdisk.c

111

bio_for_each_segment(bvec, bio, iter) {

block/bio-integrity.c

266

struct iov_iter iter;

block/bio-integrity.c

275

iov_iter_bvec(&iter, ITER_SOURCE, bvec, nr_vecs, len);

block/bio-integrity.c

276

if (!copy_from_iter_full(buf, len, &iter)) {

block/bio-integrity.c

367

int bio_integrity_map_user(struct bio *bio, struct iov_iter *iter)

block/bio-integrity.c

373

size_t offset, bytes = iter->count;

block/bio-integrity.c

383

nr_vecs = iov_iter_npages(iter, BIO_MAX_VECS + 1);

block/bio-integrity.c

393

copy = iov_iter_alignment(iter) &

block/bio-integrity.c

399

ret = iov_iter_extract_pages(iter, &pages, bytes, nr_vecs,

block/bio-integrity.c

408

if (user_backed_iter(iter) && unlikely(ret != bytes)) {

block/bio-integrity.c

477

it = meta->iter;

block/bio-integrity.c

493

iov_iter_advance(&meta->iter, integrity_bytes);

block/bio.c

1185

void bio_iov_bvec_set(struct bio *bio, const struct iov_iter *iter)

block/bio.c

1189

bio->bi_io_vec = (struct bio_vec *)iter->bvec;

block/bio.c

1191

bio->bi_iter.bi_bvec_done = iter->iov_offset;

block/bio.c

1192

bio->bi_iter.bi_size = iov_iter_count(iter);

block/bio.c

1201

static int bio_iov_iter_align_down(struct bio *bio, struct iov_iter *iter,

block/bio.c

1209

iov_iter_revert(iter, nbytes);

block/bio.c

1245

int bio_iov_iter_get_pages(struct bio *bio, struct iov_iter *iter,

block/bio.c

1253

if (iov_iter_is_bvec(iter)) {

block/bio.c

1254

bio_iov_bvec_set(bio, iter);

block/bio.c

1255

iov_iter_advance(iter, bio->bi_iter.bi_size);

block/bio.c

1259

if (iov_iter_extract_will_pin(iter))

block/bio.c

1267

ret = iov_iter_extract_bvecs(iter, bio->bi_io_vec,

block/bio.c

1276

} while (iov_iter_count(iter) && !bio_full(bio, 0));

block/bio.c

1280

return bio_iov_iter_align_down(bio, iter,

block/bio.c

1313

static int bio_iov_iter_bounce_write(struct bio *bio, struct iov_iter *iter,

block/bio.c

1316

size_t total_len = min(maxlen, iov_iter_count(iter));

block/bio.c

1341

if (iter->nofault)

block/bio.c

1343

iter);

block/bio.c

1345

copied = copy_folio_from_iter(folio, 0, this_len, iter);

block/bio.c

1356

iov_iter_revert(iter, bio->bi_iter.bi_size - this_len +

block/bio.c

1366

return bio_iov_iter_align_down(bio, iter,

block/bio.c

1370

static int bio_iov_iter_bounce_read(struct bio *bio, struct iov_iter *iter,

block/bio.c

1373

size_t len = min3(iov_iter_count(iter), maxlen, SZ_1M);

block/bio.c

1382

ret = iov_iter_extract_bvecs(iter, bio->bi_io_vec + 1, len,

block/bio.c

1400

if (iov_iter_extract_will_pin(iter))

block/bio.c

1404

ret = bio_iov_iter_align_down(bio, iter,

block/bio.c

1431

int bio_iov_iter_bounce(struct bio *bio, struct iov_iter *iter, size_t maxlen,

block/bio.c

1435

return bio_iov_iter_bounce_write(bio, iter, maxlen, minsize);

block/bio.c

1436

return bio_iov_iter_bounce_read(bio, iter, maxlen, minsize);

block/bio.c

649

struct bvec_iter iter;

block/bio.c

651

bio_for_each_segment(bv, bio, iter)

block/bio.c

669

struct bvec_iter iter;

block/bio.c

679

bio_for_each_segment(bv, bio, iter) {

block/blk-cgroup.c

1091

struct class_dev_iter iter;

block/blk-cgroup.c

1094

class_dev_iter_init(&iter, &block_class, NULL, &disk_type);

block/blk-cgroup.c

1095

while ((dev = class_dev_iter_next(&iter))) {

block/blk-cgroup.c

1126

class_dev_iter_exit(&iter);

block/blk-crypto-fallback.c

374

struct bio_crypt_ctx *bc, struct bvec_iter iter,

block/blk-crypto-fallback.c

395

__bio_for_each_segment(bv, bio, iter, iter) {

block/blk-integrity.c

127

struct iov_iter iter;

block/blk-integrity.c

129

iov_iter_ubuf(&iter, rq_data_dir(rq), ubuf, bytes);

block/blk-integrity.c

130

ret = bio_integrity_map_user(rq->bio, &iter);

block/blk-integrity.c

33

struct bvec_iter iter;

block/blk-integrity.c

36

bio_for_each_integrity_vec(iv, bio, iter) {

block/blk-map.c

109

&iter);

block/blk-map.c

111

if (!iov_iter_count(&iter))

block/blk-map.c

142

ret = bio_copy_to_iter(bio, bmd->iter);

block/blk-map.c

151

struct iov_iter *iter, gfp_t gfp_mask)

block/blk-map.c

158

unsigned int len = iter->count;

block/blk-map.c

161

bmd = bio_alloc_map_data(iter, gfp_mask);

block/blk-map.c

17

struct iov_iter iter;

block/blk-map.c

226

if (iov_iter_rw(iter) == WRITE &&

block/blk-map.c

228

ret = bio_copy_from_iter(bio, iter);

block/blk-map.c

232

struct iov_iter iter2 = *iter;

block/blk-map.c

242

iov_iter_advance(iter, bio->bi_iter.bi_size);

block/blk-map.c

260

static int bio_map_user_iov(struct request *rq, struct iov_iter *iter,

block/blk-map.c

263

unsigned int nr_vecs = iov_iter_npages(iter, BIO_MAX_VECS);

block/blk-map.c

267

if (!iov_iter_count(iter))

block/blk-map.c

277

ret = bio_iov_iter_get_pages(bio, iter, 0);

block/blk-map.c

32

bmd->iter = *data;

block/blk-map.c

35

bmd->iter.__iov = bmd->iov;

block/blk-map.c

463

static int blk_rq_map_user_bvec(struct request *rq, const struct iov_iter *iter)

block/blk-map.c

469

if (!iov_iter_count(iter) || iov_iter_count(iter) > max_bytes)

block/blk-map.c

476

bio_iov_bvec_set(bio, iter);

block/blk-map.c

501

const struct iov_iter *iter, gfp_t gfp_mask)

block/blk-map.c

511

else if (iov_iter_alignment(iter) & align)

block/blk-map.c

513

else if (iov_iter_is_bvec(iter))

block/blk-map.c

515

else if (!user_backed_iter(iter))

block/blk-map.c

518

copy = queue_virt_boundary(q) & iov_iter_gap_alignment(iter);

block/blk-map.c

521

ret = blk_rq_map_user_bvec(rq, iter);

block/blk-map.c

530

i = *iter;

block/blk-map.c

578

struct iov_iter iter;

block/blk-map.c

581

UIO_FASTIOV, &iov, &iter);

block/blk-map.c

587

iov_iter_truncate(&iter, buf_len);

block/blk-map.c

588

if (check_iter_count && !iov_iter_count(&iter)) {

block/blk-map.c

594

ret = blk_rq_map_user_iov(req->q, req, map_data, &iter,

block/blk-map.c

67

static int bio_copy_from_iter(struct bio *bio, struct iov_iter *iter)

block/blk-map.c

78

iter);

block/blk-map.c

80

if (!iov_iter_count(iter))

block/blk-map.c

98

static int bio_copy_to_iter(struct bio *bio, struct iov_iter iter)

block/blk-merge.c

27

struct bvec_iter iter = bio->bi_iter;

block/blk-merge.c

34

bio_advance_iter(bio, &iter, iter.bi_size);

block/blk-merge.c

341

struct bvec_iter iter;

block/blk-merge.c

349

bio_for_each_bvec(bv, bio, iter) {

block/blk-merge.c

36

if (!iter.bi_bvec_done)

block/blk-merge.c

37

idx = iter.bi_idx - 1;

block/blk-merge.c

39

idx = iter.bi_idx;

block/blk-merge.c

47

if (iter.bi_bvec_done)

block/blk-merge.c

48

bv->bv_len = iter.bi_bvec_done;

block/blk-merge.c

491

struct req_iterator iter;

block/blk-merge.c

514

rq_for_each_bvec(bv, rq, iter)

block/blk-mq-dma.c

101

iter->len = vec->len;

block/blk-mq-dma.c

106

struct dma_iova_state *state, struct blk_dma_iter *iter,

block/blk-mq-dma.c

11

if (iter->iter.bi_size)

block/blk-mq-dma.c

114

iter->addr = state->addr;

block/blk-mq-dma.c

115

iter->len = dma_iova_size(state);

block/blk-mq-dma.c

117

if (iter->p2pdma.map == PCI_P2PDMA_MAP_THRU_HOST_BRIDGE)

block/blk-mq-dma.c

126

} while (blk_map_iter_next(req, &iter->iter, vec));

block/blk-mq-dma.c

13

if (!iter->bio || !iter->bio->bi_next)

block/blk-mq-dma.c

136

iter->status = errno_to_blk_status(error);

block/blk-mq-dma.c

141

struct blk_map_iter *iter)

block/blk-mq-dma.c

146

*iter = (struct blk_map_iter) {

block/blk-mq-dma.c

148

.iter = {

block/blk-mq-dma.c

153

*iter = (struct blk_map_iter) {

block/blk-mq-dma.c

156

.iter = bio->bi_iter,

block/blk-mq-dma.c

16

iter->bio = iter->bio->bi_next;

block/blk-mq-dma.c

160

*iter = (struct blk_map_iter) {};

block/blk-mq-dma.c

165

struct dma_iova_state *state, struct blk_dma_iter *iter,

block/blk-mq-dma.c

17

if (iter->is_integrity) {

block/blk-mq-dma.c

170

memset(&iter->p2pdma, 0, sizeof(iter->p2pdma));

block/blk-mq-dma.c

171

iter->status = BLK_STS_OK;

block/blk-mq-dma.c

172

iter->p2pdma.map = PCI_P2PDMA_MAP_NONE;

block/blk-mq-dma.c

178

if (!blk_map_iter_next(req, &iter->iter, &vec))

block/blk-mq-dma.c

18

iter->iter = bio_integrity(iter->bio)->bip_iter;

block/blk-mq-dma.c

181

switch (pci_p2pdma_state(&iter->p2pdma, dma_dev,

block/blk-mq-dma.c

184

return blk_dma_map_bus(iter, &vec);

block/blk-mq-dma.c

19

iter->bvecs = bio_integrity(iter->bio)->bip_vec;

block/blk-mq-dma.c

193

iter->status = BLK_STS_INVAL;

block/blk-mq-dma.c

199

return blk_rq_dma_map_iova(req, dma_dev, state, iter, &vec);

block/blk-mq-dma.c

201

return blk_dma_map_direct(req, dma_dev, iter, &vec);

block/blk-mq-dma.c

21

iter->iter = iter->bio->bi_iter;

block/blk-mq-dma.c

22

iter->bvecs = iter->bio->bi_io_vec;

block/blk-mq-dma.c

227

struct dma_iova_state *state, struct blk_dma_iter *iter)

block/blk-mq-dma.c

229

blk_rq_map_iter_init(req, &iter->iter);

block/blk-mq-dma.c

230

return blk_dma_map_iter_start(req, dma_dev, state, iter,

block/blk-mq-dma.c

253

struct blk_dma_iter *iter)

block/blk-mq-dma.c

257

if (!blk_map_iter_next(req, &iter->iter, &vec))

block/blk-mq-dma.c

260

if (iter->p2pdma.map == PCI_P2PDMA_MAP_BUS_ADDR)

block/blk-mq-dma.c

261

return blk_dma_map_bus(iter, &vec);

block/blk-mq-dma.c

262

return blk_dma_map_direct(req, dma_dev, iter, &vec);

block/blk-mq-dma.c

27

static bool blk_map_iter_next(struct request *req, struct blk_map_iter *iter,

block/blk-mq-dma.c

290

struct blk_map_iter iter;

block/blk-mq-dma.c

294

blk_rq_map_iter_init(rq, &iter);

block/blk-mq-dma.c

295

while (blk_map_iter_next(rq, &iter, &vec)) {

block/blk-mq-dma.c

33

if (!iter->iter.bi_size)

block/blk-mq-dma.c

343

struct blk_dma_iter *iter)

block/blk-mq-dma.c

349

iter->iter = (struct blk_map_iter) {

block/blk-mq-dma.c

351

.iter = bio_integrity(bio)->bip_iter,

block/blk-mq-dma.c

355

return blk_dma_map_iter_start(req, dma_dev, state, iter, len);

block/blk-mq-dma.c

36

bv = mp_bvec_iter_bvec(iter->bvecs, iter->iter);

block/blk-mq-dma.c

379

struct device *dma_dev, struct blk_dma_iter *iter)

block/blk-mq-dma.c

383

if (!blk_map_iter_next(req, &iter->iter, &vec))

block/blk-mq-dma.c

386

if (iter->p2pdma.map == PCI_P2PDMA_MAP_BUS_ADDR)

block/blk-mq-dma.c

387

return blk_dma_map_bus(iter, &vec);

block/blk-mq-dma.c

388

return blk_dma_map_direct(req, dma_dev, iter, &vec);

block/blk-mq-dma.c

40

bvec_iter_advance_single(iter->bvecs, &iter->iter, bv.bv_len);

block/blk-mq-dma.c

410

struct blk_map_iter iter = {

block/blk-mq-dma.c

412

.iter = bio_integrity(bio)->bip_iter,

block/blk-mq-dma.c

417

while (blk_map_iter_next(rq, &iter, &vec)) {

block/blk-mq-dma.c

47

while (!iter->iter.bi_size || !iter->iter.bi_bvec_done) {

block/blk-mq-dma.c

50

if (!__blk_map_iter_next(iter))

block/blk-mq-dma.c

53

next = mp_bvec_iter_bvec(iter->bvecs, iter->iter);

block/blk-mq-dma.c

59

bvec_iter_advance_single(iter->bvecs, &iter->iter, next.bv_len);

block/blk-mq-dma.c

80

static bool blk_dma_map_bus(struct blk_dma_iter *iter, struct phys_vec *vec)

block/blk-mq-dma.c

82

iter->addr = pci_p2pdma_bus_addr_map(iter->p2pdma.mem, vec->paddr);

block/blk-mq-dma.c

83

iter->len = vec->len;

block/blk-mq-dma.c

88

struct blk_dma_iter *iter, struct phys_vec *vec)

block/blk-mq-dma.c

9

static bool __blk_map_iter_next(struct blk_map_iter *iter)

block/blk-mq-dma.c

92

if (iter->p2pdma.map == PCI_P2PDMA_MAP_THRU_HOST_BRIDGE)

block/blk-mq-dma.c

95

iter->addr = dma_map_phys(dma_dev, vec->paddr, vec->len,

block/blk-mq-dma.c

97

if (dma_mapping_error(dma_dev, iter->addr)) {

block/blk-mq-dma.c

98

iter->status = BLK_STS_RESOURCE;

block/early-lookup.c

127

struct class_dev_iter iter;

block/early-lookup.c

130

class_dev_iter_init(&iter, &block_class, NULL, &disk_type);

block/early-lookup.c

131

while ((dev = class_dev_iter_next(&iter))) {

block/early-lookup.c

149

class_dev_iter_exit(&iter);

block/early-lookup.c

274

struct class_dev_iter iter;

block/early-lookup.c

277

class_dev_iter_init(&iter, &block_class, NULL, &disk_type);

block/early-lookup.c

278

while ((dev = class_dev_iter_next(&iter))) {

block/early-lookup.c

315

class_dev_iter_exit(&iter);

block/fops.c

175

static ssize_t __blkdev_direct_IO(struct kiocb *iocb, struct iov_iter *iter,

block/fops.c

181

bool is_read = (iov_iter_rw(iter) == READ), is_sync;

block/fops.c

206

if (is_read && user_backed_iter(iter))

block/fops.c

219

ret = blkdev_iov_iter_get_pages(bio, iter, bdev);

block/fops.c

233

if (unlikely(iov_iter_count(iter))) {

block/fops.c

254

nr_pages = bio_iov_vecs_to_alloc(iter, BIO_MAX_VECS);

block/fops.c

321

struct iov_iter *iter,

block/fops.c

325

bool is_read = iov_iter_rw(iter) == READ;

block/fops.c

343

if (iov_iter_is_bvec(iter)) {

block/fops.c

350

bio_iov_bvec_set(bio, iter);

block/fops.c

352

ret = blkdev_iov_iter_get_pages(bio, iter, bdev);

block/fops.c

359

if (user_backed_iter(iter)) {

block/fops.c

394

static ssize_t blkdev_direct_IO(struct kiocb *iocb, struct iov_iter *iter)

block/fops.c

399

if (!iov_iter_count(iter))

block/fops.c

40

struct iov_iter *iter)

block/fops.c

402

if (blkdev_dio_invalid(bdev, iocb, iter))

block/fops.c

405

if (iov_iter_rw(iter) == WRITE) {

block/fops.c

42

return (iocb->ki_pos | iov_iter_count(iter)) &

block/fops.c

425

nr_pages = bio_iov_vecs_to_alloc(iter, BIO_MAX_VECS + 1);

block/fops.c

429

return __blkdev_direct_IO_simple(iocb, iter, bdev,

block/fops.c

431

return __blkdev_direct_IO_async(iocb, iter, bdev, nr_pages);

block/fops.c

435

return __blkdev_direct_IO(iocb, iter, bdev, bio_max_segs(nr_pages));

block/fops.c

47

struct iov_iter *iter, struct block_device *bdev)

block/fops.c

49

return bio_iov_iter_get_pages(bio, iter,

block/fops.c

56

struct iov_iter *iter, struct block_device *bdev,

block/fops.c

73

if (iov_iter_rw(iter) == READ) {

block/fops.c

75

if (user_backed_iter(iter))

block/fops.c

87

ret = blkdev_iov_iter_get_pages(&bio, iter, bdev);

block/fops.c

92

if (iov_iter_rw(iter) == WRITE)

block/genhd.c

910

struct class_dev_iter *iter;

block/genhd.c

913

iter = kmalloc_obj(*iter);

block/genhd.c

914

if (!iter)

block/genhd.c

917

seqf->private = iter;

block/genhd.c

918

class_dev_iter_init(iter, &block_class, NULL, &disk_type);

block/genhd.c

920

dev = class_dev_iter_next(iter);

block/genhd.c

942

struct class_dev_iter *iter = seqf->private;

block/genhd.c

945

if (iter) {

block/genhd.c

946

class_dev_iter_exit(iter);

block/genhd.c

947

kfree(iter);

block/sed-opal.c

1017

struct opal_resp_tok *iter;

block/sed-opal.c

1051

iter = resp->toks;

block/sed-opal.c

1056

token_length = response_parse_tiny(iter, pos);

block/sed-opal.c

1058

token_length = response_parse_short(iter, pos);

block/sed-opal.c

1060

token_length = response_parse_medium(iter, pos);

block/sed-opal.c

1062

token_length = response_parse_long(iter, pos);

block/sed-opal.c

1066

token_length = response_parse_token(iter, pos);

block/sed-opal.c

1076

iter++;

block/sed-opal.c

1242

struct opal_suspend_data *iter;

block/sed-opal.c

1244

list_for_each_entry(iter, &dev->unlk_lst, node) {

block/sed-opal.c

1245

if (iter->lr == sus->lr) {

block/sed-opal.c

1246

list_del(&iter->node);

block/sed-opal.c

1247

kfree(iter);

block/sed-opal.c

1583

int *iter,

block/sed-opal.c

1588

int n = *iter;

block/sed-opal.c

1622

*iter = n;

block/sed-opal.c

2940

struct opal_suspend_data *iter;

block/sed-opal.c

2961

list_for_each_entry(iter, &dev->unlk_lst, node) {

block/sed-opal.c

2962

if ((iter->unlk.flags & OPAL_SAVE_FOR_LOCK) &&

block/sed-opal.c

2963

iter->lr == lk_unlk->session.opal_key.lr &&

block/sed-opal.c

2964

iter->unlk.session.opal_key.key_len > 0) {

block/sed-opal.c

2966

iter->unlk.session.opal_key.key_len;

block/sed-opal.c

2968

iter->unlk.session.opal_key.key,

block/sed-opal.c

2969

iter->unlk.session.opal_key.key_len);

block/t10-pi.c

104

bvec_iter_advance_single(bip->bip_vec, iter, len);

block/t10-pi.c

111

struct bvec_iter *iter, void *tuple,

block/t10-pi.c

115

struct bio_vec pbv = bvec_iter_bvec(bip->bip_vec, *iter);

block/t10-pi.c

121

bvec_iter_advance_single(bip->bip_vec, iter, len);

block/t10-pi.c

134

static blk_status_t blk_verify_ext_pi(struct blk_integrity_iter *iter,

block/t10-pi.c

137

u64 seed = lower_48_bits(iter->seed);

block/t10-pi.c

142

if (iter->bi->flags & BLK_INTEGRITY_REF_TAG) {

block/t10-pi.c

147

iter->bio->bi_bdev->bd_disk->disk_name, seed,

block/t10-pi.c

155

if (guard != iter->csum) {

block/t10-pi.c

157

iter->bio->bi_bdev->bd_disk->disk_name, iter->seed,

block/t10-pi.c

158

guard, iter->csum);

block/t10-pi.c

165

static blk_status_t blk_verify_pi(struct blk_integrity_iter *iter,

block/t10-pi.c

168

u32 seed = lower_32_bits(iter->seed);

block/t10-pi.c

172

if (iter->bi->flags & BLK_INTEGRITY_REF_TAG) {

block/t10-pi.c

177

iter->bio->bi_bdev->bd_disk->disk_name, seed,

block/t10-pi.c

185

if (guard != (u16)iter->csum) {

block/t10-pi.c

187

iter->bio->bi_bdev->bd_disk->disk_name, iter->seed,

block/t10-pi.c

188

guard, (u16)iter->csum);

block/t10-pi.c

195

static blk_status_t blk_verify_t10_pi(struct blk_integrity_iter *iter,

block/t10-pi.c

200

return blk_verify_pi(iter, pi, guard);

block/t10-pi.c

203

static blk_status_t blk_verify_ip_pi(struct blk_integrity_iter *iter,

block/t10-pi.c

208

return blk_verify_pi(iter, pi, guard);

block/t10-pi.c

211

static blk_status_t blk_integrity_verify(struct blk_integrity_iter *iter,

block/t10-pi.c

214

switch (iter->bi->csum_type) {

block/t10-pi.c

216

return blk_verify_ext_pi(iter, &tuple->crc64_pi);

block/t10-pi.c

218

return blk_verify_t10_pi(iter, &tuple->t10_pi);

block/t10-pi.c

220

return blk_verify_ip_pi(iter, &tuple->t10_pi);

block/t10-pi.c

226

static void blk_set_ext_pi(struct blk_integrity_iter *iter,

block/t10-pi.c

229

put_unaligned_be64(iter->csum, &pi->guard_tag);

block/t10-pi.c

231

put_unaligned_be48(iter->seed, &pi->ref_tag);

block/t10-pi.c

234

static void blk_set_pi(struct blk_integrity_iter *iter,

block/t10-pi.c

239

put_unaligned_be32(iter->seed, &pi->ref_tag);

block/t10-pi.c

242

static void blk_set_t10_pi(struct blk_integrity_iter *iter,

block/t10-pi.c

245

blk_set_pi(iter, pi, cpu_to_be16((u16)iter->csum));

block/t10-pi.c

248

static void blk_set_ip_pi(struct blk_integrity_iter *iter,

block/t10-pi.c

251

blk_set_pi(iter, pi, (__force __be16)(u16)iter->csum);

block/t10-pi.c

254

static void blk_integrity_set(struct blk_integrity_iter *iter,

block/t10-pi.c

257

switch (iter->bi->csum_type) {

block/t10-pi.c

259

return blk_set_ext_pi(iter, &tuple->crc64_pi);

block/t10-pi.c

261

return blk_set_t10_pi(iter, &tuple->t10_pi);

block/t10-pi.c

263

return blk_set_ip_pi(iter, &tuple->t10_pi);

block/t10-pi.c

270

static blk_status_t blk_integrity_interval(struct blk_integrity_iter *iter,

block/t10-pi.c

278

blk_integrity_csum_offset(iter);

block/t10-pi.c

279

pbv = bvec_iter_bvec(iter->bip->bip_vec, iter->prot_iter);

block/t10-pi.c

280

if (pbv.bv_len >= iter->bi->pi_tuple_size) {

block/t10-pi.c

282

bvec_iter_advance_single(iter->bip->bip_vec, &iter->prot_iter,

block/t10-pi.c

283

iter->bi->metadata_size - iter->bi->pi_offset);

block/t10-pi.c

285

blk_integrity_copy_to_tuple(iter->bip, &iter->prot_iter,

block/t10-pi.c

286

ptuple, iter->bi->pi_tuple_size);

block/t10-pi.c

290

ret = blk_integrity_verify(iter, ptuple);

block/t10-pi.c

292

blk_integrity_set(iter, ptuple);

block/t10-pi.c

297

blk_integrity_copy_from_tuple(iter->bip, &iter->prot_iter,

block/t10-pi.c

298

ptuple, iter->bi->pi_tuple_size);

block/t10-pi.c

301

iter->interval_remaining = 1 << iter->bi->interval_exp;

block/t10-pi.c

302

iter->csum = 0;

block/t10-pi.c

303

iter->seed++;

block/t10-pi.c

313

struct blk_integrity_iter iter = {

block/t10-pi.c

325

while (iter.data_iter.bi_size && ret == BLK_STS_OK) {

block/t10-pi.c

326

struct bio_vec bv = bvec_iter_bvec(iter.bio->bi_io_vec,

block/t10-pi.c

327

iter.data_iter);

block/t10-pi.c

332

bvec_iter_advance_single(iter.bio->bi_io_vec, &iter.data_iter,

block/t10-pi.c

335

len = min(iter.interval_remaining, bv.bv_len);

block/t10-pi.c

336

blk_calculate_guard(&iter, data, len);

block/t10-pi.c

339

iter.interval_remaining -= len;

block/t10-pi.c

340

if (!iter.interval_remaining)

block/t10-pi.c

341

ret = blk_integrity_interval(&iter, verify);

block/t10-pi.c

386

struct bvec_iter *iter)

block/t10-pi.c

39

static void blk_calculate_guard(struct blk_integrity_iter *iter, void *data,

block/t10-pi.c

391

struct bio_vec bv = mp_bvec_iter_bvec(bip->bip_vec, *iter);

block/t10-pi.c

394

bvec_iter_advance_single(bip->bip_vec, iter, len);

block/t10-pi.c

402

struct bvec_iter *iter)

block/t10-pi.c

407

blk_pi_advance_offset(bi, bip, iter);

block/t10-pi.c

408

pbv = bvec_iter_bvec(bip->bip_vec, *iter);

block/t10-pi.c

416

titer = *iter;

block/t10-pi.c

42

switch (iter->bi->csum_type) {

block/t10-pi.c

424

struct bvec_iter *iter)

block/t10-pi.c

431

blk_integrity_copy_from_tuple(bip, iter, ptuple,

block/t10-pi.c

436

bvec_iter_advance(bip->bip_vec, iter, len);

block/t10-pi.c

44

iter->csum = crc64_nvme(iter->csum, data, len);

block/t10-pi.c

47

iter->csum = crc_t10dif_update(iter->csum, data, len);

block/t10-pi.c

50

iter->csum = (__force u32)csum_partial(data, len,

block/t10-pi.c

51

(__force __wsum)iter->csum);

block/t10-pi.c

513

struct bvec_iter iter = bip->bip_iter;

block/t10-pi.c

523

while (iter.bi_size && *intervals) {

block/t10-pi.c

524

ptuple = blk_tuple_remap_begin(&tuple, bi, bip, &iter);

block/t10-pi.c

531

blk_tuple_remap_end(&tuple, ptuple, bi, bip, &iter);

block/t10-pi.c

55

iter->csum = U64_MAX;

block/t10-pi.c

60

static void blk_integrity_csum_finish(struct blk_integrity_iter *iter)

block/t10-pi.c

62

switch (iter->bi->csum_type) {

block/t10-pi.c

64

iter->csum = (__force u16)csum_fold((__force __wsum)iter->csum);

block/t10-pi.c

75

static void blk_integrity_csum_offset(struct blk_integrity_iter *iter)

block/t10-pi.c

77

unsigned int offset = iter->bi->pi_offset;

block/t10-pi.c

78

struct bio_vec *bvec = iter->bip->bip_vec;

block/t10-pi.c

81

struct bio_vec pbv = bvec_iter_bvec(bvec, iter->prot_iter);

block/t10-pi.c

85

blk_calculate_guard(iter, prot_buf, len);

block/t10-pi.c

88

bvec_iter_advance_single(bvec, &iter->prot_iter, len);

block/t10-pi.c

90

blk_integrity_csum_finish(iter);

block/t10-pi.c

94

struct bvec_iter *iter, void *tuple,

block/t10-pi.c

98

struct bio_vec pbv = bvec_iter_bvec(bip->bip_vec, *iter);

drivers/accel/habanalabs/common/command_submission.c

508

struct hl_cs *next = NULL, *iter, *first_cs;

drivers/accel/habanalabs/common/command_submission.c

543

list_for_each_entry(iter, &hdev->cs_mirror_list, mirror_node)

drivers/accel/habanalabs/common/command_submission.c

544

if (cs_needs_timeout(iter)) {

drivers/accel/habanalabs/common/command_submission.c

545

next = iter;

drivers/accel/habanalabs/common/hldio.c

266

iov_iter_bvec(&io->iter, io->type, io->bv, 1, io->len_bytes);

drivers/accel/habanalabs/common/hldio.c

268

rc = io->f.filp->f_op->read_iter(&io->kio, &io->iter);

drivers/accel/habanalabs/common/hldio.c

55

struct iov_iter iter;

drivers/acpi/acpi_ipmi.c

359

struct acpi_ipmi_msg *tx_msg = NULL, *iter, *temp;

drivers/acpi/acpi_ipmi.c

363

list_for_each_entry_safe(iter, temp, &ipmi->tx_msg_list, head) {

drivers/acpi/acpi_ipmi.c

364

if (msg == iter) {

drivers/acpi/acpi_ipmi.c

365

tx_msg = iter;

drivers/acpi/acpi_ipmi.c

366

list_del(&iter->head);

drivers/acpi/acpi_ipmi.c

379

struct acpi_ipmi_msg *tx_msg = NULL, *iter, *temp;

drivers/acpi/acpi_ipmi.c

391

list_for_each_entry_safe(iter, temp, &ipmi_device->tx_msg_list, head) {

drivers/acpi/acpi_ipmi.c

392

if (msg->msgid == iter->tx_msgid) {

drivers/acpi/acpi_ipmi.c

393

tx_msg = iter;

drivers/acpi/acpi_ipmi.c

394

list_del(&iter->head);

drivers/acpi/acpi_ipmi.c

488

struct acpi_ipmi_device *ipmi_device = NULL, *iter, *temp;

drivers/acpi/acpi_ipmi.c

491

list_for_each_entry_safe(iter, temp,

drivers/acpi/acpi_ipmi.c

493

if (iter->ipmi_ifnum == iface) {

drivers/acpi/acpi_ipmi.c

494

ipmi_device = iter;

drivers/acpi/acpi_ipmi.c

495

__ipmi_dev_kill(iter);

drivers/acpi/pfr_update.c

471

struct iov_iter iter;

drivers/acpi/pfr_update.c

487

iov_iter_init(&iter, ITER_SOURCE, &iov, 1, len);

drivers/acpi/pfr_update.c

497

if (!copy_from_iter_full(buf_ptr, len, &iter)) {

drivers/base/attribute_container.c

180

#define klist_for_each_entry(pos, head, member, iter) \

drivers/base/attribute_container.c

181

for (klist_iter_init(head, iter); (pos = ({ \

drivers/base/attribute_container.c

182

struct klist_node *n = klist_next(iter); \

drivers/base/attribute_container.c

184

({ klist_iter_exit(iter) ; NULL; }); \

drivers/base/attribute_container.c

214

struct klist_iter iter;

drivers/base/attribute_container.c

222

klist_for_each_entry(ic, &cont->containers, node, &iter) {

drivers/base/attribute_container.c

247

struct klist_iter iter;

drivers/base/attribute_container.c

252

klist_for_each_entry(ic, &cont->containers, node, &iter) {

drivers/base/attribute_container.c

257

klist_iter_exit(&iter);

drivers/base/attribute_container.c

269

klist_for_each_entry(ic, &cont->containers, node, &iter) {

drivers/base/attribute_container.c

271

klist_iter_exit(&iter);

drivers/base/attribute_container.c

360

struct klist_iter iter;

drivers/base/attribute_container.c

370

klist_for_each_entry(ic, &cont->containers, node, &iter) {

drivers/base/attribute_container.c

487

struct klist_iter iter;

drivers/base/attribute_container.c

489

klist_for_each_entry(ic, &cont->containers, node, &iter) {

drivers/base/attribute_container.c

493

klist_iter_exit(&iter);

drivers/base/bus.c

1176

static void subsys_dev_iter_init(struct subsys_dev_iter *iter, struct subsys_private *sp,

drivers/base/bus.c

1183

klist_iter_init_node(&sp->klist_devices, &iter->ki, start_knode);

drivers/base/bus.c

1184

iter->type = type;

drivers/base/bus.c

1199

static struct device *subsys_dev_iter_next(struct subsys_dev_iter *iter)

drivers/base/bus.c

1205

knode = klist_next(&iter->ki);

drivers/base/bus.c

1209

if (!iter->type || iter->type == dev->type)

drivers/base/bus.c

1221

static void subsys_dev_iter_exit(struct subsys_dev_iter *iter)

drivers/base/bus.c

1223

klist_iter_exit(&iter->ki);

drivers/base/bus.c

1229

struct subsys_dev_iter iter;

drivers/base/bus.c

1247

subsys_dev_iter_init(&iter, sp, NULL, NULL);

drivers/base/bus.c

1248

while ((dev = subsys_dev_iter_next(&iter)))

drivers/base/bus.c

1250

subsys_dev_iter_exit(&iter);

drivers/base/bus.c

1261

struct subsys_dev_iter iter;

drivers/base/bus.c

1274

subsys_dev_iter_init(&iter, sp, NULL, NULL);

drivers/base/bus.c

1275

while ((dev = subsys_dev_iter_next(&iter)))

drivers/base/bus.c

1277

subsys_dev_iter_exit(&iter);

drivers/base/class.c

320

void class_dev_iter_init(struct class_dev_iter *iter, const struct class *class,

drivers/base/class.c

326

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

drivers/base/class.c

335

klist_iter_init_node(&sp->klist_devices, &iter->ki, start_knode);

drivers/base/class.c

336

iter->type = type;

drivers/base/class.c

337

iter->sp = sp;

drivers/base/class.c

353

struct device *class_dev_iter_next(struct class_dev_iter *iter)

drivers/base/class.c

358

if (!iter->sp)

drivers/base/class.c

362

knode = klist_next(&iter->ki);

drivers/base/class.c

366

if (!iter->type || iter->type == dev->type)

drivers/base/class.c

379

void class_dev_iter_exit(struct class_dev_iter *iter)

drivers/base/class.c

381

klist_iter_exit(&iter->ki);

drivers/base/class.c

382

subsys_put(iter->sp);

drivers/base/class.c

408

struct class_dev_iter iter;

drivers/base/class.c

420

class_dev_iter_init(&iter, class, start, NULL);

drivers/base/class.c

421

while ((dev = class_dev_iter_next(&iter))) {

drivers/base/class.c

426

class_dev_iter_exit(&iter);

drivers/base/class.c

457

struct class_dev_iter iter;

drivers/base/class.c

468

class_dev_iter_init(&iter, class, start, NULL);

drivers/base/class.c

469

while ((dev = class_dev_iter_next(&iter))) {

drivers/base/class.c

475

class_dev_iter_exit(&iter);

drivers/base/class.c

486

struct class_dev_iter iter;

drivers/base/class.c

505

class_dev_iter_init(&iter, parent, NULL, NULL);

drivers/base/class.c

506

while ((dev = class_dev_iter_next(&iter)))

drivers/base/class.c

508

class_dev_iter_exit(&iter);

drivers/base/class.c

520

struct class_dev_iter iter;

drivers/base/class.c

533

class_dev_iter_init(&iter, parent, NULL, NULL);

drivers/base/class.c

534

while ((dev = class_dev_iter_next(&iter)))

drivers/base/class.c

536

class_dev_iter_exit(&iter);

drivers/block/aoe/aoe.h

111

struct bvec_iter iter;

drivers/block/aoe/aoe.h

129

struct bvec_iter iter;

drivers/block/aoe/aoecmd.c

1025

bvcpy(struct sk_buff *skb, struct bio *bio, struct bvec_iter iter, long cnt)

drivers/block/aoe/aoecmd.c

1030

iter.bi_size = cnt;

drivers/block/aoe/aoecmd.c

1032

__bio_for_each_segment(bv, bio, iter, iter) {

drivers/block/aoe/aoecmd.c

1131

if (n > f->iter.bi_size) {

drivers/block/aoe/aoecmd.c

1135

n, f->iter.bi_size);

drivers/block/aoe/aoecmd.c

1139

bvcpy(skb, f->buf->bio, f->iter, n);

drivers/block/aoe/aoecmd.c

1183

if (buf && --buf->nframesout == 0 && buf->iter.bi_size == 0)

drivers/block/aoe/aoecmd.c

1639

buf->iter.bi_size = 0;

drivers/block/aoe/aoecmd.c

198

memset(&f->iter, 0, sizeof(f->iter));

drivers/block/aoe/aoecmd.c

296

skb_fillup(struct sk_buff *skb, struct bio *bio, struct bvec_iter iter)

drivers/block/aoe/aoecmd.c

301

__bio_for_each_segment(bv, bio, iter, iter)

drivers/block/aoe/aoecmd.c

342

ah->scnt = f->iter.bi_size >> 9;

drivers/block/aoe/aoecmd.c

343

put_lba(ah, f->iter.bi_sector);

drivers/block/aoe/aoecmd.c

352

skb_fillup(skb, f->buf->bio, f->iter);

drivers/block/aoe/aoecmd.c

354

skb->len += f->iter.bi_size;

drivers/block/aoe/aoecmd.c

355

skb->data_len = f->iter.bi_size;

drivers/block/aoe/aoecmd.c

356

skb->truesize += f->iter.bi_size;

drivers/block/aoe/aoecmd.c

385

f->iter = buf->iter;

drivers/block/aoe/aoecmd.c

386

f->iter.bi_size = min_t(unsigned long,

drivers/block/aoe/aoecmd.c

388

f->iter.bi_size);

drivers/block/aoe/aoecmd.c

389

bio_advance_iter(buf->bio, &buf->iter, f->iter.bi_size);

drivers/block/aoe/aoecmd.c

391

if (!buf->iter.bi_size)

drivers/block/aoe/aoecmd.c

575

nf->iter = f->iter;

drivers/block/aoe/aoecmd.c

606

f->iter.bi_size = t->d->maxbcnt ? t->d->maxbcnt : DEFAULTBCNT;

drivers/block/aoe/aoecmd.c

609

for (frag = 0, n = f->iter.bi_size; n > 0; ++frag, n -= m) {

drivers/block/aoe/aoecmd.c

616

skb->len += f->iter.bi_size;

drivers/block/aoe/aoecmd.c

617

skb->data_len = f->iter.bi_size;

drivers/block/aoe/aoecmd.c

618

skb->truesize += f->iter.bi_size;

drivers/block/aoe/aoecmd.c

839

buf->iter = bio->bi_iter;

drivers/block/drbd/drbd_main.c

1571

struct bvec_iter iter;

drivers/block/drbd/drbd_main.c

1574

bio_for_each_segment(bvec, bio, iter) {

drivers/block/drbd/drbd_main.c

1579

bio_iter_last(bvec, iter)

drivers/block/drbd/drbd_main.c

1590

struct bvec_iter iter;

drivers/block/drbd/drbd_main.c

1593

bio_for_each_segment(bvec, bio, iter) {

drivers/block/drbd/drbd_main.c

1598

bio_iter_last(bvec, iter) ? 0 : MSG_MORE);

drivers/block/drbd/drbd_receiver.c

1798

struct bvec_iter iter;

drivers/block/drbd/drbd_receiver.c

1825

bio_for_each_segment(bvec, bio, iter) {

drivers/block/drbd/drbd_req.c

332

struct drbd_request *iter = req;

drivers/block/drbd/drbd_req.c

339

list_for_each_entry_continue(iter, &connection->transfer_log, tl_requests) {

drivers/block/drbd/drbd_req.c

340

const unsigned int s = iter->rq_state;

drivers/block/drbd/drbd_req.c

343

req = iter;

drivers/block/drbd/drbd_req.c

362

struct drbd_request *iter = req;

drivers/block/drbd/drbd_req.c

369

list_for_each_entry_continue(iter, &connection->transfer_log, tl_requests) {

drivers/block/drbd/drbd_req.c

370

const unsigned int s = iter->rq_state;

drivers/block/drbd/drbd_req.c

373

req = iter;

drivers/block/drbd/drbd_req.c

392

struct drbd_request *iter = req;

drivers/block/drbd/drbd_req.c

399

list_for_each_entry_continue(iter, &connection->transfer_log, tl_requests) {

drivers/block/drbd/drbd_req.c

400

const unsigned int s = iter->rq_state;

drivers/block/drbd/drbd_req.c

403

req = iter;

drivers/block/drbd/drbd_worker.c

320

struct bvec_iter iter;

drivers/block/drbd/drbd_worker.c

326

bio_for_each_segment(bvec, bio, iter) {

drivers/block/floppy.c

2432

struct req_iterator iter;

drivers/block/floppy.c

2462

rq_for_each_segment(bv, current_req, iter) {

drivers/block/loop.c

343

struct iov_iter iter;

drivers/block/loop.c

370

iov_iter_bvec(&iter, rw, cmd->bvec, nr_bvec, blk_rq_bytes(rq));

drivers/block/loop.c

371

iter.iov_offset = 0;

drivers/block/loop.c

378

iov_iter_bvec(&iter, rw,

drivers/block/loop.c

381

iter.iov_offset = rq->bio->bi_iter.bi_bvec_done;

drivers/block/loop.c

398

ret = file->f_op->write_iter(&cmd->iocb, &iter);

drivers/block/loop.c

400

ret = file->f_op->read_iter(&cmd->iocb, &iter);

drivers/block/n64cart.c

91

struct bvec_iter iter;

drivers/block/n64cart.c

95

bio_for_each_segment(bvec, bio, iter) {

drivers/block/nbd.c

552

struct iov_iter *iter, int msg_flags, int *sent)

drivers/block/nbd.c

565

msg.msg_iter = *iter;

drivers/block/nbd.c

600

struct iov_iter *iter, int msg_flags, int *sent)

drivers/block/nbd.c

605

return __sock_xmit(nbd, sock, send, iter, msg_flags, sent);

drivers/block/nbd.c

743

struct bvec_iter iter;

drivers/block/nbd.c

746

bio_for_each_segment(bvec, bio, iter) {

drivers/block/nbd.c

747

bool is_last = !next && bio_iter_last(bvec, iter);

drivers/block/nbd.c

937

struct req_iterator iter;

drivers/block/nbd.c

941

rq_for_each_segment(bvec, req, iter) {

drivers/block/null_blk/main.c

1292

struct req_iterator iter;

drivers/block/null_blk/main.c

1296

rq_for_each_segment(bvec, rq, iter) {

drivers/block/ps3disk.c

111

struct req_iterator iter;

drivers/block/ps3disk.c

113

rq_for_each_segment(bv, req, iter)

drivers/block/ps3disk.c

84

struct req_iterator iter;

drivers/block/ps3disk.c

87

rq_for_each_segment(bvec, req, iter) {

drivers/block/ps3disk.c

89

__func__, __LINE__, bio_sectors(iter.bio),

drivers/block/ps3disk.c

90

iter.bio->bi_iter.bi_sector);

drivers/block/ps3vram.c

537

struct bvec_iter iter;

drivers/block/ps3vram.c

540

bio_for_each_segment(bvec, bio, iter) {

drivers/block/rbd.c

2168

rbd_assert(obj_req->bvec_pos.iter.bi_size ==

drivers/block/rbd.c

2463

union rbd_img_fill_iter iter;

drivers/block/rbd.c

2508

fctx->iter = *fctx->pos;

drivers/block/rbd.c

2515

fctx->set_pos_fn, &fctx->iter);

drivers/block/rbd.c

2560

fctx->iter = *fctx->pos;

drivers/block/rbd.c

2567

fctx->count_fn, &fctx->iter);

drivers/block/rbd.c

2584

fctx->iter = *fctx->pos;

drivers/block/rbd.c

2590

fctx->copy_fn, &fctx->iter);

drivers/block/rbd.c

2644

obj_req->bvec_pos.iter.bi_size += bv.bv_len;

drivers/block/rbd.c

2669

struct ceph_bio_iter it = { .bio = bio, .iter = bio->bi_iter };

drivers/block/rbd.c

2704

obj_req->bvec_pos.iter.bi_size += bv.bv_len;

drivers/block/rbd.c

2732

.iter = { .bi_size = ceph_file_extents_bytes(img_extents,

drivers/block/rbd.c

3000

.iter = { .bi_size = bytes },

drivers/block/rbd.c

751

struct rbd_client *rbdc = NULL, *iter;

drivers/block/rbd.c

757

list_for_each_entry(iter, &rbd_client_list, node) {

drivers/block/rbd.c

758

if (!ceph_compare_options(ceph_opts, iter->client)) {

drivers/block/rbd.c

759

__rbd_get_client(iter);

drivers/block/rbd.c

761

rbdc = iter;

drivers/block/ublk_drv.c

1411

struct req_iterator iter;

drivers/block/ublk_drv.c

1415

rq_for_each_segment(bv, req, iter) {

drivers/block/ublk_drv.c

1428

struct bvec_iter iter;

drivers/block/ublk_drv.c

1434

bio_for_each_integrity_vec(iv, bio, iter) {

drivers/block/ublk_drv.c

1475

struct iov_iter iter;

drivers/block/ublk_drv.c

1478

import_ubuf(dir, u64_to_user_ptr(io->buf.addr), rq_bytes, &iter);

drivers/block/ublk_drv.c

1479

return ublk_copy_user_pages(req, 0, &iter, dir);

drivers/block/ublk_drv.c

1494

struct iov_iter iter;

drivers/block/ublk_drv.c

1499

import_ubuf(dir, u64_to_user_ptr(io->buf.addr), io->res, &iter);

drivers/block/ublk_drv.c

1500

return ublk_copy_user_pages(req, 0, &iter, dir);

drivers/block/ublk_drv.c

3595

struct ublk_batch_io_iter *iter,

drivers/block/ublk_drv.c

3605

for (i = 0; i < bytes; i += iter->elem_bytes) {

drivers/block/ublk_drv.c

3607

(const struct ublk_elem_header *)&iter->buf[i];

drivers/block/ublk_drv.c

3619

iter->done += i;

drivers/block/ublk_drv.c

3623

static int ublk_walk_cmd_buf(struct ublk_batch_io_iter *iter,

drivers/block/ublk_drv.c

3632

while (iter->done < iter->total) {

drivers/block/ublk_drv.c

3633

unsigned int len = min(sizeof(iter->buf), iter->total - iter->done);

drivers/block/ublk_drv.c

3635

if (iter->kaddr) {

drivers/block/ublk_drv.c

3636

memcpy(iter->buf, iter->kaddr + iter->done, len);

drivers/block/ublk_drv.c

3637

} else if (copy_from_user(iter->buf, iter->uaddr + iter->done,

drivers/block/ublk_drv.c

3644

ret = __ublk_walk_cmd_buf(ubq, iter, data, len, cb);

drivers/block/ublk_drv.c

3676

static void ublk_batch_revert_prep_cmd(struct ublk_batch_io_iter *iter,

drivers/block/ublk_drv.c

3682

iter->total = iter->done;

drivers/block/ublk_drv.c

3683

iter->done = 0;

drivers/block/ublk_drv.c

3685

ret = ublk_walk_cmd_buf(iter, data, ublk_batch_unprep_io);

drivers/block/ublk_drv.c

3724

struct ublk_batch_io_iter iter = {

drivers/block/ublk_drv.c

3732

cmd_buf = vmemdup_user(iter.uaddr, iter.total);

drivers/block/ublk_drv.c

3735

iter.kaddr = cmd_buf;

drivers/block/ublk_drv.c

3738

ret = ublk_walk_cmd_buf(&iter, data, ublk_batch_prep_io);

drivers/block/ublk_drv.c

3740

if (ret && iter.done)

drivers/block/ublk_drv.c

3741

ublk_batch_revert_prep_cmd(&iter, data);

drivers/block/ublk_drv.c

3812

struct ublk_batch_io_iter iter = {

drivers/block/ublk_drv.c

3821

ret = ublk_walk_cmd_buf(&iter, data, ublk_batch_commit_io);

drivers/block/ublk_drv.c

3826

return iter.done == 0 ? ret : iter.done;

drivers/block/ublk_drv.c

4049

ublk_user_copy(struct kiocb *iocb, struct iov_iter *iter, int dir)

drivers/block/ublk_drv.c

4062

if (!user_backed_iter(iter))

drivers/block/ublk_drv.c

4120

ret = ublk_copy_user_integrity(req, buf_off, iter, dir);

drivers/block/ublk_drv.c

4122

ret = ublk_copy_user_pages(req, buf_off, iter, dir);

drivers/block/ublk_drv.c

5595

struct req_iterator iter;

drivers/block/ublk_drv.c

5601

rq_for_each_bvec(bv, rq, iter) {

drivers/block/zloop.c

526

struct iov_iter iter;

drivers/block/zloop.c

546

iov_iter_bvec(&iter, rw, cmd->bvec, nr_bvec, blk_rq_bytes(rq));

drivers/block/zloop.c

553

iov_iter_bvec(&iter, rw,

drivers/block/zloop.c

556

iter.iov_offset = rq->bio->bi_iter.bi_bvec_done;

drivers/block/zloop.c

567

return zone->file->f_op->write_iter(&cmd->iocb, &iter);

drivers/block/zloop.c

568

return zone->file->f_op->read_iter(&cmd->iocb, &iter);

drivers/block/zram/zram_drv.c

2714

struct bvec_iter iter = bio->bi_iter;

drivers/block/zram/zram_drv.c

2717

u32 index = iter.bi_sector >> SECTORS_PER_PAGE_SHIFT;

drivers/block/zram/zram_drv.c

2718

u32 offset = (iter.bi_sector & (SECTORS_PER_PAGE - 1)) <<

drivers/block/zram/zram_drv.c

2720

struct bio_vec bv = bio_iter_iovec(bio, iter);

drivers/block/zram/zram_drv.c

2735

bio_advance_iter_single(bio, &iter, bv.bv_len);

drivers/block/zram/zram_drv.c

2736

} while (iter.bi_size);

drivers/block/zram/zram_drv.c

2745

struct bvec_iter iter = bio->bi_iter;

drivers/block/zram/zram_drv.c

2748

u32 index = iter.bi_sector >> SECTORS_PER_PAGE_SHIFT;

drivers/block/zram/zram_drv.c

2749

u32 offset = (iter.bi_sector & (SECTORS_PER_PAGE - 1)) <<

drivers/block/zram/zram_drv.c

2751

struct bio_vec bv = bio_iter_iovec(bio, iter);

drivers/block/zram/zram_drv.c

2765

bio_advance_iter_single(bio, &iter, bv.bv_len);

drivers/block/zram/zram_drv.c

2766

} while (iter.bi_size);

drivers/char/mem.c

450

static ssize_t read_iter_zero(struct kiocb *iocb, struct iov_iter *iter)

drivers/char/mem.c

454

while (iov_iter_count(iter)) {

drivers/char/mem.c

455

size_t chunk = iov_iter_count(iter), n;

drivers/char/mem.c

459

n = iov_iter_zero(chunk, iter);

drivers/char/mem.c

460

if (!n && iov_iter_count(iter))

drivers/char/misc.c

121

struct miscdevice *c = NULL, *iter;

drivers/char/misc.c

127

list_for_each_entry(iter, &misc_list, list) {

drivers/char/misc.c

128

if (iter->minor != minor)

drivers/char/misc.c

130

c = iter;

drivers/char/misc.c

131

new_fops = fops_get(iter->fops);

drivers/char/misc.c

141

list_for_each_entry(iter, &misc_list, list) {

drivers/char/misc.c

142

if (iter->minor != minor)

drivers/char/misc.c

144

c = iter;

drivers/char/misc.c

145

new_fops = fops_get(iter->fops);

drivers/char/random.c

1382

struct iov_iter iter;

drivers/char/random.c

1403

ret = import_ubuf(ITER_DEST, ubuf, len, &iter);

drivers/char/random.c

1406

return get_random_bytes_user(&iter);

drivers/char/random.c

1415

static ssize_t write_pool_user(struct iov_iter *iter)

drivers/char/random.c

1421

if (unlikely(!iov_iter_count(iter)))

drivers/char/random.c

1425

copied = copy_from_iter(block, sizeof(block), iter);

drivers/char/random.c

1428

if (!iov_iter_count(iter) || copied != sizeof(block))

drivers/char/random.c

1443

static ssize_t random_write_iter(struct kiocb *kiocb, struct iov_iter *iter)

drivers/char/random.c

1445

return write_pool_user(iter);

drivers/char/random.c

1448

static ssize_t urandom_read_iter(struct kiocb *kiocb, struct iov_iter *iter)

drivers/char/random.c

1465

current->comm, iov_iter_count(iter));

drivers/char/random.c

1469

return get_random_bytes_user(iter);

drivers/char/random.c

1472

static ssize_t random_read_iter(struct kiocb *kiocb, struct iov_iter *iter)

drivers/char/random.c

1484

return get_random_bytes_user(iter);

drivers/char/random.c

1508

struct iov_iter iter;

drivers/char/random.c

1520

ret = import_ubuf(ITER_SOURCE, p, len, &iter);

drivers/char/random.c

1523

ret = write_pool_user(&iter);

drivers/char/random.c

431

static ssize_t get_random_bytes_user(struct iov_iter *iter)

drivers/char/random.c

437

if (unlikely(!iov_iter_count(iter)))

drivers/char/random.c

452

if (iov_iter_count(iter) <= CHACHA_KEY_SIZE) {

drivers/char/random.c

453

ret = copy_to_iter(&chacha_state.x[4], CHACHA_KEY_SIZE, iter);

drivers/char/random.c

462

copied = copy_to_iter(block, sizeof(block), iter);

drivers/char/random.c

464

if (!iov_iter_count(iter) || copied != sizeof(block))

drivers/char/xillybus/xillybus_class.c

179

struct xilly_unit *unit = NULL, *iter;

drivers/char/xillybus/xillybus_class.c

183

list_for_each_entry(iter, &unit_list, list_entry)

drivers/char/xillybus/xillybus_class.c

184

if (iter->private_data == private_data) {

drivers/char/xillybus/xillybus_class.c

185

unit = iter;

drivers/char/xillybus/xillybus_class.c

220

struct xilly_unit *unit = NULL, *iter;

drivers/char/xillybus/xillybus_class.c

224

list_for_each_entry(iter, &unit_list, list_entry)

drivers/char/xillybus/xillybus_class.c

225

if (iter->major == major &&

drivers/char/xillybus/xillybus_class.c

226

minor >= iter->lowest_minor &&

drivers/char/xillybus/xillybus_class.c

227

minor < (iter->lowest_minor + iter->num_nodes)) {

drivers/char/xillybus/xillybus_class.c

228

unit = iter;

drivers/clk/ti/clkctrl.c

228

struct omap_clkctrl_clk *entry = NULL, *iter;

drivers/clk/ti/clkctrl.c

236

list_for_each_entry(iter, &provider->clocks, node) {

drivers/clk/ti/clkctrl.c

237

if (iter->reg_offset == clkspec->args[0] &&

drivers/clk/ti/clkctrl.c

238

iter->bit_offset == clkspec->args[1]) {

drivers/clk/ti/clkctrl.c

239

entry = iter;

drivers/crypto/cavium/nitrox/nitrox_main.c

271

struct nitrox_device *ndev = NULL, *iter;

drivers/crypto/cavium/nitrox/nitrox_main.c

274

list_for_each_entry(iter, &ndevlist, list) {

drivers/crypto/cavium/nitrox/nitrox_main.c

275

if (nitrox_ready(iter)) {

drivers/crypto/cavium/nitrox/nitrox_main.c

276

ndev = iter;

drivers/crypto/marvell/cesa/cesa.h

550

struct sg_mapping_iter iter;

drivers/crypto/marvell/cesa/cesa.h

790

static inline void mv_cesa_req_dma_iter_init(struct mv_cesa_dma_iter *iter,

drivers/crypto/marvell/cesa/cesa.h

793

iter->len = len;

drivers/crypto/marvell/cesa/cesa.h

794

iter->op_len = min(len, CESA_SA_SRAM_PAYLOAD_SIZE);

drivers/crypto/marvell/cesa/cesa.h

795

iter->offset = 0;

drivers/crypto/marvell/cesa/cesa.h

798

static inline void mv_cesa_sg_dma_iter_init(struct mv_cesa_sg_dma_iter *iter,

drivers/crypto/marvell/cesa/cesa.h

802

iter->op_offset = 0;

drivers/crypto/marvell/cesa/cesa.h

803

iter->offset = 0;

drivers/crypto/marvell/cesa/cesa.h

804

iter->sg = sg;

drivers/crypto/marvell/cesa/cesa.h

805

iter->dir = dir;

drivers/crypto/marvell/cesa/cesa.h

809

mv_cesa_req_dma_iter_transfer_len(struct mv_cesa_dma_iter *iter,

drivers/crypto/marvell/cesa/cesa.h

812

return min(iter->op_len - sgiter->op_offset,

drivers/crypto/marvell/cesa/cesa.h

820

static inline bool mv_cesa_req_dma_iter_next_op(struct mv_cesa_dma_iter *iter)

drivers/crypto/marvell/cesa/cesa.h

822

iter->offset += iter->op_len;

drivers/crypto/marvell/cesa/cesa.h

823

iter->op_len = min(iter->len - iter->offset,

drivers/crypto/marvell/cesa/cesa.h

826

return iter->op_len;

drivers/crypto/marvell/cesa/cipher.c

321

struct mv_cesa_skcipher_dma_iter iter;

drivers/crypto/marvell/cesa/cipher.c

348

mv_cesa_skcipher_req_iter_init(&iter, req);

drivers/crypto/marvell/cesa/cipher.c

361

mv_cesa_set_crypt_op_len(op, iter.base.op_len);

drivers/crypto/marvell/cesa/cipher.c

364

ret = mv_cesa_dma_add_op_transfers(&basereq->chain, &iter.base,

drivers/crypto/marvell/cesa/cipher.c

365

&iter.src, flags);

drivers/crypto/marvell/cesa/cipher.c

375

ret = mv_cesa_dma_add_op_transfers(&basereq->chain, &iter.base,

drivers/crypto/marvell/cesa/cipher.c

376

&iter.dst, flags);

drivers/crypto/marvell/cesa/cipher.c

380

} while (mv_cesa_skcipher_req_iter_next_op(&iter));

drivers/crypto/marvell/cesa/cipher.c

41

mv_cesa_skcipher_req_iter_init(struct mv_cesa_skcipher_dma_iter *iter,

drivers/crypto/marvell/cesa/cipher.c

44

mv_cesa_req_dma_iter_init(&iter->base, req->cryptlen);

drivers/crypto/marvell/cesa/cipher.c

45

mv_cesa_sg_dma_iter_init(&iter->src, req->src, DMA_TO_DEVICE);

drivers/crypto/marvell/cesa/cipher.c

46

mv_cesa_sg_dma_iter_init(&iter->dst, req->dst, DMA_FROM_DEVICE);

drivers/crypto/marvell/cesa/cipher.c

50

mv_cesa_skcipher_req_iter_next_op(struct mv_cesa_skcipher_dma_iter *iter)

drivers/crypto/marvell/cesa/cipher.c

52

iter->src.op_offset = 0;

drivers/crypto/marvell/cesa/cipher.c

53

iter->dst.op_offset = 0;

drivers/crypto/marvell/cesa/cipher.c

55

return mv_cesa_req_dma_iter_next_op(&iter->base);

drivers/crypto/marvell/cesa/hash.c

27

mv_cesa_ahash_req_iter_init(struct mv_cesa_ahash_dma_iter *iter,

drivers/crypto/marvell/cesa/hash.c

36

mv_cesa_req_dma_iter_init(&iter->base, len);

drivers/crypto/marvell/cesa/hash.c

37

mv_cesa_sg_dma_iter_init(&iter->src, req->src, DMA_TO_DEVICE);

drivers/crypto/marvell/cesa/hash.c

38

iter->src.op_offset = creq->cache_ptr;

drivers/crypto/marvell/cesa/hash.c

42

mv_cesa_ahash_req_iter_next_op(struct mv_cesa_ahash_dma_iter *iter)

drivers/crypto/marvell/cesa/hash.c

44

iter->src.op_offset = 0;

drivers/crypto/marvell/cesa/hash.c

46

return mv_cesa_req_dma_iter_next_op(&iter->base);

drivers/crypto/marvell/cesa/hash.c

631

struct mv_cesa_ahash_dma_iter iter;

drivers/crypto/marvell/cesa/hash.c

654

mv_cesa_ahash_req_iter_init(&iter, req);

drivers/crypto/marvell/cesa/hash.c

664

if (iter.base.len > iter.src.op_offset) {

drivers/crypto/marvell/cesa/hash.c

672

&iter.base,

drivers/crypto/marvell/cesa/hash.c

673

&iter.src, flags);

drivers/crypto/marvell/cesa/hash.c

677

frag_len = iter.base.op_len;

drivers/crypto/marvell/cesa/hash.c

679

if (!mv_cesa_ahash_req_iter_next_op(&iter))

drivers/crypto/marvell/cesa/hash.c

692

frag_len = iter.base.op_len;

drivers/crypto/marvell/cesa/hash.c

701

op = mv_cesa_ahash_dma_last_req(&basereq->chain, &iter, creq,

drivers/crypto/marvell/cesa/hash.c

729

iter.base.len;

drivers/crypto/marvell/cesa/tdma.c

15

bool mv_cesa_req_dma_iter_next_transfer(struct mv_cesa_dma_iter *iter,

drivers/crypto/marvell/cesa/tdma.c

31

if (sgiter->op_offset == iter->op_len)

drivers/crypto/talitos.c

547

int tail, iter;

drivers/crypto/talitos.c

560

iter = tail;

drivers/crypto/talitos.c

562

request = &priv->chan[ch].fifo[iter];

drivers/crypto/talitos.c

568

iter = (iter + 1) & (priv->fifo_len - 1);

drivers/crypto/talitos.c

569

} while (iter != tail);

drivers/cxl/core/port.c

1021

struct cxl_port *iter = port;

drivers/cxl/core/port.c

1023

while (iter && !is_cxl_root(iter))

drivers/cxl/core/port.c

1024

iter = to_cxl_port(iter->dev.parent);

drivers/cxl/core/port.c

1026

if (!iter)

drivers/cxl/core/port.c

1028

get_device(&iter->dev);

drivers/cxl/core/port.c

1029

return to_cxl_root(iter);

drivers/cxl/core/port.c

1802

struct device *iter;

drivers/cxl/core/port.c

1822

for (iter = dev; iter; iter = grandparent(iter)) {

drivers/cxl/core/port.c

1823

struct device *dport_dev = grandparent(iter);

drivers/cxl/core/port.c

1833

dev_name(iter), dev_name(dport_dev));

drivers/cxl/core/port.c

1838

dev_name(iter), dev_name(dport_dev),

drivers/cxl/core/port.c

2375

struct cxl_port *iter = port;

drivers/cxl/core/port.c

2399

dport = iter->parent_dport;

drivers/cxl/core/port.c

2400

iter = to_cxl_port(iter->dev.parent);

drivers/cxl/core/port.c

2401

is_cxl_root = parent_port_is_cxl_root(iter);

drivers/cxl/core/port.c

2415

dport = iter->parent_dport;

drivers/cxl/core/port.c

712

struct cxl_port *iter;

drivers/cxl/core/port.c

723

iter = port;

drivers/cxl/core/port.c

724

while (!iter->host_bridge &&

drivers/cxl/core/port.c

725

!is_cxl_root(to_cxl_port(iter->dev.parent)))

drivers/cxl/core/port.c

726

iter = to_cxl_port(iter->dev.parent);

drivers/cxl/core/port.c

727

if (iter->host_bridge)

drivers/cxl/core/port.c

728

port->host_bridge = iter->host_bridge;

drivers/cxl/core/port.c

732

port->host_bridge = iter->uport_dev;

drivers/cxl/core/region.c

1020

struct cxl_region_ref *cxl_rr, *iter;

drivers/cxl/core/region.c

1024

xa_for_each(&port->regions, index, iter) {

drivers/cxl/core/region.c

1025

struct cxl_region_params *ip = &iter->region->params;

drivers/cxl/core/region.c

1031

if (auto_order_ok(port, iter->region, cxld))

drivers/cxl/core/region.c

1036

dev_name(&iter->region->dev), ip->res, p->res);

drivers/cxl/core/region.c

1450

struct cxl_port *iter = port;

drivers/cxl/core/region.c

1481

cxl_rr_iter = cxl_rr_load(iter, cxlr);

drivers/cxl/core/region.c

1483

iter = to_cxl_port(iter->dev.parent);

drivers/cxl/core/region.c

1484

} while (!is_cxl_root(iter));

drivers/cxl/core/region.c

1671

struct cxl_port *iter;

drivers/cxl/core/region.c

1690

iter = cxled_to_port(cxled);

drivers/cxl/core/region.c

1691

while (!is_cxl_root(to_cxl_port(iter->dev.parent)))

drivers/cxl/core/region.c

1692

iter = to_cxl_port(iter->dev.parent);

drivers/cxl/core/region.c

1694

for (ep = cxl_ep_load(iter, cxlmd); iter;

drivers/cxl/core/region.c

1695

iter = ep->next, ep = cxl_ep_load(iter, cxlmd))

drivers/cxl/core/region.c

1696

cxl_port_reset_targets(iter, cxlr);

drivers/cxl/core/region.c

1707

struct cxl_port *iter;

drivers/cxl/core/region.c

1723

iter = cxled_to_port(cxled);

drivers/cxl/core/region.c

1724

while (!is_cxl_root(to_cxl_port(iter->dev.parent)))

drivers/cxl/core/region.c

1725

iter = to_cxl_port(iter->dev.parent);

drivers/cxl/core/region.c

1731

for (ep = cxl_ep_load(iter, cxlmd); iter;

drivers/cxl/core/region.c

1732

iter = ep->next, ep = cxl_ep_load(iter, cxlmd)) {

drivers/cxl/core/region.c

1733

rc = cxl_port_setup_targets(iter, cxlr, cxled);

drivers/cxl/core/region.c

1807

struct cxl_port *iter;

drivers/cxl/core/region.c

1817

for (iter = cxled_to_port(cxled); !is_cxl_root(iter);

drivers/cxl/core/region.c

1818

iter = to_cxl_port(iter->dev.parent)) {

drivers/cxl/core/region.c

1819

rc = cxl_port_attach_region(iter, cxlr, cxled, pos);

drivers/cxl/core/region.c

1827

for (iter = cxled_to_port(cxled); !is_cxl_root(iter);

drivers/cxl/core/region.c

1828

iter = to_cxl_port(iter->dev.parent))

drivers/cxl/core/region.c

1829

cxl_port_detach_region(iter, cxlr, cxled);

drivers/cxl/core/region.c

1972

struct cxl_port *iter, *port = cxled_to_port(cxled);

drivers/cxl/core/region.c

2007

for (iter = port; iter; iter = parent_port_of(iter)) {

drivers/cxl/core/region.c

2008

if (is_cxl_root(iter))

drivers/cxl/core/region.c

2011

rc = find_pos_and_ways(iter, hpa_range, &parent_pos,

drivers/cxl/core/region.c

2306

for (struct cxl_port *iter = cxled_to_port(cxled); !is_cxl_root(iter);

drivers/cxl/core/region.c

2307

iter = to_cxl_port(iter->dev.parent))

drivers/cxl/core/region.c

2308

cxl_port_detach_region(iter, cxlr, cxled);

drivers/cxl/core/region.c

264

struct cxl_port *iter = cxled_to_port(cxled);

drivers/cxl/core/region.c

271

while (!is_cxl_root(to_cxl_port(iter->dev.parent)))

drivers/cxl/core/region.c

272

iter = to_cxl_port(iter->dev.parent);

drivers/cxl/core/region.c

274

for (ep = cxl_ep_load(iter, cxlmd); iter;

drivers/cxl/core/region.c

275

iter = ep->next, ep = cxl_ep_load(iter, cxlmd)) {

drivers/cxl/core/region.c

279

cxl_rr = cxl_rr_load(iter, cxlr);

drivers/cxl/core/region.c

321

struct cxl_port *iter;

drivers/cxl/core/region.c

325

for (iter = cxled_to_port(cxled); !is_cxl_root(iter);

drivers/cxl/core/region.c

326

iter = to_cxl_port(iter->dev.parent)) {

drivers/cxl/core/region.c

327

cxl_rr = cxl_rr_load(iter, cxlr);

drivers/cxl/core/region.c

336

for (ep = cxl_ep_load(iter, cxlmd); ep && iter;

drivers/cxl/core/region.c

337

iter = ep->next, ep = cxl_ep_load(iter, cxlmd)) {

drivers/cxl/core/region.c

338

cxl_rr = cxl_rr_load(iter, cxlr);

drivers/cxl/core/region.c

3864

struct cxl_region_ref *iter;

drivers/cxl/core/region.c

3872

xa_for_each(&endpoint->regions, index, iter) {

drivers/cxl/core/region.c

3873

struct cxl_region_params *p = &iter->region->params;

drivers/cxl/port.c

290

struct cxl_port *endpoint, *iter, *down;

drivers/cxl/port.c

297

for (iter = parent_port, down = NULL; !is_cxl_root(iter);

drivers/cxl/port.c

298

down = iter, iter = to_cxl_port(iter->dev.parent)) {

drivers/cxl/port.c

301

ep = cxl_ep_load(iter, cxlmd);

drivers/dax/super.c

295

void *addr, size_t bytes, struct iov_iter *iter)

drivers/dax/super.c

299

return dax_dev->ops->recovery_write(dax_dev, pgoff, addr, bytes, iter);

drivers/dma-buf/dma-buf.c

498

struct dma_fence_unwrap iter;

drivers/dma-buf/dma-buf.c

519

dma_fence_unwrap_for_each(f, &iter, fence)

drivers/dma-buf/dma-buf.c

527

dma_fence_unwrap_for_each(f, &iter, fence)

drivers/dma-buf/dma-fence-unwrap.c

123

struct dma_fence_unwrap *iter)

drivers/dma-buf/dma-fence-unwrap.c

133

dma_fence_unwrap_for_each(tmp, &iter[i], fences[i]) {

drivers/dma-buf/dma-fence-unwrap.c

167

dma_fence_unwrap_for_each(tmp, &iter[i], fences[i]) {

drivers/dma-buf/st-dma-fence-unwrap.c

120

struct dma_fence_unwrap iter;

drivers/dma-buf/st-dma-fence-unwrap.c

139

dma_fence_unwrap_for_each(fence, &iter, array) {

drivers/dma-buf/st-dma-fence-unwrap.c

158

struct dma_fence_unwrap iter;

drivers/dma-buf/st-dma-fence-unwrap.c

177

dma_fence_unwrap_for_each(fence, &iter, chain) {

drivers/dma-buf/st-dma-fence-unwrap.c

196

struct dma_fence_unwrap iter;

drivers/dma-buf/st-dma-fence-unwrap.c

218

dma_fence_unwrap_for_each(fence, &iter, chain) {

drivers/dma-buf/st-dma-fence-unwrap.c

237

struct dma_fence_unwrap iter;

drivers/dma-buf/st-dma-fence-unwrap.c

258

dma_fence_unwrap_for_each(fence, &iter, f3) {

drivers/dma-buf/st-dma-fence-unwrap.c

283

struct dma_fence_unwrap iter;

drivers/dma-buf/st-dma-fence-unwrap.c

296

dma_fence_unwrap_for_each(fence, &iter, f2) {

drivers/dma-buf/st-dma-fence-unwrap.c

316

struct dma_fence_unwrap iter;

drivers/dma-buf/st-dma-fence-unwrap.c

349

dma_fence_unwrap_for_each(fence, &iter, f4) {

drivers/dma-buf/st-dma-fence-unwrap.c

376

struct dma_fence_unwrap iter;

drivers/dma-buf/st-dma-fence-unwrap.c

413

dma_fence_unwrap_for_each(fence, &iter, a2) {

drivers/dma-buf/st-dma-fence-unwrap.c

440

struct dma_fence_unwrap iter;

drivers/dma-buf/st-dma-fence-unwrap.c

475

dma_fence_unwrap_for_each(fence, &iter, f5) {

drivers/dma-buf/st-dma-fence-unwrap.c

504

struct dma_fence_unwrap iter;

drivers/dma-buf/st-dma-fence-unwrap.c

557

dma_fence_unwrap_for_each(fence, &iter, f7) {

drivers/dma-buf/sync_file.c

299

struct dma_fence_unwrap iter;

drivers/dma-buf/sync_file.c

313

dma_fence_unwrap_for_each(fence, &iter, sync_file->fence)

drivers/dma-buf/sync_file.c

338

dma_fence_unwrap_for_each(fence, &iter, sync_file->fence) {

drivers/dma/at_xdmac.c

1542

struct at_xdmac_desc *desc, *_desc, *iter;

drivers/dma/at_xdmac.c

1658

list_for_each_entry_safe(iter, _desc, descs_list, desc_node) {

drivers/dma/at_xdmac.c

1659

dwidth = at_xdmac_get_dwidth(iter->lld.mbr_cfg);

drivers/dma/at_xdmac.c

1660

residue -= (iter->lld.mbr_ubc & 0xffffff) << dwidth;

drivers/dma/at_xdmac.c

1661

if ((iter->lld.mbr_nda & 0xfffffffc) == cur_nda) {

drivers/dma/at_xdmac.c

1662

desc = iter;

drivers/dma/fsl-edma-common.c

601

u16 soff, doff, iter;

drivers/dma/fsl-edma-common.c

636

iter = period_len / nbytes;

drivers/dma/fsl-edma-common.c

668

fsl_chan->attr, soff, nbytes, 0, iter,

drivers/dma/fsl-edma-common.c

669

iter, doff, last_sg, major_int, false, true);

drivers/dma/fsl-edma-common.c

685

u16 soff, doff, iter;

drivers/dma/fsl-edma-common.c

760

iter = sg_dma_len(sg) / nbytes;

drivers/dma/fsl-edma-common.c

765

nbytes, 0, iter, iter, doff, last_sg,

drivers/dma/fsl-edma-common.c

771

nbytes, 0, iter, iter, doff, last_sg,

drivers/dma/mpc512x_dma.c

697

int iter, i;

drivers/dma/mpc512x_dma.c

778

iter = len / tcd->nbytes;

drivers/dma/mpc512x_dma.c

779

if (iter >= 1 << 15) {

drivers/dma/mpc512x_dma.c

784

tcd->biter = iter & 0x1ff;

drivers/dma/mpc512x_dma.c

785

tcd->biter_linkch = iter >> 9;

drivers/dma/mv_xor.c

217

struct mv_xor_desc_slot *iter, *_iter;

drivers/dma/mv_xor.c

220

list_for_each_entry_safe(iter, _iter, &mv_chan->completed_slots,

drivers/dma/mv_xor.c

223

if (async_tx_test_ack(&iter->async_tx)) {

drivers/dma/mv_xor.c

224

list_move_tail(&iter->node, &mv_chan->free_slots);

drivers/dma/mv_xor.c

225

if (!list_empty(&iter->sg_tx_list)) {

drivers/dma/mv_xor.c

226

list_splice_tail_init(&iter->sg_tx_list,

drivers/dma/mv_xor.c

265

struct mv_xor_desc_slot *iter, *_iter;

drivers/dma/mv_xor.c

280

list_for_each_entry_safe(iter, _iter, &mv_chan->chain,

drivers/dma/mv_xor.c

284

hw_desc = iter->hw_desc;

drivers/dma/mv_xor.c

286

cookie = mv_desc_run_tx_complete_actions(iter, mv_chan,

drivers/dma/mv_xor.c

290

mv_desc_clean_slot(iter, mv_chan);

drivers/dma/mv_xor.c

293

if (iter->async_tx.phys == current_desc) {

drivers/dma/mv_xor.c

298

if (iter->async_tx.phys == current_desc) {

drivers/dma/mv_xor.c

311

iter = list_entry(mv_chan->chain.next,

drivers/dma/mv_xor.c

314

mv_chan_start_new_chain(mv_chan, iter);

drivers/dma/mv_xor.c

316

if (!list_is_last(&iter->node, &mv_chan->chain)) {

drivers/dma/mv_xor.c

321

iter = list_entry(iter->node.next,

drivers/dma/mv_xor.c

324

mv_chan_start_new_chain(mv_chan, iter);

drivers/dma/mv_xor.c

351

struct mv_xor_desc_slot *iter;

drivers/dma/mv_xor.c

356

iter = list_first_entry(&mv_chan->free_slots,

drivers/dma/mv_xor.c

360

list_move_tail(&iter->node, &mv_chan->allocated_slots);

drivers/dma/mv_xor.c

365

async_tx_ack(&iter->async_tx);

drivers/dma/mv_xor.c

366

iter->async_tx.cookie = -EBUSY;

drivers/dma/mv_xor.c

368

return iter;

drivers/dma/mv_xor.c

630

struct mv_xor_desc_slot *iter, *_iter;

drivers/dma/mv_xor.c

637

list_for_each_entry_safe(iter, _iter, &mv_chan->chain,

drivers/dma/mv_xor.c

640

list_move_tail(&iter->node, &mv_chan->free_slots);

drivers/dma/mv_xor.c

642

list_for_each_entry_safe(iter, _iter, &mv_chan->completed_slots,

drivers/dma/mv_xor.c

645

list_move_tail(&iter->node, &mv_chan->free_slots);

drivers/dma/mv_xor.c

647

list_for_each_entry_safe(iter, _iter, &mv_chan->allocated_slots,

drivers/dma/mv_xor.c

650

list_move_tail(&iter->node, &mv_chan->free_slots);

drivers/dma/mv_xor.c

653

iter, _iter, &mv_chan->free_slots, node) {

drivers/dma/mv_xor.c

654

list_del(&iter->node);

drivers/dma/mv_xor.c

655

kfree(iter);

drivers/dma/ppc4xx/adma.c

1097

struct ppc440spe_adma_desc_slot *iter;

drivers/dma/ppc4xx/adma.c

1110

iter = chan_last_sub[chan->device->id];

drivers/dma/ppc4xx/adma.c

1111

BUG_ON(!iter);

drivers/dma/ppc4xx/adma.c

1114

iter = chan_first_cdb[chan->device->id];

drivers/dma/ppc4xx/adma.c

1115

BUG_ON(!iter);

drivers/dma/ppc4xx/adma.c

1116

ppc440spe_dma_put_desc(chan, iter);

drivers/dma/ppc4xx/adma.c

1121

if (!iter->hw_next)

drivers/dma/ppc4xx/adma.c

1125

list_for_each_entry_continue(iter, &chan->chain, chain_node) {

drivers/dma/ppc4xx/adma.c

1126

ppc440spe_dma_put_desc(chan, iter);

drivers/dma/ppc4xx/adma.c

1127

if (!iter->hw_next)

drivers/dma/ppc4xx/adma.c

1423

struct ppc440spe_adma_desc_slot *iter = tdesc->group_head;

drivers/dma/ppc4xx/adma.c

1432

list_for_each_entry(iter, &tdesc->group_list, chain_node) {

drivers/dma/ppc4xx/adma.c

1436

return iter;

drivers/dma/ppc4xx/adma.c

1535

struct ppc440spe_adma_desc_slot *iter, *_iter, *group_start = NULL;

drivers/dma/ppc4xx/adma.c

1554

list_for_each_entry_safe(iter, _iter, &chan->chain,

drivers/dma/ppc4xx/adma.c

1559

iter->async_tx.cookie, iter->idx, busy, iter->phys,

drivers/dma/ppc4xx/adma.c

1560

ppc440spe_desc_get_link(iter, chan), current_desc,

drivers/dma/ppc4xx/adma.c

1561

async_tx_test_ack(&iter->async_tx));

drivers/dma/ppc4xx/adma.c

1576

if (iter->phys == current_desc) {

drivers/dma/ppc4xx/adma.c

1578

if (busy || ppc440spe_desc_get_link(iter, chan)) {

drivers/dma/ppc4xx/adma.c

1588

slot_cnt = iter->slot_cnt;

drivers/dma/ppc4xx/adma.c

1589

slots_per_op = iter->slots_per_op;

drivers/dma/ppc4xx/adma.c

1598

group_start = iter;

drivers/dma/ppc4xx/adma.c

1642

cookie = ppc440spe_adma_run_tx_complete_actions(iter, chan,

drivers/dma/ppc4xx/adma.c

1645

if (ppc440spe_adma_clean_slot(iter, chan))

drivers/dma/ppc4xx/adma.c

1687

struct ppc440spe_adma_desc_slot *iter = NULL, *_iter;

drivers/dma/ppc4xx/adma.c

1701

iter = chan->last_used;

drivers/dma/ppc4xx/adma.c

1703

iter = list_entry(&chan->all_slots,

drivers/dma/ppc4xx/adma.c

1706

list_for_each_entry_safe_continue(iter, _iter, &chan->all_slots,

drivers/dma/ppc4xx/adma.c

1710

if (iter->slots_per_op) {

drivers/dma/ppc4xx/adma.c

1717

alloc_start = iter;

drivers/dma/ppc4xx/adma.c

1723

iter = alloc_start;

drivers/dma/ppc4xx/adma.c

1728

async_tx_ack(&iter->async_tx);

drivers/dma/ppc4xx/adma.c

1730

list_add_tail(&iter->chain_node, &chain);

drivers/dma/ppc4xx/adma.c

1731

alloc_tail = iter;

drivers/dma/ppc4xx/adma.c

1732

iter->async_tx.cookie = 0;

drivers/dma/ppc4xx/adma.c

1733

iter->hw_next = NULL;

drivers/dma/ppc4xx/adma.c

1734

iter->flags = 0;

drivers/dma/ppc4xx/adma.c

1735

iter->slot_cnt = num_slots;

drivers/dma/ppc4xx/adma.c

1736

iter->xor_check_result = NULL;

drivers/dma/ppc4xx/adma.c

1738

iter->slots_per_op = slots_per_op - i;

drivers/dma/ppc4xx/adma.c

1739

last_used = iter;

drivers/dma/ppc4xx/adma.c

174

struct ppc440spe_adma_desc_slot *iter)

drivers/dma/ppc4xx/adma.c

1740

iter = list_entry(iter->slot_node.next,

drivers/dma/ppc4xx/adma.c

176

for (; iter; iter = iter->hw_next)

drivers/dma/ppc4xx/adma.c

177

print_cb(chan, iter->hw_desc);

drivers/dma/ppc4xx/adma.c

2100

struct ppc440spe_adma_desc_slot *iter;

drivers/dma/ppc4xx/adma.c

2110

iter = list_first_entry(&sw_desc->group_list,

drivers/dma/ppc4xx/adma.c

2113

memset(iter->hw_desc, 0, sizeof(struct dma_cdb));

drivers/dma/ppc4xx/adma.c

2115

iter->hw_next = list_entry(iter->chain_node.next,

drivers/dma/ppc4xx/adma.c

2118

clear_bit(PPC440SPE_DESC_INT, &iter->flags);

drivers/dma/ppc4xx/adma.c

2119

hw_desc = iter->hw_desc;

drivers/dma/ppc4xx/adma.c

2122

ppc440spe_desc_set_dest_addr(iter, chan,

drivers/dma/ppc4xx/adma.c

2124

ppc440spe_desc_set_dest_addr(iter, chan, 0, dst[1], 1);

drivers/dma/ppc4xx/adma.c

2125

ppc440spe_desc_set_src_addr(iter, chan, 0, DMA_CUED_XOR_HB,

drivers/dma/ppc4xx/adma.c

2127

ppc440spe_desc_set_byte_count(iter, ppc440spe_chan, len);

drivers/dma/ppc4xx/adma.c

2128

iter->unmap_len = len;

drivers/dma/ppc4xx/adma.c

2134

iter = list_first_entry(&iter->chain_node,

drivers/dma/ppc4xx/adma.c

2137

memset(iter->hw_desc, 0, sizeof(struct dma_cdb));

drivers/dma/ppc4xx/adma.c

2138

iter->hw_next = NULL;

drivers/dma/ppc4xx/adma.c

2140

set_bit(PPC440SPE_DESC_INT, &iter->flags);

drivers/dma/ppc4xx/adma.c

2142

clear_bit(PPC440SPE_DESC_INT, &iter->flags);

drivers/dma/ppc4xx/adma.c

2144

hw_desc = iter->hw_desc;

drivers/dma/ppc4xx/adma.c

2146

ppc440spe_desc_set_src_addr(iter, chan, 0,

drivers/dma/ppc4xx/adma.c

2148

ppc440spe_desc_set_dest_addr(iter, chan,

drivers/dma/ppc4xx/adma.c

2151

ppc440spe_desc_set_src_mult(iter, chan, DMA_CUED_MULT1_OFF,

drivers/dma/ppc4xx/adma.c

2153

ppc440spe_desc_set_byte_count(iter, ppc440spe_chan, len);

drivers/dma/ppc4xx/adma.c

2154

iter->unmap_len = len;

drivers/dma/ppc4xx/adma.c

2186

struct ppc440spe_adma_desc_slot *iter;

drivers/dma/ppc4xx/adma.c

2194

iter = list_first_entry(&sw_desc->group_list,

drivers/dma/ppc4xx/adma.c

2197

memset(iter->hw_desc, 0, sizeof(struct dma_cdb));

drivers/dma/ppc4xx/adma.c

2198

iter->hw_next = list_entry(iter->chain_node.next,

drivers/dma/ppc4xx/adma.c

2201

clear_bit(PPC440SPE_DESC_INT, &iter->flags);

drivers/dma/ppc4xx/adma.c

2202

hw_desc = iter->hw_desc;

drivers/dma/ppc4xx/adma.c

2205

ppc440spe_desc_set_dest_addr(iter, chan, DMA_CUED_XOR_BASE,

drivers/dma/ppc4xx/adma.c

2207

ppc440spe_desc_set_dest_addr(iter, chan, 0,

drivers/dma/ppc4xx/adma.c

2209

ppc440spe_desc_set_src_addr(iter, chan, 0, DMA_CUED_XOR_HB,

drivers/dma/ppc4xx/adma.c

2211

ppc440spe_desc_set_byte_count(iter, ppc440spe_chan, len);

drivers/dma/ppc4xx/adma.c

2212

iter->unmap_len = len;

drivers/dma/ppc4xx/adma.c

2216

iter = list_first_entry(&iter->chain_node,

drivers/dma/ppc4xx/adma.c

2219

memset(iter->hw_desc, 0, sizeof(struct dma_cdb));

drivers/dma/ppc4xx/adma.c

2221

iter->hw_next = list_entry(iter->chain_node.next,

drivers/dma/ppc4xx/adma.c

2225

set_bit(PPC440SPE_DESC_INT, &iter->flags);

drivers/dma/ppc4xx/adma.c

2227

clear_bit(PPC440SPE_DESC_INT, &iter->flags);

drivers/dma/ppc4xx/adma.c

2229

hw_desc = iter->hw_desc;

drivers/dma/ppc4xx/adma.c

2231

ppc440spe_desc_set_src_addr(iter, chan, 0, DMA_CUED_XOR_HB,

drivers/dma/ppc4xx/adma.c

2233

ppc440spe_desc_set_dest_addr(iter, chan, DMA_CUED_XOR_BASE,

drivers/dma/ppc4xx/adma.c

2235

ppc440spe_desc_set_src_mult(iter, chan, DMA_CUED_MULT1_OFF,

drivers/dma/ppc4xx/adma.c

2237

ppc440spe_desc_set_byte_count(iter, ppc440spe_chan, len);

drivers/dma/ppc4xx/adma.c

2238

iter->unmap_len = len;

drivers/dma/ppc4xx/adma.c

2244

iter = list_first_entry(&iter->chain_node,

drivers/dma/ppc4xx/adma.c

2247

memset(iter->hw_desc, 0, sizeof(struct dma_cdb));

drivers/dma/ppc4xx/adma.c

2248

iter->hw_next = NULL;

drivers/dma/ppc4xx/adma.c

2250

set_bit(PPC440SPE_DESC_INT, &iter->flags);

drivers/dma/ppc4xx/adma.c

2252

clear_bit(PPC440SPE_DESC_INT, &iter->flags);

drivers/dma/ppc4xx/adma.c

2254

hw_desc = iter->hw_desc;

drivers/dma/ppc4xx/adma.c

2256

ppc440spe_desc_set_src_addr(iter, chan, 0, DMA_CUED_XOR_HB,

drivers/dma/ppc4xx/adma.c

2258

ppc440spe_desc_set_dest_addr(iter, chan, DMA_CUED_XOR_BASE,

drivers/dma/ppc4xx/adma.c

2260

ppc440spe_desc_set_src_mult(iter, chan, DMA_CUED_MULT1_OFF,

drivers/dma/ppc4xx/adma.c

2262

ppc440spe_desc_set_byte_count(iter, ppc440spe_chan, len);

drivers/dma/ppc4xx/adma.c

2263

iter->unmap_len = len;

drivers/dma/ppc4xx/adma.c

2278

struct ppc440spe_adma_desc_slot *sw_desc = NULL, *iter;

drivers/dma/ppc4xx/adma.c

2405

list_for_each_entry(iter, &sw_desc->group_list,

drivers/dma/ppc4xx/adma.c

2407

ppc440spe_desc_set_byte_count(iter,

drivers/dma/ppc4xx/adma.c

2409

iter->unmap_len = len;

drivers/dma/ppc4xx/adma.c

2423

struct ppc440spe_adma_desc_slot *sw_desc = NULL, *iter;

drivers/dma/ppc4xx/adma.c

2445

list_for_each_entry(iter, &sw_desc->group_list, chain_node) {

drivers/dma/ppc4xx/adma.c

2446

ppc440spe_desc_init_dma2pq(iter, dst_cnt, src_cnt,

drivers/dma/ppc4xx/adma.c

2448

ppc440spe_desc_set_byte_count(iter, ppc440spe_chan,

drivers/dma/ppc4xx/adma.c

2450

iter->unmap_len = len;

drivers/dma/ppc4xx/adma.c

2452

ppc440spe_init_rxor_cursor(&(iter->rxor_cursor));

drivers/dma/ppc4xx/adma.c

2453

iter->rxor_cursor.len = len;

drivers/dma/ppc4xx/adma.c

2454

iter->descs_per_op = descs_per_op;

drivers/dma/ppc4xx/adma.c

2457

list_for_each_entry(iter, &sw_desc->group_list, chain_node) {

drivers/dma/ppc4xx/adma.c

2460

ppc440spe_adma_init_dma2rxor_slot(iter, src,

drivers/dma/ppc4xx/adma.c

2462

if (likely(!list_is_last(&iter->chain_node,

drivers/dma/ppc4xx/adma.c

2465

iter->hw_next =

drivers/dma/ppc4xx/adma.c

2466

list_entry(iter->chain_node.next,

drivers/dma/ppc4xx/adma.c

2469

ppc440spe_xor_set_link(iter, iter->hw_next);

drivers/dma/ppc4xx/adma.c

2472

iter->hw_next = NULL;

drivers/dma/ppc4xx/adma.c

2588

struct ppc440spe_adma_desc_slot *sw_desc, *iter;

drivers/dma/ppc4xx/adma.c

2626

list_for_each_entry(iter, &sw_desc->group_list, chain_node) {

drivers/dma/ppc4xx/adma.c

2627

ppc440spe_desc_set_byte_count(iter, ppc440spe_chan,

drivers/dma/ppc4xx/adma.c

2629

iter->unmap_len = len;

drivers/dma/ppc4xx/adma.c

2636

iter = sw_desc->group_head;

drivers/dma/ppc4xx/adma.c

2637

chan = to_ppc440spe_adma_chan(iter->async_tx.chan);

drivers/dma/ppc4xx/adma.c

2638

memset(iter->hw_desc, 0, sizeof(struct dma_cdb));

drivers/dma/ppc4xx/adma.c

2639

iter->hw_next = list_entry(iter->chain_node.next,

drivers/dma/ppc4xx/adma.c

2642

hw_desc = iter->hw_desc;

drivers/dma/ppc4xx/adma.c

2644

iter->src_cnt = 0;

drivers/dma/ppc4xx/adma.c

2645

iter->dst_cnt = 0;

drivers/dma/ppc4xx/adma.c

2646

ppc440spe_desc_set_dest_addr(iter, chan, 0,

drivers/dma/ppc4xx/adma.c

2648

ppc440spe_desc_set_src_addr(iter, chan, 0, 0, pdest);

drivers/dma/ppc4xx/adma.c

2649

ppc440spe_desc_set_byte_count(iter, ppc440spe_chan,

drivers/dma/ppc4xx/adma.c

2651

iter->unmap_len = 0;

drivers/dma/ppc4xx/adma.c

2659

iter = list_first_entry(&sw_desc->group_list,

drivers/dma/ppc4xx/adma.c

2662

chan = to_ppc440spe_adma_chan(iter->async_tx.chan);

drivers/dma/ppc4xx/adma.c

2665

iter = list_entry(iter->chain_node.next,

drivers/dma/ppc4xx/adma.c

2670

memset(iter->hw_desc, 0, sizeof(struct dma_cdb));

drivers/dma/ppc4xx/adma.c

2671

iter->hw_next = list_entry(iter->chain_node.next,

drivers/dma/ppc4xx/adma.c

2674

hw_desc = iter->hw_desc;

drivers/dma/ppc4xx/adma.c

2676

iter->src_cnt = 0;

drivers/dma/ppc4xx/adma.c

2677

iter->dst_cnt = 0;

drivers/dma/ppc4xx/adma.c

2678

ppc440spe_desc_set_dest_addr(iter, chan, 0,

drivers/dma/ppc4xx/adma.c

2680

ppc440spe_desc_set_src_addr(iter, chan, 0, 0, qdest);

drivers/dma/ppc4xx/adma.c

2681

ppc440spe_desc_set_byte_count(iter, ppc440spe_chan,

drivers/dma/ppc4xx/adma.c

2683

iter->unmap_len = 0;

drivers/dma/ppc4xx/adma.c

2693

list_for_each_entry_reverse(iter, &sw_desc->group_list,

drivers/dma/ppc4xx/adma.c

2703

&iter->flags);

drivers/dma/ppc4xx/adma.c

2706

&iter->flags);

drivers/dma/ppc4xx/adma.c

2711

&iter->flags);

drivers/dma/ppc4xx/adma.c

2714

&iter->flags);

drivers/dma/ppc4xx/adma.c

2717

iter->xor_check_result = pqres;

drivers/dma/ppc4xx/adma.c

2723

*iter->xor_check_result = 0;

drivers/dma/ppc4xx/adma.c

2724

ppc440spe_desc_set_dcheck(iter, ppc440spe_chan,

drivers/dma/ppc4xx/adma.c

2732

list_for_each_entry_continue_reverse(iter, &sw_desc->group_list,

drivers/dma/ppc4xx/adma.c

2737

chan = to_ppc440spe_adma_chan(iter->async_tx.chan);

drivers/dma/ppc4xx/adma.c

2738

ppc440spe_desc_set_src_addr(iter, chan, 0,

drivers/dma/ppc4xx/adma.c

2744

ppc440spe_desc_set_src_mult(iter, chan,

drivers/dma/ppc4xx/adma.c

2808

static void ppc440spe_adma_pq_zero_op(struct ppc440spe_adma_desc_slot *iter,

drivers/dma/ppc4xx/adma.c

2815

ppc440spe_desc_set_dest_addr(iter, chan, DMA_CUED_XOR_BASE, addr, 0);

drivers/dma/ppc4xx/adma.c

2818

ppc440spe_desc_set_src_addr(iter, chan, 0, DMA_CUED_XOR_HB, addr);

drivers/dma/ppc4xx/adma.c

2821

ppc440spe_desc_set_src_mult(iter, chan, DMA_CUED_MULT1_OFF,

drivers/dma/ppc4xx/adma.c

2832

struct ppc440spe_adma_desc_slot *iter;

drivers/dma/ppc4xx/adma.c

2866

iter = ppc440spe_get_group_entry(sw_desc, index);

drivers/dma/ppc4xx/adma.c

2869

list_for_each_entry_from(iter,

drivers/dma/ppc4xx/adma.c

2871

ppc440spe_desc_set_dest_addr(iter, chan,

drivers/dma/ppc4xx/adma.c

2875

list_for_each_entry_from(iter,

drivers/dma/ppc4xx/adma.c

2877

ppc440spe_desc_set_dest_addr(iter, chan,

drivers/dma/ppc4xx/adma.c

2879

ppc440spe_desc_set_dest_addr(iter, chan,

drivers/dma/ppc4xx/adma.c

2891

iter = ppc440spe_get_group_entry(

drivers/dma/ppc4xx/adma.c

2893

ppc440spe_adma_pq_zero_op(iter, chan,

drivers/dma/ppc4xx/adma.c

2899

iter = ppc440spe_get_group_entry(

drivers/dma/ppc4xx/adma.c

2901

ppc440spe_adma_pq_zero_op(iter, chan,

drivers/dma/ppc4xx/adma.c

2923

iter = ppc440spe_get_group_entry(sw_desc, index++);

drivers/dma/ppc4xx/adma.c

2924

ppc440spe_desc_set_dest_addr(iter, chan,

drivers/dma/ppc4xx/adma.c

2929

iter = ppc440spe_get_group_entry(sw_desc,

drivers/dma/ppc4xx/adma.c

2931

ppc440spe_desc_set_dest_addr(iter, chan,

drivers/dma/ppc4xx/adma.c

2939

iter = ppc440spe_get_group_entry(sw_desc,

drivers/dma/ppc4xx/adma.c

2943

list_for_each_entry_from(iter,

drivers/dma/ppc4xx/adma.c

2947

iter, chan,

drivers/dma/ppc4xx/adma.c

2953

list_for_each_entry_from(iter,

drivers/dma/ppc4xx/adma.c

2957

iter, chan,

drivers/dma/ppc4xx/adma.c

2961

iter, chan,

drivers/dma/ppc4xx/adma.c

2987

iter = ppc440spe_get_group_entry(sw_desc, 0);

drivers/dma/ppc4xx/adma.c

2989

ppc440spe_desc_set_dest_addr(iter, chan,

drivers/dma/ppc4xx/adma.c

2992

iter = list_entry(iter->chain_node.next,

drivers/dma/ppc4xx/adma.c

2999

iter = ppc440spe_get_group_entry(sw_desc,

drivers/dma/ppc4xx/adma.c

3002

ppc440spe_desc_set_dest_addr(iter,

drivers/dma/ppc4xx/adma.c

3004

iter = list_entry(iter->chain_node.next,

drivers/dma/ppc4xx/adma.c

3022

struct ppc440spe_adma_desc_slot *iter, *end;

drivers/dma/ppc4xx/adma.c

3041

iter = ppc440spe_get_group_entry(sw_desc, idx);

drivers/dma/ppc4xx/adma.c

3045

list_for_each_entry_from(iter, &sw_desc->group_list,

drivers/dma/ppc4xx/adma.c

3047

if (unlikely(iter == end))

drivers/dma/ppc4xx/adma.c

3049

ppc440spe_desc_set_dest_addr(iter, chan,

drivers/dma/ppc4xx/adma.c

3051

ppc440spe_desc_set_dest_addr(iter, chan,

drivers/dma/ppc4xx/adma.c

3057

list_for_each_entry_from(iter, &sw_desc->group_list,

drivers/dma/ppc4xx/adma.c

3059

if (unlikely(iter == end))

drivers/dma/ppc4xx/adma.c

3061

ppc440spe_desc_set_dest_addr(iter, chan,

drivers/dma/ppc4xx/adma.c

3100

struct ppc440spe_adma_desc_slot *iter = NULL;

drivers/dma/ppc4xx/adma.c

3138

iter = ppc440spe_get_group_entry(sw_desc, 0);

drivers/dma/ppc4xx/adma.c

3144

iter = NULL;

drivers/dma/ppc4xx/adma.c

3150

iter = ppc440spe_get_group_entry(sw_desc,

drivers/dma/ppc4xx/adma.c

3165

iter = ppc440spe_get_group_entry(sw_desc,

drivers/dma/ppc4xx/adma.c

3169

if (likely(iter)) {

drivers/dma/ppc4xx/adma.c

3170

ppc440spe_desc_set_src_addr(iter, chan, 0, haddr, addr);

drivers/dma/ppc4xx/adma.c

3178

iter = ppc440spe_get_group_entry(sw_desc, 1);

drivers/dma/ppc4xx/adma.c

3179

ppc440spe_desc_set_src_addr(iter, chan, 0,

drivers/dma/ppc4xx/adma.c

3187

iter = sw_desc->group_head;

drivers/dma/ppc4xx/adma.c

3188

if (iter->dst_cnt == 2) {

drivers/dma/ppc4xx/adma.c

3190

ppc440spe_adma_dma2rxor_set_src(iter, index, addr);

drivers/dma/ppc4xx/adma.c

3193

iter = ppc440spe_get_group_entry(sw_desc,

drivers/dma/ppc4xx/adma.c

3196

ppc440spe_adma_dma2rxor_set_src(iter, index, addr);

drivers/dma/ppc4xx/adma.c

322

struct ppc440spe_adma_desc_slot *iter;

drivers/dma/ppc4xx/adma.c

336

list_for_each_entry(iter, &desc->group_list, chain_node) {

drivers/dma/ppc4xx/adma.c

337

hw_desc = iter->hw_desc;

drivers/dma/ppc4xx/adma.c

338

memset(iter->hw_desc, 0, sizeof(struct dma_cdb));

drivers/dma/ppc4xx/adma.c

340

if (likely(!list_is_last(&iter->chain_node,

drivers/dma/ppc4xx/adma.c

343

iter->hw_next = list_entry(iter->chain_node.next,

drivers/dma/ppc4xx/adma.c

345

clear_bit(PPC440SPE_DESC_INT, &iter->flags);

drivers/dma/ppc4xx/adma.c

3451

struct ppc440spe_adma_desc_slot *iter = NULL, *iter1 = NULL;

drivers/dma/ppc4xx/adma.c

3464

iter = ppc440spe_get_group_entry(sw_desc,

drivers/dma/ppc4xx/adma.c

3474

iter = ppc440spe_get_group_entry(sw_desc,

drivers/dma/ppc4xx/adma.c

3493

iter = ppc440spe_get_group_entry(sw_desc, index + znum);

drivers/dma/ppc4xx/adma.c

3498

if (likely(iter)) {

drivers/dma/ppc4xx/adma.c

3499

ppc440spe_desc_set_src_mult(iter, chan,

drivers/dma/ppc4xx/adma.c

3514

iter = sw_desc->group_head;

drivers/dma/ppc4xx/adma.c

3517

ppc440spe_adma_dma2rxor_set_mult(iter, index, 1);

drivers/dma/ppc4xx/adma.c

352

iter->hw_next = NULL;

drivers/dma/ppc4xx/adma.c

3520

iter = ppc440spe_get_group_entry(sw_desc,

drivers/dma/ppc4xx/adma.c

3523

ppc440spe_adma_dma2rxor_set_mult(iter, index, mult);

drivers/dma/ppc4xx/adma.c

3534

struct ppc440spe_adma_desc_slot *iter, *_iter;

drivers/dma/ppc4xx/adma.c

354

set_bit(PPC440SPE_DESC_INT, &iter->flags);

drivers/dma/ppc4xx/adma.c

3541

list_for_each_entry_safe(iter, _iter, &ppc440spe_chan->chain,

drivers/dma/ppc4xx/adma.c

3544

list_del(&iter->chain_node);

drivers/dma/ppc4xx/adma.c

3546

list_for_each_entry_safe_reverse(iter, _iter,

drivers/dma/ppc4xx/adma.c

3548

list_del(&iter->slot_node);

drivers/dma/ppc4xx/adma.c

3549

kfree(iter);

drivers/dma/ppc4xx/adma.c

356

clear_bit(PPC440SPE_DESC_INT, &iter->flags);

drivers/dma/ppc4xx/adma.c

367

iter = list_first_entry(&desc->group_list,

drivers/dma/ppc4xx/adma.c

3700

struct ppc440spe_adma_desc_slot *sw_desc, *iter;

drivers/dma/ppc4xx/adma.c

3718

list_for_each_entry(iter, &sw_desc->group_list, chain_node) {

drivers/dma/ppc4xx/adma.c

3719

ppc440spe_desc_set_byte_count(iter, chan, PAGE_SIZE);

drivers/dma/ppc4xx/adma.c

372

hw_desc = iter->hw_desc;

drivers/dma/ppc4xx/adma.c

3720

iter->unmap_len = PAGE_SIZE;

drivers/dma/ppc4xx/adma.c

374

iter = list_first_entry(&iter->chain_node,

drivers/dma/ppc4xx/adma.c

380

hw_desc = iter->hw_desc;

drivers/dma/ppc4xx/adma.c

382

iter = list_first_entry(&iter->chain_node,

drivers/dma/ppc4xx/adma.c

387

list_for_each_entry_from(iter, &desc->group_list, chain_node) {

drivers/dma/ppc4xx/adma.c

388

hw_desc = iter->hw_desc;

drivers/dma/ppc4xx/adma.c

398

iter = list_first_entry(&desc->group_list,

drivers/dma/ppc4xx/adma.c

401

hw_desc = iter->hw_desc;

drivers/dma/ppc4xx/adma.c

405

iter = list_first_entry(&iter->chain_node,

drivers/dma/ppc4xx/adma.c

408

hw_desc = iter->hw_desc;

drivers/dma/ppc4xx/adma.c

414

iter = list_first_entry(&iter->chain_node,

drivers/dma/ppc4xx/adma.c

417

list_for_each_entry_from(iter, &desc->group_list,

drivers/dma/ppc4xx/adma.c

419

hw_desc = iter->hw_desc;

drivers/dma/ppc4xx/adma.c

435

struct ppc440spe_adma_desc_slot *iter;

drivers/dma/ppc4xx/adma.c

445

iter = list_first_entry(&desc->group_list,

drivers/dma/ppc4xx/adma.c

447

iter = list_entry(iter->chain_node.next,

drivers/dma/ppc4xx/adma.c

451

iter = list_entry(iter->chain_node.next,

drivers/dma/ppc4xx/adma.c

455

list_for_each_entry_from(iter, &desc->group_list, chain_node) {

drivers/dma/ppc4xx/adma.c

456

hw_desc = iter->hw_desc;

drivers/dma/ppc4xx/adma.c

457

memset(iter->hw_desc, 0, sizeof(struct dma_cdb));

drivers/dma/ppc4xx/adma.c

458

iter->src_cnt = 0;

drivers/dma/ppc4xx/adma.c

459

iter->dst_cnt = 0;

drivers/dma/ppc4xx/adma.c

475

if (likely(!list_is_last(&iter->chain_node,

drivers/dma/ppc4xx/adma.c

478

iter->hw_next = list_entry(iter->chain_node.next,

drivers/dma/ppc4xx/adma.c

487

iter->hw_next = NULL;

drivers/dma/ppc4xx/adma.c

491

set_bit(PPC440SPE_DESC_INT, &iter->flags);

drivers/dma/ppc4xx/adma.c

938

struct ppc440spe_adma_desc_slot *iter;

drivers/dma/ppc4xx/adma.c

945

list_for_each_entry(iter, &chan->chain,

drivers/dma/ppc4xx/adma.c

947

if (iter->phys == phys)

drivers/dma/ppc4xx/adma.c

954

BUG_ON(&iter->chain_node == &chan->chain);

drivers/dma/ppc4xx/adma.c

956

if (iter->xor_check_result) {

drivers/dma/ppc4xx/adma.c

958

&iter->flags)) {

drivers/dma/ppc4xx/adma.c

959

*iter->xor_check_result |=

drivers/dma/ppc4xx/adma.c

963

&iter->flags)) {

drivers/dma/ppc4xx/adma.c

964

*iter->xor_check_result |=

drivers/dma/qcom/hidma_ll.c

68

#define HIDMA_INCREMENT_ITERATOR(iter, size, ring_size) \

drivers/dma/qcom/hidma_ll.c

70

iter += size; \

drivers/dma/qcom/hidma_ll.c

71

if (iter >= ring_size) \

drivers/dma/qcom/hidma_ll.c

72

iter -= ring_size; \

drivers/firewire/core-transaction.c

105

t = find_and_pop_transaction_entry(card, iter == transaction);

drivers/firewire/core-transaction.c

1183

iter->node_id == source && iter->tlabel == tlabel);

drivers/firewire/core-transaction.c

85

struct fw_transaction *iter, *t = NULL; \

drivers/firewire/core-transaction.c

86

list_for_each_entry(iter, &card->transactions.list, link) { \

drivers/firewire/core-transaction.c

88

t = iter; \

drivers/firewire/sbp2.c

411

struct sbp2_orb *orb = NULL, *iter;

drivers/firewire/sbp2.c

436

list_for_each_entry(iter, &lu->orb_list, link) {

drivers/firewire/sbp2.c

438

STATUS_GET_ORB_LOW(status) == iter->request_bus) {

drivers/firewire/sbp2.c

439

iter->rcode = RCODE_COMPLETE;

drivers/firewire/sbp2.c

440

list_del(&iter->link);

drivers/firewire/sbp2.c

441

orb = iter;

drivers/firmware/arm_scmi/clock.c

317

void *iter;

drivers/firmware/arm_scmi/clock.c

319

iter = ph->hops->iter_response_init(ph, &ops, 0,

drivers/firmware/arm_scmi/clock.c

323

if (IS_ERR(iter))

drivers/firmware/arm_scmi/clock.c

324

return PTR_ERR(iter);

drivers/firmware/arm_scmi/clock.c

326

return ph->hops->iter_response_run(iter);

drivers/firmware/arm_scmi/clock.c

521

void *iter;

drivers/firmware/arm_scmi/clock.c

537

iter = ph->hops->iter_response_init(ph, &ops, clkd->tot_rates,

drivers/firmware/arm_scmi/clock.c

541

if (IS_ERR(iter))

drivers/firmware/arm_scmi/clock.c

542

return PTR_ERR(iter);

drivers/firmware/arm_scmi/clock.c

544

ret = ph->hops->iter_response_run(iter);

drivers/firmware/arm_scmi/clock.c

573

void *iter;

drivers/firmware/arm_scmi/clock.c

576

iter = ph->hops->iter_response_init(ph, &ops, 0, CLOCK_DESCRIBE_RATES,

drivers/firmware/arm_scmi/clock.c

579

if (IS_ERR(iter))

drivers/firmware/arm_scmi/clock.c

580

return PTR_ERR(iter);

drivers/firmware/arm_scmi/clock.c

585

ret = ph->hops->iter_response_run_bound(iter, &first, &last);

drivers/firmware/arm_scmi/clock.c

596

ret = ph->hops->iter_response_run_bound(iter, &first, &last);

drivers/firmware/arm_scmi/clock.c

600

ph->hops->iter_response_bound_cleanup(iter);

drivers/firmware/arm_scmi/driver.c

1816

static int __scmi_iterator_run(void *iter, unsigned int *start, unsigned int *end)

drivers/firmware/arm_scmi/driver.c

1825

if (!iter)

drivers/firmware/arm_scmi/driver.c

1828

i = iter;

drivers/firmware/arm_scmi/driver.c

1878

static void scmi_iterator_bound_cleanup(void *iter)

drivers/firmware/arm_scmi/driver.c

1880

struct scmi_iterator *i = iter;

drivers/firmware/arm_scmi/driver.c

1886

static int scmi_iterator_run(void *iter)

drivers/firmware/arm_scmi/driver.c

1890

ret = __scmi_iterator_run(iter, NULL, NULL);

drivers/firmware/arm_scmi/driver.c

1891

scmi_iterator_bound_cleanup(iter);

drivers/firmware/arm_scmi/driver.c

1896

static int scmi_iterator_run_bound(void *iter, unsigned int *start,

drivers/firmware/arm_scmi/driver.c

1899

return __scmi_iterator_run(iter, start, end);

drivers/firmware/arm_scmi/perf.c

469

void *iter;

drivers/firmware/arm_scmi/perf.c

476

iter = ph->hops->iter_response_init(ph, &ops, MAX_OPPS,

drivers/firmware/arm_scmi/perf.c

480

if (IS_ERR(iter))

drivers/firmware/arm_scmi/perf.c

481

return PTR_ERR(iter);

drivers/firmware/arm_scmi/perf.c

483

ret = ph->hops->iter_response_run(iter);

drivers/firmware/arm_scmi/pinctrl.c

291

void *iter;

drivers/firmware/arm_scmi/pinctrl.c

310

iter = ph->hops->iter_response_init(ph, &ops, size,

drivers/firmware/arm_scmi/pinctrl.c

314

if (IS_ERR(iter))

drivers/firmware/arm_scmi/pinctrl.c

315

return PTR_ERR(iter);

drivers/firmware/arm_scmi/pinctrl.c

317

return ph->hops->iter_response_run(iter);

drivers/firmware/arm_scmi/pinctrl.c

400

void *iter;

drivers/firmware/arm_scmi/pinctrl.c

425

iter = ph->hops->iter_response_init(ph, &ops, max_configs,

drivers/firmware/arm_scmi/pinctrl.c

429

if (IS_ERR(iter))

drivers/firmware/arm_scmi/pinctrl.c

430

return PTR_ERR(iter);

drivers/firmware/arm_scmi/pinctrl.c

432

return ph->hops->iter_response_run(iter);

drivers/firmware/arm_scmi/protocols.h

286

int (*iter_response_run)(void *iter);

drivers/firmware/arm_scmi/protocols.h

287

int (*iter_response_run_bound)(void *iter,

drivers/firmware/arm_scmi/protocols.h

289

void (*iter_response_bound_cleanup)(void *iter);

drivers/firmware/arm_scmi/sensors.c

356

void *iter;

drivers/firmware/arm_scmi/sensors.c

367

iter = ph->hops->iter_response_init(ph, &ops, s->intervals.count,

drivers/firmware/arm_scmi/sensors.c

371

if (IS_ERR(iter))

drivers/firmware/arm_scmi/sensors.c

372

return PTR_ERR(iter);

drivers/firmware/arm_scmi/sensors.c

374

return ph->hops->iter_response_run(iter);

drivers/firmware/arm_scmi/sensors.c

494

void *iter;

drivers/firmware/arm_scmi/sensors.c

505

iter = ph->hops->iter_response_init(ph, &ops, s->num_axis,

drivers/firmware/arm_scmi/sensors.c

509

if (IS_ERR(iter))

drivers/firmware/arm_scmi/sensors.c

510

return PTR_ERR(iter);

drivers/firmware/arm_scmi/sensors.c

516

ret = ph->hops->iter_response_run(iter);

drivers/firmware/arm_scmi/sensors.c

529

void *iter;

drivers/firmware/arm_scmi/sensors.c

545

iter = ph->hops->iter_response_init(ph, &ops, s->num_axis,

drivers/firmware/arm_scmi/sensors.c

549

if (IS_ERR(iter))

drivers/firmware/arm_scmi/sensors.c

550

return PTR_ERR(iter);

drivers/firmware/arm_scmi/sensors.c

552

ret = ph->hops->iter_response_run(iter);

drivers/firmware/arm_scmi/sensors.c

694

void *iter;

drivers/firmware/arm_scmi/sensors.c

701

iter = ph->hops->iter_response_init(ph, &ops, si->num_sensors,

drivers/firmware/arm_scmi/sensors.c

704

if (IS_ERR(iter))

drivers/firmware/arm_scmi/sensors.c

705

return PTR_ERR(iter);

drivers/firmware/arm_scmi/sensors.c

707

return ph->hops->iter_response_run(iter);

drivers/firmware/arm_scmi/vendors/imx/imx-sm-misc.c

472

void *iter;

drivers/firmware/arm_scmi/vendors/imx/imx-sm-misc.c

477

iter = ph->hops->iter_response_init(ph, &ops, *size, SCMI_IMX_MISC_SYSLOG_GET,

drivers/firmware/arm_scmi/vendors/imx/imx-sm-misc.c

480

if (IS_ERR(iter))

drivers/firmware/arm_scmi/vendors/imx/imx-sm-misc.c

481

return PTR_ERR(iter);

drivers/firmware/arm_scmi/vendors/imx/imx-sm-misc.c

484

return ph->hops->iter_response_run(iter);

drivers/firmware/arm_scmi/voltage.c

184

void *iter;

drivers/firmware/arm_scmi/voltage.c

195

iter = ph->hops->iter_response_init(ph, &ops, v->num_levels,

drivers/firmware/arm_scmi/voltage.c

199

if (IS_ERR(iter))

drivers/firmware/arm_scmi/voltage.c

200

return PTR_ERR(iter);

drivers/firmware/arm_scmi/voltage.c

202

ret = ph->hops->iter_response_run(iter);

drivers/firmware/efi/embedded-firmware.c

124

struct efi_embedded_fw *iter, *fw = NULL;

drivers/firmware/efi/embedded-firmware.c

132

list_for_each_entry(iter, &efi_embedded_fw_list, list) {

drivers/firmware/efi/embedded-firmware.c

133

if (strcmp(name, iter->name) == 0) {

drivers/firmware/efi/embedded-firmware.c

134

fw = iter;

drivers/firmware/qcom/qcom_tzmem.c

305

struct radix_tree_iter iter;

drivers/firmware/qcom/qcom_tzmem.c

315

radix_tree_for_each_slot(slot, &qcom_tzmem_chunks, &iter, 0) {

drivers/firmware/qcom/qcom_tzmem.c

488

struct radix_tree_iter iter;

drivers/firmware/qcom/qcom_tzmem.c

494

radix_tree_for_each_slot(slot, &qcom_tzmem_chunks, &iter, 0) {

drivers/gpu/buddy.c

1116

struct rb_node *iter;

drivers/gpu/buddy.c

1122

iter = rb_last(root);

drivers/gpu/buddy.c

1123

while (iter) {

drivers/gpu/buddy.c

1124

block = rbtree_get_free_block(iter);

drivers/gpu/buddy.c

1168

iter = rb_prev(iter);

drivers/gpu/buddy.c

305

struct rb_node *iter = rb_last(&mm->free_trees[tree][i]);

drivers/gpu/buddy.c

307

while (iter) {

drivers/gpu/buddy.c

311

block = rbtree_get_free_block(iter);

drivers/gpu/buddy.c

312

iter = rb_prev(iter);

drivers/gpu/buddy.c

334

if (iter == &buddy->rb)

drivers/gpu/buddy.c

335

iter = rb_prev(iter);

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

1603

struct drm_connector_list_iter iter;

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

1618

drm_connector_list_iter_begin(dev, &iter);

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

1619

drm_for_each_connector_iter(connector, &iter) {

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

1623

drm_connector_list_iter_end(&iter);

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

1638

drm_connector_list_iter_end(&iter);

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

961

struct drm_connector_list_iter iter;

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

967

drm_connector_list_iter_begin(dev, &iter);

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

969

&iter) {

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

988

drm_connector_list_iter_end(&iter);

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

340

struct drm_print_iterator iter;

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

349

iter.data = buffer;

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

350

iter.start = 0;

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

351

iter.offset = 0;

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

352

iter.remain = count;

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

354

p = drm_coredump_printer(&iter);

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

471

return count - iter.remain;

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

1746

struct drm_connector_list_iter iter;

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

1753

drm_connector_list_iter_begin(dev, &iter);

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

1754

drm_for_each_connector_iter(connector, &iter)

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

1757

drm_connector_list_iter_end(&iter);

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

1794

struct drm_connector_list_iter iter;

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

1822

drm_connector_list_iter_begin(dev, &iter);

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

1823

drm_for_each_connector_iter(connector, &iter)

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

1826

drm_connector_list_iter_end(&iter);

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

413

struct drm_connector_list_iter iter;

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

417

drm_connector_list_iter_begin(dev, &iter);

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

419

drm_for_each_connector_iter(connector, &iter) {

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

483

drm_connector_list_iter_end(&iter);

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

74

struct drm_connector_list_iter iter;

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

77

drm_connector_list_iter_begin(dev, &iter);

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

78

drm_for_each_connector_iter(connector, &iter)

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

80

drm_connector_list_iter_end(&iter);

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

2745

struct drm_connector_list_iter iter;

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

2755

drm_connector_list_iter_begin(drm_dev, &iter);

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

2756

drm_for_each_connector_iter(list_connector, &iter) {

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

2762

drm_connector_list_iter_end(&iter);

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

2784

drm_connector_list_iter_begin(drm_dev, &iter);

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

2785

drm_for_each_connector_iter(list_connector, &iter) {

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

2792

drm_connector_list_iter_end(&iter);

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

100

drm_connector_list_iter_end(&iter);

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

110

struct drm_connector_list_iter iter;

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

113

drm_connector_list_iter_begin(dev, &iter);

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

114

drm_for_each_connector_iter(connector, &iter) {

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

121

drm_connector_list_iter_end(&iter);

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

39

struct drm_connector_list_iter iter;

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

44

drm_connector_list_iter_begin(dev, &iter);

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

46

drm_for_each_connector_iter(connector, &iter) {

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

59

drm_connector_list_iter_end(&iter);

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

67

struct drm_connector_list_iter iter;

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

69

drm_connector_list_iter_begin(dev, &iter);

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

70

drm_for_each_connector_iter(connector, &iter) {

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

80

drm_connector_list_iter_end(&iter);

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

89

struct drm_connector_list_iter iter;

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

92

drm_connector_list_iter_begin(dev, &iter);

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

93

drm_for_each_connector_iter(connector, &iter) {

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

3596

struct radix_tree_iter iter;

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

3601

radix_tree_for_each_slot(slot, &ecc_log->de_page_tree, &iter, 0) {

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

3605

radix_tree_iter_delete(&ecc_log->de_page_tree, &iter, slot);

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

602

struct dma_fence_unwrap iter;

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

622

dma_fence_unwrap_for_each(f, &iter, fence)

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

717

struct dma_fence_unwrap iter;

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

745

dma_fence_unwrap_for_each(f, &iter, fence) {

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

1232

struct drm_connector_list_iter iter;

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

1240

drm_connector_list_iter_begin(dev, &iter);

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

1241

drm_for_each_connector_iter(connector, &iter) {

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

1247

drm_connector_list_iter_end(&iter);

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

1278

struct drm_connector_list_iter iter;

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

1287

drm_connector_list_iter_begin(dev, &iter);

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

1288

drm_for_each_connector_iter(connector, &iter) {

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

1294

drm_connector_list_iter_end(&iter);

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

1334

struct drm_connector_list_iter iter;

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

1357

drm_connector_list_iter_begin(dev, &iter);

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

1358

drm_for_each_connector_iter(connector, &iter) {

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

1364

drm_connector_list_iter_end(&iter);

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

332

struct drm_connector_list_iter iter;

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

335

drm_connector_list_iter_begin(dev, &iter);

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

336

drm_for_each_connector_iter(connector, &iter) {

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

373

drm_connector_list_iter_end(&iter);

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

388

struct drm_connector_list_iter iter;

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

391

drm_connector_list_iter_begin(dev, &iter);

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

392

drm_for_each_connector_iter(connector, &iter) {

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

405

drm_connector_list_iter_end(&iter);

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

1204

struct drm_connector_list_iter iter;

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

1209

drm_connector_list_iter_begin(dev, &iter);

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

1210

drm_for_each_connector_iter(connector, &iter) {

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

1216

drm_connector_list_iter_end(&iter);

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

1248

struct drm_connector_list_iter iter;

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

1254

drm_connector_list_iter_begin(dev, &iter);

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

1255

drm_for_each_connector_iter(connector, &iter) {

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

1261

drm_connector_list_iter_end(&iter);

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

1310

struct drm_connector_list_iter iter;

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

1335

drm_connector_list_iter_begin(dev, &iter);

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

1336

drm_for_each_connector_iter(connector, &iter) {

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

1342

drm_connector_list_iter_end(&iter);

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

1722

struct drm_connector_list_iter iter;

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

1730

drm_connector_list_iter_begin(dev, &iter);

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

1731

drm_for_each_connector_iter(connector, &iter) {

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

1737

drm_connector_list_iter_end(&iter);

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

311

struct drm_connector_list_iter iter;

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

314

drm_connector_list_iter_begin(dev, &iter);

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

315

drm_for_each_connector_iter(connector, &iter) {

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

342

drm_connector_list_iter_end(&iter);

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

357

struct drm_connector_list_iter iter;

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

360

drm_connector_list_iter_begin(dev, &iter);

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

361

drm_for_each_connector_iter(connector, &iter) {

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

373

drm_connector_list_iter_end(&iter);

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

1188

struct drm_connector_list_iter iter;

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

1197

drm_connector_list_iter_begin(dev, &iter);

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

1198

drm_for_each_connector_iter(connector, &iter) {

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

1204

drm_connector_list_iter_end(&iter);

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

1249

struct drm_connector_list_iter iter;

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

1260

drm_connector_list_iter_begin(dev, &iter);

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

1261

drm_for_each_connector_iter(connector, &iter) {

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

1267

drm_connector_list_iter_end(&iter);

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

1303

struct drm_connector_list_iter iter;

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

1328

drm_connector_list_iter_begin(dev, &iter);

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

1329

drm_for_each_connector_iter(connector, &iter) {

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

1335

drm_connector_list_iter_end(&iter);

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

295

struct drm_connector_list_iter iter;

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

298

drm_connector_list_iter_begin(dev, &iter);

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

299

drm_for_each_connector_iter(connector, &iter) {

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

326

drm_connector_list_iter_end(&iter);

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

341

struct drm_connector_list_iter iter;

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

344

drm_connector_list_iter_begin(dev, &iter);

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

345

drm_for_each_connector_iter(connector, &iter) {

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

357

drm_connector_list_iter_end(&iter);

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

13473

struct drm_connector_list_iter iter;

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

13476

drm_connector_list_iter_begin(dev, &iter);

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

13477

drm_for_each_connector_iter(connector, &iter) {

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

13486

drm_connector_list_iter_end(&iter);

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

2913

struct drm_connector_list_iter iter;

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

2916

drm_connector_list_iter_begin(dev, &iter);

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

2917

drm_for_each_connector_iter(connector, &iter) {

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

2940

drm_connector_list_iter_end(&iter);

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

3141

struct drm_connector_list_iter iter;

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

3144

drm_connector_list_iter_begin(dev, &iter);

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

3145

drm_for_each_connector_iter(connector, &iter) {

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

3176

drm_connector_list_iter_end(&iter);

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

3778

struct drm_connector_list_iter iter;

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

3906

drm_connector_list_iter_begin(ddev, &iter);

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

3907

drm_for_each_connector_iter(connector, &iter) {

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

3954

drm_connector_list_iter_end(&iter);

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

3959

drm_connector_list_iter_begin(ddev, &iter);

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

3960

drm_for_each_connector_iter(connector, &iter) {

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

3980

drm_connector_list_iter_end(&iter);

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

895

struct drm_connector_list_iter iter;

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

923

drm_connector_list_iter_begin(dev, &iter);

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

924

drm_for_each_connector_iter(connector, &iter) {

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

943

drm_connector_list_iter_end(&iter);

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_crc.c

105

struct drm_connector_list_iter iter;

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_crc.c

111

drm_connector_list_iter_begin(ddev, &iter);

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_crc.c

112

drm_for_each_connector_iter(connector, &iter) {

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_crc.c

131

drm_connector_list_iter_end(&iter);

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_crtc.c

136

struct drm_connector_list_iter iter;

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_crtc.c

145

drm_connector_list_iter_begin(dev, &iter);

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_crtc.c

146

drm_for_each_connector_iter(connector, &iter) {

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_crtc.c

156

drm_connector_list_iter_end(&iter);

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_debugfs.c

4217

struct drm_connector_list_iter iter;

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_debugfs.c

4224

drm_connector_list_iter_begin(dev, &iter);

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_debugfs.c

4225

drm_for_each_connector_iter(connector, &iter) {

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_debugfs.c

4242

drm_connector_list_iter_begin(dev, &iter);

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_debugfs.c

4243

drm_for_each_connector_iter(connector, &iter) {

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_irq.c

1018

drm_connector_list_iter_end(&iter);

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_irq.c

901

struct drm_connector_list_iter iter;

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_irq.c

913

drm_connector_list_iter_begin(dev, &iter);

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_irq.c

914

drm_for_each_connector_iter(connector, &iter) {

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_irq.c

965

drm_connector_list_iter_end(&iter);

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_irq.c

983

struct drm_connector_list_iter iter;

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_irq.c

986

drm_connector_list_iter_begin(dev, &iter);

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_irq.c

987

drm_for_each_connector_iter(connector, &iter) {

drivers/gpu/drm/amd/ras/ras_mgr/ras_sys.h

105

static inline void *ras_radix_tree_delete_iter(struct radix_tree_root *root, void *iter)

drivers/gpu/drm/amd/ras/ras_mgr/ras_sys.h

107

return radix_tree_delete(root, ((struct radix_tree_iter *)iter)->index);

drivers/gpu/drm/amd/ras/rascore/ras_umc.c

145

void *iter = buf;

drivers/gpu/drm/amd/ras/rascore/ras_umc.c

148

radix_tree_for_each_slot(slot, &ras_umc->root, iter, 0) {

drivers/gpu/drm/amd/ras/rascore/ras_umc.c

149

data = ras_radix_tree_delete_iter(&ras_umc->root, iter);

drivers/gpu/drm/ast/ast_mode.c

571

struct drm_atomic_helper_damage_iter iter;

drivers/gpu/drm/ast/ast_mode.c

582

drm_atomic_helper_damage_iter_init(&iter, old_plane_state, plane_state);

drivers/gpu/drm/ast/ast_mode.c

583

drm_atomic_for_each_plane_damage(&iter, &damage) {

drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_crtc.c

100

drm_connector_list_iter_end(&iter);

drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_crtc.c

78

struct drm_connector_list_iter iter;

drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_crtc.c

96

drm_connector_list_iter_begin(ddev, &iter);

drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_crtc.c

97

drm_for_each_connector_iter(connector, &iter)

drivers/gpu/drm/display/drm_dp_aux_dev.c

253

struct drm_dp_aux_dev *iter, *aux_dev = NULL;

drivers/gpu/drm/display/drm_dp_aux_dev.c

262

idr_for_each_entry(&aux_idr, iter, id) {

drivers/gpu/drm/display/drm_dp_aux_dev.c

263

if (iter->aux == aux) {

drivers/gpu/drm/display/drm_dp_aux_dev.c

264

aux_dev = iter;

drivers/gpu/drm/drm_bridge.c

1000

drm_atomic_bridge_call_pre_enable(iter, state);

drivers/gpu/drm/drm_bridge.c

1002

if (iter->pre_enable_prev_first)

drivers/gpu/drm/drm_bridge.c

1004

iter = limit;

drivers/gpu/drm/drm_bridge.c

1006

if (iter == bridge)

drivers/gpu/drm/drm_bridge.c

1319

struct drm_bridge *iter;

drivers/gpu/drm/drm_bridge.c

1332

list_for_each_entry_reverse(iter, &encoder->bridge_chain, chain_node) {

drivers/gpu/drm/drm_bridge.c

1342

drm_atomic_bridge_propagate_bus_flags(iter, conn,

drivers/gpu/drm/drm_bridge.c

1345

ret = drm_atomic_bridge_check(iter, crtc_state, conn_state);

drivers/gpu/drm/drm_bridge.c

1349

if (iter == bridge)

drivers/gpu/drm/drm_bridge.c

805

struct drm_bridge *iter;

drivers/gpu/drm/drm_bridge.c

812

list_for_each_entry_reverse(iter, &encoder->bridge_chain, chain_node) {

drivers/gpu/drm/drm_bridge.c

813

if (iter->funcs->atomic_disable) {

drivers/gpu/drm/drm_bridge.c

814

iter->funcs->atomic_disable(iter, state);

drivers/gpu/drm/drm_bridge.c

815

} else if (iter->funcs->disable) {

drivers/gpu/drm/drm_bridge.c

816

iter->funcs->disable(iter);

drivers/gpu/drm/drm_bridge.c

819

if (iter == bridge)

drivers/gpu/drm/drm_bridge.c

959

struct drm_bridge *iter, *next, *limit;

drivers/gpu/drm/drm_bridge.c

967

list_for_each_entry_reverse(iter, &encoder->bridge_chain, chain_node) {

drivers/gpu/drm/drm_bridge.c

968

if (iter->pre_enable_prev_first) {

drivers/gpu/drm/drm_bridge.c

969

next = iter;

drivers/gpu/drm/drm_bridge.c

990

if (next == iter)

drivers/gpu/drm/drm_connector.c

1050

struct drm_connector_list_iter *iter)

drivers/gpu/drm/drm_connector.c

1052

iter->dev = dev;

drivers/gpu/drm/drm_connector.c

1053

iter->conn = NULL;

drivers/gpu/drm/drm_connector.c

1085

drm_connector_list_iter_next(struct drm_connector_list_iter *iter)

drivers/gpu/drm/drm_connector.c

1087

struct drm_connector *old_conn = iter->conn;

drivers/gpu/drm/drm_connector.c

1088

struct drm_mode_config *config = &iter->dev->mode_config;

drivers/gpu/drm/drm_connector.c

1097

iter->conn = NULL;

drivers/gpu/drm/drm_connector.c

1102

iter->conn = list_entry(lhead, struct drm_connector, head);

drivers/gpu/drm/drm_connector.c

1105

} while (!kref_get_unless_zero(&iter->conn->base.refcount));

drivers/gpu/drm/drm_connector.c

1111

return iter->conn;

drivers/gpu/drm/drm_connector.c

1124

void drm_connector_list_iter_end(struct drm_connector_list_iter *iter)

drivers/gpu/drm/drm_connector.c

1126

struct drm_mode_config *config = &iter->dev->mode_config;

drivers/gpu/drm/drm_connector.c

1129

iter->dev = NULL;

drivers/gpu/drm/drm_connector.c

1130

if (iter->conn) {

drivers/gpu/drm/drm_connector.c

1132

__drm_connector_put_safe(iter->conn);

drivers/gpu/drm/drm_damage_helper.c

225

drm_atomic_helper_damage_iter_init(struct drm_atomic_helper_damage_iter *iter,

drivers/gpu/drm/drm_damage_helper.c

230

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

drivers/gpu/drm/drm_damage_helper.c

235

iter->clips = (struct drm_rect *)drm_plane_get_damage_clips(state);

drivers/gpu/drm/drm_damage_helper.c

236

iter->num_clips = drm_plane_get_damage_clips_count(state);

drivers/gpu/drm/drm_damage_helper.c

241

iter->plane_src.x1 = src.x1 >> 16;

drivers/gpu/drm/drm_damage_helper.c

242

iter->plane_src.y1 = src.y1 >> 16;

drivers/gpu/drm/drm_damage_helper.c

243

iter->plane_src.x2 = (src.x2 >> 16) + !!(src.x2 & 0xFFFF);

drivers/gpu/drm/drm_damage_helper.c

244

iter->plane_src.y2 = (src.y2 >> 16) + !!(src.y2 & 0xFFFF);

drivers/gpu/drm/drm_damage_helper.c

246

if (!iter->clips || state->ignore_damage_clips ||

drivers/gpu/drm/drm_damage_helper.c

248

iter->clips = NULL;

drivers/gpu/drm/drm_damage_helper.c

249

iter->num_clips = 0;

drivers/gpu/drm/drm_damage_helper.c

250

iter->full_update = true;

drivers/gpu/drm/drm_damage_helper.c

272

drm_atomic_helper_damage_iter_next(struct drm_atomic_helper_damage_iter *iter,

drivers/gpu/drm/drm_damage_helper.c

277

if (iter->full_update) {

drivers/gpu/drm/drm_damage_helper.c

278

*rect = iter->plane_src;

drivers/gpu/drm/drm_damage_helper.c

279

iter->full_update = false;

drivers/gpu/drm/drm_damage_helper.c

283

while (iter->curr_clip < iter->num_clips) {

drivers/gpu/drm/drm_damage_helper.c

284

*rect = iter->clips[iter->curr_clip];

drivers/gpu/drm/drm_damage_helper.c

285

iter->curr_clip++;

drivers/gpu/drm/drm_damage_helper.c

287

if (drm_rect_intersect(rect, &iter->plane_src)) {

drivers/gpu/drm/drm_damage_helper.c

316

struct drm_atomic_helper_damage_iter iter;

drivers/gpu/drm/drm_damage_helper.c

325

drm_atomic_helper_damage_iter_init(&iter, old_state, state);

drivers/gpu/drm/drm_damage_helper.c

326

drm_atomic_for_each_plane_damage(&iter, &clip) {

drivers/gpu/drm/drm_displayid.c

100

iter->length = iter->idx + sizeof(*base) + base->bytes;

drivers/gpu/drm/drm_displayid.c

106

struct displayid_iter *iter)

drivers/gpu/drm/drm_displayid.c

108

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

drivers/gpu/drm/drm_displayid.c

110

iter->drm_edid = drm_edid;

drivers/gpu/drm/drm_displayid.c

111

iter->quirks = get_quirks(drm_edid);

drivers/gpu/drm/drm_displayid.c

115

displayid_iter_block(const struct displayid_iter *iter)

drivers/gpu/drm/drm_displayid.c

119

if (!iter->section)

drivers/gpu/drm/drm_displayid.c

122

block = (const struct displayid_block *)&iter->section[iter->idx];

drivers/gpu/drm/drm_displayid.c

124

if (iter->idx + sizeof(*block) <= iter->length &&

drivers/gpu/drm/drm_displayid.c

125

iter->idx + sizeof(*block) + block->num_bytes <= iter->length)

drivers/gpu/drm/drm_displayid.c

132

__displayid_iter_next(struct displayid_iter *iter)

drivers/gpu/drm/drm_displayid.c

136

if (!iter->drm_edid)

drivers/gpu/drm/drm_displayid.c

139

if (iter->section) {

drivers/gpu/drm/drm_displayid.c

141

block = displayid_iter_block(iter);

drivers/gpu/drm/drm_displayid.c

143

iter->section = NULL;

drivers/gpu/drm/drm_displayid.c

144

iter->drm_edid = NULL;

drivers/gpu/drm/drm_displayid.c

149

iter->idx += sizeof(*block) + block->num_bytes;

drivers/gpu/drm/drm_displayid.c

151

block = displayid_iter_block(iter);

drivers/gpu/drm/drm_displayid.c

158

bool base_section = !iter->section;

drivers/gpu/drm/drm_displayid.c

160

iter->section = find_next_displayid_extension(iter);

drivers/gpu/drm/drm_displayid.c

161

if (!iter->section) {

drivers/gpu/drm/drm_displayid.c

162

iter->drm_edid = NULL;

drivers/gpu/drm/drm_displayid.c

170

base = displayid_get_header(iter->section, iter->length,

drivers/gpu/drm/drm_displayid.c

171

iter->idx);

drivers/gpu/drm/drm_displayid.c

173

iter->version = base->rev;

drivers/gpu/drm/drm_displayid.c

174

iter->primary_use = base->prod_id;

drivers/gpu/drm/drm_displayid.c

178

iter->idx += sizeof(struct displayid_header);

drivers/gpu/drm/drm_displayid.c

180

block = displayid_iter_block(iter);

drivers/gpu/drm/drm_displayid.c

186

void displayid_iter_end(struct displayid_iter *iter)

drivers/gpu/drm/drm_displayid.c

188

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

drivers/gpu/drm/drm_displayid.c

192

u8 displayid_version(const struct displayid_iter *iter)

drivers/gpu/drm/drm_displayid.c

194

return iter->version;

drivers/gpu/drm/drm_displayid.c

201

u8 displayid_primary_use(const struct displayid_iter *iter)

drivers/gpu/drm/drm_displayid.c

203

return iter->primary_use;

drivers/gpu/drm/drm_displayid.c

82

static const u8 *find_next_displayid_extension(struct displayid_iter *iter)

drivers/gpu/drm/drm_displayid.c

86

bool ignore_checksum = iter->quirks & BIT(QUIRK_IGNORE_CHECKSUM);

drivers/gpu/drm/drm_displayid.c

88

displayid = drm_edid_find_extension(iter->drm_edid, DISPLAYID_EXT, &iter->ext_index);

drivers/gpu/drm/drm_displayid.c

93

iter->length = EDID_LENGTH - 1;

drivers/gpu/drm/drm_displayid.c

94

iter->idx = 1;

drivers/gpu/drm/drm_displayid.c

96

base = validate_displayid(displayid, iter->length, iter->idx, ignore_checksum);

drivers/gpu/drm/drm_displayid_internal.h

175

struct displayid_iter *iter);

drivers/gpu/drm/drm_displayid_internal.h

177

__displayid_iter_next(struct displayid_iter *iter);

drivers/gpu/drm/drm_displayid_internal.h

180

void displayid_iter_end(struct displayid_iter *iter);

drivers/gpu/drm/drm_displayid_internal.h

182

u8 displayid_version(const struct displayid_iter *iter);

drivers/gpu/drm/drm_displayid_internal.h

183

u8 displayid_primary_use(const struct displayid_iter *iter);

drivers/gpu/drm/drm_edid.c

1763

struct drm_edid_iter *iter)

drivers/gpu/drm/drm_edid.c

1765

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

drivers/gpu/drm/drm_edid.c

1767

iter->drm_edid = drm_edid;

drivers/gpu/drm/drm_edid.c

1770

static const void *__drm_edid_iter_next(struct drm_edid_iter *iter)

drivers/gpu/drm/drm_edid.c

1774

if (!iter->drm_edid)

drivers/gpu/drm/drm_edid.c

1777

if (iter->index < drm_edid_block_count(iter->drm_edid))

drivers/gpu/drm/drm_edid.c

1778

block = drm_edid_block_data(iter->drm_edid, iter->index++);

drivers/gpu/drm/drm_edid.c

1786

static void drm_edid_iter_end(struct drm_edid_iter *iter)

drivers/gpu/drm/drm_edid.c

1788

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

drivers/gpu/drm/drm_edid.c

4231

struct displayid_iter iter;

drivers/gpu/drm/drm_edid.c

4250

displayid_iter_edid_begin(drm_edid, &iter);

drivers/gpu/drm/drm_edid.c

4251

displayid_iter_for_each(block, &iter) {

drivers/gpu/drm/drm_edid.c

4257

displayid_iter_end(&iter);

drivers/gpu/drm/drm_edid.c

5057

struct cea_db_iter *iter)

drivers/gpu/drm/drm_edid.c

5059

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

drivers/gpu/drm/drm_edid.c

5061

drm_edid_iter_begin(drm_edid, &iter->edid_iter);

drivers/gpu/drm/drm_edid.c

5062

displayid_iter_edid_begin(drm_edid, &iter->displayid_iter);

drivers/gpu/drm/drm_edid.c

5066

__cea_db_iter_current_block(const struct cea_db_iter *iter)

drivers/gpu/drm/drm_edid.c

5070

if (!iter->collection)

drivers/gpu/drm/drm_edid.c

5073

db = (const struct cea_db *)&iter->collection[iter->index];

drivers/gpu/drm/drm_edid.c

5075

if (iter->index + sizeof(*db) <= iter->end &&

drivers/gpu/drm/drm_edid.c

5076

iter->index + sizeof(*db) + cea_db_payload_len(db) <= iter->end)

drivers/gpu/drm/drm_edid.c

5101

static const void *__cea_db_iter_edid_next(struct cea_db_iter *iter)

drivers/gpu/drm/drm_edid.c

5105

drm_edid_iter_for_each(ext, &iter->edid_iter) {

drivers/gpu/drm/drm_edid.c

5116

iter->index = 4;

drivers/gpu/drm/drm_edid.c

5117

iter->end = iter->index + size;

drivers/gpu/drm/drm_edid.c

5133

static const void *__cea_db_iter_displayid_next(struct cea_db_iter *iter)

drivers/gpu/drm/drm_edid.c

5137

displayid_iter_for_each(block, &iter->displayid_iter) {

drivers/gpu/drm/drm_edid.c

5145

iter->index = sizeof(*block);

drivers/gpu/drm/drm_edid.c

5146

iter->end = iter->index + block->num_bytes;

drivers/gpu/drm/drm_edid.c

5154

static const struct cea_db *__cea_db_iter_next(struct cea_db_iter *iter)

drivers/gpu/drm/drm_edid.c

5158

if (iter->collection) {

drivers/gpu/drm/drm_edid.c

5160

db = __cea_db_iter_current_block(iter);

drivers/gpu/drm/drm_edid.c

5162

iter->collection = NULL;

drivers/gpu/drm/drm_edid.c

5167

iter->index += sizeof(*db) + cea_db_payload_len(db);

drivers/gpu/drm/drm_edid.c

5169

db = __cea_db_iter_current_block(iter);

drivers/gpu/drm/drm_edid.c

5183

iter->collection = __cea_db_iter_edid_next(iter);

drivers/gpu/drm/drm_edid.c

5184

if (!iter->collection)

drivers/gpu/drm/drm_edid.c

5185

iter->collection = __cea_db_iter_displayid_next(iter);

drivers/gpu/drm/drm_edid.c

5187

if (!iter->collection)

drivers/gpu/drm/drm_edid.c

5190

db = __cea_db_iter_current_block(iter);

drivers/gpu/drm/drm_edid.c

5199

static void cea_db_iter_end(struct cea_db_iter *iter)

drivers/gpu/drm/drm_edid.c

5201

displayid_iter_end(&iter->displayid_iter);

drivers/gpu/drm/drm_edid.c

5202

drm_edid_iter_end(&iter->edid_iter);

drivers/gpu/drm/drm_edid.c

5204

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

drivers/gpu/drm/drm_edid.c

5358

struct cea_db_iter iter;

drivers/gpu/drm/drm_edid.c

5364

cea_db_iter_edid_begin(drm_edid, &iter);

drivers/gpu/drm/drm_edid.c

5365

cea_db_iter_for_each(db, &iter) {

drivers/gpu/drm/drm_edid.c

5377

cea_db_iter_end(&iter);

drivers/gpu/drm/drm_edid.c

5709

struct cea_db_iter iter;

drivers/gpu/drm/drm_edid.c

5734

cea_db_iter_edid_begin(drm_edid, &iter);

drivers/gpu/drm/drm_edid.c

5735

cea_db_iter_for_each(db, &iter) {

drivers/gpu/drm/drm_edid.c

5763

cea_db_iter_end(&iter);

drivers/gpu/drm/drm_edid.c

5787

struct cea_db_iter iter;

drivers/gpu/drm/drm_edid.c

5790

cea_db_iter_edid_begin(drm_edid, &iter);

drivers/gpu/drm/drm_edid.c

5791

cea_db_iter_for_each(db, &iter) {

drivers/gpu/drm/drm_edid.c

5806

cea_db_iter_end(&iter);

drivers/gpu/drm/drm_edid.c

5836

struct cea_db_iter iter;

drivers/gpu/drm/drm_edid.c

5839

cea_db_iter_edid_begin(drm_edid, &iter);

drivers/gpu/drm/drm_edid.c

5840

cea_db_iter_for_each(db, &iter) {

drivers/gpu/drm/drm_edid.c

5851

cea_db_iter_end(&iter);

drivers/gpu/drm/drm_edid.c

5923

struct cea_db_iter iter;

drivers/gpu/drm/drm_edid.c

5930

cea_db_iter_edid_begin(drm_edid, &iter);

drivers/gpu/drm/drm_edid.c

5931

cea_db_iter_for_each(db, &iter) {

drivers/gpu/drm/drm_edid.c

5937

cea_db_iter_end(&iter);

drivers/gpu/drm/drm_edid.c

5965

struct cea_db_iter iter;

drivers/gpu/drm/drm_edid.c

5984

cea_db_iter_edid_begin(drm_edid, &iter);

drivers/gpu/drm/drm_edid.c

5985

cea_db_iter_for_each(db, &iter) {

drivers/gpu/drm/drm_edid.c

5997

cea_db_iter_end(&iter);

drivers/gpu/drm/drm_edid.c

6479

struct cea_db_iter iter;

drivers/gpu/drm/drm_edid.c

6509

cea_db_iter_edid_begin(drm_edid, &iter);

drivers/gpu/drm/drm_edid.c

6510

cea_db_iter_for_each(db, &iter) {

drivers/gpu/drm/drm_edid.c

6536

cea_db_iter_end(&iter);

drivers/gpu/drm/drm_edid.c

6665

struct displayid_iter iter;

drivers/gpu/drm/drm_edid.c

6667

displayid_iter_edid_begin(drm_edid, &iter);

drivers/gpu/drm/drm_edid.c

6668

displayid_iter_for_each(block, &iter) {

drivers/gpu/drm/drm_edid.c

6672

displayid_iter_end(&iter);

drivers/gpu/drm/drm_edid.c

6723

struct displayid_iter iter;

drivers/gpu/drm/drm_edid.c

6725

displayid_iter_edid_begin(drm_edid, &iter);

drivers/gpu/drm/drm_edid.c

6726

displayid_iter_for_each(block, &iter) {

drivers/gpu/drm/drm_edid.c

6730

displayid_version(&iter),

drivers/gpu/drm/drm_edid.c

6731

displayid_primary_use(&iter));

drivers/gpu/drm/drm_edid.c

6732

if (displayid_version(&iter) == DISPLAY_ID_STRUCTURE_VER_20 &&

drivers/gpu/drm/drm_edid.c

6733

(displayid_primary_use(&iter) == PRIMARY_USE_HEAD_MOUNTED_VR ||

drivers/gpu/drm/drm_edid.c

6734

displayid_primary_use(&iter) == PRIMARY_USE_HEAD_MOUNTED_AR))

drivers/gpu/drm/drm_edid.c

6743

displayid_iter_end(&iter);

drivers/gpu/drm/drm_edid.c

6998

struct displayid_iter iter;

drivers/gpu/drm/drm_edid.c

7001

displayid_iter_edid_begin(drm_edid, &iter);

drivers/gpu/drm/drm_edid.c

7002

displayid_iter_for_each(block, &iter) {

drivers/gpu/drm/drm_edid.c

7010

displayid_iter_end(&iter);

drivers/gpu/drm/drm_edid.c

7632

static bool displayid_is_tiled_block(const struct displayid_iter *iter,

drivers/gpu/drm/drm_edid.c

7635

return (displayid_version(iter) < DISPLAY_ID_STRUCTURE_VER_20 &&

drivers/gpu/drm/drm_edid.c

7637

(displayid_version(iter) == DISPLAY_ID_STRUCTURE_VER_20 &&

drivers/gpu/drm/drm_edid.c

7645

struct displayid_iter iter;

drivers/gpu/drm/drm_edid.c

7649

displayid_iter_edid_begin(drm_edid, &iter);

drivers/gpu/drm/drm_edid.c

7650

displayid_iter_for_each(block, &iter) {

drivers/gpu/drm/drm_edid.c

7651

if (displayid_is_tiled_block(&iter, block))

drivers/gpu/drm/drm_edid.c

7654

displayid_iter_end(&iter);

drivers/gpu/drm/drm_fb_dma_helper.c

128

struct drm_atomic_helper_damage_iter iter;

drivers/gpu/drm/drm_fb_dma_helper.c

141

drm_atomic_helper_damage_iter_init(&iter, old_state, state);

drivers/gpu/drm/drm_fb_dma_helper.c

143

drm_atomic_for_each_plane_damage(&iter, &clip) {

drivers/gpu/drm/drm_panic.c

556

struct kmsg_dump_iter iter;

drivers/gpu/drm/drm_panic.c

570

kmsg_dump_rewind(&iter);

drivers/gpu/drm/drm_panic.c

571

while (kmsg_dump_get_buffer(&iter, false, kmsg_buf, sizeof(kmsg_buf), &kmsg_len)) {

drivers/gpu/drm/drm_panic.c

653

struct kmsg_dump_iter iter;

drivers/gpu/drm/drm_panic.c

666

kmsg_dump_rewind(&iter);

drivers/gpu/drm/drm_panic.c

667

kmsg_dump_get_buffer(&iter, false, qrbuf1, max_kmsg_size, &kmsg_len);

drivers/gpu/drm/drm_panic.c

710

struct kmsg_dump_iter iter;

drivers/gpu/drm/drm_panic.c

715

kmsg_dump_rewind(&iter);

drivers/gpu/drm/drm_panic.c

716

kmsg_dump_get_buffer(&iter, false, qrbuf1, max_kmsg_size, &kmsg_len);

drivers/gpu/drm/drm_syncobj.c

1687

struct dma_fence *iter, *last_signaled =

drivers/gpu/drm/drm_syncobj.c

1694

dma_fence_chain_for_each(iter, fence) {

drivers/gpu/drm/drm_syncobj.c

1695

if (iter->context != fence->context) {

drivers/gpu/drm/drm_syncobj.c

1696

dma_fence_put(iter);

drivers/gpu/drm/drm_syncobj.c

1702

last_signaled = dma_fence_get(iter);

drivers/gpu/drm/drm_vma_manager.c

146

struct rb_node *iter;

drivers/gpu/drm/drm_vma_manager.c

149

iter = mgr->vm_addr_space_mm.interval_tree.rb_root.rb_node;

drivers/gpu/drm/drm_vma_manager.c

152

while (likely(iter)) {

drivers/gpu/drm/drm_vma_manager.c

153

node = rb_entry(iter, struct drm_mm_node, rb);

drivers/gpu/drm/drm_vma_manager.c

156

iter = iter->rb_right;

drivers/gpu/drm/drm_vma_manager.c

161

iter = iter->rb_left;

drivers/gpu/drm/drm_vma_manager.c

247

struct rb_node **iter;

drivers/gpu/drm/drm_vma_manager.c

260

iter = &node->vm_files.rb_node;

drivers/gpu/drm/drm_vma_manager.c

262

while (likely(*iter)) {

drivers/gpu/drm/drm_vma_manager.c

263

parent = *iter;

drivers/gpu/drm/drm_vma_manager.c

264

entry = rb_entry(*iter, struct drm_vma_offset_file, vm_rb);

drivers/gpu/drm/drm_vma_manager.c

271

iter = &(*iter)->rb_right;

drivers/gpu/drm/drm_vma_manager.c

273

iter = &(*iter)->rb_left;

drivers/gpu/drm/drm_vma_manager.c

284

rb_link_node(&new->vm_rb, parent, iter);

drivers/gpu/drm/drm_vma_manager.c

362

struct rb_node *iter;

drivers/gpu/drm/drm_vma_manager.c

366

iter = node->vm_files.rb_node;

drivers/gpu/drm/drm_vma_manager.c

367

while (likely(iter)) {

drivers/gpu/drm/drm_vma_manager.c

368

entry = rb_entry(iter, struct drm_vma_offset_file, vm_rb);

drivers/gpu/drm/drm_vma_manager.c

376

iter = iter->rb_right;

drivers/gpu/drm/drm_vma_manager.c

378

iter = iter->rb_left;

drivers/gpu/drm/drm_vma_manager.c

403

struct rb_node *iter;

drivers/gpu/drm/drm_vma_manager.c

407

iter = node->vm_files.rb_node;

drivers/gpu/drm/drm_vma_manager.c

408

while (likely(iter)) {

drivers/gpu/drm/drm_vma_manager.c

409

entry = rb_entry(iter, struct drm_vma_offset_file, vm_rb);

drivers/gpu/drm/drm_vma_manager.c

413

iter = iter->rb_right;

drivers/gpu/drm/drm_vma_manager.c

415

iter = iter->rb_left;

drivers/gpu/drm/drm_vma_manager.c

420

return iter;

drivers/gpu/drm/etnaviv/etnaviv_dump.c

100

static void etnaviv_core_dump_mmu(struct core_dump_iterator *iter,

drivers/gpu/drm/etnaviv/etnaviv_dump.c

103

etnaviv_iommu_dump(mmu, iter->data);

drivers/gpu/drm/etnaviv/etnaviv_dump.c

105

etnaviv_core_dump_header(iter, ETDUMP_BUF_MMU, iter->data + mmu_size);

drivers/gpu/drm/etnaviv/etnaviv_dump.c

108

static void etnaviv_core_dump_mem(struct core_dump_iterator *iter, u32 type,

drivers/gpu/drm/etnaviv/etnaviv_dump.c

111

memcpy(iter->data, ptr, size);

drivers/gpu/drm/etnaviv/etnaviv_dump.c

113

iter->hdr->iova = cpu_to_le64(iova);

drivers/gpu/drm/etnaviv/etnaviv_dump.c

115

etnaviv_core_dump_header(iter, type, iter->data + size);

drivers/gpu/drm/etnaviv/etnaviv_dump.c

121

struct core_dump_iterator iter;

drivers/gpu/drm/etnaviv/etnaviv_dump.c

159

file_size += sizeof(*iter.hdr) * n_obj;

drivers/gpu/drm/etnaviv/etnaviv_dump.c

162

iter.start = __vmalloc(file_size, GFP_NOWAIT);

drivers/gpu/drm/etnaviv/etnaviv_dump.c

163

if (!iter.start) {

drivers/gpu/drm/etnaviv/etnaviv_dump.c

170

iter.hdr = iter.start;

drivers/gpu/drm/etnaviv/etnaviv_dump.c

171

iter.data = &iter.hdr[n_obj];

drivers/gpu/drm/etnaviv/etnaviv_dump.c

173

memset(iter.hdr, 0, iter.data - iter.start);

drivers/gpu/drm/etnaviv/etnaviv_dump.c

175

etnaviv_core_dump_registers(&iter, gpu);

drivers/gpu/drm/etnaviv/etnaviv_dump.c

176

etnaviv_core_dump_mmu(&iter, submit->mmu_context, mmu_size);

drivers/gpu/drm/etnaviv/etnaviv_dump.c

177

etnaviv_core_dump_mem(&iter, ETDUMP_BUF_RING, gpu->buffer.vaddr,

drivers/gpu/drm/etnaviv/etnaviv_dump.c

182

etnaviv_core_dump_mem(&iter, ETDUMP_BUF_CMD,

drivers/gpu/drm/etnaviv/etnaviv_dump.c

191

bomap_start = bomap = iter.data;

drivers/gpu/drm/etnaviv/etnaviv_dump.c

193

etnaviv_core_dump_header(&iter, ETDUMP_BUF_BOMAP,

drivers/gpu/drm/etnaviv/etnaviv_dump.c

214

iter.hdr->data[0] = cpu_to_le32((bomap - bomap_start));

drivers/gpu/drm/etnaviv/etnaviv_dump.c

220

iter.hdr->iova = cpu_to_le64(vram->iova);

drivers/gpu/drm/etnaviv/etnaviv_dump.c

224

memcpy(iter.data, vaddr, obj->base.size);

drivers/gpu/drm/etnaviv/etnaviv_dump.c

226

etnaviv_core_dump_header(&iter, ETDUMP_BUF_BO, iter.data +

drivers/gpu/drm/etnaviv/etnaviv_dump.c

230

etnaviv_core_dump_header(&iter, ETDUMP_BUF_END, iter.data);

drivers/gpu/drm/etnaviv/etnaviv_dump.c

232

dev_coredumpv(gpu->dev, iter.start, iter.data - iter.start, GFP_NOWAIT);

drivers/gpu/drm/etnaviv/etnaviv_dump.c

67

static void etnaviv_core_dump_header(struct core_dump_iterator *iter,

drivers/gpu/drm/etnaviv/etnaviv_dump.c

70

struct etnaviv_dump_object_header *hdr = iter->hdr;

drivers/gpu/drm/etnaviv/etnaviv_dump.c

74

hdr->file_offset = cpu_to_le32(iter->data - iter->start);

drivers/gpu/drm/etnaviv/etnaviv_dump.c

75

hdr->file_size = cpu_to_le32(data_end - iter->data);

drivers/gpu/drm/etnaviv/etnaviv_dump.c

77

iter->hdr++;

drivers/gpu/drm/etnaviv/etnaviv_dump.c

78

iter->data += le32_to_cpu(hdr->file_size);

drivers/gpu/drm/etnaviv/etnaviv_dump.c

81

static void etnaviv_core_dump_registers(struct core_dump_iterator *iter,

drivers/gpu/drm/etnaviv/etnaviv_dump.c

84

struct etnaviv_dump_registers *reg = iter->data;

drivers/gpu/drm/etnaviv/etnaviv_dump.c

97

etnaviv_core_dump_header(iter, ETDUMP_BUF_REG, reg);

drivers/gpu/drm/etnaviv/etnaviv_perfmon.c

509

if (domain->iter >= nr_domains)

drivers/gpu/drm/etnaviv/etnaviv_perfmon.c

512

dom = pm_domain(gpu, domain->iter);

drivers/gpu/drm/etnaviv/etnaviv_perfmon.c

516

domain->id = domain->iter;

drivers/gpu/drm/etnaviv/etnaviv_perfmon.c

520

domain->iter++;

drivers/gpu/drm/etnaviv/etnaviv_perfmon.c

521

if (domain->iter == nr_domains)

drivers/gpu/drm/etnaviv/etnaviv_perfmon.c

522

domain->iter = 0xff;

drivers/gpu/drm/etnaviv/etnaviv_perfmon.c

541

if (signal->iter >= dom->nr_signals)

drivers/gpu/drm/etnaviv/etnaviv_perfmon.c

544

sig = &dom->signal[signal->iter];

drivers/gpu/drm/etnaviv/etnaviv_perfmon.c

546

signal->id = signal->iter;

drivers/gpu/drm/etnaviv/etnaviv_perfmon.c

549

signal->iter++;

drivers/gpu/drm/etnaviv/etnaviv_perfmon.c

550

if (signal->iter == dom->nr_signals)

drivers/gpu/drm/etnaviv/etnaviv_perfmon.c

551

signal->iter = 0xffff;

drivers/gpu/drm/gud/gud_pipe.c

627

struct drm_atomic_helper_damage_iter iter;

drivers/gpu/drm/gud/gud_pipe.c

650

drm_atomic_helper_damage_iter_init(&iter, old_state, new_state);

drivers/gpu/drm/gud/gud_pipe.c

651

drm_atomic_for_each_plane_damage(&iter, &damage)

drivers/gpu/drm/hyperv/hyperv_drm_modeset.c

179

struct drm_atomic_helper_damage_iter iter;

drivers/gpu/drm/hyperv/hyperv_drm_modeset.c

181

drm_atomic_helper_damage_iter_init(&iter, old_state, new_state);

drivers/gpu/drm/hyperv/hyperv_drm_modeset.c

182

drm_atomic_for_each_plane_damage(&iter, &damage) {

drivers/gpu/drm/i915/display/intel_crtc.c

318

struct intel_crtc *iter;

drivers/gpu/drm/i915/display/intel_crtc.c

320

list_for_each_entry(iter, &display->pipe_list, pipe_head) {

drivers/gpu/drm/i915/display/intel_crtc.c

321

if (crtc->pipe < iter->pipe) {

drivers/gpu/drm/i915/display/intel_crtc.c

322

list_add_tail(&crtc->pipe_head, &iter->pipe_head);

drivers/gpu/drm/i915/display/intel_display.h

258

#define for_each_intel_connector_iter(intel_connector, iter) \

drivers/gpu/drm/i915/display/intel_display.h

259

while ((intel_connector = to_intel_connector(drm_connector_list_iter_next(iter))))

drivers/gpu/drm/i915/display/skl_watermark.c

1389

_skl_allocate_plane_ddb(struct skl_plane_ddb_iter *iter,

drivers/gpu/drm/i915/display/skl_watermark.c

1395

if (data_rate && iter->data_rate) {

drivers/gpu/drm/i915/display/skl_watermark.c

1396

extra = min_t(u16, iter->size,

drivers/gpu/drm/i915/display/skl_watermark.c

1397

DIV64_U64_ROUND_UP(iter->size * data_rate,

drivers/gpu/drm/i915/display/skl_watermark.c

1398

iter->data_rate));

drivers/gpu/drm/i915/display/skl_watermark.c

1399

iter->size -= extra;

drivers/gpu/drm/i915/display/skl_watermark.c

1400

iter->data_rate -= data_rate;

drivers/gpu/drm/i915/display/skl_watermark.c

1410

iter->start = skl_ddb_entry_init(ddb, iter->start,

drivers/gpu/drm/i915/display/skl_watermark.c

1411

iter->start + size);

drivers/gpu/drm/i915/display/skl_watermark.c

1415

skl_allocate_plane_ddb(struct skl_plane_ddb_iter *iter,

drivers/gpu/drm/i915/display/skl_watermark.c

1419

_skl_allocate_plane_ddb(iter, wm->min_ddb_alloc, ddb, data_rate);

drivers/gpu/drm/i915/display/skl_watermark.c

1423

skl_allocate_plane_ddb_nv12(struct skl_plane_ddb_iter *iter,

drivers/gpu/drm/i915/display/skl_watermark.c

1428

_skl_allocate_plane_ddb(iter, wm->min_ddb_alloc, ddb_y, data_rate_y);

drivers/gpu/drm/i915/display/skl_watermark.c

1429

_skl_allocate_plane_ddb(iter, wm->min_ddb_alloc_uv, ddb, data_rate);

drivers/gpu/drm/i915/display/skl_watermark.c

1443

struct skl_plane_ddb_iter iter;

drivers/gpu/drm/i915/display/skl_watermark.c

1460

iter.start = alloc->start;

drivers/gpu/drm/i915/display/skl_watermark.c

1461

iter.size = skl_ddb_entry_size(alloc);

drivers/gpu/drm/i915/display/skl_watermark.c

1462

if (iter.size == 0)

drivers/gpu/drm/i915/display/skl_watermark.c

1467

iter.size -= cursor_size;

drivers/gpu/drm/i915/display/skl_watermark.c

1471

iter.data_rate = skl_total_relative_data_rate(crtc_state);

drivers/gpu/drm/i915/display/skl_watermark.c

1500

if (blocks <= iter.size) {

drivers/gpu/drm/i915/display/skl_watermark.c

1501

iter.size -= blocks;

drivers/gpu/drm/i915/display/skl_watermark.c

1510

blocks, iter.size);

drivers/gpu/drm/i915/display/skl_watermark.c

1515

if (iter.data_rate == 0)

drivers/gpu/drm/i915/display/skl_watermark.c

1516

iter.size = 0;

drivers/gpu/drm/i915/display/skl_watermark.c

1539

skl_allocate_plane_ddb_nv12(&iter, &wm->wm[level],

drivers/gpu/drm/i915/display/skl_watermark.c

1543

skl_allocate_plane_ddb(&iter, &wm->wm[level],

drivers/gpu/drm/i915/display/skl_watermark.c

1551

drm_WARN_ON(display->drm, iter.size != 0 || iter.data_rate != 0);

drivers/gpu/drm/i915/gem/i915_gem_context.c

106

struct radix_tree_iter iter;

drivers/gpu/drm/i915/gem/i915_gem_context.c

111

radix_tree_for_each_slot(slot, &ctx->handles_vma, &iter, 0) {

drivers/gpu/drm/i915/gem/i915_gem_context.c

124

if (lut->handle != iter.index)

drivers/gpu/drm/i915/gem/i915_gem_context.c

134

radix_tree_iter_delete(&ctx->handles_vma, &iter, slot);

drivers/gpu/drm/i915/gem/i915_gem_object.h

376

struct i915_gem_object_page_iter *iter,

drivers/gpu/drm/i915/gem/i915_gem_pages.c

181

struct radix_tree_iter iter;

drivers/gpu/drm/i915/gem/i915_gem_pages.c

185

radix_tree_for_each_slot(slot, &obj->mm.get_page.radix, &iter, 0)

drivers/gpu/drm/i915/gem/i915_gem_pages.c

186

radix_tree_delete(&obj->mm.get_page.radix, iter.index);

drivers/gpu/drm/i915/gem/i915_gem_pages.c

187

radix_tree_for_each_slot(slot, &obj->mm.get_dma_page.radix, &iter, 0)

drivers/gpu/drm/i915/gem/i915_gem_pages.c

188

radix_tree_delete(&obj->mm.get_dma_page.radix, iter.index);

drivers/gpu/drm/i915/gem/i915_gem_pages.c

280

struct sgt_iter iter;

drivers/gpu/drm/i915/gem/i915_gem_pages.c

323

for_each_sgt_page(page, iter, obj->mm.pages)

drivers/gpu/drm/i915/gem/i915_gem_pages.c

339

struct sgt_iter iter;

drivers/gpu/drm/i915/gem/i915_gem_pages.c

353

for_each_sgt_daddr(addr, iter, obj->mm.pages)

drivers/gpu/drm/i915/gem/i915_gem_pages.c

382

struct sgt_iter iter;

drivers/gpu/drm/i915/gem/i915_gem_pages.c

390

for_each_sgt_page(page, iter, obj->mm.pages)

drivers/gpu/drm/i915/gem/i915_gem_pages.c

646

struct i915_gem_object_page_iter *iter,

drivers/gpu/drm/i915/gem/i915_gem_pages.c

651

const bool dma = iter == &obj->mm.get_dma_page ||

drivers/gpu/drm/i915/gem/i915_gem_pages.c

652

iter == &obj->ttm.get_io_page;

drivers/gpu/drm/i915/gem/i915_gem_pages.c

670

if (n < READ_ONCE(iter->sg_idx))

drivers/gpu/drm/i915/gem/i915_gem_pages.c

673

mutex_lock(&iter->lock);

drivers/gpu/drm/i915/gem/i915_gem_pages.c

680

sg = iter->sg_pos;

drivers/gpu/drm/i915/gem/i915_gem_pages.c

681

idx = iter->sg_idx;

drivers/gpu/drm/i915/gem/i915_gem_pages.c

697

ret = radix_tree_insert(&iter->radix, idx, sg);

drivers/gpu/drm/i915/gem/i915_gem_pages.c

703

ret = radix_tree_insert(&iter->radix, idx + i, entry);

drivers/gpu/drm/i915/gem/i915_gem_pages.c

714

iter->sg_pos = sg;

drivers/gpu/drm/i915/gem/i915_gem_pages.c

715

iter->sg_idx = idx;

drivers/gpu/drm/i915/gem/i915_gem_pages.c

717

mutex_unlock(&iter->lock);

drivers/gpu/drm/i915/gem/i915_gem_pages.c

737

sg = radix_tree_lookup(&iter->radix, n);

drivers/gpu/drm/i915/gem/i915_gem_pages.c

750

sg = radix_tree_lookup(&iter->radix, base);

drivers/gpu/drm/i915/gem/i915_gem_shmem.c

414

struct iov_iter iter;

drivers/gpu/drm/i915/gem/i915_gem_shmem.c

447

iov_iter_ubuf(&iter, ITER_SOURCE, (void __user *)user_data, size);

drivers/gpu/drm/i915/gem/i915_gem_shmem.c

449

written = file->f_op->write_iter(&kiocb, &iter);

drivers/gpu/drm/i915/gem/i915_gem_ttm.c

395

struct radix_tree_iter iter;

drivers/gpu/drm/i915/gem/i915_gem_ttm.c

402

radix_tree_for_each_slot(slot, &obj->ttm.get_io_page.radix, &iter, 0)

drivers/gpu/drm/i915/gem/i915_gem_ttm.c

403

radix_tree_delete(&obj->ttm.get_io_page.radix, iter.index);

drivers/gpu/drm/i915/gem/i915_gem_wait.c

125

struct dma_fence *iter;

drivers/gpu/drm/i915/gem/i915_gem_wait.c

128

dma_fence_chain_for_each(iter, fence) {

drivers/gpu/drm/i915/gem/i915_gem_wait.c

129

fence_set_priority(to_dma_fence_chain(iter)->fence,

drivers/gpu/drm/i915/gem/i915_gem_wait.c

133

dma_fence_put(iter);

drivers/gpu/drm/i915/gt/gen6_ppgtt.c

121

struct sgt_dma iter = sgt_dma(vma_res);

drivers/gpu/drm/i915/gt/gen6_ppgtt.c

128

GEM_BUG_ON(sg_dma_len(iter.sg) < I915_GTT_PAGE_SIZE);

drivers/gpu/drm/i915/gt/gen6_ppgtt.c

129

vaddr[act_pte] = pte_encode | GEN6_PTE_ADDR_ENCODE(iter.dma);

drivers/gpu/drm/i915/gt/gen6_ppgtt.c

131

iter.dma += I915_GTT_PAGE_SIZE;

drivers/gpu/drm/i915/gt/gen6_ppgtt.c

132

if (iter.dma == iter.max) {

drivers/gpu/drm/i915/gt/gen6_ppgtt.c

133

iter.sg = __sg_next(iter.sg);

drivers/gpu/drm/i915/gt/gen6_ppgtt.c

134

if (!iter.sg || sg_dma_len(iter.sg) == 0)

drivers/gpu/drm/i915/gt/gen6_ppgtt.c

137

iter.dma = sg_dma_address(iter.sg);

drivers/gpu/drm/i915/gt/gen6_ppgtt.c

138

iter.max = iter.dma + sg_dma_len(iter.sg);

drivers/gpu/drm/i915/gt/gen6_ppgtt.h

57

#define gen6_for_each_pde(pt, pd, start, length, iter) \

drivers/gpu/drm/i915/gt/gen6_ppgtt.h

58

for (iter = gen6_pde_index(start); \

drivers/gpu/drm/i915/gt/gen6_ppgtt.h

59

length > 0 && iter < I915_PDES && \

drivers/gpu/drm/i915/gt/gen6_ppgtt.h

60

(pt = i915_pt_entry(pd, iter), true); \

drivers/gpu/drm/i915/gt/gen6_ppgtt.h

63

start += temp; length -= temp; }), ++iter)

drivers/gpu/drm/i915/gt/gen6_ppgtt.h

65

#define gen6_for_all_pdes(pt, pd, iter) \

drivers/gpu/drm/i915/gt/gen6_ppgtt.h

66

for (iter = 0; \

drivers/gpu/drm/i915/gt/gen6_ppgtt.h

67

iter < I915_PDES && \

drivers/gpu/drm/i915/gt/gen6_ppgtt.h

68

(pt = i915_pt_entry(pd, iter), true); \

drivers/gpu/drm/i915/gt/gen6_ppgtt.h

69

++iter)

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

457

struct sgt_dma *iter,

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

469

GEM_BUG_ON(sg_dma_len(iter->sg) < I915_GTT_PAGE_SIZE);

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

470

vaddr[gen8_pd_index(idx, 0)] = pte_encode | iter->dma;

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

472

iter->dma += I915_GTT_PAGE_SIZE;

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

473

if (iter->dma >= iter->max) {

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

474

iter->sg = __sg_next(iter->sg);

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

475

if (!iter->sg || sg_dma_len(iter->sg) == 0) {

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

480

iter->dma = sg_dma_address(iter->sg);

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

481

iter->max = iter->dma + sg_dma_len(iter->sg);

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

505

struct sgt_dma *iter,

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

510

unsigned int rem = sg_dma_len(iter->sg);

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

532

IS_ALIGNED(iter->dma, I915_GTT_PAGE_SIZE_2M) &&

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

565

} else if (IS_ALIGNED(iter->dma, I915_GTT_PAGE_SIZE_64K) &&

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

582

encode | (iter->dma + i *

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

587

iter->dma += page_size;

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

589

if (iter->dma >= iter->max) {

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

590

iter->sg = __sg_next(iter->sg);

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

591

if (!iter->sg)

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

594

rem = sg_dma_len(iter->sg);

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

598

iter->dma = sg_dma_address(iter->sg);

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

599

iter->max = iter->dma + rem;

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

601

if (unlikely(!IS_ALIGNED(iter->dma, page_size)))

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

608

} while (iter->sg && sg_dma_len(iter->sg));

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

613

struct sgt_dma *iter,

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

618

unsigned int rem = sg_dma_len(iter->sg);

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

635

IS_ALIGNED(iter->dma, I915_GTT_PAGE_SIZE_2M) &&

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

652

IS_ALIGNED(iter->dma, I915_GTT_PAGE_SIZE_64K) &&

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

661

GEM_BUG_ON(sg_dma_len(iter->sg) < page_size);

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

662

vaddr[index++] = encode | iter->dma;

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

665

iter->dma += page_size;

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

667

if (iter->dma >= iter->max) {

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

668

iter->sg = __sg_next(iter->sg);

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

669

if (!iter->sg)

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

672

rem = sg_dma_len(iter->sg);

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

676

iter->dma = sg_dma_address(iter->sg);

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

677

iter->max = iter->dma + rem;

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

680

!(IS_ALIGNED(iter->dma, I915_GTT_PAGE_SIZE_64K) &&

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

685

if (unlikely(!IS_ALIGNED(iter->dma, page_size)))

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

701

!iter->sg && IS_ALIGNED(vma_res->start +

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

732

} while (iter->sg && sg_dma_len(iter->sg));

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

741

struct sgt_dma iter = sgt_dma(vma_res);

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

745

xehp_ppgtt_insert_huge(vm, vma_res, &iter, pat_index, flags);

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

747

gen8_ppgtt_insert_huge(vm, vma_res, &iter, pat_index, flags);

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

755

idx = gen8_ppgtt_insert_pte(ppgtt, pdp, &iter, idx,

drivers/gpu/drm/i915/gt/intel_engine_cs.c

1776

int iter;

drivers/gpu/drm/i915/gt/intel_engine_cs.c

1796

for_each_ss_steering(iter, engine->gt, slice, subslice) {

drivers/gpu/drm/i915/gt/intel_engine_cs.c

1808

for_each_ss_steering(iter, engine->gt, slice, subslice)

drivers/gpu/drm/i915/gt/intel_ggtt.c

347

struct sgt_iter iter;

drivers/gpu/drm/i915/gt/intel_ggtt.c

361

iter = __sgt_iter(pages->sgl, true);

drivers/gpu/drm/i915/gt/intel_ggtt.c

396

for_each_sgt_daddr_next(addr, iter) {

drivers/gpu/drm/i915/gt/intel_ggtt.c

501

struct sgt_iter iter;

drivers/gpu/drm/i915/gt/intel_ggtt.c

516

for_each_sgt_daddr(addr, iter, vma_res->bi.pages)

drivers/gpu/drm/i915/gt/intel_ggtt.c

657

struct sgt_iter iter;

drivers/gpu/drm/i915/gt/intel_ggtt.c

667

for_each_sgt_daddr(addr, iter, vma_res->bi.pages)

drivers/gpu/drm/i915/gt/uc/intel_guc_capture.c

296

int slice, subslice, iter, i, num_steer_regs, num_tot_regs = 0;

drivers/gpu/drm/i915/gt/uc/intel_guc_capture.c

316

for_each_ss_steering(iter, gt, slice, subslice)

drivers/gpu/drm/i915/gt/uc/intel_guc_capture.c

333

for_each_ss_steering(iter, gt, slice, subslice) {

drivers/gpu/drm/i915/gt/uc/intel_uc_fw.c

1282

struct sgt_iter iter;

drivers/gpu/drm/i915/gt/uc/intel_uc_fw.c

1294

for_each_sgt_page(page, iter, uc_fw->obj->mm.pages) {

drivers/gpu/drm/i915/gt/uc/intel_uc_fw.c

1314

for_each_sgt_daddr(addr, iter, uc_fw->obj->mm.pages) {

drivers/gpu/drm/i915/gvt/gtt.c

703

struct radix_tree_iter iter;

drivers/gpu/drm/i915/gvt/gtt.c

708

radix_tree_for_each_slot(slot, &vgpu->gtt.spt_tree, &iter, 0) {

drivers/gpu/drm/i915/gvt/handlers.c

2869

static int handle_mmio(struct intel_gvt_mmio_table_iter *iter, u32 offset,

drivers/gpu/drm/i915/gvt/handlers.c

2872

struct intel_gvt *gvt = iter->data;

drivers/gpu/drm/i915/gvt/handlers.c

2908

static int handle_mmio_block(struct intel_gvt_mmio_table_iter *iter,

drivers/gpu/drm/i915/gvt/handlers.c

2911

struct intel_gvt *gvt = iter->data;

drivers/gpu/drm/i915/gvt/handlers.c

2935

static int handle_mmio_cb(struct intel_gvt_mmio_table_iter *iter, u32 offset,

drivers/gpu/drm/i915/gvt/handlers.c

2939

return handle_mmio(iter, offset, size);

drivers/gpu/drm/i915/gvt/handlers.c

2941

return handle_mmio_block(iter, offset, size);

drivers/gpu/drm/i915/gvt/handlers.c

2946

struct intel_gvt_mmio_table_iter iter = {

drivers/gpu/drm/i915/gvt/handlers.c

2952

return intel_gvt_iterate_mmio_table(&iter);

drivers/gpu/drm/i915/i915_deps.c

225

struct dma_resv_iter iter;

drivers/gpu/drm/i915/i915_deps.c

229

dma_resv_for_each_fence(&iter, resv, dma_resv_usage_rw(true), fence) {

drivers/gpu/drm/i915/i915_gpu_error.c

1147

struct sgt_iter iter;

drivers/gpu/drm/i915/i915_gpu_error.c

1178

for_each_sgt_daddr(dma, iter, vma_res->bi.pages) {

drivers/gpu/drm/i915/i915_gpu_error.c

1208

for_each_sgt_daddr(dma, iter, vma_res->bi.pages) {

drivers/gpu/drm/i915/i915_gpu_error.c

1228

for_each_sgt_page(page, iter, vma_res->bi.pages) {

drivers/gpu/drm/i915/i915_gpu_error.c

444

int iter;

drivers/gpu/drm/i915/i915_gpu_error.c

458

for_each_ss_steering(iter, ee->engine->gt, slice, subslice)

drivers/gpu/drm/i915/i915_gpu_error.c

463

for_each_ss_steering(iter, ee->engine->gt, slice, subslice)

drivers/gpu/drm/i915/i915_gpu_error.c

472

for_each_ss_steering(iter, ee->engine->gt, slice, subslice)

drivers/gpu/drm/i915/i915_gpu_error.c

84

__sg_set_buf(e->cur++, e->buf, e->bytes, e->iter);

drivers/gpu/drm/i915/i915_gpu_error.c

85

e->iter += e->bytes;

drivers/gpu/drm/i915/i915_gpu_error.c

980

__sg_set_buf(m.cur++, m.buf, m.bytes, m.iter);

drivers/gpu/drm/i915/i915_gpu_error.h

238

loff_t iter;

drivers/gpu/drm/i915/i915_request.c

1361

struct dma_fence *iter;

drivers/gpu/drm/i915/i915_request.c

1367

dma_fence_chain_for_each(iter, fence) {

drivers/gpu/drm/i915/i915_request.c

1368

struct dma_fence_chain *chain = to_dma_fence_chain(iter);

drivers/gpu/drm/i915/i915_request.c

1371

err = __i915_request_await_external(rq, iter);

drivers/gpu/drm/i915/i915_request.c

1380

dma_fence_put(iter);

drivers/gpu/drm/i915/i915_vma.c

1145

struct scatterlist *iter;

drivers/gpu/drm/i915/i915_vma.c

1148

iter = i915_gem_object_get_sg_dma(obj, obj_offset, &offset);

drivers/gpu/drm/i915/i915_vma.c

1149

GEM_BUG_ON(!iter);

drivers/gpu/drm/i915/i915_vma.c

1154

len = min(sg_dma_len(iter) - (offset << PAGE_SHIFT),

drivers/gpu/drm/i915/i915_vma.c

1158

sg_dma_address(iter) + (offset << PAGE_SHIFT);

drivers/gpu/drm/i915/i915_vma.c

1167

iter = __sg_next(iter);

drivers/gpu/drm/i915/intel_gvt.c

105

save_mmio(iter, offset, size);

drivers/gpu/drm/i915/intel_gvt.c

113

struct intel_gvt_mmio_table_iter iter;

drivers/gpu/drm/i915/intel_gvt.c

134

iter.i915 = dev_priv;

drivers/gpu/drm/i915/intel_gvt.c

135

iter.data = vgpu->initial_mmio;

drivers/gpu/drm/i915/intel_gvt.c

136

iter.handle_mmio_cb = handle_mmio;

drivers/gpu/drm/i915/intel_gvt.c

138

ret = intel_gvt_iterate_mmio_table(&iter);

drivers/gpu/drm/i915/intel_gvt.c

86

static void save_mmio(struct intel_gvt_mmio_table_iter *iter, u32 offset,

drivers/gpu/drm/i915/intel_gvt.c

89

struct drm_i915_private *dev_priv = iter->i915;

drivers/gpu/drm/i915/intel_gvt.c

93

mmio = iter->data + i;

drivers/gpu/drm/i915/intel_gvt.c

99

static int handle_mmio(struct intel_gvt_mmio_table_iter *iter,

drivers/gpu/drm/i915/intel_gvt.h

36

int (*handle_mmio_cb)(struct intel_gvt_mmio_table_iter *iter,

drivers/gpu/drm/i915/intel_gvt.h

44

int intel_gvt_iterate_mmio_table(struct intel_gvt_mmio_table_iter *iter);

drivers/gpu/drm/i915/intel_gvt.h

72

static inline int intel_gvt_iterate_mmio_table(struct intel_gvt_mmio_table_iter *iter)

drivers/gpu/drm/i915/intel_gvt_mmio_table.c

1120

static int iterate_bxt_mmio(struct intel_gvt_mmio_table_iter *iter)

drivers/gpu/drm/i915/intel_gvt_mmio_table.c

1122

struct drm_i915_private *dev_priv = iter->i915;

drivers/gpu/drm/i915/intel_gvt_mmio_table.c

1283

int intel_gvt_iterate_mmio_table(struct intel_gvt_mmio_table_iter *iter)

drivers/gpu/drm/i915/intel_gvt_mmio_table.c

1285

struct drm_i915_private *i915 = iter->i915;

drivers/gpu/drm/i915/intel_gvt_mmio_table.c

1288

ret = iterate_generic_mmio(iter);

drivers/gpu/drm/i915/intel_gvt_mmio_table.c

1293

ret = iterate_bdw_only_mmio(iter);

drivers/gpu/drm/i915/intel_gvt_mmio_table.c

1296

ret = iterate_bdw_plus_mmio(iter);

drivers/gpu/drm/i915/intel_gvt_mmio_table.c

1299

ret = iterate_pre_skl_mmio(iter);

drivers/gpu/drm/i915/intel_gvt_mmio_table.c

1306

ret = iterate_bdw_plus_mmio(iter);

drivers/gpu/drm/i915/intel_gvt_mmio_table.c

1309

ret = iterate_skl_plus_mmio(iter);

drivers/gpu/drm/i915/intel_gvt_mmio_table.c

1313

ret = iterate_bdw_plus_mmio(iter);

drivers/gpu/drm/i915/intel_gvt_mmio_table.c

1316

ret = iterate_skl_plus_mmio(iter);

drivers/gpu/drm/i915/intel_gvt_mmio_table.c

1319

ret = iterate_bxt_mmio(iter);

drivers/gpu/drm/i915/intel_gvt_mmio_table.c

51

ret = iter->handle_mmio_cb(iter, i915_mmio_reg_offset(reg), s); \

drivers/gpu/drm/i915/intel_gvt_mmio_table.c

63

if (HAS_ENGINE(to_gt(iter->i915), VCS1)) \

drivers/gpu/drm/i915/intel_gvt_mmio_table.c

70

static int iterate_generic_mmio(struct intel_gvt_mmio_table_iter *iter)

drivers/gpu/drm/i915/intel_gvt_mmio_table.c

72

struct drm_i915_private *dev_priv = iter->i915;

drivers/gpu/drm/i915/intel_gvt_mmio_table.c

724

static int iterate_bdw_only_mmio(struct intel_gvt_mmio_table_iter *iter)

drivers/gpu/drm/i915/intel_gvt_mmio_table.c

749

static int iterate_bdw_plus_mmio(struct intel_gvt_mmio_table_iter *iter)

drivers/gpu/drm/i915/intel_gvt_mmio_table.c

751

struct drm_i915_private *dev_priv = iter->i915;

drivers/gpu/drm/i915/intel_gvt_mmio_table.c

902

static int iterate_pre_skl_mmio(struct intel_gvt_mmio_table_iter *iter)

drivers/gpu/drm/i915/intel_gvt_mmio_table.c

921

static int iterate_skl_plus_mmio(struct intel_gvt_mmio_table_iter *iter)

drivers/gpu/drm/i915/intel_gvt_mmio_table.c

923

struct drm_i915_private *dev_priv = iter->i915;

drivers/gpu/drm/imagination/pvr_sync.c

208

struct dma_fence_unwrap iter;

drivers/gpu/drm/imagination/pvr_sync.c

213

dma_fence_unwrap_for_each(uf, &iter, f) {

drivers/gpu/drm/imagination/pvr_sync.c

222

dma_fence_unwrap_for_each(uf, &iter, f) {

drivers/gpu/drm/mgag200/mgag200_mode.c

509

struct drm_atomic_helper_damage_iter iter;

drivers/gpu/drm/mgag200/mgag200_mode.c

513

drm_atomic_helper_damage_iter_init(&iter, old_plane_state, plane_state);

drivers/gpu/drm/mgag200/mgag200_mode.c

514

drm_atomic_for_each_plane_damage(&iter, &damage) {

drivers/gpu/drm/msm/disp/msm_disp_snapshot.c

13

struct drm_print_iterator iter;

drivers/gpu/drm/msm/disp/msm_disp_snapshot.c

19

iter.data = buffer;

drivers/gpu/drm/msm/disp/msm_disp_snapshot.c

20

iter.offset = 0;

drivers/gpu/drm/msm/disp/msm_disp_snapshot.c

21

iter.start = offset;

drivers/gpu/drm/msm/disp/msm_disp_snapshot.c

22

iter.remain = count;

drivers/gpu/drm/msm/disp/msm_disp_snapshot.c

24

p = drm_coredump_printer(&iter);

drivers/gpu/drm/msm/disp/msm_disp_snapshot.c

28

return count - iter.remain;

drivers/gpu/drm/msm/msm_gpu.c

183

struct drm_print_iterator iter;

drivers/gpu/drm/msm/msm_gpu.c

191

iter.data = buffer;

drivers/gpu/drm/msm/msm_gpu.c

192

iter.offset = 0;

drivers/gpu/drm/msm/msm_gpu.c

193

iter.start = offset;

drivers/gpu/drm/msm/msm_gpu.c

194

iter.remain = count;

drivers/gpu/drm/msm/msm_gpu.c

196

p = drm_coredump_printer(&iter);

drivers/gpu/drm/msm/msm_gpu.c

211

return count - iter.remain;

drivers/gpu/drm/mxsfb/mxsfb_drv.c

117

struct drm_connector_list_iter iter;

drivers/gpu/drm/mxsfb/mxsfb_drv.c

147

drm_connector_list_iter_begin(drm, &iter);

drivers/gpu/drm/mxsfb/mxsfb_drv.c

148

mxsfb->connector = drm_connector_list_iter_next(&iter);

drivers/gpu/drm/mxsfb/mxsfb_drv.c

149

drm_connector_list_iter_end(&iter);

drivers/gpu/drm/nouveau/nouveau_connector.h

176

#define nouveau_for_each_non_mst_connector_iter(connector, iter) \

drivers/gpu/drm/nouveau/nouveau_connector.h

177

drm_for_each_connector_iter(connector, iter) \

drivers/gpu/drm/nouveau/nvkm/engine/gr/gf100.c

1713

const struct gf100_gr_pack *iter;

drivers/gpu/drm/nouveau/nvkm/engine/gr/gf100.c

1725

pack_for_each_init(init, iter, pack) {

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/gsp.c

797

acpi_handle iter = NULL, handle_mux = NULL;

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/gsp.c

806

status = acpi_get_next_object(ACPI_TYPE_DEVICE, handle, iter, &iter);

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/gsp.c

807

if (ACPI_FAILURE(status) || !iter)

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/gsp.c

810

ret = acpi_get_local_u64_address(iter, &value);

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/gsp.c

814

handle_mux = iter;

drivers/gpu/drm/panfrost/panfrost_dump.c

100

panfrost_core_dump_header(iter, PANFROSTDUMP_BUF_REG, dumpreg);

drivers/gpu/drm/panfrost/panfrost_dump.c

106

struct panfrost_dump_iterator iter;

drivers/gpu/drm/panfrost/panfrost_dump.c

153

file_size += sizeof(*iter.hdr) * n_obj;

drivers/gpu/drm/panfrost/panfrost_dump.c

163

iter.start = __vmalloc(file_size, GFP_KERNEL | __GFP_NOWARN |

drivers/gpu/drm/panfrost/panfrost_dump.c

165

if (!iter.start) {

drivers/gpu/drm/panfrost/panfrost_dump.c

171

iter.hdr = iter.start;

drivers/gpu/drm/panfrost/panfrost_dump.c

172

iter.data = &iter.hdr[n_obj];

drivers/gpu/drm/panfrost/panfrost_dump.c

174

memset(iter.hdr, 0, iter.data - iter.start);

drivers/gpu/drm/panfrost/panfrost_dump.c

180

iter.hdr->reghdr.jc = job->jc;

drivers/gpu/drm/panfrost/panfrost_dump.c

181

iter.hdr->reghdr.major = PANFROSTDUMP_MAJOR;

drivers/gpu/drm/panfrost/panfrost_dump.c

182

iter.hdr->reghdr.minor = PANFROSTDUMP_MINOR;

drivers/gpu/drm/panfrost/panfrost_dump.c

183

iter.hdr->reghdr.gpu_id = pfdev->features.id;

drivers/gpu/drm/panfrost/panfrost_dump.c

184

iter.hdr->reghdr.nbos = job->bo_count;

drivers/gpu/drm/panfrost/panfrost_dump.c

186

panfrost_core_dump_registers(&iter, pfdev, as_nr, slot);

drivers/gpu/drm/panfrost/panfrost_dump.c

190

bomap_start = bomap = iter.data;

drivers/gpu/drm/panfrost/panfrost_dump.c

192

panfrost_core_dump_header(&iter, PANFROSTDUMP_BUF_BOMAP,

drivers/gpu/drm/panfrost/panfrost_dump.c

208

iter.hdr->bomap.valid = 0;

drivers/gpu/drm/panfrost/panfrost_dump.c

215

iter.hdr->bomap.valid = 0;

drivers/gpu/drm/panfrost/panfrost_dump.c

221

iter.hdr->bomap.data[0] = bomap - bomap_start;

drivers/gpu/drm/panfrost/panfrost_dump.c

226

iter.hdr->bomap.iova = mapping->mmnode.start << PAGE_SHIFT;

drivers/gpu/drm/panfrost/panfrost_dump.c

229

memcpy(iter.data, vaddr, bo->base.base.size);

drivers/gpu/drm/panfrost/panfrost_dump.c

233

iter.hdr->bomap.valid = 1;

drivers/gpu/drm/panfrost/panfrost_dump.c

235

dump_header: panfrost_core_dump_header(&iter, PANFROSTDUMP_BUF_BO, iter.data +

drivers/gpu/drm/panfrost/panfrost_dump.c

238

panfrost_core_dump_header(&iter, PANFROSTDUMP_BUF_TRAILER, iter.data);

drivers/gpu/drm/panfrost/panfrost_dump.c

240

dev_coredumpv(pfdev->base.dev, iter.start, iter.data - iter.start, GFP_KERNEL);

drivers/gpu/drm/panfrost/panfrost_dump.c

61

static void panfrost_core_dump_header(struct panfrost_dump_iterator *iter,

drivers/gpu/drm/panfrost/panfrost_dump.c

64

struct panfrost_dump_object_header *hdr = iter->hdr;

drivers/gpu/drm/panfrost/panfrost_dump.c

68

hdr->file_offset = iter->data - iter->start;

drivers/gpu/drm/panfrost/panfrost_dump.c

69

hdr->file_size = data_end - iter->data;

drivers/gpu/drm/panfrost/panfrost_dump.c

71

iter->hdr++;

drivers/gpu/drm/panfrost/panfrost_dump.c

72

iter->data += hdr->file_size;

drivers/gpu/drm/panfrost/panfrost_dump.c

76

panfrost_core_dump_registers(struct panfrost_dump_iterator *iter,

drivers/gpu/drm/panfrost/panfrost_dump.c

80

struct panfrost_dump_registers *dumpreg = iter->data;

drivers/gpu/drm/panfrost/panfrost_gem.c

113

struct panfrost_gem_mapping *iter, *mapping = NULL;

drivers/gpu/drm/panfrost/panfrost_gem.c

116

list_for_each_entry(iter, &bo->mappings.list, node) {

drivers/gpu/drm/panfrost/panfrost_gem.c

117

if (iter->mmu == priv->mmu) {

drivers/gpu/drm/panfrost/panfrost_gem.c

118

kref_get(&iter->refcount);

drivers/gpu/drm/panfrost/panfrost_gem.c

119

mapping = iter;

drivers/gpu/drm/panfrost/panfrost_gem.c

227

struct panfrost_gem_mapping *mapping = NULL, *iter;

drivers/gpu/drm/panfrost/panfrost_gem.c

230

list_for_each_entry(iter, &bo->mappings.list, node) {

drivers/gpu/drm/panfrost/panfrost_gem.c

231

if (iter->mmu == priv->mmu) {

drivers/gpu/drm/panfrost/panfrost_gem.c

232

mapping = iter;

drivers/gpu/drm/panfrost/panfrost_gem.c

233

list_del(&iter->node);

drivers/gpu/drm/panthor/panthor_fw.c

414

struct panthor_fw_binary_iter *iter,

drivers/gpu/drm/panthor/panthor_fw.c

417

size_t new_offset = iter->offset + size;

drivers/gpu/drm/panthor/panthor_fw.c

419

if (new_offset > iter->size || new_offset < iter->offset) {

drivers/gpu/drm/panthor/panthor_fw.c

424

memcpy(out, iter->data + iter->offset, size);

drivers/gpu/drm/panthor/panthor_fw.c

425

iter->offset = new_offset;

drivers/gpu/drm/panthor/panthor_fw.c

430

struct panthor_fw_binary_iter *iter,

drivers/gpu/drm/panthor/panthor_fw.c

434

size_t new_offset = iter->offset + size;

drivers/gpu/drm/panthor/panthor_fw.c

436

if (new_offset > iter->size || new_offset < iter->offset) {

drivers/gpu/drm/panthor/panthor_fw.c

442

sub_iter->data = iter->data + iter->offset;

drivers/gpu/drm/panthor/panthor_fw.c

444

iter->offset = new_offset;

drivers/gpu/drm/panthor/panthor_fw.c

541

struct panthor_fw_binary_iter *iter,

drivers/gpu/drm/panthor/panthor_fw.c

551

ret = panthor_fw_binary_iter_read(ptdev, iter, &hdr, sizeof(hdr));

drivers/gpu/drm/panthor/panthor_fw.c

598

name_len = iter->size - iter->offset;

drivers/gpu/drm/panthor/panthor_fw.c

624

memcpy(name, iter->data + iter->offset, name_len);

drivers/gpu/drm/panthor/panthor_fw.c

687

struct panthor_fw_binary_iter *iter,

drivers/gpu/drm/panthor/panthor_fw.c

695

ret = panthor_fw_binary_iter_read(ptdev, iter, &hdr, sizeof(hdr));

drivers/gpu/drm/panthor/panthor_fw.c

746

struct panthor_fw_binary_iter *iter)

drivers/gpu/drm/panthor/panthor_fw.c

752

ret = panthor_fw_binary_iter_read(ptdev, iter, &ehdr, sizeof(ehdr));

drivers/gpu/drm/panthor/panthor_fw.c

756

if ((iter->offset % sizeof(u32)) ||

drivers/gpu/drm/panthor/panthor_fw.c

759

(u32)(iter->offset - sizeof(u32)), CSF_FW_BINARY_ENTRY_SIZE(ehdr));

drivers/gpu/drm/panthor/panthor_fw.c

763

if (panthor_fw_binary_sub_iter_init(ptdev, iter, &eiter,

drivers/gpu/drm/panthor/panthor_fw.c

795

struct panthor_fw_binary_iter iter = {};

drivers/gpu/drm/panthor/panthor_fw.c

812

iter.data = fw->data;

drivers/gpu/drm/panthor/panthor_fw.c

813

iter.size = fw->size;

drivers/gpu/drm/panthor/panthor_fw.c

814

ret = panthor_fw_binary_iter_read(ptdev, &iter, &hdr, sizeof(hdr));

drivers/gpu/drm/panthor/panthor_fw.c

831

if (hdr.size > iter.size) {

drivers/gpu/drm/panthor/panthor_fw.c

837

iter.size = hdr.size;

drivers/gpu/drm/panthor/panthor_fw.c

839

while (iter.offset < hdr.size) {

drivers/gpu/drm/panthor/panthor_fw.c

840

ret = panthor_fw_load_entry(ptdev, fw, &iter);

drivers/gpu/drm/sitronix/st7571.c

349

struct drm_atomic_helper_damage_iter iter;

drivers/gpu/drm/sitronix/st7571.c

365

drm_atomic_helper_damage_iter_init(&iter, old_plane_state, plane_state);

drivers/gpu/drm/sitronix/st7571.c

366

drm_atomic_for_each_plane_damage(&iter, &damage) {

drivers/gpu/drm/sitronix/st7920.c

399

struct drm_atomic_helper_damage_iter iter;

drivers/gpu/drm/sitronix/st7920.c

410

drm_atomic_helper_damage_iter_init(&iter, old_plane_state, plane_state);

drivers/gpu/drm/sitronix/st7920.c

411

drm_atomic_for_each_plane_damage(&iter, &damage) {

drivers/gpu/drm/solomon/ssd130x.c

1207

struct drm_atomic_helper_damage_iter iter;

drivers/gpu/drm/solomon/ssd130x.c

1219

drm_atomic_helper_damage_iter_init(&iter, old_plane_state, plane_state);

drivers/gpu/drm/solomon/ssd130x.c

1220

drm_atomic_for_each_plane_damage(&iter, &damage) {

drivers/gpu/drm/solomon/ssd130x.c

1248

struct drm_atomic_helper_damage_iter iter;

drivers/gpu/drm/solomon/ssd130x.c

1260

drm_atomic_helper_damage_iter_init(&iter, old_plane_state, plane_state);

drivers/gpu/drm/solomon/ssd130x.c

1261

drm_atomic_for_each_plane_damage(&iter, &damage) {

drivers/gpu/drm/solomon/ssd130x.c

1288

struct drm_atomic_helper_damage_iter iter;

drivers/gpu/drm/solomon/ssd130x.c

1300

drm_atomic_helper_damage_iter_init(&iter, old_plane_state, plane_state);

drivers/gpu/drm/solomon/ssd130x.c

1301

drm_atomic_for_each_plane_damage(&iter, &damage) {

drivers/gpu/drm/stm/ltdc.c

901

struct drm_connector_list_iter iter;

drivers/gpu/drm/stm/ltdc.c

929

drm_connector_list_iter_begin(ddev, &iter);

drivers/gpu/drm/stm/ltdc.c

930

drm_for_each_connector_iter(connector, &iter)

drivers/gpu/drm/stm/ltdc.c

933

drm_connector_list_iter_end(&iter);

drivers/gpu/drm/sun4i/sun4i_tcon.c

46

struct drm_connector_list_iter iter;

drivers/gpu/drm/sun4i/sun4i_tcon.c

48

drm_connector_list_iter_begin(encoder->dev, &iter);

drivers/gpu/drm/sun4i/sun4i_tcon.c

49

drm_for_each_connector_iter(connector, &iter)

drivers/gpu/drm/sun4i/sun4i_tcon.c

51

drm_connector_list_iter_end(&iter);

drivers/gpu/drm/sun4i/sun4i_tcon.c

54

drm_connector_list_iter_end(&iter);

drivers/gpu/drm/sysfb/drm_sysfb_modeset.c

343

struct drm_atomic_helper_damage_iter iter;

drivers/gpu/drm/sysfb/drm_sysfb_modeset.c

354

drm_atomic_helper_damage_iter_init(&iter, old_plane_state, plane_state);

drivers/gpu/drm/sysfb/drm_sysfb_modeset.c

355

drm_atomic_for_each_plane_damage(&iter, &damage) {

drivers/gpu/drm/tests/drm_damage_helper_test.c

122

struct drm_atomic_helper_damage_iter iter;

drivers/gpu/drm/tests/drm_damage_helper_test.c

129

drm_atomic_helper_damage_iter_init(&iter, &mock->old_state, &mock->state);

drivers/gpu/drm/tests/drm_damage_helper_test.c

130

drm_atomic_for_each_plane_damage(&iter, &clip)

drivers/gpu/drm/tests/drm_damage_helper_test.c

140

struct drm_atomic_helper_damage_iter iter;

drivers/gpu/drm/tests/drm_damage_helper_test.c

149

drm_atomic_helper_damage_iter_init(&iter, &mock->old_state, &mock->state);

drivers/gpu/drm/tests/drm_damage_helper_test.c

150

drm_atomic_for_each_plane_damage(&iter, &clip)

drivers/gpu/drm/tests/drm_damage_helper_test.c

161

struct drm_atomic_helper_damage_iter iter;

drivers/gpu/drm/tests/drm_damage_helper_test.c

169

drm_atomic_helper_damage_iter_init(&iter, &mock->old_state, &mock->state);

drivers/gpu/drm/tests/drm_damage_helper_test.c

170

drm_atomic_for_each_plane_damage(&iter, &clip)

drivers/gpu/drm/tests/drm_damage_helper_test.c

180

struct drm_atomic_helper_damage_iter iter;

drivers/gpu/drm/tests/drm_damage_helper_test.c

189

drm_atomic_helper_damage_iter_init(&iter, &mock->old_state, &mock->state);

drivers/gpu/drm/tests/drm_damage_helper_test.c

190

drm_atomic_for_each_plane_damage(&iter, &clip)

drivers/gpu/drm/tests/drm_damage_helper_test.c

200

struct drm_atomic_helper_damage_iter iter;

drivers/gpu/drm/tests/drm_damage_helper_test.c

208

drm_atomic_helper_damage_iter_init(&iter, &mock->old_state, &mock->state);

drivers/gpu/drm/tests/drm_damage_helper_test.c

209

drm_atomic_for_each_plane_damage(&iter, &clip)

drivers/gpu/drm/tests/drm_damage_helper_test.c

218

struct drm_atomic_helper_damage_iter iter;

drivers/gpu/drm/tests/drm_damage_helper_test.c

226

drm_atomic_helper_damage_iter_init(&iter, &mock->old_state, &mock->state);

drivers/gpu/drm/tests/drm_damage_helper_test.c

227

drm_atomic_for_each_plane_damage(&iter, &clip)

drivers/gpu/drm/tests/drm_damage_helper_test.c

236

struct drm_atomic_helper_damage_iter iter;

drivers/gpu/drm/tests/drm_damage_helper_test.c

244

drm_atomic_helper_damage_iter_init(&iter, &mock->old_state, &mock->state);

drivers/gpu/drm/tests/drm_damage_helper_test.c

245

drm_atomic_for_each_plane_damage(&iter, &clip)

drivers/gpu/drm/tests/drm_damage_helper_test.c

254

struct drm_atomic_helper_damage_iter iter;

drivers/gpu/drm/tests/drm_damage_helper_test.c

266

drm_atomic_helper_damage_iter_init(&iter, &mock->old_state, &mock->state);

drivers/gpu/drm/tests/drm_damage_helper_test.c

267

drm_atomic_for_each_plane_damage(&iter, &clip)

drivers/gpu/drm/tests/drm_damage_helper_test.c

277

struct drm_atomic_helper_damage_iter iter;

drivers/gpu/drm/tests/drm_damage_helper_test.c

288

drm_atomic_helper_damage_iter_init(&iter, &mock->old_state, &mock->state);

drivers/gpu/drm/tests/drm_damage_helper_test.c

289

drm_atomic_for_each_plane_damage(&iter, &clip)

drivers/gpu/drm/tests/drm_damage_helper_test.c

299

struct drm_atomic_helper_damage_iter iter;

drivers/gpu/drm/tests/drm_damage_helper_test.c

311

drm_atomic_helper_damage_iter_init(&iter, &mock->old_state, &mock->state);

drivers/gpu/drm/tests/drm_damage_helper_test.c

312

drm_atomic_for_each_plane_damage(&iter, &clip)

drivers/gpu/drm/tests/drm_damage_helper_test.c

322

struct drm_atomic_helper_damage_iter iter;

drivers/gpu/drm/tests/drm_damage_helper_test.c

334

drm_atomic_helper_damage_iter_init(&iter, &mock->old_state, &mock->state);

drivers/gpu/drm/tests/drm_damage_helper_test.c

335

drm_atomic_for_each_plane_damage(&iter, &clip)

drivers/gpu/drm/tests/drm_damage_helper_test.c

344

struct drm_atomic_helper_damage_iter iter;

drivers/gpu/drm/tests/drm_damage_helper_test.c

358

drm_atomic_helper_damage_iter_init(&iter, &mock->old_state, &mock->state);

drivers/gpu/drm/tests/drm_damage_helper_test.c

359

drm_atomic_for_each_plane_damage(&iter, &clip)

drivers/gpu/drm/tests/drm_damage_helper_test.c

369

struct drm_atomic_helper_damage_iter iter;

drivers/gpu/drm/tests/drm_damage_helper_test.c

384

drm_atomic_helper_damage_iter_init(&iter, &mock->old_state, &mock->state);

drivers/gpu/drm/tests/drm_damage_helper_test.c

385

drm_atomic_for_each_plane_damage(&iter, &clip)

drivers/gpu/drm/tests/drm_damage_helper_test.c

396

struct drm_atomic_helper_damage_iter iter;

drivers/gpu/drm/tests/drm_damage_helper_test.c

411

drm_atomic_helper_damage_iter_init(&iter, &mock->old_state, &mock->state);

drivers/gpu/drm/tests/drm_damage_helper_test.c

412

drm_atomic_for_each_plane_damage(&iter, &clip)

drivers/gpu/drm/tests/drm_damage_helper_test.c

421

struct drm_atomic_helper_damage_iter iter;

drivers/gpu/drm/tests/drm_damage_helper_test.c

434

drm_atomic_helper_damage_iter_init(&iter, &mock->old_state, &mock->state);

drivers/gpu/drm/tests/drm_damage_helper_test.c

435

drm_atomic_for_each_plane_damage(&iter, &clip)

drivers/gpu/drm/tests/drm_damage_helper_test.c

446

struct drm_atomic_helper_damage_iter iter;

drivers/gpu/drm/tests/drm_damage_helper_test.c

461

drm_atomic_helper_damage_iter_init(&iter, &mock->old_state, &mock->state);

drivers/gpu/drm/tests/drm_damage_helper_test.c

462

drm_atomic_for_each_plane_damage(&iter, &clip)

drivers/gpu/drm/tests/drm_damage_helper_test.c

473

struct drm_atomic_helper_damage_iter iter;

drivers/gpu/drm/tests/drm_damage_helper_test.c

486

drm_atomic_helper_damage_iter_init(&iter, &mock->old_state, &mock->state);

drivers/gpu/drm/tests/drm_damage_helper_test.c

487

drm_atomic_for_each_plane_damage(&iter, &clip) {

drivers/gpu/drm/tests/drm_damage_helper_test.c

501

struct drm_atomic_helper_damage_iter iter;

drivers/gpu/drm/tests/drm_damage_helper_test.c

516

drm_atomic_helper_damage_iter_init(&iter, &mock->old_state, &mock->state);

drivers/gpu/drm/tests/drm_damage_helper_test.c

517

drm_atomic_for_each_plane_damage(&iter, &clip) {

drivers/gpu/drm/tests/drm_damage_helper_test.c

531

struct drm_atomic_helper_damage_iter iter;

drivers/gpu/drm/tests/drm_damage_helper_test.c

544

drm_atomic_helper_damage_iter_init(&iter, &mock->old_state, &mock->state);

drivers/gpu/drm/tests/drm_damage_helper_test.c

545

drm_atomic_for_each_plane_damage(&iter, &clip)

drivers/gpu/drm/tests/drm_damage_helper_test.c

555

struct drm_atomic_helper_damage_iter iter;

drivers/gpu/drm/tests/drm_damage_helper_test.c

570

drm_atomic_helper_damage_iter_init(&iter, &mock->old_state, &mock->state);

drivers/gpu/drm/tests/drm_damage_helper_test.c

571

drm_atomic_for_each_plane_damage(&iter, &clip)

drivers/gpu/drm/tests/drm_damage_helper_test.c

582

struct drm_atomic_helper_damage_iter iter;

drivers/gpu/drm/tests/drm_damage_helper_test.c

599

drm_atomic_helper_damage_iter_init(&iter, &mock->old_state, &mock->state);

drivers/gpu/drm/tests/drm_damage_helper_test.c

600

drm_atomic_for_each_plane_damage(&iter, &clip)

drivers/gpu/drm/tiny/appletbdrm.c

323

struct drm_atomic_helper_damage_iter iter;

drivers/gpu/drm/tiny/appletbdrm.c

327

drm_atomic_helper_damage_iter_init(&iter, plane->state, new_plane_state);

drivers/gpu/drm/tiny/appletbdrm.c

328

drm_atomic_for_each_plane_damage(&iter, &damage) {

drivers/gpu/drm/tiny/appletbdrm.c

386

struct drm_atomic_helper_damage_iter iter;

drivers/gpu/drm/tiny/appletbdrm.c

415

drm_atomic_helper_damage_iter_init(&iter, old_state, state);

drivers/gpu/drm/tiny/appletbdrm.c

416

drm_atomic_for_each_plane_damage(&iter, &damage) {

drivers/gpu/drm/tiny/bochs.c

453

struct drm_atomic_helper_damage_iter iter;

drivers/gpu/drm/tiny/bochs.c

459

drm_atomic_helper_damage_iter_init(&iter, old_plane_state, plane_state);

drivers/gpu/drm/tiny/bochs.c

460

drm_atomic_for_each_plane_damage(&iter, &damage) {

drivers/gpu/drm/tiny/cirrus-qemu.c

338

struct drm_atomic_helper_damage_iter iter;

drivers/gpu/drm/tiny/cirrus-qemu.c

353

drm_atomic_helper_damage_iter_init(&iter, old_plane_state, plane_state);

drivers/gpu/drm/tiny/cirrus-qemu.c

354

drm_atomic_for_each_plane_damage(&iter, &damage) {

drivers/gpu/drm/ttm/ttm_resource.c

736

static void ttm_kmap_iter_iomap_map_local(struct ttm_kmap_iter *iter,

drivers/gpu/drm/ttm/ttm_resource.c

741

container_of(iter, typeof(*iter_io), base);

drivers/gpu/drm/ttm/ttm_resource.c

767

static void ttm_kmap_iter_iomap_unmap_local(struct ttm_kmap_iter *iter,

drivers/gpu/drm/ttm/ttm_resource.c

818

static void ttm_kmap_iter_linear_io_map_local(struct ttm_kmap_iter *iter,

drivers/gpu/drm/ttm/ttm_resource.c

823

container_of(iter, typeof(*iter_io), base);

drivers/gpu/drm/ttm/ttm_tt.c

487

static void ttm_kmap_iter_tt_map_local(struct ttm_kmap_iter *iter,

drivers/gpu/drm/ttm/ttm_tt.c

492

container_of(iter, typeof(*iter_tt), base);

drivers/gpu/drm/ttm/ttm_tt.c

498

static void ttm_kmap_iter_tt_unmap_local(struct ttm_kmap_iter *iter,

drivers/gpu/drm/udl/udl_modeset.c

290

struct drm_atomic_helper_damage_iter iter;

drivers/gpu/drm/udl/udl_modeset.c

304

drm_atomic_helper_damage_iter_init(&iter, old_plane_state, plane_state);

drivers/gpu/drm/udl/udl_modeset.c

305

drm_atomic_for_each_plane_damage(&iter, &damage) {

drivers/gpu/drm/vmwgfx/vmwgfx_drv.h

327

struct sg_dma_page_iter iter;

drivers/gpu/drm/vmwgfx/vmwgfx_gmr.c

38

struct vmw_piter *iter,

drivers/gpu/drm/vmwgfx/vmwgfx_gmr.c

85

*cmd = vmw_piter_dma_addr(iter) >> PAGE_SHIFT;

drivers/gpu/drm/vmwgfx/vmwgfx_gmr.c

87

*((uint64_t *)cmd) = vmw_piter_dma_addr(iter) >>

drivers/gpu/drm/vmwgfx/vmwgfx_gmr.c

91

vmw_piter_next(iter);

drivers/gpu/drm/vmwgfx/vmwgfx_kms.c

1737

struct drm_atomic_helper_damage_iter iter;

drivers/gpu/drm/vmwgfx/vmwgfx_kms.c

1753

drm_atomic_helper_damage_iter_init(&iter, old_state, state);

drivers/gpu/drm/vmwgfx/vmwgfx_kms.c

1754

drm_atomic_for_each_plane_damage(&iter, &clip)

drivers/gpu/drm/vmwgfx/vmwgfx_kms.c

1821

drm_atomic_helper_damage_iter_init(&iter, old_state, state);

drivers/gpu/drm/vmwgfx/vmwgfx_kms.c

1822

drm_atomic_for_each_plane_damage(&iter, &clip) {

drivers/gpu/drm/vmwgfx/vmwgfx_mob.c

126

struct vmw_piter iter;

drivers/gpu/drm/vmwgfx/vmwgfx_mob.c

132

vmw_piter_start(&iter, vsgt, offset >> PAGE_SHIFT);

drivers/gpu/drm/vmwgfx/vmwgfx_mob.c

133

WARN_ON(!vmw_piter_next(&iter));

drivers/gpu/drm/vmwgfx/vmwgfx_mob.c

143

mob->pt_root_page = vmw_piter_dma_addr(&iter);

drivers/gpu/drm/vmwgfx/vmwgfx_mob.c

149

vmw_mob_pt_setup(mob, iter, otable->size >> PAGE_SHIFT);

drivers/gpu/drm/vmwgfx/vmwgfx_ttm_buffer.c

119

__sg_page_iter_start(&viter->iter.base, vsgt->sgt->sgl,

drivers/gpu/drm/vmwgfx/vmwgfx_ttm_buffer.c

77

return __sg_page_iter_dma_next(&viter->iter) && ret;

drivers/gpu/drm/vmwgfx/vmwgfx_ttm_buffer.c

88

return sg_page_iter_dma_address(&viter->iter);

drivers/gpu/drm/xe/xe_devcoredump.c

100

p = drm_coredump_printer(&iter);

drivers/gpu/drm/xe/xe_devcoredump.c

136

return count - iter.remain;

drivers/gpu/drm/xe/xe_devcoredump.c

89

struct drm_print_iterator iter;

drivers/gpu/drm/xe/xe_devcoredump.c

96

iter.data = buffer;

drivers/gpu/drm/xe/xe_devcoredump.c

97

iter.start = start;

drivers/gpu/drm/xe/xe_devcoredump.c

98

iter.remain = count;

drivers/gpu/drm/xe/xe_query.c

377

int iter = 0;

drivers/gpu/drm/xe/xe_query.c

395

gt_list->gt_list[iter].type = DRM_XE_QUERY_GT_TYPE_MEDIA;

drivers/gpu/drm/xe/xe_query.c

397

gt_list->gt_list[iter].type = DRM_XE_QUERY_GT_TYPE_MAIN;

drivers/gpu/drm/xe/xe_query.c

398

gt_list->gt_list[iter].tile_id = gt_to_tile(gt)->id;

drivers/gpu/drm/xe/xe_query.c

399

gt_list->gt_list[iter].gt_id = gt->info.id;

drivers/gpu/drm/xe/xe_query.c

400

gt_list->gt_list[iter].reference_clock = gt->info.reference_clock;

drivers/gpu/drm/xe/xe_query.c

416

gt_list->gt_list[iter].near_mem_regions = 0x1;

drivers/gpu/drm/xe/xe_query.c

418

gt_list->gt_list[iter].near_mem_regions =

drivers/gpu/drm/xe/xe_query.c

420

gt_list->gt_list[iter].far_mem_regions = xe->info.mem_region_mask ^

drivers/gpu/drm/xe/xe_query.c

421

gt_list->gt_list[iter].near_mem_regions;

drivers/gpu/drm/xe/xe_query.c

423

gt_list->gt_list[iter].ip_ver_major =

drivers/gpu/drm/xe/xe_query.c

425

gt_list->gt_list[iter].ip_ver_minor =

drivers/gpu/drm/xe/xe_query.c

427

gt_list->gt_list[iter].ip_ver_rev =

drivers/gpu/drm/xe/xe_query.c

430

iter++;

drivers/gpu/drm/xe/xe_sched_job.c

208

struct dma_fence *iter;

drivers/gpu/drm/xe/xe_sched_job.c

210

dma_fence_chain_for_each(iter, job->fence)

drivers/gpu/drm/xe/xe_sched_job.c

211

xe_fence_set_error(dma_fence_chain_contained(iter),

drivers/gpu/drm/xlnx/zynqmp_dp.c

1097

unsigned int i, iter;

drivers/gpu/drm/xlnx/zynqmp_dp.c

1100

iter = zynqmp_dp_aux_timeout_ms * 1000 / 400;

drivers/gpu/drm/xlnx/zynqmp_dp.c

1101

iter = iter ? iter : 1;

drivers/gpu/drm/xlnx/zynqmp_dp.c

1103

for (i = 0; i < iter; i++) {

drivers/hid/hid-wiimote-core.c

1252

const __u8 *iter, *mods;

drivers/hid/hid-wiimote-core.c

1262

for (iter = mods; *iter != WIIMOD_NULL; ++iter) {

drivers/hid/hid-wiimote-core.c

1263

ops = wiimod_table[*iter];

drivers/hid/hid-wiimote-core.c

1273

const __u8 *iter, *mods;

drivers/hid/hid-wiimote-core.c

1283

for (iter = mods; *iter != WIIMOD_NULL; ++iter) {

drivers/hid/hid-wiimote-core.c

1284

ops = wiimod_table[*iter];

drivers/hid/hid-wiimote-core.c

1313

const __u8 *iter, *mods;

drivers/hid/hid-wiimote-core.c

1375

for (iter = mods; *iter != WIIMOD_NULL; ++iter) {

drivers/hid/hid-wiimote-core.c

1376

ops = wiimod_table[*iter];

drivers/hid/hid-wiimote-core.c

1395

const __u8 *iter, *mods;

drivers/hid/hid-wiimote-core.c

1405

for (iter = mods; *iter != WIIMOD_NULL; ++iter) {

drivers/hid/hid-wiimote-core.c

1406

ops = wiimod_table[*iter];

drivers/hid/hid-wiimote-core.c

628

const __u8 *mods, *iter;

drivers/hid/hid-wiimote-core.c

634

for (iter = mods; *iter != WIIMOD_NULL; ++iter) {

drivers/hid/hid-wiimote-core.c

635

if (wiimod_table[*iter]->flags & WIIMOD_FLAG_INPUT) {

drivers/hid/hid-wiimote-core.c

655

for (iter = mods; *iter != WIIMOD_NULL; ++iter) {

drivers/hid/hid-wiimote-core.c

656

ops = wiimod_table[*iter];

drivers/hid/hid-wiimote-core.c

677

for ( ; iter-- != mods; ) {

drivers/hid/hid-wiimote-core.c

678

ops = wiimod_table[*iter];

drivers/hid/hid-wiimote-core.c

691

const __u8 *mods, *iter;

drivers/hid/hid-wiimote-core.c

702

for (iter = mods; *iter != WIIMOD_NULL; ++iter)

drivers/hid/hid-wiimote-core.c

710

for ( ; iter-- != mods; ) {

drivers/hid/hid-wiimote-core.c

711

ops = wiimod_table[*iter];

drivers/hv/channel_mgmt.c

983

struct vmbus_channel *channel = NULL, *iter;

drivers/hv/channel_mgmt.c

992

list_for_each_entry(iter, &vmbus_connection.chn_list, listentry) {

drivers/hv/channel_mgmt.c

993

inst1 = &iter->offermsg.offer.if_instance;

drivers/hv/channel_mgmt.c

997

channel = iter;

drivers/hv/hv_common.c

189

struct kmsg_dump_iter iter;

drivers/hv/hv_common.c

202

kmsg_dump_rewind(&iter);

drivers/hv/hv_common.c

204

(void)kmsg_dump_get_buffer(&iter, false, hv_panic_page, HV_HYP_PAGE_SIZE,

drivers/hv/vmbus_drv.c

2466

struct resource *iter, *shadow;

drivers/hv/vmbus_drv.c

2494

for (iter = hyperv_mmio; iter; iter = iter->sibling) {

drivers/hv/vmbus_drv.c

2495

if ((iter->start >= max) || (iter->end <= min))

drivers/hv/vmbus_drv.c

2498

range_min = iter->start;

drivers/hv/vmbus_drv.c

2499

range_max = iter->end;

drivers/hv/vmbus_drv.c

2510

shadow = __request_region(iter, start, size, NULL,

drivers/hv/vmbus_drv.c

2522

__release_region(iter, start, size);

drivers/hv/vmbus_drv.c

2542

struct resource *iter;

drivers/hv/vmbus_drv.c

2556

for (iter = hyperv_mmio; iter; iter = iter->sibling) {

drivers/hv/vmbus_drv.c

2557

if ((iter->start >= start + size) || (iter->end <= start))

drivers/hv/vmbus_drv.c

2560

__release_region(iter, start, size);

drivers/hwspinlock/hwspinlock_core.c

374

struct radix_tree_iter iter;

drivers/hwspinlock/hwspinlock_core.c

392

radix_tree_for_each_slot(slot, &hwspinlock_tree, &iter, 0) {

drivers/hwspinlock/hwspinlock_core.c

397

slot = radix_tree_iter_retry(&iter);

drivers/hwtracing/intel_th/msu.c

1255

struct msc_window *win, *iter;

drivers/hwtracing/intel_th/msu.c

1257

list_for_each_entry_safe(win, iter, &msc->win_list, entry)

drivers/hwtracing/intel_th/msu.c

1475

struct msc_iter *iter;

drivers/hwtracing/intel_th/msu.c

1480

iter = msc_iter_install(msc);

drivers/hwtracing/intel_th/msu.c

1481

if (IS_ERR(iter))

drivers/hwtracing/intel_th/msu.c

1482

return PTR_ERR(iter);

drivers/hwtracing/intel_th/msu.c

1484

file->private_data = iter;

drivers/hwtracing/intel_th/msu.c

1491

struct msc_iter *iter = file->private_data;

drivers/hwtracing/intel_th/msu.c

1492

struct msc *msc = iter->msc;

drivers/hwtracing/intel_th/msu.c

1495

msc_iter_remove(iter, msc);

drivers/hwtracing/intel_th/msu.c

1540

struct msc_iter *iter = file->private_data;

drivers/hwtracing/intel_th/msu.c

1541

struct msc *msc = iter->msc;

drivers/hwtracing/intel_th/msu.c

1573

ret = msc_buffer_iterate(iter, len, &u, msc_win_to_user);

drivers/hwtracing/intel_th/msu.c

1575

*ppos = iter->offset;

drivers/hwtracing/intel_th/msu.c

1592

struct msc_iter *iter = vma->vm_file->private_data;

drivers/hwtracing/intel_th/msu.c

1593

struct msc *msc = iter->msc;

drivers/hwtracing/intel_th/msu.c

1600

struct msc_iter *iter = vma->vm_file->private_data;

drivers/hwtracing/intel_th/msu.c

1601

struct msc *msc = iter->msc;

drivers/hwtracing/intel_th/msu.c

1613

struct msc_iter *iter = vmf->vma->vm_file->private_data;

drivers/hwtracing/intel_th/msu.c

1614

struct msc *msc = iter->msc;

drivers/hwtracing/intel_th/msu.c

1634

struct msc_iter *iter = vma->vm_file->private_data;

drivers/hwtracing/intel_th/msu.c

1635

struct msc *msc = iter->msc;

drivers/hwtracing/intel_th/msu.c

444

static struct msc_block_desc *msc_iter_bdesc(struct msc_iter *iter)

drivers/hwtracing/intel_th/msu.c

446

return sg_virt(iter->block);

drivers/hwtracing/intel_th/msu.c

451

struct msc_iter *iter;

drivers/hwtracing/intel_th/msu.c

453

iter = kzalloc_obj(*iter);

drivers/hwtracing/intel_th/msu.c

454

if (!iter)

drivers/hwtracing/intel_th/msu.c

466

kfree(iter);

drivers/hwtracing/intel_th/msu.c

467

iter = ERR_PTR(-EBUSY);

drivers/hwtracing/intel_th/msu.c

471

iter->msc = msc;

drivers/hwtracing/intel_th/msu.c

473

list_add_tail(&iter->entry, &msc->iter_list);

drivers/hwtracing/intel_th/msu.c

477

return iter;

drivers/hwtracing/intel_th/msu.c

480

static void msc_iter_remove(struct msc_iter *iter, struct msc *msc)

drivers/hwtracing/intel_th/msu.c

483

list_del(&iter->entry);

drivers/hwtracing/intel_th/msu.c

486

kfree(iter);

drivers/hwtracing/intel_th/msu.c

489

static void msc_iter_block_start(struct msc_iter *iter)

drivers/hwtracing/intel_th/msu.c

491

if (iter->start_block)

drivers/hwtracing/intel_th/msu.c

494

iter->start_block = msc_win_oldest_sg(iter->win);

drivers/hwtracing/intel_th/msu.c

495

iter->block = iter->start_block;

drivers/hwtracing/intel_th/msu.c

496

iter->wrap_count = 0;

drivers/hwtracing/intel_th/msu.c

502

if (msc_block_wrapped(msc_iter_bdesc(iter)))

drivers/hwtracing/intel_th/msu.c

503

iter->wrap_count = 2;

drivers/hwtracing/intel_th/msu.c

507

static int msc_iter_win_start(struct msc_iter *iter, struct msc *msc)

drivers/hwtracing/intel_th/msu.c

510

if (iter->start_win)

drivers/hwtracing/intel_th/msu.c

513

iter->start_win = msc_oldest_window(msc);

drivers/hwtracing/intel_th/msu.c

514

if (!iter->start_win)

drivers/hwtracing/intel_th/msu.c

517

iter->win = iter->start_win;

drivers/hwtracing/intel_th/msu.c

518

iter->start_block = NULL;

drivers/hwtracing/intel_th/msu.c

520

msc_iter_block_start(iter);

drivers/hwtracing/intel_th/msu.c

525

static int msc_iter_win_advance(struct msc_iter *iter)

drivers/hwtracing/intel_th/msu.c

527

iter->win = msc_next_window(iter->win);

drivers/hwtracing/intel_th/msu.c

528

iter->start_block = NULL;

drivers/hwtracing/intel_th/msu.c

530

if (iter->win == iter->start_win) {

drivers/hwtracing/intel_th/msu.c

531

iter->eof++;

drivers/hwtracing/intel_th/msu.c

535

msc_iter_block_start(iter);

drivers/hwtracing/intel_th/msu.c

540

static int msc_iter_block_advance(struct msc_iter *iter)

drivers/hwtracing/intel_th/msu.c

542

iter->block_off = 0;

drivers/hwtracing/intel_th/msu.c

545

if (iter->wrap_count && iter->block == iter->start_block) {

drivers/hwtracing/intel_th/msu.c

546

iter->wrap_count--;

drivers/hwtracing/intel_th/msu.c

547

if (!iter->wrap_count)

drivers/hwtracing/intel_th/msu.c

549

return msc_iter_win_advance(iter);

drivers/hwtracing/intel_th/msu.c

553

if (!iter->wrap_count && msc_block_last_written(msc_iter_bdesc(iter)))

drivers/hwtracing/intel_th/msu.c

555

return msc_iter_win_advance(iter);

drivers/hwtracing/intel_th/msu.c

558

if (sg_is_last(iter->block))

drivers/hwtracing/intel_th/msu.c

559

iter->block = msc_win_base_sg(iter->win);

drivers/hwtracing/intel_th/msu.c

561

iter->block = sg_next(iter->block);

drivers/hwtracing/intel_th/msu.c

564

if (!iter->wrap_count && iter->block == iter->start_block)

drivers/hwtracing/intel_th/msu.c

565

return msc_iter_win_advance(iter);

drivers/hwtracing/intel_th/msu.c

587

msc_buffer_iterate(struct msc_iter *iter, size_t size, void *data,

drivers/hwtracing/intel_th/msu.c

590

struct msc *msc = iter->msc;

drivers/hwtracing/intel_th/msu.c

594

if (iter->eof)

drivers/hwtracing/intel_th/msu.c

598

if (msc_iter_win_start(iter, msc))

drivers/hwtracing/intel_th/msu.c

602

unsigned long data_bytes = msc_data_sz(msc_iter_bdesc(iter));

drivers/hwtracing/intel_th/msu.c

603

void *src = (void *)msc_iter_bdesc(iter) + MSC_BDESC;

drivers/hwtracing/intel_th/msu.c

621

if (iter->block == iter->start_block && iter->wrap_count == 2) {

drivers/hwtracing/intel_th/msu.c

629

tocopy -= iter->block_off;

drivers/hwtracing/intel_th/msu.c

630

src += iter->block_off;

drivers/hwtracing/intel_th/msu.c

644

iter->block_off += copied;

drivers/hwtracing/intel_th/msu.c

645

iter->offset += copied;

drivers/hwtracing/intel_th/msu.c

651

if (msc_iter_block_advance(iter))

drivers/hwtracing/stm/core.c

435

struct stm_pdrv_entry *pe, *iter;

drivers/hwtracing/stm/core.c

439

list_for_each_entry_safe(pe, iter, &stm_pdrv_head, entry) {

drivers/hwtracing/stm/core.c

942

struct stm_source_device *src, *iter;

drivers/hwtracing/stm/core.c

949

list_for_each_entry_safe(src, iter, &stm->link_list, link_entry) {

drivers/i2c/busses/i2c-npcm7xx.c

1959

int iter = 27;

drivers/i2c/busses/i2c-npcm7xx.c

1999

} while (!done && iter--);

drivers/iio/common/ssp_sensors/ssp_spi.c

338

struct ssp_msg *msg = NULL, *iter, *n;

drivers/iio/common/ssp_sensors/ssp_spi.c

364

list_for_each_entry_safe(iter, n, &data->pending_list, list) {

drivers/iio/common/ssp_sensors/ssp_spi.c

365

if (iter->options == msg_options) {

drivers/iio/common/ssp_sensors/ssp_spi.c

366

list_del(&iter->list);

drivers/iio/common/ssp_sensors/ssp_spi.c

367

msg = iter;

drivers/iio/industrialio-backend.c

583

struct iio_backend *back = ERR_PTR(-ENODEV), *iter;

drivers/iio/industrialio-backend.c

593

list_for_each_entry(iter, &iio_back_list, entry) {

drivers/iio/industrialio-backend.c

594

if (dev == iter->frontend_dev) {

drivers/iio/industrialio-backend.c

601

back = iter;

drivers/iio/industrialio-sw-device.c

32

struct iio_sw_device_type *d = NULL, *iter;

drivers/iio/industrialio-sw-device.c

34

list_for_each_entry(iter, &iio_device_types_list, list)

drivers/iio/industrialio-sw-device.c

35

if (!strcmp(iter->name, name)) {

drivers/iio/industrialio-sw-device.c

36

d = iter;

drivers/iio/industrialio-sw-device.c

45

struct iio_sw_device_type *iter;

drivers/iio/industrialio-sw-device.c

49

iter = __iio_find_sw_device_type(d->name, strlen(d->name));

drivers/iio/industrialio-sw-device.c

50

if (iter)

drivers/iio/industrialio-sw-device.c

70

struct iio_sw_device_type *iter;

drivers/iio/industrialio-sw-device.c

73

iter = __iio_find_sw_device_type(dt->name, strlen(dt->name));

drivers/iio/industrialio-sw-device.c

74

if (iter)

drivers/iio/industrialio-sw-trigger.c

32

struct iio_sw_trigger_type *t = NULL, *iter;

drivers/iio/industrialio-sw-trigger.c

34

list_for_each_entry(iter, &iio_trigger_types_list, list)

drivers/iio/industrialio-sw-trigger.c

35

if (!strcmp(iter->name, name)) {

drivers/iio/industrialio-sw-trigger.c

36

t = iter;

drivers/iio/industrialio-sw-trigger.c

45

struct iio_sw_trigger_type *iter;

drivers/iio/industrialio-sw-trigger.c

49

iter = __iio_find_sw_trigger_type(t->name, strlen(t->name));

drivers/iio/industrialio-sw-trigger.c

50

if (iter)

drivers/iio/industrialio-sw-trigger.c

74

struct iio_sw_trigger_type *iter;

drivers/iio/industrialio-sw-trigger.c

77

iter = __iio_find_sw_trigger_type(t->name, strlen(t->name));

drivers/iio/industrialio-sw-trigger.c

78

if (iter)

drivers/iio/industrialio-trigger.c

135

struct iio_trigger *iter;

drivers/iio/industrialio-trigger.c

137

list_for_each_entry(iter, &iio_trigger_list, list)

drivers/iio/industrialio-trigger.c

138

if (!strcmp(iter->name, name))

drivers/iio/industrialio-trigger.c

139

return iter;

drivers/iio/industrialio-trigger.c

146

struct iio_trigger *iter;

drivers/iio/industrialio-trigger.c

149

list_for_each_entry(iter, &iio_trigger_list, list)

drivers/iio/industrialio-trigger.c

150

if (sysfs_streq(iter->name, name))

drivers/iio/industrialio-trigger.c

151

return iio_trigger_get(iter);

drivers/iio/trigger/iio-trig-sysfs.c

179

struct iio_sysfs_trig *t = NULL, *iter;

drivers/iio/trigger/iio-trig-sysfs.c

182

list_for_each_entry(iter, &iio_sysfs_trig_list, l)

drivers/iio/trigger/iio-trig-sysfs.c

183

if (id == iter->id) {

drivers/iio/trigger/iio-trig-sysfs.c

184

t = iter;

drivers/infiniband/core/rw.c

206

struct bvec_iter *iter, u64 remote_addr, u32 rkey,

drivers/infiniband/core/rw.c

231

for (sg = ctx->reg[0].sgt.sgl; iter->bi_size; sg = sg_next(sg)) {

drivers/infiniband/core/rw.c

232

struct bio_vec bv = mp_bvec_iter_bvec(bvecs, *iter);

drivers/infiniband/core/rw.c

239

bvec_iter_advance(bvecs, iter, bv.bv_len);

drivers/infiniband/core/rw.c

371

struct bvec_iter *iter, u64 remote_addr, u32 rkey,

drivers/infiniband/core/rw.c

376

struct bio_vec bv = mp_bvec_iter_bvec(bvecs, *iter);

drivers/infiniband/core/rw.c

404

const struct bio_vec *bvecs, u32 nr_bvec, struct bvec_iter *iter,

drivers/infiniband/core/rw.c

444

struct bio_vec bv = mp_bvec_iter_bvec(bvecs, *iter);

drivers/infiniband/core/rw.c

459

bvec_iter_advance_single(bvecs, iter, bv.bv_len);

drivers/infiniband/core/rw.c

489

struct bvec_iter *iter, u64 remote_addr, u32 rkey,

drivers/infiniband/core/rw.c

494

size_t total_len = iter->bi_size;

drivers/infiniband/core/rw.c

504

first_bv = mp_bvec_iter_bvec(bvec, *iter);

drivers/infiniband/core/rw.c

510

while (iter->bi_size) {

drivers/infiniband/core/rw.c

511

struct bio_vec bv = mp_bvec_iter_bvec(bvec, *iter);

drivers/infiniband/core/rw.c

519

bvec_iter_advance(bvec, iter, bv.bv_len);

drivers/infiniband/core/rw.c

667

struct bvec_iter iter, u64 remote_addr, u32 rkey,

drivers/infiniband/core/rw.c

673

if (nr_bvec == 0 || iter.bi_size == 0)

drivers/infiniband/core/rw.c

682

nr_bvec, &iter, remote_addr,

drivers/infiniband/core/rw.c

686

nr_bvec, &iter, remote_addr,

drivers/infiniband/core/rw.c

690

return rdma_rw_init_single_wr_bvec(ctx, qp, bvecs, &iter,

drivers/infiniband/core/rw.c

698

ret = rdma_rw_init_iova_wrs_bvec(ctx, qp, bvecs, &iter, remote_addr,

drivers/infiniband/core/rw.c

714

return rdma_rw_init_map_wrs_bvec(ctx, qp, bvecs, nr_bvec, &iter,

drivers/infiniband/core/sa_query.c

1132

struct ib_sa_query *query = NULL, *iter;

drivers/infiniband/core/sa_query.c

1142

list_for_each_entry(iter, &ib_nl_request_list, list) {

drivers/infiniband/core/sa_query.c

1147

if (nlh->nlmsg_seq == iter->seq) {

drivers/infiniband/core/sa_query.c

1148

if (!ib_sa_query_cancelled(iter)) {

drivers/infiniband/core/sa_query.c

1149

list_del(&iter->list);

drivers/infiniband/core/sa_query.c

1150

query = iter;

drivers/infiniband/core/uverbs_cmd.c

121

struct uverbs_req_iter *iter,

drivers/infiniband/core/uverbs_cmd.c

131

iter->cur = attrs->ucore.inbuf + req_len;

drivers/infiniband/core/uverbs_cmd.c

132

iter->end = attrs->ucore.inbuf + attrs->ucore.inlen;

drivers/infiniband/core/uverbs_cmd.c

136

static int uverbs_request_next(struct uverbs_req_iter *iter, void *val,

drivers/infiniband/core/uverbs_cmd.c

139

if (iter->cur + len > iter->end)

drivers/infiniband/core/uverbs_cmd.c

142

if (copy_from_user(val, iter->cur, len))

drivers/infiniband/core/uverbs_cmd.c

145

iter->cur += len;

drivers/infiniband/core/uverbs_cmd.c

149

static const void __user *uverbs_request_next_ptr(struct uverbs_req_iter *iter,

drivers/infiniband/core/uverbs_cmd.c

152

const void __user *res = iter->cur;

drivers/infiniband/core/uverbs_cmd.c

154

if (len > iter->end - iter->cur)

drivers/infiniband/core/uverbs_cmd.c

156

iter->cur += len;

drivers/infiniband/core/uverbs_cmd.c

160

static int uverbs_request_finish(struct uverbs_req_iter *iter)

drivers/infiniband/core/uverbs_cmd.c

162

if (!ib_is_buffer_cleared(iter->cur, iter->end - iter->cur))

drivers/infiniband/core/uverbs_cmd.c

2030

struct uverbs_req_iter iter;

drivers/infiniband/core/uverbs_cmd.c

2032

ret = uverbs_request_start(attrs, &iter, &cmd, sizeof(cmd));

drivers/infiniband/core/uverbs_cmd.c

2035

wqes = uverbs_request_next_ptr(&iter, size_mul(cmd.wqe_size,

drivers/infiniband/core/uverbs_cmd.c

2039

sgls = uverbs_request_next_ptr(&iter,

drivers/infiniband/core/uverbs_cmd.c

2044

ret = uverbs_request_finish(&iter);

drivers/infiniband/core/uverbs_cmd.c

2216

ib_uverbs_unmarshall_recv(struct uverbs_req_iter *iter, u32 wr_count,

drivers/infiniband/core/uverbs_cmd.c

2230

wqes = uverbs_request_next_ptr(iter, size_mul(wqe_size, wr_count));

drivers/infiniband/core/uverbs_cmd.c

2233

sgls = uverbs_request_next_ptr(iter, size_mul(sge_count,

drivers/infiniband/core/uverbs_cmd.c

2237

ret = uverbs_request_finish(iter);

drivers/infiniband/core/uverbs_cmd.c

2321

struct uverbs_req_iter iter;

drivers/infiniband/core/uverbs_cmd.c

2323

ret = uverbs_request_start(attrs, &iter, &cmd, sizeof(cmd));

drivers/infiniband/core/uverbs_cmd.c

2327

wr = ib_uverbs_unmarshall_recv(&iter, cmd.wr_count, cmd.wqe_size,

drivers/infiniband/core/uverbs_cmd.c

2372

struct uverbs_req_iter iter;

drivers/infiniband/core/uverbs_cmd.c

2374

ret = uverbs_request_start(attrs, &iter, &cmd, sizeof(cmd));

drivers/infiniband/core/uverbs_cmd.c

2378

wr = ib_uverbs_unmarshall_recv(&iter, cmd.wr_count, cmd.wqe_size,

drivers/infiniband/core/uverbs_cmd.c

3011

struct uverbs_req_iter iter;

drivers/infiniband/core/uverbs_cmd.c

3014

err = uverbs_request_start(attrs, &iter, &cmd, sizeof(cmd));

drivers/infiniband/core/uverbs_cmd.c

3030

err = uverbs_request_next(&iter, wqs_handles,

drivers/infiniband/core/uverbs_cmd.c

3035

err = uverbs_request_finish(&iter);

drivers/infiniband/core/uverbs_cmd.c

3139

struct uverbs_req_iter iter;

drivers/infiniband/core/uverbs_cmd.c

3145

err = uverbs_request_start(attrs, &iter, &cmd, sizeof(cmd));

drivers/infiniband/core/uverbs_cmd.c

3181

err = uverbs_request_next(&iter, &kern_flow_attr->flow_specs,

drivers/infiniband/core/uverbs_cmd.c

3189

err = uverbs_request_finish(&iter);

drivers/infiniband/core/uverbs_uapi.c

356

struct radix_tree_iter iter;

drivers/infiniband/core/uverbs_uapi.c

363

radix_tree_for_each_slot (slot, &uapi->radix, &iter,

drivers/infiniband/core/uverbs_uapi.c

367

u32 attr_key = iter.index & UVERBS_API_ATTR_KEY_MASK;

drivers/infiniband/core/uverbs_uapi.c

371

if (uapi_key_attr_to_ioctl_method(iter.index) !=

drivers/infiniband/core/uverbs_uapi.c

420

struct radix_tree_iter iter;

drivers/infiniband/core/uverbs_uapi.c

425

radix_tree_for_each_slot (slot, &uapi->radix, &iter, 0) {

drivers/infiniband/core/uverbs_uapi.c

429

if (uapi_key_is_ioctl_method(iter.index)) {

drivers/infiniband/core/uverbs_uapi.c

431

iter.index);

drivers/infiniband/core/uverbs_uapi.c

436

if (uapi_key_is_write_method(iter.index))

drivers/infiniband/core/uverbs_uapi.c

438

iter.index & UVERBS_API_ATTR_KEY_MASK);

drivers/infiniband/core/uverbs_uapi.c

439

if (uapi_key_is_write_ex_method(iter.index))

drivers/infiniband/core/uverbs_uapi.c

442

iter.index & UVERBS_API_ATTR_KEY_MASK);

drivers/infiniband/core/uverbs_uapi.c

458

radix_tree_for_each_slot (slot, &uapi->radix, &iter, 0) {

drivers/infiniband/core/uverbs_uapi.c

459

if (uapi_key_is_write_method(iter.index))

drivers/infiniband/core/uverbs_uapi.c

460

uapi->write_methods[iter.index &

drivers/infiniband/core/uverbs_uapi.c

463

if (uapi_key_is_write_ex_method(iter.index))

drivers/infiniband/core/uverbs_uapi.c

464

uapi->write_ex_methods[iter.index &

drivers/infiniband/core/uverbs_uapi.c

474

struct radix_tree_iter iter;

drivers/infiniband/core/uverbs_uapi.c

477

radix_tree_for_each_slot (slot, &uapi->radix, &iter, start) {

drivers/infiniband/core/uverbs_uapi.c

478

if (iter.index > last)

drivers/infiniband/core/uverbs_uapi.c

481

radix_tree_iter_delete(&uapi->radix, &iter, slot);

drivers/infiniband/core/uverbs_uapi.c

528

struct radix_tree_iter iter;

drivers/infiniband/core/uverbs_uapi.c

534

radix_tree_for_each_slot (slot, &uapi->radix, &iter, starting_key) {

drivers/infiniband/core/uverbs_uapi.c

535

uapi_key_okay(iter.index);

drivers/infiniband/core/uverbs_uapi.c

537

if (uapi_key_is_object(iter.index)) {

drivers/infiniband/core/uverbs_uapi.c

544

starting_key = iter.index;

drivers/infiniband/core/uverbs_uapi.c

545

uapi_remove_object(uapi, iter.index);

drivers/infiniband/core/uverbs_uapi.c

551

if (uapi_key_is_ioctl_method(iter.index)) {

drivers/infiniband/core/uverbs_uapi.c

556

starting_key = iter.index;

drivers/infiniband/core/uverbs_uapi.c

557

uapi_remove_method(uapi, iter.index);

drivers/infiniband/core/uverbs_uapi.c

563

if (uapi_key_is_write_method(iter.index) ||

drivers/infiniband/core/uverbs_uapi.c

564

uapi_key_is_write_ex_method(iter.index)) {

drivers/infiniband/core/uverbs_uapi.c

570

radix_tree_iter_delete(&uapi->radix, &iter, slot);

drivers/infiniband/core/uverbs_uapi.c

575

if (uapi_key_is_attr(iter.index)) {

drivers/infiniband/core/uverbs_uapi.c

600

starting_key = iter.index;

drivers/infiniband/core/uverbs_uapi.c

603

iter.index & (UVERBS_API_OBJ_KEY_MASK |

drivers/infiniband/core/uverbs_uapi.c

689

struct radix_tree_iter iter;

drivers/infiniband/core/uverbs_uapi.c

694

radix_tree_for_each_slot (slot, &uapi->radix, &iter, 0) {

drivers/infiniband/core/uverbs_uapi.c

695

if (uapi_key_is_ioctl_method(iter.index)) {

drivers/infiniband/core/uverbs_uapi.c

714

struct radix_tree_iter iter;

drivers/infiniband/core/uverbs_uapi.c

717

radix_tree_for_each_slot (slot, &uapi->radix, &iter, 0) {

drivers/infiniband/core/uverbs_uapi.c

718

if (uapi_key_is_object(iter.index)) {

drivers/infiniband/core/uverbs_uapi.c

741

} else if (uapi_key_is_attr(iter.index)) {

drivers/infiniband/hw/hfi1/debugfs.c

193

struct rvt_qp_iter *iter;

drivers/infiniband/hw/hfi1/debugfs.c

196

iter = rvt_qp_iter_init(s->private, 0, NULL);

drivers/infiniband/hw/hfi1/debugfs.c

201

if (!iter)

drivers/infiniband/hw/hfi1/debugfs.c

205

if (rvt_qp_iter_next(iter)) {

drivers/infiniband/hw/hfi1/debugfs.c

206

kfree(iter);

drivers/infiniband/hw/hfi1/debugfs.c

211

return iter;

drivers/infiniband/hw/hfi1/debugfs.c

218

struct rvt_qp_iter *iter = iter_ptr;

drivers/infiniband/hw/hfi1/debugfs.c

222

if (rvt_qp_iter_next(iter)) {

drivers/infiniband/hw/hfi1/debugfs.c

223

kfree(iter);

drivers/infiniband/hw/hfi1/debugfs.c

227

return iter;

drivers/infiniband/hw/hfi1/debugfs.c

238

struct rvt_qp_iter *iter = iter_ptr;

drivers/infiniband/hw/hfi1/debugfs.c

240

if (!iter)

drivers/infiniband/hw/hfi1/debugfs.c

243

qp_iter_print(s, iter);

drivers/infiniband/hw/hfi1/qp.c

597

void qp_iter_print(struct seq_file *s, struct rvt_qp_iter *iter)

drivers/infiniband/hw/hfi1/qp.c

600

struct rvt_qp *qp = iter->qp;

drivers/infiniband/hw/hfi1/qp.c

615

iter->n,

drivers/infiniband/hw/hfi1/qp.h

83

void qp_iter_print(struct seq_file *s, struct rvt_qp_iter *iter);

drivers/infiniband/hw/mlx5/fs.c

648

struct mlx5_ib_flow_handler *iter, *tmp;

drivers/infiniband/hw/mlx5/fs.c

653

list_for_each_entry_safe(iter, tmp, &handler->list, list) {

drivers/infiniband/hw/mlx5/fs.c

654

mlx5_del_flow_rules(iter->rule);

drivers/infiniband/hw/mlx5/fs.c

655

put_flow_table(dev, iter->prio, true);

drivers/infiniband/hw/mlx5/fs.c

656

list_del(&iter->list);

drivers/infiniband/hw/mlx5/fs.c

657

kfree(iter);

drivers/infiniband/hw/mlx5/macsec.c

43

struct mlx5_macsec_device *iter, *macsec_device = NULL;

drivers/infiniband/hw/mlx5/macsec.c

45

list_for_each_entry(iter, macsec_devices_list, macsec_devices_list_entry) {

drivers/infiniband/hw/mlx5/macsec.c

46

if (iter->macdev == macdev) {

drivers/infiniband/hw/mlx5/macsec.c

47

macsec_device = iter;

drivers/infiniband/hw/mthca/mthca_cmd.c

660

struct mthca_icm_iter iter;

drivers/infiniband/hw/mthca/mthca_cmd.c

674

for (mthca_icm_first(icm, &iter);

drivers/infiniband/hw/mthca/mthca_cmd.c

675

!mthca_icm_last(&iter);

drivers/infiniband/hw/mthca/mthca_cmd.c

676

mthca_icm_next(&iter)) {

drivers/infiniband/hw/mthca/mthca_cmd.c

682

lg = ffs(mthca_icm_addr(&iter) | mthca_icm_size(&iter)) - 1;

drivers/infiniband/hw/mthca/mthca_cmd.c

686

(unsigned long long) mthca_icm_addr(&iter),

drivers/infiniband/hw/mthca/mthca_cmd.c

687

mthca_icm_size(&iter));

drivers/infiniband/hw/mthca/mthca_cmd.c

691

for (i = 0; i < mthca_icm_size(&iter) >> lg; ++i) {

drivers/infiniband/hw/mthca/mthca_cmd.c

698

cpu_to_be64((mthca_icm_addr(&iter) + (i << lg)) |

drivers/infiniband/hw/mthca/mthca_memfree.h

100

struct mthca_icm_iter *iter)

drivers/infiniband/hw/mthca/mthca_memfree.h

102

iter->icm = icm;

drivers/infiniband/hw/mthca/mthca_memfree.h

103

iter->chunk = list_empty(&icm->chunk_list) ?

drivers/infiniband/hw/mthca/mthca_memfree.h

106

iter->page_idx = 0;

drivers/infiniband/hw/mthca/mthca_memfree.h

109

static inline int mthca_icm_last(struct mthca_icm_iter *iter)

drivers/infiniband/hw/mthca/mthca_memfree.h

111

return !iter->chunk;

drivers/infiniband/hw/mthca/mthca_memfree.h

114

static inline void mthca_icm_next(struct mthca_icm_iter *iter)

drivers/infiniband/hw/mthca/mthca_memfree.h

116

if (++iter->page_idx >= iter->chunk->nsg) {

drivers/infiniband/hw/mthca/mthca_memfree.h

117

if (iter->chunk->list.next == &iter->icm->chunk_list) {

drivers/infiniband/hw/mthca/mthca_memfree.h

118

iter->chunk = NULL;

drivers/infiniband/hw/mthca/mthca_memfree.h

122

iter->chunk = list_entry(iter->chunk->list.next,

drivers/infiniband/hw/mthca/mthca_memfree.h

124

iter->page_idx = 0;

drivers/infiniband/hw/mthca/mthca_memfree.h

128

static inline dma_addr_t mthca_icm_addr(struct mthca_icm_iter *iter)

drivers/infiniband/hw/mthca/mthca_memfree.h

130

return sg_dma_address(&iter->chunk->mem[iter->page_idx]);

drivers/infiniband/hw/mthca/mthca_memfree.h

133

static inline unsigned long mthca_icm_size(struct mthca_icm_iter *iter)

drivers/infiniband/hw/mthca/mthca_memfree.h

135

return sg_dma_len(&iter->chunk->mem[iter->page_idx]);

drivers/infiniband/hw/qedr/verbs.c

1048

int iter;

drivers/infiniband/hw/qedr/verbs.c

1088

iter = QEDR_DESTROY_CQ_MAX_ITERATIONS;

drivers/infiniband/hw/qedr/verbs.c

1089

while (oparams.num_cq_notif != READ_ONCE(cq->cnq_notif) && iter) {

drivers/infiniband/hw/qedr/verbs.c

1091

iter--;

drivers/infiniband/hw/qedr/verbs.c

1094

iter = QEDR_DESTROY_CQ_MAX_ITERATIONS;

drivers/infiniband/hw/qedr/verbs.c

1095

while (oparams.num_cq_notif != READ_ONCE(cq->cnq_notif) && iter) {

drivers/infiniband/hw/qedr/verbs.c

1097

iter--;

drivers/infiniband/sw/rdmavt/qp.c

2676

int rvt_qp_iter_next(struct rvt_qp_iter *iter)

drivers/infiniband/sw/rdmavt/qp.c

2679

int n = iter->n;

drivers/infiniband/sw/rdmavt/qp.c

2681

struct rvt_qp *pqp = iter->qp;

drivers/infiniband/sw/rdmavt/qp.c

2683

struct rvt_dev_info *rdi = iter->rdi;

drivers/infiniband/sw/rdmavt/qp.c

2699

for (; n < rdi->qp_dev->qp_table_size + iter->specials; n++) {

drivers/infiniband/sw/rdmavt/qp.c

2703

if (n < iter->specials) {

drivers/infiniband/sw/rdmavt/qp.c

2713

(n - iter->specials)]);

drivers/infiniband/sw/rdmavt/qp.c

2718

iter->qp = qp;

drivers/infiniband/sw/rdmavt/qp.c

2719

iter->n = n;

drivers/infiniband/ulp/ipoib/ipoib.h

564

int ipoib_mcast_iter_next(struct ipoib_mcast_iter *iter);

drivers/infiniband/ulp/ipoib/ipoib.h

565

void ipoib_mcast_iter_read(struct ipoib_mcast_iter *iter,

drivers/infiniband/ulp/ipoib/ipoib.h

573

int ipoib_path_iter_next(struct ipoib_path_iter *iter);

drivers/infiniband/ulp/ipoib/ipoib.h

574

void ipoib_path_iter_read(struct ipoib_path_iter *iter,

drivers/infiniband/ulp/ipoib/ipoib_fs.c

105

if (!iter)

drivers/infiniband/ulp/ipoib/ipoib_fs.c

108

ipoib_mcast_iter_read(iter, &mgid, &created, &queuelen,

drivers/infiniband/ulp/ipoib/ipoib_fs.c

138

struct ipoib_path_iter *iter;

drivers/infiniband/ulp/ipoib/ipoib_fs.c

141

iter = ipoib_path_iter_init(file->private);

drivers/infiniband/ulp/ipoib/ipoib_fs.c

142

if (!iter)

drivers/infiniband/ulp/ipoib/ipoib_fs.c

146

if (ipoib_path_iter_next(iter)) {

drivers/infiniband/ulp/ipoib/ipoib_fs.c

147

kfree(iter);

drivers/infiniband/ulp/ipoib/ipoib_fs.c

152

return iter;

drivers/infiniband/ulp/ipoib/ipoib_fs.c

158

struct ipoib_path_iter *iter = iter_ptr;

drivers/infiniband/ulp/ipoib/ipoib_fs.c

162

if (ipoib_path_iter_next(iter)) {

drivers/infiniband/ulp/ipoib/ipoib_fs.c

163

kfree(iter);

drivers/infiniband/ulp/ipoib/ipoib_fs.c

167

return iter;

drivers/infiniband/ulp/ipoib/ipoib_fs.c

177

struct ipoib_path_iter *iter = iter_ptr;

drivers/infiniband/ulp/ipoib/ipoib_fs.c

182

if (!iter)

drivers/infiniband/ulp/ipoib/ipoib_fs.c

185

ipoib_path_iter_read(iter, &path);

drivers/infiniband/ulp/ipoib/ipoib_fs.c

60

struct ipoib_mcast_iter *iter;

drivers/infiniband/ulp/ipoib/ipoib_fs.c

63

iter = ipoib_mcast_iter_init(file->private);

drivers/infiniband/ulp/ipoib/ipoib_fs.c

64

if (!iter)

drivers/infiniband/ulp/ipoib/ipoib_fs.c

68

if (ipoib_mcast_iter_next(iter)) {

drivers/infiniband/ulp/ipoib/ipoib_fs.c

69

kfree(iter);

drivers/infiniband/ulp/ipoib/ipoib_fs.c

74

return iter;

drivers/infiniband/ulp/ipoib/ipoib_fs.c

80

struct ipoib_mcast_iter *iter = iter_ptr;

drivers/infiniband/ulp/ipoib/ipoib_fs.c

84

if (ipoib_mcast_iter_next(iter)) {

drivers/infiniband/ulp/ipoib/ipoib_fs.c

85

kfree(iter);

drivers/infiniband/ulp/ipoib/ipoib_fs.c

89

return iter;

drivers/infiniband/ulp/ipoib/ipoib_fs.c

99

struct ipoib_mcast_iter *iter = iter_ptr;

drivers/infiniband/ulp/ipoib/ipoib_main.c

674

struct ipoib_path_iter *iter;

drivers/infiniband/ulp/ipoib/ipoib_main.c

676

iter = kmalloc_obj(*iter);

drivers/infiniband/ulp/ipoib/ipoib_main.c

677

if (!iter)

drivers/infiniband/ulp/ipoib/ipoib_main.c

680

iter->dev = dev;

drivers/infiniband/ulp/ipoib/ipoib_main.c

681

memset(iter->path.pathrec.dgid.raw, 0, 16);

drivers/infiniband/ulp/ipoib/ipoib_main.c

683

if (ipoib_path_iter_next(iter)) {

drivers/infiniband/ulp/ipoib/ipoib_main.c

684

kfree(iter);

drivers/infiniband/ulp/ipoib/ipoib_main.c

688

return iter;

drivers/infiniband/ulp/ipoib/ipoib_main.c

691

int ipoib_path_iter_next(struct ipoib_path_iter *iter)

drivers/infiniband/ulp/ipoib/ipoib_main.c

693

struct ipoib_dev_priv *priv = ipoib_priv(iter->dev);

drivers/infiniband/ulp/ipoib/ipoib_main.c

705

if (memcmp(iter->path.pathrec.dgid.raw, path->pathrec.dgid.raw,

drivers/infiniband/ulp/ipoib/ipoib_main.c

707

iter->path = *path;

drivers/infiniband/ulp/ipoib/ipoib_main.c

720

void ipoib_path_iter_read(struct ipoib_path_iter *iter,

drivers/infiniband/ulp/ipoib/ipoib_main.c

723

*path = iter->path;

drivers/infiniband/ulp/ipoib/ipoib_multicast.c

1000

struct ipoib_dev_priv *priv = ipoib_priv(iter->dev);

drivers/infiniband/ulp/ipoib/ipoib_multicast.c

1012

if (memcmp(iter->mgid.raw, mcast->mcmember.mgid.raw,

drivers/infiniband/ulp/ipoib/ipoib_multicast.c

1014

iter->mgid = mcast->mcmember.mgid;

drivers/infiniband/ulp/ipoib/ipoib_multicast.c

1015

iter->created = mcast->created;

drivers/infiniband/ulp/ipoib/ipoib_multicast.c

1016

iter->queuelen = skb_queue_len(&mcast->pkt_queue);

drivers/infiniband/ulp/ipoib/ipoib_multicast.c

1017

iter->complete = !!mcast->ah;

drivers/infiniband/ulp/ipoib/ipoib_multicast.c

1018

iter->send_only = !!(mcast->flags & (1 << IPOIB_MCAST_FLAG_SENDONLY));

drivers/infiniband/ulp/ipoib/ipoib_multicast.c

1033

void ipoib_mcast_iter_read(struct ipoib_mcast_iter *iter,

drivers/infiniband/ulp/ipoib/ipoib_multicast.c

1040

*mgid = iter->mgid;

drivers/infiniband/ulp/ipoib/ipoib_multicast.c

1041

*created = iter->created;

drivers/infiniband/ulp/ipoib/ipoib_multicast.c

1042

*queuelen = iter->queuelen;

drivers/infiniband/ulp/ipoib/ipoib_multicast.c

1043

*complete = iter->complete;

drivers/infiniband/ulp/ipoib/ipoib_multicast.c

1044

*send_only = iter->send_only;

drivers/infiniband/ulp/ipoib/ipoib_multicast.c

981

struct ipoib_mcast_iter *iter;

drivers/infiniband/ulp/ipoib/ipoib_multicast.c

983

iter = kmalloc_obj(*iter);

drivers/infiniband/ulp/ipoib/ipoib_multicast.c

984

if (!iter)

drivers/infiniband/ulp/ipoib/ipoib_multicast.c

987

iter->dev = dev;

drivers/infiniband/ulp/ipoib/ipoib_multicast.c

988

memset(iter->mgid.raw, 0, 16);

drivers/infiniband/ulp/ipoib/ipoib_multicast.c

990

if (ipoib_mcast_iter_next(iter)) {

drivers/infiniband/ulp/ipoib/ipoib_multicast.c

991

kfree(iter);

drivers/infiniband/ulp/ipoib/ipoib_multicast.c

995

return iter;

drivers/infiniband/ulp/ipoib/ipoib_multicast.c

998

int ipoib_mcast_iter_next(struct ipoib_mcast_iter *iter)

drivers/infiniband/ulp/rtrs/rtrs-clt.c

956

struct iov_iter iter;

drivers/infiniband/ulp/rtrs/rtrs-clt.c

975

iov_iter_kvec(&iter, ITER_SOURCE, vec, 1, usr_len);

drivers/infiniband/ulp/rtrs/rtrs-clt.c

976

len = _copy_from_iter(req->iu->buf, usr_len, &iter);

drivers/iommu/generic_pt/kunit_iommu_pt.h

335

unsigned int iter;

drivers/iommu/generic_pt/kunit_iommu_pt.h

346

for (iter = 0; iter != 1000; iter++) {

drivers/iommu/generic_pt/kunit_iommu_pt.h

386

if (iter % 100)

drivers/iommu/intel/dmar.c

586

struct acpi_dmar_header *iter, *next;

drivers/iommu/intel/dmar.c

589

for (iter = start; iter < end; iter = next) {

drivers/iommu/intel/dmar.c

590

next = (void *)iter + iter->length;

drivers/iommu/intel/dmar.c

591

if (iter->length == 0) {

drivers/iommu/intel/dmar.c

602

dmar_table_print_dmar_entry(iter);

drivers/iommu/intel/dmar.c

604

if (iter->type >= ACPI_DMAR_TYPE_RESERVED) {

drivers/iommu/intel/dmar.c

607

iter->type);

drivers/iommu/intel/dmar.c

608

} else if (cb->cb[iter->type]) {

drivers/iommu/intel/dmar.c

611

ret = cb->cb[iter->type](iter, cb->arg[iter->type]);

drivers/iommu/intel/dmar.c

616

iter->type);

drivers/iommu/iommu.c

884

struct iommu_resv_region *iter, *tmp, *nr, *top;

drivers/iommu/iommu.c

893

list_for_each_entry(iter, regions, list) {

drivers/iommu/iommu.c

894

if (nr->start < iter->start ||

drivers/iommu/iommu.c

895

(nr->start == iter->start && nr->type <= iter->type))

drivers/iommu/iommu.c

898

list_add_tail(&nr->list, &iter->list);

drivers/iommu/iommu.c

901

list_for_each_entry_safe(iter, tmp, regions, list) {

drivers/iommu/iommu.c

902

phys_addr_t top_end, iter_end = iter->start + iter->length - 1;

drivers/iommu/iommu.c

905

if (iter->type != new->type) {

drivers/iommu/iommu.c

906

list_move_tail(&iter->list, &stack);

drivers/iommu/iommu.c

912

if (top->type == iter->type)

drivers/iommu/iommu.c

915

list_move_tail(&iter->list, &stack);

drivers/iommu/iommu.c

921

if (iter->start > top_end + 1) {

drivers/iommu/iommu.c

922

list_move_tail(&iter->list, &stack);

drivers/iommu/iommu.c

925

list_del(&iter->list);

drivers/iommu/iommu.c

926

kfree(iter);

drivers/iommu/iommufd/device.c

1336

struct iopt_area_contig_iter iter;

drivers/iommu/iommufd/device.c

1357

iopt_for_each_contig_area(&iter, area, iopt, iova, last_iova)

drivers/iommu/iommufd/device.c

1359

area, iopt_area_iova_to_index(area, iter.cur_iova),

drivers/iommu/iommufd/device.c

1364

WARN_ON(!iopt_area_contig_done(&iter));

drivers/iommu/iommufd/device.c

1370

static bool iopt_area_contig_is_aligned(struct iopt_area_contig_iter *iter)

drivers/iommu/iommufd/device.c

1372

if (iopt_area_start_byte(iter->area, iter->cur_iova) % PAGE_SIZE)

drivers/iommu/iommufd/device.c

1375

if (!iopt_area_contig_done(iter) &&

drivers/iommu/iommufd/device.c

1376

(iopt_area_start_byte(iter->area, iopt_area_last_iova(iter->area)) %

drivers/iommu/iommufd/device.c

1413

struct iopt_area_contig_iter iter;

drivers/iommu/iommufd/device.c

1438

iopt_for_each_contig_area(&iter, area, iopt, iova, last_iova) {

drivers/iommu/iommufd/device.c

1442

iopt_area_iova_to_index(area, iter.cur_iova);

drivers/iommu/iommufd/device.c

1445

!iopt_area_contig_is_aligned(&iter)) {

drivers/iommu/iommufd/device.c

1461

if (!iopt_area_contig_done(&iter)) {

drivers/iommu/iommufd/device.c

1471

if (iova < iter.cur_iova) {

drivers/iommu/iommufd/device.c

1472

last_iova = iter.cur_iova - 1;

drivers/iommu/iommufd/device.c

1473

iopt_for_each_contig_area(&iter, area, iopt, iova, last_iova)

drivers/iommu/iommufd/device.c

1476

iopt_area_iova_to_index(area, iter.cur_iova),

drivers/iommu/iommufd/device.c

1503

struct iopt_area_contig_iter iter;

drivers/iommu/iommufd/device.c

1522

iopt_for_each_contig_area(&iter, area, iopt, iova, last_iova) {

drivers/iommu/iommufd/device.c

1524

unsigned long bytes = (last - iter.cur_iova) + 1;

drivers/iommu/iommufd/device.c

1537

area->pages, iopt_area_start_byte(area, iter.cur_iova),

drivers/iommu/iommufd/device.c

1543

if (!iopt_area_contig_done(&iter))

drivers/iommu/iommufd/double_span.h

32

struct interval_tree_double_span_iter *iter);

drivers/iommu/iommufd/double_span.h

34

struct interval_tree_double_span_iter *iter,

drivers/iommu/iommufd/double_span.h

38

struct interval_tree_double_span_iter *iter);

drivers/iommu/iommufd/io_pagetable.c

33

struct iopt_area *iopt_area_contig_init(struct iopt_area_contig_iter *iter,

drivers/iommu/iommufd/io_pagetable.c

40

iter->cur_iova = iova;

drivers/iommu/iommufd/io_pagetable.c

41

iter->last_iova = last_iova;

drivers/iommu/iommufd/io_pagetable.c

42

iter->area = iopt_area_iter_first(iopt, iova, iova);

drivers/iommu/iommufd/io_pagetable.c

43

if (!iter->area)

drivers/iommu/iommufd/io_pagetable.c

45

if (!iter->area->pages) {

drivers/iommu/iommufd/io_pagetable.c

46

iter->area = NULL;

drivers/iommu/iommufd/io_pagetable.c

49

return iter->area;

drivers/iommu/iommufd/io_pagetable.c

52

struct iopt_area *iopt_area_contig_next(struct iopt_area_contig_iter *iter)

drivers/iommu/iommufd/io_pagetable.c

541

struct iopt_area_contig_iter iter;

drivers/iommu/iommufd/io_pagetable.c

550

iopt_for_each_contig_area(&iter, area, arg->iopt, iova, last_iova) {

drivers/iommu/iommufd/io_pagetable.c

553

ret = ops->read_and_clear_dirty(domain, iter.cur_iova,

drivers/iommu/iommufd/io_pagetable.c

554

last - iter.cur_iova + 1, flags,

drivers/iommu/iommufd/io_pagetable.c

56

if (!iter->area)

drivers/iommu/iommufd/io_pagetable.c

560

if (!iopt_area_contig_done(&iter))

drivers/iommu/iommufd/io_pagetable.c

574

struct iova_bitmap *iter;

drivers/iommu/iommufd/io_pagetable.c

58

last_iova = iopt_area_last_iova(iter->area);

drivers/iommu/iommufd/io_pagetable.c

580

iter = iova_bitmap_alloc(bitmap->iova, bitmap->length,

drivers/iommu/iommufd/io_pagetable.c

583

if (IS_ERR(iter))

drivers/iommu/iommufd/io_pagetable.c

586

iommu_dirty_bitmap_init(&dirty, iter, &gather);

drivers/iommu/iommufd/io_pagetable.c

59

if (iter->last_iova <= last_iova)

drivers/iommu/iommufd/io_pagetable.c

592

iova_bitmap_for_each(iter, &arg, __iommu_read_and_clear_dirty);

drivers/iommu/iommufd/io_pagetable.c

597

iova_bitmap_free(iter);

drivers/iommu/iommufd/io_pagetable.c

62

iter->cur_iova = last_iova + 1;

drivers/iommu/iommufd/io_pagetable.c

63

iter->area = iopt_area_iter_next(iter->area, iter->cur_iova,

drivers/iommu/iommufd/io_pagetable.c

64

iter->last_iova);

drivers/iommu/iommufd/io_pagetable.c

65

if (!iter->area)

drivers/iommu/iommufd/io_pagetable.c

67

if (iter->cur_iova != iopt_area_iova(iter->area) ||

drivers/iommu/iommufd/io_pagetable.c

68

!iter->area->pages) {

drivers/iommu/iommufd/io_pagetable.c

69

iter->area = NULL;

drivers/iommu/iommufd/io_pagetable.c

703

struct iopt_area_contig_iter iter;

drivers/iommu/iommufd/io_pagetable.c

714

iopt_for_each_contig_area(&iter, area, iopt, iova, last_iova) {

drivers/iommu/iommufd/io_pagetable.c

72

return iter->area;

drivers/iommu/iommufd/io_pagetable.c

723

elm->start_byte = iopt_area_start_byte(area, iter.cur_iova);

drivers/iommu/iommufd/io_pagetable.c

725

elm->length = (last - iter.cur_iova) + 1;

drivers/iommu/iommufd/io_pagetable.c

729

if (!iopt_area_contig_done(&iter)) {

drivers/iommu/iommufd/io_pagetable.h

164

struct iopt_area *iopt_area_contig_init(struct iopt_area_contig_iter *iter,

drivers/iommu/iommufd/io_pagetable.h

168

struct iopt_area *iopt_area_contig_next(struct iopt_area_contig_iter *iter);

drivers/iommu/iommufd/io_pagetable.h

170

static inline bool iopt_area_contig_done(struct iopt_area_contig_iter *iter)

drivers/iommu/iommufd/io_pagetable.h

172

return iter->area && iter->last_iova <= iopt_area_last_iova(iter->area);

drivers/iommu/iommufd/io_pagetable.h

180

#define iopt_for_each_contig_area(iter, area, iopt, iova, last_iova) \

drivers/iommu/iommufd/io_pagetable.h

181

for (area = iopt_area_contig_init(iter, iopt, iova, last_iova); area; \

drivers/iommu/iommufd/io_pagetable.h

182

area = iopt_area_contig_next(iter))

drivers/iommu/iommufd/pages.c

107

struct interval_tree_double_span_iter *iter)

drivers/iommu/iommufd/pages.c

112

for (i = 0; i != ARRAY_SIZE(iter->spans); i++) {

drivers/iommu/iommufd/pages.c

113

if (interval_tree_span_iter_done(&iter->spans[i])) {

drivers/iommu/iommufd/pages.c

114

iter->is_used = -1;

drivers/iommu/iommufd/pages.c

118

if (iter->spans[i].is_hole) {

drivers/iommu/iommufd/pages.c

119

last_hole = min(last_hole, iter->spans[i].last_hole);

drivers/iommu/iommufd/pages.c

123

iter->is_used = i + 1;

drivers/iommu/iommufd/pages.c

124

iter->start_used = iter->spans[i].start_used;

drivers/iommu/iommufd/pages.c

125

iter->last_used = min(iter->spans[i].last_used, last_hole);

drivers/iommu/iommufd/pages.c

129

iter->is_used = 0;

drivers/iommu/iommufd/pages.c

130

iter->start_hole = iter->spans[0].start_hole;

drivers/iommu/iommufd/pages.c

131

iter->last_hole =

drivers/iommu/iommufd/pages.c

132

min(iter->spans[0].last_hole, iter->spans[1].last_hole);

drivers/iommu/iommufd/pages.c

136

struct interval_tree_double_span_iter *iter,

drivers/iommu/iommufd/pages.c

142

iter->itrees[0] = itree1;

drivers/iommu/iommufd/pages.c

143

iter->itrees[1] = itree2;

drivers/iommu/iommufd/pages.c

144

for (i = 0; i != ARRAY_SIZE(iter->spans); i++)

drivers/iommu/iommufd/pages.c

145

interval_tree_span_iter_first(&iter->spans[i], iter->itrees[i],

drivers/iommu/iommufd/pages.c

147

interval_tree_double_span_iter_update(iter);

drivers/iommu/iommufd/pages.c

151

struct interval_tree_double_span_iter *iter)

drivers/iommu/iommufd/pages.c

155

if (iter->is_used == -1 ||

drivers/iommu/iommufd/pages.c

156

iter->last_hole == iter->spans[0].last_index) {

drivers/iommu/iommufd/pages.c

157

iter->is_used = -1;

drivers/iommu/iommufd/pages.c

161

for (i = 0; i != ARRAY_SIZE(iter->spans); i++)

drivers/iommu/iommufd/pages.c

163

&iter->spans[i], iter->itrees[i], iter->last_hole + 1);

drivers/iommu/iommufd/pages.c

164

interval_tree_double_span_iter_update(iter);

drivers/iommu/msm_iommu.c

632

struct msm_iommu_dev *iommu = NULL, *iter;

drivers/iommu/msm_iommu.c

637

list_for_each_entry(iter, &qcom_iommu_devices, dev_node) {

drivers/iommu/msm_iommu.c

638

if (iter->dev->of_node == spec->np) {

drivers/iommu/msm_iommu.c

639

iommu = iter;

drivers/irqchip/irq-sifive-plic.c

100

for (unsigned int iter = 1; iter < ACCESS_PRIVATE(priv, total_irqs); iter++)

drivers/irqchip/irq-sifive-plic.c

99

#define for_each_device_irq(iter, priv) \

drivers/md/bcache/alloc.c

419

size_t iter;

drivers/md/bcache/alloc.c

423

for (iter = 0; iter < prio_buckets(ca) * 2; iter++)

drivers/md/bcache/alloc.c

424

BUG_ON(ca->prio_buckets[iter] == (uint64_t) r);

drivers/md/bcache/alloc.c

427

fifo_for_each(i, &ca->free[j], iter)

drivers/md/bcache/alloc.c

429

fifo_for_each(i, &ca->free_inc, iter)

drivers/md/bcache/bset.c

1089

static inline bool btree_iter_end(struct btree_iter *iter)

drivers/md/bcache/bset.c

1091

return !iter->used;

drivers/md/bcache/bset.c

1094

void bch_btree_iter_push(struct btree_iter *iter, struct bkey *k,

drivers/md/bcache/bset.c

1098

BUG_ON(!heap_add(iter,

drivers/md/bcache/bset.c

1104

struct btree_iter_stack *iter,

drivers/md/bcache/bset.c

111

static void bch_btree_iter_next_check(struct btree_iter *iter)

drivers/md/bcache/bset.c

1110

iter->iter.size = ARRAY_SIZE(iter->stack_data);

drivers/md/bcache/bset.c

1111

iter->iter.used = 0;

drivers/md/bcache/bset.c

1114

iter->iter.b = b;

drivers/md/bcache/bset.c

1119

bch_btree_iter_push(&iter->iter, ret, bset_bkey_last(start->data));

drivers/md/bcache/bset.c

1126

struct btree_iter_stack *iter,

drivers/md/bcache/bset.c

1129

return __bch_btree_iter_stack_init(b, iter, search, b->set);

drivers/md/bcache/bset.c

113

struct bkey *k = iter->data->k, *next = bkey_next(k);

drivers/md/bcache/bset.c

1132

static inline struct bkey *__bch_btree_iter_next(struct btree_iter *iter,

drivers/md/bcache/bset.c

1138

if (!btree_iter_end(iter)) {

drivers/md/bcache/bset.c

1139

bch_btree_iter_next_check(iter);

drivers/md/bcache/bset.c

1141

ret = iter->data->k;

drivers/md/bcache/bset.c

1142

iter->data->k = bkey_next(iter->data->k);

drivers/md/bcache/bset.c

1144

if (iter->data->k > iter->data->end) {

drivers/md/bcache/bset.c

1146

iter->data->k = iter->data->end;

drivers/md/bcache/bset.c

1149

if (iter->data->k == iter->data->end)

drivers/md/bcache/bset.c

115

if (next < iter->data->end &&

drivers/md/bcache/bset.c

1150

heap_pop(iter, b, cmp);

drivers/md/bcache/bset.c

1152

heap_sift(iter, 0, cmp);

drivers/md/bcache/bset.c

1158

struct bkey *bch_btree_iter_next(struct btree_iter *iter)

drivers/md/bcache/bset.c

116

bkey_cmp(k, iter->b->ops->is_extents ?

drivers/md/bcache/bset.c

1160

return __bch_btree_iter_next(iter, btree_iter_cmp);

drivers/md/bcache/bset.c

1164

struct bkey *bch_btree_iter_next_filter(struct btree_iter *iter,

drivers/md/bcache/bset.c

1170

ret = bch_btree_iter_next(iter);

drivers/md/bcache/bset.c

118

bch_dump_bucket(iter->b);

drivers/md/bcache/bset.c

1195

struct btree_iter *iter,

drivers/md/bcache/bset.c

1206

for (i = iter->used / 2 - 1; i >= 0; --i)

drivers/md/bcache/bset.c

1207

heap_sift(iter, i, b->ops->sort_cmp);

drivers/md/bcache/bset.c

1209

while (!btree_iter_end(iter)) {

drivers/md/bcache/bset.c

1211

k = b->ops->sort_fixup(iter, &tmp.k);

drivers/md/bcache/bset.c

1216

k = __bch_btree_iter_next(iter, b->ops->sort_cmp);

drivers/md/bcache/bset.c

1235

static void __btree_sort(struct btree_keys *b, struct btree_iter *iter,

drivers/md/bcache/bset.c

125

static inline void bch_btree_iter_next_check(struct btree_iter *iter) {}

drivers/md/bcache/bset.c

1256

btree_mergesort(b, out, iter, fixup, false);

drivers/md/bcache/bset.c

1296

struct btree_iter_stack iter;

drivers/md/bcache/bset.c

1299

__bch_btree_iter_stack_init(b, &iter, NULL, &b->set[start]);

drivers/md/bcache/bset.c

1310

__btree_sort(b, &iter.iter, start, order, false, state);

drivers/md/bcache/bset.c

1316

struct btree_iter *iter,

drivers/md/bcache/bset.c

1319

__btree_sort(b, iter, 0, b->page_order, true, state);

drivers/md/bcache/bset.c

1326

struct btree_iter_stack iter;

drivers/md/bcache/bset.c

1328

bch_btree_iter_stack_init(b, &iter, NULL);

drivers/md/bcache/bset.c

1330

btree_mergesort(b, new->set->data, &iter.iter, false, true);

drivers/md/bcache/bset.c

57

struct btree_iter_stack iter;

drivers/md/bcache/bset.c

61

for_each_key(b, k, &iter)

drivers/md/bcache/bset.c

70

struct btree_iter_stack iter;

drivers/md/bcache/bset.c

73

for_each_key(b, k, &iter) {

drivers/md/bcache/bset.c

882

struct btree_iter_stack iter;

drivers/md/bcache/bset.c

898

m = bch_btree_iter_stack_init(b, &iter, preceding_key_p);

drivers/md/bcache/bset.c

900

if (b->ops->insert_fixup(b, k, &iter.iter, replace_key))

drivers/md/bcache/bset.h

192

struct bkey *(*sort_fixup)(struct btree_iter *iter,

drivers/md/bcache/bset.h

196

struct btree_iter *iter,

drivers/md/bcache/bset.h

331

TRAILING_OVERLAP(struct btree_iter, iter, data,

drivers/md/bcache/bset.h

335

static_assert(offsetof(struct btree_iter_stack, iter.data) ==

drivers/md/bcache/bset.h

340

struct bkey *bch_btree_iter_next(struct btree_iter *iter);

drivers/md/bcache/bset.h

341

struct bkey *bch_btree_iter_next_filter(struct btree_iter *iter,

drivers/md/bcache/bset.h

345

void bch_btree_iter_push(struct btree_iter *iter, struct bkey *k,

drivers/md/bcache/bset.h

348

struct btree_iter_stack *iter,

drivers/md/bcache/bset.h

366

((k) = bch_btree_iter_next_filter(&((stack_iter)->iter), (b), \

drivers/md/bcache/bset.h

371

((k) = bch_btree_iter_next(&((stack_iter)->iter)));)

drivers/md/bcache/bset.h

391

struct btree_iter *iter,

drivers/md/bcache/btree.c

1310

struct btree_iter_stack iter;

drivers/md/bcache/btree.c

1315

for_each_key_filter(&b->keys, k, &iter, bch_ptr_invalid) {

drivers/md/bcache/btree.c

152

struct btree_iter *iter;

drivers/md/bcache/btree.c

1571

struct btree_iter_stack iter;

drivers/md/bcache/btree.c

1574

for_each_key_filter(&b->keys, k, &iter, bch_ptr_bad)

drivers/md/bcache/btree.c

159

iter = mempool_alloc(&b->c->fill_iter, GFP_NOIO);

drivers/md/bcache/btree.c

160

iter->size = b->c->cache->sb.bucket_size / b->c->cache->sb.block_size;

drivers/md/bcache/btree.c

161

iter->used = 0;

drivers/md/bcache/btree.c

1612

struct btree_iter_stack iter;

drivers/md/bcache/btree.c

1616

bch_btree_iter_stack_init(&b->keys, &iter, &b->c->gc_done);

drivers/md/bcache/btree.c

1622

k = bch_btree_iter_next_filter(&iter.iter, &b->keys,

drivers/md/bcache/btree.c

164

iter->b = &b->keys;

drivers/md/bcache/btree.c

1917

struct btree_iter_stack iter;

drivers/md/bcache/btree.c

1919

for_each_key_filter(&b->keys, k, &iter, bch_ptr_invalid)

drivers/md/bcache/btree.c

1925

bch_btree_iter_stack_init(&b->keys, &iter, NULL);

drivers/md/bcache/btree.c

1928

k = bch_btree_iter_next_filter(&iter.iter, &b->keys,

drivers/md/bcache/btree.c

1956

struct btree_iter_stack iter;

drivers/md/bcache/btree.c

1965

bch_btree_iter_stack_init(&c->root->keys, &iter, NULL);

drivers/md/bcache/btree.c

1966

k = bch_btree_iter_next_filter(&iter.iter, &c->root->keys, bch_ptr_bad);

drivers/md/bcache/btree.c

1984

k = bch_btree_iter_next_filter(&iter.iter,

drivers/md/bcache/btree.c

202

bch_btree_iter_push(iter, i->start, bset_bkey_last(i));

drivers/md/bcache/btree.c

2057

struct btree_iter_stack iter;

drivers/md/bcache/btree.c

2061

for_each_key_filter(&c->root->keys, k, &iter, bch_ptr_invalid)

drivers/md/bcache/btree.c

214

bch_btree_sort_and_fix_extents(&b->keys, iter, &b->c->sort);

drivers/md/bcache/btree.c

226

mempool_free(iter, &b->c->fill_iter);

drivers/md/bcache/btree.c

2553

struct btree_iter_stack iter;

drivers/md/bcache/btree.c

2555

bch_btree_iter_stack_init(&b->keys, &iter, from);

drivers/md/bcache/btree.c

2557

while ((k = bch_btree_iter_next_filter(&iter.iter, &b->keys,

drivers/md/bcache/btree.c

2586

struct btree_iter_stack iter;

drivers/md/bcache/btree.c

2588

bch_btree_iter_stack_init(&b->keys, &iter, from);

drivers/md/bcache/btree.c

2590

while ((k = bch_btree_iter_next_filter(&iter.iter, &b->keys,

drivers/md/bcache/btree.h

204

#define for_each_cached_btree(b, c, iter) \

drivers/md/bcache/btree.h

205

for (iter = 0; \

drivers/md/bcache/btree.h

206

iter < ARRAY_SIZE((c)->bucket_hash); \

drivers/md/bcache/btree.h

207

iter++) \

drivers/md/bcache/btree.h

208

hlist_for_each_entry_rcu((b), (c)->bucket_hash + iter, hash)

drivers/md/bcache/debug.c

113

struct bvec_iter iter, citer = { 0 };

drivers/md/bcache/debug.c

129

bio_for_each_segment(bv, bio, iter) {

drivers/md/bcache/extents.c

229

struct btree_iter *iter,

drivers/md/bcache/extents.c

266

static struct bkey *bch_extent_sort_fixup(struct btree_iter *iter,

drivers/md/bcache/extents.c

269

while (iter->used > 1) {

drivers/md/bcache/extents.c

270

struct btree_iter_set *top = iter->data, *i = top + 1;

drivers/md/bcache/extents.c

272

if (iter->used > 2 &&

drivers/md/bcache/extents.c

280

sort_key_next(iter, i);

drivers/md/bcache/extents.c

281

heap_sift(iter, i - top, bch_extent_sort_cmp);

drivers/md/bcache/extents.c

287

sort_key_next(iter, i);

drivers/md/bcache/extents.c

291

heap_sift(iter, i - top, bch_extent_sort_cmp);

drivers/md/bcache/extents.c

30

static void sort_key_next(struct btree_iter *iter,

drivers/md/bcache/extents.c

301

heap_sift(iter, 0, bch_extent_sort_cmp);

drivers/md/bcache/extents.c

325

struct btree_iter *iter,

drivers/md/bcache/extents.c

337

struct bkey *k = bch_btree_iter_next(iter);

drivers/md/bcache/extents.c

36

*i = iter->data[--iter->used];

drivers/md/bcache/request.c

43

struct bvec_iter iter;

drivers/md/bcache/request.c

46

bio_for_each_segment(bv, bio, iter) {

drivers/md/bcache/sysfs.c

662

struct btree_iter_stack iter;

drivers/md/bcache/sysfs.c

673

for_each_key_filter(&b->keys, k, &iter, bch_ptr_bad)

drivers/md/bcache/util.h

119

#define fifo_for_each(c, fifo, iter) \

drivers/md/bcache/util.h

120

for (iter = (fifo)->front; \

drivers/md/bcache/util.h

121

c = (fifo)->data[iter], iter != (fifo)->back; \

drivers/md/bcache/util.h

122

iter = (iter + 1) & (fifo)->mask)

drivers/md/bcache/writeback.c

1001

k, &iter, bch_ptr_invalid) {

drivers/md/bcache/writeback.c

910

struct btree_iter_stack iter;

drivers/md/bcache/writeback.c

917

bch_btree_iter_stack_init(&c->root->keys, &iter, NULL);

drivers/md/bcache/writeback.c

918

k = bch_btree_iter_next_filter(&iter.iter, &c->root->keys, bch_ptr_bad);

drivers/md/bcache/writeback.c

932

k = bch_btree_iter_next_filter(&iter.iter,

drivers/md/bcache/writeback.c

981

struct btree_iter_stack iter;

drivers/md/dm-ebs-target.c

126

struct bvec_iter iter;

drivers/md/dm-ebs-target.c

128

bio_for_each_bvec(bv, bio, iter) {

drivers/md/dm-ebs-target.c

129

rr = __ebs_rw_bvec(ec, op, &bv, &iter);

drivers/md/dm-ebs-target.c

66

struct bvec_iter *iter)

drivers/md/dm-ebs-target.c

72

unsigned int buf_off = to_bytes(__block_mod(iter->bi_sector, ec->u_bs));

drivers/md/dm-ebs-target.c

73

sector_t block = __sector_to_block(ec, iter->bi_sector);

drivers/md/dm-flakey.c

364

struct bvec_iter iter;

drivers/md/dm-flakey.c

371

__bio_for_each_segment(bvec, bio, iter, start) {

drivers/md/dm-flakey.c

372

if (bio_iter_len(bio, iter) > corrupt_bio_byte) {

drivers/md/dm-flakey.c

384

corrupt_bio_byte -= bio_iter_len(bio, iter);

drivers/md/dm-flakey.c

432

struct bvec_iter iter = bio->bi_iter;

drivers/md/dm-flakey.c

475

struct bio_vec bvec = bvec_iter_bvec(bio->bi_io_vec, iter);

drivers/md/dm-flakey.c

481

bvec_iter_advance(bio->bi_io_vec, &iter, this_step);

drivers/md/dm-integrity.c

1799

struct bvec_iter iter;

drivers/md/dm-integrity.c

1812

__bio_for_each_segment(bv, bio, iter, dio->bio_details.bi_iter) {

drivers/md/dm-integrity.c

1883

struct bvec_iter iter;

drivers/md/dm-integrity.c

1940

__bio_for_each_segment(bv, bio, iter, dio->bio_details.bi_iter) {

drivers/md/dm-integrity.c

1987

struct bvec_iter iter;

drivers/md/dm-integrity.c

1993

bip_for_each_vec(biv, bip, iter) {

drivers/md/dm-integrity.c

2033

struct bvec_iter iter;

drivers/md/dm-integrity.c

2036

bio_for_each_segment(bv, bio, iter) {

drivers/md/dm-io-rewind.c

111

struct bvec_iter *iter, unsigned int bytes)

drivers/md/dm-io-rewind.c

113

iter->bi_sector -= bytes >> 9;

drivers/md/dm-io-rewind.c

117

iter->bi_size += bytes;

drivers/md/dm-io-rewind.c

119

dm_bvec_iter_rewind(bio->bi_io_vec, iter, bytes);

drivers/md/dm-io-rewind.c

13

struct bvec_iter *iter,

drivers/md/dm-io-rewind.c

18

iter->bi_size += bytes;

drivers/md/dm-io-rewind.c

19

if (bytes <= iter->bi_bvec_done) {

drivers/md/dm-io-rewind.c

20

iter->bi_bvec_done -= bytes;

drivers/md/dm-io-rewind.c

24

bytes -= iter->bi_bvec_done;

drivers/md/dm-io-rewind.c

25

idx = iter->bi_idx - 1;

drivers/md/dm-io-rewind.c

34

iter->bi_size -= bytes;

drivers/md/dm-io-rewind.c

35

iter->bi_bvec_done = 0;

drivers/md/dm-io-rewind.c

36

iter->bi_idx = 0;

drivers/md/dm-io-rewind.c

40

iter->bi_idx = idx;

drivers/md/dm-io-rewind.c

41

iter->bi_bvec_done = bv[idx].bv_len - bytes;

drivers/md/dm-log-writes.c

649

struct bvec_iter iter;

drivers/md/dm-log-writes.c

733

bio_for_each_segment(bv, bio, iter) {

drivers/md/dm-pcache/segment.c

11

struct iov_iter iter;

drivers/md/dm-pcache/segment.c

15

iov_iter_bvec(&iter, ITER_DEST, &bio->bi_io_vec[bio->bi_iter.bi_idx],

drivers/md/dm-pcache/segment.c

17

iter.iov_offset = bio->bi_iter.bi_bvec_done;

drivers/md/dm-pcache/segment.c

19

iov_iter_advance(&iter, bio_off);

drivers/md/dm-pcache/segment.c

22

copied = _copy_mc_to_iter(src, data_len, &iter);

drivers/md/dm-pcache/segment.c

32

struct iov_iter iter;

drivers/md/dm-pcache/segment.c

36

iov_iter_bvec(&iter, ITER_SOURCE, &bio->bi_io_vec[bio->bi_iter.bi_idx],

drivers/md/dm-pcache/segment.c

38

iter.iov_offset = bio->bi_iter.bi_bvec_done;

drivers/md/dm-pcache/segment.c

40

iov_iter_advance(&iter, bio_off);

drivers/md/dm-pcache/segment.c

43

copied = _copy_from_iter_flushcache(dst, data_len, &iter);

drivers/md/dm-vdo/data-vio.c

298

struct bvec_iter iter;

drivers/md/dm-vdo/data-vio.c

300

bio_for_each_segment(biovec, bio, iter) {

drivers/md/dm-vdo/data-vio.c

520

struct bvec_iter iter;

drivers/md/dm-vdo/data-vio.c

522

bio_for_each_segment(biovec, bio, iter) {

drivers/md/dm-verity-target.c

516

struct bvec_iter *iter;

drivers/md/dm-verity-target.c

528

iter_copy = io->iter;

drivers/md/dm-verity-target.c

529

iter = &iter_copy;

drivers/md/dm-verity-target.c

531

iter = &io->iter;

drivers/md/dm-verity-target.c

534

b++, bio_advance_iter_single(bio, iter, block_size)) {

drivers/md/dm-verity-target.c

552

bv = bio_iter_iovec(bio, *iter);

drivers/md/dm-verity-target.c

819

io->iter = bio->bi_iter;

drivers/md/dm-verity.h

100

struct bvec_iter iter;

drivers/md/md.c

10854

struct md_rdev *rdev = NULL, *iter;

drivers/md/md.c

10858

rdev_for_each_rcu(iter, mddev) {

drivers/md/md.c

10859

if (iter->desc_nr == nr) {

drivers/md/md.c

10860

rdev = iter;

drivers/md/md.c

2753

struct md_rdev *rdev = NULL, *iter;

drivers/md/md.c

2758

rdev_for_each(iter, mddev)

drivers/md/md.c

2759

if ((iter->raid_disk >= 0) && !test_bit(Faulty, &iter->flags)) {

drivers/md/md.c

2760

rdev = iter;

drivers/md/raid5.c

1382

struct bvec_iter iter;

drivers/md/raid5.c

1398

bio_for_each_segment(bvl, bio, iter) {

drivers/media/mc/mc-device.c

580

struct media_pad *iter;

drivers/media/mc/mc-device.c

596

media_entity_for_each_pad(entity, iter)

drivers/media/mc/mc-device.c

597

media_gobj_destroy(&iter->graph_obj);

drivers/media/mc/mc-device.c

609

struct media_pad *iter;

drivers/media/mc/mc-device.c

638

media_entity_for_each_pad(entity, iter)

drivers/media/mc/mc-device.c

639

media_gobj_create(mdev, MEDIA_GRAPH_PAD, &iter->graph_obj);

drivers/media/mc/mc-entity.c

1003

struct media_pipeline_pad_iter *iter,

drivers/media/mc/mc-entity.c

1007

iter->cursor = pipe->pads.next;

drivers/media/mc/mc-entity.c

1009

if (iter->cursor == &pipe->pads)

drivers/media/mc/mc-entity.c

1012

pad = list_entry(iter->cursor, struct media_pipeline_pad, list)->pad;

drivers/media/mc/mc-entity.c

1013

iter->cursor = iter->cursor->next;

drivers/media/mc/mc-entity.c

1020

struct media_pipeline_entity_iter *iter)

drivers/media/mc/mc-entity.c

1022

return media_entity_enum_init(&iter->ent_enum, pipe->mdev);

drivers/media/mc/mc-entity.c

1026

void media_pipeline_entity_iter_cleanup(struct media_pipeline_entity_iter *iter)

drivers/media/mc/mc-entity.c

1028

media_entity_enum_cleanup(&iter->ent_enum);

drivers/media/mc/mc-entity.c

1034

struct media_pipeline_entity_iter *iter,

drivers/media/mc/mc-entity.c

1038

iter->cursor = pipe->pads.next;

drivers/media/mc/mc-entity.c

1040

while (iter->cursor != &pipe->pads) {

drivers/media/mc/mc-entity.c

1044

ppad = list_entry(iter->cursor, struct media_pipeline_pad, list);

drivers/media/mc/mc-entity.c

1046

iter->cursor = iter->cursor->next;

drivers/media/mc/mc-entity.c

1048

if (!media_entity_enum_test_and_set(&iter->ent_enum, entity))

drivers/media/mc/mc-entity.c

198

struct media_pad *iter;

drivers/media/mc/mc-entity.c

211

media_entity_for_each_pad(entity, iter) {

drivers/media/mc/mc-entity.c

212

iter->entity = entity;

drivers/media/mc/mc-entity.c

213

iter->index = i++;

drivers/media/mc/mc-entity.c

215

if (hweight32(iter->flags & (MEDIA_PAD_FL_SINK |

drivers/media/mc/mc-entity.c

223

&iter->graph_obj);

drivers/media/mc/mc-entity.c

227

media_entity_for_each_pad(entity, iter)

drivers/media/mc/mc-entity.c

228

media_gobj_destroy(&iter->graph_obj);

drivers/media/platform/broadcom/bcm2835-unicam.c

1671

struct media_pipeline_pad_iter iter;

drivers/media/platform/broadcom/bcm2835-unicam.c

1696

media_pipeline_for_each_pad(&unicam->pipe.pipe, &iter, pad) {

drivers/media/platform/qcom/iris/iris_hfi_gen1_response.c

401

struct iris_buffer *buf, *iter;

drivers/media/platform/qcom/iris/iris_hfi_gen1_response.c

447

list_for_each_entry(iter, &buffers->list, list) {

drivers/media/platform/qcom/iris/iris_hfi_gen1_response.c

448

if (!(iter->attr & BUF_ATTR_QUEUED))

drivers/media/platform/qcom/iris/iris_hfi_gen1_response.c

451

found = (iter->index == output_tag &&

drivers/media/platform/qcom/iris/iris_hfi_gen1_response.c

452

iter->data_offset == offset);

drivers/media/platform/qcom/iris/iris_hfi_gen1_response.c

455

buf = iter;

drivers/media/platform/qcom/iris/iris_hfi_gen2_response.c

435

struct iris_buffer *buf, *iter;

drivers/media/platform/qcom/iris/iris_hfi_gen2_response.c

438

list_for_each_entry(iter, &buffers->list, list) {

drivers/media/platform/qcom/iris/iris_hfi_gen2_response.c

439

if (iter->device_addr == buffer->base_address) {

drivers/media/platform/qcom/iris/iris_hfi_gen2_response.c

441

buf = iter;

drivers/media/platform/qcom/iris/iris_vidc.c

45

struct iris_inst *iter;

drivers/media/platform/qcom/iris/iris_vidc.c

50

list_for_each_entry(iter, &core->instances, list)

drivers/media/platform/qcom/iris/iris_vidc.c

62

struct iris_inst *iter, *temp;

drivers/media/platform/qcom/iris/iris_vidc.c

65

list_for_each_entry_safe(iter, temp, &core->instances, list) {

drivers/media/platform/qcom/iris/iris_vidc.c

66

if (iter->session_id == inst->session_id) {

drivers/media/platform/qcom/iris/iris_vidc.c

67

list_del_init(&iter->list);

drivers/media/platform/rockchip/rga/rga-buf.c

23

struct sg_dma_page_iter iter;

drivers/media/platform/rockchip/rga/rga-buf.c

28

for_each_sgtable_dma_page(sgt, &iter, 0) {

drivers/media/platform/rockchip/rga/rga-buf.c

31

addr = sg_page_iter_dma_address(&iter);

drivers/media/platform/ti/omap3isp/ispvideo.c

228

struct media_pipeline_entity_iter iter;

drivers/media/platform/ti/omap3isp/ispvideo.c

233

ret = media_pipeline_entity_iter_init(&pipe->pipe, &iter);

drivers/media/platform/ti/omap3isp/ispvideo.c

237

media_pipeline_for_each_entity(&pipe->pipe, &iter, entity) {

drivers/media/platform/ti/omap3isp/ispvideo.c

256

media_pipeline_entity_iter_cleanup(&iter);

drivers/media/platform/xilinx/xilinx-dma.c

177

struct media_pipeline_pad_iter iter;

drivers/media/platform/xilinx/xilinx-dma.c

183

media_pipeline_for_each_pad(&pipe->pipe, &iter, pad) {

drivers/media/usb/uvc/uvc_ctrl.c

3036

struct uvc_entity *entity, *iter;

drivers/media/usb/uvc/uvc_ctrl.c

3047

list_for_each_entry(iter, &chain->entities, chain) {

drivers/media/usb/uvc/uvc_ctrl.c

3048

if (UVC_ENTITY_TYPE(iter) == UVC_VC_EXTENSION_UNIT &&

drivers/media/usb/uvc/uvc_ctrl.c

3049

iter->id == xqry->unit) {

drivers/media/usb/uvc/uvc_ctrl.c

3050

entity = iter;

drivers/misc/bcm-vk/bcm_vk_msg.c

1012

struct bcm_vk_wkent *entry = NULL, *iter;

drivers/misc/bcm-vk/bcm_vk_msg.c

1031

list_for_each_entry(iter, &chan->pendq[q_num], node) {

drivers/misc/bcm-vk/bcm_vk_msg.c

1032

if (iter->ctx->idx == ctx->idx) {

drivers/misc/bcm-vk/bcm_vk_msg.c

1034

(iter->to_h_blks * VK_MSGQ_BLK_SIZE)) {

drivers/misc/bcm-vk/bcm_vk_msg.c

1035

list_del(&iter->node);

drivers/misc/bcm-vk/bcm_vk_msg.c

1037

entry = iter;

drivers/misc/bcm-vk/bcm_vk_msg.c

1040

tmp_msg = iter->to_h_msg[0];

drivers/misc/bcm-vk/bcm_vk_msg.c

1041

tmp_usr_msg_id = iter->usr_msg_id;

drivers/misc/bcm-vk/bcm_vk_msg.c

1042

tmp_blks = iter->to_h_blks;

drivers/misc/bcm-vk/bcm_vk_msg.c

760

struct bcm_vk_wkent *entry = NULL, *iter;

drivers/misc/bcm-vk/bcm_vk_msg.c

763

list_for_each_entry(iter, &chan->pendq[q_num], node) {

drivers/misc/bcm-vk/bcm_vk_msg.c

764

if (get_msg_id(&iter->to_v_msg[0]) == msg_id) {

drivers/misc/bcm-vk/bcm_vk_msg.c

765

list_del(&iter->node);

drivers/misc/bcm-vk/bcm_vk_msg.c

766

entry = iter;

drivers/misc/fastrpc.c

1905

struct fastrpc_buf *buf = NULL, *iter, *b;

drivers/misc/fastrpc.c

1913

list_for_each_entry_safe(iter, b, &fl->mmaps, node) {

drivers/misc/fastrpc.c

1914

if ((iter->raddr == req.vaddrout) && (iter->size == req.size)) {

drivers/misc/fastrpc.c

1915

buf = iter;

drivers/misc/fastrpc.c

2035

struct fastrpc_map *map = NULL, *iter, *m;

drivers/misc/fastrpc.c

2042

list_for_each_entry_safe(iter, m, &fl->maps, node) {

drivers/misc/fastrpc.c

2043

if ((req->fd < 0 || iter->fd == req->fd) && (iter->raddr == req->vaddr)) {

drivers/misc/fastrpc.c

2044

map = iter;

drivers/misc/vmw_vmci/vmci_context.c

648

struct vmci_handle_list *notifier = NULL, *iter, *tmp;

drivers/misc/vmw_vmci/vmci_context.c

658

list_for_each_entry_safe(iter, tmp,

drivers/misc/vmw_vmci/vmci_context.c

660

if (vmci_handle_is_equal(iter->handle, handle)) {

drivers/misc/vmw_vmci/vmci_context.c

661

list_del_rcu(&iter->node);

drivers/misc/vmw_vmci/vmci_context.c

663

notifier = iter;

drivers/mmc/host/dw_mmc-exynos.c

498

const u8 iter = 8;

drivers/mmc/host/dw_mmc-exynos.c

502

for (i = 0; i < iter; i++) {

drivers/mmc/host/dw_mmc-exynos.c

510

for (i = 0; i < iter; i++) {

drivers/mmc/host/dw_mmc-exynos.c

523

for (i = 0; i < iter; i++) {

drivers/mmc/host/sdhci-tegra.c

1014

u8 iter = TRIES_256;

drivers/mmc/host/sdhci-tegra.c

1024

iter = TRIES_128;

drivers/mmc/host/sdhci-tegra.c

1029

iter = TRIES_128;

drivers/mmc/host/sdhci-tegra.c

1045

val |= (iter << SDHCI_VNDR_TUN_CTRL0_TUN_ITER_SHIFT |

drivers/mmc/host/sdhci-tegra.c

1051

host->tuning_loop_count = (iter == TRIES_128) ? 128 : 256;

drivers/mtd/devices/mtd_intel_dg.c

390

u32 iter = 0;

drivers/mtd/devices/mtd_intel_dg.c

401

++iter < NVM_NON_POSTED_ERASE_DONE_ITER) {

drivers/mtd/mtd_blkdevs.c

49

struct req_iterator iter;

drivers/mtd/mtd_blkdevs.c

76

rq_for_each_segment(bvec, req, iter)

drivers/mtd/mtd_blkdevs.c

83

rq_for_each_segment(bvec, req, iter)

drivers/mtd/mtdcore.c

1944

int (*iter)(struct mtd_info *,

drivers/mtd/mtdcore.c

1953

ret = iter(mtd, section, oobregion);

drivers/mtd/mtdcore.c

2013

int (*iter)(struct mtd_info *,

drivers/mtd/mtdcore.c

2021

&oobregion, iter);

drivers/mtd/mtdcore.c

2034

ret = iter(mtd, ++section, &oobregion);

drivers/mtd/mtdcore.c

2056

int (*iter)(struct mtd_info *,

drivers/mtd/mtdcore.c

2064

&oobregion, iter);

drivers/mtd/mtdcore.c

2077

ret = iter(mtd, ++section, &oobregion);

drivers/mtd/mtdcore.c

2093

int (*iter)(struct mtd_info *,

drivers/mtd/mtdcore.c

2101

ret = iter(mtd, section++, &oobregion);

drivers/mtd/mtdcore.c

398

int (*iter)(struct mtd_info *, int section,

drivers/mtd/mtdcore.c

408

err = iter(mtd, section, &region);

drivers/mtd/mtdoops.c

305

struct kmsg_dump_iter iter;

drivers/mtd/mtdoops.c

311

kmsg_dump_rewind(&iter);

drivers/mtd/mtdoops.c

315

kmsg_dump_get_buffer(&iter, true,

drivers/mtd/nand/spi/core.c

1050

struct nand_io_iter iter;

drivers/mtd/nand/spi/core.c

1059

nanddev_io_for_each_page(nand, NAND_PAGE_WRITE, to, ops, &iter) {

drivers/mtd/nand/spi/core.c

1061

iter.req.mode = MTD_OPS_RAW;

drivers/mtd/nand/spi/core.c

1063

ret = spinand_select_target(spinand, iter.req.pos.target);

drivers/mtd/nand/spi/core.c

1067

ret = spinand_write_page(spinand, &iter.req);

drivers/mtd/nand/spi/core.c

1071

ops->retlen += iter.req.datalen;

drivers/mtd/nand/spi/core.c

1072

ops->oobretlen += iter.req.ooblen;

drivers/mtd/nand/spi/core.c

821

struct nand_io_iter iter;

drivers/mtd/nand/spi/core.c

832

nanddev_io_for_each_page(nand, NAND_PAGE_READ, from, ops, &iter) {

drivers/mtd/nand/spi/core.c

834

iter.req.mode = MTD_OPS_RAW;

drivers/mtd/nand/spi/core.c

836

ret = spinand_select_target(spinand, iter.req.pos.target);

drivers/mtd/nand/spi/core.c

841

ret = spinand_read_page(spinand, &iter.req);

drivers/mtd/nand/spi/core.c

867

ops->retlen += iter.req.datalen;

drivers/mtd/nand/spi/core.c

868

ops->oobretlen += iter.req.ooblen;

drivers/mtd/nand/spi/core.c

891

struct nand_io_iter iter;

drivers/mtd/nand/spi/core.c

913

nanddev_io_for_each_block(nand, NAND_PAGE_READ, from, ops, &iter) {

drivers/mtd/nand/spi/core.c

914

ret = spinand_select_target(spinand, iter.req.pos.target);

drivers/mtd/nand/spi/core.c

918

ret = nand_ecc_prepare_io_req(nand, &iter.req);

drivers/mtd/nand/spi/core.c

922

ret = spinand_load_page_op(spinand, &iter.req);

drivers/mtd/nand/spi/core.c

931

ret = spinand_read_from_cache_op(spinand, &iter.req);

drivers/mtd/nand/spi/core.c

935

ops->retlen += iter.req.datalen;

drivers/mtd/nand/spi/core.c

943

ret = nand_ecc_finish_io_req(nand, &iter.req);

drivers/mtd/ubi/block.c

190

struct req_iterator iter;

drivers/mtd/ubi/block.c

222

rq_for_each_segment(bvec, req, iter)

drivers/mtd/ubi/debug.c

508

static int eraseblk_count_seq_show(struct seq_file *s, void *iter)

drivers/mtd/ubi/debug.c

512

int *block_number = iter;

drivers/net/bonding/bond_3ad.c

1572

struct list_head *iter;

drivers/net/bonding/bond_3ad.c

1636

bond_for_each_slave(bond, slave, iter) {

drivers/net/bonding/bond_3ad.c

1868

struct list_head *iter;

drivers/net/bonding/bond_3ad.c

1877

bond_for_each_slave_rcu(bond, slave, iter) {

drivers/net/bonding/bond_3ad.c

1923

bond_for_each_slave_rcu(bond, slave, iter) {

drivers/net/bonding/bond_3ad.c

2333

struct list_head *iter;

drivers/net/bonding/bond_3ad.c

2368

bond_for_each_slave(bond, slave_iter, iter) {

drivers/net/bonding/bond_3ad.c

2445

bond_for_each_slave(bond, slave_iter, iter) {

drivers/net/bonding/bond_3ad.c

2491

struct list_head *iter;

drivers/net/bonding/bond_3ad.c

2505

bond_for_each_slave(bond, slave, iter) {

drivers/net/bonding/bond_3ad.c

2554

struct list_head *iter;

drivers/net/bonding/bond_3ad.c

2590

bond_for_each_slave_rcu(bond, slave, iter) {

drivers/net/bonding/bond_3ad.c

2611

bond_for_each_slave_rcu(bond, slave, iter) {

drivers/net/bonding/bond_3ad.c

2885

struct list_head *iter;

drivers/net/bonding/bond_3ad.c

2889

bond_for_each_slave_rcu(bond, slave, iter) {

drivers/net/bonding/bond_3ad.c

2956

struct list_head *iter;

drivers/net/bonding/bond_3ad.c

2962

bond_for_each_slave(bond, slave, iter) {

drivers/net/bonding/bond_3ad.c

2981

struct list_head *iter;

drivers/net/bonding/bond_3ad.c

2987

bond_for_each_slave(bond, slave, iter) {

drivers/net/bonding/bond_3ad.c

874

struct list_head *iter;

drivers/net/bonding/bond_3ad.c

877

bond_for_each_slave_rcu(bond, slave, iter)

drivers/net/bonding/bond_alb.c

1167

struct list_head *iter;

drivers/net/bonding/bond_alb.c

1192

bond_for_each_slave(bond, tmp_slave1, iter) {

drivers/net/bonding/bond_alb.c

1242

struct list_head *iter;

drivers/net/bonding/bond_alb.c

1250

bond_for_each_slave(bond, slave, iter) {

drivers/net/bonding/bond_alb.c

1271

bond_for_each_slave(bond, rollback_slave, iter) {

drivers/net/bonding/bond_alb.c

1537

struct list_head *iter;

drivers/net/bonding/bond_alb.c

1555

bond_for_each_slave_rcu(bond, slave, iter) {

drivers/net/bonding/bond_alb.c

1571

bond_for_each_slave_rcu(bond, slave, iter) {

drivers/net/bonding/bond_alb.c

170

struct list_head *iter;

drivers/net/bonding/bond_alb.c

177

bond_for_each_slave_rcu(bond, slave, iter) {

drivers/net/bonding/bond_alb.c

310

struct list_head *iter;

drivers/net/bonding/bond_alb.c

313

bond_for_each_slave_rcu(bond, slave, iter) {

drivers/net/bonding/bond_main.c

1099

struct list_head *iter;

drivers/net/bonding/bond_main.c

1102

bond_for_each_slave(bond, slave, iter) {

drivers/net/bonding/bond_main.c

1155

struct list_head *iter;

drivers/net/bonding/bond_main.c

1162

bond_for_each_slave(bond, slave, iter) {

drivers/net/bonding/bond_main.c

1427

struct list_head *iter;

drivers/net/bonding/bond_main.c

1434

bond_for_each_slave_rcu(bond, slave, iter) {

drivers/net/bonding/bond_main.c

1454

struct list_head *iter;

drivers/net/bonding/bond_main.c

1457

bond_for_each_slave(bond, slave, iter)

drivers/net/bonding/bond_main.c

1465

struct list_head *iter;

drivers/net/bonding/bond_main.c

1469

bond_for_each_slave(bond, slave, iter) {

drivers/net/bonding/bond_main.c

1497

struct list_head *iter;

drivers/net/bonding/bond_main.c

1504

bond_for_each_slave(bond, slave, iter) {

drivers/net/bonding/bond_main.c

1869

struct list_head *iter;

drivers/net/bonding/bond_main.c

1879

bond_for_each_slave(bond, slave, iter)

drivers/net/bonding/bond_main.c

2641

struct list_head *iter;

drivers/net/bonding/bond_main.c

2645

bond_for_each_slave(bond, slave, iter) {

drivers/net/bonding/bond_main.c

2663

struct list_head *iter;

drivers/net/bonding/bond_main.c

2677

bond_for_each_slave_rcu(bond, slave, iter) {

drivers/net/bonding/bond_main.c

2788

struct list_head *iter;

drivers/net/bonding/bond_main.c

2793

bond_for_each_slave(bond, slave, iter) {

drivers/net/bonding/bond_main.c

2899

struct list_head *iter;

drivers/net/bonding/bond_main.c

2923

bond_for_each_slave(bond, slave, iter) {

drivers/net/bonding/bond_main.c

3052

struct list_head *iter;

drivers/net/bonding/bond_main.c

3062

netdev_for_each_upper_dev_rcu(start_dev, upper, iter) {

drivers/net/bonding/bond_main.c

3486

struct list_head *iter;

drivers/net/bonding/bond_main.c

3503

bond_for_each_slave_rcu(bond, slave, iter) {

drivers/net/bonding/bond_main.c

3569

bond_for_each_slave(bond, slave, iter) {

drivers/net/bonding/bond_main.c

3603

struct list_head *iter;

drivers/net/bonding/bond_main.c

3607

bond_for_each_slave_rcu(bond, slave, iter) {

drivers/net/bonding/bond_main.c

3673

struct list_head *iter;

drivers/net/bonding/bond_main.c

3677

bond_for_each_slave(bond, slave, iter) {

drivers/net/bonding/bond_main.c

3767

struct list_head *iter;

drivers/net/bonding/bond_main.c

378

struct list_head *iter;

drivers/net/bonding/bond_main.c

3792

bond_for_each_slave_rcu(bond, slave, iter) {

drivers/net/bonding/bond_main.c

381

bond_for_each_slave(bond, slave, iter) {

drivers/net/bonding/bond_main.c

3834

bond_for_each_slave_rcu(bond, slave, iter) {

drivers/net/bonding/bond_main.c

391

bond_for_each_slave(bond, rollback_slave, iter) {

drivers/net/bonding/bond_main.c

411

struct list_head *iter;

drivers/net/bonding/bond_main.c

414

bond_for_each_slave(bond, slave, iter)

drivers/net/bonding/bond_main.c

4350

struct list_head *iter;

drivers/net/bonding/bond_main.c

4361

bond_for_each_slave(bond, slave, iter) {

drivers/net/bonding/bond_main.c

4397

bond_for_each_slave(bond, slave, iter)

drivers/net/bonding/bond_main.c

4436

struct list_head *iter;

drivers/net/bonding/bond_main.c

4438

bond_for_each_slave(bond, slave, iter)

drivers/net/bonding/bond_main.c

4478

struct list_head *niter, *iter, *iter_stack[MAX_NEST_DEV + 1];

drivers/net/bonding/bond_main.c

4482

iter = &dev->adj_list.lower;

drivers/net/bonding/bond_main.c

4487

ldev = netdev_next_lower_dev_rcu(now, &iter);

drivers/net/bonding/bond_main.c

4494

iter_stack[cur++] = iter;

drivers/net/bonding/bond_main.c

4508

iter = niter;

drivers/net/bonding/bond_main.c

4520

struct list_head *iter;

drivers/net/bonding/bond_main.c

4533

bond_for_each_slave_rcu(bond, slave, iter) {

drivers/net/bonding/bond_main.c

4700

struct list_head *iter;

drivers/net/bonding/bond_main.c

4711

bond_for_each_slave_rcu(bond, slave, iter) {

drivers/net/bonding/bond_main.c

4779

struct list_head *iter;

drivers/net/bonding/bond_main.c

4784

bond_for_each_slave(bond, slave, iter) {

drivers/net/bonding/bond_main.c

4811

bond_for_each_slave(bond, rollback_slave, iter) {

drivers/net/bonding/bond_main.c

4837

struct list_head *iter;

drivers/net/bonding/bond_main.c

4856

bond_for_each_slave(bond, slave, iter) {

drivers/net/bonding/bond_main.c

4882

bond_for_each_slave(bond, rollback_slave, iter) {

drivers/net/bonding/bond_main.c

4909

struct list_head *iter;

drivers/net/bonding/bond_main.c

4914

bond_for_each_slave_rcu(bond, slave, iter) {

drivers/net/bonding/bond_main.c

4923

bond_for_each_slave_rcu(bond, slave, iter) {

drivers/net/bonding/bond_main.c

5170

struct list_head *iter;

drivers/net/bonding/bond_main.c

5199

bond_for_each_slave(bond, slave, iter) {

drivers/net/bonding/bond_main.c

5378

struct list_head *iter;

drivers/net/bonding/bond_main.c

5384

bond_for_each_slave_rcu(bond, slave, iter) {

drivers/net/bonding/bond_main.c

5693

struct list_head *iter;

drivers/net/bonding/bond_main.c

5715

bond_for_each_slave(bond, slave, iter) {

drivers/net/bonding/bond_main.c

5758

bond_for_each_slave(bond, rollback_slave, iter) {

drivers/net/bonding/bond_main.c

5860

struct list_head *iter;

drivers/net/bonding/bond_main.c

5872

bond_for_each_slave(bond, slave, iter) {

drivers/net/bonding/bond_main.c

5909

struct list_head *iter;

drivers/net/bonding/bond_main.c

5923

bond_for_each_slave_rcu(bond, slave, iter) {

drivers/net/bonding/bond_main.c

6070

struct list_head *iter;

drivers/net/bonding/bond_main.c

6076

bond_for_each_slave(bond, slave, iter)

drivers/net/bonding/bond_main.c

758

struct list_head *iter;

drivers/net/bonding/bond_main.c

767

bond_for_each_slave(bond, slave, iter) {

drivers/net/bonding/bond_main.c

847

struct list_head *iter;

drivers/net/bonding/bond_main.c

858

bond_for_each_slave(bond, slave, iter) {

drivers/net/bonding/bond_main.c

870

struct list_head *iter;

drivers/net/bonding/bond_main.c

881

bond_for_each_slave(bond, slave, iter) {

drivers/net/bonding/bond_main.c

995

struct list_head *iter;

drivers/net/bonding/bond_main.c

997

bond_for_each_slave(bond, slave, iter) {

drivers/net/bonding/bond_options.c

1168

struct list_head *iter;

drivers/net/bonding/bond_options.c

1172

bond_for_each_slave(bond, slave, iter)

drivers/net/bonding/bond_options.c

1216

struct list_head *iter;

drivers/net/bonding/bond_options.c

1239

bond_for_each_slave(bond, slave, iter) {

drivers/net/bonding/bond_options.c

1393

struct list_head *iter;

drivers/net/bonding/bond_options.c

1397

bond_for_each_slave(bond, slave, iter) {

drivers/net/bonding/bond_options.c

1464

struct list_head *iter;

drivers/net/bonding/bond_options.c

1472

bond_for_each_slave(bond, slave, iter)

drivers/net/bonding/bond_options.c

1524

struct list_head *iter;

drivers/net/bonding/bond_options.c

1541

bond_for_each_slave(bond, slave, iter) {

drivers/net/bonding/bond_options.c

1625

struct list_head *iter;

drivers/net/bonding/bond_options.c

1631

bond_for_each_slave(bond, slave, iter) {

drivers/net/bonding/bond_options.c

1730

struct list_head *iter;

drivers/net/bonding/bond_options.c

1759

bond_for_each_slave(bond, slave, iter) {

drivers/net/bonding/bond_procfs.c

16

struct list_head *iter;

drivers/net/bonding/bond_procfs.c

25

bond_for_each_slave_rcu(bond, slave, iter)

drivers/net/bonding/bond_procfs.c

35

struct list_head *iter;

drivers/net/bonding/bond_procfs.c

43

bond_for_each_slave_rcu(bond, slave, iter) {

drivers/net/bonding/bond_sysfs.c

169

struct list_head *iter;

drivers/net/bonding/bond_sysfs.c

175

bond_for_each_slave_rcu(bond, slave, iter) {

drivers/net/bonding/bond_sysfs.c

637

struct list_head *iter;

drivers/net/bonding/bond_sysfs.c

643

bond_for_each_slave_rcu(bond, slave, iter) {

drivers/net/can/spi/mcp251xfd/mcp251xfd-dump.c

101

static void mcp251xfd_dump_ring(struct mcp251xfd_dump_iter *iter,

drivers/net/can/spi/mcp251xfd/mcp251xfd-dump.c

106

struct mcp251xfd_dump_object_reg *reg = iter->data;

drivers/net/can/spi/mcp251xfd/mcp251xfd-dump.c

114

mcp251xfd_dump_header(iter, object_type, reg);

drivers/net/can/spi/mcp251xfd/mcp251xfd-dump.c

118

struct mcp251xfd_dump_iter *iter)

drivers/net/can/spi/mcp251xfd/mcp251xfd-dump.c

147

mcp251xfd_dump_ring(iter, MCP251XFD_DUMP_OBJECT_TYPE_TEF,

drivers/net/can/spi/mcp251xfd/mcp251xfd-dump.c

152

struct mcp251xfd_dump_iter *iter,

drivers/net/can/spi/mcp251xfd/mcp251xfd-dump.c

180

mcp251xfd_dump_ring(iter, MCP251XFD_DUMP_OBJECT_TYPE_RX,

drivers/net/can/spi/mcp251xfd/mcp251xfd-dump.c

185

struct mcp251xfd_dump_iter *iter)

drivers/net/can/spi/mcp251xfd/mcp251xfd-dump.c

191

mcp251xfd_dump_rx_ring_one(priv, iter, rx_ring);

drivers/net/can/spi/mcp251xfd/mcp251xfd-dump.c

195

struct mcp251xfd_dump_iter *iter)

drivers/net/can/spi/mcp251xfd/mcp251xfd-dump.c

223

mcp251xfd_dump_ring(iter, MCP251XFD_DUMP_OBJECT_TYPE_TX,

drivers/net/can/spi/mcp251xfd/mcp251xfd-dump.c

228

struct mcp251xfd_dump_iter *iter)

drivers/net/can/spi/mcp251xfd/mcp251xfd-dump.c

230

struct mcp251xfd_dump_object_header *hdr = iter->hdr;

drivers/net/can/spi/mcp251xfd/mcp251xfd-dump.c

238

iter->hdr = NULL;

drivers/net/can/spi/mcp251xfd/mcp251xfd-dump.c

243

struct mcp251xfd_dump_iter iter;

drivers/net/can/spi/mcp251xfd/mcp251xfd-dump.c

263

file_size += sizeof(*iter.hdr) * obj_num;

drivers/net/can/spi/mcp251xfd/mcp251xfd-dump.c

266

iter.start = __vmalloc(file_size, GFP_KERNEL | __GFP_NOWARN |

drivers/net/can/spi/mcp251xfd/mcp251xfd-dump.c

268

if (!iter.start) {

drivers/net/can/spi/mcp251xfd/mcp251xfd-dump.c

274

iter.hdr = iter.start;

drivers/net/can/spi/mcp251xfd/mcp251xfd-dump.c

275

iter.data = &iter.hdr[obj_num];

drivers/net/can/spi/mcp251xfd/mcp251xfd-dump.c

277

mcp251xfd_dump_registers(priv, &iter);

drivers/net/can/spi/mcp251xfd/mcp251xfd-dump.c

278

mcp251xfd_dump_tef_ring(priv, &iter);

drivers/net/can/spi/mcp251xfd/mcp251xfd-dump.c

279

mcp251xfd_dump_rx_ring(priv, &iter);

drivers/net/can/spi/mcp251xfd/mcp251xfd-dump.c

280

mcp251xfd_dump_tx_ring(priv, &iter);

drivers/net/can/spi/mcp251xfd/mcp251xfd-dump.c

281

mcp251xfd_dump_end(priv, &iter);

drivers/net/can/spi/mcp251xfd/mcp251xfd-dump.c

283

dev_coredumpv(&priv->spi->dev, iter.start,

drivers/net/can/spi/mcp251xfd/mcp251xfd-dump.c

284

iter.data - iter.start, GFP_KERNEL);

drivers/net/can/spi/mcp251xfd/mcp251xfd-dump.c

44

static void mcp251xfd_dump_header(struct mcp251xfd_dump_iter *iter,

drivers/net/can/spi/mcp251xfd/mcp251xfd-dump.c

48

struct mcp251xfd_dump_object_header *hdr = iter->hdr;

drivers/net/can/spi/mcp251xfd/mcp251xfd-dump.c

51

len = data_end - iter->data;

drivers/net/can/spi/mcp251xfd/mcp251xfd-dump.c

57

hdr->offset = cpu_to_le32(iter->data - iter->start);

drivers/net/can/spi/mcp251xfd/mcp251xfd-dump.c

60

iter->hdr++;

drivers/net/can/spi/mcp251xfd/mcp251xfd-dump.c

61

iter->data += len;

drivers/net/can/spi/mcp251xfd/mcp251xfd-dump.c

65

struct mcp251xfd_dump_iter *iter)

drivers/net/can/spi/mcp251xfd/mcp251xfd-dump.c

68

struct mcp251xfd_dump_object_reg *reg = iter->data;

drivers/net/can/spi/mcp251xfd/mcp251xfd-dump.c

98

mcp251xfd_dump_header(iter, MCP251XFD_DUMP_OBJECT_TYPE_REG, reg);

drivers/net/dsa/bcm_sf2_cfp.c

1303

unsigned int i, j, iter;

drivers/net/dsa/bcm_sf2_cfp.c

1321

iter = (i - 1) * s + j;

drivers/net/dsa/bcm_sf2_cfp.c

1322

data[iter] = core_readl(priv, stat->offset);

drivers/net/ethernet/airoha/airoha_ppe.c

1004

struct airoha_flow_table_entry *iter;

drivers/net/ethernet/airoha/airoha_ppe.c

1009

hlist_for_each_entry_safe(iter, n, &e->l2_flows, l2_subflow_node) {

drivers/net/ethernet/airoha/airoha_ppe.c

1014

hwe = airoha_ppe_foe_get_entry_locked(ppe, iter->hash);

drivers/net/ethernet/airoha/airoha_ppe.c

1021

iter->hash = 0xffff;

drivers/net/ethernet/airoha/airoha_ppe.c

1022

airoha_ppe_foe_remove_flow(ppe, iter);

drivers/net/ethernet/broadcom/bnge/bnge_netdev.h

414

#define bnge_for_each_napi_tx(iter, bnapi, txr) \

drivers/net/ethernet/broadcom/bnge/bnge_netdev.h

415

for (iter = 0, txr = (bnapi)->tx_ring[0]; txr; \

drivers/net/ethernet/broadcom/bnge/bnge_netdev.h

416

txr = (iter < BNGE_MAX_TXR_PER_NAPI - 1) ? \

drivers/net/ethernet/broadcom/bnge/bnge_netdev.h

417

(bnapi)->tx_ring[++iter] : NULL)

drivers/net/ethernet/broadcom/bnxt/bnxt.h

1232

#define bnxt_for_each_napi_tx(iter, bnapi, txr) \

drivers/net/ethernet/broadcom/bnxt/bnxt.h

1233

for (iter = 0, txr = (bnapi)->tx_ring[0]; txr; \

drivers/net/ethernet/broadcom/bnxt/bnxt.h

1234

txr = (iter < BNXT_MAX_TXR_PER_NAPI - 1) ? \

drivers/net/ethernet/broadcom/bnxt/bnxt.h

1235

(bnapi)->tx_ring[++iter] : NULL)

drivers/net/ethernet/broadcom/bnxt/bnxt.h

1860

struct rhashtable_iter iter;

drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c

1792

struct rhashtable_iter *iter = &tc_info->iter;

drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c

1796

rhashtable_walk_start(iter);

drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c

1800

flow_node = rhashtable_walk_next(iter);

drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c

1818

rhashtable_walk_stop(iter);

drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c

1832

rhashtable_walk_enter(&tc_info->flow_table, &tc_info->iter);

drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c

1850

rhashtable_walk_exit(&tc_info->iter);

drivers/net/ethernet/chelsio/cxgb/common.h

308

#define for_each_port(adapter, iter) \

drivers/net/ethernet/chelsio/cxgb/common.h

309

for (iter = 0; iter < (adapter)->params.nports; ++iter)

drivers/net/ethernet/chelsio/cxgb3/common.h

613

#define for_each_port(adapter, iter) \

drivers/net/ethernet/chelsio/cxgb3/common.h

614

for (iter = 0; iter < (adapter)->params.nports; ++iter)

drivers/net/ethernet/chelsio/cxgb4/cudbg_lib.c

3087

u32 size, j, iter;

drivers/net/ethernet/chelsio/cxgb4/cudbg_lib.c

3130

iter = up_cim_reg->ireg_offset_range;

drivers/net/ethernet/chelsio/cxgb4/cudbg_lib.c

3135

iter = up_cim_reg->ireg_offset_range;

drivers/net/ethernet/chelsio/cxgb4/cudbg_lib.c

3140

iter = 1;

drivers/net/ethernet/chelsio/cxgb4/cudbg_lib.c

3146

for (j = 0; j < iter; j++, buff++) {

drivers/net/ethernet/chelsio/cxgb4/cxgb4.h

1648

#define for_each_port(adapter, iter) \

drivers/net/ethernet/chelsio/cxgb4/cxgb4.h

1649

for (iter = 0; iter < (adapter)->params.nports; ++iter)

drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c

3994

struct scatterlist *iter;

drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c

4007

for_each_sg(adapter->hma.sgt->sgl, iter,

drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c

4009

page = sg_page(iter);

drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c

4022

struct scatterlist *sgl, *iter;

drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c

4078

for_each_sg(sgl, iter, sgt->orig_nents, i) {

drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c

4087

sg_set_page(iter, newpage, page_size << page_order, 0);

drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c

4104

for_each_sg(sgl, iter, sgt->nents, i) {

drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c

4105

newpage = sg_page(iter);

drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c

4106

adapter->hma.phy_addr[i] = sg_dma_address(iter);

drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c

1026

struct rhashtable_iter iter;

drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c

1031

rhashtable_walk_enter(&adap->flower_tbl, &iter);

drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c

1033

rhashtable_walk_start(&iter);

drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c

1035

while ((flower_entry = rhashtable_walk_next(&iter)) &&

drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c

1053

rhashtable_walk_stop(&iter);

drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c

1056

rhashtable_walk_exit(&iter);

drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c

795

struct rhashtable_iter iter;

drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c

808

rhashtable_walk_enter(&adap->flower_tbl, &iter);

drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c

810

rhashtable_walk_start(&iter);

drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c

812

fe = rhashtable_walk_next(&iter);

drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c

827

fe = rhashtable_walk_next(&iter);

drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c

830

rhashtable_walk_stop(&iter);

drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c

832

rhashtable_walk_exit(&iter);

drivers/net/ethernet/chelsio/cxgb4vf/adapter.h

350

#define for_each_ethrxq(sge, iter) \

drivers/net/ethernet/chelsio/cxgb4vf/adapter.h

351

for (iter = 0; iter < (sge)->ethqsets; iter++)

drivers/net/ethernet/chelsio/cxgb4vf/t4vf_common.h

306

#define for_each_port(adapter, iter) \

drivers/net/ethernet/chelsio/cxgb4vf/t4vf_common.h

307

for (iter = 0; iter < (adapter)->params.nports; iter++)

drivers/net/ethernet/freescale/dpaa2/dpaa2-switch.c

2184

struct list_head *iter;

drivers/net/ethernet/freescale/dpaa2/dpaa2-switch.c

2189

netdev_for_each_upper_dev_rcu(netdev, upper_dev, iter)

drivers/net/ethernet/freescale/dpaa2/dpaa2-switch.c

2204

struct list_head *iter;

drivers/net/ethernet/freescale/dpaa2/dpaa2-switch.c

2219

netdev_for_each_lower_dev(upper_dev, other_dev, iter) {

drivers/net/ethernet/freescale/dpaa2/dpaa2-switch.c

76

struct list_head *iter;

drivers/net/ethernet/freescale/dpaa2/dpaa2-switch.c

87

netdev_for_each_lower_dev(upper_dev, other_dev, iter) {

drivers/net/ethernet/intel/i40e/i40e_main.c

7836

struct i40e_channel *ch = NULL, *ch_tmp, *iter;

drivers/net/ethernet/intel/i40e/i40e_main.c

7842

list_for_each_entry_safe(iter, ch_tmp, &vsi->macvlan_list, list) {

drivers/net/ethernet/intel/i40e/i40e_main.c

7843

if (!i40e_is_channel_macvlan(iter)) {

drivers/net/ethernet/intel/i40e/i40e_main.c

7844

iter->fwd = fwd;

drivers/net/ethernet/intel/i40e/i40e_main.c

7849

iter->num_queue_pairs,

drivers/net/ethernet/intel/i40e/i40e_main.c

7850

iter->base_queue);

drivers/net/ethernet/intel/i40e/i40e_main.c

7851

for (i = 0; i < iter->num_queue_pairs; i++) {

drivers/net/ethernet/intel/i40e/i40e_main.c

7855

pf_q = iter->base_queue + i;

drivers/net/ethernet/intel/i40e/i40e_main.c

7859

tx_ring->ch = iter;

drivers/net/ethernet/intel/i40e/i40e_main.c

7863

rx_ring->ch = iter;

drivers/net/ethernet/intel/i40e/i40e_main.c

7865

ch = iter;

drivers/net/ethernet/intel/ice/ice_eswitch_br.c

32

struct list_head *iter;

drivers/net/ethernet/intel/ice/ice_eswitch_br.c

34

netdev_for_each_lower_dev(lag_dev, lower, iter) {

drivers/net/ethernet/intel/ice/ice_sched.c

2894

struct ice_sched_agg_vsi_info *agg_vsi_info, *iter, *old_agg_vsi_info = NULL;

drivers/net/ethernet/intel/ice/ice_sched.c

2912

list_for_each_entry_safe(iter, vtmp,

drivers/net/ethernet/intel/ice/ice_sched.c

2915

if (iter->vsi_handle == vsi_handle) {

drivers/net/ethernet/intel/ice/ice_sched.c

2916

old_agg_vsi_info = iter;

drivers/net/ethernet/intel/idpf/idpf.h

610

#define idpf_for_each_vport(adapter, iter) \

drivers/net/ethernet/intel/idpf/idpf.h

611

for (struct idpf_vport **__##iter = &(adapter)->vports[0], \

drivers/net/ethernet/intel/idpf/idpf.h

612

*iter = (adapter)->max_vports ? *__##iter : NULL; \

drivers/net/ethernet/intel/idpf/idpf.h

613

iter; \

drivers/net/ethernet/intel/idpf/idpf.h

614

iter = (++__##iter) < &(adapter)->vports[(adapter)->max_vports] ? \

drivers/net/ethernet/intel/idpf/idpf.h

615

*__##iter : NULL)

drivers/net/ethernet/intel/idpf/idpf_ethtool.c

302

struct idpf_fsteer_fltr *f, *iter;

drivers/net/ethernet/intel/idpf/idpf_ethtool.c

330

list_for_each_entry_safe(f, iter,

drivers/net/ethernet/marvell/octeontx2/af/rvu_cgx.c

128

int cgx, lmac, iter;

drivers/net/ethernet/marvell/octeontx2/af/rvu_cgx.c

162

for_each_set_bit(iter, &lmac_bmap, rvu->hw->lmac_per_cgx) {

drivers/net/ethernet/marvell/octeontx2/af/rvu_cgx.c

163

if (iter >= MAX_LMAC_COUNT)

drivers/net/ethernet/marvell/octeontx2/af/rvu_cgx.c

166

iter);

drivers/net/ethernet/marvell/octeontx2/af/rvu_debugfs.c

3515

struct rvu_npc_mcam_rule *iter;

drivers/net/ethernet/marvell/octeontx2/af/rvu_debugfs.c

3531

list_for_each_entry(iter, &mcam->mcam_rules, list) {

drivers/net/ethernet/marvell/octeontx2/af/rvu_debugfs.c

3532

pf = rvu_get_pf(rvu->pdev, iter->owner);

drivers/net/ethernet/marvell/octeontx2/af/rvu_debugfs.c

3535

if (iter->owner & RVU_PFVF_FUNC_MASK) {

drivers/net/ethernet/marvell/octeontx2/af/rvu_debugfs.c

3536

vf = (iter->owner & RVU_PFVF_FUNC_MASK) - 1;

drivers/net/ethernet/marvell/octeontx2/af/rvu_debugfs.c

3541

seq_printf(s, "\tdirection: %s\n", is_npc_intf_rx(iter->intf) ?

drivers/net/ethernet/marvell/octeontx2/af/rvu_debugfs.c

3544

rvu_dbg_get_intf_name(iter->intf));

drivers/net/ethernet/marvell/octeontx2/af/rvu_debugfs.c

3545

seq_printf(s, "\tmcam entry: %d\n", iter->entry);

drivers/net/ethernet/marvell/octeontx2/af/rvu_debugfs.c

3547

rvu_dbg_npc_mcam_show_flows(s, iter);

drivers/net/ethernet/marvell/octeontx2/af/rvu_debugfs.c

3548

if (is_npc_intf_rx(iter->intf)) {

drivers/net/ethernet/marvell/octeontx2/af/rvu_debugfs.c

3549

target = iter->rx_action.pf_func;

drivers/net/ethernet/marvell/octeontx2/af/rvu_debugfs.c

3558

seq_printf(s, "\tchannel: 0x%x\n", iter->chan);

drivers/net/ethernet/marvell/octeontx2/af/rvu_debugfs.c

3559

seq_printf(s, "\tchannel_mask: 0x%x\n", iter->chan_mask);

drivers/net/ethernet/marvell/octeontx2/af/rvu_debugfs.c

3562

rvu_dbg_npc_mcam_show_action(s, iter);

drivers/net/ethernet/marvell/octeontx2/af/rvu_debugfs.c

3564

enabled = is_mcam_entry_enabled(rvu, mcam, blkaddr, iter->entry);

drivers/net/ethernet/marvell/octeontx2/af/rvu_debugfs.c

3567

seq_printf(s, "\tpriority: %u\n", iter->hw_prio);

drivers/net/ethernet/marvell/octeontx2/af/rvu_debugfs.c

3568

index = iter->entry & (mcam->banksize - 1);

drivers/net/ethernet/marvell/octeontx2/af/rvu_debugfs.c

3569

bank = npc_get_bank(mcam, iter->entry);

drivers/net/ethernet/marvell/octeontx2/af/rvu_debugfs.c

3576

if (!iter->has_cntr)

drivers/net/ethernet/marvell/octeontx2/af/rvu_debugfs.c

3578

seq_printf(s, "\tcounter: %d\n", iter->cntr);

drivers/net/ethernet/marvell/octeontx2/af/rvu_debugfs.c

3580

hits = rvu_read64(rvu, blkaddr, NPC_AF_MATCH_STATX(iter->cntr));

drivers/net/ethernet/marvell/octeontx2/af/rvu_nix.c

4777

int iter;

drivers/net/ethernet/marvell/octeontx2/af/rvu_nix.c

4824

for_each_set_bit(iter, &lmac_bmap, rvu->hw->lmac_per_cgx) {

drivers/net/ethernet/marvell/octeontx2/af/rvu_nix.c

4825

lmac_fifo_len = rvu_cgx_get_lmac_fifolen(rvu, cgx, iter);

drivers/net/ethernet/marvell/octeontx2/af/rvu_nix.c

4829

__func__, cgx, iter);

drivers/net/ethernet/marvell/octeontx2/af/rvu_nix.c

4837

link = iter + slink;

drivers/net/ethernet/marvell/octeontx2/af/rvu_nix.c

6337

struct nix_mcast_grp_elem *iter;

drivers/net/ethernet/marvell/octeontx2/af/rvu_nix.c

6340

list_for_each_entry(iter, &mcast_grp->mcast_grp_head, list) {

drivers/net/ethernet/marvell/octeontx2/af/rvu_nix.c

6341

if (iter->mcast_grp_idx == mcast_grp_idx) {

drivers/net/ethernet/marvell/octeontx2/af/rvu_nix.c

6348

return iter;

drivers/net/ethernet/marvell/octeontx2/af/rvu_npc_fs.c

1216

struct rvu_npc_mcam_rule *iter;

drivers/net/ethernet/marvell/octeontx2/af/rvu_npc_fs.c

1219

list_for_each_entry(iter, &mcam->mcam_rules, list) {

drivers/net/ethernet/marvell/octeontx2/af/rvu_npc_fs.c

1220

if (iter->entry == entry) {

drivers/net/ethernet/marvell/octeontx2/af/rvu_npc_fs.c

1222

return iter;

drivers/net/ethernet/marvell/octeontx2/af/rvu_npc_fs.c

1234

struct rvu_npc_mcam_rule *iter;

drivers/net/ethernet/marvell/octeontx2/af/rvu_npc_fs.c

1237

list_for_each_entry(iter, &mcam->mcam_rules, list) {

drivers/net/ethernet/marvell/octeontx2/af/rvu_npc_fs.c

1238

if (iter->entry > rule->entry)

drivers/net/ethernet/marvell/octeontx2/af/rvu_npc_fs.c

1240

head = &iter->list;

drivers/net/ethernet/marvell/octeontx2/af/rvu_npc_fs.c

1934

struct rvu_npc_mcam_rule *iter, *tmp;

drivers/net/ethernet/marvell/octeontx2/af/rvu_npc_fs.c

1946

list_for_each_entry_safe(iter, tmp, &mcam->mcam_rules, list) {

drivers/net/ethernet/marvell/octeontx2/af/rvu_npc_fs.c

1947

if (iter->owner == pcifunc) {

drivers/net/ethernet/marvell/octeontx2/af/rvu_npc_fs.c

1950

list_move_tail(&iter->list, &del_list);

drivers/net/ethernet/marvell/octeontx2/af/rvu_npc_fs.c

1952

} else if (req->end && iter->entry >= req->start &&

drivers/net/ethernet/marvell/octeontx2/af/rvu_npc_fs.c

1953

iter->entry <= req->end) {

drivers/net/ethernet/marvell/octeontx2/af/rvu_npc_fs.c

1954

list_move_tail(&iter->list, &del_list);

drivers/net/ethernet/marvell/octeontx2/af/rvu_npc_fs.c

1956

} else if (req->entry == iter->entry) {

drivers/net/ethernet/marvell/octeontx2/af/rvu_npc_fs.c

1960

NPC_AF_MATCH_STATX(iter->cntr));

drivers/net/ethernet/marvell/octeontx2/af/rvu_npc_fs.c

1961

list_move_tail(&iter->list, &del_list);

drivers/net/ethernet/marvell/octeontx2/af/rvu_npc_fs.c

1968

list_for_each_entry_safe(iter, tmp, &del_list, list) {

drivers/net/ethernet/marvell/octeontx2/af/rvu_npc_fs.c

1969

u16 entry = iter->entry;

drivers/net/ethernet/marvell/octeontx2/af/rvu_npc_fs.c

1973

if (npc_delete_flow(rvu, iter, pcifunc))

drivers/net/ethernet/marvell/octeontx2/af/rvu_npc_hash.c

1846

struct npc_exact_table_entry *tmp, *iter;

drivers/net/ethernet/marvell/octeontx2/af/rvu_npc_hash.c

1850

list_for_each_entry_safe(iter, tmp, &table->lhead_gbl, glist) {

drivers/net/ethernet/marvell/octeontx2/af/rvu_npc_hash.c

1851

if (pcifunc != iter->pcifunc)

drivers/net/ethernet/marvell/octeontx2/af/rvu_npc_hash.c

1854

seq_id = iter->seq_id;

drivers/net/ethernet/marvell/octeontx2/af/rvu_npc_hash.c

801

struct npc_exact_table_entry *entry, *tmp, *iter;

drivers/net/ethernet/marvell/octeontx2/af/rvu_npc_hash.c

864

list_for_each_entry_safe(iter, tmp, lhead, list) {

drivers/net/ethernet/marvell/octeontx2/af/rvu_npc_hash.c

865

if (index < iter->index)

drivers/net/ethernet/marvell/octeontx2/af/rvu_npc_hash.c

868

pprev = &iter->list;

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

1496

struct otx2_flow *iter;

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

1500

list_for_each_entry(iter, &pfvf->flow_cfg->flow_list, list) {

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

1501

if ((iter->rule_type & DMAC_FILTER_RULE) && iter->entry == 0) {

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

1502

eth_hdr = &iter->flow_spec.h_u.ether_spec;

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

1519

list_del(&iter->list);

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

1520

kfree(iter);

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

1596

struct otx2_flow *iter, *tmp;

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

1617

list_for_each_entry_safe(iter, tmp, &flow_cfg->flow_list, list) {

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

1618

list_del(&iter->list);

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

1619

kfree(iter);

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

1629

struct otx2_flow *iter, *tmp;

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

1640

list_for_each_entry_safe(iter, tmp, &flow_cfg->flow_list, list) {

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

1641

list_del(&iter->list);

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

1642

kfree(iter);

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

1769

struct otx2_flow *iter;

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

1772

list_for_each_entry(iter, &pf->flow_cfg->flow_list, list) {

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

1773

if (iter->rule_type & DMAC_FILTER_RULE) {

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

1774

eth_hdr = &iter->flow_spec.h_u.ether_spec;

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

1776

iter->entry);

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

621

struct otx2_flow *iter;

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

623

list_for_each_entry(iter, &pfvf->flow_cfg->flow_list, list) {

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

624

if (iter->location == location)

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

625

return iter;

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

634

struct otx2_flow *iter;

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

636

list_for_each_entry(iter, &pfvf->flow_cfg->flow_list, list) {

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

637

if (iter->location > flow->location)

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

639

head = &iter->list;

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

662

struct otx2_flow *iter;

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

667

list_for_each_entry(iter, &pfvf->flow_cfg->flow_list, list) {

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

668

if (iter->location == location) {

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

669

nfc->fs = iter->flow_spec;

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

670

nfc->rss_context = iter->rss_ctx_id;

drivers/net/ethernet/marvell/octeontx2/nic/otx2_tc.c

941

struct otx2_tc_flow *iter, *tmp;

drivers/net/ethernet/marvell/octeontx2/nic/otx2_tc.c

946

list_for_each_entry_safe(iter, tmp, &flow_cfg->flow_list_tc, list) {

drivers/net/ethernet/marvell/octeontx2/nic/otx2_tc.c

947

list_del(&iter->list);

drivers/net/ethernet/marvell/octeontx2/nic/otx2_tc.c

948

kfree(iter);

drivers/net/ethernet/marvell/prestera/prestera_main.c

1176

struct list_head *iter;

drivers/net/ethernet/marvell/prestera/prestera_main.c

1179

netdev_for_each_lower_dev(lag_dev, dev, iter) {

drivers/net/ethernet/marvell/prestera/prestera_router.c

1079

struct rhashtable_iter iter;

drivers/net/ethernet/marvell/prestera/prestera_router.c

1081

rhashtable_walk_enter(&sw->router->kern_neigh_cache_ht, &iter);

drivers/net/ethernet/marvell/prestera/prestera_router.c

1082

rhashtable_walk_start(&iter);

drivers/net/ethernet/marvell/prestera/prestera_router.c

1084

n_cache = rhashtable_walk_next(&iter);

drivers/net/ethernet/marvell/prestera/prestera_router.c

1092

rhashtable_walk_stop(&iter);

drivers/net/ethernet/marvell/prestera/prestera_router.c

1094

rhashtable_walk_start(&iter);

drivers/net/ethernet/marvell/prestera/prestera_router.c

1096

rhashtable_walk_stop(&iter);

drivers/net/ethernet/marvell/prestera/prestera_router.c

1097

rhashtable_walk_exit(&iter);

drivers/net/ethernet/marvell/prestera/prestera_router.c

1129

struct rhashtable_iter iter;

drivers/net/ethernet/marvell/prestera/prestera_router.c

1131

rhashtable_walk_enter(&sw->router->kern_neigh_cache_ht, &iter);

drivers/net/ethernet/marvell/prestera/prestera_router.c

1132

rhashtable_walk_start(&iter);

drivers/net/ethernet/marvell/prestera/prestera_router.c

1134

n_cache = rhashtable_walk_next(&iter);

drivers/net/ethernet/marvell/prestera/prestera_router.c

1142

rhashtable_walk_stop(&iter);

drivers/net/ethernet/marvell/prestera/prestera_router.c

1145

rhashtable_walk_start(&iter);

drivers/net/ethernet/marvell/prestera/prestera_router.c

1147

rhashtable_walk_stop(&iter);

drivers/net/ethernet/marvell/prestera/prestera_router.c

1148

rhashtable_walk_exit(&iter);

drivers/net/ethernet/marvell/prestera/prestera_router.c

322

struct fib6_info *iter;

drivers/net/ethernet/marvell/prestera/prestera_router.c

334

list_for_each_entry(iter, &fen6_info->rt->fib6_siblings,

drivers/net/ethernet/marvell/prestera/prestera_router.c

337

return &iter->fib6_nh->nh_common;

drivers/net/ethernet/mediatek/mtk_eth_soc.c

3556

struct list_head *iter;

drivers/net/ethernet/mediatek/mtk_eth_soc.c

3562

netdev_for_each_lower_dev(dev, ldev, iter) {

drivers/net/ethernet/mellanox/mlx4/fw.c

1522

struct mlx4_icm_iter iter;

drivers/net/ethernet/mellanox/mlx4/fw.c

1535

for (mlx4_icm_first(icm, &iter);

drivers/net/ethernet/mellanox/mlx4/fw.c

1536

!mlx4_icm_last(&iter);

drivers/net/ethernet/mellanox/mlx4/fw.c

1537

mlx4_icm_next(&iter)) {

drivers/net/ethernet/mellanox/mlx4/fw.c

1543

lg = ffs(mlx4_icm_addr(&iter) | mlx4_icm_size(&iter)) - 1;

drivers/net/ethernet/mellanox/mlx4/fw.c

1547

(unsigned long long) mlx4_icm_addr(&iter),

drivers/net/ethernet/mellanox/mlx4/fw.c

1548

mlx4_icm_size(&iter));

drivers/net/ethernet/mellanox/mlx4/fw.c

1553

for (i = 0; i < mlx4_icm_size(&iter) >> lg; ++i) {

drivers/net/ethernet/mellanox/mlx4/fw.c

1560

cpu_to_be64((mlx4_icm_addr(&iter) + (i << lg)) |

drivers/net/ethernet/mellanox/mlx4/icm.h

100

iter->chunk = list_empty(&icm->chunk_list) ?

drivers/net/ethernet/mellanox/mlx4/icm.h

103

iter->page_idx = 0;

drivers/net/ethernet/mellanox/mlx4/icm.h

106

static inline int mlx4_icm_last(struct mlx4_icm_iter *iter)

drivers/net/ethernet/mellanox/mlx4/icm.h

108

return !iter->chunk;

drivers/net/ethernet/mellanox/mlx4/icm.h

111

static inline void mlx4_icm_next(struct mlx4_icm_iter *iter)

drivers/net/ethernet/mellanox/mlx4/icm.h

113

if (++iter->page_idx >= iter->chunk->nsg) {

drivers/net/ethernet/mellanox/mlx4/icm.h

114

if (iter->chunk->list.next == &iter->icm->chunk_list) {

drivers/net/ethernet/mellanox/mlx4/icm.h

115

iter->chunk = NULL;

drivers/net/ethernet/mellanox/mlx4/icm.h

119

iter->chunk = list_entry(iter->chunk->list.next,

drivers/net/ethernet/mellanox/mlx4/icm.h

121

iter->page_idx = 0;

drivers/net/ethernet/mellanox/mlx4/icm.h

125

static inline dma_addr_t mlx4_icm_addr(struct mlx4_icm_iter *iter)

drivers/net/ethernet/mellanox/mlx4/icm.h

127

if (iter->chunk->coherent)

drivers/net/ethernet/mellanox/mlx4/icm.h

128

return iter->chunk->buf[iter->page_idx].dma_addr;

drivers/net/ethernet/mellanox/mlx4/icm.h

130

return sg_dma_address(&iter->chunk->sg[iter->page_idx]);

drivers/net/ethernet/mellanox/mlx4/icm.h

133

static inline unsigned long mlx4_icm_size(struct mlx4_icm_iter *iter)

drivers/net/ethernet/mellanox/mlx4/icm.h

135

if (iter->chunk->coherent)

drivers/net/ethernet/mellanox/mlx4/icm.h

136

return iter->chunk->buf[iter->page_idx].size;

drivers/net/ethernet/mellanox/mlx4/icm.h

138

return sg_dma_len(&iter->chunk->sg[iter->page_idx]);

drivers/net/ethernet/mellanox/mlx4/icm.h

97

struct mlx4_icm_iter *iter)

drivers/net/ethernet/mellanox/mlx4/icm.h

99

iter->icm = icm;

drivers/net/ethernet/mellanox/mlx5/core/en/rep/bond.c

196

struct list_head *iter;

drivers/net/ethernet/mellanox/mlx5/core/en/rep/bond.c

219

netdev_for_each_lower_dev(lag_dev, dev, iter) {

drivers/net/ethernet/mellanox/mlx5/core/en/rep/bridge.c

168

struct list_head *iter;

drivers/net/ethernet/mellanox/mlx5/core/en/rep/bridge.c

173

netdev_for_each_lower_dev(dev, lower, iter) {

drivers/net/ethernet/mellanox/mlx5/core/en/rep/bridge.c

44

struct list_head *iter;

drivers/net/ethernet/mellanox/mlx5/core/en/rep/bridge.c

46

netdev_for_each_lower_dev(dev, lower, iter) {

drivers/net/ethernet/mellanox/mlx5/core/en/rep/bridge.c

86

struct list_head *iter;

drivers/net/ethernet/mellanox/mlx5/core/en/rep/bridge.c

92

netdev_for_each_lower_dev(dev, lower_dev, iter) {

drivers/net/ethernet/mellanox/mlx5/core/en_accel/macsec.c

1445

struct mlx5e_macsec_device *iter;

drivers/net/ethernet/mellanox/mlx5/core/en_accel/macsec.c

1450

list_for_each_entry(iter, device_list, macsec_device_list_element) {

drivers/net/ethernet/mellanox/mlx5/core/en_accel/macsec.c

1452

macsec_sa = iter->tx_sa[i];

drivers/net/ethernet/mellanox/mlx5/core/en_accel/macsec.c

1469

struct mlx5e_macsec_device *iter;

drivers/net/ethernet/mellanox/mlx5/core/en_accel/macsec.c

1474

list_for_each_entry(iter, device_list, macsec_device_list_element) {

drivers/net/ethernet/mellanox/mlx5/core/en_accel/macsec.c

1475

sc_list = &iter->macsec_rx_sc_list_head;

drivers/net/ethernet/mellanox/mlx5/core/en_accel/macsec.c

411

struct mlx5e_macsec_rx_sc *iter;

drivers/net/ethernet/mellanox/mlx5/core/en_accel/macsec.c

413

list_for_each_entry_rcu(iter, list, rx_sc_list_element) {

drivers/net/ethernet/mellanox/mlx5/core/en_accel/macsec.c

414

if (iter->sci == sci)

drivers/net/ethernet/mellanox/mlx5/core/en_accel/macsec.c

415

return iter;

drivers/net/ethernet/mellanox/mlx5/core/en_accel/macsec.c

480

struct mlx5e_macsec_device *iter;

drivers/net/ethernet/mellanox/mlx5/core/en_accel/macsec.c

484

list_for_each_entry_rcu(iter, list, macsec_device_list_element) {

drivers/net/ethernet/mellanox/mlx5/core/en_accel/macsec.c

485

if (iter->netdev == ctx->secy->netdev)

drivers/net/ethernet/mellanox/mlx5/core/en_accel/macsec.c

486

return iter;

drivers/net/ethernet/mellanox/mlx5/core/en_fs_ethtool.c

400

struct mlx5e_ethtool_rule *iter;

drivers/net/ethernet/mellanox/mlx5/core/en_fs_ethtool.c

402

list_for_each_entry(iter, &ethtool->rules, list) {

drivers/net/ethernet/mellanox/mlx5/core/en_fs_ethtool.c

403

if (iter->flow_spec.location > rule->flow_spec.location)

drivers/net/ethernet/mellanox/mlx5/core/en_fs_ethtool.c

405

head = &iter->list;

drivers/net/ethernet/mellanox/mlx5/core/en_fs_ethtool.c

526

struct mlx5e_ethtool_rule *iter;

drivers/net/ethernet/mellanox/mlx5/core/en_fs_ethtool.c

528

list_for_each_entry(iter, &ethtool->rules, list) {

drivers/net/ethernet/mellanox/mlx5/core/en_fs_ethtool.c

529

if (iter->flow_spec.location == location)

drivers/net/ethernet/mellanox/mlx5/core/en_fs_ethtool.c

530

return iter;

drivers/net/ethernet/mellanox/mlx5/core/en_fs_ethtool.c

853

struct mlx5e_ethtool_rule *iter;

drivers/net/ethernet/mellanox/mlx5/core/en_fs_ethtool.c

856

list_for_each_entry_safe(iter, temp, &ethtool->rules, list)

drivers/net/ethernet/mellanox/mlx5/core/en_fs_ethtool.c

857

del_ethtool_rule(fs, iter);

drivers/net/ethernet/mellanox/mlx5/core/esw/ipsec_fs.c

162

struct rhashtable_iter iter;

drivers/net/ethernet/mellanox/mlx5/core/esw/ipsec_fs.c

172

rhashtable_walk_enter(&rpriv->tc_ht, &iter);

drivers/net/ethernet/mellanox/mlx5/core/esw/ipsec_fs.c

173

rhashtable_walk_start(&iter);

drivers/net/ethernet/mellanox/mlx5/core/esw/ipsec_fs.c

174

while ((flow = rhashtable_walk_next(&iter)) != NULL) {

drivers/net/ethernet/mellanox/mlx5/core/esw/ipsec_fs.c

183

rhashtable_walk_stop(&iter);

drivers/net/ethernet/mellanox/mlx5/core/esw/ipsec_fs.c

184

rhashtable_walk_exit(&iter);

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c

1001

ft = find_closest_ft_recursive(iter, &iter->children, reverse);

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c

1080

struct mlx5_flow_table *iter;

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c

1083

fs_for_each_ft(iter, prio) {

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c

1084

err = root->cmds->modify_flow_table(root, iter, ft);

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c

1088

iter->id, iter->type, err);

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c

1189

struct fs_node *iter;

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c

1194

list_for_each_entry(iter, &fte->dup->children, list) {

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c

1195

tmp_rule = container_of(iter, struct mlx5_flow_rule, node);

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c

1268

struct mlx5_flow_rule *iter;

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c

1283

list_for_each_entry(iter, &new_next_ft->fwd_rules, next_ft) {

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c

1284

if ((iter->sw_action & MLX5_FLOW_CONTEXT_ACTION_FWD_NEXT_NS) &&

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c

1285

iter->ft->ns == new_next_ft->ns)

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c

1288

err = _mlx5_modify_rule_destination(iter, &dest);

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c

1327

struct mlx5_flow_table *iter;

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c

1329

fs_for_each_ft(iter, prio) {

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c

1330

if (iter->level > ft->level)

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c

1332

prev = &iter->node.list;

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c

2063

struct match_list *iter, *match_tmp;

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c

2065

list_for_each_entry_safe(iter, match_tmp, &head->list,

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c

2067

tree_put_node(&iter->g->node, ft_locked);

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c

2068

list_del(&iter->list);

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c

2069

kfree(iter);

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c

2111

struct match_list *iter;

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c

2114

list_for_each_entry(iter, match_head, list)

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c

2115

version += (u64)atomic_read(&iter->g->node.version);

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c

2229

struct match_list *iter;

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c

2249

list_for_each_entry(iter, match_head, list) {

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c

2252

g = iter->g;

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c

2290

list_for_each_entry(iter, match_head, list) {

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c

2291

g = iter->g;

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c

3139

struct fs_node *iter;

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c

3143

list_for_each_entry_safe(iter, temp, &node->children, list)

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c

3144

clean_tree(iter);

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c

695

struct fs_node *iter;

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c

703

list_for_each_entry(iter, &fte->node.children, list)

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c

704

iter->del_sw_func = del_sw_hw_rule;

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c

990

struct fs_node *iter = list_entry(start, struct fs_node, list);

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c

996

list_for_each_advance_continue(iter, &root->children, reverse) {

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c

997

if (iter->type == FS_TYPE_FLOW_TABLE) {

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c

998

fs_get_obj(ft, iter);

drivers/net/ethernet/mellanox/mlx5/core/irq_affinity.c

102

struct mlx5_irq *iter;

drivers/net/ethernet/mellanox/mlx5/core/irq_affinity.c

107

xa_for_each_range(&pool->irqs, index, iter, start, end) {

drivers/net/ethernet/mellanox/mlx5/core/irq_affinity.c

108

int iter_refcount = mlx5_irq_read_locked(iter);

drivers/net/ethernet/mellanox/mlx5/core/irq_affinity.c

111

iter_mask = irq_get_effective_affinity_mask(mlx5_irq_get_irq(iter));

drivers/net/ethernet/mellanox/mlx5/core/irq_affinity.c

119

return iter;

drivers/net/ethernet/mellanox/mlx5/core/irq_affinity.c

125

irq = iter;

drivers/net/ethernet/mellanox/mlx5/core/lib/devcom.c

18

#define devcom_for_each_component(iter) \

drivers/net/ethernet/mellanox/mlx5/core/lib/devcom.c

19

list_for_each_entry(iter, &devcom_comp_list, comp_list)

drivers/net/ethernet/mellanox/mlx5/core/lib/devcom.c

54

struct mlx5_devcom_dev *iter;

drivers/net/ethernet/mellanox/mlx5/core/lib/devcom.c

56

list_for_each_entry(iter, &devcom_dev_list, list)

drivers/net/ethernet/mellanox/mlx5/core/lib/devcom.c

57

if (iter->dev == dev)

drivers/net/ethernet/mellanox/mlx5/core/lib/macsec_fs.c

2284

struct mlx5_macsec_device *iter, *macsec_device = NULL;

drivers/net/ethernet/mellanox/mlx5/core/lib/macsec_fs.c

2290

list_for_each_entry(iter, &macsec_fs->macsec_devices_list, macsec_devices_list_entry) {

drivers/net/ethernet/mellanox/mlx5/core/lib/macsec_fs.c

2291

if (iter->macdev == macdev) {

drivers/net/ethernet/mellanox/mlx5/core/lib/macsec_fs.c

2292

macsec_device = iter;

drivers/net/ethernet/mellanox/mlx5/core/lib/macsec_fs.c

655

struct mlx5_macsec_device *iter, *macsec_device = NULL;

drivers/net/ethernet/mellanox/mlx5/core/lib/macsec_fs.c

659

list_for_each_entry(iter, macsec_devices_list, macsec_devices_list_entry) {

drivers/net/ethernet/mellanox/mlx5/core/lib/macsec_fs.c

660

if (iter->macdev == macdev) {

drivers/net/ethernet/mellanox/mlx5/core/lib/macsec_fs.c

661

macsec_device = iter;

drivers/net/ethernet/mellanox/mlx5/core/lib/macsec_fs.c

700

struct mlx5_macsec_device *iter, *macsec_device = NULL;

drivers/net/ethernet/mellanox/mlx5/core/lib/macsec_fs.c

720

list_for_each_entry(iter, macsec_devices_list, macsec_devices_list_entry) {

drivers/net/ethernet/mellanox/mlx5/core/lib/macsec_fs.c

721

if (iter->macdev == macdev) {

drivers/net/ethernet/mellanox/mlx5/core/lib/macsec_fs.c

722

macsec_device = iter;

drivers/net/ethernet/mellanox/mlx5/core/pagealloc.c

259

struct fw_page *iter;

drivers/net/ethernet/mellanox/mlx5/core/pagealloc.c

262

list_for_each_entry(iter, &dev->priv.free_list, list) {

drivers/net/ethernet/mellanox/mlx5/core/pagealloc.c

263

if (iter->function != function)

drivers/net/ethernet/mellanox/mlx5/core/pagealloc.c

265

fp = iter;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_send.c

875

int data_len, iter = 0, cur_sent;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_send.c

890

send_info.remote_addr = arg_id + iter;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_send.c

896

iter++;

drivers/net/ethernet/mellanox/mlxsw/spectrum.c

4092

struct list_head *iter;

drivers/net/ethernet/mellanox/mlxsw/spectrum.c

4097

netdev_for_each_upper_dev_rcu(lag_dev, upper_dev, iter) {

drivers/net/ethernet/mellanox/mlxsw/spectrum.c

4270

struct list_head *iter;

drivers/net/ethernet/mellanox/mlxsw/spectrum.c

4282

netdev_for_each_upper_dev_rcu(lag_dev, upper_dev, iter) {

drivers/net/ethernet/mellanox/mlxsw/spectrum.c

4301

netdev_for_each_upper_dev_rcu(lag_dev, upper_dev, iter) {

drivers/net/ethernet/mellanox/mlxsw/spectrum.c

4328

struct list_head *iter;

drivers/net/ethernet/mellanox/mlxsw/spectrum.c

4330

netdev_for_each_upper_dev_rcu(lag_dev, upper_dev, iter) {

drivers/net/ethernet/mellanox/mlxsw/spectrum.c

4601

struct list_head *iter;

drivers/net/ethernet/mellanox/mlxsw/spectrum.c

4603

netdev_for_each_lower_dev(br_dev, dev, iter) {

drivers/net/ethernet/mellanox/mlxsw/spectrum.c

4615

struct list_head *iter;

drivers/net/ethernet/mellanox/mlxsw/spectrum.c

4617

netdev_for_each_lower_dev(br_dev, dev, iter) {

drivers/net/ethernet/mellanox/mlxsw/spectrum.c

4673

struct list_head *iter;

drivers/net/ethernet/mellanox/mlxsw/spectrum.c

4676

netdev_for_each_upper_dev_rcu(dev, upper_dev, iter) {

drivers/net/ethernet/mellanox/mlxsw/spectrum.c

4937

struct list_head *iter;

drivers/net/ethernet/mellanox/mlxsw/spectrum.c

4940

netdev_for_each_lower_dev(lag_dev, dev, iter) {

drivers/net/ethernet/mellanox/mlxsw/spectrum.c

5026

struct list_head *iter;

drivers/net/ethernet/mellanox/mlxsw/spectrum.c

5029

netdev_for_each_lower_dev(lag_dev, dev, iter) {

drivers/net/ethernet/mellanox/mlxsw/spectrum.h

432

struct list_head *iter;

drivers/net/ethernet/mellanox/mlxsw/spectrum.h

434

netdev_for_each_lower_dev(br_dev, dev, iter) {

drivers/net/ethernet/mellanox/mlxsw/spectrum_ptp.c

848

struct rhashtable_iter iter;

drivers/net/ethernet/mellanox/mlxsw/spectrum_ptp.c

855

rhltable_walk_enter(&ptp_state->unmatched_ht, &iter);

drivers/net/ethernet/mellanox/mlxsw/spectrum_ptp.c

856

rhashtable_walk_start(&iter);

drivers/net/ethernet/mellanox/mlxsw/spectrum_ptp.c

857

while ((obj = rhashtable_walk_next(&iter))) {

drivers/net/ethernet/mellanox/mlxsw/spectrum_ptp.c

865

rhashtable_walk_stop(&iter);

drivers/net/ethernet/mellanox/mlxsw/spectrum_ptp.c

866

rhashtable_walk_exit(&iter);

drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c

10153

struct list_head *iter;

drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c

10163

netdev_for_each_upper_dev_rcu(lag_dev, upper_dev, iter) {

drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c

10179

netdev_for_each_upper_dev_rcu(lag_dev, upper_dev, iter) {

drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c

10199

struct list_head *iter;

drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c

10202

netdev_for_each_upper_dev_rcu(lag_dev, upper_dev, iter) {

drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c

7822

struct fib6_info *iter;

drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c

7841

list_for_each_entry(iter, &rt->fib6_siblings, fib6_siblings) {

drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c

7845

rt_arr[i + 1] = iter;

drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c

7846

fib6_info_hold(iter);

drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c

9247

struct list_head *iter;

drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c

9250

netdev_for_each_lower_dev(lag_dev, port_dev, iter) {

drivers/net/ethernet/mellanox/mlxsw/spectrum_span.c

342

struct list_head *iter;

drivers/net/ethernet/mellanox/mlxsw/spectrum_span.c

344

netdev_for_each_lower_dev(lag_dev, dev, iter)

drivers/net/ethernet/mellanox/mlxsw/spectrum_switchdev.c

199

struct list_head *iter;

drivers/net/ethernet/mellanox/mlxsw/spectrum_switchdev.c

202

netdev_for_each_lower_dev(br_dev, dev, iter) {

drivers/net/ethernet/mellanox/mlxsw/spectrum_switchdev.c

217

netdev_for_each_lower_dev(br_dev, dev, iter) {

drivers/net/ethernet/mellanox/mlxsw/spectrum_switchdev.c

231

struct list_head *iter;

drivers/net/ethernet/mellanox/mlxsw/spectrum_switchdev.c

233

netdev_for_each_lower_dev(br_dev, dev, iter) {

drivers/net/ethernet/mellanox/mlxsw/spectrum_switchdev.c

2572

struct list_head *iter;

drivers/net/ethernet/mellanox/mlxsw/spectrum_switchdev.c

2574

netdev_for_each_lower_dev(br_dev, dev, iter) {

drivers/net/ethernet/microchip/lan966x/lan966x_lag.c

290

struct list_head *iter;

drivers/net/ethernet/microchip/lan966x/lan966x_lag.c

293

netdev_for_each_lower_dev(dev, lower, iter) {

drivers/net/ethernet/microchip/lan966x/lan966x_lag.c

314

struct list_head *iter;

drivers/net/ethernet/microchip/lan966x/lan966x_lag.c

317

netdev_for_each_lower_dev(dev, lower, iter) {

drivers/net/ethernet/microchip/lan966x/lan966x_switchdev.c

365

struct list_head *iter;

drivers/net/ethernet/microchip/lan966x/lan966x_switchdev.c

371

netdev_for_each_lower_dev(upper, dev, iter) {

drivers/net/ethernet/microchip/vcap/vcap_api.c

1449

struct vcap_stream_iter iter;

drivers/net/ethernet/microchip/vcap/vcap_api.c

146

struct vcap_stream_iter iter;

drivers/net/ethernet/microchip/vcap/vcap_api.c

1471

vcap_iter_init(&iter, vctrl->vcaps[vt].act_width, tgt,

drivers/net/ethernet/microchip/vcap/vcap_api.c

1473

vcap_decode_field(actstream, &iter, actionfield[idx].width,

drivers/net/ethernet/microchip/vcap/vcap_api.c

153

vcap_iter_set(&iter, sw_width, tg, 0);

drivers/net/ethernet/microchip/vcap/vcap_api.c

154

while (iter.tg->width) {

drivers/net/ethernet/microchip/vcap/vcap_api.c

156

iter.offset = iter.tg->offset;

drivers/net/ethernet/microchip/vcap/vcap_api.c

157

vcap_iter_update(&iter);

drivers/net/ethernet/microchip/vcap/vcap_api.c

158

for (idx = 0; idx < iter.tg->width; idx++) {

drivers/net/ethernet/microchip/vcap/vcap_api.c

163

vcap_set_bit(stream, &iter, 0x1);

drivers/net/ethernet/microchip/vcap/vcap_api.c

165

vcap_set_bit(stream, &iter,

drivers/net/ethernet/microchip/vcap/vcap_api.c

1652

struct vcap_admin *iter, *last = NULL;

drivers/net/ethernet/microchip/vcap/vcap_api.c

1655

list_for_each_entry(iter, &vctrl->list, list) {

drivers/net/ethernet/microchip/vcap/vcap_api.c

1656

if (iter->first_cid > max_cid &&

drivers/net/ethernet/microchip/vcap/vcap_api.c

1657

iter->ingress == ingress) {

drivers/net/ethernet/microchip/vcap/vcap_api.c

1658

last = iter;

drivers/net/ethernet/microchip/vcap/vcap_api.c

1659

max_cid = iter->first_cid;

drivers/net/ethernet/microchip/vcap/vcap_api.c

166

(iter.tg->value >> idx) & 0x1);

drivers/net/ethernet/microchip/vcap/vcap_api.c

167

iter.offset++;

drivers/net/ethernet/microchip/vcap/vcap_api.c

168

vcap_iter_update(&iter);

drivers/net/ethernet/microchip/vcap/vcap_api.c

170

iter.tg++; /* next typegroup */

drivers/net/ethernet/microchip/vcap/vcap_api.c

2113

struct vcap_rule_internal *duprule, *iter, *elem = NULL;

drivers/net/ethernet/microchip/vcap/vcap_api.c

2125

list_for_each_entry(iter, &admin->rules, list) {

drivers/net/ethernet/microchip/vcap/vcap_api.c

2126

if (ri->sort_key < iter->sort_key) {

drivers/net/ethernet/microchip/vcap/vcap_api.c

2127

elem = iter;

drivers/net/ethernet/microchip/vcap/vcap_api.c

228

struct vcap_stream_iter iter;

drivers/net/ethernet/microchip/vcap/vcap_api.c

255

vcap_iter_init(&iter, vcap->sw_width, tgt, typefld->offset);

drivers/net/ethernet/microchip/vcap/vcap_api.c

256

vcap_decode_field(mskstream, &iter, typefld->width, (u8 *)&mask);

drivers/net/ethernet/microchip/vcap/vcap_api.c

264

vcap_iter_init(&iter, vcap->sw_width, tgt, typefld->offset);

drivers/net/ethernet/microchip/vcap/vcap_api.c

265

vcap_decode_field(keystream, &iter, typefld->width, (u8 *)&value);

drivers/net/ethernet/microchip/vcap/vcap_api.c

275

struct vcap_stream_iter iter;

drivers/net/ethernet/microchip/vcap/vcap_api.c

278

vcap_iter_set(&iter, sw_width, tgt, 0);

drivers/net/ethernet/microchip/vcap/vcap_api.c

280

while (iter.tg->width) {

drivers/net/ethernet/microchip/vcap/vcap_api.c

282

u32 tg_value = iter.tg->value;

drivers/net/ethernet/microchip/vcap/vcap_api.c

285

tg_value = (1 << iter.tg->width) - 1;

drivers/net/ethernet/microchip/vcap/vcap_api.c

287

iter.offset = iter.tg->offset;

drivers/net/ethernet/microchip/vcap/vcap_api.c

288

vcap_iter_update(&iter);

drivers/net/ethernet/microchip/vcap/vcap_api.c

289

for (idx = 0; idx < iter.tg->width; idx++) {

drivers/net/ethernet/microchip/vcap/vcap_api.c

291

if (vcap_get_bit(stream, &iter))

drivers/net/ethernet/microchip/vcap/vcap_api.c

293

iter.offset++;

drivers/net/ethernet/microchip/vcap/vcap_api.c

294

vcap_iter_update(&iter);

drivers/net/ethernet/microchip/vcap/vcap_api.c

298

iter.tg++; /* next typegroup */

drivers/net/ethernet/microchip/vcap/vcap_api.c

453

struct vcap_stream_iter iter;

drivers/net/ethernet/microchip/vcap/vcap_api.c

493

vcap_iter_init(&iter, sw_width, tgt, rf->offset);

drivers/net/ethernet/microchip/vcap/vcap_api.c

494

vcap_encode_field(cache->keystream, &iter, rf->width, value);

drivers/net/ethernet/microchip/vcap/vcap_api.c

495

vcap_iter_init(&iter, sw_width, tgt, rf->offset);

drivers/net/ethernet/microchip/vcap/vcap_api.c

496

vcap_encode_field(cache->maskstream, &iter, rf->width, mask);

drivers/net/ethernet/microchip/vcap/vcap_api.c

747

struct vcap_stream_iter iter;

drivers/net/ethernet/microchip/vcap/vcap_api.c

777

vcap_iter_init(&iter, act_width, tgt, rf->offset);

drivers/net/ethernet/microchip/vcap/vcap_api.c

778

vcap_encode_field(cache->actionstream, &iter, rf->width, value);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

331

struct vcap_stream_iter iter = {

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

340

vcap_set_bit(stream, &iter, 1);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

348

struct vcap_stream_iter iter = {

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

357

vcap_set_bit(stream, &iter, 0);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

366

struct vcap_stream_iter iter;

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

379

vcap_iter_init(&iter, 52, typegroups, 86);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

381

KUNIT_EXPECT_EQ(test, 52, iter.sw_width);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

382

KUNIT_EXPECT_EQ(test, 86 + 2, iter.offset);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

383

KUNIT_EXPECT_EQ(test, 3, iter.reg_idx);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

384

KUNIT_EXPECT_EQ(test, 4, iter.reg_bitpos);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

386

vcap_iter_init(&iter, 49, typegroups2, 134);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

388

KUNIT_EXPECT_EQ(test, 49, iter.sw_width);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

389

KUNIT_EXPECT_EQ(test, 134 + 7, iter.offset);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

390

KUNIT_EXPECT_EQ(test, 5, iter.reg_idx);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

391

KUNIT_EXPECT_EQ(test, 11, iter.reg_bitpos);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

396

struct vcap_stream_iter iter;

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

408

vcap_iter_init(&iter, 49, typegroups, 86);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

410

KUNIT_EXPECT_EQ(test, 49, iter.sw_width);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

411

KUNIT_EXPECT_EQ(test, 86 + 5, iter.offset);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

412

KUNIT_EXPECT_EQ(test, 3, iter.reg_idx);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

413

KUNIT_EXPECT_EQ(test, 10, iter.reg_bitpos);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

415

vcap_iter_next(&iter);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

417

KUNIT_EXPECT_EQ(test, 91 + 1, iter.offset);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

418

KUNIT_EXPECT_EQ(test, 3, iter.reg_idx);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

419

KUNIT_EXPECT_EQ(test, 11, iter.reg_bitpos);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

422

vcap_iter_next(&iter);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

424

KUNIT_EXPECT_EQ(test, 92 + 6 + 2, iter.offset);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

425

KUNIT_EXPECT_EQ(test, 4, iter.reg_idx);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

426

KUNIT_EXPECT_EQ(test, 2, iter.reg_bitpos);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

460

struct vcap_stream_iter iter;

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

472

vcap_iter_init(&iter, 49, typegroups, 44);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

474

KUNIT_EXPECT_EQ(test, 48, iter.offset);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

475

KUNIT_EXPECT_EQ(test, 1, iter.reg_idx);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

476

KUNIT_EXPECT_EQ(test, 16, iter.reg_bitpos);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

478

vcap_encode_bit(stream, &iter, 1);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

487

struct vcap_stream_iter iter;

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

505

vcap_iter_init(&iter, 49, typegroups, rf.offset);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

507

KUNIT_EXPECT_EQ(test, 91, iter.offset);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

508

KUNIT_EXPECT_EQ(test, 3, iter.reg_idx);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

509

KUNIT_EXPECT_EQ(test, 10, iter.reg_bitpos);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

511

vcap_encode_field(stream, &iter, rf.width, value);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

538

struct vcap_stream_iter iter;

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

554

vcap_iter_init(&iter, sw_width, tgt, rf.offset);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

556

KUNIT_EXPECT_EQ(test, 1, iter.regs_per_sw);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

557

KUNIT_EXPECT_EQ(test, 21, iter.sw_width);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

558

KUNIT_EXPECT_EQ(test, 25 + 3 + 2, iter.offset);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

559

KUNIT_EXPECT_EQ(test, 1, iter.reg_idx);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

560

KUNIT_EXPECT_EQ(test, 25 + 3 + 2 - sw_width, iter.reg_bitpos);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

562

vcap_encode_field(stream, &iter, rf.width, value);

drivers/net/ethernet/mscc/ocelot_net.c

1555

struct list_head *iter;

drivers/net/ethernet/mscc/ocelot_net.c

1558

netdev_for_each_lower_dev(dev, lower, iter) {

drivers/net/ethernet/mscc/ocelot_net.c

1592

struct list_head *iter;

drivers/net/ethernet/mscc/ocelot_net.c

1595

netdev_for_each_lower_dev(dev, lower, iter) {

drivers/net/ethernet/netronome/nfp/abm/cls.c

110

struct nfp_abm_u32_match *iter;

drivers/net/ethernet/netronome/nfp/abm/cls.c

112

list_for_each_entry(iter, &alink->dscp_map, list)

drivers/net/ethernet/netronome/nfp/abm/cls.c

113

if ((prio & iter->mask) == iter->val)

drivers/net/ethernet/netronome/nfp/abm/cls.c

114

return iter->band;

drivers/net/ethernet/netronome/nfp/abm/cls.c

158

struct nfp_abm_u32_match *iter;

drivers/net/ethernet/netronome/nfp/abm/cls.c

160

list_for_each_entry(iter, &alink->dscp_map, list)

drivers/net/ethernet/netronome/nfp/abm/cls.c

161

if (iter->handle == knode->handle) {

drivers/net/ethernet/netronome/nfp/abm/cls.c

162

list_del(&iter->list);

drivers/net/ethernet/netronome/nfp/abm/cls.c

163

kfree(iter);

drivers/net/ethernet/netronome/nfp/abm/cls.c

174

struct nfp_abm_u32_match *match = NULL, *iter;

drivers/net/ethernet/netronome/nfp/abm/cls.c

189

list_for_each_entry(iter, &alink->dscp_map, list) {

drivers/net/ethernet/netronome/nfp/abm/cls.c

192

if (iter->handle == knode->handle) {

drivers/net/ethernet/netronome/nfp/abm/cls.c

193

match = iter;

drivers/net/ethernet/netronome/nfp/abm/cls.c

197

cmask = iter->mask & mask;

drivers/net/ethernet/netronome/nfp/abm/cls.c

198

if ((iter->val & cmask) == (val & cmask) &&

drivers/net/ethernet/netronome/nfp/abm/cls.c

199

iter->band != knode->res->classid) {

drivers/net/ethernet/netronome/nfp/abm/qdisc.c

248

struct radix_tree_iter iter;

drivers/net/ethernet/netronome/nfp/abm/qdisc.c

260

radix_tree_for_each_slot(slot, &alink->qdiscs, &iter, 0) {

drivers/net/ethernet/netronome/nfp/abm/qdisc.c

269

radix_tree_for_each_slot(slot, &alink->qdiscs, &iter, 0) {

drivers/net/ethernet/netronome/nfp/abm/qdisc.c

288

struct radix_tree_iter iter;

drivers/net/ethernet/netronome/nfp/abm/qdisc.c

303

radix_tree_for_each_slot(slot, &alink->qdiscs, &iter, 0) {

drivers/net/ethernet/netronome/nfp/flower/conntrack.c

1790

struct rhashtable_iter iter;

drivers/net/ethernet/netronome/nfp/flower/conntrack.c

1792

rhashtable_walk_enter(&zt->tc_merge_tb, &iter);

drivers/net/ethernet/netronome/nfp/flower/conntrack.c

1793

rhashtable_walk_start(&iter);

drivers/net/ethernet/netronome/nfp/flower/conntrack.c

1794

while ((tc_merge_entry = rhashtable_walk_next(&iter)) != NULL) {

drivers/net/ethernet/netronome/nfp/flower/conntrack.c

1797

rhashtable_walk_stop(&iter);

drivers/net/ethernet/netronome/nfp/flower/conntrack.c

1799

rhashtable_walk_start(&iter);

drivers/net/ethernet/netronome/nfp/flower/conntrack.c

1801

rhashtable_walk_stop(&iter);

drivers/net/ethernet/netronome/nfp/flower/conntrack.c

1802

rhashtable_walk_exit(&iter);

drivers/net/ethernet/netronome/nfp/flower/conntrack.c

1944

struct rhashtable_iter iter;

drivers/net/ethernet/netronome/nfp/flower/conntrack.c

1947

rhashtable_walk_enter(&priv->ct_zone_table, &iter);

drivers/net/ethernet/netronome/nfp/flower/conntrack.c

1948

rhashtable_walk_start(&iter);

drivers/net/ethernet/netronome/nfp/flower/conntrack.c

1949

while ((zone_table = rhashtable_walk_next(&iter)) != NULL) {

drivers/net/ethernet/netronome/nfp/flower/conntrack.c

1952

rhashtable_walk_stop(&iter);

drivers/net/ethernet/netronome/nfp/flower/conntrack.c

1954

rhashtable_walk_start(&iter);

drivers/net/ethernet/netronome/nfp/flower/conntrack.c

1956

rhashtable_walk_stop(&iter);

drivers/net/ethernet/netronome/nfp/flower/conntrack.c

1957

rhashtable_walk_exit(&iter);

drivers/net/ethernet/netronome/nfp/flower/qos_conf.c

675

struct rhashtable_iter iter;

drivers/net/ethernet/netronome/nfp/flower/qos_conf.c

678

rhashtable_walk_enter(&fl_priv->meter_table, &iter);

drivers/net/ethernet/netronome/nfp/flower/qos_conf.c

679

rhashtable_walk_start(&iter);

drivers/net/ethernet/netronome/nfp/flower/qos_conf.c

681

while ((meter_entry = rhashtable_walk_next(&iter)) != NULL) {

drivers/net/ethernet/netronome/nfp/flower/qos_conf.c

688

rhashtable_walk_stop(&iter);

drivers/net/ethernet/netronome/nfp/flower/qos_conf.c

689

rhashtable_walk_exit(&iter);

drivers/net/ethernet/netronome/nfp/flower/tunnel_conf.c

376

struct rhashtable_iter iter;

drivers/net/ethernet/netronome/nfp/flower/tunnel_conf.c

380

rhashtable_walk_enter(&priv->neigh_table, &iter);

drivers/net/ethernet/netronome/nfp/flower/tunnel_conf.c

381

rhashtable_walk_start(&iter);

drivers/net/ethernet/netronome/nfp/flower/tunnel_conf.c

382

while ((nn_entry = rhashtable_walk_next(&iter)) != NULL) {

drivers/net/ethernet/netronome/nfp/flower/tunnel_conf.c

395

rhashtable_walk_stop(&iter);

drivers/net/ethernet/netronome/nfp/flower/tunnel_conf.c

396

rhashtable_walk_exit(&iter);

drivers/net/ethernet/netronome/nfp/flower/tunnel_conf.c

404

struct rhashtable_iter iter;

drivers/net/ethernet/netronome/nfp/flower/tunnel_conf.c

408

rhashtable_walk_enter(&priv->neigh_table, &iter);

drivers/net/ethernet/netronome/nfp/flower/tunnel_conf.c

409

rhashtable_walk_start(&iter);

drivers/net/ethernet/netronome/nfp/flower/tunnel_conf.c

410

while ((neigh = rhashtable_walk_next(&iter)) != NULL) {

drivers/net/ethernet/netronome/nfp/flower/tunnel_conf.c

434

rhashtable_walk_stop(&iter);

drivers/net/ethernet/netronome/nfp/flower/tunnel_conf.c

435

rhashtable_walk_exit(&iter);

drivers/net/ethernet/qlogic/qed/qed_vf.c

108

iter = QED_VF_CHANNEL_USLEEP_ITERATIONS;

drivers/net/ethernet/qlogic/qed/qed_vf.c

109

while (!*done && iter--) {

drivers/net/ethernet/qlogic/qed/qed_vf.c

114

iter = QED_VF_CHANNEL_MSLEEP_ITERATIONS;

drivers/net/ethernet/qlogic/qed/qed_vf.c

115

while (!*done && iter--) {

drivers/net/ethernet/qlogic/qed/qed_vf.c

68

int iter, rc = 0;

drivers/net/ethernet/qlogic/qede/qede_ethtool.c

1553

int i, iter, rc = 0;

drivers/net/ethernet/qlogic/qede/qede_ethtool.c

1572

for (iter = 0; iter < QEDE_SELFTEST_POLL_COUNT; iter++) {

drivers/net/ethernet/qlogic/qede/qede_ethtool.c

1609

if (iter == QEDE_SELFTEST_POLL_COUNT) {

drivers/net/ethernet/sun/ldmvsw.c

171

struct vnet *iter;

drivers/net/ethernet/sun/ldmvsw.c

197

list_for_each_entry(iter, &vnet_list, list) {

drivers/net/ethernet/sun/ldmvsw.c

198

if (iter->local_mac == *local_mac) {

drivers/net/ethernet/sun/ldmvsw.c

199

vp = iter;

drivers/net/ethernet/sun/sunvnet.c

334

struct vnet *iter, *vp;

drivers/net/ethernet/sun/sunvnet.c

338

list_for_each_entry(iter, &vnet_list, list) {

drivers/net/ethernet/sun/sunvnet.c

339

if (iter->local_mac == *local_mac) {

drivers/net/ethernet/sun/sunvnet.c

340

vp = iter;

drivers/net/netdevsim/fib.c

580

struct nsim_fib6_rt_nh *iter, *tmp;

drivers/net/netdevsim/fib.c

582

list_for_each_entry_safe(iter, tmp, &fib6_rt->nh_list, list)

drivers/net/netdevsim/fib.c

583

nsim_fib6_rt_nh_del(fib6_rt, iter->rt);

drivers/net/netdevsim/fib.c

804

struct fib6_info *iter;

drivers/net/netdevsim/fib.c

823

list_for_each_entry(iter, &rt->fib6_siblings, fib6_siblings) {

drivers/net/netdevsim/fib.c

827

rt_arr[i + 1] = iter;

drivers/net/netdevsim/fib.c

828

fib6_info_hold(iter);

drivers/net/phy/mscc/mscc_serdes.c

321

u32 iter;

drivers/net/phy/mscc/mscc_serdes.c

443

for (iter = 0; iter < gp_iter; iter++) {

drivers/net/tap.c

706

struct iov_iter *iter)

drivers/net/tap.c

722

ret = tun_vnet_hdr_put(vnet_hdr_len, iter, &vnet_hdr);

drivers/net/tap.c

740

ret = skb_copy_datagram_iter(skb, 0, iter, vlan_offset);

drivers/net/tap.c

741

if (ret || !iov_iter_count(iter))

drivers/net/tap.c

744

ret = copy_to_iter(&veth, sizeof(veth), iter);

drivers/net/tap.c

745

if (ret != sizeof(veth) || !iov_iter_count(iter))

drivers/net/tap.c

749

ret = skb_copy_datagram_iter(skb, vlan_offset, iter,

drivers/net/tun.c

2010

struct iov_iter *iter)

drivers/net/tun.c

2020

ret = tun_vnet_hdr_put(vnet_hdr_sz, iter, &gso);

drivers/net/tun.c

2025

ret = copy_to_iter(xdp_frame->data, size, iter) + vnet_hdr_sz;

drivers/net/tun.c

2038

struct iov_iter *iter)

drivers/net/tun.c

2056

if (iov_iter_count(iter) < sizeof(pi))

drivers/net/tun.c

2060

if (iov_iter_count(iter) < total) {

drivers/net/tun.c

2065

if (copy_to_iter(&pi, sizeof(pi), iter) != sizeof(pi))

drivers/net/tun.c

2085

iter, gso);

drivers/net/tun.c

2099

ret = skb_copy_datagram_iter(skb, 0, iter, vlan_offset);

drivers/net/tun.c

2100

if (ret || !iov_iter_count(iter))

drivers/net/tun.c

2103

ret = copy_to_iter(&veth, sizeof(veth), iter);

drivers/net/tun.c

2104

if (ret != sizeof(veth) || !iov_iter_count(iter))

drivers/net/tun.c

2108

skb_copy_datagram_iter(skb, vlan_offset, iter, skb->len - vlan_offset);

drivers/net/tun_vnet.h

157

struct iov_iter *iter,

drivers/net/tun_vnet.h

162

if (unlikely(iov_iter_count(iter) < sz))

drivers/net/tun_vnet.h

165

if (unlikely(copy_to_iter(hdr, parsed_size, iter) != parsed_size))

drivers/net/tun_vnet.h

168

if (iov_iter_zero(sz - parsed_size, iter) != sz - parsed_size)

drivers/net/tun_vnet.h

174

static inline int tun_vnet_hdr_put(int sz, struct iov_iter *iter,

drivers/net/tun_vnet.h

177

return __tun_vnet_hdr_put(sz, 0, iter, hdr);

drivers/net/usb/qmi_wwan.c

142

struct list_head *iter;

drivers/net/usb/qmi_wwan.c

146

netdev_for_each_upper_dev_rcu(dev->net, ldev, iter) {

drivers/net/usb/qmi_wwan.c

1582

struct list_head *iter;

drivers/net/usb/qmi_wwan.c

1596

netdev_for_each_upper_dev_rcu(dev->net, ldev, iter)

drivers/net/usb/qmi_wwan.c

395

struct list_head *iter;

drivers/net/usb/qmi_wwan.c

400

netdev_for_each_upper_dev_rcu(dev, ldev, iter) {

drivers/net/vrf.c

1626

struct list_head *iter;

drivers/net/vrf.c

1628

netdev_for_each_lower_dev(dev, port_dev, iter)

drivers/net/wireless/ath/ath10k/wmi-tlv.c

113

ret = iter(ar, tlv_tag, tlv_len, ptr, data);

drivers/net/wireless/ath/ath10k/wmi-tlv.c

73

int (*iter)(struct ath10k *ar, u16 tag, u16 len,

drivers/net/wireless/ath/ath11k/dp_rx.c

1326

int (*iter)(struct ath11k_base *ar, u16 tag, u16 len,

drivers/net/wireless/ath/ath11k/dp_rx.c

1352

ret = iter(ab, tlv_tag, tlv_len, ptr, data);

drivers/net/wireless/ath/ath11k/dp_rx.h

81

int (*iter)(struct ath11k_base *ar, u16 tag, u16 len,

drivers/net/wireless/ath/ath11k/wmi.c

180

int (*iter)(struct ath11k_base *ab, u16 tag, u16 len,

drivers/net/wireless/ath/ath11k/wmi.c

217

ret = iter(ab, tlv_tag, tlv_len, ptr, data);

drivers/net/wireless/ath/ath12k/dp_htt.c

150

int (*iter)(struct ath12k_base *ab, u16 tag, u16 len,

drivers/net/wireless/ath/ath12k/dp_htt.c

176

ret = iter(ab, tlv_tag, tlv_len, ptr, data);

drivers/net/wireless/ath/ath12k/dp_htt.h

1538

int (*iter)(struct ath12k_base *ab, u16 tag, u16 len,

drivers/net/wireless/ath/ath12k/wmi.c

301

int (*iter)(struct ath12k_base *ab, u16 tag, u16 len,

drivers/net/wireless/ath/ath12k/wmi.c

338

ret = iter(ab, tlv_tag, tlv_len, ptr, data);

drivers/net/wireless/ath/carl9170/debug.c

299

struct carl9170_sta_tid *iter;

drivers/net/wireless/ath/carl9170/debug.c

305

list_for_each_entry_rcu(iter, &ar->tx_ampdu_list, list) {

drivers/net/wireless/ath/carl9170/debug.c

307

spin_lock_bh(&iter->lock);

drivers/net/wireless/ath/carl9170/debug.c

310

cnt, iter->tid, iter->bsn, iter->snx, iter->hsn,

drivers/net/wireless/ath/carl9170/debug.c

311

iter->max, iter->state, iter->counter);

drivers/net/wireless/ath/carl9170/debug.c

314

CARL9170_BAW_BITS, iter->bitmap);

drivers/net/wireless/ath/carl9170/debug.c

323

offset = BM_STR_OFF(SEQ_DIFF(iter->snx, iter->bsn));

drivers/net/wireless/ath/carl9170/debug.c

326

offset = BM_STR_OFF(((int)iter->hsn - (int)iter->bsn) %

drivers/net/wireless/ath/carl9170/debug.c

331

" currently queued:%d\n", skb_queue_len(&iter->queue));

drivers/net/wireless/ath/carl9170/debug.c

334

skb_queue_walk(&iter->queue, skb) {

drivers/net/wireless/ath/carl9170/debug.c

343

spin_unlock_bh(&iter->lock);

drivers/net/wireless/ath/carl9170/debug.c

435

struct carl9170_vif_info *iter;

drivers/net/wireless/ath/carl9170/debug.c

445

list_for_each_entry_rcu(iter, &ar->vif_list, list) {

drivers/net/wireless/ath/carl9170/debug.c

446

struct ieee80211_vif *vif = carl9170_get_vif(iter);

drivers/net/wireless/ath/carl9170/debug.c

449

"Master" : " Slave"), iter->id, vif->type, vif->addr,

drivers/net/wireless/ath/carl9170/debug.c

450

iter->enable_beacon ? "beaconing " : "");

drivers/net/wireless/ath/carl9170/fw.c

23

const struct carl9170fw_desc_head *iter;

drivers/net/wireless/ath/carl9170/fw.c

25

carl9170fw_for_each_hdr(iter, ar->fw.desc) {

drivers/net/wireless/ath/carl9170/fw.c

26

if (carl9170fw_desc_cmp(iter, descid, len,

drivers/net/wireless/ath/carl9170/fw.c

28

return (void *)iter;

drivers/net/wireless/ath/carl9170/fw.c

32

if (carl9170fw_desc_cmp(iter, descid, len,

drivers/net/wireless/ath/carl9170/fw.c

34

return (void *)iter;

drivers/net/wireless/ath/carl9170/main.c

1050

struct carl9170_vif_info *iter;

drivers/net/wireless/ath/carl9170/main.c

1055

list_for_each_entry_rcu(iter, &ar->vif_list, list) {

drivers/net/wireless/ath/carl9170/main.c

1056

if (iter->active && iter->enable_beacon)

drivers/net/wireless/ath/carl9170/tx.c

1402

struct sk_buff *iter;

drivers/net/wireless/ath/carl9170/tx.c

1437

skb_queue_reverse_walk(&agg->queue, iter) {

drivers/net/wireless/ath/carl9170/tx.c

1438

qseq = carl9170_get_seq(iter);

drivers/net/wireless/ath/carl9170/tx.c

1441

__skb_queue_after(&agg->queue, iter, skb);

drivers/net/wireless/ath/carl9170/tx.c

605

struct carl9170_sta_tid *iter;

drivers/net/wireless/ath/carl9170/tx.c

612

list_for_each_entry_rcu(iter, &ar->tx_ampdu_list, list) {

drivers/net/wireless/ath/carl9170/tx.c

613

if (iter->state < CARL9170_TID_STATE_IDLE)

drivers/net/wireless/ath/carl9170/tx.c

616

spin_lock_bh(&iter->lock);

drivers/net/wireless/ath/carl9170/tx.c

617

skb = skb_peek(&iter->queue);

drivers/net/wireless/ath/carl9170/tx.c

627

sta = iter->sta;

drivers/net/wireless/ath/carl9170/tx.c

631

ieee80211_stop_tx_ba_session(sta, iter->tid);

drivers/net/wireless/ath/carl9170/tx.c

633

spin_unlock_bh(&iter->lock);

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

1123

struct iwl_txf_iter_data *iter = &fwrt->dump.txf_iter_data;

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

1133

size += iter->fifo_size;

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

377

struct iwl_txf_iter_data *iter = &fwrt->dump.txf_iter_data;

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

39

struct scatterlist *new, *iter;

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

390

iter->internal_txf = 0;

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

391

iter->fifo_size = 0;

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

392

iter->fifo = -1;

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

394

iter->lmac = 1;

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

396

iter->lmac = 0;

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

399

if (!iter->internal_txf) {

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

400

for (iter->fifo++; iter->fifo < txf_num; iter->fifo++) {

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

401

iter->fifo_size =

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

402

cfg->lmac[iter->lmac].txfifo_size[iter->fifo];

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

403

if (iter->fifo_size && (lmac_bitmap & BIT(iter->fifo)))

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

406

iter->fifo--;

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

409

iter->internal_txf = 1;

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

415

for (iter->fifo++; iter->fifo < int_txf_num + txf_num; iter->fifo++) {

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

416

iter->fifo_size =

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

417

cfg->internal_txfifo_size[iter->fifo - txf_num];

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

418

if (iter->fifo_size && (lmac_bitmap & BIT(iter->fifo)))

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

431

struct iwl_txf_iter_data *iter = &fwrt->dump.txf_iter_data;

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

442

range->fifo_hdr.fifo_num = cpu_to_le32(iter->fifo);

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

444

range->range_data_size = cpu_to_le32(iter->fifo_size + registers_size);

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

446

iwl_trans_write_prph(fwrt->trans, TXF_LARC_NUM + offs, iter->fifo);

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

477

for (i = 0; i < iter->fifo_size; i += sizeof(*data))

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

482

reg_dump, iter->fifo_size);

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

70

for_each_sg(new, iter, n_fill, i) {

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

78

sg_set_page(iter, new_page, PAGE_SIZE, 0);

drivers/net/wireless/intel/iwlwifi/mei/main.c

2063

unsigned int iter = IWLMEI_DEVICE_DOWN_WAIT_ITERATION;

drivers/net/wireless/intel/iwlwifi/mei/main.c

2071

while (!down && iter--) {

drivers/net/wireless/intel/iwlwifi/mld/iface.c

391

struct ieee80211_vif *iter;

drivers/net/wireless/intel/iwlwifi/mld/iface.c

406

for_each_active_interface(iter, mld->hw) {

drivers/net/wireless/intel/iwlwifi/mld/iface.c

407

if (iter->type != NL80211_IFTYPE_NAN_DATA)

drivers/net/wireless/intel/iwlwifi/mld/iface.c

413

memcpy(cmd->nan.ndi_addrs[idx].addr, iter->addr, ETH_ALEN);

drivers/net/wireless/intel/iwlwifi/mld/nan.c

859

struct ieee80211_vif *iter;

drivers/net/wireless/intel/iwlwifi/mld/nan.c

861

for_each_active_interface(iter, mld->hw)

drivers/net/wireless/intel/iwlwifi/mld/nan.c

862

iwl_mld_nan_set_mcast_data_links(iter);

drivers/net/wireless/intel/iwlwifi/mld/nan.c

945

struct ieee80211_sta *iter;

drivers/net/wireless/intel/iwlwifi/mld/nan.c

948

for_each_station(iter, mld->hw) {

drivers/net/wireless/intel/iwlwifi/mld/nan.c

949

struct iwl_mld_sta *tmp = iwl_mld_sta_from_mac80211(iter);

drivers/net/wireless/intel/iwlwifi/mld/nan.c

952

iwl_mld_config_tlc(mld, tmp->vif, iter);

drivers/net/wireless/intel/iwlwifi/mld/tlc.c

645

struct ieee80211_sta *nmi, *iter;

drivers/net/wireless/intel/iwlwifi/mld/tlc.c

657

for_each_station(iter, mld->hw) {

drivers/net/wireless/intel/iwlwifi/mld/tlc.c

658

struct iwl_mld_sta *mld_sta = iwl_mld_sta_from_mac80211(iter);

drivers/net/wireless/intel/iwlwifi/mld/tlc.c

661

iter_nmi = wiphy_dereference(mld->wiphy, iter->nmi);

drivers/net/wireless/intel/iwlwifi/mvm/ftm-initiator.c

1133

struct iwl_mvm_smooth_entry *resp = NULL, *iter;

drivers/net/wireless/intel/iwlwifi/mvm/ftm-initiator.c

1150

list_for_each_entry(iter, &mvm->ftm_initiator.smooth.resp, list) {

drivers/net/wireless/intel/iwlwifi/mvm/ftm-initiator.c

1151

if (!memcmp(res->addr, iter->addr, ETH_ALEN)) {

drivers/net/wireless/intel/iwlwifi/mvm/ftm-initiator.c

1152

resp = iter;

drivers/net/wireless/intel/iwlwifi/mvm/ftm-initiator.c

688

ieee80211_iter_keys(mvm->hw, vif, iter, &target);

drivers/net/wireless/intel/iwlwifi/pcie/gen1_2/trans.c

42

u32 block, u32 vec, u32 iter)

drivers/net/wireless/intel/iwlwifi/pcie/gen1_2/trans.c

48

for (i = 0; i < iter; i++)

drivers/net/wireless/intel/iwlwifi/pcie/gen1_2/trans.c

547

int iter;

drivers/net/wireless/intel/iwlwifi/pcie/gen1_2/trans.c

562

for (iter = 0; iter < 10; iter++) {

drivers/net/wireless/marvell/libertas/firmware.c

100

if (!iter->helper) {

drivers/net/wireless/marvell/libertas/firmware.c

106

if (iter->model != priv->fw_model) {

drivers/net/wireless/marvell/libertas/firmware.c

107

iter++;

drivers/net/wireless/marvell/libertas/firmware.c

111

priv->fw_iter = iter;

drivers/net/wireless/marvell/libertas/firmware.c

112

do_load_firmware(priv, iter->helper, helper_firmware_cb);

drivers/net/wireless/marvell/libertas/firmware.c

178

const struct lbs_fw_table *iter;

drivers/net/wireless/marvell/libertas/firmware.c

185

iter = fw_table;

drivers/net/wireless/marvell/libertas/firmware.c

186

while (iter && iter->helper) {

drivers/net/wireless/marvell/libertas/firmware.c

187

if (iter->model != card_model)

drivers/net/wireless/marvell/libertas/firmware.c

191

ret = request_firmware(helper, iter->helper, dev);

drivers/net/wireless/marvell/libertas/firmware.c

199

if (iter->fwname == NULL)

drivers/net/wireless/marvell/libertas/firmware.c

204

ret = request_firmware(mainfw, iter->fwname, dev);

drivers/net/wireless/marvell/libertas/firmware.c

218

iter++;

drivers/net/wireless/marvell/libertas/firmware.c

87

const struct lbs_fw_table *iter;

drivers/net/wireless/marvell/libertas/firmware.c

90

iter = priv->fw_table;

drivers/net/wireless/marvell/libertas/firmware.c

92

iter = ++priv->fw_iter;

drivers/net/wireless/mediatek/mt76/dma.c

654

struct sk_buff *iter;

drivers/net/wireless/mediatek/mt76/dma.c

687

skb_walk_frags(skb, iter) {

drivers/net/wireless/mediatek/mt76/dma.c

691

addr = dma_map_single(dev->dma_dev, iter->data, iter->len,

drivers/net/wireless/mediatek/mt76/dma.c

697

tx_info.buf[n++].len = iter->len;

drivers/net/wireless/mediatek/mt76/mt7915/debugfs.c

1239

struct mt7915_twt_flow *iter;

drivers/net/wireless/mediatek/mt76/mt7915/debugfs.c

1245

list_for_each_entry_rcu(iter, &dev->twt_list, list)

drivers/net/wireless/mediatek/mt76/mt7915/debugfs.c

1248

iter->wcid, iter->id,

drivers/net/wireless/mediatek/mt76/mt7915/debugfs.c

1249

iter->sched ? 's' : 'u',

drivers/net/wireless/mediatek/mt76/mt7915/debugfs.c

1250

iter->protection ? 'p' : '-',

drivers/net/wireless/mediatek/mt76/mt7915/debugfs.c

1251

iter->trigger ? 't' : '-',

drivers/net/wireless/mediatek/mt76/mt7915/debugfs.c

1252

iter->flowtype ? '-' : 'a',

drivers/net/wireless/mediatek/mt76/mt7915/debugfs.c

1253

iter->exp, iter->mantissa,

drivers/net/wireless/mediatek/mt76/mt7915/debugfs.c

1254

iter->duration, iter->tsf);

drivers/net/wireless/mediatek/mt76/mt7915/mac.c

2183

struct mt7915_twt_flow *iter, *iter_next;

drivers/net/wireless/mediatek/mt76/mt7915/mac.c

2187

iter = list_first_entry_or_null(&dev->twt_list,

drivers/net/wireless/mediatek/mt76/mt7915/mac.c

2189

if (!iter || !iter->sched || iter->start_tsf > duration) {

drivers/net/wireless/mediatek/mt76/mt7915/mac.c

2195

list_for_each_entry_safe(iter, iter_next, &dev->twt_list, list) {

drivers/net/wireless/mediatek/mt76/mt7915/mac.c

2196

start_tsf = iter->start_tsf +

drivers/net/wireless/mediatek/mt76/mt7915/mac.c

2197

mt7915_mac_twt_duration_align(iter->duration);

drivers/net/wireless/mediatek/mt76/mt7915/mac.c

2198

if (list_is_last(&iter->list, &dev->twt_list))

drivers/net/wireless/mediatek/mt76/mt7915/mac.c

2203

list_add(&flow->list, &iter->list);

drivers/net/wireless/mediatek/mt76/mt7996/debugfs.c

820

struct mt7996_twt_flow *iter;

drivers/net/wireless/mediatek/mt76/mt7996/debugfs.c

826

list_for_each_entry_rcu(iter, &dev->twt_list, list)

drivers/net/wireless/mediatek/mt76/mt7996/debugfs.c

829

iter->wcid, iter->id,

drivers/net/wireless/mediatek/mt76/mt7996/debugfs.c

830

iter->sched ? 's' : 'u',

drivers/net/wireless/mediatek/mt76/mt7996/debugfs.c

831

iter->protection ? 'p' : '-',

drivers/net/wireless/mediatek/mt76/mt7996/debugfs.c

832

iter->trigger ? 't' : '-',

drivers/net/wireless/mediatek/mt76/mt7996/debugfs.c

833

iter->flowtype ? '-' : 'a',

drivers/net/wireless/mediatek/mt76/mt7996/debugfs.c

834

iter->exp, iter->mantissa,

drivers/net/wireless/mediatek/mt76/mt7996/debugfs.c

835

iter->duration, iter->tsf);

drivers/net/wireless/mediatek/mt76/mt7996/mac.c

3043

struct mt7996_twt_flow *iter, *iter_next;

drivers/net/wireless/mediatek/mt76/mt7996/mac.c

3047

iter = list_first_entry_or_null(&dev->twt_list,

drivers/net/wireless/mediatek/mt76/mt7996/mac.c

3049

if (!iter || !iter->sched || iter->start_tsf > duration) {

drivers/net/wireless/mediatek/mt76/mt7996/mac.c

3055

list_for_each_entry_safe(iter, iter_next, &dev->twt_list, list) {

drivers/net/wireless/mediatek/mt76/mt7996/mac.c

3056

start_tsf = iter->start_tsf +

drivers/net/wireless/mediatek/mt76/mt7996/mac.c

3057

mt7996_mac_twt_duration_align(iter->duration);

drivers/net/wireless/mediatek/mt76/mt7996/mac.c

3058

if (list_is_last(&iter->list, &dev->twt_list))

drivers/net/wireless/mediatek/mt76/mt7996/mac.c

3063

list_add(&flow->list, &iter->list);

drivers/net/wireless/mediatek/mt76/mt7996/main.c

476

struct ieee80211_bss_conf *iter;

drivers/net/wireless/mediatek/mt76/mt7996/main.c

482

for_each_vif_active_link(vif, iter, link_id) {

drivers/net/wireless/mediatek/mt76/sdio_txrx.c

254

struct sk_buff *iter;

drivers/net/wireless/mediatek/mt76/sdio_txrx.c

287

skb_walk_frags(e->skb, iter) {

drivers/net/wireless/mediatek/mt76/sdio_txrx.c

288

memcpy(sdio->xmit_buf + len, iter->data, iter->len);

drivers/net/wireless/mediatek/mt76/sdio_txrx.c

289

len += iter->len;

drivers/net/wireless/mediatek/mt76/tx.c

798

struct sk_buff *iter, *last = skb;

drivers/net/wireless/mediatek/mt76/tx.c

803

skb_walk_frags(skb, iter) {

drivers/net/wireless/mediatek/mt76/tx.c

804

last = iter;

drivers/net/wireless/mediatek/mt76/tx.c

805

if (!iter->next) {

drivers/net/wireless/realtek/rtl818x/rtl8187/dev.c

511

struct sk_buff *skb, *iter;

drivers/net/wireless/realtek/rtl818x/rtl8187/dev.c

521

skb_queue_reverse_walk(&priv->b_tx_status.queue, iter) {

drivers/net/wireless/realtek/rtl818x/rtl8187/dev.c

522

ieee80211hdr = (struct ieee80211_hdr *)iter->data;

drivers/net/wireless/realtek/rtl818x/rtl8187/dev.c

536

skb = iter;

drivers/net/wireless/realtek/rtlwifi/base.c

1992

struct rtl_bssid_entry *entry = NULL, *iter;

drivers/net/wireless/realtek/rtlwifi/base.c

2005

list_for_each_entry(iter, &rtlpriv->scan_list.list, list) {

drivers/net/wireless/realtek/rtlwifi/base.c

2006

if (memcmp(iter->bssid, hdr->addr3, ETH_ALEN) == 0) {

drivers/net/wireless/realtek/rtlwifi/base.c

2007

list_del_init(&iter->list);

drivers/net/wireless/realtek/rtlwifi/base.c

2008

entry = iter;

drivers/net/wireless/realtek/rtw88/fw.c

1630

struct sk_buff *iter;

drivers/net/wireless/realtek/rtw88/fw.c

1649

iter = rtw_get_rsvd_page_skb(hw, rsvd_pkt);

drivers/net/wireless/realtek/rtw88/fw.c

1650

if (!iter) {

drivers/net/wireless/realtek/rtw88/fw.c

1659

rtw_fill_rsvd_page_desc(rtwdev, iter, rsvd_pkt->type);

drivers/net/wireless/realtek/rtw88/fw.c

1661

rsvd_pkt->skb = iter;

drivers/net/wireless/realtek/rtw88/fw.c

1678

total_page += rtw_len_to_page(iter->len + tx_desc_sz,

drivers/net/wireless/realtek/rtw88/fw.c

1681

total_page += rtw_len_to_page(iter->len, page_size);

drivers/net/wireless/st/cw1200/queue.c

103

--queue->link_map_cache[iter->txpriv.link_id];

drivers/net/wireless/st/cw1200/queue.c

106

if (!--stats->link_map_cache[iter->txpriv.link_id])

drivers/net/wireless/st/cw1200/queue.c

110

cw1200_queue_register_post_gc(head, iter);

drivers/net/wireless/st/cw1200/queue.c

111

iter->skb = NULL;

drivers/net/wireless/st/cw1200/queue.c

112

list_move_tail(&iter->head, &queue->free_pool);

drivers/net/wireless/st/cw1200/queue.c

94

struct cw1200_queue_item *item = NULL, *iter, *tmp;

drivers/net/wireless/st/cw1200/queue.c

97

list_for_each_entry_safe(iter, tmp, &queue->queue, head) {

drivers/net/wireless/st/cw1200/queue.c

98

if (time_is_after_jiffies(iter->queue_timestamp + queue->ttl)) {

drivers/net/wireless/st/cw1200/queue.c

99

item = iter;

drivers/net/wireless/ti/wlcore/main.c

2867

struct wl12xx_vif *iter;

drivers/net/wireless/ti/wlcore/main.c

2881

wl12xx_for_each_wlvif(wl, iter) {

drivers/net/wireless/ti/wlcore/main.c

2882

if (iter != wlvif)

drivers/net/wireless/ti/wlcore/main.c

2888

WARN_ON(iter != wlvif);

drivers/net/wwan/wwan_core.c

416

struct class_dev_iter iter;

drivers/net/wwan/wwan_core.c

427

class_dev_iter_init(&iter, &wwan_class, NULL, &wwan_port_dev_type);

drivers/net/wwan/wwan_core.c

428

while ((dev = class_dev_iter_next(&iter))) {

drivers/net/wwan/wwan_core.c

437

class_dev_iter_exit(&iter);

drivers/nvdimm/btt.c

1442

struct bvec_iter iter;

drivers/nvdimm/btt.c

1455

bio_for_each_segment(bvec, bio, iter) {

drivers/nvdimm/btt.c

1467

bio_op(bio), iter.bi_sector);

drivers/nvdimm/btt.c

1473

(unsigned long long) iter.bi_sector, len);

drivers/nvdimm/pmem.c

207

struct bvec_iter iter;

drivers/nvdimm/pmem.c

217

bio_for_each_segment(bvec, bio, iter) {

drivers/nvdimm/pmem.c

220

iter.bi_sector, bvec.bv_len);

drivers/nvdimm/pmem.c

223

iter.bi_sector, bvec.bv_len);

drivers/nvme/host/ioctl.c

126

struct iov_iter *iter, unsigned int flags)

drivers/nvme/host/ioctl.c

138

if (iter)

drivers/nvme/host/ioctl.c

139

ret = blk_rq_map_user_iov(q, req, NULL, iter, GFP_KERNEL);

drivers/nvme/host/ioctl.c

454

struct iov_iter iter;

drivers/nvme/host/ioctl.c

497

ddir, &iter, issue_flags);

drivers/nvme/host/ioctl.c

500

ddir, &iter, ioucmd, issue_flags);

drivers/nvme/host/ioctl.c

504

map_iter = &iter;

drivers/nvme/host/pci.c

1000

if (!blk_rq_dma_map_iter_next(req, dma_dev, iter))

drivers/nvme/host/pci.c

1002

return nvme_pci_prp_save_mapping(req, dma_dev, iter);

drivers/nvme/host/pci.c

1005

static void nvme_unmap_iter(struct request *req, struct blk_dma_iter *iter,

drivers/nvme/host/pci.c

1011

if (!blk_rq_dma_unmap(req, dev, state, iter->len, iter->p2pdma.map)) {

drivers/nvme/host/pci.c

1014

if (iter->p2pdma.map == PCI_P2PDMA_MAP_THRU_HOST_BRIDGE)

drivers/nvme/host/pci.c

1017

dma_unmap_phys(dev, iter->addr, iter->len, rq_dma_dir(req),

drivers/nvme/host/pci.c

1023

struct blk_dma_iter *iter)

drivers/nvme/host/pci.c

1032

if (!nvme_pci_prp_save_mapping(req, nvmeq->dev->dev, iter)) {

drivers/nvme/host/pci.c

1033

nvme_unmap_iter(req, iter, &iod->dma_state);

drivers/nvme/host/pci.c

1034

return iter->status;

drivers/nvme/host/pci.c

1043

prp1_dma = iter->addr;

drivers/nvme/host/pci.c

1045

(iter->addr & (NVME_CTRL_PAGE_SIZE - 1)));

drivers/nvme/host/pci.c

1047

iter->addr += prp_len;

drivers/nvme/host/pci.c

1048

iter->len -= prp_len;

drivers/nvme/host/pci.c

1053

if (!nvme_pci_prp_iter_next(req, nvmeq->dev->dev, iter)) {

drivers/nvme/host/pci.c

1054

if (WARN_ON_ONCE(!iter->status))

drivers/nvme/host/pci.c

1064

prp2_dma = iter->addr;

drivers/nvme/host/pci.c

1076

iter->status = BLK_STS_RESOURCE;

drivers/nvme/host/pci.c

1083

prp_list[i++] = cpu_to_le64(iter->addr);

drivers/nvme/host/pci.c

1085

if (WARN_ON_ONCE(iter->len < prp_len))

drivers/nvme/host/pci.c

1089

iter->addr += prp_len;

drivers/nvme/host/pci.c

1090

iter->len -= prp_len;

drivers/nvme/host/pci.c

1095

if (!nvme_pci_prp_iter_next(req, nvmeq->dev->dev, iter)) {

drivers/nvme/host/pci.c

1096

if (WARN_ON_ONCE(!iter->status))

drivers/nvme/host/pci.c

1114

iter->status = BLK_STS_RESOURCE;

drivers/nvme/host/pci.c

1132

if (unlikely(iter->status))

drivers/nvme/host/pci.c

1134

return iter->status;

drivers/nvme/host/pci.c

1145

struct blk_dma_iter *iter)

drivers/nvme/host/pci.c

1147

sge->addr = cpu_to_le64(iter->addr);

drivers/nvme/host/pci.c

1148

sge->length = cpu_to_le32(iter->len);

drivers/nvme/host/pci.c

1161

struct blk_dma_iter *iter)

drivers/nvme/host/pci.c

1174

nvme_pci_sgl_set_data(&iod->cmd.common.dptr.sgl, iter);

drivers/nvme/host/pci.c

1175

iod->total_len += iter->len;

drivers/nvme/host/pci.c

1185

nvme_unmap_iter(req, iter, &iod->dma_state);

drivers/nvme/host/pci.c

1193

iter->status = BLK_STS_IOERR;

drivers/nvme/host/pci.c

1196

nvme_pci_sgl_set_data(&sg_list[mapped++], iter);

drivers/nvme/host/pci.c

1197

iod->total_len += iter->len;

drivers/nvme/host/pci.c

1198

} while (blk_rq_dma_map_iter_next(req, nvmeq->dev->dev, iter));

drivers/nvme/host/pci.c

1201

if (unlikely(iter->status))

drivers/nvme/host/pci.c

1203

return iter->status;

drivers/nvme/host/pci.c

1251

struct blk_dma_iter iter;

drivers/nvme/host/pci.c

1264

if (!blk_rq_dma_map_iter_start(req, dev->dev, &iod->dma_state, &iter))

drivers/nvme/host/pci.c

1265

return iter.status;

drivers/nvme/host/pci.c

1267

switch (iter.p2pdma.map) {

drivers/nvme/host/pci.c

1283

return nvme_pci_setup_data_sgl(req, &iter);

drivers/nvme/host/pci.c

1284

return nvme_pci_setup_data_prp(req, &iter);

drivers/nvme/host/pci.c

1294

struct blk_dma_iter iter;

drivers/nvme/host/pci.c

1299

&iod->meta_dma_state, &iter))

drivers/nvme/host/pci.c

1300

return iter.status;

drivers/nvme/host/pci.c

1302

switch (iter.p2pdma.map) {

drivers/nvme/host/pci.c

1336

iod->cmd.common.metadata = cpu_to_le64(iter.addr);

drivers/nvme/host/pci.c

1337

iod->meta_total_len = iter.len;

drivers/nvme/host/pci.c

1338

iod->meta_dma = iter.addr;

drivers/nvme/host/pci.c

1346

nvme_unmap_iter(req, &iter, &iod->meta_dma_state);

drivers/nvme/host/pci.c

1355

iod->meta_total_len = iter.len;

drivers/nvme/host/pci.c

1356

nvme_pci_sgl_set_data(sg_list, &iter);

drivers/nvme/host/pci.c

1362

nvme_pci_sgl_set_data(&sg_list[++i], &iter);

drivers/nvme/host/pci.c

1363

iod->meta_total_len += iter.len;

drivers/nvme/host/pci.c

1364

} while (blk_rq_integrity_dma_map_iter_next(req, dev->dev, &iter));

drivers/nvme/host/pci.c

1367

if (unlikely(iter.status))

drivers/nvme/host/pci.c

1369

return iter.status;

drivers/nvme/host/pci.c

970

struct blk_dma_iter *iter)

drivers/nvme/host/pci.c

984

iter->status = BLK_STS_RESOURCE;

drivers/nvme/host/pci.c

989

iod->dma_vecs[iod->nr_dma_vecs].addr = iter->addr;

drivers/nvme/host/pci.c

990

iod->dma_vecs[iod->nr_dma_vecs].len = iter->len;

drivers/nvme/host/pci.c

996

struct blk_dma_iter *iter)

drivers/nvme/host/pci.c

998

if (iter->len)

drivers/nvme/host/tcp.c

313

return req->iter.bvec->bv_page;

drivers/nvme/host/tcp.c

318

return req->iter.bvec->bv_offset + req->iter.iov_offset;

drivers/nvme/host/tcp.c

323

return min_t(size_t, iov_iter_single_seg_count(&req->iter),

drivers/nvme/host/tcp.c

345

iov_iter_bvec(&req->iter, dir, &rq->special_vec, 1,

drivers/nvme/host/tcp.c

347

req->iter.iov_offset = 0;

drivers/nvme/host/tcp.c

357

iov_iter_bvec(&req->iter, dir,

drivers/nvme/host/tcp.c

360

req->iter.iov_offset = bio->bi_iter.bi_bvec_done;

drivers/nvme/host/tcp.c

369

iov_iter_advance(&req->iter, len);

drivers/nvme/host/tcp.c

370

if (!iov_iter_count(&req->iter) &&

drivers/nvme/host/tcp.c

82

struct iov_iter iter;

drivers/nvme/host/tcp.c

919

if (!iov_iter_count(&req->iter)) {

drivers/nvme/host/tcp.c

938

iov_iter_count(&req->iter));

drivers/nvme/host/tcp.c

942

&req->iter, recv_len, &queue->rcv_crc);

drivers/nvme/host/tcp.c

945

&req->iter, recv_len);

drivers/nvme/target/core.c

1571

struct radix_tree_iter iter;

drivers/nvme/target/core.c

1576

radix_tree_for_each_slot(slot, &ctrl->p2p_ns_map, &iter, 0)

drivers/nvme/target/io-cmd-file.c

100

return call_iter(iocb, &iter);

drivers/nvme/target/io-cmd-file.c

80

ssize_t (*call_iter)(struct kiocb *iocb, struct iov_iter *iter);

drivers/nvme/target/io-cmd-file.c

81

struct iov_iter iter;

drivers/nvme/target/io-cmd-file.c

94

iov_iter_bvec(&iter, rw, req->f.bvec, nr_segs, count);

drivers/nvmem/core.c

1373

struct nvmem_cell_entry *iter, *cell = NULL;

drivers/nvmem/core.c

1376

list_for_each_entry(iter, &nvmem->cells, node) {

drivers/nvmem/core.c

1377

if (np == iter->np) {

drivers/nvmem/core.c

1378

cell = iter;

drivers/nvmem/core.c

722

struct nvmem_cell_entry *iter, *cell = NULL;

drivers/nvmem/core.c

725

list_for_each_entry(iter, &nvmem->cells, node) {

drivers/nvmem/core.c

726

if (strcmp(cell_id, iter->name) == 0) {

drivers/nvmem/core.c

727

cell = iter;

drivers/opp/core.c

1800

struct dev_pm_opp *opp = NULL, *iter;

drivers/opp/core.c

1812

list_for_each_entry(iter, &opp_table->opp_list, node) {

drivers/opp/core.c

1813

if (iter->rates[0] == freq) {

drivers/opp/core.c

1814

opp = iter;

drivers/opp/debugfs.c

220

struct opp_device *new_dev = NULL, *iter;

drivers/opp/debugfs.c

225

list_for_each_entry(iter, &opp_table->dev_list, node)

drivers/opp/debugfs.c

226

if (iter != opp_dev) {

drivers/opp/debugfs.c

227

new_dev = iter;

drivers/pci/controller/pci-hyperv.c

2660

struct hv_pci_dev *iter, *hpdev = NULL;

drivers/pci/controller/pci-hyperv.c

2663

list_for_each_entry(iter, &hbus->children, list_entry) {

drivers/pci/controller/pci-hyperv.c

2664

if (iter->desc.win_slot.slot == wslot) {

drivers/pci/controller/pci-hyperv.c

2665

hpdev = iter;

drivers/pinctrl/core.c

722

struct radix_tree_iter iter;

drivers/pinctrl/core.c

725

radix_tree_for_each_slot(slot, &pctldev->pin_group_tree, &iter, 0)

drivers/pinctrl/core.c

726

radix_tree_delete(&pctldev->pin_group_tree, iter.index);

drivers/pinctrl/pinmux.c

1010

struct radix_tree_iter iter;

drivers/pinctrl/pinmux.c

1013

radix_tree_for_each_slot(slot, &pctldev->pin_function_tree, &iter, 0)

drivers/pinctrl/pinmux.c

1014

radix_tree_delete(&pctldev->pin_function_tree, iter.index);

drivers/platform/raspberrypi/vchiq-interface/vchiq_arm.c

584

struct bulk_waiter_node *waiter = NULL, *iter;

drivers/platform/raspberrypi/vchiq-interface/vchiq_arm.c

594

list_for_each_entry(iter, &instance->bulk_waiter_list, list) {

drivers/platform/raspberrypi/vchiq-interface/vchiq_arm.c

595

if (iter->pid == current->pid) {

drivers/platform/raspberrypi/vchiq-interface/vchiq_arm.c

596

list_del(&iter->list);

drivers/platform/raspberrypi/vchiq-interface/vchiq_arm.c

597

waiter = iter;

drivers/platform/raspberrypi/vchiq-interface/vchiq_dev.c

291

struct bulk_waiter_node *waiter = NULL, *iter;

drivers/platform/raspberrypi/vchiq-interface/vchiq_dev.c

317

list_for_each_entry(iter, &instance->bulk_waiter_list,

drivers/platform/raspberrypi/vchiq-interface/vchiq_dev.c

319

if (iter->pid == current->pid) {

drivers/platform/raspberrypi/vchiq-interface/vchiq_dev.c

320

list_del(&iter->list);

drivers/platform/raspberrypi/vchiq-interface/vchiq_dev.c

321

waiter = iter;

drivers/platform/x86/intel/pmc/core.c

331

unsigned int index, iter, idx, ip = 0;

drivers/platform/x86/intel/pmc/core.c

337

iter = pmc->map->ppfear0_offset;

drivers/platform/x86/intel/pmc/core.c

340

index < PPFEAR_MAX_NUM_ENTRIES; index++, iter++)

drivers/platform/x86/intel/pmc/core.c

341

pf_regs[index] = pmc_core_reg_read_byte(pmc, iter);

drivers/pmdomain/qcom/cpr.c

1293

struct corner *iter;

drivers/pmdomain/qcom/cpr.c

1315

for (iter = drv->corners; iter <= end; iter++) {

drivers/pmdomain/qcom/cpr.c

1316

if (iter->freq > rate)

drivers/pmdomain/qcom/cpr.c

1319

if (iter->freq == rate) {

drivers/pmdomain/qcom/cpr.c

1320

drv->corner = iter;

drivers/pmdomain/qcom/cpr.c

1323

if (iter->freq < rate)

drivers/pmdomain/qcom/cpr.c

1324

drv->corner = iter;

drivers/power/sequencing/core.c

328

struct radix_tree_iter iter;

drivers/power/sequencing/core.c

337

radix_tree_for_each_slot(slot, &visited_units, &iter, 0)

drivers/power/sequencing/core.c

338

radix_tree_delete(&visited_units, iter.index);

drivers/power/sequencing/core.c

450

struct radix_tree_iter iter;

drivers/power/sequencing/core.c

456

radix_tree_for_each_slot(slot, &processed_units, &iter, 0)

drivers/power/sequencing/core.c

457

radix_tree_delete(&processed_units, iter.index);

drivers/resctrl/mpam_devices.c

148

struct mpam_garbage *iter, *tmp;

drivers/resctrl/mpam_devices.c

156

llist_for_each_entry_safe(iter, tmp, to_free, llist) {

drivers/resctrl/mpam_devices.c

157

if (iter->pdev)

drivers/resctrl/mpam_devices.c

158

devm_kfree(&iter->pdev->dev, iter->to_free);

drivers/resctrl/mpam_devices.c

160

kfree(iter->to_free);

drivers/s390/block/dasd_diag.c

515

struct req_iterator iter;

drivers/s390/block/dasd_diag.c

536

rq_for_each_segment(bv, req, iter) {

drivers/s390/block/dasd_diag.c

555

rq_for_each_segment(bv, req, iter) {

drivers/s390/block/dasd_eckd.c

3261

struct req_iterator iter;

drivers/s390/block/dasd_eckd.c

3308

rq_for_each_segment(bv, req, iter) {

drivers/s390/block/dasd_eckd.c

3969

struct req_iterator iter;

drivers/s390/block/dasd_eckd.c

3991

rq_for_each_segment(bv, req, iter) {

drivers/s390/block/dasd_eckd.c

4064

rq_for_each_segment(bv, req, iter) {

drivers/s390/block/dasd_eckd.c

4155

struct req_iterator iter;

drivers/s390/block/dasd_eckd.c

4229

rq_for_each_segment(bv, req, iter) {

drivers/s390/block/dasd_eckd.c

4485

struct req_iterator iter;

drivers/s390/block/dasd_eckd.c

4522

rq_for_each_segment(bv, req, iter) {

drivers/s390/block/dasd_eckd.c

4572

rq_for_each_segment(bv, req, iter) {

drivers/s390/block/dasd_eckd.c

4605

rq_for_each_segment(bv, req, iter) {

drivers/s390/block/dasd_eckd.c

4734

struct req_iterator iter;

drivers/s390/block/dasd_eckd.c

4838

rq_for_each_segment(bv, req, iter) {

drivers/s390/block/dasd_eckd.c

4881

struct req_iterator iter;

drivers/s390/block/dasd_eckd.c

4899

rq_for_each_segment(bv, req, iter) {

drivers/s390/block/dasd_fba.c

434

struct req_iterator iter;

drivers/s390/block/dasd_fba.c

456

rq_for_each_segment(bv, req, iter) {

drivers/s390/block/dasd_fba.c

498

rq_for_each_segment(bv, req, iter) {

drivers/s390/block/dasd_fba.c

566

struct req_iterator iter;

drivers/s390/block/dasd_fba.c

580

rq_for_each_segment(bv, req, iter) {

drivers/s390/block/dcssblk.c

884

struct bvec_iter iter;

drivers/s390/block/dcssblk.c

914

bio_for_each_segment(bvec, bio, iter) {

drivers/s390/block/scm_blk.c

184

struct req_iterator iter;

drivers/s390/block/scm_blk.c

199

rq_for_each_segment(bv, req, iter) {

drivers/s390/block/scm_blk.c

52

struct list_head *iter, *safe;

drivers/s390/block/scm_blk.c

56

list_for_each_safe(iter, safe, &inactive_requests) {

drivers/s390/block/scm_blk.c

57

scmrq = list_entry(iter, struct scm_request, list);

drivers/s390/char/zcore.c

103

iov_iter_kvec(&iter, ITER_DEST, &kvec, 1, count);

drivers/s390/char/zcore.c

104

if (memcpy_hsa_iter(&iter, src, count) < count)

drivers/s390/char/zcore.c

62

size_t memcpy_hsa_iter(struct iov_iter *iter, unsigned long src, size_t count)

drivers/s390/char/zcore.c

78

copied = copy_to_iter(hsa_buf + offset, bytes, iter);

drivers/s390/char/zcore.c

98

struct iov_iter iter;

drivers/s390/cio/blacklist.c

292

struct ccwdev_iter *iter = s->private;

drivers/s390/cio/blacklist.c

296

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

drivers/s390/cio/blacklist.c

297

iter->ssid = *offset / (__MAX_SUBCHANNEL + 1);

drivers/s390/cio/blacklist.c

298

iter->devno = *offset % (__MAX_SUBCHANNEL + 1);

drivers/s390/cio/blacklist.c

299

return iter;

drivers/s390/cio/blacklist.c

310

struct ccwdev_iter *iter;

drivers/s390/cio/blacklist.c

316

iter = it;

drivers/s390/cio/blacklist.c

317

if (iter->devno == __MAX_SUBCHANNEL) {

drivers/s390/cio/blacklist.c

318

iter->devno = 0;

drivers/s390/cio/blacklist.c

319

iter->ssid++;

drivers/s390/cio/blacklist.c

320

if (iter->ssid > __MAX_SSID)

drivers/s390/cio/blacklist.c

323

iter->devno++;

drivers/s390/cio/blacklist.c

324

return iter;

drivers/s390/cio/blacklist.c

330

struct ccwdev_iter *iter;

drivers/s390/cio/blacklist.c

332

iter = it;

drivers/s390/cio/blacklist.c

333

if (!is_blacklisted(iter->ssid, iter->devno))

drivers/s390/cio/blacklist.c

336

if (!iter->in_range) {

drivers/s390/cio/blacklist.c

338

if ((iter->devno == __MAX_SUBCHANNEL) ||

drivers/s390/cio/blacklist.c

339

!is_blacklisted(iter->ssid, iter->devno + 1)) {

drivers/s390/cio/blacklist.c

341

seq_printf(s, "0.%x.%04x\n", iter->ssid, iter->devno);

drivers/s390/cio/blacklist.c

344

iter->in_range = 1;

drivers/s390/cio/blacklist.c

345

seq_printf(s, "0.%x.%04x-", iter->ssid, iter->devno);

drivers/s390/cio/blacklist.c

348

if ((iter->devno == __MAX_SUBCHANNEL) ||

drivers/s390/cio/blacklist.c

349

!is_blacklisted(iter->ssid, iter->devno + 1)) {

drivers/s390/cio/blacklist.c

351

iter->in_range = 0;

drivers/s390/cio/blacklist.c

352

seq_printf(s, "0.%x.%04x\n", iter->ssid, iter->devno);

drivers/s390/cio/vfio_ccw_cp.c

492

struct ccwchain *iter;

drivers/s390/cio/vfio_ccw_cp.c

495

list_for_each_entry(iter, &cp->ccwchain_list, next) {

drivers/s390/cio/vfio_ccw_cp.c

496

ccw_head = iter->ch_iova;

drivers/s390/cio/vfio_ccw_cp.c

497

if (is_cpa_within_range(ccw->cda, ccw_head, iter->ch_len)) {

drivers/s390/cio/vfio_ccw_cp.c

500

ccw->cda = virt_to_dma32((void *)iter->ch_ccw + offset);

drivers/s390/net/qeth_l2_main.c

759

struct list_head *iter;

drivers/s390/net/qeth_l2_main.c

775

iter = &brdev->adj_list.lower;

drivers/s390/net/qeth_l2_main.c

776

lowerdev = netdev_next_lower_dev_rcu(brdev, &iter);

drivers/s390/net/qeth_l2_main.c

796

lowerdev = netdev_next_lower_dev_rcu(brdev, &iter);

drivers/s390/net/qeth_l2_main.c

856

struct list_head *iter;

drivers/s390/net/qeth_l2_main.c

871

iter = &brdev->adj_list.lower;

drivers/s390/net/qeth_l2_main.c

872

lowerdev = netdev_next_lower_dev_rcu(brdev, &iter);

drivers/s390/net/qeth_l2_main.c

885

lowerdev = netdev_next_lower_dev_rcu(brdev, &iter);

drivers/scsi/aha1542.c

266

struct req_iterator iter;

drivers/scsi/aha1542.c

269

rq_for_each_segment(bv, rq, iter) {

drivers/scsi/aha1542.c

450

struct req_iterator iter;

drivers/scsi/aha1542.c

453

rq_for_each_segment(bv, rq, iter) {

drivers/scsi/dc395x.c

3030

struct DeviceCtlBlk *p = NULL, *iter;

drivers/scsi/dc395x.c

3032

list_for_each_entry(iter, &acb->dcb_list, list)

drivers/scsi/dc395x.c

3033

if (iter->target_id == dcb->target_id) {

drivers/scsi/dc395x.c

3034

p = iter;

drivers/scsi/fnic/fnic.h

574

struct fnic_scsi_iter_data *iter = iter_data;

drivers/scsi/fnic/fnic.h

576

return iter->fn(iter->fnic, sc, iter->data1, iter->data2);

drivers/scsi/lpfc/lpfc_sli.c

22060

struct lpfc_io_buf *lpfc_ncmd = NULL, *iter;

drivers/scsi/lpfc/lpfc_sli.c

22069

list_for_each_entry_safe(iter, lpfc_ncmd_next,

drivers/scsi/lpfc/lpfc_sli.c

22071

list_del(&iter->list);

drivers/scsi/lpfc/lpfc_sli.c

22073

lpfc_ncmd = iter;

drivers/scsi/qedf/qedf_dbg.c

156

qedf_create_sysfs_attr(struct Scsi_Host *shost, struct sysfs_bin_attrs *iter)

drivers/scsi/qedf/qedf_dbg.c

160

for (; iter->name; iter++) {

drivers/scsi/qedf/qedf_dbg.c

162

iter->attr);

drivers/scsi/qedf/qedf_dbg.c

165

iter->name, ret);

drivers/scsi/qedf/qedf_dbg.c

171

qedf_remove_sysfs_attr(struct Scsi_Host *shost, struct sysfs_bin_attrs *iter)

drivers/scsi/qedf/qedf_dbg.c

173

for (; iter->name; iter++)

drivers/scsi/qedf/qedf_dbg.c

174

sysfs_remove_bin_file(&shost->shost_gendev.kobj, iter->attr);

drivers/scsi/qedf/qedf_dbg.h

113

struct sysfs_bin_attrs *iter);

drivers/scsi/qedf/qedf_dbg.h

115

struct sysfs_bin_attrs *iter);

drivers/scsi/qla2xxx/qla_attr.c

1021

struct sysfs_entry *iter;

drivers/scsi/qla2xxx/qla_attr.c

1024

for (iter = bin_file_entries; iter->name; iter++) {

drivers/scsi/qla2xxx/qla_attr.c

1025

if (iter->type && !IS_FWI2_CAPABLE(vha->hw))

drivers/scsi/qla2xxx/qla_attr.c

1027

if (iter->type == 2 && !IS_QLA25XX(vha->hw))

drivers/scsi/qla2xxx/qla_attr.c

1029

if (iter->type == 3 && !(IS_CNA_CAPABLE(vha->hw)))

drivers/scsi/qla2xxx/qla_attr.c

1033

iter->attr);

drivers/scsi/qla2xxx/qla_attr.c

1037

iter->name, ret);

drivers/scsi/qla2xxx/qla_attr.c

1041

iter->name);

drivers/scsi/qla2xxx/qla_attr.c

1049

struct sysfs_entry *iter;

drivers/scsi/qla2xxx/qla_attr.c

1052

for (iter = bin_file_entries; iter->name; iter++) {

drivers/scsi/qla2xxx/qla_attr.c

1053

if (iter->type && !IS_FWI2_CAPABLE(ha))

drivers/scsi/qla2xxx/qla_attr.c

1055

if (iter->type == 2 && !IS_QLA25XX(ha))

drivers/scsi/qla2xxx/qla_attr.c

1057

if (iter->type == 3 && !(IS_CNA_CAPABLE(ha)))

drivers/scsi/qla2xxx/qla_attr.c

1061

iter->attr);

drivers/scsi/qla2xxx/qla_attr.c

237

__le32 *iter = (__force __le32 *)buf;

drivers/scsi/qla2xxx/qla_attr.c

241

for (cnt = 0; cnt < ((count >> 2) - 1); cnt++, iter++)

drivers/scsi/qla2xxx/qla_attr.c

242

chksum += le32_to_cpu(*iter);

drivers/scsi/qla2xxx/qla_attr.c

244

*iter = cpu_to_le32(chksum);

drivers/scsi/qla2xxx/qla_attr.c

246

uint8_t *iter;

drivers/scsi/qla2xxx/qla_attr.c

249

iter = (uint8_t *)buf;

drivers/scsi/qla2xxx/qla_attr.c

252

chksum += *iter++;

drivers/scsi/qla2xxx/qla_attr.c

254

*iter = chksum;

drivers/scsi/qla2xxx/qla_inline.h

73

uint32_t iter = bsize >> 2;

drivers/scsi/qla2xxx/qla_inline.h

75

for (; iter ; iter--)

drivers/scsi/qla2xxx/qla_inline.h

86

uint32_t iter = bsize >> 2;

drivers/scsi/qla2xxx/qla_inline.h

88

for ( ; iter--; isrc++)

drivers/scsi/qla2xxx/qla_isr.c

2794

uint16_t iter;

drivers/scsi/qla2xxx/qla_isr.c

2811

iter = le16_to_cpu(iocb->u.nvme.rsp_pyld_len) >> 2;

drivers/scsi/qla2xxx/qla_isr.c

2812

for (; iter; iter--)

drivers/scsi/qla2xxx/qla_isr.c

347

unsigned long iter;

drivers/scsi/qla2xxx/qla_isr.c

366

for (iter = 50; iter--; ) {

drivers/scsi/qla2xxx/qla_isr.c

4250

unsigned long iter;

drivers/scsi/qla2xxx/qla_isr.c

4274

for (iter = 50; iter--; ) {

drivers/scsi/qla2xxx/qla_isr.c

460

unsigned long iter;

drivers/scsi/qla2xxx/qla_isr.c

481

for (iter = 50; iter--; ) {

drivers/scsi/qla2xxx/qla_mbx.c

3205

uint32_t *iter = (uint32_t *)stats;

drivers/scsi/qla2xxx/qla_mbx.c

3206

ushort dwords = offsetof(typeof(*stats), link_up_cnt)/sizeof(*iter);

drivers/scsi/qla2xxx/qla_mbx.c

3246

for ( ; dwords--; iter++)

drivers/scsi/qla2xxx/qla_mbx.c

3247

le32_to_cpus(iter);

drivers/scsi/qla2xxx/qla_mbx.c

3264

uint32_t *iter = (uint32_t *)stats;

drivers/scsi/qla2xxx/qla_mbx.c

3265

ushort dwords = sizeof(*stats)/sizeof(*iter);

drivers/scsi/qla2xxx/qla_mbx.c

3291

for ( ; dwords--; iter++)

drivers/scsi/qla2xxx/qla_mbx.c

3292

le32_to_cpus(iter);

drivers/scsi/qla2xxx/qla_mbx.c

6926

uint16_t iter, addr, offset;

drivers/scsi/qla2xxx/qla_mbx.c

6937

for (iter = 0; iter < SFP_DEV_SIZE / SFP_BLOCK_SIZE; iter++) {

drivers/scsi/qla2xxx/qla_mbx.c

6938

if (iter == 4) {

drivers/scsi/qla2xxx/qla_mr.c

2881

unsigned long iter;

drivers/scsi/qla2xxx/qla_mr.c

2905

for (iter = 50; iter--; clr_intr = 0) {

drivers/scsi/qla2xxx/qla_nx.c

1966

unsigned long iter;

drivers/scsi/qla2xxx/qla_nx.c

1999

for (iter = 1; iter--; ) {

drivers/scsi/qla2xxx/qla_nx2.c

3884

unsigned long iter;

drivers/scsi/qla2xxx/qla_nx2.c

3935

for (iter = 1; iter--; ) {

drivers/scsi/qla2xxx/qla_sup.c

3140

uint32_t istart, iend, iter, vend;

drivers/scsi/qla2xxx/qla_sup.c

3153

iter = istart;

drivers/scsi/qla2xxx/qla_sup.c

3154

while ((iter < iend) && !do_next) {

drivers/scsi/qla2xxx/qla_sup.c

3155

iter++;

drivers/scsi/qla2xxx/qla_sup.c

3156

if (qla2x00_read_flash_byte(ha, iter) == '/') {

drivers/scsi/qla2xxx/qla_sup.c

3157

if (qla2x00_read_flash_byte(ha, iter + 2) ==

drivers/scsi/qla2xxx/qla_sup.c

3161

iter + 3) == '/')

drivers/scsi/qla2xxx/qla_sup.c

3170

while ((iter > istart) && !do_next) {

drivers/scsi/qla2xxx/qla_sup.c

3171

iter--;

drivers/scsi/qla2xxx/qla_sup.c

3172

if (qla2x00_read_flash_byte(ha, iter) == ' ')

drivers/scsi/qla2xxx/qla_sup.c

3182

vend = iter - 1;

drivers/scsi/qla2xxx/qla_sup.c

3184

while ((iter > istart) && !do_next) {

drivers/scsi/qla2xxx/qla_sup.c

3185

iter--;

drivers/scsi/qla2xxx/qla_sup.c

3186

rbyte = qla2x00_read_flash_byte(ha, iter);

drivers/scsi/qla2xxx/qla_sup.c

3194

iter++;

drivers/scsi/qla2xxx/qla_sup.c

3195

if ((vend - iter) &&

drivers/scsi/qla2xxx/qla_sup.c

3196

((vend - iter) < sizeof(ha->fcode_revision))) {

drivers/scsi/qla2xxx/qla_sup.c

3198

while (iter <= vend) {

drivers/scsi/qla2xxx/qla_sup.c

3199

*vbyte++ = qla2x00_read_flash_byte(ha, iter);

drivers/scsi/qla2xxx/qla_sup.c

3200

iter++;

drivers/scsi/qla4xxx/ql4_attr.c

128

struct sysfs_entry *iter;

drivers/scsi/qla4xxx/ql4_attr.c

131

for (iter = bin_file_entries; iter->name; iter++) {

drivers/scsi/qla4xxx/ql4_attr.c

133

iter->attr);

drivers/scsi/qla4xxx/ql4_attr.c

137

iter->name, ret);

drivers/scsi/qla4xxx/ql4_attr.c

144

struct sysfs_entry *iter;

drivers/scsi/qla4xxx/ql4_attr.c

146

for (iter = bin_file_entries; iter->name; iter++)

drivers/scsi/qla4xxx/ql4_attr.c

148

iter->attr);

drivers/scsi/scsi_bsg.c

85

struct iov_iter iter;

drivers/scsi/scsi_bsg.c

91

&iter, ioucmd, issue_flags);

drivers/scsi/scsi_bsg.c

94

ret = blk_rq_map_user_iov(req->q, req, NULL, &iter, gfp_mask);

drivers/soc/qcom/pdr_interface.c

302

struct pdr_service *pds = NULL, *iter;

drivers/soc/qcom/pdr_interface.c

309

list_for_each_entry(iter, &pdr->lookups, node) {

drivers/soc/qcom/pdr_interface.c

310

if (strcmp(iter->service_path, ind_msg->service_path))

drivers/soc/qcom/pdr_interface.c

313

pds = iter;

drivers/soc/qcom/qcom-geni-se.c

542

int iter = (ceil_bpw * pack_words) / BITS_PER_BYTE;

drivers/soc/qcom/qcom-geni-se.c

545

if (iter <= 0 || iter > NUM_PACKING_VECTORS)

drivers/soc/qcom/qcom-geni-se.c

548

for (i = 0; i < iter; i++) {

drivers/soc/qcom/qcom-geni-se.c

562

cfg[iter - 1] |= PACKING_STOP_BIT;

drivers/soc/ti/knav_qmss_queue.c

757

struct knav_pool *pool, *pi = NULL, *iter;

drivers/soc/ti/knav_qmss_queue.c

813

list_for_each_entry(iter, &region->pools, region_inst) {

drivers/soc/ti/knav_qmss_queue.c

814

if ((iter->region_offset - last_offset) >= num_desc) {

drivers/soc/ti/knav_qmss_queue.c

815

pi = iter;

drivers/soc/ti/knav_qmss_queue.c

818

last_offset = iter->region_offset + iter->num_desc;

drivers/spi/spi-pci1xxxx.c

1005

store_restore_config(spi_ptr, spi_sub_ptr, iter, 1);

drivers/spi/spi-pci1xxxx.c

1008

SPI_MST_EVENT_MASK_REG_OFFSET(iter));

drivers/spi/spi-pci1xxxx.c

280

u8 iter, irq_index;

drivers/spi/spi-pci1xxxx.c

286

for (iter = 0; iter < spi_bus->total_hw_instances; iter++) {

drivers/spi/spi-pci1xxxx.c

287

spi_sub_ptr = spi_bus->spi_int[iter];

drivers/spi/spi-pci1xxxx.c

289

if (iter == 0) {

drivers/spi/spi-pci1xxxx.c

311

writel((regval | (data << (iter * 16))), spi_bus->dma_offset_bar +

drivers/spi/spi-pci1xxxx.c

318

writel(regval | (data << (iter * 16)), spi_bus->dma_offset_bar +

drivers/spi/spi-pci1xxxx.c

328

u8 iter, irq_index;

drivers/spi/spi-pci1xxxx.c

341

for (iter = 0; iter < hw_inst; iter++) {

drivers/spi/spi-pci1xxxx.c

342

spi_sub_ptr = spi_bus->spi_int[iter];

drivers/spi/spi-pci1xxxx.c

802

u8 hw_inst_cnt, iter, start, only_sec_inst;

drivers/spi/spi-pci1xxxx.c

828

for (iter = 0; iter < hw_inst_cnt; iter++) {

drivers/spi/spi-pci1xxxx.c

829

spi_bus->spi_int[iter] = devm_kzalloc(&pdev->dev,

drivers/spi/spi-pci1xxxx.c

832

if (!spi_bus->spi_int[iter])

drivers/spi/spi-pci1xxxx.c

834

spi_sub_ptr = spi_bus->spi_int[iter];

drivers/spi/spi-pci1xxxx.c

842

if (!iter) {

drivers/spi/spi-pci1xxxx.c

898

if (iter == 1) {

drivers/spi/spi-pci1xxxx.c

907

spi_sub_ptr->irq[0] = pci_irq_vector(pdev, iter);

drivers/spi/spi-pci1xxxx.c

976

u8 iter;

drivers/spi/spi-pci1xxxx.c

978

for (iter = 0; iter < spi_ptr->total_hw_instances; iter++) {

drivers/spi/spi-pci1xxxx.c

979

spi_sub_ptr = spi_ptr->spi_int[iter];

drivers/spi/spi-pci1xxxx.c

982

SPI_MST_EVENT_MASK_REG_OFFSET(iter));

drivers/spi/spi-pci1xxxx.c

985

store_restore_config(spi_ptr, spi_sub_ptr, iter, 0);

drivers/spi/spi-pci1xxxx.c

996

u8 iter;

drivers/spi/spi-pci1xxxx.c

998

for (iter = 0; iter < spi_ptr->total_hw_instances; iter++) {

drivers/spi/spi-pci1xxxx.c

999

spi_sub_ptr = spi_ptr->spi_int[iter];

drivers/spi/spidev.c

570

struct spidev_data *spidev = NULL, *iter;

drivers/spi/spidev.c

575

list_for_each_entry(iter, &device_list, device_entry) {

drivers/spi/spidev.c

576

if (iter->devt == inode->i_rdev) {

drivers/spi/spidev.c

578

spidev = iter;

drivers/staging/greybus/audio_codec.c

500

struct gbaudio_module_info *module = NULL, *iter;

drivers/staging/greybus/audio_codec.c

514

list_for_each_entry(iter, &codec->module_list, list) {

drivers/staging/greybus/audio_codec.c

516

data = find_data(iter, dai->id);

drivers/staging/greybus/audio_codec.c

518

module = iter;

drivers/staging/greybus/audio_codec.c

568

struct gbaudio_module_info *module = NULL, *iter;

drivers/staging/greybus/audio_codec.c

597

list_for_each_entry(iter, &codec->module_list, list) {

drivers/staging/greybus/audio_codec.c

599

data = find_data(iter, dai->id);

drivers/staging/greybus/audio_codec.c

601

module = iter;

drivers/target/sbp/sbp_target.c

1247

struct sg_mapping_iter iter;

drivers/target/sbp/sbp_target.c

1285

sg_miter_start(&iter, req->se_cmd.t_data_sg, req->se_cmd.t_data_nents,

drivers/target/sbp/sbp_target.c

1298

sg_miter_next(&iter);

drivers/target/sbp/sbp_target.c

1300

tfr_length = min3(length, max_payload, (int)iter.length);

drivers/target/sbp/sbp_target.c

1306

offset, iter.addr, tfr_length);

drivers/target/sbp/sbp_target.c

1313

iter.consumed = tfr_length;

drivers/target/sbp/sbp_target.c

1316

sg_miter_stop(&iter);

drivers/target/target_core_device.c

914

struct devices_idr_iter *iter = data;

drivers/target/target_core_device.c

933

ret = iter->fn(dev, iter->data);

drivers/target/target_core_device.c

951

struct devices_idr_iter iter = { .fn = fn, .data = data };

drivers/target/target_core_device.c

955

ret = idr_for_each(&devices_idr, target_devices_idr_iter, &iter);

drivers/target/target_core_file.c

274

struct iov_iter iter;

drivers/target/target_core_file.c

289

iov_iter_bvec(&iter, is_write, aio_cmd->bvecs, sgl_nents, len);

drivers/target/target_core_file.c

302

ret = file->f_op->write_iter(&aio_cmd->iocb, &iter);

drivers/target/target_core_file.c

304

ret = file->f_op->read_iter(&aio_cmd->iocb, &iter);

drivers/target/target_core_file.c

317

struct iov_iter iter;

drivers/target/target_core_file.c

334

iov_iter_bvec(&iter, is_write, bvec, sgl_nents, len);

drivers/target/target_core_file.c

336

ret = vfs_iter_write(fd, &iter, &pos, 0);

drivers/target/target_core_file.c

338

ret = vfs_iter_read(fd, &iter, &pos, 0);

drivers/target/target_core_file.c

372

ret += iov_iter_zero(data_length - ret, &iter);

drivers/target/target_core_file.c

434

struct iov_iter iter;

drivers/target/target_core_file.c

469

iov_iter_bvec(&iter, ITER_SOURCE, bvec, nolb, len);

drivers/target/target_core_file.c

470

ret = vfs_iter_write(fd_dev->fd_file, &iter, &pos, 0);

drivers/tee/tee_shm.c

401

register_shm_helper(struct tee_context *ctx, struct iov_iter *iter, u32 flags,

drivers/tee/tee_shm.c

433

addr = untagged_addr((unsigned long)iter_iov_addr(iter));

drivers/tee/tee_shm.c

435

num_pages = iov_iter_npages(iter, INT_MAX);

drivers/tee/tee_shm.c

447

len = iov_iter_extract_pages(iter, &shm->pages, LONG_MAX, num_pages, 0,

drivers/tee/tee_shm.c

475

if (!iov_iter_is_kvec(iter))

drivers/tee/tee_shm.c

502

struct iov_iter iter;

drivers/tee/tee_shm.c

515

iov_iter_ubuf(&iter, ITER_DEST, (void __user *)addr, length);

drivers/tee/tee_shm.c

516

shm = register_shm_helper(ctx, &iter, flags, id);

drivers/tee/tee_shm.c

550

struct iov_iter iter;

drivers/tee/tee_shm.c

554

iov_iter_kvec(&iter, ITER_DEST, &kvec, 1, length);

drivers/tee/tee_shm.c

556

return register_shm_helper(ctx, &iter, flags, -1);

drivers/thunderbolt/ctl.c

176

struct tb_cfg_request *req = NULL, *iter;

drivers/thunderbolt/ctl.c

179

list_for_each_entry(iter, &pkg->ctl->request_queue, list) {

drivers/thunderbolt/ctl.c

180

tb_cfg_request_get(iter);

drivers/thunderbolt/ctl.c

181

if (iter->match(iter, pkg)) {

drivers/thunderbolt/ctl.c

182

req = iter;

drivers/thunderbolt/ctl.c

185

tb_cfg_request_put(iter);

drivers/tty/tty_io.c

1105

ssize_t redirected_tty_write(struct kiocb *iocb, struct iov_iter *iter)

drivers/tty/tty_io.c

1121

res = file_tty_write(p, iocb, iter);

drivers/tty/tty_io.c

1125

return tty_write(iocb, iter);

drivers/ufs/core/ufs-txeq.c

555

static void tx_eqtr_iter_try_update(struct tx_eqtr_iter *iter,

drivers/ufs/core/ufs-txeq.c

558

if (!test_bit(preshoot, &iter->preshoot_bitmap) ||

drivers/ufs/core/ufs-txeq.c

559

!test_bit(deemphasis, &iter->deemphasis_bitmap) ||

drivers/ufs/core/ufs-txeq.c

561

iter->is_updated = false;

drivers/ufs/core/ufs-txeq.c

565

iter->preshoot = preshoot;

drivers/ufs/core/ufs-txeq.c

566

iter->deemphasis = deemphasis;

drivers/ufs/core/ufs-txeq.c

567

iter->is_updated = true;

drivers/ufs/core/ufs-txeq.c

960

static inline u32 ufshcd_compose_tx_eqtr_setting(struct tx_eqtr_iter *iter,

drivers/ufs/core/ufs-txeq.c

967

setting |= TX_HS_PRESHOOT_BITS(lane, iter->preshoot);

drivers/ufs/core/ufs-txeq.c

968

setting |= TX_HS_DEEMPHASIS_BITS(lane, iter->deemphasis);

drivers/usb/core/devio.c

1597

struct usb_memory *usbm = NULL, *iter;

drivers/usb/core/devio.c

1602

list_for_each_entry(iter, &ps->memory_list, memlist) {

drivers/usb/core/devio.c

1603

if (uurb_start >= iter->vm_start &&

drivers/usb/core/devio.c

1604

uurb_start < iter->vm_start + iter->size) {

drivers/usb/core/devio.c

1605

if (uurb->buffer_length > iter->vm_start + iter->size -

drivers/usb/core/devio.c

1609

usbm = iter;

drivers/usb/gadget/composite.c

1765

struct usb_function *iter;

drivers/usb/gadget/composite.c

2229

list_for_each_entry(iter, &cdev->config->functions, list) {

drivers/usb/gadget/composite.c

2230

if (test_bit(endp, iter->endpoints)) {

drivers/usb/gadget/composite.c

2231

f = iter;

drivers/usb/gadget/composite.c

951

struct usb_configuration *c = NULL, *iter;

drivers/usb/gadget/composite.c

957

list_for_each_entry(iter, &cdev->configs, list) {

drivers/usb/gadget/composite.c

958

if (iter->bConfigurationValue != number)

drivers/usb/gadget/composite.c

967

c = iter;

drivers/usb/gadget/configfs.c

1227

struct usb_configuration *c = NULL, *iter;

drivers/usb/gadget/configfs.c

1231

list_for_each_entry(iter, &cdev->configs, list) {

drivers/usb/gadget/configfs.c

1232

if (iter != &c_target->c)

drivers/usb/gadget/configfs.c

1234

c = iter;

drivers/usb/gadget/configfs.c

1619

struct list_head *iter;

drivers/usb/gadget/configfs.c

1625

list_for_each(iter, &gi->string_list)

drivers/usb/gadget/configfs.c

435

struct usb_function_instance *a_fi = NULL, *iter;

drivers/usb/gadget/configfs.c

451

list_for_each_entry(iter, &gi->available_func, cfs_list) {

drivers/usb/gadget/configfs.c

452

if (iter != fi)

drivers/usb/gadget/configfs.c

454

a_fi = iter;

drivers/usb/gadget/function/f_fs.c

760

static ssize_t ffs_copy_to_iter(void *data, int data_len, struct iov_iter *iter)

drivers/usb/gadget/function/f_fs.c

762

ssize_t ret = copy_to_iter(data, data_len, iter);

drivers/usb/gadget/function/f_fs.c

766

if (iov_iter_count(iter))

drivers/usb/gadget/function/f_fs.c

913

struct iov_iter *iter)

drivers/usb/gadget/function/f_fs.c

925

ret = copy_to_iter(buf->data, buf->length, iter);

drivers/usb/gadget/function/f_fs.c

931

if (iov_iter_count(iter)) {

drivers/usb/gadget/function/f_fs.c

947

struct iov_iter *iter)

drivers/usb/gadget/function/f_fs.c

951

ssize_t ret = copy_to_iter(data, data_len, iter);

drivers/usb/gadget/function/f_fs.c

955

if (iov_iter_count(iter))

drivers/usb/gadget/function/uvc_configfs.c

1043

u8 *source_ids, *iter;

drivers/usb/gadget/function/uvc_configfs.c

1058

iter = source_ids = kcalloc(n, sizeof(u8), GFP_KERNEL);

drivers/usb/gadget/function/uvc_configfs.c

1064

ret = __uvcg_iter_item_entries(page, len, __uvcg_fill_item_entries, &iter,

drivers/usb/gadget/function/uvc_configfs.c

1122

u8 *bm_controls, *iter;

drivers/usb/gadget/function/uvc_configfs.c

1137

iter = bm_controls = kcalloc(n, sizeof(u8), GFP_KERNEL);

drivers/usb/gadget/function/uvc_configfs.c

1143

ret = __uvcg_iter_item_entries(page, len, __uvcg_fill_item_entries, &iter,

drivers/usb/gadget/function/uvc_video.c

139

struct scatterlist *sg, *iter;

drivers/usb/gadget/function/uvc_video.c

163

for_each_sg(sg, iter, ureq->sgt.nents - 1, i) {

drivers/usb/gadget/function/uvc_video.c

170

sg_set_page(iter, sg_page(buf->sg), part, buf->offset);

drivers/usb/gadget/udc/aspeed-vhub/epn.c

476

struct ast_vhub_req *req = NULL, *iter;

drivers/usb/gadget/udc/aspeed-vhub/epn.c

483

list_for_each_entry(iter, &ep->queue, queue) {

drivers/usb/gadget/udc/aspeed-vhub/epn.c

484

if (&iter->req != u_req)

drivers/usb/gadget/udc/aspeed-vhub/epn.c

486

req = iter;

drivers/usb/gadget/udc/at91_udc.c

708

struct at91_request *req = NULL, *iter;

drivers/usb/gadget/udc/at91_udc.c

721

list_for_each_entry(iter, &ep->queue, queue) {

drivers/usb/gadget/udc/at91_udc.c

722

if (&iter->req != _req)

drivers/usb/gadget/udc/at91_udc.c

724

req = iter;

drivers/usb/gadget/udc/atmel_usba_udc.c

862

struct usba_request *iter;

drivers/usb/gadget/udc/atmel_usba_udc.c

871

list_for_each_entry(iter, &ep->queue, queue) {

drivers/usb/gadget/udc/atmel_usba_udc.c

872

if (&iter->req != _req)

drivers/usb/gadget/udc/atmel_usba_udc.c

874

req = iter;

drivers/usb/gadget/udc/bdc/bdc_ep.c

1763

struct bdc_req *iter;

drivers/usb/gadget/udc/bdc/bdc_ep.c

1781

list_for_each_entry(iter, &ep->queue, queue) {

drivers/usb/gadget/udc/bdc/bdc_ep.c

1782

if (&iter->usb_req != _req)

drivers/usb/gadget/udc/bdc/bdc_ep.c

1784

req = iter;

drivers/usb/gadget/udc/dummy_hcd.c

783

struct dummy_request *req = NULL, *iter;

drivers/usb/gadget/udc/dummy_hcd.c

794

list_for_each_entry(iter, &ep->queue, queue) {

drivers/usb/gadget/udc/dummy_hcd.c

795

if (&iter->req != _req)

drivers/usb/gadget/udc/dummy_hcd.c

797

list_del_init(&iter->queue);

drivers/usb/gadget/udc/dummy_hcd.c

799

req = iter;

drivers/usb/gadget/udc/fsl_qe_udc.c

1781

struct qe_req *iter;

drivers/usb/gadget/udc/fsl_qe_udc.c

1790

list_for_each_entry(iter, &ep->queue, queue) {

drivers/usb/gadget/udc/fsl_qe_udc.c

1791

if (&iter->req != _req)

drivers/usb/gadget/udc/fsl_qe_udc.c

1793

req = iter;

drivers/usb/gadget/udc/fsl_udc_core.c

917

struct fsl_req *iter;

drivers/usb/gadget/udc/fsl_udc_core.c

939

list_for_each_entry(iter, &ep->queue, queue) {

drivers/usb/gadget/udc/fsl_udc_core.c

940

if (&iter->req != _req)

drivers/usb/gadget/udc/fsl_udc_core.c

942

req = iter;

drivers/usb/gadget/udc/goku_udc.c

812

struct goku_request *req = NULL, *iter;

drivers/usb/gadget/udc/goku_udc.c

836

list_for_each_entry(iter, &ep->queue, queue) {

drivers/usb/gadget/udc/goku_udc.c

837

if (&iter->req != _req)

drivers/usb/gadget/udc/goku_udc.c

839

req = iter;

drivers/usb/gadget/udc/gr_udc.c

1692

struct gr_request *req = NULL, *iter;

drivers/usb/gadget/udc/gr_udc.c

1712

list_for_each_entry(iter, &ep->queue, queue) {

drivers/usb/gadget/udc/gr_udc.c

1713

if (&iter->req != _req)

drivers/usb/gadget/udc/gr_udc.c

1715

req = iter;

drivers/usb/gadget/udc/lpc32xx_udc.c

1831

struct lpc32xx_request *req = NULL, *iter;

drivers/usb/gadget/udc/lpc32xx_udc.c

1841

list_for_each_entry(iter, &ep->queue, queue) {

drivers/usb/gadget/udc/lpc32xx_udc.c

1842

if (&iter->req != _req)

drivers/usb/gadget/udc/lpc32xx_udc.c

1844

req = iter;

drivers/usb/gadget/udc/max3420_udc.c

1047

struct max3420_req *iter;

drivers/usb/gadget/udc/max3420_udc.c

1054

list_for_each_entry(iter, &ep->queue, queue) {

drivers/usb/gadget/udc/max3420_udc.c

1055

if (iter != req)

drivers/usb/gadget/udc/max3420_udc.c

1058

t = iter;

drivers/usb/gadget/udc/net2280.c

1236

struct net2280_request *iter;

drivers/usb/gadget/udc/net2280.c

1262

list_for_each_entry(iter, &ep->queue, queue) {

drivers/usb/gadget/udc/net2280.c

1263

if (&iter->req != _req)

drivers/usb/gadget/udc/net2280.c

1265

req = iter;

drivers/usb/gadget/udc/omap_udc.c

1004

struct omap_req *req = NULL, *iter;

drivers/usb/gadget/udc/omap_udc.c

1013

list_for_each_entry(iter, &ep->queue, queue) {

drivers/usb/gadget/udc/omap_udc.c

1014

if (&iter->req != _req)

drivers/usb/gadget/udc/omap_udc.c

1016

req = iter;

drivers/usb/gadget/udc/pxa25x_udc.c

954

struct pxa25x_request *iter;

drivers/usb/gadget/udc/pxa25x_udc.c

964

list_for_each_entry(iter, &ep->queue, queue) {

drivers/usb/gadget/udc/pxa25x_udc.c

965

if (&iter->req != _req)

drivers/usb/gadget/udc/pxa25x_udc.c

967

req = iter;

drivers/usb/gadget/udc/pxa27x_udc.c

1161

struct pxa27x_request *req = NULL, *iter;

drivers/usb/gadget/udc/pxa27x_udc.c

1175

list_for_each_entry(iter, &ep->queue, queue) {

drivers/usb/gadget/udc/pxa27x_udc.c

1176

if (&iter->req != _req)

drivers/usb/gadget/udc/pxa27x_udc.c

1178

req = iter;

drivers/usb/gadget/udc/tegra-xudc.c

1429

struct tegra_xudc_request *r = NULL, *iter;

drivers/usb/gadget/udc/tegra-xudc.c

1435

list_for_each_entry(iter, &ep->queue, list) {

drivers/usb/gadget/udc/tegra-xudc.c

1436

if (iter != req)

drivers/usb/gadget/udc/tegra-xudc.c

1438

r = iter;

drivers/usb/gadget/udc/udc-xilinx.c

1142

struct xusb_req *iter;

drivers/usb/gadget/udc/udc-xilinx.c

1148

list_for_each_entry(iter, &ep->queue, queue) {

drivers/usb/gadget/udc/udc-xilinx.c

1149

if (&iter->usb_req != _req)

drivers/usb/gadget/udc/udc-xilinx.c

1151

req = iter;

drivers/vfio/platform/vfio_platform_common.c

34

struct vfio_platform_reset_node *iter;

drivers/vfio/platform/vfio_platform_common.c

38

list_for_each_entry(iter, &reset_list, link) {

drivers/vfio/platform/vfio_platform_common.c

39

if (!strcmp(iter->compat, compat) &&

drivers/vfio/platform/vfio_platform_common.c

40

try_module_get(iter->owner)) {

drivers/vfio/platform/vfio_platform_common.c

41

*module = iter->owner;

drivers/vfio/platform/vfio_platform_common.c

42

reset_fn = iter->of_reset;

drivers/vfio/platform/vfio_platform_common.c

683

struct vfio_platform_reset_node *iter, *temp;

drivers/vfio/platform/vfio_platform_common.c

686

list_for_each_entry_safe(iter, temp, &reset_list, link) {

drivers/vfio/platform/vfio_platform_common.c

687

if (!strcmp(iter->compat, compat) && (iter->of_reset == fn)) {

drivers/vfio/platform/vfio_platform_common.c

688

list_del(&iter->link);

drivers/vfio/vfio_main.c

1185

static int vfio_device_log_read_and_clear(struct iova_bitmap *iter,

drivers/vfio/vfio_main.c

1191

return device->log_ops->log_read_and_clear(device, iova, length, iter);

drivers/vfio/vfio_main.c

1203

struct iova_bitmap *iter;

drivers/vfio/vfio_main.c

1226

iter = iova_bitmap_alloc(report.iova, report.length,

drivers/vfio/vfio_main.c

1229

if (IS_ERR(iter))

drivers/vfio/vfio_main.c

1230

return PTR_ERR(iter);

drivers/vfio/vfio_main.c

1232

ret = iova_bitmap_for_each(iter, device,

drivers/vfio/vfio_main.c

1235

iova_bitmap_free(iter);

drivers/vhost/net.c

635

static size_t init_iov_iter(struct vhost_virtqueue *vq, struct iov_iter *iter,

drivers/vhost/net.c

641

iov_iter_init(iter, ITER_SOURCE, vq->iov, out, len);

drivers/vhost/net.c

642

iov_iter_advance(iter, hdr_size);

drivers/vhost/net.c

644

return iov_iter_count(iter);

drivers/vhost/scsi.c

658

struct iov_iter *iter = cmd->read_iter;

drivers/vhost/scsi.c

671

if (copy_page_to_iter(page, 0, len, iter) != len) {

drivers/vhost/scsi.c

774

static void vhost_scsi_revert_map_iov_to_sgl(struct iov_iter *iter,

drivers/vhost/scsi.c

792

iov_iter_revert(iter, revert_bytes);

drivers/vhost/scsi.c

802

struct iov_iter *iter,

drivers/vhost/scsi.c

815

bytes = iov_iter_get_pages2(iter, pages, LONG_MAX,

drivers/vhost/scsi.c

853

vhost_scsi_revert_map_iov_to_sgl(iter, *sgl, sg);

drivers/vhost/scsi.c

855

iov_iter_revert(iter, bytes);

drivers/vhost/scsi.c

867

vhost_scsi_calc_sgls(struct iov_iter *iter, size_t bytes, int max_sgls)

drivers/vhost/scsi.c

871

if (!iter || !iter_iov(iter)) {

drivers/vhost/scsi.c

877

sgl_count = iov_iter_npages(iter, 0xffff);

drivers/vhost/scsi.c

887

vhost_scsi_copy_iov_to_sgl(struct vhost_scsi_cmd *cmd, struct iov_iter *iter,

drivers/vhost/scsi.c

891

size_t len = iov_iter_count(iter);

drivers/vhost/scsi.c

902

cmd->read_iov = dup_iter(cmd->read_iter, iter, GFP_KERNEL);

drivers/vhost/scsi.c

920

copy_page_from_iter(page, 0, nbytes, iter) != nbytes) {

drivers/vhost/scsi.c

947

vhost_scsi_map_iov_to_sgl(struct vhost_scsi_cmd *cmd, struct iov_iter *iter,

drivers/vhost/scsi.c

953

while (iov_iter_count(iter)) {

drivers/vhost/scsi.c

954

ret = vhost_scsi_map_to_sgl(cmd, iter, sg_table, &sg, is_prot);

drivers/vhost/scsi.c

956

vhost_scsi_revert_map_iov_to_sgl(iter, sg_table->sgl,

drivers/vhost/vringh.c

1115

struct iov_iter iter;

drivers/vhost/vringh.c

1129

iov_iter_init(&iter, ITER_SOURCE, ivec.iov.iovec, ret,

drivers/vhost/vringh.c

1132

iov_iter_bvec(&iter, ITER_SOURCE, ivec.iov.bvec, ret,

drivers/vhost/vringh.c

1136

size = copy_from_iter(dst, translated, &iter);

drivers/vhost/vringh.c

1162

struct iov_iter iter;

drivers/vhost/vringh.c

1176

iov_iter_init(&iter, ITER_DEST, ivec.iov.iovec, ret,

drivers/vhost/vringh.c

1179

iov_iter_bvec(&iter, ITER_DEST, ivec.iov.bvec, ret,

drivers/vhost/vringh.c

1183

size = copy_to_iter(src, translated, &iter);

drivers/video/fbdev/core/fb_imageblit.h

100

data = *iter->data++ >> BITS_PER_BYTE/2;

drivers/video/fbdev/core/fb_imageblit.h

102

data = iter->data[-1] & ((1 << BITS_PER_BYTE/2)-1);

drivers/video/fbdev/core/fb_imageblit.h

103

} else if (iter->i != 0) {

drivers/video/fbdev/core/fb_imageblit.h

104

*bits = iter->bpp * iter->i;

drivers/video/fbdev/core/fb_imageblit.h

105

if (iter->top)

drivers/video/fbdev/core/fb_imageblit.h

106

data = iter->data[-1] & ((1 << BITS_PER_BYTE/2)-1);

drivers/video/fbdev/core/fb_imageblit.h

108

data = *iter->data++ >> BITS_PER_BYTE/2;

drivers/video/fbdev/core/fb_imageblit.h

110

data >>= BITS_PER_BYTE/2 - iter->i;

drivers/video/fbdev/core/fb_imageblit.h

112

iter->i = 0;

drivers/video/fbdev/core/fb_imageblit.h

114

*bits = iter->bpp * BITS_PER_BYTE/2;

drivers/video/fbdev/core/fb_imageblit.h

115

iter->i = iter->width;

drivers/video/fbdev/core/fb_imageblit.h

116

iter->top = false;

drivers/video/fbdev/core/fb_imageblit.h

119

*pixels = (iter->fgxcolor & iter->expand[data]) ^ iter->bgcolor;

drivers/video/fbdev/core/fb_imageblit.h

127

static __always_inline void fb_bitblit(bool (*get)(void *iter, unsigned long *pixels,

drivers/video/fbdev/core/fb_imageblit.h

129

void *iter, int bits, struct fb_address *dst,

drivers/video/fbdev/core/fb_imageblit.h

145

while (get(iter, &pixels, &bits)) {

drivers/video/fbdev/core/fb_imageblit.h

172

struct fb_color_iter iter;

drivers/video/fbdev/core/fb_imageblit.h

175

iter.data = (const u8 *)image->data;

drivers/video/fbdev/core/fb_imageblit.h

176

iter.palette = palette;

drivers/video/fbdev/core/fb_imageblit.h

177

iter.reverse = reverse;

drivers/video/fbdev/core/fb_imageblit.h

180

iter.shift = BITS_PER_BYTE - bpp;

drivers/video/fbdev/core/fb_imageblit.h

182

iter.shift = 0;

drivers/video/fbdev/core/fb_imageblit.h

185

iter.shift = BITS_PER_LONG - BITS_PER_BYTE;

drivers/video/fbdev/core/fb_imageblit.h

187

iter.shift = BITS_PER_LONG - bpp;

drivers/video/fbdev/core/fb_imageblit.h

189

iter.width = image->width;

drivers/video/fbdev/core/fb_imageblit.h

190

iter.i = 0;

drivers/video/fbdev/core/fb_imageblit.h

194

fb_bitblit(fb_color_image, &iter, bpp, dst, reverse);

drivers/video/fbdev/core/fb_imageblit.h

232

struct fb_bitmap4x_iter iter;

drivers/video/fbdev/core/fb_imageblit.h

235

iter.data = (const u8 *)image->data;

drivers/video/fbdev/core/fb_imageblit.h

240

iter.fgxcolor = (fgcolor ^ bgcolor) * mul[bpp-1];

drivers/video/fbdev/core/fb_imageblit.h

241

iter.bgcolor = bgcolor * mul[bpp-1];

drivers/video/fbdev/core/fb_imageblit.h

242

iter.width = image->width;

drivers/video/fbdev/core/fb_imageblit.h

243

iter.i = image->width;

drivers/video/fbdev/core/fb_imageblit.h

244

iter.expand = expand[bpp-1];

drivers/video/fbdev/core/fb_imageblit.h

245

iter.bpp = bpp;

drivers/video/fbdev/core/fb_imageblit.h

246

iter.top = false;

drivers/video/fbdev/core/fb_imageblit.h

250

fb_bitblit(fb_bitmap4x_image, &iter, bpp * BITS_PER_BYTE/2, dst, reverse);

drivers/video/fbdev/core/fb_imageblit.h

260

struct fb_bitmap_iter iter;

drivers/video/fbdev/core/fb_imageblit.h

263

iter.colors[0] = bgcolor;

drivers/video/fbdev/core/fb_imageblit.h

264

iter.colors[1] = fgcolor;

drivers/video/fbdev/core/fb_imageblit.h

266

iter.colors[0] <<= BITS_PER_LONG - bpp;

drivers/video/fbdev/core/fb_imageblit.h

267

iter.colors[1] <<= BITS_PER_LONG - bpp;

drivers/video/fbdev/core/fb_imageblit.h

269

iter.data = (const u8 *)image->data;

drivers/video/fbdev/core/fb_imageblit.h

270

iter.width = image->width;

drivers/video/fbdev/core/fb_imageblit.h

271

iter.i = 0;

drivers/video/fbdev/core/fb_imageblit.h

275

fb_bitblit(fb_bitmap_image, &iter, bpp, dst, reverse);

drivers/video/fbdev/core/fb_imageblit.h

39

struct fb_bitmap_iter *iter = iterator;

drivers/video/fbdev/core/fb_imageblit.h

41

if (iter->i < iter->width) {

drivers/video/fbdev/core/fb_imageblit.h

42

int bit = ~iter->i & (BITS_PER_BYTE-1);

drivers/video/fbdev/core/fb_imageblit.h

43

int byte = iter->i++ / BITS_PER_BYTE;

drivers/video/fbdev/core/fb_imageblit.h

45

*pixels = iter->colors[(iter->data[byte] >> bit) & 1];

drivers/video/fbdev/core/fb_imageblit.h

48

iter->data += BITS_TO_BYTES(iter->width);

drivers/video/fbdev/core/fb_imageblit.h

49

iter->i = 0;

drivers/video/fbdev/core/fb_imageblit.h

64

struct fb_color_iter *iter = iterator;

drivers/video/fbdev/core/fb_imageblit.h

66

if (iter->i < iter->width) {

drivers/video/fbdev/core/fb_imageblit.h

67

unsigned long color = iter->data[iter->i++];

drivers/video/fbdev/core/fb_imageblit.h

69

if (iter->palette)

drivers/video/fbdev/core/fb_imageblit.h

70

color = iter->palette[color];

drivers/video/fbdev/core/fb_imageblit.h

71

*pixels = color << iter->shift;

drivers/video/fbdev/core/fb_imageblit.h

72

if (iter->reverse.pixel)

drivers/video/fbdev/core/fb_imageblit.h

76

iter->data += iter->width;

drivers/video/fbdev/core/fb_imageblit.h

77

iter->i = 0;

drivers/video/fbdev/core/fb_imageblit.h

93

struct fb_bitmap4x_iter *iter = iterator;

drivers/video/fbdev/core/fb_imageblit.h

96

if (iter->i >= BITS_PER_BYTE/2) {

drivers/video/fbdev/core/fb_imageblit.h

97

iter->i -= BITS_PER_BYTE/2;

drivers/video/fbdev/core/fb_imageblit.h

98

iter->top = !iter->top;

drivers/video/fbdev/core/fb_imageblit.h

99

if (iter->top)

drivers/video/fbdev/mmp/core.c

130

struct mmp_path *path = NULL, *iter;

drivers/video/fbdev/mmp/core.c

133

list_for_each_entry(iter, &path_list, node) {

drivers/video/fbdev/mmp/core.c

134

if (!strcmp(name, iter->name)) {

drivers/video/fbdev/mmp/core.c

135

path = iter;

drivers/video/fbdev/riva/riva_hw.c

244

int iter = 0;

drivers/video/fbdev/riva/riva_hw.c

329

iter++;

drivers/video/fbdev/riva/riva_hw.c

375

if (iter>100)

drivers/w1/w1.c

822

struct w1_master *dev = NULL, *iter;

drivers/w1/w1.c

825

list_for_each_entry(iter, &w1_masters, w1_master_entry) {

drivers/w1/w1.c

826

if (iter->id == id) {

drivers/w1/w1.c

827

dev = iter;

drivers/w1/w1.c

828

atomic_inc(&iter->refcnt);

drivers/w1/w1.c

840

struct w1_slave *sl = NULL, *iter;

drivers/w1/w1.c

845

list_for_each_entry(iter, &dev->slist, w1_slave_entry) {

drivers/w1/w1.c

846

if (iter->reg_num.family == id->family &&

drivers/w1/w1.c

847

iter->reg_num.id == id->id &&

drivers/w1/w1.c

848

iter->reg_num.crc == id->crc) {

drivers/w1/w1.c

849

sl = iter;

drivers/w1/w1.c

851

atomic_inc(&iter->refcnt);

drivers/xen/pvcalls-back.c

1002

struct radix_tree_iter iter;

drivers/xen/pvcalls-back.c

1014

radix_tree_for_each_slot(slot, &fedata->socketpass_mappings, &iter, 0) {

drivers/xen/pvcalls-back.c

1020

slot = radix_tree_iter_retry(&iter);

fs/affs/file.c

397

affs_direct_IO(struct kiocb *iocb, struct iov_iter *iter)

fs/affs/file.c

402

size_t count = iov_iter_count(iter);

fs/affs/file.c

406

if (iov_iter_rw(iter) == WRITE) {

fs/affs/file.c

413

ret = blockdev_direct_IO(iocb, inode, iter, affs_get_block);

fs/affs/file.c

414

if (ret < 0 && iov_iter_rw(iter) == WRITE)

fs/afs/cmservice.c

259

call->iter = &call->def_iter;

fs/afs/cmservice.c

266

iov_iter_count(call->iter), call->count2 * 3 * 4);

fs/afs/dir.c

137

struct iov_iter iter;

fs/afs/dir.c

143

iov_iter_folio_queue(&iter, ITER_SOURCE, dvnode->directory, 0, 0, i_size);

fs/afs/dir.c

144

iterate_folioq(&iter, iov_iter_count(&iter), NULL, NULL,

fs/afs/dir.c

199

struct iov_iter iter;

fs/afs/dir.c

206

iov_iter_folio_queue(&iter, ITER_SOURCE, dvnode->directory, 0, 0, i_size);

fs/afs/dir.c

207

checked = iterate_folioq(&iter, iov_iter_count(&iter), dvnode, NULL,

fs/afs/dir.c

2215

struct iov_iter iter;

fs/afs/dir.c

2231

iov_iter_folio_queue(&iter, ITER_SOURCE, dvnode->directory, 0, 0,

fs/afs/dir.c

2233

ret = netfs_writeback_single(mapping, wbc, &iter);

fs/afs/dir.c

237

struct iov_iter iter;

fs/afs/dir.c

261

iov_iter_folio_queue(&iter, ITER_DEST, dvnode->directory, 0, 0, dvnode->directory_size);

fs/afs/dir.c

267

ret = netfs_read_single(&dvnode->netfs.inode, file, &iter);

fs/afs/dir.c

492

struct iov_iter iter;

fs/afs/dir.c

501

iov_iter_folio_queue(&iter, ITER_SOURCE, dvnode->directory, 0, 0, i_size);

fs/afs/dir.c

502

iov_iter_advance(&iter, round_down(dir_ctx->pos, AFS_DIR_BLOCK_SIZE));

fs/afs/dir.c

504

iterate_folioq(&iter, iov_iter_count(&iter), dvnode, &ctx,

fs/afs/dir_edit.c

111

static union afs_xdr_dir_block *afs_dir_get_block(struct afs_dir_iter *iter, size_t block)

fs/afs/dir_edit.c

114

struct afs_vnode *dvnode = iter->dvnode;

fs/afs/dir_edit.c

117

size_t blend = (block + 1) * AFS_DIR_BLOCK_SIZE, fpos = iter->fpos;

fs/afs/dir_edit.c

131

fq = iter->fq;

fs/afs/dir_edit.c

137

for (int s = iter->fq_slot; s < folioq_count(fq); s++) {

fs/afs/dir_edit.c

145

iter->fq = fq;

fs/afs/dir_edit.c

146

iter->fq_slot = s;

fs/afs/dir_edit.c

147

iter->fpos = fpos;

fs/afs/dir_edit.c

152

iter->fq_slot = 0;

fs/afs/dir_edit.c

156

iter->fq = NULL;

fs/afs/dir_edit.c

157

iter->fq_slot = 0;

fs/afs/dir_edit.c

247

struct afs_dir_iter iter = { .dvnode = vnode };

fs/afs/dir_edit.c

261

meta = afs_dir_get_block(&iter, 0);

fs/afs/dir_edit.c

266

iter.nr_slots = afs_dir_calc_slots(name->len);

fs/afs/dir_edit.c

284

meta->meta.alloc_ctrs[b] < iter.nr_slots)

fs/afs/dir_edit.c

287

block = afs_dir_get_block(&iter, b);

fs/afs/dir_edit.c

311

slot = afs_find_contig_bits(block, iter.nr_slots);

fs/afs/dir_edit.c

332

block = afs_dir_get_block(&iter, 0);

fs/afs/dir_edit.c

350

afs_set_contig_bits(block, slot, iter.nr_slots);

fs/afs/dir_edit.c

354

meta->meta.alloc_ctrs[b] -= iter.nr_slots;

fs/afs/dir_edit.c

358

iter.bucket = afs_dir_hash_name(name);

fs/afs/dir_edit.c

359

de->u.hash_next = meta->meta.hashtable[iter.bucket];

fs/afs/dir_edit.c

360

meta->meta.hashtable[iter.bucket] = htons(entry);

fs/afs/dir_edit.c

398

struct afs_dir_iter iter = { .dvnode = vnode };

fs/afs/dir_edit.c

415

if (!afs_dir_init_iter(&iter, name))

fs/afs/dir_edit.c

418

meta = afs_dir_get_block(&iter, 0);

fs/afs/dir_edit.c

423

found = afs_dir_search_bucket(&iter, name, &fid);

fs/afs/dir_edit.c

436

block = afs_dir_find_block(&iter, b);

fs/afs/dir_edit.c

452

afs_clear_contig_bits(block, slot, iter.nr_slots);

fs/afs/dir_edit.c

456

meta->meta.alloc_ctrs[b] += iter.nr_slots;

fs/afs/dir_edit.c

460

memset(de, 0, sizeof(*de) * iter.nr_slots);

fs/afs/dir_edit.c

466

if (!iter.prev_entry) {

fs/afs/dir_edit.c

467

__be16 prev_next = meta->meta.hashtable[iter.bucket];

fs/afs/dir_edit.c

472

iter.bucket, iter.prev_entry, prev_next, entry,

fs/afs/dir_edit.c

476

meta->meta.hashtable[iter.bucket] = next;

fs/afs/dir_edit.c

478

unsigned int pb = iter.prev_entry / AFS_DIR_SLOTS_PER_BLOCK;

fs/afs/dir_edit.c

479

unsigned int ps = iter.prev_entry % AFS_DIR_SLOTS_PER_BLOCK;

fs/afs/dir_edit.c

482

pblock = afs_dir_find_block(&iter, pb);

fs/afs/dir_edit.c

491

iter.bucket, iter.prev_entry, prev_next, entry,

fs/afs/dir_edit.c

533

struct afs_dir_iter iter = { .dvnode = vnode };

fs/afs/dir_edit.c

552

block = afs_dir_get_block(&iter, b);

fs/afs/dir_edit.c

607

struct afs_dir_iter iter = { .dvnode = dvnode };

fs/afs/dir_edit.c

618

meta = afs_dir_get_block(&iter, 0);

fs/afs/dir_search.c

102

iter->fq = fq;

fs/afs/dir_search.c

103

iter->fq_slot = slot;

fs/afs/dir_search.c

104

iter->fpos = fpos;

fs/afs/dir_search.c

105

iter->block = kmap_local_folio(folio, blpos - fpos);

fs/afs/dir_search.c

106

return iter->block;

fs/afs/dir_search.c

114

iter->fq = NULL;

fs/afs/dir_search.c

115

iter->fq_slot = 0;

fs/afs/dir_search.c

123

int afs_dir_search_bucket(struct afs_dir_iter *iter, const struct qstr *name,

fs/afs/dir_search.c

130

meta = afs_dir_find_block(iter, 0);

fs/afs/dir_search.c

134

entry = ntohs(meta->meta.hashtable[iter->bucket & (AFS_DIR_HASHTBL_SIZE - 1)]);

fs/afs/dir_search.c

135

_enter("%x,%x", iter->bucket, entry);

fs/afs/dir_search.c

148

iter->bucket, resv, slot, slot + iter->nr_slots - 1);

fs/afs/dir_search.c

152

block = afs_dir_find_block(iter, blnum);

fs/afs/dir_search.c

157

if (slot + iter->nr_slots <= AFS_DIR_SLOTS_PER_BLOCK &&

fs/afs/dir_search.c

166

iter->prev_entry = entry;

fs/afs/dir_search.c

168

if (!--iter->loop_check) {

fs/afs/dir_search.c

169

kdebug("dir chain loop h=%x", iter->bucket);

fs/afs/dir_search.c

176

if (iter->block) {

fs/afs/dir_search.c

177

kunmap_local(iter->block);

fs/afs/dir_search.c

178

iter->block = NULL;

fs/afs/dir_search.c

183

afs_invalidate_dir(iter->dvnode, afs_dir_invalid_iter_stale);

fs/afs/dir_search.c

194

struct afs_dir_iter iter = { .dvnode = dvnode, };

fs/afs/dir_search.c

199

if (!afs_dir_init_iter(&iter, name))

fs/afs/dir_search.c

219

ret = afs_dir_search_bucket(&iter, name, _fid);

fs/afs/dir_search.c

222

afs_dir_reset_iter(&iter);

fs/afs/dir_search.c

40

static bool afs_dir_reset_iter(struct afs_dir_iter *iter)

fs/afs/dir_search.c

42

unsigned long long i_size = i_size_read(&iter->dvnode->netfs.inode);

fs/afs/dir_search.c

49

iter->loop_check = nblocks * (AFS_DIR_SLOTS_PER_BLOCK - AFS_DIR_RESV_BLOCKS);

fs/afs/dir_search.c

50

iter->prev_entry = 0; /* Hash head is previous */

fs/afs/dir_search.c

57

bool afs_dir_init_iter(struct afs_dir_iter *iter, const struct qstr *name)

fs/afs/dir_search.c

59

iter->nr_slots = afs_dir_calc_slots(name->len);

fs/afs/dir_search.c

60

iter->bucket = afs_dir_hash_name(name);

fs/afs/dir_search.c

61

return afs_dir_reset_iter(iter);

fs/afs/dir_search.c

67

union afs_xdr_dir_block *afs_dir_find_block(struct afs_dir_iter *iter, size_t block)

fs/afs/dir_search.c

69

struct folio_queue *fq = iter->fq;

fs/afs/dir_search.c

70

struct afs_vnode *dvnode = iter->dvnode;

fs/afs/dir_search.c

73

size_t blend = (block + 1) * AFS_DIR_BLOCK_SIZE, fpos = iter->fpos;

fs/afs/dir_search.c

74

int slot = iter->fq_slot;

fs/afs/dir_search.c

78

if (iter->block) {

fs/afs/dir_search.c

79

kunmap_local(iter->block);

fs/afs/dir_search.c

80

iter->block = NULL;

fs/afs/file.c

24

static ssize_t afs_file_read_iter(struct kiocb *iocb, struct iov_iter *iter);

fs/afs/file.c

559

static ssize_t afs_file_read_iter(struct kiocb *iocb, struct iov_iter *iter)

fs/afs/file.c

567

return netfs_unbuffered_read_iter(iocb, iter);

fs/afs/file.c

574

ret = filemap_read(iocb, iter, 0);

fs/afs/fsclient.c

1674

_enter("{%u,%zu}", call->unmarshall, iov_iter_count(call->iter));

fs/afs/fsclient.c

311

call->unmarshall, call->iov_len, iov_iter_count(call->iter),

fs/afs/fsclient.c

342

call->iter = &subreq->io_iter;

fs/afs/fsclient.c

358

call->iter = &call->def_iter;

fs/afs/fsclient.c

369

iov_iter_count(call->iter), call->remaining);

fs/afs/internal.h

1129

bool afs_dir_init_iter(struct afs_dir_iter *iter, const struct qstr *name);

fs/afs/internal.h

1130

union afs_xdr_dir_block *afs_dir_find_block(struct afs_dir_iter *iter, size_t block);

fs/afs/internal.h

1131

int afs_dir_search_bucket(struct afs_dir_iter *iter, const struct qstr *name,

fs/afs/internal.h

144

struct iov_iter *iter; /* Iterator currently in use */

fs/afs/rxrpc.c

184

call->iter = &call->def_iter;

fs/afs/rxrpc.c

815

_enter("{%zu}", iov_iter_count(call->iter));

fs/afs/rxrpc.c

938

struct iov_iter *iter = call->iter;

fs/afs/rxrpc.c

944

call->type->name, call->iov_len, iov_iter_count(iter), want_more);

fs/afs/rxrpc.c

946

ret = rxrpc_kernel_recv_data(net->socket, call->rxcall, iter,

fs/afs/rxrpc.c

949

trace_afs_receive_data(call, call->iter, want_more, ret);

fs/afs/symlink.c

107

iov_iter_folio_queue(&iter, ITER_DEST, vnode->directory, 0, 0, PAGE_SIZE);

fs/afs/symlink.c

112

ret = netfs_read_single(&vnode->netfs.inode, NULL, &iter);

fs/afs/symlink.c

238

struct iov_iter iter;

fs/afs/symlink.c

252

iov_iter_folio_queue(&iter, ITER_SOURCE, vnode->directory, 0, 0,

fs/afs/symlink.c

254

ret = netfs_writeback_single(mapping, wbc, &iter);

fs/afs/symlink.c

86

struct iov_iter iter;

fs/afs/vlclient.c

181

call->unmarshall, iov_iter_count(call->iter), call->count);

fs/afs/vlclient.c

323

call->unmarshall, iov_iter_count(call->iter), call->count);

fs/afs/vlclient.c

439

call->unmarshall, iov_iter_count(call->iter), call->count2);

fs/afs/vlclient.c

687

call->unmarshall, iov_iter_count(call->iter), call->count);

fs/afs/yfsclient.c

362

call->unmarshall, call->iov_len, iov_iter_count(call->iter),

fs/afs/yfsclient.c

388

call->iter = &subreq->io_iter;

fs/afs/yfsclient.c

403

call->iter = &call->def_iter;

fs/afs/yfsclient.c

414

iov_iter_count(call->iter), call->remaining);

fs/aio.c

1600

struct iov_iter *iter)

fs/aio.c

1606

ssize_t ret = import_ubuf(rw, buf, len, iter);

fs/aio.c

1611

return __import_iovec(rw, buf, len, UIO_FASTIOV, iovec, iter, compat);

fs/aio.c

1638

struct iov_iter iter;

fs/aio.c

1651

ret = aio_setup_rw(ITER_DEST, iocb, &iovec, vectored, compat, &iter);

fs/aio.c

1654

ret = rw_verify_area(READ, file, &req->ki_pos, iov_iter_count(&iter));

fs/aio.c

1656

aio_rw_done(req, file->f_op->read_iter(req, &iter));

fs/aio.c

1665

struct iov_iter iter;

fs/aio.c

1679

ret = aio_setup_rw(ITER_SOURCE, iocb, &iovec, vectored, compat, &iter);

fs/aio.c

1682

ret = rw_verify_area(WRITE, file, &req->ki_pos, iov_iter_count(&iter));

fs/aio.c

1687

aio_rw_done(req, file->f_op->write_iter(req, &iter));

fs/backing-file.c

164

static int do_backing_file_read_iter(struct file *file, struct iov_iter *iter,

fs/backing-file.c

173

return vfs_iter_read(file, iter, &iocb->ki_pos, rwf);

fs/backing-file.c

184

ret = vfs_iocb_iter_read(file, &aio->iocb, iter);

fs/backing-file.c

191

ssize_t backing_file_read_iter(struct file *file, struct iov_iter *iter,

fs/backing-file.c

200

if (!iov_iter_count(iter))

fs/backing-file.c

208

ret = do_backing_file_read_iter(file, iter, iocb, flags);

fs/backing-file.c

217

static int do_backing_file_write_iter(struct file *file, struct iov_iter *iter,

fs/backing-file.c

227

ret = vfs_iter_write(file, iter, &iocb->ki_pos, rwf);

fs/backing-file.c

247

ret = vfs_iocb_iter_write(file, &aio->iocb, iter);

fs/backing-file.c

254

ssize_t backing_file_write_iter(struct file *file, struct iov_iter *iter,

fs/backing-file.c

263

if (!iov_iter_count(iter))

fs/backing-file.c

275

return do_backing_file_write_iter(file, iter, iocb, flags, ctx->end_write);

fs/btrfs/backref.c

2817

int btrfs_backref_iter_init(struct btrfs_backref_iter *iter)

fs/btrfs/backref.c

2819

iter->path = btrfs_alloc_path();

fs/btrfs/backref.c

2820

if (!iter->path)

fs/btrfs/backref.c

2824

iter->path->search_commit_root = true;

fs/btrfs/backref.c

2825

iter->path->skip_locking = true;

fs/btrfs/backref.c

2830

static void btrfs_backref_iter_release(struct btrfs_backref_iter *iter)

fs/btrfs/backref.c

2832

iter->bytenr = 0;

fs/btrfs/backref.c

2833

iter->item_ptr = 0;

fs/btrfs/backref.c

2834

iter->cur_ptr = 0;

fs/btrfs/backref.c

2835

iter->end_ptr = 0;

fs/btrfs/backref.c

2836

btrfs_release_path(iter->path);

fs/btrfs/backref.c

2837

memset(&iter->cur_key, 0, sizeof(iter->cur_key));

fs/btrfs/backref.c

2840

int btrfs_backref_iter_start(struct btrfs_fs_info *fs_info, struct btrfs_backref_iter *iter, u64 bytenr)

fs/btrfs/backref.c

2843

struct btrfs_path *path = iter->path;

fs/btrfs/backref.c

2858

iter->bytenr = bytenr;

fs/btrfs/backref.c

2884

memcpy(&iter->cur_key, &key, sizeof(key));

fs/btrfs/backref.c

2885

iter->item_ptr = (u32)btrfs_item_ptr_offset(path->nodes[0],

fs/btrfs/backref.c

2887

iter->end_ptr = (u32)(iter->item_ptr +

fs/btrfs/backref.c

2903

iter->cur_ptr = (u32)(iter->item_ptr + sizeof(*ei));

fs/btrfs/backref.c

2906

if (iter->cur_ptr >= iter->end_ptr) {

fs/btrfs/backref.c

2917

btrfs_item_key_to_cpu(path->nodes[0], &iter->cur_key,

fs/btrfs/backref.c

2919

if (iter->cur_key.objectid != bytenr ||

fs/btrfs/backref.c

2920

(iter->cur_key.type != BTRFS_SHARED_BLOCK_REF_KEY &&

fs/btrfs/backref.c

2921

iter->cur_key.type != BTRFS_TREE_BLOCK_REF_KEY)) {

fs/btrfs/backref.c

2925

iter->cur_ptr = (u32)btrfs_item_ptr_offset(path->nodes[0],

fs/btrfs/backref.c

2927

iter->item_ptr = iter->cur_ptr;

fs/btrfs/backref.c

2928

iter->end_ptr = (u32)(iter->item_ptr + btrfs_item_size(

fs/btrfs/backref.c

2934

btrfs_backref_iter_release(iter);

fs/btrfs/backref.c

2938

static bool btrfs_backref_iter_is_inline_ref(struct btrfs_backref_iter *iter)

fs/btrfs/backref.c

2940

if (iter->cur_key.type == BTRFS_EXTENT_ITEM_KEY ||

fs/btrfs/backref.c

2941

iter->cur_key.type == BTRFS_METADATA_ITEM_KEY)

fs/btrfs/backref.c

2956

int btrfs_backref_iter_next(struct btrfs_fs_info *fs_info, struct btrfs_backref_iter *iter)

fs/btrfs/backref.c

2958

struct extent_buffer *eb = iter->path->nodes[0];

fs/btrfs/backref.c

2960

struct btrfs_path *path = iter->path;

fs/btrfs/backref.c

2965

if (btrfs_backref_iter_is_inline_ref(iter)) {

fs/btrfs/backref.c

2967

ASSERT(iter->cur_ptr < iter->end_ptr,

fs/btrfs/backref.c

2969

iter->cur_ptr, iter->end_ptr);

fs/btrfs/backref.c

2971

if (btrfs_backref_has_tree_block_info(iter)) {

fs/btrfs/backref.c

2979

((unsigned long)iter->cur_ptr);

fs/btrfs/backref.c

2984

iter->cur_ptr += size;

fs/btrfs/backref.c

2985

if (iter->cur_ptr < iter->end_ptr)

fs/btrfs/backref.c

2992

extent_root = btrfs_extent_root(fs_info, iter->bytenr);

fs/btrfs/backref.c

2995

iter->bytenr);

fs/btrfs/backref.c

2999

ret = btrfs_next_item(extent_root, iter->path);

fs/btrfs/backref.c

3003

btrfs_item_key_to_cpu(path->nodes[0], &iter->cur_key, path->slots[0]);

fs/btrfs/backref.c

3004

if (iter->cur_key.objectid != iter->bytenr ||

fs/btrfs/backref.c

3005

(iter->cur_key.type != BTRFS_TREE_BLOCK_REF_KEY &&

fs/btrfs/backref.c

3006

iter->cur_key.type != BTRFS_SHARED_BLOCK_REF_KEY))

fs/btrfs/backref.c

3008

iter->item_ptr = (u32)btrfs_item_ptr_offset(path->nodes[0],

fs/btrfs/backref.c

3010

iter->cur_ptr = iter->item_ptr;

fs/btrfs/backref.c

3011

iter->end_ptr = iter->item_ptr + (u32)btrfs_item_size(path->nodes[0],

fs/btrfs/backref.c

3449

struct btrfs_backref_iter *iter,

fs/btrfs/backref.c

3457

ret = btrfs_backref_iter_start(trans->fs_info, iter, cur->bytenr);

fs/btrfs/backref.c

3464

if (btrfs_backref_has_tree_block_info(iter)) {

fs/btrfs/backref.c

3465

ret = btrfs_backref_iter_next(trans->fs_info, iter);

fs/btrfs/backref.c

3495

for (; ret == 0; ret = btrfs_backref_iter_next(trans->fs_info, iter)) {

fs/btrfs/backref.c

3501

eb = iter->path->nodes[0];

fs/btrfs/backref.c

3503

key.objectid = iter->bytenr;

fs/btrfs/backref.c

3504

if (btrfs_backref_iter_is_inline_ref(iter)) {

fs/btrfs/backref.c

3509

((unsigned long)iter->cur_ptr);

fs/btrfs/backref.c

3519

key.type = iter->cur_key.type;

fs/btrfs/backref.c

3520

key.offset = iter->cur_key.offset;

fs/btrfs/backref.c

3561

btrfs_backref_iter_release(iter);

fs/btrfs/backref.h

294

struct btrfs_backref_iter *iter)

fs/btrfs/backref.h

296

if (iter->cur_key.type == BTRFS_EXTENT_ITEM_KEY &&

fs/btrfs/backref.h

297

iter->cur_ptr - iter->item_ptr == sizeof(struct btrfs_extent_item))

fs/btrfs/backref.h

302

int btrfs_backref_iter_init(struct btrfs_backref_iter *iter);

fs/btrfs/backref.h

304

int btrfs_backref_iter_start(struct btrfs_fs_info *fs_info, struct btrfs_backref_iter *iter, u64 bytenr);

fs/btrfs/backref.h

306

int btrfs_backref_iter_next(struct btrfs_fs_info *fs_info, struct btrfs_backref_iter *iter);

fs/btrfs/backref.h

459

struct btrfs_backref_iter *iter,

fs/btrfs/bio.c

310

struct bvec_iter *iter = &bbio->saved_iter;

fs/btrfs/bio.c

332

btrfs_bio_for_each_block(paddr, &bbio->bio, iter, step) {

fs/btrfs/bio.c

885

struct bvec_iter iter;

fs/btrfs/bio.c

897

bio_for_each_bvec(bvec, &bbio->bio, iter)

fs/btrfs/bio.c

902

btrfs_ino(bbio->inode), logical, length, iter.bi_idx,

fs/btrfs/btrfs_inode.h

608

ssize_t btrfs_encoded_read(struct kiocb *iocb, struct iov_iter *iter,

fs/btrfs/btrfs_inode.h

612

ssize_t btrfs_encoded_read_regular(struct kiocb *iocb, struct iov_iter *iter,

fs/btrfs/direct-io.c

1053

const struct iov_iter *iter, loff_t offset)

fs/btrfs/direct-io.c

1058

ret = check_direct_IO(fs_info, iter, offset);

fs/btrfs/direct-io.c

1062

if (!iter_is_iovec(iter))

fs/btrfs/direct-io.c

1065

for (seg = 0; seg < iter->nr_segs; seg++) {

fs/btrfs/direct-io.c

1066

for (i = seg + 1; i < iter->nr_segs; i++) {

fs/btrfs/direct-io.c

1067

const struct iovec *iov1 = iter_iov(iter) + seg;

fs/btrfs/direct-io.c

1068

const struct iovec *iov2 = iter_iov(iter) + i;

fs/btrfs/direct-io.c

368

struct iomap_iter *iter = container_of(iomap, struct iomap_iter, iomap);

fs/btrfs/direct-io.c

372

struct btrfs_dio_data *dio_data = iter->private;

fs/btrfs/direct-io.c

620

struct iomap_iter *iter = container_of(iomap, struct iomap_iter, iomap);

fs/btrfs/direct-io.c

621

struct btrfs_dio_data *dio_data = iter->private;

fs/btrfs/direct-io.c

761

static void btrfs_dio_submit_io(const struct iomap_iter *iter, struct bio *bio,

fs/btrfs/direct-io.c

767

struct btrfs_dio_data *dio_data = iter->private;

fs/btrfs/direct-io.c

769

btrfs_bio_init(bbio, BTRFS_I(iter->inode), file_offset,

fs/btrfs/direct-io.c

784

if (iter->flags & IOMAP_WRITE) {

fs/btrfs/direct-io.c

811

static ssize_t btrfs_dio_read(struct kiocb *iocb, struct iov_iter *iter,

fs/btrfs/direct-io.c

816

return iomap_dio_rw(iocb, iter, &btrfs_dio_iomap_ops, &btrfs_dio_ops,

fs/btrfs/direct-io.c

820

static struct iomap_dio *btrfs_dio_write(struct kiocb *iocb, struct iov_iter *iter,

fs/btrfs/direct-io.c

825

return __iomap_dio_rw(iocb, iter, &btrfs_dio_iomap_ops, &btrfs_dio_ops,

fs/btrfs/direct-io.c

830

const struct iov_iter *iter, loff_t offset)

fs/btrfs/direct-io.c

837

if (iov_iter_alignment(iter) & blocksize_mask)

fs/btrfs/file-item.c

806

struct bvec_iter iter = *src;

fs/btrfs/file-item.c

815

btrfs_bio_for_each_block(paddr, bio, &iter, step) {

fs/btrfs/file.c

1172

const struct iov_iter *iter, u64 start)

fs/btrfs/file.c

1177

iov_iter_count(iter));

fs/btrfs/file.c

1187

static int copy_one_range(struct btrfs_inode *inode, struct iov_iter *iter,

fs/btrfs/file.c

1193

size_t write_bytes = calc_write_bytes(inode, iter, start);

fs/btrfs/file.c

1209

if (unlikely(fault_in_iov_iter_readable(iter, write_bytes)))

fs/btrfs/file.c

1271

write_bytes, iter);

fs/btrfs/file.c

1285

iov_iter_revert(iter, copied);

fs/btrfs/file.c

1340

ssize_t btrfs_buffered_write(struct kiocb *iocb, struct iov_iter *iter)

fs/btrfs/file.c

1366

ret = generic_write_checks(iocb, iter);

fs/btrfs/file.c

1375

while (iov_iter_count(iter) > 0) {

fs/btrfs/file.c

1376

ret = copy_one_range(BTRFS_I(inode), iter, &data_reserved, pos, nowait);

fs/btrfs/inode.c

9288

struct iov_iter *iter, u64 start,

fs/btrfs/inode.c

9364

ret = copy_to_iter(tmp, count, iter);

fs/btrfs/inode.c

9476

ssize_t btrfs_encoded_read_regular(struct kiocb *iocb, struct iov_iter *iter,

fs/btrfs/inode.c

9522

iter) != bytes) {

fs/btrfs/inode.c

9540

ssize_t btrfs_encoded_read(struct kiocb *iocb, struct iov_iter *iter,

fs/btrfs/inode.c

9549

size_t count = iov_iter_count(iter);

fs/btrfs/inode.c

9630

ret = btrfs_encoded_read_inline(iocb, iter, start, lockend,

fs/btrfs/inode.c

9688

ret = iov_iter_zero(count, iter);

fs/btrfs/ioctl.c

4310

struct iov_iter iter;

fs/btrfs/ioctl.c

4352

&iov, &iter);

fs/btrfs/ioctl.c

4356

if (iov_iter_count(&iter) == 0) {

fs/btrfs/ioctl.c

4368

ret = btrfs_encoded_read(&kiocb, &iter, &args, &cached_state,

fs/btrfs/ioctl.c

4383

ret = btrfs_encoded_read_regular(&kiocb, &iter, start, lockend,

fs/btrfs/ioctl.c

4416

struct iov_iter iter;

fs/btrfs/ioctl.c

4476

&iov, &iter);

fs/btrfs/ioctl.c

4480

if (iov_iter_count(&iter) == 0) {

fs/btrfs/ioctl.c

4497

ret = btrfs_do_write_iter(&kiocb, &iter, &args);

fs/btrfs/ioctl.c

4515

struct iov_iter iter;

fs/btrfs/ioctl.c

4529

struct iov_iter iter;

fs/btrfs/ioctl.c

4575

&priv->iter) != bytes) {

fs/btrfs/ioctl.c

4613

static int btrfs_uring_read_extent(struct kiocb *iocb, struct iov_iter *iter,

fs/btrfs/ioctl.c

4645

priv->iter = *iter;

fs/btrfs/ioctl.c

4764

&data->iter);

fs/btrfs/ioctl.c

4768

if (iov_iter_count(&data->iter) == 0) {

fs/btrfs/ioctl.c

4788

ret = btrfs_encoded_read(&kiocb, &data->iter, &data->args, &cached_state,

fs/btrfs/ioctl.c

4809

u64 count = min_t(u64, iov_iter_count(&data->iter), disk_io_size);

fs/btrfs/ioctl.c

4815

ret = btrfs_uring_read_extent(&kiocb, &data->iter, start, lockend,

fs/btrfs/ioctl.c

4919

&data->iter);

fs/btrfs/ioctl.c

4923

if (iov_iter_count(&data->iter) == 0) {

fs/btrfs/ioctl.c

4947

ret = btrfs_do_write_iter(&kiocb, &data->iter, &data->args);

fs/btrfs/misc.h

32

const struct bvec_iter *iter)

fs/btrfs/misc.h

34

struct bio_vec bv = bio_iter_iovec(bio, *iter);

fs/btrfs/misc.h

51

#define btrfs_bio_for_each_block(paddr, bio, iter, blocksize) \

fs/btrfs/misc.h

52

for (; (iter)->bi_size && \

fs/btrfs/misc.h

53

(paddr = bio_iter_phys((bio), (iter)), 1); \

fs/btrfs/misc.h

54

bio_advance_iter_single((bio), (iter), (blocksize)))

fs/btrfs/misc.h

82

for (struct bvec_iter iter = init_bvec_iter_for_bio(bio); \

fs/btrfs/misc.h

83

(iter).bi_size && \

fs/btrfs/misc.h

84

(paddr = bio_iter_phys((bio), &(iter)), 1); \

fs/btrfs/misc.h

85

bio_advance_iter_single((bio), &(iter), (blocksize)))

fs/btrfs/qgroup.c

4659

struct ulist_iterator iter;

fs/btrfs/qgroup.c

4669

ULIST_ITER_INIT(&iter);

fs/btrfs/qgroup.c

4670

while ((unode = ulist_next(&changeset.range_changed, &iter))) {

fs/btrfs/raid56.c

1293

struct bvec_iter iter = bio->bi_iter;

fs/btrfs/raid56.c

1298

btrfs_bio_for_each_block(paddr, bio, &iter, step) {

fs/btrfs/relocation.c

503

struct btrfs_backref_iter iter;

fs/btrfs/relocation.c

512

ret = btrfs_backref_iter_init(&iter);

fs/btrfs/relocation.c

531

ret = btrfs_backref_add_tree_node(trans, cache, path, &iter,

fs/btrfs/relocation.c

556

btrfs_free_path(iter.path);

fs/cachefiles/internal.h

259

struct iov_iter *iter,

fs/cachefiles/io.c

124

iov_iter_zero(len, iter);

fs/cachefiles/io.c

131

iov_iter_zero(skipped, iter);

fs/cachefiles/io.c

161

ret = vfs_iocb_iter_read(file, &ki->iocb, iter);

fs/cachefiles/io.c

284

struct iov_iter *iter,

fs/cachefiles/io.c

292

size_t len = iov_iter_count(iter);

fs/cachefiles/io.c

332

ret = vfs_iocb_iter_write(file, &ki->iocb, iter);

fs/cachefiles/io.c

361

struct iov_iter *iter,

fs/cachefiles/io.c

374

start_pos, iter,

fs/cachefiles/io.c

77

struct iov_iter *iter,

fs/cachefiles/io.c

87

size_t len = iov_iter_count(iter), skipped = 0;

fs/cachefiles/ondemand.c

59

struct iov_iter *iter)

fs/cachefiles/ondemand.c

64

size_t len = iter->count, aligned_len = len;

fs/cachefiles/ondemand.c

85

ret = __cachefiles_write(object, file, pos, iter, NULL, NULL);

fs/ceph/caps.c

1674

struct ceph_cap_flush *cf = NULL, *iter;

fs/ceph/caps.c

1684

list_for_each_entry(iter, &ci->i_cap_flush_list, i_list) {

fs/ceph/caps.c

1685

if (iter->tid >= first_tid) {

fs/ceph/caps.c

1686

cf = iter;

fs/ceph/caps.c

3364

struct ceph_cap_snap *capsnap = NULL, *iter;

fs/ceph/caps.c

3392

list_for_each_entry(iter, &ci->i_cap_snaps, ci_item) {

fs/ceph/caps.c

3393

if (iter->context == snapc) {

fs/ceph/caps.c

3394

capsnap = iter;

fs/ceph/caps.c

4000

struct ceph_cap_snap *capsnap = NULL, *iter;

fs/ceph/caps.c

4008

list_for_each_entry(iter, &ci->i_cap_snaps, ci_item) {

fs/ceph/caps.c

4009

if (iter->follows == follows) {

fs/ceph/caps.c

4010

if (iter->cap_flush.tid != flush_tid) {

fs/ceph/caps.c

4012

"tid %lld != %lld\n", iter,

fs/ceph/caps.c

4014

iter->cap_flush.tid);

fs/ceph/caps.c

4017

capsnap = iter;

fs/ceph/caps.c

4021

iter, iter->follows);

fs/ceph/file.c

104

static ssize_t __iter_get_bvecs(struct iov_iter *iter, size_t maxsize,

fs/ceph/file.c

110

if (maxsize > iov_iter_count(iter))

fs/ceph/file.c

111

maxsize = iov_iter_count(iter);

fs/ceph/file.c

119

bytes = iov_iter_get_pages2(iter, pages, maxsize - size,

fs/ceph/file.c

1367

unsigned int len = osd_data->bvec_pos.iter.bi_size;

fs/ceph/file.c

146

static ssize_t iter_get_bvecs_alloc(struct iov_iter *iter, size_t maxsize,

fs/ceph/file.c

150

size_t orig_count = iov_iter_count(iter);

fs/ceph/file.c

1519

ceph_direct_read_write(struct kiocb *iocb, struct iov_iter *iter,

fs/ceph/file.c

1537

size_t count = iov_iter_count(iter);

fs/ceph/file.c

1539

bool write = iov_iter_rw(iter) == WRITE;

fs/ceph/file.c

154

iov_iter_truncate(iter, maxsize);

fs/ceph/file.c

1540

bool should_dirty = !write && user_backed_iter(iter);

fs/ceph/file.c

155

npages = iov_iter_npages(iter, INT_MAX);

fs/ceph/file.c

156

iov_iter_reexpand(iter, orig_count);

fs/ceph/file.c

1567

while (iov_iter_count(iter) > 0) {

fs/ceph/file.c

1568

u64 size = iov_iter_count(iter);

fs/ceph/file.c

1603

len = iter_get_bvecs_alloc(iter, size, &bvecs, &num_pages);

fs/ceph/file.c

166

bytes = __iter_get_bvecs(iter, maxsize, bv);

fs/ceph/inode.c

2449

struct iov_iter iter;

fs/ceph/inode.c

2492

iov_iter_kvec(&iter, READ, &iov, 1, len);

fs/ceph/inode.c

2495

ret = __ceph_sync_read(inode, &pos, &iter, &retry_op, &objver);

fs/coredump.c

1278

struct iov_iter iter;

fs/coredump.c

1297

iov_iter_bvec(&iter, ITER_SOURCE, &bvec, 1, PAGE_SIZE);

fs/coredump.c

1298

n = __kernel_write_iter(cprm->file, &iter, &pos);

fs/dax.c

1040

static int copy_cow_page_dax(struct vm_fault *vmf, const struct iomap_iter *iter)

fs/dax.c

1042

pgoff_t pgoff = dax_iomap_pgoff(&iter->iomap, iter->pos);

fs/dax.c

1048

rc = dax_direct_access(iter->iomap.dax_dev, pgoff, 1, DAX_ACCESS,

fs/dax.c

1065

static bool dax_fault_is_synchronous(const struct iomap_iter *iter,

fs/dax.c

1068

return (iter->flags & IOMAP_WRITE) && (vma->vm_flags & VM_SYNC) &&

fs/dax.c

1069

(iter->iomap.flags & IOMAP_F_DIRTY);

fs/dax.c

1080

const struct iomap_iter *iter, void *entry, unsigned long pfn,

fs/dax.c

1085

bool write = iter->flags & IOMAP_WRITE;

fs/dax.c

1086

bool dirty = write && !dax_fault_is_synchronous(iter, vmf->vma);

fs/dax.c

1087

bool shared = iter->iomap.flags & IOMAP_F_SHARED;

fs/dax.c

1396

const struct iomap_iter *iter, void **entry)

fs/dax.c

1398

struct inode *inode = iter->inode;

fs/dax.c

1403

*entry = dax_insert_entry(xas, vmf, iter, *entry, pfn, DAX_ZERO_PAGE);

fs/dax.c

1412

const struct iomap_iter *iter, void **entry)

fs/dax.c

1426

*entry = dax_insert_entry(xas, vmf, iter, *entry, folio_pfn(zero_folio),

fs/dax.c

1436

const struct iomap_iter *iter, void **entry)

fs/dax.c

1442

static int dax_unshare_iter(struct iomap_iter *iter)

fs/dax.c

1444

struct iomap *iomap = &iter->iomap;

fs/dax.c

1445

const struct iomap *srcmap = iomap_iter_srcmap(iter);

fs/dax.c

1446

loff_t copy_pos = iter->pos;

fs/dax.c

1447

u64 copy_len = iomap_length(iter);

fs/dax.c

1453

if (!iomap_want_unshare_iter(iter))

fs/dax.c

1454

return iomap_iter_advance_full(iter);

fs/dax.c

1471

invalidate_inode_pages2_range(iter->inode->i_mapping,

fs/dax.c

1491

return iomap_iter_advance_full(iter);

fs/dax.c

1497

struct iomap_iter iter = {

fs/dax.c

1508

iter.len = min(len, size - pos);

fs/dax.c

1509

while ((ret = iomap_iter(&iter, ops)) > 0)

fs/dax.c

1510

iter.status = dax_unshare_iter(&iter);

fs/dax.c

1515

static int dax_memzero(struct iomap_iter *iter, loff_t pos, size_t size)

fs/dax.c

1517

const struct iomap *iomap = &iter->iomap;

fs/dax.c

1518

const struct iomap *srcmap = iomap_iter_srcmap(iter);

fs/dax.c

1538

static int dax_zero_iter(struct iomap_iter *iter, bool *did_zero)

fs/dax.c

1540

const struct iomap *iomap = &iter->iomap;

fs/dax.c

1541

const struct iomap *srcmap = iomap_iter_srcmap(iter);

fs/dax.c

1542

u64 length = iomap_length(iter);

fs/dax.c

1547

return iomap_iter_advance(iter, length);

fs/dax.c

1554

invalidate_inode_pages2_range(iter->inode->i_mapping,

fs/dax.c

1555

iter->pos >> PAGE_SHIFT,

fs/dax.c

1556

(iter->pos + length - 1) >> PAGE_SHIFT);

fs/dax.c

1559

loff_t pos = iter->pos;

fs/dax.c

1570

ret = dax_memzero(iter, pos, length);

fs/dax.c

1576

ret = iomap_iter_advance(iter, length);

fs/dax.c

1579

} while ((length = iomap_length(iter)) > 0);

fs/dax.c

1589

struct iomap_iter iter = {

fs/dax.c

1597

while ((ret = iomap_iter(&iter, ops)) > 0)

fs/dax.c

1598

iter.status = dax_zero_iter(&iter, did_zero);

fs/dax.c

1616

static int dax_iomap_iter(struct iomap_iter *iomi, struct iov_iter *iter)

fs/dax.c

1624

bool write = iov_iter_rw(iter) == WRITE;

fs/dax.c

1636

done = iov_iter_zero(min(length, end - pos), iter);

fs/dax.c

1686

if (map_len == -EHWPOISON && iov_iter_rw(iter) == WRITE) {

fs/dax.c

1713

map_len, iter);

fs/dax.c

1716

map_len, iter);

fs/dax.c

1719

map_len, iter);

fs/dax.c

1744

dax_iomap_rw(struct kiocb *iocb, struct iov_iter *iter,

fs/dax.c

1750

.len = iov_iter_count(iter),

fs/dax.c

1762

if (iov_iter_rw(iter) == WRITE) {

fs/dax.c

1773

iomi.status = dax_iomap_iter(&iomi, iter);

fs/dax.c

1804

const struct iomap_iter *iter)

fs/dax.c

1809

switch (iter->iomap.type) {

fs/dax.c

1815

error = copy_cow_page_dax(vmf, iter);

fs/dax.c

1843

const struct iomap_iter *iter, unsigned long *pfnp,

fs/dax.c

1846

const struct iomap *iomap = &iter->iomap;

fs/dax.c

1847

const struct iomap *srcmap = iomap_iter_srcmap(iter);

fs/dax.c

1850

bool write = iter->flags & IOMAP_WRITE;

fs/dax.c

1858

return dax_fault_cow_page(vmf, iter);

fs/dax.c

1864

return dax_load_hole(xas, vmf, iter, entry);

fs/dax.c

1865

return dax_pmd_load_hole(xas, vmf, iter, entry);

fs/dax.c

1877

*entry = dax_insert_entry(xas, vmf, iter, *entry, pfn, entry_flags);

fs/dax.c

1886

if (dax_fault_is_synchronous(iter, vmf->vma))

fs/dax.c

1904

struct iomap_iter iter = {

fs/dax.c

1914

trace_dax_pte_fault(iter.inode, vmf, ret);

fs/dax.c

1920

if (iter.pos >= i_size_read(iter.inode)) {

fs/dax.c

1926

iter.flags |= IOMAP_WRITE;

fs/dax.c

1945

while ((error = iomap_iter(&iter, ops)) > 0) {

fs/dax.c

1946

if (WARN_ON_ONCE(iomap_length(&iter) < PAGE_SIZE)) {

fs/dax.c

1947

iter.status = -EIO; /* fs corruption? */

fs/dax.c

1951

ret = dax_fault_iter(vmf, &iter, pfnp, &xas, &entry, false);

fs/dax.c

1953

(iter.iomap.flags & IOMAP_F_NEW)) {

fs/dax.c

1960

iter.status = iomap_iter_advance(&iter, PAGE_SIZE);

fs/dax.c

1971

trace_dax_pte_fault_done(iter.inode, vmf, ret);

fs/dax.c

2014

struct iomap_iter iter = {

fs/dax.c

2024

iter.flags |= IOMAP_WRITE;

fs/dax.c

2031

max_pgoff = DIV_ROUND_UP(i_size_read(iter.inode), PAGE_SIZE);

fs/dax.c

2033

trace_dax_pmd_fault(iter.inode, vmf, max_pgoff, 0);

fs/dax.c

2066

iter.pos = (loff_t)xas.xa_index << PAGE_SHIFT;

fs/dax.c

2067

while (iomap_iter(&iter, ops) > 0) {

fs/dax.c

2068

if (iomap_length(&iter) < PMD_SIZE)

fs/dax.c

2071

ret = dax_fault_iter(vmf, &iter, pfnp, &xas, &entry, true);

fs/dax.c

2073

iter.status = iomap_iter_advance(&iter, PMD_SIZE);

fs/dax.c

2084

trace_dax_pmd_fault_done(iter.inode, vmf, max_pgoff, ret);

fs/direct-io.c

105

struct iov_iter *iter;

fs/direct-io.c

1102

struct block_device *bdev, struct iov_iter *iter,

fs/direct-io.c

1110

const size_t count = iov_iter_count(iter);

fs/direct-io.c

1117

unsigned long align = offset | iov_iter_alignment(iter);

fs/direct-io.c

1120

if (iov_iter_rw(iter) == READ && !count)

fs/direct-io.c

1134

if (dio->flags & DIO_LOCKING && iov_iter_rw(iter) == READ) {

fs/direct-io.c

1138

dio->is_pinned = iov_iter_extract_will_pin(iter);

fs/direct-io.c

1142

if (iov_iter_rw(iter) == READ && offset >= dio->i_size) {

fs/direct-io.c

1155

if (dio->flags & DIO_LOCKING && iov_iter_rw(iter) == READ) {

fs/direct-io.c

1171

else if (iov_iter_rw(iter) == WRITE && end > i_size_read(inode))

fs/direct-io.c

1177

if (iov_iter_rw(iter) == WRITE)

fs/direct-io.c

1186

if (dio->is_async && iov_iter_rw(iter) == WRITE) {

fs/direct-io.c

1221

dio->should_dirty = user_backed_iter(iter) && iov_iter_rw(iter) == READ;

fs/direct-io.c

1222

sdio.iter = iter;

fs/direct-io.c

1232

sdio.pages_in_io += iov_iter_npages(iter, INT_MAX);

fs/direct-io.c

1278

if (iov_iter_rw(iter) == READ && (dio->flags & DIO_LOCKING))

fs/direct-io.c

1290

(iov_iter_rw(iter) == READ || dio->result == count))

fs/direct-io.c

1303

if (dio->flags & DIO_LOCKING && iov_iter_rw(iter) == READ)

fs/direct-io.c

172

ret = iov_iter_extract_pages(sdio->iter, &pages, LONG_MAX,

fs/dlm/dir.c

254

struct dlm_dir_dump *iter, *dd = NULL;

fs/dlm/dir.c

257

list_for_each_entry(iter, &ls->ls_dir_dump_list, list) {

fs/dlm/dir.c

258

if (iter->nodeid_init == nodeid) {

fs/dlm/dir.c

259

dd = iter;

fs/dlm/lock.c

1641

struct dlm_lkb *lkb = NULL, *iter;

fs/dlm/lock.c

1643

list_for_each_entry(iter, head, lkb_statequeue)

fs/dlm/lock.c

1644

if (iter->lkb_rqmode < mode) {

fs/dlm/lock.c

1645

lkb = iter;

fs/dlm/lock.c

1646

list_add_tail(new, &iter->lkb_statequeue);

fs/dlm/lock.c

5154

struct dlm_lkb *lkb = NULL, *iter;

fs/dlm/lock.c

5157

list_for_each_entry(iter, &ls->ls_waiters, lkb_wait_reply) {

fs/dlm/lock.c

5158

if (test_bit(DLM_IFL_RESEND_BIT, &iter->lkb_iflags)) {

fs/dlm/lock.c

5159

hold_lkb(iter);

fs/dlm/lock.c

5160

lkb = iter;

fs/dlm/lock.c

5867

struct dlm_lkb *lkb = NULL, *iter;

fs/dlm/lock.c

5873

list_for_each_entry(iter, &ls->ls_orphans, lkb_ownqueue) {

fs/dlm/lock.c

5874

if (iter->lkb_resource->res_length != namelen)

fs/dlm/lock.c

5876

if (memcmp(iter->lkb_resource->res_name, name, namelen))

fs/dlm/lock.c

5878

if (iter->lkb_grmode != mode) {

fs/dlm/lock.c

5883

lkb = iter;

fs/dlm/lock.c

5884

list_del_init(&iter->lkb_ownqueue);

fs/dlm/lock.c

5885

clear_bit(DLM_DFL_ORPHAN_BIT, &iter->lkb_dflags);

fs/dlm/lock.c

5886

*lkid = iter->lkb_id;

fs/dlm/plock.c

49

struct plock_op *op = NULL, *iter;

fs/dlm/plock.c

51

list_for_each_entry(iter, &recv_list, list) {

fs/dlm/plock.c

52

if (iter->info.fsid == info->fsid &&

fs/dlm/plock.c

523

struct plock_op *op = NULL, *iter;

fs/dlm/plock.c

53

iter->info.number == info->number &&

fs/dlm/plock.c

54

iter->info.owner == info->owner &&

fs/dlm/plock.c

548

list_for_each_entry(iter, &recv_list, list) {

fs/dlm/plock.c

549

if (!iter->info.wait &&

fs/dlm/plock.c

55

iter->info.pid == info->pid &&

fs/dlm/plock.c

550

iter->info.fsid == info.fsid) {

fs/dlm/plock.c

551

op = iter;

fs/dlm/plock.c

56

iter->info.start == info->start &&

fs/dlm/plock.c

57

iter->info.end == info->end &&

fs/dlm/plock.c

58

iter->info.ex == info->ex &&

fs/dlm/plock.c

59

iter->info.wait) {

fs/dlm/plock.c

60

op = iter;

fs/dlm/recover.c

733

struct dlm_lkb *big_lkb = NULL, *iter, *high_lkb = NULL;

fs/dlm/recover.c

751

list_for_each_entry(iter, &r->res_grantqueue, lkb_statequeue) {

fs/dlm/recover.c

752

if (!(iter->lkb_exflags & DLM_LKF_VALBLK))

fs/dlm/recover.c

757

if (iter->lkb_grmode > DLM_LOCK_CR) {

fs/dlm/recover.c

758

big_lkb = iter;

fs/dlm/recover.c

762

if (((int)iter->lkb_lvbseq - (int)high_seq) >= 0) {

fs/dlm/recover.c

763

high_lkb = iter;

fs/dlm/recover.c

764

high_seq = iter->lkb_lvbseq;

fs/dlm/recover.c

768

list_for_each_entry(iter, &r->res_convertqueue, lkb_statequeue) {

fs/dlm/recover.c

769

if (!(iter->lkb_exflags & DLM_LKF_VALBLK))

fs/dlm/recover.c

774

if (iter->lkb_grmode > DLM_LOCK_CR) {

fs/dlm/recover.c

775

big_lkb = iter;

fs/dlm/recover.c

779

if (((int)iter->lkb_lvbseq - (int)high_seq) >= 0) {

fs/dlm/recover.c

780

high_lkb = iter;

fs/dlm/recover.c

781

high_seq = iter->lkb_lvbseq;

fs/erofs/data.c

302

struct iomap_iter *iter = container_of(iomap, struct iomap_iter, iomap);

fs/erofs/data.c

303

struct erofs_iomap_iter_ctx *ctx = iter->private;

fs/erofs/data.c

367

struct iomap_iter *iter = container_of(iomap, struct iomap_iter, iomap);

fs/erofs/data.c

368

struct erofs_iomap_iter_ctx *ctx = iter->private;

fs/erofs/fileio.c

46

struct iov_iter iter;

fs/erofs/fileio.c

57

iov_iter_bvec(&iter, ITER_DEST, rq->bvecs, rq->bio.bi_vcnt,

fs/erofs/fileio.c

60

ret = vfs_iocb_iter_read(rq->iocb.ki_filp, &rq->iocb, &iter);

fs/erofs/zdata.c

141

static struct page *z_erofs_bvec_iter_end(struct z_erofs_bvec_iter *iter)

fs/erofs/zdata.c

143

if (iter->bvpage)

fs/erofs/zdata.c

144

kunmap_local(iter->bvset);

fs/erofs/zdata.c

145

return iter->bvpage;

fs/erofs/zdata.c

148

static struct page *z_erofs_bvset_flip(struct z_erofs_bvec_iter *iter)

fs/erofs/zdata.c

152

struct page *nextpage = iter->bvset->nextpage;

fs/erofs/zdata.c

156

oldpage = z_erofs_bvec_iter_end(iter);

fs/erofs/zdata.c

157

iter->bvpage = nextpage;

fs/erofs/zdata.c

158

iter->bvset = kmap_local_page(nextpage);

fs/erofs/zdata.c

159

iter->nr = (PAGE_SIZE - base) / sizeof(struct z_erofs_bvec);

fs/erofs/zdata.c

160

iter->cur = 0;

fs/erofs/zdata.c

164

static void z_erofs_bvec_iter_begin(struct z_erofs_bvec_iter *iter,

fs/erofs/zdata.c

169

*iter = (struct z_erofs_bvec_iter) {

fs/erofs/zdata.c

174

while (cur > iter->nr) {

fs/erofs/zdata.c

175

cur -= iter->nr;

fs/erofs/zdata.c

176

z_erofs_bvset_flip(iter);

fs/erofs/zdata.c

178

iter->cur = cur;

fs/erofs/zdata.c

181

static int z_erofs_bvec_enqueue(struct z_erofs_bvec_iter *iter,

fs/erofs/zdata.c

186

if (iter->cur >= iter->nr) {

fs/erofs/zdata.c

196

DBG_BUGON(iter->bvset->nextpage);

fs/erofs/zdata.c

197

iter->bvset->nextpage = nextpage;

fs/erofs/zdata.c

198

z_erofs_bvset_flip(iter);

fs/erofs/zdata.c

200

iter->bvset->nextpage = NULL;

fs/erofs/zdata.c

203

iter->bvset->bvec[iter->cur++] = *bvec;

fs/erofs/zdata.c

207

static void z_erofs_bvec_dequeue(struct z_erofs_bvec_iter *iter,

fs/erofs/zdata.c

211

if (iter->cur == iter->nr)

fs/erofs/zdata.c

212

*old_bvpage = z_erofs_bvset_flip(iter);

fs/erofs/zdata.c

215

*bvec = iter->bvset->bvec[iter->cur++];

fs/exfat/file.c

731

static ssize_t exfat_file_write_iter(struct kiocb *iocb, struct iov_iter *iter)

fs/exfat/file.c

751

ret = generic_write_checks(iocb, iter);

fs/exfat/file.c

773

ret = exfat_dio_write_iter(iocb, iter);

fs/exfat/file.c

775

ret = iomap_file_buffered_write(iocb, iter,

fs/exfat/file.c

800

static ssize_t exfat_file_read_iter(struct kiocb *iocb, struct iov_iter *iter)

fs/exfat/file.c

812

ret = iomap_dio_rw(iocb, iter, &exfat_iomap_ops, NULL, 0,

fs/exfat/file.c

815

ret = generic_file_read_iter(iocb, iter);

fs/exfat/iomap.c

234

struct folio_iter iter;

fs/exfat/iomap.c

236

bio_for_each_folio_all(iter, bio) {

fs/exfat/iomap.c

237

struct folio *folio = iter.folio;

fs/exfat/iomap.c

243

if (pos + iter.offset < valid_size &&

fs/exfat/iomap.c

244

pos + iter.offset + iter.length > valid_size)

fs/exfat/iomap.c

246

iter.offset + iter.length);

fs/exfat/iomap.c

248

iomap_finish_folio_read(folio, iter.offset, iter.length, error);

fs/exfat/iomap.c

253

static void exfat_iomap_bio_submit_read(const struct iomap_iter *iter,

fs/exfat/iomap.c

256

iomap_bio_submit_read_endio(iter, ctx, exfat_iomap_read_end_io);

fs/ext2/trace.h

12

TP_PROTO(struct kiocb *iocb, struct iov_iter *iter, ssize_t ret),

fs/ext2/trace.h

13

TP_ARGS(iocb, iter, ret),

fs/ext2/trace.h

29

__entry->count = iov_iter_count(iter);

fs/ext2/trace.h

47

TP_PROTO(struct kiocb *iocb, struct iov_iter *iter, ssize_t ret), \

fs/ext2/trace.h

48

TP_ARGS(iocb, iter, ret))

fs/ext4/fast_commit.c

1262

struct ext4_inode_info *iter;

fs/ext4/fast_commit.c

1271

list_for_each_entry(iter, &sbi->s_fc_q[FC_Q_MAIN], i_fc_list) {

fs/ext4/fast_commit.c

1279

inodes[i++] = &iter->vfs_inode;

fs/ext4/fast_commit.c

1344

struct ext4_inode_info *iter;

fs/ext4/fast_commit.c

1365

list_for_each_entry(iter, &sbi->s_fc_q[FC_Q_MAIN], i_fc_list) {

fs/ext4/fast_commit.c

1366

ext4_set_inode_state(&iter->vfs_inode,

fs/ext4/fast_commit.c

1380

list_for_each_entry(iter, &sbi->s_fc_q[FC_Q_MAIN], i_fc_list) {

fs/ext4/fast_commit.c

1381

ext4_clear_inode_state(&iter->vfs_inode,

fs/ext4/fast_commit.c

1383

ext4_fc_wake_inode_state(&iter->vfs_inode,

fs/ext4/fast_commit.c

1421

list_for_each_entry(iter, &sbi->s_fc_q[FC_Q_MAIN], i_fc_list) {

fs/ext4/fast_commit.c

1422

ext4_set_inode_state(&iter->vfs_inode,

fs/ext4/fast_commit.c

1474

list_for_each_entry(iter, &sbi->s_fc_q[FC_Q_MAIN], i_fc_list) {

fs/ext4/fast_commit.c

1475

inode = &iter->vfs_inode;

fs/ext4/fast_commit.c

1498

struct ext4_inode_info *iter;

fs/ext4/fast_commit.c

1504

list_for_each_entry(iter, &sbi->s_fc_q[FC_Q_MAIN], i_fc_list)

fs/ext4/file.c

55

static bool ext4_should_use_dio(struct kiocb *iocb, struct iov_iter *iter)

fs/ext4/file.c

66

return IS_ALIGNED(iocb->ki_pos | iov_iter_alignment(iter), dio_align);

fs/ext4/mballoc.c

4349

struct rb_node *iter;

fs/ext4/mballoc.c

4352

for (iter = ei->i_prealloc_node.rb_node; iter;

fs/ext4/mballoc.c

4353

iter = ext4_mb_pa_rb_next_iter(start, tmp_pa_start, iter)) {

fs/ext4/mballoc.c

4354

tmp_pa = rb_entry(iter, struct ext4_prealloc_space,

fs/ext4/mballoc.c

4384

struct rb_node *iter;

fs/ext4/mballoc.c

4399

for (iter = ei->i_prealloc_node.rb_node; iter;

fs/ext4/mballoc.c

4400

iter = ext4_mb_pa_rb_next_iter(ac->ac_o_ex.fe_logical,

fs/ext4/mballoc.c

4401

tmp_pa_start, iter)) {

fs/ext4/mballoc.c

4402

tmp_pa = rb_entry(iter, struct ext4_prealloc_space,

fs/ext4/mballoc.c

4445

for (iter = &left_pa->pa_node.inode_node;;

fs/ext4/mballoc.c

4446

iter = rb_prev(iter)) {

fs/ext4/mballoc.c

4447

if (!iter) {

fs/ext4/mballoc.c

4452

tmp_pa = rb_entry(iter, struct ext4_prealloc_space,

fs/ext4/mballoc.c

4465

for (iter = &right_pa->pa_node.inode_node;;

fs/ext4/mballoc.c

4466

iter = rb_next(iter)) {

fs/ext4/mballoc.c

4467

if (!iter) {

fs/ext4/mballoc.c

4472

tmp_pa = rb_entry(iter, struct ext4_prealloc_space,

fs/ext4/mballoc.c

4883

struct rb_node *iter;

fs/ext4/mballoc.c

4909

for (iter = ei->i_prealloc_node.rb_node; iter;

fs/ext4/mballoc.c

4910

iter = ext4_mb_pa_rb_next_iter(ac->ac_o_ex.fe_logical,

fs/ext4/mballoc.c

4911

tmp_pa->pa_lstart, iter)) {

fs/ext4/mballoc.c

4912

tmp_pa = rb_entry(iter, struct ext4_prealloc_space,

fs/ext4/mballoc.c

4945

for (iter = &tmp_pa->pa_node.inode_node;; iter = rb_prev(iter)) {

fs/ext4/mballoc.c

4946

if (!iter) {

fs/ext4/mballoc.c

4953

tmp_pa = rb_entry(iter, struct ext4_prealloc_space,

fs/ext4/mballoc.c

5224

struct rb_node **iter = &root->rb_node, *parent = NULL;

fs/ext4/mballoc.c

5228

while (*iter) {

fs/ext4/mballoc.c

5229

iter_pa = rb_entry(*iter, struct ext4_prealloc_space,

fs/ext4/mballoc.c

5236

parent = *iter;

fs/ext4/mballoc.c

5238

iter = &((*iter)->rb_left);

fs/ext4/mballoc.c

5240

iter = &((*iter)->rb_right);

fs/ext4/mballoc.c

5243

rb_link_node(new, parent, iter);

fs/ext4/mballoc.c

5616

struct rb_node *iter;

fs/ext4/mballoc.c

5633

for (iter = rb_first(&ei->i_prealloc_node); iter;

fs/ext4/mballoc.c

5634

iter = rb_next(iter)) {

fs/ext4/mballoc.c

5635

pa = rb_entry(iter, struct ext4_prealloc_space,

fs/f2fs/file.c

4767

struct iov_iter *iter)

fs/f2fs/file.c

4774

if (f2fs_force_buffered_io(inode, iov_iter_rw(iter)))

fs/f2fs/file.c

4788

align = iocb->ki_pos | iov_iter_alignment(iter);

fs/f2fs/file.c

4835

static void f2fs_dio_read_submit_io(const struct iomap_iter *iter,

fs/f2fs/file.c

4838

struct f2fs_sb_info *sbi = F2FS_I_SB(iter->inode);

fs/f2fs/file.c

5017

static int f2fs_preallocate_blocks(struct kiocb *iocb, struct iov_iter *iter,

fs/f2fs/file.c

5023

const size_t count = iov_iter_count(iter);

fs/f2fs/file.c

5044

if (fault_in_iov_iter_readable(iter, count))

fs/f2fs/file.c

5131

static void f2fs_dio_write_submit_io(const struct iomap_iter *iter,

fs/f2fs/file.c

5134

struct inode *inode = iter->inode;

fs/f2fs/file.c

5136

struct kiocb *iocb = iter->private;

fs/f2fs/gc.c

572

unsigned int iter = 0;

fs/f2fs/gc.c

607

iter++;

fs/f2fs/gc.c

616

if (iter < dirty_threshold) {

fs/f2fs/gc.c

639

unsigned int cost, iter;

fs/f2fs/gc.c

646

iter = 0;

fs/f2fs/gc.c

667

iter++;

fs/f2fs/gc.c

679

if (iter < dirty_threshold) {

fs/f2fs/segment.c

1785

struct discard_cmd *dc = NULL, *iter, *tmp;

fs/f2fs/segment.c

1792

list_for_each_entry_safe(iter, tmp, wait_list, list) {

fs/f2fs/segment.c

1793

if (iter->di.lstart + iter->di.len <= start ||

fs/f2fs/segment.c

1794

end <= iter->di.lstart)

fs/f2fs/segment.c

1796

if (iter->di.len < dpolicy->granularity)

fs/f2fs/segment.c

1798

if (iter->state == D_DONE && !iter->ref) {

fs/f2fs/segment.c

1799

wait_for_completion_io(&iter->wait);

fs/f2fs/segment.c

1800

if (!iter->error)

fs/f2fs/segment.c

1801

trimmed += iter->di.len;

fs/f2fs/segment.c

1802

__remove_discard_cmd(sbi, iter);

fs/f2fs/segment.c

1804

iter->ref++;

fs/f2fs/segment.c

1805

dc = iter;

fs/fat/inode.c

256

static ssize_t fat_direct_IO(struct kiocb *iocb, struct iov_iter *iter)

fs/fat/inode.c

261

size_t count = iov_iter_count(iter);

fs/fat/inode.c

265

if (iov_iter_rw(iter) == WRITE) {

fs/fat/inode.c

284

ret = blockdev_direct_IO(iocb, inode, iter, fat_get_block);

fs/fat/inode.c

285

if (ret < 0 && iov_iter_rw(iter) == WRITE)

fs/fuse/dev.c

1050

err = iov_iter_get_pages2(cs->iter, &page, PAGE_SIZE, 1, &off);

fs/fuse/dev.c

974

struct iov_iter *iter)

fs/fuse/dev.c

978

cs->iter = iter;

fs/fuse/dev_uring.c

1103

struct iov_iter iter;

fs/fuse/dev_uring.c

1114

FUSE_URING_IOV_SEGS, &iov, &iter);

fs/fuse/dev_uring.c

649

struct iov_iter *iter)

fs/fuse/dev_uring.c

653

err = import_ubuf(dir, ent->payload, ring->max_payload_sz, iter);

fs/fuse/dev_uring.c

659

fuse_copy_init(cs, dir == ITER_DEST, iter);

fs/fuse/dev_uring.c

673

struct iov_iter iter;

fs/fuse/dev_uring.c

682

err = setup_fuse_copy_state(&cs, ring, req, ent, ITER_SOURCE, &iter);

fs/fuse/dev_uring.c

702

struct iov_iter iter;

fs/fuse/dev_uring.c

708

err = setup_fuse_copy_state(&cs, ring, req, ent, ITER_DEST, &iter);

fs/fuse/file.c

1011

static int fuse_iomap_read_folio_range(const struct iomap_iter *iter,

fs/fuse/file.c

1015

struct file *file = iter->private;

fs/fuse/file.c

1411

static bool fuse_io_past_eof(struct kiocb *iocb, struct iov_iter *iter)

fs/fuse/file.c

1415

return iocb->ki_pos + iov_iter_count(iter) > i_size_read(inode);

fs/fuse/file.c

1665

ssize_t fuse_direct_io(struct fuse_io_priv *io, struct iov_iter *iter,

fs/fuse/file.c

1677

size_t count = iov_iter_count(iter);

fs/fuse/file.c

1686

max_pages = iov_iter_npages(iter, fc->max_pages);

fs/fuse/file.c

1714

io->should_dirty = !write && user_backed_iter(iter);

fs/fuse/file.c

1720

err = fuse_get_user_pages(&ia->ap, iter, &nbytes, write,

fs/fuse/file.c

1740

iov_iter_revert(iter, nbytes);

fs/fuse/file.c

1750

iov_iter_revert(iter, nbytes - nres);

fs/fuse/file.c

1754

max_pages = iov_iter_npages(iter, fc->max_pages);

fs/fuse/file.c

1770

struct iov_iter *iter,

fs/fuse/file.c

1776

res = fuse_direct_io(io, iter, ppos, 0);

fs/fuse/file.c

1783

static ssize_t fuse_direct_IO(struct kiocb *iocb, struct iov_iter *iter);

fs/fuse/file.c

2728

fuse_direct_IO(struct kiocb *iocb, struct iov_iter *iter)

fs/fuse/file.c

2737

size_t count = iov_iter_count(iter), shortened = 0;

fs/fuse/file.c

2746

if ((iov_iter_rw(iter) == READ) && (offset >= i_size))

fs/fuse/file.c

2749

if ((iov_iter_rw(iter) == WRITE) && async && !inode->i_sb->s_dio_done_wq) {

fs/fuse/file.c

2764

io->write = (iov_iter_rw(iter) == WRITE);

fs/fuse/file.c

2776

iov_iter_truncate(iter, fuse_round_up(ff->fm->fc, i_size - offset));

fs/fuse/file.c

2777

shortened = count - iov_iter_count(iter);

fs/fuse/file.c

2797

if (iov_iter_rw(iter) == WRITE) {

fs/fuse/file.c

2798

ret = fuse_direct_io(io, iter, &pos, FUSE_DIO_WRITE);

fs/fuse/file.c

2801

ret = __fuse_direct_read(io, iter, &pos);

fs/fuse/file.c

2803

iov_iter_reexpand(iter, iov_iter_count(iter) + shortened);

fs/fuse/file.c

2820

if (iov_iter_rw(iter) == WRITE) {

fs/fuse/file.c

958

static int fuse_iomap_read_folio_range_async(const struct iomap_iter *iter,

fs/fuse/file.c

964

loff_t pos = iter->pos;

fs/fuse/fuse_dev_i.h

317

struct iov_iter *iter;

fs/fuse/fuse_dev_i.h

376

struct iov_iter *iter);

fs/fuse/fuse_i.h

1177

ssize_t fuse_direct_io(struct fuse_io_priv *io, struct iov_iter *iter,

fs/fuse/fuse_i.h

1314

ssize_t fuse_passthrough_read_iter(struct kiocb *iocb, struct iov_iter *iter);

fs/fuse/fuse_i.h

1315

ssize_t fuse_passthrough_write_iter(struct kiocb *iocb, struct iov_iter *iter);

fs/fuse/passthrough.c

28

ssize_t fuse_passthrough_read_iter(struct kiocb *iocb, struct iov_iter *iter)

fs/fuse/passthrough.c

33

size_t count = iov_iter_count(iter);

fs/fuse/passthrough.c

47

ret = backing_file_read_iter(backing_file, iter, iocb, iocb->ki_flags,

fs/fuse/passthrough.c

54

struct iov_iter *iter)

fs/fuse/passthrough.c

60

size_t count = iov_iter_count(iter);

fs/fuse/passthrough.c

74

ret = backing_file_write_iter(backing_file, iter, iocb, iocb->ki_flags,

fs/gfs2/bmap.c

964

gfs2_iomap_get_folio(struct iomap_iter *iter, loff_t pos, unsigned len)

fs/gfs2/bmap.c

966

struct inode *inode = iter->inode;

fs/gfs2/bmap.c

975

return iomap_get_folio(iter, pos, len);

fs/gfs2/bmap.c

982

folio = iomap_get_folio(iter, pos, len);

fs/gfs2/glock.c

2008

struct rhashtable_iter iter;

fs/gfs2/glock.c

2010

rhashtable_walk_enter(&gl_hash_table, &iter);

fs/gfs2/glock.c

2013

rhashtable_walk_start(&iter);

fs/gfs2/glock.c

2015

while ((gl = rhashtable_walk_next(&iter)) && !IS_ERR(gl)) {

fs/gfs2/glock.c

2020

rhashtable_walk_stop(&iter);

fs/gfs2/glock.c

2023

rhashtable_walk_exit(&iter);

fs/gfs2/quota.c

1343

struct gfs2_quota_data *iter;

fs/gfs2/quota.c

1348

list_for_each_entry(iter, &sdp->sd_quota_list, qd_list) {

fs/gfs2/quota.c

1349

if (qd_grab_sync(sdp, iter, sync_gen)) {

fs/gfs2/quota.c

1350

qda[num_qd++] = iter;

fs/gfs2/recovery.c

58

struct gfs2_revoke_replay *rr = NULL, *iter;

fs/gfs2/recovery.c

60

list_for_each_entry(iter, head, rr_list) {

fs/gfs2/recovery.c

61

if (iter->rr_blkno == blkno) {

fs/gfs2/recovery.c

62

rr = iter;

fs/gfs2/recovery.c

85

struct gfs2_revoke_replay *rr = NULL, *iter;

fs/gfs2/recovery.c

88

list_for_each_entry(iter, &jd->jd_revoke_list, rr_list) {

fs/gfs2/recovery.c

89

if (iter->rr_blkno == blkno) {

fs/gfs2/recovery.c

90

rr = iter;

fs/hfs/inode.c

126

static ssize_t hfs_direct_IO(struct kiocb *iocb, struct iov_iter *iter)

fs/hfs/inode.c

131

size_t count = iov_iter_count(iter);

fs/hfs/inode.c

134

ret = blockdev_direct_IO(iocb, inode, iter, hfs_get_block);

fs/hfs/inode.c

140

if (unlikely(iov_iter_rw(iter) == WRITE && ret < 0)) {

fs/hfsplus/inode.c

123

static ssize_t hfsplus_direct_IO(struct kiocb *iocb, struct iov_iter *iter)

fs/hfsplus/inode.c

129

size_t count = iov_iter_count(iter);

fs/hfsplus/inode.c

137

if (iov_iter_rw(iter) == WRITE && iocb->ki_pos > i_size_read(inode)) {

fs/hfsplus/inode.c

166

ret = blockdev_direct_IO(iocb, inode, iter, hfsplus_get_block);

fs/hfsplus/inode.c

172

if (unlikely(iov_iter_rw(iter) == WRITE && ret < 0)) {

fs/iomap/bio.c

108

static void iomap_read_alloc_bio(const struct iomap_iter *iter,

fs/iomap/bio.c

111

const struct iomap *iomap = &iter->iomap;

fs/iomap/bio.c

112

unsigned int nr_vecs = DIV_ROUND_UP(iomap_length(iter), PAGE_SIZE);

fs/iomap/bio.c

121

ctx->ops->submit_read(iter, ctx);

fs/iomap/bio.c

139

bio->bi_iter.bi_sector = iomap_sector(iomap, iter->pos);

fs/iomap/bio.c

141

offset_in_folio(folio, iter->pos));

fs/iomap/bio.c

143

ctx->read_ctx_file_offset = iter->pos;

fs/iomap/bio.c

146

int iomap_bio_read_folio_range(const struct iomap_iter *iter,

fs/iomap/bio.c

153

bio_end_sector(bio) != iomap_sector(&iter->iomap, iter->pos) ||

fs/iomap/bio.c

154

bio->bi_iter.bi_size > iomap_max_bio_size(&iter->iomap) - plen ||

fs/iomap/bio.c

155

!bio_add_folio(bio, folio, plen, offset_in_folio(folio, iter->pos)))

fs/iomap/bio.c

156

iomap_read_alloc_bio(iter, ctx, plen);

fs/iomap/bio.c

167

int iomap_bio_read_folio_range_sync(const struct iomap_iter *iter,

fs/iomap/bio.c

170

const struct iomap *srcmap = iomap_iter_srcmap(iter);

fs/iomap/bio.c

81

void iomap_bio_submit_read_endio(const struct iomap_iter *iter,

fs/iomap/bio.c

87

if (iter->iomap.flags & IOMAP_F_INTEGRITY)

fs/iomap/bio.c

95

static void iomap_bio_submit_read(const struct iomap_iter *iter,

fs/iomap/bio.c

98

return iomap_bio_submit_read_endio(iter, ctx, iomap_read_end_io);

fs/iomap/buffered-io.c

1001

loff_t pos = iter->pos;

fs/iomap/buffered-io.c

1013

static int iomap_write_begin_inline(const struct iomap_iter *iter,

fs/iomap/buffered-io.c

1017

if (WARN_ON_ONCE(iomap_iter_srcmap(iter)->offset != 0))

fs/iomap/buffered-io.c

1019

return iomap_read_inline_data(iter, folio);

fs/iomap/buffered-io.c

1027

static int iomap_write_begin(struct iomap_iter *iter,

fs/iomap/buffered-io.c

1031

const struct iomap *srcmap = iomap_iter_srcmap(iter);

fs/iomap/buffered-io.c

1033

u64 len = min_t(u64, SIZE_MAX, iomap_length(iter));

fs/iomap/buffered-io.c

1044

folio = __iomap_get_folio(iter, write_ops, len);

fs/iomap/buffered-io.c

1053

WARN_ON_ONCE(!(iter->iomap.flags & IOMAP_F_FOLIO_BATCH));

fs/iomap/buffered-io.c

1068

bool iomap_valid = write_ops->iomap_valid(iter->inode,

fs/iomap/buffered-io.c

1069

&iter->iomap);

fs/iomap/buffered-io.c

1071

iter->iomap.flags |= IOMAP_F_STALE;

fs/iomap/buffered-io.c

1084

if (folio_pos(folio) > iter->pos) {

fs/iomap/buffered-io.c

1085

len = min_t(u64, folio_pos(folio) - iter->pos,

fs/iomap/buffered-io.c

1086

iomap_length(iter));

fs/iomap/buffered-io.c

1087

status = iomap_iter_advance(iter, len);

fs/iomap/buffered-io.c

1088

len = iomap_length(iter);

fs/iomap/buffered-io.c

1093

pos = iomap_trim_folio_range(iter, folio, poffset, &len);

fs/iomap/buffered-io.c

1096

status = iomap_write_begin_inline(iter, folio);

fs/iomap/buffered-io.c

1100

status = __iomap_write_begin(iter, write_ops, len, folio);

fs/iomap/buffered-io.c

1110

__iomap_put_folio(iter, write_ops, 0, folio);

fs/iomap/buffered-io.c

1138

static bool iomap_write_end_inline(const struct iomap_iter *iter,

fs/iomap/buffered-io.c

1141

const struct iomap *iomap = &iter->iomap;

fs/iomap/buffered-io.c

1154

mark_inode_dirty(iter->inode);

fs/iomap/buffered-io.c

1162

static bool iomap_write_end(struct iomap_iter *iter, size_t len, size_t copied,

fs/iomap/buffered-io.c

1165

const struct iomap *srcmap = iomap_iter_srcmap(iter);

fs/iomap/buffered-io.c

1166

loff_t pos = iter->pos;

fs/iomap/buffered-io.c

1169

return iomap_write_end_inline(iter, folio, pos, copied);

fs/iomap/buffered-io.c

1179

return __iomap_write_end(iter->inode, pos, len, copied, folio);

fs/iomap/buffered-io.c

1182

static int iomap_write_iter(struct iomap_iter *iter, struct iov_iter *i,

fs/iomap/buffered-io.c

1187

struct address_space *mapping = iter->inode->i_mapping;

fs/iomap/buffered-io.c

1189

unsigned int bdp_flags = (iter->flags & IOMAP_NOWAIT) ? BDP_ASYNC : 0;

fs/iomap/buffered-io.c

1202

offset = iter->pos & (chunk - 1);

fs/iomap/buffered-io.c

1209

if (bytes > iomap_length(iter))

fs/iomap/buffered-io.c

1210

bytes = iomap_length(iter);

fs/iomap/buffered-io.c

1227

status = iomap_write_begin(iter, write_ops, &folio, &offset,

fs/iomap/buffered-io.c

1230

iomap_write_failed(iter->inode, iter->pos, bytes);

fs/iomap/buffered-io.c

1233

if (iter->iomap.flags & IOMAP_F_STALE)

fs/iomap/buffered-io.c

1236

pos = iter->pos;

fs/iomap/buffered-io.c

1242

written = iomap_write_end(iter, bytes, copied, folio) ?

fs/iomap/buffered-io.c

1252

old_size = iter->inode->i_size;

fs/iomap/buffered-io.c

1254

!(iter->iomap.flags & IOMAP_F_FSVERITY)) {

fs/iomap/buffered-io.c

1255

i_size_write(iter->inode, pos + written);

fs/iomap/buffered-io.c

1256

iter->iomap.flags |= IOMAP_F_SIZE_CHANGED;

fs/iomap/buffered-io.c

1258

__iomap_put_folio(iter, write_ops, written, folio);

fs/iomap/buffered-io.c

1260

if (old_size < pos && !(iter->iomap.flags & IOMAP_F_FSVERITY))

fs/iomap/buffered-io.c

1261

pagecache_isize_extended(iter->inode, old_size, pos);

fs/iomap/buffered-io.c

1271

iomap_write_failed(iter->inode, pos, bytes);

fs/iomap/buffered-io.c

1282

iomap_iter_advance(iter, written);

fs/iomap/buffered-io.c

1284

} while (iov_iter_count(i) && iomap_length(iter));

fs/iomap/buffered-io.c

1294

struct iomap_iter iter = {

fs/iomap/buffered-io.c

1304

iter.flags |= IOMAP_NOWAIT;

fs/iomap/buffered-io.c

1306

iter.flags |= IOMAP_DONTCACHE;

fs/iomap/buffered-io.c

1308

while ((ret = iomap_iter(&iter, ops)) > 0)

fs/iomap/buffered-io.c

1309

iter.status = iomap_write_iter(&iter, i, write_ops);

fs/iomap/buffered-io.c

1311

if (unlikely(iter.pos == iocb->ki_pos))

fs/iomap/buffered-io.c

1313

ret = iter.pos - iocb->ki_pos;

fs/iomap/buffered-io.c

1314

iocb->ki_pos = iter.pos;

fs/iomap/buffered-io.c

1567

static int iomap_unshare_iter(struct iomap_iter *iter,

fs/iomap/buffered-io.c

1570

struct iomap *iomap = &iter->iomap;

fs/iomap/buffered-io.c

1571

u64 bytes = iomap_length(iter);

fs/iomap/buffered-io.c

1574

if (!iomap_want_unshare_iter(iter))

fs/iomap/buffered-io.c

1575

return iomap_iter_advance(iter, bytes);

fs/iomap/buffered-io.c

1583

status = iomap_write_begin(iter, write_ops, &folio, &offset,

fs/iomap/buffered-io.c

1590

ret = iomap_write_end(iter, bytes, bytes, folio);

fs/iomap/buffered-io.c

1591

__iomap_put_folio(iter, write_ops, bytes, folio);

fs/iomap/buffered-io.c

1597

balance_dirty_pages_ratelimited(iter->inode->i_mapping);

fs/iomap/buffered-io.c

1599

status = iomap_iter_advance(iter, bytes);

fs/iomap/buffered-io.c

1602

} while ((bytes = iomap_length(iter)) > 0);

fs/iomap/buffered-io.c

1612

struct iomap_iter iter = {

fs/iomap/buffered-io.c

1623

iter.len = min(len, size - pos);

fs/iomap/buffered-io.c

1624

while ((ret = iomap_iter(&iter, ops)) > 0)

fs/iomap/buffered-io.c

1625

iter.status = iomap_unshare_iter(&iter, write_ops);

fs/iomap/buffered-io.c

1644

static int iomap_zero_iter(struct iomap_iter *iter, bool *did_zero,

fs/iomap/buffered-io.c

1647

u64 bytes = iomap_length(iter);

fs/iomap/buffered-io.c

1656

balance_dirty_pages_ratelimited(iter->inode->i_mapping);

fs/iomap/buffered-io.c

1659

status = iomap_write_begin(iter, write_ops, &folio, &offset,

fs/iomap/buffered-io.c

1663

if (iter->iomap.flags & IOMAP_F_STALE)

fs/iomap/buffered-io.c

1668

status = iomap_iter_advance_full(iter);

fs/iomap/buffered-io.c

1675

WARN_ON_ONCE(folio_pos(folio) > iter->inode->i_size);

fs/iomap/buffered-io.c

1677

trace_iomap_zero_iter(iter->inode, folio_pos(folio) + offset,

fs/iomap/buffered-io.c

1684

ret = iomap_write_end(iter, bytes, bytes, folio);

fs/iomap/buffered-io.c

1685

__iomap_put_folio(iter, write_ops, bytes, folio);

fs/iomap/buffered-io.c

1689

status = iomap_iter_advance(iter, bytes);

fs/iomap/buffered-io.c

1692

} while ((bytes = iomap_length(iter)) > 0);

fs/iomap/buffered-io.c

1713

struct iomap_iter *iter,

fs/iomap/buffered-io.c

1718

struct address_space *mapping = iter->inode->i_mapping;

fs/iomap/buffered-io.c

1723

if (!iter->fbatch) {

fs/iomap/buffered-io.c

1728

count = filemap_get_folios_dirty(mapping, &pstart, pend, iter->fbatch);

fs/iomap/buffered-io.c

1741

struct iomap_iter iter = {

fs/iomap/buffered-io.c

1760

range_dirty = filemap_range_needs_writeback(mapping, iter.pos,

fs/iomap/buffered-io.c

1761

iter.pos + iter.len - 1);

fs/iomap/buffered-io.c

1762

while ((ret = iomap_iter(&iter, ops)) > 0) {

fs/iomap/buffered-io.c

1763

const struct iomap *srcmap = iomap_iter_srcmap(&iter);

fs/iomap/buffered-io.c

1765

if (!(iter.iomap.flags & IOMAP_F_FOLIO_BATCH) &&

fs/iomap/buffered-io.c

1772

status = iomap_zero_iter_flush_and_stale(&iter);

fs/iomap/buffered-io.c

1774

status = iomap_iter_advance_full(&iter);

fs/iomap/buffered-io.c

1776

iter.status = status;

fs/iomap/buffered-io.c

1780

iter.status = iomap_zero_iter(&iter, did_zero, write_ops);

fs/iomap/buffered-io.c

1802

static int iomap_folio_mkwrite_iter(struct iomap_iter *iter,

fs/iomap/buffered-io.c

1805

loff_t length = iomap_length(iter);

fs/iomap/buffered-io.c

1808

if (iter->iomap.flags & IOMAP_F_BUFFER_HEAD) {

fs/iomap/buffered-io.c

1809

ret = __block_write_begin_int(folio, iter->pos, length, NULL,

fs/iomap/buffered-io.c

1810

&iter->iomap);

fs/iomap/buffered-io.c

1819

return iomap_iter_advance(iter, length);

fs/iomap/buffered-io.c

1825

struct iomap_iter iter = {

fs/iomap/buffered-io.c

1834

ret = folio_mkwrite_check_truncate(folio, iter.inode);

fs/iomap/buffered-io.c

1837

iter.pos = folio_pos(folio);

fs/iomap/buffered-io.c

1838

iter.len = ret;

fs/iomap/buffered-io.c

1839

while ((ret = iomap_iter(&iter, ops)) > 0)

fs/iomap/buffered-io.c

1840

iter.status = iomap_folio_mkwrite_iter(&iter, folio);

fs/iomap/buffered-io.c

376

static inline bool iomap_block_needs_zeroing(const struct iomap_iter *iter,

fs/iomap/buffered-io.c

379

const struct iomap *srcmap = iomap_iter_srcmap(iter);

fs/iomap/buffered-io.c

400

return pos >= i_size_read(iter->inode);

fs/iomap/buffered-io.c

412

static int iomap_read_inline_data(const struct iomap_iter *iter,

fs/iomap/buffered-io.c

415

const struct iomap *iomap = iomap_iter_srcmap(iter);

fs/iomap/buffered-io.c

416

size_t size = i_size_read(iter->inode) - iomap->offset;

fs/iomap/buffered-io.c

426

fserror_report_io(iter->inode, FSERR_BUFFERED_READ,

fs/iomap/buffered-io.c

431

ifs_alloc(iter->inode, folio, iter->flags);

fs/iomap/buffered-io.c

551

static int iomap_read_folio_iter(struct iomap_iter *iter,

fs/iomap/buffered-io.c

554

const struct iomap *iomap = &iter->iomap;

fs/iomap/buffered-io.c

555

loff_t pos = iter->pos;

fs/iomap/buffered-io.c

556

loff_t length = iomap_length(iter);

fs/iomap/buffered-io.c

565

ret = iomap_read_inline_data(iter, folio);

fs/iomap/buffered-io.c

568

return iomap_iter_advance(iter, length);

fs/iomap/buffered-io.c

571

ifs = ifs_alloc(iter->inode, folio, iter->flags);

fs/iomap/buffered-io.c

575

iomap_adjust_read_range(iter->inode, folio, &pos, length, &poff,

fs/iomap/buffered-io.c

578

pos_diff = pos - iter->pos;

fs/iomap/buffered-io.c

582

ret = iomap_iter_advance(iter, pos_diff);

fs/iomap/buffered-io.c

604

} else if (iomap_block_needs_zeroing(iter, pos)) {

fs/iomap/buffered-io.c

614

ret = ctx->ops->read_folio_range(iter, ctx, plen);

fs/iomap/buffered-io.c

616

fserror_report_io(iter->inode,

fs/iomap/buffered-io.c

636

ret = iomap_iter_advance(iter, plen);

fs/iomap/buffered-io.c

640

pos = iter->pos;

fs/iomap/buffered-io.c

649

struct iomap_iter iter = {

fs/iomap/buffered-io.c

658

trace_iomap_readpage(iter.inode, 1);

fs/iomap/buffered-io.c

664

ctx->vi = fsverity_get_info(iter.inode);

fs/iomap/buffered-io.c

665

if (ctx->vi && iter.pos < i_size_read(iter.inode))

fs/iomap/buffered-io.c

669

while ((ret = iomap_iter(&iter, ops)) > 0) {

fs/iomap/buffered-io.c

670

iter.status = iomap_read_folio_iter(&iter, ctx,

fs/iomap/buffered-io.c

673

ctx->ops->submit_read(&iter, ctx);

fs/iomap/buffered-io.c

681

static int iomap_readahead_iter(struct iomap_iter *iter,

fs/iomap/buffered-io.c

686

while (iomap_length(iter)) {

fs/iomap/buffered-io.c

688

offset_in_folio(ctx->cur_folio, iter->pos) == 0) {

fs/iomap/buffered-io.c

698

ret = iomap_read_folio_iter(iter, ctx, cur_bytes_submitted);

fs/iomap/buffered-io.c

726

struct iomap_iter iter = {

fs/iomap/buffered-io.c

740

ctx->vi = fsverity_get_info(iter.inode);

fs/iomap/buffered-io.c

741

if (ctx->vi && iter.pos < i_size_read(iter.inode))

fs/iomap/buffered-io.c

745

while (iomap_iter(&iter, ops) > 0) {

fs/iomap/buffered-io.c

746

iter.status = iomap_readahead_iter(&iter, ctx,

fs/iomap/buffered-io.c

749

ctx->ops->submit_read(&iter, ctx);

fs/iomap/buffered-io.c

793

struct folio *iomap_get_folio(struct iomap_iter *iter, loff_t pos, size_t len)

fs/iomap/buffered-io.c

797

if (iter->flags & IOMAP_NOWAIT)

fs/iomap/buffered-io.c

799

if (iter->flags & IOMAP_DONTCACHE)

fs/iomap/buffered-io.c

803

return __filemap_get_folio(iter->inode->i_mapping, pos >> PAGE_SHIFT,

fs/iomap/buffered-io.c

804

fgp, mapping_gfp_mask(iter->inode->i_mapping));

fs/iomap/buffered-io.c

869

static int __iomap_write_begin(const struct iomap_iter *iter,

fs/iomap/buffered-io.c

874

loff_t pos = iter->pos;

fs/iomap/buffered-io.c

875

loff_t block_size = i_blocksize(iter->inode);

fs/iomap/buffered-io.c

878

unsigned int nr_blocks = i_blocks_per_folio(iter->inode, folio);

fs/iomap/buffered-io.c

889

if (!(iter->flags & IOMAP_UNSHARE) && pos <= folio_pos(folio) &&

fs/iomap/buffered-io.c

893

ifs = ifs_alloc(iter->inode, folio, iter->flags);

fs/iomap/buffered-io.c

894

if ((iter->flags & IOMAP_NOWAIT) && !ifs && nr_blocks > 1)

fs/iomap/buffered-io.c

901

iomap_adjust_read_range(iter->inode, folio, &block_start,

fs/iomap/buffered-io.c

910

if (!(iter->flags & IOMAP_UNSHARE) && from <= poff &&

fs/iomap/buffered-io.c

914

if (iomap_block_needs_zeroing(iter, block_start)) {

fs/iomap/buffered-io.c

915

if (WARN_ON_ONCE(iter->flags & IOMAP_UNSHARE))

fs/iomap/buffered-io.c

919

const struct iomap *iomap = iomap_iter_srcmap(iter);

fs/iomap/buffered-io.c

922

if (iter->flags & IOMAP_NOWAIT)

fs/iomap/buffered-io.c

926

status = write_ops->read_folio_range(iter,

fs/iomap/buffered-io.c

929

status = iomap_bio_read_folio_range_sync(iter,

fs/iomap/buffered-io.c

932

fserror_report_io(iter->inode,

fs/iomap/buffered-io.c

947

static struct folio *__iomap_get_folio(struct iomap_iter *iter,

fs/iomap/buffered-io.c

950

loff_t pos = iter->pos;

fs/iomap/buffered-io.c

952

if (!mapping_large_folio_support(iter->inode->i_mapping))

fs/iomap/buffered-io.c

955

if (iter->iomap.flags & IOMAP_F_FOLIO_BATCH) {

fs/iomap/buffered-io.c

956

struct folio *folio = folio_batch_next(iter->fbatch);

fs/iomap/buffered-io.c

967

if (unlikely(folio->mapping != iter->inode->i_mapping)) {

fs/iomap/buffered-io.c

968

iter->iomap.flags |= IOMAP_F_STALE;

fs/iomap/buffered-io.c

979

return write_ops->get_folio(iter, pos, len);

fs/iomap/buffered-io.c

980

return iomap_get_folio(iter, pos, len);

fs/iomap/buffered-io.c

983

static void __iomap_put_folio(struct iomap_iter *iter,

fs/iomap/buffered-io.c

987

loff_t pos = iter->pos;

fs/iomap/buffered-io.c

990

write_ops->put_folio(iter->inode, pos, ret, folio);

fs/iomap/buffered-io.c

998

static loff_t iomap_trim_folio_range(struct iomap_iter *iter,

fs/iomap/direct-io.c

298

static int iomap_dio_zero(const struct iomap_iter *iter, struct iomap_dio *dio,

fs/iomap/direct-io.c

316

bio = iomap_dio_alloc_bio(iter, dio, nr_vecs,

fs/iomap/direct-io.c

319

bio->bi_iter.bi_sector = iomap_sector(&iter->iomap, pos);

fs/iomap/direct-io.c

329

iomap_dio_submit_bio(iter, dio, bio, pos);

fs/iomap/direct-io.c

334

static ssize_t iomap_dio_bio_iter_one(struct iomap_iter *iter,

fs/iomap/direct-io.c

343

nr_vecs = bio_iov_bounce_nr_vecs(dio->submit.iter, op);

fs/iomap/direct-io.c

345

nr_vecs = bio_iov_vecs_to_alloc(dio->submit.iter, BIO_MAX_VECS);

fs/iomap/direct-io.c

347

bio = iomap_dio_alloc_bio(iter, dio, nr_vecs, op);

fs/iomap/direct-io.c

348

fscrypt_set_bio_crypt_ctx(bio, iter->inode, pos, GFP_KERNEL);

fs/iomap/direct-io.c

349

bio->bi_iter.bi_sector = iomap_sector(&iter->iomap, pos);

fs/iomap/direct-io.c

350

bio->bi_write_hint = iter->inode->i_write_hint;

fs/iomap/direct-io.c

357

ret = bio_iov_iter_bounce(bio, dio->submit.iter,

fs/iomap/direct-io.c

358

iomap_max_bio_size(&iter->iomap), alignment);

fs/iomap/direct-io.c

360

ret = bio_iov_iter_get_pages(bio, dio->submit.iter,

fs/iomap/direct-io.c

370

if ((op & REQ_ATOMIC) && WARN_ON_ONCE(ret != iomap_length(iter))) {

fs/iomap/direct-io.c

375

if (iter->iomap.flags & IOMAP_F_INTEGRITY) {

fs/iomap/direct-io.c

391

if (iov_iter_count(dio->submit.iter))

fs/iomap/direct-io.c

393

iomap_dio_submit_bio(iter, dio, bio, pos);

fs/iomap/direct-io.c

406

static int iomap_dio_bio_iter(struct iomap_iter *iter, struct iomap_dio *dio)

fs/iomap/direct-io.c

408

const struct iomap *iomap = &iter->iomap;

fs/iomap/direct-io.c

409

struct inode *inode = iter->inode;

fs/iomap/direct-io.c

411

const loff_t length = iomap_length(iter);

fs/iomap/direct-io.c

412

loff_t pos = iter->pos;

fs/iomap/direct-io.c

43

struct iov_iter *iter;

fs/iomap/direct-io.c

458

if (length != iter->len)

fs/iomap/direct-io.c

520

orig_count = iov_iter_count(dio->submit.iter);

fs/iomap/direct-io.c

521

iov_iter_truncate(dio->submit.iter, length);

fs/iomap/direct-io.c

523

if (!iov_iter_count(dio->submit.iter))

fs/iomap/direct-io.c

538

ret = iomap_dio_zero(iter, dio, pos - pad, pad);

fs/iomap/direct-io.c

54

static struct bio *iomap_dio_alloc_bio(const struct iomap_iter *iter,

fs/iomap/direct-io.c

551

ret = iomap_dio_bio_iter_one(iter, dio, pos, alignment, bio_opf);

fs/iomap/direct-io.c

565

} while (iov_iter_count(dio->submit.iter));

fs/iomap/direct-io.c

578

ret = iomap_dio_zero(iter, dio, pos,

fs/iomap/direct-io.c

58

return bio_alloc_bioset(iter->iomap.bdev, nr_vecs, opf,

fs/iomap/direct-io.c

583

iov_iter_reexpand(dio->submit.iter, orig_count - copied);

fs/iomap/direct-io.c

585

return iomap_iter_advance(iter, copied);

fs/iomap/direct-io.c

589

static int iomap_dio_hole_iter(struct iomap_iter *iter, struct iomap_dio *dio)

fs/iomap/direct-io.c

591

loff_t length = iov_iter_zero(iomap_length(iter), dio->submit.iter);

fs/iomap/direct-io.c

596

return iomap_iter_advance(iter, length);

fs/iomap/direct-io.c

60

return bio_alloc(iter->iomap.bdev, nr_vecs, opf, GFP_KERNEL);

fs/iomap/direct-io.c

602

struct iov_iter *iter = dio->submit.iter;

fs/iomap/direct-io.c

616

copied = copy_from_iter(inline_data, length, iter);

fs/iomap/direct-io.c

623

copied = copy_to_iter(inline_data, length, iter);

fs/iomap/direct-io.c

63

static void iomap_dio_submit_bio(const struct iomap_iter *iter,

fs/iomap/direct-io.c

631

static int iomap_dio_iter(struct iomap_iter *iter, struct iomap_dio *dio)

fs/iomap/direct-io.c

633

switch (iter->iomap.type) {

fs/iomap/direct-io.c

637

return iomap_dio_hole_iter(iter, dio);

fs/iomap/direct-io.c

640

return iomap_dio_hole_iter(iter, dio);

fs/iomap/direct-io.c

641

return iomap_dio_bio_iter(iter, dio);

fs/iomap/direct-io.c

643

return iomap_dio_bio_iter(iter, dio);

fs/iomap/direct-io.c

645

return iomap_dio_inline_iter(iter, dio);

fs/iomap/direct-io.c

683

__iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter,

fs/iomap/direct-io.c

691

.len = iov_iter_count(iter),

fs/iomap/direct-io.c

701

trace_iomap_dio_rw_begin(iocb, iter, dio_flags, done_before);

fs/iomap/direct-io.c

719

dio->submit.iter = iter;

fs/iomap/direct-io.c

725

if (iov_iter_rw(iter) == READ) {

fs/iomap/direct-io.c

729

if (user_backed_iter(iter))

fs/iomap/direct-io.c

77

dio->dops->submit_io(iter, bio, pos);

fs/iomap/direct-io.c

79

WARN_ON_ONCE(iter->iomap.flags & IOMAP_F_ANON_WRITE);

fs/iomap/direct-io.c

824

if (iov_iter_rw(iter) == READ && iomi.pos >= dio->i_size)

fs/iomap/direct-io.c

825

iov_iter_revert(iter, iomi.pos - dio->i_size);

fs/iomap/direct-io.c

897

iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter,

fs/iomap/direct-io.c

903

dio = __iomap_dio_rw(iocb, iter, ops, dops, dio_flags, private,

fs/iomap/fiemap.c

110

while ((ret = iomap_iter(&iter, ops)) > 0) {

fs/iomap/fiemap.c

111

if (iter.iomap.type == IOMAP_MAPPED)

fs/iomap/fiemap.c

112

bno = iomap_sector(&iter.iomap, iter.pos) >> blkshift;

fs/iomap/fiemap.c

39

static int iomap_fiemap_iter(struct iomap_iter *iter,

fs/iomap/fiemap.c

44

if (iter->iomap.type == IOMAP_HOLE)

fs/iomap/fiemap.c

48

*prev = iter->iomap;

fs/iomap/fiemap.c

55

return iomap_iter_advance_full(iter);

fs/iomap/fiemap.c

61

struct iomap_iter iter = {

fs/iomap/fiemap.c

72

ret = fiemap_prep(inode, fi, start, &iter.len, 0);

fs/iomap/fiemap.c

76

while ((ret = iomap_iter(&iter, ops)) > 0)

fs/iomap/fiemap.c

77

iter.status = iomap_fiemap_iter(&iter, fi, &prev);

fs/iomap/fiemap.c

97

struct iomap_iter iter = {

fs/iomap/internal.h

24

int iomap_bio_read_folio_range_sync(const struct iomap_iter *iter,

fs/iomap/internal.h

27

static inline int iomap_bio_read_folio_range_sync(const struct iomap_iter *iter,

fs/iomap/iter.c

101

iomap_iter_clean_fbatch(iter);

fs/iomap/iter.c

102

iter->status = 0;

fs/iomap/iter.c

106

memset(&iter->iomap, 0, sizeof(iter->iomap));

fs/iomap/iter.c

107

memset(&iter->srcmap, 0, sizeof(iter->srcmap));

fs/iomap/iter.c

11

if (iter->iomap.flags & IOMAP_F_FOLIO_BATCH) {

fs/iomap/iter.c

110

ret = ops->iomap_begin(iter->inode, iter->pos, iter->len, iter->flags,

fs/iomap/iter.c

111

&iter->iomap, &iter->srcmap);

fs/iomap/iter.c

114

iomap_iter_done(iter);

fs/iomap/iter.c

12

folio_batch_release(iter->fbatch);

fs/iomap/iter.c

13

folio_batch_reinit(iter->fbatch);

fs/iomap/iter.c

14

iter->iomap.flags &= ~IOMAP_F_FOLIO_BATCH;

fs/iomap/iter.c

19

int iomap_iter_advance(struct iomap_iter *iter, u64 count)

fs/iomap/iter.c

21

if (WARN_ON_ONCE(count > iomap_length(iter)))

fs/iomap/iter.c

23

iter->pos += count;

fs/iomap/iter.c

24

iter->len -= count;

fs/iomap/iter.c

28

static inline void iomap_iter_done(struct iomap_iter *iter)

fs/iomap/iter.c

30

WARN_ON_ONCE(iter->iomap.offset > iter->pos);

fs/iomap/iter.c

31

WARN_ON_ONCE(iter->iomap.length == 0);

fs/iomap/iter.c

32

WARN_ON_ONCE(iter->iomap.offset + iter->iomap.length <= iter->pos);

fs/iomap/iter.c

33

WARN_ON_ONCE(iter->iomap.flags & IOMAP_F_STALE);

fs/iomap/iter.c

35

iter->iter_start_pos = iter->pos;

fs/iomap/iter.c

37

trace_iomap_iter_dstmap(iter->inode, &iter->iomap);

fs/iomap/iter.c

38

if (iter->srcmap.type != IOMAP_HOLE)

fs/iomap/iter.c

39

trace_iomap_iter_srcmap(iter->inode, &iter->srcmap);

fs/iomap/iter.c

57

int iomap_iter(struct iomap_iter *iter, const struct iomap_ops *ops)

fs/iomap/iter.c

59

bool stale = iter->iomap.flags & IOMAP_F_STALE;

fs/iomap/iter.c

64

trace_iomap_iter(iter, ops, _RET_IP_);

fs/iomap/iter.c

66

if (!iter->iomap.length)

fs/iomap/iter.c

73

advanced = iter->pos - iter->iter_start_pos;

fs/iomap/iter.c

74

olen = iter->len + advanced;

fs/iomap/iter.c

77

ret = ops->iomap_end(iter->inode, iter->iter_start_pos,

fs/iomap/iter.c

78

iomap_length_trim(iter, iter->iter_start_pos,

fs/iomap/iter.c

80

advanced, iter->flags, &iter->iomap);

fs/iomap/iter.c

86

if (WARN_ON_ONCE(iter->status > 0))

fs/iomap/iter.c

87

iter->status = -EIO;

fs/iomap/iter.c

9

static inline void iomap_iter_clean_fbatch(struct iomap_iter *iter)

fs/iomap/iter.c

95

if (iter->status < 0)

fs/iomap/iter.c

96

ret = iter->status;

fs/iomap/iter.c

97

else if (iter->len == 0 || (!advanced && !stale))

fs/iomap/seek.c

12

loff_t length = iomap_length(iter);

fs/iomap/seek.c

14

switch (iter->iomap.type) {

fs/iomap/seek.c

16

*hole_pos = mapping_seek_hole_data(iter->inode->i_mapping,

fs/iomap/seek.c

17

iter->pos, iter->pos + length, SEEK_HOLE);

fs/iomap/seek.c

18

if (*hole_pos == iter->pos + length)

fs/iomap/seek.c

19

return iomap_iter_advance(iter, length);

fs/iomap/seek.c

22

*hole_pos = iter->pos;

fs/iomap/seek.c

25

return iomap_iter_advance(iter, length);

fs/iomap/seek.c

33

struct iomap_iter iter = {

fs/iomap/seek.c

44

iter.len = size - pos;

fs/iomap/seek.c

45

while ((ret = iomap_iter(&iter, ops)) > 0)

fs/iomap/seek.c

46

iter.status = iomap_seek_hole_iter(&iter, &pos);

fs/iomap/seek.c

49

if (iter.len) /* found hole before EOF */

fs/iomap/seek.c

55

static int iomap_seek_data_iter(struct iomap_iter *iter,

fs/iomap/seek.c

58

loff_t length = iomap_length(iter);

fs/iomap/seek.c

60

switch (iter->iomap.type) {

fs/iomap/seek.c

62

return iomap_iter_advance(iter, length);

fs/iomap/seek.c

64

*hole_pos = mapping_seek_hole_data(iter->inode->i_mapping,

fs/iomap/seek.c

65

iter->pos, iter->pos + length, SEEK_DATA);

fs/iomap/seek.c

67

return iomap_iter_advance(iter, length);

fs/iomap/seek.c

70

*hole_pos = iter->pos;

fs/iomap/seek.c

79

struct iomap_iter iter = {

fs/iomap/seek.c

9

static int iomap_seek_hole_iter(struct iomap_iter *iter,

fs/iomap/seek.c

90

iter.len = size - pos;

fs/iomap/seek.c

91

while ((ret = iomap_iter(&iter, ops)) > 0)

fs/iomap/seek.c

92

iter.status = iomap_seek_data_iter(&iter, &pos);

fs/iomap/seek.c

95

if (iter.len) /* found data before EOF */

fs/iomap/swapfile.c

133

return iomap_iter_advance_full(iter);

fs/iomap/swapfile.c

145

struct iomap_iter iter = {

fs/iomap/swapfile.c

166

while ((ret = iomap_iter(&iter, ops)) > 0)

fs/iomap/swapfile.c

167

iter.status = iomap_swapfile_iter(&iter, &iter.iomap, &isi);

fs/iomap/swapfile.c

94

static int iomap_swapfile_iter(struct iomap_iter *iter,

fs/iomap/trace.h

221

TP_PROTO(struct iomap_iter *iter, const void *ops,

fs/iomap/trace.h

223

TP_ARGS(iter, ops, caller),

fs/iomap/trace.h

235

__entry->dev = iter->inode->i_sb->s_dev;

fs/iomap/trace.h

236

__entry->ino = iter->inode->i_ino;

fs/iomap/trace.h

237

__entry->pos = iter->pos;

fs/iomap/trace.h

238

__entry->length = iomap_length(iter);

fs/iomap/trace.h

239

__entry->status = iter->status;

fs/iomap/trace.h

240

__entry->flags = iter->flags;

fs/iomap/trace.h

257

TP_PROTO(struct kiocb *iocb, struct iov_iter *iter,

fs/iomap/trace.h

259

TP_ARGS(iocb, iter, dio_flags, done_before),

fs/iomap/trace.h

276

__entry->count = iov_iter_count(iter);

fs/jfs/inode.c

331

static ssize_t jfs_direct_IO(struct kiocb *iocb, struct iov_iter *iter)

fs/jfs/inode.c

336

size_t count = iov_iter_count(iter);

fs/jfs/inode.c

339

ret = blockdev_direct_IO(iocb, inode, iter, jfs_get_block);

fs/jfs/inode.c

345

if (unlikely(iov_iter_rw(iter) == WRITE && ret < 0)) {

fs/kernfs/file.c

232

static ssize_t kernfs_file_read_iter(struct kiocb *iocb, struct iov_iter *iter)

fs/kernfs/file.c

235

ssize_t len = min_t(size_t, iov_iter_count(iter), PAGE_SIZE);

fs/kernfs/file.c

272

if (copy_to_iter(buf, len, iter) != len) {

fs/kernfs/file.c

287

static ssize_t kernfs_fop_read_iter(struct kiocb *iocb, struct iov_iter *iter)

fs/kernfs/file.c

290

return seq_read_iter(iocb, iter);

fs/kernfs/file.c

291

return kernfs_file_read_iter(iocb, iter);

fs/kernfs/file.c

304

static ssize_t kernfs_fop_write_iter(struct kiocb *iocb, struct iov_iter *iter)

fs/kernfs/file.c

307

ssize_t len = iov_iter_count(iter);

fs/kernfs/file.c

326

if (copy_from_iter(buf, len, iter) != len) {

fs/libfs.c

1641

ssize_t noop_direct_IO(struct kiocb *iocb, struct iov_iter *iter)

fs/libfs.c

2073

ssize_t direct_write_fallback(struct kiocb *iocb, struct iov_iter *iter,

fs/locks.c

3018

struct locks_iterator *iter = f->private;

fs/locks.c

3035

lock_get_status(f, cur, iter->li_pos, "-> ", level);

fs/locks.c

3037

lock_get_status(f, cur, iter->li_pos, "", level);

fs/locks.c

3101

struct locks_iterator *iter = f->private;

fs/locks.c

3103

iter->li_pos = *pos + 1;

fs/locks.c

3106

return seq_hlist_start_percpu(&file_lock_list.hlist, &iter->li_cpu, *pos);

fs/locks.c

3111

struct locks_iterator *iter = f->private;

fs/locks.c

3113

++iter->li_pos;

fs/locks.c

3114

return seq_hlist_next_percpu(v, &file_lock_list.hlist, &iter->li_cpu, pos);

fs/netfs/buffered_read.c

114

size_t limit = netfs_limit_iter(&rreq->buffer.iter, 0, rsize,

fs/netfs/buffered_read.c

123

subreq->io_iter = rreq->buffer.iter;

fs/netfs/buffered_read.c

455

iov_iter_bvec(&rreq->buffer.iter, ITER_DEST, bvec, i, rreq->len);

fs/netfs/buffered_read.c

788

ssize_t netfs_buffered_read_iter(struct kiocb *iocb, struct iov_iter *iter)

fs/netfs/buffered_read.c

800

ret = filemap_read(iocb, iter, 0);

fs/netfs/buffered_read.c

828

ssize_t netfs_file_read_iter(struct kiocb *iocb, struct iov_iter *iter)

fs/netfs/buffered_read.c

834

return netfs_unbuffered_read_iter(iocb, iter);

fs/netfs/buffered_read.c

836

return netfs_buffered_read_iter(iocb, iter);

fs/netfs/buffered_write.c

113

ret = filemap_write_and_wait_range(mapping, pos, pos + iter->count);

fs/netfs/buffered_write.c

119

wreq = netfs_begin_writethrough(iocb, iter->count);

fs/netfs/buffered_write.c

145

part = min(max_chunk - offset, iov_iter_count(iter));

fs/netfs/buffered_write.c

159

if (unlikely(fault_in_iov_iter_readable(iter, part) == part))

fs/netfs/buffered_write.c

217

copied = copy_folio_from_iter_atomic(folio, offset, part, iter);

fs/netfs/buffered_write.c

230

copied = copy_folio_from_iter_atomic(folio, offset, part, iter);

fs/netfs/buffered_write.c

243

copied = copy_folio_from_iter_atomic(folio, offset, part, iter);

fs/netfs/buffered_write.c

255

iov_iter_revert(iter, copied);

fs/netfs/buffered_write.c

292

copied = copy_folio_from_iter_atomic(folio, offset, part, iter);

fs/netfs/buffered_write.c

304

copied = copy_folio_from_iter_atomic(folio, offset, part, iter);

fs/netfs/buffered_write.c

314

iov_iter_revert(iter, copied);

fs/netfs/buffered_write.c

332

copied = copy_folio_from_iter_atomic(folio, offset, part, iter);

fs/netfs/buffered_write.c

411

} while (iov_iter_count(iter));

fs/netfs/buffered_write.c

87

ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter,

fs/netfs/buffered_write.c

99

.range_end = iocb->ki_pos + iter->count,

fs/netfs/direct_read.c

153

ssize_t netfs_unbuffered_read_iter_locked(struct kiocb *iocb, struct iov_iter *iter)

fs/netfs/direct_read.c

157

size_t orig_count = iov_iter_count(iter);

fs/netfs/direct_read.c

189

if (user_backed_iter(iter)) {

fs/netfs/direct_read.c

190

ret = netfs_extract_user_iter(iter, rreq->len, &rreq->buffer.iter, 0);

fs/netfs/direct_read.c

193

rreq->direct_bv = (struct bio_vec *)rreq->buffer.iter.bvec;

fs/netfs/direct_read.c

195

rreq->direct_bv_unpin = iov_iter_extract_will_pin(iter);

fs/netfs/direct_read.c

196

rreq->len = iov_iter_count(&rreq->buffer.iter);

fs/netfs/direct_read.c

198

rreq->buffer.iter = *iter;

fs/netfs/direct_read.c

201

iov_iter_advance(iter, orig_count);

fs/netfs/direct_read.c

240

ssize_t netfs_unbuffered_read_iter(struct kiocb *iocb, struct iov_iter *iter)

fs/netfs/direct_read.c

245

if (!iter->count)

fs/netfs/direct_read.c

250

ret = netfs_unbuffered_read_iter_locked(iocb, iter);

fs/netfs/direct_read.c

28

size_t limit = netfs_limit_iter(&rreq->buffer.iter, 0, rsize,

fs/netfs/direct_read.c

39

subreq->io_iter = rreq->buffer.iter;

fs/netfs/direct_read.c

41

iov_iter_advance(&rreq->buffer.iter, subreq->len);

fs/netfs/direct_write.c

170

iov_iter_advance(&wreq->buffer.iter, subreq->transferred);

fs/netfs/direct_write.c

182

subreq->io_iter = wreq->buffer.iter;

fs/netfs/direct_write.c

215

ssize_t netfs_unbuffered_write_iter_locked(struct kiocb *iocb, struct iov_iter *iter,

fs/netfs/direct_write.c

220

unsigned long long end = start + iov_iter_count(iter);

fs/netfs/direct_write.c

222

size_t len = iov_iter_count(iter);

fs/netfs/direct_write.c

255

if (user_backed_iter(iter)) {

fs/netfs/direct_write.c

256

n = netfs_extract_user_iter(iter, len, &wreq->buffer.iter, 0);

fs/netfs/direct_write.c

261

wreq->direct_bv = (struct bio_vec *)wreq->buffer.iter.bvec;

fs/netfs/direct_write.c

263

wreq->direct_bv_unpin = iov_iter_extract_will_pin(iter);

fs/netfs/direct_write.c

270

wreq->buffer.iter = *iter;

fs/netfs/direct_write.c

273

wreq->len = iov_iter_count(&wreq->buffer.iter);

fs/netfs/direct_write.c

76

iov_iter_advance(&wreq->buffer.iter, subreq->transferred);

fs/netfs/fscache_io.c

218

struct iov_iter iter;

fs/netfs/fscache_io.c

251

iov_iter_xarray(&iter, ITER_SOURCE, &mapping->i_pages, start, len);

fs/netfs/fscache_io.c

252

fscache_write(cres, start, &iter, fscache_wreq_done, wreq);

fs/netfs/iterator.c

124

static size_t netfs_limit_bvec(const struct iov_iter *iter, size_t start_offset,

fs/netfs/iterator.c

127

const struct bio_vec *bvecs = iter->bvec;

fs/netfs/iterator.c

128

unsigned int nbv = iter->nr_segs, ix = 0, nsegs = 0;

fs/netfs/iterator.c

129

size_t len, span = 0, n = iter->count;

fs/netfs/iterator.c

130

size_t skip = iter->iov_offset + start_offset;

fs/netfs/iterator.c

132

if (WARN_ON(!iov_iter_is_bvec(iter)) ||

fs/netfs/iterator.c

165

static size_t netfs_limit_kvec(const struct iov_iter *iter, size_t start_offset,

fs/netfs/iterator.c

168

const struct kvec *kvecs = iter->kvec;

fs/netfs/iterator.c

169

unsigned int nkv = iter->nr_segs, ix = 0, nsegs = 0;

fs/netfs/iterator.c

170

size_t len, span = 0, n = iter->count;

fs/netfs/iterator.c

171

size_t skip = iter->iov_offset + start_offset;

fs/netfs/iterator.c

173

if (WARN_ON(!iov_iter_is_kvec(iter)) ||

fs/netfs/iterator.c

207

static size_t netfs_limit_xarray(const struct iov_iter *iter, size_t start_offset,

fs/netfs/iterator.c

212

loff_t pos = iter->xarray_start + iter->iov_offset;

fs/netfs/iterator.c

214

size_t span = 0, n = iter->count;

fs/netfs/iterator.c

216

XA_STATE(xas, iter->xarray, index);

fs/netfs/iterator.c

218

if (WARN_ON(!iov_iter_is_xarray(iter)) ||

fs/netfs/iterator.c

252

static size_t netfs_limit_folioq(const struct iov_iter *iter, size_t start_offset,

fs/netfs/iterator.c

255

const struct folio_queue *folioq = iter->folioq;

fs/netfs/iterator.c

257

unsigned int slot = iter->folioq_slot;

fs/netfs/iterator.c

258

size_t span = 0, n = iter->count;

fs/netfs/iterator.c

260

if (WARN_ON(!iov_iter_is_folioq(iter)) ||

fs/netfs/iterator.c

271

start_offset += iter->iov_offset;

fs/netfs/iterator.c

295

size_t netfs_limit_iter(const struct iov_iter *iter, size_t start_offset,

fs/netfs/iterator.c

298

if (iov_iter_is_folioq(iter))

fs/netfs/iterator.c

299

return netfs_limit_folioq(iter, start_offset, max_size, max_segs);

fs/netfs/iterator.c

300

if (iov_iter_is_bvec(iter))

fs/netfs/iterator.c

301

return netfs_limit_bvec(iter, start_offset, max_size, max_segs);

fs/netfs/iterator.c

302

if (iov_iter_is_xarray(iter))

fs/netfs/iterator.c

303

return netfs_limit_xarray(iter, start_offset, max_size, max_segs);

fs/netfs/iterator.c

304

if (iov_iter_is_kvec(iter))

fs/netfs/iterator.c

305

return netfs_limit_kvec(iter, start_offset, max_size, max_segs);

fs/netfs/read_pgpriv2.c

73

creq->buffer.iter.iov_offset = cache->submit_off;

fs/netfs/read_pgpriv2.c

86

creq->buffer.iter.iov_offset = 0;

fs/netfs/read_single.c

102

subreq->io_iter = rreq->buffer.iter;

fs/netfs/read_single.c

162

ssize_t netfs_read_single(struct inode *inode, struct file *file, struct iov_iter *iter)

fs/netfs/read_single.c

168

rreq = netfs_alloc_request(inode->i_mapping, file, 0, iov_iter_count(iter),

fs/netfs/read_single.c

180

rreq->buffer.iter = *iter;

fs/netfs/rolling_buffer.c

100

roll->iter.folioq_slot = 0;

fs/netfs/rolling_buffer.c

145

WRITE_ONCE(roll->iter.count, roll->iter.count + size);

fs/netfs/rolling_buffer.c

170

WRITE_ONCE(roll->iter.count, roll->iter.count + size);

fs/netfs/rolling_buffer.c

73

iov_iter_folio_queue(&roll->iter, direction, fq, 0, 0, 0);

fs/netfs/rolling_buffer.c

97

if (roll->iter.folioq == head &&

fs/netfs/rolling_buffer.c

98

roll->iter.folioq_slot == folioq_nr_slots(head)) {

fs/netfs/rolling_buffer.c

99

roll->iter.folioq = fq;

fs/netfs/write_issue.c

162

struct iov_iter *wreq_iter = &wreq->buffer.iter;

fs/netfs/write_issue.c

650

wreq->debug_id, wreq->buffer.iter.count, wreq->wsize, copied, to_page_end);

fs/netfs/write_issue.c

813

wreq->buffer.iter.iov_offset = 0;

fs/netfs/write_issue.c

838

struct iov_iter *iter)

fs/netfs/write_issue.c

843

size_t size = iov_iter_count(iter);

fs/netfs/write_issue.c

846

if (WARN_ON_ONCE(!iov_iter_is_folioq(iter)))

fs/netfs/write_issue.c

868

for (fq = (struct folio_queue *)iter->folioq; fq; fq = fq->next) {

fs/nfs/direct.c

1009

file, iov_iter_count(iter), (long long) iocb->ki_pos);

fs/nfs/direct.c

1013

result = iov_iter_count(iter);

fs/nfs/direct.c

1015

result = generic_write_checks(iocb, iter);

fs/nfs/direct.c

1022

end = (pos + iov_iter_count(iter) - 1) >> PAGE_SHIFT;

fs/nfs/direct.c

1047

requested = nfs_direct_write_schedule_iovec(dreq, iter, pos,

fs/nfs/direct.c

1059

requested = nfs_direct_write_schedule_iovec(dreq, iter, pos,

fs/nfs/direct.c

1078

iov_iter_revert(iter, requested);

fs/nfs/direct.c

155

int nfs_swap_rw(struct kiocb *iocb, struct iov_iter *iter)

fs/nfs/direct.c

159

if (iov_iter_rw(iter) == READ)

fs/nfs/direct.c

160

ret = nfs_file_direct_read(iocb, iter, true);

fs/nfs/direct.c

162

ret = nfs_file_direct_write(iocb, iter, true);

fs/nfs/direct.c

341

struct iov_iter *iter,

fs/nfs/direct.c

356

while (iov_iter_count(iter)) {

fs/nfs/direct.c

362

result = iov_iter_get_pages_alloc2(iter, &pagevec,

fs/nfs/direct.c

432

ssize_t nfs_file_direct_read(struct kiocb *iocb, struct iov_iter *iter,

fs/nfs/direct.c

441

size_t count = iov_iter_count(iter);

fs/nfs/direct.c

477

if (user_backed_iter(iter))

fs/nfs/direct.c

495

requested = nfs_direct_read_schedule_iovec(dreq, iter, iocb->ki_pos);

fs/nfs/direct.c

506

iov_iter_revert(iter, requested);

fs/nfs/direct.c

872

struct iov_iter *iter,

fs/nfs/direct.c

891

NFS_I(inode)->write_io += iov_iter_count(iter);

fs/nfs/direct.c

892

while (iov_iter_count(iter)) {

fs/nfs/direct.c

898

result = iov_iter_get_pages_alloc2(iter, &pagevec,

fs/nfs/direct.c

996

ssize_t nfs_file_direct_write(struct kiocb *iocb, struct iov_iter *iter,

fs/nfs/localio.c

408

nfs_local_iter_setup(struct iov_iter *iter, int rw, struct bio_vec *bvec,

fs/nfs/localio.c

412

iov_iter_bvec(iter, rw, bvec, nvecs, total);

fs/nfs/localio.c

414

iov_iter_advance(iter, start);

fs/nfs/localio.c

415

iov_iter_truncate(iter, len);

fs/nfs/nfs42proc.c

247

struct nfs4_copy_state *copy, *tmp_copy = NULL, *iter;

fs/nfs/nfs42proc.c

260

list_for_each_entry(iter,

fs/nfs/nfs42proc.c

263

if (memcmp(&res->write_res.stateid, &iter->stateid,

fs/nfs/nfs42proc.c

266

tmp_copy = iter;

fs/nfs/nfs42proc.c

267

list_del(&iter->copies);

fs/nfs/nfstrace.h

1092

const struct iov_iter *iter

fs/nfs/nfstrace.h

1095

TP_ARGS(iocb, iter),

fs/nfs/nfstrace.h

1116

__entry->count = iov_iter_count(iter);

fs/nfs/nfstrace.h

1134

const struct iov_iter *iter \

fs/nfs/nfstrace.h

1136

TP_ARGS(iocb, iter))

fs/nfsd/filecache.c

745

struct rhashtable_iter iter;

fs/nfsd/filecache.c

749

rhltable_walk_enter(&nfsd_file_rhltable, &iter);

fs/nfsd/filecache.c

751

rhashtable_walk_start(&iter);

fs/nfsd/filecache.c

753

nf = rhashtable_walk_next(&iter);

fs/nfsd/filecache.c

763

nf = rhashtable_walk_next(&iter);

fs/nfsd/filecache.c

766

rhashtable_walk_stop(&iter);

fs/nfsd/filecache.c

768

rhashtable_walk_exit(&iter);

fs/nfsd/filecache.c

913

struct rhashtable_iter iter;

fs/nfsd/filecache.c

925

rhltable_walk_enter(&nfsd_file_rhltable, &iter);

fs/nfsd/filecache.c

927

rhashtable_walk_start(&iter);

fs/nfsd/filecache.c

929

nf = rhashtable_walk_next(&iter);

fs/nfsd/filecache.c

933

nf = rhashtable_walk_next(&iter);

fs/nfsd/filecache.c

936

rhashtable_walk_stop(&iter);

fs/nfsd/filecache.c

938

rhashtable_walk_exit(&iter);

fs/nfsd/vfs.c

1119

struct iov_iter iter;

fs/nfsd/vfs.c

1147

iov_iter_bvec(&iter, ITER_DEST, rqstp->rq_bvec, v,

fs/nfsd/vfs.c

1150

host_err = vfs_iocb_iter_read(nf->nf_file, &kiocb, &iter);

fs/nfsd/vfs.c

1198

struct iov_iter iter;

fs/nfsd/vfs.c

1237

iov_iter_bvec(&iter, ITER_DEST, rqstp->rq_bvec, v, *count - total);

fs/nfsd/vfs.c

1238

host_err = vfs_iocb_iter_read(file, &kiocb, &iter);

fs/nfsd/vfs.c

1280

struct iov_iter iter;

fs/nfsd/vfs.c

1285

iov_iter_bvec_offset(const struct iov_iter *iter)

fs/nfsd/vfs.c

1287

return (unsigned long)(iter->bvec->bv_offset + iter->iov_offset);

fs/nfsd/vfs.c

1296

iov_iter_bvec(&segment->iter, ITER_SOURCE, bvec, nvecs, total);

fs/nfsd/vfs.c

1298

iov_iter_advance(&segment->iter, start);

fs/nfsd/vfs.c

1299

iov_iter_truncate(&segment->iter, len);

fs/nfsd/vfs.c

1350

if (iov_iter_bvec_offset(&segments[nsegs].iter) & (mem_align - 1))

fs/nfsd/vfs.c

1386

segments[i].iter.count);

fs/nfsd/vfs.c

1389

segments[i].iter.count);

fs/nfsd/vfs.c

1398

host_err = vfs_iocb_iter_write(file, kiocb, &segments[i].iter);

fs/nfsd/vfs.c

1402

if (host_err < segments[i].iter.count)

fs/nfsd/vfs.c

1436

struct iov_iter iter;

fs/nfsd/vfs.c

1502

iov_iter_bvec(&iter, ITER_SOURCE, rqstp->rq_bvec, nvecs, *cnt);

fs/nfsd/vfs.c

1503

host_err = vfs_iocb_iter_write(file, &kiocb, &iter);

fs/nilfs2/inode.c

261

nilfs_direct_IO(struct kiocb *iocb, struct iov_iter *iter)

fs/nilfs2/inode.c

265

if (iov_iter_rw(iter) == WRITE)

fs/nilfs2/inode.c

269

return blockdev_direct_IO(iocb, inode, iter, nilfs_get_block);

fs/ntfs/aops.c

21

struct folio_iter iter;

fs/ntfs/aops.c

23

bio_for_each_folio_all(iter, bio) {

fs/ntfs/aops.c

24

struct folio *folio = iter.folio;

fs/ntfs/aops.c

30

if (pos + iter.offset < init_size &&

fs/ntfs/aops.c

31

pos + iter.offset + iter.length > init_size)

fs/ntfs/aops.c

33

iter.offset + iter.length);

fs/ntfs/aops.c

35

iomap_finish_folio_read(folio, iter.offset, iter.length, error);

fs/ntfs/aops.c

40

static void ntfs_iomap_bio_submit_read(const struct iomap_iter *iter,

fs/ntfs/aops.c

43

iomap_bio_submit_read_endio(iter, ctx, ntfs_iomap_read_end_io);

fs/ntfs3/file.c

51

static bool ntfs_should_use_dio(struct kiocb *iocb, struct iov_iter *iter)

fs/ntfs3/file.c

59

return IS_ALIGNED(iocb->ki_pos | iov_iter_alignment(iter), dio_align);

fs/ntfs3/file.c

815

static ssize_t ntfs_file_read_iter(struct kiocb *iocb, struct iov_iter *iter)

fs/ntfs3/file.c

820

size_t bytes = iov_iter_count(iter);

fs/ntfs3/file.c

844

!ntfs_should_use_dio(iocb, iter)) {

fs/ntfs3/file.c

846

return generic_file_read_iter(iocb, iter);

fs/ntfs3/file.c

875

err = iomap_dio_rw(iocb, iter, &ntfs_iomap_ops, NULL, dio_flags,

fs/ntfs3/file.c

884

iov_iter_revert(iter, to_zero);

fs/ntfs3/file.c

885

iov_iter_zero(to_zero, iter);

fs/ntfs3/file.c

890

iov_iter_zero(bytes, iter);

fs/ntfs3/index.c

1251

size_t iter = 0;

fs/ntfs3/index.c

1287

if (iter++ >= 1000)

fs/ntfs3/inode.c

608

static void ntfs_iomap_bio_submit_read(const struct iomap_iter *iter,

fs/ntfs3/inode.c

611

iomap_bio_submit_read_endio(iter, ctx, ntfs_iomap_read_end_io);

fs/ocfs2/aops.c

2436

static ssize_t ocfs2_direct_IO(struct kiocb *iocb, struct iov_iter *iter)

fs/ocfs2/aops.c

2451

if (iocb->ki_pos + iter->count > i_size_read(inode) &&

fs/ocfs2/aops.c

2455

if (iov_iter_rw(iter) == READ)

fs/ocfs2/aops.c

2461

iter, get_block,

fs/ocfs2/dlm/dlmcommon.h

1095

struct dlm_node_iter *iter)

fs/ocfs2/dlm/dlmcommon.h

1097

bitmap_copy(iter->node_map, map, O2NM_MAX_NODES);

fs/ocfs2/dlm/dlmcommon.h

1098

iter->curnode = -1;

fs/ocfs2/dlm/dlmcommon.h

1101

static inline int dlm_node_iter_next(struct dlm_node_iter *iter)

fs/ocfs2/dlm/dlmcommon.h

1104

bit = find_next_bit(iter->node_map, O2NM_MAX_NODES, iter->curnode+1);

fs/ocfs2/dlm/dlmcommon.h

1106

iter->curnode = O2NM_MAX_NODES;

fs/ocfs2/dlm/dlmcommon.h

1109

iter->curnode = bit;

fs/ocfs2/dlm/dlmdebug.c

488

struct dlm_lock_resource *res = NULL, *iter;

fs/ocfs2/dlm/dlmdebug.c

503

list_for_each_entry(iter, track_list, tracking) {

fs/ocfs2/dlm/dlmdebug.c

504

if (&iter->tracking != &dlm->tracking_list) {

fs/ocfs2/dlm/dlmdebug.c

505

dlm_lockres_get(iter);

fs/ocfs2/dlm/dlmdebug.c

506

res = iter;

fs/ocfs2/dlm/dlmdomain.c

409

struct hlist_node *iter;

fs/ocfs2/dlm/dlmdomain.c

421

iter = bucket->first;

fs/ocfs2/dlm/dlmdomain.c

422

while (iter) {

fs/ocfs2/dlm/dlmdomain.c

424

res = hlist_entry(iter, struct dlm_lock_resource,

fs/ocfs2/dlm/dlmdomain.c

435

iter = res->hash_node.next;

fs/ocfs2/dlm/dlmmaster.c

1161

static void dlm_bitmap_diff_iter_init(struct dlm_bitmap_diff_iter *iter,

fs/ocfs2/dlm/dlmmaster.c

1168

iter->curnode = -1;

fs/ocfs2/dlm/dlmmaster.c

1169

iter->orig_bm = orig_bm;

fs/ocfs2/dlm/dlmmaster.c

1170

iter->cur_bm = cur_bm;

fs/ocfs2/dlm/dlmmaster.c

1173

p1 = *(iter->orig_bm + i);

fs/ocfs2/dlm/dlmmaster.c

1174

p2 = *(iter->cur_bm + i);

fs/ocfs2/dlm/dlmmaster.c

1175

iter->diff_bm[i] = (p1 & ~p2) | (p2 & ~p1);

fs/ocfs2/dlm/dlmmaster.c

1179

static int dlm_bitmap_diff_iter_next(struct dlm_bitmap_diff_iter *iter,

fs/ocfs2/dlm/dlmmaster.c

1184

if (iter->curnode >= O2NM_MAX_NODES)

fs/ocfs2/dlm/dlmmaster.c

1187

bit = find_next_bit(iter->diff_bm, O2NM_MAX_NODES,

fs/ocfs2/dlm/dlmmaster.c

1188

iter->curnode+1);

fs/ocfs2/dlm/dlmmaster.c

1190

iter->curnode = O2NM_MAX_NODES;

fs/ocfs2/dlm/dlmmaster.c

1195

if (test_bit(bit, iter->orig_bm))

fs/ocfs2/dlm/dlmmaster.c

1200

iter->curnode = bit;

fs/ocfs2/dlm/dlmmaster.c

1646

struct dlm_node_iter iter;

fs/ocfs2/dlm/dlmmaster.c

1662

dlm_node_iter_init(nodemap, &iter);

fs/ocfs2/dlm/dlmmaster.c

1663

while ((to = dlm_node_iter_next(&iter)) >= 0) {

fs/ocfs2/dlm/dlmmaster.c

2156

struct dlm_node_iter iter;

fs/ocfs2/dlm/dlmmaster.c

2162

dlm_node_iter_init(dlm->domain_map, &iter);

fs/ocfs2/dlm/dlmmaster.c

2165

while ((nodenum = dlm_node_iter_next(&iter)) >= 0) {

fs/ocfs2/dlm/dlmmaster.c

3012

struct dlm_node_iter *iter)

fs/ocfs2/dlm/dlmmaster.c

3027

while ((nodenum = dlm_node_iter_next(iter)) >= 0) {

fs/ocfs2/dlm/dlmmaster.c

3037

clear_bit(nodenum, iter->node_map);

fs/ocfs2/dlm/dlmmaster.c

3052

clear_bit(nodenum, iter->node_map);

fs/ocfs2/dlm/dlmmaster.c

3401

struct dlm_node_iter iter;

fs/ocfs2/dlm/dlmmaster.c

3405

dlm_node_iter_init(dlm->domain_map, &iter);

fs/ocfs2/dlm/dlmmaster.c

3406

clear_bit(old_master, iter.node_map);

fs/ocfs2/dlm/dlmmaster.c

3407

clear_bit(dlm->node_num, iter.node_map);

fs/ocfs2/dlm/dlmmaster.c

3419

dlm->node_num, &iter);

fs/ocfs2/dlm/dlmmaster.c

3429

ret = dlm_do_assert_master(dlm, res, iter.node_map,

fs/ocfs2/dlm/dlmmaster.c

3437

bitmap_zero(iter.node_map, O2NM_MAX_NODES);

fs/ocfs2/dlm/dlmmaster.c

3438

set_bit(old_master, iter.node_map);

fs/ocfs2/dlm/dlmmaster.c

3441

ret = dlm_do_assert_master(dlm, res, iter.node_map,

fs/ocfs2/dlm/dlmmaster.c

711

struct dlm_node_iter iter;

fs/ocfs2/dlm/dlmmaster.c

933

dlm_node_iter_init(mle->vote_map, &iter);

fs/ocfs2/dlm/dlmmaster.c

934

while ((nodenum = dlm_node_iter_next(&iter)) >= 0) {

fs/ocfs2/dlm/dlmrecovery.c

1081

struct list_head *iter, *queue = &res->granted;

fs/ocfs2/dlm/dlmrecovery.c

1085

list_for_each(iter, queue)

fs/ocfs2/dlm/dlmrecovery.c

1603

struct dlm_node_iter iter;

fs/ocfs2/dlm/dlmrecovery.c

1633

dlm_node_iter_init(dlm->domain_map, &iter);

fs/ocfs2/dlm/dlmrecovery.c

1636

while ((nodenum = dlm_node_iter_next(&iter)) >= 0) {

fs/ocfs2/dlm/dlmrecovery.c

1790

struct list_head *queue, *iter;

fs/ocfs2/dlm/dlmrecovery.c

1833

list_for_each(iter, tmpq) {

fs/ocfs2/dlm/dlmrecovery.c

1834

lock = list_entry(iter,

fs/ocfs2/dlm/dlmrecovery.c

2671

struct dlm_node_iter iter;

fs/ocfs2/dlm/dlmrecovery.c

2678

dlm_node_iter_init(dlm->domain_map, &iter);

fs/ocfs2/dlm/dlmrecovery.c

2681

clear_bit(dead_node, iter.node_map);

fs/ocfs2/dlm/dlmrecovery.c

2687

while ((nodenum = dlm_node_iter_next(&iter)) >= 0) {

fs/ocfs2/dlm/dlmrecovery.c

2833

struct dlm_node_iter iter;

fs/ocfs2/dlm/dlmrecovery.c

2842

dlm_node_iter_init(dlm->domain_map, &iter);

fs/ocfs2/dlm/dlmrecovery.c

2852

while ((nodenum = dlm_node_iter_next(&iter)) >= 0) {

fs/ocfs2/dlm/dlmrecovery.c

2877

iter.curnode = -1;

fs/ocfs2/dlm/dlmunlock.c

395

struct dlm_lock *lock = NULL, *iter;

fs/ocfs2/dlm/dlmunlock.c

463

list_for_each_entry(iter, queue, list) {

fs/ocfs2/dlm/dlmunlock.c

464

if (iter->ml.cookie == unlock->cookie &&

fs/ocfs2/dlm/dlmunlock.c

465

iter->ml.node == unlock->node_idx) {

fs/ocfs2/dlm/dlmunlock.c

466

dlm_lock_get(iter);

fs/ocfs2/dlm/dlmunlock.c

467

lock = iter;

fs/ocfs2/dlmglue.c

3056

struct ocfs2_lock_res *iter, *ret = NULL;

fs/ocfs2/dlmglue.c

3061

list_for_each_entry(iter, &start->l_debug_list, l_debug_list) {

fs/ocfs2/dlmglue.c

3063

if (&iter->l_debug_list == &dlm_debug->d_lockres_tracking) {

fs/ocfs2/dlmglue.c

3070

if (iter->l_ops != NULL) {

fs/ocfs2/dlmglue.c

3071

ret = iter;

fs/ocfs2/dlmglue.c

3082

struct ocfs2_lock_res *iter;

fs/ocfs2/dlmglue.c

3085

iter = ocfs2_dlm_next_res(&priv->p_iter_res, priv);

fs/ocfs2/dlmglue.c

3086

if (iter) {

fs/ocfs2/dlmglue.c

3094

priv->p_tmp_res = *iter;

fs/ocfs2/dlmglue.c

3095

iter = &priv->p_tmp_res;

fs/ocfs2/dlmglue.c

3099

return iter;

fs/ocfs2/dlmglue.c

3109

struct ocfs2_lock_res *iter = v;

fs/ocfs2/dlmglue.c

3114

iter = ocfs2_dlm_next_res(iter, priv);

fs/ocfs2/dlmglue.c

3116

if (iter) {

fs/ocfs2/dlmglue.c

3117

list_add(&dummy->l_debug_list, &iter->l_debug_list);

fs/ocfs2/dlmglue.c

3118

priv->p_tmp_res = *iter;

fs/ocfs2/dlmglue.c

3119

iter = &priv->p_tmp_res;

fs/ocfs2/dlmglue.c

3123

return iter;

fs/ocfs2/journal.c

2149

struct inode *iter;

fs/ocfs2/journal.c

2163

iter = ocfs2_iget(p->osb, ino,

fs/ocfs2/journal.c

2165

if (IS_ERR(iter))

fs/ocfs2/journal.c

2170

OCFS2_I(iter)->ip_flags |= OCFS2_INODE_DIO_ORPHAN_ENTRY;

fs/ocfs2/journal.c

2174

if (OCFS2_I(iter)->ip_next_orphan) {

fs/ocfs2/journal.c

2175

iput(iter);

fs/ocfs2/journal.c

2179

trace_ocfs2_orphan_filldir((unsigned long long)OCFS2_I(iter)->ip_blkno);

fs/ocfs2/journal.c

2182

OCFS2_I(iter)->ip_next_orphan = p->head;

fs/ocfs2/journal.c

2183

p->head = iter;

fs/ocfs2/journal.c

2294

struct inode *iter;

fs/ocfs2/journal.c

2315

iter = oi->ip_next_orphan;

fs/ocfs2/journal.c

2371

inode = iter;

fs/ocfs2/quota_local.c

924

struct ocfs2_quota_chunk *chunk = NULL, *iter;

fs/ocfs2/quota_local.c

928

list_for_each_entry(iter, &oinfo->dqi_chunk, qc_chunk) {

fs/ocfs2/quota_local.c

930

iter->qc_headerbh->b_data;

fs/ocfs2/quota_local.c

932

chunk = iter;

fs/orangefs/devorangefs-req.c

362

struct iov_iter *iter)

fs/orangefs/devorangefs-req.c

371

int total = ret = iov_iter_count(iter);

fs/orangefs/devorangefs-req.c

388

if (!copy_from_iter_full(&head, head_size, iter)) {

fs/orangefs/devorangefs-req.c

423

if (!copy_from_iter_full(&op->downcall, downcall_size, iter)) {

fs/orangefs/devorangefs-req.c

474

op->downcall.trailer_size, iter)) {

fs/orangefs/file.c

140

ret = orangefs_bufmap_copy_from_iovec(iter, buffer_index,

fs/orangefs/file.c

174

iov_iter_revert(iter, total_size);

fs/orangefs/file.c

254

ret = orangefs_bufmap_copy_to_iovec(iter, buffer_index,

fs/orangefs/file.c

324

struct iov_iter *iter)

fs/orangefs/file.c

334

ret = generic_file_read_iter(iocb, iter);

fs/orangefs/file.c

361

struct iov_iter *iter)

fs/orangefs/file.c

372

ret = generic_file_write_iter(iocb, iter);

fs/orangefs/file.c

50

loff_t *offset, struct iov_iter *iter, size_t total_size,

fs/orangefs/inode.c

107

ret = wait_for_direct_io(ORANGEFS_IO_WRITE, inode, &off, &iter, ow->len,

fs/orangefs/inode.c

220

struct iov_iter iter;

fs/orangefs/inode.c

24

struct iov_iter iter;

fs/orangefs/inode.c

244

iov_iter_xarray(&iter, ITER_DEST, i_pages,

fs/orangefs/inode.c

256

&offset, &iter, this_size,

fs/orangefs/inode.c

282

struct iov_iter iter;

fs/orangefs/inode.c

292

iov_iter_bvec(&iter, ITER_DEST, &bv, 1, folio_size(folio));

fs/orangefs/inode.c

294

ret = wait_for_direct_io(ORANGEFS_IO_READ, inode, &off, &iter,

fs/orangefs/inode.c

297

iov_iter_zero(~0U, &iter);

fs/orangefs/inode.c

494

struct iov_iter *iter)

fs/orangefs/inode.c

506

enum ORANGEFS_io_type type = iov_iter_rw(iter) == WRITE ?

fs/orangefs/inode.c

512

size_t count = iov_iter_count(iter);

fs/orangefs/inode.c

53

iov_iter_bvec(&iter, ITER_SOURCE, &bv, 1, wlen);

fs/orangefs/inode.c

537

while (iov_iter_count(iter)) {

fs/orangefs/inode.c

538

size_t each_count = iov_iter_count(iter);

fs/orangefs/inode.c

55

ret = wait_for_direct_io(ORANGEFS_IO_WRITE, inode, &off, &iter, wlen,

fs/orangefs/inode.c

556

ret = wait_for_direct_io(type, inode, offset, iter,

fs/orangefs/inode.c

83

struct iov_iter iter;

fs/orangefs/inode.c

98

iov_iter_bvec(&iter, ITER_SOURCE, ow->bv, ow->nfolios, ow->len);

fs/orangefs/orangefs-bufmap.c

649

int orangefs_bufmap_copy_from_iovec(struct iov_iter *iter,

fs/orangefs/orangefs-bufmap.c

689

copied = copy_from_iter(kaddr, first, iter);

fs/orangefs/orangefs-bufmap.c

699

copied = copy_from_iter(kaddr, second, iter);

fs/orangefs/orangefs-bufmap.c

727

copied = copy_from_iter(kaddr, copy_amount, iter);

fs/orangefs/orangefs-bufmap.c

744

int orangefs_bufmap_copy_to_iovec(struct iov_iter *iter,

fs/orangefs/orangefs-bufmap.c

786

copied = copy_to_iter(kaddr, first, iter);

fs/orangefs/orangefs-bufmap.c

796

copied = copy_to_iter(kaddr, second, iter);

fs/orangefs/orangefs-bufmap.c

825

copied = copy_to_iter(kaddr, copy_amount, iter);

fs/orangefs/orangefs-bufmap.h

27

int orangefs_bufmap_copy_from_iovec(struct iov_iter *iter,

fs/orangefs/orangefs-bufmap.h

31

int orangefs_bufmap_copy_to_iovec(struct iov_iter *iter,

fs/overlayfs/file.c

323

static ssize_t ovl_read_iter(struct kiocb *iocb, struct iov_iter *iter)

fs/overlayfs/file.c

332

if (!iov_iter_count(iter))

fs/overlayfs/file.c

339

return backing_file_read_iter(realfile, iter, iocb, iocb->ki_flags,

fs/overlayfs/file.c

343

static ssize_t ovl_write_iter(struct kiocb *iocb, struct iov_iter *iter)

fs/overlayfs/file.c

355

if (!iov_iter_count(iter))

fs/overlayfs/file.c

370

ret = backing_file_write_iter(realfile, iter, iocb, ifl, &ctx);

fs/overlayfs/params.c

524

char *dup = NULL, *iter;

fs/overlayfs/params.c

563

iter = dup;

fs/overlayfs/params.c

567

err = ovl_kern_path(iter, &path, Opt_lowerdir);

fs/overlayfs/params.c

571

err = ovl_do_parse_layer(fc, iter, &path, Opt_lowerdir);

fs/overlayfs/params.c

583

iter = strchr(iter, '\0') + 1;

fs/overlayfs/params.c

584

if (*iter) {

fs/overlayfs/params.c

600

iter++;

fs/proc/base.c

3577

auto iter = make_tgid_iter(pos - TGID_OFFSET, pid_ns);

fs/proc/base.c

3578

while (next_tgid(&iter)) {

fs/proc/base.c

3583

if (!has_pid_permissions(fs_info, iter.task, HIDEPID_INVISIBLE))

fs/proc/base.c

3586

len = snprintf(name, sizeof(name), "%u", iter.tgid);

fs/proc/base.c

3587

ctx->pos = iter.tgid + TGID_OFFSET;

fs/proc/base.c

3589

proc_pid_instantiate, iter.task, NULL)) {

fs/proc/base.c

3590

put_task_struct(iter.task);

fs/proc/inode.c

289

static ssize_t proc_reg_read_iter(struct kiocb *iocb, struct iov_iter *iter)

fs/proc/inode.c

295

return pde->proc_ops->proc_read_iter(iocb, iter);

fs/proc/inode.c

299

ret = pde->proc_ops->proc_read_iter(iocb, iter);

fs/proc/internal.h

397

struct vma_iterator iter;

fs/proc/kcore.c

324

static ssize_t read_kcore_iter(struct kiocb *iocb, struct iov_iter *iter)

fs/proc/kcore.c

334

size_t buflen = iov_iter_count(iter);

fs/proc/kcore.c

372

if (copy_to_iter((char *)&ehdr + *fpos, tsz, iter) != tsz) {

fs/proc/kcore.c

416

iter) != tsz) {

fs/proc/kcore.c

465

if (copy_to_iter(notes + *fpos - notes_offset, tsz, iter) != tsz) {

fs/proc/kcore.c

515

if (iov_iter_zero(tsz, iter) != tsz) {

fs/proc/kcore.c

534

read += vread_iter(iter, src, left);

fs/proc/kcore.c

541

if (fault_in_iov_iter_writeable(iter, left)) {

fs/proc/kcore.c

550

if (copy_to_iter((char *)start, tsz, iter) != tsz) {

fs/proc/kcore.c

568

if (iov_iter_zero(tsz, iter) != tsz) {

fs/proc/kcore.c

581

if (iov_iter_zero(tsz, iter) != tsz)

fs/proc/kcore.c

599

if (iov_iter_zero(tsz, iter) != tsz) {

fs/proc/kcore.c

608

} else if (_copy_to_iter(buf, tsz, iter) != tsz) {

fs/proc/kcore.c

615

if (iov_iter_zero(tsz, iter) != tsz) {

fs/proc/proc_sysctl.c

553

static ssize_t proc_sys_call_handler(struct kiocb *iocb, struct iov_iter *iter,

fs/proc/proc_sysctl.c

559

size_t count = iov_iter_count(iter);

fs/proc/proc_sysctl.c

589

if (!copy_from_iter_full(kbuf, count, iter))

fs/proc/proc_sysctl.c

606

if (copy_to_iter(kbuf, count, iter) < count)

fs/proc/proc_sysctl.c

619

static ssize_t proc_sys_read(struct kiocb *iocb, struct iov_iter *iter)

fs/proc/proc_sysctl.c

621

return proc_sys_call_handler(iocb, iter, 0);

fs/proc/proc_sysctl.c

624

static ssize_t proc_sys_write(struct kiocb *iocb, struct iov_iter *iter)

fs/proc/proc_sysctl.c

626

return proc_sys_call_handler(iocb, iter, 1);

fs/proc/task_mmu.c

191

return vma_next(&priv->iter);

fs/proc/task_mmu.c

194

vma = lock_next_vma(lock_ctx->mm, &priv->iter, last_pos);

fs/proc/task_mmu.c

212

vma_iter_set(&priv->iter, pos);

fs/proc/task_mmu.c

233

vma_iter_set(&priv->iter, priv->lock_ctx.locked_vma->vm_end);

fs/proc/task_mmu.c

262

return vma_next(&priv->iter);

fs/proc/task_mmu.c

344

vma_iter_init(&priv->iter, mm, (unsigned long)last_addr);

fs/proc/task_nommu.c

181

struct vm_area_struct *vma = vma_next(&priv->iter);

fs/proc/task_nommu.c

221

vma_iter_init(&priv->iter, mm, last_addr);

fs/proc/vmcore.c

159

ssize_t read_from_oldmem(struct iov_iter *iter, size_t count,

fs/proc/vmcore.c

182

tmp = iov_iter_zero(nr_bytes, iter);

fs/proc/vmcore.c

185

tmp = copy_oldmem_page_encrypted(iter, pfn,

fs/proc/vmcore.c

189

tmp = copy_oldmem_page(iter, pfn, nr_bytes,

fs/proc/vmcore.c

228

struct iov_iter iter;

fs/proc/vmcore.c

230

iov_iter_kvec(&iter, ITER_DEST, &kvec, 1, count);

fs/proc/vmcore.c

232

return read_from_oldmem(&iter, count, ppos, false);

fs/proc/vmcore.c

241

struct iov_iter iter;

fs/proc/vmcore.c

243

iov_iter_kvec(&iter, ITER_DEST, &kvec, 1, count);

fs/proc/vmcore.c

245

return read_from_oldmem(&iter, count, ppos,

fs/proc/vmcore.c

263

ssize_t __weak copy_oldmem_page_encrypted(struct iov_iter *iter,

fs/proc/vmcore.c

266

return copy_oldmem_page(iter, pfn, csize, offset);

fs/proc/vmcore.c

270

static int vmcoredd_copy_dumps(struct iov_iter *iter, u64 start, size_t size)

fs/proc/vmcore.c

281

if (copy_to_iter(buf, tsz, iter) < tsz)

fs/proc/vmcore.c

333

static ssize_t __read_vmcore(struct iov_iter *iter, loff_t *fpos)

fs/proc/vmcore.c

340

if (!iov_iter_count(iter) || *fpos >= vmcore_size)

fs/proc/vmcore.c

343

iov_iter_truncate(iter, vmcore_size - *fpos);

fs/proc/vmcore.c

347

tsz = min(elfcorebuf_sz - (size_t)*fpos, iov_iter_count(iter));

fs/proc/vmcore.c

348

if (copy_to_iter(elfcorebuf + *fpos, tsz, iter) < tsz)

fs/proc/vmcore.c

354

if (!iov_iter_count(iter))

fs/proc/vmcore.c

375

(size_t)*fpos, iov_iter_count(iter));

fs/proc/vmcore.c

377

if (vmcoredd_copy_dumps(iter, start, tsz))

fs/proc/vmcore.c

384

if (!iov_iter_count(iter))

fs/proc/vmcore.c

391

iov_iter_count(iter));

fs/proc/vmcore.c

393

if (copy_to_iter(kaddr, tsz, iter) < tsz)

fs/proc/vmcore.c

400

if (!iov_iter_count(iter))

fs/proc/vmcore.c

410

iov_iter_count(iter));

fs/proc/vmcore.c

412

tmp = read_from_oldmem(iter, tsz, &start,

fs/proc/vmcore.c

420

if (!iov_iter_count(iter))

fs/proc/vmcore.c

430

static ssize_t read_vmcore(struct kiocb *iocb, struct iov_iter *iter)

fs/proc/vmcore.c

432

return __read_vmcore(iter, &iocb->ki_pos);

fs/proc/vmcore.c

475

struct iov_iter iter;

fs/proc/vmcore.c

488

iov_iter_kvec(&iter, ITER_DEST, &kvec, 1, PAGE_SIZE);

fs/proc/vmcore.c

490

rc = __read_vmcore(&iter, &offset);

fs/pstore/platform.c

280

struct kmsg_dump_iter iter;

fs/pstore/platform.c

301

kmsg_dump_rewind(&iter);

fs/pstore/platform.c

328

if (!kmsg_dump_get_buffer(&iter, true, dst + header_size,

fs/read_write.c

1006

&iter);

fs/read_write.c

1010

tot_len = iov_iter_count(&iter);

fs/read_write.c

1019

ret = do_iter_readv_writev(file, &iter, pos, READ, flags);

fs/read_write.c

1021

ret = do_loop_readv_writev(file, &iter, pos, READ, flags);

fs/read_write.c

1034

struct iov_iter iter;

fs/read_write.c

1044

&iter);

fs/read_write.c

1048

tot_len = iov_iter_count(&iter);

fs/read_write.c

1058

ret = do_iter_readv_writev(file, &iter, pos, WRITE, flags);

fs/read_write.c

1060

ret = do_loop_readv_writev(file, &iter, pos, WRITE, flags);

fs/read_write.c

1804

int generic_atomic_write_valid(struct kiocb *iocb, struct iov_iter *iter)

fs/read_write.c

1806

size_t len = iov_iter_count(iter);

fs/read_write.c

1808

if (!iter_is_ubuf(iter))

fs/read_write.c

486

struct iov_iter iter;

fs/read_write.c

491

iov_iter_ubuf(&iter, ITER_DEST, buf, len);

fs/read_write.c

493

ret = filp->f_op->read_iter(&kiocb, &iter);

fs/read_write.c

515

struct iov_iter iter;

fs/read_write.c

531

iov_iter_kvec(&iter, ITER_DEST, &iov, 1, iov.iov_len);

fs/read_write.c

532

ret = file->f_op->read_iter(&kiocb, &iter);

fs/read_write.c

588

struct iov_iter iter;

fs/read_write.c

593

iov_iter_ubuf(&iter, ITER_SOURCE, (void __user *)buf, len);

fs/read_write.c

595

ret = filp->f_op->write_iter(&kiocb, &iter);

fs/read_write.c

639

struct iov_iter iter;

fs/read_write.c

640

iov_iter_kvec(&iter, ITER_SOURCE, &iov, 1, iov.iov_len);

fs/read_write.c

641

return __kernel_write_iter(file, &iter, pos);

fs/read_write.c

813

static ssize_t do_iter_readv_writev(struct file *filp, struct iov_iter *iter,

fs/read_write.c

826

ret = filp->f_op->read_iter(&kiocb, iter);

fs/read_write.c

828

ret = filp->f_op->write_iter(&kiocb, iter);

fs/read_write.c

836

static ssize_t do_loop_readv_writev(struct file *filp, struct iov_iter *iter,

fs/read_write.c

844

while (iov_iter_count(iter)) {

fs/read_write.c

848

nr = filp->f_op->read(filp, iter_iov_addr(iter),

fs/read_write.c

849

iter_iov_len(iter), ppos);

fs/read_write.c

851

nr = filp->f_op->write(filp, iter_iov_addr(iter),

fs/read_write.c

852

iter_iov_len(iter), ppos);

fs/read_write.c

861

if (nr != iter_iov_len(iter))

fs/read_write.c

863

iov_iter_advance(iter, nr);

fs/read_write.c

870

struct iov_iter *iter)

fs/read_write.c

882

tot_len = iov_iter_count(iter);

fs/read_write.c

889

ret = file->f_op->read_iter(iocb, iter);

fs/read_write.c

897

ssize_t vfs_iter_read(struct file *file, struct iov_iter *iter, loff_t *ppos,

fs/read_write.c

910

tot_len = iov_iter_count(iter);

fs/read_write.c

917

ret = do_iter_readv_writev(file, iter, ppos, READ, flags);

fs/read_write.c

930

struct iov_iter *iter)

fs/read_write.c

942

tot_len = iov_iter_count(iter);

fs/read_write.c

950

ret = file->f_op->write_iter(iocb, iter);

fs/read_write.c

960

ssize_t vfs_iter_write(struct file *file, struct iov_iter *iter, loff_t *ppos,

fs/read_write.c

973

tot_len = iov_iter_count(iter);

fs/read_write.c

982

ret = do_iter_readv_writev(file, iter, ppos, WRITE, flags);

fs/read_write.c

996

struct iov_iter iter;

fs/readdir.c

35

int (*iter)(struct file *, struct dir_context *))

fs/readdir.c

67

ret = iter(file, ctx);

fs/seq_file.c

156

struct iov_iter iter;

fs/seq_file.c

160

iov_iter_init(&iter, ITER_DEST, &iov, 1, size);

fs/seq_file.c

163

ret = seq_read_iter(&kiocb, &iter);

fs/seq_file.c

172

ssize_t seq_read_iter(struct kiocb *iocb, struct iov_iter *iter)

fs/seq_file.c

180

if (!iov_iter_count(iter))

fs/seq_file.c

217

n = copy_to_iter(m->buf + m->from, m->count, iter);

fs/seq_file.c

271

if (m->count >= iov_iter_count(iter))

fs/seq_file.c

282

n = copy_to_iter(m->buf, m->count, iter);

fs/smb/client/cifsencrypt.c

57

static int cifs_sig_iter(const struct iov_iter *iter, size_t maxsize,

fs/smb/client/cifsencrypt.c

60

struct iov_iter tmp_iter = *iter;

fs/smb/client/cifsencrypt.c

73

struct iov_iter iter;

fs/smb/client/cifsencrypt.c

80

iov_iter_kvec(&iter, ITER_SOURCE, rqst->rq_iov, rqst->rq_nvec, size);

fs/smb/client/cifsencrypt.c

82

if (iov_iter_count(&iter) <= 4)

fs/smb/client/cifsencrypt.c

84

iov_iter_count(&iter), 4);

fs/smb/client/cifsencrypt.c

86

rc = cifs_sig_iter(&iter, iov_iter_count(&iter), ctx);

fs/smb/client/cifsfs.h

111

ssize_t cifs_loose_read_iter(struct kiocb *iocb, struct iov_iter *iter);

fs/smb/client/cifsproto.h

233

struct iov_iter *iter, unsigned int to_read);

fs/smb/client/compress.c

166

struct iov_iter iter = *source;

fs/smb/client/compress.c

169

while (iov_iter_count(&iter) >= SZ_2K) {

fs/smb/client/compress.c

170

size_t part = umin(umin(iov_iter_count(&iter), SZ_2K), max);

fs/smb/client/compress.c

173

n = copy_from_iter(sample + s, part, &iter);

fs/smb/client/compress.c

180

if (iov_iter_count(&iter) < PAGE_SIZE - SZ_2K)

fs/smb/client/compress.c

183

iov_iter_advance(&iter, SZ_2K);

fs/smb/client/compress.c

310

struct iov_iter iter;

fs/smb/client/compress.c

329

iter = rq->rq_iter;

fs/smb/client/compress.c

331

if (!copy_from_iter_full(src, slen, &iter)) {

fs/smb/client/connect.c

817

cifs_read_iter_from_socket(struct TCP_Server_Info *server, struct iov_iter *iter,

fs/smb/client/connect.c

820

struct msghdr smb_msg = { .msg_iter = *iter };

fs/smb/client/file.c

3049

ssize_t cifs_loose_read_iter(struct kiocb *iocb, struct iov_iter *iter)

fs/smb/client/file.c

3055

return netfs_unbuffered_read_iter(iocb, iter);

fs/smb/client/file.c

3061

return netfs_file_read_iter(iocb, iter);

fs/smb/client/file.c

3475

static int cifs_swap_rw(struct kiocb *iocb, struct iov_iter *iter)

fs/smb/client/file.c

3479

if (iov_iter_rw(iter) == READ)

fs/smb/client/file.c

3480

ret = netfs_unbuffered_read_iter_locked(iocb, iter);

fs/smb/client/file.c

3482

ret = netfs_unbuffered_write_iter_locked(iocb, iter, NULL);

fs/smb/client/smb2misc.c

165

struct cifs_ses *iter;

fs/smb/client/smb2misc.c

169

list_for_each_entry(iter, &pserver->smb_ses_list, smb_ses_list) {

fs/smb/client/smb2misc.c

170

if (iter->Suid == le64_to_cpu(thdr->SessionId)) {

fs/smb/client/smb2misc.c

171

ses = iter;

fs/smb/client/smb2ops.c

4550

struct iov_iter *iter = &rqst[i].rq_iter;

fs/smb/client/smb2ops.c

4551

size_t count = iov_iter_count(iter);

fs/smb/client/smb2ops.c

4563

rc = extract_iter_to_sg(iter, count, &sgtable,

fs/smb/client/smb2ops.c

4565

iov_iter_revert(iter, rc);

fs/smb/client/smb2ops.c

4688

static bool cifs_copy_iter_to_folioq(struct iov_iter *iter, size_t size,

fs/smb/client/smb2ops.c

4698

if (copy_folio_from_iter(folio, 0, part, iter) != part)

fs/smb/client/smb2ops.c

4787

unsigned int buf_data_size, struct iov_iter *iter,

fs/smb/client/smb2ops.c

4803

if (iter) {

fs/smb/client/smb2ops.c

4804

rqst.rq_iter = *iter;

fs/smb/client/smb2ops.c

4805

iter_size = iov_iter_count(iter);

fs/smb/client/smb2ops.c

4846

size_t skip, struct iov_iter *iter)

fs/smb/client/smb2ops.c

4860

n = copy_folio_to_iter(folio, skip, len, iter);

fs/smb/client/smb2ops.c

5044

struct iov_iter iter;

fs/smb/client/smb2ops.c

5046

iov_iter_folio_queue(&iter, ITER_DEST, dw->buffer, 0, 0, dw->len);

fs/smb/client/smb2ops.c

5048

&iter, true);

fs/smb/client/smb2ops.c

5107

struct iov_iter iter;

fs/smb/client/smb2ops.c

5146

iov_iter_folio_queue(&iter, ITER_DEST, dw->buffer, 0, 0, len);

fs/smb/client/smb2ops.c

5149

rc = cifs_read_iter_from_socket(server, &iter, dw->len);

fs/smb/client/smb2ops.c

5155

struct iov_iter tmp = iter;

fs/smb/client/smb2ops.c

5160

iov_iter_truncate(&iter, dw->len);

fs/smb/client/smb2ops.c

5182

&iter, false);

fs/smb/client/smbdirect.c

169

struct iov_iter *iter,

fs/smb/client/smbdirect.c

180

while (iov_iter_count(iter) > 0) {

fs/smb/client/smbdirect.c

185

iter,

fs/smb/client/smbdirect.c

419

struct iov_iter iter;

fs/smb/client/smbdirect.c

466

iov_iter_kvec(&iter, ITER_SOURCE, rqst->rq_iov, rqst->rq_nvec, klen);

fs/smb/client/smbdirect.c

468

rc = smbd_post_send_full_iter(sc, batch, &iter, remaining_data_length);

fs/smb/client/smbdirect.c

518

struct iov_iter *iter,

fs/smb/client/smbdirect.c

526

return smbdirect_connection_register_mr_io(sc, iter, writing, need_invalidate);

fs/smb/client/smbdirect.h

48

struct smbd_connection *info, struct iov_iter *iter,

fs/smb/server/smb2pdu.c

7872

struct ksmbd_work *iter;

fs/smb/server/smb2pdu.c

7886

list_for_each_entry(iter, command_list,

fs/smb/server/smb2pdu.c

7888

chdr = smb_get_msg(iter->request_buf);

fs/smb/server/smb2pdu.c

7890

if (iter->async_id !=

fs/smb/server/smb2pdu.c

7902

if (iter->state != KSMBD_WORK_ACTIVE)

fs/smb/server/smb2pdu.c

7909

iter->state = KSMBD_WORK_CANCELLED;

fs/smb/server/smb2pdu.c

7910

if (iter->cancel_fn)

fs/smb/server/smb2pdu.c

7911

iter->cancel_fn(iter->cancel_argv);

fs/smb/server/smb2pdu.c

7919

list_for_each_entry(iter, command_list, request_entry) {

fs/smb/server/smb2pdu.c

7920

chdr = smb_get_msg(iter->request_buf);

fs/smb/server/smb2pdu.c

7923

iter == work)

fs/smb/server/smb2pdu.c

7930

iter->state = KSMBD_WORK_CANCELLED;

fs/smb/server/transport_rdma.c

247

struct iov_iter iter;

fs/smb/server/transport_rdma.c

249

iov_iter_kvec(&iter, ITER_SOURCE, iov, niovs, buflen);

fs/smb/server/transport_rdma.c

251

return smbdirect_connection_send_iter(sc, &iter, 0,

fs/smb/smbdirect/connection.c

1081

struct iov_iter *iter,

fs/smb/smbdirect/connection.c

1097

if (iter) {

fs/smb/smbdirect/connection.c

1098

if (WARN_ON_ONCE(iov_iter_rw(iter) != ITER_SOURCE))

fs/smb/smbdirect/connection.c

1103

iov_iter_count(iter) > remaining_data_length))

fs/smb/smbdirect/connection.c

1184

if (iter) {

fs/smb/smbdirect/connection.c

1193

size_t payload_len = umin(iov_iter_count(iter),

fs/smb/smbdirect/connection.c

1196

ret = smbdirect_map_sges_from_iter(iter, payload_len, &extract);

fs/smb/smbdirect/connection.c

1294

struct iov_iter *iter,

fs/smb/smbdirect/connection.c

1301

int total_count = iov_iter_count(iter);

fs/smb/smbdirect/connection.c

1309

if (WARN_ON_ONCE(iov_iter_rw(iter) != ITER_SOURCE))

fs/smb/smbdirect/connection.c

1325

if (iov_iter_count(iter) <= 4)

fs/smb/smbdirect/connection.c

1327

if (!copy_from_iter_full(&hdr, sizeof(hdr), iter))

fs/smb/smbdirect/connection.c

1329

if (iov_iter_count(iter) != be32_to_cpu(hdr))

fs/smb/smbdirect/connection.c

1336

if (iov_iter_count(iter) > sp->max_fragmented_send_size)

fs/smb/smbdirect/connection.c

1341

iov_iter_count(iter));

fs/smb/smbdirect/connection.c

1344

while (iov_iter_count(iter)) {

fs/smb/smbdirect/connection.c

1347

iter,

fs/smb/smbdirect/connection.c

1349

iov_iter_count(iter));

fs/smb/smbdirect/connection.c

19

static ssize_t smbdirect_map_sges_from_iter(struct iov_iter *iter, size_t len,

fs/smb/smbdirect/connection.c

1968

static ssize_t smbdirect_map_sges_from_bvec(struct iov_iter *iter,

fs/smb/smbdirect/connection.c

1972

const struct bio_vec *bv = iter->bvec;

fs/smb/smbdirect/connection.c

1973

unsigned long start = iter->iov_offset;

fs/smb/smbdirect/connection.c

1977

for (i = 0; i < iter->nr_segs; i++) {

fs/smb/smbdirect/connection.c

2005

iov_iter_advance(iter, ret);

fs/smb/smbdirect/connection.c

2014

static ssize_t smbdirect_map_sges_from_kvec(struct iov_iter *iter,

fs/smb/smbdirect/connection.c

2018

const struct kvec *kv = iter->kvec;

fs/smb/smbdirect/connection.c

2019

unsigned long start = iter->iov_offset;

fs/smb/smbdirect/connection.c

2023

for (i = 0; i < iter->nr_segs; i++) {

fs/smb/smbdirect/connection.c

2066

iov_iter_advance(iter, ret);

fs/smb/smbdirect/connection.c

2074

static ssize_t smbdirect_map_sges_from_folioq(struct iov_iter *iter,

fs/smb/smbdirect/connection.c

2078

const struct folio_queue *folioq = iter->folioq;

fs/smb/smbdirect/connection.c

2079

unsigned int slot = iter->folioq_slot;

fs/smb/smbdirect/connection.c

2081

size_t offset = iter->iov_offset;

fs/smb/smbdirect/connection.c

2118

WARN_ON_ONCE(ret < iter->count);

fs/smb/smbdirect/connection.c

2127

iter->folioq = folioq;

fs/smb/smbdirect/connection.c

2128

iter->folioq_slot = slot;

fs/smb/smbdirect/connection.c

2129

iter->iov_offset = offset;

fs/smb/smbdirect/connection.c

2130

iter->count -= ret;

fs/smb/smbdirect/connection.c

2145

static ssize_t smbdirect_map_sges_from_iter(struct iov_iter *iter, size_t len,

fs/smb/smbdirect/connection.c

2151

if (WARN_ON_ONCE(iov_iter_rw(iter) != ITER_SOURCE))

fs/smb/smbdirect/connection.c

2154

switch (iov_iter_type(iter)) {

fs/smb/smbdirect/connection.c

2156

ret = smbdirect_map_sges_from_bvec(iter, state, len);

fs/smb/smbdirect/connection.c

2159

ret = smbdirect_map_sges_from_kvec(iter, state, len);

fs/smb/smbdirect/connection.c

2162

ret = smbdirect_map_sges_from_folioq(iter, state, len);

fs/smb/smbdirect/connection.c

2165

WARN_ONCE(1, "iov_iter_type[%u]\n", iov_iter_type(iter));

fs/smb/smbdirect/devices.c

220

struct list_head *iter;

fs/smb/smbdirect/devices.c

229

netdev_for_each_lower_dev(netdev, lower_dev, iter) {

fs/smb/smbdirect/mr.c

241

static int smbdirect_iter_to_sgt(struct iov_iter *iter,

fs/smb/smbdirect/mr.c

249

ret = extract_iter_to_sg(iter, iov_iter_count(iter), sgt, max_sg, 0);

fs/smb/smbdirect/mr.c

266

struct iov_iter *iter,

fs/smb/smbdirect/mr.c

275

num_pages = iov_iter_npages(iter, sp->max_frmr_depth + 1);

fs/smb/smbdirect/mr.c

300

num_pages, iov_iter_count(iter), sp->max_frmr_depth);

fs/smb/smbdirect/mr.c

301

smbdirect_iter_to_sgt(iter, &mr->sgt, sp->max_frmr_depth);

fs/splice.c

1501

static ssize_t vmsplice_to_user(struct file *file, struct iov_iter *iter,

fs/splice.c

1506

.total_len = iov_iter_count(iter),

fs/splice.c

1508

.u.data = iter

fs/splice.c

1534

static ssize_t vmsplice_to_pipe(struct file *file, struct iov_iter *iter,

fs/splice.c

1553

ret = iter_to_pipe(iter, pipe, buf_flag);

fs/splice.c

1583

struct iov_iter iter;

fs/splice.c

1601

ARRAY_SIZE(iovstack), &iov, &iter);

fs/splice.c

1605

if (!iov_iter_count(&iter))

fs/splice.c

1608

error = vmsplice_to_pipe(fd_file(f), &iter, flags);

fs/splice.c

1610

error = vmsplice_to_user(fd_file(f), &iter, flags);

fs/udf/dir.c

101

if (iter.fi.fileCharacteristics & FID_FILE_CHAR_PARENT) {

fs/udf/dir.c

107

flen = udf_get_filename(sb, iter.name,

fs/udf/dir.c

108

iter.fi.lengthFileIdent, fname, UDF_NAME_LEN);

fs/udf/dir.c

112

tloc = lelb_to_cpu(iter.fi.icb.extLocation);

fs/udf/dir.c

119

ctx->pos = (iter.pos >> 2) + 1;

fs/udf/dir.c

123

udf_fiiter_release(&iter);

fs/udf/dir.c

45

struct udf_fileident_iter iter;

fs/udf/dir.c

77

for (ret = udf_fiiter_init(&iter, dir, nf_pos);

fs/udf/dir.c

78

!ret && iter.pos < dir->i_size;

fs/udf/dir.c

79

ret = udf_fiiter_advance(&iter)) {

fs/udf/dir.c

84

if (iter.pos < emit_pos)

fs/udf/dir.c

89

ctx->pos = (iter.pos >> 2) + 1;

fs/udf/dir.c

91

if (iter.fi.fileCharacteristics & FID_FILE_CHAR_DELETED) {

fs/udf/dir.c

96

if (iter.fi.fileCharacteristics & FID_FILE_CHAR_HIDDEN) {

fs/udf/directory.c

101

memcpy((char *)(&iter->fi) + len, iter->bh[1]->b_data,

fs/udf/directory.c

103

err = udf_verify_fi(iter);

fs/udf/directory.c

109

le16_to_cpu(iter->fi.lengthOfImpUse);

fs/udf/directory.c

110

if (off + udf_dir_entry_len(&iter->fi) <= blksize) {

fs/udf/directory.c

111

iter->name = iter->bh[0]->b_data + nameoff;

fs/udf/directory.c

113

iter->name = iter->bh[1]->b_data + (nameoff - blksize);

fs/udf/directory.c

115

iter->name = iter->namebuf;

fs/udf/directory.c

117

memcpy(iter->name, iter->bh[0]->b_data + nameoff, len);

fs/udf/directory.c

118

memcpy(iter->name + len, iter->bh[1]->b_data,

fs/udf/directory.c

119

iter->fi.lengthFileIdent - len);

fs/udf/directory.c

125

static void udf_readahead_dir(struct udf_fileident_iter *iter)

fs/udf/directory.c

127

unsigned int ralen = 16 >> (iter->dir->i_blkbits - 9);

fs/udf/directory.c

132

if (iter->loffset & (ralen - 1))

fs/udf/directory.c

135

if (iter->loffset + ralen > (iter->elen >> iter->dir->i_blkbits))

fs/udf/directory.c

136

ralen = (iter->elen >> iter->dir->i_blkbits) - iter->loffset;

fs/udf/directory.c

139

blk = udf_get_lb_pblock(iter->dir->i_sb, &iter->eloc,

fs/udf/directory.c

140

iter->loffset + i);

fs/udf/directory.c

141

tmp = sb_getblk(iter->dir->i_sb, blk);

fs/udf/directory.c

154

static struct buffer_head *udf_fiiter_bread_blk(struct udf_fileident_iter *iter)

fs/udf/directory.c

158

udf_readahead_dir(iter);

fs/udf/directory.c

159

blk = udf_get_lb_pblock(iter->dir->i_sb, &iter->eloc, iter->loffset);

fs/udf/directory.c

160

return sb_bread(iter->dir->i_sb, blk);

fs/udf/directory.c

167

static int udf_fiiter_advance_blk(struct udf_fileident_iter *iter)

fs/udf/directory.c

172

iter->loffset++;

fs/udf/directory.c

173

if (iter->loffset < DIV_ROUND_UP(iter->elen, 1<<iter->dir->i_blkbits))

fs/udf/directory.c

176

iter->loffset = 0;

fs/udf/directory.c

177

err = udf_next_aext(iter->dir, &iter->epos, &iter->eloc,

fs/udf/directory.c

178

&iter->elen, &etype, 1);

fs/udf/directory.c

182

if (iter->pos == iter->dir->i_size) {

fs/udf/directory.c

183

iter->elen = 0;

fs/udf/directory.c

186

udf_err(iter->dir->i_sb,

fs/udf/directory.c

188

(unsigned long long)iter->pos, iter->dir->i_ino);

fs/udf/directory.c

19

static int udf_verify_fi(struct udf_fileident_iter *iter)

fs/udf/directory.c

194

static int udf_fiiter_load_bhs(struct udf_fileident_iter *iter)

fs/udf/directory.c

196

int blksize = 1 << iter->dir->i_blkbits;

fs/udf/directory.c

197

int off = iter->pos & (blksize - 1);

fs/udf/directory.c

202

if (!iter->bh[0] && iter->elen) {

fs/udf/directory.c

203

iter->bh[0] = udf_fiiter_bread_blk(iter);

fs/udf/directory.c

204

if (!iter->bh[0]) {

fs/udf/directory.c

208

if (!buffer_uptodate(iter->bh[0])) {

fs/udf/directory.c

214

if (iter->pos >= iter->dir->i_size)

fs/udf/directory.c

219

fi = (struct fileIdentDesc *)(iter->bh[0]->b_data + off);

fs/udf/directory.c

223

err = udf_fiiter_advance_blk(iter);

fs/udf/directory.c

226

iter->bh[1] = udf_fiiter_bread_blk(iter);

fs/udf/directory.c

227

if (!iter->bh[1]) {

fs/udf/directory.c

23

if (iter->fi.descTag.tagIdent != cpu_to_le16(TAG_IDENT_FID)) {

fs/udf/directory.c

231

if (!buffer_uptodate(iter->bh[1])) {

fs/udf/directory.c

238

brelse(iter->bh[0]);

fs/udf/directory.c

239

brelse(iter->bh[1]);

fs/udf/directory.c

24

udf_err(iter->dir->i_sb,

fs/udf/directory.c

240

iter->bh[0] = iter->bh[1] = NULL;

fs/udf/directory.c

244

int udf_fiiter_init(struct udf_fileident_iter *iter, struct inode *dir,

fs/udf/directory.c

251

iter->dir = dir;

fs/udf/directory.c

252

iter->bh[0] = iter->bh[1] = NULL;

fs/udf/directory.c

253

iter->pos = pos;

fs/udf/directory.c

254

iter->elen = 0;

fs/udf/directory.c

255

iter->epos.bh = NULL;

fs/udf/directory.c

256

iter->name = NULL;

fs/udf/directory.c

26

iter->dir->i_ino, (unsigned long long)iter->pos,

fs/udf/directory.c

262

iter->namebuf = kmalloc(UDF_NAME_LEN_CS0, GFP_KERNEL | __GFP_NOFAIL);

fs/udf/directory.c

265

err = udf_copy_fi(iter);

fs/udf/directory.c

269

err = inode_bmap(dir, iter->pos >> dir->i_blkbits, &iter->epos,

fs/udf/directory.c

27

le16_to_cpu(iter->fi.descTag.tagIdent));

fs/udf/directory.c

270

&iter->eloc, &iter->elen, &iter->loffset, &etype);

fs/udf/directory.c

280

err = udf_fiiter_load_bhs(iter);

fs/udf/directory.c

283

err = udf_copy_fi(iter);

fs/udf/directory.c

286

udf_fiiter_release(iter);

fs/udf/directory.c

290

int udf_fiiter_advance(struct udf_fileident_iter *iter)

fs/udf/directory.c

293

int blksize = 1 << iter->dir->i_blkbits;

fs/udf/directory.c

296

oldoff = iter->pos & (blksize - 1);

fs/udf/directory.c

297

len = udf_dir_entry_len(&iter->fi);

fs/udf/directory.c

298

iter->pos += len;

fs/udf/directory.c

299

if (UDF_I(iter->dir)->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) {

fs/udf/directory.c

30

len = udf_dir_entry_len(&iter->fi);

fs/udf/directory.c

301

brelse(iter->bh[0]);

fs/udf/directory.c

302

iter->bh[0] = NULL;

fs/udf/directory.c

304

if (iter->bh[1]) {

fs/udf/directory.c

305

iter->bh[0] = iter->bh[1];

fs/udf/directory.c

306

iter->bh[1] = NULL;

fs/udf/directory.c

308

err = udf_fiiter_advance_blk(iter);

fs/udf/directory.c

31

if (le16_to_cpu(iter->fi.lengthOfImpUse) & 3) {

fs/udf/directory.c

313

err = udf_fiiter_load_bhs(iter);

fs/udf/directory.c

317

return udf_copy_fi(iter);

fs/udf/directory.c

32

udf_err(iter->dir->i_sb,

fs/udf/directory.c

320

void udf_fiiter_release(struct udf_fileident_iter *iter)

fs/udf/directory.c

322

iter->dir = NULL;

fs/udf/directory.c

323

brelse(iter->bh[0]);

fs/udf/directory.c

324

brelse(iter->bh[1]);

fs/udf/directory.c

325

iter->bh[0] = iter->bh[1] = NULL;

fs/udf/directory.c

326

kfree(iter->namebuf);

fs/udf/directory.c

327

iter->namebuf = NULL;

fs/udf/directory.c

34

iter->dir->i_ino, (unsigned long long)iter->pos);

fs/udf/directory.c

407

void udf_fiiter_write_fi(struct udf_fileident_iter *iter, uint8_t *impuse)

fs/udf/directory.c

409

struct udf_inode_info *iinfo = UDF_I(iter->dir);

fs/udf/directory.c

412

int blksize = 1 << iter->dir->i_blkbits;

fs/udf/directory.c

414

off = iter->pos & (blksize - 1);

fs/udf/directory.c

417

len1 = iter->dir->i_size;

fs/udf/directory.c

419

buf1 = iter->bh[0]->b_data;

fs/udf/directory.c

42

if (len > 1 << iter->dir->i_blkbits) {

fs/udf/directory.c

421

if (iter->bh[1]) {

fs/udf/directory.c

422

buf2 = iter->bh[1]->b_data;

fs/udf/directory.c

427

udf_copy_fi_to_bufs(buf1, len1, buf2, len2, off, &iter->fi, impuse,

fs/udf/directory.c

428

iter->name == iter->namebuf ? iter->name : NULL);

fs/udf/directory.c

43

udf_err(iter->dir->i_sb,

fs/udf/directory.c

431

mark_inode_dirty(iter->dir);

fs/udf/directory.c

433

mmb_mark_buffer_dirty(iter->bh[0], &iinfo->i_metadata_bhs);

fs/udf/directory.c

434

if (iter->bh[1])

fs/udf/directory.c

435

mmb_mark_buffer_dirty(iter->bh[1],

fs/udf/directory.c

438

inode_inc_iversion(iter->dir);

fs/udf/directory.c

441

void udf_fiiter_update_elen(struct udf_fileident_iter *iter, uint32_t new_elen)

fs/udf/directory.c

443

struct udf_inode_info *iinfo = UDF_I(iter->dir);

fs/udf/directory.c

444

int diff = new_elen - iter->elen;

fs/udf/directory.c

447

if (!iter->elen)

fs/udf/directory.c

449

iter->elen = new_elen;

fs/udf/directory.c

45

iter->dir->i_ino, len, (unsigned long long)iter->pos);

fs/udf/directory.c

451

iter->epos.offset -= sizeof(struct short_ad);

fs/udf/directory.c

453

iter->epos.offset -= sizeof(struct long_ad);

fs/udf/directory.c

454

udf_write_aext(iter->dir, &iter->epos, &iter->eloc, iter->elen, 1);

fs/udf/directory.c

456

mark_inode_dirty(iter->dir);

fs/udf/directory.c

460

int udf_fiiter_append_blk(struct udf_fileident_iter *iter)

fs/udf/directory.c

462

struct udf_inode_info *iinfo = UDF_I(iter->dir);

fs/udf/directory.c

463

int blksize = 1 << iter->dir->i_blkbits;

fs/udf/directory.c

466

uint32_t old_elen = iter->elen;

fs/udf/directory.c

474

udf_fiiter_update_elen(iter, ALIGN(iter->elen, blksize));

fs/udf/directory.c

477

block = iinfo->i_lenExtents >> iter->dir->i_blkbits;

fs/udf/directory.c

478

bh = udf_bread(iter->dir, block, 1, &err);

fs/udf/directory.c

48

if (iter->pos + len > iter->dir->i_size) {

fs/udf/directory.c

480

udf_fiiter_update_elen(iter, old_elen);

fs/udf/directory.c

483

err = inode_bmap(iter->dir, block, &iter->epos, &iter->eloc, &iter->elen,

fs/udf/directory.c

484

&iter->loffset, &etype);

fs/udf/directory.c

486

udf_err(iter->dir->i_sb,

fs/udf/directory.c

488

(unsigned long long)block, iter->dir->i_ino);

fs/udf/directory.c

49

udf_err(iter->dir->i_sb,

fs/udf/directory.c

491

if (!(iter->pos & (blksize - 1))) {

fs/udf/directory.c

492

brelse(iter->bh[0]);

fs/udf/directory.c

493

iter->bh[0] = bh;

fs/udf/directory.c

495

iter->bh[1] = bh;

fs/udf/directory.c

51

iter->dir->i_ino, (unsigned long long)iter->pos);

fs/udf/directory.c

54

if (udf_dir_entry_len(&iter->fi) !=

fs/udf/directory.c

55

sizeof(struct tag) + le16_to_cpu(iter->fi.descTag.descCRCLength)) {

fs/udf/directory.c

56

udf_err(iter->dir->i_sb,

fs/udf/directory.c

58

iter->dir->i_ino,

fs/udf/directory.c

59

(unsigned)le16_to_cpu(iter->fi.descTag.descCRCLength),

fs/udf/directory.c

60

(unsigned)(udf_dir_entry_len(&iter->fi) -

fs/udf/directory.c

67

static int udf_copy_fi(struct udf_fileident_iter *iter)

fs/udf/directory.c

69

struct udf_inode_info *iinfo = UDF_I(iter->dir);

fs/udf/directory.c

70

u32 blksize = 1 << iter->dir->i_blkbits;

fs/udf/directory.c

75

if (iter->pos >= iter->dir->i_size) {

fs/udf/directory.c

76

iter->name = NULL;

fs/udf/directory.c

79

if (iter->dir->i_size < iter->pos + sizeof(struct fileIdentDesc)) {

fs/udf/directory.c

80

udf_err(iter->dir->i_sb,

fs/udf/directory.c

82

iter->dir->i_ino);

fs/udf/directory.c

86

memcpy(&iter->fi, iinfo->i_data + iinfo->i_lenEAttr + iter->pos,

fs/udf/directory.c

88

err = udf_verify_fi(iter);

fs/udf/directory.c

91

iter->name = iinfo->i_data + iinfo->i_lenEAttr + iter->pos +

fs/udf/directory.c

93

le16_to_cpu(iter->fi.lengthOfImpUse);

fs/udf/directory.c

97

off = iter->pos & (blksize - 1);

fs/udf/directory.c

99

memcpy(&iter->fi, iter->bh[0]->b_data + off, len);

fs/udf/inode.c

300

static ssize_t udf_direct_IO(struct kiocb *iocb, struct iov_iter *iter)

fs/udf/inode.c

305

size_t count = iov_iter_count(iter);

fs/udf/inode.c

311

ret = blockdev_direct_IO(iocb, inode, iter, udf_get_block);

fs/udf/inode.c

312

if (unlikely(ret < 0 && iov_iter_rw(iter) == WRITE))

fs/udf/namei.c

100

udf_fiiter_release(iter);

fs/udf/namei.c

111

struct udf_fileident_iter iter;

fs/udf/namei.c

117

err = udf_fiiter_find_entry(dir, &dentry->d_name, &iter);

fs/udf/namei.c

124

loc = lelb_to_cpu(iter.fi.icb.extLocation);

fs/udf/namei.c

125

udf_fiiter_release(&iter);

fs/udf/namei.c

141

struct udf_fileident_iter iter;

fs/udf/namei.c

198

for (ret = udf_fiiter_init(&iter, inode, 0);

fs/udf/namei.c

199

!ret && iter.pos < inode->i_size;

fs/udf/namei.c

200

ret = udf_fiiter_advance(&iter)) {

fs/udf/namei.c

201

iter.fi.descTag.tagLocation = cpu_to_le32(*block);

fs/udf/namei.c

202

if (iter.fi.lengthOfImpUse != cpu_to_le16(0))

fs/udf/namei.c

203

impuse = dbh->b_data + iter.pos +

fs/udf/namei.c

207

udf_fiiter_write_fi(&iter, impuse);

fs/udf/namei.c

215

udf_fiiter_release(&iter);

fs/udf/namei.c

221

struct udf_fileident_iter *iter)

fs/udf/namei.c

239

for (ret = udf_fiiter_init(iter, dir, 0);

fs/udf/namei.c

240

!ret && iter->pos < dir->i_size;

fs/udf/namei.c

241

ret = udf_fiiter_advance(iter)) {

fs/udf/namei.c

242

if (iter->fi.fileCharacteristics & FID_FILE_CHAR_DELETED) {

fs/udf/namei.c

243

if (udf_dir_entry_len(&iter->fi) == nfidlen) {

fs/udf/namei.c

244

iter->fi.descTag.tagSerialNum = cpu_to_le16(1);

fs/udf/namei.c

245

iter->fi.fileVersionNum = cpu_to_le16(1);

fs/udf/namei.c

246

iter->fi.fileCharacteristics = 0;

fs/udf/namei.c

247

iter->fi.lengthFileIdent = namelen;

fs/udf/namei.c

248

iter->fi.lengthOfImpUse = cpu_to_le16(0);

fs/udf/namei.c

249

memcpy(iter->namebuf, name, namelen);

fs/udf/namei.c

250

iter->name = iter->namebuf;

fs/udf/namei.c

256

udf_fiiter_release(iter);

fs/udf/namei.c

260

blksize - udf_ext0_offset(dir) - iter->pos < nfidlen) {

fs/udf/namei.c

261

udf_fiiter_release(iter);

fs/udf/namei.c

265

ret = udf_fiiter_init(iter, dir, dir->i_size);

fs/udf/namei.c

274

block = iter->eloc.logicalBlockNum +

fs/udf/namei.c

275

((iter->elen - 1) >> dir->i_blkbits);

fs/udf/namei.c

277

off = iter->pos & (blksize - 1);

fs/udf/namei.c

284

ret = udf_fiiter_append_blk(iter);

fs/udf/namei.c

286

udf_fiiter_release(iter);

fs/udf/namei.c

291

if (!(iter->pos & (blksize - 1)))

fs/udf/namei.c

292

block = iter->eloc.logicalBlockNum +

fs/udf/namei.c

293

((iter->elen - 1) >> dir->i_blkbits);

fs/udf/namei.c

295

memset(&iter->fi, 0, sizeof(struct fileIdentDesc));

fs/udf/namei.c

297

udf_new_tag((char *)(&iter->fi), TAG_IDENT_FID, 3, 1, block,

fs/udf/namei.c

300

udf_new_tag((char *)(&iter->fi), TAG_IDENT_FID, 2, 1, block,

fs/udf/namei.c

302

iter->fi.fileVersionNum = cpu_to_le16(1);

fs/udf/namei.c

303

iter->fi.lengthFileIdent = namelen;

fs/udf/namei.c

304

iter->fi.lengthOfImpUse = cpu_to_le16(0);

fs/udf/namei.c

305

memcpy(iter->namebuf, name, namelen);

fs/udf/namei.c

306

iter->name = iter->namebuf;

fs/udf/namei.c

313

udf_fiiter_update_elen(iter, iter->elen -

fs/udf/namei.c

321

static void udf_fiiter_delete_entry(struct udf_fileident_iter *iter)

fs/udf/namei.c

323

iter->fi.fileCharacteristics |= FID_FILE_CHAR_DELETED;

fs/udf/namei.c

325

if (UDF_QUERY_FLAG(iter->dir->i_sb, UDF_FLAG_STRICT))

fs/udf/namei.c

326

memset(&iter->fi.icb, 0x00, sizeof(struct long_ad));

fs/udf/namei.c

328

udf_fiiter_write_fi(iter, NULL);

fs/udf/namei.c

350

struct udf_fileident_iter iter;

fs/udf/namei.c

353

err = udf_fiiter_add_entry(dir, dentry, &iter);

fs/udf/namei.c

359

iter.fi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);

fs/udf/namei.c

360

iter.fi.icb.extLocation = cpu_to_lelb(iinfo->i_location);

fs/udf/namei.c

361

*(__le32 *)((struct allocDescImpUse *)iter.fi.icb.impUse)->impUse =

fs/udf/namei.c

363

udf_fiiter_write_fi(&iter, NULL);

fs/udf/namei.c

366

udf_fiiter_release(&iter);

fs/udf/namei.c

426

struct udf_fileident_iter iter;

fs/udf/namei.c

438

err = udf_fiiter_add_entry(inode, NULL, &iter);

fs/udf/namei.c

445

iter.fi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);

fs/udf/namei.c

446

iter.fi.icb.extLocation = cpu_to_lelb(dinfo->i_location);

fs/udf/namei.c

447

*(__le32 *)((struct allocDescImpUse *)iter.fi.icb.impUse)->impUse =

fs/udf/namei.c

449

iter.fi.fileCharacteristics =

fs/udf/namei.c

451

udf_fiiter_write_fi(&iter, NULL);

fs/udf/namei.c

452

udf_fiiter_release(&iter);

fs/udf/namei.c

455

err = udf_fiiter_add_entry(dir, dentry, &iter);

fs/udf/namei.c

461

iter.fi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);

fs/udf/namei.c

462

iter.fi.icb.extLocation = cpu_to_lelb(iinfo->i_location);

fs/udf/namei.c

463

*(__le32 *)((struct allocDescImpUse *)iter.fi.icb.impUse)->impUse =

fs/udf/namei.c

465

iter.fi.fileCharacteristics |= FID_FILE_CHAR_DIRECTORY;

fs/udf/namei.c

466

udf_fiiter_write_fi(&iter, NULL);

fs/udf/namei.c

467

udf_fiiter_release(&iter);

fs/udf/namei.c

479

struct udf_fileident_iter iter;

fs/udf/namei.c

482

for (ret = udf_fiiter_init(&iter, dir, 0);

fs/udf/namei.c

483

!ret && iter.pos < dir->i_size;

fs/udf/namei.c

484

ret = udf_fiiter_advance(&iter)) {

fs/udf/namei.c

485

if (iter.fi.lengthFileIdent &&

fs/udf/namei.c

486

!(iter.fi.fileCharacteristics & FID_FILE_CHAR_DELETED)) {

fs/udf/namei.c

487

udf_fiiter_release(&iter);

fs/udf/namei.c

491

udf_fiiter_release(&iter);

fs/udf/namei.c

500

struct udf_fileident_iter iter;

fs/udf/namei.c

503

ret = udf_fiiter_find_entry(dir, &dentry->d_name, &iter);

fs/udf/namei.c

508

tloc = lelb_to_cpu(iter.fi.icb.extLocation);

fs/udf/namei.c

514

udf_fiiter_delete_entry(&iter);

fs/udf/namei.c

53

struct udf_fileident_iter *iter)

fs/udf/namei.c

531

udf_fiiter_release(&iter);

fs/udf/namei.c

540

struct udf_fileident_iter iter;

fs/udf/namei.c

543

ret = udf_fiiter_find_entry(dir, &dentry->d_name, &iter);

fs/udf/namei.c

548

tloc = lelb_to_cpu(iter.fi.icb.extLocation);

fs/udf/namei.c

557

udf_fiiter_delete_entry(&iter);

fs/udf/namei.c

565

udf_fiiter_release(&iter);

fs/udf/namei.c

66

for (ret = udf_fiiter_init(iter, dir, 0);

fs/udf/namei.c

67

!ret && iter->pos < dir->i_size;

fs/udf/namei.c

68

ret = udf_fiiter_advance(iter)) {

fs/udf/namei.c

69

if (iter->fi.fileCharacteristics & FID_FILE_CHAR_DELETED) {

fs/udf/namei.c

735

struct udf_fileident_iter iter;

fs/udf/namei.c

738

err = udf_fiiter_add_entry(dir, dentry, &iter);

fs/udf/namei.c

74

if (iter->fi.fileCharacteristics & FID_FILE_CHAR_HIDDEN) {

fs/udf/namei.c

741

iter.fi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);

fs/udf/namei.c

742

iter.fi.icb.extLocation = cpu_to_lelb(UDF_I(inode)->i_location);

fs/udf/namei.c

744

*(__le32 *)((struct allocDescImpUse *)iter.fi.icb.impUse)->impUse =

fs/udf/namei.c

747

udf_fiiter_write_fi(&iter, NULL);

fs/udf/namei.c

748

udf_fiiter_release(&iter);

fs/udf/namei.c

79

if ((iter->fi.fileCharacteristics & FID_FILE_CHAR_PARENT) &&

fs/udf/namei.c

83

if (!iter->fi.lengthFileIdent)

fs/udf/namei.c

86

flen = udf_get_filename(sb, iter->name,

fs/udf/namei.c

87

iter->fi.lengthFileIdent, fname, UDF_NAME_LEN);

fs/udf/namei.c

918

struct udf_fileident_iter iter;

fs/udf/namei.c

921

err = udf_fiiter_find_entry(d_inode(child), &dotdot_name, &iter);

fs/udf/namei.c

925

tloc = lelb_to_cpu(iter.fi.icb.extLocation);

fs/udf/namei.c

926

udf_fiiter_release(&iter);

fs/udf/udfdecl.h

246

int udf_fiiter_init(struct udf_fileident_iter *iter, struct inode *dir,

fs/udf/udfdecl.h

248

int udf_fiiter_advance(struct udf_fileident_iter *iter);

fs/udf/udfdecl.h

249

void udf_fiiter_release(struct udf_fileident_iter *iter);

fs/udf/udfdecl.h

250

void udf_fiiter_write_fi(struct udf_fileident_iter *iter, uint8_t *impuse);

fs/udf/udfdecl.h

251

void udf_fiiter_update_elen(struct udf_fileident_iter *iter, uint32_t new_elen);

fs/udf/udfdecl.h

252

int udf_fiiter_append_blk(struct udf_fileident_iter *iter);

fs/xfs/xfs_aops.c

760

const struct iomap_iter *iter,

fs/xfs/xfs_aops.c

766

iomap_init_ioend(iter->inode, bio, ctx->read_ctx_file_offset, 0);

fs/xfs/xfs_aops.c

767

iomap_bio_submit_read_endio(iter, ctx, xfs_end_bio);

fs/xfs/xfs_file.c

234

const struct iomap_iter *iter,

fs/xfs/xfs_file.c

238

iomap_init_ioend(iter->inode, bio, file_offset, IOMAP_IOEND_DIRECT);

fs/xfs/xfs_file.c

705

const struct iomap_iter *iter,

fs/xfs/xfs_file.c

709

struct xfs_mount *mp = XFS_I(iter->inode)->i_mount;

fs/xfs/xfs_file.c

710

struct xfs_zone_alloc_ctx *ac = iter->private;

fs/xfs/xfs_file.c

726

ioend = iomap_init_ioend(iter->inode, bio, file_offset,

fs/xfs/xfs_iomap.c

1594

struct iomap_iter *iter =

fs/xfs/xfs_iomap.c

1597

struct xfs_zone_alloc_ctx *ac = iter->private;

fs/xfs/xfs_iomap.c

1785

struct iomap_iter *iter = container_of(iomap, struct iomap_iter,

fs/xfs/xfs_iomap.c

1903

fbatch_count = iomap_fill_dirty_folios(iter, &start, end,

fs/xfs/xfs_iomap.c

1949

iomap_fill_dirty_folios(iter, &foffset, fend,

fs/xfs/xfs_iomap.c

2118

struct iomap_iter *iter =

fs/xfs/xfs_iomap.c

2124

offset, offset + length, iter->private);

fs/xfs/xfs_trace.h

1752

TP_PROTO(struct kiocb *iocb, struct iov_iter *iter),

fs/xfs/xfs_trace.h

1753

TP_ARGS(iocb, iter),

fs/xfs/xfs_trace.h

1766

__entry->count = iov_iter_count(iter);

fs/xfs/xfs_trace.h

1778

TP_PROTO(struct kiocb *iocb, struct iov_iter *iter), \

fs/xfs/xfs_trace.h

1779

TP_ARGS(iocb, iter))

fs/xfs/xfs_zone_gc.c

1137

if (data->iter.victim_rtg)

fs/xfs/xfs_zone_gc.c

1138

xfs_rtgroup_rele(data->iter.victim_rtg);

fs/xfs/xfs_zone_gc.c

158

struct xfs_zone_gc_iter iter;

fs/xfs/xfs_zone_gc.c

217

data->iter.recs = kzalloc_objs(*data->iter.recs, XFS_ZONE_GC_RECS);

fs/xfs/xfs_zone_gc.c

218

if (!data->iter.recs)

fs/xfs/xfs_zone_gc.c

243

kfree(data->iter.recs);

fs/xfs/xfs_zone_gc.c

258

kfree(data->iter.recs);

fs/xfs/xfs_zone_gc.c

264

struct xfs_zone_gc_iter *iter,

fs/xfs/xfs_zone_gc.c

268

iter->next_startblock = 0;

fs/xfs/xfs_zone_gc.c

269

iter->rec_count = 0;

fs/xfs/xfs_zone_gc.c

270

iter->rec_idx = 0;

fs/xfs/xfs_zone_gc.c

271

iter->victim_rtg = victim_rtg;

fs/xfs/xfs_zone_gc.c

284

struct xfs_zone_gc_iter *iter = private;

fs/xfs/xfs_zone_gc.c

290

iter->recs[iter->rec_count] = *irec;

fs/xfs/xfs_zone_gc.c

291

if (++iter->rec_count == XFS_ZONE_GC_RECS) {

fs/xfs/xfs_zone_gc.c

292

iter->next_startblock =

fs/xfs/xfs_zone_gc.c

317

struct xfs_zone_gc_iter *iter)

fs/xfs/xfs_zone_gc.c

319

struct xfs_rtgroup *rtg = iter->victim_rtg;

fs/xfs/xfs_zone_gc.c

326

ASSERT(iter->next_startblock <= rtg_blocks(rtg));

fs/xfs/xfs_zone_gc.c

327

if (iter->next_startblock == rtg_blocks(rtg))

fs/xfs/xfs_zone_gc.c

330

ASSERT(iter->next_startblock < rtg_blocks(rtg));

fs/xfs/xfs_zone_gc.c

331

ri_low.rm_startblock = iter->next_startblock;

fs/xfs/xfs_zone_gc.c

334

iter->rec_idx = 0;

fs/xfs/xfs_zone_gc.c

335

iter->rec_count = 0;

fs/xfs/xfs_zone_gc.c

341

xfs_zone_gc_query_cb, iter);

fs/xfs/xfs_zone_gc.c

357

sort(iter->recs, iter->rec_count, sizeof(iter->recs[0]),

fs/xfs/xfs_zone_gc.c

364

iter->next_startblock = rtg_blocks(rtg);

fs/xfs/xfs_zone_gc.c

365

if (iter->rec_count == 0)

fs/xfs/xfs_zone_gc.c

371

atomic_dec(&iter->victim_rtg->rtg_gccount);

fs/xfs/xfs_zone_gc.c

372

xfs_rtgroup_rele(iter->victim_rtg);

fs/xfs/xfs_zone_gc.c

373

iter->victim_rtg = NULL;

fs/xfs/xfs_zone_gc.c

380

struct xfs_zone_gc_iter *iter,

fs/xfs/xfs_zone_gc.c

388

if (iter->rec_idx == iter->rec_count) {

fs/xfs/xfs_zone_gc.c

389

error = xfs_zone_gc_query(mp, iter);

fs/xfs/xfs_zone_gc.c

392

if (!iter->victim_rtg)

fs/xfs/xfs_zone_gc.c

396

irec = &iter->recs[iter->rec_idx];

fs/xfs/xfs_zone_gc.c

404

iter->rec_idx++;

fs/xfs/xfs_zone_gc.c

411

iter->rec_idx++;

fs/xfs/xfs_zone_gc.c

426

struct xfs_zone_gc_iter *iter,

fs/xfs/xfs_zone_gc.c

429

struct xfs_rmap_irec *irec = &iter->recs[iter->rec_idx];

fs/xfs/xfs_zone_gc.c

435

iter->rec_idx++;

fs/xfs/xfs_zone_gc.c

506

struct xfs_zone_gc_iter *iter = &data->iter;

fs/xfs/xfs_zone_gc.c

524

xfs_zone_gc_iter_init(iter, victim_rtg);

fs/xfs/xfs_zone_gc.c

685

if (!data->iter.victim_rtg) {

fs/xfs/xfs_zone_gc.c

701

struct xfs_zone_gc_iter *iter = &data->iter;

fs/xfs/xfs_zone_gc.c

715

if (!xfs_zone_gc_iter_irec(mp, iter, &irec, &ip))

fs/xfs/xfs_zone_gc.c

735

xfs_rgbno_to_rtb(iter->victim_rtg, irec.rm_startblock);

fs/xfs/xfs_zone_gc.c

740

chunk->victim_rtg = iter->victim_rtg;

fs/xfs/xfs_zone_gc.c

755

xfs_zone_gc_iter_advance(iter, irec.rm_blockcount);

include/drm/drm_client.h

241

#define drm_client_for_each_connector_iter(connector, iter) \

include/drm/drm_client.h

242

drm_for_each_connector_iter(connector, iter) \

include/drm/drm_connector.h

2642

struct drm_connector_list_iter *iter);

include/drm/drm_connector.h

2644

drm_connector_list_iter_next(struct drm_connector_list_iter *iter);

include/drm/drm_connector.h

2645

void drm_connector_list_iter_end(struct drm_connector_list_iter *iter);

include/drm/drm_connector.h

2660

#define drm_for_each_connector_iter(connector, iter) \

include/drm/drm_connector.h

2661

while ((connector = drm_connector_list_iter_next(iter)))

include/drm/drm_damage_helper.h

46

#define drm_atomic_for_each_plane_damage(iter, rect) \

include/drm/drm_damage_helper.h

47

while (drm_atomic_helper_damage_iter_next(iter, rect))

include/drm/drm_damage_helper.h

74

drm_atomic_helper_damage_iter_init(struct drm_atomic_helper_damage_iter *iter,

include/drm/drm_damage_helper.h

78

drm_atomic_helper_damage_iter_next(struct drm_atomic_helper_damage_iter *iter,

include/drm/drm_print.h

333

drm_coredump_printer(struct drm_print_iterator *iter)

include/drm/drm_print.h

338

.arg = iter,

include/drm/drm_print.h

342

iter->offset = 0;

include/drm/gpu_scheduler.h

718

struct drm_sched_pending_job_iter iter = {

include/drm/gpu_scheduler.h

723

return iter;

include/drm/gpu_scheduler.h

728

__drm_sched_pending_job_iter_end(const struct drm_sched_pending_job_iter iter)

include/drm/gpu_scheduler.h

730

WARN_ON(!drm_sched_is_stopped(iter.sched));

include/linux/backing-file.h

27

ssize_t backing_file_read_iter(struct file *file, struct iov_iter *iter,

include/linux/backing-file.h

30

ssize_t backing_file_write_iter(struct file *file, struct iov_iter *iter,

include/linux/bio-integrity.h

36

#define bip_for_each_vec(bvl, bip, iter) \

include/linux/bio-integrity.h

37

for_each_bvec(bvl, (bip)->bip_vec, iter, (bip)->bip_iter)

include/linux/bio-integrity.h

78

int bio_integrity_map_user(struct bio *bio, struct iov_iter *iter);

include/linux/bio-integrity.h

93

static inline int bio_integrity_map_user(struct bio *bio, struct iov_iter *iter)

include/linux/bio.h

100

bvec_advance(&bio->bi_io_vec[iter->idx], iter);

include/linux/bio.h

108

#define bio_for_each_segment_all(bvl, bio, iter) \

include/linux/bio.h

109

for (bvl = bvec_init_iter_all(&iter); bio_next_segment((bio), &iter); )

include/linux/bio.h

112

struct bvec_iter *iter, unsigned int bytes)

include/linux/bio.h

114

iter->bi_sector += bytes >> 9;

include/linux/bio.h

117

iter->bi_size -= bytes;

include/linux/bio.h

119

bvec_iter_advance(bio->bi_io_vec, iter, bytes);

include/linux/bio.h

125

struct bvec_iter *iter,

include/linux/bio.h

128

iter->bi_sector += bytes >> 9;

include/linux/bio.h

131

iter->bi_size -= bytes;

include/linux/bio.h

133

bvec_iter_advance_single(bio->bi_io_vec, iter, bytes);

include/linux/bio.h

158

#define __bio_for_each_segment(bvl, bio, iter, start) \

include/linux/bio.h

159

for (iter = (start); \

include/linux/bio.h

160

(iter).bi_size && \

include/linux/bio.h

161

((bvl = bio_iter_iovec((bio), (iter))), 1); \

include/linux/bio.h

162

bio_advance_iter_single((bio), &(iter), (bvl).bv_len))

include/linux/bio.h

164

#define bio_for_each_segment(bvl, bio, iter) \

include/linux/bio.h

165

__bio_for_each_segment(bvl, bio, iter, (bio)->bi_iter)

include/linux/bio.h

167

#define __bio_for_each_bvec(bvl, bio, iter, start) \

include/linux/bio.h

168

for (iter = (start); \

include/linux/bio.h

169

(iter).bi_size && \

include/linux/bio.h

170

((bvl = mp_bvec_iter_bvec((bio)->bi_io_vec, (iter))), 1); \

include/linux/bio.h

171

bio_advance_iter_single((bio), &(iter), (bvl).bv_len))

include/linux/bio.h

174

#define bio_for_each_bvec(bvl, bio, iter) \

include/linux/bio.h

175

__bio_for_each_bvec(bvl, bio, iter, (bio)->bi_iter)

include/linux/bio.h

185

#define bio_iter_last(bvec, iter) ((iter).bi_size == (bvec).bv_len)

include/linux/bio.h

191

struct bvec_iter iter;

include/linux/bio.h

207

bio_for_each_segment(bv, bio, iter)

include/linux/bio.h

23

#define bio_iter_iovec(bio, iter) \

include/linux/bio.h

24

bvec_iter_bvec((bio)->bi_io_vec, (iter))

include/linux/bio.h

26

#define bio_iter_page(bio, iter) \

include/linux/bio.h

27

bvec_iter_page((bio)->bi_io_vec, (iter))

include/linux/bio.h

28

#define bio_iter_len(bio, iter) \

include/linux/bio.h

29

bvec_iter_len((bio)->bi_io_vec, (iter))

include/linux/bio.h

30

#define bio_iter_offset(bio, iter) \

include/linux/bio.h

31

bvec_iter_offset((bio)->bi_io_vec, (iter))

include/linux/bio.h

37

#define bvec_iter_sectors(iter) ((iter).bi_size >> 9)

include/linux/bio.h

38

#define bvec_iter_end_sector(iter) ((iter).bi_sector + bvec_iter_sectors((iter)))

include/linux/bio.h

401

static inline int bio_iov_vecs_to_alloc(struct iov_iter *iter, int max_segs)

include/linux/bio.h

403

if (iov_iter_is_bvec(iter))

include/linux/bio.h

405

return iov_iter_npages(iter, max_segs);

include/linux/bio.h

417

bio_iov_bounce_nr_vecs(struct iov_iter *iter, blk_opf_t op)

include/linux/bio.h

427

return iov_iter_npages(iter, BIO_MAX_VECS);

include/linux/bio.h

428

return iov_iter_npages(iter, BIO_MAX_VECS - 1) + 1;

include/linux/bio.h

479

int bio_iov_iter_get_pages(struct bio *bio, struct iov_iter *iter,

include/linux/bio.h

482

void bio_iov_bvec_set(struct bio *bio, const struct iov_iter *iter);

include/linux/bio.h

487

int bio_iov_iter_bounce(struct bio *bio, struct iov_iter *iter, size_t maxlen,

include/linux/bio.h

95

struct bvec_iter_all *iter)

include/linux/bio.h

97

if (iter->idx >= bio->bi_vcnt)

include/linux/blk-integrity.h

128

struct blk_dma_iter *iter)

include/linux/blk-integrity.h

133

struct device *dma_dev, struct blk_dma_iter *iter)

include/linux/blk-integrity.h

39

struct blk_dma_iter *iter);

include/linux/blk-integrity.h

41

struct device *dma_dev, struct blk_dma_iter *iter);

include/linux/blk-mq-dma.h

25

struct blk_map_iter iter;

include/linux/blk-mq-dma.h

29

struct dma_iova_state *state, struct blk_dma_iter *iter);

include/linux/blk-mq-dma.h

31

struct blk_dma_iter *iter);

include/linux/blk-mq-dma.h

9

struct bvec_iter iter;

include/linux/blk-mq.h

1084

struct bvec_iter iter;

include/linux/blk-mq.h

1094

bio_for_each_segment(bvl, _iter.bio, _iter.iter)

include/linux/blk-mq.h

1098

bio_for_each_bvec(bvl, _iter.bio, _iter.iter)

include/linux/blk-mq.h

1102

bio_iter_last(bvec, _iter.iter))

include/linux/bpf_types.h

144

BPF_LINK_TYPE(BPF_LINK_TYPE_ITER, iter)

include/linux/bpf_verifier.h

1483

} iter;

include/linux/bpf_verifier.h

549

#define bpf_for_each_spilled_reg(iter, frame, reg, mask) \

include/linux/bpf_verifier.h

550

for (iter = 0, reg = bpf_get_spilled_reg(iter, frame, mask); \

include/linux/bpf_verifier.h

551

iter < frame->allocated_stack / BPF_REG_SIZE; \

include/linux/bpf_verifier.h

552

iter++, reg = bpf_get_spilled_reg(iter, frame, mask))

include/linux/bpf_verifier.h

555

#define bpf_for_each_spilled_stack_arg(iter, frame, reg) \

include/linux/bpf_verifier.h

556

for (iter = 0, reg = bpf_get_spilled_stack_arg(iter, frame); \

include/linux/bpf_verifier.h

557

iter < frame->out_stack_arg_cnt; \

include/linux/bpf_verifier.h

558

iter++, reg = bpf_get_spilled_stack_arg(iter, frame))

include/linux/bpf_verifier.h

93

} iter;

include/linux/bvec.h

123

__bvec_iter_bvec(const struct bio_vec *bvecs, const struct bvec_iter iter)

include/linux/bvec.h

125

return bvecs + iter.bi_idx;

include/linux/bvec.h

130

mp_bvec_iter_page(const struct bio_vec *bvecs, const struct bvec_iter iter)

include/linux/bvec.h

132

return __bvec_iter_bvec(bvecs, iter)->bv_page;

include/linux/bvec.h

136

mp_bvec_iter_len(const struct bio_vec *bvecs, const struct bvec_iter iter)

include/linux/bvec.h

138

return min(__bvec_iter_bvec(bvecs, iter)->bv_len - iter.bi_bvec_done,

include/linux/bvec.h

139

iter.bi_size);

include/linux/bvec.h

143

mp_bvec_iter_offset(const struct bio_vec *bvecs, const struct bvec_iter iter)

include/linux/bvec.h

145

return __bvec_iter_bvec(bvecs, iter)->bv_offset + iter.bi_bvec_done;

include/linux/bvec.h

149

mp_bvec_iter_page_idx(const struct bio_vec *bvecs, const struct bvec_iter iter)

include/linux/bvec.h

151

return mp_bvec_iter_offset(bvecs, iter) / PAGE_SIZE;

include/linux/bvec.h

155

mp_bvec_iter_bvec(const struct bio_vec *bvecs, const struct bvec_iter iter)

include/linux/bvec.h

158

.bv_page = mp_bvec_iter_page(bvecs, iter),

include/linux/bvec.h

159

.bv_len = mp_bvec_iter_len(bvecs, iter),

include/linux/bvec.h

160

.bv_offset = mp_bvec_iter_offset(bvecs, iter),

include/linux/bvec.h

166

bvec_iter_offset(const struct bio_vec *bvecs, const struct bvec_iter iter)

include/linux/bvec.h

168

return mp_bvec_iter_offset(bvecs, iter) % PAGE_SIZE;

include/linux/bvec.h

172

bvec_iter_len(const struct bio_vec *bvecs, const struct bvec_iter iter)

include/linux/bvec.h

174

return min(mp_bvec_iter_len(bvecs, iter),

include/linux/bvec.h

175

PAGE_SIZE - bvec_iter_offset(bvecs, iter));

include/linux/bvec.h

179

bvec_iter_page(const struct bio_vec *bvecs, const struct bvec_iter iter)

include/linux/bvec.h

181

return mp_bvec_iter_page(bvecs, iter) +

include/linux/bvec.h

182

mp_bvec_iter_page_idx(bvecs, iter);

include/linux/bvec.h

186

bvec_iter_bvec(const struct bio_vec *bvecs, const struct bvec_iter iter)

include/linux/bvec.h

189

.bv_page = bvec_iter_page(bvecs, iter),

include/linux/bvec.h

190

.bv_len = bvec_iter_len(bvecs, iter),

include/linux/bvec.h

191

.bv_offset = bvec_iter_offset(bvecs, iter),

include/linux/bvec.h

196

struct bvec_iter *iter, unsigned bytes)

include/linux/bvec.h

198

unsigned int idx = iter->bi_idx;

include/linux/bvec.h

200

if (WARN_ONCE(bytes > iter->bi_size,

include/linux/bvec.h

202

iter->bi_size = 0;

include/linux/bvec.h

206

iter->bi_size -= bytes;

include/linux/bvec.h

207

bytes += iter->bi_bvec_done;

include/linux/bvec.h

214

iter->bi_idx = idx;

include/linux/bvec.h

215

iter->bi_bvec_done = bytes;

include/linux/bvec.h

224

struct bvec_iter *iter, unsigned int bytes)

include/linux/bvec.h

226

unsigned int done = iter->bi_bvec_done + bytes;

include/linux/bvec.h

228

if (done == bv[iter->bi_idx].bv_len) {

include/linux/bvec.h

230

iter->bi_idx++;

include/linux/bvec.h

232

iter->bi_bvec_done = done;

include/linux/bvec.h

233

iter->bi_size -= bytes;

include/linux/bvec.h

236

#define for_each_bvec(bvl, bio_vec, iter, start) \

include/linux/bvec.h

237

for (iter = (start); \

include/linux/bvec.h

238

(iter).bi_size && \

include/linux/bvec.h

239

((bvl = bvec_iter_bvec((bio_vec), (iter))), 1); \

include/linux/bvec.h

240

bvec_iter_advance_single((bio_vec), &(iter), (bvl).bv_len))

include/linux/bvec.h

242

#define for_each_mp_bvec(bvl, bio_vec, iter, start) \

include/linux/bvec.h

243

for (iter = (start); \

include/linux/bvec.h

244

(iter).bi_size && \

include/linux/bvec.h

245

((bvl = mp_bvec_iter_bvec((bio_vec), (iter))), 1); \

include/linux/bvec.h

246

bvec_iter_advance_single((bio_vec), &(iter), (bvl).bv_len))

include/linux/ceph/messenger.h

134

struct bvec_iter iter;

include/linux/ceph/messenger.h

141

BUG_ON(!(it)->iter.bi_size); \

include/linux/ceph/messenger.h

142

__cur_n = min((it)->iter.bi_size, __n); \

include/linux/ceph/messenger.h

144

bio_advance_iter((it)->bio, &(it)->iter, __cur_n); \

include/linux/ceph/messenger.h

145

if (!(it)->iter.bi_size && (it)->bio->bi_next) { \

include/linux/ceph/messenger.h

148

(it)->iter = (it)->bio->bi_iter; \

include/linux/ceph/messenger.h

168

__cur_iter = (it)->iter; \

include/linux/ceph/messenger.h

178

struct bvec_iter iter;

include/linux/ceph/messenger.h

182

BUG_ON((n) > (it)->iter.bi_size); \

include/linux/ceph/messenger.h

184

bvec_iter_advance((it)->bvecs, &(it)->iter, (n)); \

include/linux/ceph/messenger.h

201

__cur_iter = (it)->iter; \

include/linux/ceph/messenger.h

208

BUG_ON((n) > (it)->iter.bi_size); \

include/linux/ceph/messenger.h

209

(it)->iter.bi_size = (n); \

include/linux/ceph/messenger.h

229

struct iov_iter iter;

include/linux/ceph/messenger.h

617

struct iov_iter *iter);

include/linux/ceph/osd_client.h

136

struct iov_iter iter;

include/linux/ceph/osd_client.h

507

unsigned int which, struct iov_iter *iter);

include/linux/codetag.h

81

struct codetag *codetag_next_ct(struct codetag_iterator *iter);

include/linux/crash_dump.h

182

ssize_t read_from_oldmem(struct iov_iter *iter, size_t count,

include/linux/crash_dump.h

185

static inline ssize_t read_from_oldmem(struct iov_iter *iter, size_t count,

include/linux/crash_dump.h

33

ssize_t copy_oldmem_page_encrypted(struct iov_iter *iter, unsigned long pfn,

include/linux/dax.h

268

ssize_t dax_iomap_rw(struct kiocb *iocb, struct iov_iter *iter,

include/linux/dax.h

37

void *addr, size_t bytes, struct iov_iter *iter);

include/linux/devcoredump.h

29

struct scatterlist *iter;

include/linux/devcoredump.h

33

iter = table;

include/linux/devcoredump.h

34

for_each_sg(table, iter, sg_nents(table), i) {

include/linux/devcoredump.h

35

page = sg_page(iter);

include/linux/devcoredump.h

41

iter = table;

include/linux/devcoredump.h

43

while (!sg_is_last(iter)) {

include/linux/devcoredump.h

44

iter++;

include/linux/devcoredump.h

45

if (sg_is_chain(iter)) {

include/linux/devcoredump.h

46

iter = sg_chain_ptr(iter);

include/linux/devcoredump.h

48

delete_iter = iter;

include/linux/device/class.h

88

void class_dev_iter_init(struct class_dev_iter *iter, const struct class *class,

include/linux/device/class.h

90

struct device *class_dev_iter_next(struct class_dev_iter *iter);

include/linux/device/class.h

91

void class_dev_iter_exit(struct class_dev_iter *iter);

include/linux/dma-fence-chain.h

119

#define dma_fence_chain_for_each(iter, head) \

include/linux/dma-fence-chain.h

120

for (iter = dma_fence_get(head); iter; \

include/linux/dma-fence-chain.h

121

iter = dma_fence_chain_walk(iter))

include/linux/fs.h

3071

ssize_t direct_write_fallback(struct kiocb *iocb, struct iov_iter *iter,

include/linux/fs.h

3074

ssize_t vfs_iter_read(struct file *file, struct iov_iter *iter, loff_t *ppos,

include/linux/fs.h

3076

ssize_t vfs_iter_write(struct file *file, struct iov_iter *iter, loff_t *ppos,

include/linux/fs.h

3079

struct iov_iter *iter);

include/linux/fs.h

3081

struct iov_iter *iter);

include/linux/fs.h

3125

struct block_device *bdev, struct iov_iter *iter,

include/linux/fs.h

3132

struct iov_iter *iter,

include/linux/fs.h

3135

return __blockdev_direct_IO(iocb, inode, inode->i_sb->s_bdev, iter,

include/linux/fs.h

3269

extern ssize_t noop_direct_IO(struct kiocb *iocb, struct iov_iter *iter);

include/linux/fs.h

3653

int generic_atomic_write_valid(struct kiocb *iocb, struct iov_iter *iter);

include/linux/fs.h

424

ssize_t (*direct_IO)(struct kiocb *, struct iov_iter *iter);

include/linux/fs.h

441

int (*swap_rw)(struct kiocb *iocb, struct iov_iter *iter);

include/linux/fscache.h

506

struct iov_iter *iter,

include/linux/fscache.h

512

return ops->read(cres, start_pos, iter, read_hole,

include/linux/fscache.h

565

struct iov_iter *iter,

include/linux/fscache.h

570

return ops->write(cres, start_pos, iter, term_func, term_func_priv);

include/linux/fsnotify_backend.h

525

static inline int fsnotify_iter_step(struct fsnotify_iter_info *iter, int type,

include/linux/fsnotify_backend.h

529

*markp = fsnotify_iter_mark(iter, type);

include/linux/fsnotify_backend.h

551

#define fsnotify_foreach_iter_mark_type(iter, mark, type) \

include/linux/fsnotify_backend.h

553

type = fsnotify_iter_step(iter, type, &mark), \

include/linux/ftrace.h

851

struct ftrace_rec_iter *ftrace_rec_iter_next(struct ftrace_rec_iter *iter);

include/linux/ftrace.h

852

struct dyn_ftrace *ftrace_rec_iter_record(struct ftrace_rec_iter *iter);

include/linux/ftrace.h

854

#define for_ftrace_rec_iter(iter) \

include/linux/ftrace.h

855

for (iter = ftrace_rec_iter_start(); \

include/linux/ftrace.h

856

iter; \

include/linux/ftrace.h

857

iter = ftrace_rec_iter_next(iter))

include/linux/generic-radix-tree.h

312

static inline void __genradix_iter_advance(struct genradix_iter *iter,

include/linux/generic-radix-tree.h

315

if (iter->offset + obj_size < iter->offset) {

include/linux/generic-radix-tree.h

316

iter->offset = SIZE_MAX;

include/linux/generic-radix-tree.h

317

iter->pos = SIZE_MAX;

include/linux/generic-radix-tree.h

321

iter->offset += obj_size;

include/linux/generic-radix-tree.h

324

(iter->offset & (GENRADIX_NODE_SIZE - 1)) + obj_size > GENRADIX_NODE_SIZE)

include/linux/generic-radix-tree.h

325

iter->offset = round_up(iter->offset, GENRADIX_NODE_SIZE);

include/linux/generic-radix-tree.h

327

iter->pos++;

include/linux/generic-radix-tree.h

333

static inline void __genradix_iter_rewind(struct genradix_iter *iter,

include/linux/generic-radix-tree.h

336

if (iter->offset == 0 ||

include/linux/generic-radix-tree.h

337

iter->offset == SIZE_MAX) {

include/linux/generic-radix-tree.h

338

iter->offset = SIZE_MAX;

include/linux/generic-radix-tree.h

342

if ((iter->offset & (GENRADIX_NODE_SIZE - 1)) == 0)

include/linux/generic-radix-tree.h

343

iter->offset -= GENRADIX_NODE_SIZE % obj_size;

include/linux/generic-radix-tree.h

345

iter->offset -= obj_size;

include/linux/generic-radix-tree.h

346

iter->pos--;

include/linux/interval_tree.h

75

void interval_tree_span_iter_advance(struct interval_tree_span_iter *iter,

include/linux/io_uring/cmd.h

105

int ddir, struct iov_iter *iter,

include/linux/io_uring/cmd.h

46

struct iov_iter *iter,

include/linux/io_uring/cmd.h

52

int ddir, struct iov_iter *iter,

include/linux/io_uring/cmd.h

97

struct iov_iter *iter, struct io_uring_cmd *ioucmd,

include/linux/iomap.h

163

struct folio *(*get_folio)(struct iomap_iter *iter, loff_t pos,

include/linux/iomap.h

192

int (*read_folio_range)(const struct iomap_iter *iter,

include/linux/iomap.h

263

int iomap_iter(struct iomap_iter *iter, const struct iomap_ops *ops);

include/linux/iomap.h

264

int iomap_iter_advance(struct iomap_iter *iter, u64 count);

include/linux/iomap.h

275

static inline u64 iomap_length_trim(const struct iomap_iter *iter, loff_t pos,

include/linux/iomap.h

278

u64 end = iter->iomap.offset + iter->iomap.length;

include/linux/iomap.h

280

if (iter->srcmap.type != IOMAP_HOLE)

include/linux/iomap.h

281

end = min(end, iter->srcmap.offset + iter->srcmap.length);

include/linux/iomap.h

291

static inline u64 iomap_length(const struct iomap_iter *iter)

include/linux/iomap.h

293

return iomap_length_trim(iter, iter->pos, iter->len);

include/linux/iomap.h

299

static inline int iomap_iter_advance_full(struct iomap_iter *iter)

include/linux/iomap.h

301

return iomap_iter_advance(iter, iomap_length(iter));

include/linux/iomap.h

347

static inline bool iomap_want_unshare_iter(const struct iomap_iter *iter)

include/linux/iomap.h

349

return (iter->iomap.flags & IOMAP_F_SHARED) &&

include/linux/iomap.h

350

iter->srcmap.type == IOMAP_MAPPED;

include/linux/iomap.h

364

struct folio *iomap_get_folio(struct iomap_iter *iter, loff_t pos, size_t len);

include/linux/iomap.h

371

unsigned int iomap_fill_dirty_folios(struct iomap_iter *iter, loff_t *start,

include/linux/iomap.h

522

int (*read_folio_range)(const struct iomap_iter *iter,

include/linux/iomap.h

530

void (*submit_read)(const struct iomap_iter *iter,

include/linux/iomap.h

549

void (*submit_io)(const struct iomap_iter *iter, struct bio *bio,

include/linux/iomap.h

600

ssize_t iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter,

include/linux/iomap.h

603

struct iomap_dio *__iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter,

include/linux/iomap.h

623

int iomap_bio_read_folio_range(const struct iomap_iter *iter,

include/linux/iomap.h

625

void iomap_bio_submit_read_endio(const struct iomap_iter *iter,

include/linux/iov_iter.h

100

iter->iov_offset = skip;

include/linux/iov_iter.h

101

iter->count -= progress;

include/linux/iov_iter.h

109

size_t iterate_bvec(struct iov_iter *iter, size_t len, void *priv, void *priv2,

include/linux/iov_iter.h

112

const struct bio_vec *p = iter->bvec;

include/linux/iov_iter.h

113

size_t progress = 0, skip = iter->iov_offset;

include/linux/iov_iter.h

137

iter->nr_segs -= p - iter->bvec;

include/linux/iov_iter.h

138

iter->bvec = p;

include/linux/iov_iter.h

139

iter->iov_offset = skip;

include/linux/iov_iter.h

140

iter->count -= progress;

include/linux/iov_iter.h

148

size_t iterate_folioq(struct iov_iter *iter, size_t len, void *priv, void *priv2,

include/linux/iov_iter.h

151

const struct folio_queue *folioq = iter->folioq;

include/linux/iov_iter.h

152

unsigned int slot = iter->folioq_slot;

include/linux/iov_iter.h

153

size_t progress = 0, skip = iter->iov_offset;

include/linux/iov_iter.h

193

iter->folioq_slot = slot;

include/linux/iov_iter.h

194

iter->folioq = folioq;

include/linux/iov_iter.h

195

iter->iov_offset = skip;

include/linux/iov_iter.h

196

iter->count -= progress;

include/linux/iov_iter.h

204

size_t iterate_xarray(struct iov_iter *iter, size_t len, void *priv, void *priv2,

include/linux/iov_iter.h

209

loff_t start = iter->xarray_start + iter->iov_offset;

include/linux/iov_iter.h

211

XA_STATE(xas, iter->xarray, index);

include/linux/iov_iter.h

24

size_t iterate_ubuf(struct iov_iter *iter, size_t len, void *priv, void *priv2,

include/linux/iov_iter.h

248

iter->iov_offset += progress;

include/linux/iov_iter.h

249

iter->count -= progress;

include/linux/iov_iter.h

257

size_t iterate_discard(struct iov_iter *iter, size_t len, void *priv, void *priv2,

include/linux/iov_iter.h

262

iter->count -= progress;

include/linux/iov_iter.h

27

void __user *base = iter->ubuf;

include/linux/iov_iter.h

293

size_t iterate_and_advance2(struct iov_iter *iter, size_t len, void *priv,

include/linux/iov_iter.h

296

if (unlikely(iter->count < len))

include/linux/iov_iter.h

297

len = iter->count;

include/linux/iov_iter.h

30

remain = step(base + iter->iov_offset, 0, len, priv, priv2);

include/linux/iov_iter.h

301

if (likely(iter_is_ubuf(iter)))

include/linux/iov_iter.h

302

return iterate_ubuf(iter, len, priv, priv2, ustep);

include/linux/iov_iter.h

303

if (likely(iter_is_iovec(iter)))

include/linux/iov_iter.h

304

return iterate_iovec(iter, len, priv, priv2, ustep);

include/linux/iov_iter.h

305

if (iov_iter_is_bvec(iter))

include/linux/iov_iter.h

306

return iterate_bvec(iter, len, priv, priv2, step);

include/linux/iov_iter.h

307

if (iov_iter_is_kvec(iter))

include/linux/iov_iter.h

308

return iterate_kvec(iter, len, priv, priv2, step);

include/linux/iov_iter.h

309

if (iov_iter_is_folioq(iter))

include/linux/iov_iter.h

310

return iterate_folioq(iter, len, priv, priv2, step);

include/linux/iov_iter.h

311

if (iov_iter_is_xarray(iter))

include/linux/iov_iter.h

312

return iterate_xarray(iter, len, priv, priv2, step);

include/linux/iov_iter.h

313

return iterate_discard(iter, len, priv, priv2, step);

include/linux/iov_iter.h

32

iter->iov_offset += progress;

include/linux/iov_iter.h

327

size_t iterate_and_advance(struct iov_iter *iter, size_t len, void *priv,

include/linux/iov_iter.h

33

iter->count -= progress;

include/linux/iov_iter.h

330

return iterate_and_advance2(iter, len, priv, NULL, ustep, step);

include/linux/iov_iter.h

362

size_t iterate_and_advance_kernel(struct iov_iter *iter, size_t len, void *priv,

include/linux/iov_iter.h

365

if (unlikely(iter->count < len))

include/linux/iov_iter.h

366

len = iter->count;

include/linux/iov_iter.h

369

if (iov_iter_is_bvec(iter))

include/linux/iov_iter.h

370

return iterate_bvec(iter, len, priv, priv2, step);

include/linux/iov_iter.h

371

if (iov_iter_is_kvec(iter))

include/linux/iov_iter.h

372

return iterate_kvec(iter, len, priv, priv2, step);

include/linux/iov_iter.h

373

if (iov_iter_is_folioq(iter))

include/linux/iov_iter.h

374

return iterate_folioq(iter, len, priv, priv2, step);

include/linux/iov_iter.h

375

if (iov_iter_is_xarray(iter))

include/linux/iov_iter.h

376

return iterate_xarray(iter, len, priv, priv2, step);

include/linux/iov_iter.h

377

return iterate_discard(iter, len, priv, priv2, step);

include/linux/iov_iter.h

41

size_t iterate_iovec(struct iov_iter *iter, size_t len, void *priv, void *priv2,

include/linux/iov_iter.h

44

const struct iovec *p = iter->__iov;

include/linux/iov_iter.h

45

size_t progress = 0, skip = iter->iov_offset;

include/linux/iov_iter.h

64

iter->nr_segs -= p - iter->__iov;

include/linux/iov_iter.h

65

iter->__iov = p;

include/linux/iov_iter.h

66

iter->iov_offset = skip;

include/linux/iov_iter.h

67

iter->count -= progress;

include/linux/iov_iter.h

75

size_t iterate_kvec(struct iov_iter *iter, size_t len, void *priv, void *priv2,

include/linux/iov_iter.h

78

const struct kvec *p = iter->kvec;

include/linux/iov_iter.h

79

size_t progress = 0, skip = iter->iov_offset;

include/linux/iov_iter.h

98

iter->nr_segs -= p - iter->kvec;

include/linux/iov_iter.h

99

iter->kvec = p;

include/linux/kmsg_dump.h

101

static inline void kmsg_dump_rewind(struct kmsg_dump_iter *iter)

include/linux/kmsg_dump.h

71

bool kmsg_dump_get_line(struct kmsg_dump_iter *iter, bool syslog,

include/linux/kmsg_dump.h

74

bool kmsg_dump_get_buffer(struct kmsg_dump_iter *iter, bool syslog,

include/linux/kmsg_dump.h

77

void kmsg_dump_rewind(struct kmsg_dump_iter *iter);

include/linux/kmsg_dump.h

89

static inline bool kmsg_dump_get_line(struct kmsg_dump_iter *iter, bool syslog,

include/linux/kmsg_dump.h

95

static inline bool kmsg_dump_get_buffer(struct kmsg_dump_iter *iter, bool syslog,

include/linux/kvm_host.h

1132

static inline void kvm_memslot_iter_next(struct kvm_memslot_iter *iter)

include/linux/kvm_host.h

1134

iter->node = rb_next(iter->node);

include/linux/kvm_host.h

1135

if (!iter->node)

include/linux/kvm_host.h

1138

iter->slot = container_of(iter->node, struct kvm_memory_slot, gfn_node[iter->slots->node_idx]);

include/linux/kvm_host.h

1141

static inline void kvm_memslot_iter_start(struct kvm_memslot_iter *iter,

include/linux/kvm_host.h

1149

iter->slots = slots;

include/linux/kvm_host.h

1155

iter->node = NULL;

include/linux/kvm_host.h

1159

iter->node = tmp;

include/linux/kvm_host.h

1170

if (iter->node) {

include/linux/kvm_host.h

1176

tmp = rb_prev(iter->node);

include/linux/kvm_host.h

1178

iter->node = tmp;

include/linux/kvm_host.h

1181

iter->node = rb_last(&slots->gfn_tree);

include/linux/kvm_host.h

1184

if (iter->node) {

include/linux/kvm_host.h

1185

iter->slot = container_of(iter->node, struct kvm_memory_slot, gfn_node[idx]);

include/linux/kvm_host.h

1196

if (iter->slot->base_gfn + iter->slot->npages <= start)

include/linux/kvm_host.h

1197

kvm_memslot_iter_next(iter);

include/linux/kvm_host.h

1201

static inline bool kvm_memslot_iter_is_valid(struct kvm_memslot_iter *iter, gfn_t end)

include/linux/kvm_host.h

1203

if (!iter->node)

include/linux/kvm_host.h

1210

return iter->slot->base_gfn < end;

include/linux/kvm_host.h

1214

#define kvm_for_each_memslot_in_gfn_range(iter, slots, start, end) \

include/linux/kvm_host.h

1215

for (kvm_memslot_iter_start(iter, slots, start); \

include/linux/kvm_host.h

1216

kvm_memslot_iter_is_valid(iter, end); \

include/linux/kvm_host.h

1217

kvm_memslot_iter_next(iter))

include/linux/memcontrol.h

117

struct mem_cgroup_reclaim_iter iter;

include/linux/mmap_lock.h

484

struct vma_iterator *iter,

include/linux/mroute_base.h

304

struct mr_table *(*iter)(struct net *net,

include/linux/mroute_base.h

355

struct mr_table *(*iter)(struct net *net,

include/linux/mroute_base.h

401

void *mr_vif_seq_idx(struct net *net, struct mr_vif_iter *iter, loff_t pos);

include/linux/mroute_base.h

444

static inline void *mr_vif_seq_idx(struct net *net, struct mr_vif_iter *iter,

include/linux/mtd/nand.h

1000

iter->dataleft);

include/linux/mtd/nand.h

1001

iter->req.ooblen = min_t(unsigned int, iter->oobbytes_per_page,

include/linux/mtd/nand.h

1002

iter->oobleft);

include/linux/mtd/nand.h

1014

struct nand_io_iter *iter)

include/linux/mtd/nand.h

1016

nanddev_pos_next_eraseblock(nand, &iter->req.pos);

include/linux/mtd/nand.h

1017

iter->dataleft -= iter->req.datalen;

include/linux/mtd/nand.h

1018

iter->req.databuf.in += iter->req.datalen;

include/linux/mtd/nand.h

1019

iter->req.dataoffs = 0;

include/linux/mtd/nand.h

1020

iter->req.datalen = min_t(unsigned int, nanddev_eraseblock_size(nand),

include/linux/mtd/nand.h

1021

iter->dataleft);

include/linux/mtd/nand.h

1036

const struct nand_io_iter *iter)

include/linux/mtd/nand.h

1038

if (iter->dataleft || iter->oobleft)

include/linux/mtd/nand.h

1054

#define nanddev_io_for_each_page(nand, type, start, req, iter) \

include/linux/mtd/nand.h

1055

for (nanddev_io_page_iter_init(nand, type, start, req, iter); \

include/linux/mtd/nand.h

1056

!nanddev_io_iter_end(nand, iter); \

include/linux/mtd/nand.h

1057

nanddev_io_iter_next_page(nand, iter))

include/linux/mtd/nand.h

1069

#define nanddev_io_for_each_block(nand, type, start, req, iter) \

include/linux/mtd/nand.h

1070

for (nanddev_io_block_iter_init(nand, type, start, req, iter); \

include/linux/mtd/nand.h

1071

!nanddev_io_iter_end(nand, iter); \

include/linux/mtd/nand.h

1072

nanddev_io_iter_next_block(nand, iter))

include/linux/mtd/nand.h

924

struct nand_io_iter *iter)

include/linux/mtd/nand.h

928

iter->req.type = reqtype;

include/linux/mtd/nand.h

929

iter->req.mode = req->mode;

include/linux/mtd/nand.h

930

iter->req.dataoffs = nanddev_offs_to_pos(nand, offs, &iter->req.pos);

include/linux/mtd/nand.h

931

iter->req.ooboffs = req->ooboffs;

include/linux/mtd/nand.h

932

iter->oobbytes_per_page = mtd_oobavail(mtd, req);

include/linux/mtd/nand.h

933

iter->dataleft = req->len;

include/linux/mtd/nand.h

934

iter->oobleft = req->ooblen;

include/linux/mtd/nand.h

935

iter->req.databuf.in = req->datbuf;

include/linux/mtd/nand.h

936

iter->req.datalen = min_t(unsigned int,

include/linux/mtd/nand.h

937

nand->memorg.pagesize - iter->req.dataoffs,

include/linux/mtd/nand.h

938

iter->dataleft);

include/linux/mtd/nand.h

939

iter->req.oobbuf.in = req->oobbuf;

include/linux/mtd/nand.h

940

iter->req.ooblen = min_t(unsigned int,

include/linux/mtd/nand.h

941

iter->oobbytes_per_page - iter->req.ooboffs,

include/linux/mtd/nand.h

942

iter->oobleft);

include/linux/mtd/nand.h

943

iter->req.continuous = false;

include/linux/mtd/nand.h

961

struct nand_io_iter *iter)

include/linux/mtd/nand.h

965

iter->req.type = reqtype;

include/linux/mtd/nand.h

966

iter->req.mode = req->mode;

include/linux/mtd/nand.h

967

iter->req.dataoffs = nanddev_offs_to_pos(nand, offs, &iter->req.pos);

include/linux/mtd/nand.h

968

iter->req.ooboffs = 0;

include/linux/mtd/nand.h

969

iter->oobbytes_per_page = 0;

include/linux/mtd/nand.h

970

iter->dataleft = req->len;

include/linux/mtd/nand.h

971

iter->oobleft = 0;

include/linux/mtd/nand.h

972

iter->req.databuf.in = req->datbuf;

include/linux/mtd/nand.h

973

offs_in_eb = (nand->memorg.pagesize * iter->req.pos.page) + iter->req.dataoffs;

include/linux/mtd/nand.h

974

iter->req.datalen = min_t(unsigned int,

include/linux/mtd/nand.h

976

iter->dataleft);

include/linux/mtd/nand.h

977

iter->req.oobbuf.in = NULL;

include/linux/mtd/nand.h

978

iter->req.ooblen = 0;

include/linux/mtd/nand.h

979

iter->req.continuous = true;

include/linux/mtd/nand.h

990

struct nand_io_iter *iter)

include/linux/mtd/nand.h

992

nanddev_pos_next_page(nand, &iter->req.pos);

include/linux/mtd/nand.h

993

iter->dataleft -= iter->req.datalen;

include/linux/mtd/nand.h

994

iter->req.databuf.in += iter->req.datalen;

include/linux/mtd/nand.h

995

iter->oobleft -= iter->req.ooblen;

include/linux/mtd/nand.h

996

iter->req.oobbuf.in += iter->req.ooblen;

include/linux/mtd/nand.h

997

iter->req.dataoffs = 0;

include/linux/mtd/nand.h

998

iter->req.ooboffs = 0;

include/linux/mtd/nand.h

999

iter->req.datalen = min_t(unsigned int, nand->memorg.pagesize,

include/linux/netdevice.h

5210

struct list_head **iter);

include/linux/netdevice.h

5213

#define netdev_for_each_upper_dev_rcu(dev, updev, iter) \

include/linux/netdevice.h

5214

for (iter = &(dev)->adj_list.upper, \

include/linux/netdevice.h

5215

updev = netdev_upper_get_next_dev_rcu(dev, &(iter)); \

include/linux/netdevice.h

5217

updev = netdev_upper_get_next_dev_rcu(dev, &(iter)))

include/linux/netdevice.h

5230

struct list_head **iter);

include/linux/netdevice.h

5232

struct list_head **iter);

include/linux/netdevice.h

5234

#define netdev_for_each_lower_private(dev, priv, iter) \

include/linux/netdevice.h

5235

for (iter = (dev)->adj_list.lower.next, \

include/linux/netdevice.h

5236

priv = netdev_lower_get_next_private(dev, &(iter)); \

include/linux/netdevice.h

5238

priv = netdev_lower_get_next_private(dev, &(iter)))

include/linux/netdevice.h

5240

#define netdev_for_each_lower_private_rcu(dev, priv, iter) \

include/linux/netdevice.h

5241

for (iter = &(dev)->adj_list.lower, \

include/linux/netdevice.h

5242

priv = netdev_lower_get_next_private_rcu(dev, &(iter)); \

include/linux/netdevice.h

5244

priv = netdev_lower_get_next_private_rcu(dev, &(iter)))

include/linux/netdevice.h

5247

struct list_head **iter);

include/linux/netdevice.h

5249

#define netdev_for_each_lower_dev(dev, ldev, iter) \

include/linux/netdevice.h

5250

for (iter = (dev)->adj_list.lower.next, \

include/linux/netdevice.h

5251

ldev = netdev_lower_get_next(dev, &(iter)); \

include/linux/netdevice.h

5253

ldev = netdev_lower_get_next(dev, &(iter)))

include/linux/netdevice.h

5256

struct list_head **iter);

include/linux/netfs.h

335

struct iov_iter *iter,

include/linux/netfs.h

343

struct iov_iter *iter,

include/linux/netfs.h

393

ssize_t netfs_unbuffered_read_iter_locked(struct kiocb *iocb, struct iov_iter *iter);

include/linux/netfs.h

394

ssize_t netfs_unbuffered_read_iter(struct kiocb *iocb, struct iov_iter *iter);

include/linux/netfs.h

395

ssize_t netfs_buffered_read_iter(struct kiocb *iocb, struct iov_iter *iter);

include/linux/netfs.h

396

ssize_t netfs_file_read_iter(struct kiocb *iocb, struct iov_iter *iter);

include/linux/netfs.h

399

ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter,

include/linux/netfs.h

404

ssize_t netfs_unbuffered_write_iter_locked(struct kiocb *iocb, struct iov_iter *iter,

include/linux/netfs.h

410

ssize_t netfs_read_single(struct inode *inode, struct file *file, struct iov_iter *iter);

include/linux/netfs.h

413

struct iov_iter *iter);

include/linux/netfs.h

443

size_t netfs_limit_iter(const struct iov_iter *iter, size_t start_offset,

include/linux/nfs_fs.h

551

int nfs_swap_rw(struct kiocb *iocb, struct iov_iter *iter);

include/linux/nfs_fs.h

553

struct iov_iter *iter, bool swap);

include/linux/nfs_fs.h

555

struct iov_iter *iter, bool swap);

include/linux/page_ext.h

129

static inline struct page_ext *page_ext_iter_begin(struct page_ext_iter *iter,

include/linux/page_ext.h

135

iter->index = 0;

include/linux/page_ext.h

136

iter->start_pfn = pfn;

include/linux/page_ext.h

137

iter->page_ext = page_ext_lookup(pfn);

include/linux/page_ext.h

139

return iter->page_ext;

include/linux/page_ext.h

151

static inline struct page_ext *page_ext_iter_next(struct page_ext_iter *iter,

include/linux/page_ext.h

156

if (WARN_ON_ONCE(!iter->page_ext))

include/linux/page_ext.h

159

if (++iter->index >= count)

include/linux/page_ext.h

161

pfn = iter->start_pfn + iter->index;

include/linux/page_ext.h

164

iter->page_ext = page_ext_next(iter->page_ext);

include/linux/page_ext.h

166

iter->page_ext = page_ext_lookup(pfn);

include/linux/page_ext.h

168

return iter->page_ext;

include/linux/page_ext.h

177

static inline struct page_ext *page_ext_iter_get(const struct page_ext_iter *iter)

include/linux/page_ext.h

179

return iter->page_ext;

include/linux/radix-tree.h

233

struct radix_tree_iter *iter, void __rcu **slot);

include/linux/radix-tree.h

249

const struct radix_tree_iter *iter, unsigned int tag);

include/linux/radix-tree.h

264

struct radix_tree_iter *iter, gfp_t gfp,

include/linux/radix-tree.h

281

radix_tree_iter_init(struct radix_tree_iter *iter, unsigned long start)

include/linux/radix-tree.h

291

iter->index = 0;

include/linux/radix-tree.h

292

iter->next_index = start;

include/linux/radix-tree.h

310

struct radix_tree_iter *iter, unsigned flags);

include/linux/radix-tree.h

324

struct radix_tree_iter *iter, unsigned long index)

include/linux/radix-tree.h

326

radix_tree_iter_init(iter, index);

include/linux/radix-tree.h

327

return radix_tree_next_chunk(root, iter, RADIX_TREE_ITER_CONTIG);

include/linux/radix-tree.h

340

void __rcu **radix_tree_iter_retry(struct radix_tree_iter *iter)

include/linux/radix-tree.h

342

iter->next_index = iter->index;

include/linux/radix-tree.h

343

iter->tags = 0;

include/linux/radix-tree.h

348

__radix_tree_iter_add(struct radix_tree_iter *iter, unsigned long slots)

include/linux/radix-tree.h

350

return iter->index + slots;

include/linux/radix-tree.h

364

struct radix_tree_iter *iter);

include/linux/radix-tree.h

373

radix_tree_chunk_size(struct radix_tree_iter *iter)

include/linux/radix-tree.h

375

return iter->next_index - iter->index;

include/linux/radix-tree.h

398

struct radix_tree_iter *iter, unsigned flags)

include/linux/radix-tree.h

401

iter->tags >>= 1;

include/linux/radix-tree.h

402

if (unlikely(!iter->tags))

include/linux/radix-tree.h

404

if (likely(iter->tags & 1ul)) {

include/linux/radix-tree.h

405

iter->index = __radix_tree_iter_add(iter, 1);

include/linux/radix-tree.h

410

unsigned offset = __ffs(iter->tags);

include/linux/radix-tree.h

412

iter->tags >>= offset++;

include/linux/radix-tree.h

413

iter->index = __radix_tree_iter_add(iter, offset);

include/linux/radix-tree.h

418

long count = radix_tree_chunk_size(iter);

include/linux/radix-tree.h

422

iter->index = __radix_tree_iter_add(iter, 1);

include/linux/radix-tree.h

428

iter->next_index = 0;

include/linux/radix-tree.h

449

#define radix_tree_for_each_slot(slot, root, iter, start) \

include/linux/radix-tree.h

450

for (slot = radix_tree_iter_init(iter, start) ; \

include/linux/radix-tree.h

451

slot || (slot = radix_tree_next_chunk(root, iter, 0)) ; \

include/linux/radix-tree.h

452

slot = radix_tree_next_slot(slot, iter, 0))

include/linux/radix-tree.h

465

#define radix_tree_for_each_tagged(slot, root, iter, start, tag) \

include/linux/radix-tree.h

466

for (slot = radix_tree_iter_init(iter, start) ; \

include/linux/radix-tree.h

467

slot || (slot = radix_tree_next_chunk(root, iter, \

include/linux/radix-tree.h

469

slot = radix_tree_next_slot(slot, iter, \

include/linux/rhashtable.h

1313

struct rhashtable_iter *iter)

include/linux/rhashtable.h

1315

rhashtable_walk_enter(&hlt->ht, iter);

include/linux/rhashtable.h

240

struct rhashtable_iter *iter);

include/linux/rhashtable.h

241

void rhashtable_walk_exit(struct rhashtable_iter *iter);

include/linux/rhashtable.h

242

int rhashtable_walk_start_check(struct rhashtable_iter *iter) __acquires_shared(RCU);

include/linux/rhashtable.h

244

static inline void rhashtable_walk_start(struct rhashtable_iter *iter)

include/linux/rhashtable.h

247

(void)rhashtable_walk_start_check(iter);

include/linux/rhashtable.h

250

void *rhashtable_walk_next(struct rhashtable_iter *iter);

include/linux/rhashtable.h

251

void *rhashtable_walk_peek(struct rhashtable_iter *iter);

include/linux/rhashtable.h

252

void rhashtable_walk_stop(struct rhashtable_iter *iter) __releases_shared(RCU);

include/linux/ring_buffer.h

159

void ring_buffer_read_finish(struct ring_buffer_iter *iter);

include/linux/ring_buffer.h

162

ring_buffer_iter_peek(struct ring_buffer_iter *iter, u64 *ts);

include/linux/ring_buffer.h

163

void ring_buffer_iter_advance(struct ring_buffer_iter *iter);

include/linux/ring_buffer.h

164

void ring_buffer_iter_reset(struct ring_buffer_iter *iter);

include/linux/ring_buffer.h

165

int ring_buffer_iter_empty(struct ring_buffer_iter *iter);

include/linux/ring_buffer.h

166

bool ring_buffer_iter_dropped(struct ring_buffer_iter *iter);

include/linux/rolling_buffer.h

27

struct iov_iter iter; /* Iterator tracking what's left in the buffer */

include/linux/rolling_buffer.h

58

iov_iter_advance(&roll->iter, amount);

include/linux/seq_file.h

110

ssize_t seq_read_iter(struct kiocb *iocb, struct iov_iter *iter);

include/linux/skbuff.h

4215

#define skb_walk_frags(skb, iter) \

include/linux/skbuff.h

4216

for (iter = skb_shinfo(skb)->frag_list; iter; iter = iter->next)

include/linux/skbuff.h

5458

ssize_t skb_splice_from_iter(struct sk_buff *skb, struct iov_iter *iter,

include/linux/smbdirect.h

137

struct iov_iter *iter,

include/linux/smbdirect.h

144

struct iov_iter *iter,

include/linux/smbdirect.h

173

struct iov_iter *iter,

include/linux/trace_events.h

47

const char *trace_print_bitmask_seq(struct trace_iterator *iter, void *bitmask_ptr,

include/linux/trace_events.h

63

int trace_raw_output_prep(struct trace_iterator *iter,

include/linux/trace_events.h

66

void trace_event_printf(struct trace_iterator *iter, const char *fmt, ...);

include/linux/uio.h

101

#define iter_iov_addr(iter) (iter_iov(iter)->iov_base + (iter)->iov_offset)

include/linux/uio.h

115

static inline void iov_iter_save_state(struct iov_iter *iter,

include/linux/uio.h

118

state->iov_offset = iter->iov_offset;

include/linux/uio.h

119

state->count = iter->count;

include/linux/uio.h

120

state->nr_segs = iter->nr_segs;

include/linux/uio.h

392

ssize_t iov_iter_extract_bvecs(struct iov_iter *iter, struct bio_vec *bv,

include/linux/uio.h

412

static inline bool iov_iter_extract_will_pin(const struct iov_iter *iter)

include/linux/uio.h

414

return user_backed_iter(iter);

include/linux/uio.h

418

ssize_t extract_iter_to_sg(struct iov_iter *iter, size_t len,

include/linux/uio.h

91

struct iov_iter iter;

include/linux/uio.h

94

static inline const struct iovec *iter_iov(const struct iov_iter *iter)

include/linux/uio.h

96

if (iter->iter_type == ITER_UBUF)

include/linux/uio.h

97

return (const struct iovec *) &iter->__ubuf_iovec;

include/linux/uio.h

98

return iter->__iov;

include/linux/vmalloc.h

277

long vread_iter(struct iov_iter *iter, const char *addr, size_t count);

include/media/media-entity.h

1194

struct media_pipeline_pad_iter *iter,

include/media/media-entity.h

1207

#define media_pipeline_for_each_pad(pipe, iter, pad) \

include/media/media-entity.h

1208

for (pad = __media_pipeline_pad_iter_next((pipe), iter, NULL); \

include/media/media-entity.h

1210

pad = __media_pipeline_pad_iter_next((pipe), iter, pad))

include/media/media-entity.h

1228

struct media_pipeline_entity_iter *iter);

include/media/media-entity.h

1237

void media_pipeline_entity_iter_cleanup(struct media_pipeline_entity_iter *iter);

include/media/media-entity.h

1241

struct media_pipeline_entity_iter *iter,

include/media/media-entity.h

1257

#define media_pipeline_for_each_entity(pipe, iter, entity) \

include/media/media-entity.h

1258

for (entity = __media_pipeline_entity_iter_next((pipe), iter, NULL); \

include/media/media-entity.h

1260

entity = __media_pipeline_entity_iter_next((pipe), iter, entity))

include/media/media-entity.h

383

#define media_entity_for_each_pad(entity, iter) \

include/media/media-entity.h

384

for (iter = (entity)->pads; \

include/media/media-entity.h

385

iter < &(entity)->pads[(entity)->num_pads]; \

include/media/media-entity.h

386

++iter)

include/net/bonding.h

404

struct list_head *iter;

include/net/bonding.h

407

bond_for_each_slave(bond, tmp, iter) {

include/net/bonding.h

417

struct list_head *iter;

include/net/bonding.h

420

bond_for_each_slave(bond, tmp, iter) {

include/net/bonding.h

642

struct list_head *iter;

include/net/bonding.h

645

bond_for_each_slave(bond, tmp, iter) {

include/net/bonding.h

743

struct list_head *iter;

include/net/bonding.h

746

bond_for_each_slave(bond, tmp, iter)

include/net/bonding.h

756

struct list_head *iter;

include/net/bonding.h

759

bond_for_each_slave_rcu(bond, tmp, iter)

include/net/bonding.h

80

#define bond_for_each_slave(bond, pos, iter) \

include/net/bonding.h

81

netdev_for_each_lower_private((bond)->dev, pos, iter)

include/net/bonding.h

84

#define bond_for_each_slave_rcu(bond, pos, iter) \

include/net/bonding.h

85

netdev_for_each_lower_private_rcu((bond)->dev, pos, iter)

include/net/cfg80211.h

10307

void (*iter)(const struct ieee80211_iface_combination *c,

include/net/cfg80211.h

7997

(*iter)(void *data, u8 type,

include/net/cfg80211.h

8499

void (*iter)(struct wiphy *wiphy,

include/net/ip.h

185

unsigned int hlen, struct ip_fraglist_iter *iter);

include/net/ip.h

186

void ip_fraglist_prepare(struct sk_buff *skb, struct ip_fraglist_iter *iter);

include/net/ip.h

188

static inline struct sk_buff *ip_fraglist_next(struct ip_fraglist_iter *iter)

include/net/ip.h

190

struct sk_buff *skb = iter->frag;

include/net/ip.h

192

iter->frag = skb->next;

include/net/ipv6.h

169

struct ip6_fraglist_iter *iter);

include/net/ipv6.h

170

void ip6_fraglist_prepare(struct sk_buff *skb, struct ip6_fraglist_iter *iter);

include/net/ipv6.h

172

static inline struct sk_buff *ip6_fraglist_next(struct ip6_fraglist_iter *iter)

include/net/ipv6.h

174

struct sk_buff *skb = iter->frag;

include/net/ipv6.h

176

iter->frag = skb->next;

include/net/mac80211.h

6899

void (*iter)(struct ieee80211_hw *hw,

include/net/mac80211.h

6923

void (*iter)(struct ieee80211_hw *hw,

include/net/mac80211.h

6951

void (*iter)(struct ieee80211_hw *hw,

include/net/mac80211.h

6976

void (*iter)(struct ieee80211_hw *hw,

include/net/netfilter/nf_conntrack.h

242

void nf_ct_iterate_cleanup_net(int (*iter)(struct nf_conn *i, void *data),

include/net/netfilter/nf_conntrack.h

246

void nf_ct_iterate_destroy(int (*iter)(struct nf_conn *i, void *data),

include/net/netfilter/nf_conntrack_expect.h

143

void nf_ct_expect_iterate_destroy(bool (*iter)(struct nf_conntrack_expect *e, void *data), void *data);

include/net/netfilter/nf_conntrack_expect.h

145

bool (*iter)(struct nf_conntrack_expect *e, void *data),

include/net/netfilter/nf_tables.h

1160

const struct nft_set_iter *iter,

include/net/netfilter/nf_tables.h

337

const struct nft_set_iter *iter,

include/net/netfilter/nf_tables.h

490

struct nft_set_iter *iter);

include/net/netlabel.h

333

struct netlbl_lsm_catmap *iter;

include/net/netlabel.h

336

iter = catmap;

include/net/netlabel.h

338

kfree(iter);

include/net/sctp/sctp.h

103

void sctp_transport_walk_start(struct rhashtable_iter *iter);

include/net/sctp/sctp.h

104

void sctp_transport_walk_stop(struct rhashtable_iter *iter);

include/net/sctp/sctp.h

106

struct rhashtable_iter *iter);

include/net/sctp/sctp.h

108

struct rhashtable_iter *iter, int pos);

include/rdma/ib_verbs.h

3299

#define rdma_for_each_port(device, iter) \

include/rdma/ib_verbs.h

3300

for (iter = rdma_start_port(device + \

include/rdma/ib_verbs.h

3302

iter))); \

include/rdma/ib_verbs.h

3303

iter <= rdma_end_port(device); iter++)

include/rdma/rdmavt_qp.h

1001

int rvt_qp_iter_next(struct rvt_qp_iter *iter);

include/rdma/rw.h

66

struct bvec_iter iter, u64 remote_addr, u32 rkey,

include/sound/pcm.h

1540

struct iov_iter *iter) __must_check;

include/sound/pcm.h

1542

struct iov_iter *iter) __must_check;

include/sound/pcm.h

74

unsigned long pos, struct iov_iter *iter, unsigned long bytes);

include/sound/soc-component.h

144

unsigned long pos, struct iov_iter *iter,

include/sound/soc-component.h

419

struct iov_iter *iter, unsigned long bytes);

include/trace/events/afs.h

609

TP_PROTO(struct afs_call *call, struct iov_iter *iter,

include/trace/events/afs.h

612

TP_ARGS(call, iter, want_more, ret),

include/trace/events/afs.h

627

__entry->remain = iov_iter_count(iter);

include/trace/stages/stage3_trace_output.h

42

trace_print_bitmask_seq(iter, __bitmask, __bitmask_size); \

include/trace/stages/stage3_trace_output.h

54

trace_print_bitmask_seq(iter, __bitmask, __bitmask_size); \

include/trace/trace_custom_events.h

79

trace_custom_raw_output_##call(struct trace_iterator *iter, int flags, \

include/trace/trace_custom_events.h

82

struct trace_seq *s = &iter->seq; \

include/trace/trace_custom_events.h

83

struct trace_seq __maybe_unused *p = &iter->tmp_seq; \

include/trace/trace_custom_events.h

87

field = (typeof(field))iter->ent; \

include/trace/trace_custom_events.h

89

ret = trace_raw_output_prep(iter, trace_event); \

include/trace/trace_custom_events.h

93

trace_event_printf(iter, print); \

include/trace/trace_events.h

205

trace_raw_output_##call(struct trace_iterator *iter, int flags, \

include/trace/trace_events.h

208

struct trace_seq *s = &iter->seq; \

include/trace/trace_events.h

209

struct trace_seq __maybe_unused *p = &iter->tmp_seq; \

include/trace/trace_events.h

213

field = (typeof(field))iter->ent; \

include/trace/trace_events.h

215

ret = trace_raw_output_prep(iter, trace_event); \

include/trace/trace_events.h

219

trace_event_printf(iter, print); \

include/trace/trace_events.h

233

trace_raw_output_##call(struct trace_iterator *iter, int flags, \

include/trace/trace_events.h

238

struct trace_seq *p = &iter->tmp_seq; \

include/trace/trace_events.h

240

entry = iter->ent; \

include/trace/trace_events.h

250

return trace_output_call(iter, #call, print); \

include/uapi/drm/etnaviv_drm.h

253

__u8 iter; /* in/out, select pm domain at index iter */

include/uapi/drm/etnaviv_drm.h

263

__u16 iter; /* in/out, select pm source at index iter */

include/uapi/linux/bpf.h

6808

} iter;

io_uring/mock_file.c

70

struct iov_iter iter;

io_uring/mock_file.c

85

ret = io_uring_cmd_import_fixed_vec(cmd, iovec, iovec_len, dir, &iter,

io_uring/mock_file.c

89

ret = io_copy_regbuf(&iter, ubuf);

io_uring/rsrc.c

1129

static int io_import_kbuf(int ddir, struct iov_iter *iter,

io_uring/rsrc.c

1134

iov_iter_bvec(iter, ddir, imu->bvec, imu->nr_bvecs, count);

io_uring/rsrc.c

1135

iov_iter_advance(iter, offset);

io_uring/rsrc.c

1139

static int io_import_fixed(int ddir, struct iov_iter *iter,

io_uring/rsrc.c

1155

iov_iter_bvec(iter, ddir, NULL, 0, 0);

io_uring/rsrc.c

1162

return io_import_kbuf(ddir, iter, imu, len, offset);

io_uring/rsrc.c

1186

iov_iter_bvec(iter, ddir, bvec, nr_segs, len);

io_uring/rsrc.c

1187

iter->iov_offset = offset;

io_uring/rsrc.c

1214

int io_import_reg_buf(struct io_kiocb *req, struct iov_iter *iter,

io_uring/rsrc.c

1223

return io_import_fixed(ddir, iter, node->buf, buf_addr, len);

io_uring/rsrc.c

1475

static int io_vec_fill_bvec(int ddir, struct iov_iter *iter,

io_uring/rsrc.c

1525

iov_iter_bvec(iter, ddir, res_bvec, bvec_idx, total_len);

io_uring/rsrc.c

1544

static int io_vec_fill_kern_bvec(int ddir, struct iov_iter *iter,

io_uring/rsrc.c

1568

iov_iter_bvec(iter, ddir, res_bvec, res_idx, total_len);

io_uring/rsrc.c

1620

int io_import_reg_vec(int ddir, struct iov_iter *iter,

io_uring/rsrc.c

1679

return io_vec_fill_kern_bvec(ddir, iter, imu, iov, nr_iovs, vec);

io_uring/rsrc.c

1681

return io_vec_fill_bvec(ddir, iter, imu, iov, nr_iovs, vec);

io_uring/rsrc.h

67

int io_import_reg_buf(struct io_kiocb *req, struct iov_iter *iter,

io_uring/rsrc.h

70

int io_import_reg_vec(int ddir, struct iov_iter *iter,

io_uring/rw.c

1001

iov_iter_advance(&io->iter, ret);

io_uring/rw.c

1002

if (!iov_iter_count(&io->iter))

io_uring/rw.c

1005

iov_iter_save_state(&io->iter, &io->iter_state);

io_uring/rw.c

1013

req->cqe.res = iov_iter_count(&io->iter);

io_uring/rw.c

1020

ret = io_iter_do_read(rw, &io->iter);

io_uring/rw.c

1025

iov_iter_restore(&io->iter, &io->iter_state);

io_uring/rw.c

105

io_vec_reset_iovec(&io->vec, iov, io->iter.nr_segs);

io_uring/rw.c

1152

req->cqe.res = iov_iter_count(&io->iter);

io_uring/rw.c

1182

ret2 = req->file->f_op->write_iter(kiocb, &io->iter);

io_uring/rw.c

1184

ret2 = loop_rw_iter(WRITE, rw, &io->iter);

io_uring/rw.c

1211

iov_iter_save_state(&io->iter, &io->iter_state);

io_uring/rw.c

1222

iov_iter_restore(&io->iter, &io->iter_state);

io_uring/rw.c

129

return import_ubuf(ddir, sel->addr, sqe_len, &io->iter);

io_uring/rw.c

143

iov_iter_save_state(&io->iter, &io->iter_state);

io_uring/rw.c

221

iov_iter_save_state(&io->meta.iter, &io->meta_state.iter_meta);

io_uring/rw.c

228

iov_iter_restore(&io->meta.iter, &io->meta_state.iter_meta);

io_uring/rw.c

251

pi_attr.len, &io->meta.iter);

io_uring/rw.c

383

ret = io_import_reg_buf(req, &io->iter, rw->addr, rw->len, ddir,

io_uring/rw.c

385

iov_iter_save_state(&io->iter, &io->iter_state);

io_uring/rw.c

407

ret = io_import_reg_vec(ddir, &io->iter, req, &io->vec,

io_uring/rw.c

411

iov_iter_save_state(&io->iter, &io->iter_state);

io_uring/rw.c

518

iov_iter_restore(&io->iter, &io->iter_state);

io_uring/rw.c

692

static ssize_t loop_rw_iter(int ddir, struct io_rw *rw, struct iov_iter *iter)

io_uring/rw.c

716

while (iov_iter_count(iter)) {

io_uring/rw.c

721

if (iter_is_ubuf(iter)) {

io_uring/rw.c

722

addr = iter->ubuf + iter->iov_offset;

io_uring/rw.c

723

len = iov_iter_count(iter);

io_uring/rw.c

724

} else if (!iov_iter_is_bvec(iter)) {

io_uring/rw.c

725

addr = iter_iov_addr(iter);

io_uring/rw.c

726

len = iter_iov_len(iter);

io_uring/rw.c

743

if (!iov_iter_is_bvec(iter)) {

io_uring/rw.c

744

iov_iter_advance(iter, nr);

io_uring/rw.c

835

static inline int io_iter_do_read(struct io_rw *rw, struct iov_iter *iter)

io_uring/rw.c

840

return file->f_op->read_iter(&rw->kiocb, iter);

io_uring/rw.c

842

return loop_rw_iter(READ, rw, iter);

io_uring/rw.c

939

req->cqe.res = iov_iter_count(&io->iter);

io_uring/rw.c

957

ret = io_iter_do_read(rw, &io->iter);

io_uring/rw.c

99

ret = __import_iovec(ddir, uvec, uvec_segs, nr_segs, &iov, &io->iter,

io_uring/rw.c

992

iov_iter_restore(&io->iter, &io->iter_state);

io_uring/rw.h

16

struct iov_iter iter;

io_uring/uring_cmd.c

290

struct iov_iter *iter,

io_uring/uring_cmd.c

299

return io_import_reg_buf(req, iter, ubuf, len, rw, issue_flags);

io_uring/uring_cmd.c

306

int ddir, struct iov_iter *iter,

io_uring/uring_cmd.c

320

return io_import_reg_vec(ddir, iter, req, &ac->vec, uvec_segs,

ipc/util.c

778

struct ipc_proc_iter *iter = s->private;

ipc/util.c

779

return iter->pid_ns;

ipc/util.c

818

struct ipc_proc_iter *iter = s->private;

ipc/util.c

819

struct ipc_proc_iface *iface = iter->iface;

ipc/util.c

828

return sysvipc_find_ipc(&iter->ns->ids[iface->ids], pos);

ipc/util.c

837

struct ipc_proc_iter *iter = s->private;

ipc/util.c

838

struct ipc_proc_iface *iface = iter->iface;

ipc/util.c

841

ids = &iter->ns->ids[iface->ids];

ipc/util.c

864

struct ipc_proc_iter *iter = s->private;

ipc/util.c

865

struct ipc_proc_iface *iface = iter->iface;

ipc/util.c

872

ids = &iter->ns->ids[iface->ids];

ipc/util.c

879

struct ipc_proc_iter *iter = s->private;

ipc/util.c

880

struct ipc_proc_iface *iface = iter->iface;

ipc/util.c

899

struct ipc_proc_iter *iter;

ipc/util.c

901

iter = __seq_open_private(file, &sysvipc_proc_seqops, sizeof(*iter));

ipc/util.c

902

if (!iter)

ipc/util.c

905

iter->iface = pde_data(inode);

ipc/util.c

906

iter->ns = get_ipc_ns(current->nsproxy->ipc_ns);

ipc/util.c

907

iter->pid_ns = get_pid_ns(task_active_pid_ns(current));

ipc/util.c

915

struct ipc_proc_iter *iter = seq->private;

ipc/util.c

916

put_ipc_ns(iter->ns);

ipc/util.c

917

put_pid_ns(iter->pid_ns);

kernel/auditsc.c

1131

unsigned int iter;

kernel/auditsc.c

1164

iter = 0;

kernel/auditsc.c

1237

if (require_data || (iter > 0) ||

kernel/auditsc.c

1239

if (iter == 0) {

kernel/auditsc.c

1247

" a%d[%d]=", arg, iter++);

kernel/auditsc.c

1281

iter = 0;

kernel/bpf/bpf_iter.c

340

struct bpf_iter_target_info *tinfo = NULL, *iter;

kernel/bpf/bpf_iter.c

349

list_for_each_entry(iter, &targets, list) {

kernel/bpf/bpf_iter.c

350

if (iter->btf_id && iter->btf_id == prog_btf_id) {

kernel/bpf/bpf_iter.c

351

tinfo = iter;

kernel/bpf/bpf_iter.c

354

if (!strcmp(attach_fname + prefix_len, iter->reg_info->target)) {

kernel/bpf/bpf_iter.c

355

cache_btf_id(iter, prog);

kernel/bpf/bpf_iter.c

356

tinfo = iter;

kernel/bpf/bpf_iter.c

456

char __user *ubuf = u64_to_user_ptr(info->iter.target_name);

kernel/bpf/bpf_iter.c

458

u32 ulen = info->iter.target_name_len;

kernel/bpf/bpf_iter.c

467

info->iter.target_name_len = target_len + 1;

kernel/bpf/bpf_iter.c

507

struct bpf_iter_target_info *tinfo = NULL, *iter;

kernel/bpf/bpf_iter.c

537

list_for_each_entry(iter, &targets, list) {

kernel/bpf/bpf_iter.c

538

if (iter->btf_id == prog_btf_id) {

kernel/bpf/bpf_iter.c

539

tinfo = iter;

kernel/bpf/cgroup_iter.c

279

info->iter.cgroup.order = aux->cgroup.order;

kernel/bpf/cgroup_iter.c

280

info->iter.cgroup.cgroup_id = cgroup_id(aux->cgroup.start);

kernel/bpf/devmap.c

614

struct list_head *iter;

kernel/bpf/devmap.c

617

netdev_for_each_upper_dev_rcu(dev, upper, iter) {

kernel/bpf/hashtab.c

3121

struct rhashtable_iter iter;

kernel/bpf/hashtab.c

3135

rhashtable_walk_enter(&rhtab->ht, &iter);

kernel/bpf/hashtab.c

3136

rhashtable_walk_start(&iter);

kernel/bpf/hashtab.c

3138

while ((elem = rhashtable_walk_next(&iter))) {

kernel/bpf/hashtab.c

3148

rhashtable_walk_stop(&iter);

kernel/bpf/hashtab.c

3150

rhashtable_walk_start(&iter);

kernel/bpf/hashtab.c

3154

rhashtable_walk_stop(&iter);

kernel/bpf/hashtab.c

3155

rhashtable_walk_exit(&iter);

kernel/bpf/hashtab.c

3396

struct rhashtable_iter iter;

kernel/bpf/hashtab.c

3405

rhashtable_walk_start(&info->iter);

kernel/bpf/hashtab.c

3412

elem = rhashtable_walk_peek(&info->iter);

kernel/bpf/hashtab.c

3432

elem = rhashtable_walk_next(&info->iter);

kernel/bpf/hashtab.c

3477

rhashtable_walk_stop(&info->iter);

kernel/bpf/hashtab.c

3488

rhashtable_walk_enter(&info->rhtab->ht, &info->iter);

kernel/bpf/hashtab.c

3496

rhashtable_walk_exit(&info->iter);

kernel/bpf/inode.c

221

static void map_iter_free(struct map_iter *iter)

kernel/bpf/inode.c

223

if (iter) {

kernel/bpf/inode.c

224

kfree(iter->key);

kernel/bpf/inode.c

225

kfree(iter);

kernel/bpf/inode.c

231

struct map_iter *iter;

kernel/bpf/inode.c

233

iter = kzalloc_obj(*iter, GFP_KERNEL | __GFP_NOWARN);

kernel/bpf/inode.c

234

if (!iter)

kernel/bpf/inode.c

237

iter->key = kzalloc(map->key_size, GFP_KERNEL | __GFP_NOWARN);

kernel/bpf/inode.c

238

if (!iter->key)

kernel/bpf/inode.c

241

return iter;

kernel/bpf/inode.c

244

map_iter_free(iter);

kernel/bpf/inode.c

309

struct map_iter *iter;

kernel/bpf/inode.c

313

iter = map_iter_alloc(map);

kernel/bpf/inode.c

314

if (!iter)

kernel/bpf/inode.c

319

map_iter_free(iter);

kernel/bpf/inode.c

324

m->private = iter;

kernel/bpf/log.c

782

iter_type_str(reg->iter.btf, reg->iter.btf_id),

kernel/bpf/log.c

783

reg->id, iter_state_str(reg->iter.state),

kernel/bpf/log.c

784

reg->iter.depth);

kernel/bpf/map_iter.c

165

info->iter.map.map_id = aux->map->id;

kernel/bpf/states.c

1202

if (slot->iter.state != BPF_ITER_STATE_ACTIVE)

kernel/bpf/states.c

1206

if (cur_slot->iter.depth != slot->iter.depth)

kernel/bpf/states.c

1348

if (iter_state->iter.state == BPF_ITER_STATE_ACTIVE) {

kernel/bpf/states.c

815

if (old_reg->iter.btf != cur_reg->iter.btf ||

kernel/bpf/states.c

816

old_reg->iter.btf_id != cur_reg->iter.btf_id ||

kernel/bpf/states.c

817

old_reg->iter.state != cur_reg->iter.state ||

kernel/bpf/task_iter.c

673

info->iter.task.tid = aux->task.pid;

kernel/bpf/task_iter.c

676

info->iter.task.pid = aux->task.pid;

kernel/bpf/verifier.c

1051

if (st->iter.btf != btf || st->iter.btf_id != btf_id)

kernel/bpf/verifier.c

7431

meta->iter.spi = spi;

kernel/bpf/verifier.c

7432

meta->iter.frameno = reg->frameno;

kernel/bpf/verifier.c

7528

int iter_frameno = meta->iter.frameno;

kernel/bpf/verifier.c

7529

int iter_spi = meta->iter.spi;

kernel/bpf/verifier.c

7623

if (cur_iter->iter.state != BPF_ITER_STATE_ACTIVE &&

kernel/bpf/verifier.c

7624

cur_iter->iter.state != BPF_ITER_STATE_DRAINED) {

kernel/bpf/verifier.c

7626

cur_iter->iter.state, iter_state_str(cur_iter->iter.state));

kernel/bpf/verifier.c

7630

if (cur_iter->iter.state == BPF_ITER_STATE_ACTIVE) {

kernel/bpf/verifier.c

7650

queued_iter->iter.state = BPF_ITER_STATE_ACTIVE;

kernel/bpf/verifier.c

7651

queued_iter->iter.depth++;

kernel/bpf/verifier.c

7661

cur_iter->iter.state = BPF_ITER_STATE_DRAINED;

kernel/bpf/verifier.c

961

st->iter.btf = btf;

kernel/bpf/verifier.c

962

st->iter.btf_id = btf_id;

kernel/bpf/verifier.c

963

st->iter.state = BPF_ITER_STATE_ACTIVE;

kernel/bpf/verifier.c

964

st->iter.depth = 0;

kernel/cgroup/cgroup-internal.h

78

struct css_task_iter iter;

kernel/cgroup/cgroup-v1.c

411

int *iter, ret;

kernel/cgroup/cgroup-v1.c

453

iter = l->list + index;

kernel/cgroup/cgroup-v1.c

454

*pos = *iter;

kernel/cgroup/cgroup-v1.c

455

return iter;

kernel/cgroup/cgroup.c

5251

css_task_iter_end(&ctx->procs.iter);

kernel/cgroup/cgroup.c

5262

return css_task_iter_next(&ctx->procs.iter);

kernel/cgroup/cgroup.c

5271

struct css_task_iter *it = &ctx->procs.iter;

kernel/crash_dump_dm_crypt.c

58

struct iov_iter iter;

kernel/crash_dump_dm_crypt.c

60

iov_iter_kvec(&iter, READ, &kvec, 1, count);

kernel/crash_dump_dm_crypt.c

61

return read_from_oldmem(&iter, count, ppos, cc_platform_has(CC_ATTR_MEM_ENCRYPT));

kernel/debug/kdb/kdb_main.c

2008

struct kmsg_dump_iter iter;

kernel/debug/kdb/kdb_main.c

2028

kmsg_dump_rewind(&iter);

kernel/debug/kdb/kdb_main.c

2029

while (kmsg_dump_get_line(&iter, 1, NULL, 0, NULL))

kernel/debug/kdb/kdb_main.c

2061

kmsg_dump_rewind(&iter);

kernel/debug/kdb/kdb_main.c

2062

while (kmsg_dump_get_line(&iter, 1, buf, sizeof(buf), &len)) {

kernel/events/core.c

11837

struct perf_addr_filter *filter, *iter;

kernel/events/core.c

11839

list_for_each_entry_safe(filter, iter, filters, entry) {

kernel/events/core.c

2260

struct perf_event *iter;

kernel/events/core.c

2266

iter = event->aux_event;

kernel/events/core.c

2268

put_event(iter);

kernel/events/core.c

2276

for_each_sibling_event(iter, event) {

kernel/events/core.c

2277

if (iter->aux_event != event)

kernel/events/core.c

2280

iter->aux_event = NULL;

kernel/events/core.c

2288

__event_disable(iter, ctx, PERF_EVENT_STATE_ERROR);

kernel/events/core.c

9134

struct perf_event *iter;

kernel/events/core.c

9139

list_for_each_entry_rcu(iter, &event->rb->event_list, rb_entry) {

kernel/events/core.c

9146

cpu = iter->cpu;

kernel/events/core.c

9148

cpu = READ_ONCE(iter->oncpu);

kernel/events/hw_breakpoint.c

326

struct perf_event *iter;

kernel/events/hw_breakpoint.c

339

rhl_for_each_entry_rcu(iter, pos, head, hw.bp_list) {

kernel/events/hw_breakpoint.c

340

if (find_slot_idx(iter->attr.bp_type) != type)

kernel/events/hw_breakpoint.c

343

if (iter->cpu >= 0) {

kernel/events/hw_breakpoint.c

347

} else if (cpu != iter->cpu)

kernel/events/hw_breakpoint.c

351

count += hw_breakpoint_weight(iter);

kernel/events/uprobes.c

2527

return_consumer_find(struct return_instance *ri, int *iter, int id)

kernel/events/uprobes.c

2532

for (idx = *iter; idx < ri->cons_cnt; idx++)

kernel/events/uprobes.c

2536

*iter = idx + 1;

kernel/gcov/fs.c

113

struct gcov_iterator *iter;

kernel/gcov/fs.c

119

iter = kvmalloc_flex(*iter, buffer, size);

kernel/gcov/fs.c

120

if (!iter)

kernel/gcov/fs.c

123

iter->info = info;

kernel/gcov/fs.c

124

iter->size = size;

kernel/gcov/fs.c

125

convert_to_gcda(iter->buffer, info);

kernel/gcov/fs.c

127

return iter;

kernel/gcov/fs.c

135

static void gcov_iter_free(struct gcov_iterator *iter)

kernel/gcov/fs.c

137

kvfree(iter);

kernel/gcov/fs.c

144

static struct gcov_info *gcov_iter_get_info(struct gcov_iterator *iter)

kernel/gcov/fs.c

146

return iter->info;

kernel/gcov/fs.c

153

static void gcov_iter_start(struct gcov_iterator *iter)

kernel/gcov/fs.c

155

iter->pos = 0;

kernel/gcov/fs.c

164

static int gcov_iter_next(struct gcov_iterator *iter)

kernel/gcov/fs.c

166

if (iter->pos < iter->size)

kernel/gcov/fs.c

167

iter->pos += ITER_STRIDE;

kernel/gcov/fs.c

169

if (iter->pos >= iter->size)

kernel/gcov/fs.c

182

static int gcov_iter_write(struct gcov_iterator *iter, struct seq_file *seq)

kernel/gcov/fs.c

186

if (iter->pos >= iter->size)

kernel/gcov/fs.c

190

if (iter->pos + len > iter->size)

kernel/gcov/fs.c

191

len = iter->size - iter->pos;

kernel/gcov/fs.c

193

seq_write(seq, iter->buffer + iter->pos, len);

kernel/gcov/fs.c

219

struct gcov_iterator *iter = data;

kernel/gcov/fs.c

222

if (gcov_iter_next(iter))

kernel/gcov/fs.c

225

return iter;

kernel/gcov/fs.c

231

struct gcov_iterator *iter = data;

kernel/gcov/fs.c

233

if (gcov_iter_write(iter, seq))

kernel/gcov/fs.c

291

struct gcov_iterator *iter;

kernel/gcov/fs.c

305

iter = gcov_iter_new(info);

kernel/gcov/fs.c

306

if (!iter)

kernel/gcov/fs.c

312

seq->private = iter;

kernel/gcov/fs.c

318

gcov_iter_free(iter);

kernel/gcov/fs.c

330

struct gcov_iterator *iter;

kernel/gcov/fs.c

335

iter = seq->private;

kernel/gcov/fs.c

336

info = gcov_iter_get_info(iter);

kernel/gcov/fs.c

337

gcov_iter_free(iter);

kernel/jump_label.c

387

struct jump_entry *iter;

kernel/jump_label.c

389

iter = iter_start;

kernel/jump_label.c

390

while (iter < iter_stop) {

kernel/jump_label.c

391

if (init || !jump_entry_is_init(iter)) {

kernel/jump_label.c

392

if (addr_conflict(iter, start, end))

kernel/jump_label.c

395

iter++;

kernel/jump_label.c

530

struct jump_entry *iter;

kernel/jump_label.c

539

for (iter = iter_start; iter < iter_stop; iter++) {

kernel/jump_label.c

544

if (jump_label_type(iter) == JUMP_LABEL_NOP)

kernel/jump_label.c

545

arch_jump_label_transform_static(iter, JUMP_LABEL_NOP);

kernel/jump_label.c

547

in_init = init_section_contains((void *)jump_entry_code(iter), 1);

kernel/jump_label.c

548

jump_entry_set_init(iter, in_init);

kernel/jump_label.c

550

iterk = jump_entry_key(iter);

kernel/jump_label.c

555

static_key_set_entries(key, iter);

kernel/jump_label.c

577

struct jump_entry *iter;

kernel/jump_label.c

585

for (iter = iter_start; iter < iter_stop; iter++) {

kernel/jump_label.c

586

struct static_key *iterk = jump_entry_key(iter);

kernel/jump_label.c

694

struct jump_entry *iter;

kernel/jump_label.c

704

for (iter = iter_start; iter < iter_stop; iter++) {

kernel/jump_label.c

708

in_init = within_module_init(jump_entry_code(iter), mod);

kernel/jump_label.c

709

jump_entry_set_init(iter, in_init);

kernel/jump_label.c

711

iterk = jump_entry_key(iter);

kernel/jump_label.c

717

static_key_set_entries(key, iter);

kernel/jump_label.c

748

jlm->entries = iter;

kernel/jump_label.c

755

if (jump_label_type(iter) != jump_label_init_type(iter))

kernel/jump_label.c

756

__jump_label_update(key, iter, iter_stop, true);

kernel/jump_label.c

766

struct jump_entry *iter;

kernel/jump_label.c

770

for (iter = iter_start; iter < iter_stop; iter++) {

kernel/jump_label.c

771

if (jump_entry_key(iter) == key)

kernel/jump_label.c

774

key = jump_entry_key(iter);

kernel/kallsyms.c

608

static int get_ksymbol_mod(struct kallsym_iter *iter)

kernel/kallsyms.c

610

int ret = module_get_kallsym(iter->pos - kallsyms_num_syms,

kernel/kallsyms.c

611

&iter->value, &iter->type,

kernel/kallsyms.c

612

iter->name, iter->module_name,

kernel/kallsyms.c

613

&iter->exported);

kernel/kallsyms.c

615

iter->pos_mod_end = iter->pos;

kernel/kallsyms.c

627

static int get_ksymbol_ftrace_mod(struct kallsym_iter *iter)

kernel/kallsyms.c

629

int ret = ftrace_mod_get_kallsym(iter->pos - iter->pos_mod_end,

kernel/kallsyms.c

630

&iter->value, &iter->type,

kernel/kallsyms.c

631

iter->name, iter->module_name,

kernel/kallsyms.c

632

&iter->exported);

kernel/kallsyms.c

634

iter->pos_ftrace_mod_end = iter->pos;

kernel/kallsyms.c

641

static int get_ksymbol_bpf(struct kallsym_iter *iter)

kernel/kallsyms.c

645

strscpy(iter->module_name, "bpf", MODULE_NAME_LEN);

kernel/kallsyms.c

646

iter->exported = 0;

kernel/kallsyms.c

647

ret = bpf_get_kallsym(iter->pos - iter->pos_ftrace_mod_end,

kernel/kallsyms.c

648

&iter->value, &iter->type,

kernel/kallsyms.c

649

iter->name);

kernel/kallsyms.c

651

iter->pos_bpf_end = iter->pos;

kernel/kallsyms.c

663

static int get_ksymbol_kprobe(struct kallsym_iter *iter)

kernel/kallsyms.c

665

strscpy(iter->module_name, "__builtin__kprobes", MODULE_NAME_LEN);

kernel/kallsyms.c

666

iter->exported = 0;

kernel/kallsyms.c

667

return kprobe_get_kallsym(iter->pos - iter->pos_bpf_end,

kernel/kallsyms.c

668

&iter->value, &iter->type,

kernel/kallsyms.c

669

iter->name) < 0 ? 0 : 1;

kernel/kallsyms.c

673

static unsigned long get_ksymbol_core(struct kallsym_iter *iter)

kernel/kallsyms.c

675

unsigned off = iter->nameoff;

kernel/kallsyms.c

677

iter->module_name[0] = '\0';

kernel/kallsyms.c

678

iter->value = kallsyms_sym_address(iter->pos);

kernel/kallsyms.c

680

iter->type = kallsyms_get_symbol_type(off);

kernel/kallsyms.c

682

off = kallsyms_expand_symbol(off, iter->name, ARRAY_SIZE(iter->name));

kernel/kallsyms.c

684

return off - iter->nameoff;

kernel/kallsyms.c

687

static void reset_iter(struct kallsym_iter *iter, loff_t new_pos)

kernel/kallsyms.c

689

iter->name[0] = '\0';

kernel/kallsyms.c

690

iter->nameoff = get_symbol_offset(new_pos);

kernel/kallsyms.c

691

iter->pos = new_pos;

kernel/kallsyms.c

693

iter->pos_mod_end = 0;

kernel/kallsyms.c

694

iter->pos_ftrace_mod_end = 0;

kernel/kallsyms.c

695

iter->pos_bpf_end = 0;

kernel/kallsyms.c

704

static int update_iter_mod(struct kallsym_iter *iter, loff_t pos)

kernel/kallsyms.c

706

iter->pos = pos;

kernel/kallsyms.c

708

if ((!iter->pos_mod_end || iter->pos_mod_end > pos) &&

kernel/kallsyms.c

709

get_ksymbol_mod(iter))

kernel/kallsyms.c

712

if ((!iter->pos_ftrace_mod_end || iter->pos_ftrace_mod_end > pos) &&

kernel/kallsyms.c

713

get_ksymbol_ftrace_mod(iter))

kernel/kallsyms.c

716

if ((!iter->pos_bpf_end || iter->pos_bpf_end > pos) &&

kernel/kallsyms.c

717

get_ksymbol_bpf(iter))

kernel/kallsyms.c

720

return get_ksymbol_kprobe(iter);

kernel/kallsyms.c

724

static int update_iter(struct kallsym_iter *iter, loff_t pos)

kernel/kallsyms.c

728

return update_iter_mod(iter, pos);

kernel/kallsyms.c

731

if (pos != iter->pos)

kernel/kallsyms.c

732

reset_iter(iter, pos);

kernel/kallsyms.c

734

iter->nameoff += get_ksymbol_core(iter);

kernel/kallsyms.c

735

iter->pos++;

kernel/kallsyms.c

763

struct kallsym_iter *iter = m->private;

kernel/kallsyms.c

766

if (!iter->name[0])

kernel/kallsyms.c

769

value = iter->show_value ? (void *)iter->value : NULL;

kernel/kallsyms.c

771

if (iter->module_name[0]) {

kernel/kallsyms.c

778

type = iter->exported ? toupper(iter->type) :

kernel/kallsyms.c

779

tolower(iter->type);

kernel/kallsyms.c

781

type, iter->name, iter->module_name);

kernel/kallsyms.c

784

iter->type, iter->name);

kernel/kallsyms.c

840

struct kallsym_iter *iter = priv_data;

kernel/kallsyms.c

842

reset_iter(iter, 0);

kernel/kallsyms.c

847

iter->show_value = kallsyms_show_value(current_cred());

kernel/kallsyms.c

891

struct kallsym_iter *iter;

kernel/kallsyms.c

892

iter = __seq_open_private(file, &kallsyms_op, sizeof(*iter));

kernel/kallsyms.c

893

if (!iter)

kernel/kallsyms.c

895

reset_iter(iter, 0);

kernel/kallsyms.c

901

iter->show_value = kallsyms_show_value(file->f_cred);

kernel/kcsan/kcsan_test.c

323

static noinline void test_delay(int iter)

kernel/kcsan/kcsan_test.c

325

while (iter--)

kernel/kprobes.c

2572

unsigned long *iter;

kernel/kprobes.c

2575

for (iter = start; iter < end; iter++) {

kernel/kprobes.c

2576

entry = (unsigned long)dereference_symbol_descriptor((void *)*iter);

kernel/liveupdate/luo_file.c

180

struct luo_file *iter;

kernel/liveupdate/luo_file.c

182

list_for_each_entry(iter, &file_set->files_list, list) {

kernel/liveupdate/luo_file.c

183

if (iter->token == token)

kernel/liveupdate/luo_flb.c

252

struct luo_flb_link *iter;

kernel/liveupdate/luo_flb.c

256

list_for_each_entry(iter, flb_list, list) {

kernel/liveupdate/luo_flb.c

257

err = luo_flb_file_preserve_one(iter->flb);

kernel/liveupdate/luo_flb.c

266

list_for_each_entry_continue_reverse(iter, flb_list, list)

kernel/liveupdate/luo_flb.c

267

luo_flb_file_unpreserve_one(iter->flb);

kernel/liveupdate/luo_flb.c

288

struct luo_flb_link *iter;

kernel/liveupdate/luo_flb.c

291

list_for_each_entry_reverse(iter, flb_list, list)

kernel/liveupdate/luo_flb.c

292

luo_flb_file_unpreserve_one(iter->flb);

kernel/liveupdate/luo_flb.c

309

struct luo_flb_link *iter;

kernel/liveupdate/luo_flb.c

312

list_for_each_entry_reverse(iter, flb_list, list)

kernel/liveupdate/luo_flb.c

313

liveupdate_flb_put_incoming(iter->flb);

kernel/liveupdate/luo_flb.c

321

struct luo_flb_link *iter;

kernel/liveupdate/luo_flb.c

325

list_for_each_entry(iter, flb_list, list) {

kernel/liveupdate/luo_flb.c

326

if (iter->flb == flb) {

kernel/liveupdate/luo_flb.c

327

list_del(&iter->list);

kernel/liveupdate/luo_flb.c

328

kfree(iter);

kernel/liveupdate/luo_flb.c

362

struct luo_flb_link *iter, *tmp;

kernel/liveupdate/luo_flb.c

368

list_for_each_entry_safe(iter, tmp, flb_list, list)

kernel/liveupdate/luo_flb.c

369

luo_flb_unregister_one(fh, iter->flb);

kernel/liveupdate/luo_flb.c

401

struct luo_flb_link *iter;

kernel/liveupdate/luo_flb.c

425

list_for_each_entry(iter, flb_list, list) {

kernel/liveupdate/luo_flb.c

426

if (iter->flb == flb)

kernel/locking/lockdep_proc.c

602

struct lock_stat_data *iter;

kernel/locking/lockdep_proc.c

607

iter = data->stats + (*pos - 1);

kernel/locking/lockdep_proc.c

608

if (iter >= data->iter_end)

kernel/locking/lockdep_proc.c

609

iter = NULL;

kernel/locking/lockdep_proc.c

611

return iter;

kernel/locking/lockdep_proc.c

652

struct lock_stat_data *iter = data->stats;

kernel/locking/lockdep_proc.c

659

iter->class = class;

kernel/locking/lockdep_proc.c

660

lock_stats(class, &iter->stats);

kernel/locking/lockdep_proc.c

661

iter++;

kernel/locking/lockdep_proc.c

664

data->iter_end = iter;

kernel/printk/printk.c

4898

bool kmsg_dump_get_line(struct kmsg_dump_iter *iter, bool syslog,

kernel/printk/printk.c

4908

if (iter->cur_seq < min_seq)

kernel/printk/printk.c

4909

iter->cur_seq = min_seq;

kernel/printk/printk.c

4915

if (!prb_read_valid(prb, iter->cur_seq, &r))

kernel/printk/printk.c

4919

if (!prb_read_valid_info(prb, iter->cur_seq,

kernel/printk/printk.c

4928

iter->cur_seq = r.info->seq + 1;

kernel/printk/printk.c

4956

bool kmsg_dump_get_buffer(struct kmsg_dump_iter *iter, bool syslog,

kernel/printk/printk.c

4971

if (iter->cur_seq < min_seq)

kernel/printk/printk.c

4972

iter->cur_seq = min_seq;

kernel/printk/printk.c

4974

if (prb_read_valid_info(prb, iter->cur_seq, &info, NULL)) {

kernel/printk/printk.c

4975

if (info.seq != iter->cur_seq) {

kernel/printk/printk.c

4977

iter->cur_seq = info.seq;

kernel/printk/printk.c

4982

if (iter->cur_seq >= iter->next_seq)

kernel/printk/printk.c

4991

seq = find_first_fitting_seq(iter->cur_seq, iter->next_seq,

kernel/printk/printk.c

5003

if (r.info->seq >= iter->next_seq)

kernel/printk/printk.c

5012

iter->next_seq = next_seq;

kernel/printk/printk.c

5029

void kmsg_dump_rewind(struct kmsg_dump_iter *iter)

kernel/printk/printk.c

5031

iter->cur_seq = latched_seq_read_nolock(&clear_seq);

kernel/printk/printk.c

5032

iter->next_seq = prb_next_seq(prb);

kernel/rcu/rcutorture.c

3316

static void rcu_torture_fwd_prog_cond_resched(unsigned long iter)

kernel/rcu/rcutorture.c

3320

if (need_resched() || (iter & 0xfff))

kernel/sched/ext/ext.c

781

static void scx_task_iter_start(struct scx_task_iter *iter, struct cgroup *cgrp)

kernel/sched/ext/ext.c

783

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

kernel/sched/ext/ext.c

788

iter->cgrp = cgrp;

kernel/sched/ext/ext.c

789

iter->css_pos = css_next_descendant_pre(NULL, &iter->cgrp->self);

kernel/sched/ext/ext.c

790

css_task_iter_start(iter->css_pos, CSS_TASK_ITER_WITH_DEAD,

kernel/sched/ext/ext.c

791

&iter->css_iter);

kernel/sched/ext/ext.c

797

iter->cursor = (struct sched_ext_entity){ .flags = SCX_TASK_CURSOR };

kernel/sched/ext/ext.c

798

list_add(&iter->cursor.tasks_node, &scx_tasks);

kernel/sched/ext/ext.c

799

iter->list_locked = true;

kernel/sched/ext/ext.c

802

static void __scx_task_iter_rq_unlock(struct scx_task_iter *iter)

kernel/sched/ext/ext.c

804

if (iter->locked_task) {

kernel/sched/ext/ext.c

805

__balance_callbacks(iter->rq, &iter->rf);

kernel/sched/ext/ext.c

806

task_rq_unlock(iter->rq, iter->locked_task, &iter->rf);

kernel/sched/ext/ext.c

807

iter->locked_task = NULL;

kernel/sched/ext/ext.c

820

static void scx_task_iter_unlock(struct scx_task_iter *iter)

kernel/sched/ext/ext.c

822

__scx_task_iter_rq_unlock(iter);

kernel/sched/ext/ext.c

823

if (iter->list_locked) {

kernel/sched/ext/ext.c

824

iter->list_locked = false;

kernel/sched/ext/ext.c

829

static void __scx_task_iter_maybe_relock(struct scx_task_iter *iter)

kernel/sched/ext/ext.c

831

if (!iter->list_locked) {

kernel/sched/ext/ext.c

833

iter->list_locked = true;

kernel/sched/ext/ext.c

845

static void scx_task_iter_relock(struct scx_task_iter *iter,

kernel/sched/ext/ext.c

848

__scx_task_iter_maybe_relock(iter);

kernel/sched/ext/ext.c

850

iter->rq = task_rq_lock(p, &iter->rf);

kernel/sched/ext/ext.c

851

iter->locked_task = p;

kernel/sched/ext/ext.c

863

static void scx_task_iter_stop(struct scx_task_iter *iter)

kernel/sched/ext/ext.c

866

if (iter->cgrp) {

kernel/sched/ext/ext.c

867

if (iter->css_pos)

kernel/sched/ext/ext.c

868

css_task_iter_end(&iter->css_iter);

kernel/sched/ext/ext.c

869

__scx_task_iter_rq_unlock(iter);

kernel/sched/ext/ext.c

873

__scx_task_iter_maybe_relock(iter);

kernel/sched/ext/ext.c

874

list_del_init(&iter->cursor.tasks_node);

kernel/sched/ext/ext.c

875

scx_task_iter_unlock(iter);

kernel/sched/ext/ext.c

886

static struct task_struct *scx_task_iter_next(struct scx_task_iter *iter)

kernel/sched/ext/ext.c

888

struct list_head *cursor = &iter->cursor.tasks_node;

kernel/sched/ext/ext.c

891

if (!(++iter->cnt % SCX_TASK_ITER_BATCH)) {

kernel/sched/ext/ext.c

892

scx_task_iter_unlock(iter);

kernel/sched/ext/ext.c

897

if (iter->cgrp) {

kernel/sched/ext/ext.c

898

while (iter->css_pos) {

kernel/sched/ext/ext.c

901

p = css_task_iter_next(&iter->css_iter);

kernel/sched/ext/ext.c

905

css_task_iter_end(&iter->css_iter);

kernel/sched/ext/ext.c

906

iter->css_pos = css_next_descendant_pre(iter->css_pos,

kernel/sched/ext/ext.c

907

&iter->cgrp->self);

kernel/sched/ext/ext.c

908

if (iter->css_pos)

kernel/sched/ext/ext.c

909

css_task_iter_start(iter->css_pos, CSS_TASK_ITER_WITH_DEAD,

kernel/sched/ext/ext.c

910

&iter->css_iter);

kernel/sched/ext/ext.c

915

__scx_task_iter_maybe_relock(iter);

kernel/sched/ext/ext.c

938

static struct task_struct *scx_task_iter_next_locked(struct scx_task_iter *iter)

kernel/sched/ext/ext.c

942

__scx_task_iter_rq_unlock(iter);

kernel/sched/ext/ext.c

944

while ((p = scx_task_iter_next(iter))) {

kernel/sched/ext/ext.c

973

iter->rq = task_rq_lock(p, &iter->rf);

kernel/sched/ext/ext.c

974

iter->locked_task = p;

kernel/sched/ext/ext.c

984

__scx_task_iter_rq_unlock(iter);

kernel/sched/psi.c

793

#define for_each_group(iter, group) \

kernel/sched/psi.c

794

for (typeof(group) iter = group; iter; iter = iter->parent)

kernel/sched/rt.c

2938

rt_rq_iter_t iter;

kernel/sched/rt.c

2942

for_each_rt_rq(rt_rq, iter, cpu_rq(cpu))

kernel/sched/rt.c

511

#define for_each_rt_rq(rt_rq, iter, rq) \

kernel/sched/rt.c

512

for (iter = &root_task_group; \

kernel/sched/rt.c

513

iter && (rt_rq = iter->rt_rq[cpu_of(rq)]); \

kernel/sched/rt.c

514

iter = next_task_group(iter))

kernel/sched/rt.c

620

struct rt_rq *iter = sched_rt_period_rt_rq(rt_b, i);

kernel/sched/rt.c

623

if (iter == rt_rq)

kernel/sched/rt.c

626

raw_spin_lock(&iter->rt_runtime_lock);

kernel/sched/rt.c

632

if (iter->rt_runtime == RUNTIME_INF)

kernel/sched/rt.c

639

diff = iter->rt_runtime - iter->rt_time;

kernel/sched/rt.c

644

iter->rt_runtime -= diff;

kernel/sched/rt.c

647

raw_spin_unlock(&iter->rt_runtime_lock);

kernel/sched/rt.c

652

raw_spin_unlock(&iter->rt_runtime_lock);

kernel/sched/rt.c

663

rt_rq_iter_t iter;

kernel/sched/rt.c

669

for_each_rt_rq(rt_rq, iter, rq) {

kernel/sched/rt.c

697

struct rt_rq *iter = sched_rt_period_rt_rq(rt_b, i);

kernel/sched/rt.c

703

if (iter == rt_rq || iter->rt_runtime == RUNTIME_INF)

kernel/sched/rt.c

706

raw_spin_lock(&iter->rt_runtime_lock);

kernel/sched/rt.c

708

diff = min_t(s64, iter->rt_runtime, want);

kernel/sched/rt.c

709

iter->rt_runtime -= diff;

kernel/sched/rt.c

712

iter->rt_runtime -= want;

kernel/sched/rt.c

715

raw_spin_unlock(&iter->rt_runtime_lock);

kernel/sched/rt.c

744

rt_rq_iter_t iter;

kernel/sched/rt.c

753

for_each_rt_rq(rt_rq, iter, rq) {

kernel/sched/rt.c

910

#define for_each_rt_rq(rt_rq, iter, rq) \

kernel/sched/rt.c

911

for ((void) iter, rt_rq = &rq->rt; rt_rq; rt_rq = NULL)

kernel/static_call_inline.c

308

struct static_call_site *iter = iter_start;

kernel/static_call_inline.c

310

while (iter < iter_stop) {

kernel/static_call_inline.c

311

if (init || !static_call_is_init(iter)) {

kernel/static_call_inline.c

312

if (addr_conflict(iter, start, end))

kernel/static_call_inline.c

315

iter++;

kernel/time/clockevents.c

743

struct clock_event_device *ce = NULL, *iter;

kernel/time/clockevents.c

751

list_for_each_entry(iter, &clockevent_devices, list) {

kernel/time/clockevents.c

752

if (!strcmp(iter->name, name)) {

kernel/time/clockevents.c

753

ret = __clockevents_try_unbind(iter, dev->id);

kernel/time/clockevents.c

754

ce = iter;

kernel/time/timer_list.c

282

struct timer_list_iter *iter = v;

kernel/time/timer_list.c

284

if (iter->cpu == -1 && !iter->second_pass)

kernel/time/timer_list.c

285

timer_list_header(m, iter->now);

kernel/time/timer_list.c

286

else if (!iter->second_pass)

kernel/time/timer_list.c

287

print_cpu(m, iter->cpu, iter->now);

kernel/time/timer_list.c

289

else if (iter->cpu == -1 && iter->second_pass)

kernel/time/timer_list.c

292

print_tickdevice(m, tick_get_device(iter->cpu), iter->cpu);

kernel/time/timer_list.c

297

static void *move_iter(struct timer_list_iter *iter, loff_t offset)

kernel/time/timer_list.c

300

iter->cpu = cpumask_next(iter->cpu, cpu_online_mask);

kernel/time/timer_list.c

301

if (iter->cpu >= nr_cpu_ids) {

kernel/time/timer_list.c

303

if (!iter->second_pass) {

kernel/time/timer_list.c

304

iter->cpu = -1;

kernel/time/timer_list.c

305

iter->second_pass = true;

kernel/time/timer_list.c

313

return iter;

kernel/time/timer_list.c

318

struct timer_list_iter *iter = file->private;

kernel/time/timer_list.c

321

iter->now = ktime_to_ns(ktime_get());

kernel/time/timer_list.c

322

iter->cpu = -1;

kernel/time/timer_list.c

323

iter->second_pass = false;

kernel/time/timer_list.c

324

return move_iter(iter, *offset);

kernel/time/timer_list.c

329

struct timer_list_iter *iter = file->private;

kernel/time/timer_list.c

331

return move_iter(iter, 1);

kernel/time/timer_migration.c

1489

struct tmigr_hierarchy *iter;

kernel/time/timer_migration.c

1491

list_for_each_entry(iter, &tmigr_hierarchy_list, node) {

kernel/time/timer_migration.c

1492

if (iter->capacity == capacity)

kernel/time/timer_migration.c

1493

return iter;

kernel/trace/blktrace.c

1490

typedef void (blk_log_action_t) (struct trace_iterator *iter, const char *act,

kernel/trace/blktrace.c

1493

static void blk_log_action_classic(struct trace_iterator *iter, const char *act,

kernel/trace/blktrace.c

1497

unsigned long long ts = iter->ts;

kernel/trace/blktrace.c

1500

const struct blk_io_trace2 *t = te_blk_io_trace(iter->ent);

kernel/trace/blktrace.c

1504

trace_seq_printf(&iter->seq,

kernel/trace/blktrace.c

1506

MAJOR(t->device), MINOR(t->device), iter->cpu,

kernel/trace/blktrace.c

1507

secs, nsec_rem, iter->ent->pid, act, rwbs);

kernel/trace/blktrace.c

1510

static void blk_log_action(struct trace_iterator *iter, const char *act,

kernel/trace/blktrace.c

1514

const struct blk_io_trace2 *t = te_blk_io_trace(iter->ent);

kernel/trace/blktrace.c

1518

u64 id = t_cgid(iter->ent);

kernel/trace/blktrace.c

1525

trace_seq_printf(&iter->seq, "%3d,%-3d %s %2s %3s ",

kernel/trace/blktrace.c

1542

trace_seq_printf(&iter->seq,

kernel/trace/blktrace.c

1548

trace_seq_printf(&iter->seq, "%3d,%-3d %2s %3s ",

kernel/trace/blktrace.c

1730

static enum print_line_t print_one_line(struct trace_iterator *iter,

kernel/trace/blktrace.c

1733

struct trace_array *tr = iter->tr;

kernel/trace/blktrace.c

1734

struct trace_seq *s = &iter->seq;

kernel/trace/blktrace.c

1741

t = te_blk_io_trace(iter->ent);

kernel/trace/blktrace.c

1748

log_action(iter, long_act ? "message" : "m", has_cg);

kernel/trace/blktrace.c

1749

blk_log_msg(s, iter->ent, has_cg);

kernel/trace/blktrace.c

1756

log_action(iter, what2act[what].act[long_act], has_cg);

kernel/trace/blktrace.c

1757

what2act[what].print(s, iter->ent, has_cg);

kernel/trace/blktrace.c

1763

static enum print_line_t blk_trace_event_print(struct trace_iterator *iter,

kernel/trace/blktrace.c

1766

return print_one_line(iter, false);

kernel/trace/blktrace.c

1769

static void blk_trace_synthesize_old_trace(struct trace_iterator *iter)

kernel/trace/blktrace.c

1771

struct trace_seq *s = &iter->seq;

kernel/trace/blktrace.c

1772

struct blk_io_trace2 *t = (struct blk_io_trace2 *)iter->ent;

kernel/trace/blktrace.c

1776

.time = iter->ts,

kernel/trace/blktrace.c

1785

blk_trace_event_print_binary(struct trace_iterator *iter, int flags,

kernel/trace/blktrace.c

1788

blk_trace_synthesize_old_trace(iter);

kernel/trace/blktrace.c

1790

return trace_handle_return(&iter->seq);

kernel/trace/blktrace.c

1793

static enum print_line_t blk_tracer_print_line(struct trace_iterator *iter)

kernel/trace/blktrace.c

1795

if ((iter->ent->type != TRACE_BLK) ||

kernel/trace/blktrace.c

1799

return print_one_line(iter, true);

kernel/trace/fprobe.c

727

struct rhashtable_iter iter;

kernel/trace/fprobe.c

748

rhltable_walk_enter(&fprobe_ip_table, &iter);

kernel/trace/fprobe.c

750

rhashtable_walk_start(&iter);

kernel/trace/fprobe.c

752

while ((node = rhashtable_walk_next(&iter)) && !IS_ERR(node))

kernel/trace/fprobe.c

758

rhashtable_walk_stop(&iter);

kernel/trace/fprobe.c

760

rhashtable_walk_exit(&iter);

kernel/trace/ftrace.c

2838

struct ftrace_rec_iter *iter = &ftrace_rec_iter;

kernel/trace/ftrace.c

2840

iter->pg = ftrace_pages_start;

kernel/trace/ftrace.c

2841

iter->index = 0;

kernel/trace/ftrace.c

2844

while (iter->pg && !iter->pg->index)

kernel/trace/ftrace.c

2845

iter->pg = iter->pg->next;

kernel/trace/ftrace.c

2847

if (!iter->pg)

kernel/trace/ftrace.c

2850

return iter;

kernel/trace/ftrace.c

2859

struct ftrace_rec_iter *ftrace_rec_iter_next(struct ftrace_rec_iter *iter)

kernel/trace/ftrace.c

2861

iter->index++;

kernel/trace/ftrace.c

2863

if (iter->index >= iter->pg->index) {

kernel/trace/ftrace.c

2864

iter->pg = iter->pg->next;

kernel/trace/ftrace.c

2865

iter->index = 0;

kernel/trace/ftrace.c

2868

while (iter->pg && !iter->pg->index)

kernel/trace/ftrace.c

2869

iter->pg = iter->pg->next;

kernel/trace/ftrace.c

2872

if (!iter->pg)

kernel/trace/ftrace.c

2875

return iter;

kernel/trace/ftrace.c

2884

struct dyn_ftrace *ftrace_rec_iter_record(struct ftrace_rec_iter *iter)

kernel/trace/ftrace.c

2886

return &iter->pg->records[iter->index];

kernel/trace/ftrace.c

3994

struct ftrace_iterator *iter = m->private;

kernel/trace/ftrace.c

3995

struct trace_array *tr = iter->ops->private;

kernel/trace/ftrace.c

4004

iter->pos = *pos;

kernel/trace/ftrace.c

4013

if (!iter->probe) {

kernel/trace/ftrace.c

4015

iter->probe = list_entry(next, struct ftrace_func_probe, list);

kernel/trace/ftrace.c

4018

if (iter->probe_entry)

kernel/trace/ftrace.c

4019

hnd = &iter->probe_entry->hlist;

kernel/trace/ftrace.c

4021

hash = iter->probe->ops.func_hash->filter_hash;

kernel/trace/ftrace.c

4033

if (iter->pidx >= size) {

kernel/trace/ftrace.c

4034

if (iter->probe->list.next == func_probes)

kernel/trace/ftrace.c

4036

next = iter->probe->list.next;

kernel/trace/ftrace.c

4037

iter->probe = list_entry(next, struct ftrace_func_probe, list);

kernel/trace/ftrace.c

4038

hash = iter->probe->ops.func_hash->filter_hash;

kernel/trace/ftrace.c

4040

iter->pidx = 0;

kernel/trace/ftrace.c

4043

hhd = &hash->buckets[iter->pidx];

kernel/trace/ftrace.c

4046

iter->pidx++;

kernel/trace/ftrace.c

4056

iter->pidx++;

kernel/trace/ftrace.c

4064

iter->probe_entry = hlist_entry(hnd, struct ftrace_func_entry, hlist);

kernel/trace/ftrace.c

4066

return iter;

kernel/trace/ftrace.c

4071

struct ftrace_iterator *iter = m->private;

kernel/trace/ftrace.c

4075

if (!(iter->flags & FTRACE_ITER_DO_PROBES))

kernel/trace/ftrace.c

4078

if (iter->mod_pos > *pos)

kernel/trace/ftrace.c

4081

iter->probe = NULL;

kernel/trace/ftrace.c

4082

iter->probe_entry = NULL;

kernel/trace/ftrace.c

4083

iter->pidx = 0;

kernel/trace/ftrace.c

4084

for (l = 0; l <= (*pos - iter->mod_pos); ) {

kernel/trace/ftrace.c

4093

iter->flags |= FTRACE_ITER_PROBE;

kernel/trace/ftrace.c

4095

return iter;

kernel/trace/ftrace.c

4099

t_probe_show(struct seq_file *m, struct ftrace_iterator *iter)

kernel/trace/ftrace.c

4105

probe = iter->probe;

kernel/trace/ftrace.c

4106

probe_entry = iter->probe_entry;

kernel/trace/ftrace.c

4125

struct ftrace_iterator *iter = m->private;

kernel/trace/ftrace.c

4126

struct trace_array *tr = iter->tr;

kernel/trace/ftrace.c

4129

iter->pos = *pos;

kernel/trace/ftrace.c

4131

iter->mod_list = iter->mod_list->next;

kernel/trace/ftrace.c

4133

if (iter->mod_list == &tr->mod_trace ||

kernel/trace/ftrace.c

4134

iter->mod_list == &tr->mod_notrace) {

kernel/trace/ftrace.c

4135

iter->flags &= ~FTRACE_ITER_MOD;

kernel/trace/ftrace.c

4139

iter->mod_pos = *pos;

kernel/trace/ftrace.c

4141

return iter;

kernel/trace/ftrace.c

4146

struct ftrace_iterator *iter = m->private;

kernel/trace/ftrace.c

4150

if (iter->func_pos > *pos)

kernel/trace/ftrace.c

4153

iter->mod_pos = iter->func_pos;

kernel/trace/ftrace.c

4156

if (!iter->tr)

kernel/trace/ftrace.c

4159

for (l = 0; l <= (*pos - iter->func_pos); ) {

kernel/trace/ftrace.c

4165

iter->flags &= ~FTRACE_ITER_MOD;

kernel/trace/ftrace.c

4170

iter->flags |= FTRACE_ITER_MOD;

kernel/trace/ftrace.c

4172

return iter;

kernel/trace/ftrace.c

4176

t_mod_show(struct seq_file *m, struct ftrace_iterator *iter)

kernel/trace/ftrace.c

4179

struct trace_array *tr = iter->tr;

kernel/trace/ftrace.c

4181

if (WARN_ON_ONCE(!iter->mod_list) ||

kernel/trace/ftrace.c

4182

iter->mod_list == &tr->mod_trace ||

kernel/trace/ftrace.c

4183

iter->mod_list == &tr->mod_notrace)

kernel/trace/ftrace.c

4186

ftrace_mod = list_entry(iter->mod_list, struct ftrace_mod_load, list);

kernel/trace/ftrace.c

4201

struct ftrace_iterator *iter = m->private;

kernel/trace/ftrace.c

4207

if (iter->idx >= iter->pg->index) {

kernel/trace/ftrace.c

4208

if (iter->pg->next) {

kernel/trace/ftrace.c

4209

iter->pg = iter->pg->next;

kernel/trace/ftrace.c

4210

iter->idx = 0;

kernel/trace/ftrace.c

4214

rec = &iter->pg->records[iter->idx++];

kernel/trace/ftrace.c

4215

if (((iter->flags & (FTRACE_ITER_FILTER | FTRACE_ITER_NOTRACE)) &&

kernel/trace/ftrace.c

4216

!ftrace_lookup_ip(iter->hash, rec->ip)) ||

kernel/trace/ftrace.c

4218

((iter->flags & FTRACE_ITER_ENABLED) &&

kernel/trace/ftrace.c

4221

((iter->flags & FTRACE_ITER_TOUCHED) &&

kernel/trace/ftrace.c

4232

iter->pos = iter->func_pos = *pos;

kernel/trace/ftrace.c

4233

iter->func = rec;

kernel/trace/ftrace.c

4235

return iter;

kernel/trace/ftrace.c

4241

struct ftrace_iterator *iter = m->private;

kernel/trace/ftrace.c

4248

if (iter->flags & FTRACE_ITER_PROBE)

kernel/trace/ftrace.c

4251

if (iter->flags & FTRACE_ITER_MOD)

kernel/trace/ftrace.c

4254

if (iter->flags & FTRACE_ITER_PRINTALL) {

kernel/trace/ftrace.c

4268

static void reset_iter_read(struct ftrace_iterator *iter)

kernel/trace/ftrace.c

4270

iter->pos = 0;

kernel/trace/ftrace.c

4271

iter->func_pos = 0;

kernel/trace/ftrace.c

4272

iter->flags &= ~(FTRACE_ITER_PRINTALL | FTRACE_ITER_PROBE | FTRACE_ITER_MOD);

kernel/trace/ftrace.c

4277

struct ftrace_iterator *iter = m->private;

kernel/trace/ftrace.c

4289

if (*pos < iter->pos)

kernel/trace/ftrace.c

4290

reset_iter_read(iter);

kernel/trace/ftrace.c

4297

if ((iter->flags & (FTRACE_ITER_FILTER | FTRACE_ITER_NOTRACE)) &&

kernel/trace/ftrace.c

4298

ftrace_hash_empty(iter->hash)) {

kernel/trace/ftrace.c

4299

iter->func_pos = 1; /* Account for the message */

kernel/trace/ftrace.c

4302

iter->flags |= FTRACE_ITER_PRINTALL;

kernel/trace/ftrace.c

4304

iter->flags &= ~FTRACE_ITER_PROBE;

kernel/trace/ftrace.c

4305

return iter;

kernel/trace/ftrace.c

4308

if (iter->flags & FTRACE_ITER_MOD)

kernel/trace/ftrace.c

4316

iter->pg = ftrace_pages_start;

kernel/trace/ftrace.c

4317

iter->idx = 0;

kernel/trace/ftrace.c

4327

return iter;

kernel/trace/ftrace.c

4488

struct ftrace_iterator *iter = m->private;

kernel/trace/ftrace.c

4491

if (iter->flags & FTRACE_ITER_PROBE)

kernel/trace/ftrace.c

4492

return t_probe_show(m, iter);

kernel/trace/ftrace.c

4494

if (iter->flags & FTRACE_ITER_MOD)

kernel/trace/ftrace.c

4495

return t_mod_show(m, iter);

kernel/trace/ftrace.c

4497

if (iter->flags & FTRACE_ITER_PRINTALL) {

kernel/trace/ftrace.c

4498

if (iter->flags & FTRACE_ITER_NOTRACE)

kernel/trace/ftrace.c

4505

rec = iter->func;

kernel/trace/ftrace.c

4510

if (iter->flags & FTRACE_ITER_ADDRS)

kernel/trace/ftrace.c

4520

if (iter->flags & (FTRACE_ITER_ENABLED | FTRACE_ITER_TOUCHED)) {

kernel/trace/ftrace.c

4583

struct ftrace_iterator *iter;

kernel/trace/ftrace.c

4593

iter = __seq_open_private(file, &show_ftrace_seq_ops, sizeof(*iter));

kernel/trace/ftrace.c

4594

if (!iter)

kernel/trace/ftrace.c

4597

iter->pg = ftrace_pages_start;

kernel/trace/ftrace.c

4598

iter->ops = &global_ops;

kernel/trace/ftrace.c

4606

struct ftrace_iterator *iter;

kernel/trace/ftrace.c

4617

iter = __seq_open_private(file, &show_ftrace_seq_ops, sizeof(*iter));

kernel/trace/ftrace.c

4618

if (!iter)

kernel/trace/ftrace.c

4621

iter->pg = ftrace_pages_start;

kernel/trace/ftrace.c

4622

iter->flags = FTRACE_ITER_ENABLED;

kernel/trace/ftrace.c

4623

iter->ops = &global_ops;

kernel/trace/ftrace.c

4631

struct ftrace_iterator *iter;

kernel/trace/ftrace.c

4642

iter = __seq_open_private(file, &show_ftrace_seq_ops, sizeof(*iter));

kernel/trace/ftrace.c

4643

if (!iter)

kernel/trace/ftrace.c

4646

iter->pg = ftrace_pages_start;

kernel/trace/ftrace.c

4647

iter->flags = FTRACE_ITER_TOUCHED;

kernel/trace/ftrace.c

4648

iter->ops = &global_ops;

kernel/trace/ftrace.c

4656

struct ftrace_iterator *iter;

kernel/trace/ftrace.c

4666

iter = __seq_open_private(file, &show_ftrace_seq_ops, sizeof(*iter));

kernel/trace/ftrace.c

4667

if (!iter)

kernel/trace/ftrace.c

4670

iter->pg = ftrace_pages_start;

kernel/trace/ftrace.c

4671

iter->flags = FTRACE_ITER_ADDRS;

kernel/trace/ftrace.c

4672

iter->ops = &global_ops;

kernel/trace/ftrace.c

4699

struct ftrace_iterator *iter;

kernel/trace/ftrace.c

4713

iter = kzalloc_obj(*iter);

kernel/trace/ftrace.c

4714

if (!iter)

kernel/trace/ftrace.c

4717

if (trace_parser_get_init(&iter->parser, FTRACE_BUFF_MAX))

kernel/trace/ftrace.c

4720

iter->ops = ops;

kernel/trace/ftrace.c

4721

iter->flags = flag;

kernel/trace/ftrace.c

4722

iter->tr = tr;

kernel/trace/ftrace.c

4734

iter->mod_list = mod_head;

kernel/trace/ftrace.c

4740

iter->hash = alloc_ftrace_hash(size_bits);

kernel/trace/ftrace.c

4743

iter->hash = alloc_and_copy_ftrace_hash(size_bits, hash);

kernel/trace/ftrace.c

4747

iter->hash = alloc_and_copy_ftrace_hash(hash->size_bits, hash);

kernel/trace/ftrace.c

4749

iter->hash = EMPTY_HASH;

kernel/trace/ftrace.c

4752

if (!iter->hash) {

kernel/trace/ftrace.c

4753

trace_parser_put(&iter->parser);

kernel/trace/ftrace.c

4760

iter->pg = ftrace_pages_start;

kernel/trace/ftrace.c

4765

m->private = iter;

kernel/trace/ftrace.c

4768

free_ftrace_hash(iter->hash);

kernel/trace/ftrace.c

4769

trace_parser_put(&iter->parser);

kernel/trace/ftrace.c

4772

file->private_data = iter;

kernel/trace/ftrace.c

4779

kfree(iter);

kernel/trace/ftrace.c

5474

struct ftrace_func_probe *probe = NULL, *iter;

kernel/trace/ftrace.c

5494

list_for_each_entry(iter, &tr->func_probes, list) {

kernel/trace/ftrace.c

5495

if (iter->probe_ops == probe_ops) {

kernel/trace/ftrace.c

5496

probe = iter;

kernel/trace/ftrace.c

5618

struct ftrace_func_probe *probe = NULL, *iter;

kernel/trace/ftrace.c

5648

list_for_each_entry(iter, &tr->func_probes, list) {

kernel/trace/ftrace.c

5649

if (iter->probe_ops == probe_ops) {

kernel/trace/ftrace.c

5650

probe = iter;

kernel/trace/ftrace.c

5794

static int ftrace_process_regex(struct ftrace_iterator *iter,

kernel/trace/ftrace.c

5797

struct ftrace_hash *hash = iter->hash;

kernel/trace/ftrace.c

5798

struct trace_array *tr = iter->ops->private;

kernel/trace/ftrace.c

5832

struct ftrace_iterator *iter;

kernel/trace/ftrace.c

5841

iter = m->private;

kernel/trace/ftrace.c

5843

iter = file->private_data;

kernel/trace/ftrace.c

5850

parser = &iter->parser;

kernel/trace/ftrace.c

5857

ret = ftrace_process_regex(iter, parser->buffer,

kernel/trace/ftrace.c

6202

struct ftrace_func_entry *entry, *iter;

kernel/trace/ftrace.c

6238

hlist_for_each_entry(iter, &hash->buckets[i], hlist) {

kernel/trace/ftrace.c

6239

entry = __ftrace_lookup_ip(direct_functions, iter->ip);

kernel/trace/ftrace.c

6983

struct ftrace_iterator *iter;

kernel/trace/ftrace.c

6989

iter = m->private;

kernel/trace/ftrace.c

6992

iter = file->private_data;

kernel/trace/ftrace.c

6994

parser = &iter->parser;

kernel/trace/ftrace.c

6997

int enable = !(iter->flags & FTRACE_ITER_NOTRACE);

kernel/trace/ftrace.c

6999

ftrace_process_regex(iter, parser->buffer,

kernel/trace/ftrace.c

7006

mutex_lock(&iter->ops->func_hash->regex_lock);

kernel/trace/ftrace.c

7009

filter_hash = !!(iter->flags & FTRACE_ITER_FILTER);

kernel/trace/ftrace.c

7012

orig_hash = &iter->ops->func_hash->filter_hash;

kernel/trace/ftrace.c

7013

if (iter->tr) {

kernel/trace/ftrace.c

7014

if (list_empty(&iter->tr->mod_trace))

kernel/trace/ftrace.c

7015

iter->hash->flags &= ~FTRACE_HASH_FL_MOD;

kernel/trace/ftrace.c

7017

iter->hash->flags |= FTRACE_HASH_FL_MOD;

kernel/trace/ftrace.c

7020

orig_hash = &iter->ops->func_hash->notrace_hash;

kernel/trace/ftrace.c

7023

ftrace_hash_move_and_update_ops(iter->ops, orig_hash,

kernel/trace/ftrace.c

7024

iter->hash, filter_hash);

kernel/trace/ftrace.c

7028

mutex_unlock(&iter->ops->func_hash->regex_lock);

kernel/trace/ftrace.c

7029

free_ftrace_hash(iter->hash);

kernel/trace/ftrace.c

7030

if (iter->tr)

kernel/trace/ftrace.c

7031

trace_array_put(iter->tr);

kernel/trace/ftrace.c

7032

kfree(iter);

kernel/trace/ring_buffer.c

3443

rb_iter_head_event(struct ring_buffer_iter *iter)

kernel/trace/ring_buffer.c

3446

struct buffer_page *iter_head_page = iter->head_page;

kernel/trace/ring_buffer.c

3450

if (iter->head != iter->next_event)

kernel/trace/ring_buffer.c

3451

return iter->event;

kernel/trace/ring_buffer.c

3462

if (iter->head > commit - 8)

kernel/trace/ring_buffer.c

3465

event = __rb_page_index(iter_head_page, iter->head);

kernel/trace/ring_buffer.c

3474

if ((iter->head + length) > commit || length > iter->event_size)

kernel/trace/ring_buffer.c

3478

memcpy(iter->event, event, length);

kernel/trace/ring_buffer.c

3486

if (iter->page_stamp != iter_head_page->page->time_stamp ||

kernel/trace/ring_buffer.c

3490

iter->next_event = iter->head + length;

kernel/trace/ring_buffer.c

3491

return iter->event;

kernel/trace/ring_buffer.c

3494

iter->page_stamp = iter->read_stamp = iter->head_page->page->time_stamp;

kernel/trace/ring_buffer.c

3495

iter->head = 0;

kernel/trace/ring_buffer.c

3496

iter->next_event = 0;

kernel/trace/ring_buffer.c

3497

iter->missed_events = 1;

kernel/trace/ring_buffer.c

3517

static void rb_inc_iter(struct ring_buffer_iter *iter)

kernel/trace/ring_buffer.c

3519

struct ring_buffer_per_cpu *cpu_buffer = iter->cpu_buffer;

kernel/trace/ring_buffer.c

3527

if (iter->head_page == cpu_buffer->reader_page)

kernel/trace/ring_buffer.c

3528

iter->head_page = rb_set_head_page(cpu_buffer);

kernel/trace/ring_buffer.c

3530

rb_inc_page(&iter->head_page);

kernel/trace/ring_buffer.c

3532

if (rb_page_commit(iter->head_page) & RB_MISSED_EVENTS)

kernel/trace/ring_buffer.c

3533

iter->missed_events = -1;

kernel/trace/ring_buffer.c

3535

iter->page_stamp = iter->read_stamp = iter->head_page->page->time_stamp;

kernel/trace/ring_buffer.c

3536

iter->head = 0;

kernel/trace/ring_buffer.c

3537

iter->next_event = 0;

kernel/trace/ring_buffer.c

5576

static void rb_iter_reset(struct ring_buffer_iter *iter)

kernel/trace/ring_buffer.c

5578

struct ring_buffer_per_cpu *cpu_buffer = iter->cpu_buffer;

kernel/trace/ring_buffer.c

5586

iter->head_page = cpu_buffer->reader_page;

kernel/trace/ring_buffer.c

5587

iter->head = cpu_buffer->reader_page->read;

kernel/trace/ring_buffer.c

5588

iter->next_event = iter->head;

kernel/trace/ring_buffer.c

5589

iter->missed_events = 0;

kernel/trace/ring_buffer.c

5591

iter->cache_reader_page = iter->head_page;

kernel/trace/ring_buffer.c

5592

iter->cache_read = cpu_buffer->read;

kernel/trace/ring_buffer.c

5593

iter->cache_pages_removed = cpu_buffer->pages_removed;

kernel/trace/ring_buffer.c

5595

if (iter->head) {

kernel/trace/ring_buffer.c

5596

iter->read_stamp = cpu_buffer->read_stamp;

kernel/trace/ring_buffer.c

5597

iter->page_stamp = cpu_buffer->reader_page->page->time_stamp;

kernel/trace/ring_buffer.c

5599

iter->read_stamp = iter->head_page->page->time_stamp;

kernel/trace/ring_buffer.c

5600

iter->page_stamp = iter->read_stamp;

kernel/trace/ring_buffer.c

5611

void ring_buffer_iter_reset(struct ring_buffer_iter *iter)

kernel/trace/ring_buffer.c

5616

if (!iter)

kernel/trace/ring_buffer.c

5619

cpu_buffer = iter->cpu_buffer;

kernel/trace/ring_buffer.c

5622

rb_iter_reset(iter);

kernel/trace/ring_buffer.c

5631

int ring_buffer_iter_empty(struct ring_buffer_iter *iter)

kernel/trace/ring_buffer.c

5642

cpu_buffer = iter->cpu_buffer;

kernel/trace/ring_buffer.c

5668

return ((iter->head_page == commit_page && iter->head >= commit) ||

kernel/trace/ring_buffer.c

5669

(iter->head_page == reader && commit_page == head_page &&

kernel/trace/ring_buffer.c

5671

iter->head == rb_page_size(cpu_buffer->reader_page)));

kernel/trace/ring_buffer.c

5706

rb_update_iter_read_stamp(struct ring_buffer_iter *iter,

kernel/trace/ring_buffer.c

5717

iter->read_stamp += delta;

kernel/trace/ring_buffer.c

5722

delta = rb_fix_abs_ts(delta, iter->read_stamp);

kernel/trace/ring_buffer.c

5723

iter->read_stamp = delta;

kernel/trace/ring_buffer.c

5727

iter->read_stamp += event->time_delta;

kernel/trace/ring_buffer.c

5731

RB_WARN_ON(iter->cpu_buffer, 1);

kernel/trace/ring_buffer.c

6006

static void rb_advance_iter(struct ring_buffer_iter *iter)

kernel/trace/ring_buffer.c

6010

cpu_buffer = iter->cpu_buffer;

kernel/trace/ring_buffer.c

6013

if (iter->head == iter->next_event) {

kernel/trace/ring_buffer.c

6015

if (rb_iter_head_event(iter) == NULL)

kernel/trace/ring_buffer.c

6019

iter->head = iter->next_event;

kernel/trace/ring_buffer.c

6024

if (iter->next_event >= rb_page_size(iter->head_page)) {

kernel/trace/ring_buffer.c

6026

if (iter->head_page == cpu_buffer->commit_page)

kernel/trace/ring_buffer.c

6028

rb_inc_iter(iter);

kernel/trace/ring_buffer.c

6032

rb_update_iter_read_stamp(iter, iter->event);

kernel/trace/ring_buffer.c

6115

rb_iter_peek(struct ring_buffer_iter *iter, u64 *ts)

kernel/trace/ring_buffer.c

6126

cpu_buffer = iter->cpu_buffer;

kernel/trace/ring_buffer.c

6135

if (unlikely(iter->cache_read != cpu_buffer->read ||

kernel/trace/ring_buffer.c

6136

iter->cache_reader_page != cpu_buffer->reader_page ||

kernel/trace/ring_buffer.c

6137

iter->cache_pages_removed != cpu_buffer->pages_removed))

kernel/trace/ring_buffer.c

6138

rb_iter_reset(iter);

kernel/trace/ring_buffer.c

6141

if (ring_buffer_iter_empty(iter))

kernel/trace/ring_buffer.c

6157

if (iter->head >= rb_page_size(iter->head_page)) {

kernel/trace/ring_buffer.c

6158

rb_inc_iter(iter);

kernel/trace/ring_buffer.c

6162

event = rb_iter_head_event(iter);

kernel/trace/ring_buffer.c

6169

rb_inc_iter(iter);

kernel/trace/ring_buffer.c

6172

rb_advance_iter(iter);

kernel/trace/ring_buffer.c

6177

rb_advance_iter(iter);

kernel/trace/ring_buffer.c

6183

*ts = rb_fix_abs_ts(*ts, iter->head_page->page->time_stamp);

kernel/trace/ring_buffer.c

6188

rb_advance_iter(iter);

kernel/trace/ring_buffer.c

6193

*ts = iter->read_stamp + event->time_delta;

kernel/trace/ring_buffer.c

6280

bool ring_buffer_iter_dropped(struct ring_buffer_iter *iter)

kernel/trace/ring_buffer.c

6282

return iter->missed_events != 0;

kernel/trace/ring_buffer.c

6295

ring_buffer_iter_peek(struct ring_buffer_iter *iter, u64 *ts)

kernel/trace/ring_buffer.c

6297

struct ring_buffer_per_cpu *cpu_buffer = iter->cpu_buffer;

kernel/trace/ring_buffer.c

6303

event = rb_iter_peek(iter, ts);

kernel/trace/ring_buffer.c

6379

struct ring_buffer_iter *iter;

kernel/trace/ring_buffer.c

6384

iter = kzalloc_obj(*iter, flags);

kernel/trace/ring_buffer.c

6385

if (!iter)

kernel/trace/ring_buffer.c

6389

iter->event_size = buffer->subbuf_size;

kernel/trace/ring_buffer.c

6390

iter->event = kmalloc(iter->event_size, flags);

kernel/trace/ring_buffer.c

6391

if (!iter->event) {

kernel/trace/ring_buffer.c

6392

kfree(iter);

kernel/trace/ring_buffer.c

6398

iter->cpu_buffer = cpu_buffer;

kernel/trace/ring_buffer.c

6404

rb_iter_reset(iter);

kernel/trace/ring_buffer.c

6407

return iter;

kernel/trace/ring_buffer.c

6418

ring_buffer_read_finish(struct ring_buffer_iter *iter)

kernel/trace/ring_buffer.c

6420

struct ring_buffer_per_cpu *cpu_buffer = iter->cpu_buffer;

kernel/trace/ring_buffer.c

6426

kfree(iter->event);

kernel/trace/ring_buffer.c

6427

kfree(iter);

kernel/trace/ring_buffer.c

6438

void ring_buffer_iter_advance(struct ring_buffer_iter *iter)

kernel/trace/ring_buffer.c

6440

struct ring_buffer_per_cpu *cpu_buffer = iter->cpu_buffer;

kernel/trace/ring_buffer.c

6444

iter->missed_events = 0;

kernel/trace/ring_buffer.c

6445

rb_advance_iter(iter);

kernel/trace/trace.c

1223

struct trace_iterator *iter;

kernel/trace/trace.c

1230

struct trace_iterator *iter = pwait->iter;

kernel/trace/trace.c

1232

if (atomic_read_acquire(&iter->wait_index) != pwait->wait_index)

kernel/trace/trace.c

1235

return iter->closed;

kernel/trace/trace.c

1238

static int wait_on_pipe(struct trace_iterator *iter, int full)

kernel/trace/trace.c

1244

if (trace_buffer_iter(iter, iter->cpu_file))

kernel/trace/trace.c

1247

pwait.wait_index = atomic_read_acquire(&iter->wait_index);

kernel/trace/trace.c

1248

pwait.iter = iter;

kernel/trace/trace.c

1250

ret = ring_buffer_wait(iter->array_buffer->buffer, iter->cpu_file, full,

kernel/trace/trace.c

1258

if (iter->snapshot)

kernel/trace/trace.c

1259

iter->array_buffer = &iter->tr->snapshot_buffer;

kernel/trace/trace.c

1950

struct trace_iterator *iter = tracepoint_print_iter;

kernel/trace/trace.c

1953

if (WARN_ON_ONCE(!iter))

kernel/trace/trace.c

1970

trace_seq_init(&iter->seq);

kernel/trace/trace.c

1971

iter->ent = fbuffer->entry;

kernel/trace/trace.c

1972

event_call->event.funcs->trace(iter, 0, event);

kernel/trace/trace.c

1973

trace_seq_putc(&iter->seq, 0);

kernel/trace/trace.c

1974

printk("%s", iter->seq.buffer);

kernel/trace/trace.c

2342

peek_next_entry(struct trace_iterator *iter, int cpu, u64 *ts,

kernel/trace/trace.c

2346

struct ring_buffer_iter *buf_iter = trace_buffer_iter(iter, cpu);

kernel/trace/trace.c

2354

event = ring_buffer_peek(iter->array_buffer->buffer, cpu, ts,

kernel/trace/trace.c

2359

iter->ent_size = ring_buffer_event_length(event);

kernel/trace/trace.c

2362

iter->ent_size = 0;

kernel/trace/trace.c

2367

__find_next_entry(struct trace_iterator *iter, int *ent_cpu,

kernel/trace/trace.c

2370

struct trace_buffer *buffer = iter->array_buffer->buffer;

kernel/trace/trace.c

2373

int cpu_file = iter->cpu_file;

kernel/trace/trace.c

2386

ent = peek_next_entry(iter, cpu_file, ent_ts, missing_events);

kernel/trace/trace.c

2398

ent = peek_next_entry(iter, cpu, &ts, &lost_events);

kernel/trace/trace.c

2408

next_size = iter->ent_size;

kernel/trace/trace.c

2412

iter->ent_size = next_size;

kernel/trace/trace.c

2429

char *trace_iter_expand_format(struct trace_iterator *iter)

kernel/trace/trace.c

2437

if (!iter->tr || iter->fmt == static_fmt_buf)

kernel/trace/trace.c

2440

tmp = krealloc(iter->fmt, iter->fmt_size + STATIC_FMT_BUF_SIZE,

kernel/trace/trace.c

2443

iter->fmt_size += STATIC_FMT_BUF_SIZE;

kernel/trace/trace.c

2444

iter->fmt = tmp;

kernel/trace/trace.c

2451

static bool trace_safe_str(struct trace_iterator *iter, const char *str)

kernel/trace/trace.c

2458

if ((addr >= (unsigned long)iter->ent) &&

kernel/trace/trace.c

2459

(addr < (unsigned long)iter->ent + iter->ent_size))

kernel/trace/trace.c

2463

if ((addr >= (unsigned long)iter->tmp_seq.buffer) &&

kernel/trace/trace.c

2464

(addr < (unsigned long)iter->tmp_seq.buffer + TRACE_SEQ_BUFFER_SIZE))

kernel/trace/trace.c

2478

if (!iter->ent)

kernel/trace/trace.c

2481

trace_event = ftrace_find_event(iter->ent->type);

kernel/trace/trace.c

2517

bool ignore_event(struct trace_iterator *iter)

kernel/trace/trace.c

2526

trace_event = ftrace_find_event(iter->ent->type);

kernel/trace/trace.c

2528

seq = &iter->seq;

kernel/trace/trace.c

2531

trace_seq_printf(seq, "EVENT ID %d NOT FOUND?\n", iter->ent->type);

kernel/trace/trace.c

2547

ptr = iter->ent;

kernel/trace/trace.c

2558

good = trace_safe_str(iter, str);

kernel/trace/trace.c

2579

const char *trace_event_format(struct trace_iterator *iter, const char *fmt)

kernel/trace/trace.c

2587

if (!iter->tr || iter->tr->trace_flags & TRACE_ITER(HASH_PTR))

kernel/trace/trace.c

2591

new_fmt = q = iter->fmt;

kernel/trace/trace.c

2593

if (unlikely(q - new_fmt + 3 > iter->fmt_size)) {

kernel/trace/trace.c

2594

if (!trace_iter_expand_format(iter))

kernel/trace/trace.c

2597

q += iter->fmt - new_fmt;

kernel/trace/trace.c

2598

new_fmt = iter->fmt;

kernel/trace/trace.c

2622

struct trace_entry *trace_find_next_entry(struct trace_iterator *iter,

kernel/trace/trace.c

2626

int ent_size = iter->ent_size;

kernel/trace/trace.c

2637

if (iter->temp == static_temp_buf &&

kernel/trace/trace.c

2646

if (iter->ent && iter->ent != iter->temp) {

kernel/trace/trace.c

2647

if ((!iter->temp || iter->temp_size < iter->ent_size) &&

kernel/trace/trace.c

2648

!WARN_ON_ONCE(iter->temp == static_temp_buf)) {

kernel/trace/trace.c

2650

temp = kmalloc(iter->ent_size, GFP_KERNEL);

kernel/trace/trace.c

2653

kfree(iter->temp);

kernel/trace/trace.c

2654

iter->temp = temp;

kernel/trace/trace.c

2655

iter->temp_size = iter->ent_size;

kernel/trace/trace.c

2657

memcpy(iter->temp, iter->ent, iter->ent_size);

kernel/trace/trace.c

2658

iter->ent = iter->temp;

kernel/trace/trace.c

2660

entry = __find_next_entry(iter, ent_cpu, NULL, ent_ts);

kernel/trace/trace.c

2662

iter->ent_size = ent_size;

kernel/trace/trace.c

2668

void *trace_find_next_entry_inc(struct trace_iterator *iter)

kernel/trace/trace.c

2672

iter->ent = __find_next_entry(iter, &iter->cpu,

kernel/trace/trace.c

2673

&iter->lost_events, &iter->ts);

kernel/trace/trace.c

2675

if (iter->ent) {

kernel/trace/trace.c

2676

iter->idx++;

kernel/trace/trace.c

2677

buf_iter = trace_buffer_iter(iter, iter->cpu);

kernel/trace/trace.c

2682

return iter->ent ? iter : NULL;

kernel/trace/trace.c

2685

static void trace_consume(struct trace_iterator *iter)

kernel/trace/trace.c

2687

ring_buffer_consume(iter->array_buffer->buffer, iter->cpu, &iter->ts,

kernel/trace/trace.c

2688

&iter->lost_events);

kernel/trace/trace.c

2693

struct trace_iterator *iter = m->private;

kernel/trace/trace.c

2697

WARN_ON_ONCE(iter->leftover);

kernel/trace/trace.c

2702

if (iter->idx > i)

kernel/trace/trace.c

2705

if (iter->idx < 0)

kernel/trace/trace.c

2706

ent = trace_find_next_entry_inc(iter);

kernel/trace/trace.c

2708

ent = iter;

kernel/trace/trace.c

2710

while (ent && iter->idx < i)

kernel/trace/trace.c

2711

ent = trace_find_next_entry_inc(iter);

kernel/trace/trace.c

2713

iter->pos = *pos;

kernel/trace/trace.c

2718

void tracing_iter_reset(struct trace_iterator *iter, int cpu)

kernel/trace/trace.c

2724

per_cpu_ptr(iter->array_buffer->data, cpu)->skipped_entries = 0;

kernel/trace/trace.c

2726

buf_iter = trace_buffer_iter(iter, cpu);

kernel/trace/trace.c

2738

if (ts >= iter->array_buffer->time_start)

kernel/trace/trace.c

2746

per_cpu_ptr(iter->array_buffer->data, cpu)->skipped_entries = entries;

kernel/trace/trace.c

2755

struct trace_iterator *iter = m->private;

kernel/trace/trace.c

2756

struct trace_array *tr = iter->tr;

kernel/trace/trace.c

2757

int cpu_file = iter->cpu_file;

kernel/trace/trace.c

2763

if (unlikely(tr->current_trace != iter->trace)) {

kernel/trace/trace.c

2765

if (iter->trace->close)

kernel/trace/trace.c

2766

iter->trace->close(iter);

kernel/trace/trace.c

2767

iter->trace = tr->current_trace;

kernel/trace/trace.c

2769

if (iter->trace->open)

kernel/trace/trace.c

2770

iter->trace->open(iter);

kernel/trace/trace.c

2774

if (iter->snapshot && tracer_uses_snapshot(iter->trace))

kernel/trace/trace.c

2777

if (*pos != iter->pos) {

kernel/trace/trace.c

2778

iter->ent = NULL;

kernel/trace/trace.c

2779

iter->cpu = 0;

kernel/trace/trace.c

2780

iter->idx = -1;

kernel/trace/trace.c

2784

tracing_iter_reset(iter, cpu);

kernel/trace/trace.c

2786

tracing_iter_reset(iter, cpu_file);

kernel/trace/trace.c

2788

iter->leftover = 0;

kernel/trace/trace.c

2789

for (p = iter; p && l < *pos; p = s_next(m, p, &l))

kernel/trace/trace.c

2797

if (iter->leftover)

kernel/trace/trace.c

2798

p = iter;

kernel/trace/trace.c

2812

struct trace_iterator *iter = m->private;

kernel/trace/trace.c

2814

if (iter->snapshot && tracer_uses_snapshot(iter->trace))

kernel/trace/trace.c

2817

trace_access_unlock(iter->cpu_file);

kernel/trace/trace.c

2939

print_trace_header(struct seq_file *m, struct trace_iterator *iter)

kernel/trace/trace.c

2942

struct array_buffer *buf = iter->array_buffer;

kernel/trace/trace.c

2944

struct tracer *type = iter->trace;

kernel/trace/trace.c

2979

seq_print_ip_sym(&iter->seq, data->critical_start, sym_flags);

kernel/trace/trace.c

2980

trace_print_seq(m, &iter->seq);

kernel/trace/trace.c

2982

seq_print_ip_sym(&iter->seq, data->critical_end, sym_flags);

kernel/trace/trace.c

2983

trace_print_seq(m, &iter->seq);

kernel/trace/trace.c

2990

static void test_cpu_buff_start(struct trace_iterator *iter)

kernel/trace/trace.c

2992

struct trace_seq *s = &iter->seq;

kernel/trace/trace.c

2993

struct trace_array *tr = iter->tr;

kernel/trace/trace.c

2998

if (!(iter->iter_flags & TRACE_FILE_ANNOTATE))

kernel/trace/trace.c

3001

if (cpumask_available(iter->started) &&

kernel/trace/trace.c

3002

cpumask_test_cpu(iter->cpu, iter->started))

kernel/trace/trace.c

3005

if (per_cpu_ptr(iter->array_buffer->data, iter->cpu)->skipped_entries)

kernel/trace/trace.c

3008

if (cpumask_available(iter->started))

kernel/trace/trace.c

3009

cpumask_set_cpu(iter->cpu, iter->started);

kernel/trace/trace.c

3012

if (iter->idx > 1)

kernel/trace/trace.c

3014

iter->cpu);

kernel/trace/trace.c

3033

static enum print_line_t print_trace_fmt(struct trace_iterator *iter)

kernel/trace/trace.c

3035

struct trace_array *tr = iter->tr;

kernel/trace/trace.c

3036

struct trace_seq *s = &iter->seq;

kernel/trace/trace.c

3041

entry = iter->ent;

kernel/trace/trace.c

3043

test_cpu_buff_start(iter);

kernel/trace/trace.c

3048

if (iter->iter_flags & TRACE_FILE_LAT_FMT)

kernel/trace/trace.c

3049

trace_print_lat_context(iter);

kernel/trace/trace.c

3051

trace_print_context(iter);

kernel/trace/trace.c

3059

return print_event_fields(iter, event);

kernel/trace/trace.c

3069

return print_event_fields(iter, event);

kernel/trace/trace.c

3071

return event->funcs->trace(iter, sym_flags, event);

kernel/trace/trace.c

3079

static enum print_line_t print_raw_fmt(struct trace_iterator *iter)

kernel/trace/trace.c

3081

struct trace_array *tr = iter->tr;

kernel/trace/trace.c

3082

struct trace_seq *s = &iter->seq;

kernel/trace/trace.c

3086

entry = iter->ent;

kernel/trace/trace.c

3090

entry->pid, iter->cpu, iter->ts);

kernel/trace/trace.c

3097

return event->funcs->raw(iter, 0, event);

kernel/trace/trace.c

3104

static enum print_line_t print_hex_fmt(struct trace_iterator *iter)

kernel/trace/trace.c

3106

struct trace_array *tr = iter->tr;

kernel/trace/trace.c

3107

struct trace_seq *s = &iter->seq;

kernel/trace/trace.c

3112

entry = iter->ent;

kernel/trace/trace.c

3116

SEQ_PUT_HEX_FIELD(s, iter->cpu);

kernel/trace/trace.c

3117

SEQ_PUT_HEX_FIELD(s, iter->ts);

kernel/trace/trace.c

3124

enum print_line_t ret = event->funcs->hex(iter, 0, event);

kernel/trace/trace.c

3134

static enum print_line_t print_bin_fmt(struct trace_iterator *iter)

kernel/trace/trace.c

3136

struct trace_array *tr = iter->tr;

kernel/trace/trace.c

3137

struct trace_seq *s = &iter->seq;

kernel/trace/trace.c

3141

entry = iter->ent;

kernel/trace/trace.c

3145

SEQ_PUT_FIELD(s, iter->cpu);

kernel/trace/trace.c

3146

SEQ_PUT_FIELD(s, iter->ts);

kernel/trace/trace.c

3152

return event ? event->funcs->binary(iter, 0, event) :

kernel/trace/trace.c

3156

int trace_empty(struct trace_iterator *iter)

kernel/trace/trace.c

3162

if (iter->cpu_file != RING_BUFFER_ALL_CPUS) {

kernel/trace/trace.c

3163

cpu = iter->cpu_file;

kernel/trace/trace.c

3164

buf_iter = trace_buffer_iter(iter, cpu);

kernel/trace/trace.c

3169

if (!ring_buffer_empty_cpu(iter->array_buffer->buffer, cpu))

kernel/trace/trace.c

3176

buf_iter = trace_buffer_iter(iter, cpu);

kernel/trace/trace.c

3181

if (!ring_buffer_empty_cpu(iter->array_buffer->buffer, cpu))

kernel/trace/trace.c

3190

enum print_line_t print_trace_line(struct trace_iterator *iter)

kernel/trace/trace.c

3192

struct trace_array *tr = iter->tr;

kernel/trace/trace.c

3196

if (iter->lost_events) {

kernel/trace/trace.c

3197

if (iter->lost_events == (unsigned long)-1)

kernel/trace/trace.c

3198

trace_seq_printf(&iter->seq, "CPU:%d [LOST EVENTS]\n",

kernel/trace/trace.c

3199

iter->cpu);

kernel/trace/trace.c

3201

trace_seq_printf(&iter->seq, "CPU:%d [LOST %lu EVENTS]\n",

kernel/trace/trace.c

3202

iter->cpu, iter->lost_events);

kernel/trace/trace.c

3203

if (trace_seq_has_overflowed(&iter->seq))

kernel/trace/trace.c

3207

if (iter->trace && iter->trace->print_line) {

kernel/trace/trace.c

3208

ret = iter->trace->print_line(iter);

kernel/trace/trace.c

3213

if (iter->ent->type == TRACE_BPUTS &&

kernel/trace/trace.c

3216

return trace_print_bputs_msg_only(iter);

kernel/trace/trace.c

3218

if (iter->ent->type == TRACE_BPRINT &&

kernel/trace/trace.c

3221

return trace_print_bprintk_msg_only(iter);

kernel/trace/trace.c

3223

if (iter->ent->type == TRACE_PRINT &&

kernel/trace/trace.c

3226

return trace_print_printk_msg_only(iter);

kernel/trace/trace.c

3229

return print_bin_fmt(iter);

kernel/trace/trace.c

3232

return print_hex_fmt(iter);

kernel/trace/trace.c

3235

return print_raw_fmt(iter);

kernel/trace/trace.c

3237

return print_trace_fmt(iter);

kernel/trace/trace.c

3242

struct trace_iterator *iter = m->private;

kernel/trace/trace.c

3243

struct trace_array *tr = iter->tr;

kernel/trace/trace.c

3246

if (trace_empty(iter))

kernel/trace/trace.c

3249

if (iter->iter_flags & TRACE_FILE_LAT_FMT)

kernel/trace/trace.c

3250

print_trace_header(m, iter);

kernel/trace/trace.c

3258

struct trace_iterator *iter = m->private;

kernel/trace/trace.c

3259

struct trace_array *tr = iter->tr;

kernel/trace/trace.c

3265

if (iter->iter_flags & TRACE_FILE_LAT_FMT) {

kernel/trace/trace.c

3267

if (trace_empty(iter))

kernel/trace/trace.c

3269

print_trace_header(m, iter);

kernel/trace/trace.c

3275

print_func_help_header_irq(iter->array_buffer,

kernel/trace/trace.c

3278

print_func_help_header(iter->array_buffer, m,

kernel/trace/trace.c

3294

struct trace_iterator *iter = v;

kernel/trace/trace.c

3297

if (iter->ent == NULL) {

kernel/trace/trace.c

3298

if (iter->tr) {

kernel/trace/trace.c

3299

seq_printf(m, "# tracer: %s\n", iter->trace->name);

kernel/trace/trace.c

3303

if (iter->snapshot && trace_empty(iter))

kernel/trace/trace.c

3304

print_snapshot_help(m, iter);

kernel/trace/trace.c

3305

else if (iter->trace && iter->trace->print_header)

kernel/trace/trace.c

3306

iter->trace->print_header(m);

kernel/trace/trace.c

3310

} else if (iter->leftover) {

kernel/trace/trace.c

3315

ret = trace_print_seq(m, &iter->seq);

kernel/trace/trace.c

3318

iter->leftover = ret;

kernel/trace/trace.c

3321

ret = print_trace_line(iter);

kernel/trace/trace.c

3323

iter->seq.full = 0;

kernel/trace/trace.c

3324

trace_seq_puts(&iter->seq, "[LINE TOO BIG]\n");

kernel/trace/trace.c

3326

ret = trace_print_seq(m, &iter->seq);

kernel/trace/trace.c

3334

iter->leftover = ret;

kernel/trace/trace.c

3354

static void free_trace_iter_content(struct trace_iterator *iter)

kernel/trace/trace.c

3357

if (iter->fmt != static_fmt_buf)

kernel/trace/trace.c

3358

kfree(iter->fmt);

kernel/trace/trace.c

3360

kfree(iter->temp);

kernel/trace/trace.c

3361

kfree(iter->buffer_iter);

kernel/trace/trace.c

3362

mutex_destroy(&iter->mutex);

kernel/trace/trace.c

3363

free_cpumask_var(iter->started);

kernel/trace/trace.c

3370

struct trace_iterator *iter;

kernel/trace/trace.c

3376

iter = __seq_open_private(file, &tracer_seq_ops, sizeof(*iter));

kernel/trace/trace.c

3377

if (!iter)

kernel/trace/trace.c

3380

iter->buffer_iter = kzalloc_objs(*iter->buffer_iter, nr_cpu_ids);

kernel/trace/trace.c

3381

if (!iter->buffer_iter)

kernel/trace/trace.c

3392

iter->temp = kmalloc(128, GFP_KERNEL);

kernel/trace/trace.c

3393

if (iter->temp)

kernel/trace/trace.c

3394

iter->temp_size = 128;

kernel/trace/trace.c

3403

iter->fmt = NULL;

kernel/trace/trace.c

3404

iter->fmt_size = 0;

kernel/trace/trace.c

3407

iter->trace = tr->current_trace;

kernel/trace/trace.c

3409

if (!zalloc_cpumask_var(&iter->started, GFP_KERNEL))

kernel/trace/trace.c

3412

iter->tr = tr;

kernel/trace/trace.c

3417

iter->array_buffer = &tr->snapshot_buffer;

kernel/trace/trace.c

3420

iter->array_buffer = &tr->array_buffer;

kernel/trace/trace.c

3421

iter->snapshot = snapshot;

kernel/trace/trace.c

3422

iter->pos = -1;

kernel/trace/trace.c

3423

iter->cpu_file = tracing_get_cpu(inode);

kernel/trace/trace.c

3424

mutex_init(&iter->mutex);

kernel/trace/trace.c

3427

if (iter->trace->open)

kernel/trace/trace.c

3428

iter->trace->open(iter);

kernel/trace/trace.c

3431

if (ring_buffer_overruns(iter->array_buffer->buffer))

kernel/trace/trace.c

3432

iter->iter_flags |= TRACE_FILE_ANNOTATE;

kernel/trace/trace.c

3436

iter->iter_flags |= TRACE_FILE_TIME_IN_NS;

kernel/trace/trace.c

3442

if (!iter->snapshot && (tr->trace_flags & TRACE_ITER(PAUSE_ON_TRACE))) {

kernel/trace/trace.c

3443

iter->iter_flags |= TRACE_FILE_PAUSE;

kernel/trace/trace.c

3447

if (iter->cpu_file == RING_BUFFER_ALL_CPUS) {

kernel/trace/trace.c

3449

iter->buffer_iter[cpu] =

kernel/trace/trace.c

3450

ring_buffer_read_start(iter->array_buffer->buffer,

kernel/trace/trace.c

3452

tracing_iter_reset(iter, cpu);

kernel/trace/trace.c

3455

cpu = iter->cpu_file;

kernel/trace/trace.c

3456

iter->buffer_iter[cpu] =

kernel/trace/trace.c

3457

ring_buffer_read_start(iter->array_buffer->buffer,

kernel/trace/trace.c

3459

tracing_iter_reset(iter, cpu);

kernel/trace/trace.c

3464

return iter;

kernel/trace/trace.c

3468

free_trace_iter_content(iter);

kernel/trace/trace.c

3555

struct trace_iterator *iter;

kernel/trace/trace.c

3564

iter = m->private;

kernel/trace/trace.c

3568

if (iter->buffer_iter[cpu])

kernel/trace/trace.c

3569

ring_buffer_read_finish(iter->buffer_iter[cpu]);

kernel/trace/trace.c

3572

if (iter->trace && iter->trace->close)

kernel/trace/trace.c

3573

iter->trace->close(iter);

kernel/trace/trace.c

3575

if (iter->iter_flags & TRACE_FILE_PAUSE)

kernel/trace/trace.c

3583

free_trace_iter_content(iter);

kernel/trace/trace.c

3611

struct trace_iterator *iter;

kernel/trace/trace.c

3637

iter = __tracing_open(inode, file, false);

kernel/trace/trace.c

3638

if (IS_ERR(iter))

kernel/trace/trace.c

3639

ret = PTR_ERR(iter);

kernel/trace/trace.c

3641

iter->iter_flags |= TRACE_FILE_LAT_FMT;

kernel/trace/trace.c

5224

struct trace_iterator *iter;

kernel/trace/trace.c

5239

iter = kzalloc_obj(*iter);

kernel/trace/trace.c

5240

if (!iter) {

kernel/trace/trace.c

5245

trace_seq_init(&iter->seq);

kernel/trace/trace.c

5246

iter->trace = tr->current_trace;

kernel/trace/trace.c

5248

if (!alloc_cpumask_var(&iter->started, GFP_KERNEL)) {

kernel/trace/trace.c

5254

cpumask_setall(iter->started);

kernel/trace/trace.c

5257

iter->iter_flags |= TRACE_FILE_LAT_FMT;

kernel/trace/trace.c

5261

iter->iter_flags |= TRACE_FILE_TIME_IN_NS;

kernel/trace/trace.c

5263

iter->tr = tr;

kernel/trace/trace.c

5264

iter->array_buffer = &tr->array_buffer;

kernel/trace/trace.c

5265

iter->cpu_file = cpu;

kernel/trace/trace.c

5266

mutex_init(&iter->mutex);

kernel/trace/trace.c

5267

filp->private_data = iter;

kernel/trace/trace.c

5269

if (iter->trace->pipe_open)

kernel/trace/trace.c

5270

iter->trace->pipe_open(iter);

kernel/trace/trace.c

5279

kfree(iter);

kernel/trace/trace.c

5289

struct trace_iterator *iter = file->private_data;

kernel/trace/trace.c

5295

if (iter->trace->pipe_close)

kernel/trace/trace.c

5296

iter->trace->pipe_close(iter);

kernel/trace/trace.c

5297

close_pipe_on_cpu(tr, iter->cpu_file);

kernel/trace/trace.c

5300

free_trace_iter_content(iter);

kernel/trace/trace.c

5301

kfree(iter);

kernel/trace/trace.c

5309

trace_poll(struct trace_iterator *iter, struct file *filp, poll_table *poll_table)

kernel/trace/trace.c

5311

struct trace_array *tr = iter->tr;

kernel/trace/trace.c

5314

if (trace_buffer_iter(iter, iter->cpu_file))

kernel/trace/trace.c

5323

return ring_buffer_poll_wait(iter->array_buffer->buffer, iter->cpu_file,

kernel/trace/trace.c

5324

filp, poll_table, iter->tr->buffer_percent);

kernel/trace/trace.c

5330

struct trace_iterator *iter = filp->private_data;

kernel/trace/trace.c

5332

return trace_poll(iter, filp, poll_table);

kernel/trace/trace.c

5338

struct trace_iterator *iter = filp->private_data;

kernel/trace/trace.c

5341

while (trace_empty(iter)) {

kernel/trace/trace.c

5356

if (!tracer_tracing_is_on(iter->tr) && iter->pos)

kernel/trace/trace.c

5359

mutex_unlock(&iter->mutex);

kernel/trace/trace.c

5361

ret = wait_on_pipe(iter, 0);

kernel/trace/trace.c

5363

mutex_lock(&iter->mutex);

kernel/trace/trace.c

5395

struct trace_iterator *iter = filp->private_data;

kernel/trace/trace.c

5403

guard(mutex)(&iter->mutex);

kernel/trace/trace.c

5406

sret = trace_seq_to_user(&iter->seq, ubuf, cnt);

kernel/trace/trace.c

5410

trace_seq_init(&iter->seq);

kernel/trace/trace.c

5412

if (iter->trace->read) {

kernel/trace/trace.c

5413

sret = iter->trace->read(iter, filp, ubuf, cnt, ppos);

kernel/trace/trace.c

5419

if (update_last_data_if_empty(iter->tr))

kernel/trace/trace.c

5427

if (trace_empty(iter))

kernel/trace/trace.c

5434

trace_iterator_reset(iter);

kernel/trace/trace.c

5435

cpumask_clear(iter->started);

kernel/trace/trace.c

5436

trace_seq_init(&iter->seq);

kernel/trace/trace.c

5439

trace_access_lock(iter->cpu_file);

kernel/trace/trace.c

5440

while (trace_find_next_entry_inc(iter) != NULL) {

kernel/trace/trace.c

5442

int save_len = iter->seq.seq.len;

kernel/trace/trace.c

5444

ret = print_trace_line(iter);

kernel/trace/trace.c

5453

iter->seq.full = 0;

kernel/trace/trace.c

5454

trace_seq_puts(&iter->seq, "[LINE TOO BIG]\n");

kernel/trace/trace.c

5455

trace_consume(iter);

kernel/trace/trace.c

5460

iter->seq.seq.len = save_len;

kernel/trace/trace.c

5464

trace_consume(iter);

kernel/trace/trace.c

5466

if (trace_seq_used(&iter->seq) >= cnt)

kernel/trace/trace.c

5474

WARN_ONCE(iter->seq.full, "full flag set for trace type %d",

kernel/trace/trace.c

5475

iter->ent->type);

kernel/trace/trace.c

5477

trace_access_unlock(iter->cpu_file);

kernel/trace/trace.c

5481

sret = trace_seq_to_user(&iter->seq, ubuf, cnt);

kernel/trace/trace.c

5482

if (iter->seq.readpos >= trace_seq_used(&iter->seq))

kernel/trace/trace.c

5483

trace_seq_init(&iter->seq);

kernel/trace/trace.c

5502

tracing_fill_pipe_page(size_t rem, struct trace_iterator *iter)

kernel/trace/trace.c

5510

save_len = iter->seq.seq.len;

kernel/trace/trace.c

5511

ret = print_trace_line(iter);

kernel/trace/trace.c

5513

if (trace_seq_has_overflowed(&iter->seq)) {

kernel/trace/trace.c

5514

iter->seq.seq.len = save_len;

kernel/trace/trace.c

5524

iter->seq.seq.len = save_len;

kernel/trace/trace.c

5528

count = trace_seq_used(&iter->seq) - save_len;

kernel/trace/trace.c

5531

iter->seq.seq.len = save_len;

kernel/trace/trace.c

5536

trace_consume(iter);

kernel/trace/trace.c

5538

if (!trace_find_next_entry_inc(iter)) {

kernel/trace/trace.c

5540

iter->ent = NULL;

kernel/trace/trace.c

5556

struct trace_iterator *iter = filp->private_data;

kernel/trace/trace.c

5572

mutex_lock(&iter->mutex);

kernel/trace/trace.c

5574

if (iter->trace->splice_read) {

kernel/trace/trace.c

5575

ret = iter->trace->splice_read(iter, filp,

kernel/trace/trace.c

5585

if (!iter->ent && !trace_find_next_entry_inc(iter)) {

kernel/trace/trace.c

5591

trace_access_lock(iter->cpu_file);

kernel/trace/trace.c

5599

rem = tracing_fill_pipe_page(rem, iter);

kernel/trace/trace.c

5602

ret = trace_seq_to_buffer(&iter->seq,

kernel/trace/trace.c

5604

min((size_t)trace_seq_used(&iter->seq),

kernel/trace/trace.c

5613

trace_seq_init(&iter->seq);

kernel/trace/trace.c

5616

trace_access_unlock(iter->cpu_file);

kernel/trace/trace.c

5618

mutex_unlock(&iter->mutex);

kernel/trace/trace.c

5631

mutex_unlock(&iter->mutex);

kernel/trace/trace.c

7048

info->iter.tr = tr;

kernel/trace/trace.c

7049

info->iter.cpu_file = tracing_get_cpu(inode);

kernel/trace/trace.c

7050

info->iter.trace = tr->current_trace;

kernel/trace/trace.c

7051

info->iter.array_buffer = &tr->array_buffer;

kernel/trace/trace.c

7073

struct trace_iterator *iter = &info->iter;

kernel/trace/trace.c

7075

return trace_poll(iter, filp, poll_table);

kernel/trace/trace.c

7082

struct trace_iterator *iter = &info->iter;

kernel/trace/trace.c

7091

if (iter->snapshot && tracer_uses_snapshot(iter->tr->current_trace))

kernel/trace/trace.c

7094

page_size = ring_buffer_subbuf_size_get(iter->array_buffer->buffer);

kernel/trace/trace.c

7099

ring_buffer_free_read_page(iter->array_buffer->buffer,

kernel/trace/trace.c

7106

info->spare = ring_buffer_alloc_read_page(iter->array_buffer->buffer,

kernel/trace/trace.c

7107

iter->cpu_file);

kernel/trace/trace.c

7112

info->spare_cpu = iter->cpu_file;

kernel/trace/trace.c

7124

trace_access_lock(iter->cpu_file);

kernel/trace/trace.c

7125

ret = ring_buffer_read_page(iter->array_buffer->buffer,

kernel/trace/trace.c

7128

iter->cpu_file, 0);

kernel/trace/trace.c

7129

trace_access_unlock(iter->cpu_file);

kernel/trace/trace.c

7132

if (trace_empty(iter) && !iter->closed) {

kernel/trace/trace.c

7133

if (update_last_data_if_empty(iter->tr))

kernel/trace/trace.c

7139

ret = wait_on_pipe(iter, 0);

kernel/trace/trace.c

7169

struct trace_iterator *iter = &info->iter;

kernel/trace/trace.c

7171

iter->closed = true;

kernel/trace/trace.c

7173

(void)atomic_fetch_inc_release(&iter->wait_index);

kernel/trace/trace.c

7175

ring_buffer_wake_waiters(iter->array_buffer->buffer, iter->cpu_file);

kernel/trace/trace.c

7183

struct trace_iterator *iter = &info->iter;

kernel/trace/trace.c

7187

iter->tr->trace_ref--;

kernel/trace/trace.c

7189

__trace_array_put(iter->tr);

kernel/trace/trace.c

7192

ring_buffer_free_read_page(iter->array_buffer->buffer,

kernel/trace/trace.c

7259

struct trace_iterator *iter = &info->iter;

kernel/trace/trace.c

7275

if (iter->snapshot && tracer_uses_snapshot(iter->tr->current_trace))

kernel/trace/trace.c

7278

page_size = ring_buffer_subbuf_size_get(iter->array_buffer->buffer);

kernel/trace/trace.c

7292

trace_access_lock(iter->cpu_file);

kernel/trace/trace.c

7293

entries = ring_buffer_entries_cpu(iter->array_buffer->buffer, iter->cpu_file);

kernel/trace/trace.c

7306

ref->buffer = iter->array_buffer->buffer;

kernel/trace/trace.c

7307

ref->page = ring_buffer_alloc_read_page(ref->buffer, iter->cpu_file);

kernel/trace/trace.c

7314

ref->cpu = iter->cpu_file;

kernel/trace/trace.c

7317

len, iter->cpu_file, 1);

kernel/trace/trace.c

7334

entries = ring_buffer_entries_cpu(iter->array_buffer->buffer, iter->cpu_file);

kernel/trace/trace.c

7337

trace_access_unlock(iter->cpu_file);

kernel/trace/trace.c

7353

ret = wait_on_pipe(iter, iter->snapshot ? 0 : iter->tr->buffer_percent);

kernel/trace/trace.c

7358

if (!tracer_tracing_is_on(iter->tr))

kernel/trace/trace.c

7377

struct trace_iterator *iter = &info->iter;

kernel/trace/trace.c

7382

err = ring_buffer_wait(iter->array_buffer->buffer,

kernel/trace/trace.c

7383

iter->cpu_file,

kernel/trace/trace.c

7384

iter->tr->buffer_percent,

kernel/trace/trace.c

7390

return ring_buffer_map_get_reader(iter->array_buffer->buffer,

kernel/trace/trace.c

7391

iter->cpu_file);

kernel/trace/trace.c

7403

(void)atomic_fetch_inc_release(&iter->wait_index);

kernel/trace/trace.c

7405

ring_buffer_wake_waiters(iter->array_buffer->buffer, iter->cpu_file);

kernel/trace/trace.c

7417

struct trace_iterator *iter = &info->iter;

kernel/trace/trace.c

7419

ring_buffer_map_dup(iter->array_buffer->buffer, iter->cpu_file);

kernel/trace/trace.c

7425

struct trace_iterator *iter = &info->iter;

kernel/trace/trace.c

7427

WARN_ON(ring_buffer_unmap(iter->array_buffer->buffer, iter->cpu_file));

kernel/trace/trace.c

7428

put_snapshot_map(iter->tr);

kernel/trace/trace.c

7449

struct trace_iterator *iter = &info->iter;

kernel/trace/trace.c

7453

if (iter->tr->flags & (TRACE_ARRAY_FL_MEMMAP | TRACE_ARRAY_FL_VMALLOC))

kernel/trace/trace.c

7456

ret = get_snapshot_map(iter->tr);

kernel/trace/trace.c

7460

ret = ring_buffer_map(iter->array_buffer->buffer, iter->cpu_file, vma);

kernel/trace/trace.c

7462

put_snapshot_map(iter->tr);

kernel/trace/trace.c

9325

static void trace_init_iter(struct trace_iterator *iter, struct trace_array *tr)

kernel/trace/trace.c

9327

iter->tr = tr;

kernel/trace/trace.c

9328

iter->trace = iter->tr->current_trace;

kernel/trace/trace.c

9329

iter->cpu_file = RING_BUFFER_ALL_CPUS;

kernel/trace/trace.c

9330

iter->array_buffer = &tr->array_buffer;

kernel/trace/trace.c

9332

if (iter->trace && iter->trace->open)

kernel/trace/trace.c

9333

iter->trace->open(iter);

kernel/trace/trace.c

9336

if (ring_buffer_overruns(iter->array_buffer->buffer))

kernel/trace/trace.c

9337

iter->iter_flags |= TRACE_FILE_ANNOTATE;

kernel/trace/trace.c

9340

if (trace_clocks[iter->tr->clock_id].in_ns)

kernel/trace/trace.c

9341

iter->iter_flags |= TRACE_FILE_TIME_IN_NS;

kernel/trace/trace.c

9344

iter->temp = static_temp_buf;

kernel/trace/trace.c

9345

iter->temp_size = STATIC_TEMP_BUF_SIZE;

kernel/trace/trace.c

9346

iter->fmt = static_fmt_buf;

kernel/trace/trace.c

9347

iter->fmt_size = STATIC_FMT_BUF_SIZE;

kernel/trace/trace.c

9350

void trace_init_global_iter(struct trace_iterator *iter)

kernel/trace/trace.c

9352

trace_init_iter(iter, &global_trace);

kernel/trace/trace.c

9358

static struct trace_iterator iter;

kernel/trace/trace.c

9376

trace_init_iter(&iter, tr);

kernel/trace/trace.c

9387

iter.cpu_file = raw_smp_processor_id();

kernel/trace/trace.c

9389

iter.cpu_file = RING_BUFFER_ALL_CPUS;

kernel/trace/trace.c

9409

while (!trace_empty(&iter)) {

kernel/trace/trace.c

9416

trace_iterator_reset(&iter);

kernel/trace/trace.c

9417

iter.iter_flags |= TRACE_FILE_LAT_FMT;

kernel/trace/trace.c

9419

if (trace_find_next_entry_inc(&iter) != NULL) {

kernel/trace/trace.c

9422

ret = print_trace_line(&iter);

kernel/trace/trace.c

9424

trace_consume(&iter);

kernel/trace/trace.c

9426

trace_printk_seq(&iter.seq);

kernel/trace/trace.h

1046

print_graph_function_flags(struct trace_iterator *iter, u32 flags);

kernel/trace/trace.h

1050

extern void graph_trace_open(struct trace_iterator *iter);

kernel/trace/trace.h

1051

extern void graph_trace_close(struct trace_iterator *iter);

kernel/trace/trace.h

1230

print_graph_function_flags(struct trace_iterator *iter, u32 flags)

kernel/trace/trace.h

2315

void print_snapshot_help(struct seq_file *m, struct trace_iterator *iter);

kernel/trace/trace.h

2353

static inline void print_snapshot_help(struct seq_file *m, struct trace_iterator *iter)

kernel/trace/trace.h

2384

static __always_inline void trace_iterator_reset(struct trace_iterator *iter)

kernel/trace/trace.h

2386

memset_startat(iter, 0, seq);

kernel/trace/trace.h

2387

iter->pos = -1;

kernel/trace/trace.h

643

void (*open)(struct trace_iterator *iter);

kernel/trace/trace.h

644

void (*pipe_open)(struct trace_iterator *iter);

kernel/trace/trace.h

645

void (*close)(struct trace_iterator *iter);

kernel/trace/trace.h

646

void (*pipe_close)(struct trace_iterator *iter);

kernel/trace/trace.h

647

ssize_t (*read)(struct trace_iterator *iter,

kernel/trace/trace.h

650

ssize_t (*splice_read)(struct trace_iterator *iter,

kernel/trace/trace.h

661

enum print_line_t (*print_line)(struct trace_iterator *iter);

kernel/trace/trace.h

682

trace_buffer_iter(struct trace_iterator *iter, int cpu)

kernel/trace/trace.h

684

return iter->buffer_iter ? iter->buffer_iter[cpu] : NULL;

kernel/trace/trace.h

748

struct trace_iterator iter;

kernel/trace/trace.h

784

struct trace_entry *trace_find_next_entry(struct trace_iterator *iter,

kernel/trace/trace.h

791

const char *trace_event_format(struct trace_iterator *iter, const char *fmt);

kernel/trace/trace.h

792

char *trace_iter_expand_format(struct trace_iterator *iter);

kernel/trace/trace.h

793

bool ignore_event(struct trace_iterator *iter);

kernel/trace/trace.h

795

int trace_empty(struct trace_iterator *iter);

kernel/trace/trace.h

797

void *trace_find_next_entry_inc(struct trace_iterator *iter);

kernel/trace/trace.h

799

void trace_init_global_iter(struct trace_iterator *iter);

kernel/trace/trace.h

801

void tracing_iter_reset(struct trace_iterator *iter, int cpu);

kernel/trace/trace.h

817

void print_trace_header(struct seq_file *m, struct trace_iterator *iter);

kernel/trace/trace.h

984

enum print_line_t print_trace_line(struct trace_iterator *iter);

kernel/trace/trace_branch.c

134

static enum print_line_t trace_branch_print(struct trace_iterator *iter,

kernel/trace/trace_branch.c

139

trace_assign_type(field, iter->ent);

kernel/trace/trace_branch.c

141

trace_seq_printf(&iter->seq, "[%s] %s:%s:%d\n",

kernel/trace/trace_branch.c

147

return trace_handle_return(&iter->seq);

kernel/trace/trace_eprobe.c

256

print_eprobe_event(struct trace_iterator *iter, int flags,

kernel/trace/trace_eprobe.c

262

struct trace_seq *s = &iter->seq;

kernel/trace/trace_eprobe.c

267

field = (struct eprobe_trace_entry_head *)iter->ent;

kernel/trace/trace_eprobe.c

601

struct event_trigger_data *trigger = NULL, *iter;

kernel/trace/trace_eprobe.c

610

list_for_each_entry(iter, &file->triggers, list) {

kernel/trace/trace_eprobe.c

611

if (!(iter->flags & EVENT_TRIGGER_FL_PROBE))

kernel/trace/trace_eprobe.c

613

edata = iter->private_data;

kernel/trace/trace_eprobe.c

615

trigger = iter;

kernel/trace/trace_events.c

1617

struct set_event_iter *iter = v;

kernel/trace/trace_events.c

1623

if (iter->type == SET_EVENT_FILE) {

kernel/trace/trace_events.c

1624

file = iter->file;

kernel/trace/trace_events.c

1627

iter->file = file;

kernel/trace/trace_events.c

1628

return iter;

kernel/trace/trace_events.c

1632

iter->type = SET_EVENT_MOD;

kernel/trace/trace_events.c

1633

iter->event_mod = list_entry(&tr->mod_events, struct event_mod_load, list);

kernel/trace/trace_events.c

1638

list_for_each_entry_continue(iter->event_mod, &tr->mod_events, list)

kernel/trace/trace_events.c

1639

return iter;

kernel/trace/trace_events.c

1648

kfree(iter);

kernel/trace/trace_events.c

1655

struct set_event_iter *iter;

kernel/trace/trace_events.c

1658

iter = kzalloc_obj(*iter);

kernel/trace/trace_events.c

1660

if (!iter)

kernel/trace/trace_events.c

1663

iter->type = SET_EVENT_FILE;

kernel/trace/trace_events.c

1664

iter->file = list_entry(&tr->events, struct trace_event_file, list);

kernel/trace/trace_events.c

1667

iter = s_next(m, iter, &l);

kernel/trace/trace_events.c

1668

if (!iter)

kernel/trace/trace_events.c

1671

return iter;

kernel/trace/trace_events.c

1770

struct set_event_iter *iter = v;

kernel/trace/trace_events.c

1774

if (iter->type == SET_EVENT_FILE)

kernel/trace/trace_events.c

1775

return t_show(m, iter->file);

kernel/trace/trace_events.c

1778

if (iter->event_mod->match) {

kernel/trace/trace_events.c

1779

seq_printf(m, "%s:mod:%s\n", iter->event_mod->match,

kernel/trace/trace_events.c

1780

iter->event_mod->module);

kernel/trace/trace_events.c

1784

system = iter->event_mod->system ? : "*";

kernel/trace/trace_events.c

1785

event = iter->event_mod->event ? : "*";

kernel/trace/trace_events.c

1787

seq_printf(m, "%s:%s:mod:%s\n", system, event, iter->event_mod->module);

kernel/trace/trace_events.c

1794

struct set_event_iter *iter = v;

kernel/trace/trace_events.c

1796

return t_show(m, iter->file);

kernel/trace/trace_events.c

2932

struct event_subsystem *system, *iter;

kernel/trace/trace_events.c

2959

list_for_each_entry(iter, &event_subsystems, list) {

kernel/trace/trace_events.c

2960

if (strcmp(iter->name, name) == 0) {

kernel/trace/trace_events.c

2961

system = iter;

kernel/trace/trace_events.c

4747

struct trace_event_call **iter, *call;

kernel/trace/trace_events.c

4753

for_each_event(iter, __start_ftrace_events, __stop_ftrace_events) {

kernel/trace/trace_events.c

4755

call = *iter;

kernel/trace/trace_events_hist.c

6721

struct event_trigger_data *test = NULL, *iter, *named_data = NULL;

kernel/trace/trace_events_hist.c

6729

list_for_each_entry(iter, &file->triggers, list) {

kernel/trace/trace_events_hist.c

6730

if (iter->cmd_ops->trigger_type == ETT_EVENT_HIST) {

kernel/trace/trace_events_hist.c

6731

if (!hist_trigger_match(data, iter, named_data, false))

kernel/trace/trace_events_hist.c

6733

test = iter;

kernel/trace/trace_events_synth.c

344

static enum print_line_t print_synth_event(struct trace_iterator *iter,

kernel/trace/trace_events_synth.c

348

struct trace_array *tr = iter->tr;

kernel/trace/trace_events_synth.c

349

struct trace_seq *s = &iter->seq;

kernel/trace/trace_events_synth.c

356

entry = (struct synth_trace_event *)iter->ent;

kernel/trace/trace_events_trigger.c

1902

struct event_trigger_data *data = NULL, *iter;

kernel/trace/trace_events_trigger.c

1907

list_for_each_entry(iter, &file->triggers, list) {

kernel/trace/trace_events_trigger.c

1908

enable_data = iter->private_data;

kernel/trace/trace_events_trigger.c

1910

(iter->cmd_ops->trigger_type ==

kernel/trace/trace_events_trigger.c

1913

data = iter;

kernel/trace/trace_events_trigger.c

734

struct event_trigger_data *data = NULL, *iter;

kernel/trace/trace_events_trigger.c

738

list_for_each_entry(iter, &file->triggers, list) {

kernel/trace/trace_events_trigger.c

739

if (iter->cmd_ops->trigger_type == test->cmd_ops->trigger_type) {

kernel/trace/trace_events_trigger.c

740

data = iter;

kernel/trace/trace_events_user.c

1464

static enum print_line_t user_event_print_trace(struct trace_iterator *iter,

kernel/trace/trace_events_user.c

1468

return print_event_fields(iter, event);

kernel/trace/trace_fprobe.c

620

print_fentry_event(struct trace_iterator *iter, int flags,

kernel/trace/trace_fprobe.c

624

struct trace_seq *s = &iter->seq;

kernel/trace/trace_fprobe.c

627

field = (struct fentry_trace_entry_head *)iter->ent;

kernel/trace/trace_fprobe.c

650

print_fexit_event(struct trace_iterator *iter, int flags,

kernel/trace/trace_fprobe.c

654

struct trace_seq *s = &iter->seq;

kernel/trace/trace_fprobe.c

657

field = (struct fexit_trace_entry_head *)iter->ent;

kernel/trace/trace_functions_graph.c

1000

(void *)graph_ret->func + iter->tr->text_delta,

kernel/trace/trace_functions_graph.c

1013

print_graph_irq(iter, graph_ret->func, TRACE_GRAPH_RET,

kernel/trace/trace_functions_graph.c

1014

cpu, iter->ent->pid, flags);

kernel/trace/trace_functions_graph.c

1020

print_graph_entry_nested(struct trace_iterator *iter,

kernel/trace/trace_functions_graph.c

1025

struct fgraph_data *data = iter->private;

kernel/trace/trace_functions_graph.c

1026

struct trace_array *tr = iter->tr;

kernel/trace/trace_functions_graph.c

1033

int cpu = iter->cpu;

kernel/trace/trace_functions_graph.c

1051

func = call->func + iter->tr->text_delta;

kernel/trace/trace_functions_graph.c

1055

args_size = iter->ent_size - offsetof(struct ftrace_graph_ent_entry, args);

kernel/trace/trace_functions_graph.c

1081

print_graph_prologue(struct trace_iterator *iter, struct trace_seq *s,

kernel/trace/trace_functions_graph.c

1084

struct fgraph_data *data = iter->private;

kernel/trace/trace_functions_graph.c

1085

struct trace_entry *ent = iter->ent;

kernel/trace/trace_functions_graph.c

1086

struct trace_array *tr = iter->tr;

kernel/trace/trace_functions_graph.c

1087

int cpu = iter->cpu;

kernel/trace/trace_functions_graph.c

1094

print_graph_irq(iter, addr, type, cpu, ent->pid, flags);

kernel/trace/trace_functions_graph.c

1101

print_graph_abs_time(iter->ts, s);

kernel/trace/trace_functions_graph.c

1105

print_graph_rel_time(iter, s);

kernel/trace/trace_functions_graph.c

1136

check_irq_entry(struct trace_iterator *iter, u32 flags,

kernel/trace/trace_functions_graph.c

1139

int cpu = iter->cpu;

kernel/trace/trace_functions_graph.c

1141

struct fgraph_data *data = iter->private;

kernel/trace/trace_functions_graph.c

1143

addr += iter->tr->text_delta;

kernel/trace/trace_functions_graph.c

1185

check_irq_return(struct trace_iterator *iter, u32 flags, int depth)

kernel/trace/trace_functions_graph.c

1187

int cpu = iter->cpu;

kernel/trace/trace_functions_graph.c

1189

struct fgraph_data *data = iter->private;

kernel/trace/trace_functions_graph.c

1230

struct trace_iterator *iter, u32 flags)

kernel/trace/trace_functions_graph.c

1232

struct fgraph_data *data = iter->private;

kernel/trace/trace_functions_graph.c

1236

int cpu = iter->cpu;

kernel/trace/trace_functions_graph.c

1250

if (iter->ent_size > sizeof(save_buf))

kernel/trace/trace_functions_graph.c

1251

iter->ent_size = sizeof(save_buf);

kernel/trace/trace_functions_graph.c

1254

memcpy(entry, field, iter->ent_size);

kernel/trace/trace_functions_graph.c

1258

if (check_irq_entry(iter, flags, call->func, call->depth))

kernel/trace/trace_functions_graph.c

1261

print_graph_prologue(iter, s, TRACE_GRAPH_ENT, call->func, flags);

kernel/trace/trace_functions_graph.c

1263

leaf_ret = get_return_for_leaf(iter, entry);

kernel/trace/trace_functions_graph.c

1265

ret = print_graph_entry_leaf(iter, entry, leaf_ret, s, flags);

kernel/trace/trace_functions_graph.c

1267

ret = print_graph_entry_nested(iter, entry, s, cpu, flags);

kernel/trace/trace_functions_graph.c

1286

struct trace_entry *ent, struct trace_iterator *iter,

kernel/trace/trace_functions_graph.c

1293

struct fgraph_data *data = iter->private;

kernel/trace/trace_functions_graph.c

1294

struct trace_array *tr = iter->tr;

kernel/trace/trace_functions_graph.c

1297

int cpu = iter->cpu;

kernel/trace/trace_functions_graph.c

1301

func = trace->func + iter->tr->text_delta;

kernel/trace/trace_functions_graph.c

1303

if (check_irq_return(iter, flags, trace->depth))

kernel/trace/trace_functions_graph.c

1308

int cpu = iter->cpu;

kernel/trace/trace_functions_graph.c

1327

print_graph_prologue(iter, s, 0, 0, flags);

kernel/trace/trace_functions_graph.c

1363

print_graph_irq(iter, trace->func, TRACE_GRAPH_RET,

kernel/trace/trace_functions_graph.c

1371

struct trace_iterator *iter, u32 flags)

kernel/trace/trace_functions_graph.c

1373

struct trace_array *tr = iter->tr;

kernel/trace/trace_functions_graph.c

1375

struct fgraph_data *data = iter->private;

kernel/trace/trace_functions_graph.c

1382

depth = per_cpu_ptr(data->cpu_data, iter->cpu)->depth;

kernel/trace/trace_functions_graph.c

1384

print_graph_prologue(iter, s, 0, 0, flags);

kernel/trace/trace_functions_graph.c

1397

switch (iter->ent->type) {

kernel/trace/trace_functions_graph.c

1399

ret = trace_print_bputs_msg_only(iter);

kernel/trace/trace_functions_graph.c

1404

ret = trace_print_bprintk_msg_only(iter);

kernel/trace/trace_functions_graph.c

1409

ret = trace_print_printk_msg_only(iter);

kernel/trace/trace_functions_graph.c

1418

ret = event->funcs->trace(iter, sym_flags, event);

kernel/trace/trace_functions_graph.c

1439

print_graph_function_flags(struct trace_iterator *iter, u32 flags)

kernel/trace/trace_functions_graph.c

1442

struct fgraph_data *data = iter->private;

kernel/trace/trace_functions_graph.c

1443

struct trace_entry *entry = iter->ent;

kernel/trace/trace_functions_graph.c

1444

struct trace_seq *s = &iter->seq;

kernel/trace/trace_functions_graph.c

1445

int cpu = iter->cpu;

kernel/trace/trace_functions_graph.c

1459

iter->cpu = data->cpu;

kernel/trace/trace_functions_graph.c

1460

ret = print_graph_entry(field, s, iter, flags);

kernel/trace/trace_functions_graph.c

1461

if (ret == TRACE_TYPE_HANDLED && iter->cpu != cpu) {

kernel/trace/trace_functions_graph.c

1462

per_cpu_ptr(data->cpu_data, iter->cpu)->ignore = 1;

kernel/trace/trace_functions_graph.c

1465

iter->cpu = cpu;

kernel/trace/trace_functions_graph.c

1472

return print_graph_entry(field, s, iter, flags);

kernel/trace/trace_functions_graph.c

1486

s, iter, flags);

kernel/trace/trace_functions_graph.c

1492

return print_graph_return(field, s, entry, iter, flags);

kernel/trace/trace_functions_graph.c

1500

return print_graph_comment(s, entry, iter, flags);

kernel/trace/trace_functions_graph.c

1507

print_graph_function(struct trace_iterator *iter)

kernel/trace/trace_functions_graph.c

1509

struct trace_array *tr = iter->tr;

kernel/trace/trace_functions_graph.c

1510

return print_graph_function_flags(iter, tr->current_trace_flags->val);

kernel/trace/trace_functions_graph.c

1514

print_graph_function_event(struct trace_iterator *iter, int flags,

kernel/trace/trace_functions_graph.c

1517

return print_graph_function(iter);

kernel/trace/trace_functions_graph.c

1586

struct trace_iterator *iter = s->private;

kernel/trace/trace_functions_graph.c

1587

struct trace_array *tr = iter->tr;

kernel/trace/trace_functions_graph.c

1594

struct trace_iterator *iter = s->private;

kernel/trace/trace_functions_graph.c

1595

struct trace_array *tr = iter->tr;

kernel/trace/trace_functions_graph.c

1602

if (trace_empty(iter))

kernel/trace/trace_functions_graph.c

1605

print_trace_header(s, iter);

kernel/trace/trace_functions_graph.c

1611

void graph_trace_open(struct trace_iterator *iter)

kernel/trace/trace_functions_graph.c

1618

iter->private = NULL;

kernel/trace/trace_functions_graph.c

1643

iter->private = data;

kernel/trace/trace_functions_graph.c

1653

void graph_trace_close(struct trace_iterator *iter)

kernel/trace/trace_functions_graph.c

1655

struct fgraph_data *data = iter->private;

kernel/trace/trace_functions_graph.c

1660

iter->private = NULL;

kernel/trace/trace_functions_graph.c

637

get_return_for_leaf(struct trace_iterator *iter,

kernel/trace/trace_functions_graph.c

640

struct fgraph_data *data = iter->private;

kernel/trace/trace_functions_graph.c

654

ring_iter = trace_buffer_iter(iter, iter->cpu);

kernel/trace/trace_functions_graph.c

664

ring_buffer_consume(iter->array_buffer->buffer, iter->cpu,

kernel/trace/trace_functions_graph.c

666

event = ring_buffer_peek(iter->array_buffer->buffer, iter->cpu,

kernel/trace/trace_functions_graph.c

680

int size = min_t(int, sizeof(data->rent), iter->ent_size);

kernel/trace/trace_functions_graph.c

721

print_graph_rel_time(struct trace_iterator *iter, struct trace_seq *s)

kernel/trace/trace_functions_graph.c

725

usecs = iter->ts - iter->array_buffer->time_start;

kernel/trace/trace_functions_graph.c

732

print_graph_irq(struct trace_iterator *iter, unsigned long addr,

kernel/trace/trace_functions_graph.c

735

struct trace_array *tr = iter->tr;

kernel/trace/trace_functions_graph.c

736

struct trace_seq *s = &iter->seq;

kernel/trace/trace_functions_graph.c

737

struct trace_entry *ent = iter->ent;

kernel/trace/trace_functions_graph.c

739

addr += iter->tr->text_delta;

kernel/trace/trace_functions_graph.c

748

print_graph_abs_time(iter->ts, s);

kernel/trace/trace_functions_graph.c

752

print_graph_rel_time(iter, s);

kernel/trace/trace_functions_graph.c

947

print_graph_entry_leaf(struct trace_iterator *iter,

kernel/trace/trace_functions_graph.c

952

struct fgraph_data *data = iter->private;

kernel/trace/trace_functions_graph.c

953

struct trace_array *tr = iter->tr;

kernel/trace/trace_functions_graph.c

959

int cpu = iter->cpu;

kernel/trace/trace_functions_graph.c

962

args_size = iter->ent_size - offsetof(struct ftrace_graph_ent_entry, args);

kernel/trace/trace_functions_graph.c

993

ret_func = graph_ret->func + iter->tr->text_delta;

kernel/trace/trace_irqsoff.c

246

static void irqsoff_trace_open(struct trace_iterator *iter)

kernel/trace/trace_irqsoff.c

248

if (is_graph(iter->tr))

kernel/trace/trace_irqsoff.c

249

graph_trace_open(iter);

kernel/trace/trace_irqsoff.c

252

static void irqsoff_trace_close(struct trace_iterator *iter)

kernel/trace/trace_irqsoff.c

254

if (iter->private)

kernel/trace/trace_irqsoff.c

255

graph_trace_close(iter);

kernel/trace/trace_irqsoff.c

263

static enum print_line_t irqsoff_print_line(struct trace_iterator *iter)

kernel/trace/trace_irqsoff.c

269

if (is_graph(iter->tr))

kernel/trace/trace_irqsoff.c

270

return print_graph_function_flags(iter, GRAPH_TRACER_FLAGS);

kernel/trace/trace_irqsoff.c

305

static enum print_line_t irqsoff_print_line(struct trace_iterator *iter)

kernel/trace/trace_irqsoff.c

310

static void irqsoff_trace_open(struct trace_iterator *iter) { }

kernel/trace/trace_irqsoff.c

311

static void irqsoff_trace_close(struct trace_iterator *iter) { }

kernel/trace/trace_kdb.c

117

trace_init_global_iter(&iter);

kernel/trace/trace_kdb.c

118

iter.buffer_iter = buffer_iter;

kernel/trace/trace_kdb.c

120

tracer_tracing_disable(iter.tr);

kernel/trace/trace_kdb.c

133

tracer_tracing_enable(iter.tr);

kernel/trace/trace_kdb.c

20

static struct trace_iterator iter;

kernel/trace/trace_kdb.c

29

tr = iter.tr;

kernel/trace/trace_kdb.c

40

trace_iterator_reset(&iter);

kernel/trace/trace_kdb.c

41

iter.iter_flags |= TRACE_FILE_LAT_FMT;

kernel/trace/trace_kdb.c

45

iter.buffer_iter[cpu] =

kernel/trace/trace_kdb.c

46

ring_buffer_read_start(iter.array_buffer->buffer,

kernel/trace/trace_kdb.c

48

tracing_iter_reset(&iter, cpu);

kernel/trace/trace_kdb.c

51

iter.cpu_file = cpu_file;

kernel/trace/trace_kdb.c

52

iter.buffer_iter[cpu_file] =

kernel/trace/trace_kdb.c

53

ring_buffer_read_start(iter.array_buffer->buffer,

kernel/trace/trace_kdb.c

55

tracing_iter_reset(&iter, cpu_file);

kernel/trace/trace_kdb.c

58

while (trace_find_next_entry_inc(&iter)) {

kernel/trace/trace_kdb.c

64

print_trace_line(&iter);

kernel/trace/trace_kdb.c

65

trace_printk_seq(&iter.seq);

kernel/trace/trace_kdb.c

83

if (iter.buffer_iter[cpu]) {

kernel/trace/trace_kdb.c

84

ring_buffer_read_finish(iter.buffer_iter[cpu]);

kernel/trace/trace_kdb.c

85

iter.buffer_iter[cpu] = NULL;

kernel/trace/trace_kprobe.c

1582

print_kprobe_event(struct trace_iterator *iter, int flags,

kernel/trace/trace_kprobe.c

1586

struct trace_seq *s = &iter->seq;

kernel/trace/trace_kprobe.c

1589

field = (struct kprobe_trace_entry_head *)iter->ent;

kernel/trace/trace_kprobe.c

1612

print_kretprobe_event(struct trace_iterator *iter, int flags,

kernel/trace/trace_kprobe.c

1616

struct trace_seq *s = &iter->seq;

kernel/trace/trace_kprobe.c

1619

field = (struct kretprobe_trace_entry_head *)iter->ent;

kernel/trace/trace_mmiotrace.c

100

struct trace_seq *s = &iter->seq;

kernel/trace/trace_mmiotrace.c

109

iter->private = hiter;

kernel/trace/trace_mmiotrace.c

112

static void mmio_close(struct trace_iterator *iter)

kernel/trace/trace_mmiotrace.c

114

struct header_iter *hiter = iter->private;

kernel/trace/trace_mmiotrace.c

116

iter->private = NULL;

kernel/trace/trace_mmiotrace.c

119

static unsigned long count_overruns(struct trace_iterator *iter)

kernel/trace/trace_mmiotrace.c

122

unsigned long over = ring_buffer_overruns(iter->array_buffer->buffer);

kernel/trace/trace_mmiotrace.c

130

static ssize_t mmio_read(struct trace_iterator *iter, struct file *filp,

kernel/trace/trace_mmiotrace.c

134

struct header_iter *hiter = iter->private;

kernel/trace/trace_mmiotrace.c

135

struct trace_seq *s = &iter->seq;

kernel/trace/trace_mmiotrace.c

138

n = count_overruns(iter);

kernel/trace/trace_mmiotrace.c

156

iter->private = NULL;

kernel/trace/trace_mmiotrace.c

164

static enum print_line_t mmio_print_rw(struct trace_iterator *iter)

kernel/trace/trace_mmiotrace.c

166

struct trace_entry *entry = iter->ent;

kernel/trace/trace_mmiotrace.c

169

struct trace_seq *s = &iter->seq;

kernel/trace/trace_mmiotrace.c

170

unsigned long long t = ns2usecs(iter->ts);

kernel/trace/trace_mmiotrace.c

209

static enum print_line_t mmio_print_map(struct trace_iterator *iter)

kernel/trace/trace_mmiotrace.c

211

struct trace_entry *entry = iter->ent;

kernel/trace/trace_mmiotrace.c

214

struct trace_seq *s = &iter->seq;

kernel/trace/trace_mmiotrace.c

215

unsigned long long t = ns2usecs(iter->ts);

kernel/trace/trace_mmiotrace.c

243

static enum print_line_t mmio_print_mark(struct trace_iterator *iter)

kernel/trace/trace_mmiotrace.c

245

struct trace_entry *entry = iter->ent;

kernel/trace/trace_mmiotrace.c

248

struct trace_seq *s = &iter->seq;

kernel/trace/trace_mmiotrace.c

249

unsigned long long t = ns2usecs(iter->ts);

kernel/trace/trace_mmiotrace.c

259

static enum print_line_t mmio_print_line(struct trace_iterator *iter)

kernel/trace/trace_mmiotrace.c

261

switch (iter->ent->type) {

kernel/trace/trace_mmiotrace.c

263

return mmio_print_rw(iter);

kernel/trace/trace_mmiotrace.c

265

return mmio_print_map(iter);

kernel/trace/trace_mmiotrace.c

267

return mmio_print_mark(iter);

kernel/trace/trace_mmiotrace.c

97

static void mmio_pipe_open(struct trace_iterator *iter)

kernel/trace/trace_output.c

1001

pos = (void *)iter->ent + field->offset;

kernel/trace/trace_output.c

1006

trace_seq_printf(&iter->seq, "%.*s", field->size, (char *)pos);

kernel/trace/trace_output.c

1016

if (offset + len > iter->ent_size) {

kernel/trace/trace_output.c

1017

trace_seq_puts(&iter->seq, "<OVERFLOW>");

kernel/trace/trace_output.c

1020

str = (char *)iter->ent + offset;

kernel/trace/trace_output.c

1029

trace_seq_putc(&iter->seq, str[i]);

kernel/trace/trace_output.c

1031

trace_seq_putc(&iter->seq, '.');

kernel/trace/trace_output.c

1033

trace_seq_puts(&iter->seq, " (");

kernel/trace/trace_output.c

1036

trace_seq_putc(&iter->seq, ':');

kernel/trace/trace_output.c

1037

trace_seq_printf(&iter->seq, "%02x", str[i]);

kernel/trace/trace_output.c

1039

trace_seq_putc(&iter->seq, ')');

kernel/trace/trace_output.c

1041

trace_seq_printf(&iter->seq, "%.*s", len, str);

kernel/trace/trace_output.c

1045

if (!iter->fmt_size)

kernel/trace/trace_output.c

1046

trace_iter_expand_format(iter);

kernel/trace/trace_output.c

1048

ret = strncpy_from_kernel_nofault(iter->fmt, (void *)addr,

kernel/trace/trace_output.c

1049

iter->fmt_size);

kernel/trace/trace_output.c

1051

trace_seq_printf(&iter->seq, "(0x%px)", pos);

kernel/trace/trace_output.c

1053

trace_seq_printf(&iter->seq, "(0x%px:%s)",

kernel/trace/trace_output.c

1054

pos, iter->fmt);

kernel/trace/trace_output.c

1058

trace_seq_printf(&iter->seq, "%pS", (void *)addr);

kernel/trace/trace_output.c

1065

trace_seq_printf(&iter->seq, "'%c'",

kernel/trace/trace_output.c

1068

trace_seq_printf(&iter->seq, "(%d)",

kernel/trace/trace_output.c

1072

trace_seq_printf(&iter->seq, "0x%x (%d)",

kernel/trace/trace_output.c

1079

print_array(iter, pos, NULL);

kernel/trace/trace_output.c

1084

print_array(iter, pos, field);

kernel/trace/trace_output.c

1097

trace_seq_printf(&iter->seq, "%pS ", (void *)ip);

kernel/trace/trace_output.c

1102

trace_seq_printf(&iter->seq, "%pS (%d)",

kernel/trace/trace_output.c

1105

trace_seq_printf(&iter->seq, "0x%x (%d)",

kernel/trace/trace_output.c

1113

trace_seq_printf(&iter->seq, "%pS (%lld)",

kernel/trace/trace_output.c

1116

trace_seq_printf(&iter->seq, "0x%llx (%lld)", laddr, laddr);

kernel/trace/trace_output.c

1120

trace_seq_puts(&iter->seq, "<INVALID-SIZE>");

kernel/trace/trace_output.c

1125

trace_seq_puts(&iter->seq, "<INVALID-TYPE>");

kernel/trace/trace_output.c

1128

trace_seq_putc(&iter->seq, '\n');

kernel/trace/trace_output.c

1131

enum print_line_t print_event_fields(struct trace_iterator *iter,

kernel/trace/trace_output.c

1153

trace_seq_printf(&iter->seq, "UNKNOWN TYPE %d\n", event->type);

kernel/trace/trace_output.c

1161

trace_seq_printf(&iter->seq, "%s:", trace_event_name(call));

kernel/trace/trace_output.c

1164

print_fields(iter, call, head);

kernel/trace/trace_output.c

1166

trace_seq_puts(&iter->seq, "No fields found\n");

kernel/trace/trace_output.c

1169

return trace_handle_return(&iter->seq);

kernel/trace/trace_output.c

1172

enum print_line_t trace_nop_print(struct trace_iterator *iter, int flags,

kernel/trace/trace_output.c

1175

trace_seq_printf(&iter->seq, "type: %d\n", iter->ent->type);

kernel/trace/trace_output.c

1177

return trace_handle_return(&iter->seq);

kernel/trace/trace_output.c

1198

static enum print_line_t trace_fn_trace(struct trace_iterator *iter, int flags,

kernel/trace/trace_output.c

1202

struct trace_seq *s = &iter->seq;

kernel/trace/trace_output.c

1206

trace_assign_type(field, iter->ent);

kernel/trace/trace_output.c

1208

args_size = iter->ent_size - offsetof(struct ftrace_entry, args);

kernel/trace/trace_output.c

1214

print_fn_trace(s, field->ip, field->parent_ip, args, iter->tr, flags);

kernel/trace/trace_output.c

1220

static enum print_line_t trace_fn_raw(struct trace_iterator *iter, int flags,

kernel/trace/trace_output.c

1225

trace_assign_type(field, iter->ent);

kernel/trace/trace_output.c

1227

trace_seq_printf(&iter->seq, "%lx %lx\n",

kernel/trace/trace_output.c

1231

return trace_handle_return(&iter->seq);

kernel/trace/trace_output.c

1234

static enum print_line_t trace_fn_hex(struct trace_iterator *iter, int flags,

kernel/trace/trace_output.c

1238

struct trace_seq *s = &iter->seq;

kernel/trace/trace_output.c

1240

trace_assign_type(field, iter->ent);

kernel/trace/trace_output.c

1248

static enum print_line_t trace_fn_bin(struct trace_iterator *iter, int flags,

kernel/trace/trace_output.c

1252

struct trace_seq *s = &iter->seq;

kernel/trace/trace_output.c

1254

trace_assign_type(field, iter->ent);

kernel/trace/trace_output.c

1275

static enum print_line_t trace_ctxwake_print(struct trace_iterator *iter,

kernel/trace/trace_output.c

1283

trace_assign_type(field, iter->ent);

kernel/trace/trace_output.c

1288

trace_seq_printf(&iter->seq,

kernel/trace/trace_output.c

1298

return trace_handle_return(&iter->seq);

kernel/trace/trace_output.c

1301

static enum print_line_t trace_ctx_print(struct trace_iterator *iter, int flags,

kernel/trace/trace_output.c

1304

return trace_ctxwake_print(iter, "==>");

kernel/trace/trace_output.c

1307

static enum print_line_t trace_wake_print(struct trace_iterator *iter,

kernel/trace/trace_output.c

1310

return trace_ctxwake_print(iter, " +");

kernel/trace/trace_output.c

1313

static int trace_ctxwake_raw(struct trace_iterator *iter, char S)

kernel/trace/trace_output.c

1318

trace_assign_type(field, iter->ent);

kernel/trace/trace_output.c

1323

trace_seq_printf(&iter->seq, "%d %d %c %d %d %d %c\n",

kernel/trace/trace_output.c

1332

return trace_handle_return(&iter->seq);

kernel/trace/trace_output.c

1335

static enum print_line_t trace_ctx_raw(struct trace_iterator *iter, int flags,

kernel/trace/trace_output.c

1338

return trace_ctxwake_raw(iter, 0);

kernel/trace/trace_output.c

1341

static enum print_line_t trace_wake_raw(struct trace_iterator *iter, int flags,

kernel/trace/trace_output.c

1344

return trace_ctxwake_raw(iter, '+');

kernel/trace/trace_output.c

1348

static int trace_ctxwake_hex(struct trace_iterator *iter, char S)

kernel/trace/trace_output.c

1351

struct trace_seq *s = &iter->seq;

kernel/trace/trace_output.c

1354

trace_assign_type(field, iter->ent);

kernel/trace/trace_output.c

1371

static enum print_line_t trace_ctx_hex(struct trace_iterator *iter, int flags,

kernel/trace/trace_output.c

1374

return trace_ctxwake_hex(iter, 0);

kernel/trace/trace_output.c

1377

static enum print_line_t trace_wake_hex(struct trace_iterator *iter, int flags,

kernel/trace/trace_output.c

1380

return trace_ctxwake_hex(iter, '+');

kernel/trace/trace_output.c

1383

static enum print_line_t trace_ctxwake_bin(struct trace_iterator *iter,

kernel/trace/trace_output.c

1387

struct trace_seq *s = &iter->seq;

kernel/trace/trace_output.c

1389

trace_assign_type(field, iter->ent);

kernel/trace/trace_output.c

1428

static enum print_line_t trace_stack_print(struct trace_iterator *iter,

kernel/trace/trace_output.c

1432

struct trace_seq *s = &iter->seq;

kernel/trace/trace_output.c

1436

trace_assign_type(field, iter->ent);

kernel/trace/trace_output.c

1437

end = (unsigned long *)((long)iter->ent + iter->ent_size);

kernel/trace/trace_output.c

1451

seq_print_ip_sym(s, trace_adjust_address(iter->tr, *p), flags);

kernel/trace/trace_output.c

1468

static enum print_line_t trace_user_stack_print(struct trace_iterator *iter,

kernel/trace/trace_output.c

1471

struct trace_array *tr = iter->tr;

kernel/trace/trace_output.c

1473

struct trace_seq *s = &iter->seq;

kernel/trace/trace_output.c

1477

trace_assign_type(field, iter->ent);

kernel/trace/trace_output.c

1522

trace_hwlat_print(struct trace_iterator *iter, int flags,

kernel/trace/trace_output.c

1525

struct trace_entry *entry = iter->ent;

kernel/trace/trace_output.c

1526

struct trace_seq *s = &iter->seq;

kernel/trace/trace_output.c

1556

trace_hwlat_raw(struct trace_iterator *iter, int flags,

kernel/trace/trace_output.c

1560

struct trace_seq *s = &iter->seq;

kernel/trace/trace_output.c

1562

trace_assign_type(field, iter->ent);

kernel/trace/trace_output.c

1586

trace_osnoise_print(struct trace_iterator *iter, int flags,

kernel/trace/trace_output.c

1589

struct trace_entry *entry = iter->ent;

kernel/trace/trace_output.c

1590

struct trace_seq *s = &iter->seq;

kernel/trace/trace_output.c

1623

trace_osnoise_raw(struct trace_iterator *iter, int flags,

kernel/trace/trace_output.c

1627

struct trace_seq *s = &iter->seq;

kernel/trace/trace_output.c

1629

trace_assign_type(field, iter->ent);

kernel/trace/trace_output.c

1658

trace_timerlat_print(struct trace_iterator *iter, int flags,

kernel/trace/trace_output.c

1661

struct trace_entry *entry = iter->ent;

kernel/trace/trace_output.c

1662

struct trace_seq *s = &iter->seq;

kernel/trace/trace_output.c

1676

trace_timerlat_raw(struct trace_iterator *iter, int flags,

kernel/trace/trace_output.c

1680

struct trace_seq *s = &iter->seq;

kernel/trace/trace_output.c

1682

trace_assign_type(field, iter->ent);

kernel/trace/trace_output.c

1704

trace_bputs_print(struct trace_iterator *iter, int flags,

kernel/trace/trace_output.c

1707

struct trace_entry *entry = iter->ent;

kernel/trace/trace_output.c

1708

struct trace_seq *s = &iter->seq;

kernel/trace/trace_output.c

1722

trace_bputs_raw(struct trace_iterator *iter, int flags,

kernel/trace/trace_output.c

1726

struct trace_seq *s = &iter->seq;

kernel/trace/trace_output.c

1728

trace_assign_type(field, iter->ent);

kernel/trace/trace_output.c

1748

trace_bprint_print(struct trace_iterator *iter, int flags,

kernel/trace/trace_output.c

1751

struct trace_entry *entry = iter->ent;

kernel/trace/trace_output.c

1752

struct trace_seq *s = &iter->seq;

kernel/trace/trace_output.c

1766

trace_bprint_raw(struct trace_iterator *iter, int flags,

kernel/trace/trace_output.c

1770

struct trace_seq *s = &iter->seq;

kernel/trace/trace_output.c

1772

trace_assign_type(field, iter->ent);

kernel/trace/trace_output.c

1791

static enum print_line_t trace_print_print(struct trace_iterator *iter,

kernel/trace/trace_output.c

1795

struct trace_seq *s = &iter->seq;

kernel/trace/trace_output.c

1798

trace_assign_type(field, iter->ent);

kernel/trace/trace_output.c

1800

ip = trace_adjust_address(iter->tr, field->ip);

kernel/trace/trace_output.c

1808

static enum print_line_t trace_print_raw(struct trace_iterator *iter, int flags,

kernel/trace/trace_output.c

1813

trace_assign_type(field, iter->ent);

kernel/trace/trace_output.c

1815

trace_seq_printf(&iter->seq, "# %lx %s", field->ip, field->buf);

kernel/trace/trace_output.c

1817

return trace_handle_return(&iter->seq);

kernel/trace/trace_output.c

1830

static enum print_line_t trace_raw_data(struct trace_iterator *iter, int flags,

kernel/trace/trace_output.c

1836

trace_assign_type(field, iter->ent);

kernel/trace/trace_output.c

1838

trace_seq_printf(&iter->seq, "# %x buf:", field->id);

kernel/trace/trace_output.c

1840

for (i = 0; i < iter->ent_size - offsetof(struct raw_data_entry, buf); i++)

kernel/trace/trace_output.c

1841

trace_seq_printf(&iter->seq, " %02x",

kernel/trace/trace_output.c

1844

trace_seq_putc(&iter->seq, '\n');

kernel/trace/trace_output.c

1846

return trace_handle_return(&iter->seq);

kernel/trace/trace_output.c

1860

trace_func_repeats_raw(struct trace_iterator *iter, int flags,

kernel/trace/trace_output.c

1864

struct trace_seq *s = &iter->seq;

kernel/trace/trace_output.c

1866

trace_assign_type(field, iter->ent);

kernel/trace/trace_output.c

1878

trace_func_repeats_print(struct trace_iterator *iter, int flags,

kernel/trace/trace_output.c

1882

struct trace_seq *s = &iter->seq;

kernel/trace/trace_output.c

1884

trace_assign_type(field, iter->ent);

kernel/trace/trace_output.c

1886

print_fn_trace(s, field->ip, field->parent_ip, NULL, iter->tr, flags);

kernel/trace/trace_output.c

1888

trace_print_time(s, iter,

kernel/trace/trace_output.c

1889

iter->ts - FUNC_REPEATS_GET_DELTA_TS(field));

kernel/trace/trace_output.c

217

trace_print_bitmask_seq(struct trace_iterator *iter, void *bitmask_ptr,

kernel/trace/trace_output.c

220

struct trace_seq *p = &iter->tmp_seq;

kernel/trace/trace_output.c

221

const struct trace_array *tr = iter->tr;

kernel/trace/trace_output.c

30

enum print_line_t trace_print_bputs_msg_only(struct trace_iterator *iter)

kernel/trace/trace_output.c

32

struct trace_seq *s = &iter->seq;

kernel/trace/trace_output.c

328

int trace_raw_output_prep(struct trace_iterator *iter,

kernel/trace/trace_output.c

33

struct trace_entry *entry = iter->ent;

kernel/trace/trace_output.c

332

struct trace_seq *s = &iter->seq;

kernel/trace/trace_output.c

333

struct trace_seq *p = &iter->tmp_seq;

kernel/trace/trace_output.c

337

entry = iter->ent;

kernel/trace/trace_output.c

351

void trace_event_printf(struct trace_iterator *iter, const char *fmt, ...)

kernel/trace/trace_output.c

353

struct trace_seq *s = &iter->seq;

kernel/trace/trace_output.c

356

if (ignore_event(iter))

kernel/trace/trace_output.c

360

trace_seq_vprintf(s, trace_event_format(iter, fmt), ap);

kernel/trace/trace_output.c

366

int trace_output_raw(struct trace_iterator *iter, char *name,

kernel/trace/trace_output.c

369

struct trace_seq *s = &iter->seq;

kernel/trace/trace_output.c

372

trace_seq_vprintf(s, trace_event_format(iter, fmt), ap);

kernel/trace/trace_output.c

377

int trace_output_call(struct trace_iterator *iter, char *name, char *fmt, ...)

kernel/trace/trace_output.c

383

ret = trace_output_raw(iter, name, fmt, ap);

kernel/trace/trace_output.c

43

enum print_line_t trace_print_bprintk_msg_only(struct trace_iterator *iter)

kernel/trace/trace_output.c

45

struct trace_seq *s = &iter->seq;

kernel/trace/trace_output.c

46

struct trace_entry *entry = iter->ent;

kernel/trace/trace_output.c

56

enum print_line_t trace_print_printk_msg_only(struct trace_iterator *iter)

kernel/trace/trace_output.c

58

struct trace_seq *s = &iter->seq;

kernel/trace/trace_output.c

59

struct trace_entry *entry = iter->ent;

kernel/trace/trace_output.c

597

lat_print_timestamp(struct trace_iterator *iter, u64 next_ts)

kernel/trace/trace_output.c

599

struct trace_array *tr = iter->tr;

kernel/trace/trace_output.c

601

unsigned long in_ns = iter->iter_flags & TRACE_FILE_TIME_IN_NS;

kernel/trace/trace_output.c

602

unsigned long long abs_ts = iter->ts - iter->array_buffer->time_start;

kernel/trace/trace_output.c

603

unsigned long long rel_ts = next_ts - iter->ts;

kernel/trace/trace_output.c

604

struct trace_seq *s = &iter->seq;

kernel/trace/trace_output.c

619

ns2usecs(iter->ts),

kernel/trace/trace_output.c

626

iter->ts, abs_ts, rel_ts);

kernel/trace/trace_output.c

641

static void trace_print_time(struct trace_seq *s, struct trace_iterator *iter,

kernel/trace/trace_output.c

647

if (iter->iter_flags & TRACE_FILE_TIME_IN_NS) {

kernel/trace/trace_output.c

656

int trace_print_context(struct trace_iterator *iter)

kernel/trace/trace_output.c

658

struct trace_array *tr = iter->tr;

kernel/trace/trace_output.c

659

struct trace_seq *s = &iter->seq;

kernel/trace/trace_output.c

660

struct trace_entry *entry = iter->ent;

kernel/trace/trace_output.c

676

trace_seq_printf(s, "[%03d] ", iter->cpu);

kernel/trace/trace_output.c

681

trace_print_time(s, iter, iter->ts);

kernel/trace/trace_output.c

687

int trace_print_lat_context(struct trace_iterator *iter)

kernel/trace/trace_output.c

690

struct trace_array *tr = iter->tr;

kernel/trace/trace_output.c

691

struct trace_seq *s = &iter->seq;

kernel/trace/trace_output.c

695

next_entry = trace_find_next_entry(iter, NULL, &next_ts);

kernel/trace/trace_output.c

697

next_ts = iter->ts;

kernel/trace/trace_output.c

700

entry = iter->ent;

kernel/trace/trace_output.c

709

comm, entry->pid, iter->cpu, entry->flags,

kernel/trace/trace_output.c

710

entry->preempt_count & 0xf, iter->idx);

kernel/trace/trace_output.c

712

lat_print_generic(s, entry, iter->cpu);

kernel/trace/trace_output.c

715

lat_print_timestamp(iter, next_ts);

kernel/trace/trace_output.c

954

static void print_array(struct trace_iterator *iter, void *pos,

kernel/trace/trace_output.c

967

if (offset + len > iter->ent_size) {

kernel/trace/trace_output.c

968

trace_seq_puts(&iter->seq, "<OVERFLOW>");

kernel/trace/trace_output.c

972

pos = (void *)iter->ent + offset;

kernel/trace/trace_output.c

976

trace_seq_putc(&iter->seq, ',');

kernel/trace/trace_output.c

977

trace_seq_printf(&iter->seq, "%02x", *(unsigned char *)pos);

kernel/trace/trace_output.c

981

static void print_fields(struct trace_iterator *iter, struct trace_event_call *call,

kernel/trace/trace_output.c

985

struct trace_array *tr = iter->tr;

kernel/trace/trace_output.c

996

trace_seq_printf(&iter->seq, " %s=", field->name);

kernel/trace/trace_output.c

997

if (field->offset + field->size > iter->ent_size) {

kernel/trace/trace_output.c

998

trace_seq_puts(&iter->seq, "<OVERFLOW>");

kernel/trace/trace_output.h

11

trace_print_bprintk_msg_only(struct trace_iterator *iter);

kernel/trace/trace_output.h

13

trace_print_printk_msg_only(struct trace_iterator *iter);

kernel/trace/trace_output.h

31

extern int trace_print_context(struct trace_iterator *iter);

kernel/trace/trace_output.h

32

extern int trace_print_lat_context(struct trace_iterator *iter);

kernel/trace/trace_output.h

33

extern enum print_line_t print_event_fields(struct trace_iterator *iter,

kernel/trace/trace_output.h

40

extern enum print_line_t trace_nop_print(struct trace_iterator *iter,

kernel/trace/trace_output.h

9

trace_print_bputs_msg_only(struct trace_iterator *iter);

kernel/trace/trace_printk.c

55

const char **iter;

kernel/trace/trace_printk.c

63

for (iter = start; iter < end; iter++) {

kernel/trace/trace_printk.c

64

struct trace_bprintk_fmt *tb_fmt = lookup_format(*iter);

kernel/trace/trace_printk.c

67

*iter = tb_fmt->fmt;

kernel/trace/trace_printk.c

74

fmt = kmalloc(strlen(*iter) + 1, GFP_KERNEL);

kernel/trace/trace_printk.c

77

strcpy(fmt, *iter);

kernel/trace/trace_printk.c

82

*iter = fmt;

kernel/trace/trace_remote.c

296

struct trace_remote_iterator *iter;

kernel/trace/trace_remote.c

298

iter = container_of(dwork, struct trace_remote_iterator, poll_work);

kernel/trace/trace_remote.c

299

ring_buffer_poll_remote(iter->remote->trace_buffer, iter->cpu);

kernel/trace/trace_remote.c

301

msecs_to_jiffies(iter->remote->poll_ms));

kernel/trace/trace_remote.c

304

static void __free_ring_buffer_iter(struct trace_remote_iterator *iter, int cpu)

kernel/trace/trace_remote.c

307

ring_buffer_read_finish(iter->rb_iter);

kernel/trace/trace_remote.c

312

if (iter->rb_iters[cpu])

kernel/trace/trace_remote.c

313

ring_buffer_read_finish(iter->rb_iters[cpu]);

kernel/trace/trace_remote.c

316

kfree(iter->rb_iters);

kernel/trace/trace_remote.c

319

static int __alloc_ring_buffer_iter(struct trace_remote_iterator *iter, int cpu)

kernel/trace/trace_remote.c

322

iter->rb_iter = ring_buffer_read_start(iter->remote->trace_buffer, cpu, GFP_KERNEL);

kernel/trace/trace_remote.c

324

return iter->rb_iter ? 0 : -ENOMEM;

kernel/trace/trace_remote.c

327

iter->rb_iters = kcalloc(nr_cpu_ids, sizeof(*iter->rb_iters), GFP_KERNEL);

kernel/trace/trace_remote.c

328

if (!iter->rb_iters)

kernel/trace/trace_remote.c

332

iter->rb_iters[cpu] = ring_buffer_read_start(iter->remote->trace_buffer, cpu,

kernel/trace/trace_remote.c

334

if (!iter->rb_iters[cpu]) {

kernel/trace/trace_remote.c

336

if (!trace_remote_has_cpu(iter->remote, cpu))

kernel/trace/trace_remote.c

339

__free_ring_buffer_iter(iter, RING_BUFFER_ALL_CPUS);

kernel/trace/trace_remote.c

350

struct trace_remote_iterator *iter = NULL;

kernel/trace/trace_remote.c

367

iter = kzalloc_obj(*iter);

kernel/trace/trace_remote.c

368

if (iter) {

kernel/trace/trace_remote.c

369

iter->remote = remote;

kernel/trace/trace_remote.c

370

iter->cpu = cpu;

kernel/trace/trace_remote.c

371

iter->type = type;

kernel/trace/trace_remote.c

372

trace_seq_init(&iter->seq);

kernel/trace/trace_remote.c

377

INIT_DELAYED_WORK(&iter->poll_work, __poll_remote);

kernel/trace/trace_remote.c

378

schedule_delayed_work(&iter->poll_work, msecs_to_jiffies(remote->poll_ms));

kernel/trace/trace_remote.c

381

ret = __alloc_ring_buffer_iter(iter, cpu);

kernel/trace/trace_remote.c

388

return iter;

kernel/trace/trace_remote.c

393

kfree(iter);

kernel/trace/trace_remote.c

399

static void trace_remote_iter_free(struct trace_remote_iterator *iter)

kernel/trace/trace_remote.c

403

if (!iter)

kernel/trace/trace_remote.c

406

remote = iter->remote;

kernel/trace/trace_remote.c

410

switch (iter->type) {

kernel/trace/trace_remote.c

412

cancel_delayed_work_sync(&iter->poll_work);

kernel/trace/trace_remote.c

415

__free_ring_buffer_iter(iter, iter->cpu);

kernel/trace/trace_remote.c

419

kfree(iter);

kernel/trace/trace_remote.c

423

static void trace_remote_iter_read_start(struct trace_remote_iterator *iter)

kernel/trace/trace_remote.c

425

struct trace_remote *remote = iter->remote;

kernel/trace/trace_remote.c

426

int cpu = iter->cpu;

kernel/trace/trace_remote.c

429

if (cpu == RING_BUFFER_ALL_CPUS && iter->type == TRI_CONSUMING)

kernel/trace/trace_remote.c

446

if (iter->type == TRI_CONSUMING)

kernel/trace/trace_remote.c

452

static void trace_remote_iter_read_finished(struct trace_remote_iterator *iter)

kernel/trace/trace_remote.c

454

struct trace_remote *remote = iter->remote;

kernel/trace/trace_remote.c

455

int cpu = iter->cpu;

kernel/trace/trace_remote.c

463

if (iter->type == TRI_CONSUMING)

kernel/trace/trace_remote.c

470

if (cpu == RING_BUFFER_ALL_CPUS && iter->type == TRI_CONSUMING)

kernel/trace/trace_remote.c

476

static struct ring_buffer_iter *__get_rb_iter(struct trace_remote_iterator *iter, int cpu)

kernel/trace/trace_remote.c

478

return iter->cpu != RING_BUFFER_ALL_CPUS ? iter->rb_iter : iter->rb_iters[cpu];

kernel/trace/trace_remote.c

482

__peek_event(struct trace_remote_iterator *iter, int cpu, u64 *ts, unsigned long *lost_events)

kernel/trace/trace_remote.c

487

switch (iter->type) {

kernel/trace/trace_remote.c

489

return ring_buffer_peek(iter->remote->trace_buffer, cpu, ts, lost_events);

kernel/trace/trace_remote.c

491

rb_iter = __get_rb_iter(iter, cpu);

kernel/trace/trace_remote.c

507

static bool trace_remote_iter_read_event(struct trace_remote_iterator *iter)

kernel/trace/trace_remote.c

509

struct trace_buffer *trace_buffer = iter->remote->trace_buffer;

kernel/trace/trace_remote.c

511

int cpu = iter->cpu;

kernel/trace/trace_remote.c

517

rb_evt = __peek_event(iter, cpu, &iter->ts, &iter->lost_events);

kernel/trace/trace_remote.c

521

iter->evt_cpu = cpu;

kernel/trace/trace_remote.c

522

iter->evt = ring_buffer_event_data(rb_evt);

kernel/trace/trace_remote.c

526

iter->ts = U64_MAX;

kernel/trace/trace_remote.c

534

rb_evt = __peek_event(iter, cpu, &ts, &lost_events);

kernel/trace/trace_remote.c

538

if (ts >= iter->ts)

kernel/trace/trace_remote.c

541

iter->ts = ts;

kernel/trace/trace_remote.c

542

iter->evt_cpu = cpu;

kernel/trace/trace_remote.c

543

iter->evt = ring_buffer_event_data(rb_evt);

kernel/trace/trace_remote.c

544

iter->lost_events = lost_events;

kernel/trace/trace_remote.c

547

return iter->ts != U64_MAX;

kernel/trace/trace_remote.c

550

static void trace_remote_iter_move(struct trace_remote_iterator *iter)

kernel/trace/trace_remote.c

552

struct trace_buffer *trace_buffer = iter->remote->trace_buffer;

kernel/trace/trace_remote.c

554

switch (iter->type) {

kernel/trace/trace_remote.c

556

ring_buffer_consume(trace_buffer, iter->evt_cpu, NULL, NULL);

kernel/trace/trace_remote.c

559

ring_buffer_iter_advance(__get_rb_iter(iter, iter->evt_cpu));

kernel/trace/trace_remote.c

566

static int trace_remote_iter_print_event(struct trace_remote_iterator *iter)

kernel/trace/trace_remote.c

570

u64 ts = iter->ts;

kernel/trace/trace_remote.c

572

if (iter->lost_events)

kernel/trace/trace_remote.c

573

trace_seq_printf(&iter->seq, "CPU:%d [LOST %lu EVENTS]\n",

kernel/trace/trace_remote.c

574

iter->evt_cpu, iter->lost_events);

kernel/trace/trace_remote.c

579

trace_seq_printf(&iter->seq, "[%03d]\t%5llu.%06lu: ", iter->evt_cpu,

kernel/trace/trace_remote.c

582

evt = trace_remote_find_event(iter->remote, iter->evt->id);

kernel/trace/trace_remote.c

584

trace_seq_printf(&iter->seq, "UNKNOWN id=%d\n", iter->evt->id);

kernel/trace/trace_remote.c

586

evt->print(iter->evt, &iter->seq);

kernel/trace/trace_remote.c

588

return trace_seq_has_overflowed(&iter->seq) ? -EOVERFLOW : 0;

kernel/trace/trace_remote.c

594

struct trace_remote_iterator *iter;

kernel/trace/trace_remote.c

599

iter = trace_remote_iter(remote, cpu, TRI_CONSUMING);

kernel/trace/trace_remote.c

600

if (IS_ERR(iter))

kernel/trace/trace_remote.c

601

return PTR_ERR(iter);

kernel/trace/trace_remote.c

603

filp->private_data = iter;

kernel/trace/trace_remote.c

610

struct trace_remote_iterator *iter = filp->private_data;

kernel/trace/trace_remote.c

611

struct trace_remote *remote = iter->remote;

kernel/trace/trace_remote.c

615

trace_remote_iter_free(iter);

kernel/trace/trace_remote.c

622

struct trace_remote_iterator *iter = filp->private_data;

kernel/trace/trace_remote.c

623

struct trace_buffer *trace_buffer = iter->remote->trace_buffer;

kernel/trace/trace_remote.c

627

ret = trace_seq_to_user(&iter->seq, ubuf, cnt);

kernel/trace/trace_remote.c

631

trace_seq_init(&iter->seq);

kernel/trace/trace_remote.c

633

ret = ring_buffer_wait(trace_buffer, iter->cpu, 0, NULL, NULL);

kernel/trace/trace_remote.c

637

trace_remote_iter_read_start(iter);

kernel/trace/trace_remote.c

639

while (trace_remote_iter_read_event(iter)) {

kernel/trace/trace_remote.c

640

int prev_len = iter->seq.seq.len;

kernel/trace/trace_remote.c

642

if (trace_remote_iter_print_event(iter)) {

kernel/trace/trace_remote.c

643

iter->seq.seq.len = prev_len;

kernel/trace/trace_remote.c

647

trace_remote_iter_move(iter);

kernel/trace/trace_remote.c

650

trace_remote_iter_read_finished(iter);

kernel/trace/trace_remote.c

663

struct trace_remote_iterator *iter = m->private;

kernel/trace/trace_remote.c

667

if (!iter || !trace_remote_iter_read_event(iter))

kernel/trace/trace_remote.c

670

trace_remote_iter_move(iter);

kernel/trace/trace_remote.c

671

iter->pos++;

kernel/trace/trace_remote.c

673

return iter;

kernel/trace/trace_remote.c

678

struct trace_remote_iterator *iter = m->private;

kernel/trace/trace_remote.c

681

if (!iter)

kernel/trace/trace_remote.c

684

trace_remote_iter_read_start(iter);

kernel/trace/trace_remote.c

687

iter->pos = -1;

kernel/trace/trace_remote.c

691

i = iter->pos;

kernel/trace/trace_remote.c

693

iter = trace_next(m, NULL, &i);

kernel/trace/trace_remote.c

694

if (!iter)

kernel/trace/trace_remote.c

698

return iter;

kernel/trace/trace_remote.c

703

struct trace_remote_iterator *iter = v;

kernel/trace/trace_remote.c

705

trace_seq_init(&iter->seq);

kernel/trace/trace_remote.c

707

if (trace_remote_iter_print_event(iter)) {

kernel/trace/trace_remote.c

708

seq_printf(m, "[EVENT %d PRINT TOO BIG]\n", iter->evt->id);

kernel/trace/trace_remote.c

712

return trace_print_seq(m, &iter->seq);

kernel/trace/trace_remote.c

717

struct trace_remote_iterator *iter = m->private;

kernel/trace/trace_remote.c

719

if (iter)

kernel/trace/trace_remote.c

720

trace_remote_iter_read_finished(iter);

kernel/trace/trace_remote.c

733

struct trace_remote_iterator *iter = NULL;

kernel/trace/trace_remote.c

742

iter = trace_remote_iter(remote, cpu, TRI_NONCONSUMING);

kernel/trace/trace_remote.c

743

if (IS_ERR(iter))

kernel/trace/trace_remote.c

744

return PTR_ERR(iter);

kernel/trace/trace_remote.c

748

trace_remote_iter_free(iter);

kernel/trace/trace_remote.c

752

((struct seq_file *)filp->private_data)->private = (void *)iter;

kernel/trace/trace_remote.c

759

struct trace_remote_iterator *iter;

kernel/trace/trace_remote.c

764

iter = ((struct seq_file *)filp->private_data)->private;

kernel/trace/trace_remote.c

767

if (!iter)

kernel/trace/trace_remote.c

770

guard(mutex)(&iter->remote->lock);

kernel/trace/trace_remote.c

772

trace_remote_iter_free(iter);

kernel/trace/trace_sched_wakeup.c

183

static void wakeup_trace_open(struct trace_iterator *iter)

kernel/trace/trace_sched_wakeup.c

185

if (is_graph(iter->tr))

kernel/trace/trace_sched_wakeup.c

186

graph_trace_open(iter);

kernel/trace/trace_sched_wakeup.c

189

static void wakeup_trace_close(struct trace_iterator *iter)

kernel/trace/trace_sched_wakeup.c

191

if (iter->private)

kernel/trace/trace_sched_wakeup.c

192

graph_trace_close(iter);

kernel/trace/trace_sched_wakeup.c

202

static enum print_line_t wakeup_print_line(struct trace_iterator *iter)

kernel/trace/trace_sched_wakeup.c

208

if (is_graph(iter->tr))

kernel/trace/trace_sched_wakeup.c

209

return print_graph_function_flags(iter, GRAPH_TRACER_FLAGS);

kernel/trace/trace_sched_wakeup.c

302

static enum print_line_t wakeup_print_line(struct trace_iterator *iter)

kernel/trace/trace_sched_wakeup.c

307

static void wakeup_trace_open(struct trace_iterator *iter) { }

kernel/trace/trace_sched_wakeup.c

308

static void wakeup_trace_close(struct trace_iterator *iter) { }

kernel/trace/trace_snapshot.c

573

void print_snapshot_help(struct seq_file *m, struct trace_iterator *iter)

kernel/trace/trace_snapshot.c

575

if (iter->tr->allocated_snapshot)

kernel/trace/trace_snapshot.c

581

if (iter->cpu_file == RING_BUFFER_ALL_CPUS)

kernel/trace/trace_snapshot.c

590

struct trace_iterator *iter;

kernel/trace/trace_snapshot.c

599

iter = __tracing_open(inode, file, true);

kernel/trace/trace_snapshot.c

600

if (IS_ERR(iter))

kernel/trace/trace_snapshot.c

601

ret = PTR_ERR(iter);

kernel/trace/trace_snapshot.c

608

iter = kzalloc_obj(*iter);

kernel/trace/trace_snapshot.c

609

if (!iter) {

kernel/trace/trace_snapshot.c

615

iter->tr = tr;

kernel/trace/trace_snapshot.c

616

iter->array_buffer = &tr->snapshot_buffer;

kernel/trace/trace_snapshot.c

617

iter->cpu_file = tracing_get_cpu(inode);

kernel/trace/trace_snapshot.c

618

m->private = iter;

kernel/trace/trace_snapshot.c

638

struct trace_iterator *iter = m->private;

kernel/trace/trace_snapshot.c

639

struct trace_array *tr = iter->tr;

kernel/trace/trace_snapshot.c

667

if (iter->cpu_file != RING_BUFFER_ALL_CPUS)

kernel/trace/trace_snapshot.c

675

if (iter->cpu_file != RING_BUFFER_ALL_CPUS)

kernel/trace/trace_snapshot.c

680

&tr->array_buffer, iter->cpu_file);

kernel/trace/trace_snapshot.c

687

if (iter->cpu_file == RING_BUFFER_ALL_CPUS) {

kernel/trace/trace_snapshot.c

692

smp_call_function_single(iter->cpu_file, tracing_swap_cpu_buffer,

kernel/trace/trace_snapshot.c

699

if (iter->cpu_file == RING_BUFFER_ALL_CPUS)

kernel/trace/trace_snapshot.c

702

tracing_reset_cpu(&tr->snapshot_buffer, iter->cpu_file);

kernel/trace/trace_snapshot.c

745

if (tracer_uses_snapshot(info->iter.trace)) {

kernel/trace/trace_snapshot.c

750

info->iter.snapshot = true;

kernel/trace/trace_snapshot.c

751

info->iter.array_buffer = &info->iter.tr->snapshot_buffer;

kernel/trace/trace_syscalls.c

240

print_syscall_enter(struct trace_iterator *iter, int flags,

kernel/trace/trace_syscalls.c

243

struct trace_array *tr = iter->tr;

kernel/trace/trace_syscalls.c

244

struct trace_seq *s = &iter->seq;

kernel/trace/trace_syscalls.c

245

struct trace_entry *ent = iter->ent;

kernel/trace/trace_syscalls.c

348

print_syscall_exit(struct trace_iterator *iter, int flags,

kernel/trace/trace_syscalls.c

351

struct trace_seq *s = &iter->seq;

kernel/trace/trace_syscalls.c

352

struct trace_entry *ent = iter->ent;

kernel/trace/trace_uprobe.c

1067

print_uprobe_event(struct trace_iterator *iter, int flags, struct trace_event *event)

kernel/trace/trace_uprobe.c

1070

struct trace_seq *s = &iter->seq;

kernel/trace/trace_uprobe.c

1074

entry = (struct uprobe_trace_entry_head *)iter->ent;

kernel/tracepoint.c

526

tracepoint_ptr_t *iter;

kernel/tracepoint.c

530

for (iter = begin; iter < end; iter++)

kernel/tracepoint.c

531

fct(tracepoint_ptr_deref(iter), priv);

kernel/tracepoint.c

714

tracepoint_ptr_t *begin, *end, *iter;

kernel/tracepoint.c

724

for (iter = begin; iter < end; iter++)

kernel/tracepoint.c

725

fct(tracepoint_ptr_deref(iter), mod, priv);

kernel/ucount.c

217

struct ucounts *ucounts, *iter, *bad;

kernel/ucount.c

220

for (iter = ucounts; iter; iter = tns->ucounts) {

kernel/ucount.c

222

tns = iter->ns;

kernel/ucount.c

224

if (!atomic_long_inc_below(&iter->ucount[type], max))

kernel/ucount.c

229

bad = iter;

kernel/ucount.c

230

for (iter = ucounts; iter != bad; iter = iter->ns->ucounts)

kernel/ucount.c

231

atomic_long_dec(&iter->ucount[type]);

kernel/ucount.c

239

struct ucounts *iter;

kernel/ucount.c

240

for (iter = ucounts; iter; iter = iter->ns->ucounts) {

kernel/ucount.c

241

long dec = atomic_long_dec_if_positive(&iter->ucount[type]);

kernel/ucount.c

249

struct ucounts *iter;

kernel/ucount.c

253

for (iter = ucounts; iter; iter = iter->ns->ucounts) {

kernel/ucount.c

254

long new = atomic_long_add_return(v, &iter->rlimit[type]);

kernel/ucount.c

257

else if (iter == ucounts)

kernel/ucount.c

259

max = get_userns_rlimit_max(iter->ns, type);

kernel/ucount.c

266

struct ucounts *iter;

kernel/ucount.c

268

for (iter = ucounts; iter; iter = iter->ns->ucounts) {

kernel/ucount.c

269

long dec = atomic_long_sub_return(v, &iter->rlimit[type]);

kernel/ucount.c

271

if (iter == ucounts)

kernel/ucount.c

280

struct ucounts *iter, *next;

kernel/ucount.c

281

for (iter = ucounts; iter != last; iter = next) {

kernel/ucount.c

282

long dec = atomic_long_sub_return(1, &iter->rlimit[type]);

kernel/ucount.c

284

next = iter->ns->ucounts;

kernel/ucount.c

286

put_ucounts(iter);

kernel/ucount.c

299

struct ucounts *iter;

kernel/ucount.c

303

for (iter = ucounts; iter; iter = iter->ns->ucounts) {

kernel/ucount.c

304

long new = atomic_long_add_return(1, &iter->rlimit[type]);

kernel/ucount.c

307

if (iter == ucounts)

kernel/ucount.c

310

max = get_userns_rlimit_max(iter->ns, type);

kernel/ucount.c

317

if (!get_ucounts(iter))

kernel/ucount.c

322

dec = atomic_long_sub_return(1, &iter->rlimit[type]);

kernel/ucount.c

324

do_dec_rlimit_put_ucounts(ucounts, iter, type);

kernel/ucount.c

330

struct ucounts *iter;

kernel/ucount.c

334

for (iter = ucounts; iter; iter = iter->ns->ucounts) {

kernel/ucount.c

335

long val = get_rlimit_value(iter, type);

kernel/ucount.c

338

max = get_userns_rlimit_max(iter->ns, type);

lib/alloc_tag.c

130

alloc_tag_to_text(&buf, priv->iter.ct);

lib/alloc_tag.c

144

struct codetag_iterator iter;

lib/alloc_tag.c

157

iter = codetag_get_ct_iter(alloc_tag_cttype);

lib/alloc_tag.c

158

while ((ct = codetag_next_ct(&iter))) {

lib/alloc_tag.c

56

struct codetag_iterator iter;

lib/alloc_tag.c

70

priv->iter = codetag_get_ct_iter(alloc_tag_cttype);

lib/alloc_tag.c

72

priv->iter = priv->reported_iter;

lib/alloc_tag.c

74

codetag_next_ct(&priv->iter);

lib/alloc_tag.c

75

return priv->iter.ct ? priv : NULL;

lib/alloc_tag.c

83

priv->reported_iter = priv->iter;

lib/alloc_tag.c

84

ct = codetag_next_ct(&priv->iter);

lib/codetag.c

104

if (!iter->cmod || iter->mod_seq != cmod->mod_seq) {

lib/codetag.c

105

iter->cmod = cmod;

lib/codetag.c

106

iter->mod_seq = cmod->mod_seq;

lib/codetag.c

109

ct = get_next_module_ct(iter);

lib/codetag.c

115

iter->mod_id++;

lib/codetag.c

118

iter->ct = ct;

lib/codetag.c

55

struct codetag_iterator iter = {

lib/codetag.c

63

return iter;

lib/codetag.c

72

struct codetag *get_next_module_ct(struct codetag_iterator *iter)

lib/codetag.c

75

((char *)iter->ct + iter->cttype->desc.tag_size);

lib/codetag.c

77

return res < iter->cmod->range.stop ? res : NULL;

lib/codetag.c

80

struct codetag *codetag_next_ct(struct codetag_iterator *iter)

lib/codetag.c

82

struct codetag_type *cttype = iter->cttype;

lib/codetag.c

93

cmod = idr_find(&cttype->mod_idr, iter->mod_id);

lib/codetag.c

98

&iter->mod_id);

lib/dynamic_debug.c

1036

static struct _ddebug *ddebug_iter_first(struct ddebug_iter *iter)

lib/dynamic_debug.c

1039

iter->table = NULL;

lib/dynamic_debug.c

1042

iter->table = list_entry(ddebug_tables.next,

lib/dynamic_debug.c

1044

iter->idx = iter->table->num_ddebugs;

lib/dynamic_debug.c

1045

return &iter->table->ddebugs[--iter->idx];

lib/dynamic_debug.c

1054

static struct _ddebug *ddebug_iter_next(struct ddebug_iter *iter)

lib/dynamic_debug.c

1056

if (iter->table == NULL)

lib/dynamic_debug.c

1058

if (--iter->idx < 0) {

lib/dynamic_debug.c

1060

if (list_is_last(&iter->table->link, &ddebug_tables)) {

lib/dynamic_debug.c

1061

iter->table = NULL;

lib/dynamic_debug.c

1064

iter->table = list_entry(iter->table->link.next,

lib/dynamic_debug.c

1066

iter->idx = iter->table->num_ddebugs;

lib/dynamic_debug.c

1067

--iter->idx;

lib/dynamic_debug.c

1069

return &iter->table->ddebugs[iter->idx];

lib/dynamic_debug.c

1079

struct ddebug_iter *iter = m->private;

lib/dynamic_debug.c

1089

dp = ddebug_iter_first(iter);

lib/dynamic_debug.c

1091

dp = ddebug_iter_next(iter);

lib/dynamic_debug.c

1102

struct ddebug_iter *iter = m->private;

lib/dynamic_debug.c

1106

dp = ddebug_iter_first(iter);

lib/dynamic_debug.c

1108

dp = ddebug_iter_next(iter);

lib/dynamic_debug.c

1116

static const char *ddebug_class_name(struct ddebug_iter *iter, struct _ddebug *dp)

lib/dynamic_debug.c

1120

list_for_each_entry(map, &iter->table->maps, link)

lib/dynamic_debug.c

1135

struct ddebug_iter *iter = m->private;

lib/dynamic_debug.c

1148

iter->table->mod_name, dp->function,

lib/dynamic_debug.c

1154

class = ddebug_class_name(iter, dp);

lib/dynamic_debug.c

1410

struct _ddebug *iter, *iter_mod_start;

lib/dynamic_debug.c

1440

iter = iter_mod_start = __start___dyndbg;

lib/dynamic_debug.c

1441

modname = iter->modname;

lib/dynamic_debug.c

1444

for (; iter < __stop___dyndbg; iter++, i++, mod_sites++) {

lib/dynamic_debug.c

1446

if (strcmp(modname, iter->modname)) {

lib/dynamic_debug.c

1455

modname = iter->modname;

lib/dynamic_debug.c

1456

iter_mod_start = iter;

lib/error-inject.c

68

struct error_injection_entry *iter;

lib/error-inject.c

73

for (iter = start; iter < end; iter++) {

lib/error-inject.c

74

entry = (unsigned long)dereference_symbol_descriptor((void *)iter->addr);

lib/error-inject.c

88

ent->etype = iter->etype;

lib/generic-radix-tree.c

105

if (ilog2(iter->offset) >= genradix_depth_shift(level))

lib/generic-radix-tree.c

111

i = (iter->offset >> genradix_depth_shift(level)) &

lib/generic-radix-tree.c

117

if (iter->offset + objs_per_ptr < iter->offset) {

lib/generic-radix-tree.c

118

iter->offset = SIZE_MAX;

lib/generic-radix-tree.c

119

iter->pos = SIZE_MAX;

lib/generic-radix-tree.c

124

iter->offset = round_down(iter->offset + objs_per_ptr,

lib/generic-radix-tree.c

126

iter->pos = (iter->offset >> GENRADIX_NODE_SHIFT) *

lib/generic-radix-tree.c

135

return &n->data[iter->offset & (GENRADIX_NODE_SIZE - 1)];

lib/generic-radix-tree.c

139

void *__genradix_iter_peek_prev(struct genradix_iter *iter,

lib/generic-radix-tree.c

148

if (iter->offset == SIZE_MAX)

lib/generic-radix-tree.c

159

if (ilog2(iter->offset) >= genradix_depth_shift(level)) {

lib/generic-radix-tree.c

160

iter->offset = genradix_depth_size(level);

lib/generic-radix-tree.c

161

iter->pos = (iter->offset >> GENRADIX_NODE_SHIFT) * objs_per_page;

lib/generic-radix-tree.c

163

iter->offset -= obj_size_plus_page_remainder;

lib/generic-radix-tree.c

164

iter->pos--;

lib/generic-radix-tree.c

170

i = (iter->offset >> genradix_depth_shift(level)) &

lib/generic-radix-tree.c

176

iter->offset = round_down(iter->offset, objs_per_ptr);

lib/generic-radix-tree.c

177

iter->pos = (iter->offset >> GENRADIX_NODE_SHIFT) * objs_per_page;

lib/generic-radix-tree.c

179

if (!iter->offset)

lib/generic-radix-tree.c

182

iter->offset -= obj_size_plus_page_remainder;

lib/generic-radix-tree.c

183

iter->pos--;

lib/generic-radix-tree.c

193

return &n->data[iter->offset & (GENRADIX_NODE_SIZE - 1)];

lib/generic-radix-tree.c

86

void *__genradix_iter_peek(struct genradix_iter *iter,

lib/generic-radix-tree.c

94

if (iter->offset == SIZE_MAX)

lib/idr.c

200

struct radix_tree_iter iter;

lib/idr.c

204

radix_tree_for_each_slot(slot, &idr->idr_rt, &iter, 0) {

lib/idr.c

206

unsigned long id = iter.index + base;

lib/idr.c

231

struct radix_tree_iter iter;

lib/idr.c

238

radix_tree_for_each_slot(slot, &idr->idr_rt, &iter, id) {

lib/idr.c

246

slot = radix_tree_iter_retry(&iter);

lib/idr.c

251

*nextid = iter.index + base;

lib/idr.c

36

struct radix_tree_iter iter;

lib/idr.c

47

radix_tree_iter_init(&iter, id);

lib/idr.c

48

slot = idr_get_free(&idr->idr_rt, &iter, gfp, max - base);

lib/idr.c

52

*nextid = iter.index + base;

lib/idr.c

54

radix_tree_iter_replace(&idr->idr_rt, &iter, slot, ptr);

lib/idr.c

55

radix_tree_iter_tag_clear(&idr->idr_rt, &iter, IDR_FREE);

lib/interval_tree.c

100

iter->last_used = iter->last_index;

lib/interval_tree.c

101

iter->nodes[0] = NULL;

lib/interval_tree.c

102

iter->nodes[1] = NULL;

lib/interval_tree.c

104

iter->is_hole = 0;

lib/interval_tree.c

108

if (!iter->nodes[1]) {

lib/interval_tree.c

110

iter->start_hole = iter->nodes[0]->last + 1;

lib/interval_tree.c

111

iter->last_hole = iter->last_index;

lib/interval_tree.c

112

iter->nodes[0] = NULL;

lib/interval_tree.c

113

iter->is_hole = 1;

lib/interval_tree.c

118

iter->start_hole = iter->nodes[0]->last + 1;

lib/interval_tree.c

119

iter->last_hole = iter->nodes[1]->start - 1;

lib/interval_tree.c

120

iter->is_hole = 1;

lib/interval_tree.c

121

interval_tree_span_iter_next_gap(iter);

lib/interval_tree.c

131

void interval_tree_span_iter_advance(struct interval_tree_span_iter *iter,

lib/interval_tree.c

135

if (iter->is_hole == -1)

lib/interval_tree.c

138

iter->first_index = new_index;

lib/interval_tree.c

139

if (new_index > iter->last_index) {

lib/interval_tree.c

140

iter->is_hole = -1;

lib/interval_tree.c

145

if (iter->start_hole <= new_index && new_index <= iter->last_hole) {

lib/interval_tree.c

146

iter->start_hole = new_index;

lib/interval_tree.c

149

if (new_index == iter->last_hole + 1)

lib/interval_tree.c

150

interval_tree_span_iter_next(iter);

lib/interval_tree.c

152

interval_tree_span_iter_first(iter, itree, new_index,

lib/interval_tree.c

153

iter->last_index);

lib/interval_tree.c

50

void interval_tree_span_iter_first(struct interval_tree_span_iter *iter,

lib/interval_tree.c

55

iter->first_index = first_index;

lib/interval_tree.c

56

iter->last_index = last_index;

lib/interval_tree.c

57

iter->nodes[0] = NULL;

lib/interval_tree.c

58

iter->nodes[1] =

lib/interval_tree.c

60

if (!iter->nodes[1]) {

lib/interval_tree.c

62

iter->start_hole = first_index;

lib/interval_tree.c

63

iter->last_hole = last_index;

lib/interval_tree.c

64

iter->is_hole = 1;

lib/interval_tree.c

67

if (iter->nodes[1]->start > first_index) {

lib/interval_tree.c

69

iter->start_hole = first_index;

lib/interval_tree.c

70

iter->last_hole = iter->nodes[1]->start - 1;

lib/interval_tree.c

71

iter->is_hole = 1;

lib/interval_tree.c

72

interval_tree_span_iter_next_gap(iter);

lib/interval_tree.c

77

iter->start_used = first_index;

lib/interval_tree.c

78

iter->is_hole = 0;

lib/interval_tree.c

79

interval_tree_span_iter_next_gap(iter);

lib/interval_tree.c

80

iter->last_used = iter->nodes[0]->last;

lib/interval_tree.c

81

if (iter->last_used >= last_index) {

lib/interval_tree.c

82

iter->last_used = last_index;

lib/interval_tree.c

83

iter->nodes[0] = NULL;

lib/interval_tree.c

84

iter->nodes[1] = NULL;

lib/interval_tree.c

89

void interval_tree_span_iter_next(struct interval_tree_span_iter *iter)

lib/interval_tree.c

91

if (!iter->nodes[0] && !iter->nodes[1]) {

lib/interval_tree.c

92

iter->is_hole = -1;

lib/interval_tree.c

96

if (iter->is_hole) {

lib/interval_tree.c

97

iter->start_used = iter->last_hole + 1;

lib/interval_tree.c

98

iter->last_used = iter->nodes[0]->last;

lib/interval_tree.c

99

if (iter->last_used >= iter->last_index) {

lib/iov_iter.c

1916

ssize_t iov_iter_extract_bvecs(struct iov_iter *iter, struct bio_vec *bv,

lib/iov_iter.c

1935

size = iov_iter_extract_pages(iter, &pages, max_size, entries_left,

lib/iov_iter.c

1956

iov_iter_revert(iter, left);

lib/iov_iter.c

1957

if (iov_iter_extract_will_pin(iter)) {

lib/iov_iter.c

913

static ssize_t iter_folioq_get_pages(struct iov_iter *iter,

lib/iov_iter.c

917

const struct folio_queue *folioq = iter->folioq;

lib/iov_iter.c

919

unsigned int slot = iter->folioq_slot;

lib/iov_iter.c

920

size_t extracted = 0, count = iter->count, iov_offset = iter->iov_offset;

lib/iov_iter.c

965

iter->count = count;

lib/iov_iter.c

966

iter->iov_offset = iov_offset;

lib/iov_iter.c

967

iter->folioq = folioq;

lib/iov_iter.c

968

iter->folioq_slot = slot;

lib/math/cordic.c

50

unsigned iter;

lib/math/cordic.c

71

for (iter = 0; iter < CORDIC_NUM_ITER; iter++) {

lib/math/cordic.c

73

valtmp = coord.i - (coord.q >> iter);

lib/math/cordic.c

74

coord.q += (coord.i >> iter);

lib/math/cordic.c

75

angle += arctan_table[iter];

lib/math/cordic.c

77

valtmp = coord.i + (coord.q >> iter);

lib/math/cordic.c

78

coord.q -= (coord.i >> iter);

lib/math/cordic.c

79

angle -= arctan_table[iter];

lib/plist.c

101

prev = iter;

lib/plist.c

102

iter = list_entry(iter->prio_list.next,

lib/plist.c

106

} while (iter != first);

lib/plist.c

109

list_add_tail(&node->prio_list, &iter->prio_list);

lib/plist.c

157

struct plist_node *iter;

lib/plist.c

167

iter = plist_next(node);

lib/plist.c

169

if (node->prio != iter->prio)

lib/plist.c

178

if (!list_empty(&iter->prio_list)) {

lib/plist.c

179

iter = list_entry(iter->prio_list.next, struct plist_node,

lib/plist.c

181

node_next = &iter->node_list;

lib/plist.c

185

plist_for_each_continue(iter, head) {

lib/plist.c

186

if (node->prio != iter->prio) {

lib/plist.c

187

node_next = &iter->node_list;

lib/plist.c

75

struct plist_node *first, *iter, *prev = NULL, *last, *reverse_iter;

lib/plist.c

85

first = iter = plist_first(head);

lib/plist.c

89

if (node->prio < iter->prio) {

lib/plist.c

90

node_next = &iter->node_list;

lib/plist.c

94

iter = list_entry(reverse_iter->prio_list.next,

lib/plist.c

97

node_next = &iter->node_list;

lib/radix-tree.c

1061

const struct radix_tree_iter *iter, unsigned int tag)

lib/radix-tree.c

1063

node_tag_clear(root, iter->node, tag, iter_offset(iter));

lib/radix-tree.c

1111

static void set_iter_tags(struct radix_tree_iter *iter,

lib/radix-tree.c

1119

iter->tags = 1;

lib/radix-tree.c

1123

iter->tags = node->tags[tag][tag_long] >> tag_bit;

lib/radix-tree.c

1129

iter->tags |= node->tags[tag][tag_long + 1] <<

lib/radix-tree.c

1132

iter->next_index = __radix_tree_iter_add(iter, BITS_PER_LONG);

lib/radix-tree.c

1137

struct radix_tree_iter *iter)

lib/radix-tree.c

1139

iter->index = __radix_tree_iter_add(iter, 1);

lib/radix-tree.c

1140

iter->next_index = iter->index;

lib/radix-tree.c

1141

iter->tags = 0;

lib/radix-tree.c

1155

struct radix_tree_iter *iter, unsigned flags)

lib/radix-tree.c

1173

index = iter->next_index;

lib/radix-tree.c

1174

if (!index && iter->index)

lib/radix-tree.c

1186

iter->index = index;

lib/radix-tree.c

1187

iter->next_index = maxindex + 1;

lib/radix-tree.c

1188

iter->tags = 1;

lib/radix-tree.c

1189

iter->node = NULL;

lib/radix-tree.c

1230

iter->index = (index &~ node_maxindex(node)) | offset;

lib/radix-tree.c

1231

iter->next_index = (index | node_maxindex(node)) + 1;

lib/radix-tree.c

1232

iter->node = node;

lib/radix-tree.c

1235

set_iter_tags(iter, node, offset, tag);

lib/radix-tree.c

1265

struct radix_tree_iter iter;

lib/radix-tree.c

1272

radix_tree_for_each_slot(slot, root, &iter, first_index) {

lib/radix-tree.c

1277

slot = radix_tree_iter_retry(&iter);

lib/radix-tree.c

1306

struct radix_tree_iter iter;

lib/radix-tree.c

1313

radix_tree_for_each_tagged(slot, root, &iter, first_index, tag) {

lib/radix-tree.c

1318

slot = radix_tree_iter_retry(&iter);

lib/radix-tree.c

1347

struct radix_tree_iter iter;

lib/radix-tree.c

1354

radix_tree_for_each_tagged(slot, root, &iter, first_index, tag) {

lib/radix-tree.c

1395

struct radix_tree_iter *iter, void __rcu **slot)

lib/radix-tree.c

1397

if (__radix_tree_delete(root, iter->node, slot))

lib/radix-tree.c

1398

iter->index = iter->next_index;

lib/radix-tree.c

1477

struct radix_tree_iter *iter, gfp_t gfp,

lib/radix-tree.c

1482

unsigned long maxindex, start = iter->next_index;

lib/radix-tree.c

1537

iter->index = start;

lib/radix-tree.c

1539

iter->next_index = 1 + min(max, (start | node_maxindex(node)));

lib/radix-tree.c

1541

iter->next_index = 1;

lib/radix-tree.c

1542

iter->node = node;

lib/radix-tree.c

1543

set_iter_tags(iter, node, offset, IDR_FREE);

lib/radix-tree.c

203

static unsigned int iter_offset(const struct radix_tree_iter *iter)

lib/radix-tree.c

205

return iter->index & RADIX_TREE_MAP_MASK;

lib/radix-tree.c

932

const struct radix_tree_iter *iter,

lib/radix-tree.c

935

__radix_tree_replace(root, iter->node, slot, item);

lib/rhashtable.c

1008

void *rhashtable_walk_next(struct rhashtable_iter *iter)

lib/rhashtable.c

1010

struct rhlist_head *list = iter->list;

lib/rhashtable.c

1011

struct rhashtable *ht = iter->ht;

lib/rhashtable.c

1012

struct rhash_head *p = iter->p;

lib/rhashtable.c

1021

iter->skip++;

lib/rhashtable.c

1022

iter->p = p;

lib/rhashtable.c

1023

iter->list = list;

lib/rhashtable.c

1030

iter->skip = 0;

lib/rhashtable.c

1031

iter->slot++;

lib/rhashtable.c

1034

return __rhashtable_walk_find_next(iter);

lib/rhashtable.c

1047

void *rhashtable_walk_peek(struct rhashtable_iter *iter)

lib/rhashtable.c

1049

struct rhlist_head *list = iter->list;

lib/rhashtable.c

1050

struct rhashtable *ht = iter->ht;

lib/rhashtable.c

1051

struct rhash_head *p = iter->p;

lib/rhashtable.c

1058

if (iter->skip) {

lib/rhashtable.c

1065

iter->skip--;

lib/rhashtable.c

1068

return __rhashtable_walk_find_next(iter);

lib/rhashtable.c

1079

void rhashtable_walk_stop(struct rhashtable_iter *iter)

lib/rhashtable.c

1082

struct bucket_table *tbl = iter->walker.tbl;

lib/rhashtable.c

1087

ht = iter->ht;

lib/rhashtable.c

1092

iter->walker.tbl = NULL;

lib/rhashtable.c

1094

list_add(&iter->walker.list, &tbl->walkers);

lib/rhashtable.c

813

void rhashtable_walk_enter(struct rhashtable *ht, struct rhashtable_iter *iter)

lib/rhashtable.c

815

iter->ht = ht;

lib/rhashtable.c

816

iter->p = NULL;

lib/rhashtable.c

817

iter->slot = 0;

lib/rhashtable.c

818

iter->skip = 0;

lib/rhashtable.c

819

iter->end_of_table = 0;

lib/rhashtable.c

822

iter->walker.tbl =

lib/rhashtable.c

824

list_add(&iter->walker.list, &iter->walker.tbl->walkers);

lib/rhashtable.c

835

void rhashtable_walk_exit(struct rhashtable_iter *iter)

lib/rhashtable.c

837

spin_lock(&iter->ht->lock);

lib/rhashtable.c

838

if (iter->walker.tbl)

lib/rhashtable.c

839

list_del(&iter->walker.list);

lib/rhashtable.c

840

spin_unlock(&iter->ht->lock);

lib/rhashtable.c

862

int rhashtable_walk_start_check(struct rhashtable_iter *iter)

lib/rhashtable.c

865

struct rhashtable *ht = iter->ht;

lib/rhashtable.c

871

if (iter->walker.tbl)

lib/rhashtable.c

872

list_del(&iter->walker.list);

lib/rhashtable.c

875

if (iter->end_of_table)

lib/rhashtable.c

877

if (!iter->walker.tbl) {

lib/rhashtable.c

878

iter->walker.tbl = rht_dereference_rcu(ht->tbl, ht);

lib/rhashtable.c

879

iter->slot = 0;

lib/rhashtable.c

880

iter->skip = 0;

lib/rhashtable.c

881

iter->p = NULL;

lib/rhashtable.c

885

if (iter->p && !rhlist) {

lib/rhashtable.c

892

rht_for_each_rcu(p, iter->walker.tbl, iter->slot) {

lib/rhashtable.c

894

if (p == iter->p) {

lib/rhashtable.c

895

iter->skip = skip;

lib/rhashtable.c

899

iter->p = NULL;

lib/rhashtable.c

900

} else if (iter->p && rhlist) {

lib/rhashtable.c

907

rht_for_each_rcu(p, iter->walker.tbl, iter->slot) {

lib/rhashtable.c

912

if (list == iter->list) {

lib/rhashtable.c

913

iter->p = p;

lib/rhashtable.c

914

iter->skip = skip;

lib/rhashtable.c

919

iter->p = NULL;

lib/rhashtable.c

936

static void *__rhashtable_walk_find_next(struct rhashtable_iter *iter)

lib/rhashtable.c

938

struct bucket_table *tbl = iter->walker.tbl;

lib/rhashtable.c

939

struct rhlist_head *list = iter->list;

lib/rhashtable.c

940

struct rhashtable *ht = iter->ht;

lib/rhashtable.c

941

struct rhash_head *p = iter->p;

lib/rhashtable.c

947

for (; iter->slot < tbl->size; iter->slot++) {

lib/rhashtable.c

948

int skip = iter->skip;

lib/rhashtable.c

950

rht_for_each_rcu(p, tbl, iter->slot) {

lib/rhashtable.c

970

iter->skip++;

lib/rhashtable.c

971

iter->p = p;

lib/rhashtable.c

972

iter->list = list;

lib/rhashtable.c

976

iter->skip = 0;

lib/rhashtable.c

979

iter->p = NULL;

lib/rhashtable.c

984

iter->walker.tbl = rht_dereference_rcu(tbl->future_tbl, ht);

lib/rhashtable.c

985

if (iter->walker.tbl) {

lib/rhashtable.c

986

iter->slot = 0;

lib/rhashtable.c

987

iter->skip = 0;

lib/rhashtable.c

990

iter->end_of_table = true;

lib/scatterlist.c

1113

static ssize_t extract_user_to_sg(struct iov_iter *iter,

lib/scatterlist.c

1130

res = iov_iter_extract_pages(iter, &pages, maxsize, sg_max,

lib/scatterlist.c

1166

static ssize_t extract_bvec_to_sg(struct iov_iter *iter,

lib/scatterlist.c

1172

const struct bio_vec *bv = iter->bvec;

lib/scatterlist.c

1174

unsigned long start = iter->iov_offset;

lib/scatterlist.c

1178

for (i = 0; i < iter->nr_segs; i++) {

lib/scatterlist.c

1203

iov_iter_advance(iter, ret);

lib/scatterlist.c

1212

static ssize_t extract_kvec_to_sg(struct iov_iter *iter,

lib/scatterlist.c

1218

const struct kvec *kv = iter->kvec;

lib/scatterlist.c

1220

unsigned long start = iter->iov_offset;

lib/scatterlist.c

1224

for (i = 0; i < iter->nr_segs; i++) {

lib/scatterlist.c

1266

iov_iter_advance(iter, ret);

lib/scatterlist.c

1274

static ssize_t extract_folioq_to_sg(struct iov_iter *iter,

lib/scatterlist.c

1280

const struct folio_queue *folioq = iter->folioq;

lib/scatterlist.c

1282

unsigned int slot = iter->folioq_slot;

lib/scatterlist.c

1284

size_t offset = iter->iov_offset;

lib/scatterlist.c

1315

WARN_ON_ONCE(ret < iter->count);

lib/scatterlist.c

1324

iter->folioq = folioq;

lib/scatterlist.c

1325

iter->folioq_slot = slot;

lib/scatterlist.c

1326

iter->iov_offset = offset;

lib/scatterlist.c

1327

iter->count -= ret;

lib/scatterlist.c

1335

static ssize_t extract_xarray_to_sg(struct iov_iter *iter,

lib/scatterlist.c

1342

struct xarray *xa = iter->xarray;

lib/scatterlist.c

1344

loff_t start = iter->xarray_start + iter->iov_offset;

lib/scatterlist.c

1377

iov_iter_advance(iter, ret);

lib/scatterlist.c

1409

ssize_t extract_iter_to_sg(struct iov_iter *iter, size_t maxsize,

lib/scatterlist.c

1416

switch (iov_iter_type(iter)) {

lib/scatterlist.c

1419

return extract_user_to_sg(iter, maxsize, sgtable, sg_max,

lib/scatterlist.c

1422

return extract_bvec_to_sg(iter, maxsize, sgtable, sg_max,

lib/scatterlist.c

1425

return extract_kvec_to_sg(iter, maxsize, sgtable, sg_max,

lib/scatterlist.c

1428

return extract_folioq_to_sg(iter, maxsize, sgtable, sg_max,

lib/scatterlist.c

1431

return extract_xarray_to_sg(iter, maxsize, sgtable, sg_max,

lib/scatterlist.c

1434

pr_err("%s(%u) unsupported\n", __func__, iov_iter_type(iter));

lib/test_lockup.c

352

unsigned int iter = 0;

lib/test_lockup.c

361

while (iter++ < iterations && !signal_pending(main_task)) {

lib/test_meminit.c

221

int iter;

lib/test_meminit.c

229

for (iter = 0; iter < 10; iter++) {

lib/test_meminit.c

295

int i, iter, maxiter = 1024;

lib/test_meminit.c

322

for (iter = 0; iter < maxiter; iter++) {

lib/test_meminit.c

324

used_objects[iter] = buf;

lib/test_meminit.c

327

for (i = 0; i <= iter; i++)

lib/test_meminit.c

333

for (iter = 0; iter < maxiter; iter++)

lib/test_meminit.c

334

kmem_cache_free(c, used_objects[iter]);

lib/test_meminit.c

348

int i, iter, maxiter = 1024;

lib/test_meminit.c

354

for (iter = 0; (iter < maxiter) && !fail; iter++) {

lib/tests/cpumask_kunit.c

20

int cpu, iter = 0; \

lib/tests/cpumask_kunit.c

22

iter++; \

lib/tests/cpumask_kunit.c

23

KUNIT_EXPECT_EQ_MSG((test), mask_weight, iter, MASK_MSG(mask)); \

lib/tests/cpumask_kunit.c

31

int cpu, iter = 0; \

lib/tests/cpumask_kunit.c

35

iter++; \

lib/tests/cpumask_kunit.c

36

KUNIT_EXPECT_EQ((test), weight, iter); \

lib/tests/cpumask_kunit.c

43

int cpu, iter = 0; \

lib/tests/cpumask_kunit.c

45

iter++; \

lib/tests/cpumask_kunit.c

46

KUNIT_EXPECT_EQ_MSG((test), mask_weight, iter, MASK_MSG(mask)); \

lib/tests/cpumask_kunit.c

52

int cpu, iter = 0; \

lib/tests/cpumask_kunit.c

54

iter++; \

lib/tests/cpumask_kunit.c

55

KUNIT_EXPECT_EQ_MSG((test), mask_weight, iter, MASK_MSG(cpu_##name##_mask)); \

lib/tests/kunit_iov_iter.c

1017

} while (iov_iter_count(&iter) > 0);

lib/tests/kunit_iov_iter.c

1020

KUNIT_EXPECT_EQ(test, iter.count, 0);

lib/tests/kunit_iov_iter.c

1021

KUNIT_EXPECT_EQ(test, iter.iov_offset, pr->to - pr->from);

lib/tests/kunit_iov_iter.c

1084

iov_kunit_iter_to_sg_check(struct kunit *test, struct iov_iter *iter,

lib/tests/kunit_iov_iter.c

1093

if (iov_iter_extract_will_pin(iter))

lib/tests/kunit_iov_iter.c

1097

i = extract_iter_to_sg(iter, bufsize, data->sgt, 0, 0);

lib/tests/kunit_iov_iter.c

1101

i = extract_iter_to_sg(iter, bufsize - tail, data->sgt, 1, 0);

lib/tests/kunit_iov_iter.c

1105

i += extract_iter_to_sg(iter, bufsize - tail - i, data->sgt,

lib/tests/kunit_iov_iter.c

1110

i += extract_iter_to_sg(iter, tail, data->sgt,

lib/tests/kunit_iov_iter.c

113

iov_iter_kvec(iter, dir, kvec, i, size);

lib/tests/kunit_iov_iter.c

1134

struct iov_iter iter;

lib/tests/kunit_iov_iter.c

1143

iov_iter_kvec(&iter, READ, &kvec, 1, bufsize);

lib/tests/kunit_iov_iter.c

1145

iov_kunit_iter_to_sg_check(test, &iter, bufsize, &data);

lib/tests/kunit_iov_iter.c

1154

struct iov_iter iter;

lib/tests/kunit_iov_iter.c

1171

iov_iter_bvec(&iter, READ, bvec, k, bufsize);

lib/tests/kunit_iov_iter.c

1173

iov_kunit_iter_to_sg_check(test, &iter, bufsize, &data);

lib/tests/kunit_iov_iter.c

1180

struct iov_iter iter;

lib/tests/kunit_iov_iter.c

1187

iov_kunit_load_folioq(test, &iter, READ, folioq, data.pages,

lib/tests/kunit_iov_iter.c

1190

iov_kunit_iter_to_sg_check(test, &iter, bufsize, &data);

lib/tests/kunit_iov_iter.c

1197

struct iov_iter iter;

lib/tests/kunit_iov_iter.c

1204

iov_kunit_load_xarray(test, &iter, READ, xarray, data.pages,

lib/tests/kunit_iov_iter.c

1207

iov_kunit_iter_to_sg_check(test, &iter, bufsize, &data);

lib/tests/kunit_iov_iter.c

1213

struct iov_iter iter;

lib/tests/kunit_iov_iter.c

1219

iov_iter_ubuf(&iter, READ, data.ubuf, bufsize);

lib/tests/kunit_iov_iter.c

122

struct iov_iter iter;

lib/tests/kunit_iov_iter.c

1221

iov_kunit_iter_to_sg_check(test, &iter, bufsize, &data);

lib/tests/kunit_iov_iter.c

139

iov_kunit_load_kvec(test, &iter, READ, kvec, ARRAY_SIZE(kvec),

lib/tests/kunit_iov_iter.c

141

size = iter.count;

lib/tests/kunit_iov_iter.c

143

copied = copy_to_iter(scratch, size, &iter);

lib/tests/kunit_iov_iter.c

146

KUNIT_EXPECT_EQ(test, iter.count, 0);

lib/tests/kunit_iov_iter.c

147

KUNIT_EXPECT_EQ(test, iter.nr_segs, 0);

lib/tests/kunit_iov_iter.c

172

struct iov_iter iter;

lib/tests/kunit_iov_iter.c

189

iov_kunit_load_kvec(test, &iter, WRITE, kvec, ARRAY_SIZE(kvec),

lib/tests/kunit_iov_iter.c

191

size = min(iter.count, bufsize);

lib/tests/kunit_iov_iter.c

193

copied = copy_from_iter(scratch, size, &iter);

lib/tests/kunit_iov_iter.c

196

KUNIT_EXPECT_EQ(test, iter.count, 0);

lib/tests/kunit_iov_iter.c

197

KUNIT_EXPECT_EQ(test, iter.nr_segs, 0);

lib/tests/kunit_iov_iter.c

238

struct iov_iter *iter, int dir,

lib/tests/kunit_iov_iter.c

272

iov_iter_bvec(iter, dir, bvec, i, size);

lib/tests/kunit_iov_iter.c

281

struct iov_iter iter;

lib/tests/kunit_iov_iter.c

298

iov_kunit_load_bvec(test, &iter, READ, bvec, ARRAY_SIZE(bvec),

lib/tests/kunit_iov_iter.c

300

size = iter.count;

lib/tests/kunit_iov_iter.c

302

copied = copy_to_iter(scratch, size, &iter);

lib/tests/kunit_iov_iter.c

305

KUNIT_EXPECT_EQ(test, iter.count, 0);

lib/tests/kunit_iov_iter.c

306

KUNIT_EXPECT_EQ(test, iter.nr_segs, 0);

lib/tests/kunit_iov_iter.c

334

struct iov_iter iter;

lib/tests/kunit_iov_iter.c

351

iov_kunit_load_bvec(test, &iter, WRITE, bvec, ARRAY_SIZE(bvec),

lib/tests/kunit_iov_iter.c

353

size = iter.count;

lib/tests/kunit_iov_iter.c

355

copied = copy_from_iter(scratch, size, &iter);

lib/tests/kunit_iov_iter.c

358

KUNIT_EXPECT_EQ(test, iter.count, 0);

lib/tests/kunit_iov_iter.c

359

KUNIT_EXPECT_EQ(test, iter.nr_segs, 0);

lib/tests/kunit_iov_iter.c

396

struct iov_iter *iter, int dir,

lib/tests/kunit_iov_iter.c

415

iov_iter_folio_queue(iter, dir, folioq, 0, 0, size);

lib/tests/kunit_iov_iter.c

435

struct iov_iter iter;

lib/tests/kunit_iov_iter.c

454

iov_kunit_load_folioq(test, &iter, READ, folioq, bpages, npages);

lib/tests/kunit_iov_iter.c

461

iov_iter_folio_queue(&iter, READ, folioq, 0, 0, pr->to);

lib/tests/kunit_iov_iter.c

462

iov_iter_advance(&iter, pr->from);

lib/tests/kunit_iov_iter.c

463

copied = copy_to_iter(scratch + i, size, &iter);

lib/tests/kunit_iov_iter.c

466

KUNIT_EXPECT_EQ(test, iter.count, 0);

lib/tests/kunit_iov_iter.c

467

KUNIT_EXPECT_EQ(test, iter.iov_offset, pr->to % PAGE_SIZE);

lib/tests/kunit_iov_iter.c

497

struct iov_iter iter;

lib/tests/kunit_iov_iter.c

516

iov_kunit_load_folioq(test, &iter, READ, folioq, bpages, npages);

lib/tests/kunit_iov_iter.c

523

iov_iter_folio_queue(&iter, WRITE, folioq, 0, 0, pr->to);

lib/tests/kunit_iov_iter.c

524

iov_iter_advance(&iter, pr->from);

lib/tests/kunit_iov_iter.c

525

copied = copy_from_iter(scratch + i, size, &iter);

lib/tests/kunit_iov_iter.c

528

KUNIT_EXPECT_EQ(test, iter.count, 0);

lib/tests/kunit_iov_iter.c

529

KUNIT_EXPECT_EQ(test, iter.iov_offset, pr->to % PAGE_SIZE);

lib/tests/kunit_iov_iter.c

564

struct iov_iter *iter, int dir,

lib/tests/kunit_iov_iter.c

577

iov_iter_xarray(iter, dir, xarray, 0, size);

lib/tests/kunit_iov_iter.c

597

struct iov_iter iter;

lib/tests/kunit_iov_iter.c

616

iov_kunit_load_xarray(test, &iter, READ, xarray, bpages, npages);

lib/tests/kunit_iov_iter.c

623

iov_iter_xarray(&iter, READ, xarray, pr->from, size);

lib/tests/kunit_iov_iter.c

624

copied = copy_to_iter(scratch + i, size, &iter);

lib/tests/kunit_iov_iter.c

627

KUNIT_EXPECT_EQ(test, iter.count, 0);

lib/tests/kunit_iov_iter.c

628

KUNIT_EXPECT_EQ(test, iter.iov_offset, size);

lib/tests/kunit_iov_iter.c

655

struct iov_iter iter;

lib/tests/kunit_iov_iter.c

674

iov_kunit_load_xarray(test, &iter, READ, xarray, bpages, npages);

lib/tests/kunit_iov_iter.c

681

iov_iter_xarray(&iter, WRITE, xarray, pr->from, size);

lib/tests/kunit_iov_iter.c

682

copied = copy_from_iter(scratch + i, size, &iter);

lib/tests/kunit_iov_iter.c

685

KUNIT_EXPECT_EQ(test, iter.count, 0);

lib/tests/kunit_iov_iter.c

686

KUNIT_EXPECT_EQ(test, iter.iov_offset, size);

lib/tests/kunit_iov_iter.c

718

struct iov_iter iter;

lib/tests/kunit_iov_iter.c

731

iov_kunit_load_kvec(test, &iter, READ, kvec, ARRAY_SIZE(kvec),

lib/tests/kunit_iov_iter.c

733

size = iter.count;

lib/tests/kunit_iov_iter.c

743

len = iov_iter_extract_pages(&iter, &pages, 100 * 1024,

lib/tests/kunit_iov_iter.c

751

KUNIT_EXPECT_EQ(test, iter.count, size - len);

lib/tests/kunit_iov_iter.c

784

} while (iov_iter_count(&iter) > 0);

lib/tests/kunit_iov_iter.c

788

KUNIT_EXPECT_EQ(test, iter.count, 0);

lib/tests/kunit_iov_iter.c

798

struct iov_iter iter;

lib/tests/kunit_iov_iter.c

809

iov_kunit_load_bvec(test, &iter, READ, bvec, ARRAY_SIZE(bvec),

lib/tests/kunit_iov_iter.c

811

size = iter.count;

lib/tests/kunit_iov_iter.c

821

len = iov_iter_extract_pages(&iter, &pages, 100 * 1024,

lib/tests/kunit_iov_iter.c

829

KUNIT_EXPECT_EQ(test, iter.count, size - len);

lib/tests/kunit_iov_iter.c

862

} while (iov_iter_count(&iter) > 0);

lib/tests/kunit_iov_iter.c

866

KUNIT_EXPECT_EQ(test, iter.count, 0);

lib/tests/kunit_iov_iter.c

877

struct iov_iter iter;

lib/tests/kunit_iov_iter.c

889

iov_kunit_load_folioq(test, &iter, READ, folioq, bpages, npages);

lib/tests/kunit_iov_iter.c

896

iov_iter_folio_queue(&iter, WRITE, folioq, 0, 0, pr->to);

lib/tests/kunit_iov_iter.c

897

iov_iter_advance(&iter, from);

lib/tests/kunit_iov_iter.c

905

len = iov_iter_extract_pages(&iter, &pages, 100 * 1024,

lib/tests/kunit_iov_iter.c

911

KUNIT_EXPECT_EQ(test, iter.count, size - len);

lib/tests/kunit_iov_iter.c

939

} while (iov_iter_count(&iter) > 0);

lib/tests/kunit_iov_iter.c

94

struct iov_iter *iter, int dir,

lib/tests/kunit_iov_iter.c

942

KUNIT_EXPECT_EQ(test, iter.count, 0);

lib/tests/kunit_iov_iter.c

955

struct iov_iter iter;

lib/tests/kunit_iov_iter.c

968

iov_kunit_load_xarray(test, &iter, READ, xarray, bpages, npages);

lib/tests/kunit_iov_iter.c

975

iov_iter_xarray(&iter, WRITE, xarray, from, size);

lib/tests/kunit_iov_iter.c

983

len = iov_iter_extract_pages(&iter, &pages, 100 * 1024,

lib/tests/kunit_iov_iter.c

989

KUNIT_EXPECT_EQ(test, iter.count, size - len);

mm/backing-dev.c

854

struct radix_tree_iter iter;

mm/backing-dev.c

861

radix_tree_for_each_slot(slot, &bdi->cgwb_tree, &iter, 0)

mm/filemap.c

2777

ssize_t filemap_read(struct kiocb *iocb, struct iov_iter *iter,

mm/filemap.c

2794

if (unlikely(!iov_iter_count(iter)))

mm/filemap.c

2797

iov_iter_truncate(iter, inode->i_sb->s_maxbytes - iocb->ki_pos);

mm/filemap.c

2814

error = filemap_get_pages(iocb, iter->count, &fbatch, false);

mm/filemap.c

2829

end_offset = min_t(loff_t, isize, iocb->ki_pos + iter->count);

mm/filemap.c

2865

copied = copy_folio_to_iter(folio, offset, bytes, iter);

mm/filemap.c

2884

} while (iov_iter_count(iter) && iocb->ki_pos < isize && !error);

mm/filemap.c

2965

generic_file_read_iter(struct kiocb *iocb, struct iov_iter *iter)

mm/filemap.c

2967

size_t count = iov_iter_count(iter);

mm/filemap.c

2983

retval = mapping->a_ops->direct_IO(iocb, iter);

mm/filemap.c

2989

iov_iter_revert(iter, count - iov_iter_count(iter));

mm/filemap.c

3006

return filemap_read(iocb, iter, retval);

mm/hugetlb.c

601

struct file_region *iter, *trg = NULL;

mm/hugetlb.c

611

list_for_each_entry_safe(iter, trg, head, link) {

mm/hugetlb.c

613

if (iter->from < f) {

mm/hugetlb.c

617

if (iter->to > last_accounted_offset)

mm/hugetlb.c

618

last_accounted_offset = iter->to;

mm/hugetlb.c

625

if (iter->from >= t) {

mm/hugetlb.c

626

rg = iter->link.prev;

mm/hugetlb.c

633

if (iter->from > last_accounted_offset)

mm/hugetlb.c

634

add += hugetlb_resv_map_add(resv, iter->link.prev,

mm/hugetlb.c

636

iter->from, h, h_cg,

mm/hugetlb.c

639

last_accounted_offset = iter->to;

mm/kfence/kfence_test.c

551

int iter;

mm/kfence/kfence_test.c

553

for (iter = 0; iter < 5; iter++) {

mm/kfence/kfence_test.c

555

0, (iter & 1) ? ctor_set_x : NULL);

mm/kmsan/core.c

111

iter = backwards ? n - 1 : 0;

mm/kmsan/core.c

116

for (i = 0; i < n; i++, iter += step) {

mm/kmsan/core.c

117

oiter_src = (iter + src_off) / KMSAN_ORIGIN_SIZE;

mm/kmsan/core.c

118

oiter_dst = (iter + dst_off) / KMSAN_ORIGIN_SIZE;

mm/kmsan/core.c

119

if (!shadow_src[iter]) {

mm/kmsan/core.c

120

shadow_dst[iter] = 0;

mm/kmsan/core.c

125

shadow_dst[iter] = shadow_src[iter];

mm/kmsan/core.c

83

int i, iter, step, src_off, dst_off, oiter_src, oiter_dst;

mm/madvise.c

2018

static ssize_t vector_madvise(struct mm_struct *mm, struct iov_iter *iter,

mm/madvise.c

2030

total_len = iov_iter_count(iter);

mm/madvise.c

2037

while (iov_iter_count(iter)) {

mm/madvise.c

2038

unsigned long start = (unsigned long)iter_iov_addr(iter);

mm/madvise.c

2039

size_t len_in = iter_iov_len(iter);

mm/madvise.c

2074

iov_iter_advance(iter, iter_iov_len(iter));

mm/madvise.c

2080

ret = (total_len - iov_iter_count(iter)) ? : ret;

mm/madvise.c

2091

struct iov_iter iter;

mm/madvise.c

2101

ret = import_iovec(ITER_DEST, vec, vlen, ARRAY_SIZE(iovstack), &iov, &iter);

mm/madvise.c

2142

ret = vector_madvise(mm, &iter, behavior);

mm/memcontrol-v1.c

1266

struct mem_cgroup *iter, *failed = NULL;

mm/memcontrol-v1.c

1270

for_each_mem_cgroup_tree(iter, memcg) {

mm/memcontrol-v1.c

1271

if (iter->oom_lock) {

mm/memcontrol-v1.c

1276

failed = iter;

mm/memcontrol-v1.c

1277

mem_cgroup_iter_break(memcg, iter);

mm/memcontrol-v1.c

1280

iter->oom_lock = true;

mm/memcontrol-v1.c

1288

for_each_mem_cgroup_tree(iter, memcg) {

mm/memcontrol-v1.c

1289

if (iter == failed) {

mm/memcontrol-v1.c

1290

mem_cgroup_iter_break(memcg, iter);

mm/memcontrol-v1.c

1293

iter->oom_lock = false;

mm/memcontrol-v1.c

1305

struct mem_cgroup *iter;

mm/memcontrol-v1.c

1309

for_each_mem_cgroup_tree(iter, memcg)

mm/memcontrol-v1.c

1310

iter->oom_lock = false;

mm/memcontrol-v1.c

1316

struct mem_cgroup *iter;

mm/memcontrol-v1.c

1319

for_each_mem_cgroup_tree(iter, memcg)

mm/memcontrol-v1.c

1320

iter->under_oom++;

mm/memcontrol-v1.c

1326

struct mem_cgroup *iter;

mm/memcontrol-v1.c

1333

for_each_mem_cgroup_tree(iter, memcg)

mm/memcontrol-v1.c

1334

if (iter->under_oom > 0)

mm/memcontrol-v1.c

1335

iter->under_oom--;

mm/memcontrol-v1.c

769

struct mem_cgroup *iter;

mm/memcontrol-v1.c

771

for_each_mem_cgroup_tree(iter, memcg)

mm/memcontrol-v1.c

772

mem_cgroup_oom_notify_cb(iter);

mm/memcontrol-v1.h

15

#define for_each_mem_cgroup_tree(iter, root) \

mm/memcontrol-v1.h

16

for (iter = mem_cgroup_iter(root, NULL, NULL); \

mm/memcontrol-v1.h

17

iter != NULL; \

mm/memcontrol-v1.h

18

iter = mem_cgroup_iter(root, iter, NULL))

mm/memcontrol-v1.h

20

#define for_each_mem_cgroup(iter) \

mm/memcontrol-v1.h

21

for (iter = mem_cgroup_iter(NULL, NULL, NULL); \

mm/memcontrol-v1.h

22

iter != NULL; \

mm/memcontrol-v1.h

23

iter = mem_cgroup_iter(NULL, iter, NULL))

mm/memcontrol.c

1217

struct mem_cgroup_reclaim_iter *iter;

mm/memcontrol.c

1236

iter = &root->nodeinfo[nid]->iter;

mm/memcontrol.c

1237

gen = atomic_read(&iter->generation);

mm/memcontrol.c

1248

pos = READ_ONCE(iter->position);

mm/memcontrol.c

1272

if (cmpxchg(&iter->position, pos, next) != pos) {

mm/memcontrol.c

1279

atomic_inc(&iter->generation);

mm/memcontrol.c

1317

struct mem_cgroup_reclaim_iter *iter;

mm/memcontrol.c

1323

iter = &mz->iter;

mm/memcontrol.c

1324

cmpxchg(&iter->position, dead_memcg, NULL);

mm/memcontrol.c

1365

struct mem_cgroup *iter;

mm/memcontrol.c

1370

for_each_mem_cgroup_tree(iter, memcg) {

mm/memcontrol.c

1374

css_task_iter_start(&iter->css, CSS_TASK_ITER_PROCS, &it);

mm/memcontrol.c

1382

mem_cgroup_iter_break(memcg, iter);

mm/memcontrol.c

213

struct obj_cgroup *objcg, *iter;

mm/memcontrol.c

221

list_for_each_entry(iter, &pn->objcg_list, list)

mm/memcontrol.c

222

WRITE_ONCE(iter->memcg, parent);

mm/nommu.c

178

long vread_iter(struct iov_iter *iter, const char *addr, size_t count)

mm/nommu.c

184

return copy_to_iter(addr, count, iter);

mm/page_owner.c

251

struct page_ext_iter iter;

mm/page_owner.c

256

for_each_page_ext(page, 1 << order, page_ext, iter) {

mm/page_owner.c

279

struct page_ext_iter iter;

mm/page_owner.c

284

for_each_page_ext(page, 1 << order, page_ext, iter) {

mm/page_owner.c

363

struct page_ext_iter iter;

mm/page_owner.c

368

for_each_page_ext(page, 1 << old_order, page_ext, iter) {

mm/page_owner.c

378

struct page_ext_iter iter;

mm/page_owner.c

418

for_each_page_ext(&old->page, 1 << new_page_owner->order, page_ext, iter) {

mm/page_table_check.c

100

struct page_ext_iter iter;

mm/page_table_check.c

113

for_each_page_ext(page, pgcnt, page_ext, iter) {

mm/page_table_check.c

133

struct page_ext_iter iter;

mm/page_table_check.c

139

for_each_page_ext(page, 1 << order, page_ext, iter) {

mm/page_table_check.c

65

struct page_ext_iter iter;

mm/page_table_check.c

78

for_each_page_ext(page, pgcnt, page_ext, iter) {

mm/process_vm_access.c

119

start_offset, bytes, iter,

mm/process_vm_access.c

151

static ssize_t process_vm_rw_core(pid_t pid, struct iov_iter *iter,

mm/process_vm_access.c

165

size_t total_len = iov_iter_count(iter);

mm/process_vm_access.c

215

for (i = 0; i < riovcnt && iov_iter_count(iter) && !rc; i++)

mm/process_vm_access.c

218

iter, process_pages, mm, task, vm_write);

mm/process_vm_access.c

221

total_len -= iov_iter_count(iter);

mm/process_vm_access.c

265

struct iov_iter iter;

mm/process_vm_access.c

273

rc = import_iovec(dir, lvec, liovcnt, UIO_FASTIOV, &iov_l, &iter);

mm/process_vm_access.c

276

if (!iov_iter_count(&iter))

mm/process_vm_access.c

284

rc = process_vm_rw_core(pid, &iter, iov_r, riovcnt, flags, vm_write);

mm/process_vm_access.c

30

struct iov_iter *iter,

mm/process_vm_access.c

34

while (len && iov_iter_count(iter)) {

mm/process_vm_access.c

43

copied = copy_page_from_iter(page, offset, copy, iter);

mm/process_vm_access.c

45

copied = copy_page_to_iter(page, offset, copy, iter);

mm/process_vm_access.c

48

if (copied < copy && iov_iter_count(iter))

mm/process_vm_access.c

75

struct iov_iter *iter,

mm/process_vm_access.c

95

while (!rc && nr_pages && iov_iter_count(iter)) {

mm/shmem.c

897

swp_entry_t iter, swap;

mm/shmem.c

913

iter = swap;

mm/shmem.c

922

if (!expected || entry != swp_to_radix_entry(iter)) {

mm/shmem.c

926

iter.val += 1 << xas_get_order(&xas);

mm/shmem.c

928

if (expected && iter.val - nr != swap.val) {

mm/slub.c

1959

const char *iter;

mm/slub.c

1980

next_block = parse_slub_debug_flags(next_block, &block_flags, &iter, false);

mm/slub.c

1981

if (!iter)

mm/slub.c

1984

while (*iter) {

mm/slub.c

1988

end = strchrnul(iter, ',');

mm/slub.c

1992

glob = strnchr(iter, end - iter, '*');

mm/slub.c

1994

cmplen = glob - iter;

mm/slub.c

1996

cmplen = max_t(size_t, len, (end - iter));

mm/slub.c

1998

if (!strncmp(name, iter, cmplen)) {

mm/slub.c

2005

iter = end + 1;

mm/slub.c

3582

struct slab_obj_iter *iter)

mm/slub.c

3585

if (iter->random) {

mm/slub.c

3593

idx = s->random_seq[iter->pos];

mm/slub.c

3594

iter->pos++;

mm/slub.c

3595

if (iter->pos >= iter->freelist_count)

mm/slub.c

3596

iter->pos = 0;

mm/slub.c

3597

} while (unlikely(idx >= iter->page_limit));

mm/slub.c

3599

return setup_object(s, (char *)iter->start + idx);

mm/slub.c

3602

return setup_object(s, (char *)iter->start + iter->pos++ * s->size);

mm/slub.c

3607

struct slab_obj_iter *iter)

mm/slub.c

3618

cur = next_slab_obj(s, iter);

mm/slub.c

3622

next = next_slab_obj(s, iter);

mm/slub.c

3632

struct slab_obj_iter *iter,

mm/slub.c

3635

iter->pos = 0;

mm/slub.c

3636

iter->start = fixup_red_left(s, slab_address(slab));

mm/slub.c

3639

iter->random = (slab->objects >= 2 && s->random_seq);

mm/slub.c

3640

if (!iter->random)

mm/slub.c

3643

iter->freelist_count = oo_objects(s->oo);

mm/slub.c

3644

iter->page_limit = slab->objects * s->size;

mm/slub.c

3647

iter->pos = get_random_u32_below(iter->freelist_count);

mm/slub.c

3656

iter->pos = prandom_u32_state(state) % iter->freelist_count;

mm/slub.c

3672

struct slab_obj_iter iter;

mm/slub.c

3677

init_slab_obj_iter(s, slab, &iter, allow_spin);

mm/slub.c

3678

object = next_slab_obj(s, &iter);

mm/slub.c

3682

build_slab_freelist(s, slab, &iter);

mm/slub.c

4377

struct slab_obj_iter iter;

mm/slub.c

4390

init_slab_obj_iter(s, slab, &iter, allow_spin);

mm/slub.c

4393

p[allocated] = next_slab_obj(s, &iter);

mm/slub.c

4397

build_slab_freelist(s, slab, &iter);

mm/slub.c

7657

struct slab_obj_iter iter;

mm/slub.c

7669

init_slab_obj_iter(kmem_cache_node, slab, &iter, true);

mm/slub.c

7671

n = next_slab_obj(kmem_cache_node, &iter);

mm/slub.c

7675

build_slab_freelist(kmem_cache_node, slab, &iter);

mm/vmalloc.c

4496

static size_t zero_iter(struct iov_iter *iter, size_t count)

mm/vmalloc.c

4504

copied = copy_page_to_iter_nofault(ZERO_PAGE(0), 0, num, iter);

mm/vmalloc.c

4520

static size_t aligned_vread_iter(struct iov_iter *iter,

mm/vmalloc.c

4545

length, iter);

mm/vmalloc.c

4547

copied = zero_iter(iter, length);

mm/vmalloc.c

4564

static size_t vmap_ram_vread_iter(struct iov_iter *iter, const char *addr,

mm/vmalloc.c

4580

return aligned_vread_iter(iter, addr, count);

mm/vmalloc.c

4609

size_t zeroed = zero_iter(iter, to_zero);

mm/vmalloc.c

4624

copied = aligned_vread_iter(iter, start + offset, n);

mm/vmalloc.c

4637

return count - remains + zero_iter(iter, remains);

mm/vmalloc.c

4668

long vread_iter(struct iov_iter *iter, const char *addr, size_t count)

mm/vmalloc.c

4735

size_t zeroed = zero_iter(iter, to_zero);

mm/vmalloc.c

4749

copied = vmap_ram_vread_iter(iter, addr, n, flags);

mm/vmalloc.c

4751

copied = aligned_vread_iter(iter, addr, n);

mm/vmalloc.c

4753

copied = zero_iter(iter, n);

mm/vmalloc.c

4771

return count - remains + zero_iter(iter, remains);

mm/vmscan.c

3011

static bool iterate_mm_list(struct lru_gen_mm_walk *walk, struct mm_struct **iter)

mm/vmscan.c

3059

if (*iter || last)

mm/vmscan.c

3067

if (*iter)

mm/vmscan.c

3068

mmdrop(*iter);

mm/vmscan.c

3070

*iter = mm;

net/batman-adv/bat_iv_ogm.c

1661

struct list_head *iter;

net/batman-adv/bat_iv_ogm.c

1699

netdev_for_each_lower_private_rcu(if_incoming->mesh_iface, hard_iface, iter) {

net/batman-adv/bat_iv_ogm.c

1761

netdev_for_each_lower_private_rcu(bat_priv->mesh_iface, hard_iface, iter) {

net/batman-adv/bat_iv_ogm.c

2232

struct list_head *iter;

net/batman-adv/bat_iv_ogm.c

2249

netdev_for_each_lower_private_rcu(bat_priv->mesh_iface, hard_iface, iter) {

net/batman-adv/bat_iv_ogm.c

815

struct list_head *iter;

net/batman-adv/bat_iv_ogm.c

882

netdev_for_each_lower_private_rcu(hard_iface->mesh_iface, tmp_hard_iface, iter) {

net/batman-adv/bat_v.c

215

struct list_head *iter;

net/batman-adv/bat_v.c

231

netdev_for_each_lower_private_rcu(bat_priv->mesh_iface, hard_iface, iter) {

net/batman-adv/bat_v_elp.c

485

struct list_head *iter;

net/batman-adv/bat_v_elp.c

489

netdev_for_each_lower_private_rcu(primary_iface->mesh_iface, hard_iface, iter)

net/batman-adv/bat_v_ogm.c

282

struct list_head *iter;

net/batman-adv/bat_v_ogm.c

317

netdev_for_each_lower_private_rcu(bat_priv->mesh_iface, hard_iface, iter) {

net/batman-adv/bat_v_ogm.c

890

struct list_head *iter;

net/batman-adv/bat_v_ogm.c

953

netdev_for_each_lower_private_rcu(bat_priv->mesh_iface, hard_iface, iter) {

net/batman-adv/hard-interface.c

473

struct list_head *iter;

net/batman-adv/hard-interface.c

476

netdev_for_each_lower_private_rcu(mesh_iface, hard_iface, iter) {

net/batman-adv/hard-interface.c

540

struct list_head *iter;

net/batman-adv/hard-interface.c

545

netdev_for_each_lower_private(mesh_iface, tmp_hard_iface, iter) {

net/batman-adv/hard-interface.c

573

struct list_head *iter;

net/batman-adv/hard-interface.c

576

netdev_for_each_lower_private_rcu(mesh_iface, hard_iface, iter) {

net/batman-adv/hard-interface.c

612

struct list_head *iter;

net/batman-adv/hard-interface.c

616

netdev_for_each_lower_private_rcu(mesh_iface, hard_iface, iter) {

net/batman-adv/main.c

316

struct list_head *iter;

net/batman-adv/main.c

320

netdev_for_each_lower_private_rcu(bat_priv->mesh_iface, hard_iface, iter) {

net/batman-adv/multicast.c

249

struct list_head *iter;

net/batman-adv/multicast.c

252

netdev_for_each_lower_private_rcu(bat_priv->mesh_iface, hard_iface, iter) {

net/batman-adv/netlink.c

961

struct list_head *iter;

net/batman-adv/netlink.c

973

netdev_for_each_lower_private(mesh_iface, hard_iface, iter) {

net/batman-adv/originator.c

1211

struct list_head *iter;

net/batman-adv/originator.c

1236

netdev_for_each_lower_private_rcu(bat_priv->mesh_iface, hard_iface, iter) {

net/batman-adv/send.c

912

struct list_head *iter;

net/batman-adv/send.c

920

netdev_for_each_lower_private_rcu(bat_priv->mesh_iface, hard_iface, iter) {

net/bridge/br_switchdev.c

593

struct list_head *iter;

net/bridge/br_switchdev.c

595

netdev_for_each_lower_dev(dev, lower_dev, iter)

net/bridge/netfilter/nf_conntrack_bridge.c

59

struct ip_fraglist_iter iter;

net/bridge/netfilter/nf_conntrack_bridge.c

78

ip_fraglist_init(skb, iph, hlen, &iter);

net/bridge/netfilter/nf_conntrack_bridge.c

81

if (iter.frag)

net/bridge/netfilter/nf_conntrack_bridge.c

82

ip_fraglist_prepare(skb, &iter);

net/bridge/netfilter/nf_conntrack_bridge.c

86

if (err || !iter.frag)

net/bridge/netfilter/nf_conntrack_bridge.c

89

skb = ip_fraglist_next(&iter);

net/bridge/netfilter/nf_conntrack_bridge.c

95

kfree_skb_list(iter.frag);

net/ceph/messenger.c

1946

msg->data_length += bvec_pos->iter.bi_size;

net/ceph/messenger.c

1951

struct iov_iter *iter)

net/ceph/messenger.c

1957

data->iter = *iter;

net/ceph/messenger.c

1959

msg->data_length += iov_iter_count(&data->iter);

net/ceph/messenger.c

733

if (cursor->resid < it->iter.bi_size)

net/ceph/messenger.c

734

it->iter.bi_size = cursor->resid;

net/ceph/messenger.c

736

BUG_ON(cursor->resid < bio_iter_len(it->bio, it->iter));

net/ceph/messenger.c

744

cursor->bio_iter.iter);

net/ceph/messenger.c

755

struct page *page = bio_iter_page(it->bio, it->iter);

net/ceph/messenger.c

758

BUG_ON(bytes > bio_iter_len(it->bio, it->iter));

net/ceph/messenger.c

760

bio_advance_iter(it->bio, &it->iter, bytes);

net/ceph/messenger.c

765

if (!bytes || (it->iter.bi_size && it->iter.bi_bvec_done &&

net/ceph/messenger.c

766

page == bio_iter_page(it->bio, it->iter)))

net/ceph/messenger.c

769

if (!it->iter.bi_size) {

net/ceph/messenger.c

771

it->iter = it->bio->bi_iter;

net/ceph/messenger.c

772

if (cursor->resid < it->iter.bi_size)

net/ceph/messenger.c

773

it->iter.bi_size = cursor->resid;

net/ceph/messenger.c

776

BUG_ON(cursor->resid < bio_iter_len(it->bio, it->iter));

net/ceph/messenger.c

787

cursor->resid = min_t(size_t, length, data->bvec_pos.iter.bi_size);

net/ceph/messenger.c

788

cursor->bvec_iter = data->bvec_pos.iter;

net/ceph/messenger.c

978

cursor->iov_iter = data->iter;

net/ceph/osd_client.c

175

struct iov_iter *iter)

net/ceph/osd_client.c

178

osd_data->iter = *iter;

net/ceph/osd_client.c

245

.iter = { .bi_size = bytes },

net/ceph/osd_client.c

271

unsigned int which, struct iov_iter *iter)

net/ceph/osd_client.c

276

ceph_osd_iter_init(osd_data, iter);

net/ceph/osd_client.c

312

.iter = { .bi_size = bytes },

net/ceph/osd_client.c

348

return osd_data->bvec_pos.iter.bi_size;

net/ceph/osd_client.c

350

return iov_iter_count(&osd_data->iter);

net/ceph/osd_client.c

960

ceph_msg_data_add_iter(msg, &osd_data->iter);

net/core/dev.c

10104

struct list_head *iter;

net/core/dev.c

10117

netdev_for_each_lower_dev(dev, lower_dev, iter) {

net/core/dev.c

10408

struct list_head *iter;

net/core/dev.c

10448

netdev_for_each_upper_dev_rcu(dev, upper, iter) {

net/core/dev.c

11006

struct list_head *iter;

net/core/dev.c

11021

netdev_for_each_upper_dev_rcu(dev, upper, iter)

net/core/dev.c

11049

netdev_for_each_lower_dev(dev, lower, iter)

net/core/dev.c

12830

struct list_head *iter;

net/core/dev.c

12836

netdev_for_each_lower_dev(dev, lower_dev, iter) {

net/core/dev.c

1828

struct list_head *iter;

net/core/dev.c

1836

netdev_for_each_lower_dev(dev, lower_dev, iter) {

net/core/dev.c

8157

struct list_head **iter)

net/core/dev.c

8164

upper = list_entry_rcu((*iter)->next, struct netdev_adjacent, list);

net/core/dev.c

8169

*iter = &upper->list;

net/core/dev.c

8176

struct list_head **iter,

net/core/dev.c

8181

upper = list_entry((*iter)->next, struct netdev_adjacent, list);

net/core/dev.c

8186

*iter = &upper->list;

net/core/dev.c

8193

struct list_head **iter)

net/core/dev.c

8199

upper = list_entry_rcu((*iter)->next, struct netdev_adjacent, list);

net/core/dev.c

8204

*iter = &upper->list;

net/core/dev.c

8215

struct list_head *niter, *iter, *iter_stack[MAX_NEST_DEV + 1];

net/core/dev.c

8220

iter = &dev->adj_list.upper;

net/core/dev.c

8231

udev = __netdev_next_upper_dev(now, &iter, &ignore);

net/core/dev.c

8240

iter_stack[cur++] = iter;

net/core/dev.c

8252

iter = niter;

net/core/dev.c

8264

struct list_head *niter, *iter, *iter_stack[MAX_NEST_DEV + 1];

net/core/dev.c

8268

iter = &dev->adj_list.upper;

net/core/dev.c

8279

udev = netdev_next_upper_dev_rcu(now, &iter);

net/core/dev.c

8286

iter_stack[cur++] = iter;

net/core/dev.c

8298

iter = niter;

net/core/dev.c

8331

struct list_head **iter)

net/core/dev.c

8335

lower = list_entry(*iter, struct netdev_adjacent, list);

net/core/dev.c

8340

*iter = lower->list.next;

net/core/dev.c

8357

struct list_head **iter)

net/core/dev.c

8363

lower = list_entry_rcu((*iter)->next, struct netdev_adjacent, list);

net/core/dev.c

8368

*iter = &lower->list;

net/core/dev.c

8385

void *netdev_lower_get_next(struct net_device *dev, struct list_head **iter)

net/core/dev.c

8389

lower = list_entry(*iter, struct netdev_adjacent, list);

net/core/dev.c

8394

*iter = lower->list.next;

net/core/dev.c

8401

struct list_head **iter)

net/core/dev.c

8405

lower = list_entry((*iter)->next, struct netdev_adjacent, list);

net/core/dev.c

8410

*iter = &lower->list;

net/core/dev.c

8416

struct list_head **iter,

net/core/dev.c

8421

lower = list_entry((*iter)->next, struct netdev_adjacent, list);

net/core/dev.c

8426

*iter = &lower->list;

net/core/dev.c

8438

struct list_head *niter, *iter, *iter_stack[MAX_NEST_DEV + 1];

net/core/dev.c

8442

iter = &dev->adj_list.lower;

net/core/dev.c

8453

ldev = netdev_next_lower_dev(now, &iter);

net/core/dev.c

8460

iter_stack[cur++] = iter;

net/core/dev.c

8472

iter = niter;

net/core/dev.c

8485

struct list_head *niter, *iter, *iter_stack[MAX_NEST_DEV + 1];

net/core/dev.c

8490

iter = &dev->adj_list.lower;

net/core/dev.c

8501

ldev = __netdev_next_lower_dev(now, &iter, &ignore);

net/core/dev.c

8510

iter_stack[cur++] = iter;

net/core/dev.c

8522

iter = niter;

net/core/dev.c

8529

struct list_head **iter)

net/core/dev.c

8533

lower = list_entry_rcu((*iter)->next, struct netdev_adjacent, list);

net/core/dev.c

8537

*iter = &lower->list;

net/core/dev.c

8546

struct list_head *iter;

net/core/dev.c

8550

for (iter = &dev->adj_list.upper,

net/core/dev.c

8551

udev = __netdev_next_upper_dev(dev, &iter, &ignore);

net/core/dev.c

8553

udev = __netdev_next_upper_dev(dev, &iter, &ignore)) {

net/core/dev.c

8566

struct list_head *iter;

net/core/dev.c

8570

for (iter = &dev->adj_list.lower,

net/core/dev.c

8571

ldev = __netdev_next_lower_dev(dev, &iter, &ignore);

net/core/dev.c

8573

ldev = __netdev_next_lower_dev(dev, &iter, &ignore)) {

net/core/dev.c

8623

struct list_head *niter, *iter, *iter_stack[MAX_NEST_DEV + 1];

net/core/dev.c

8627

iter = &dev->adj_list.lower;

net/core/dev.c

8638

ldev = netdev_next_lower_dev_rcu(now, &iter);

net/core/dev.c

8645

iter_stack[cur++] = iter;

net/core/dev.c

8657

iter = niter;

net/core/dev.c

9475

struct netdev_adjacent *iter;

net/core/dev.c

9479

list_for_each_entry(iter, &dev->adj_list.upper, list) {

net/core/dev.c

9480

if (!net_eq(net, dev_net(iter->dev)))

net/core/dev.c

9482

netdev_adjacent_sysfs_add(iter->dev, dev,

net/core/dev.c

9483

&iter->dev->adj_list.lower);

net/core/dev.c

9484

netdev_adjacent_sysfs_add(dev, iter->dev,

net/core/dev.c

9488

list_for_each_entry(iter, &dev->adj_list.lower, list) {

net/core/dev.c

9489

if (!net_eq(net, dev_net(iter->dev)))

net/core/dev.c

9491

netdev_adjacent_sysfs_add(iter->dev, dev,

net/core/dev.c

9492

&iter->dev->adj_list.upper);

net/core/dev.c

9493

netdev_adjacent_sysfs_add(dev, iter->dev,

net/core/dev.c

9500

struct netdev_adjacent *iter;

net/core/dev.c

9504

list_for_each_entry(iter, &dev->adj_list.upper, list) {

net/core/dev.c

9505

if (!net_eq(net, dev_net(iter->dev)))

net/core/dev.c

9507

netdev_adjacent_sysfs_del(iter->dev, dev->name,

net/core/dev.c

9508

&iter->dev->adj_list.lower);

net/core/dev.c

9509

netdev_adjacent_sysfs_del(dev, iter->dev->name,

net/core/dev.c

9513

list_for_each_entry(iter, &dev->adj_list.lower, list) {

net/core/dev.c

9514

if (!net_eq(net, dev_net(iter->dev)))

net/core/dev.c

9516

netdev_adjacent_sysfs_del(iter->dev, dev->name,

net/core/dev.c

9517

&iter->dev->adj_list.upper);

net/core/dev.c

9518

netdev_adjacent_sysfs_del(dev, iter->dev->name,

net/core/dev.c

9525

struct netdev_adjacent *iter;

net/core/dev.c

9529

list_for_each_entry(iter, &dev->adj_list.upper, list) {

net/core/dev.c

9530

if (!net_eq(net, dev_net(iter->dev)))

net/core/dev.c

9532

netdev_adjacent_sysfs_del(iter->dev, oldname,

net/core/dev.c

9533

&iter->dev->adj_list.lower);

net/core/dev.c

9534

netdev_adjacent_sysfs_add(iter->dev, dev,

net/core/dev.c

9535

&iter->dev->adj_list.lower);

net/core/dev.c

9538

list_for_each_entry(iter, &dev->adj_list.lower, list) {

net/core/dev.c

9539

if (!net_eq(net, dev_net(iter->dev)))

net/core/dev.c

9541

netdev_adjacent_sysfs_del(iter->dev, oldname,

net/core/dev.c

9542

&iter->dev->adj_list.upper);

net/core/dev.c

9543

netdev_adjacent_sysfs_add(iter->dev, dev,

net/core/dev.c

9544

&iter->dev->adj_list.upper);

net/core/dev_addr_lists_test.c

569

int i, iter;

net/core/dev_addr_lists_test.c

582

for (iter = 0; iter < 1000; iter++) {

net/core/gso.c

227

const struct sk_buff *iter;

net/core/gso.c

235

skb_walk_frags(skb, iter) {

net/core/gso.c

236

if (seg_len + skb_headlen(iter) > max_len)

net/core/net-procfs.c

180

struct ptype_iter_state *iter = seq->private;

net/core/net-procfs.c

191

iter->dev = dev;

net/core/net-procfs.c

198

iter->dev = NULL;

net/core/net-procfs.c

231

struct ptype_iter_state *iter = seq->private;

net/core/net-procfs.c

244

dev = iter->dev;

net/core/net-procfs.c

252

iter->dev = dev;

net/core/net-procfs.c

256

iter->dev = NULL;

net/core/net-procfs.c

295

struct ptype_iter_state *iter = seq->private;

net/core/net-procfs.c

303

dev = iter->dev;

net/core/skbuff.c

3209

struct sk_buff *iter;

net/core/skbuff.c

3243

skb_walk_frags(skb, iter) {

net/core/skbuff.c

3244

if (*offset >= iter->len) {

net/core/skbuff.c

3245

*offset -= iter->len;

net/core/skbuff.c

3252

if (__skb_splice_bits(iter, pipe, offset, len, spd, sk))

net/core/skbuff.c

4829

struct sk_buff *iter;

net/core/skbuff.c

4845

skb_walk_frags(head_skb, iter) {

net/core/skbuff.c

4846

if (frag_len != iter->len && iter->next)

net/core/skbuff.c

4848

if (skb_headlen(iter) && !iter->head_frag)

net/core/skbuff.c

4851

len -= iter->len;

net/core/skbuff.c

5091

struct sk_buff *iter;

net/core/skbuff.c

5102

for (iter = segs; iter; iter = iter->next) {

net/core/skbuff.c

5103

skb_shinfo(iter)->gso_size = gso_size;

net/core/skbuff.c

5104

skb_shinfo(iter)->gso_segs = partial_segs;

net/core/skbuff.c

5105

skb_shinfo(iter)->gso_type = type;

net/core/skbuff.c

5106

SKB_GSO_CB(iter)->data_offset = skb_headroom(iter) + doffset;

net/core/skbuff.c

7379

ssize_t skb_splice_from_iter(struct sk_buff *skb, struct iov_iter *iter,

net/core/skbuff.c

7387

while (iter->count > 0) {

net/core/skbuff.c

7399

len = iov_iter_extract_pages(iter, &ppages, maxsize, nr, 0, &off);

net/core/skbuff.c

7417

iov_iter_revert(iter, len);

net/core/skmsg.c

416

struct iov_iter *iter = &msg->msg_iter;

net/core/skmsg.c

444

copy = copy_page_to_iter(page, sge->offset, copy, iter);

net/core/xdp.c

100

rhashtable_walk_enter(mem_id_ht, &iter);

net/core/xdp.c

102

rhashtable_walk_start(&iter);

net/core/xdp.c

104

while ((xa = rhashtable_walk_next(&iter)) && !IS_ERR(xa)) {

net/core/xdp.c

109

rhashtable_walk_stop(&iter);

net/core/xdp.c

112

rhashtable_walk_exit(&iter);

net/core/xdp.c

96

struct rhashtable_iter iter;

net/dsa/conduit.c

526

struct list_head *iter;

net/dsa/conduit.c

530

netdev_for_each_upper_dev_rcu(lag_dev, upper, iter)

net/dsa/port.c

741

struct list_head *iter;

net/dsa/port.c

743

netdev_for_each_upper_dev_rcu(user, upper_dev, iter) {

net/dsa/user.c

2904

struct list_head *iter;

net/dsa/user.c

2922

netdev_for_each_upper_dev_rcu(conduit, upper, iter) {

net/dsa/user.c

3060

struct list_head *iter;

net/dsa/user.c

3067

netdev_for_each_lower_dev(dev, lower, iter) {

net/dsa/user.c

3092

struct list_head *iter;

net/dsa/user.c

3099

netdev_for_each_lower_dev(dev, lower, iter) {

net/dsa/user.c

3280

struct list_head *iter;

net/dsa/user.c

3294

netdev_for_each_lower_dev(lag_dev, lower, iter) {

net/dsa/user.c

3323

struct list_head *iter;

net/dsa/user.c

3333

netdev_for_each_lower_dev(br, lower, iter) {

net/dsa/user.c

3417

struct list_head *iter;

net/dsa/user.c

3419

netdev_for_each_lower_dev(lag_dev, lower, iter) {

net/dsa/user.c

660

struct list_head *iter;

net/dsa/user.c

662

netdev_for_each_upper_dev_rcu(user, upper_dev, iter) {

net/ipv4/cipso_ipv4.c

1011

u32 iter;

net/ipv4/cipso_ipv4.c

1016

for (iter = 0; iter < rngcat_len; iter += 4) {

net/ipv4/cipso_ipv4.c

1017

cat_high = get_unaligned_be16(&rngcat[iter]);

net/ipv4/cipso_ipv4.c

1018

if ((iter + 4) <= rngcat_len)

net/ipv4/cipso_ipv4.c

1019

cat_low = get_unaligned_be16(&rngcat[iter + 2]);

net/ipv4/cipso_ipv4.c

1051

int iter = -1;

net/ipv4/cipso_ipv4.c

1062

iter = netlbl_catmap_walk(secattr->attr.mls.cat, iter + 1);

net/ipv4/cipso_ipv4.c

1063

if (iter < 0)

net/ipv4/cipso_ipv4.c

1065

cat_size += (iter == 0 ? 0 : sizeof(u16));

net/ipv4/cipso_ipv4.c

1068

array[array_cnt++] = iter;

net/ipv4/cipso_ipv4.c

1070

iter = netlbl_catmap_walkrng(secattr->attr.mls.cat, iter);

net/ipv4/cipso_ipv4.c

1071

if (iter < 0)

net/ipv4/cipso_ipv4.c

1076

array[array_cnt++] = iter;

net/ipv4/cipso_ipv4.c

1079

for (iter = 0; array_cnt > 0;) {

net/ipv4/cipso_ipv4.c

1080

*((__be16 *)&net_cat[iter]) = htons(array[--array_cnt]);

net/ipv4/cipso_ipv4.c

1081

iter += 2;

net/ipv4/cipso_ipv4.c

1084

*((__be16 *)&net_cat[iter]) = htons(array[array_cnt]);

net/ipv4/cipso_ipv4.c

1085

iter += 2;

net/ipv4/cipso_ipv4.c

169

u32 iter;

net/ipv4/cipso_ipv4.c

176

for (iter = 0; iter < CIPSO_V4_CACHE_BUCKETS; iter++) {

net/ipv4/cipso_ipv4.c

1761

u32 iter;

net/ipv4/cipso_ipv4.c

1769

iter = 0;

net/ipv4/cipso_ipv4.c

177

spin_lock_init(&cipso_v4_cache[iter].lock);

net/ipv4/cipso_ipv4.c

1772

switch (doi_def->tags[iter]) {

net/ipv4/cipso_ipv4.c

178

cipso_v4_cache[iter].size = 0;

net/ipv4/cipso_ipv4.c

179

INIT_LIST_HEAD(&cipso_v4_cache[iter].list);

net/ipv4/cipso_ipv4.c

1801

iter++;

net/ipv4/cipso_ipv4.c

1803

iter < CIPSO_V4_TAG_MAXCNT &&

net/ipv4/cipso_ipv4.c

1804

doi_def->tags[iter] != CIPSO_V4_TAG_INVALID);

net/ipv4/cipso_ipv4.c

1813

int iter = 0, optlen = 0;

net/ipv4/cipso_ipv4.c

1821

while (iter < len) {

net/ipv4/cipso_ipv4.c

1822

if (data[iter] == IPOPT_END) {

net/ipv4/cipso_ipv4.c

1824

} else if (data[iter] == IPOPT_NOP) {

net/ipv4/cipso_ipv4.c

1825

iter++;

net/ipv4/cipso_ipv4.c

1827

iter += data[iter + 1];

net/ipv4/cipso_ipv4.c

1828

optlen = iter;

net/ipv4/cipso_ipv4.c

195

u32 iter;

net/ipv4/cipso_ipv4.c

197

for (iter = 0; iter < CIPSO_V4_CACHE_BUCKETS; iter++) {

net/ipv4/cipso_ipv4.c

198

spin_lock_bh(&cipso_v4_cache[iter].lock);

net/ipv4/cipso_ipv4.c

201

&cipso_v4_cache[iter].list, list) {

net/ipv4/cipso_ipv4.c

205

cipso_v4_cache[iter].size = 0;

net/ipv4/cipso_ipv4.c

206

spin_unlock_bh(&cipso_v4_cache[iter].lock);

net/ipv4/cipso_ipv4.c

360

struct cipso_v4_doi *iter;

net/ipv4/cipso_ipv4.c

362

list_for_each_entry_rcu(iter, &cipso_v4_doi_list, list)

net/ipv4/cipso_ipv4.c

363

if (iter->doi == doi && refcount_read(&iter->refcount))

net/ipv4/cipso_ipv4.c

364

return iter;

net/ipv4/cipso_ipv4.c

385

u32 iter;

net/ipv4/cipso_ipv4.c

395

for (iter = 0; iter < CIPSO_V4_TAG_MAXCNT; iter++) {

net/ipv4/cipso_ipv4.c

396

switch (doi_def->tags[iter]) {

net/ipv4/cipso_ipv4.c

409

if (iter == 0)

net/ipv4/cipso_ipv4.c

909

u32 iter;

net/ipv4/cipso_ipv4.c

914

for (iter = 0; iter < enumcat_len; iter += 2) {

net/ipv4/cipso_ipv4.c

915

cat = get_unaligned_be16(&enumcat[iter]);

net/ipv4/cipso_ipv4.c

979

u32 iter;

net/ipv4/cipso_ipv4.c

981

for (iter = 0; iter < net_cat_len; iter += 2) {

net/ipv4/cipso_ipv4.c

983

get_unaligned_be16(&net_cat[iter]),

net/ipv4/fib_trie.c

2426

static struct key_vector *fib_trie_get_next(struct fib_trie_iter *iter)

net/ipv4/fib_trie.c

2428

unsigned long cindex = iter->index;

net/ipv4/fib_trie.c

2429

struct key_vector *pn = iter->tnode;

net/ipv4/fib_trie.c

2433

iter->tnode, iter->index, iter->depth);

net/ipv4/fib_trie.c

2443

iter->tnode = pn;

net/ipv4/fib_trie.c

2444

iter->index = cindex;

net/ipv4/fib_trie.c

2447

iter->tnode = n;

net/ipv4/fib_trie.c

2448

iter->index = 0;

net/ipv4/fib_trie.c

2449

++iter->depth;

net/ipv4/fib_trie.c

2459

--iter->depth;

net/ipv4/fib_trie.c

2463

iter->tnode = pn;

net/ipv4/fib_trie.c

2464

iter->index = 0;

net/ipv4/fib_trie.c

2469

static struct key_vector *fib_trie_get_first(struct fib_trie_iter *iter,

net/ipv4/fib_trie.c

2483

iter->tnode = n;

net/ipv4/fib_trie.c

2484

iter->index = 0;

net/ipv4/fib_trie.c

2485

iter->depth = 1;

net/ipv4/fib_trie.c

2487

iter->tnode = pn;

net/ipv4/fib_trie.c

2488

iter->index = 0;

net/ipv4/fib_trie.c

2489

iter->depth = 0;

net/ipv4/fib_trie.c

2498

struct fib_trie_iter iter;

net/ipv4/fib_trie.c

2503

for (n = fib_trie_get_first(&iter, t); n; n = fib_trie_get_next(&iter)) {

net/ipv4/fib_trie.c

2508

s->totdepth += iter.depth;

net/ipv4/fib_trie.c

2509

if (iter.depth > s->maxdepth)

net/ipv4/fib_trie.c

2510

s->maxdepth = iter.depth;

net/ipv4/fib_trie.c

2647

struct fib_trie_iter *iter = seq->private;

net/ipv4/fib_trie.c

2659

for (n = fib_trie_get_first(iter,

net/ipv4/fib_trie.c

2661

n; n = fib_trie_get_next(iter))

net/ipv4/fib_trie.c

2663

iter->tb = tb;

net/ipv4/fib_trie.c

2681

struct fib_trie_iter *iter = seq->private;

net/ipv4/fib_trie.c

2683

struct fib_table *tb = iter->tb;

net/ipv4/fib_trie.c

2690

n = fib_trie_get_next(iter);

net/ipv4/fib_trie.c

2698

n = fib_trie_get_first(iter, (struct trie *) tb->tb_data);

net/ipv4/fib_trie.c

2707

n = fib_trie_get_first(iter, (struct trie *) tb->tb_data);

net/ipv4/fib_trie.c

2715

iter->tb = tb;

net/ipv4/fib_trie.c

2771

const struct fib_trie_iter *iter = seq->private;

net/ipv4/fib_trie.c

2775

fib_table_print(seq, iter->tb);

net/ipv4/fib_trie.c

2780

seq_indent(seq, iter->depth-1);

net/ipv4/fib_trie.c

2789

seq_indent(seq, iter->depth);

net/ipv4/fib_trie.c

2795

seq_indent(seq, iter->depth + 1);

net/ipv4/fib_trie.c

2827

static struct key_vector *fib_route_get_idx(struct fib_route_iter *iter,

net/ipv4/fib_trie.c

2830

struct key_vector *l, **tp = &iter->tnode;

net/ipv4/fib_trie.c

2834

if (iter->pos > 0 && pos >= iter->pos) {

net/ipv4/fib_trie.c

2835

key = iter->key;

net/ipv4/fib_trie.c

2837

iter->pos = 1;

net/ipv4/fib_trie.c

2841

pos -= iter->pos;

net/ipv4/fib_trie.c

2845

iter->pos++;

net/ipv4/fib_trie.c

2854

iter->key = l->key; /* remember it */

net/ipv4/fib_trie.c

2856

iter->pos = 0; /* forget it */

net/ipv4/fib_trie.c

2864

struct fib_route_iter *iter = seq->private;

net/ipv4/fib_trie.c

2874

iter->main_tb = tb;

net/ipv4/fib_trie.c

2876

iter->tnode = t->kv;

net/ipv4/fib_trie.c

2879

return fib_route_get_idx(iter, *pos);

net/ipv4/fib_trie.c

2881

iter->pos = 0;

net/ipv4/fib_trie.c

2882

iter->key = KEY_MAX;

net/ipv4/fib_trie.c

2889

struct fib_route_iter *iter = seq->private;

net/ipv4/fib_trie.c

2891

t_key key = iter->key + 1;

net/ipv4/fib_trie.c

2897

l = leaf_walk_rcu(&iter->tnode, key);

net/ipv4/fib_trie.c

2900

iter->key = l->key;

net/ipv4/fib_trie.c

2901

iter->pos++;

net/ipv4/fib_trie.c

2903

iter->pos = 0;

net/ipv4/fib_trie.c

2941

struct fib_route_iter *iter = seq->private;

net/ipv4/fib_trie.c

2942

struct fib_table *tb = iter->main_tb;

net/ipv4/ip_output.c

598

unsigned int hlen, struct ip_fraglist_iter *iter)

net/ipv4/ip_output.c

602

iter->frag = skb_shinfo(skb)->frag_list;

net/ipv4/ip_output.c

605

iter->offset = 0;

net/ipv4/ip_output.c

606

iter->iph = iph;

net/ipv4/ip_output.c

607

iter->hlen = hlen;

net/ipv4/ip_output.c

617

void ip_fraglist_prepare(struct sk_buff *skb, struct ip_fraglist_iter *iter)

net/ipv4/ip_output.c

619

unsigned int hlen = iter->hlen;

net/ipv4/ip_output.c

620

struct iphdr *iph = iter->iph;

net/ipv4/ip_output.c

623

frag = iter->frag;

net/ipv4/ip_output.c

629

iter->iph = ip_hdr(frag);

net/ipv4/ip_output.c

630

iph = iter->iph;

net/ipv4/ip_output.c

633

iter->offset += skb->len - hlen;

net/ipv4/ip_output.c

634

iph->frag_off = htons(iter->offset >> 3);

net/ipv4/ip_output.c

768

struct ip_fraglist_iter iter;

net/ipv4/ip_output.c

835

ip_fraglist_init(skb, iph, hlen, &iter);

net/ipv4/ip_output.c

840

if (iter.frag) {

net/ipv4/ip_output.c

841

bool first_frag = (iter.offset == 0);

net/ipv4/ip_output.c

843

IPCB(iter.frag)->flags = IPCB(skb)->flags;

net/ipv4/ip_output.c

844

ip_fraglist_prepare(skb, &iter);

net/ipv4/ip_output.c

850

IPCB(iter.frag)->opt.optlen =

net/ipv4/ip_output.c

852

ip_options_fragment(iter.frag);

net/ipv4/ip_output.c

853

ip_send_check(iter.iph);

net/ipv4/ip_output.c

862

if (err || !iter.frag)

net/ipv4/ip_output.c

865

skb = ip_fraglist_next(&iter);

net/ipv4/ip_output.c

873

kfree_skb_list(iter.frag);

net/ipv4/ipconfig.c

329

struct list_head *iter;

net/ipv4/ipconfig.c

335

netdev_for_each_lower_dev(selected_dev, lower, iter) {

net/ipv4/ipmr.c

3138

struct mr_vif_iter *iter = seq->private;

net/ipv4/ipmr.c

3149

iter->mrt = mrt;

net/ipv4/ipmr.c

3162

struct mr_vif_iter *iter = seq->private;

net/ipv4/ipmr.c

3163

struct mr_table *mrt = iter->mrt;

net/ipv4/ipmr_base.c

126

void *mr_vif_seq_idx(struct net *net, struct mr_vif_iter *iter, loff_t pos)

net/ipv4/ipmr_base.c

128

struct mr_table *mrt = iter->mrt;

net/ipv4/ipmr_base.c

130

for (iter->ct = 0; iter->ct < mrt->maxvif; ++iter->ct) {

net/ipv4/ipmr_base.c

131

if (!VIF_EXISTS(mrt, iter->ct))

net/ipv4/ipmr_base.c

134

return &mrt->vif_table[iter->ct];

net/ipv4/ipmr_base.c

141

struct mr_vif_iter *iter = seq->private;

net/ipv4/ipmr_base.c

143

struct mr_table *mrt = iter->mrt;

net/ipv4/ipmr_base.c

147

return mr_vif_seq_idx(net, iter, 0);

net/ipv4/ipmr_base.c

149

while (++iter->ct < mrt->maxvif) {

net/ipv4/ipmr_base.c

150

if (!VIF_EXISTS(mrt, iter->ct))

net/ipv4/ipmr_base.c

152

return &mrt->vif_table[iter->ct];

net/ipv4/ipmr_base.c

358

struct mr_table *(*iter)(struct net *net,

net/ipv4/ipmr_base.c

381

for (mrt = iter(net, NULL); mrt; mrt = iter(net, mrt)) {

net/ipv4/netfilter/arp_tables.c

1006

xt_entry_foreach(iter, loc_cpu_entry, newinfo->size)

net/ipv4/netfilter/arp_tables.c

1007

cleanup_entry(iter, net);

net/ipv4/netfilter/arp_tables.c

1021

struct arpt_entry *iter;

net/ipv4/netfilter/arp_tables.c

1044

xt_entry_foreach(iter, private->entries, private->size) {

net/ipv4/netfilter/arp_tables.c

1047

tmp = xt_get_this_cpu_counter(&iter->counters);

net/ipv4/netfilter/arp_tables.c

1269

struct arpt_entry *iter;

net/ipv4/netfilter/arp_tables.c

1308

xt_entry_foreach(iter, loc_cpu_entry, newinfo->size)

net/ipv4/netfilter/arp_tables.c

1309

cleanup_entry(iter, net);

net/ipv4/netfilter/arp_tables.c

1358

struct arpt_entry *iter;

net/ipv4/netfilter/arp_tables.c

1366

xt_entry_foreach(iter, private->entries, total_size) {

net/ipv4/netfilter/arp_tables.c

1367

ret = compat_copy_entry_to_user(iter, &pos,

net/ipv4/netfilter/arp_tables.c

1508

struct arpt_entry *iter;

net/ipv4/netfilter/arp_tables.c

1512

xt_entry_foreach(iter, loc_cpu_entry, private->size)

net/ipv4/netfilter/arp_tables.c

1513

cleanup_entry(iter, net);

net/ipv4/netfilter/arp_tables.c

1546

struct arpt_entry *iter;

net/ipv4/netfilter/arp_tables.c

1548

xt_entry_foreach(iter, loc_cpu_entry, newinfo->size)

net/ipv4/netfilter/arp_tables.c

1549

cleanup_entry(iter, net);

net/ipv4/netfilter/arp_tables.c

537

struct arpt_entry *iter;

net/ipv4/netfilter/arp_tables.c

557

xt_entry_foreach(iter, entry0, newinfo->size) {

net/ipv4/netfilter/arp_tables.c

558

ret = check_entry_size_and_hooks(iter, newinfo, entry0,

net/ipv4/netfilter/arp_tables.c

566

offsets[i] = (void *)iter - entry0;

net/ipv4/netfilter/arp_tables.c

568

if (strcmp(arpt_get_target(iter)->u.user.name,

net/ipv4/netfilter/arp_tables.c

589

xt_entry_foreach(iter, entry0, newinfo->size) {

net/ipv4/netfilter/arp_tables.c

590

ret = find_check_entry(iter, net, repl->name, repl->size,

net/ipv4/netfilter/arp_tables.c

598

xt_entry_foreach(iter, entry0, newinfo->size) {

net/ipv4/netfilter/arp_tables.c

601

cleanup_entry(iter, net);

net/ipv4/netfilter/arp_tables.c

615

struct arpt_entry *iter;

net/ipv4/netfilter/arp_tables.c

623

xt_entry_foreach(iter, t->entries, t->size) {

net/ipv4/netfilter/arp_tables.c

628

tmp = xt_get_per_cpu_counter(&iter->counters, cpu);

net/ipv4/netfilter/arp_tables.c

645

struct arpt_entry *iter;

net/ipv4/netfilter/arp_tables.c

650

xt_entry_foreach(iter, t->entries, t->size) {

net/ipv4/netfilter/arp_tables.c

653

tmp = xt_get_per_cpu_counter(&iter->counters, cpu);

net/ipv4/netfilter/arp_tables.c

778

struct arpt_entry *iter;

net/ipv4/netfilter/arp_tables.c

792

xt_entry_foreach(iter, loc_cpu_entry, info->size) {

net/ipv4/netfilter/arp_tables.c

793

ret = compat_calc_entry(iter, info, loc_cpu_entry, newinfo);

net/ipv4/netfilter/arp_tables.c

901

struct arpt_entry *iter;

net/ipv4/netfilter/arp_tables.c

940

xt_entry_foreach(iter, loc_cpu_old_entry, oldinfo->size)

net/ipv4/netfilter/arp_tables.c

941

cleanup_entry(iter, net);

net/ipv4/netfilter/arp_tables.c

967

struct arpt_entry *iter;

net/ipv4/netfilter/ip_tables.c

1042

struct ipt_entry *iter;

net/ipv4/netfilter/ip_tables.c

1079

xt_entry_foreach(iter, oldinfo->entries, oldinfo->size)

net/ipv4/netfilter/ip_tables.c

1080

cleanup_entry(iter, net);

net/ipv4/netfilter/ip_tables.c

1107

struct ipt_entry *iter;

net/ipv4/netfilter/ip_tables.c

1146

xt_entry_foreach(iter, loc_cpu_entry, newinfo->size)

net/ipv4/netfilter/ip_tables.c

1147

cleanup_entry(iter, net);

net/ipv4/netfilter/ip_tables.c

1162

struct ipt_entry *iter;

net/ipv4/netfilter/ip_tables.c

1184

xt_entry_foreach(iter, private->entries, private->size) {

net/ipv4/netfilter/ip_tables.c

1187

tmp = xt_get_this_cpu_counter(&iter->counters);

net/ipv4/netfilter/ip_tables.c

1494

struct ipt_entry *iter;

net/ipv4/netfilter/ip_tables.c

1533

xt_entry_foreach(iter, loc_cpu_entry, newinfo->size)

net/ipv4/netfilter/ip_tables.c

1534

cleanup_entry(iter, net);

net/ipv4/netfilter/ip_tables.c

1556

struct ipt_entry *iter;

net/ipv4/netfilter/ip_tables.c

1564

xt_entry_foreach(iter, private->entries, total_size) {

net/ipv4/netfilter/ip_tables.c

1565

ret = compat_copy_entry_to_user(iter, &pos,

net/ipv4/netfilter/ip_tables.c

1710

struct ipt_entry *iter;

net/ipv4/netfilter/ip_tables.c

1715

xt_entry_foreach(iter, loc_cpu_entry, private->size)

net/ipv4/netfilter/ip_tables.c

1716

cleanup_entry(iter, net);

net/ipv4/netfilter/ip_tables.c

1748

struct ipt_entry *iter;

net/ipv4/netfilter/ip_tables.c

1750

xt_entry_foreach(iter, loc_cpu_entry, newinfo->size)

net/ipv4/netfilter/ip_tables.c

1751

cleanup_entry(iter, net);

net/ipv4/netfilter/ip_tables.c

196

const struct ipt_entry *iter;

net/ipv4/netfilter/ip_tables.c

204

xt_entry_foreach(iter, root, private->size - private->hook_entry[hook])

net/ipv4/netfilter/ip_tables.c

205

if (get_chainname_rulenum(iter, e, hookname,

net/ipv4/netfilter/ip_tables.c

664

struct ipt_entry *iter;

net/ipv4/netfilter/ip_tables.c

683

xt_entry_foreach(iter, entry0, newinfo->size) {

net/ipv4/netfilter/ip_tables.c

684

ret = check_entry_size_and_hooks(iter, newinfo, entry0,

net/ipv4/netfilter/ip_tables.c

692

offsets[i] = (void *)iter - entry0;

net/ipv4/netfilter/ip_tables.c

694

if (strcmp(ipt_get_target(iter)->u.user.name,

net/ipv4/netfilter/ip_tables.c

715

xt_entry_foreach(iter, entry0, newinfo->size) {

net/ipv4/netfilter/ip_tables.c

716

ret = find_check_entry(iter, net, repl->name, repl->size,

net/ipv4/netfilter/ip_tables.c

724

xt_entry_foreach(iter, entry0, newinfo->size) {

net/ipv4/netfilter/ip_tables.c

727

cleanup_entry(iter, net);

net/ipv4/netfilter/ip_tables.c

742

struct ipt_entry *iter;

net/ipv4/netfilter/ip_tables.c

750

xt_entry_foreach(iter, t->entries, t->size) {

net/ipv4/netfilter/ip_tables.c

755

tmp = xt_get_per_cpu_counter(&iter->counters, cpu);

net/ipv4/netfilter/ip_tables.c

772

struct ipt_entry *iter;

net/ipv4/netfilter/ip_tables.c

777

xt_entry_foreach(iter, t->entries, t->size) {

net/ipv4/netfilter/ip_tables.c

780

tmp = xt_get_per_cpu_counter(&iter->counters, cpu);

net/ipv4/netfilter/ip_tables.c

921

struct ipt_entry *iter;

net/ipv4/netfilter/ip_tables.c

935

xt_entry_foreach(iter, loc_cpu_entry, info->size) {

net/ipv4/netfilter/ip_tables.c

936

ret = compat_calc_entry(iter, info, loc_cpu_entry, newinfo);

net/ipv4/tcp_ipv4.c

2912

static void bpf_iter_tcp_put_batch(struct bpf_tcp_iter_state *iter)

net/ipv4/tcp_ipv4.c

2915

unsigned int cur_sk = iter->cur_sk;

net/ipv4/tcp_ipv4.c

2921

while (cur_sk < iter->end_sk) {

net/ipv4/tcp_ipv4.c

2922

item = &iter->batch[cur_sk++];

net/ipv4/tcp_ipv4.c

2929

static int bpf_iter_tcp_realloc_batch(struct bpf_tcp_iter_state *iter,

net/ipv4/tcp_ipv4.c

2939

memcpy(new_batch, iter->batch, sizeof(*iter->batch) * iter->end_sk);

net/ipv4/tcp_ipv4.c

2940

kvfree(iter->batch);

net/ipv4/tcp_ipv4.c

2941

iter->batch = new_batch;

net/ipv4/tcp_ipv4.c

2942

iter->max_sk = new_batch_sz;

net/ipv4/tcp_ipv4.c

2968

struct bpf_tcp_iter_state *iter = seq->private;

net/ipv4/tcp_ipv4.c

2969

struct tcp_iter_state *st = &iter->state;

net/ipv4/tcp_ipv4.c

2970

unsigned int find_cookie = iter->cur_sk;

net/ipv4/tcp_ipv4.c

2971

unsigned int end_cookie = iter->end_sk;

net/ipv4/tcp_ipv4.c

2979

iter->cur_sk = 0;

net/ipv4/tcp_ipv4.c

2980

iter->end_sk = 0;

net/ipv4/tcp_ipv4.c

2983

sk = bpf_iter_tcp_resume_bucket(sk, &iter->batch[find_cookie],

net/ipv4/tcp_ipv4.c

2998

struct bpf_tcp_iter_state *iter = seq->private;

net/ipv4/tcp_ipv4.c

2999

struct tcp_iter_state *st = &iter->state;

net/ipv4/tcp_ipv4.c

3000

unsigned int find_cookie = iter->cur_sk;

net/ipv4/tcp_ipv4.c

3001

unsigned int end_cookie = iter->end_sk;

net/ipv4/tcp_ipv4.c

3009

iter->cur_sk = 0;

net/ipv4/tcp_ipv4.c

3010

iter->end_sk = 0;

net/ipv4/tcp_ipv4.c

3013

sk = bpf_iter_tcp_resume_bucket(sk, &iter->batch[find_cookie],

net/ipv4/tcp_ipv4.c

3027

struct bpf_tcp_iter_state *iter = seq->private;

net/ipv4/tcp_ipv4.c

3028

struct tcp_iter_state *st = &iter->state;

net/ipv4/tcp_ipv4.c

3050

struct bpf_tcp_iter_state *iter = seq->private;

net/ipv4/tcp_ipv4.c

3056

iter->batch[iter->end_sk++].sk = *start_sk;

net/ipv4/tcp_ipv4.c

3062

if (iter->end_sk < iter->max_sk) {

net/ipv4/tcp_ipv4.c

3064

iter->batch[iter->end_sk++].sk = sk;

net/ipv4/tcp_ipv4.c

3079

struct bpf_tcp_iter_state *iter = seq->private;

net/ipv4/tcp_ipv4.c

3085

iter->batch[iter->end_sk++].sk = *start_sk;

net/ipv4/tcp_ipv4.c

3091

if (iter->end_sk < iter->max_sk) {

net/ipv4/tcp_ipv4.c

3093

iter->batch[iter->end_sk++].sk = sk;

net/ipv4/tcp_ipv4.c

3108

struct bpf_tcp_iter_state *iter = seq->private;

net/ipv4/tcp_ipv4.c

3109

struct tcp_iter_state *st = &iter->state;

net/ipv4/tcp_ipv4.c

3120

struct bpf_tcp_iter_state *iter = seq->private;

net/ipv4/tcp_ipv4.c

3121

struct tcp_iter_state *st = &iter->state;

net/ipv4/tcp_ipv4.c

3131

struct bpf_tcp_iter_state *iter = seq->private;

net/ipv4/tcp_ipv4.c

3141

if (likely(iter->end_sk == expected))

net/ipv4/tcp_ipv4.c

3146

bpf_iter_tcp_put_batch(iter);

net/ipv4/tcp_ipv4.c

3147

err = bpf_iter_tcp_realloc_batch(iter, expected * 3 / 2,

net/ipv4/tcp_ipv4.c

3150

iter->cur_sk = 0;

net/ipv4/tcp_ipv4.c

3151

iter->end_sk = 0;

net/ipv4/tcp_ipv4.c

3160

if (likely(iter->end_sk == expected))

net/ipv4/tcp_ipv4.c

3167

err = bpf_iter_tcp_realloc_batch(iter, expected, GFP_NOWAIT);

net/ipv4/tcp_ipv4.c

3174

WARN_ON_ONCE(iter->end_sk != expected);

net/ipv4/tcp_ipv4.c

3177

return iter->batch[0].sk;

net/ipv4/tcp_ipv4.c

3193

struct bpf_tcp_iter_state *iter = seq->private;

net/ipv4/tcp_ipv4.c

3194

struct tcp_iter_state *st = &iter->state;

net/ipv4/tcp_ipv4.c

3201

if (iter->cur_sk < iter->end_sk) {

net/ipv4/tcp_ipv4.c

3207

sock_gen_put(iter->batch[iter->cur_sk++].sk);

net/ipv4/tcp_ipv4.c

3210

if (iter->cur_sk < iter->end_sk)

net/ipv4/tcp_ipv4.c

3211

sk = iter->batch[iter->cur_sk].sk;

net/ipv4/tcp_ipv4.c

3266

struct bpf_tcp_iter_state *iter = seq->private;

net/ipv4/tcp_ipv4.c

3277

if (iter->cur_sk < iter->end_sk)

net/ipv4/tcp_ipv4.c

3278

bpf_iter_tcp_put_batch(iter);

net/ipv4/tcp_ipv4.c

3580

struct bpf_tcp_iter_state *iter = priv_data;

net/ipv4/tcp_ipv4.c

3587

err = bpf_iter_tcp_realloc_batch(iter, INIT_BATCH_SZ, GFP_USER);

net/ipv4/tcp_ipv4.c

3598

struct bpf_tcp_iter_state *iter = priv_data;

net/ipv4/tcp_ipv4.c

3601

kvfree(iter->batch);

net/ipv4/udp.c

3312

static int bpf_iter_udp_realloc_batch(struct bpf_udp_iter_state *iter,

net/ipv4/udp.c

3333

struct bpf_udp_iter_state *iter = seq->private;

net/ipv4/udp.c

3334

struct udp_iter_state *state = &iter->state;

net/ipv4/udp.c

3347

if (iter->cur_sk == iter->end_sk)

net/ipv4/udp.c

3360

find_cookie = iter->cur_sk;

net/ipv4/udp.c

3361

end_cookie = iter->end_sk;

net/ipv4/udp.c

3362

iter->cur_sk = 0;

net/ipv4/udp.c

3363

iter->end_sk = 0;

net/ipv4/udp.c

3382

sk = bpf_iter_udp_resume(sk, &iter->batch[find_cookie],

net/ipv4/udp.c

3387

if (iter->end_sk < iter->max_sk) {

net/ipv4/udp.c

3389

iter->batch[iter->end_sk++].sk = sk;

net/ipv4/udp.c

3396

if (unlikely(resizes <= 1 && iter->end_sk &&

net/ipv4/udp.c

3397

iter->end_sk != batch_sks)) {

net/ipv4/udp.c

3405

err = bpf_iter_udp_realloc_batch(iter,

net/ipv4/udp.c

3417

err = bpf_iter_udp_realloc_batch(iter, batch_sks,

net/ipv4/udp.c

3425

sk = iter->batch[iter->end_sk - 1].sk;

net/ipv4/udp.c

3429

batch_sks = iter->end_sk;

net/ipv4/udp.c

3435

if (iter->end_sk)

net/ipv4/udp.c

3441

WARN_ON_ONCE(iter->end_sk != batch_sks);

net/ipv4/udp.c

3442

return iter->end_sk ? iter->batch[0].sk : NULL;

net/ipv4/udp.c

3447

struct bpf_udp_iter_state *iter = seq->private;

net/ipv4/udp.c

3453

if (iter->cur_sk < iter->end_sk)

net/ipv4/udp.c

3454

sock_put(iter->batch[iter->cur_sk++].sk);

net/ipv4/udp.c

3459

if (iter->cur_sk < iter->end_sk)

net/ipv4/udp.c

3460

sk = iter->batch[iter->cur_sk].sk;

net/ipv4/udp.c

3522

static void bpf_iter_udp_put_batch(struct bpf_udp_iter_state *iter)

net/ipv4/udp.c

3525

unsigned int cur_sk = iter->cur_sk;

net/ipv4/udp.c

3531

while (cur_sk < iter->end_sk) {

net/ipv4/udp.c

3532

item = &iter->batch[cur_sk++];

net/ipv4/udp.c

3541

struct bpf_udp_iter_state *iter = seq->private;

net/ipv4/udp.c

3552

if (iter->cur_sk < iter->end_sk)

net/ipv4/udp.c

3553

bpf_iter_udp_put_batch(iter);

net/ipv4/udp.c

3801

static int bpf_iter_udp_realloc_batch(struct bpf_udp_iter_state *iter,

net/ipv4/udp.c

3812

bpf_iter_udp_put_batch(iter);

net/ipv4/udp.c

3814

memcpy(new_batch, iter->batch, sizeof(*iter->batch) * iter->end_sk);

net/ipv4/udp.c

3815

kvfree(iter->batch);

net/ipv4/udp.c

3816

iter->batch = new_batch;

net/ipv4/udp.c

3817

iter->max_sk = new_batch_sz;

net/ipv4/udp.c

3826

struct bpf_udp_iter_state *iter = priv_data;

net/ipv4/udp.c

3833

ret = bpf_iter_udp_realloc_batch(iter, INIT_BATCH_SZ, GFP_USER);

net/ipv4/udp.c

3837

iter->state.bucket = -1;

net/ipv4/udp.c

3844

struct bpf_udp_iter_state *iter = priv_data;

net/ipv4/udp.c

3847

kvfree(iter->batch);

net/ipv6/calipso.c

134

u32 iter;

net/ipv6/calipso.c

141

for (iter = 0; iter < CALIPSO_CACHE_BUCKETS; iter++) {

net/ipv6/calipso.c

142

spin_lock_init(&calipso_cache[iter].lock);

net/ipv6/calipso.c

143

calipso_cache[iter].size = 0;

net/ipv6/calipso.c

144

INIT_LIST_HEAD(&calipso_cache[iter].list);

net/ipv6/calipso.c

161

u32 iter;

net/ipv6/calipso.c

163

for (iter = 0; iter < CALIPSO_CACHE_BUCKETS; iter++) {

net/ipv6/calipso.c

164

spin_lock_bh(&calipso_cache[iter].lock);

net/ipv6/calipso.c

167

&calipso_cache[iter].list, list) {

net/ipv6/calipso.c

171

calipso_cache[iter].size = 0;

net/ipv6/calipso.c

172

spin_unlock_bh(&calipso_cache[iter].lock);

net/ipv6/calipso.c

326

struct calipso_doi *iter;

net/ipv6/calipso.c

328

list_for_each_entry_rcu(iter, &calipso_doi_list, list)

net/ipv6/calipso.c

329

if (iter->doi == doi && refcount_read(&iter->refcount))

net/ipv6/calipso.c

330

return iter;

net/ipv6/ila/ila_xlat.c

383

struct rhashtable_iter iter;

net/ipv6/ila/ila_xlat.c

388

rhashtable_walk_enter(&ilan->xlat.rhash_table, &iter);

net/ipv6/ila/ila_xlat.c

389

rhashtable_walk_start(&iter);

net/ipv6/ila/ila_xlat.c

392

ila = rhashtable_walk_next(&iter);

net/ipv6/ila/ila_xlat.c

419

rhashtable_walk_stop(&iter);

net/ipv6/ila/ila_xlat.c

420

rhashtable_walk_exit(&iter);

net/ipv6/ila/ila_xlat.c

510

struct ila_dump_iter *iter;

net/ipv6/ila/ila_xlat.c

512

iter = kmalloc_obj(*iter);

net/ipv6/ila/ila_xlat.c

513

if (!iter)

net/ipv6/ila/ila_xlat.c

516

rhashtable_walk_enter(&ilan->xlat.rhash_table, &iter->rhiter);

net/ipv6/ila/ila_xlat.c

518

iter->skip = 0;

net/ipv6/ila/ila_xlat.c

519

cb->args[0] = (long)iter;

net/ipv6/ila/ila_xlat.c

526

struct ila_dump_iter *iter = (struct ila_dump_iter *)cb->args[0];

net/ipv6/ila/ila_xlat.c

528

rhashtable_walk_exit(&iter->rhiter);

net/ipv6/ila/ila_xlat.c

530

kfree(iter);

net/ipv6/ila/ila_xlat.c

537

struct ila_dump_iter *iter = (struct ila_dump_iter *)cb->args[0];

net/ipv6/ila/ila_xlat.c

538

struct rhashtable_iter *rhiter = &iter->rhiter;

net/ipv6/ila/ila_xlat.c

539

int skip = iter->skip;

net/ipv6/ila/ila_xlat.c

597

iter->skip = skip;

net/ipv6/ioam6.c

245

struct rhashtable_iter *iter = (struct rhashtable_iter *)cb->args[0];

net/ipv6/ioam6.c

247

if (!iter) {

net/ipv6/ioam6.c

248

iter = kmalloc_obj(*iter);

net/ipv6/ioam6.c

249

if (!iter)

net/ipv6/ioam6.c

252

cb->args[0] = (long)iter;

net/ipv6/ioam6.c

255

rhashtable_walk_enter(&nsdata->namespaces, iter);

net/ipv6/ioam6.c

262

struct rhashtable_iter *iter = (struct rhashtable_iter *)cb->args[0];

net/ipv6/ioam6.c

264

rhashtable_walk_exit(iter);

net/ipv6/ioam6.c

265

kfree(iter);

net/ipv6/ioam6.c

272

struct rhashtable_iter *iter;

net/ipv6/ioam6.c

276

iter = (struct rhashtable_iter *)cb->args[0];

net/ipv6/ioam6.c

277

rhashtable_walk_start(iter);

net/ipv6/ioam6.c

280

ns = rhashtable_walk_next(iter);

net/ipv6/ioam6.c

304

rhashtable_walk_stop(iter);

net/ipv6/ioam6.c

431

struct rhashtable_iter *iter = (struct rhashtable_iter *)cb->args[0];

net/ipv6/ioam6.c

433

if (!iter) {

net/ipv6/ioam6.c

434

iter = kmalloc_obj(*iter);

net/ipv6/ioam6.c

435

if (!iter)

net/ipv6/ioam6.c

438

cb->args[0] = (long)iter;

net/ipv6/ioam6.c

441

rhashtable_walk_enter(&nsdata->schemas, iter);

net/ipv6/ioam6.c

448

struct rhashtable_iter *iter = (struct rhashtable_iter *)cb->args[0];

net/ipv6/ioam6.c

450

rhashtable_walk_exit(iter);

net/ipv6/ioam6.c

451

kfree(iter);

net/ipv6/ioam6.c

458

struct rhashtable_iter *iter;

net/ipv6/ioam6.c

462

iter = (struct rhashtable_iter *)cb->args[0];

net/ipv6/ioam6.c

463

rhashtable_walk_start(iter);

net/ipv6/ioam6.c

466

sc = rhashtable_walk_next(iter);

net/ipv6/ioam6.c

490

rhashtable_walk_stop(iter);

net/ipv6/ip6_fib.c

1095

struct fib6_info *iter = NULL;

net/ipv6/ip6_fib.c

1113

for (iter = leaf; iter;

net/ipv6/ip6_fib.c

1114

iter = rcu_dereference_protected(iter->fib6_next,

net/ipv6/ip6_fib.c

1120

if (iter->fib6_metric == rt->fib6_metric) {

net/ipv6/ip6_fib.c

1130

if (rt_can_ecmp == rt6_qualify_for_ecmp(iter)) {

net/ipv6/ip6_fib.c

1138

if (rt6_duplicate_nexthop(iter, rt)) {

net/ipv6/ip6_fib.c

1141

if (!(iter->fib6_flags & RTF_EXPIRES))

net/ipv6/ip6_fib.c

1144

fib6_clean_expires(iter);

net/ipv6/ip6_fib.c

1145

fib6_may_remove_gc_list(info->nl_net, iter);

net/ipv6/ip6_fib.c

1147

fib6_set_expires(iter, rt->expires);

net/ipv6/ip6_fib.c

1148

fib6_add_gc_list(iter);

net/ipv6/ip6_fib.c

1151

(iter->nh || !iter->fib6_nh->fib_nh_gw_family)) {

net/ipv6/ip6_fib.c

1152

iter->fib6_flags &= ~RTF_ADDRCONF;

net/ipv6/ip6_fib.c

1153

iter->fib6_flags &= ~RTF_PREFIX_RT;

net/ipv6/ip6_fib.c

1157

fib6_metric_set(iter, RTAX_MTU,

net/ipv6/ip6_fib.c

1173

rt6_qualify_for_ecmp(iter))

net/ipv6/ip6_fib.c

1178

if (iter->fib6_metric > rt->fib6_metric)

net/ipv6/ip6_fib.c

1182

ins = &iter->fib6_next;

net/ipv6/ip6_fib.c

1190

iter = rcu_dereference_protected(*ins,

net/ipv6/ip6_fib.c

1284

rcu_assign_pointer(rt->fib6_next, iter);

net/ipv6/ip6_fib.c

1317

rt->fib6_next = iter->fib6_next;

net/ipv6/ip6_fib.c

1325

nsiblings = iter->fib6_nsiblings;

net/ipv6/ip6_fib.c

1326

iter->fib6_node = NULL;

net/ipv6/ip6_fib.c

1327

list_add(&iter->purge_link, purge_list);

net/ipv6/ip6_fib.c

1328

if (rcu_access_pointer(fn->rr_ptr) == iter)

net/ipv6/ip6_fib.c

1334

iter = rcu_dereference_protected(*ins,

net/ipv6/ip6_fib.c

1336

while (iter) {

net/ipv6/ip6_fib.c

1337

if (iter->fib6_metric > rt->fib6_metric)

net/ipv6/ip6_fib.c

1339

if (rt6_qualify_for_ecmp(iter)) {

net/ipv6/ip6_fib.c

1340

*ins = iter->fib6_next;

net/ipv6/ip6_fib.c

1341

iter->fib6_node = NULL;

net/ipv6/ip6_fib.c

1342

list_add(&iter->purge_link, purge_list);

net/ipv6/ip6_fib.c

1343

if (rcu_access_pointer(fn->rr_ptr) == iter)

net/ipv6/ip6_fib.c

1348

ins = &iter->fib6_next;

net/ipv6/ip6_fib.c

1350

iter = rcu_dereference_protected(*ins,

net/ipv6/ip6_fib.c

1537

struct fib6_info *iter, *next;

net/ipv6/ip6_fib.c

1539

list_for_each_entry_safe(iter, next, &purge_list, purge_link) {

net/ipv6/ip6_fib.c

1540

list_del(&iter->purge_link);

net/ipv6/ip6_fib.c

1541

fib6_purge_rt(iter, fn, info->nl_net);

net/ipv6/ip6_fib.c

1542

fib6_info_release(iter);

net/ipv6/ip6_fib.c

1849

int iter = 0;

net/ipv6/ip6_fib.c

1874

pr_debug("fixing tree: plen=%d iter=%d\n", fn->fn_bit, iter);

net/ipv6/ip6_fib.c

1875

iter++;

net/ipv6/ip6_fib.c

2605

struct ipv6_route_iter *iter = seq->private;

net/ipv6/ip6_fib.c

2631

iter->w.leaf = NULL;

net/ipv6/ip6_fib.c

2637

struct ipv6_route_iter *iter = w->args;

net/ipv6/ip6_fib.c

2639

if (!iter->skip)

net/ipv6/ip6_fib.c

2643

iter->w.leaf = rcu_dereference_protected(

net/ipv6/ip6_fib.c

2644

iter->w.leaf->fib6_next,

net/ipv6/ip6_fib.c

2645

lockdep_is_held(&iter->tbl->tb6_lock));

net/ipv6/ip6_fib.c

2646

iter->skip--;

net/ipv6/ip6_fib.c

2647

if (!iter->skip && iter->w.leaf)

net/ipv6/ip6_fib.c

2649

} while (iter->w.leaf);

net/ipv6/ip6_fib.c

2654

static void ipv6_route_seq_setup_walk(struct ipv6_route_iter *iter,

net/ipv6/ip6_fib.c

2657

memset(&iter->w, 0, sizeof(iter->w));

net/ipv6/ip6_fib.c

2658

iter->w.func = ipv6_route_yield;

net/ipv6/ip6_fib.c

2659

iter->w.root = &iter->tbl->tb6_root;

net/ipv6/ip6_fib.c

2660

iter->w.state = FWS_INIT;

net/ipv6/ip6_fib.c

2661

iter->w.node = iter->w.root;

net/ipv6/ip6_fib.c

2662

iter->w.args = iter;

net/ipv6/ip6_fib.c

2663

iter->sernum = READ_ONCE(iter->w.root->fn_sernum);

net/ipv6/ip6_fib.c

2664

INIT_LIST_HEAD(&iter->w.lh);

net/ipv6/ip6_fib.c

2665

fib6_walker_link(net, &iter->w);

net/ipv6/ip6_fib.c

2689

static void ipv6_route_check_sernum(struct ipv6_route_iter *iter)

net/ipv6/ip6_fib.c

2691

int sernum = READ_ONCE(iter->w.root->fn_sernum);

net/ipv6/ip6_fib.c

2693

if (iter->sernum != sernum) {

net/ipv6/ip6_fib.c

2694

iter->sernum = sernum;

net/ipv6/ip6_fib.c

2695

iter->w.state = FWS_INIT;

net/ipv6/ip6_fib.c

2696

iter->w.node = iter->w.root;

net/ipv6/ip6_fib.c

2697

WARN_ON(iter->w.skip);

net/ipv6/ip6_fib.c

2698

iter->w.skip = iter->w.count;

net/ipv6/ip6_fib.c

2707

struct ipv6_route_iter *iter = seq->private;

net/ipv6/ip6_fib.c

2718

ipv6_route_check_sernum(iter);

net/ipv6/ip6_fib.c

2719

spin_lock_bh(&iter->tbl->tb6_lock);

net/ipv6/ip6_fib.c

2720

r = fib6_walk_continue(&iter->w);

net/ipv6/ip6_fib.c

2721

spin_unlock_bh(&iter->tbl->tb6_lock);

net/ipv6/ip6_fib.c

2723

return iter->w.leaf;

net/ipv6/ip6_fib.c

2725

fib6_walker_unlink(net, &iter->w);

net/ipv6/ip6_fib.c

2728

fib6_walker_unlink(net, &iter->w);

net/ipv6/ip6_fib.c

2730

iter->tbl = ipv6_route_seq_next_table(iter->tbl, net);

net/ipv6/ip6_fib.c

2731

if (!iter->tbl)

net/ipv6/ip6_fib.c

2734

ipv6_route_seq_setup_walk(iter, net);

net/ipv6/ip6_fib.c

2742

struct ipv6_route_iter *iter = seq->private;

net/ipv6/ip6_fib.c

2745

iter->tbl = ipv6_route_seq_next_table(NULL, net);

net/ipv6/ip6_fib.c

2746

iter->skip = *pos;

net/ipv6/ip6_fib.c

2748

if (iter->tbl) {

net/ipv6/ip6_fib.c

2751

ipv6_route_seq_setup_walk(iter, net);

net/ipv6/ip6_fib.c

2758

static bool ipv6_route_iter_active(struct ipv6_route_iter *iter)

net/ipv6/ip6_fib.c

2760

struct fib6_walker *w = &iter->w;

net/ipv6/ip6_fib.c

2768

struct ipv6_route_iter *iter = seq->private;

net/ipv6/ip6_fib.c

2770

if (ipv6_route_iter_active(iter))

net/ipv6/ip6_fib.c

2771

fib6_walker_unlink(net, &iter->w);

net/ipv6/ip6_fib.c

2790

struct ipv6_route_iter *iter = seq->private;

net/ipv6/ip6_fib.c

2801

iter->w.leaf = NULL;

net/ipv6/ip6_gre.c

278

struct ip6_tnl *iter;

net/ipv6/ip6_gre.c

281

(iter = rtnl_dereference(*tp)) != NULL;

net/ipv6/ip6_gre.c

282

tp = &iter->next) {

net/ipv6/ip6_gre.c

283

if (t == iter) {

net/ipv6/ip6_output.c

1002

skb = ip6_fraglist_next(&iter);

net/ipv6/ip6_output.c

1005

kfree(iter.tmp_hdr);

net/ipv6/ip6_output.c

1014

kfree_skb_list(iter.frag);

net/ipv6/ip6_output.c

724

struct ip6_fraglist_iter *iter)

net/ipv6/ip6_output.c

731

iter->tmp_hdr = kmemdup(skb_network_header(skb), hlen, GFP_ATOMIC);

net/ipv6/ip6_output.c

732

if (!iter->tmp_hdr)

net/ipv6/ip6_output.c

735

iter->frag = skb_shinfo(skb)->frag_list;

net/ipv6/ip6_output.c

738

iter->offset = 0;

net/ipv6/ip6_output.c

739

iter->hlen = hlen;

net/ipv6/ip6_output.c

740

iter->frag_id = frag_id;

net/ipv6/ip6_output.c

741

iter->nexthdr = nexthdr;

net/ipv6/ip6_output.c

747

memcpy(skb_network_header(skb), iter->tmp_hdr, hlen);

net/ipv6/ip6_output.c

764

struct ip6_fraglist_iter *iter)

net/ipv6/ip6_output.c

766

struct sk_buff *frag = iter->frag;

net/ipv6/ip6_output.c

767

unsigned int hlen = iter->hlen;

net/ipv6/ip6_output.c

775

memcpy(skb_network_header(frag), iter->tmp_hdr, hlen);

net/ipv6/ip6_output.c

776

iter->offset += skb->len - hlen - sizeof(struct frag_hdr);

net/ipv6/ip6_output.c

777

fh->nexthdr = iter->nexthdr;

net/ipv6/ip6_output.c

779

fh->frag_off = htons(iter->offset);

net/ipv6/ip6_output.c

782

fh->identification = iter->frag_id;

net/ipv6/ip6_output.c

951

struct ip6_fraglist_iter iter;

net/ipv6/ip6_output.c

980

&iter);

net/ipv6/ip6_output.c

990

if (iter.frag)

net/ipv6/ip6_output.c

991

ip6_fraglist_prepare(skb, &iter);

net/ipv6/ip6_output.c

999

if (err || !iter.frag)

net/ipv6/ip6_tunnel.c

230

struct ip6_tnl *iter;

net/ipv6/ip6_tunnel.c

236

(iter = rtnl_dereference(*tp)) != NULL;

net/ipv6/ip6_tunnel.c

237

tp = &iter->next) {

net/ipv6/ip6_tunnel.c

238

if (t == iter) {

net/ipv6/ip6_vti.c

168

struct ip6_tnl *iter;

net/ipv6/ip6_vti.c

171

(iter = rtnl_dereference(*tp)) != NULL;

net/ipv6/ip6_vti.c

172

tp = &iter->next) {

net/ipv6/ip6_vti.c

173

if (t == iter) {

net/ipv6/ip6mr.c

447

struct mr_vif_iter *iter = seq->private;

net/ipv6/ip6mr.c

458

iter->mrt = mrt;

net/ipv6/ip6mr.c

471

struct mr_vif_iter *iter = seq->private;

net/ipv6/ip6mr.c

472

struct mr_table *mrt = iter->mrt;

net/ipv6/netfilter.c

155

struct ip6_fraglist_iter iter;

net/ipv6/netfilter.c

176

&iter);

net/ipv6/netfilter.c

184

if (iter.frag)

net/ipv6/netfilter.c

185

ip6_fraglist_prepare(skb, &iter);

net/ipv6/netfilter.c

189

if (err || !iter.frag)

net/ipv6/netfilter.c

192

skb = ip6_fraglist_next(&iter);

net/ipv6/netfilter.c

195

kfree(iter.tmp_hdr);

net/ipv6/netfilter.c

199

kfree_skb_list(iter.frag);

net/ipv6/netfilter/ip6_tables.c

1059

struct ip6t_entry *iter;

net/ipv6/netfilter/ip6_tables.c

1096

xt_entry_foreach(iter, oldinfo->entries, oldinfo->size)

net/ipv6/netfilter/ip6_tables.c

1097

cleanup_entry(iter, net);

net/ipv6/netfilter/ip6_tables.c

1124

struct ip6t_entry *iter;

net/ipv6/netfilter/ip6_tables.c

1163

xt_entry_foreach(iter, loc_cpu_entry, newinfo->size)

net/ipv6/netfilter/ip6_tables.c

1164

cleanup_entry(iter, net);

net/ipv6/netfilter/ip6_tables.c

1179

struct ip6t_entry *iter;

net/ipv6/netfilter/ip6_tables.c

1200

xt_entry_foreach(iter, private->entries, private->size) {

net/ipv6/netfilter/ip6_tables.c

1203

tmp = xt_get_this_cpu_counter(&iter->counters);

net/ipv6/netfilter/ip6_tables.c

1503

struct ip6t_entry *iter;

net/ipv6/netfilter/ip6_tables.c

1542

xt_entry_foreach(iter, loc_cpu_entry, newinfo->size)

net/ipv6/netfilter/ip6_tables.c

1543

cleanup_entry(iter, net);

net/ipv6/netfilter/ip6_tables.c

1565

struct ip6t_entry *iter;

net/ipv6/netfilter/ip6_tables.c

1573

xt_entry_foreach(iter, private->entries, total_size) {

net/ipv6/netfilter/ip6_tables.c

1574

ret = compat_copy_entry_to_user(iter, &pos,

net/ipv6/netfilter/ip6_tables.c

1719

struct ip6t_entry *iter;

net/ipv6/netfilter/ip6_tables.c

1724

xt_entry_foreach(iter, loc_cpu_entry, private->size)

net/ipv6/netfilter/ip6_tables.c

1725

cleanup_entry(iter, net);

net/ipv6/netfilter/ip6_tables.c

1757

struct ip6t_entry *iter;

net/ipv6/netfilter/ip6_tables.c

1759

xt_entry_foreach(iter, loc_cpu_entry, newinfo->size)

net/ipv6/netfilter/ip6_tables.c

1760

cleanup_entry(iter, net);

net/ipv6/netfilter/ip6_tables.c

221

const struct ip6t_entry *iter;

net/ipv6/netfilter/ip6_tables.c

229

xt_entry_foreach(iter, root, private->size - private->hook_entry[hook])

net/ipv6/netfilter/ip6_tables.c

230

if (get_chainname_rulenum(iter, e, hookname,

net/ipv6/netfilter/ip6_tables.c

681

struct ip6t_entry *iter;

net/ipv6/netfilter/ip6_tables.c

700

xt_entry_foreach(iter, entry0, newinfo->size) {

net/ipv6/netfilter/ip6_tables.c

701

ret = check_entry_size_and_hooks(iter, newinfo, entry0,

net/ipv6/netfilter/ip6_tables.c

709

offsets[i] = (void *)iter - entry0;

net/ipv6/netfilter/ip6_tables.c

711

if (strcmp(ip6t_get_target(iter)->u.user.name,

net/ipv6/netfilter/ip6_tables.c

732

xt_entry_foreach(iter, entry0, newinfo->size) {

net/ipv6/netfilter/ip6_tables.c

733

ret = find_check_entry(iter, net, repl->name, repl->size,

net/ipv6/netfilter/ip6_tables.c

741

xt_entry_foreach(iter, entry0, newinfo->size) {

net/ipv6/netfilter/ip6_tables.c

744

cleanup_entry(iter, net);

net/ipv6/netfilter/ip6_tables.c

759

struct ip6t_entry *iter;

net/ipv6/netfilter/ip6_tables.c

767

xt_entry_foreach(iter, t->entries, t->size) {

net/ipv6/netfilter/ip6_tables.c

772

tmp = xt_get_per_cpu_counter(&iter->counters, cpu);

net/ipv6/netfilter/ip6_tables.c

789

struct ip6t_entry *iter;

net/ipv6/netfilter/ip6_tables.c

794

xt_entry_foreach(iter, t->entries, t->size) {

net/ipv6/netfilter/ip6_tables.c

797

tmp = xt_get_per_cpu_counter(&iter->counters, cpu);

net/ipv6/netfilter/ip6_tables.c

937

struct ip6t_entry *iter;

net/ipv6/netfilter/ip6_tables.c

951

xt_entry_foreach(iter, loc_cpu_entry, info->size) {

net/ipv6/netfilter/ip6_tables.c

952

ret = compat_calc_entry(iter, info, loc_cpu_entry, newinfo);

net/ipv6/netfilter/nft_fib_ipv6.c

174

struct fib6_info *iter;

net/ipv6/netfilter/nft_fib_ipv6.c

189

list_for_each_entry_rcu(iter, &rt->fib6_siblings, fib6_siblings) {

net/ipv6/netfilter/nft_fib_ipv6.c

190

nh_dev = fib6_info_nh_dev(iter);

net/ipv6/route.c

417

struct fib6_info *iter;

net/ipv6/route.c

423

iter = rcu_dereference(fn->leaf);

net/ipv6/route.c

424

if (!iter)

net/ipv6/route.c

427

while (iter) {

net/ipv6/route.c

428

if (iter->fib6_metric == rt->fib6_metric &&

net/ipv6/route.c

429

rt6_qualify_for_ecmp(iter))

net/ipv6/route.c

430

return iter;

net/ipv6/route.c

431

iter = rcu_dereference(iter->fib6_next);

net/ipv6/route.c

4794

struct fib6_info *iter;

net/ipv6/route.c

4799

iter = rcu_dereference_protected(fn->leaf,

net/ipv6/route.c

4801

while (iter) {

net/ipv6/route.c

4802

if (iter->fib6_metric == rt->fib6_metric &&

net/ipv6/route.c

4803

rt6_qualify_for_ecmp(iter))

net/ipv6/route.c

4804

return iter;

net/ipv6/route.c

4805

iter = rcu_dereference_protected(iter->fib6_next,

net/ipv6/route.c

4825

struct fib6_info *iter;

net/ipv6/route.c

4831

list_for_each_entry(iter, &rt->fib6_siblings, fib6_siblings) {

net/ipv6/route.c

4832

if (!rt6_is_dead(iter))

net/ipv6/route.c

4833

total += iter->fib6_nh->fib_nh_weight;

net/ipv6/route.c

4853

struct fib6_info *iter;

net/ipv6/route.c

4858

list_for_each_entry(iter, &rt->fib6_siblings, fib6_siblings)

net/ipv6/route.c

4859

rt6_upper_bound_set(iter, &weight, total);

net/ipv6/route.c

4920

struct fib6_info *iter;

net/ipv6/route.c

4924

list_for_each_entry(iter, &rt->fib6_siblings, fib6_siblings)

net/ipv6/route.c

4925

if (iter->fib6_nh->fib_nh_dev == dev)

net/ipv6/route.c

4933

struct fib6_info *iter;

net/ipv6/route.c

4936

list_for_each_entry(iter, &rt->fib6_siblings, fib6_siblings)

net/ipv6/route.c

4937

iter->should_flush = 1;

net/ipv6/route.c

4943

struct fib6_info *iter;

net/ipv6/route.c

4949

list_for_each_entry(iter, &rt->fib6_siblings, fib6_siblings)

net/ipv6/route.c

4950

if (iter->fib6_nh->fib_nh_dev == down_dev ||

net/ipv6/route.c

4951

iter->fib6_nh->fib_nh_flags & RTNH_F_DEAD)

net/ipv6/route.c

4961

struct fib6_info *iter;

net/ipv6/route.c

4965

list_for_each_entry(iter, &rt->fib6_siblings, fib6_siblings)

net/ipv6/route.c

4966

if (iter->fib6_nh->fib_nh_dev == dev)

net/ipv6/route.c

4967

iter->fib6_nh->fib_nh_flags |= nh_flags;

net/ipv6/seg6.c

339

struct rhashtable_iter *iter;

net/ipv6/seg6.c

342

iter = (struct rhashtable_iter *)cb->args[0];

net/ipv6/seg6.c

344

if (!iter) {

net/ipv6/seg6.c

345

iter = kmalloc_obj(*iter);

net/ipv6/seg6.c

346

if (!iter)

net/ipv6/seg6.c

349

cb->args[0] = (long)iter;

net/ipv6/seg6.c

352

rhashtable_walk_enter(&sdata->hmac_infos, iter);

net/ipv6/seg6.c

359

struct rhashtable_iter *iter = (struct rhashtable_iter *)cb->args[0];

net/ipv6/seg6.c

361

rhashtable_walk_exit(iter);

net/ipv6/seg6.c

363

kfree(iter);

net/ipv6/seg6.c

370

struct rhashtable_iter *iter = (struct rhashtable_iter *)cb->args[0];

net/ipv6/seg6.c

374

rhashtable_walk_start(iter);

net/ipv6/seg6.c

377

hinfo = rhashtable_walk_next(iter);

net/ipv6/seg6.c

400

rhashtable_walk_stop(iter);

net/ipv6/sit.c

166

struct ip_tunnel *iter;

net/ipv6/sit.c

169

(iter = rtnl_dereference(*tp)) != NULL;

net/ipv6/sit.c

170

tp = &iter->next) {

net/ipv6/sit.c

171

if (t == iter) {

net/mac80211/cfg.c

4399

struct ieee80211_link_data *iter;

net/mac80211/cfg.c

4401

for_each_sdata_link_rcu(local, iter) {

net/mac80211/cfg.c

4402

if (iter->sdata == sdata ||

net/mac80211/cfg.c

4403

rcu_access_pointer(iter->conf->tx_bss_conf) != tx_bss_conf)

net/mac80211/cfg.c

4406

wiphy_work_queue(iter->sdata->local->hw.wiphy,

net/mac80211/cfg.c

4407

&iter->csa.finalize_work);

net/mac80211/chan.c

104

iter->per_link = CHANCTX_ITER_POS_ASSIGNED;

net/mac80211/chan.c

1110

struct ieee80211_chanctx_user_iter iter;

net/mac80211/chan.c

1116

for_each_chanctx_user_assigned(local, ctx, &iter) {

net/mac80211/chan.c

1118

compat = iter.chanreq;

net/mac80211/chan.c

1120

compat = ieee80211_chanreq_compatible(iter.chanreq,

net/mac80211/chan.c

114

struct ieee80211_chanctx_user_iter *iter,

net/mac80211/chan.c

123

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

net/mac80211/chan.c

1264

struct ieee80211_chanctx_user_iter iter;

net/mac80211/chan.c

1273

for_each_chanctx_user_assigned(local, chanctx, &iter) {

net/mac80211/chan.c

1276

switch (iter.iftype) {

net/mac80211/chan.c

1278

if (!iter.sdata->u.mgd.associated)

net/mac80211/chan.c

128

if (iter->iftype == NL80211_IFTYPE_NAN)

net/mac80211/chan.c

129

found = ieee80211_chanctx_user_iter_next_nan_channel(ctx, iter);

net/mac80211/chan.c

1295

if (iter.iftype == NL80211_IFTYPE_MONITOR) {

net/mac80211/chan.c

1300

if (iter.nan_channel) {

net/mac80211/chan.c

1302

iter.nan_channel->needed_rx_chains;

net/mac80211/chan.c

1306

if (!iter.link)

net/mac80211/chan.c

1309

switch (iter.link->smps_mode) {

net/mac80211/chan.c

131

found = ieee80211_chanctx_user_iter_next_link(ctx, iter, type);

net/mac80211/chan.c

1312

iter.link->smps_mode);

net/mac80211/chan.c

1315

needed_static = iter.link->needed_rx_chains;

net/mac80211/chan.c

1316

needed_dynamic = iter.link->needed_rx_chains;

net/mac80211/chan.c

1320

needed_dynamic = iter.link->needed_rx_chains;

net/mac80211/chan.c

138

iter->sdata = list_prepare_entry(iter->sdata, &local->interfaces, list);

net/mac80211/chan.c

139

list_for_each_entry_continue(iter->sdata, &local->interfaces, list) {

net/mac80211/chan.c

140

if (!ieee80211_sdata_running(iter->sdata))

net/mac80211/chan.c

144

if (iter->sdata->vif.type == NL80211_IFTYPE_AP_VLAN)

net/mac80211/chan.c

148

if (iter->sdata->vif.type == NL80211_IFTYPE_NAN &&

net/mac80211/chan.c

152

iter->nan_channel = NULL;

net/mac80211/chan.c

153

iter->link = NULL;

net/mac80211/chan.c

154

iter->iftype = iter->sdata->vif.type;

net/mac80211/chan.c

155

iter->chanreq = NULL;

net/mac80211/chan.c

156

iter->per_link = CHANCTX_ITER_POS_ASSIGNED;

net/mac80211/chan.c

157

iter->nan_channel_next_idx = 0;

net/mac80211/chan.c

161

iter->done = true;

net/mac80211/chan.c

164

#define for_each_chanctx_user_assigned(local, ctx, iter) \

net/mac80211/chan.c

165

for (ieee80211_chanctx_user_iter_next(local, ctx, iter, \

net/mac80211/chan.c

168

!((iter)->done); \

net/mac80211/chan.c

169

ieee80211_chanctx_user_iter_next(local, ctx, iter, \

net/mac80211/chan.c

173

#define for_each_chanctx_user_reserved(local, ctx, iter) \

net/mac80211/chan.c

174

for (ieee80211_chanctx_user_iter_next(local, ctx, iter, \

net/mac80211/chan.c

177

!((iter)->done); \

net/mac80211/chan.c

178

ieee80211_chanctx_user_iter_next(local, ctx, iter, \

net/mac80211/chan.c

1813

struct ieee80211_chanctx_user_iter iter;

net/mac80211/chan.c

182

#define for_each_chanctx_user_all(local, ctx, iter) \

net/mac80211/chan.c

1823

for_each_chanctx_user_reserved(local, ctx, &iter) {

net/mac80211/chan.c

1824

if (!ieee80211_link_has_in_place_reservation(iter.link))

net/mac80211/chan.c

1827

old_ctx = ieee80211_link_get_chanctx(iter.link);

net/mac80211/chan.c

1828

vif_chsw[i].vif = &iter.sdata->vif;

net/mac80211/chan.c

183

for (ieee80211_chanctx_user_iter_next(local, ctx, iter, \

net/mac80211/chan.c

1831

vif_chsw[i].link_conf = iter.link->conf;

net/mac80211/chan.c

186

!((iter)->done); \

net/mac80211/chan.c

187

ieee80211_chanctx_user_iter_next(local, ctx, iter, \

net/mac80211/chan.c

1908

struct ieee80211_chanctx_user_iter iter;

net/mac80211/chan.c

1924

for_each_chanctx_user_assigned(local, ctx->replace_ctx, &iter) {

net/mac80211/chan.c

1926

if (iter.link && iter.link->reserved_chanctx) {

net/mac80211/chan.c

1928

if (iter.link->reserved_ready)

net/mac80211/chan.c

194

struct ieee80211_chanctx_user_iter iter;

net/mac80211/chan.c

1950

for_each_chanctx_user_reserved(local, ctx, &iter) {

net/mac80211/chan.c

1951

if (ieee80211_link_has_in_place_reservation(iter.link) &&

net/mac80211/chan.c

1952

!iter.link->reserved_ready)

net/mac80211/chan.c

1955

old_ctx = ieee80211_link_get_chanctx(iter.link);

net/mac80211/chan.c

1966

if (iter.radar_required)

net/mac80211/chan.c

197

for_each_chanctx_user_assigned(local, ctx, &iter)

net/mac80211/chan.c

1981

struct ieee80211_chanctx_user_iter iter;

net/mac80211/chan.c

1991

for_each_chanctx_user_reserved(local, ctx, &iter) {

net/mac80211/chan.c

1992

if (!ieee80211_link_has_in_place_reservation(iter.link))

net/mac80211/chan.c

1996

ieee80211_link_get_chanctx(iter.link),

net/mac80211/chan.c

2025

struct ieee80211_chanctx_user_iter iter;

net/mac80211/chan.c

2035

for_each_chanctx_user_reserved(local, ctx, &iter) {

net/mac80211/chan.c

2036

struct ieee80211_link_data *link = iter.link;

net/mac80211/chan.c

2037

struct ieee80211_sub_if_data *sdata = iter.sdata;

net/mac80211/chan.c

2053

link->radar_required = iter.radar_required;

net/mac80211/chan.c

2055

if (link_conf->chanreq.oper.width != iter.chanreq->oper.width)

net/mac80211/chan.c

206

struct ieee80211_chanctx_user_iter iter;

net/mac80211/chan.c

2072

for_each_chanctx_user_reserved(local, ctx, &iter) {

net/mac80211/chan.c

2073

if (ieee80211_link_get_chanctx(iter.link) != ctx)

net/mac80211/chan.c

2076

iter.link->reserved_chanctx = NULL;

net/mac80211/chan.c

2078

ieee80211_link_chanctx_reservation_complete(iter.link);

net/mac80211/chan.c

2089

for_each_chanctx_user_reserved(local, ctx, &iter) {

net/mac80211/chan.c

209

for_each_chanctx_user_reserved(local, ctx, &iter)

net/mac80211/chan.c

2090

struct ieee80211_link_data *link = iter.link;

net/mac80211/chan.c

2135

struct ieee80211_chanctx_user_iter iter;

net/mac80211/chan.c

2140

for_each_chanctx_user_reserved(local, ctx, &iter) {

net/mac80211/chan.c

2141

ieee80211_link_unreserve_chanctx(iter.link);

net/mac80211/chan.c

2142

ieee80211_link_chanctx_reservation_complete(iter.link);

net/mac80211/chan.c

218

struct ieee80211_chanctx_user_iter iter;

net/mac80211/chan.c

221

for_each_chanctx_user_all(local, ctx, &iter)

net/mac80211/chan.c

2521

void (*iter)(struct ieee80211_hw *hw,

net/mac80211/chan.c

2532

iter(hw, &ctx->conf, iter_data);

net/mac80211/chan.c

2539

void (*iter)(struct ieee80211_hw *hw,

net/mac80211/chan.c

2551

iter(hw, &ctx->conf, iter_data);

net/mac80211/chan.c

341

struct ieee80211_chanctx_user_iter iter;

net/mac80211/chan.c

345

for_each_chanctx_user_all(local, ctx, &iter) {

net/mac80211/chan.c

346

if (iter.link && iter.link == skip_link)

net/mac80211/chan.c

349

ret = ieee80211_chanreq_compatible(ret, iter.chanreq, tmp);

net/mac80211/chan.c

373

struct ieee80211_chanctx_user_iter iter;

net/mac80211/chan.c

38

struct ieee80211_chanctx_user_iter *iter)

net/mac80211/chan.c

380

for_each_chanctx_user_reserved(local, ctx, &iter) {

net/mac80211/chan.c

381

req = ieee80211_chanreq_compatible(iter.chanreq, req, tmp);

net/mac80211/chan.c

396

struct ieee80211_chanctx_user_iter iter;

net/mac80211/chan.c

400

for_each_chanctx_user_assigned(local, ctx, &iter) {

net/mac80211/chan.c

401

if (iter.link && iter.link->reserved_chanctx)

net/mac80211/chan.c

404

comp_def = ieee80211_chanreq_compatible(iter.chanreq,

net/mac80211/chan.c

41

for (int i = iter->nan_channel_next_idx;

net/mac80211/chan.c

42

i < ARRAY_SIZE(iter->sdata->vif.cfg.nan_sched.channels); i++) {

net/mac80211/chan.c

44

&iter->sdata->vif.cfg.nan_sched.channels[i];

net/mac80211/chan.c

52

iter->nan_channel = nan_channel;

net/mac80211/chan.c

53

iter->nan_channel_next_idx = i + 1;

net/mac80211/chan.c

54

iter->chanreq = &nan_channel->chanreq;

net/mac80211/chan.c

55

iter->link = NULL;

net/mac80211/chan.c

56

iter->reserved = false;

net/mac80211/chan.c

57

iter->radar_required = false;

net/mac80211/chan.c

570

ieee80211_get_width_of_chanctx_user(struct ieee80211_chanctx_user_iter *iter)

net/mac80211/chan.c

572

if (iter->link)

net/mac80211/chan.c

573

return ieee80211_get_width_of_link(iter->link);

net/mac80211/chan.c

575

if (WARN_ON_ONCE(!iter->nan_channel || iter->reserved))

net/mac80211/chan.c

578

return iter->nan_channel->chanreq.oper.width;

net/mac80211/chan.c

588

struct ieee80211_chanctx_user_iter iter;

net/mac80211/chan.c

597

for_each_chanctx_user_reserved(local, ctx, &iter) {

net/mac80211/chan.c

598

width = ieee80211_get_width_of_chanctx_user(&iter);

net/mac80211/chan.c

605

for_each_chanctx_user_assigned(local, ctx, &iter) {

net/mac80211/chan.c

606

width = ieee80211_get_width_of_chanctx_user(&iter);

net/mac80211/chan.c

65

struct ieee80211_chanctx_user_iter *iter,

net/mac80211/chan.c

68

for (int link_id = iter->link ? iter->link->link_id : 0;

net/mac80211/chan.c

69

link_id < ARRAY_SIZE(iter->sdata->link);

net/mac80211/chan.c

73

link = sdata_dereference(iter->sdata->link[link_id],

net/mac80211/chan.c

74

iter->sdata);

net/mac80211/chan.c

78

switch (iter->per_link) {

net/mac80211/chan.c

782

struct ieee80211_chanctx_user_iter iter;

net/mac80211/chan.c

787

for_each_chanctx_user_assigned(local, ctx, &iter) {

net/mac80211/chan.c

788

if (!iter.link)

net/mac80211/chan.c

790

if (!iter.sdata->vif.cfg.assoc)

net/mac80211/chan.c

794

if (!iter.link->conf->chanreq.oper.npca_chan)

net/mac80211/chan.c

797

if (!iter.link->conf->npca.enabled)

net/mac80211/chan.c

80

iter->per_link = CHANCTX_ITER_POS_RESERVED;

net/mac80211/chan.c

801

iter.link->conf->npca.enabled = enable;

net/mac80211/chan.c

802

drv_link_info_changed(local, iter.sdata,

net/mac80211/chan.c

803

iter.link->conf,

net/mac80211/chan.c

804

iter.link->link_id,

net/mac80211/chan.c

83

iter->link = link;

net/mac80211/chan.c

84

iter->reserved = false;

net/mac80211/chan.c

85

iter->radar_required = link->radar_required;

net/mac80211/chan.c

86

iter->chanreq = &link->conf->chanreq;

net/mac80211/chan.c

91

iter->per_link = CHANCTX_ITER_POS_DONE;

net/mac80211/chan.c

94

iter->link = link;

net/mac80211/chan.c

95

iter->reserved = true;

net/mac80211/chan.c

96

iter->radar_required =

net/mac80211/chan.c

984

struct ieee80211_chanctx_user_iter iter;

net/mac80211/chan.c

988

for_each_chanctx_user_assigned(local, ctx, &iter) {

net/mac80211/chan.c

989

if (iter.radar_required)

net/mac80211/chan.c

99

iter->chanreq = &link->reserved;

net/mac80211/iface.c

110

struct ieee80211_sub_if_data *iter;

net/mac80211/iface.c

121

list_for_each_entry(iter, &local->interfaces, list) {

net/mac80211/iface.c

122

if (iter->vif.type == NL80211_IFTYPE_NAN &&

net/mac80211/iface.c

123

iter->u.nan.started) {

net/mac80211/iface.c

165

struct ieee80211_sub_if_data *iter;

net/mac80211/iface.c

188

list_for_each_entry(iter, &local->interfaces, list) {

net/mac80211/iface.c

189

if (iter == sdata)

net/mac80211/iface.c

192

if (iter->vif.type == NL80211_IFTYPE_MONITOR &&

net/mac80211/iface.c

193

!(iter->u.mntr.flags & MONITOR_FLAG_ACTIVE))

net/mac80211/iface.c

196

m = iter->vif.addr;

net/mac80211/iface.c

482

struct ieee80211_sub_if_data *iter;

net/mac80211/iface.c

638

list_for_each_entry(iter, &local->interfaces, list) {

net/mac80211/iface.c

639

WARN_ON(iter->vif.type == NL80211_IFTYPE_NAN_DATA &&

net/mac80211/iface.c

640

ieee80211_sdata_running(iter));

net/mac80211/key.c

1004

void (*iter)(struct ieee80211_hw *hw,

net/mac80211/key.c

1016

iter(hw, vif, key->sta ? &key->sta->sta : NULL,

net/mac80211/key.c

1022

void (*iter)(struct ieee80211_hw *hw,

net/mac80211/key.c

1038

ieee80211_key_iter(hw, vif, key, iter, iter_data);

net/mac80211/key.c

1044

iter, iter_data);

net/mac80211/key.c

1052

void (*iter)(struct ieee80211_hw *hw,

net/mac80211/key.c

1062

ieee80211_key_iter(hw, &sdata->vif, key, iter, iter_data);

net/mac80211/key.c

1067

void (*iter)(struct ieee80211_hw *hw,

net/mac80211/key.c

1079

_ieee80211_iter_keys_rcu(hw, sdata, iter, iter_data);

net/mac80211/key.c

1082

_ieee80211_iter_keys_rcu(hw, sdata, iter, iter_data);

net/mac80211/tx.c

4274

struct txq_info *iter, *tmp, *txqi = to_txq_info(txq);

net/mac80211/tx.c

4289

list_for_each_entry_safe(iter, tmp, &local->active_txqs[ac],

net/mac80211/tx.c

4291

if (iter == txqi)

net/mac80211/tx.c

4294

if (!iter->txq.sta) {

net/mac80211/tx.c

4295

list_move_tail(&iter->schedule_order,

net/mac80211/tx.c

4299

sta = container_of(iter->txq.sta, struct sta_info, sta);

net/mac80211/tx.c

4302

list_move_tail(&iter->schedule_order, &local->active_txqs[ac]);

net/mptcp/pm.c

1065

struct mptcp_subflow_context *iter, *subflow = mptcp_subflow_ctx(ssk);

net/mptcp/pm.c

1078

mptcp_for_each_subflow(msk, iter) {

net/mptcp/pm.c

1079

if (iter != subflow && mptcp_subflow_active(iter) &&

net/mptcp/pm.c

1080

iter->stale_count < active_max_loss_cnt) {

net/netfilter/ipvs/ip_vs_conn.c

1591

struct ip_vs_iter_state *iter = seq->private;

net/netfilter/ipvs/ip_vs_conn.c

1594

struct ip_vs_rht *t = iter->t;

net/netfilter/ipvs/ip_vs_conn.c

1601

for (idx = iter->bucket; idx < t->size; idx++) {

net/netfilter/ipvs/ip_vs_conn.c

1612

if (skip >= iter->skip_elems) {

net/netfilter/ipvs/ip_vs_conn.c

1613

iter->bucket = idx;

net/netfilter/ipvs/ip_vs_conn.c

1623

if (iter->gen != atomic_read(&ipvs->conn_tab_changes))

net/netfilter/ipvs/ip_vs_conn.c

1626

iter->skip_elems = 0;

net/netfilter/ipvs/ip_vs_conn.c

1629

iter->bucket = idx;

net/netfilter/ipvs/ip_vs_conn.c

1636

struct ip_vs_iter_state *iter = seq->private;

net/netfilter/ipvs/ip_vs_conn.c

1641

iter->gen = atomic_read(&ipvs->conn_tab_changes);

net/netfilter/ipvs/ip_vs_conn.c

1643

iter->t = rcu_dereference(ipvs->conn_tab);

net/netfilter/ipvs/ip_vs_conn.c

1645

iter->skip_elems = 0;

net/netfilter/ipvs/ip_vs_conn.c

1646

iter->bucket = 0;

net/netfilter/ipvs/ip_vs_conn.c

1655

struct ip_vs_iter_state *iter = seq->private;

net/netfilter/ipvs/ip_vs_conn.c

1664

t = iter->t;

net/netfilter/ipvs/ip_vs_conn.c

1675

iter->skip_elems++;

net/netfilter/ipvs/ip_vs_conn.c

1679

iter->skip_elems = 0;

net/netfilter/ipvs/ip_vs_conn.c

1680

iter->bucket++;

net/netfilter/ipvs/ip_vs_ctl.c

2899

struct ip_vs_iter *iter = seq->private;

net/netfilter/ipvs/ip_vs_ctl.c

2900

struct ip_vs_rht *t = iter->t;

net/netfilter/ipvs/ip_vs_ctl.c

2912

iter->bucket = idx;

net/netfilter/ipvs/ip_vs_ctl.c

2923

struct ip_vs_iter *iter = seq->private;

net/netfilter/ipvs/ip_vs_ctl.c

2928

iter->t = rcu_dereference(ipvs->svc_table);

net/netfilter/ipvs/ip_vs_ctl.c

2936

struct ip_vs_iter *iter;

net/netfilter/ipvs/ip_vs_ctl.c

2945

iter = seq->private;

net/netfilter/ipvs/ip_vs_ctl.c

2946

t = iter->t;

net/netfilter/ipvs/ip_vs_ctl.c

2957

while (++iter->bucket < t->size) {

net/netfilter/ipvs/ip_vs_ctl.c

2958

hlist_bl_for_each_entry_rcu(svc, e, &t->buckets[iter->bucket],

net/netfilter/nf_conntrack_core.c

2304

get_next_corpse(int (*iter)(struct nf_conn *i, void *data),

net/netfilter/nf_conntrack_core.c

2341

if (iter(ct, iter_data->data))

net/netfilter/nf_conntrack_core.c

2357

static void nf_ct_iterate_cleanup(int (*iter)(struct nf_conn *i, void *data),

net/netfilter/nf_conntrack_core.c

2366

while ((ct = get_next_corpse(iter, iter_data, &bucket)) != NULL) {

net/netfilter/nf_conntrack_core.c

2376

void nf_ct_iterate_cleanup_net(int (*iter)(struct nf_conn *i, void *data),

net/netfilter/nf_conntrack_core.c

2387

nf_ct_iterate_cleanup(iter, iter_data);

net/netfilter/nf_conntrack_core.c

2403

nf_ct_iterate_destroy(int (*iter)(struct nf_conn *i, void *data), void *data)

net/netfilter/nf_conntrack_core.c

2433

nf_ct_iterate_cleanup(iter, &iter_data);

net/netfilter/nf_conntrack_expect.c

582

void nf_ct_expect_iterate_destroy(bool (*iter)(struct nf_conntrack_expect *e, void *data),

net/netfilter/nf_conntrack_expect.c

595

if (iter(exp, data))

net/netfilter/nf_conntrack_expect.c

605

bool (*iter)(struct nf_conntrack_expect *e, void *data),

net/netfilter/nf_conntrack_expect.c

623

if (iter(exp, data))

net/netfilter/nf_conntrack_netlink.c

1593

struct nf_ct_iter_data iter = {

net/netfilter/nf_conntrack_netlink.c

1604

iter.data = filter;

net/netfilter/nf_conntrack_netlink.c

1607

nf_ct_iterate_cleanup_net(ctnetlink_flush_iterate, &iter);

net/netfilter/nf_flow_table_core.c

426

void (*iter)(struct nf_flowtable *flowtable,

net/netfilter/nf_flow_table_core.c

451

iter(flow_table, flow, data);

net/netfilter/nf_flow_table_xdp.c

102

hash_for_each_possible(nf_xdp_hashtable, iter, hnode, key) {

net/netfilter/nf_flow_table_xdp.c

103

if (key == iter->net_device_addr) {

net/netfilter/nf_flow_table_xdp.c

104

elem = iter;

net/netfilter/nf_flow_table_xdp.c

30

struct flow_offload_xdp *iter;

net/netfilter/nf_flow_table_xdp.c

32

hash_for_each_possible_rcu(nf_xdp_hashtable, iter, hnode, key) {

net/netfilter/nf_flow_table_xdp.c

33

if (key == iter->net_device_addr) {

net/netfilter/nf_flow_table_xdp.c

40

ft_elem = list_first_or_null_rcu(&iter->head,

net/netfilter/nf_flow_table_xdp.c

53

struct flow_offload_xdp *iter, *elem = NULL;

net/netfilter/nf_flow_table_xdp.c

65

hash_for_each_possible(nf_xdp_hashtable, iter, hnode, key) {

net/netfilter/nf_flow_table_xdp.c

66

if (key == iter->net_device_addr) {

net/netfilter/nf_flow_table_xdp.c

67

elem = iter;

net/netfilter/nf_flow_table_xdp.c

97

struct flow_offload_xdp *iter, *elem = NULL;

net/netfilter/nf_nat_masquerade.c

103

int (*iter)(struct nf_conn *i, void *data),

net/netfilter/nf_nat_masquerade.c

127

w->iter = iter;

net/netfilter/nf_nat_masquerade.c

18

int (*iter)(struct nf_conn *i, void *data);

net/netfilter/nf_nat_masquerade.c

87

nf_ct_iterate_cleanup_net(w->iter, &iter_data);

net/netfilter/nf_tables_api.c

4248

const struct nft_set_iter *iter,

net/netfilter/nf_tables_api.c

4256

if (!nft_set_elem_active(ext, iter->genmask))

net/netfilter/nf_tables_api.c

5843

const struct nft_set_iter *iter,

net/netfilter/nf_tables_api.c

5848

if (!nft_set_elem_active(ext, iter->genmask))

net/netfilter/nf_tables_api.c

5880

struct nft_set_iter iter = {

net/netfilter/nf_tables_api.c

5899

set->ops->walk(ctx, set, &iter);

net/netfilter/nf_tables_api.c

5900

if (!iter.err)

net/netfilter/nf_tables_api.c

5901

iter.err = nft_set_catchall_bind_check(ctx, set);

net/netfilter/nf_tables_api.c

5903

if (iter.err < 0)

net/netfilter/nf_tables_api.c

5904

return iter.err;

net/netfilter/nf_tables_api.c

5937

const struct nft_set_iter *iter,

net/netfilter/nf_tables_api.c

5943

if (nft_set_elem_active(ext, iter->genmask))

net/netfilter/nf_tables_api.c

5971

struct nft_set_iter iter = {

net/netfilter/nf_tables_api.c

5977

set->ops->walk(ctx, set, &iter);

net/netfilter/nf_tables_api.c

5978

WARN_ON_ONCE(iter.err);

net/netfilter/nf_tables_api.c

6227

struct nft_set_iter iter;

net/netfilter/nf_tables_api.c

6234

const struct nft_set_iter *iter,

net/netfilter/nf_tables_api.c

6240

if (!nft_set_elem_active(ext, iter->genmask))

net/netfilter/nf_tables_api.c

6246

args = container_of(iter, struct nft_set_dump_args, iter);

net/netfilter/nf_tables_api.c

6302

.iter = {

net/netfilter/nf_tables_api.c

6359

set->ops->walk(&dump_ctx->ctx, set, &args.iter);

net/netfilter/nf_tables_api.c

6361

if (!args.iter.err && args.iter.count == cb->args[0])

net/netfilter/nf_tables_api.c

6362

args.iter.err = nft_set_catchall_dump(net, skb, set,

net/netfilter/nf_tables_api.c

6367

if (dump_ctx->reset && args.iter.count > args.iter.skip)

net/netfilter/nf_tables_api.c

6369

args.iter.count - args.iter.skip);

net/netfilter/nf_tables_api.c

6373

if (args.iter.err && args.iter.err != -EMSGSIZE)

net/netfilter/nf_tables_api.c

6374

return args.iter.err;

net/netfilter/nf_tables_api.c

6375

if (args.iter.count == cb->args[0])

net/netfilter/nf_tables_api.c

6378

cb->args[0] = args.iter.count;

net/netfilter/nf_tables_api.c

7919

const struct nft_set_iter *iter,

net/netfilter/nf_tables_api.c

7925

if (!nft_set_elem_active(ext, iter->genmask))

net/netfilter/nf_tables_api.c

7990

struct nft_set_iter iter = {

net/netfilter/nf_tables_api.c

7996

set->ops->walk(ctx, set, &iter);

net/netfilter/nf_tables_api.c

7997

if (!iter.err)

net/netfilter/nf_tables_api.c

7998

iter.err = nft_set_catchall_flush(ctx, set);

net/netfilter/nf_tables_api.c

8000

return iter.err;

net/netfilter/nf_tables_api.c

834

const struct nft_set_iter *iter,

net/netfilter/nf_tables_api.c

839

if (!nft_set_elem_active(ext, iter->genmask))

net/netfilter/nf_tables_api.c

878

struct nft_set_iter iter = {

net/netfilter/nf_tables_api.c

884

set->ops->walk(ctx, set, &iter);

net/netfilter/nf_tables_api.c

885

WARN_ON_ONCE(iter.err);

net/netfilter/nft_lookup.c

249

struct nft_set_iter iter = {

net/netfilter/nft_lookup.c

259

priv->set->ops->walk(ctx, priv->set, &iter);

net/netfilter/nft_lookup.c

260

if (!iter.err)

net/netfilter/nft_lookup.c

261

iter.err = nft_set_catchall_validate(ctx, priv->set);

net/netfilter/nft_lookup.c

263

if (iter.err < 0)

net/netfilter/nft_lookup.c

264

return iter.err;

net/netfilter/nft_set_bitmap.c

224

struct nft_set_iter *iter)

net/netfilter/nft_set_bitmap.c

231

if (iter->count < iter->skip)

net/netfilter/nft_set_bitmap.c

234

iter->err = iter->fn(ctx, set, iter, &be->priv);

net/netfilter/nft_set_bitmap.c

236

if (iter->err < 0)

net/netfilter/nft_set_bitmap.c

239

iter->count++;

net/netfilter/nft_set_hash.c

268

struct nft_set_iter *iter)

net/netfilter/nft_set_hash.c

280

iter->err = PTR_ERR(he);

net/netfilter/nft_set_hash.c

287

if (iter->count < iter->skip)

net/netfilter/nft_set_hash.c

290

iter->err = iter->fn(ctx, set, iter, &he->priv);

net/netfilter/nft_set_hash.c

291

if (iter->err < 0)

net/netfilter/nft_set_hash.c

295

iter->count++;

net/netfilter/nft_set_hash.c

303

struct nft_set_iter *iter)

net/netfilter/nft_set_hash.c

320

iter->err = -EMLINK;

net/netfilter/nft_set_hash.c

339

iter->err = PTR_ERR(he);

net/netfilter/nft_set_hash.c

358

if (iter->err == 0) {

net/netfilter/nft_set_hash.c

359

iter->err = iter->fn(ctx, set, iter, &he->priv);

net/netfilter/nft_set_hash.c

360

if (iter->err == 0)

net/netfilter/nft_set_hash.c

361

iter->count++;

net/netfilter/nft_set_hash.c

373

struct nft_set_iter *iter)

net/netfilter/nft_set_hash.c

375

switch (iter->type) {

net/netfilter/nft_set_hash.c

379

WARN_ON_ONCE(iter->skip != 0);

net/netfilter/nft_set_hash.c

381

nft_rhash_walk_update(ctx, set, iter);

net/netfilter/nft_set_hash.c

384

nft_rhash_walk_ro(ctx, set, iter);

net/netfilter/nft_set_hash.c

387

iter->err = -EINVAL;

net/netfilter/nft_set_hash.c

752

struct nft_set_iter *iter)

net/netfilter/nft_set_hash.c

761

if (iter->count < iter->skip)

net/netfilter/nft_set_hash.c

764

iter->err = iter->fn(ctx, set, iter, &he->priv);

net/netfilter/nft_set_hash.c

765

if (iter->err < 0)

net/netfilter/nft_set_hash.c

768

iter->count++;

net/netfilter/nft_set_pipapo.c

2158

struct nft_set_iter *iter)

net/netfilter/nft_set_pipapo.c

2172

if (iter->count < iter->skip)

net/netfilter/nft_set_pipapo.c

2177

iter->err = iter->fn(ctx, set, iter, &e->priv);

net/netfilter/nft_set_pipapo.c

2178

if (iter->err < 0)

net/netfilter/nft_set_pipapo.c

2182

iter->count++;

net/netfilter/nft_set_pipapo.c

2196

struct nft_set_iter *iter)

net/netfilter/nft_set_pipapo.c

2201

switch (iter->type) {

net/netfilter/nft_set_pipapo.c

2205

iter->err = -ENOMEM;

net/netfilter/nft_set_pipapo.c

2208

nft_pipapo_do_walk(ctx, set, m, iter);

net/netfilter/nft_set_pipapo.c

2216

nft_pipapo_do_walk(ctx, set, m, iter);

net/netfilter/nft_set_pipapo.c

2221

nft_pipapo_do_walk(ctx, set, m, iter);

net/netfilter/nft_set_pipapo.c

2225

iter->err = -EINVAL;

net/netfilter/nft_set_rbtree.c

842

struct nft_set_iter *iter)

net/netfilter/nft_set_rbtree.c

851

if (iter->count < iter->skip)

net/netfilter/nft_set_rbtree.c

854

iter->err = iter->fn(ctx, set, iter, &rbe->priv);

net/netfilter/nft_set_rbtree.c

855

if (iter->err < 0)

net/netfilter/nft_set_rbtree.c

858

iter->count++;

net/netfilter/nft_set_rbtree.c

864

struct nft_set_iter *iter)

net/netfilter/nft_set_rbtree.c

868

switch (iter->type) {

net/netfilter/nft_set_rbtree.c

871

iter->err = -ENOMEM;

net/netfilter/nft_set_rbtree.c

878

nft_rbtree_do_walk(ctx, set, iter);

net/netfilter/nft_set_rbtree.c

882

nft_rbtree_do_walk(ctx, set, iter);

net/netfilter/nft_set_rbtree.c

886

iter->err = -EINVAL;

net/netlabel/netlabel_addrlist.c

101

list_for_each_entry_rcu(iter, head, list)

net/netlabel/netlabel_addrlist.c

102

if (iter->valid &&

net/netlabel/netlabel_addrlist.c

103

ipv6_masked_addr_cmp(&iter->addr, &iter->mask, addr) == 0)

net/netlabel/netlabel_addrlist.c

104

return iter;

net/netlabel/netlabel_addrlist.c

125

struct netlbl_af6list *iter;

net/netlabel/netlabel_addrlist.c

127

list_for_each_entry_rcu(iter, head, list)

net/netlabel/netlabel_addrlist.c

128

if (iter->valid &&

net/netlabel/netlabel_addrlist.c

129

ipv6_addr_equal(&iter->addr, addr) &&

net/netlabel/netlabel_addrlist.c

130

ipv6_addr_equal(&iter->mask, mask))

net/netlabel/netlabel_addrlist.c

131

return iter;

net/netlabel/netlabel_addrlist.c

150

struct netlbl_af4list *iter;

net/netlabel/netlabel_addrlist.c

152

iter = netlbl_af4list_search(entry->addr, head);

net/netlabel/netlabel_addrlist.c

153

if (iter != NULL &&

net/netlabel/netlabel_addrlist.c

154

iter->addr == entry->addr && iter->mask == entry->mask)

net/netlabel/netlabel_addrlist.c

161

list_for_each_entry_rcu(iter, head, list)

net/netlabel/netlabel_addrlist.c

162

if (iter->valid &&

net/netlabel/netlabel_addrlist.c

163

ntohl(entry->mask) > ntohl(iter->mask)) {

net/netlabel/netlabel_addrlist.c

165

iter->list.prev,

net/netlabel/netlabel_addrlist.c

166

&iter->list);

net/netlabel/netlabel_addrlist.c

187

struct netlbl_af6list *iter;

net/netlabel/netlabel_addrlist.c

189

iter = netlbl_af6list_search(&entry->addr, head);

net/netlabel/netlabel_addrlist.c

190

if (iter != NULL &&

net/netlabel/netlabel_addrlist.c

191

ipv6_addr_equal(&iter->addr, &entry->addr) &&

net/netlabel/netlabel_addrlist.c

192

ipv6_addr_equal(&iter->mask, &entry->mask))

net/netlabel/netlabel_addrlist.c

199

list_for_each_entry_rcu(iter, head, list)

net/netlabel/netlabel_addrlist.c

200

if (iter->valid &&

net/netlabel/netlabel_addrlist.c

201

ipv6_addr_cmp(&entry->mask, &iter->mask) > 0) {

net/netlabel/netlabel_addrlist.c

203

iter->list.prev,

net/netlabel/netlabel_addrlist.c

204

&iter->list);

net/netlabel/netlabel_addrlist.c

357

int iter = -1;

net/netlabel/netlabel_addrlist.c

358

while (ntohl(mask->s6_addr32[++iter]) == 0xffffffff)

net/netlabel/netlabel_addrlist.c

360

mask_val = ntohl(mask->s6_addr32[iter]);

net/netlabel/netlabel_addrlist.c

49

struct netlbl_af4list *iter;

net/netlabel/netlabel_addrlist.c

51

list_for_each_entry_rcu(iter, head, list)

net/netlabel/netlabel_addrlist.c

52

if (iter->valid && (addr & iter->mask) == iter->addr)

net/netlabel/netlabel_addrlist.c

53

return iter;

net/netlabel/netlabel_addrlist.c

74

struct netlbl_af4list *iter;

net/netlabel/netlabel_addrlist.c

76

list_for_each_entry_rcu(iter, head, list)

net/netlabel/netlabel_addrlist.c

77

if (iter->valid && iter->addr == addr && iter->mask == mask)

net/netlabel/netlabel_addrlist.c

78

return iter;

net/netlabel/netlabel_addrlist.c

99

struct netlbl_af6list *iter;

net/netlabel/netlabel_addrlist.h

149

#define netlbl_af6list_foreach(iter, head) \

net/netlabel/netlabel_addrlist.h

150

for (iter = __af6list_valid((head)->next, head); \

net/netlabel/netlabel_addrlist.h

151

&iter->list != (head); \

net/netlabel/netlabel_addrlist.h

152

iter = __af6list_valid(iter->list.next, head))

net/netlabel/netlabel_addrlist.h

154

#define netlbl_af6list_foreach_rcu(iter, head) \

net/netlabel/netlabel_addrlist.h

155

for (iter = __af6list_valid_rcu((head)->next, head); \

net/netlabel/netlabel_addrlist.h

156

&iter->list != (head); \

net/netlabel/netlabel_addrlist.h

157

iter = __af6list_valid_rcu(iter->list.next, head))

net/netlabel/netlabel_addrlist.h

159

#define netlbl_af6list_foreach_safe(iter, tmp, head) \

net/netlabel/netlabel_addrlist.h

160

for (iter = __af6list_valid((head)->next, head), \

net/netlabel/netlabel_addrlist.h

161

tmp = __af6list_valid(iter->list.next, head); \

net/netlabel/netlabel_addrlist.h

162

&iter->list != (head); \

net/netlabel/netlabel_addrlist.h

163

iter = tmp, tmp = __af6list_valid(iter->list.next, head))

net/netlabel/netlabel_addrlist.h

82

#define netlbl_af4list_foreach(iter, head) \

net/netlabel/netlabel_addrlist.h

83

for (iter = __af4list_valid((head)->next, head); \

net/netlabel/netlabel_addrlist.h

84

&iter->list != (head); \

net/netlabel/netlabel_addrlist.h

85

iter = __af4list_valid(iter->list.next, head))

net/netlabel/netlabel_addrlist.h

87

#define netlbl_af4list_foreach_rcu(iter, head) \

net/netlabel/netlabel_addrlist.h

88

for (iter = __af4list_valid_rcu((head)->next, head); \

net/netlabel/netlabel_addrlist.h

89

&iter->list != (head); \

net/netlabel/netlabel_addrlist.h

90

iter = __af4list_valid_rcu(iter->list.next, head))

net/netlabel/netlabel_addrlist.h

92

#define netlbl_af4list_foreach_safe(iter, tmp, head) \

net/netlabel/netlabel_addrlist.h

93

for (iter = __af4list_valid((head)->next, head), \

net/netlabel/netlabel_addrlist.h

94

tmp = __af4list_valid(iter->list.next, head); \

net/netlabel/netlabel_addrlist.h

95

&iter->list != (head); \

net/netlabel/netlabel_addrlist.h

96

iter = tmp, tmp = __af4list_valid(iter->list.next, head))

net/netlabel/netlabel_cipso_v4.c

100

while (iter < CIPSO_V4_TAG_MAXCNT)

net/netlabel/netlabel_cipso_v4.c

101

doi_def->tags[iter++] = CIPSO_V4_TAG_INVALID;

net/netlabel/netlabel_cipso_v4.c

130

u32 iter;

net/netlabel/netlabel_cipso_v4.c

202

for (iter = 0; iter < doi_def->map.std->lvl.local_size; iter++)

net/netlabel/netlabel_cipso_v4.c

203

doi_def->map.std->lvl.local[iter] = CIPSO_V4_INV_LVL;

net/netlabel/netlabel_cipso_v4.c

204

for (iter = 0; iter < doi_def->map.std->lvl.cipso_size; iter++)

net/netlabel/netlabel_cipso_v4.c

205

doi_def->map.std->lvl.cipso[iter] = CIPSO_V4_INV_LVL;

net/netlabel/netlabel_cipso_v4.c

279

for (iter = 0; iter < doi_def->map.std->cat.local_size; iter++)

net/netlabel/netlabel_cipso_v4.c

280

doi_def->map.std->cat.local[iter] = CIPSO_V4_INV_CAT;

net/netlabel/netlabel_cipso_v4.c

281

for (iter = 0; iter < doi_def->map.std->cat.cipso_size; iter++)

net/netlabel/netlabel_cipso_v4.c

282

doi_def->map.std->cat.cipso[iter] = CIPSO_V4_INV_CAT;

net/netlabel/netlabel_cipso_v4.c

458

u32 iter;

net/netlabel/netlabel_cipso_v4.c

496

for (iter = 0;

net/netlabel/netlabel_cipso_v4.c

497

iter < CIPSO_V4_TAG_MAXCNT &&

net/netlabel/netlabel_cipso_v4.c

498

doi_def->tags[iter] != CIPSO_V4_TAG_INVALID;

net/netlabel/netlabel_cipso_v4.c

499

iter++) {

net/netlabel/netlabel_cipso_v4.c

502

doi_def->tags[iter]);

net/netlabel/netlabel_cipso_v4.c

516

for (iter = 0;

net/netlabel/netlabel_cipso_v4.c

517

iter < doi_def->map.std->lvl.local_size;

net/netlabel/netlabel_cipso_v4.c

518

iter++) {

net/netlabel/netlabel_cipso_v4.c

519

if (doi_def->map.std->lvl.local[iter] ==

net/netlabel/netlabel_cipso_v4.c

531

iter);

net/netlabel/netlabel_cipso_v4.c

536

doi_def->map.std->lvl.local[iter]);

net/netlabel/netlabel_cipso_v4.c

549

for (iter = 0;

net/netlabel/netlabel_cipso_v4.c

550

iter < doi_def->map.std->cat.local_size;

net/netlabel/netlabel_cipso_v4.c

551

iter++) {

net/netlabel/netlabel_cipso_v4.c

552

if (doi_def->map.std->cat.local[iter] ==

net/netlabel/netlabel_cipso_v4.c

564

iter);

net/netlabel/netlabel_cipso_v4.c

569

doi_def->map.std->cat.local[iter]);

net/netlabel/netlabel_cipso_v4.c

84

u32 iter = 0;

net/netlabel/netlabel_cipso_v4.c

96

if (iter >= CIPSO_V4_TAG_MAXCNT)

net/netlabel/netlabel_cipso_v4.c

98

doi_def->tags[iter++] = nla_get_u8(nla);

net/netlabel/netlabel_domainhash.c

107

u32 iter;

net/netlabel/netlabel_domainhash.c

114

for (iter = 0, val = 0, len = strlen(key); iter < len; iter++)

net/netlabel/netlabel_domainhash.c

115

val = (val << 4 | (val >> (8 * sizeof(u32) - 4))) ^ key[iter];

net/netlabel/netlabel_domainhash.c

142

struct netlbl_dom_map *iter;

net/netlabel/netlabel_domainhash.c

147

list_for_each_entry_rcu(iter, bkt_list, list,

net/netlabel/netlabel_domainhash.c

149

if (iter->valid &&

net/netlabel/netlabel_domainhash.c

150

netlbl_family_match(iter->family, family) &&

net/netlabel/netlabel_domainhash.c

151

strcmp(iter->domain, domain) == 0)

net/netlabel/netlabel_domainhash.c

152

return iter;

net/netlabel/netlabel_domainhash.c

364

u32 iter;

net/netlabel/netlabel_domainhash.c

379

for (iter = 0; iter < hsh_tbl->size; iter++)

net/netlabel/netlabel_domainhash.c

380

INIT_LIST_HEAD(&hsh_tbl->tbl[iter]);

net/netlabel/netlabel_domainhash.h

43

#define netlbl_domhsh_addr4_entry(iter) \

net/netlabel/netlabel_domainhash.h

44

container_of(iter, struct netlbl_domaddr4_map, list)

net/netlabel/netlabel_domainhash.h

50

#define netlbl_domhsh_addr6_entry(iter) \

net/netlabel/netlabel_domainhash.h

51

container_of(iter, struct netlbl_domaddr6_map, list)

net/netlabel/netlabel_kapi.c

559

struct netlbl_lsm_catmap *iter = *catmap;

net/netlabel/netlabel_kapi.c

562

if (iter == NULL)

net/netlabel/netlabel_kapi.c

564

if (offset < iter->startbit)

net/netlabel/netlabel_kapi.c

566

while (iter && offset >= (iter->startbit + NETLBL_CATMAP_SIZE)) {

net/netlabel/netlabel_kapi.c

567

prev = iter;

net/netlabel/netlabel_kapi.c

568

iter = iter->next;

net/netlabel/netlabel_kapi.c

570

if (iter == NULL || offset < iter->startbit)

net/netlabel/netlabel_kapi.c

573

return iter;

net/netlabel/netlabel_kapi.c

577

return iter;

net/netlabel/netlabel_kapi.c

582

iter = netlbl_catmap_alloc(gfp_flags);

net/netlabel/netlabel_kapi.c

583

if (iter == NULL)

net/netlabel/netlabel_kapi.c

585

iter->startbit = offset & ~(NETLBL_CATMAP_SIZE - 1);

net/netlabel/netlabel_kapi.c

588

iter->next = *catmap;

net/netlabel/netlabel_kapi.c

589

*catmap = iter;

net/netlabel/netlabel_kapi.c

591

iter->next = prev->next;

net/netlabel/netlabel_kapi.c

592

prev->next = iter;

net/netlabel/netlabel_kapi.c

595

return iter;

net/netlabel/netlabel_kapi.c

610

struct netlbl_lsm_catmap *iter;

net/netlabel/netlabel_kapi.c

615

iter = _netlbl_catmap_getnode(&catmap, offset, _CM_F_WALK, 0);

net/netlabel/netlabel_kapi.c

616

if (iter == NULL)

net/netlabel/netlabel_kapi.c

618

if (offset > iter->startbit) {

net/netlabel/netlabel_kapi.c

619

offset -= iter->startbit;

net/netlabel/netlabel_kapi.c

626

bitmap = iter->bitmap[idx] >> bit;

net/netlabel/netlabel_kapi.c

634

return iter->startbit +

net/netlabel/netlabel_kapi.c

638

if (iter->next != NULL) {

net/netlabel/netlabel_kapi.c

639

iter = iter->next;

net/netlabel/netlabel_kapi.c

644

bitmap = iter->bitmap[idx];

net/netlabel/netlabel_kapi.c

665

struct netlbl_lsm_catmap *iter;

net/netlabel/netlabel_kapi.c

672

iter = _netlbl_catmap_getnode(&catmap, offset, _CM_F_WALK, 0);

net/netlabel/netlabel_kapi.c

673

if (iter == NULL)

net/netlabel/netlabel_kapi.c

675

if (offset > iter->startbit) {

net/netlabel/netlabel_kapi.c

676

offset -= iter->startbit;

net/netlabel/netlabel_kapi.c

686

bitmap = iter->bitmap[idx];

net/netlabel/netlabel_kapi.c

695

return iter->startbit +

net/netlabel/netlabel_kapi.c

698

if (iter->next == NULL)

net/netlabel/netlabel_kapi.c

699

return iter->startbit + NETLBL_CATMAP_SIZE - 1;

net/netlabel/netlabel_kapi.c

700

prev = iter;

net/netlabel/netlabel_kapi.c

701

iter = iter->next;

net/netlabel/netlabel_kapi.c

729

struct netlbl_lsm_catmap *iter;

net/netlabel/netlabel_kapi.c

747

iter = _netlbl_catmap_getnode(&catmap, off, _CM_F_WALK, 0);

net/netlabel/netlabel_kapi.c

748

if (iter == NULL) {

net/netlabel/netlabel_kapi.c

753

if (off < iter->startbit) {

net/netlabel/netlabel_kapi.c

754

*offset = iter->startbit;

net/netlabel/netlabel_kapi.c

757

off -= iter->startbit;

net/netlabel/netlabel_kapi.c

759

*bitmap = iter->bitmap[idx] >> (off % NETLBL_CATMAP_MAPSIZE);

net/netlabel/netlabel_kapi.c

779

struct netlbl_lsm_catmap *iter;

net/netlabel/netlabel_kapi.c

782

iter = _netlbl_catmap_getnode(catmap, bit, _CM_F_ALLOC, flags);

net/netlabel/netlabel_kapi.c

783

if (iter == NULL)

net/netlabel/netlabel_kapi.c

786

bit -= iter->startbit;

net/netlabel/netlabel_kapi.c

788

iter->bitmap[idx] |= NETLBL_CATMAP_BIT << (bit % NETLBL_CATMAP_MAPSIZE);

net/netlabel/netlabel_kapi.c

847

struct netlbl_lsm_catmap *iter;

net/netlabel/netlabel_kapi.c

854

iter = _netlbl_catmap_getnode(catmap, offset, _CM_F_ALLOC, flags);

net/netlabel/netlabel_kapi.c

855

if (iter == NULL)

net/netlabel/netlabel_kapi.c

858

offset -= iter->startbit;

net/netlabel/netlabel_kapi.c

860

iter->bitmap[idx] |= (u64)bitmap

net/netlabel/netlabel_unlabeled.c

1400

u32 iter;

net/netlabel/netlabel_unlabeled.c

1415

for (iter = 0; iter < hsh_tbl->size; iter++)

net/netlabel/netlabel_unlabeled.c

1416

INIT_LIST_HEAD(&hsh_tbl->tbl[iter]);

net/netlabel/netlabel_unlabeled.c

206

struct netlbl_unlhsh_iface *iter;

net/netlabel/netlabel_unlabeled.c

210

list_for_each_entry_rcu(iter, bkt_list, list,

net/netlabel/netlabel_unlabeled.c

212

if (iter->valid && iter->ifindex == ifindex)

net/netlabel/netlabel_unlabeled.c

213

return iter;

net/netlabel/netlabel_unlabeled.c

66

#define netlbl_unlhsh_addr4_entry(iter) \

net/netlabel/netlabel_unlabeled.c

67

container_of(iter, struct netlbl_unlhsh_addr4, list)

net/netlabel/netlabel_unlabeled.c

74

#define netlbl_unlhsh_addr6_entry(iter) \

net/netlabel/netlabel_unlabeled.c

75

container_of(iter, struct netlbl_unlhsh_addr6, list)

net/netlink/af_netlink.c

2623

static void netlink_walk_start(struct nl_seq_iter *iter)

net/netlink/af_netlink.c

2625

rhashtable_walk_enter(&nl_table[iter->link].hash, &iter->hti);

net/netlink/af_netlink.c

2626

rhashtable_walk_start(&iter->hti);

net/netlink/af_netlink.c

2629

static void netlink_walk_stop(struct nl_seq_iter *iter)

net/netlink/af_netlink.c

2631

rhashtable_walk_stop(&iter->hti);

net/netlink/af_netlink.c

2632

rhashtable_walk_exit(&iter->hti);

net/netlink/af_netlink.c

2637

struct nl_seq_iter *iter = seq->private;

net/netlink/af_netlink.c

2642

nlk = rhashtable_walk_next(&iter->hti);

net/netlink/af_netlink.c

2654

netlink_walk_stop(iter);

net/netlink/af_netlink.c

2655

if (++iter->link >= MAX_LINKS)

net/netlink/af_netlink.c

2658

netlink_walk_start(iter);

net/netlink/af_netlink.c

2668

struct nl_seq_iter *iter = seq->private;

net/netlink/af_netlink.c

2672

iter->link = 0;

net/netlink/af_netlink.c

2674

netlink_walk_start(iter);

net/netlink/af_netlink.c

2690

struct nl_seq_iter *iter = seq->private;

net/netlink/af_netlink.c

2692

if (iter->link >= MAX_LINKS)

net/netlink/af_netlink.c

2695

netlink_walk_stop(iter);

net/netlink/genetlink.c

208

static void genl_op_from_split(struct genl_op_iter *iter)

net/netlink/genetlink.c

210

const struct genl_family *family = iter->family;

net/netlink/genetlink.c

213

i = iter->entry_idx - family->n_ops - family->n_small_ops;

net/netlink/genetlink.c

216

iter->doit = family->split_ops[i + cnt];

net/netlink/genetlink.c

217

genl_op_fill_in_reject_policy_split(family, &iter->doit);

net/netlink/genetlink.c

220

memset(&iter->doit, 0, sizeof(iter->doit));

net/netlink/genetlink.c

225

(!cnt || family->split_ops[i + cnt].cmd == iter->doit.cmd)) {

net/netlink/genetlink.c

226

iter->dumpit = family->split_ops[i + cnt];

net/netlink/genetlink.c

227

genl_op_fill_in_reject_policy_split(family, &iter->dumpit);

net/netlink/genetlink.c

230

memset(&iter->dumpit, 0, sizeof(iter->dumpit));

net/netlink/genetlink.c

234

iter->entry_idx += cnt;

net/netlink/genetlink.c

332

genl_op_iter_init(const struct genl_family *family, struct genl_op_iter *iter)

net/netlink/genetlink.c

334

iter->family = family;

net/netlink/genetlink.c

335

iter->cmd_idx = 0;

net/netlink/genetlink.c

336

iter->entry_idx = 0;

net/netlink/genetlink.c

338

iter->flags = 0;

net/netlink/genetlink.c

340

return iter->family->n_ops +

net/netlink/genetlink.c

341

iter->family->n_small_ops +

net/netlink/genetlink.c

342

iter->family->n_split_ops;

net/netlink/genetlink.c

345

static bool genl_op_iter_next(struct genl_op_iter *iter)

net/netlink/genetlink.c

347

const struct genl_family *family = iter->family;

net/netlink/genetlink.c

351

if (iter->entry_idx < family->n_ops) {

net/netlink/genetlink.c

352

genl_op_from_full(family, iter->entry_idx, &op);

net/netlink/genetlink.c

353

} else if (iter->entry_idx < family->n_ops + family->n_small_ops) {

net/netlink/genetlink.c

354

genl_op_from_small(family, iter->entry_idx - family->n_ops,

net/netlink/genetlink.c

356

} else if (iter->entry_idx <

net/netlink/genetlink.c

360

genl_op_from_split(iter);

net/netlink/genetlink.c

365

iter->cmd_idx++;

net/netlink/genetlink.c

368

iter->entry_idx++;

net/netlink/genetlink.c

370

genl_cmd_full_to_split(&iter->doit, family,

net/netlink/genetlink.c

372

genl_cmd_full_to_split(&iter->dumpit, family,

net/netlink/genetlink.c

376

iter->cmd = iter->doit.cmd | iter->dumpit.cmd;

net/netlink/genetlink.c

377

iter->flags = iter->doit.flags | iter->dumpit.flags;

net/netlink/genetlink.c

388

static unsigned int genl_op_iter_idx(struct genl_op_iter *iter)

net/netlink/genetlink.c

390

return iter->cmd_idx;

net/nfc/netlink.c

1367

struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0];

net/nfc/netlink.c

1371

if (!iter) {

net/nfc/netlink.c

1373

iter = kmalloc_obj(struct class_dev_iter);

net/nfc/netlink.c

1374

if (!iter)

net/nfc/netlink.c

1376

cb->args[0] = (long) iter;

net/nfc/netlink.c

1384

nfc_device_iter_init(iter);

net/nfc/netlink.c

1385

dev = nfc_device_iter_next(iter);

net/nfc/netlink.c

1396

dev = nfc_device_iter_next(iter);

net/nfc/netlink.c

1408

struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0];

net/nfc/netlink.c

1410

if (iter) {

net/nfc/netlink.c

1411

nfc_device_iter_exit(iter);

net/nfc/netlink.c

1412

kfree(iter);

net/nfc/netlink.c

1837

struct class_dev_iter iter;

net/nfc/netlink.c

1844

nfc_device_iter_init(&iter);

net/nfc/netlink.c

1845

dev = nfc_device_iter_next(&iter);

net/nfc/netlink.c

1857

dev = nfc_device_iter_next(&iter);

net/nfc/netlink.c

1860

nfc_device_iter_exit(&iter);

net/nfc/netlink.c

601

struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0];

net/nfc/netlink.c

605

if (!iter) {

net/nfc/netlink.c

607

iter = kmalloc_obj(struct class_dev_iter);

net/nfc/netlink.c

608

if (!iter)

net/nfc/netlink.c

610

cb->args[0] = (long) iter;

net/nfc/netlink.c

618

nfc_device_iter_init(iter);

net/nfc/netlink.c

619

dev = nfc_device_iter_next(iter);

net/nfc/netlink.c

630

dev = nfc_device_iter_next(iter);

net/nfc/netlink.c

642

struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0];

net/nfc/netlink.c

644

if (iter) {

net/nfc/netlink.c

645

nfc_device_iter_exit(iter);

net/nfc/netlink.c

646

kfree(iter);

net/nfc/nfc.h

106

static inline void nfc_device_iter_init(struct class_dev_iter *iter)

net/nfc/nfc.h

108

class_dev_iter_init(iter, &nfc_class, NULL, NULL);

net/nfc/nfc.h

111

static inline struct nfc_dev *nfc_device_iter_next(struct class_dev_iter *iter)

net/nfc/nfc.h

113

struct device *d = class_dev_iter_next(iter);

net/nfc/nfc.h

120

static inline void nfc_device_iter_exit(struct class_dev_iter *iter)

net/nfc/nfc.h

122

class_dev_iter_exit(iter);

net/qrtr/af_qrtr.c

171

struct radix_tree_iter iter;

net/qrtr/af_qrtr.c

181

radix_tree_for_each_slot(slot, &qrtr_nodes, &iter, 0) {

net/qrtr/af_qrtr.c

183

radix_tree_iter_delete(&qrtr_nodes, &iter, slot);

net/qrtr/af_qrtr.c

621

struct radix_tree_iter iter;

net/qrtr/af_qrtr.c

635

radix_tree_for_each_slot(slot, &qrtr_nodes, &iter, 0) {

net/qrtr/af_qrtr.c

638

src.sq_node = iter.index;

net/rds/af_rds.c

736

struct rds_info_iterator *iter,

net/rds/af_rds.c

762

rds_inc_info_copy(inc, iter,

net/rds/af_rds.c

779

struct rds_info_iterator *iter,

net/rds/af_rds.c

800

rds6_inc_info_copy(inc, iter, &inc->i_saddr,

net/rds/af_rds.c

815

struct rds_info_iterator *iter,

net/rds/af_rds.c

857

rds_info_copy(iter, &sinfo, sizeof(sinfo));

net/rds/af_rds.c

875

struct rds_info_iterator *iter,

net/rds/af_rds.c

912

rds_info_copy(iter, &sinfo6, sizeof(sinfo6));

net/rds/connection.c

554

struct rds_info_iterator *iter,

net/rds/connection.c

559

rds6_inc_info_copy(inc, iter, saddr, daddr, flip);

net/rds/connection.c

562

rds_inc_info_copy(inc, iter, *(__be32 *)saddr,

net/rds/connection.c

567

struct rds_info_iterator *iter,

net/rds/connection.c

617

iter,

net/rds/connection.c

637

struct rds_info_iterator *iter,

net/rds/connection.c

641

rds_conn_message_info_cmn(sock, len, iter, lens, want_send, false);

net/rds/connection.c

646

struct rds_info_iterator *iter,

net/rds/connection.c

650

rds_conn_message_info_cmn(sock, len, iter, lens, want_send, true);

net/rds/connection.c

655

struct rds_info_iterator *iter,

net/rds/connection.c

658

rds_conn_message_info(sock, len, iter, lens, 1);

net/rds/connection.c

663

struct rds_info_iterator *iter,

net/rds/connection.c

666

rds6_conn_message_info(sock, len, iter, lens, 1);

net/rds/connection.c

672

struct rds_info_iterator *iter,

net/rds/connection.c

675

rds_conn_message_info(sock, len, iter, lens, 0);

net/rds/connection.c

681

struct rds_info_iterator *iter,

net/rds/connection.c

684

rds6_conn_message_info(sock, len, iter, lens, 0);

net/rds/connection.c

689

struct rds_info_iterator *iter,

net/rds/connection.c

727

rds_info_copy(iter, buffer, item_len);

net/rds/connection.c

738

struct rds_info_iterator *iter,

net/rds/connection.c

789

rds_info_copy(iter, buffer, item_len);

net/rds/connection.c

856

struct rds_info_iterator *iter,

net/rds/connection.c

861

rds_walk_conn_path_info(sock, len, iter, lens,

net/rds/connection.c

869

struct rds_info_iterator *iter,

net/rds/connection.c

874

rds_walk_conn_path_info(sock, len, iter, lens,

net/rds/ib.c

368

struct rds_info_iterator *iter,

net/rds/ib.c

373

rds_for_each_conn_info(sock, len, iter, lens,

net/rds/ib.c

382

struct rds_info_iterator *iter,

net/rds/ib.c

387

rds_for_each_conn_info(sock, len, iter, lens,

net/rds/ib.h

442

unsigned int rds_ib_stats_info_copy(struct rds_info_iterator *iter,

net/rds/ib_rdma.c

439

int iter = 0;

net/rds/ib_rdma.c

451

if (++iter > 2) {

net/rds/ib_stats.c

103

rds_stats_info_copy(iter, (uint64_t *)&stats, rds_ib_stat_names,

net/rds/ib_stats.c

84

unsigned int rds_ib_stats_info_copy(struct rds_info_iterator *iter,

net/rds/info.c

105

void rds_info_iter_unmap(struct rds_info_iterator *iter)

net/rds/info.c

107

if (iter->addr) {

net/rds/info.c

108

kunmap_atomic(iter->addr);

net/rds/info.c

109

iter->addr = NULL;

net/rds/info.c

116

void rds_info_copy(struct rds_info_iterator *iter, void *data,

net/rds/info.c

122

if (!iter->addr)

net/rds/info.c

123

iter->addr = kmap_atomic(*iter->pages);

net/rds/info.c

125

this = min(bytes, PAGE_SIZE - iter->offset);

net/rds/info.c

128

"bytes %lu\n", *iter->pages, iter->addr,

net/rds/info.c

129

iter->offset, this, data, bytes);

net/rds/info.c

131

memcpy(iter->addr + iter->offset, data, this);

net/rds/info.c

135

iter->offset += this;

net/rds/info.c

137

if (iter->offset == PAGE_SIZE) {

net/rds/info.c

138

kunmap_atomic(iter->addr);

net/rds/info.c

139

iter->addr = NULL;

net/rds/info.c

140

iter->offset = 0;

net/rds/info.c

141

iter->pages++;

net/rds/info.c

159

struct rds_info_iterator iter;

net/rds/info.c

223

iter.pages = pages;

net/rds/info.c

224

iter.addr = NULL;

net/rds/info.c

225

iter.offset = offset0;

net/rds/info.c

227

func(sock, len, &iter, &lens);

net/rds/info.c

232

rds_info_iter_unmap(&iter);

net/rds/info.h

19

struct rds_info_iterator *iter,

net/rds/info.h

25

void rds_info_copy(struct rds_info_iterator *iter, void *data,

net/rds/info.h

27

void rds_info_iter_unmap(struct rds_info_iterator *iter);

net/rds/rds.h

1008

void rds_stats_info_copy(struct rds_info_iterator *iter,

net/rds/rds.h

1046

unsigned int rds_trans_stats_info_copy(struct rds_info_iterator *iter,

net/rds/rds.h

598

unsigned int (*stats_info_copy)(struct rds_info_iterator *iter,

net/rds/rds.h

817

struct rds_info_iterator *iter,

net/rds/rds.h

937

struct rds_info_iterator *iter,

net/rds/rds.h

940

struct rds_info_iterator *iter,

net/rds/recv.c

835

struct rds_info_iterator *iter,

net/rds/recv.c

858

rds_info_copy(iter, &minfo, sizeof(minfo));

net/rds/recv.c

863

struct rds_info_iterator *iter,

net/rds/recv.c

887

rds_info_copy(iter, &minfo6, sizeof(minfo6));

net/rds/stats.c

112

struct rds_info_iterator *iter,

net/rds/stats.c

136

rds_stats_info_copy(iter, (uint64_t *)&stats, rds_stat_names,

net/rds/stats.c

142

lens->nr = rds_trans_stats_info_copy(iter, avail) +

net/rds/stats.c

85

void rds_stats_info_copy(struct rds_info_iterator *iter,

net/rds/stats.c

96

rds_info_copy(iter, &ctr, sizeof(ctr));

net/rds/tcp.c

220

struct rds_info_iterator *iter,

net/rds/tcp.c

267

rds_info_copy(iter, &tsinfo, sizeof(tsinfo));

net/rds/tcp.c

285

struct rds_info_iterator *iter,

net/rds/tcp.c

328

rds_info_copy(iter, &tsinfo6, sizeof(tsinfo6));

net/rds/tcp.h

117

unsigned int rds_tcp_stats_info_copy(struct rds_info_iterator *iter,

net/rds/tcp_stats.c

51

unsigned int rds_tcp_stats_info_copy(struct rds_info_iterator *iter,

net/rds/tcp_stats.c

70

rds_stats_info_copy(iter, (uint64_t *)&stats, rds_tcp_stat_names,

net/rds/transport.c

144

unsigned int rds_trans_stats_info_copy(struct rds_info_iterator *iter,

net/rds/transport.c

153

rds_info_iter_unmap(iter);

net/rds/transport.c

161

part = trans->stats_info_copy(iter, avail);

net/rxrpc/recvmsg.c

280

struct msghdr *msg, struct iov_iter *iter,

net/rxrpc/recvmsg.c

349

copy, iter);

net/rxrpc/recvmsg.c

645

struct iov_iter *iter, size_t *_len,

net/rxrpc/recvmsg.c

655

ret = rxrpc_recvmsg_data(sock, call, NULL, iter, *_len, 0, &offset);

net/rxrpc/recvmsg.c

667

if (iov_iter_count(iter) > 0)

net/rxrpc/recvmsg.c

685

_leave(" = %d [%zu,%d]", ret, iov_iter_count(iter), *_abort);

net/rxrpc/recvmsg.c

705

if (iov_iter_count(iter) > 0)

net/rxrpc/rxperf.c

166

iov_iter_kvec(&call->iter, READ, call->kvec, 1, call->iov_len);

net/rxrpc/rxperf.c

364

ret = rxrpc_kernel_recv_data(rxperf_socket, call->rxcall, &call->iter,

net/rxrpc/rxperf.c

368

iov_iter_count(&call->iter), call->iov_len, want_more, ret);

net/rxrpc/rxperf.c

449

iov_iter_kvec(&call->iter, READ, call->kvec, 1, call->iov_len);

net/rxrpc/rxperf.c

482

iov_iter_discard(&call->iter, READ, call->req_len);

net/rxrpc/rxperf.c

494

iov_iter_kvec(&call->iter, READ, call->kvec, 1, call->iov_len);

net/rxrpc/rxperf.c

50

struct iov_iter iter;

net/sched/cls_api.c

201

struct tcf_proto *iter;

net/sched/cls_api.c

205

hash_for_each_possible_rcu(chain->block->proto_destroy_ht, iter,

net/sched/cls_api.c

207

if (tcf_proto_cmp(tp, iter)) {

net/sctp/proc.c

205

struct sctp_ht_iter *iter = seq->private;

net/sctp/proc.c

207

sctp_transport_walk_start(&iter->hti);

net/sctp/proc.c

209

return sctp_transport_get_idx(seq_file_net(seq), &iter->hti, *pos);

net/sctp/proc.c

214

struct sctp_ht_iter *iter = seq->private;

net/sctp/proc.c

222

sctp_transport_walk_stop(&iter->hti);

net/sctp/proc.c

227

struct sctp_ht_iter *iter = seq->private;

net/sctp/proc.c

237

return sctp_transport_get_next(seq_file_net(seq), &iter->hti);

net/sctp/socket.c

5315

void sctp_transport_walk_start(struct rhashtable_iter *iter) __acquires(RCU)

net/sctp/socket.c

5317

rhltable_walk_enter(&sctp_transport_hashtable, iter);

net/sctp/socket.c

5319

rhashtable_walk_start(iter);

net/sctp/socket.c

5322

void sctp_transport_walk_stop(struct rhashtable_iter *iter) __releases(RCU)

net/sctp/socket.c

5324

rhashtable_walk_stop(iter);

net/sctp/socket.c

5325

rhashtable_walk_exit(iter);

net/sctp/socket.c

5329

struct rhashtable_iter *iter)

net/sctp/socket.c

5333

t = rhashtable_walk_next(iter);

net/sctp/socket.c

5334

for (; t; t = rhashtable_walk_next(iter)) {

net/sctp/socket.c

5355

struct rhashtable_iter *iter,

net/sctp/socket.c

5363

while ((t = sctp_transport_get_next(net, iter)) && !IS_ERR(t)) {

net/sctp/tsnmap.c

143

struct sctp_tsnmap_iter *iter)

net/sctp/tsnmap.c

146

iter->start = map->cumulative_tsn_ack_point + 1;

net/sctp/tsnmap.c

153

struct sctp_tsnmap_iter *iter,

net/sctp/tsnmap.c

160

if (TSN_lte(map->max_tsn_seen, iter->start))

net/sctp/tsnmap.c

163

offset = iter->start - map->base_tsn;

net/sctp/tsnmap.c

182

iter->start = map->cumulative_tsn_ack_point + *end + 1;

net/sctp/tsnmap.c

320

struct sctp_tsnmap_iter iter;

net/sctp/tsnmap.c

326

sctp_tsnmap_iter_init(map, &iter);

net/sctp/tsnmap.c

327

while (sctp_tsnmap_next_gap_ack(map, &iter,

net/sunrpc/xprtrdma/svc_rdma_rw.c

153

struct bvec_iter iter = {

net/sunrpc/xprtrdma/svc_rdma_rw.c

161

iter, offset, handle, direction);

net/switchdev/switchdev.c

640

struct list_head *iter;

net/switchdev/switchdev.c

649

netdev_for_each_lower_dev(dev, lower_dev, iter) {

net/switchdev/switchdev.c

722

struct list_head *iter;

net/switchdev/switchdev.c

741

netdev_for_each_lower_dev(dev, lower_dev, iter) {

net/switchdev/switchdev.c

835

struct list_head *iter;

net/switchdev/switchdev.c

852

netdev_for_each_lower_dev(dev, lower_dev, iter) {

net/switchdev/switchdev.c

944

struct list_head *iter;

net/switchdev/switchdev.c

963

netdev_for_each_lower_dev(dev, lower_dev, iter) {

net/tipc/socket.c

2972

struct rhashtable_iter iter;

net/tipc/socket.c

2976

rhashtable_walk_enter(&tn->sk_rht, &iter);

net/tipc/socket.c

2979

rhashtable_walk_start(&iter);

net/tipc/socket.c

2981

while ((tsk = rhashtable_walk_next(&iter)) && !IS_ERR(tsk)) {

net/tipc/socket.c

2983

rhashtable_walk_stop(&iter);

net/tipc/socket.c

2989

rhashtable_walk_start(&iter);

net/tipc/socket.c

2993

rhashtable_walk_stop(&iter);

net/tipc/socket.c

2996

rhashtable_walk_exit(&iter);

net/tipc/socket.c

3561

struct rhashtable_iter *iter = (void *)cb->args[4];

net/tipc/socket.c

3565

rhashtable_walk_start(iter);

net/tipc/socket.c

3566

while ((tsk = rhashtable_walk_next(iter)) != NULL) {

net/tipc/socket.c

3574

rhashtable_walk_stop(iter);

net/tipc/socket.c

3583

rhashtable_walk_start(iter);

net/tipc/socket.c

3586

rhashtable_walk_stop(iter);

net/tipc/socket.c

3601

struct rhashtable_iter *iter = (void *)cb->args[4];

net/tipc/socket.c

3604

if (!iter) {

net/tipc/socket.c

3605

iter = kmalloc_obj(*iter);

net/tipc/socket.c

3606

if (!iter)

net/tipc/socket.c

3609

cb->args[4] = (long)iter;

net/tipc/socket.c

3612

rhashtable_walk_enter(&tn->sk_rht, iter);

net/tls/tls_device.c

422

struct iov_iter *iter,

net/tls/tls_device.c

501

rc = iov_iter_extract_pages(iter, &pages,

net/tls/tls_device.c

511

iov_iter_revert(iter, copy);

net/tls/tls_device.c

524

iter);

net/tls/tls_device.c

596

struct iov_iter iter = {};

net/tls/tls_device.c

607

iov_iter_bvec(&iter, ITER_SOURCE, NULL, 0, 0);

net/tls/tls_device.c

608

tls_push_data(sk, &iter, 0, 0, TLS_RECORD_TYPE_DATA);

net/tls/tls_device.c

677

struct iov_iter iter;

net/tls/tls_device.c

679

iov_iter_kvec(&iter, ITER_SOURCE, NULL, 0, 0);

net/tls/tls_device.c

680

return tls_push_data(sk, &iter, 0, flags, TLS_RECORD_TYPE_DATA);

net/tls/tls_strp.c

162

struct sk_buff *iter, *clone;

net/tls/tls_strp.c

167

iter = shinfo->frag_list;

net/tls/tls_strp.c

170

if (iter->len <= offset) {

net/tls/tls_strp.c

171

offset -= iter->len;

net/tls/tls_strp.c

175

chunk = iter->len - offset;

net/tls/tls_strp.c

178

clone = skb_clone(iter, strp->sk->sk_allocation);

net/tls/tls_strp.c

185

iter = iter->next;

net/unix/af_unix.c

3631

struct bpf_unix_iter_state *iter = seq->private;

net/unix/af_unix.c

3636

iter->batch[iter->end_sk++] = start_sk;

net/unix/af_unix.c

3639

if (iter->end_sk < iter->max_sk) {

net/unix/af_unix.c

3641

iter->batch[iter->end_sk++] = sk;

net/unix/af_unix.c

3652

static void bpf_iter_unix_put_batch(struct bpf_unix_iter_state *iter)

net/unix/af_unix.c

3654

while (iter->cur_sk < iter->end_sk)

net/unix/af_unix.c

3655

sock_put(iter->batch[iter->cur_sk++]);

net/unix/af_unix.c

3658

static int bpf_iter_unix_realloc_batch(struct bpf_unix_iter_state *iter,

net/unix/af_unix.c

3668

bpf_iter_unix_put_batch(iter);

net/unix/af_unix.c

3669

kvfree(iter->batch);

net/unix/af_unix.c

3670

iter->batch = new_batch;

net/unix/af_unix.c

3671

iter->max_sk = new_batch_sz;

net/unix/af_unix.c

3679

struct bpf_unix_iter_state *iter = seq->private;

net/unix/af_unix.c

3684

if (iter->st_bucket_done)

net/unix/af_unix.c

3689

iter->cur_sk = 0;

net/unix/af_unix.c

3690

iter->end_sk = 0;

net/unix/af_unix.c

3698

if (iter->end_sk == expected) {

net/unix/af_unix.c

3699

iter->st_bucket_done = true;

net/unix/af_unix.c

3703

if (!resized && !bpf_iter_unix_realloc_batch(iter, expected * 3 / 2)) {

net/unix/af_unix.c

3724

struct bpf_unix_iter_state *iter = seq->private;

net/unix/af_unix.c

3731

if (iter->cur_sk < iter->end_sk)

net/unix/af_unix.c

3732

sock_put(iter->batch[iter->cur_sk++]);

net/unix/af_unix.c

3736

if (iter->cur_sk < iter->end_sk)

net/unix/af_unix.c

3737

sk = iter->batch[iter->cur_sk];

net/unix/af_unix.c

3775

struct bpf_unix_iter_state *iter = seq->private;

net/unix/af_unix.c

3786

if (iter->cur_sk < iter->end_sk)

net/unix/af_unix.c

3787

bpf_iter_unix_put_batch(iter);

net/unix/af_unix.c

3870

struct bpf_unix_iter_state *iter = priv_data;

net/unix/af_unix.c

3877

err = bpf_iter_unix_realloc_batch(iter, INIT_BATCH_SZ);

net/unix/af_unix.c

3888

struct bpf_unix_iter_state *iter = priv_data;

net/unix/af_unix.c

3891

kvfree(iter->batch);

net/wireless/core.c

1833

struct wireless_dev *iter;

net/wireless/core.c

1836

list_for_each_entry(iter, &rdev->wiphy.wdev_list, list) {

net/wireless/core.c

1837

if (iter->iftype == NL80211_IFTYPE_NAN &&

net/wireless/core.c

1838

wdev_running(iter)) {

net/wireless/scan.c

3398

void (*iter)(struct wiphy *wiphy,

net/wireless/scan.c

3411

iter(wiphy, &bss->pub, iter_data);

net/wireless/scan.c

644

(*iter)(void *data, u8 type,

net/wireless/scan.c

679

switch (iter(iter_data, type, info,

net/wireless/util.c

2477

void (*iter)(const struct ieee80211_iface_combination *c,

net/wireless/util.c

2586

(*iter)(c, data);

net/xfrm/xfrm_interface_core.c

226

struct xfrm_if *iter;

net/xfrm/xfrm_interface_core.c

229

(iter = rtnl_dereference(*xip)) != NULL;

net/xfrm/xfrm_interface_core.c

230

xip = &iter->next) {

net/xfrm/xfrm_interface_core.c

231

if (xi == iter) {

scripts/kconfig/gconf.c

100

valid = gtk_tree_model_iter_children(model, &iter, parent);

scripts/kconfig/gconf.c

104

gtk_tree_model_get(model, &iter, COL_MENU, &menu, -1);

scripts/kconfig/gconf.c

1130

static gboolean visible_func(GtkTreeModel *model, GtkTreeIter *iter,

scripts/kconfig/gconf.c

1135

gtk_tree_model_get(model, iter, COL_MENU, &menu, -1);

scripts/kconfig/gconf.c

114

path = gtk_tree_model_get_path(model, &iter);

scripts/kconfig/gconf.c

121

gtk_tree_selection_select_iter(selection, &iter);

scripts/kconfig/gconf.c

126

_select_menu(view, model, &iter, match);

scripts/kconfig/gconf.c

128

valid = gtk_tree_model_iter_next(model, &iter);

scripts/kconfig/gconf.c

252

GtkTreeIter iter;

scripts/kconfig/gconf.c

255

valid = gtk_tree_model_iter_children(model, &iter, parent);

scripts/kconfig/gconf.c

259

gtk_tree_model_get(model, &iter, COL_MENU, &menu, -1);

scripts/kconfig/gconf.c

262

set_node(store, &iter, menu);

scripts/kconfig/gconf.c

264

_update_tree(store, &iter);

scripts/kconfig/gconf.c

266

valid = gtk_tree_model_iter_next(model, &iter);

scripts/kconfig/gconf.c

662

GtkTreeIter iter;

scripts/kconfig/gconf.c

667

if (!gtk_tree_model_get_iter(model, &iter, path))

scripts/kconfig/gconf.c

670

gtk_tree_model_get(model, &iter, COL_MENU, &menu, -1);

scripts/kconfig/gconf.c

673

gtk_tree_model_get(model, &iter, COL_VALUE, &old_def, -1);

scripts/kconfig/gconf.c

752

GtkTreeIter iter;

scripts/kconfig/gconf.c

762

if (!gtk_tree_model_get_iter(model, &iter, path))

scripts/kconfig/gconf.c

764

gtk_tree_model_get(model, &iter, COL_MENU, &menu, -1);

scripts/kconfig/gconf.c

804

GtkTreeIter iter;

scripts/kconfig/gconf.c

820

gtk_tree_model_get_iter(model, &iter, path);

scripts/kconfig/gconf.c

821

gtk_tree_model_get(model, &iter, COL_MENU, &menu, -1);

scripts/kconfig/gconf.c

843

GtkTreeIter iter;

scripts/kconfig/gconf.c

847

if (gtk_tree_selection_get_selected(selection, &model, &iter)) {

scripts/kconfig/gconf.c

848

gtk_tree_model_get(model, &iter, COL_MENU, &menu, -1);

scripts/kconfig/gconf.c

862

GtkTreeIter iter;

scripts/kconfig/gconf.c

871

gtk_tree_model_get_iter(model, &iter, path);

scripts/kconfig/gconf.c

872

gtk_tree_model_get(model, &iter, COL_MENU, &menu, -1);

scripts/kconfig/gconf.c

895

GtkTreeIter iter;

scripts/kconfig/gconf.c

915

gtk_tree_store_append(tree, &iter, parent);

scripts/kconfig/gconf.c

916

set_node(tree, &iter, child);

scripts/kconfig/gconf.c

919

_display_tree(tree, child, &iter);

scripts/kconfig/gconf.c

97

GtkTreeIter iter;

security/lsm_init.c

33

#define lsm_order_for_each(iter) \

security/lsm_init.c

34

for ((iter) = lsm_order; *(iter); (iter)++)

security/lsm_init.c

35

#define lsm_for_each_raw(iter) \

security/lsm_init.c

36

for ((iter) = __start_lsm_info; \

security/lsm_init.c

37

(iter) < __end_lsm_info; (iter)++)

security/lsm_init.c

38

#define lsm_early_for_each_raw(iter) \

security/lsm_init.c

39

for ((iter) = __start_early_lsm_info; \

security/lsm_init.c

40

(iter) < __end_early_lsm_info; (iter)++)

security/selinux/hooks.c

3181

int orig, iter;

security/selinux/hooks.c

3193

orig = iter = tsec->avdcache.dir_spot;

security/selinux/hooks.c

3195

if (tsec->avdcache.dir[iter].isid == isec->sid) {

security/selinux/hooks.c

3197

tsec->avdcache.dir_spot = iter;

security/selinux/hooks.c

3198

*avdc = &tsec->avdcache.dir[iter];

security/selinux/hooks.c

3201

iter = (iter - 1) & (TSEC_AVDC_DIR_SIZE - 1);

security/selinux/hooks.c

3202

} while (iter != orig);

security/selinux/ibpkey.c

224

int iter;

security/selinux/ibpkey.c

229

for (iter = 0; iter < SEL_PKEY_HASH_SIZE; iter++) {

security/selinux/ibpkey.c

230

INIT_LIST_HEAD(&sel_ib_pkey_hash[iter].list);

security/selinux/ibpkey.c

231

sel_ib_pkey_hash[iter].size = 0;

security/selinux/netnode.c

296

int iter;

security/selinux/netnode.c

301

for (iter = 0; iter < SEL_NETNODE_HASH_SIZE; iter++) {

security/selinux/netnode.c

302

INIT_LIST_HEAD(&sel_netnode_hash[iter].list);

security/selinux/netnode.c

303

sel_netnode_hash[iter].size = 0;

security/selinux/netport.c

224

int iter;

security/selinux/netport.c

229

for (iter = 0; iter < SEL_NETPORT_HASH_SIZE; iter++) {

security/selinux/netport.c

230

INIT_LIST_HEAD(&sel_netport_hash[iter].list);

security/selinux/netport.c

231

sel_netport_hash[iter].size = 0;

security/selinux/selinuxfs.c

1741

unsigned int iter;

security/selinux/selinuxfs.c

1745

for (iter = 0; !err && iter <= POLICYDB_CAP_MAX; iter++) {

security/selinux/selinuxfs.c

1748

if (iter < ARRAY_SIZE(selinux_policycap_names))

security/selinux/selinuxfs.c

1749

name = selinux_policycap_names[iter];

security/selinux/selinuxfs.c

1758

inode->i_ino = iter | SEL_POLICYCAP_INO_OFFSET;

security/selinux/ss/ebitmap.c

115

unsigned int iter;

security/selinux/ss/ebitmap.c

129

for (iter = 0; iter < EBITMAP_UNIT_NUMS; iter++) {

security/selinux/ss/ebitmap.c

130

e_map = e_iter->maps[iter];

security/selinux/xfrm.c

451

struct dst_entry *iter;

security/selinux/xfrm.c

453

for (iter = dst; iter != NULL; iter = xfrm_dst_child(iter)) {

security/selinux/xfrm.c

454

struct xfrm_state *x = iter->xfrm;

sound/core/control.c

361

unsigned int iter = 100000;

sound/core/control.c

364

if (--iter == 0) {

sound/core/memalloc.c

625

struct sg_dma_page_iter iter;

sound/core/memalloc.c

627

snd_dma_noncontig_iter_set(dmab, &iter.base, offset);

sound/core/memalloc.c

628

__sg_page_iter_dma_next(&iter);

sound/core/memalloc.c

629

return sg_page_iter_dma_address(&iter) + offset % PAGE_SIZE;

sound/core/memalloc.c

635

struct sg_page_iter iter;

sound/core/memalloc.c

637

snd_dma_noncontig_iter_set(dmab, &iter, offset);

sound/core/memalloc.c

638

__sg_page_iter_next(&iter);

sound/core/memalloc.c

639

return sg_page_iter_page(&iter);

sound/core/memalloc.c

646

struct sg_dma_page_iter iter;

sound/core/memalloc.c

652

snd_dma_noncontig_iter_set(dmab, &iter.base, start);

sound/core/memalloc.c

653

if (!__sg_page_iter_dma_next(&iter))

sound/core/memalloc.c

656

addr = sg_page_iter_dma_address(&iter);

sound/core/memalloc.c

662

if (!__sg_page_iter_dma_next(&iter) ||

sound/core/memalloc.c

663

sg_page_iter_dma_address(&iter) != addr)

sound/core/memory.c

26

struct iov_iter iter;

sound/core/memory.c

28

if (import_ubuf(ITER_DEST, dst, count, &iter))

sound/core/memory.c

30

if (copy_to_iter_fromio((const void __iomem *)src, count, &iter) != count)

sound/core/memory.c

83

struct iov_iter iter;

sound/core/memory.c

85

if (import_ubuf(ITER_SOURCE, (void __user *)src, count, &iter))

sound/core/memory.c

87

if (copy_from_iter_toio((void __iomem *)dst, count, &iter) != count)

sound/core/pcm_lib.c

2040

struct iov_iter *iter, unsigned long bytes);

sound/core/pcm_lib.c

2057

struct iov_iter *iter, unsigned long bytes)

sound/core/pcm_lib.c

2060

bytes, iter) != bytes)

sound/core/pcm_lib.c

2070

unsigned long hwoff, struct iov_iter *iter,

sound/core/pcm_lib.c

2090

struct iov_iter *iter, unsigned long bytes)

sound/core/pcm_lib.c

2093

bytes, iter) != bytes)

sound/core/pcm_lib.c

2103

struct iov_iter iter;

sound/core/pcm_lib.c

2114

iov_iter_kvec(&iter, type, &kvec, 1, bytes);

sound/core/pcm_lib.c

2115

return transfer(substream, c, hwoff, &iter, bytes);

sound/core/pcm_lib.c

2118

err = import_ubuf(type, (__force void __user *)data, bytes, &iter);

sound/core/pcm_lib.c

2121

return transfer(substream, c, hwoff, &iter, bytes);

sound/drivers/dummy.c

625

struct iov_iter *iter, unsigned long bytes)

sound/isa/cs423x/cs4236.c

500

struct pnp_dev *cdev, *iter;

sound/isa/cs423x/cs4236.c

516

list_for_each_entry(iter, &(pdev->protocol->devices), protocol_list) {

sound/isa/cs423x/cs4236.c

517

if (!strcmp(iter->id[0].id, cid)) {

sound/isa/cs423x/cs4236.c

518

cdev = iter;

sound/isa/sb/emu8000_pcm.c

410

#define GET_VAL(sval, iter) \

sound/isa/sb/emu8000_pcm.c

412

if (!iter) \

sound/isa/sb/emu8000_pcm.c

414

else if (copy_from_iter(&sval, 2, iter) != 2) \

sound/isa/sb/emu8000_pcm.c

420

#define LOOP_WRITE(rec, offset, iter, count) \

sound/isa/sb/emu8000_pcm.c

428

GET_VAL(sval, iter); \

sound/isa/sb/emu8000_pcm.c

463

#define LOOP_WRITE(rec, pos, iter, count) \

sound/isa/sb/emu8000_pcm.c

473

GET_VAL(sval, iter); \

sound/isa/sb/emu8000_pcm.c

477

GET_VAL(sval, iter); \

sound/soc/soc-component.c

985

struct iov_iter *iter, unsigned long bytes)

sound/soc/soc-component.c

996

channel, pos, iter, bytes));

sound/soc/soc-generic-dmaengine-pcm.c

293

struct iov_iter *iter, unsigned long bytes)

sound/soc/soc-generic-dmaengine-pcm.c

305

if (copy_from_iter(dma_ptr, bytes, iter) != bytes)

sound/soc/soc-generic-dmaengine-pcm.c

315

if (copy_to_iter(dma_ptr, bytes, iter) != bytes)

sound/soc/sof/topology.c

200

int i, iter;

sound/soc/sof/topology.c

210

iter = exp * -1;

sound/soc/sof/topology.c

212

iter = exp;

sound/soc/sof/topology.c

215

for (i = 0; i < iter; i++) {

tools/bpf/bpftool/cgroup.c

252

__u32 iter;

tools/bpf/bpftool/cgroup.c

266

for (iter = 0; iter < p.prog_cnt; iter++)

tools/bpf/bpftool/cgroup.c

267

show_bpf_prog(prog_ids[iter], type, NULL, level);

tools/bpf/bpftool/cgroup.c

280

__u32 iter;

tools/bpf/bpftool/cgroup.c

295

for (iter = 0; iter < p.prog_cnt; iter++) {

tools/bpf/bpftool/cgroup.c

298

attach_flags = prog_attach_flags[iter] ?: p.attach_flags;

tools/bpf/bpftool/cgroup.c

315

show_bpf_prog(prog_ids[iter], type,

tools/bpf/bpftool/link.c

1057

!info.iter.target_name) {

tools/bpf/bpftool/link.c

1058

info.iter.target_name = ptr_to_u64(&buf);

tools/bpf/bpftool/link.c

1059

info.iter.target_name_len = sizeof(buf);

tools/bpf/bpftool/link.c

203

const char *target_name = u64_to_ptr(info->iter.target_name);

tools/bpf/bpftool/link.c

208

jsonw_uint_field(wtr, "map_id", info->iter.map.map_id);

tools/bpf/bpftool/link.c

210

if (info->iter.task.tid)

tools/bpf/bpftool/link.c

211

jsonw_uint_field(wtr, "tid", info->iter.task.tid);

tools/bpf/bpftool/link.c

212

else if (info->iter.task.pid)

tools/bpf/bpftool/link.c

213

jsonw_uint_field(wtr, "pid", info->iter.task.pid);

tools/bpf/bpftool/link.c

217

jsonw_lluint_field(wtr, "cgroup_id", info->iter.cgroup.cgroup_id);

tools/bpf/bpftool/link.c

219

cgroup_order_string(info->iter.cgroup.order));

tools/bpf/bpftool/link.c

679

const char *target_name = u64_to_ptr(info->iter.target_name);

tools/bpf/bpftool/link.c

684

printf("map_id %u ", info->iter.map.map_id);

tools/bpf/bpftool/link.c

686

if (info->iter.task.tid)

tools/bpf/bpftool/link.c

687

printf("tid %u ", info->iter.task.tid);

tools/bpf/bpftool/link.c

688

else if (info->iter.task.pid)

tools/bpf/bpftool/link.c

689

printf("pid %u ", info->iter.task.pid);

tools/bpf/bpftool/link.c

693

printf("cgroup_id %llu ", info->iter.cgroup.cgroup_id);

tools/bpf/bpftool/link.c

695

cgroup_order_string(info->iter.cgroup.order));

tools/bpf/bpftool/pids.c

146

fd = bpf_iter_create(bpf_link__fd(skel->links.iter));

tools/bpf/bpftool/skeleton/pid_iter.bpf.c

67

int iter(struct bpf_iter__task_file *ctx)

tools/include/uapi/linux/bpf.h

6808

} iter;

tools/lib/bpf/elf.c

104

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

tools/lib/bpf/elf.c

121

iter->strtabidx = sh.sh_link;

tools/lib/bpf/elf.c

122

iter->syms = elf_getdata(scn, 0);

tools/lib/bpf/elf.c

123

if (!iter->syms) {

tools/lib/bpf/elf.c

128

iter->nr_syms = iter->syms->d_size / sh.sh_entsize;

tools/lib/bpf/elf.c

129

iter->elf = elf;

tools/lib/bpf/elf.c

130

iter->st_type = st_type;

tools/lib/bpf/elf.c

139

iter->versyms = elf_getdata(scn, 0);

tools/lib/bpf/elf.c

145

iter->verdefs = elf_getdata(scn, 0);

tools/lib/bpf/elf.c

146

if (!iter->verdefs || !gelf_getshdr(scn, &sh)) {

tools/lib/bpf/elf.c

150

iter->verdef_strtabidx = sh.sh_link;

tools/lib/bpf/elf.c

155

static struct elf_sym *elf_sym_iter_next(struct elf_sym_iter *iter)

tools/lib/bpf/elf.c

157

struct elf_sym *ret = &iter->sym;

tools/lib/bpf/elf.c

164

for (idx = iter->next_sym_idx; idx < iter->nr_syms; idx++) {

tools/lib/bpf/elf.c

165

if (!gelf_getsym(iter->syms, idx, sym))

tools/lib/bpf/elf.c

167

if (GELF_ST_TYPE(sym->st_info) != iter->st_type)

tools/lib/bpf/elf.c

169

name = elf_strptr(iter->elf, iter->strtabidx, sym->st_name);

tools/lib/bpf/elf.c

172

sym_scn = elf_getscn(iter->elf, sym->st_shndx);

tools/lib/bpf/elf.c

178

iter->next_sym_idx = idx + 1;

tools/lib/bpf/elf.c

183

if (iter->versyms) {

tools/lib/bpf/elf.c

184

if (!gelf_getversym(iter->versyms, idx, &versym))

tools/lib/bpf/elf.c

195

static const char *elf_get_vername(struct elf_sym_iter *iter, int ver)

tools/lib/bpf/elf.c

201

if (!iter->verdefs)

tools/lib/bpf/elf.c

205

while (gelf_getverdef(iter->verdefs, offset, &verdef)) {

tools/lib/bpf/elf.c

214

if (!gelf_getverdaux(iter->verdefs, offset + verdef.vd_aux, &verdaux))

tools/lib/bpf/elf.c

217

return elf_strptr(iter->elf, iter->verdef_strtabidx, verdaux.vda_name);

tools/lib/bpf/elf.c

223

static bool symbol_match(struct elf_sym_iter *iter, int sh_type, struct elf_sym *sym,

tools/lib/bpf/elf.c

248

ver_name = elf_get_vername(iter, sym->ver);

tools/lib/bpf/elf.c

312

struct elf_sym_iter iter;

tools/lib/bpf/elf.c

317

ret = elf_sym_iter_new(&iter, elf, binary_path, sh_types[i], STT_FUNC);

tools/lib/bpf/elf.c

323

while ((sym = elf_sym_iter_next(&iter))) {

tools/lib/bpf/elf.c

324

if (!symbol_match(&iter, sh_types[i], sym, name, name_len, lib_ver))

tools/lib/bpf/elf.c

437

struct elf_sym_iter iter;

tools/lib/bpf/elf.c

440

err = elf_sym_iter_new(&iter, elf_fd.elf, binary_path, sh_types[i], st_type);

tools/lib/bpf/elf.c

446

while ((sym = elf_sym_iter_next(&iter))) {

tools/lib/bpf/elf.c

518

struct elf_sym_iter iter;

tools/lib/bpf/elf.c

521

err = elf_sym_iter_new(&iter, elf_fd.elf, binary_path, sh_types[i], STT_FUNC);

tools/lib/bpf/elf.c

527

while ((sym = elf_sym_iter_next(&iter))) {

tools/lib/bpf/elf.c

96

static int elf_sym_iter_new(struct elf_sym_iter *iter,

tools/net/ynl/lib/ynl.h

107

#define ynl_dump_foreach(dump, iter) \

tools/net/ynl/lib/ynl.h

108

for (typeof(dump->obj) *iter = &dump->obj; \

tools/net/ynl/lib/ynl.h

109

!ynl_dump_obj_is_last(iter); \

tools/net/ynl/lib/ynl.h

110

iter = ynl_dump_obj_next(iter))

tools/objtool/arch/x86/special.c

22

struct special_alt *iter = group;

tools/objtool/arch/x86/special.c

24

unsigned int len = max(iter->orig_len, alt->orig_len);

tools/objtool/arch/x86/special.c

25

iter->orig_len = alt->orig_len = len;

tools/objtool/arch/x86/special.c

27

if (iter == prev)

tools/objtool/arch/x86/special.c

30

iter = list_next_entry(iter, list);

tools/objtool/elf.c

512

struct symbol *iter;

tools/objtool/elf.c

526

__sym_for_each(iter, &sym->sec->symbol_tree, sym->offset, sym->offset) {

tools/objtool/elf.c

527

if (!is_undef_sym(iter) && iter->offset == sym->offset &&

tools/objtool/elf.c

528

iter->type == sym->type && iter->len == sym->len)

tools/objtool/elf.c

529

iter->alias = sym;

tools/perf/bench/epoll-wait.c

383

size_t i, j, iter;

tools/perf/bench/epoll-wait.c

392

for (iter = 0; !wdone; iter++) {

tools/perf/bench/epoll-wait.c

414

printinfo("exiting writer-thread (total full-loops: %zd)\n", iter);

tools/perf/builtin-annotate.c

101

struct block_range_iter iter;

tools/perf/builtin-annotate.c

111

iter = block_range__create(start->addr, end->addr);

tools/perf/builtin-annotate.c

112

if (!block_range_iter__valid(&iter))

tools/perf/builtin-annotate.c

120

entry = block_range_iter(&iter);

tools/perf/builtin-annotate.c

125

entry = block_range_iter(&iter);

tools/perf/builtin-annotate.c

133

} while (block_range_iter__next(&iter));

tools/perf/builtin-annotate.c

138

entry = block_range_iter(&iter);

tools/perf/builtin-annotate.c

171

static int hist_iter__branch_callback(struct hist_entry_iter *iter,

tools/perf/builtin-annotate.c

176

struct hist_entry *he = iter->he;

tools/perf/builtin-annotate.c

178

struct perf_sample *sample = iter->sample;

tools/perf/builtin-annotate.c

198

struct hist_entry_iter iter = {

tools/perf/builtin-annotate.c

224

ret = hist_entry_iter__add(&iter, &a, PERF_MAX_STACK_DEPTH, ann);

tools/perf/builtin-annotate.c

363

struct annotated_item_stat *istat, *pos, *iter;

tools/perf/builtin-annotate.c

377

list_for_each_entry(iter, head, list) {

tools/perf/builtin-annotate.c

378

sum2 = iter->good + iter->bad;

tools/perf/builtin-annotate.c

382

list_move_tail(&istat->list, &iter->list);

tools/perf/builtin-diff.c

399

struct hist_entry_iter iter = {

tools/perf/builtin-diff.c

439

if (hist_entry_iter__add(&iter, &al, PERF_MAX_STACK_DEPTH,

tools/perf/builtin-report.c

168

static int hist_iter__report_callback(struct hist_entry_iter *iter,

tools/perf/builtin-report.c

174

struct hist_entry *he = iter->he;

tools/perf/builtin-report.c

175

struct perf_sample *sample = iter->sample;

tools/perf/builtin-report.c

209

static int hist_iter__branch_callback(struct hist_entry_iter *iter,

tools/perf/builtin-report.c

214

struct hist_entry *he = iter->he;

tools/perf/builtin-report.c

217

struct perf_sample *sample = iter->sample;

tools/perf/builtin-report.c

271

struct hist_entry_iter iter = {

tools/perf/builtin-report.c

313

iter.add_entry_cb = hist_iter__branch_callback;

tools/perf/builtin-report.c

314

iter.ops = &hist_iter_branch;

tools/perf/builtin-report.c

316

iter.ops = &hist_iter_mem;

tools/perf/builtin-report.c

318

iter.ops = &hist_iter_cumulative;

tools/perf/builtin-report.c

320

iter.ops = &hist_iter_normal;

tools/perf/builtin-report.c

336

ret = hist_entry_iter__add(&iter, &al, rep->max_stack, rep);

tools/perf/builtin-top.c

729

static int hist_iter__top_callback(struct hist_entry_iter *iter,

tools/perf/builtin-top.c

732

EXCLUSIVE_LOCKS_REQUIRED(iter->he->hists->lock)

tools/perf/builtin-top.c

737

perf_top__record_precise_ip(top, iter->he, iter->sample, al->addr);

tools/perf/builtin-top.c

739

hist__account_cycles(iter->sample->branch_stack, al, iter->sample,

tools/perf/builtin-top.c

834

struct hist_entry_iter iter = {

tools/perf/builtin-top.c

840

iter.ops = &hist_iter_cumulative;

tools/perf/builtin-top.c

842

iter.ops = &hist_iter_normal;

tools/perf/builtin-top.c

846

if (hist_entry_iter__add(&iter, &al, top->max_stack, top) < 0)

tools/perf/tests/hists_cumulate.c

108

if (hist_entry_iter__add(&iter, &al, sysctl_perf_event_max_stack,

tools/perf/tests/hists_cumulate.c

89

struct hist_entry_iter iter = {

tools/perf/tests/hists_cumulate.c

95

iter.ops = &hist_iter_cumulative;

tools/perf/tests/hists_cumulate.c

97

iter.ops = &hist_iter_normal;

tools/perf/tests/hists_filter.c

65

struct hist_entry_iter iter = {

tools/perf/tests/hists_filter.c

87

if (hist_entry_iter__add(&iter, &al,

tools/perf/tests/hists_output.c

59

struct hist_entry_iter iter = {

tools/perf/tests/hists_output.c

74

if (hist_entry_iter__add(&iter, &al, sysctl_perf_event_max_stack,

tools/perf/ui/gtk/annotate.c

137

GtkTreeIter iter;

tools/perf/ui/gtk/annotate.c

140

gtk_list_store_append(store, &iter);

tools/perf/ui/gtk/annotate.c

157

gtk_list_store_set(store, &iter, ANN_COL__PERCENT, s, -1);

tools/perf/ui/gtk/annotate.c

159

gtk_list_store_set(store, &iter, ANN_COL__OFFSET, s, -1);

tools/perf/ui/gtk/annotate.c

161

gtk_list_store_set(store, &iter, ANN_COL__LINE, s, -1);

tools/perf/ui/gtk/hists.c

106

GtkTreeIter iter, new_parent;

tools/perf/ui/gtk/hists.c

119

gtk_tree_store_append(store, &iter, &new_parent);

tools/perf/ui/gtk/hists.c

122

gtk_tree_store_set(store, &iter, 0, buf, -1);

tools/perf/ui/gtk/hists.c

125

gtk_tree_store_set(store, &iter, col, buf, -1);

tools/perf/ui/gtk/hists.c

132

new_parent = iter;

tools/perf/ui/gtk/hists.c

140

gtk_tree_store_append(store, &iter, &new_parent);

tools/perf/ui/gtk/hists.c

143

gtk_tree_store_set(store, &iter, 0, buf, -1);

tools/perf/ui/gtk/hists.c

146

gtk_tree_store_set(store, &iter, col, buf, -1);

tools/perf/ui/gtk/hists.c

153

new_parent = iter;

tools/perf/ui/gtk/hists.c

168

GtkTreeIter iter;

tools/perf/ui/gtk/hists.c

209

gtk_tree_store_append(store, &iter, parent);

tools/perf/ui/gtk/hists.c

212

gtk_tree_store_set(store, &iter, 0, buf, -1);

tools/perf/ui/gtk/hists.c

214

gtk_tree_store_set(store, &iter, col, str, -1);

tools/perf/ui/gtk/hists.c

229

GtkTreeIter iter, new_parent;

tools/perf/ui/gtk/hists.c

241

gtk_tree_store_append(store, &iter, &new_parent);

tools/perf/ui/gtk/hists.c

244

gtk_tree_store_set(store, &iter, 0, buf, -1);

tools/perf/ui/gtk/hists.c

247

gtk_tree_store_set(store, &iter, col, buf, -1);

tools/perf/ui/gtk/hists.c

254

new_parent = iter;

tools/perf/ui/gtk/hists.c

265

perf_gtk__add_callchain_graph(&node->rb_root, store, &iter, col,

tools/perf/ui/gtk/hists.c

360

GtkTreeIter iter;

tools/perf/ui/gtk/hists.c

371

gtk_tree_store_append(store, &iter, NULL);

tools/perf/ui/gtk/hists.c

384

gtk_tree_store_set(store, &iter, col_idx++, s, -1);

tools/perf/ui/gtk/hists.c

393

perf_gtk__add_callchain(&h->sorted_chain, store, &iter,

tools/perf/ui/gtk/hists.c

421

GtkTreeIter iter;

tools/perf/ui/gtk/hists.c

433

gtk_tree_store_append(store, &iter, parent);

tools/perf/ui/gtk/hists.c

446

gtk_tree_store_set(store, &iter, col_idx++, hpp->buf, -1);

tools/perf/ui/gtk/hists.c

463

gtk_tree_store_set(store, &iter, col_idx, strim(bf), -1);

tools/perf/ui/gtk/hists.c

470

store, &iter, hpp,

tools/perf/ui/gtk/hists.c

480

gtk_tree_store_append(store, &child, &iter);

tools/perf/ui/gtk/hists.c

490

perf_gtk__add_callchain(&he->sorted_chain, store, &iter,

tools/perf/util/annotate.c

1063

struct annotation_line *iter;

tools/perf/util/annotate.c

1071

iter = rb_entry(parent, struct annotation_line, rb_node);

tools/perf/util/annotate.c

1073

ret = strcmp(iter->path, al->path);

tools/perf/util/annotate.c

1076

iter->data[i].percent_sum += annotation_data__percent(&al->data[i],

tools/perf/util/annotate.c

1112

struct annotation_line *iter;

tools/perf/util/annotate.c

1118

iter = rb_entry(parent, struct annotation_line, rb_node);

tools/perf/util/annotate.c

1120

if (cmp_source_line(al, iter))

tools/perf/util/block-range.c

118

return iter;

tools/perf/util/block-range.c

131

iter.start = head;

tools/perf/util/block-range.c

141

return iter;

tools/perf/util/block-range.c

154

iter.start = entry;

tools/perf/util/block-range.c

155

iter.end = entry;

tools/perf/util/block-range.c

165

return iter;

tools/perf/util/block-range.c

188

iter.start = entry;

tools/perf/util/block-range.c

195

entry = iter.start;

tools/perf/util/block-range.c

203

return iter;

tools/perf/util/block-range.c

225

iter.end = entry;

tools/perf/util/block-range.c

234

iter.end = entry;

tools/perf/util/block-range.c

250

return iter;

tools/perf/util/block-range.c

263

iter.end = tail;

tools/perf/util/block-range.c

273

return iter;

tools/perf/util/block-range.c

291

assert(iter.start->start == start && iter.start->is_target);

tools/perf/util/block-range.c

292

assert(iter.end->end == end && iter.end->is_branch);

tools/perf/util/block-range.c

296

return iter;

tools/perf/util/block-range.c

82

struct block_range_iter iter = { NULL, NULL };

tools/perf/util/block-range.h

51

static inline struct block_range *block_range_iter(struct block_range_iter *iter)

tools/perf/util/block-range.h

53

return iter->start;

tools/perf/util/block-range.h

56

static inline bool block_range_iter__next(struct block_range_iter *iter)

tools/perf/util/block-range.h

58

if (iter->start == iter->end)

tools/perf/util/block-range.h

61

iter->start = block_range__next(iter->start);

tools/perf/util/block-range.h

65

static inline bool block_range_iter__valid(struct block_range_iter *iter)

tools/perf/util/block-range.h

67

if (!iter->start || !iter->end)

tools/perf/util/bpf_skel/lock_contention.bpf.c

1033

struct bpf_iter__kmem_cache___new *iter = ctx;

tools/perf/util/bpf_skel/lock_contention.bpf.c

1035

s = iter->s;

tools/perf/util/hist.c

1000

iter->curr = 0;

tools/perf/util/hist.c

1001

iter->total = sample->branch_stack->nr;

tools/perf/util/hist.c

1003

iter->bi = bi;

tools/perf/util/hist.c

1008

iter_add_single_branch_entry(struct hist_entry_iter *iter __maybe_unused,

tools/perf/util/hist.c

1015

iter_next_branch_entry(struct hist_entry_iter *iter, struct addr_location *al)

tools/perf/util/hist.c

1017

struct branch_info *bi = iter->bi;

tools/perf/util/hist.c

1018

int i = iter->curr;

tools/perf/util/hist.c

1023

if (iter->curr >= iter->total)

tools/perf/util/hist.c

1036

iter_add_next_branch_entry(struct hist_entry_iter *iter, struct addr_location *al)

tools/perf/util/hist.c

1039

struct perf_sample *sample = iter->sample;

tools/perf/util/hist.c

1043

int i = iter->curr;

tools/perf/util/hist.c

1046

bi = iter->bi;

tools/perf/util/hist.c

1048

if (iter->hide_unresolved && !(bi[i].from.ms.sym && bi[i].to.ms.sym))

tools/perf/util/hist.c

1058

he = hists__add_entry(hists, al, iter->parent, &bi[i], NULL, NULL,

tools/perf/util/hist.c

1064

iter->he = he;

tools/perf/util/hist.c

1065

iter->curr++;

tools/perf/util/hist.c

1078

iter_finish_branch_entry(struct hist_entry_iter *iter,

tools/perf/util/hist.c

1081

struct evsel *evsel = iter->sample->evsel;

tools/perf/util/hist.c

1084

for (int i = 0; i < iter->total; i++)

tools/perf/util/hist.c

1085

branch_info__exit(&iter->bi[i]);

tools/perf/util/hist.c

1087

if (iter->he)

tools/perf/util/hist.c

1088

hists__inc_nr_samples(hists, iter->he->filtered);

tools/perf/util/hist.c

1090

zfree(&iter->bi);

tools/perf/util/hist.c

1091

iter->he = NULL;

tools/perf/util/hist.c

1093

return iter->curr >= iter->total ? 0 : -1;

tools/perf/util/hist.c

1097

iter_prepare_normal_entry(struct hist_entry_iter *iter __maybe_unused,

tools/perf/util/hist.c

1104

iter_add_single_normal_entry(struct hist_entry_iter *iter, struct addr_location *al)

tools/perf/util/hist.c

1106

struct perf_sample *sample = iter->sample;

tools/perf/util/hist.c

1110

he = hists__add_entry(evsel__hists(evsel), al, iter->parent, NULL, NULL,

tools/perf/util/hist.c

1115

iter->he = he;

tools/perf/util/hist.c

1120

iter_finish_normal_entry(struct hist_entry_iter *iter,

tools/perf/util/hist.c

1123

struct hist_entry *he = iter->he;

tools/perf/util/hist.c

1124

struct perf_sample *sample = iter->sample;

tools/perf/util/hist.c

1130

iter->he = NULL;

tools/perf/util/hist.c

1138

iter_prepare_cumulative_entry(struct hist_entry_iter *iter,

tools/perf/util/hist.c

1158

iter->he_cache = he_cache;

tools/perf/util/hist.c

1159

iter->curr = 0;

tools/perf/util/hist.c

1165

iter_add_single_cumulative_entry(struct hist_entry_iter *iter,

tools/perf/util/hist.c

1168

struct perf_sample *sample = iter->sample;

tools/perf/util/hist.c

1171

struct hist_entry **he_cache = iter->he_cache;

tools/perf/util/hist.c

1175

he = hists__add_entry(hists, al, iter->parent, NULL, NULL, NULL,

tools/perf/util/hist.c

1180

iter->he = he;

tools/perf/util/hist.c

1181

he_cache[iter->curr++] = he;

tools/perf/util/hist.c

1197

iter_next_cumulative_entry(struct hist_entry_iter *iter,

tools/perf/util/hist.c

1206

return fill_callchain_info(al, node, iter->hide_unresolved);

tools/perf/util/hist.c

1224

iter_add_next_cumulative_entry(struct hist_entry_iter *iter,

tools/perf/util/hist.c

1227

struct perf_sample *sample = iter->sample;

tools/perf/util/hist.c

1229

struct hist_entry **he_cache = iter->he_cache;

tools/perf/util/hist.c

1243

.parent = iter->parent,

tools/perf/util/hist.c

1262

for (i = 0; i < iter->curr; i++) {

tools/perf/util/hist.c

1273

iter->he = NULL;

tools/perf/util/hist.c

1278

he = hists__add_entry(evsel__hists(evsel), al, iter->parent, NULL, NULL,

tools/perf/util/hist.c

1283

iter->he = he;

tools/perf/util/hist.c

1284

he_cache[iter->curr++] = he;

tools/perf/util/hist.c

1292

iter_finish_cumulative_entry(struct hist_entry_iter *iter,

tools/perf/util/hist.c

1295

mem_info__zput(iter->mi);

tools/perf/util/hist.c

1296

zfree(&iter->bi);

tools/perf/util/hist.c

1297

zfree(&iter->he_cache);

tools/perf/util/hist.c

1298

iter->he = NULL;

tools/perf/util/hist.c

1335

int hist_entry_iter__add(struct hist_entry_iter *iter, struct addr_location *al,

tools/perf/util/hist.c

1344

err = sample__resolve_callchain(iter->sample, get_tls_callchain_cursor(), &iter->parent,

tools/perf/util/hist.c

1351

err = iter->ops->prepare_entry(iter, al);

tools/perf/util/hist.c

1355

err = iter->ops->add_single_entry(iter, al);

tools/perf/util/hist.c

1359

if (iter->he && iter->add_entry_cb) {

tools/perf/util/hist.c

1360

err = iter->add_entry_cb(iter, al, true, arg);

tools/perf/util/hist.c

1365

while (iter->ops->next_entry(iter, al)) {

tools/perf/util/hist.c

1366

err = iter->ops->add_next_entry(iter, al);

tools/perf/util/hist.c

1370

if (iter->he && iter->add_entry_cb) {

tools/perf/util/hist.c

1371

err = iter->add_entry_cb(iter, al, false, arg);

tools/perf/util/hist.c

1378

err2 = iter->ops->finish_entry(iter, al);

tools/perf/util/hist.c

1634

struct hist_entry *iter, *new;

tools/perf/util/hist.c

1641

iter = rb_entry(parent, struct hist_entry, rb_node_in);

tools/perf/util/hist.c

1642

cmp = hist_entry__collapse_hierarchy(hpp_list, iter, he);

tools/perf/util/hist.c

1644

he_stat__add_stat(&iter->stat, &he->stat);

tools/perf/util/hist.c

1645

hists__add_mem_stat(hists, iter, he);

tools/perf/util/hist.c

1646

return iter;

tools/perf/util/hist.c

1755

struct hist_entry *iter;

tools/perf/util/hist.c

1764

iter = rb_entry(parent, struct hist_entry, rb_node_in);

tools/perf/util/hist.c

1766

cmp = hist_entry__collapse(iter, he);

tools/perf/util/hist.c

1771

he_stat__add_stat(&iter->stat, &he->stat);

tools/perf/util/hist.c

1773

he_stat__add_stat(iter->stat_acc, he->stat_acc);

tools/perf/util/hist.c

1774

hists__add_mem_stat(hists, iter, he);

tools/perf/util/hist.c

1781

if (callchain_merge(cursor, iter->callchain, he->callchain) < 0)

tools/perf/util/hist.c

1938

struct hist_entry *iter;

tools/perf/util/hist.c

1944

iter = rb_entry(parent, struct hist_entry, rb_node);

tools/perf/util/hist.c

1946

if (hist_entry__sort(he, iter) > 0)

tools/perf/util/hist.c

2025

struct hist_entry *iter;

tools/perf/util/hist.c

2044

iter = rb_entry(parent, struct hist_entry, rb_node);

tools/perf/util/hist.c

2046

if (hist_entry__sort(he, iter) > 0)

tools/perf/util/hist.c

2358

struct hist_entry *iter;

tools/perf/util/hist.c

2365

iter = rb_entry(parent, struct hist_entry, rb_node);

tools/perf/util/hist.c

2367

if (hist_entry__sort(he, iter) > 0)

tools/perf/util/hist.c

2645

struct hist_entry *iter = rb_entry(n, struct hist_entry, rb_node_in);

tools/perf/util/hist.c

2646

int64_t cmp = hist_entry__collapse(iter, he);

tools/perf/util/hist.c

2653

return iter;

tools/perf/util/hist.c

2665

struct hist_entry *iter;

tools/perf/util/hist.c

2668

iter = rb_entry(n, struct hist_entry, rb_node_in);

tools/perf/util/hist.c

2669

cmp = hist_entry__collapse_hierarchy(he->hpp_list, iter, he);

tools/perf/util/hist.c

2675

return iter;

tools/perf/util/hist.c

906

iter_next_nop_entry(struct hist_entry_iter *iter __maybe_unused,

tools/perf/util/hist.c

913

iter_add_next_nop_entry(struct hist_entry_iter *iter __maybe_unused,

tools/perf/util/hist.c

920

iter_prepare_mem_entry(struct hist_entry_iter *iter, struct addr_location *al)

tools/perf/util/hist.c

922

struct perf_sample *sample = iter->sample;

tools/perf/util/hist.c

929

iter->mi = mi;

tools/perf/util/hist.c

934

iter_add_single_mem_entry(struct hist_entry_iter *iter, struct addr_location *al)

tools/perf/util/hist.c

937

struct mem_info *mi = iter->mi;

tools/perf/util/hist.c

938

struct perf_sample *sample = iter->sample;

tools/perf/util/hist.c

958

he = hists__add_entry(hists, al, iter->parent, NULL, mi, NULL,

tools/perf/util/hist.c

963

iter->he = he;

tools/perf/util/hist.c

968

iter_finish_mem_entry(struct hist_entry_iter *iter,

tools/perf/util/hist.c

971

struct evsel *evsel = iter->sample->evsel;

tools/perf/util/hist.c

973

struct hist_entry *he = iter->he;

tools/perf/util/hist.c

981

err = hist_entry__append_callchain(he, iter->sample);

tools/perf/util/hist.c

984

mem_info__zput(iter->mi);

tools/perf/util/hist.c

986

iter->he = NULL;

tools/perf/util/hist.c

991

iter_prepare_branch_entry(struct hist_entry_iter *iter, struct addr_location *al)

tools/perf/util/hist.c

994

struct perf_sample *sample = iter->sample;

tools/perf/util/hist.h

169

int (*add_entry_cb)(struct hist_entry_iter *iter,

tools/perf/util/hist.h

367

int hist_entry_iter__add(struct hist_entry_iter *iter, struct addr_location *al,

tools/perf/util/machine.c

2197

struct iterations *iter,

tools/perf/util/machine.c

2261

if (iter) {

tools/perf/util/machine.c

2262

nr_loop_iter = iter->nr_loop_iter;

tools/perf/util/machine.c

2263

iter_cycles = iter->cycles;

tools/perf/util/machine.c

2306

static void save_iterations(struct iterations *iter,

tools/perf/util/machine.c

2311

iter->nr_loop_iter++;

tools/perf/util/machine.c

2312

iter->cycles = 0;

tools/perf/util/machine.c

2315

iter->cycles += be[i].flags.cycles;

tools/perf/util/machine.c

2326

struct iterations *iter)

tools/perf/util/machine.c

2353

save_iterations(iter + i + off,

tools/perf/util/machine.c

2356

memmove(iter + i, iter + i + off,

tools/perf/util/machine.c

2357

j * sizeof(*iter));

tools/perf/util/machine.c

2876

struct iterations iter[nr];

tools/perf/util/machine.c

2907

memset(iter, 0, sizeof(struct iterations) * nr);

tools/perf/util/machine.c

2908

nr = remove_loops(be, nr, iter);

tools/perf/util/machine.c

2921

&iter[i], 0, symbols);

tools/perf/util/ordered-events.c

227

struct ordered_event *tmp, *iter;

tools/perf/util/ordered-events.c

239

list_for_each_entry_safe(iter, tmp, head, list) {

tools/perf/util/ordered-events.c

243

if (iter->timestamp > limit)

tools/perf/util/ordered-events.c

245

ret = oe->deliver(oe, iter);

tools/perf/util/ordered-events.c

249

ordered_events__delete(oe, iter);

tools/perf/util/ordered-events.c

250

oe->last_flush = iter->timestamp;

tools/power/x86/turbostat/turbostat.c

2011

const struct dirent *pmt_diriter_next(struct pmt_diriter_t *iter)

tools/power/x86/turbostat/turbostat.c

2015

if (!iter->dir)

tools/power/x86/turbostat/turbostat.c

2018

if (iter->current_name_idx >= iter->num_names)

tools/power/x86/turbostat/turbostat.c

2021

ret = iter->namelist[iter->current_name_idx];

tools/power/x86/turbostat/turbostat.c

2022

++iter->current_name_idx;

tools/power/x86/turbostat/turbostat.c

2027

const struct dirent *pmt_diriter_begin(struct pmt_diriter_t *iter, const char *pmt_root_path)

tools/power/x86/turbostat/turbostat.c

2029

int num_names = iter->num_names;

tools/power/x86/turbostat/turbostat.c

2031

if (!iter->dir) {

tools/power/x86/turbostat/turbostat.c

2032

iter->dir = opendir(pmt_root_path);

tools/power/x86/turbostat/turbostat.c

2033

if (iter->dir == NULL)

tools/power/x86/turbostat/turbostat.c

2036

num_names = scandir(pmt_root_path, &iter->namelist, pmt_telemdir_filter, pmt_telemdir_sort);

tools/power/x86/turbostat/turbostat.c

2041

iter->current_name_idx = 0;

tools/power/x86/turbostat/turbostat.c

2042

iter->num_names = num_names;

tools/power/x86/turbostat/turbostat.c

2044

return pmt_diriter_next(iter);

tools/power/x86/turbostat/turbostat.c

2047

void pmt_diriter_init(struct pmt_diriter_t *iter)

tools/power/x86/turbostat/turbostat.c

2049

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

tools/power/x86/turbostat/turbostat.c

2052

void pmt_diriter_remove(struct pmt_diriter_t *iter)

tools/power/x86/turbostat/turbostat.c

2054

if (iter->namelist) {

tools/power/x86/turbostat/turbostat.c

2055

for (unsigned int i = 0; i < iter->num_names; i++) {

tools/power/x86/turbostat/turbostat.c

2056

free(iter->namelist[i]);

tools/power/x86/turbostat/turbostat.c

2057

iter->namelist[i] = NULL;

tools/power/x86/turbostat/turbostat.c

2061

free(iter->namelist);

tools/power/x86/turbostat/turbostat.c

2062

iter->namelist = NULL;

tools/power/x86/turbostat/turbostat.c

2063

iter->num_names = 0;

tools/power/x86/turbostat/turbostat.c

2064

iter->current_name_idx = 0;

tools/power/x86/turbostat/turbostat.c

2066

closedir(iter->dir);

tools/power/x86/turbostat/turbostat.c

2067

iter->dir = NULL;

tools/testing/cxl/test/cxl.c

1084

struct cxl_port *port, *iter;

tools/testing/cxl/test/cxl.c

1176

iter = port;

tools/testing/cxl/test/cxl.c

1178

dport = iter->parent_dport;

tools/testing/cxl/test/cxl.c

1179

iter = dport->port;

tools/testing/cxl/test/cxl.c

1180

dev = device_find_child(&iter->dev, NULL, first_decoder);

tools/testing/cxl/test/cxl.c

1201

iter->commit_end = 0;

tools/testing/cxl/test/cxl.c

1226

cxl_port_update_decoder_targets(iter, dport);

tools/testing/radix-tree/benchmark.c

17

struct radix_tree_iter iter;

tools/testing/radix-tree/benchmark.c

29

radix_tree_for_each_tagged(slot, root, &iter, 0, 0)

tools/testing/radix-tree/benchmark.c

32

radix_tree_for_each_slot(slot, root, &iter, 0)

tools/testing/radix-tree/regression3.c

34

struct radix_tree_iter iter;

tools/testing/radix-tree/regression3.c

44

radix_tree_for_each_tagged(slot, &root, &iter, 0, 0) {

tools/testing/radix-tree/regression3.c

45

printv(2, "tagged %ld %p\n", iter.index, *slot);

tools/testing/radix-tree/regression3.c

52

printv(2, "retry at %ld\n", iter.index);

tools/testing/radix-tree/regression3.c

53

slot = radix_tree_iter_retry(&iter);

tools/testing/radix-tree/regression3.c

60

radix_tree_for_each_slot(slot, &root, &iter, 0) {

tools/testing/radix-tree/regression3.c

61

printv(2, "slot %ld %p\n", iter.index, *slot);

tools/testing/radix-tree/regression3.c

67

printv(2, "retry at %ld\n", iter.index);

tools/testing/radix-tree/regression3.c

68

slot = radix_tree_iter_retry(&iter);

tools/testing/radix-tree/regression3.c

73

radix_tree_for_each_slot(slot, &root, &iter, 0) {

tools/testing/radix-tree/regression3.c

74

printv(2, "slot %ld %p\n", iter.index, *slot);

tools/testing/radix-tree/regression3.c

75

if (!iter.index) {

tools/testing/radix-tree/regression3.c

76

printv(2, "next at %ld\n", iter.index);

tools/testing/radix-tree/regression3.c

77

slot = radix_tree_iter_resume(slot, &iter);

tools/testing/radix-tree/regression3.c

83

radix_tree_for_each_tagged(slot, &root, &iter, 0, 0) {

tools/testing/radix-tree/regression3.c

84

printv(2, "tagged %ld %p\n", iter.index, *slot);

tools/testing/radix-tree/regression3.c

85

if (!iter.index) {

tools/testing/radix-tree/regression3.c

86

printv(2, "next at %ld\n", iter.index);

tools/testing/radix-tree/regression3.c

87

slot = radix_tree_iter_resume(slot, &iter);

tools/testing/selftests/alsa/conf.c

199

int iter = 0, ret;

tools/testing/selftests/alsa/conf.c

211

iter++;

tools/testing/selftests/alsa/conf.c

222

return iter > 0;

tools/testing/selftests/arm64/fp/kernel-test.c

313

printf("Failed to compute digest, iter=%d\n", iter);

tools/testing/selftests/arm64/fp/kernel-test.c

318

printf("Digest mismatch, iter=%d\n", iter);

tools/testing/selftests/arm64/fp/kernel-test.c

322

iter++;

tools/testing/selftests/arm64/fp/kernel-test.c

34

static int iter;

tools/testing/selftests/arm64/fp/kernel-test.c

39

sig, iter, sigs);

tools/testing/selftests/bpf/bench.c

159

void ops_report_progress(int iter, struct bench_res *res, long delta_ns)

tools/testing/selftests/bpf/bench.c

166

printf("Iter %3d (%7.3lfus): ", iter, (delta_ns - 1000000000) / 1000.0);

tools/testing/selftests/bpf/bench.c

192

void local_storage_report_progress(int iter, struct bench_res *res,

tools/testing/selftests/bpf/bench.c

201

printf("Iter %3d (%7.3lfus): ", iter, (delta_ns - 1000000000) / 1000.0);

tools/testing/selftests/bpf/bench.c

39

void false_hits_report_progress(int iter, struct bench_res *res, long delta_ns)

tools/testing/selftests/bpf/bench.c

44

iter, (delta_ns - 1000000000) / 1000.0);

tools/testing/selftests/bpf/bench.c

68

void hits_drops_report_progress(int iter, struct bench_res *res, long delta_ns)

tools/testing/selftests/bpf/bench.c

764

int iter = state.res_cnt++;

tools/testing/selftests/bpf/bench.c

765

struct bench_res *res = &state.results[iter];

tools/testing/selftests/bpf/bench.c

770

bench->report_progress(iter, res, delta_ns);

tools/testing/selftests/bpf/bench.c

772

if (iter == env.duration_sec + env.warmup_sec)

tools/testing/selftests/bpf/bench.c

78

iter, (delta_ns - 1000000000) / 1000.0);

tools/testing/selftests/bpf/bench.h

61

void (*report_progress)(int iter, struct bench_res* res, long delta_ns);

tools/testing/selftests/bpf/bench.h

74

void hits_drops_report_progress(int iter, struct bench_res *res, long delta_ns);

tools/testing/selftests/bpf/bench.h

76

void false_hits_report_progress(int iter, struct bench_res *res, long delta_ns);

tools/testing/selftests/bpf/bench.h

78

void ops_report_progress(int iter, struct bench_res *res, long delta_ns);

tools/testing/selftests/bpf/bench.h

80

void local_storage_report_progress(int iter, struct bench_res *res,

tools/testing/selftests/bpf/benchs/bench_htab_mem.c

309

static void htab_mem_report_progress(int iter, struct bench_res *res, long delta_ns)

tools/testing/selftests/bpf/benchs/bench_htab_mem.c

315

printf("Iter %3d (%7.3lfus): ", iter, (delta_ns - 1000000000) / 1000.0);

tools/testing/selftests/bpf/benchs/bench_local_storage_create.c

198

static void report_progress(int iter, struct bench_res *res, long delta_ns)

tools/testing/selftests/bpf/benchs/bench_local_storage_create.c

205

iter, (delta_ns - 1000000000) / 1000.0);

tools/testing/selftests/bpf/benchs/bench_local_storage_rcu_tasks_trace.c

207

static void report_progress(int iter, struct bench_res *res, long delta_ns)

tools/testing/selftests/bpf/benchs/bench_local_storage_rcu_tasks_trace.c

219

iter, res->gp_ns / (double)res->gp_ct);

tools/testing/selftests/bpf/benchs/bench_local_storage_rcu_tasks_trace.c

221

iter, res->stime / (double)res->gp_ct);

tools/testing/selftests/bpf/benchs/bench_lpm_trie_map.c

364

static void frac_second_report_progress(int iter, struct bench_res *res,

tools/testing/selftests/bpf/benchs/bench_lpm_trie_map.c

374

printf("Iter %3d (%7.3lfus): ", iter,

tools/testing/selftests/bpf/benchs/bench_lpm_trie_map.c

413

static void insert_ops_report_progress(int iter, struct bench_res *res,

tools/testing/selftests/bpf/benchs/bench_lpm_trie_map.c

419

frac_second_report_progress(iter, res, delta_ns, rate_divisor, rate);

tools/testing/selftests/bpf/benchs/bench_lpm_trie_map.c

422

static void delete_ops_report_progress(int iter, struct bench_res *res,

tools/testing/selftests/bpf/benchs/bench_lpm_trie_map.c

428

frac_second_report_progress(iter, res, delta_ns, rate_divisor, rate);

tools/testing/selftests/bpf/benchs/bench_lpm_trie_map.c

431

static void free_ops_report_progress(int iter, struct bench_res *res,

tools/testing/selftests/bpf/benchs/bench_lpm_trie_map.c

437

frac_second_report_progress(iter, res, delta_ns, rate_divisor, rate);

tools/testing/selftests/bpf/benchs/bench_sockmap.c

502

static void report_progress(int iter, struct bench_res *res, long delta_ns)

tools/testing/selftests/bpf/benchs/bench_sockmap.c

513

iter, (delta_ns - 1000000000) / 1000.0);

tools/testing/selftests/bpf/map_tests/lpm_trie_map_basic_ops.c

702

int iter;

tools/testing/selftests/bpf/map_tests/lpm_trie_map_basic_ops.c

712

int i, j, ret, iter, key_size;

tools/testing/selftests/bpf/map_tests/lpm_trie_map_basic_ops.c

718

for (iter = 0; iter < info->iter; iter++)

tools/testing/selftests/bpf/map_tests/lpm_trie_map_basic_ops.c

723

j = (iter < (info->iter / 2)) ? i : MAX_TEST_KEYS - i - 1;

tools/testing/selftests/bpf/map_tests/lpm_trie_map_basic_ops.c

750

info->iter = 2000;

tools/testing/selftests/bpf/prog_tests/bpf_iter.c

198

ASSERT_EQ(info.iter.task.tid, getpid(), "check_task_tid");

tools/testing/selftests/bpf/progs/bpf_iter_ksym.c

32

struct kallsym_iter *iter = ctx->ksym;

tools/testing/selftests/bpf/progs/bpf_iter_ksym.c

37

if (!iter)

tools/testing/selftests/bpf/progs/bpf_iter_ksym.c

45

BPF_SEQ_PRINTF(seq, "0x%x\n", iter->value - last_sym_value);

tools/testing/selftests/bpf/progs/bpf_iter_ksym.c

49

value = iter->show_value ? iter->value : 0;

tools/testing/selftests/bpf/progs/bpf_iter_ksym.c

53

type = iter->type;

tools/testing/selftests/bpf/progs/bpf_iter_ksym.c

55

if (iter->module_name[0]) {

tools/testing/selftests/bpf/progs/bpf_iter_ksym.c

56

type = iter->exported ? to_upper(type) : to_lower(type);

tools/testing/selftests/bpf/progs/bpf_iter_ksym.c

58

value, type, iter->name, iter->module_name);

tools/testing/selftests/bpf/progs/bpf_iter_ksym.c

60

BPF_SEQ_PRINTF(seq, "0x%llx %c %s ", value, type, iter->name);

tools/testing/selftests/bpf/progs/bpf_iter_ksym.c

62

if (!iter->pos_mod_end || iter->pos_mod_end > iter->pos)

tools/testing/selftests/bpf/progs/bpf_iter_ksym.c

64

else if (!iter->pos_ftrace_mod_end || iter->pos_ftrace_mod_end > iter->pos)

tools/testing/selftests/bpf/progs/bpf_iter_ksym.c

66

else if (!iter->pos_bpf_end || iter->pos_bpf_end > iter->pos)

tools/testing/selftests/bpf/progs/iters_looping.c

120

: __imm_ptr(iter), ITER_HELPERS

tools/testing/selftests/bpf/progs/iters_looping.c

132

struct bpf_iter_num iter;

tools/testing/selftests/bpf/progs/iters_looping.c

158

: __imm_ptr(iter), ITER_HELPERS

tools/testing/selftests/bpf/progs/iters_looping.c

168

struct bpf_iter_num iter;

tools/testing/selftests/bpf/progs/iters_looping.c

190

: __imm_ptr(iter), ITER_HELPERS

tools/testing/selftests/bpf/progs/iters_looping.c

35

struct bpf_iter_num iter;

tools/testing/selftests/bpf/progs/iters_looping.c

55

: __imm_ptr(iter), ITER_HELPERS

tools/testing/selftests/bpf/progs/iters_looping.c

66

struct bpf_iter_num iter;

tools/testing/selftests/bpf/progs/iters_looping.c

86

: __imm_ptr(iter), ITER_HELPERS

tools/testing/selftests/bpf/progs/iters_looping.c

99

struct bpf_iter_num iter;

tools/testing/selftests/bpf/progs/iters_state_safety.c

113

: __imm_ptr(iter), ITER_HELPERS

tools/testing/selftests/bpf/progs/iters_state_safety.c

124

struct bpf_iter_num iter;

tools/testing/selftests/bpf/progs/iters_state_safety.c

138

: __imm_ptr(iter), ITER_HELPERS

tools/testing/selftests/bpf/progs/iters_state_safety.c

149

struct bpf_iter_num iter;

tools/testing/selftests/bpf/progs/iters_state_safety.c

169

: __imm_ptr(iter), ITER_HELPERS, __imm(bpf_probe_read_kernel)

tools/testing/selftests/bpf/progs/iters_state_safety.c

178

struct bpf_iter_num iter;

tools/testing/selftests/bpf/progs/iters_state_safety.c

180

bpf_iter_num_new(&iter, 0, 1);

tools/testing/selftests/bpf/progs/iters_state_safety.c

202

struct bpf_iter_num iter;

tools/testing/selftests/bpf/progs/iters_state_safety.c

225

: __imm_ptr(iter), ITER_HELPERS

tools/testing/selftests/bpf/progs/iters_state_safety.c

236

struct bpf_iter_num iter;

tools/testing/selftests/bpf/progs/iters_state_safety.c

253

: __imm_ptr(iter), ITER_HELPERS

tools/testing/selftests/bpf/progs/iters_state_safety.c

264

struct bpf_iter_num iter;

tools/testing/selftests/bpf/progs/iters_state_safety.c

279

: __imm_ptr(iter), ITER_HELPERS

tools/testing/selftests/bpf/progs/iters_state_safety.c

290

struct bpf_iter_num iter;

tools/testing/selftests/bpf/progs/iters_state_safety.c

300

: __imm_ptr(iter), ITER_HELPERS

tools/testing/selftests/bpf/progs/iters_state_safety.c

311

struct bpf_iter_num iter;

tools/testing/selftests/bpf/progs/iters_state_safety.c

326

: __imm_ptr(iter), ITER_HELPERS

tools/testing/selftests/bpf/progs/iters_state_safety.c

36

struct bpf_iter_num iter;

tools/testing/selftests/bpf/progs/iters_state_safety.c

375

struct bpf_iter_num iter;

tools/testing/selftests/bpf/progs/iters_state_safety.c

417

: __imm_ptr(iter),

tools/testing/selftests/bpf/progs/iters_state_safety.c

48

: __imm_ptr(iter), ITER_HELPERS

tools/testing/selftests/bpf/progs/iters_state_safety.c

59

struct bpf_iter_num iter;

tools/testing/selftests/bpf/progs/iters_state_safety.c

68

: __imm_ptr(iter), ITER_HELPERS

tools/testing/selftests/bpf/progs/iters_state_safety.c

80

struct bpf_iter_num iter;

tools/testing/selftests/bpf/progs/iters_state_safety.c

86

: __imm_ptr(iter), ITER_HELPERS

tools/testing/selftests/bpf/progs/iters_state_safety.c

97

struct bpf_iter_num iter;

tools/testing/selftests/bpf/progs/verifier_bits_iter.c

204

struct bpf_iter_bits iter;

tools/testing/selftests/bpf/progs/verifier_bits_iter.c

209

err = bpf_iter_bits_new(&iter, bad_addr, 1);

tools/testing/selftests/bpf/progs/verifier_bits_iter.c

210

bpf_iter_bits_destroy(&iter);

tools/testing/selftests/bpf/progs/verifier_bits_iter.c

220

err = bpf_iter_bits_new(&iter, bad_addr, 4);

tools/testing/selftests/bpf/progs/verifier_bits_iter.c

221

bpf_iter_bits_destroy(&iter);

tools/testing/selftests/bpf/progs/verifier_bits_iter.c

60

struct bpf_iter_bits iter;

tools/testing/selftests/bpf/progs/verifier_bits_iter.c

64

err = bpf_iter_bits_new(&iter, NULL, 1);

tools/testing/selftests/bpf/progs/verifier_bits_iter.c

65

bpf_iter_bits_destroy(&iter);

tools/testing/selftests/bpf/progs/verifier_linked_scalars.c

486

struct bpf_iter_num iter;

tools/testing/selftests/bpf/progs/verifier_linked_scalars.c

527

: __imm_ptr(iter),

tools/testing/selftests/bpf/trace_helpers.c

481

int read_trace_pipe_iter(void (*cb)(const char *str, void *data), void *data, int iter)

tools/testing/selftests/bpf/trace_helpers.c

495

if (iter)

tools/testing/selftests/bpf/trace_helpers.c

501

if (iter && !(--iter))

tools/testing/selftests/bpf/trace_helpers.h

56

void *data, int iter);

tools/testing/selftests/kvm/lib/arm64/vgic.c

83

struct list_head *iter;

tools/testing/selftests/kvm/lib/arm64/vgic.c

92

list_for_each(iter, &vm->vcpus)

tools/testing/selftests/kvm/riscv/sbi_pmu_test.c

89

static inline void dummy_func_loop(u64 iter)

tools/testing/selftests/kvm/riscv/sbi_pmu_test.c

93

while (i < iter) {

tools/testing/selftests/kvm/x86/amx_test.c

278

int iter = 0;

tools/testing/selftests/kvm/x86/amx_test.c

288

++iter;

tools/testing/selftests/kvm/x86/amx_test.c

290

fprintf(stderr, "GUEST_SYNC #%d, save tiledata\n", iter);

tools/testing/selftests/kvm/x86/amx_test.c

294

fprintf(stderr, "GUEST_SYNC #%d, check TMM0 contents\n", iter);

tools/testing/selftests/kvm/x86/amx_test.c

307

fprintf(stderr, "GUEST_SYNC #%d, before KVM_SET_XSAVE\n", iter);

tools/testing/selftests/kvm/x86/amx_test.c

309

fprintf(stderr, "GUEST_SYNC #%d, after KVM_SET_XSAVE\n", iter);

tools/testing/selftests/kvm/x86/amx_test.c

312

fprintf(stderr, "GUEST_SYNC #%d, save/restore VM state\n", iter);

tools/testing/selftests/mm/folio_split_race_test.c

233

uint64_t iter;

tools/testing/selftests/mm/folio_split_race_test.c

256

for (iter = 0; iter < NUM_ITERATIONS; iter++) {

tools/testing/selftests/mm/folio_split_race_test.c

262

if (iter < NUM_ITERATIONS)

tools/testing/selftests/mm/folio_split_race_test.c

266

iter, corrupted_pages);

tools/testing/selftests/mm/folio_split_race_test.c

271

ksft_exit(iter == NUM_ITERATIONS);

tools/testing/selftests/mm/hugetlb-read-hwpoison.c

47

char iter = 0;

tools/testing/selftests/mm/hugetlb-read-hwpoison.c

51

iter++;

tools/testing/selftests/mm/hugetlb-read-hwpoison.c

52

memset(filemap + offset, iter, wr_chunk_size);

tools/testing/selftests/net/nettest.c

1316

if (iter != -1) {

tools/testing/selftests/net/nettest.c

1317

--iter;

tools/testing/selftests/net/nettest.c

1318

if (iter == 0)

tools/testing/selftests/net/nettest.c

141

static int iter = 1;

tools/testing/selftests/net/nettest.c

2098

iter = atoi(optarg);

tools/testing/selftests/net/nettest.c

2201

if (iter == 0) {

tools/testing/selftests/net/tcp_fastopen_backup_key.c

213

static int iter;

tools/testing/selftests/net/tcp_fastopen_backup_key.c

219

if (iter < N_LISTEN) {

tools/testing/selftests/net/tcp_fastopen_backup_key.c

221

if (iter == 0) {

tools/testing/selftests/net/tcp_fastopen_backup_key.c

236

if (++iter >= (N_LISTEN * 2))

tools/testing/selftests/net/tcp_fastopen_backup_key.c

237

iter = 0;

tools/testing/selftests/perf_events/sigtrap_threads.c

101

ctx.iterate_on = iter; /* idempotent write */

tools/testing/selftests/perf_events/sigtrap_threads.c

91

int iter;

tools/testing/selftests/perf_events/sigtrap_threads.c

97

iter = ctx.iterate_on; /* read */

tools/testing/selftests/perf_events/sigtrap_threads.c

98

if (iter >= 0) {

tools/testing/selftests/perf_events/sigtrap_threads.c

99

for (i = 0; i < iter - 1; i++) {

tools/testing/selftests/pidfd/pidfd_poll_test.c

29

int iter, nevents;

tools/testing/selftests/pidfd/pidfd_poll_test.c

47

for (iter = 0; iter < nr_iterations; iter++) {

tools/testing/selftests/pidfd/pidfd_poll_test.c

53

iter--;

tools/testing/selftests/powerpc/security/entry_flush.c

112

iter = repetitions;

tools/testing/selftests/powerpc/security/entry_flush.c

24

int fd, passes = 0, iter, rc = 0;

tools/testing/selftests/powerpc/security/entry_flush.c

66

iter = repetitions;

tools/testing/selftests/powerpc/security/entry_flush.c

88

while (--iter)

tools/testing/selftests/powerpc/security/rfi_flush.c

112

iter = repetitions;

tools/testing/selftests/powerpc/security/rfi_flush.c

24

int fd, passes = 0, iter, rc = 0;

tools/testing/selftests/powerpc/security/rfi_flush.c

67

iter = repetitions;

tools/testing/selftests/powerpc/security/rfi_flush.c

89

while (--iter)

tools/testing/selftests/powerpc/security/uaccess_flush.c

102

while (--iter)

tools/testing/selftests/powerpc/security/uaccess_flush.c

126

iter = repetitions;

tools/testing/selftests/powerpc/security/uaccess_flush.c

25

int fd, passes = 0, iter, rc = 0;

tools/testing/selftests/powerpc/security/uaccess_flush.c

80

iter = repetitions;

virt/kvm/kvm_main.c

1984

struct kvm_memslot_iter iter;

virt/kvm/kvm_main.c

1986

kvm_for_each_memslot_in_gfn_range(&iter, slots, start, end) {

virt/kvm/kvm_main.c

1987

if (iter.slot->id != id)

virt/kvm/kvm_main.c

2471

struct kvm_memslot_iter iter;

virt/kvm/kvm_main.c

2490

kvm_for_each_memslot_in_gfn_range(&iter, slots, range->start, range->end) {

virt/kvm/kvm_main.c

2491

slot = iter.slot;