arch/loongarch/include/asm/cacheflush.h

57

static inline void flush_cache_line(int leaf, unsigned long addr)

arch/loongarch/include/asm/cacheflush.h

59

switch (leaf) {

arch/loongarch/mm/cache.c

112

cdesc++; leaf++; \

arch/loongarch/mm/cache.c

117

unsigned int leaf = 0, level = 1;

arch/loongarch/mm/cache.c

126

populate_cache_properties(config, cdesc, level, leaf);

arch/loongarch/mm/cache.c

131

populate_cache_properties(config, cdesc, level, leaf);

arch/loongarch/mm/cache.c

144

populate_cache_properties(config, cdesc, level, leaf);

arch/loongarch/mm/cache.c

149

populate_cache_properties(config, cdesc, level, leaf);

arch/loongarch/mm/cache.c

155

BUG_ON(leaf > CACHE_LEAVES_MAX);

arch/loongarch/mm/cache.c

157

current_cpu_data.cache_leaves_present = leaf;

arch/loongarch/mm/cache.c

44

static void flush_cache_leaf(unsigned int leaf)

arch/loongarch/mm/cache.c

48

struct cache_desc *cdesc = current_cpu_data.cache_leaves + leaf;

arch/loongarch/mm/cache.c

55

flush_cache_line(leaf, addr);

arch/loongarch/mm/cache.c

68

int leaf;

arch/loongarch/mm/cache.c

72

leaf = cache_present - 1;

arch/loongarch/mm/cache.c

73

if (cache_inclusive(cdesc + leaf)) {

arch/loongarch/mm/cache.c

74

flush_cache_leaf(leaf);

arch/loongarch/mm/cache.c

78

for (leaf = 0; leaf < cache_present; leaf++)

arch/loongarch/mm/cache.c

79

flush_cache_leaf(leaf);

arch/loongarch/mm/cache.c

94

#define populate_cache_properties(cfg0, cdesc, level, leaf) \

arch/loongarch/mm/cache.c

98

cfg1 = read_cpucfg(LOONGARCH_CPUCFG17 + leaf); \

arch/mips/kernel/cacheinfo.c

10

leaf->type = c_type; \

arch/mips/kernel/cacheinfo.c

11

leaf->level = c_level; \

arch/mips/kernel/cacheinfo.c

12

leaf->coherency_line_size = c->cache.linesz; \

arch/mips/kernel/cacheinfo.c

13

leaf->number_of_sets = c->cache.sets; \

arch/mips/kernel/cacheinfo.c

14

leaf->ways_of_associativity = c->cache.ways; \

arch/mips/kernel/cacheinfo.c

15

leaf->size = c->cache.linesz * c->cache.sets * \

arch/mips/kernel/cacheinfo.c

17

leaf++; \

arch/mips/kernel/cacheinfo.c

8

#define populate_cache(cache, leaf, c_level, c_type) \

arch/mips/kernel/process.c

553

int leaf;

arch/mips/kernel/process.c

611

leaf = get_frame_info(&info);

arch/mips/kernel/process.c

612

if (leaf < 0)

arch/mips/kernel/process.c

618

if (leaf)

arch/powerpc/kvm/book3s_64_mmu_radix.c

1380

goto leaf;

arch/powerpc/kvm/book3s_64_mmu_radix.c

1392

goto leaf;

arch/powerpc/kvm/book3s_64_mmu_radix.c

1402

leaf:

arch/s390/kvm/dat.c

387

bool leaf = flags & DAT_WALK_LEAF;

arch/s390/kvm/dat.c

456

if (walk_level == TABLE_TYPE_REGION3 || ((leaf || any) && entry.pud.h.fc))

arch/s390/kvm/dat.c

487

if (walk_level == TABLE_TYPE_SEGMENT || ((leaf || any) && entry.pmd.h.fc))

arch/x86/boot/startup/sev-shared.c

169

static int __sev_cpuid_hv_msr(struct cpuid_leaf *leaf)

arch/x86/boot/startup/sev-shared.c

181

if (cpuid_function_is_indexed(leaf->fn) && leaf->subfn)

arch/x86/boot/startup/sev-shared.c

184

ret = __sev_cpuid_hv(leaf->fn, GHCB_CPUID_REQ_EAX, &leaf->eax);

arch/x86/boot/startup/sev-shared.c

185

ret = ret ? : __sev_cpuid_hv(leaf->fn, GHCB_CPUID_REQ_EBX, &leaf->ebx);

arch/x86/boot/startup/sev-shared.c

186

ret = ret ? : __sev_cpuid_hv(leaf->fn, GHCB_CPUID_REQ_ECX, &leaf->ecx);

arch/x86/boot/startup/sev-shared.c

187

ret = ret ? : __sev_cpuid_hv(leaf->fn, GHCB_CPUID_REQ_EDX, &leaf->edx);

arch/x86/boot/startup/sev-shared.c

262

snp_cpuid_get_validated_func(struct cpuid_leaf *leaf)

arch/x86/boot/startup/sev-shared.c

270

if (e->eax_in != leaf->fn)

arch/x86/boot/startup/sev-shared.c

273

if (cpuid_function_is_indexed(leaf->fn) && e->ecx_in != leaf->subfn)

arch/x86/boot/startup/sev-shared.c

286

leaf->eax = e->eax;

arch/x86/boot/startup/sev-shared.c

287

leaf->ebx = e->ebx;

arch/x86/boot/startup/sev-shared.c

288

leaf->ecx = e->ecx;

arch/x86/boot/startup/sev-shared.c

289

leaf->edx = e->edx;

arch/x86/boot/startup/sev-shared.c

297

static void snp_cpuid_hv_msr(void *ctx, struct cpuid_leaf *leaf)

arch/x86/boot/startup/sev-shared.c

299

if (__sev_cpuid_hv_msr(leaf))

arch/x86/boot/startup/sev-shared.c

304

snp_cpuid_postprocess(void (*cpuid_fn)(void *ctx, struct cpuid_leaf *leaf),

arch/x86/boot/startup/sev-shared.c

305

void *ctx, struct cpuid_leaf *leaf)

arch/x86/boot/startup/sev-shared.c

307

struct cpuid_leaf leaf_hv = *leaf;

arch/x86/boot/startup/sev-shared.c

309

switch (leaf->fn) {

arch/x86/boot/startup/sev-shared.c

314

leaf->ebx = (leaf_hv.ebx & GENMASK(31, 24)) | (leaf->ebx & GENMASK(23, 0));

arch/x86/boot/startup/sev-shared.c

316

leaf->edx = (leaf_hv.edx & BIT(9)) | (leaf->edx & ~BIT(9));

arch/x86/boot/startup/sev-shared.c

320

leaf->ecx |= BIT(27);

arch/x86/boot/startup/sev-shared.c

324

leaf->ecx &= ~BIT(4);

arch/x86/boot/startup/sev-shared.c

326

leaf->ecx |= BIT(4);

arch/x86/boot/startup/sev-shared.c

333

leaf->edx = leaf_hv.edx;

arch/x86/boot/startup/sev-shared.c

340

if (leaf->subfn != 0 && leaf->subfn != 1)

arch/x86/boot/startup/sev-shared.c

345

if (leaf->subfn == 1) {

arch/x86/boot/startup/sev-shared.c

347

if (leaf->eax & BIT(3)) {

arch/x86/boot/startup/sev-shared.c

364

if (!(leaf->eax & (BIT(1) | BIT(3))))

arch/x86/boot/startup/sev-shared.c

374

leaf->ebx = xsave_size;

arch/x86/boot/startup/sev-shared.c

381

leaf->eax = leaf_hv.eax;

arch/x86/boot/startup/sev-shared.c

383

leaf->ebx = (leaf->ebx & GENMASK(31, 8)) | (leaf_hv.ebx & GENMASK(7, 0));

arch/x86/boot/startup/sev-shared.c

385

leaf->ecx = (leaf->ecx & GENMASK(31, 8)) | (leaf_hv.ecx & GENMASK(7, 0));

arch/x86/boot/startup/sev-shared.c

399

int snp_cpuid(void (*cpuid_fn)(void *ctx, struct cpuid_leaf *leaf),

arch/x86/boot/startup/sev-shared.c

400

void *ctx, struct cpuid_leaf *leaf)

arch/x86/boot/startup/sev-shared.c

407

if (!snp_cpuid_get_validated_func(leaf)) {

arch/x86/boot/startup/sev-shared.c

425

leaf->eax = leaf->ebx = leaf->ecx = leaf->edx = 0;

arch/x86/boot/startup/sev-shared.c

428

if (!(leaf->fn <= cpuid_std_range_max ||

arch/x86/boot/startup/sev-shared.c

429

(leaf->fn >= 0x40000000 && leaf->fn <= cpuid_hyp_range_max) ||

arch/x86/boot/startup/sev-shared.c

430

(leaf->fn >= 0x80000000 && leaf->fn <= cpuid_ext_range_max)))

arch/x86/boot/startup/sev-shared.c

434

return snp_cpuid_postprocess(cpuid_fn, ctx, leaf);

arch/x86/boot/startup/sev-shared.c

447

struct cpuid_leaf leaf;

arch/x86/boot/startup/sev-shared.c

458

leaf.fn = fn;

arch/x86/boot/startup/sev-shared.c

459

leaf.subfn = subfn;

arch/x86/boot/startup/sev-shared.c

468

ret = snp_cpuid(snp_cpuid_hv_msr, NULL, &leaf);

arch/x86/boot/startup/sev-shared.c

479

if (__sev_cpuid_hv_msr(&leaf))

arch/x86/boot/startup/sev-shared.c

483

regs->ax = leaf.eax;

arch/x86/boot/startup/sev-shared.c

484

regs->bx = leaf.ebx;

arch/x86/boot/startup/sev-shared.c

485

regs->cx = leaf.ecx;

arch/x86/boot/startup/sev-shared.c

486

regs->dx = leaf.edx;

arch/x86/coco/sev/vc-shared.c

463

static int __sev_cpuid_hv_ghcb(struct ghcb *ghcb, struct es_em_ctxt *ctxt, struct cpuid_leaf *leaf)

arch/x86/coco/sev/vc-shared.c

468

ghcb_set_rax(ghcb, leaf->fn);

arch/x86/coco/sev/vc-shared.c

469

ghcb_set_rcx(ghcb, leaf->subfn);

arch/x86/coco/sev/vc-shared.c

488

leaf->eax = ghcb->save.rax;

arch/x86/coco/sev/vc-shared.c

489

leaf->ebx = ghcb->save.rbx;

arch/x86/coco/sev/vc-shared.c

490

leaf->ecx = ghcb->save.rcx;

arch/x86/coco/sev/vc-shared.c

491

leaf->edx = ghcb->save.rdx;

arch/x86/coco/sev/vc-shared.c

501

static void snp_cpuid_hv_ghcb(void *p, struct cpuid_leaf *leaf)

arch/x86/coco/sev/vc-shared.c

505

if (__sev_cpuid_hv_ghcb(ctx->ghcb, ctx->ctxt, leaf))

arch/x86/coco/sev/vc-shared.c

513

struct cpuid_leaf leaf;

arch/x86/coco/sev/vc-shared.c

516

leaf.fn = regs->ax;

arch/x86/coco/sev/vc-shared.c

517

leaf.subfn = regs->cx;

arch/x86/coco/sev/vc-shared.c

518

ret = snp_cpuid(snp_cpuid_hv_ghcb, &ctx, &leaf);

arch/x86/coco/sev/vc-shared.c

520

regs->ax = leaf.eax;

arch/x86/coco/sev/vc-shared.c

521

regs->bx = leaf.ebx;

arch/x86/coco/sev/vc-shared.c

522

regs->cx = leaf.ecx;

arch/x86/coco/sev/vc-shared.c

523

regs->dx = leaf.edx;

arch/x86/events/intel/pt.c

49

[PT_CAP_ ## _n] = { .name = __stringify(_n), .leaf = _l, \

arch/x86/events/intel/pt.c

54

u32 leaf;

arch/x86/events/intel/pt.c

81

u32 c = caps[cd->leaf * PT_CPUID_REGS_NUM + cd->reg];

arch/x86/include/asm/cpuid/api.h

127

static inline void __cpuid_read(u32 leaf, u32 subleaf, u32 *regs)

arch/x86/include/asm/cpuid/api.h

129

regs[CPUID_EAX] = leaf;

arch/x86/include/asm/cpuid/api.h

134

#define cpuid_subleaf(leaf, subleaf, regs) { \

arch/x86/include/asm/cpuid/api.h

136

__cpuid_read(leaf, subleaf, (u32 *)(regs)); \

arch/x86/include/asm/cpuid/api.h

139

#define cpuid_leaf(leaf, regs) { \

arch/x86/include/asm/cpuid/api.h

141

__cpuid_read(leaf, 0, (u32 *)(regs)); \

arch/x86/include/asm/cpuid/api.h

144

static inline void __cpuid_read_reg(u32 leaf, u32 subleaf,

arch/x86/include/asm/cpuid/api.h

149

__cpuid_read(leaf, subleaf, regs);

arch/x86/include/asm/cpuid/api.h

153

#define cpuid_subleaf_reg(leaf, subleaf, regidx, reg) { \

arch/x86/include/asm/cpuid/api.h

155

__cpuid_read_reg(leaf, subleaf, regidx, (u32 *)(reg)); \

arch/x86/include/asm/cpuid/api.h

158

#define cpuid_leaf_reg(leaf, regidx, reg) { \

arch/x86/include/asm/cpuid/api.h

160

__cpuid_read_reg(leaf, 0, regidx, (u32 *)(reg)); \

arch/x86/include/asm/sev.h

557

int snp_cpuid(void (*cpuid_fn)(void *ctx, struct cpuid_leaf *leaf),

arch/x86/include/asm/sev.h

558

void *ctx, struct cpuid_leaf *leaf);

arch/x86/kernel/cpu/topology_amd.c

105

store_node(tscan, leaf.nnodes_per_socket + 1, leaf.node_id);

arch/x86/kernel/cpu/topology_amd.c

109

tscan->c->topo.cu_id = leaf.core_id;

arch/x86/kernel/cpu/topology_amd.c

111

cacheinfo_amd_init_llc_id(tscan->c, leaf.node_id);

arch/x86/kernel/cpu/topology_amd.c

77

} leaf;

arch/x86/kernel/cpu/topology_amd.c

82

cpuid_leaf(0x8000001e, &leaf);

arch/x86/kernel/cpu/topology_amd.c

89

tscan->c->topo.initial_apicid = leaf.ext_apic_id;

arch/x86/kernel/cpu/topology_amd.c

98

unsigned int nthreads = leaf.core_nthreads + 1;

arch/x86/kernel/cpu/topology_ext.c

104

static bool parse_topology_leaf(struct topo_scan *tscan, u32 leaf)

arch/x86/kernel/cpu/topology_ext.c

110

for (subleaf = 0, last_dom = 0; topo_subleaf(tscan, leaf, subleaf, &last_dom); subleaf++);

arch/x86/kernel/cpu/topology_ext.c

125

leaf, tscan->dom_ncpus[TOPO_SMT_DOMAIN]);

arch/x86/kernel/cpu/topology_ext.c

45

static inline bool topo_subleaf(struct topo_scan *tscan, u32 leaf, u32 subleaf,

arch/x86/kernel/cpu/topology_ext.c

66

switch (leaf) {

arch/x86/kernel/cpu/topology_ext.c

73

cpuid_subleaf(leaf, subleaf, &sl);

arch/x86/kernel/cpu/topology_ext.c

80

leaf, subleaf, sl.type);

arch/x86/kernel/cpu/topology_ext.c

97

leaf, subleaf, tscan->c->topo.initial_apicid, sl.x2apic_id);

arch/x86/kvm/cpuid.c

703

#define kvm_cpu_cap_init(leaf, feature_initializers...) \

arch/x86/kvm/cpuid.c

705

const struct cpuid_reg cpuid = x86_feature_cpuid(leaf * 32); \

arch/x86/kvm/cpuid.c

706

const u32 __maybe_unused kvm_cpu_cap_init_in_progress = leaf; \

arch/x86/kvm/cpuid.c

715

kvm_cpu_caps[leaf] = kvm_cpu_cap_features; \

arch/x86/kvm/cpuid.c

717

if (leaf < NCAPINTS) \

arch/x86/kvm/cpuid.c

718

kvm_cpu_caps[leaf] &= kernel_cpu_caps[leaf]; \

arch/x86/kvm/cpuid.c

720

kvm_cpu_caps[leaf] |= kvm_cpu_cap_passthrough; \

arch/x86/kvm/cpuid.c

721

kvm_cpu_caps[leaf] &= (raw_cpuid_get(cpuid) | \

arch/x86/kvm/cpuid.c

723

kvm_cpu_caps[leaf] |= kvm_cpu_cap_emulated; \

arch/x86/kvm/cpuid.h

94

unsigned int leaf)

arch/x86/kvm/cpuid.h

96

u32 *reg = cpuid_entry_get_reg(entry, leaf * 32);

arch/x86/kvm/cpuid.h

98

BUILD_BUG_ON(leaf >= ARRAY_SIZE(kvm_cpu_caps));

arch/x86/kvm/cpuid.h

99

*reg = kvm_cpu_caps[leaf];

arch/x86/kvm/mmu/mmu.c

4369

int leaf = -1;

arch/x86/kvm/mmu/mmu.c

4376

leaf = iterator.level;

arch/x86/kvm/mmu/mmu.c

4379

sptes[leaf] = spte;

arch/x86/kvm/mmu/mmu.c

4382

return leaf;

arch/x86/kvm/mmu/mmu.c

4388

int leaf;

arch/x86/kvm/mmu/mmu.c

4393

leaf = kvm_tdp_mmu_get_walk(vcpu, addr, sptes, root_level);

arch/x86/kvm/mmu/mmu.c

4395

leaf = get_walk(vcpu, addr, sptes, root_level);

arch/x86/kvm/mmu/mmu.c

4398

return leaf;

arch/x86/kvm/mmu/mmu.c

4406

int root, leaf, level;

arch/x86/kvm/mmu/mmu.c

4409

leaf = get_sptes_lockless(vcpu, addr, sptes, &root);

arch/x86/kvm/mmu/mmu.c

4410

if (unlikely(leaf < 0)) {

arch/x86/kvm/mmu/mmu.c

4415

*sptep = sptes[leaf];

arch/x86/kvm/mmu/mmu.c

4423

if (!is_shadow_present_pte(sptes[leaf]))

arch/x86/kvm/mmu/mmu.c

4424

leaf++;

arch/x86/kvm/mmu/mmu.c

4428

for (level = root; level >= leaf; level--)

arch/x86/kvm/mmu/mmu.c

4434

for (level = root; level >= leaf; level--)

arch/x86/kvm/mmu/mmu.c

6474

int root_level, leaf, level;

arch/x86/kvm/mmu/mmu.c

6476

leaf = get_sptes_lockless(vcpu, gpa, sptes, &root_level);

arch/x86/kvm/mmu/mmu.c

6477

if (unlikely(leaf < 0))

arch/x86/kvm/mmu/mmu.c

6481

for (level = root_level; level >= leaf; level--)

arch/x86/kvm/mmu/tdp_mmu.c

1945

int leaf = -1;

arch/x86/kvm/mmu/tdp_mmu.c

1950

leaf = iter.level;

arch/x86/kvm/mmu/tdp_mmu.c

1951

sptes[leaf] = iter.old_spte;

arch/x86/kvm/mmu/tdp_mmu.c

1954

return leaf;

arch/x86/kvm/vmx/sgx.c

359

static inline bool encls_leaf_enabled_in_guest(struct kvm_vcpu *vcpu, u32 leaf)

arch/x86/kvm/vmx/sgx.c

365

if (leaf >= ECREATE && leaf <= ETRACK)

arch/x86/kvm/vmx/sgx.c

368

if (leaf >= EAUG && leaf <= EMODT)

arch/x86/kvm/vmx/sgx.c

383

u32 leaf = (u32)kvm_rax_read(vcpu);

arch/x86/kvm/vmx/sgx.c

388

} else if (!encls_leaf_enabled_in_guest(vcpu, leaf) ||

arch/x86/kvm/vmx/sgx.c

392

if (leaf == ECREATE)

arch/x86/kvm/vmx/sgx.c

394

if (leaf == EINIT)

arch/x86/kvm/vmx/sgx.c

396

WARN_ONCE(1, "unexpected exit on ENCLS[%u]", leaf);

arch/x86/kvm/vmx/tdx.c

1524

vcpu->run->tdx.get_tdvmcall_info.leaf = tdx->vp_enter_args.r12;

arch/x86/kvm/vmx/tdx.c

2582

static int tdx_read_cpuid(struct kvm_vcpu *vcpu, u32 leaf, u32 sub_leaf,

arch/x86/kvm/vmx/tdx.c

2597

if (leaf & TDX_MD_UNREADABLE_LEAF_MASK ||

arch/x86/kvm/vmx/tdx.c

2612

field_id |= ((leaf & 0x80000000) ? 1 : 0) << 16;

arch/x86/kvm/vmx/tdx.c

2613

field_id |= (leaf & 0x7f) << 9;

arch/x86/kvm/vmx/tdx.c

2638

out->function = leaf;

arch/x86/kvm/vmx/tdx.c

2646

if (leaf == 0x80000008) {

arch/x86/kvm/vmx/tdx.c

2977

static int tdx_vcpu_get_cpuid_leaf(struct kvm_vcpu *vcpu, u32 leaf, int *entry_index,

arch/x86/kvm/vmx/tdx.c

2984

ret = tdx_read_cpuid(vcpu, leaf, 0, false, entry_index, output_e);

arch/x86/kvm/vmx/tdx.c

2996

if (tdx_read_cpuid(vcpu, leaf, sub_leaf, true, entry_index, output_e))

arch/x86/kvm/vmx/tdx.c

3010

int r = 0, i = 0, leaf;

arch/x86/kvm/vmx/tdx.c

3032

for (leaf = 1; leaf <= level; leaf++)

arch/x86/kvm/vmx/tdx.c

3033

tdx_vcpu_get_cpuid_leaf(vcpu, leaf, &i, &td_cpuid->entries[i]);

arch/x86/kvm/vmx/tdx.c

3042

for (leaf = 0x80000001; leaf <= level; leaf++)

arch/x86/kvm/vmx/tdx.c

3043

tdx_vcpu_get_cpuid_leaf(vcpu, leaf, &i, &td_cpuid->entries[i]);

arch/x86/xen/p2m.c

154

static void p2m_mid_mfn_init(unsigned long *mid, unsigned long *leaf)

arch/x86/xen/p2m.c

159

mid[i] = virt_to_mfn(leaf);

drivers/base/arch_topology.c

504

bool leaf = true;

drivers/base/arch_topology.c

516

leaf = false;

drivers/base/arch_topology.c

534

if (!leaf) {

drivers/base/arch_topology.c

543

} else if (leaf && cpu != -ENODEV) {

drivers/base/arch_topology.c

555

bool leaf = true;

drivers/base/arch_topology.c

574

leaf = false;

drivers/base/arch_topology.c

600

if (leaf) {

drivers/base/arch_topology.c

613

if (leaf && !has_cores)

drivers/crypto/intel/qat/qat_common/adf_rl.c

185

*sla_arr = rl_data->leaf;

drivers/crypto/intel/qat/qat_common/adf_rl.c

499

sla_list = rl_data->leaf;

drivers/crypto/intel/qat/qat_common/adf_rl.h

116

struct rl_sla *leaf[RL_LEAF_MAX];

drivers/firewire/core-device.c

128

const u32 *leaf = search_leaf(directory, key);

drivers/firewire/core-device.c

129

if (!leaf)

drivers/firewire/core-device.c

132

return textual_leaf_to_string(leaf, buf, size);

drivers/firewire/sbp2.c

1001

if ((leaf[0] & 0xffff0000) == 0x00020000)

drivers/firewire/sbp2.c

1002

tgt->guid = (u64)leaf[1] << 32 | leaf[2];

drivers/firewire/sbp2.c

999

const u32 *leaf)

drivers/gpu/drm/i915/selftests/i915_syncmap.c

146

static int check_seqno(struct i915_syncmap *leaf, unsigned int idx, u32 seqno)

drivers/gpu/drm/i915/selftests/i915_syncmap.c

148

if (leaf->height) {

drivers/gpu/drm/i915/selftests/i915_syncmap.c

150

__func__, leaf->height);

drivers/gpu/drm/i915/selftests/i915_syncmap.c

154

if (__sync_seqno(leaf)[idx] != seqno) {

drivers/gpu/drm/i915/selftests/i915_syncmap.c

156

__func__, idx, __sync_seqno(leaf)[idx], seqno);

drivers/gpu/drm/i915/selftests/i915_syncmap.c

508

struct i915_syncmap *leaf = __sync_child(sync)[idx];

drivers/gpu/drm/i915/selftests/i915_syncmap.c

510

if (leaf->height) {

drivers/gpu/drm/i915/selftests/i915_syncmap.c

516

if (leaf->parent != sync) {

drivers/gpu/drm/i915/selftests/i915_syncmap.c

523

if (!is_power_of_2(leaf->bitmap)) {

drivers/gpu/drm/i915/selftests/i915_syncmap.c

525

idx, leaf->bitmap, hweight32(leaf->bitmap));

drivers/gpu/drm/i915/selftests/i915_syncmap.c

530

if (leaf->bitmap != BIT(idx)) {

drivers/gpu/drm/i915/selftests/i915_syncmap.c

532

idx, ilog2(leaf->bitmap), idx);

drivers/gpu/drm/nouveau/include/nvkm/core/intr.h

24

void (*block)(struct nvkm_intr *, int leaf, u32 mask);

drivers/gpu/drm/nouveau/include/nvkm/core/intr.h

25

void (*allow)(struct nvkm_intr *, int leaf, u32 mask);

drivers/gpu/drm/nouveau/include/nvkm/core/intr.h

26

void (*reset)(struct nvkm_intr *, int leaf, u32 mask);

drivers/gpu/drm/nouveau/include/nvkm/core/intr.h

31

int leaf;

drivers/gpu/drm/nouveau/include/nvkm/core/intr.h

60

int leaf;

drivers/gpu/drm/nouveau/nvkm/core/intr.c

107

int leaf;

drivers/gpu/drm/nouveau/nvkm/core/intr.c

110

intr = nvkm_intr_find(subdev, type, &leaf, &mask);

drivers/gpu/drm/nouveau/nvkm/core/intr.c

112

nvkm_debug(intr->subdev, "intr %d/%08x allowed by %s\n", leaf, mask, subdev->name);

drivers/gpu/drm/nouveau/nvkm/core/intr.c

114

nvkm_intr_allow_locked(intr, leaf, mask);

drivers/gpu/drm/nouveau/nvkm/core/intr.c

120

nvkm_intr_block_locked(struct nvkm_intr *intr, int leaf, u32 mask)

drivers/gpu/drm/nouveau/nvkm/core/intr.c

122

intr->mask[leaf] &= ~mask;

drivers/gpu/drm/nouveau/nvkm/core/intr.c

124

intr->func->block(intr, leaf, mask);

drivers/gpu/drm/nouveau/nvkm/core/intr.c

133

int leaf;

drivers/gpu/drm/nouveau/nvkm/core/intr.c

136

intr = nvkm_intr_find(subdev, type, &leaf, &mask);

drivers/gpu/drm/nouveau/nvkm/core/intr.c

138

nvkm_debug(intr->subdev, "intr %d/%08x blocked by %s\n", leaf, mask, subdev->name);

drivers/gpu/drm/nouveau/nvkm/core/intr.c

140

nvkm_intr_block_locked(intr, leaf, mask);

drivers/gpu/drm/nouveau/nvkm/core/intr.c

171

int prio, leaf;

drivers/gpu/drm/nouveau/nvkm/core/intr.c

199

if (intr->stat[inth->leaf] & inth->mask) {

drivers/gpu/drm/nouveau/nvkm/core/intr.c

202

intr->func->reset(intr, inth->leaf, inth->mask);

drivers/gpu/drm/nouveau/nvkm/core/intr.c

213

for (leaf = 0; leaf < intr->leaves; leaf++) {

drivers/gpu/drm/nouveau/nvkm/core/intr.c

214

if (intr->stat[leaf]) {

drivers/gpu/drm/nouveau/nvkm/core/intr.c

216

leaf, intr->stat[leaf]);

drivers/gpu/drm/nouveau/nvkm/core/intr.c

217

nvkm_intr_block_locked(intr, leaf, intr->stat[leaf]);

drivers/gpu/drm/nouveau/nvkm/core/intr.c

30

enum nvkm_intr_type type, int *leaf, u32 *mask)

drivers/gpu/drm/nouveau/nvkm/core/intr.c

414

if ((intr->mask[inth->leaf] & inth->mask) != inth->mask)

drivers/gpu/drm/nouveau/nvkm/core/intr.c

415

nvkm_intr_allow_locked(intr, inth->leaf, inth->mask);

drivers/gpu/drm/nouveau/nvkm/core/intr.c

430

ret = nvkm_intr_xlat(subdev, intr, type, &inth->leaf, &inth->mask);

drivers/gpu/drm/nouveau/nvkm/core/intr.c

435

inth->leaf, inth->mask, subdev->name);

drivers/gpu/drm/nouveau/nvkm/core/intr.c

46

*leaf = data->leaf;

drivers/gpu/drm/nouveau/nvkm/core/intr.c

54

*leaf = data->leaf;

drivers/gpu/drm/nouveau/nvkm/core/intr.c

66

*leaf = type / 32;

drivers/gpu/drm/nouveau/nvkm/core/intr.c

76

nvkm_intr_find(struct nvkm_subdev *subdev, enum nvkm_intr_type type, int *leaf, u32 *mask)

drivers/gpu/drm/nouveau/nvkm/core/intr.c

82

ret = nvkm_intr_xlat(subdev, intr, type, leaf, mask);

drivers/gpu/drm/nouveau/nvkm/core/intr.c

91

nvkm_intr_allow_locked(struct nvkm_intr *intr, int leaf, u32 mask)

drivers/gpu/drm/nouveau/nvkm/core/intr.c

93

intr->mask[leaf] |= mask;

drivers/gpu/drm/nouveau/nvkm/core/intr.c

96

intr->func->reset(intr, leaf, mask);

drivers/gpu/drm/nouveau/nvkm/core/intr.c

97

intr->func->allow(intr, leaf, mask);

drivers/gpu/drm/nouveau/nvkm/subdev/mc/gp100.c

48

gp100_mc_intr_allow(struct nvkm_intr *intr, int leaf, u32 mask)

drivers/gpu/drm/nouveau/nvkm/subdev/mc/gp100.c

52

nvkm_wr32(mc->subdev.device, 0x000160 + (leaf * 4), mask);

drivers/gpu/drm/nouveau/nvkm/subdev/mc/gp100.c

56

gp100_mc_intr_block(struct nvkm_intr *intr, int leaf, u32 mask)

drivers/gpu/drm/nouveau/nvkm/subdev/mc/gp100.c

60

nvkm_wr32(mc->subdev.device, 0x000180 + (leaf * 4), mask);

drivers/gpu/drm/nouveau/nvkm/subdev/mc/gt215.c

57

gt215_mc_intr_allow(struct nvkm_intr *intr, int leaf, u32 mask)

drivers/gpu/drm/nouveau/nvkm/subdev/mc/gt215.c

61

nvkm_mask(mc->subdev.device, 0x000640 + (leaf * 4), mask, mask);

drivers/gpu/drm/nouveau/nvkm/subdev/mc/gt215.c

65

gt215_mc_intr_block(struct nvkm_intr *intr, int leaf, u32 mask)

drivers/gpu/drm/nouveau/nvkm/subdev/mc/gt215.c

69

nvkm_mask(mc->subdev.device, 0x000640 + (leaf * 4), mask, 0);

drivers/gpu/drm/nouveau/nvkm/subdev/mc/nv04.c

100

for (leaf = 0; leaf < intr->leaves; leaf++) {

drivers/gpu/drm/nouveau/nvkm/subdev/mc/nv04.c

101

intr->stat[leaf] = nvkm_rd32(mc->subdev.device, 0x000100 + (leaf * 4));

drivers/gpu/drm/nouveau/nvkm/subdev/mc/nv04.c

102

if (intr->stat[leaf])

drivers/gpu/drm/nouveau/nvkm/subdev/mc/nv04.c

75

int leaf;

drivers/gpu/drm/nouveau/nvkm/subdev/mc/nv04.c

77

for (leaf = 0; leaf < intr->leaves; leaf++)

drivers/gpu/drm/nouveau/nvkm/subdev/mc/nv04.c

78

nvkm_wr32(mc->subdev.device, 0x000140 + (leaf * 4), 0x00000001);

drivers/gpu/drm/nouveau/nvkm/subdev/mc/nv04.c

85

int leaf;

drivers/gpu/drm/nouveau/nvkm/subdev/mc/nv04.c

87

for (leaf = 0; leaf < intr->leaves; leaf++)

drivers/gpu/drm/nouveau/nvkm/subdev/mc/nv04.c

88

nvkm_wr32(mc->subdev.device, 0x000140 + (leaf * 4), 0x00000000);

drivers/gpu/drm/nouveau/nvkm/subdev/mc/nv04.c

98

int leaf;

drivers/gpu/drm/nouveau/nvkm/subdev/vfn/tu102.c

29

tu102_vfn_intr_reset(struct nvkm_intr *intr, int leaf, u32 mask)

drivers/gpu/drm/nouveau/nvkm/subdev/vfn/tu102.c

33

nvkm_wr32(vfn->subdev.device, vfn->addr.priv + 0x1000 + (leaf * 4), mask);

drivers/gpu/drm/nouveau/nvkm/subdev/vfn/tu102.c

37

tu102_vfn_intr_allow(struct nvkm_intr *intr, int leaf, u32 mask)

drivers/gpu/drm/nouveau/nvkm/subdev/vfn/tu102.c

41

nvkm_wr32(vfn->subdev.device, vfn->addr.priv + 0x1200 + (leaf * 4), mask);

drivers/gpu/drm/nouveau/nvkm/subdev/vfn/tu102.c

45

tu102_vfn_intr_block(struct nvkm_intr *intr, int leaf, u32 mask)

drivers/gpu/drm/nouveau/nvkm/subdev/vfn/tu102.c

49

nvkm_wr32(vfn->subdev.device, vfn->addr.priv + 0x1400 + (leaf * 4), mask);

drivers/gpu/drm/nouveau/nvkm/subdev/vfn/tu102.c

74

int pending = 0, leaf;

drivers/gpu/drm/nouveau/nvkm/subdev/vfn/tu102.c

76

for (leaf = 0; leaf < 8; leaf++) {

drivers/gpu/drm/nouveau/nvkm/subdev/vfn/tu102.c

77

if (intr_top & BIT(leaf / 2)) {

drivers/gpu/drm/nouveau/nvkm/subdev/vfn/tu102.c

78

intr->stat[leaf] = nvkm_rd32(device, vfn->addr.priv + 0x1000 + (leaf * 4));

drivers/gpu/drm/nouveau/nvkm/subdev/vfn/tu102.c

79

if (intr->stat[leaf])

drivers/gpu/drm/nouveau/nvkm/subdev/vfn/tu102.c

82

intr->stat[leaf] = 0;

drivers/infiniband/hw/hns/hns_roce_hem.c

1293

&head->branch[i], &head->leaf);

drivers/infiniband/hw/hns/hns_roce_hem.c

1304

list_splice(&head->leaf, &hem_list->btm_bt);

drivers/infiniband/hw/hns/hns_roce_hem.c

1335

INIT_LIST_HEAD(&head.leaf);

drivers/infiniband/hw/hns/hns_roce_hem.c

930

struct list_head leaf;

drivers/infiniband/hw/irdma/pble.c

320

struct irdma_pble_info *leaf = lvl2->leaf;

drivers/infiniband/hw/irdma/pble.c

322

for (i = 0; i < lvl2->leaf_cnt; i++, leaf++) {

drivers/infiniband/hw/irdma/pble.c

323

if (leaf->addr)

drivers/infiniband/hw/irdma/pble.c

325

&leaf->chunkinfo);

drivers/infiniband/hw/irdma/pble.c

334

lvl2->leaf = NULL;

drivers/infiniband/hw/irdma/pble.c

350

struct irdma_pble_info *leaf;

drivers/infiniband/hw/irdma/pble.c

360

lvl2->leafmem.size = (sizeof(*leaf) * total);

drivers/infiniband/hw/irdma/pble.c

365

lvl2->leaf = lvl2->leafmem.va;

drivers/infiniband/hw/irdma/pble.c

366

leaf = lvl2->leaf;

drivers/infiniband/hw/irdma/pble.c

371

lvl2->leaf = NULL;

drivers/infiniband/hw/irdma/pble.c

378

for (i = 0; i < total; i++, leaf++) {

drivers/infiniband/hw/irdma/pble.c

382

&leaf->chunkinfo, pblcnt << 3,

drivers/infiniband/hw/irdma/pble.c

383

&leaf->addr, &fpm_addr);

drivers/infiniband/hw/irdma/pble.c

387

leaf->idx = fpm_to_idx(pble_rsrc, fpm_addr);

drivers/infiniband/hw/irdma/pble.c

389

leaf->cnt = pblcnt;

drivers/infiniband/hw/irdma/pble.c

390

*addr = (u64)leaf->idx;

drivers/infiniband/hw/irdma/pble.h

41

struct irdma_pble_info *leaf;

drivers/infiniband/hw/irdma/verbs.c

2795

pinfo = (level == PBLE_LEVEL_1) ? NULL : palloc->level2.leaf;

drivers/infiniband/hw/irdma/verbs.c

2836

struct irdma_pble_info *leaf = lvl2->leaf;

drivers/infiniband/hw/irdma/verbs.c

2849

start_addr = leaf->addr;

drivers/infiniband/hw/irdma/verbs.c

2851

for (i = 0; i < lvl2->leaf_cnt; i++, leaf++) {

drivers/infiniband/hw/irdma/verbs.c

2852

arr = leaf->addr;

drivers/infiniband/hw/irdma/verbs.c

2855

ret = irdma_check_mem_contiguous(arr, leaf->cnt, pg_size);

drivers/infiniband/hw/irdma/verbs.c

2888

palloc->level2.leaf;

drivers/infiniband/hw/irdma/verbs.c

3216

palloc->level2.leaf + (iwmr->npages >> PBLE_512_SHIFT);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

1541

int ssid, bool leaf)

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

1550

.leaf = leaf,

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

1855

.leaf = true,

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

2552

if (cmd->tlbi.leaf)

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

2649

unsigned int granule, bool leaf)

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

2679

cmd.tlbi.leaf = leaf;

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

2685

cmd.tlbi.leaf = leaf;

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

2727

unsigned int granule, bool leaf)

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

2769

__arm_smmu_domain_inv_range(invs, iova, size, granule, leaf);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

2772

__arm_smmu_domain_inv_range(invs, iova, size, granule, leaf);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

288

cmd[1] |= FIELD_PREP(CMDQ_CFGI_1_LEAF, ent->cfgi.leaf);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

304

cmd[1] |= FIELD_PREP(CMDQ_TLBI_1_LEAF, ent->tlbi.leaf);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

313

cmd[1] |= FIELD_PREP(CMDQ_TLBI_1_LEAF, ent->tlbi.leaf);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.h

1085

unsigned int granule, bool leaf);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.h

536

bool leaf;

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.h

556

bool leaf;

drivers/iommu/arm/arm-smmu/qcom_iommu.c

148

size_t granule, bool leaf, void *cookie)

drivers/iommu/arm/arm-smmu/qcom_iommu.c

154

reg = leaf ? ARM_SMMU_CB_S1_TLBIVAL : ARM_SMMU_CB_S1_TLBIVA;

drivers/iommu/msm_iommu.c

139

size_t granule, bool leaf, void *cookie)

drivers/md/persistent-data/dm-array.c

861

int (*fn)(void *context, uint64_t key, void *leaf);

drivers/md/persistent-data/dm-array.c

865

static int walk_ablock(void *context, uint64_t *keys, void *leaf)

drivers/md/persistent-data/dm-array.c

876

memcpy(&block_le, leaf, sizeof(block_le));

drivers/md/persistent-data/dm-array.c

896

int (*fn)(void *, uint64_t key, void *leaf),

drivers/md/persistent-data/dm-array.h

181

int (*fn)(void *context, uint64_t key, void *leaf),

drivers/md/persistent-data/dm-btree-internal.h

160

dm_block_t *new_root, struct dm_block **leaf);

drivers/md/persistent-data/dm-btree.c

1204

dm_block_t *new_root, struct dm_block **leaf)

drivers/md/persistent-data/dm-btree.c

1214

*leaf = shadow_current(&spine);

drivers/md/persistent-data/dm-btree.c

1422

int (*fn)(void *context, uint64_t *keys, void *leaf),

drivers/md/persistent-data/dm-btree.c

1457

int (*fn)(void *context, uint64_t *keys, void *leaf),

drivers/md/persistent-data/dm-btree.h

177

int (*fn)(void *context, uint64_t *keys, void *leaf),

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1054

hwtstamp = kvaser_usb_timestamp48_to_ktime(dev->cfg, cmd->u.leaf.tx_ack.time);

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1099

struct kvaser_usb_net_leaf_priv *leaf =

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1102

struct kvaser_usb_net_priv *priv = leaf->net;

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1112

struct kvaser_usb_net_leaf_priv *leaf = priv->sub_priv;

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1144

if (leaf->joining_bus) {

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1149

leaf->joining_bus = false;

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1167

if (es->leaf.error_factor) {

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1193

struct kvaser_usb_net_leaf_priv *leaf;

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1203

leaf = priv->sub_priv;

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1223

leaf->joining_bus))

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1224

schedule_delayed_work(&leaf->chip_state_req_work,

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1255

if (es->leaf.error_factor) {

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1258

if (es->leaf.error_factor & M16C_EF_ACKE)

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1260

if (es->leaf.error_factor & M16C_EF_CRCE)

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1262

if (es->leaf.error_factor & M16C_EF_FORME)

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1264

if (es->leaf.error_factor & M16C_EF_STFE)

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1266

if (es->leaf.error_factor & M16C_EF_BITE0)

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1268

if (es->leaf.error_factor & M16C_EF_BITE1)

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1270

if (es->leaf.error_factor & M16C_EF_TRE)

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1380

es.channel = cmd->u.leaf.can_error_event.channel;

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1381

es.status = cmd->u.leaf.can_error_event.status;

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1382

es.txerr = cmd->u.leaf.can_error_event.tx_errors_count;

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1383

es.rxerr = cmd->u.leaf.can_error_event.rx_errors_count;

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1384

es.leaf.error_factor = cmd->u.leaf.can_error_event.error_factor;

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1387

es.channel = cmd->u.leaf.log_message.channel;

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1388

es.status = cmd->u.leaf.log_message.data[0];

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1389

es.txerr = cmd->u.leaf.log_message.data[2];

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1390

es.rxerr = cmd->u.leaf.log_message.data[3];

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1391

es.leaf.error_factor = cmd->u.leaf.log_message.data[1];

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1394

es.channel = cmd->u.leaf.chip_state_event.channel;

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1395

es.status = cmd->u.leaf.chip_state_event.status;

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1396

es.txerr = cmd->u.leaf.chip_state_event.tx_errors_count;

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1397

es.rxerr = cmd->u.leaf.chip_state_event.rx_errors_count;

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1398

es.leaf.error_factor = 0;

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1465

rx_data = cmd->u.leaf.rx_can.data;

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1466

hwtstamp = kvaser_usb_timestamp48_to_ktime(dev->cfg, cmd->u.leaf.rx_can.time);

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1482

cf->can_id = le32_to_cpu(cmd->u.leaf.log_message.id);

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1488

can_frame_set_cc_len(cf, cmd->u.leaf.log_message.dlc & 0xF, priv->can.ctrlmode);

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1490

if (cmd->u.leaf.log_message.flags & MSG_FLAG_REMOTE_FRAME)

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1493

memcpy(cf->data, &cmd->u.leaf.log_message.data,

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1528

info1 = le16_to_cpu(cmd->u.leaf.error_event.info1);

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1562

error_code = cmd->u.leaf.error_event.error_code;

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1777

struct kvaser_usb_net_leaf_priv *leaf = priv->sub_priv;

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1780

leaf->joining_bus = true;

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1798

struct kvaser_usb_net_leaf_priv *leaf = priv->sub_priv;

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1803

cancel_delayed_work(&leaf->chip_state_req_work);

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1853

struct kvaser_usb_net_leaf_priv *leaf;

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1855

leaf = devm_kzalloc(&priv->dev->intf->dev, sizeof(*leaf), GFP_KERNEL);

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1856

if (!leaf)

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1859

leaf->net = priv;

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1860

INIT_DELAYED_WORK(&leaf->chip_state_req_work,

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1863

priv->sub_priv = leaf;

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1870

struct kvaser_usb_net_leaf_priv *leaf = priv->sub_priv;

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1872

if (leaf)

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1873

cancel_delayed_work_sync(&leaf->chip_state_req_work);

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1926

struct kvaser_usb_net_leaf_priv *leaf = priv->sub_priv;

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

1933

leaf->joining_bus = true;

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

202

} __packed leaf;

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

395

} __packed leaf;

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

420

[CMD_TX_ACKNOWLEDGE] = kvaser_fsize(u.leaf.tx_ack),

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

421

[CMD_GET_SOFTWARE_INFO_REPLY] = kvaser_fsize(u.leaf.softinfo),

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

422

[CMD_RX_STD_MESSAGE] = kvaser_fsize(u.leaf.rx_can),

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

423

[CMD_RX_EXT_MESSAGE] = kvaser_fsize(u.leaf.rx_can),

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

424

[CMD_LEAF_LOG_MESSAGE] = kvaser_fsize(u.leaf.log_message),

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

425

[CMD_CHIP_STATE_EVENT] = kvaser_fsize(u.leaf.chip_state_event),

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

426

[CMD_CAN_ERROR_EVENT] = kvaser_fsize(u.leaf.can_error_event),

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

427

[CMD_GET_CAPABILITIES_RESP] = kvaser_fsize(u.leaf.cap_res),

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

429

[CMD_ERROR_EVENT] = kvaser_fsize(u.leaf.error_event),

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

466

} leaf;

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

628

cmd_tx_can_flags = &cmd->u.tx_can.leaf.flags;

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

803

kvaser_usb_leaf_get_software_info_leaf(dev, &cmd.u.leaf.softinfo);

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

881

cmd->u.leaf.cap_req.cap_cmd = cpu_to_le16(cap_cmd_req);

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

892

*status = le16_to_cpu(cmd->u.leaf.cap_res.status);

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

897

cap_cmd_res = le16_to_cpu(cmd->u.leaf.cap_res.cap_cmd);

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

901

value = le32_to_cpu(cmd->u.leaf.cap_res.value);

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c

902

mask = le32_to_cpu(cmd->u.leaf.cap_res.mask);

drivers/net/ethernet/dec/tulip/eeprom.c

243

struct medialeaf *leaf = &mtable->mleaf[i];

drivers/net/ethernet/dec/tulip/eeprom.c

246

leaf->type = 0;

drivers/net/ethernet/dec/tulip/eeprom.c

247

leaf->media = p[0] & 0x3f;

drivers/net/ethernet/dec/tulip/eeprom.c

248

leaf->leafdata = p;

drivers/net/ethernet/dec/tulip/eeprom.c

253

leaf->type = p[1];

drivers/net/ethernet/dec/tulip/eeprom.c

256

leaf->media = p[2] & 0x0f;

drivers/net/ethernet/dec/tulip/eeprom.c

262

leaf->leafdata = p + 2;

drivers/net/ethernet/dec/tulip/eeprom.c

269

leaf->media = 11;

drivers/net/ethernet/dec/tulip/eeprom.c

275

leaf->media = p[2] & MEDIA_MASK;

drivers/net/ethernet/dec/tulip/eeprom.c

277

if (tp->chip_id == DM910X && leaf->media == 1)

drivers/net/ethernet/dec/tulip/eeprom.c

278

leaf->media = 3;

drivers/net/ethernet/dec/tulip/eeprom.c

279

switch (leaf->media) {

drivers/net/ethernet/dec/tulip/eeprom.c

286

if (p[1] == 2 && leaf->media == 0) {

drivers/net/ethernet/dec/tulip/eeprom.c

299

leaf->leafdata = p + 2;

drivers/net/ethernet/dec/tulip/eeprom.c

302

if (tulip_debug > 1 && leaf->media == 11) {

drivers/net/ethernet/dec/tulip/eeprom.c

303

unsigned char *bp = leaf->leafdata;

drivers/net/ethernet/dec/tulip/eeprom.c

312

i, medianame[leaf->media & 15], leaf->media,

drivers/net/ethernet/dec/tulip/eeprom.c

313

leaf->type < ARRAY_SIZE(block_name) ? block_name[leaf->type] : "<unknown>",

drivers/net/ethernet/dec/tulip/eeprom.c

314

leaf->type);

drivers/net/ethernet/marvell/octeontx2/nic/cn10k.c

207

int cn10k_alloc_leaf_profile(struct otx2_nic *pfvf, u16 *leaf)

drivers/net/ethernet/marvell/octeontx2/nic/cn10k.c

235

*leaf = rsp->prof_idx[BAND_PROF_LEAF_LAYER][0];

drivers/net/ethernet/marvell/octeontx2/nic/cn10k.c

358

int cn10k_free_leaf_profile(struct otx2_nic *pfvf, u16 leaf)

drivers/net/ethernet/marvell/octeontx2/nic/cn10k.c

367

req->prof_idx[BAND_PROF_LEAF_LAYER][0] = leaf;

drivers/net/ethernet/marvell/octeontx2/nic/cn10k.h

38

int cn10k_alloc_leaf_profile(struct otx2_nic *pfvf, u16 *leaf);

drivers/net/ethernet/marvell/octeontx2/nic/cn10k.h

41

int cn10k_free_leaf_profile(struct otx2_nic *pfvf, u16 leaf);

fs/btrfs/accessors.h

1044

#define btrfs_item_ptr(leaf, slot, type) \

fs/btrfs/accessors.h

1045

((type *)(btrfs_item_nr_offset(leaf, 0) + btrfs_item_offset(leaf, slot)))

fs/btrfs/accessors.h

1047

#define btrfs_item_ptr_offset(leaf, slot) \

fs/btrfs/accessors.h

1048

((unsigned long)(btrfs_item_nr_offset(leaf, 0) + btrfs_item_offset(leaf, slot)))

fs/btrfs/backref.c

1007

struct extent_buffer *leaf;

fs/btrfs/backref.c

1019

leaf = path->nodes[0];

fs/btrfs/backref.c

1022

item_size = btrfs_item_size(leaf, slot);

fs/btrfs/backref.c

1023

ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);

fs/btrfs/backref.c

1026

ret = ctx->check_extent_item(ctx->bytenr, ei, leaf, ctx->user_ctx);

fs/btrfs/backref.c

1031

flags = btrfs_extent_flags(leaf, ei);

fs/btrfs/backref.c

1032

btrfs_item_key_to_cpu(leaf, &found_key, slot);

fs/btrfs/backref.c

1042

*info_level = btrfs_tree_block_level(leaf, info);

fs/btrfs/backref.c

1057

type = btrfs_get_extent_inline_ref_type(leaf, iref,

fs/btrfs/backref.c

1062

offset = btrfs_extent_inline_ref_offset(leaf, iref);

fs/btrfs/backref.c

1075

count = btrfs_shared_data_ref_count(leaf, sdref);

fs/btrfs/backref.c

1092

count = btrfs_extent_data_ref_count(leaf, dref);

fs/btrfs/backref.c

1093

key.objectid = btrfs_extent_data_ref_objectid(leaf,

fs/btrfs/backref.c

1096

key.offset = btrfs_extent_data_ref_offset(leaf, dref);

fs/btrfs/backref.c

1104

root = btrfs_extent_data_ref_root(leaf, dref);

fs/btrfs/backref.c

1142

struct extent_buffer *leaf;

fs/btrfs/backref.c

1155

leaf = path->nodes[0];

fs/btrfs/backref.c

1156

btrfs_item_key_to_cpu(leaf, &key, slot);

fs/btrfs/backref.c

1177

sdref = btrfs_item_ptr(leaf, slot,

fs/btrfs/backref.c

1179

count = btrfs_shared_data_ref_count(leaf, sdref);

fs/btrfs/backref.c

1197

dref = btrfs_item_ptr(leaf, slot,

fs/btrfs/backref.c

1199

count = btrfs_extent_data_ref_count(leaf, dref);

fs/btrfs/backref.c

1200

key.objectid = btrfs_extent_data_ref_objectid(leaf,

fs/btrfs/backref.c

1203

key.offset = btrfs_extent_data_ref_offset(leaf, dref);

fs/btrfs/backref.c

1211

root = btrfs_extent_data_ref_root(leaf, dref);

fs/btrfs/backref.c

1475

struct extent_buffer *leaf;

fs/btrfs/backref.c

1479

leaf = path->nodes[0];

fs/btrfs/backref.c

1481

btrfs_item_key_to_cpu(leaf, &key, slot);

fs/btrfs/backref.c

2048

const struct extent_buffer *leaf;

fs/btrfs/backref.c

2060

leaf = path->nodes[0];

fs/btrfs/backref.c

2062

if (slot >= btrfs_header_nritems(leaf)) {

fs/btrfs/backref.c

2081

btrfs_item_key_to_cpu(leaf, &found_key, slot);

fs/btrfs/backref.c

2096

ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);

fs/btrfs/backref.h

136

const struct extent_buffer *leaf, void *user_ctx);

fs/btrfs/block-group.c

2147

struct extent_buffer *leaf;

fs/btrfs/block-group.c

2153

leaf = path->nodes[0];

fs/btrfs/block-group.c

2171

read_extent_buffer(leaf, &bg, btrfs_item_ptr_offset(leaf, slot),

fs/btrfs/block-group.c

2676

struct extent_buffer *leaf;

fs/btrfs/block-group.c

2686

leaf = path->nodes[0];

fs/btrfs/block-group.c

2697

read_extent_buffer(leaf, &bgi, btrfs_item_ptr_offset(leaf, slot),

fs/btrfs/block-group.c

2700

btrfs_item_key_to_cpu(leaf, &key, slot);

fs/btrfs/block-group.c

2819

struct extent_buffer *leaf;

fs/btrfs/block-group.c

2836

leaf = path->nodes[0];

fs/btrfs/block-group.c

2837

extent = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dev_extent);

fs/btrfs/block-group.c

2838

btrfs_set_dev_extent_chunk_tree(leaf, extent, BTRFS_CHUNK_TREE_OBJECTID);

fs/btrfs/block-group.c

2839

btrfs_set_dev_extent_chunk_objectid(leaf, extent,

fs/btrfs/block-group.c

2841

btrfs_set_dev_extent_chunk_offset(leaf, extent, chunk_offset);

fs/btrfs/block-group.c

2842

btrfs_set_dev_extent_length(leaf, extent, num_bytes);

fs/btrfs/block-group.c

3256

struct extent_buffer *leaf;

fs/btrfs/block-group.c

3307

leaf = path->nodes[0];

fs/btrfs/block-group.c

3308

bi = btrfs_item_ptr_offset(leaf, path->slots[0]);

fs/btrfs/block-group.c

3317

write_extent_buffer(leaf, &bgi, bi,

fs/btrfs/block-group.c

3320

write_extent_buffer(leaf, &bgi, bi,

fs/btrfs/block-group.c

728

struct extent_buffer *leaf;

fs/btrfs/block-group.c

776

leaf = path->nodes[0];

fs/btrfs/block-group.c

777

nritems = btrfs_header_nritems(leaf);

fs/btrfs/block-group.c

786

btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);

fs/btrfs/block-group.c

808

leaf = path->nodes[0];

fs/btrfs/block-group.c

809

nritems = btrfs_header_nritems(leaf);

fs/btrfs/ctree.c

110

static inline void memmove_leaf_items(const struct extent_buffer *leaf,

fs/btrfs/ctree.c

113

memmove_extent_buffer(leaf, btrfs_item_nr_offset(leaf, dst_item),

fs/btrfs/ctree.c

114

btrfs_item_nr_offset(leaf, src_item),

fs/btrfs/ctree.c

1850

struct extent_buffer *leaf = path->nodes[0];

fs/btrfs/ctree.c

1868

leaf_free_space = btrfs_leaf_free_space(leaf);

fs/btrfs/ctree.c

1877

ASSERT(btrfs_header_nritems(leaf) > 0);

fs/btrfs/ctree.c

1878

btrfs_item_key(leaf, &first_key, 0);

fs/btrfs/ctree.c

1932

ret = search_for_key_slot(leaf, search_low_slot, key,

fs/btrfs/ctree.c

2453

struct extent_buffer *leaf;

fs/btrfs/ctree.c

2466

leaf = p->nodes[0];

fs/btrfs/ctree.c

2469

if (p->slots[0] >= btrfs_header_nritems(leaf)) {

fs/btrfs/ctree.c

2490

leaf = p->nodes[0];

fs/btrfs/ctree.c

2491

if (p->slots[0] == btrfs_header_nritems(leaf))

fs/btrfs/ctree.c

3099

int btrfs_leaf_free_space(const struct extent_buffer *leaf)

fs/btrfs/ctree.c

3101

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/ctree.c

3102

int nritems = btrfs_header_nritems(leaf);

fs/btrfs/ctree.c

3105

ret = BTRFS_LEAF_DATA_SIZE(fs_info) - leaf_space_used(leaf, 0, nritems);

fs/btrfs/ctree.c

3111

leaf_space_used(leaf, 0, nritems), nritems);

fs/btrfs/ctree.c

3850

struct extent_buffer *leaf;

fs/btrfs/ctree.c

3856

leaf = path->nodes[0];

fs/btrfs/ctree.c

3857

btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);

fs/btrfs/ctree.c

3863

if (btrfs_leaf_free_space(leaf) >= ins_len)

fs/btrfs/ctree.c

3866

item_size = btrfs_item_size(leaf, path->slots[0]);

fs/btrfs/ctree.c

3868

fi = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/ctree.c

3870

extent_len = btrfs_file_extent_num_bytes(leaf, fi);

fs/btrfs/ctree.c

3884

leaf = path->nodes[0];

fs/btrfs/ctree.c

3886

if (item_size != btrfs_item_size(leaf, path->slots[0]))

fs/btrfs/ctree.c

3894

fi = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/ctree.c

3896

if (extent_len != btrfs_file_extent_num_bytes(leaf, fi))

fs/btrfs/ctree.c

3917

struct extent_buffer *leaf;

fs/btrfs/ctree.c

3925

leaf = path->nodes[0];

fs/btrfs/ctree.c

3930

if (WARN_ON(btrfs_leaf_free_space(leaf) < sizeof(struct btrfs_item)))

fs/btrfs/ctree.c

3934

orig_offset = btrfs_item_offset(leaf, path->slots[0]);

fs/btrfs/ctree.c

3935

item_size = btrfs_item_size(leaf, path->slots[0]);

fs/btrfs/ctree.c

3941

read_extent_buffer(leaf, buf, btrfs_item_ptr_offset(leaf,

fs/btrfs/ctree.c

3945

nritems = btrfs_header_nritems(leaf);

fs/btrfs/ctree.c

3948

memmove_leaf_items(leaf, slot + 1, slot, nritems - slot);

fs/btrfs/ctree.c

3952

btrfs_set_item_key(leaf, &disk_key, slot);

fs/btrfs/ctree.c

3954

btrfs_set_item_offset(leaf, slot, orig_offset);

fs/btrfs/ctree.c

3955

btrfs_set_item_size(leaf, slot, item_size - split_offset);

fs/btrfs/ctree.c

3957

btrfs_set_item_offset(leaf, orig_slot,

fs/btrfs/ctree.c

3959

btrfs_set_item_size(leaf, orig_slot, split_offset);

fs/btrfs/ctree.c

3961

btrfs_set_header_nritems(leaf, nritems + 1);

fs/btrfs/ctree.c

3964

write_extent_buffer(leaf, buf,

fs/btrfs/ctree.c

3965

btrfs_item_ptr_offset(leaf, path->slots[0]),

fs/btrfs/ctree.c

3969

write_extent_buffer(leaf, buf + split_offset,

fs/btrfs/ctree.c

3970

btrfs_item_ptr_offset(leaf, slot),

fs/btrfs/ctree.c

3972

btrfs_mark_buffer_dirty(trans, leaf);

fs/btrfs/ctree.c

3974

BUG_ON(btrfs_leaf_free_space(leaf) < 0);

fs/btrfs/ctree.c

4019

struct extent_buffer *leaf;

fs/btrfs/ctree.c

4027

leaf = path->nodes[0];

fs/btrfs/ctree.c

4030

old_size = btrfs_item_size(leaf, slot);

fs/btrfs/ctree.c

4034

nritems = btrfs_header_nritems(leaf);

fs/btrfs/ctree.c

4035

data_end = leaf_data_end(leaf);

fs/btrfs/ctree.c

4037

old_data_start = btrfs_item_offset(leaf, slot);

fs/btrfs/ctree.c

4051

ioff = btrfs_item_offset(leaf, i);

fs/btrfs/ctree.c

4052

btrfs_set_item_offset(leaf, i, ioff + size_diff);

fs/btrfs/ctree.c

4057

memmove_leaf_data(leaf, data_end + size_diff, data_end,

fs/btrfs/ctree.c

4063

btrfs_item_key(leaf, &disk_key, slot);

fs/btrfs/ctree.c

4069

fi = btrfs_item_ptr(leaf, slot,

fs/btrfs/ctree.c

4074

if (btrfs_file_extent_type(leaf, fi) ==

fs/btrfs/ctree.c

4076

ptr = btrfs_item_ptr_offset(leaf, slot);

fs/btrfs/ctree.c

4077

memmove_extent_buffer(leaf, ptr,

fs/btrfs/ctree.c

4083

memmove_leaf_data(leaf, data_end + size_diff, data_end,

fs/btrfs/ctree.c

4088

btrfs_set_item_key(leaf, &disk_key, slot);

fs/btrfs/ctree.c

4093

btrfs_set_item_size(leaf, slot, new_size);

fs/btrfs/ctree.c

4094

btrfs_mark_buffer_dirty(trans, leaf);

fs/btrfs/ctree.c

4096

if (unlikely(btrfs_leaf_free_space(leaf) < 0)) {

fs/btrfs/ctree.c

4097

btrfs_print_leaf(leaf);

fs/btrfs/ctree.c

4109

struct extent_buffer *leaf;

fs/btrfs/ctree.c

4116

leaf = path->nodes[0];

fs/btrfs/ctree.c

4118

nritems = btrfs_header_nritems(leaf);

fs/btrfs/ctree.c

4119

data_end = leaf_data_end(leaf);

fs/btrfs/ctree.c

4121

if (unlikely(btrfs_leaf_free_space(leaf) < data_size)) {

fs/btrfs/ctree.c

4122

btrfs_print_leaf(leaf);

fs/btrfs/ctree.c

4126

old_data = btrfs_item_data_end(leaf, slot);

fs/btrfs/ctree.c

4130

btrfs_print_leaf(leaf);

fs/btrfs/ctree.c

4131

btrfs_crit(leaf->fs_info, "slot %d too large, nritems %d",

fs/btrfs/ctree.c

4143

ioff = btrfs_item_offset(leaf, i);

fs/btrfs/ctree.c

4144

btrfs_set_item_offset(leaf, i, ioff - data_size);

fs/btrfs/ctree.c

4148

memmove_leaf_data(leaf, data_end - data_size, data_end,

fs/btrfs/ctree.c

4151

old_size = btrfs_item_size(leaf, slot);

fs/btrfs/ctree.c

4152

btrfs_set_item_size(leaf, slot, old_size + data_size);

fs/btrfs/ctree.c

4153

btrfs_mark_buffer_dirty(trans, leaf);

fs/btrfs/ctree.c

4155

if (unlikely(btrfs_leaf_free_space(leaf) < 0)) {

fs/btrfs/ctree.c

4156

btrfs_print_leaf(leaf);

fs/btrfs/ctree.c

4181

struct extent_buffer *leaf;

fs/btrfs/ctree.c

4196

leaf = path->nodes[0];

fs/btrfs/ctree.c

4199

nritems = btrfs_header_nritems(leaf);

fs/btrfs/ctree.c

4200

data_end = leaf_data_end(leaf);

fs/btrfs/ctree.c

4203

if (unlikely(btrfs_leaf_free_space(leaf) < total_size)) {

fs/btrfs/ctree.c

4204

btrfs_print_leaf(leaf);

fs/btrfs/ctree.c

4206

total_size, btrfs_leaf_free_space(leaf));

fs/btrfs/ctree.c

4211

unsigned int old_data = btrfs_item_data_end(leaf, slot);

fs/btrfs/ctree.c

4214

btrfs_print_leaf(leaf);

fs/btrfs/ctree.c

4227

ioff = btrfs_item_offset(leaf, i);

fs/btrfs/ctree.c

4228

btrfs_set_item_offset(leaf, i,

fs/btrfs/ctree.c

4232

memmove_leaf_items(leaf, slot + batch->nr, slot, nritems - slot);

fs/btrfs/ctree.c

4235

memmove_leaf_data(leaf, data_end - batch->total_data_size,

fs/btrfs/ctree.c

4243

btrfs_set_item_key(leaf, &disk_key, slot + i);

fs/btrfs/ctree.c

4245

btrfs_set_item_offset(leaf, slot + i, data_end);

fs/btrfs/ctree.c

4246

btrfs_set_item_size(leaf, slot + i, batch->data_sizes[i]);

fs/btrfs/ctree.c

4249

btrfs_set_header_nritems(leaf, nritems + batch->nr);

fs/btrfs/ctree.c

4250

btrfs_mark_buffer_dirty(trans, leaf);

fs/btrfs/ctree.c

4252

if (unlikely(btrfs_leaf_free_space(leaf) < 0)) {

fs/btrfs/ctree.c

4253

btrfs_print_leaf(leaf);

fs/btrfs/ctree.c

4324

struct extent_buffer *leaf;

fs/btrfs/ctree.c

4332

leaf = path->nodes[0];

fs/btrfs/ctree.c

4333

ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);

fs/btrfs/ctree.c

4334

write_extent_buffer(leaf, data, ptr, data_size);

fs/btrfs/ctree.c

4335

btrfs_mark_buffer_dirty(trans, leaf);

fs/btrfs/ctree.c

4353

struct extent_buffer *leaf;

fs/btrfs/ctree.c

4357

leaf = path->nodes[0];

fs/btrfs/ctree.c

4358

item_size = btrfs_item_size(leaf, path->slots[0]);

fs/btrfs/ctree.c

4366

leaf = path->nodes[0];

fs/btrfs/ctree.c

4367

memcpy_extent_buffer(leaf,

fs/btrfs/ctree.c

4368

btrfs_item_ptr_offset(leaf, path->slots[0]),

fs/btrfs/ctree.c

4369

btrfs_item_ptr_offset(leaf, path->slots[0] - 1),

fs/btrfs/ctree.c

4442

struct extent_buffer *leaf)

fs/btrfs/ctree.c

4446

WARN_ON(btrfs_header_generation(leaf) != trans->transid);

fs/btrfs/ctree.c

4459

refcount_inc(&leaf->refs);

fs/btrfs/ctree.c

4460

ret = btrfs_free_tree_block(trans, btrfs_root_id(root), leaf, 0, 1);

fs/btrfs/ctree.c

4461

free_extent_buffer_stale(leaf);

fs/btrfs/ctree.c

4475

struct extent_buffer *leaf;

fs/btrfs/ctree.c

4480

leaf = path->nodes[0];

fs/btrfs/ctree.c

4481

nritems = btrfs_header_nritems(leaf);

fs/btrfs/ctree.c

4484

const u32 last_off = btrfs_item_offset(leaf, slot + nr - 1);

fs/btrfs/ctree.c

4485

const int data_end = leaf_data_end(leaf);

fs/btrfs/ctree.c

4490

dsize += btrfs_item_size(leaf, slot + i);

fs/btrfs/ctree.c

4492

memmove_leaf_data(leaf, data_end + dsize, data_end,

fs/btrfs/ctree.c

4498

ioff = btrfs_item_offset(leaf, i);

fs/btrfs/ctree.c

4499

btrfs_set_item_offset(leaf, i, ioff + dsize);

fs/btrfs/ctree.c

45

static unsigned int leaf_data_end(const struct extent_buffer *leaf)

fs/btrfs/ctree.c

4502

memmove_leaf_items(leaf, slot, slot + nr, nritems - slot - nr);

fs/btrfs/ctree.c

4504

btrfs_set_header_nritems(leaf, nritems - nr);

fs/btrfs/ctree.c

4509

if (leaf != root->node) {

fs/btrfs/ctree.c

4510

btrfs_clear_buffer_dirty(trans, leaf);

fs/btrfs/ctree.c

4511

ret = btrfs_del_leaf(trans, root, path, leaf);

fs/btrfs/ctree.c

4516

int used = leaf_space_used(leaf, 0, nritems);

fs/btrfs/ctree.c

4520

btrfs_item_key(leaf, &disk_key, 0);

fs/btrfs/ctree.c

4540

refcount_inc(&leaf->refs);

fs/btrfs/ctree.c

4546

btrfs_item_size(leaf, 0);

fs/btrfs/ctree.c

4552

if (path->nodes[0] == leaf &&

fs/btrfs/ctree.c

4553

btrfs_header_nritems(leaf)) {

fs/btrfs/ctree.c

4564

nritems = btrfs_header_nritems(leaf);

fs/btrfs/ctree.c

4565

min_push_space = leaf_space_used(leaf, 0, nritems);

fs/btrfs/ctree.c

4572

if (btrfs_header_nritems(leaf) == 0) {

fs/btrfs/ctree.c

4574

ret = btrfs_del_leaf(trans, root, path, leaf);

fs/btrfs/ctree.c

4575

free_extent_buffer(leaf);

fs/btrfs/ctree.c

4584

if (path->nodes[0] == leaf)

fs/btrfs/ctree.c

4585

btrfs_mark_buffer_dirty(trans, leaf);

fs/btrfs/ctree.c

4586

free_extent_buffer(leaf);

fs/btrfs/ctree.c

4589

btrfs_mark_buffer_dirty(trans, leaf);

fs/btrfs/ctree.c

47

u32 nr = btrfs_header_nritems(leaf);

fs/btrfs/ctree.c

4990

struct extent_buffer *leaf;

fs/btrfs/ctree.c

50

return BTRFS_LEAF_DATA_SIZE(leaf->fs_info);

fs/btrfs/ctree.c

5002

leaf = path->nodes[0];

fs/btrfs/ctree.c

5003

nritems = btrfs_header_nritems(leaf);

fs/btrfs/ctree.c

5009

btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);

fs/btrfs/ctree.c

5031

struct extent_buffer *leaf;

fs/btrfs/ctree.c

5043

leaf = path->nodes[0];

fs/btrfs/ctree.c

5044

nritems = btrfs_header_nritems(leaf);

fs/btrfs/ctree.c

5050

btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);

fs/btrfs/ctree.c

51

return btrfs_item_offset(leaf, nr - 1);

fs/btrfs/ctree.c

67

static inline void memmove_leaf_data(const struct extent_buffer *leaf,

fs/btrfs/ctree.c

72

memmove_extent_buffer(leaf, btrfs_item_nr_offset(leaf, 0) + dst_offset,

fs/btrfs/ctree.c

73

btrfs_item_nr_offset(leaf, 0) + src_offset, len);

fs/btrfs/ctree.h

729

int btrfs_leaf_free_space(const struct extent_buffer *leaf);

fs/btrfs/delayed-inode.c

1004

struct extent_buffer *leaf;

fs/btrfs/delayed-inode.c

1031

leaf = path->nodes[0];

fs/btrfs/delayed-inode.c

1032

inode_item = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/delayed-inode.c

1034

write_extent_buffer(leaf, &node->inode_item, (unsigned long)inode_item,

fs/btrfs/delayed-inode.c

1047

if (path->slots[0] + 1 >= btrfs_header_nritems(leaf)) {

fs/btrfs/delayed-inode.c

1062

leaf = path->nodes[0];

fs/btrfs/delayed-inode.c

1066

btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);

fs/btrfs/delayed-inode.c

847

struct extent_buffer *leaf = path->nodes[0];

fs/btrfs/delayed-inode.c

853

ASSERT(leaf != NULL);

fs/btrfs/delayed-inode.c

856

last_slot = btrfs_header_nritems(leaf) - 1;

fs/btrfs/delayed-inode.c

882

btrfs_item_key_to_cpu(leaf, &key, slot);

fs/btrfs/dev-replace.c

500

struct extent_buffer *leaf = path->nodes[0];

fs/btrfs/dev-replace.c

511

dev_extent = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dev_extent);

fs/btrfs/dev-replace.c

513

chunk_offset = btrfs_dev_extent_chunk_offset(leaf, dev_extent);

fs/btrfs/dir-item.c

117

struct extent_buffer *leaf;

fs/btrfs/dir-item.c

146

leaf = path->nodes[0];

fs/btrfs/dir-item.c

147

btrfs_set_dir_item_key(leaf, dir_item, &disk_key);

fs/btrfs/dir-item.c

148

btrfs_set_dir_flags(leaf, dir_item, type);

fs/btrfs/dir-item.c

149

btrfs_set_dir_data_len(leaf, dir_item, 0);

fs/btrfs/dir-item.c

150

btrfs_set_dir_name_len(leaf, dir_item, name->len);

fs/btrfs/dir-item.c

151

btrfs_set_dir_transid(leaf, dir_item, trans->transid);

fs/btrfs/dir-item.c

154

write_extent_buffer(leaf, name->name, name_ptr, name->len);

fs/btrfs/dir-item.c

237

struct extent_buffer *leaf;

fs/btrfs/dir-item.c

267

leaf = path->nodes[0];

fs/btrfs/dir-item.c

269

if (data_size + btrfs_item_size(leaf, slot) +

fs/btrfs/dir-item.c

33

struct extent_buffer *leaf;

fs/btrfs/dir-item.c

377

struct extent_buffer *leaf;

fs/btrfs/dir-item.c

379

leaf = path->nodes[0];

fs/btrfs/dir-item.c

380

dir_item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dir_item);

fs/btrfs/dir-item.c

382

total_len = btrfs_item_size(leaf, path->slots[0]);

fs/btrfs/dir-item.c

385

btrfs_dir_name_len(leaf, dir_item) +

fs/btrfs/dir-item.c

386

btrfs_dir_data_len(leaf, dir_item);

fs/btrfs/dir-item.c

389

if (btrfs_dir_name_len(leaf, dir_item) == name_len &&

fs/btrfs/dir-item.c

390

memcmp_extent_buffer(leaf, name, name_ptr, name_len) == 0)

fs/btrfs/dir-item.c

410

struct extent_buffer *leaf;

fs/btrfs/dir-item.c

415

leaf = path->nodes[0];

fs/btrfs/dir-item.c

416

sub_item_len = sizeof(*di) + btrfs_dir_name_len(leaf, di) +

fs/btrfs/dir-item.c

417

btrfs_dir_data_len(leaf, di);

fs/btrfs/dir-item.c

418

item_len = btrfs_item_size(leaf, path->slots[0]);

fs/btrfs/dir-item.c

426

start = btrfs_item_ptr_offset(leaf, path->slots[0]);

fs/btrfs/dir-item.c

427

memmove_extent_buffer(leaf, ptr, ptr + sub_item_len,

fs/btrfs/dir-item.c

45

leaf = path->nodes[0];

fs/btrfs/dir-item.c

46

ptr = btrfs_item_ptr(leaf, path->slots[0], char);

fs/btrfs/dir-item.c

47

ASSERT(data_size <= btrfs_item_size(leaf, path->slots[0]));

fs/btrfs/dir-item.c

48

ptr += btrfs_item_size(leaf, path->slots[0]) - data_size;

fs/btrfs/dir-item.c

67

struct extent_buffer *leaf;

fs/btrfs/dir-item.c

84

leaf = path->nodes[0];

fs/btrfs/dir-item.c

86

btrfs_set_dir_item_key(leaf, dir_item, &disk_key);

fs/btrfs/dir-item.c

87

btrfs_set_dir_flags(leaf, dir_item, BTRFS_FT_XATTR);

fs/btrfs/dir-item.c

88

btrfs_set_dir_name_len(leaf, dir_item, name_len);

fs/btrfs/dir-item.c

89

btrfs_set_dir_transid(leaf, dir_item, trans->transid);

fs/btrfs/dir-item.c

90

btrfs_set_dir_data_len(leaf, dir_item, data_len);

fs/btrfs/dir-item.c

94

write_extent_buffer(leaf, name, name_ptr, name_len);

fs/btrfs/dir-item.c

95

write_extent_buffer(leaf, data, data_ptr, data_len);

fs/btrfs/disk-io.c

797

struct extent_buffer *leaf;

fs/btrfs/disk-io.c

817

leaf = btrfs_alloc_tree_block(trans, root, 0, objectid, NULL, 0, 0, 0,

fs/btrfs/disk-io.c

819

if (IS_ERR(leaf)) {

fs/btrfs/disk-io.c

820

ret = PTR_ERR(leaf);

fs/btrfs/disk-io.c

821

leaf = NULL;

fs/btrfs/disk-io.c

825

root->node = leaf;

fs/btrfs/disk-io.c

826

btrfs_mark_buffer_dirty(trans, leaf);

fs/btrfs/disk-io.c

833

btrfs_set_root_bytenr(&root->root_item, leaf->start);

fs/btrfs/disk-io.c

837

btrfs_set_root_used(&root->root_item, leaf->len);

fs/btrfs/disk-io.c

846

btrfs_tree_unlock(leaf);

fs/btrfs/disk-io.c

878

struct extent_buffer *leaf;

fs/btrfs/disk-io.c

890

leaf = btrfs_alloc_tree_block(trans, root, 0, BTRFS_TREE_LOG_OBJECTID,

fs/btrfs/disk-io.c

892

if (IS_ERR(leaf))

fs/btrfs/disk-io.c

893

return PTR_ERR(leaf);

fs/btrfs/disk-io.c

895

root->node = leaf;

fs/btrfs/export.c

159

struct extent_buffer *leaf;

fs/btrfs/export.c

198

leaf = path->nodes[0];

fs/btrfs/export.c

200

btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);

fs/btrfs/export.c

207

ref = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/export.c

209

key.objectid = btrfs_root_ref_dirid(leaf, ref);

fs/btrfs/export.c

240

struct extent_buffer *leaf;

fs/btrfs/export.c

276

leaf = path->nodes[0];

fs/btrfs/export.c

279

rref = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/export.c

282

name_len = btrfs_root_ref_name_len(leaf, rref);

fs/btrfs/export.c

284

iref = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/export.c

287

name_len = btrfs_inode_ref_name_len(leaf, iref);

fs/btrfs/export.c

290

read_extent_buffer(leaf, name, name_ptr, name_len);

fs/btrfs/extent-tree.c

1040

struct extent_buffer *leaf;

fs/btrfs/extent-tree.c

1049

leaf = path->nodes[0];

fs/btrfs/extent-tree.c

1050

ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);

fs/btrfs/extent-tree.c

1058

ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);

fs/btrfs/extent-tree.c

1059

refs = btrfs_extent_refs(leaf, ei);

fs/btrfs/extent-tree.c

1061

btrfs_set_extent_refs(leaf, ei, refs);

fs/btrfs/extent-tree.c

1063

__run_delayed_extent_op(extent_op, leaf, ei);

fs/btrfs/extent-tree.c

1066

end = (unsigned long)ei + btrfs_item_size(leaf, path->slots[0]);

fs/btrfs/extent-tree.c

1068

memmove_extent_buffer(leaf, ptr + size, ptr,

fs/btrfs/extent-tree.c

1072

btrfs_set_extent_inline_ref_type(leaf, iref, type);

fs/btrfs/extent-tree.c

1076

btrfs_set_extent_data_ref_root(leaf, dref, root_objectid);

fs/btrfs/extent-tree.c

1077

btrfs_set_extent_data_ref_objectid(leaf, dref, owner);

fs/btrfs/extent-tree.c

1078

btrfs_set_extent_data_ref_offset(leaf, dref, offset);

fs/btrfs/extent-tree.c

1079

btrfs_set_extent_data_ref_count(leaf, dref, refs_to_add);

fs/btrfs/extent-tree.c

1083

btrfs_set_shared_data_ref_count(leaf, sref, refs_to_add);

fs/btrfs/extent-tree.c

1084

btrfs_set_extent_inline_ref_offset(leaf, iref, parent);

fs/btrfs/extent-tree.c

1086

btrfs_set_extent_inline_ref_offset(leaf, iref, parent);

fs/btrfs/extent-tree.c

1088

btrfs_set_extent_inline_ref_offset(leaf, iref, root_objectid);

fs/btrfs/extent-tree.c

1129

struct extent_buffer *leaf = path->nodes[0];

fs/btrfs/extent-tree.c

1130

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/extent-tree.c

1141

ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);

fs/btrfs/extent-tree.c

1142

refs = btrfs_extent_refs(leaf, ei);

fs/btrfs/extent-tree.c

1147

btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);

fs/btrfs/extent-tree.c

1152

btrfs_print_leaf(leaf);

fs/btrfs/extent-tree.c

1159

btrfs_set_extent_refs(leaf, ei, refs);

fs/btrfs/extent-tree.c

1161

__run_delayed_extent_op(extent_op, leaf, ei);

fs/btrfs/extent-tree.c

1163

type = btrfs_get_extent_inline_ref_type(leaf, iref, BTRFS_REF_TYPE_ANY);

fs/btrfs/extent-tree.c

1173

refs = btrfs_extent_data_ref_count(leaf, dref);

fs/btrfs/extent-tree.c

1176

refs = btrfs_shared_data_ref_count(leaf, sref);

fs/btrfs/extent-tree.c

1190

btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);

fs/btrfs/extent-tree.c

1192

btrfs_print_leaf(leaf);

fs/btrfs/extent-tree.c

1204

btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);

fs/btrfs/extent-tree.c

1209

btrfs_print_leaf(leaf);

fs/btrfs/extent-tree.c

1220

btrfs_set_extent_data_ref_count(leaf, dref, refs);

fs/btrfs/extent-tree.c

1222

btrfs_set_shared_data_ref_count(leaf, sref, refs);

fs/btrfs/extent-tree.c

1225

item_size = btrfs_item_size(leaf, path->slots[0]);

fs/btrfs/extent-tree.c

1229

memmove_extent_buffer(leaf, ptr, ptr + size,

fs/btrfs/extent-tree.c

1531

struct extent_buffer *leaf;

fs/btrfs/extent-tree.c

1558

leaf = path->nodes[0];

fs/btrfs/extent-tree.c

1559

btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);

fs/btrfs/extent-tree.c

1560

item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);

fs/btrfs/extent-tree.c

1561

refs = btrfs_extent_refs(leaf, item);

fs/btrfs/extent-tree.c

1562

btrfs_set_extent_refs(leaf, item, refs + refs_to_add);

fs/btrfs/extent-tree.c

1564

__run_delayed_extent_op(extent_op, leaf, item);

fs/btrfs/extent-tree.c

163

struct extent_buffer *leaf = path->nodes[0];

fs/btrfs/extent-tree.c

165

const u32 item_size = btrfs_item_size(leaf, path->slots[0]);

fs/btrfs/extent-tree.c

1673

struct extent_buffer *leaf,

fs/btrfs/extent-tree.c

1676

u64 flags = btrfs_extent_flags(leaf, ei);

fs/btrfs/extent-tree.c

1679

btrfs_set_extent_flags(leaf, ei, flags);

fs/btrfs/extent-tree.c

1686

btrfs_set_tree_block_key(leaf, bi, &extent_op->key);

fs/btrfs/extent-tree.c

1699

struct extent_buffer *leaf;

fs/btrfs/extent-tree.c

176

ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);

fs/btrfs/extent-tree.c

1764

leaf = path->nodes[0];

fs/btrfs/extent-tree.c

1765

item_size = btrfs_item_size(leaf, path->slots[0]);

fs/btrfs/extent-tree.c

177

num_refs = btrfs_extent_refs(leaf, ei);

fs/btrfs/extent-tree.c

1776

ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);

fs/btrfs/extent-tree.c

1777

__run_delayed_extent_op(extent_op, leaf, ei);

fs/btrfs/extent-tree.c

186

extent_flags = btrfs_extent_flags(leaf, ei);

fs/btrfs/extent-tree.c

187

owner = btrfs_get_extent_owner_root(fs_info, leaf, path->slots[0]);

fs/btrfs/extent-tree.c

2427

struct extent_buffer *leaf;

fs/btrfs/extent-tree.c

2462

leaf = path->nodes[0];

fs/btrfs/extent-tree.c

2463

btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);

fs/btrfs/extent-tree.c

2468

item_size = btrfs_item_size(leaf, path->slots[0]);

fs/btrfs/extent-tree.c

2469

ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);

fs/btrfs/extent-tree.c

2478

type = btrfs_get_extent_inline_ref_type(leaf, iref, BTRFS_REF_TYPE_DATA);

fs/btrfs/extent-tree.c

2482

type = btrfs_get_extent_inline_ref_type(leaf, iref, BTRFS_REF_TYPE_DATA);

fs/btrfs/extent-tree.c

2494

if (btrfs_extent_refs(leaf, ei) !=

fs/btrfs/extent-tree.c

2495

btrfs_extent_data_ref_count(leaf, ref) ||

fs/btrfs/extent-tree.c

2496

btrfs_extent_data_ref_root(leaf, ref) != btrfs_root_id(root) ||

fs/btrfs/extent-tree.c

2497

btrfs_extent_data_ref_objectid(leaf, ref) != btrfs_ino(inode) ||

fs/btrfs/extent-tree.c

2498

btrfs_extent_data_ref_offset(leaf, ref) != offset)

fs/btrfs/extent-tree.c

2525

struct extent_buffer *leaf = path->nodes[0];

fs/btrfs/extent-tree.c

2527

ASSERT(leaf != NULL);

fs/btrfs/extent-tree.c

2528

btrfs_assert_tree_read_locked(leaf);

fs/btrfs/extent-tree.c

2533

btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);

fs/btrfs/extent-tree.c

3103

struct extent_buffer *leaf, int slot)

fs/btrfs/extent-tree.c

3115

ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);

fs/btrfs/extent-tree.c

3117

end = (unsigned long)ei + btrfs_item_size(leaf, slot);

fs/btrfs/extent-tree.c

3124

type = btrfs_get_extent_inline_ref_type(leaf, iref, BTRFS_REF_TYPE_ANY);

fs/btrfs/extent-tree.c

3129

return btrfs_extent_owner_ref_root_id(leaf, oref);

fs/btrfs/extent-tree.c

3276

struct extent_buffer *leaf;

fs/btrfs/extent-tree.c

3429

leaf = path->nodes[0];

fs/btrfs/extent-tree.c

3430

item_size = btrfs_item_size(leaf, extent_slot);

fs/btrfs/extent-tree.c

3439

ei = btrfs_item_ptr(leaf, extent_slot,

fs/btrfs/extent-tree.c

3454

WARN_ON(owner_objectid != btrfs_tree_block_level(leaf, bi));

fs/btrfs/extent-tree.c

3457

refs = btrfs_extent_refs(leaf, ei);

fs/btrfs/extent-tree.c

3468

__run_delayed_extent_op(extent_op, leaf, ei);

fs/btrfs/extent-tree.c

3481

btrfs_set_extent_refs(leaf, ei, refs);

fs/btrfs/extent-tree.c

3497

.generation = btrfs_extent_generation(leaf, ei),

fs/btrfs/extent-tree.c

3544

leaf, extent_slot);

fs/btrfs/extent-tree.c

418

static u64 hash_extent_data_ref_item(const struct extent_buffer *leaf,

fs/btrfs/extent-tree.c

421

return hash_extent_data_ref(btrfs_extent_data_ref_root(leaf, ref),

fs/btrfs/extent-tree.c

422

btrfs_extent_data_ref_objectid(leaf, ref),

fs/btrfs/extent-tree.c

423

btrfs_extent_data_ref_offset(leaf, ref));

fs/btrfs/extent-tree.c

426

static bool match_extent_data_ref(const struct extent_buffer *leaf,

fs/btrfs/extent-tree.c

430

if (btrfs_extent_data_ref_root(leaf, ref) != root_objectid ||

fs/btrfs/extent-tree.c

431

btrfs_extent_data_ref_objectid(leaf, ref) != owner ||

fs/btrfs/extent-tree.c

432

btrfs_extent_data_ref_offset(leaf, ref) != offset)

fs/btrfs/extent-tree.c

446

struct extent_buffer *leaf;

fs/btrfs/extent-tree.c

479

leaf = path->nodes[0];

fs/btrfs/extent-tree.c

480

nritems = btrfs_header_nritems(leaf);

fs/btrfs/extent-tree.c

490

leaf = path->nodes[0];

fs/btrfs/extent-tree.c

491

nritems = btrfs_header_nritems(leaf);

fs/btrfs/extent-tree.c

495

btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);

fs/btrfs/extent-tree.c

4998

struct extent_buffer *leaf;

fs/btrfs/extent-tree.c

500

ref = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/extent-tree.c

503

if (match_extent_data_ref(leaf, ref, root_objectid,

fs/btrfs/extent-tree.c

5031

leaf = path->nodes[0];

fs/btrfs/extent-tree.c

5032

extent_item = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/extent-tree.c

5034

btrfs_set_extent_refs(leaf, extent_item, ref_mod);

fs/btrfs/extent-tree.c

5035

btrfs_set_extent_generation(leaf, extent_item, trans->transid);

fs/btrfs/extent-tree.c

5036

btrfs_set_extent_flags(leaf, extent_item,

fs/btrfs/extent-tree.c

5041

btrfs_set_extent_inline_ref_type(leaf, iref, BTRFS_EXTENT_OWNER_REF_KEY);

fs/btrfs/extent-tree.c

5043

btrfs_set_extent_owner_ref_root_id(leaf, oref, oref_root);

fs/btrfs/extent-tree.c

5046

btrfs_set_extent_inline_ref_type(leaf, iref, type);

fs/btrfs/extent-tree.c

5051

btrfs_set_extent_inline_ref_offset(leaf, iref, parent);

fs/btrfs/extent-tree.c

5052

btrfs_set_shared_data_ref_count(leaf, ref, ref_mod);

fs/btrfs/extent-tree.c

5056

btrfs_set_extent_data_ref_root(leaf, ref, root_objectid);

fs/btrfs/extent-tree.c

5057

btrfs_set_extent_data_ref_objectid(leaf, ref, owner);

fs/btrfs/extent-tree.c

5058

btrfs_set_extent_data_ref_offset(leaf, ref, offset);

fs/btrfs/extent-tree.c

5059

btrfs_set_extent_data_ref_count(leaf, ref, ref_mod);

fs/btrfs/extent-tree.c

5079

struct extent_buffer *leaf;

fs/btrfs/extent-tree.c

5119

leaf = path->nodes[0];

fs/btrfs/extent-tree.c

5120

extent_item = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/extent-tree.c

5122

btrfs_set_extent_refs(leaf, extent_item, 1);

fs/btrfs/extent-tree.c

5123

btrfs_set_extent_generation(leaf, extent_item, trans->transid);

fs/btrfs/extent-tree.c

5124

btrfs_set_extent_flags(leaf, extent_item,

fs/btrfs/extent-tree.c

5131

btrfs_set_tree_block_key(leaf, block_info, &extent_op->key);

fs/btrfs/extent-tree.c

5132

btrfs_set_tree_block_level(leaf, block_info, level);

fs/btrfs/extent-tree.c

5137

btrfs_set_extent_inline_ref_type(leaf, iref,

fs/btrfs/extent-tree.c

5139

btrfs_set_extent_inline_ref_offset(leaf, iref, node->parent);

fs/btrfs/extent-tree.c

5141

btrfs_set_extent_inline_ref_type(leaf, iref,

fs/btrfs/extent-tree.c

5143

btrfs_set_extent_inline_ref_offset(leaf, iref, node->ref_root);

fs/btrfs/extent-tree.c

524

struct extent_buffer *leaf;

fs/btrfs/extent-tree.c

54

struct extent_buffer *leaf,

fs/btrfs/extent-tree.c

552

leaf = path->nodes[0];

fs/btrfs/extent-tree.c

555

ref = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/extent-tree.c

558

btrfs_set_shared_data_ref_count(leaf, ref, node->ref_mod);

fs/btrfs/extent-tree.c

560

num_refs = btrfs_shared_data_ref_count(leaf, ref);

fs/btrfs/extent-tree.c

562

btrfs_set_shared_data_ref_count(leaf, ref, num_refs);

fs/btrfs/extent-tree.c

567

ref = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/extent-tree.c

569

if (match_extent_data_ref(leaf, ref, node->ref_root,

fs/btrfs/extent-tree.c

579

leaf = path->nodes[0];

fs/btrfs/extent-tree.c

581

ref = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/extent-tree.c

584

btrfs_set_extent_data_ref_root(leaf, ref, node->ref_root);

fs/btrfs/extent-tree.c

585

btrfs_set_extent_data_ref_objectid(leaf, ref, owner);

fs/btrfs/extent-tree.c

586

btrfs_set_extent_data_ref_offset(leaf, ref, offset);

fs/btrfs/extent-tree.c

587

btrfs_set_extent_data_ref_count(leaf, ref, node->ref_mod);

fs/btrfs/extent-tree.c

589

num_refs = btrfs_extent_data_ref_count(leaf, ref);

fs/btrfs/extent-tree.c

591

btrfs_set_extent_data_ref_count(leaf, ref, num_refs);

fs/btrfs/extent-tree.c

608

struct extent_buffer *leaf;

fs/btrfs/extent-tree.c

612

leaf = path->nodes[0];

fs/btrfs/extent-tree.c

613

btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);

fs/btrfs/extent-tree.c

616

ref1 = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/extent-tree.c

618

num_refs = btrfs_extent_data_ref_count(leaf, ref1);

fs/btrfs/extent-tree.c

620

ref2 = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/extent-tree.c

622

num_refs = btrfs_shared_data_ref_count(leaf, ref2);

fs/btrfs/extent-tree.c

638

btrfs_set_extent_data_ref_count(leaf, ref1, num_refs);

fs/btrfs/extent-tree.c

640

btrfs_set_shared_data_ref_count(leaf, ref2, num_refs);

fs/btrfs/extent-tree.c

649

struct extent_buffer *leaf;

fs/btrfs/extent-tree.c

655

leaf = path->nodes[0];

fs/btrfs/extent-tree.c

656

btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);

fs/btrfs/extent-tree.c

663

type = btrfs_get_extent_inline_ref_type(leaf, iref, BTRFS_REF_TYPE_DATA);

fs/btrfs/extent-tree.c

667

num_refs = btrfs_extent_data_ref_count(leaf, ref1);

fs/btrfs/extent-tree.c

670

num_refs = btrfs_shared_data_ref_count(leaf, ref2);

fs/btrfs/extent-tree.c

673

ref1 = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/extent-tree.c

675

num_refs = btrfs_extent_data_ref_count(leaf, ref1);

fs/btrfs/extent-tree.c

677

ref2 = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/extent-tree.c

679

num_refs = btrfs_shared_data_ref_count(leaf, ref2);

fs/btrfs/extent-tree.c

807

struct extent_buffer *leaf;

fs/btrfs/extent-tree.c

889

leaf = path->nodes[0];

fs/btrfs/extent-tree.c

890

item_size = btrfs_item_size(leaf, path->slots[0]);

fs/btrfs/extent-tree.c

900

ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);

fs/btrfs/extent-tree.c

901

flags = btrfs_extent_flags(leaf, ei);

fs/btrfs/extent-tree.c

919

type = btrfs_get_extent_inline_ref_type(leaf, iref, needed);

fs/btrfs/extent-tree.c

940

if (match_extent_data_ref(leaf, dref, root_objectid,

fs/btrfs/extent-tree.c

945

if (hash_extent_data_ref_item(leaf, dref) <

fs/btrfs/extent-tree.c

950

ref_offset = btrfs_extent_inline_ref_offset(leaf, iref);

fs/btrfs/extent-tree.h

150

struct extent_buffer *leaf, int slot);

fs/btrfs/fiemap.c

560

struct extent_buffer *leaf;

fs/btrfs/fiemap.c

584

leaf = path->nodes[0];

fs/btrfs/fiemap.c

585

btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);

fs/btrfs/fiemap.c

597

ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_file_extent_item);

fs/btrfs/fiemap.c

598

if (btrfs_file_extent_type(leaf, ei) == BTRFS_FILE_EXTENT_INLINE) {

fs/btrfs/fiemap.c

610

disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, ei);

fs/btrfs/fiemap.c

620

leaf = path->nodes[0];

fs/btrfs/fiemap.c

621

ei = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/fiemap.c

623

disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, ei);

fs/btrfs/fiemap.c

684

struct extent_buffer *leaf = path->nodes[0];

fs/btrfs/fiemap.c

696

btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);

fs/btrfs/fiemap.c

709

backref_ctx->curr_leaf_bytenr = leaf->start;

fs/btrfs/fiemap.c

735

ei = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/fiemap.c

737

compression = btrfs_file_extent_compression(leaf, ei);

fs/btrfs/fiemap.c

738

extent_type = btrfs_file_extent_type(leaf, ei);

fs/btrfs/fiemap.c

739

extent_gen = btrfs_file_extent_generation(leaf, ei);

fs/btrfs/fiemap.c

742

disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, ei);

fs/btrfs/fiemap.c

744

extent_offset = btrfs_file_extent_offset(leaf, ei);

fs/btrfs/file-item.c

1040

item_offset = btrfs_item_ptr_offset(leaf,

fs/btrfs/file-item.c

1043

memzero_extent_buffer(leaf, item_offset + offset,

fs/btrfs/file-item.c

1110

struct extent_buffer *leaf = NULL;

fs/btrfs/file-item.c

1135

leaf = path->nodes[0];

fs/btrfs/file-item.c

1136

item_end = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/file-item.c

1139

btrfs_item_size(leaf, path->slots[0]));

fs/btrfs/file-item.c

1149

leaf = path->nodes[0];

fs/btrfs/file-item.c

1150

item_size = btrfs_item_size(leaf, path->slots[0]);

fs/btrfs/file-item.c

1175

if (btrfs_leaf_free_space(leaf) >= csum_size) {

fs/btrfs/file-item.c

1176

btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);

fs/btrfs/file-item.c

1196

leaf = path->nodes[0];

fs/btrfs/file-item.c

1197

btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);

fs/btrfs/file-item.c

1207

if (csum_offset == btrfs_item_size(leaf, path->slots[0]) /

fs/btrfs/file-item.c

1262

diff = diff - btrfs_item_size(leaf, path->slots[0]);

fs/btrfs/file-item.c

1263

diff = min_t(u32, btrfs_leaf_free_space(leaf), diff);

fs/btrfs/file-item.c

1293

leaf = path->nodes[0];

fs/btrfs/file-item.c

1295

item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item);

fs/btrfs/file-item.c

1297

btrfs_item_size(leaf, path->slots[0]));

fs/btrfs/file-item.c

1305

write_extent_buffer(leaf, sums->sums + index, (unsigned long)item,

fs/btrfs/file-item.c

1328

struct extent_buffer *leaf = path->nodes[0];

fs/btrfs/file-item.c

1332

u8 type = btrfs_file_extent_type(leaf, fi);

fs/btrfs/file-item.c

1333

int compress_type = btrfs_file_extent_compression(leaf, fi);

fs/btrfs/file-item.c

1335

btrfs_item_key_to_cpu(leaf, &key, slot);

fs/btrfs/file-item.c

1337

em->ram_bytes = btrfs_file_extent_ram_bytes(leaf, fi);

fs/btrfs/file-item.c

1338

em->generation = btrfs_file_extent_generation(leaf, fi);

fs/btrfs/file-item.c

1341

const u64 disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);

fs/btrfs/file-item.c

1352

em->disk_num_bytes = btrfs_file_extent_disk_num_bytes(leaf, fi);

fs/btrfs/file-item.c

1353

em->offset = btrfs_file_extent_offset(leaf, fi);

fs/btrfs/file-item.c

1391

const struct extent_buffer *leaf = path->nodes[0];

fs/btrfs/file-item.c

1397

btrfs_item_key_to_cpu(leaf, &key, slot);

fs/btrfs/file-item.c

1399

fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);

fs/btrfs/file-item.c

1401

if (btrfs_file_extent_type(leaf, fi) == BTRFS_FILE_EXTENT_INLINE)

fs/btrfs/file-item.c

1402

end = leaf->fs_info->sectorsize;

fs/btrfs/file-item.c

1404

end = key.offset + btrfs_file_extent_num_bytes(leaf, fi);

fs/btrfs/file-item.c

167

struct extent_buffer *leaf;

fs/btrfs/file-item.c

181

leaf = path->nodes[0];

fs/btrfs/file-item.c

182

item = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/file-item.c

184

btrfs_set_file_extent_disk_bytenr(leaf, item, 0);

fs/btrfs/file-item.c

185

btrfs_set_file_extent_disk_num_bytes(leaf, item, 0);

fs/btrfs/file-item.c

186

btrfs_set_file_extent_offset(leaf, item, 0);

fs/btrfs/file-item.c

187

btrfs_set_file_extent_num_bytes(leaf, item, num_bytes);

fs/btrfs/file-item.c

188

btrfs_set_file_extent_ram_bytes(leaf, item, num_bytes);

fs/btrfs/file-item.c

189

btrfs_set_file_extent_generation(leaf, item, trans->transid);

fs/btrfs/file-item.c

190

btrfs_set_file_extent_type(leaf, item, BTRFS_FILE_EXTENT_REG);

fs/btrfs/file-item.c

191

btrfs_set_file_extent_compression(leaf, item, 0);

fs/btrfs/file-item.c

192

btrfs_set_file_extent_encryption(leaf, item, 0);

fs/btrfs/file-item.c

193

btrfs_set_file_extent_other_encoding(leaf, item, 0);

fs/btrfs/file-item.c

209

struct extent_buffer *leaf;

fs/btrfs/file-item.c

220

leaf = path->nodes[0];

fs/btrfs/file-item.c

226

btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);

fs/btrfs/file-item.c

232

csums_in_item = btrfs_item_size(leaf, path->slots[0]);

fs/btrfs/file-item.c

242

item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item);

fs/btrfs/file-item.c

507

struct extent_buffer *leaf;

fs/btrfs/file-item.c

530

leaf = path->nodes[0];

fs/btrfs/file-item.c

531

btrfs_item_key_to_cpu(leaf, &key, path->slots[0] - 1);

fs/btrfs/file-item.c

551

btrfs_item_size(leaf, path->slots[0] - 1))

fs/btrfs/file-item.c

559

leaf = path->nodes[0];

fs/btrfs/file-item.c

560

if (path->slots[0] >= btrfs_header_nritems(leaf)) {

fs/btrfs/file-item.c

566

leaf = path->nodes[0];

fs/btrfs/file-item.c

569

btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);

fs/btrfs/file-item.c

579

btrfs_item_size(leaf, path->slots[0]));

fs/btrfs/file-item.c

651

struct extent_buffer *leaf;

fs/btrfs/file-item.c

686

leaf = path->nodes[0];

fs/btrfs/file-item.c

687

btrfs_item_key_to_cpu(leaf, &key, path->slots[0] - 1);

fs/btrfs/file-item.c

707

btrfs_item_size(leaf, path->slots[0] - 1))

fs/btrfs/file-item.c

716

leaf = path->nodes[0];

fs/btrfs/file-item.c

717

if (path->slots[0] >= btrfs_header_nritems(leaf)) {

fs/btrfs/file-item.c

723

leaf = path->nodes[0];

fs/btrfs/file-item.c

726

btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);

fs/btrfs/file-item.c

736

btrfs_item_size(leaf, path->slots[0]));

fs/btrfs/file-item.c

882

struct extent_buffer *leaf;

fs/btrfs/file-item.c

888

leaf = path->nodes[0];

fs/btrfs/file-item.c

889

csum_end = btrfs_item_size(leaf, path->slots[0]) / csum_size;

fs/btrfs/file-item.c

934

struct extent_buffer *leaf;

fs/btrfs/file-item.c

961

leaf = path->nodes[0];

fs/btrfs/file-item.c

962

btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);

fs/btrfs/file-item.c

972

csum_end = btrfs_item_size(leaf, path->slots[0]) / csum_size;

fs/btrfs/file-item.c

995

btrfs_item_key_to_cpu(leaf, &pk, slot);

fs/btrfs/file.c

143

struct extent_buffer *leaf;

fs/btrfs/file.c

192

leaf = path->nodes[0];

fs/btrfs/file.c

193

btrfs_item_key_to_cpu(leaf, &key, path->slots[0] - 1);

fs/btrfs/file.c

200

leaf = path->nodes[0];

fs/btrfs/file.c

201

if (path->slots[0] >= btrfs_header_nritems(leaf)) {

fs/btrfs/file.c

203

btrfs_print_leaf(leaf);

fs/btrfs/file.c

2057

static bool hole_mergeable(struct btrfs_inode *inode, struct extent_buffer *leaf,

fs/btrfs/file.c

2063

if (slot < 0 || slot >= btrfs_header_nritems(leaf))

fs/btrfs/file.c

2066

btrfs_item_key_to_cpu(leaf, &key, slot);

fs/btrfs/file.c

2071

fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);

fs/btrfs/file.c

2073

if (btrfs_file_extent_type(leaf, fi) != BTRFS_FILE_EXTENT_REG)

fs/btrfs/file.c

2076

if (btrfs_file_extent_disk_bytenr(leaf, fi))

fs/btrfs/file.c

2081

if (key.offset + btrfs_file_extent_num_bytes(leaf, fi) == start)

fs/btrfs/file.c

2092

struct extent_buffer *leaf;

fs/btrfs/file.c

2116

leaf = path->nodes[0];

fs/btrfs/file.c

2117

if (hole_mergeable(inode, leaf, path->slots[0] - 1, offset, end)) {

fs/btrfs/file.c

2121

fi = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/file.c

2123

num_bytes = btrfs_file_extent_num_bytes(leaf, fi) +

fs/btrfs/file.c

2125

btrfs_set_file_extent_num_bytes(leaf, fi, num_bytes);

fs/btrfs/file.c

2126

btrfs_set_file_extent_ram_bytes(leaf, fi, num_bytes);

fs/btrfs/file.c

2127

btrfs_set_file_extent_offset(leaf, fi, 0);

fs/btrfs/file.c

2128

btrfs_set_file_extent_generation(leaf, fi, trans->transid);

fs/btrfs/file.c

2132

if (hole_mergeable(inode, leaf, path->slots[0], offset, end)) {

fs/btrfs/file.c

2137

fi = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/file.c

2139

num_bytes = btrfs_file_extent_num_bytes(leaf, fi) + end -

fs/btrfs/file.c

214

leaf = path->nodes[0];

fs/btrfs/file.c

2141

btrfs_set_file_extent_num_bytes(leaf, fi, num_bytes);

fs/btrfs/file.c

2142

btrfs_set_file_extent_ram_bytes(leaf, fi, num_bytes);

fs/btrfs/file.c

2143

btrfs_set_file_extent_offset(leaf, fi, 0);

fs/btrfs/file.c

2144

btrfs_set_file_extent_generation(leaf, fi, trans->transid);

fs/btrfs/file.c

218

btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);

fs/btrfs/file.c

231

fi = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/file.c

2311

struct extent_buffer *leaf;

fs/btrfs/file.c

233

extent_type = btrfs_file_extent_type(leaf, fi);

fs/btrfs/file.c

2332

leaf = path->nodes[0];

fs/btrfs/file.c

2334

write_extent_buffer(leaf, extent_info->extent_buf,

fs/btrfs/file.c

2335

btrfs_item_ptr_offset(leaf, slot),

fs/btrfs/file.c

2337

extent = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);

fs/btrfs/file.c

2338

ASSERT(btrfs_file_extent_type(leaf, extent) != BTRFS_FILE_EXTENT_INLINE);

fs/btrfs/file.c

2339

btrfs_set_file_extent_offset(leaf, extent, extent_info->data_offset);

fs/btrfs/file.c

2340

btrfs_set_file_extent_num_bytes(leaf, extent, replace_len);

fs/btrfs/file.c

2342

btrfs_set_file_extent_generation(leaf, extent, trans->transid);

fs/btrfs/file.c

237

disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);

fs/btrfs/file.c

238

num_bytes = btrfs_file_extent_disk_num_bytes(leaf, fi);

fs/btrfs/file.c

239

extent_offset = btrfs_file_extent_offset(leaf, fi);

fs/btrfs/file.c

241

btrfs_file_extent_num_bytes(leaf, fi);

fs/btrfs/file.c

244

btrfs_file_extent_ram_bytes(leaf, fi);

fs/btrfs/file.c

283

btrfs_print_leaf(leaf);

fs/btrfs/file.c

303

leaf = path->nodes[0];

fs/btrfs/file.c

304

fi = btrfs_item_ptr(leaf, path->slots[0] - 1,

fs/btrfs/file.c

306

btrfs_set_file_extent_num_bytes(leaf, fi,

fs/btrfs/file.c

309

fi = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/file.c

313

btrfs_set_file_extent_offset(leaf, fi, extent_offset);

fs/btrfs/file.c

314

btrfs_set_file_extent_num_bytes(leaf, fi,

fs/btrfs/file.c

358

btrfs_set_file_extent_offset(leaf, fi, extent_offset);

fs/btrfs/file.c

359

btrfs_set_file_extent_num_bytes(leaf, fi,

fs/btrfs/file.c

3641

struct extent_buffer *leaf = path->nodes[0];

fs/btrfs/file.c

3646

if (path->slots[0] >= btrfs_header_nritems(leaf)) {

fs/btrfs/file.c

3653

leaf = path->nodes[0];

fs/btrfs/file.c

3656

btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);

fs/btrfs/file.c

3698

extent = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/file.c

3700

type = btrfs_file_extent_type(leaf, extent);

fs/btrfs/file.c

3709

btrfs_file_extent_disk_bytenr(leaf, extent) == 0)) {

fs/btrfs/file.c

373

btrfs_print_leaf(leaf);

fs/btrfs/file.c

382

btrfs_set_file_extent_num_bytes(leaf, fi,

fs/btrfs/file.c

404

btrfs_print_leaf(leaf);

fs/btrfs/file.c

439

if (path->slots[0] + 1 < btrfs_header_nritems(leaf)) {

fs/btrfs/file.c

474

leaf = path->nodes[0];

fs/btrfs/file.c

482

btrfs_leaf_free_space(leaf) >=

fs/btrfs/file.c

488

if (!del_nr && path->slots[0] < btrfs_header_nritems(leaf)) {

fs/btrfs/file.c

491

btrfs_item_key_to_cpu(leaf, &slot_key, path->slots[0]);

fs/btrfs/file.c

510

static bool extent_mergeable(struct extent_buffer *leaf, int slot, u64 objectid,

fs/btrfs/file.c

517

if (slot < 0 || slot >= btrfs_header_nritems(leaf))

fs/btrfs/file.c

520

btrfs_item_key_to_cpu(leaf, &key, slot);

fs/btrfs/file.c

524

fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);

fs/btrfs/file.c

525

if (btrfs_file_extent_type(leaf, fi) != BTRFS_FILE_EXTENT_REG ||

fs/btrfs/file.c

526

btrfs_file_extent_disk_bytenr(leaf, fi) != bytenr ||

fs/btrfs/file.c

527

btrfs_file_extent_offset(leaf, fi) != key.offset - orig_offset ||

fs/btrfs/file.c

528

btrfs_file_extent_compression(leaf, fi) ||

fs/btrfs/file.c

529

btrfs_file_extent_encryption(leaf, fi) ||

fs/btrfs/file.c

530

btrfs_file_extent_other_encoding(leaf, fi))

fs/btrfs/file.c

533

extent_end = key.offset + btrfs_file_extent_num_bytes(leaf, fi);

fs/btrfs/file.c

553

struct extent_buffer *leaf;

fs/btrfs/file.c

588

leaf = path->nodes[0];

fs/btrfs/file.c

589

btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);

fs/btrfs/file.c

595

fi = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/file.c

597

if (unlikely(btrfs_file_extent_type(leaf, fi) != BTRFS_FILE_EXTENT_PREALLOC)) {

fs/btrfs/file.c

602

extent_end = key.offset + btrfs_file_extent_num_bytes(leaf, fi);

fs/btrfs/file.c

609

bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);

fs/btrfs/file.c

610

num_bytes = btrfs_file_extent_disk_num_bytes(leaf, fi);

fs/btrfs/file.c

611

orig_offset = key.offset - btrfs_file_extent_offset(leaf, fi);

fs/btrfs/file.c

617

if (extent_mergeable(leaf, path->slots[0] - 1,

fs/btrfs/file.c

622

fi = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/file.c

624

btrfs_set_file_extent_generation(leaf, fi,

fs/btrfs/file.c

626

btrfs_set_file_extent_num_bytes(leaf, fi,

fs/btrfs/file.c

628

btrfs_set_file_extent_offset(leaf, fi,

fs/btrfs/file.c

630

fi = btrfs_item_ptr(leaf, path->slots[0] - 1,

fs/btrfs/file.c

632

btrfs_set_file_extent_generation(leaf, fi,

fs/btrfs/file.c

634

btrfs_set_file_extent_num_bytes(leaf, fi,

fs/btrfs/file.c

643

if (extent_mergeable(leaf, path->slots[0] + 1,

fs/btrfs/file.c

646

fi = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/file.c

648

btrfs_set_file_extent_num_bytes(leaf, fi,

fs/btrfs/file.c

650

btrfs_set_file_extent_generation(leaf, fi,

fs/btrfs/file.c

656

fi = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/file.c

658

btrfs_set_file_extent_generation(leaf, fi,

fs/btrfs/file.c

660

btrfs_set_file_extent_num_bytes(leaf, fi,

fs/btrfs/file.c

662

btrfs_set_file_extent_offset(leaf, fi,

fs/btrfs/file.c

683

leaf = path->nodes[0];

fs/btrfs/file.c

684

fi = btrfs_item_ptr(leaf, path->slots[0] - 1,

fs/btrfs/file.c

686

btrfs_set_file_extent_generation(leaf, fi, trans->transid);

fs/btrfs/file.c

687

btrfs_set_file_extent_num_bytes(leaf, fi,

fs/btrfs/file.c

690

fi = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/file.c

693

btrfs_set_file_extent_generation(leaf, fi, trans->transid);

fs/btrfs/file.c

694

btrfs_set_file_extent_offset(leaf, fi, split - orig_offset);

fs/btrfs/file.c

695

btrfs_set_file_extent_num_bytes(leaf, fi,

fs/btrfs/file.c

735

if (extent_mergeable(leaf, path->slots[0] + 1,

fs/btrfs/file.c

753

if (extent_mergeable(leaf, path->slots[0] - 1,

fs/btrfs/file.c

770

fi = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/file.c

772

btrfs_set_file_extent_type(leaf, fi,

fs/btrfs/file.c

774

btrfs_set_file_extent_generation(leaf, fi, trans->transid);

fs/btrfs/file.c

776

fi = btrfs_item_ptr(leaf, del_slot - 1,

fs/btrfs/file.c

778

btrfs_set_file_extent_type(leaf, fi,

fs/btrfs/file.c

780

btrfs_set_file_extent_generation(leaf, fi, trans->transid);

fs/btrfs/file.c

781

btrfs_set_file_extent_num_bytes(leaf, fi,

fs/btrfs/free-space-cache.c

108

leaf = path->nodes[0];

fs/btrfs/free-space-cache.c

109

header = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/free-space-cache.c

111

btrfs_free_space_key(leaf, header, &disk_key);

fs/btrfs/free-space-cache.c

1154

struct extent_buffer *leaf;

fs/btrfs/free-space-cache.c

1167

leaf = path->nodes[0];

fs/btrfs/free-space-cache.c

1172

btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);

fs/btrfs/free-space-cache.c

1184

header = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/free-space-cache.c

1186

btrfs_set_free_space_entries(leaf, header, entries);

fs/btrfs/free-space-cache.c

1187

btrfs_set_free_space_bitmaps(leaf, header, bitmaps);

fs/btrfs/free-space-cache.c

1188

btrfs_set_free_space_generation(leaf, header, trans->transid);

fs/btrfs/free-space-cache.c

176

struct extent_buffer *leaf;

fs/btrfs/free-space-cache.c

186

leaf = path->nodes[0];

fs/btrfs/free-space-cache.c

187

inode_item = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/free-space-cache.c

189

btrfs_item_key(leaf, &disk_key, path->slots[0]);

fs/btrfs/free-space-cache.c

190

memzero_extent_buffer(leaf, (unsigned long)inode_item,

fs/btrfs/free-space-cache.c

192

btrfs_set_inode_generation(leaf, inode_item, trans->transid);

fs/btrfs/free-space-cache.c

193

btrfs_set_inode_size(leaf, inode_item, 0);

fs/btrfs/free-space-cache.c

194

btrfs_set_inode_nbytes(leaf, inode_item, 0);

fs/btrfs/free-space-cache.c

195

btrfs_set_inode_uid(leaf, inode_item, 0);

fs/btrfs/free-space-cache.c

196

btrfs_set_inode_gid(leaf, inode_item, 0);

fs/btrfs/free-space-cache.c

197

btrfs_set_inode_mode(leaf, inode_item, S_IFREG | 0600);

fs/btrfs/free-space-cache.c

198

btrfs_set_inode_flags(leaf, inode_item, flags);

fs/btrfs/free-space-cache.c

199

btrfs_set_inode_nlink(leaf, inode_item, 1);

fs/btrfs/free-space-cache.c

200

btrfs_set_inode_transid(leaf, inode_item, trans->transid);

fs/btrfs/free-space-cache.c

201

btrfs_set_inode_block_group(leaf, inode_item, offset);

fs/btrfs/free-space-cache.c

214

leaf = path->nodes[0];

fs/btrfs/free-space-cache.c

215

header = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/free-space-cache.c

217

memzero_extent_buffer(leaf, (unsigned long)header, sizeof(*header));

fs/btrfs/free-space-cache.c

218

btrfs_set_free_space_key(leaf, header, &disk_key);

fs/btrfs/free-space-cache.c

740

struct extent_buffer *leaf;

fs/btrfs/free-space-cache.c

769

leaf = path->nodes[0];

fs/btrfs/free-space-cache.c

770

header = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/free-space-cache.c

772

num_entries = btrfs_free_space_entries(leaf, header);

fs/btrfs/free-space-cache.c

773

num_bitmaps = btrfs_free_space_bitmaps(leaf, header);

fs/btrfs/free-space-cache.c

774

generation = btrfs_free_space_generation(leaf, header);

fs/btrfs/free-space-cache.c

91

struct extent_buffer *leaf;

fs/btrfs/free-space-tree.c

1466

struct extent_buffer *leaf;

fs/btrfs/free-space-tree.c

1500

leaf = path->nodes[0];

fs/btrfs/free-space-tree.c

1504

btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0] - 1);

fs/btrfs/free-space-tree.c

205

struct extent_buffer *leaf;

fs/btrfs/free-space-tree.c

234

leaf = path->nodes[0];

fs/btrfs/free-space-tree.c

238

btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0] - 1);

fs/btrfs/free-space-tree.c

280

leaf = path->nodes[0];

fs/btrfs/free-space-tree.c

281

flags = btrfs_free_space_flags(leaf, info);

fs/btrfs/free-space-tree.c

285

btrfs_set_free_space_flags(leaf, info, flags);

fs/btrfs/free-space-tree.c

286

expected_extent_count = btrfs_free_space_extent_count(leaf, info);

fs/btrfs/free-space-tree.c

321

leaf = path->nodes[0];

fs/btrfs/free-space-tree.c

322

ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);

fs/btrfs/free-space-tree.c

323

write_extent_buffer(leaf, bitmap_cursor, ptr,

fs/btrfs/free-space-tree.c

346

struct extent_buffer *leaf;

fs/btrfs/free-space-tree.c

374

leaf = path->nodes[0];

fs/btrfs/free-space-tree.c

378

btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0] - 1);

fs/btrfs/free-space-tree.c

402

ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);

fs/btrfs/free-space-tree.c

403

read_extent_buffer(leaf, bitmap_cursor, ptr,

fs/btrfs/free-space-tree.c

426

leaf = path->nodes[0];

fs/btrfs/free-space-tree.c

427

flags = btrfs_free_space_flags(leaf, info);

fs/btrfs/free-space-tree.c

431

btrfs_set_free_space_flags(leaf, info, flags);

fs/btrfs/free-space-tree.c

432

expected_extent_count = btrfs_free_space_extent_count(leaf, info);

fs/btrfs/free-space-tree.c

513

struct extent_buffer *leaf;

fs/btrfs/free-space-tree.c

518

leaf = path->nodes[0];

fs/btrfs/free-space-tree.c

519

btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);

fs/btrfs/free-space-tree.c

526

ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);

fs/btrfs/free-space-tree.c

529

return extent_buffer_test_bit(leaf, ptr, i);

fs/btrfs/free-space-tree.c

538

struct extent_buffer *leaf;

fs/btrfs/free-space-tree.c

544

leaf = path->nodes[0];

fs/btrfs/free-space-tree.c

545

btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);

fs/btrfs/free-space-tree.c

556

ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);

fs/btrfs/free-space-tree.c

560

extent_buffer_bitmap_set(leaf, ptr, first, last - first);

fs/btrfs/free-space-tree.c

562

extent_buffer_bitmap_clear(leaf, ptr, first, last - first);

fs/btrfs/free-space-tree.c

563

btrfs_mark_buffer_dirty(trans, leaf);

fs/btrfs/free-space-tree.c

75

struct extent_buffer *leaf;

fs/btrfs/free-space-tree.c

86

leaf = path->nodes[0];

fs/btrfs/free-space-tree.c

87

info = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/free-space-tree.c

89

btrfs_set_free_space_extent_count(leaf, info, 0);

fs/btrfs/free-space-tree.c

90

btrfs_set_free_space_flags(leaf, info, 0);

fs/btrfs/inode-item.c

112

struct extent_buffer *leaf;

fs/btrfs/inode-item.c

145

leaf = path->nodes[0];

fs/btrfs/inode-item.c

146

item_size = btrfs_item_size(leaf, path->slots[0]);

fs/btrfs/inode-item.c

148

*index = btrfs_inode_extref_index(leaf, extref);

fs/btrfs/inode-item.c

156

item_start = btrfs_item_ptr_offset(leaf, path->slots[0]);

fs/btrfs/inode-item.c

158

memmove_extent_buffer(leaf, ptr, ptr + del_len,

fs/btrfs/inode-item.c

17

struct btrfs_inode_ref *btrfs_find_name_in_backref(const struct extent_buffer *leaf,

fs/btrfs/inode-item.c

173

struct extent_buffer *leaf;

fs/btrfs/inode-item.c

205

leaf = path->nodes[0];

fs/btrfs/inode-item.c

206

item_size = btrfs_item_size(leaf, path->slots[0]);

fs/btrfs/inode-item.c

209

*index = btrfs_inode_ref_index(leaf, ref);

fs/btrfs/inode-item.c

217

item_start = btrfs_item_ptr_offset(leaf, path->slots[0]);

fs/btrfs/inode-item.c

218

memmove_extent_buffer(leaf, ptr, ptr + sub_item_len,

fs/btrfs/inode-item.c

254

struct extent_buffer *leaf;

fs/btrfs/inode-item.c

279

leaf = path->nodes[0];

fs/btrfs/inode-item.c

28

item_size = btrfs_item_size(leaf, slot);

fs/btrfs/inode-item.c

280

ptr = (unsigned long)btrfs_item_ptr(leaf, path->slots[0], char);

fs/btrfs/inode-item.c

281

ptr += btrfs_item_size(leaf, path->slots[0]) - ins_len;

fs/btrfs/inode-item.c

29

ptr = btrfs_item_ptr_offset(leaf, slot);

fs/btrfs/inode-item.c

32

len = btrfs_inode_ref_name_len(leaf, ref);

fs/btrfs/inode-item.c

37

if (memcmp_extent_buffer(leaf, name->name, name_ptr,

fs/btrfs/inode-item.c

391

struct extent_buffer *leaf;

fs/btrfs/inode-item.c

398

leaf = path->nodes[0];

fs/btrfs/inode-item.c

399

btrfs_item_key_to_cpu(leaf, &found_key, slot);

fs/btrfs/inode-item.c

410

const struct extent_buffer *leaf,

fs/btrfs/inode-item.c

417

trace_btrfs_truncate_show_fi_inline(inode, leaf, fi, slot,

fs/btrfs/inode-item.c

420

trace_btrfs_truncate_show_fi_regular(inode, leaf, fi, offset);

fs/btrfs/inode-item.c

447

struct extent_buffer *leaf;

fs/btrfs/inode-item.c

45

const struct extent_buffer *leaf, int slot, u64 ref_objectid,

fs/btrfs/inode-item.c

515

leaf = path->nodes[0];

fs/btrfs/inode-item.c

516

btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);

fs/btrfs/inode-item.c

527

fi = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/inode-item.c

529

extent_type = btrfs_file_extent_type(leaf, fi);

fs/btrfs/inode-item.c

532

btrfs_file_extent_num_bytes(leaf, fi);

fs/btrfs/inode-item.c

534

item_end += btrfs_file_extent_ram_bytes(leaf, fi);

fs/btrfs/inode-item.c

536

btrfs_trace_truncate(control->inode, leaf, fi,

fs/btrfs/inode-item.c

55

item_size = btrfs_item_size(leaf, slot);

fs/btrfs/inode-item.c

56

ptr = btrfs_item_ptr_offset(leaf, slot);

fs/btrfs/inode-item.c

562

extent_start = btrfs_file_extent_disk_bytenr(leaf, fi);

fs/btrfs/inode-item.c

565

btrfs_file_extent_num_bytes(leaf, fi);

fs/btrfs/inode-item.c

571

btrfs_set_file_extent_num_bytes(leaf, fi,

fs/btrfs/inode-item.c

578

btrfs_file_extent_disk_num_bytes(leaf, fi);

fs/btrfs/inode-item.c

580

btrfs_file_extent_offset(leaf, fi);

fs/btrfs/inode-item.c

583

num_dec = btrfs_file_extent_num_bytes(leaf, fi);

fs/btrfs/inode-item.c

594

btrfs_file_extent_encryption(leaf, fi) == 0 &&

fs/btrfs/inode-item.c

595

btrfs_file_extent_other_encoding(leaf, fi) == 0 &&

fs/btrfs/inode-item.c

596

btrfs_file_extent_compression(leaf, fi) == 0) {

fs/btrfs/inode-item.c

599

btrfs_set_file_extent_ram_bytes(leaf, fi, size);

fs/btrfs/inode-item.c

660

.ref_root = btrfs_header_owner(leaf),

fs/btrfs/inode-item.c

67

ref_name_len = btrfs_inode_extref_name_len(leaf, extref);

fs/btrfs/inode-item.c

70

btrfs_inode_extref_parent(leaf, extref) == ref_objectid &&

fs/btrfs/inode-item.c

71

(memcmp_extent_buffer(leaf, name->name, name_ptr,

fs/btrfs/inode-item.h

109

struct btrfs_inode_ref *btrfs_find_name_in_backref(const struct extent_buffer *leaf,

fs/btrfs/inode-item.h

113

const struct extent_buffer *leaf, int slot, u64 ref_objectid,

fs/btrfs/inode.c

10383

struct extent_buffer *leaf;

fs/btrfs/inode.c

10410

leaf = path->nodes[0];

fs/btrfs/inode.c

10411

ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_file_extent_item);

fs/btrfs/inode.c

10413

if (btrfs_file_extent_type(leaf, ei) == BTRFS_FILE_EXTENT_INLINE) {

fs/btrfs/inode.c

10426

if (btrfs_file_extent_compression(leaf, ei) != BTRFS_COMPRESS_NONE) {

fs/btrfs/inode.c

10432

disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, ei);

fs/btrfs/inode.c

10439

logical_block_start = disk_bytenr + btrfs_file_extent_offset(leaf, ei);

fs/btrfs/inode.c

10440

extent_gen = btrfs_file_extent_generation(leaf, ei);

fs/btrfs/inode.c

10446

len = btrfs_file_extent_num_bytes(leaf, ei);

fs/btrfs/inode.c

10448

backref_ctx->curr_leaf_bytenr = leaf->start;

fs/btrfs/inode.c

1818

struct extent_buffer *leaf = path->nodes[0];

fs/btrfs/inode.c

1834

fi = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_file_extent_item);

fs/btrfs/inode.c

1835

extent_type = btrfs_file_extent_type(leaf, fi);

fs/btrfs/inode.c

1849

if (btrfs_file_extent_generation(leaf, fi) <=

fs/btrfs/inode.c

1854

if (btrfs_file_extent_disk_bytenr(leaf, fi) == 0)

fs/btrfs/inode.c

1858

if (btrfs_file_extent_compression(leaf, fi) ||

fs/btrfs/inode.c

1859

btrfs_file_extent_encryption(leaf, fi) ||

fs/btrfs/inode.c

1860

btrfs_file_extent_other_encoding(leaf, fi))

fs/btrfs/inode.c

1865

args->file_extent.disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);

fs/btrfs/inode.c

1866

args->file_extent.disk_num_bytes = btrfs_file_extent_disk_num_bytes(leaf, fi);

fs/btrfs/inode.c

1867

args->file_extent.ram_bytes = btrfs_file_extent_ram_bytes(leaf, fi);

fs/btrfs/inode.c

1868

args->file_extent.offset = btrfs_file_extent_offset(leaf, fi);

fs/btrfs/inode.c

1869

args->file_extent.compression = btrfs_file_extent_compression(leaf, fi);

fs/btrfs/inode.c

2053

struct extent_buffer *leaf;

fs/btrfs/inode.c

2069

leaf = path->nodes[0];

fs/btrfs/inode.c

2070

btrfs_item_key_to_cpu(leaf, &found_key,

fs/btrfs/inode.c

2079

leaf = path->nodes[0];

fs/btrfs/inode.c

2080

if (path->slots[0] >= btrfs_header_nritems(leaf)) {

fs/btrfs/inode.c

2086

leaf = path->nodes[0];

fs/btrfs/inode.c

2089

btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);

fs/btrfs/inode.c

2124

fi = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/inode.c

2126

extent_type = btrfs_file_extent_type(leaf, fi);

fs/btrfs/inode.c

3047

struct extent_buffer *leaf;

fs/btrfs/inode.c

3089

leaf = path->nodes[0];

fs/btrfs/inode.c

3091

write_extent_buffer(leaf, stack_fi,

fs/btrfs/inode.c

3092

btrfs_item_ptr_offset(leaf, path->slots[0]),

fs/btrfs/inode.c

3714

struct extent_buffer *leaf;

fs/btrfs/inode.c

3754

leaf = path->nodes[0];

fs/btrfs/inode.c

3755

btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);

fs/btrfs/inode.c

3916

static noinline bool acls_after_inode_item(struct extent_buffer *leaf,

fs/btrfs/inode.c

3920

u32 nritems = btrfs_header_nritems(leaf);

fs/btrfs/inode.c

3936

btrfs_item_key_to_cpu(leaf, &found_key, slot);

fs/btrfs/inode.c

4049

struct extent_buffer *leaf;

fs/btrfs/inode.c

4079

leaf = path->nodes[0];

fs/btrfs/inode.c

4084

inode_item = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/inode.c

4086

vfs_inode->i_mode = btrfs_inode_mode(leaf, inode_item);

fs/btrfs/inode.c

4087

set_nlink(vfs_inode, btrfs_inode_nlink(leaf, inode_item));

fs/btrfs/inode.c

4088

i_uid_write(vfs_inode, btrfs_inode_uid(leaf, inode_item));

fs/btrfs/inode.c

4089

i_gid_write(vfs_inode, btrfs_inode_gid(leaf, inode_item));

fs/btrfs/inode.c

4090

btrfs_i_size_write(inode, btrfs_inode_size(leaf, inode_item));

fs/btrfs/inode.c

4092

inode_set_atime(vfs_inode, btrfs_timespec_sec(leaf, &inode_item->atime),

fs/btrfs/inode.c

4093

btrfs_timespec_nsec(leaf, &inode_item->atime));

fs/btrfs/inode.c

4095

inode_set_mtime(vfs_inode, btrfs_timespec_sec(leaf, &inode_item->mtime),

fs/btrfs/inode.c

4096

btrfs_timespec_nsec(leaf, &inode_item->mtime));

fs/btrfs/inode.c

4098

inode_set_ctime(vfs_inode, btrfs_timespec_sec(leaf, &inode_item->ctime),

fs/btrfs/inode.c

4099

btrfs_timespec_nsec(leaf, &inode_item->ctime));

fs/btrfs/inode.c

4101

inode->i_otime_sec = btrfs_timespec_sec(leaf, &inode_item->otime);

fs/btrfs/inode.c

4102

inode->i_otime_nsec = btrfs_timespec_nsec(leaf, &inode_item->otime);

fs/btrfs/inode.c

4104

inode_set_bytes(vfs_inode, btrfs_inode_nbytes(leaf, inode_item));

fs/btrfs/inode.c

4105

inode->generation = btrfs_inode_generation(leaf, inode_item);

fs/btrfs/inode.c

4106

inode->last_trans = btrfs_inode_transid(leaf, inode_item);

fs/btrfs/inode.c

4108

inode_set_iversion_queried(vfs_inode, btrfs_inode_sequence(leaf, inode_item));

fs/btrfs/inode.c

4111

rdev = btrfs_inode_rdev(leaf, inode_item);

fs/btrfs/inode.c

4116

btrfs_inode_split_flags(btrfs_inode_flags(leaf, inode_item),

fs/btrfs/inode.c

4173

path->slots[0] >= btrfs_header_nritems(leaf))

fs/btrfs/inode.c

4176

btrfs_item_key_to_cpu(leaf, &location, path->slots[0]);

fs/btrfs/inode.c

4180

ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);

fs/btrfs/inode.c

4185

inode->dir_index = btrfs_inode_ref_index(leaf, ref);

fs/btrfs/inode.c

4190

inode->dir_index = btrfs_inode_extref_index(leaf, extref);

fs/btrfs/inode.c

4197

maybe_acls = acls_after_inode_item(leaf, path->slots[0],

fs/btrfs/inode.c

4271

struct extent_buffer *leaf,

fs/btrfs/inode.c

4277

btrfs_set_inode_uid(leaf, item, i_uid_read(inode));

fs/btrfs/inode.c

4278

btrfs_set_inode_gid(leaf, item, i_gid_read(inode));

fs/btrfs/inode.c

4279

btrfs_set_inode_size(leaf, item, BTRFS_I(inode)->disk_i_size);

fs/btrfs/inode.c

4280

btrfs_set_inode_mode(leaf, item, inode->i_mode);

fs/btrfs/inode.c

4281

btrfs_set_inode_nlink(leaf, item, inode->i_nlink);

fs/btrfs/inode.c

4283

btrfs_set_timespec_sec(leaf, &item->atime, inode_get_atime_sec(inode));

fs/btrfs/inode.c

4284

btrfs_set_timespec_nsec(leaf, &item->atime, inode_get_atime_nsec(inode));

fs/btrfs/inode.c

4286

btrfs_set_timespec_sec(leaf, &item->mtime, inode_get_mtime_sec(inode));

fs/btrfs/inode.c

4287

btrfs_set_timespec_nsec(leaf, &item->mtime, inode_get_mtime_nsec(inode));

fs/btrfs/inode.c

4289

btrfs_set_timespec_sec(leaf, &item->ctime, inode_get_ctime_sec(inode));

fs/btrfs/inode.c

4290

btrfs_set_timespec_nsec(leaf, &item->ctime, inode_get_ctime_nsec(inode));

fs/btrfs/inode.c

4292

btrfs_set_timespec_sec(leaf, &item->otime, BTRFS_I(inode)->i_otime_sec);

fs/btrfs/inode.c

4293

btrfs_set_timespec_nsec(leaf, &item->otime, BTRFS_I(inode)->i_otime_nsec);

fs/btrfs/inode.c

4295

btrfs_set_inode_nbytes(leaf, item, inode_get_bytes(inode));

fs/btrfs/inode.c

4296

btrfs_set_inode_generation(leaf, item, BTRFS_I(inode)->generation);

fs/btrfs/inode.c

4297

btrfs_set_inode_sequence(leaf, item, inode_peek_iversion(inode));

fs/btrfs/inode.c

4298

btrfs_set_inode_transid(leaf, item, trans->transid);

fs/btrfs/inode.c

4299

btrfs_set_inode_rdev(leaf, item, inode->i_rdev);

fs/btrfs/inode.c

4302

btrfs_set_inode_flags(leaf, item, flags);

fs/btrfs/inode.c

4303

btrfs_set_inode_block_group(leaf, item, 0);

fs/btrfs/inode.c

4314

struct extent_buffer *leaf;

fs/btrfs/inode.c

4330

leaf = path->nodes[0];

fs/btrfs/inode.c

4331

inode_item = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/inode.c

4334

fill_inode_item(trans, leaf, inode_item, &inode->vfs_inode);

fs/btrfs/inode.c

4580

struct extent_buffer *leaf;

fs/btrfs/inode.c

4618

leaf = path->nodes[0];

fs/btrfs/inode.c

4619

btrfs_dir_item_key_to_cpu(leaf, di, &key);

fs/btrfs/inode.c

4645

leaf = path->nodes[0];

fs/btrfs/inode.c

4646

btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);

fs/btrfs/inode.c

467

struct extent_buffer *leaf;

fs/btrfs/inode.c

511

leaf = path->nodes[0];

fs/btrfs/inode.c

512

ei = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/inode.c

514

btrfs_set_file_extent_generation(leaf, ei, trans->transid);

fs/btrfs/inode.c

515

btrfs_set_file_extent_type(leaf, ei, BTRFS_FILE_EXTENT_INLINE);

fs/btrfs/inode.c

516

btrfs_set_file_extent_encryption(leaf, ei, 0);

fs/btrfs/inode.c

517

btrfs_set_file_extent_other_encoding(leaf, ei, 0);

fs/btrfs/inode.c

518

btrfs_set_file_extent_ram_bytes(leaf, ei, size);

fs/btrfs/inode.c

523

write_extent_buffer(leaf, kaddr, ptr, compressed_size);

fs/btrfs/inode.c

526

btrfs_set_file_extent_compression(leaf, ei,

fs/btrfs/inode.c

533

btrfs_set_file_extent_compression(leaf, ei, 0);

fs/btrfs/inode.c

535

write_extent_buffer(leaf, kaddr, ptr, size);

fs/btrfs/inode.c

5818

struct extent_buffer *leaf;

fs/btrfs/inode.c

5846

leaf = path->nodes[0];

fs/btrfs/inode.c

5847

ref = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_root_ref);

fs/btrfs/inode.c

5848

if (btrfs_root_ref_dirid(leaf, ref) != btrfs_ino(dir) ||

fs/btrfs/inode.c

5849

btrfs_root_ref_name_len(leaf, ref) != fname.disk_name.len)

fs/btrfs/inode.c

5852

ret = memcmp_extent_buffer(leaf, fname.disk_name.name,

fs/btrfs/inode.c

6162

struct extent_buffer *leaf;

fs/btrfs/inode.c

6196

leaf = path->nodes[0];

fs/btrfs/inode.c

6197

btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);

fs/btrfs/inode.c

6342

struct extent_buffer *leaf = path->nodes[0];

fs/btrfs/inode.c

6355

di = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dir_item);

fs/btrfs/inode.c

6356

name_len = btrfs_dir_name_len(leaf, di);

fs/btrfs/inode.c

6369

ftype = btrfs_dir_flags_to_ftype(btrfs_dir_flags(leaf, di));

fs/btrfs/inode.c

6372

read_extent_buffer(leaf, name_ptr,

fs/btrfs/inode.c

6376

btrfs_dir_item_key_to_cpu(leaf, di, &location);

fs/btrfs/inode.c

7132

struct extent_buffer *leaf = path->nodes[0];

fs/btrfs/inode.c

7133

const u32 blocksize = leaf->fs_info->sectorsize;

fs/btrfs/inode.c

7140

compress_type = btrfs_file_extent_compression(leaf, item);

fs/btrfs/inode.c

7141

max_size = btrfs_file_extent_ram_bytes(leaf, item);

fs/btrfs/inode.c

7142

inline_size = btrfs_file_extent_inline_item_len(leaf, path->slots[0]);

fs/btrfs/inode.c

7148

read_extent_buffer(leaf, tmp, ptr, inline_size);

fs/btrfs/inode.c

7225

struct extent_buffer *leaf;

fs/btrfs/inode.c

7280

leaf = path->nodes[0];

fs/btrfs/inode.c

7281

item = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/inode.c

7283

btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);

fs/btrfs/inode.c

7296

extent_type = btrfs_file_extent_type(leaf, item);

fs/btrfs/inode.c

7309

trace_btrfs_get_extent_show_fi_regular(inode, leaf, item,

fs/btrfs/inode.c

7312

trace_btrfs_get_extent_show_fi_inline(inode, leaf, item,

fs/btrfs/inode.c

7319

if (path->slots[0] >= btrfs_header_nritems(leaf)) {

fs/btrfs/inode.c

7326

leaf = path->nodes[0];

fs/btrfs/inode.c

7328

btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);

fs/btrfs/inode.c

7442

struct extent_buffer *leaf;

fs/btrfs/inode.c

7466

leaf = path->nodes[0];

fs/btrfs/inode.c

7467

btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);

fs/btrfs/inode.c

7482

fi = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_file_extent_item);

fs/btrfs/inode.c

7483

found_type = btrfs_file_extent_type(leaf, fi);

fs/btrfs/inode.c

9046

struct extent_buffer *leaf;

fs/btrfs/inode.c

9104

leaf = path->nodes[0];

fs/btrfs/inode.c

9105

ei = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/inode.c

9107

btrfs_set_file_extent_generation(leaf, ei, trans->transid);

fs/btrfs/inode.c

9108

btrfs_set_file_extent_type(leaf, ei,

fs/btrfs/inode.c

9110

btrfs_set_file_extent_encryption(leaf, ei, 0);

fs/btrfs/inode.c

9111

btrfs_set_file_extent_compression(leaf, ei, 0);

fs/btrfs/inode.c

9112

btrfs_set_file_extent_other_encoding(leaf, ei, 0);

fs/btrfs/inode.c

9113

btrfs_set_file_extent_ram_bytes(leaf, ei, name_len);

fs/btrfs/inode.c

9116

write_extent_buffer(leaf, symname, ptr, name_len);

fs/btrfs/inode.c

9466

struct extent_buffer *leaf;

fs/btrfs/inode.c

9489

leaf = path->nodes[0];

fs/btrfs/inode.c

9490

item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_file_extent_item);

fs/btrfs/inode.c

9492

ram_bytes = btrfs_file_extent_ram_bytes(leaf, item);

fs/btrfs/inode.c

9498

btrfs_file_extent_compression(leaf, item));

fs/btrfs/inode.c

9505

inline_size = btrfs_file_extent_inline_item_len(leaf,

fs/btrfs/inode.c

9524

read_extent_buffer(leaf, tmp, ptr, count);

fs/btrfs/ioctl.c

1403

struct extent_buffer *leaf;

fs/btrfs/ioctl.c

1413

leaf = path->nodes[0];

fs/btrfs/ioctl.c

1415

nritems = btrfs_header_nritems(leaf);

fs/btrfs/ioctl.c

1417

if (btrfs_header_generation(leaf) > sk->max_transid) {

fs/btrfs/ioctl.c

1421

found_transid = btrfs_header_generation(leaf);

fs/btrfs/ioctl.c

1424

item_off = btrfs_item_ptr_offset(leaf, i);

fs/btrfs/ioctl.c

1425

item_len = btrfs_item_size(leaf, i);

fs/btrfs/ioctl.c

1427

btrfs_item_key_to_cpu(leaf, key, i);

fs/btrfs/ioctl.c

1471

if (read_extent_buffer_to_user_nofault(leaf, up,

fs/btrfs/ioctl.c

1742

struct extent_buffer *leaf;

fs/btrfs/ioctl.c

1778

leaf = path->nodes[0];

fs/btrfs/ioctl.c

1781

iref = btrfs_item_ptr(leaf, slot, struct btrfs_inode_ref);

fs/btrfs/ioctl.c

1782

len = btrfs_inode_ref_name_len(leaf, iref);

fs/btrfs/ioctl.c

1791

read_extent_buffer(leaf, ptr,

fs/btrfs/ioctl.c

1842

leaf = path->nodes[0];

fs/btrfs/ioctl.c

1844

btrfs_item_key_to_cpu(leaf, &key, slot);

fs/btrfs/ioctl.c

1846

item_off = btrfs_item_ptr_offset(leaf, slot);

fs/btrfs/ioctl.c

1847

item_len = btrfs_item_size(leaf, slot);

fs/btrfs/ioctl.c

1849

rref = btrfs_item_ptr(leaf, slot, struct btrfs_root_ref);

fs/btrfs/ioctl.c

1850

if (args->dirid != btrfs_root_ref_dirid(leaf, rref))

fs/btrfs/ioctl.c

1856

read_extent_buffer(leaf, args->name, item_off, item_len);

fs/btrfs/ioctl.c

1957

struct extent_buffer *leaf;

fs/btrfs/ioctl.c

2029

leaf = path->nodes[0];

fs/btrfs/ioctl.c

2031

btrfs_item_key_to_cpu(leaf, &key, slot);

fs/btrfs/ioctl.c

2036

rref = btrfs_item_ptr(leaf, slot, struct btrfs_root_ref);

fs/btrfs/ioctl.c

2037

subvol_info->dirid = btrfs_root_ref_dirid(leaf, rref);

fs/btrfs/ioctl.c

2039

item_off = btrfs_item_ptr_offset(leaf, slot)

fs/btrfs/ioctl.c

2041

item_len = btrfs_item_size(leaf, slot)

fs/btrfs/ioctl.c

2043

read_extent_buffer(leaf, subvol_info->name,

fs/btrfs/ioctl.c

2075

struct extent_buffer *leaf;

fs/btrfs/ioctl.c

2112

leaf = path->nodes[0];

fs/btrfs/ioctl.c

2115

btrfs_item_key_to_cpu(leaf, &key, slot);

fs/btrfs/ioctl.c

2126

rref = btrfs_item_ptr(leaf, slot, struct btrfs_root_ref);

fs/btrfs/ioctl.c

2129

btrfs_root_ref_dirid(leaf, rref);

fs/btrfs/ioctl.c

508

struct extent_buffer *leaf;

fs/btrfs/ioctl.c

574

leaf = btrfs_alloc_tree_block(trans, root, 0, objectid, NULL, 0, 0, 0,

fs/btrfs/ioctl.c

576

if (IS_ERR(leaf)) {

fs/btrfs/ioctl.c

577

ret = PTR_ERR(leaf);

fs/btrfs/ioctl.c

581

btrfs_mark_buffer_dirty(trans, leaf);

fs/btrfs/ioctl.c

595

btrfs_set_root_bytenr(root_item, leaf->start);

fs/btrfs/ioctl.c

599

btrfs_set_root_used(root_item, leaf->len);

fs/btrfs/ioctl.c

611

btrfs_tree_unlock(leaf);

fs/btrfs/ioctl.c

630

btrfs_tree_lock(leaf);

fs/btrfs/ioctl.c

631

btrfs_clear_buffer_dirty(trans, leaf);

fs/btrfs/ioctl.c

632

btrfs_tree_unlock(leaf);

fs/btrfs/ioctl.c

633

ret2 = btrfs_free_tree_block(trans, objectid, leaf, 0, 1);

fs/btrfs/ioctl.c

636

free_extent_buffer(leaf);

fs/btrfs/ioctl.c

640

free_extent_buffer(leaf);

fs/btrfs/ioctl.c

641

leaf = NULL;

fs/btrfs/props.c

164

struct extent_buffer *leaf;

fs/btrfs/props.c

170

leaf = path->nodes[0];

fs/btrfs/props.c

172

if (slot >= btrfs_header_nritems(leaf)) {

fs/btrfs/props.c

181

btrfs_item_key_to_cpu(leaf, &key, slot);

fs/btrfs/props.c

191

di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item);

fs/btrfs/props.c

193

total_len = btrfs_item_size(leaf, slot);

fs/btrfs/props.c

196

u32 name_len = btrfs_dir_name_len(leaf, di);

fs/btrfs/props.c

197

u32 data_len = btrfs_dir_data_len(leaf, di);

fs/btrfs/props.c

206

memcmp_extent_buffer(leaf, XATTR_BTRFS_PREFIX,

fs/btrfs/props.c

220

read_extent_buffer(leaf, name_buf, name_ptr, name_len);

fs/btrfs/props.c

236

read_extent_buffer(leaf, value_buf, data_ptr, data_len);

fs/btrfs/qgroup.c

1006

struct extent_buffer *leaf;

fs/btrfs/qgroup.c

1101

leaf = path->nodes[0];

fs/btrfs/qgroup.c

1102

ptr = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/qgroup.c

1104

btrfs_set_qgroup_status_generation(leaf, ptr, trans->transid);

fs/btrfs/qgroup.c

1105

btrfs_set_qgroup_status_version(leaf, ptr, BTRFS_QGROUP_STATUS_VERSION);

fs/btrfs/qgroup.c

1110

btrfs_set_qgroup_status_enable_gen(leaf, ptr, trans->transid);

fs/btrfs/qgroup.c

1114

btrfs_set_qgroup_status_flags(leaf, ptr, fs_info->qgroup_flags &

fs/btrfs/qgroup.c

1116

btrfs_set_qgroup_status_rescan(leaf, ptr, 0);

fs/btrfs/qgroup.c

1133

leaf = path->nodes[0];

fs/btrfs/qgroup.c

1134

btrfs_item_key_to_cpu(leaf, &found_key, slot);

fs/btrfs/qgroup.c

409

struct extent_buffer *leaf, int slot,

fs/btrfs/qgroup.c

413

ASSERT(btrfs_item_size(leaf, slot) >= sizeof(*ptr));

fs/btrfs/qgroup.c

414

fs_info->qgroup_enable_gen = btrfs_qgroup_status_enable_gen(leaf, ptr);

fs/btrfs/qgroup.c

745

struct extent_buffer *leaf;

fs/btrfs/qgroup.c

770

leaf = path->nodes[0];

fs/btrfs/qgroup.c

771

qgroup_info = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/qgroup.c

773

btrfs_set_qgroup_info_generation(leaf, qgroup_info, trans->transid);

fs/btrfs/qgroup.c

774

btrfs_set_qgroup_info_rfer(leaf, qgroup_info, 0);

fs/btrfs/qgroup.c

775

btrfs_set_qgroup_info_rfer_cmpr(leaf, qgroup_info, 0);

fs/btrfs/qgroup.c

776

btrfs_set_qgroup_info_excl(leaf, qgroup_info, 0);

fs/btrfs/qgroup.c

777

btrfs_set_qgroup_info_excl_cmpr(leaf, qgroup_info, 0);

fs/btrfs/qgroup.c

787

leaf = path->nodes[0];

fs/btrfs/qgroup.c

788

qgroup_limit = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/qgroup.c

790

btrfs_set_qgroup_limit_flags(leaf, qgroup_limit, 0);

fs/btrfs/qgroup.c

791

btrfs_set_qgroup_limit_max_rfer(leaf, qgroup_limit, 0);

fs/btrfs/qgroup.c

792

btrfs_set_qgroup_limit_max_excl(leaf, qgroup_limit, 0);

fs/btrfs/qgroup.c

793

btrfs_set_qgroup_limit_rsv_rfer(leaf, qgroup_limit, 0);

fs/btrfs/qgroup.c

794

btrfs_set_qgroup_limit_rsv_excl(leaf, qgroup_limit, 0);

fs/btrfs/qgroup.c

963

struct extent_buffer *leaf = NULL;

fs/btrfs/qgroup.c

979

leaf = path->nodes[0];

fs/btrfs/qgroup.c

980

nr = btrfs_header_nritems(leaf);

fs/btrfs/raid-stripe-tree.c

107

leaf = path->nodes[0];

fs/btrfs/raid-stripe-tree.c

109

btrfs_item_key_to_cpu(leaf, &key, slot);

fs/btrfs/raid-stripe-tree.c

137

leaf = path->nodes[0];

fs/btrfs/raid-stripe-tree.c

139

btrfs_item_key_to_cpu(leaf, &key, slot);

fs/btrfs/raid-stripe-tree.c

182

item_size = btrfs_item_size(leaf, path->slots[0]);

fs/btrfs/raid-stripe-tree.c

183

extent = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/raid-stripe-tree.c

190

phys = btrfs_raid_stride_physical(leaf, stride);

fs/btrfs/raid-stripe-tree.c

192

btrfs_set_raid_stride_physical(leaf, stride, phys);

fs/btrfs/raid-stripe-tree.c

197

btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);

fs/btrfs/raid-stripe-tree.c

23

struct extent_buffer *leaf;

fs/btrfs/raid-stripe-tree.c

268

struct extent_buffer *leaf;

fs/btrfs/raid-stripe-tree.c

281

leaf = path->nodes[0];

fs/btrfs/raid-stripe-tree.c

284

write_extent_buffer(leaf, stripe_extent, btrfs_item_ptr_offset(leaf, slot),

fs/btrfs/raid-stripe-tree.c

36

leaf = path->nodes[0];

fs/btrfs/raid-stripe-tree.c

372

struct extent_buffer *leaf;

fs/btrfs/raid-stripe-tree.c

38

item_size = btrfs_item_size(leaf, slot);

fs/btrfs/raid-stripe-tree.c

404

leaf = path->nodes[0];

fs/btrfs/raid-stripe-tree.c

407

btrfs_item_key_to_cpu(leaf, &found_key, slot);

fs/btrfs/raid-stripe-tree.c

435

num_stripes = btrfs_num_raid_stripes(btrfs_item_size(leaf, slot));

fs/btrfs/raid-stripe-tree.c

436

stripe_extent = btrfs_item_ptr(leaf, slot, struct btrfs_stripe_extent);

fs/btrfs/raid-stripe-tree.c

44

extent = btrfs_item_ptr(leaf, slot, struct btrfs_stripe_extent);

fs/btrfs/raid-stripe-tree.c

440

u64 devid = btrfs_raid_stride_devid(leaf, stride);

fs/btrfs/raid-stripe-tree.c

441

u64 physical = btrfs_raid_stride_physical(leaf, stride);

fs/btrfs/raid-stripe-tree.c

50

phys = btrfs_raid_stride_physical(leaf, stride) + frontpad;

fs/btrfs/raid-stripe-tree.c

68

struct extent_buffer *leaf;

fs/btrfs/ref-verify.c

369

struct extent_buffer *leaf,

fs/btrfs/ref-verify.c

376

u64 ref_root = btrfs_extent_data_ref_root(leaf, dref);

fs/btrfs/ref-verify.c

377

u64 owner = btrfs_extent_data_ref_objectid(leaf, dref);

fs/btrfs/ref-verify.c

378

u64 offset = btrfs_extent_data_ref_offset(leaf, dref);

fs/btrfs/ref-verify.c

379

u32 num_refs = btrfs_extent_data_ref_count(leaf, dref);

fs/btrfs/ref-verify.c

422

struct extent_buffer *leaf = path->nodes[0];

fs/btrfs/ref-verify.c

423

u32 item_size = btrfs_item_size(leaf, slot);

fs/btrfs/ref-verify.c

429

ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);

fs/btrfs/ref-verify.c

430

flags = btrfs_extent_flags(leaf, ei);

fs/btrfs/ref-verify.c

437

*tree_block_level = btrfs_tree_block_level(leaf, info);

fs/btrfs/ref-verify.c

449

type = btrfs_extent_inline_ref_type(leaf, iref);

fs/btrfs/ref-verify.c

450

offset = btrfs_extent_inline_ref_offset(leaf, iref);

fs/btrfs/ref-verify.c

462

ret = add_extent_data_ref(fs_info, leaf, dref,

fs/btrfs/ref-verify.c

467

count = btrfs_shared_data_ref_count(leaf, sref);

fs/btrfs/ref-verify.c

495

struct extent_buffer *leaf = path->nodes[0];

fs/btrfs/ref-verify.c

501

int nritems = btrfs_header_nritems(leaf);

fs/btrfs/ref-verify.c

504

btrfs_item_key_to_cpu(leaf, &key, i);

fs/btrfs/ref-verify.c

523

dref = btrfs_item_ptr(leaf, i,

fs/btrfs/ref-verify.c

525

ret = add_extent_data_ref(fs_info, leaf, dref, *bytenr,

fs/btrfs/ref-verify.c

529

sref = btrfs_item_ptr(leaf, i,

fs/btrfs/ref-verify.c

531

count = btrfs_shared_data_ref_count(leaf, sref);

fs/btrfs/reflink.c

390

struct extent_buffer *leaf;

fs/btrfs/reflink.c

454

leaf = path->nodes[0];

fs/btrfs/reflink.c

457

btrfs_item_key_to_cpu(leaf, &key, slot);

fs/btrfs/reflink.c

464

extent = btrfs_item_ptr(leaf, slot,

fs/btrfs/reflink.c

466

extent_gen = btrfs_file_extent_generation(leaf, extent);

fs/btrfs/reflink.c

467

comp = btrfs_file_extent_compression(leaf, extent);

fs/btrfs/reflink.c

468

type = btrfs_file_extent_type(leaf, extent);

fs/btrfs/reflink.c

471

disko = btrfs_file_extent_disk_bytenr(leaf, extent);

fs/btrfs/reflink.c

472

diskl = btrfs_file_extent_disk_num_bytes(leaf, extent);

fs/btrfs/reflink.c

473

datao = btrfs_file_extent_offset(leaf, extent);

fs/btrfs/reflink.c

474

datal = btrfs_file_extent_num_bytes(leaf, extent);

fs/btrfs/reflink.c

477

datal = btrfs_file_extent_ram_bytes(leaf, extent);

fs/btrfs/reflink.c

499

size = btrfs_item_size(leaf, slot);

fs/btrfs/reflink.c

500

read_extent_buffer(leaf, buf, btrfs_item_ptr_offset(leaf, slot),

fs/btrfs/relocation.c

1514

struct extent_buffer *leaf;

fs/btrfs/relocation.c

1644

leaf = btrfs_lock_root_node(root);

fs/btrfs/relocation.c

1645

ret = btrfs_cow_block(trans, root, leaf, NULL, 0, &leaf,

fs/btrfs/relocation.c

1647

btrfs_tree_unlock(leaf);

fs/btrfs/relocation.c

1648

free_extent_buffer(leaf);

fs/btrfs/relocation.c

3246

static int delete_v1_space_cache(struct extent_buffer *leaf,

fs/btrfs/relocation.c

3256

if (btrfs_header_owner(leaf) != BTRFS_ROOT_TREE_OBJECTID)

fs/btrfs/relocation.c

3259

for (i = 0; i < btrfs_header_nritems(leaf); i++) {

fs/btrfs/relocation.c

3262

btrfs_item_key_to_cpu(leaf, &key, i);

fs/btrfs/relocation.c

3265

ei = btrfs_item_ptr(leaf, i, struct btrfs_file_extent_item);

fs/btrfs/relocation.c

3266

type = btrfs_file_extent_type(leaf, ei);

fs/btrfs/relocation.c

3270

btrfs_file_extent_disk_bytenr(leaf, ei) == data_bytenr) {

fs/btrfs/relocation.c

3340

struct extent_buffer *leaf;

fs/btrfs/relocation.c

3365

leaf = path->nodes[0];

fs/btrfs/relocation.c

3366

if (path->slots[0] >= btrfs_header_nritems(leaf)) {

fs/btrfs/relocation.c

3370

leaf = path->nodes[0];

fs/btrfs/relocation.c

3373

btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);

fs/btrfs/relocation.c

3661

struct extent_buffer *leaf;

fs/btrfs/relocation.c

3672

leaf = path->nodes[0];

fs/btrfs/relocation.c

3673

item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_inode_item);

fs/btrfs/relocation.c

3674

memzero_extent_buffer(leaf, (unsigned long)item, sizeof(*item));

fs/btrfs/relocation.c

3675

btrfs_set_inode_generation(leaf, item, 1);

fs/btrfs/relocation.c

3676

btrfs_set_inode_size(leaf, item, 0);

fs/btrfs/relocation.c

3677

btrfs_set_inode_mode(leaf, item, S_IFREG | 0600);

fs/btrfs/relocation.c

3678

btrfs_set_inode_flags(leaf, item, BTRFS_INODE_NOCOMPRESS |

fs/btrfs/relocation.c

4090

struct extent_buffer *leaf;

fs/btrfs/relocation.c

4102

leaf = path->nodes[0];

fs/btrfs/relocation.c

4104

write_extent_buffer(leaf, &remap, btrfs_item_ptr_offset(leaf, path->slots[0]),

fs/btrfs/relocation.c

4119

struct extent_buffer *leaf;

fs/btrfs/relocation.c

4131

leaf = path->nodes[0];

fs/btrfs/relocation.c

4133

write_extent_buffer(leaf, &remap, btrfs_item_ptr_offset(leaf, path->slots[0]),

fs/btrfs/relocation.c

4147

struct extent_buffer *leaf;

fs/btrfs/relocation.c

4226

leaf = path->nodes[0];

fs/btrfs/relocation.c

4227

remap_ptr = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_remap_item);

fs/btrfs/relocation.c

4228

btrfs_set_remap_address(leaf, remap_ptr, dest_addr);

fs/btrfs/relocation.c

4229

btrfs_mark_buffer_dirty(trans, leaf);

fs/btrfs/relocation.c

4260

leaf = path->nodes[0];

fs/btrfs/relocation.c

4274

write_extent_buffer(leaf, &remap,

fs/btrfs/relocation.c

4275

btrfs_item_ptr_offset(leaf, path->slots[0]),

fs/btrfs/relocation.c

4343

struct extent_buffer *leaf;

fs/btrfs/relocation.c

4357

leaf = path->nodes[0];

fs/btrfs/relocation.c

4359

if (path->slots[0] >= btrfs_header_nritems(leaf)) {

fs/btrfs/relocation.c

4371

leaf = path->nodes[0];

fs/btrfs/relocation.c

4374

btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);

fs/btrfs/relocation.c

4379

if (path->slots[0] >= btrfs_header_nritems(leaf)) {

fs/btrfs/relocation.c

4391

leaf = path->nodes[0];

fs/btrfs/relocation.c

4394

btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);

fs/btrfs/relocation.c

4397

remap = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_remap_item);

fs/btrfs/relocation.c

4398

old_addr = btrfs_remap_address(leaf, remap);

fs/btrfs/relocation.c

4420

struct extent_buffer *leaf;

fs/btrfs/relocation.c

4472

leaf = path->nodes[0];

fs/btrfs/relocation.c

4474

btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);

fs/btrfs/relocation.c

4498

offset = btrfs_item_ptr_offset(leaf, path->slots[0]);

fs/btrfs/relocation.c

4499

data_size = btrfs_item_size(leaf, path->slots[0]);

fs/btrfs/relocation.c

4509

read_extent_buffer(leaf, bitmap, offset, data_size);

fs/btrfs/relocation.c

4524

if (path->slots[0] >= btrfs_header_nritems(leaf)) {

fs/btrfs/relocation.c

4531

leaf = path->nodes[0];

fs/btrfs/relocation.c

4600

struct extent_buffer *leaf;

fs/btrfs/relocation.c

4610

leaf = path->nodes[0];

fs/btrfs/relocation.c

4612

if (path->slots[0] >= btrfs_header_nritems(leaf)) {

fs/btrfs/relocation.c

4621

leaf = path->nodes[0];

fs/btrfs/relocation.c

4624

btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);

fs/btrfs/relocation.c

4653

struct extent_buffer *leaf;

fs/btrfs/relocation.c

4673

leaf = path->nodes[0];

fs/btrfs/relocation.c

4675

chunk = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_chunk);

fs/btrfs/relocation.c

4676

btrfs_set_chunk_num_stripes(leaf, chunk, 0);

fs/btrfs/relocation.c

4677

btrfs_set_chunk_sub_stripes(leaf, chunk, 0);

fs/btrfs/relocation.c

4681

btrfs_mark_buffer_dirty(trans, leaf);

fs/btrfs/relocation.c

4890

struct extent_buffer *leaf;

fs/btrfs/relocation.c

4917

leaf = path->nodes[0];

fs/btrfs/relocation.c

4919

chunk = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_chunk);

fs/btrfs/relocation.c

4920

btrfs_set_chunk_type(leaf, chunk, type);

fs/btrfs/relocation.c

4921

btrfs_mark_buffer_dirty(trans, leaf);

fs/btrfs/relocation.c

5119

struct extent_buffer *leaf;

fs/btrfs/relocation.c

5135

leaf = path->nodes[0];

fs/btrfs/relocation.c

5141

btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);

fs/btrfs/relocation.c

5159

remap = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_remap_item);

fs/btrfs/relocation.c

5160

*logical += btrfs_remap_address(leaf, remap) - found_key.objectid;

fs/btrfs/relocation.c

5468

struct extent_buffer *leaf;

fs/btrfs/relocation.c

5494

leaf = path->nodes[0];

fs/btrfs/relocation.c

5495

btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);

fs/btrfs/relocation.c

5917

struct extent_buffer *leaf = path->nodes[0];

fs/btrfs/relocation.c

5926

btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);

fs/btrfs/relocation.c

5939

remap_ptr = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_remap_item);

fs/btrfs/relocation.c

5940

new_addr = btrfs_remap_address(leaf, remap_ptr);

fs/btrfs/relocation.c

6034

struct extent_buffer *leaf;

fs/btrfs/relocation.c

6063

leaf = path->nodes[0];

fs/btrfs/relocation.c

6071

btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);

fs/btrfs/relocation.c

819

struct extent_buffer *leaf;

fs/btrfs/relocation.c

834

leaf = path->nodes[0];

fs/btrfs/relocation.c

835

fi = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/relocation.c

838

BUG_ON(btrfs_file_extent_offset(leaf, fi) ||

fs/btrfs/relocation.c

839

btrfs_file_extent_compression(leaf, fi) ||

fs/btrfs/relocation.c

840

btrfs_file_extent_encryption(leaf, fi) ||

fs/btrfs/relocation.c

841

btrfs_file_extent_other_encoding(leaf, fi));

fs/btrfs/relocation.c

843

if (num_bytes != btrfs_file_extent_disk_num_bytes(leaf, fi))

fs/btrfs/relocation.c

846

*new_bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);

fs/btrfs/relocation.c

858

struct extent_buffer *leaf)

fs/btrfs/relocation.c

879

parent = leaf->start;

fs/btrfs/relocation.c

883

nritems = btrfs_header_nritems(leaf);

fs/btrfs/relocation.c

888

btrfs_item_key_to_cpu(leaf, &key, i);

fs/btrfs/relocation.c

891

fi = btrfs_item_ptr(leaf, i, struct btrfs_file_extent_item);

fs/btrfs/relocation.c

892

if (btrfs_file_extent_type(leaf, fi) ==

fs/btrfs/relocation.c

895

bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);

fs/btrfs/relocation.c

896

num_bytes = btrfs_file_extent_disk_num_bytes(leaf, fi);

fs/btrfs/relocation.c

919

btrfs_file_extent_num_bytes(leaf, fi);

fs/btrfs/relocation.c

951

btrfs_set_file_extent_disk_bytenr(leaf, fi, new_bytenr);

fs/btrfs/relocation.c

953

key.offset -= btrfs_file_extent_offset(leaf, fi);

fs/btrfs/relocation.c

959

ref.ref_root = btrfs_header_owner(leaf);

fs/btrfs/relocation.c

973

ref.ref_root = btrfs_header_owner(leaf);

fs/btrfs/root-tree.c

216

struct extent_buffer *leaf;

fs/btrfs/root-tree.c

237

leaf = path->nodes[0];

fs/btrfs/root-tree.c

238

if (path->slots[0] >= btrfs_header_nritems(leaf)) {

fs/btrfs/root-tree.c

244

leaf = path->nodes[0];

fs/btrfs/root-tree.c

247

btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);

fs/btrfs/root-tree.c

336

struct extent_buffer *leaf;

fs/btrfs/root-tree.c

353

leaf = path->nodes[0];

fs/btrfs/root-tree.c

354

ref = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/root-tree.c

357

if ((btrfs_root_ref_dirid(leaf, ref) != dirid) ||

fs/btrfs/root-tree.c

358

(btrfs_root_ref_name_len(leaf, ref) != name->len) ||

fs/btrfs/root-tree.c

359

memcmp_extent_buffer(leaf, name->name, ptr, name->len))

fs/btrfs/root-tree.c

362

*sequence = btrfs_root_ref_sequence(leaf, ref);

fs/btrfs/root-tree.c

406

struct extent_buffer *leaf;

fs/btrfs/root-tree.c

424

leaf = path->nodes[0];

fs/btrfs/root-tree.c

425

ref = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_root_ref);

fs/btrfs/root-tree.c

426

btrfs_set_root_ref_dirid(leaf, ref, dirid);

fs/btrfs/root-tree.c

427

btrfs_set_root_ref_sequence(leaf, ref, sequence);

fs/btrfs/root-tree.c

428

btrfs_set_root_ref_name_len(leaf, ref, name->len);

fs/btrfs/root-tree.c

430

write_extent_buffer(leaf, name->name, ptr, name->len);

fs/btrfs/send.c

1489

const struct extent_buffer *leaf, void *ctx)

fs/btrfs/send.c

1491

const u64 refs = btrfs_extent_refs(leaf, ei);

fs/btrfs/send.c

1496

const u64 flags = btrfs_extent_flags(leaf, ei);

fs/btrfs/send.c

2461

struct extent_buffer *leaf;

fs/btrfs/send.c

2484

leaf = path->nodes[0];

fs/btrfs/send.c

2485

btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);

fs/btrfs/send.c

2490

ref = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_root_ref);

fs/btrfs/send.c

2491

namelen = btrfs_root_ref_name_len(leaf, ref);

fs/btrfs/send.c

2492

read_extent_buffer(leaf, name, (unsigned long)(ref + 1), namelen);

fs/btrfs/send.c

3850

struct extent_buffer *leaf = path->nodes[0];

fs/btrfs/send.c

3861

item_size = btrfs_item_size(leaf, slot);

fs/btrfs/send.c

3870

ptr = btrfs_item_ptr_offset(leaf, slot);

fs/btrfs/send.c

3873

parent = btrfs_inode_extref_parent(leaf,

fs/btrfs/send.c

3876

cur_offset += btrfs_inode_extref_name_len(leaf,

fs/btrfs/send.c

5482

struct extent_buffer *leaf = path->nodes[0];

fs/btrfs/send.c

5497

btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);

fs/btrfs/send.c

5498

ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_file_extent_item);

fs/btrfs/send.c

5499

ram_bytes = btrfs_file_extent_ram_bytes(leaf, ei);

fs/btrfs/send.c

5500

inline_size = btrfs_file_extent_inline_item_len(leaf, path->slots[0]);

fs/btrfs/send.c

5509

btrfs_file_extent_compression(leaf, ei));

fs/btrfs/send.c

5517

read_extent_buffer(leaf, sctx->send_buf + sctx->send_size,

fs/btrfs/send.c

5534

struct extent_buffer *leaf = path->nodes[0];

fs/btrfs/send.c

5557

btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);

fs/btrfs/send.c

5558

ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_file_extent_item);

fs/btrfs/send.c

5559

disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, ei);

fs/btrfs/send.c

5560

disk_num_bytes = btrfs_file_extent_disk_num_bytes(leaf, ei);

fs/btrfs/send.c

5565

min(key.offset + btrfs_file_extent_num_bytes(leaf, ei) - offset,

fs/btrfs/send.c

5568

btrfs_file_extent_ram_bytes(leaf, ei));

fs/btrfs/send.c

5570

offset - key.offset + btrfs_file_extent_offset(leaf, ei));

fs/btrfs/send.c

5572

btrfs_file_extent_compression(leaf, ei));

fs/btrfs/send.c

5632

struct extent_buffer *leaf = path->nodes[0];

fs/btrfs/send.c

5640

ei = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/send.c

5643

btrfs_file_extent_compression(leaf, ei) != BTRFS_COMPRESS_NONE) {

fs/btrfs/send.c

5644

bool is_inline = (btrfs_file_extent_type(leaf, ei) ==

fs/btrfs/send.c

5655

btrfs_file_extent_inline_item_len(leaf,

fs/btrfs/send.c

5660

btrfs_file_extent_disk_num_bytes(leaf, ei) <= len) {

fs/btrfs/send.c

5754

struct extent_buffer *leaf;

fs/btrfs/send.c

5773

leaf = path->nodes[0];

fs/btrfs/send.c

5774

buf_len = btrfs_dir_data_len(leaf, di);

fs/btrfs/send.c

5780

data_ptr = (unsigned long)(di + 1) + btrfs_dir_name_len(leaf, di);

fs/btrfs/send.c

5781

read_extent_buffer(leaf, buf, data_ptr, buf_len);

fs/btrfs/send.c

5867

struct extent_buffer *leaf = path->nodes[0];

fs/btrfs/send.c

5876

if (slot >= btrfs_header_nritems(leaf)) {

fs/btrfs/send.c

5885

btrfs_item_key_to_cpu(leaf, &key, slot);

fs/btrfs/send.c

5895

ei = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);

fs/btrfs/send.c

5896

type = btrfs_file_extent_type(leaf, ei);

fs/btrfs/send.c

5898

ext_len = btrfs_file_extent_ram_bytes(leaf, ei);

fs/btrfs/send.c

5901

ext_len = btrfs_file_extent_num_bytes(leaf, ei);

fs/btrfs/send.c

5937

clone_data_offset = btrfs_file_extent_offset(leaf, ei);

fs/btrfs/send.c

5938

if (btrfs_file_extent_disk_bytenr(leaf, ei) == disk_byte) {

fs/btrfs/send.c

5953

if (btrfs_file_extent_disk_bytenr(leaf, ei) == disk_byte &&

fs/btrfs/send.c

6359

struct extent_buffer *leaf = path->nodes[0];

fs/btrfs/send.c

6364

if (slot >= btrfs_header_nritems(leaf)) {

fs/btrfs/send.c

6373

btrfs_item_key_to_cpu(leaf, &key, slot);

fs/btrfs/send.c

6382

fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);

fs/btrfs/send.c

6386

if (btrfs_file_extent_type(leaf, fi) == BTRFS_FILE_EXTENT_INLINE)

fs/btrfs/send.c

6388

if (btrfs_file_extent_disk_bytenr(leaf, fi) == 0) {

fs/btrfs/send.c

7093

struct extent_buffer *leaf;

fs/btrfs/send.c

7107

leaf = path->nodes[0];

fs/btrfs/send.c

7108

item_size = btrfs_item_size(leaf, path->slots[0]);

fs/btrfs/send.c

7109

ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);

fs/btrfs/send.c

7115

dirid = btrfs_inode_extref_parent(leaf, extref);

fs/btrfs/send.c

7116

ref_name_len = btrfs_inode_extref_name_len(leaf, extref);

fs/btrfs/tests/inode-tests.c

22

struct extent_buffer *leaf = root->node;

fs/btrfs/tests/inode-tests.c

30

path.nodes[0] = leaf;

fs/btrfs/tests/inode-tests.c

42

fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);

fs/btrfs/tests/inode-tests.c

43

btrfs_set_file_extent_generation(leaf, fi, 1);

fs/btrfs/tests/inode-tests.c

44

btrfs_set_file_extent_type(leaf, fi, type);

fs/btrfs/tests/inode-tests.c

45

btrfs_set_file_extent_disk_bytenr(leaf, fi, disk_bytenr);

fs/btrfs/tests/inode-tests.c

46

btrfs_set_file_extent_disk_num_bytes(leaf, fi, disk_len);

fs/btrfs/tests/inode-tests.c

47

btrfs_set_file_extent_offset(leaf, fi, offset);

fs/btrfs/tests/inode-tests.c

48

btrfs_set_file_extent_num_bytes(leaf, fi, len);

fs/btrfs/tests/inode-tests.c

49

btrfs_set_file_extent_ram_bytes(leaf, fi, ram_bytes);

fs/btrfs/tests/inode-tests.c

50

btrfs_set_file_extent_compression(leaf, fi, compression);

fs/btrfs/tests/inode-tests.c

51

btrfs_set_file_extent_encryption(leaf, fi, 0);

fs/btrfs/tests/inode-tests.c

52

btrfs_set_file_extent_other_encoding(leaf, fi, 0);

fs/btrfs/tests/inode-tests.c

58

struct extent_buffer *leaf = root->node;

fs/btrfs/tests/inode-tests.c

64

path.nodes[0] = leaf;

fs/btrfs/tests/qgroup-tests.c

24

struct extent_buffer *leaf;

fs/btrfs/tests/qgroup-tests.c

47

leaf = path->nodes[0];

fs/btrfs/tests/qgroup-tests.c

48

item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);

fs/btrfs/tests/qgroup-tests.c

49

btrfs_set_extent_refs(leaf, item, 1);

fs/btrfs/tests/qgroup-tests.c

50

btrfs_set_extent_generation(leaf, item, 1);

fs/btrfs/tests/qgroup-tests.c

51

btrfs_set_extent_flags(leaf, item, BTRFS_EXTENT_FLAG_TREE_BLOCK);

fs/btrfs/tests/qgroup-tests.c

53

btrfs_set_tree_block_level(leaf, block_info, 0);

fs/btrfs/tests/qgroup-tests.c

56

btrfs_set_extent_inline_ref_type(leaf, iref,

fs/btrfs/tests/qgroup-tests.c

58

btrfs_set_extent_inline_ref_offset(leaf, iref, parent);

fs/btrfs/tests/qgroup-tests.c

60

btrfs_set_extent_inline_ref_type(leaf, iref, BTRFS_TREE_BLOCK_REF_KEY);

fs/btrfs/tests/qgroup-tests.c

61

btrfs_set_extent_inline_ref_offset(leaf, iref, root_objectid);

fs/btrfs/tree-checker.c

1001

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

1009

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

1015

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

1024

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

1037

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

1045

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

1052

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

1060

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

1076

static int check_leaf_chunk_item(struct extent_buffer *leaf,

fs/btrfs/tree-checker.c

1080

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/tree-checker.c

1083

if (unlikely(btrfs_item_size(leaf, slot) < offsetof(struct btrfs_chunk, stripe))) {

fs/btrfs/tree-checker.c

1084

chunk_err(fs_info, leaf, chunk, key->offset,

fs/btrfs/tree-checker.c

1086

btrfs_item_size(leaf, slot),

fs/btrfs/tree-checker.c

109

#define CHECK_FE_ALIGNED(leaf, slot, fi, name, alignment) \

fs/btrfs/tree-checker.c

1092

num_stripes = btrfs_chunk_num_stripes(leaf, chunk);

fs/btrfs/tree-checker.c

1098

btrfs_item_size(leaf, slot))) {

fs/btrfs/tree-checker.c

1099

chunk_err(fs_info, leaf, chunk, key->offset,

fs/btrfs/tree-checker.c

1101

btrfs_item_size(leaf, slot),

fs/btrfs/tree-checker.c

1106

return btrfs_check_chunk_valid(fs_info, leaf, chunk, key->offset,

fs/btrfs/tree-checker.c

111

if (unlikely(!IS_ALIGNED(btrfs_file_extent_##name((leaf), (fi)), \

fs/btrfs/tree-checker.c

113

file_extent_err((leaf), (slot), \

fs/btrfs/tree-checker.c

1134

static int check_dev_item(struct extent_buffer *leaf,

fs/btrfs/tree-checker.c

1138

const u32 item_size = btrfs_item_size(leaf, slot);

fs/btrfs/tree-checker.c

1141

dev_item_err(leaf, slot,

fs/btrfs/tree-checker.c

1148

dev_item_err(leaf, slot, "invalid item size: has %u expect %zu",

fs/btrfs/tree-checker.c

115

(#name), btrfs_file_extent_##name((leaf), (fi)), \

fs/btrfs/tree-checker.c

1153

ditem = btrfs_item_ptr(leaf, slot, struct btrfs_dev_item);

fs/btrfs/tree-checker.c

1154

if (unlikely(btrfs_device_id(leaf, ditem) != key->offset)) {

fs/btrfs/tree-checker.c

1155

dev_item_err(leaf, slot,

fs/btrfs/tree-checker.c

1157

key->offset, btrfs_device_id(leaf, ditem));

fs/btrfs/tree-checker.c

1166

if (unlikely(btrfs_device_bytes_used(leaf, ditem) >

fs/btrfs/tree-checker.c

1167

btrfs_device_total_bytes(leaf, ditem))) {

fs/btrfs/tree-checker.c

1168

dev_item_err(leaf, slot,

fs/btrfs/tree-checker.c

117

(!IS_ALIGNED(btrfs_file_extent_##name((leaf), (fi)), (alignment))); \

fs/btrfs/tree-checker.c

1170

btrfs_device_bytes_used(leaf, ditem),

fs/btrfs/tree-checker.c

1171

btrfs_device_total_bytes(leaf, ditem));

fs/btrfs/tree-checker.c

1181

static int check_inode_item(struct extent_buffer *leaf,

fs/btrfs/tree-checker.c

1184

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/tree-checker.c

1188

const u32 item_size = btrfs_item_size(leaf, slot);

fs/btrfs/tree-checker.c

1194

ret = check_inode_key(leaf, key, slot);

fs/btrfs/tree-checker.c

1199

generic_err(leaf, slot, "invalid item size: has %u expect %zu",

fs/btrfs/tree-checker.c

120

static u64 file_extent_end(struct extent_buffer *leaf,

fs/btrfs/tree-checker.c

1204

iitem = btrfs_item_ptr(leaf, slot, struct btrfs_inode_item);

fs/btrfs/tree-checker.c

1207

if (unlikely(btrfs_inode_generation(leaf, iitem) > super_gen + 1)) {

fs/btrfs/tree-checker.c

1208

inode_item_err(leaf, slot,

fs/btrfs/tree-checker.c

1210

btrfs_inode_generation(leaf, iitem),

fs/btrfs/tree-checker.c

1215

if (unlikely(btrfs_inode_transid(leaf, iitem) > super_gen + 1)) {

fs/btrfs/tree-checker.c

1216

inode_item_err(leaf, slot,

fs/btrfs/tree-checker.c

1218

btrfs_inode_transid(leaf, iitem), super_gen + 1);

fs/btrfs/tree-checker.c

1227

mode = btrfs_inode_mode(leaf, iitem);

fs/btrfs/tree-checker.c

1229

inode_item_err(leaf, slot,

fs/btrfs/tree-checker.c

1242

inode_item_err(leaf, slot,

fs/btrfs/tree-checker.c

1248

if (unlikely(S_ISDIR(mode) && btrfs_inode_nlink(leaf, iitem) > 1)) {

fs/btrfs/tree-checker.c

1249

inode_item_err(leaf, slot,

fs/btrfs/tree-checker.c

1251

btrfs_inode_nlink(leaf, iitem));

fs/btrfs/tree-checker.c

1254

btrfs_inode_split_flags(btrfs_inode_flags(leaf, iitem), &flags, &ro_flags);

fs/btrfs/tree-checker.c

1256

inode_item_err(leaf, slot,

fs/btrfs/tree-checker.c

1262

inode_item_err(leaf, slot,

fs/btrfs/tree-checker.c

127

if (btrfs_file_extent_type(leaf, extent) == BTRFS_FILE_EXTENT_INLINE) {

fs/btrfs/tree-checker.c

1270

static int check_root_item(struct extent_buffer *leaf, struct btrfs_key *key,

fs/btrfs/tree-checker.c

1273

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/tree-checker.c

1279

ret = check_root_key(leaf, key, slot);

fs/btrfs/tree-checker.c

128

len = btrfs_file_extent_ram_bytes(leaf, extent);

fs/btrfs/tree-checker.c

1283

if (unlikely(btrfs_item_size(leaf, slot) != sizeof(ri) &&

fs/btrfs/tree-checker.c

1284

btrfs_item_size(leaf, slot) !=

fs/btrfs/tree-checker.c

1286

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

1288

btrfs_item_size(leaf, slot), sizeof(ri),

fs/btrfs/tree-checker.c

129

end = ALIGN(key->offset + len, leaf->fs_info->sectorsize);

fs/btrfs/tree-checker.c

1298

read_extent_buffer(leaf, &ri, btrfs_item_ptr_offset(leaf, slot),

fs/btrfs/tree-checker.c

1299

btrfs_item_size(leaf, slot));

fs/btrfs/tree-checker.c

1304

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

131

len = btrfs_file_extent_num_bytes(leaf, extent);

fs/btrfs/tree-checker.c

1312

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

1320

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

1329

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

1335

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

1341

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

1358

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

1366

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

1419

static int check_extent_item(struct extent_buffer *leaf,

fs/btrfs/tree-checker.c

1423

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/tree-checker.c

1428

const u32 item_size = btrfs_item_size(leaf, slot);

fs/btrfs/tree-checker.c

1438

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

1444

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

1453

extent_err(leaf, slot,

fs/btrfs/tree-checker.c

1491

extent_err(leaf, slot,

fs/btrfs/tree-checker.c

1497

end = item_size + btrfs_item_ptr_offset(leaf, slot);

fs/btrfs/tree-checker.c

1500

ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);

fs/btrfs/tree-checker.c

1501

flags = btrfs_extent_flags(leaf, ei);

fs/btrfs/tree-checker.c

1502

total_refs = btrfs_extent_refs(leaf, ei);

fs/btrfs/tree-checker.c

1503

generation = btrfs_extent_generation(leaf, ei);

fs/btrfs/tree-checker.c

1506

extent_err(leaf, slot,

fs/btrfs/tree-checker.c

1514

extent_err(leaf, slot,

fs/btrfs/tree-checker.c

1524

extent_err(leaf, slot,

fs/btrfs/tree-checker.c

1531

extent_err(leaf, slot,

fs/btrfs/tree-checker.c

1537

extent_err(leaf, slot,

fs/btrfs/tree-checker.c

1543

extent_err(leaf, slot,

fs/btrfs/tree-checker.c

1555

if (unlikely(btrfs_tree_block_level(leaf, info) >= BTRFS_MAX_LEVEL)) {

fs/btrfs/tree-checker.c

1556

extent_err(leaf, slot,

fs/btrfs/tree-checker.c

1558

btrfs_tree_block_level(leaf, info),

fs/btrfs/tree-checker.c

1578

extent_err(leaf, slot,

fs/btrfs/tree-checker.c

1584

inline_type = btrfs_extent_inline_ref_type(leaf, iref);

fs/btrfs/tree-checker.c

1585

inline_offset = btrfs_extent_inline_ref_offset(leaf, iref);

fs/btrfs/tree-checker.c

1588

extent_err(leaf, slot,

fs/btrfs/tree-checker.c

1603

extent_err(leaf, slot,

fs/btrfs/tree-checker.c

1616

dref_root = btrfs_extent_data_ref_root(leaf, dref);

fs/btrfs/tree-checker.c

1617

dref_objectid = btrfs_extent_data_ref_objectid(leaf, dref);

fs/btrfs/tree-checker.c

1618

dref_offset = btrfs_extent_data_ref_offset(leaf, dref);

fs/btrfs/tree-checker.c

1620

btrfs_extent_data_ref_root(leaf, dref),

fs/btrfs/tree-checker.c

1621

btrfs_extent_data_ref_objectid(leaf, dref),

fs/btrfs/tree-checker.c

1622

btrfs_extent_data_ref_offset(leaf, dref));

fs/btrfs/tree-checker.c

1624

extent_err(leaf, slot,

fs/btrfs/tree-checker.c

1631

extent_err(leaf, slot,

fs/btrfs/tree-checker.c

1638

extent_err(leaf, slot,

fs/btrfs/tree-checker.c

1643

if (unlikely(btrfs_extent_data_ref_count(leaf, dref) == 0)) {

fs/btrfs/tree-checker.c

1644

extent_err(leaf, slot,

fs/btrfs/tree-checker.c

1648

inline_refs += btrfs_extent_data_ref_count(leaf, dref);

fs/btrfs/tree-checker.c

1655

extent_err(leaf, slot,

fs/btrfs/tree-checker.c

1660

if (unlikely(btrfs_shared_data_ref_count(leaf, sref) == 0)) {

fs/btrfs/tree-checker.c

1661

extent_err(leaf, slot,

fs/btrfs/tree-checker.c

1665

inline_refs += btrfs_shared_data_ref_count(leaf, sref);

fs/btrfs/tree-checker.c

1671

extent_err(leaf, slot, "unknown inline ref type: %u",

fs/btrfs/tree-checker.c

1676

extent_err(leaf, slot,

fs/btrfs/tree-checker.c

1685

extent_err(leaf, slot,

fs/btrfs/tree-checker.c

1697

extent_err(leaf, slot,

fs/btrfs/tree-checker.c

1704

extent_err(leaf, slot,

fs/btrfs/tree-checker.c

1720

extent_err(leaf, slot,

fs/btrfs/tree-checker.c

1731

static int check_simple_keyed_refs(struct extent_buffer *leaf,

fs/btrfs/tree-checker.c

1739

sref = btrfs_item_ptr(leaf, slot, struct btrfs_shared_data_ref);

fs/btrfs/tree-checker.c

1740

if (unlikely(btrfs_shared_data_ref_count(leaf, sref) == 0)) {

fs/btrfs/tree-checker.c

1741

extent_err(leaf, slot,

fs/btrfs/tree-checker.c

1749

if (unlikely(btrfs_item_size(leaf, slot) != expect_item_size)) {

fs/btrfs/tree-checker.c

175

static bool check_prev_ino(struct extent_buffer *leaf,

fs/btrfs/tree-checker.c

1750

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

1752

btrfs_item_size(leaf, slot),

fs/btrfs/tree-checker.c

1756

if (unlikely(!IS_ALIGNED(key->objectid, leaf->fs_info->sectorsize))) {

fs/btrfs/tree-checker.c

1757

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

1759

key->objectid, leaf->fs_info->sectorsize);

fs/btrfs/tree-checker.c

1763

!IS_ALIGNED(key->offset, leaf->fs_info->sectorsize))) {

fs/btrfs/tree-checker.c

1764

extent_err(leaf, slot,

fs/btrfs/tree-checker.c

1766

key->offset, leaf->fs_info->sectorsize);

fs/btrfs/tree-checker.c

1772

static int check_extent_data_ref(struct extent_buffer *leaf,

fs/btrfs/tree-checker.c

1776

unsigned long ptr = btrfs_item_ptr_offset(leaf, slot);

fs/btrfs/tree-checker.c

1777

const unsigned long end = ptr + btrfs_item_size(leaf, slot);

fs/btrfs/tree-checker.c

1779

if (unlikely(btrfs_item_size(leaf, slot) % sizeof(*dref) != 0)) {

fs/btrfs/tree-checker.c

1780

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

1782

btrfs_item_size(leaf, slot),

fs/btrfs/tree-checker.c

1786

if (unlikely(!IS_ALIGNED(key->objectid, leaf->fs_info->sectorsize))) {

fs/btrfs/tree-checker.c

1787

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

1789

key->objectid, leaf->fs_info->sectorsize);

fs/btrfs/tree-checker.c

1802

root = btrfs_extent_data_ref_root(leaf, dref);

fs/btrfs/tree-checker.c

1803

objectid = btrfs_extent_data_ref_objectid(leaf, dref);

fs/btrfs/tree-checker.c

1804

offset = btrfs_extent_data_ref_offset(leaf, dref);

fs/btrfs/tree-checker.c

1806

extent_err(leaf, slot,

fs/btrfs/tree-checker.c

1813

extent_err(leaf, slot,

fs/btrfs/tree-checker.c

1818

if (unlikely(!IS_ALIGNED(offset, leaf->fs_info->sectorsize))) {

fs/btrfs/tree-checker.c

1819

extent_err(leaf, slot,

fs/btrfs/tree-checker.c

1821

offset, leaf->fs_info->sectorsize);

fs/btrfs/tree-checker.c

1824

if (unlikely(btrfs_extent_data_ref_count(leaf, dref) == 0)) {

fs/btrfs/tree-checker.c

1825

extent_err(leaf, slot,

fs/btrfs/tree-checker.c

1835

static int check_inode_ref(struct extent_buffer *leaf,

fs/btrfs/tree-checker.c

1843

if (unlikely(!check_prev_ino(leaf, key, slot, prev_key)))

fs/btrfs/tree-checker.c

1846

if (unlikely(btrfs_item_size(leaf, slot) <= sizeof(*iref))) {

fs/btrfs/tree-checker.c

1847

inode_ref_err(leaf, slot,

fs/btrfs/tree-checker.c

1849

btrfs_item_size(leaf, slot),

fs/btrfs/tree-checker.c

1850

sizeof(*iref), BTRFS_LEAF_DATA_SIZE(leaf->fs_info));

fs/btrfs/tree-checker.c

1854

ptr = btrfs_item_ptr_offset(leaf, slot);

fs/btrfs/tree-checker.c

1855

end = ptr + btrfs_item_size(leaf, slot);

fs/btrfs/tree-checker.c

1860

inode_ref_err(leaf, slot,

fs/btrfs/tree-checker.c

1867

namelen = btrfs_inode_ref_name_len(leaf, iref);

fs/btrfs/tree-checker.c

1869

inode_ref_err(leaf, slot,

fs/btrfs/tree-checker.c

1885

static int check_inode_extref(struct extent_buffer *leaf,

fs/btrfs/tree-checker.c

1889

unsigned long ptr = btrfs_item_ptr_offset(leaf, slot);

fs/btrfs/tree-checker.c

1890

unsigned long end = ptr + btrfs_item_size(leaf, slot);

fs/btrfs/tree-checker.c

1892

if (unlikely(!check_prev_ino(leaf, key, slot, prev_key)))

fs/btrfs/tree-checker.c

1900

inode_ref_err(leaf, slot,

fs/btrfs/tree-checker.c

1906

namelen = btrfs_inode_extref_name_len(leaf, extref);

fs/btrfs/tree-checker.c

1908

inode_ref_err(leaf, slot,

fs/btrfs/tree-checker.c

1918

static int check_raid_stripe_extent(const struct extent_buffer *leaf,

fs/btrfs/tree-checker.c

1921

if (unlikely(!IS_ALIGNED(key->objectid, leaf->fs_info->sectorsize))) {

fs/btrfs/tree-checker.c

1922

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

1924

key->objectid, leaf->fs_info->sectorsize);

fs/btrfs/tree-checker.c

1928

if (unlikely(!btrfs_fs_incompat(leaf->fs_info, RAID_STRIPE_TREE))) {

fs/btrfs/tree-checker.c

1929

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

1937

static int check_remap_key(const struct extent_buffer *leaf,

fs/btrfs/tree-checker.c

1940

const u32 item_size = btrfs_item_size(leaf, slot);

fs/btrfs/tree-checker.c

1941

const u32 sectorsize = leaf->fs_info->sectorsize;

fs/btrfs/tree-checker.c

1944

if (unlikely(!btrfs_fs_incompat(leaf->fs_info, REMAP_TREE))) {

fs/btrfs/tree-checker.c

1945

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

195

if (!btrfs_is_fstree(btrfs_header_owner(leaf)))

fs/btrfs/tree-checker.c

1954

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

1963

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

1973

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

1979

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

1986

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

1993

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

2002

static int check_dev_extent_item(const struct extent_buffer *leaf,

fs/btrfs/tree-checker.c

2008

const u32 sectorsize = leaf->fs_info->sectorsize;

fs/btrfs/tree-checker.c

2010

de = btrfs_item_ptr(leaf, slot, struct btrfs_dev_extent);

fs/btrfs/tree-checker.c

2012

if (unlikely(btrfs_dev_extent_chunk_tree(leaf, de) !=

fs/btrfs/tree-checker.c

2014

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

2016

btrfs_dev_extent_chunk_tree(leaf, de),

fs/btrfs/tree-checker.c

202

dir_item_err(leaf, slot,

fs/btrfs/tree-checker.c

2020

if (unlikely(btrfs_dev_extent_chunk_objectid(leaf, de) !=

fs/btrfs/tree-checker.c

2022

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

2024

btrfs_dev_extent_chunk_objectid(leaf, de),

fs/btrfs/tree-checker.c

2030

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

2035

if (unlikely(!IS_ALIGNED(btrfs_dev_extent_chunk_offset(leaf, de),

fs/btrfs/tree-checker.c

2037

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

2039

btrfs_dev_extent_chunk_objectid(leaf, de),

fs/btrfs/tree-checker.c

2043

if (unlikely(!IS_ALIGNED(btrfs_dev_extent_length(leaf, de),

fs/btrfs/tree-checker.c

2045

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

2047

btrfs_dev_extent_length(leaf, de), sectorsize);

fs/btrfs/tree-checker.c

2056

prev_de = btrfs_item_ptr(leaf, slot - 1, struct btrfs_dev_extent);

fs/btrfs/tree-checker.c

2057

prev_len = btrfs_dev_extent_length(leaf, prev_de);

fs/btrfs/tree-checker.c

2059

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

2068

static int check_free_space_info(struct extent_buffer *leaf, struct btrfs_key *key,

fs/btrfs/tree-checker.c

207

static int check_extent_data_item(struct extent_buffer *leaf,

fs/btrfs/tree-checker.c

2071

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/tree-checker.c

2077

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

2083

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

2088

if (unlikely(btrfs_item_size(leaf, slot) !=

fs/btrfs/tree-checker.c

2090

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

2092

btrfs_item_size(leaf, slot),

fs/btrfs/tree-checker.c

2096

fsi = btrfs_item_ptr(leaf, slot, struct btrfs_free_space_info);

fs/btrfs/tree-checker.c

2097

flags = btrfs_free_space_flags(leaf, fsi);

fs/btrfs/tree-checker.c

2099

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

2104

if (unlikely(btrfs_free_space_extent_count(leaf, fsi) >

fs/btrfs/tree-checker.c

2106

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

2108

btrfs_free_space_extent_count(leaf, fsi),

fs/btrfs/tree-checker.c

211

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/tree-checker.c

2115

static int check_free_space_extent(struct extent_buffer *leaf, struct btrfs_key *key, int slot)

fs/btrfs/tree-checker.c

2117

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/tree-checker.c

2121

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

2127

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

2132

if (unlikely(btrfs_item_size(leaf, slot) != 0)) {

fs/btrfs/tree-checker.c

2133

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

2135

btrfs_item_size(leaf, slot));

fs/btrfs/tree-checker.c

214

u32 item_size = btrfs_item_size(leaf, slot);

fs/btrfs/tree-checker.c

2141

static int check_free_space_bitmap(struct extent_buffer *leaf,

fs/btrfs/tree-checker.c

2144

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/tree-checker.c

2149

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

2155

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

2161

generic_err(leaf, slot, "free space bitmap length is 0");

fs/btrfs/tree-checker.c

2172

if (unlikely(btrfs_item_size(leaf, slot) != expected_item_size)) {

fs/btrfs/tree-checker.c

2173

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

2175

btrfs_item_size(leaf, slot), expected_item_size);

fs/btrfs/tree-checker.c

218

file_extent_err(leaf, slot,

fs/btrfs/tree-checker.c

2184

static enum btrfs_tree_block_status check_leaf_item(struct extent_buffer *leaf,

fs/btrfs/tree-checker.c

2194

ret = check_extent_data_item(leaf, key, slot, prev_key);

fs/btrfs/tree-checker.c

2197

ret = check_csum_item(leaf, key, slot, prev_key);

fs/btrfs/tree-checker.c

2202

ret = check_dir_item(leaf, key, prev_key, slot);

fs/btrfs/tree-checker.c

2205

ret = check_inode_ref(leaf, key, prev_key, slot);

fs/btrfs/tree-checker.c

2208

ret = check_inode_extref(leaf, key, prev_key, slot);

fs/btrfs/tree-checker.c

2211

ret = check_block_group_item(leaf, key, slot);

fs/btrfs/tree-checker.c

2214

chunk = btrfs_item_ptr(leaf, slot, struct btrfs_chunk);

fs/btrfs/tree-checker.c

2215

ret = check_leaf_chunk_item(leaf, chunk, key, slot);

fs/btrfs/tree-checker.c

2218

ret = check_dev_item(leaf, key, slot);

fs/btrfs/tree-checker.c

2221

ret = check_dev_extent_item(leaf, key, slot, prev_key);

fs/btrfs/tree-checker.c

2224

ret = check_inode_item(leaf, key, slot);

fs/btrfs/tree-checker.c

2227

ret = check_root_item(leaf, key, slot);

fs/btrfs/tree-checker.c

2231

ret = check_extent_item(leaf, key, slot, prev_key);

fs/btrfs/tree-checker.c

2236

ret = check_simple_keyed_refs(leaf, key, slot);

fs/btrfs/tree-checker.c

2239

ret = check_extent_data_ref(leaf, key, slot);

fs/btrfs/tree-checker.c

2242

ret = check_raid_stripe_extent(leaf, key, slot);

fs/btrfs/tree-checker.c

2245

ret = check_free_space_info(leaf, key, slot);

fs/btrfs/tree-checker.c

2248

ret = check_free_space_extent(leaf, key, slot);

fs/btrfs/tree-checker.c

2251

ret = check_free_space_bitmap(leaf, key, slot);

fs/btrfs/tree-checker.c

2256

ret = check_remap_key(leaf, key, slot);

fs/btrfs/tree-checker.c

2265

enum btrfs_tree_block_status __btrfs_check_leaf(struct extent_buffer *leaf)

fs/btrfs/tree-checker.c

2267

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/tree-checker.c

2271

u32 nritems = btrfs_header_nritems(leaf);

fs/btrfs/tree-checker.c

2274

if (unlikely(btrfs_header_level(leaf) != 0)) {

fs/btrfs/tree-checker.c

2275

generic_err(leaf, 0,

fs/btrfs/tree-checker.c

2277

btrfs_header_level(leaf));

fs/btrfs/tree-checker.c

2281

if (unlikely(!btrfs_header_flag(leaf, BTRFS_HEADER_FLAG_WRITTEN))) {

fs/btrfs/tree-checker.c

2282

generic_err(leaf, 0, "invalid flag for leaf, WRITTEN not set");

fs/btrfs/tree-checker.c

2294

if (nritems == 0 && !btrfs_header_flag(leaf, BTRFS_HEADER_FLAG_RELOC)) {

fs/btrfs/tree-checker.c

2295

u64 owner = btrfs_header_owner(leaf);

fs/btrfs/tree-checker.c

230

if (unlikely(!check_prev_ino(leaf, key, slot, prev_key)))

fs/btrfs/tree-checker.c

2303

generic_err(leaf, 0,

fs/btrfs/tree-checker.c

2311

generic_err(leaf, 0,

fs/btrfs/tree-checker.c

2321

generic_err(leaf, 0,

fs/btrfs/tree-checker.c

233

fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);

fs/btrfs/tree-checker.c

2349

btrfs_item_key_to_cpu(leaf, &key, slot);

fs/btrfs/tree-checker.c

2353

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

2360

item_data_end = (u64)btrfs_item_offset(leaf, slot) +

fs/btrfs/tree-checker.c

2361

btrfs_item_size(leaf, slot);

fs/btrfs/tree-checker.c

2370

item_end_expected = btrfs_item_offset(leaf,

fs/btrfs/tree-checker.c

2373

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

2385

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

2392

if (unlikely(btrfs_item_ptr_offset(leaf, slot) <

fs/btrfs/tree-checker.c

2393

btrfs_item_nr_offset(leaf, slot) + sizeof(struct btrfs_item))) {

fs/btrfs/tree-checker.c

2394

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

2396

btrfs_item_nr_offset(leaf, slot) +

fs/btrfs/tree-checker.c

2398

btrfs_item_ptr_offset(leaf, slot));

fs/btrfs/tree-checker.c

240

file_extent_err(leaf, slot,

fs/btrfs/tree-checker.c

2403

ret = check_leaf_item(leaf, &key, slot, &prev_key);

fs/btrfs/tree-checker.c

2415

int btrfs_check_leaf(struct extent_buffer *leaf)

fs/btrfs/tree-checker.c

2419

ret = __btrfs_check_leaf(leaf);

fs/btrfs/tree-checker.c

246

if (unlikely(btrfs_file_extent_type(leaf, fi) >=

fs/btrfs/tree-checker.c

248

file_extent_err(leaf, slot,

fs/btrfs/tree-checker.c

250

btrfs_file_extent_type(leaf, fi),

fs/btrfs/tree-checker.c

259

if (unlikely(btrfs_file_extent_compression(leaf, fi) >=

fs/btrfs/tree-checker.c

261

file_extent_err(leaf, slot,

fs/btrfs/tree-checker.c

263

btrfs_file_extent_compression(leaf, fi),

fs/btrfs/tree-checker.c

267

if (unlikely(btrfs_file_extent_encryption(leaf, fi))) {

fs/btrfs/tree-checker.c

268

file_extent_err(leaf, slot,

fs/btrfs/tree-checker.c

270

btrfs_file_extent_encryption(leaf, fi));

fs/btrfs/tree-checker.c

273

if (btrfs_file_extent_type(leaf, fi) == BTRFS_FILE_EXTENT_INLINE) {

fs/btrfs/tree-checker.c

276

file_extent_err(leaf, slot,

fs/btrfs/tree-checker.c

283

if (btrfs_file_extent_compression(leaf, fi) !=

fs/btrfs/tree-checker.c

289

btrfs_file_extent_ram_bytes(leaf, fi))) {

fs/btrfs/tree-checker.c

290

file_extent_err(leaf, slot,

fs/btrfs/tree-checker.c

293

btrfs_file_extent_ram_bytes(leaf, fi));

fs/btrfs/tree-checker.c

301

file_extent_err(leaf, slot,

fs/btrfs/tree-checker.c

306

if (unlikely(CHECK_FE_ALIGNED(leaf, slot, fi, ram_bytes, sectorsize) ||

fs/btrfs/tree-checker.c

307

CHECK_FE_ALIGNED(leaf, slot, fi, disk_bytenr, sectorsize) ||

fs/btrfs/tree-checker.c

308

CHECK_FE_ALIGNED(leaf, slot, fi, disk_num_bytes, sectorsize) ||

fs/btrfs/tree-checker.c

309

CHECK_FE_ALIGNED(leaf, slot, fi, offset, sectorsize) ||

fs/btrfs/tree-checker.c

310

CHECK_FE_ALIGNED(leaf, slot, fi, num_bytes, sectorsize)))

fs/btrfs/tree-checker.c

314

if (unlikely(check_add_overflow(btrfs_file_extent_num_bytes(leaf, fi),

fs/btrfs/tree-checker.c

316

file_extent_err(leaf, slot,

fs/btrfs/tree-checker.c

319

btrfs_file_extent_num_bytes(leaf, fi));

fs/btrfs/tree-checker.c

333

prev_fi = btrfs_item_ptr(leaf, slot - 1,

fs/btrfs/tree-checker.c

335

prev_end = file_extent_end(leaf, prev_key, prev_fi);

fs/btrfs/tree-checker.c

337

file_extent_err(leaf, slot - 1,

fs/btrfs/tree-checker.c

352

btrfs_file_extent_compression(leaf, fi) == BTRFS_COMPRESS_NONE &&

fs/btrfs/tree-checker.c

353

btrfs_file_extent_disk_bytenr(leaf, fi)) {

fs/btrfs/tree-checker.c

354

if (WARN_ON(btrfs_file_extent_ram_bytes(leaf, fi) !=

fs/btrfs/tree-checker.c

355

btrfs_file_extent_disk_num_bytes(leaf, fi)))

fs/btrfs/tree-checker.c

356

file_extent_err(leaf, slot,

fs/btrfs/tree-checker.c

358

btrfs_file_extent_ram_bytes(leaf, fi),

fs/btrfs/tree-checker.c

359

btrfs_file_extent_disk_num_bytes(leaf, fi));

fs/btrfs/tree-checker.c

365

static int check_csum_item(struct extent_buffer *leaf, struct btrfs_key *key,

fs/btrfs/tree-checker.c

368

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/tree-checker.c

373

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

379

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

384

if (unlikely(!IS_ALIGNED(btrfs_item_size(leaf, slot), csumsize))) {

fs/btrfs/tree-checker.c

385

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

387

btrfs_item_size(leaf, slot), csumsize);

fs/btrfs/tree-checker.c

394

prev_item_size = btrfs_item_size(leaf, slot - 1);

fs/btrfs/tree-checker.c

398

generic_err(leaf, slot - 1,

fs/btrfs/tree-checker.c

411

static int check_inode_key(struct extent_buffer *leaf, struct btrfs_key *key,

fs/btrfs/tree-checker.c

417

btrfs_item_key_to_cpu(leaf, &item_key, slot);

fs/btrfs/tree-checker.c

433

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

440

dir_item_err(leaf, slot,

fs/btrfs/tree-checker.c

451

inode_item_err(leaf, slot,

fs/btrfs/tree-checker.c

455

dir_item_err(leaf, slot,

fs/btrfs/tree-checker.c

463

static int check_root_key(struct extent_buffer *leaf, struct btrfs_key *key,

fs/btrfs/tree-checker.c

469

btrfs_item_key_to_cpu(leaf, &item_key, slot);

fs/btrfs/tree-checker.c

480

generic_err(leaf, slot,

fs/btrfs/tree-checker.c

489

generic_err(leaf, slot, "invalid root id 0");

fs/btrfs/tree-checker.c

491

dir_item_err(leaf, slot,

fs/btrfs/tree-checker.c

498

dir_item_err(leaf, slot,

fs/btrfs/tree-checker.c

515

generic_err(leaf, slot, "invalid root id 0 for reloc tree");

fs/btrfs/tree-checker.c

521

static int check_dir_item(struct extent_buffer *leaf,

fs/btrfs/tree-checker.c

525

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/tree-checker.c

527

u32 item_size = btrfs_item_size(leaf, slot);

fs/btrfs/tree-checker.c

530

if (unlikely(!check_prev_ino(leaf, key, slot, prev_key)))

fs/btrfs/tree-checker.c

533

di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item);

fs/btrfs/tree-checker.c

546

dir_item_err(leaf, slot,

fs/btrfs/tree-checker.c

553

btrfs_dir_item_key_to_cpu(leaf, di, &location_key);

fs/btrfs/tree-checker.c

555

ret = check_root_key(leaf, &location_key, slot);

fs/btrfs/tree-checker.c

560

ret = check_inode_key(leaf, &location_key, slot);

fs/btrfs/tree-checker.c

564

dir_item_err(leaf, slot,

fs/btrfs/tree-checker.c

572

dir_type = btrfs_dir_ftype(leaf, di);

fs/btrfs/tree-checker.c

575

dir_item_err(leaf, slot,

fs/btrfs/tree-checker.c

583

dir_item_err(leaf, slot,

fs/btrfs/tree-checker.c

590

dir_item_err(leaf, slot,

fs/btrfs/tree-checker.c

600

name_len = btrfs_dir_name_len(leaf, di);

fs/btrfs/tree-checker.c

601

data_len = btrfs_dir_data_len(leaf, di);

fs/btrfs/tree-checker.c

603

dir_item_err(leaf, slot,

fs/btrfs/tree-checker.c

609

dir_item_err(leaf, slot,

fs/btrfs/tree-checker.c

617

dir_item_err(leaf, slot,

fs/btrfs/tree-checker.c

627

dir_item_err(leaf, slot,

fs/btrfs/tree-checker.c

641

read_extent_buffer(leaf, namebuf,

fs/btrfs/tree-checker.c

645

dir_item_err(leaf, slot,

fs/btrfs/tree-checker.c

682

static int check_block_group_item(struct extent_buffer *leaf,

fs/btrfs/tree-checker.c

685

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/tree-checker.c

687

u32 item_size = btrfs_item_size(leaf, slot);

fs/btrfs/tree-checker.c

698

block_group_err(leaf, slot,

fs/btrfs/tree-checker.c

709

block_group_err(leaf, slot,

fs/btrfs/tree-checker.c

715

read_extent_buffer(leaf, &bgi, btrfs_item_ptr_offset(leaf, slot),

fs/btrfs/tree-checker.c

727

block_group_err(leaf, slot,

fs/btrfs/tree-checker.c

734

block_group_err(leaf, slot,

fs/btrfs/tree-checker.c

742

block_group_err(leaf, slot,

fs/btrfs/tree-checker.c

750

block_group_err(leaf, slot,

fs/btrfs/tree-checker.c

759

block_group_err(leaf, slot,

fs/btrfs/tree-checker.c

772

block_group_err(leaf, slot,

fs/btrfs/tree-checker.c

783

block_group_err(leaf, slot,

fs/btrfs/tree-checker.c

790

block_group_err(leaf, slot,

fs/btrfs/tree-checker.c

800

bgi2 = btrfs_item_ptr(leaf, slot, struct btrfs_block_group_item_v2);

fs/btrfs/tree-checker.c

801

remap_bytes = btrfs_block_group_v2_remap_bytes(leaf, bgi2);

fs/btrfs/tree-checker.c

804

block_group_err(leaf, slot,

fs/btrfs/tree-checker.c

810

identity_remap_count = btrfs_block_group_v2_identity_remap_count(leaf, bgi2);

fs/btrfs/tree-checker.c

813

block_group_err(leaf, slot,

fs/btrfs/tree-checker.c

827

const struct extent_buffer *leaf,

fs/btrfs/tree-checker.c

831

bool is_sb = !leaf;

fs/btrfs/tree-checker.c

842

for (i = 0; i < btrfs_header_nritems(leaf); i++) {

fs/btrfs/tree-checker.c

843

if (btrfs_item_ptr_offset(leaf, i) ==

fs/btrfs/tree-checker.c

861

BTRFS_CHUNK_TREE_OBJECTID, leaf->start, slot,

fs/btrfs/tree-checker.c

902

const struct extent_buffer *leaf,

fs/btrfs/tree-checker.c

920

if (leaf) {

fs/btrfs/tree-checker.c

921

length = btrfs_chunk_length(leaf, chunk);

fs/btrfs/tree-checker.c

922

stripe_len = btrfs_chunk_stripe_len(leaf, chunk);

fs/btrfs/tree-checker.c

923

num_stripes = btrfs_chunk_num_stripes(leaf, chunk);

fs/btrfs/tree-checker.c

924

sub_stripes = btrfs_chunk_sub_stripes(leaf, chunk);

fs/btrfs/tree-checker.c

925

type = btrfs_chunk_type(leaf, chunk);

fs/btrfs/tree-checker.c

926

chunk_sector_size = btrfs_chunk_sector_size(leaf, chunk);

fs/btrfs/tree-checker.c

941

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

946

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

952

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

958

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

964

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

970

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

975

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

981

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

995

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.h

69

enum btrfs_tree_block_status __btrfs_check_leaf(struct extent_buffer *leaf);

fs/btrfs/tree-checker.h

72

int btrfs_check_leaf(struct extent_buffer *leaf);

fs/btrfs/tree-checker.h

76

const struct extent_buffer *leaf,

fs/btrfs/tree-log.c

1089

struct extent_buffer *leaf = wc->subvol_path->nodes[0];

fs/btrfs/tree-log.c

1093

btrfs_dir_item_key_to_cpu(leaf, di, &location);

fs/btrfs/tree-log.c

1094

ret = read_alloc_one_name(leaf, di + 1, btrfs_dir_name_len(leaf, di), &name);

fs/btrfs/tree-log.c

1214

struct extent_buffer *leaf = wc->subvol_path->nodes[0];

fs/btrfs/tree-log.c

1223

ptr = btrfs_item_ptr_offset(leaf, wc->subvol_path->slots[0]);

fs/btrfs/tree-log.c

1224

ptr_end = ptr + btrfs_item_size(leaf, wc->subvol_path->slots[0]);

fs/btrfs/tree-log.c

1231

ret = read_alloc_one_name(leaf, (victim_ref + 1),

fs/btrfs/tree-log.c

1232

btrfs_inode_ref_name_len(leaf, victim_ref),

fs/btrfs/tree-log.c

1276

struct extent_buffer *leaf = wc->subvol_path->nodes[0];

fs/btrfs/tree-log.c

1277

const unsigned long base = btrfs_item_ptr_offset(leaf, wc->subvol_path->slots[0]);

fs/btrfs/tree-log.c

1278

const u32 item_size = btrfs_item_size(leaf, wc->subvol_path->slots[0]);

fs/btrfs/tree-log.c

1288

victim_name.len = btrfs_inode_extref_name_len(leaf, extref);

fs/btrfs/tree-log.c

1290

if (btrfs_inode_extref_parent(leaf, extref) != btrfs_ino(dir))

fs/btrfs/tree-log.c

1293

ret = read_alloc_one_name(leaf, &extref->name, victim_name.len,

fs/btrfs/tree-log.c

1781

struct extent_buffer *leaf;

fs/btrfs/tree-log.c

1789

leaf = path->nodes[0];

fs/btrfs/tree-log.c

1790

item_size = btrfs_item_size(leaf, path->slots[0]);

fs/btrfs/tree-log.c

1791

ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);

fs/btrfs/tree-log.c

1796

name_len = btrfs_inode_extref_name_len(leaf, extref);

fs/btrfs/tree-log.c

4611

struct extent_buffer *leaf,

fs/btrfs/tree-log.c

4636

btrfs_set_inode_size(leaf, item, logged_isize);

fs/btrfs/tree-log.c

4638

btrfs_set_inode_size(leaf, item, vfs_inode->i_size);

fs/btrfs/tree-log.c

4641

btrfs_set_inode_generation(leaf, item, gen);

fs/btrfs/tree-log.c

4643

btrfs_set_inode_uid(leaf, item, i_uid_read(vfs_inode));

fs/btrfs/tree-log.c

4644

btrfs_set_inode_gid(leaf, item, i_gid_read(vfs_inode));

fs/btrfs/tree-log.c

4645

btrfs_set_inode_mode(leaf, item, vfs_inode->i_mode);

fs/btrfs/tree-log.c

4646

btrfs_set_inode_nlink(leaf, item, vfs_inode->i_nlink);

fs/btrfs/tree-log.c

4648

btrfs_set_timespec_sec(leaf, &item->atime, inode_get_atime_sec(vfs_inode));

fs/btrfs/tree-log.c

4649

btrfs_set_timespec_nsec(leaf, &item->atime, inode_get_atime_nsec(vfs_inode));

fs/btrfs/tree-log.c

4651

btrfs_set_timespec_sec(leaf, &item->mtime, inode_get_mtime_sec(vfs_inode));

fs/btrfs/tree-log.c

4652

btrfs_set_timespec_nsec(leaf, &item->mtime, inode_get_mtime_nsec(vfs_inode));

fs/btrfs/tree-log.c

4654

btrfs_set_timespec_sec(leaf, &item->ctime, inode_get_ctime_sec(vfs_inode));

fs/btrfs/tree-log.c

4655

btrfs_set_timespec_nsec(leaf, &item->ctime, inode_get_ctime_nsec(vfs_inode));

fs/btrfs/tree-log.c

4657

btrfs_set_timespec_sec(leaf, &item->otime, inode->i_otime_sec);

fs/btrfs/tree-log.c

4658

btrfs_set_timespec_nsec(leaf, &item->otime, inode->i_otime_nsec);

fs/btrfs/tree-log.c

4669

btrfs_set_inode_sequence(leaf, item, inode_peek_iversion(vfs_inode));

fs/btrfs/tree-log.c

4670

btrfs_set_inode_transid(leaf, item, trans->transid);

fs/btrfs/tree-log.c

4671

btrfs_set_inode_rdev(leaf, item, vfs_inode->i_rdev);

fs/btrfs/tree-log.c

4673

btrfs_set_inode_flags(leaf, item, flags);

fs/btrfs/tree-log.c

4674

btrfs_set_inode_block_group(leaf, item, 0);

fs/btrfs/tree-log.c

5145

struct extent_buffer *leaf;

fs/btrfs/tree-log.c

5208

leaf = path->nodes[0];

fs/btrfs/tree-log.c

5209

write_extent_buffer(leaf, &fi,

fs/btrfs/tree-log.c

5210

btrfs_item_ptr_offset(leaf, path->slots[0]),

fs/btrfs/tree-log.c

5238

struct extent_buffer *leaf;

fs/btrfs/tree-log.c

5269

leaf = path->nodes[0];

fs/btrfs/tree-log.c

5271

ei = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);

fs/btrfs/tree-log.c

5273

if (btrfs_file_extent_type(leaf, ei) ==

fs/btrfs/tree-log.c

5277

btrfs_item_key_to_cpu(leaf, &key, slot);

fs/btrfs/tree-log.c

5279

btrfs_file_extent_num_bytes(leaf, ei);

fs/btrfs/tree-log.c

5289

leaf = path->nodes[0];

fs/btrfs/tree-log.c

5292

if (slot >= btrfs_header_nritems(leaf)) {

fs/btrfs/tree-log.c

5310

btrfs_item_key_to_cpu(leaf, &key, slot);

fs/btrfs/tree-log.c

5554

struct extent_buffer *leaf = path->nodes[0];

fs/btrfs/tree-log.c

5555

int nritems = btrfs_header_nritems(leaf);

fs/btrfs/tree-log.c

5573

btrfs_item_key_to_cpu(leaf, &key, slot);

fs/btrfs/tree-log.c

5630

struct extent_buffer *leaf = path->nodes[0];

fs/btrfs/tree-log.c

5640

leaf = path->nodes[0];

fs/btrfs/tree-log.c

5643

btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);

fs/btrfs/tree-log.c

5675

leaf = path->nodes[0];

fs/btrfs/tree-log.c

5936

struct extent_buffer *leaf = path->nodes[0];

fs/btrfs/tree-log.c

5951

di = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dir_item);

fs/btrfs/tree-log.c

5952

type = btrfs_dir_ftype(leaf, di);

fs/btrfs/tree-log.c

5953

if (btrfs_dir_transid(leaf, di) < trans->transid)

fs/btrfs/tree-log.c

5955

btrfs_dir_item_key_to_cpu(leaf, di, &di_key);

fs/btrfs/tree-log.c

6687

struct extent_buffer *leaf = path->nodes[0];

fs/btrfs/tree-log.c

6688

const int last_slot = btrfs_header_nritems(leaf) - 1;

fs/btrfs/tree-log.c

6698

btrfs_item_key_to_cpu(leaf, &key, slot);

fs/btrfs/tree-log.c

7263

struct extent_buffer *leaf = path->nodes[0];

fs/btrfs/tree-log.c

7269

if (slot >= btrfs_header_nritems(leaf)) {

fs/btrfs/tree-log.c

7278

btrfs_item_key_to_cpu(leaf, &key, slot);

fs/btrfs/tree-log.c

7283

item_size = btrfs_item_size(leaf, slot);

fs/btrfs/tree-log.c

7284

ptr = btrfs_item_ptr_offset(leaf, slot);

fs/btrfs/tree-log.c

7294

dir_id = btrfs_inode_extref_parent(leaf, extref);

fs/btrfs/tree-log.c

7296

cur_offset += btrfs_inode_extref_name_len(leaf,

fs/btrfs/tree-log.c

7358

struct extent_buffer *leaf;

fs/btrfs/tree-log.c

7391

leaf = path->nodes[0];

fs/btrfs/tree-log.c

7393

if (slot >= btrfs_header_nritems(leaf)) {

fs/btrfs/tree-log.c

7399

leaf = path->nodes[0];

fs/btrfs/tree-log.c

7403

btrfs_item_key_to_cpu(leaf, &found_key, slot);

fs/btrfs/tree-log.c

7482

struct extent_buffer *leaf = path->nodes[0];

fs/btrfs/tree-log.c

7486

if (slot >= btrfs_header_nritems(leaf)) {

fs/btrfs/tree-log.c

7495

btrfs_item_key_to_cpu(leaf, &found_key, slot);

fs/btrfs/tree-log.c

777

struct extent_buffer *leaf = wc->subvol_path->nodes[0];

fs/btrfs/tree-log.c

781

ptr = btrfs_item_ptr_offset(leaf, wc->subvol_path->slots[0]);

fs/btrfs/tree-log.c

782

read_extent_buffer(leaf, &existing, ptr, sizeof(existing));

fs/btrfs/uuid-tree.c

301

struct extent_buffer *leaf;

fs/btrfs/uuid-tree.c

326

leaf = path->nodes[0];

fs/btrfs/uuid-tree.c

328

btrfs_item_key_to_cpu(leaf, &key, slot);

fs/btrfs/uuid-tree.c

334

offset = btrfs_item_ptr_offset(leaf, slot);

fs/btrfs/uuid-tree.c

335

item_size = btrfs_item_size(leaf, slot);

fs/btrfs/uuid-tree.c

349

read_extent_buffer(leaf, &subid_le, offset,

fs/btrfs/verity.c

217

struct extent_buffer *leaf;

fs/btrfs/verity.c

250

leaf = path->nodes[0];

fs/btrfs/verity.c

252

data = btrfs_item_ptr(leaf, path->slots[0], void);

fs/btrfs/verity.c

253

write_extent_buffer(leaf, src + src_offset,

fs/btrfs/verity.c

293

struct extent_buffer *leaf;

fs/btrfs/verity.c

327

leaf = path->nodes[0];

fs/btrfs/verity.c

328

btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);

fs/btrfs/verity.c

333

item_end = btrfs_item_size(leaf, path->slots[0]) + key.offset;

fs/btrfs/verity.c

369

data = btrfs_item_ptr(leaf, path->slots[0], void);

fs/btrfs/verity.c

370

read_extent_buffer(leaf, kaddr + dest_offset,

fs/btrfs/volumes.c

1959

struct extent_buffer *leaf = NULL;

fs/btrfs/volumes.c

1976

leaf = path->nodes[0];

fs/btrfs/volumes.c

1977

btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);

fs/btrfs/volumes.c

1978

extent = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/volumes.c

1981

btrfs_dev_extent_length(leaf, extent) < start);

fs/btrfs/volumes.c

1986

leaf = path->nodes[0];

fs/btrfs/volumes.c

1987

extent = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/volumes.c

1993

*dev_extent_len = btrfs_dev_extent_length(leaf, extent);

fs/btrfs/volumes.c

2068

struct extent_buffer *leaf;

fs/btrfs/volumes.c

2087

leaf = path->nodes[0];

fs/btrfs/volumes.c

2088

dev_item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dev_item);

fs/btrfs/volumes.c

2090

btrfs_set_device_id(leaf, dev_item, device->devid);

fs/btrfs/volumes.c

2091

btrfs_set_device_generation(leaf, dev_item, 0);

fs/btrfs/volumes.c

2092

btrfs_set_device_type(leaf, dev_item, device->type);

fs/btrfs/volumes.c

2093

btrfs_set_device_io_align(leaf, dev_item, device->io_align);

fs/btrfs/volumes.c

2094

btrfs_set_device_io_width(leaf, dev_item, device->io_width);

fs/btrfs/volumes.c

2095

btrfs_set_device_sector_size(leaf, dev_item, device->sector_size);

fs/btrfs/volumes.c

2096

btrfs_set_device_total_bytes(leaf, dev_item,

fs/btrfs/volumes.c

2098

btrfs_set_device_bytes_used(leaf, dev_item,

fs/btrfs/volumes.c

2100

btrfs_set_device_group(leaf, dev_item, 0);

fs/btrfs/volumes.c

2101

btrfs_set_device_seek_speed(leaf, dev_item, 0);

fs/btrfs/volumes.c

2102

btrfs_set_device_bandwidth(leaf, dev_item, 0);

fs/btrfs/volumes.c

2103

btrfs_set_device_start_offset(leaf, dev_item, 0);

fs/btrfs/volumes.c

2106

write_extent_buffer(leaf, device->uuid, ptr, BTRFS_UUID_SIZE);

fs/btrfs/volumes.c

2108

write_extent_buffer(leaf, trans->fs_info->fs_devices->metadata_uuid,

fs/btrfs/volumes.c

2741

struct extent_buffer *leaf;

fs/btrfs/volumes.c

2764

leaf = path->nodes[0];

fs/btrfs/volumes.c

2766

if (path->slots[0] >= btrfs_header_nritems(leaf)) {

fs/btrfs/volumes.c

2772

leaf = path->nodes[0];

fs/btrfs/volumes.c

2773

btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);

fs/btrfs/volumes.c

2778

btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);

fs/btrfs/volumes.c

2783

dev_item = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/volumes.c

2785

args.devid = btrfs_device_id(leaf, dev_item);

fs/btrfs/volumes.c

2786

read_extent_buffer(leaf, dev_uuid, btrfs_device_uuid(dev_item),

fs/btrfs/volumes.c

2788

read_extent_buffer(leaf, fs_uuid, btrfs_device_fsid(dev_item),

fs/btrfs/volumes.c

2796

btrfs_set_device_generation(leaf, dev_item,

fs/btrfs/volumes.c

3062

struct extent_buffer *leaf;

fs/btrfs/volumes.c

3080

leaf = path->nodes[0];

fs/btrfs/volumes.c

3081

dev_item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dev_item);

fs/btrfs/volumes.c

3083

btrfs_set_device_id(leaf, dev_item, device->devid);

fs/btrfs/volumes.c

3084

btrfs_set_device_type(leaf, dev_item, device->type);

fs/btrfs/volumes.c

3085

btrfs_set_device_io_align(leaf, dev_item, device->io_align);

fs/btrfs/volumes.c

3086

btrfs_set_device_io_width(leaf, dev_item, device->io_width);

fs/btrfs/volumes.c

3087

btrfs_set_device_sector_size(leaf, dev_item, device->sector_size);

fs/btrfs/volumes.c

3088

btrfs_set_device_total_bytes(leaf, dev_item,

fs/btrfs/volumes.c

3090

btrfs_set_device_bytes_used(leaf, dev_item,

fs/btrfs/volumes.c

3629

struct extent_buffer *leaf;

fs/btrfs/volumes.c

3675

leaf = path->nodes[0];

fs/btrfs/volumes.c

3676

btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);

fs/btrfs/volumes.c

3678

chunk = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/volumes.c

3680

chunk_type = btrfs_chunk_type(leaf, chunk);

fs/btrfs/volumes.c

3796

struct extent_buffer *leaf;

fs/btrfs/volumes.c

3819

leaf = path->nodes[0];

fs/btrfs/volumes.c

3820

item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_balance_item);

fs/btrfs/volumes.c

3822

memzero_extent_buffer(leaf, (unsigned long)item, sizeof(*item));

fs/btrfs/volumes.c

3825

btrfs_set_balance_data(leaf, item, &disk_bargs);

fs/btrfs/volumes.c

3827

btrfs_set_balance_meta(leaf, item, &disk_bargs);

fs/btrfs/volumes.c

3829

btrfs_set_balance_sys(leaf, item, &disk_bargs);

fs/btrfs/volumes.c

3830

btrfs_set_balance_flags(leaf, item, bctl->flags);

fs/btrfs/volumes.c

4015

static bool chunk_devid_filter(struct extent_buffer *leaf, struct btrfs_chunk *chunk,

fs/btrfs/volumes.c

4019

int num_stripes = btrfs_chunk_num_stripes(leaf, chunk);

fs/btrfs/volumes.c

4024

if (btrfs_stripe_devid(leaf, stripe) == bargs->devid)

fs/btrfs/volumes.c

4041

static bool chunk_drange_filter(struct extent_buffer *leaf, struct btrfs_chunk *chunk,

fs/btrfs/volumes.c

4045

int num_stripes = btrfs_chunk_num_stripes(leaf, chunk);

fs/btrfs/volumes.c

4055

type = btrfs_chunk_type(leaf, chunk);

fs/btrfs/volumes.c

4060

if (btrfs_stripe_devid(leaf, stripe) != bargs->devid)

fs/btrfs/volumes.c

4063

stripe_offset = btrfs_stripe_offset(leaf, stripe);

fs/btrfs/volumes.c

4064

stripe_length = btrfs_chunk_length(leaf, chunk);

fs/btrfs/volumes.c

4076

static bool chunk_vrange_filter(struct extent_buffer *leaf, struct btrfs_chunk *chunk,

fs/btrfs/volumes.c

4080

chunk_offset + btrfs_chunk_length(leaf, chunk) > bargs->vstart)

fs/btrfs/volumes.c

4087

static bool chunk_stripes_range_filter(struct extent_buffer *leaf,

fs/btrfs/volumes.c

4091

int num_stripes = btrfs_chunk_num_stripes(leaf, chunk);

fs/btrfs/volumes.c

4114

static bool should_balance_chunk(struct extent_buffer *leaf, struct btrfs_chunk *chunk,

fs/btrfs/volumes.c

4117

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/volumes.c

4120

u64 chunk_type = btrfs_chunk_type(leaf, chunk);

fs/btrfs/volumes.c

4158

chunk_devid_filter(leaf, chunk, bargs)) {

fs/btrfs/volumes.c

4164

chunk_drange_filter(leaf, chunk, bargs)) {

fs/btrfs/volumes.c

4170

chunk_vrange_filter(leaf, chunk, chunk_offset, bargs)) {

fs/btrfs/volumes.c

4176

chunk_stripes_range_filter(leaf, chunk, bargs)) {

fs/btrfs/volumes.c

4328

struct extent_buffer *leaf;

fs/btrfs/volumes.c

4404

leaf = path->nodes[0];

fs/btrfs/volumes.c

4406

btrfs_item_key_to_cpu(leaf, &found_key, slot);

fs/btrfs/volumes.c

4413

chunk = btrfs_item_ptr(leaf, slot, struct btrfs_chunk);

fs/btrfs/volumes.c

4414

chunk_type = btrfs_chunk_type(leaf, chunk);

fs/btrfs/volumes.c

4418

btrfs_chunk_num_stripes(leaf, chunk) == 0) {

fs/btrfs/volumes.c

4430

ret = should_balance_chunk(leaf, chunk, found_key.offset);

fs/btrfs/volumes.c

5005

struct extent_buffer *leaf;

fs/btrfs/volumes.c

5028

leaf = path->nodes[0];

fs/btrfs/volumes.c

5029

item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_balance_item);

fs/btrfs/volumes.c

5031

bctl->flags = btrfs_balance_flags(leaf, item);

fs/btrfs/volumes.c

5034

btrfs_balance_data(leaf, item, &disk_bargs);

fs/btrfs/volumes.c

5036

btrfs_balance_meta(leaf, item, &disk_bargs);

fs/btrfs/volumes.c

5038

btrfs_balance_sys(leaf, item, &disk_bargs);

fs/btrfs/volumes.c

7512

static int read_one_chunk(struct btrfs_key *key, struct extent_buffer *leaf,

fs/btrfs/volumes.c

7516

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/volumes.c

7529

length = btrfs_chunk_length(leaf, chunk);

fs/btrfs/volumes.c

7530

type = btrfs_chunk_type(leaf, chunk);

fs/btrfs/volumes.c

7532

num_stripes = btrfs_chunk_num_stripes(leaf, chunk);

fs/btrfs/volumes.c

7558

map->io_width = btrfs_chunk_io_width(leaf, chunk);

fs/btrfs/volumes.c

7559

map->io_align = btrfs_chunk_io_align(leaf, chunk);

fs/btrfs/volumes.c

7579

btrfs_stripe_offset_nr(leaf, chunk, i);

fs/btrfs/volumes.c

7580

devid = btrfs_stripe_devid_nr(leaf, chunk, i);

fs/btrfs/volumes.c

7582

read_extent_buffer(leaf, uuid, (unsigned long)

fs/btrfs/volumes.c

7612

static void fill_device_from_item(struct extent_buffer *leaf,

fs/btrfs/volumes.c

7618

device->devid = btrfs_device_id(leaf, dev_item);

fs/btrfs/volumes.c

7619

device->disk_total_bytes = btrfs_device_total_bytes(leaf, dev_item);

fs/btrfs/volumes.c

7622

device->bytes_used = btrfs_device_bytes_used(leaf, dev_item);

fs/btrfs/volumes.c

7624

device->type = btrfs_device_type(leaf, dev_item);

fs/btrfs/volumes.c

7625

device->io_align = btrfs_device_io_align(leaf, dev_item);

fs/btrfs/volumes.c

7626

device->io_width = btrfs_device_io_width(leaf, dev_item);

fs/btrfs/volumes.c

7627

device->sector_size = btrfs_device_sector_size(leaf, dev_item);

fs/btrfs/volumes.c

7632

read_extent_buffer(leaf, device->uuid, ptr, BTRFS_UUID_SIZE);

fs/btrfs/volumes.c

7694

static int read_one_dev(struct extent_buffer *leaf,

fs/btrfs/volumes.c

7698

struct btrfs_fs_info *fs_info = leaf->fs_info;

fs/btrfs/volumes.c

7705

devid = btrfs_device_id(leaf, dev_item);

fs/btrfs/volumes.c

7707

read_extent_buffer(leaf, dev_uuid, btrfs_device_uuid(dev_item),

fs/btrfs/volumes.c

7709

read_extent_buffer(leaf, fs_uuid, btrfs_device_fsid(dev_item),

fs/btrfs/volumes.c

7778

btrfs_device_generation(leaf, dev_item))

fs/btrfs/volumes.c

7782

fill_device_from_item(leaf, dev_item, device);

fs/btrfs/volumes.c

7942

struct extent_buffer *leaf;

fs/btrfs/volumes.c

7994

leaf = path->nodes[0];

fs/btrfs/volumes.c

8005

dev_item = btrfs_item_ptr(leaf, slot,

fs/btrfs/volumes.c

8007

ret = read_one_dev(leaf, dev_item);

fs/btrfs/volumes.c

8022

chunk = btrfs_item_ptr(leaf, slot, struct btrfs_chunk);

fs/btrfs/volumes.c

8023

ret = read_one_chunk(&found_key, leaf, chunk);

fs/btrfs/volumes.c

8602

struct extent_buffer *leaf = path->nodes[0];

fs/btrfs/volumes.c

8610

btrfs_item_key_to_cpu(leaf, &key, slot);

fs/btrfs/volumes.c

8616

dext = btrfs_item_ptr(leaf, slot, struct btrfs_dev_extent);

fs/btrfs/volumes.c

8617

chunk_offset = btrfs_dev_extent_chunk_offset(leaf, dext);

fs/btrfs/volumes.c

8618

physical_len = btrfs_dev_extent_length(leaf, dext);

fs/btrfs/xattr.c

160

struct extent_buffer *leaf = path->nodes[0];

fs/btrfs/xattr.c

161

const u16 old_data_len = btrfs_dir_data_len(leaf, di);

fs/btrfs/xattr.c

162

const u32 item_size = btrfs_item_size(leaf, slot);

fs/btrfs/xattr.c

168

if (btrfs_leaf_free_space(leaf) <

fs/btrfs/xattr.c

189

ptr = btrfs_item_ptr(leaf, slot, char);

fs/btrfs/xattr.c

190

ptr += btrfs_item_size(leaf, slot) - data_size;

fs/btrfs/xattr.c

192

btrfs_set_dir_data_len(leaf, di, size);

fs/btrfs/xattr.c

194

write_extent_buffer(leaf, value, data_ptr, size);

fs/btrfs/xattr.c

289

struct extent_buffer *leaf;

fs/btrfs/xattr.c

295

leaf = path->nodes[0];

fs/btrfs/xattr.c

306

di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item);

fs/btrfs/xattr.c

307

item_size = btrfs_item_size(leaf, slot);

fs/btrfs/xattr.c

310

u16 name_len = btrfs_dir_name_len(leaf, di);

fs/btrfs/xattr.c

311

u16 data_len = btrfs_dir_data_len(leaf, di);

fs/btrfs/xattr.c

328

read_extent_buffer(leaf, buffer, name_ptr, name_len);

fs/btrfs/xattr.c

33

struct extent_buffer *leaf;

fs/btrfs/xattr.c

48

leaf = path->nodes[0];

fs/btrfs/xattr.c

51

return btrfs_dir_data_len(leaf, di);

fs/btrfs/xattr.c

54

if (btrfs_dir_data_len(leaf, di) > size)

fs/btrfs/xattr.c

65

btrfs_dir_name_len(leaf, di));

fs/btrfs/xattr.c

66

read_extent_buffer(leaf, buffer, data_ptr,

fs/btrfs/xattr.c

67

btrfs_dir_data_len(leaf, di));

fs/btrfs/xattr.c

68

return btrfs_dir_data_len(leaf, di);

fs/btrfs/zoned.c

299

struct extent_buffer *leaf;

fs/btrfs/zoned.c

324

leaf = path->nodes[0];

fs/btrfs/zoned.c

325

dext = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dev_extent);

fs/btrfs/zoned.c

326

fs_info->zone_size = btrfs_dev_extent_length(leaf, dext);

fs/ext4/extents.c

2317

ext4_fsblk_t leaf;

fs/ext4/extents.c

2321

leaf = ext4_idx_pblock(path[k].p_idx);

fs/ext4/extents.c

2340

ext_debug(inode, "index is empty, remove it, free block %llu\n", leaf);

fs/ext4/extents.c

2341

trace_ext4_ext_rm_idx(inode, leaf);

fs/ext4/extents.c

2343

ext4_free_blocks(handle, inode, NULL, leaf, 1,

fs/gfs2/dir.c

1376

unsigned leaves = 0, leaf = 0, offset, sort_offset;

fs/gfs2/dir.c

1444

sort_id = gfs2_set_cookies(sdp, bh, leaf, &darr[offset],

fs/gfs2/dir.c

1450

larr[leaf++] = bh;

fs/gfs2/dir.c

1452

larr[leaf++] = NULL;

fs/gfs2/dir.c

1461

for(i = 0; i < leaf; i++)

fs/gfs2/dir.c

1728

struct gfs2_leaf *leaf, *oleaf;

fs/gfs2/dir.c

1752

leaf = new_leaf(inode, &bh, be16_to_cpu(oleaf->lf_depth));

fs/gfs2/dir.c

1753

if (!leaf) {

fs/gfs2/dir.c

1757

leaf->lf_dist = cpu_to_be32(dist);

fs/gfs2/dir.c

1803

struct gfs2_leaf *leaf;

fs/gfs2/dir.c

1820

leaf = (struct gfs2_leaf *)bh->b_data;

fs/gfs2/dir.c

1821

be16_add_cpu(&leaf->lf_entries, 1);

fs/gfs2/dir.c

1822

leaf->lf_nsec = cpu_to_be32(tv.tv_nsec);

fs/gfs2/dir.c

1823

leaf->lf_sec = cpu_to_be64(tv.tv_sec);

fs/gfs2/dir.c

1902

struct gfs2_leaf *leaf = (struct gfs2_leaf *)bh->b_data;

fs/gfs2/dir.c

1903

u16 entries = be16_to_cpu(leaf->lf_entries);

fs/gfs2/dir.c

1906

leaf->lf_entries = cpu_to_be16(--entries);

fs/gfs2/dir.c

1907

leaf->lf_nsec = cpu_to_be32(tv.tv_nsec);

fs/gfs2/dir.c

1908

leaf->lf_sec = cpu_to_be64(tv.tv_sec);

fs/gfs2/dir.c

2104

struct gfs2_leaf *leaf;

fs/gfs2/dir.c

2123

leaf = (struct gfs2_leaf *)bh->b_data;

fs/gfs2/dir.c

2124

len = BIT(dip->i_depth - be16_to_cpu(leaf->lf_depth));

fs/gfs2/dir.c

820

struct gfs2_leaf *leaf;

fs/gfs2/dir.c

838

leaf = (struct gfs2_leaf *)bh->b_data;

fs/gfs2/dir.c

839

ln = be64_to_cpu(leaf->lf_next);

fs/gfs2/dir.c

871

struct gfs2_leaf *leaf;

fs/gfs2/dir.c

885

leaf = (struct gfs2_leaf *)bh->b_data;

fs/gfs2/dir.c

886

leaf->lf_depth = cpu_to_be16(depth);

fs/gfs2/dir.c

887

leaf->lf_entries = 0;

fs/gfs2/dir.c

888

leaf->lf_dirent_format = cpu_to_be32(GFS2_FORMAT_DE);

fs/gfs2/dir.c

889

leaf->lf_next = 0;

fs/gfs2/dir.c

890

leaf->lf_inode = cpu_to_be64(ip->i_no_addr);

fs/gfs2/dir.c

891

leaf->lf_dist = cpu_to_be32(1);

fs/gfs2/dir.c

892

leaf->lf_nsec = cpu_to_be32(tv.tv_nsec);

fs/gfs2/dir.c

893

leaf->lf_sec = cpu_to_be64(tv.tv_sec);

fs/gfs2/dir.c

894

memset(leaf->lf_reserved2, 0, sizeof(leaf->lf_reserved2));

fs/gfs2/dir.c

895

dent = (struct gfs2_dirent *)(leaf+1);

fs/gfs2/dir.c

898

return leaf;

fs/gfs2/dir.c

915

struct gfs2_leaf *leaf;

fs/gfs2/dir.c

927

leaf = new_leaf(inode, &bh, 0);

fs/gfs2/dir.c

928

if (!leaf)

fs/gfs2/dir.c

933

leaf->lf_entries = cpu_to_be16(dip->i_entries);

fs/jfs/jfs_dmap.c

1076

s8 *leaf;

fs/jfs/jfs_dmap.c

1086

leaf = dp->tree.stree + le32_to_cpu(dp->tree.leafidx);

fs/jfs/jfs_dmap.c

1103

if (leaf[word] == NOFREE)

fs/jfs/jfs_dmap.c

1150

if (leaf[word] < BUDMIN)

fs/jfs/jfs_dmap.c

1157

min_t(int, leaf[word], NLSTOL2BSZ(nwords));

fs/jfs/jfs_dmap.c

1207

s8 *leaf;

fs/jfs/jfs_dmap.c

1214

leaf = dp->tree.stree + le32_to_cpu(dp->tree.leafidx);

fs/jfs/jfs_dmap.c

1228

if (leaf[word] < l2nb)

fs/jfs/jfs_dmap.c

1241

if (leaf[word] < BUDMIN)

fs/jfs/jfs_dmap.c

2145

s8 *leaf;

fs/jfs/jfs_dmap.c

2148

leaf = dp->tree.stree + LEAFIND;

fs/jfs/jfs_dmap.c

2214

if (leaf[word] < BUDMIN) {

fs/jfs/jfs_dmap.c

2225

size = min_t(int, leaf[word],

fs/jfs/jfs_dmap.c

2630

s8 *leaf = tp->dmt_stree + le32_to_cpu(tp->dmt_leafidx);

fs/jfs/jfs_dmap.c

2634

if (leaf[leafno] > tp->dmt_budmin) {

fs/jfs/jfs_dmap.c

2640

cursz = leaf[leafno] - 1;

fs/jfs/jfs_dmap.c

2695

s8 *leaf = tp->dmt_stree + le32_to_cpu(tp->dmt_leafidx);

fs/jfs/jfs_dmap.c

2700

assert(leaf[leafno] == NOFREE);

fs/jfs/jfs_dmap.c

2721

while (leaf[leafno] == NOFREE) {

fs/jfs/jfs_dmap.c

2737

if (leaf[bud] != NOFREE) {

fs/jfs/jfs_dmap.c

2741

cursz = leaf[bud] - 1;

fs/jfs/jfs_dmap.c

2748

if (leaf[leafno] != size) {

fs/jfs/jfs_dmap.c

2773

s8 *leaf;

fs/jfs/jfs_dmap.c

2780

leaf = tp->dmt_stree + le32_to_cpu(tp->dmt_leafidx);

fs/jfs/jfs_dmap.c

2807

if (newval > leaf[buddy])

fs/jfs/jfs_dmap.c

2811

if (newval < leaf[buddy])

fs/jfs/jfs_dtree.c

3667

lh->inumber = cpu_to_le32(data->leaf.ino);

fs/jfs/jfs_dtree.c

3670

if (data->leaf.ip) {

fs/jfs/jfs_dtree.c

3674

lh->index = cpu_to_le32(add_index(data->leaf.tid,

fs/jfs/jfs_dtree.c

3675

data->leaf.ip,

fs/jfs/jfs_dtree.c

3754

if ((p->header.flag & BT_LEAF) && data->leaf.ip) {

fs/jfs/jfs_dtree.c

3764

modify_index(data->leaf.tid, data->leaf.ip,

fs/jfs/jfs_dtree.c

850

data.leaf.tid = tid;

fs/jfs/jfs_dtree.c

851

data.leaf.ip = ip;

fs/jfs/jfs_dtree.c

854

data.leaf.ip = NULL; /* signifies legacy directory format */

fs/jfs/jfs_dtree.c

856

data.leaf.ino = *fsn;

fs/jfs/jfs_dtree.h

19

} leaf;

fs/proc/bootconfig.c

28

struct xbc_node *leaf, *vnode;

fs/proc/bootconfig.c

38

xbc_for_each_key_value(leaf, val) {

fs/proc/bootconfig.c

39

ret = xbc_node_compose_key(leaf, key, XBC_KEYLEN_MAX);

fs/proc/bootconfig.c

46

vnode = xbc_node_get_child(leaf);

fs/ubifs/tnc.c

350

ubifs_assert(c, !zbr->leaf);

fs/ubifs/tnc.c

366

zbr->leaf = lnc_node;

fs/ubifs/tnc.c

384

ubifs_assert(c, !zbr->leaf);

fs/ubifs/tnc.c

394

zbr->leaf = node;

fs/ubifs/tnc.c

404

if (!zbr->leaf)

fs/ubifs/tnc.c

406

kfree(zbr->leaf);

fs/ubifs/tnc.c

407

zbr->leaf = NULL;

fs/ubifs/tnc.c

428

if (zbr->leaf) {

fs/ubifs/tnc.c

431

memcpy(node, zbr->leaf, zbr->len);

fs/ubifs/tnc.c

575

if (!zbr->leaf) {

fs/ubifs/tnc.c

589

dent = zbr->leaf;

fs/ubifs/tnc.c

863

if (!zbr->leaf) {

fs/ubifs/tnc.c

882

dent = zbr->leaf;

fs/ubifs/ubifs.h

750

void *leaf;

fs/unicode/mkutf8data.c

1417

struct unicode_data *leaf = l;

fs/unicode/mkutf8data.c

1419

printf("%*sleaf @ %p code %X ccc %d gen %d", indent, "", leaf,

fs/unicode/mkutf8data.c

1420

leaf->code, leaf->ccc, leaf->gen);

fs/unicode/mkutf8data.c

1422

if (leaf->utf8nfdi && leaf->utf8nfdi[0] == HANGUL)

fs/unicode/mkutf8data.c

1424

else if (leaf->utf8nfdi)

fs/unicode/mkutf8data.c

1425

printf(" nfdi \"%s\"", (const char*)leaf->utf8nfdi);

fs/unicode/mkutf8data.c

1432

struct unicode_data *leaf = l;

fs/unicode/mkutf8data.c

1434

printf("%*sleaf @ %p code %X ccc %d gen %d", indent, "", leaf,

fs/unicode/mkutf8data.c

1435

leaf->code, leaf->ccc, leaf->gen);

fs/unicode/mkutf8data.c

1437

if (leaf->utf8nfdicf)

fs/unicode/mkutf8data.c

1438

printf(" nfdicf \"%s\"", (const char*)leaf->utf8nfdicf);

fs/unicode/mkutf8data.c

1439

else if (leaf->utf8nfdi && leaf->utf8nfdi[0] == HANGUL)

fs/unicode/mkutf8data.c

1441

else if (leaf->utf8nfdi)

fs/unicode/mkutf8data.c

1442

printf(" nfdi \"%s\"", (const char*)leaf->utf8nfdi);

fs/unicode/mkutf8data.c

1453

struct unicode_data *leaf = l;

fs/unicode/mkutf8data.c

1455

if (leaf->utf8nfdicf)

fs/unicode/mkutf8data.c

1462

struct unicode_data *leaf = l;

fs/unicode/mkutf8data.c

1464

return leaf->correction;

fs/unicode/mkutf8data.c

1469

struct unicode_data *leaf = l;

fs/unicode/mkutf8data.c

1472

if (HANGUL_SYLLABLE(leaf->code))

fs/unicode/mkutf8data.c

1474

else if (leaf->utf8nfdi)

fs/unicode/mkutf8data.c

1475

size += strlen(leaf->utf8nfdi) + 1;

fs/unicode/mkutf8data.c

1481

struct unicode_data *leaf = l;

fs/unicode/mkutf8data.c

1484

if (HANGUL_SYLLABLE(leaf->code))

fs/unicode/mkutf8data.c

1486

else if (leaf->utf8nfdicf)

fs/unicode/mkutf8data.c

1487

size += strlen(leaf->utf8nfdicf) + 1;

fs/unicode/mkutf8data.c

1488

else if (leaf->utf8nfdi)

fs/unicode/mkutf8data.c

1489

size += strlen(leaf->utf8nfdi) + 1;

fs/unicode/mkutf8data.c

1495

struct unicode_data *leaf = l;

fs/unicode/mkutf8data.c

1497

return &tree->leafindex[leaf->code];

fs/unicode/mkutf8data.c

1502

struct unicode_data *leaf = l;

fs/unicode/mkutf8data.c

1504

return &tree->leafindex[leaf->code];

fs/unicode/mkutf8data.c

1509

struct unicode_data *leaf = l;

fs/unicode/mkutf8data.c

1512

*data++ = leaf->gen;

fs/unicode/mkutf8data.c

1514

if (HANGUL_SYLLABLE(leaf->code)) {

fs/unicode/mkutf8data.c

1517

} else if (leaf->utf8nfdi) {

fs/unicode/mkutf8data.c

1519

s = (unsigned char*)leaf->utf8nfdi;

fs/unicode/mkutf8data.c

1523

*data++ = leaf->ccc;

fs/unicode/mkutf8data.c

1530

struct unicode_data *leaf = l;

fs/unicode/mkutf8data.c

1533

*data++ = leaf->gen;

fs/unicode/mkutf8data.c

1535

if (HANGUL_SYLLABLE(leaf->code)) {

fs/unicode/mkutf8data.c

1538

} else if (leaf->utf8nfdicf) {

fs/unicode/mkutf8data.c

1540

s = (unsigned char*)leaf->utf8nfdicf;

fs/unicode/mkutf8data.c

1543

} else if (leaf->utf8nfdi) {

fs/unicode/mkutf8data.c

1545

s = (unsigned char*)leaf->utf8nfdi;

fs/unicode/mkutf8data.c

1549

*data++ = leaf->ccc;

fs/unicode/mkutf8data.c

1748

utf8leaf_t *leaf;

fs/unicode/mkutf8data.c

1765

leaf = utf8lookup(tree, hangul, key);

fs/unicode/mkutf8data.c

1767

if (!leaf) {

fs/unicode/mkutf8data.c

1777

if (data->gen != LEAF_GEN(leaf))

fs/unicode/mkutf8data.c

1779

if (LEAF_CCC(leaf) == DECOMPOSE) {

fs/unicode/mkutf8data.c

1787

LEAF_STR(leaf))) {

fs/unicode/mkutf8data.c

1796

LEAF_STR(leaf)))

fs/unicode/mkutf8data.c

1799

LEAF_STR(leaf))) {

fs/unicode/mkutf8data.c

1803

} else if (data->ccc != LEAF_CCC(leaf)) {

fs/unicode/mkutf8data.c

1813

if (leaf) {

fs/unicode/mkutf8data.c

1816

LEAF_GEN(leaf),

fs/unicode/mkutf8data.c

1817

LEAF_CCC(leaf),

fs/unicode/mkutf8data.c

1818

LEAF_CCC(leaf) == DECOMPOSE ?

fs/unicode/mkutf8data.c

1819

LEAF_STR(leaf) : "");

fs/unicode/mkutf8data.c

2805

utf8leaf_t *leaf;

fs/unicode/mkutf8data.c

2814

leaf = utf8lookup(tree, hangul, s);

fs/unicode/mkutf8data.c

2815

if (!leaf)

fs/unicode/mkutf8data.c

2817

leaf_age = ages[LEAF_GEN(leaf)];

fs/unicode/mkutf8data.c

2832

utf8leaf_t *leaf;

fs/unicode/mkutf8data.c

2841

leaf = utf8lookup(tree, hangul, s);

fs/unicode/mkutf8data.c

2842

if (!leaf)

fs/unicode/mkutf8data.c

2844

leaf_age = ages[LEAF_GEN(leaf)];

fs/unicode/mkutf8data.c

2858

utf8leaf_t *leaf;

fs/unicode/mkutf8data.c

2867

leaf = utf8nlookup(tree, hangul, s, len);

fs/unicode/mkutf8data.c

2868

if (!leaf)

fs/unicode/mkutf8data.c

2870

leaf_age = ages[LEAF_GEN(leaf)];

fs/unicode/mkutf8data.c

2885

utf8leaf_t *leaf;

fs/unicode/mkutf8data.c

2894

leaf = utf8nlookup(tree, hangul, s, len);

fs/unicode/mkutf8data.c

2895

if (!leaf)

fs/unicode/mkutf8data.c

2897

leaf_age = ages[LEAF_GEN(leaf)];

fs/unicode/mkutf8data.c

2914

utf8leaf_t *leaf;

fs/unicode/mkutf8data.c

2921

leaf = utf8lookup(tree, hangul, s);

fs/unicode/mkutf8data.c

2922

if (!leaf)

fs/unicode/mkutf8data.c

2924

if (ages[LEAF_GEN(leaf)] > tree->maxage)

fs/unicode/mkutf8data.c

2926

else if (LEAF_CCC(leaf) == DECOMPOSE)

fs/unicode/mkutf8data.c

2927

ret += strlen(LEAF_STR(leaf));

fs/unicode/mkutf8data.c

2941

utf8leaf_t *leaf;

fs/unicode/mkutf8data.c

2948

leaf = utf8nlookup(tree, hangul, s, len);

fs/unicode/mkutf8data.c

2949

if (!leaf)

fs/unicode/mkutf8data.c

2951

if (ages[LEAF_GEN(leaf)] > tree->maxage)

fs/unicode/mkutf8data.c

2953

else if (LEAF_CCC(leaf) == DECOMPOSE)

fs/unicode/mkutf8data.c

2954

ret += strlen(LEAF_STR(leaf));

fs/unicode/mkutf8data.c

3059

utf8leaf_t *leaf;

fs/unicode/mkutf8data.c

3086

leaf = utf8lookup(u8c->tree, u8c->hangul, u8c->s);

fs/unicode/mkutf8data.c

3088

leaf = utf8nlookup(u8c->tree, u8c->hangul,

fs/unicode/mkutf8data.c

3093

if (!leaf)

fs/unicode/mkutf8data.c

3097

if (ages[LEAF_GEN(leaf)] > u8c->tree->maxage) {

fs/unicode/mkutf8data.c

3099

} else if ((ccc = LEAF_CCC(leaf)) == DECOMPOSE) {

fs/unicode/mkutf8data.c

3102

u8c->s = LEAF_STR(leaf);

fs/unicode/mkutf8data.c

3110

leaf = utf8lookup(u8c->tree, u8c->hangul, u8c->s);

fs/unicode/mkutf8data.c

3111

ccc = LEAF_CCC(leaf);

fs/unicode/mkutf8data.c

383

void *leaf = NULL;

fs/unicode/mkutf8data.c

386

while (!leaf && node) {

fs/unicode/mkutf8data.c

394

leaf = node->right;

fs/unicode/mkutf8data.c

403

leaf = node->left;

fs/unicode/mkutf8data.c

410

return leaf;

fs/unicode/mkutf8data.c

533

static int insert(struct tree *tree, char *key, int keylen, void *leaf)

fs/unicode/mkutf8data.c

559

*cursor = leaf;

fs/unicode/mkutf8data.c

577

leaf = node->left;

fs/unicode/mkutf8data.c

582

tree->root = leaf;

fs/unicode/mkutf8data.c

585

parent->left = leaf;

fs/unicode/mkutf8data.c

594

parent->right = leaf;

fs/unicode/utf8-norm.c

389

utf8leaf_t *leaf;

fs/unicode/utf8-norm.c

394

leaf = utf8nlookup(um, n, hangul, s, len);

fs/unicode/utf8-norm.c

395

if (!leaf)

fs/unicode/utf8-norm.c

397

if (um->tables->utf8agetab[LEAF_GEN(leaf)] >

fs/unicode/utf8-norm.c

400

else if (LEAF_CCC(leaf) == DECOMPOSE)

fs/unicode/utf8-norm.c

401

ret += strlen(LEAF_STR(leaf));

fs/unicode/utf8-norm.c

473

utf8leaf_t *leaf;

fs/unicode/utf8-norm.c

500

leaf = utf8lookup(u8c->um, u8c->n, u8c->hangul, u8c->s);

fs/unicode/utf8-norm.c

502

leaf = utf8nlookup(u8c->um, u8c->n, u8c->hangul,

fs/unicode/utf8-norm.c

507

if (!leaf)

fs/unicode/utf8-norm.c

510

ccc = LEAF_CCC(leaf);

fs/unicode/utf8-norm.c

512

if (u8c->um->tables->utf8agetab[LEAF_GEN(leaf)] >

fs/unicode/utf8-norm.c

518

u8c->s = LEAF_STR(leaf);

fs/unicode/utf8-norm.c

527

leaf = utf8lookup(u8c->um, u8c->n, u8c->hangul, u8c->s);

fs/unicode/utf8-norm.c

528

if (!leaf)

fs/unicode/utf8-norm.c

530

ccc = LEAF_CCC(leaf);

fs/xfs/libxfs/xfs_alloc_btree.c

554

bool leaf)

fs/xfs/libxfs/xfs_alloc_btree.c

556

if (leaf)

fs/xfs/libxfs/xfs_alloc_btree.c

568

bool leaf)

fs/xfs/libxfs/xfs_alloc_btree.c

571

return xfs_allocbt_block_maxrecs(blocklen, leaf);

fs/xfs/libxfs/xfs_alloc_btree.h

57

bool leaf);

fs/xfs/libxfs/xfs_attr_leaf.c

109

const struct xfs_attr_leafblock *leaf)

fs/xfs/libxfs/xfs_attr_leaf.c

1105

struct xfs_attr_leafblock *leaf;

fs/xfs/libxfs/xfs_attr_leaf.c

1113

leaf = bp->b_addr;

fs/xfs/libxfs/xfs_attr_leaf.c

1114

xfs_attr3_leaf_hdr_from_disk(mp->m_attr_geo, &leafhdr, leaf);

fs/xfs/libxfs/xfs_attr_leaf.c

1115

entry = xfs_attr3_leaf_entryp(leaf);

fs/xfs/libxfs/xfs_attr_leaf.c

112

xfs_attr_leaf_entries_end(ichdr->count, leaf);

fs/xfs/libxfs/xfs_attr_leaf.c

1123

name_loc = xfs_attr3_leaf_name_local(leaf, i);

fs/xfs/libxfs/xfs_attr_leaf.c

1214

struct xfs_attr_leafblock *leaf;

fs/xfs/libxfs/xfs_attr_leaf.c

1229

leaf = (xfs_attr_leafblock_t *)tmpbuffer;

fs/xfs/libxfs/xfs_attr_leaf.c

1230

xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr, leaf);

fs/xfs/libxfs/xfs_attr_leaf.c

1231

entry = xfs_attr3_leaf_entryp(leaf);

fs/xfs/libxfs/xfs_attr_leaf.c

1277

name_loc = xfs_attr3_leaf_name_local(leaf, i);

fs/xfs/libxfs/xfs_attr_leaf.c

1300

struct xfs_attr_leafblock *leaf;

fs/xfs/libxfs/xfs_attr_leaf.c

1345

leaf = bp2->b_addr;

fs/xfs/libxfs/xfs_attr_leaf.c

1346

xfs_attr3_leaf_hdr_from_disk(args->geo, &icleafhdr, leaf);

fs/xfs/libxfs/xfs_attr_leaf.c

1347

entries = xfs_attr3_leaf_entryp(leaf);

fs/xfs/libxfs/xfs_attr_leaf.c

1374

struct xfs_attr_leafblock *leaf;

fs/xfs/libxfs/xfs_attr_leaf.c

1389

leaf = bp->b_addr;

fs/xfs/libxfs/xfs_attr_leaf.c

1390

memset(leaf, 0, args->geo->blksize);

fs/xfs/libxfs/xfs_attr_leaf.c

1411

xfs_attr3_leaf_hdr_to_disk(args->geo, leaf, &ichdr);

fs/xfs/libxfs/xfs_attr_leaf.c

1513

struct xfs_attr_leafblock *leaf;

fs/xfs/libxfs/xfs_attr_leaf.c

1524

leaf = bp->b_addr;

fs/xfs/libxfs/xfs_attr_leaf.c

1525

xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr, leaf);

fs/xfs/libxfs/xfs_attr_leaf.c

1533

tablesize = xfs_attr_leaf_entries_end(ichdr.count + 1, leaf);

fs/xfs/libxfs/xfs_attr_leaf.c

1577

xfs_attr3_leaf_hdr_to_disk(args->geo, leaf, &ichdr);

fs/xfs/libxfs/xfs_attr_leaf.c

1579

XFS_DA_LOGRANGE(leaf, &leaf->hdr,

fs/xfs/libxfs/xfs_attr_leaf.c

1580

xfs_attr3_leaf_hdr_size(leaf)));

fs/xfs/libxfs/xfs_attr_leaf.c

1594

struct xfs_attr_leafblock *leaf;

fs/xfs/libxfs/xfs_attr_leaf.c

1605

leaf = bp->b_addr;

fs/xfs/libxfs/xfs_attr_leaf.c

1612

entry = &xfs_attr3_leaf_entryp(leaf)[args->index];

fs/xfs/libxfs/xfs_attr_leaf.c

1618

XFS_DA_LOGRANGE(leaf, entry, tmp + sizeof(*entry)));

fs/xfs/libxfs/xfs_attr_leaf.c

1650

XFS_DA_LOGRANGE(leaf, entry, sizeof(*entry)));

fs/xfs/libxfs/xfs_attr_leaf.c

1664

name_loc = xfs_attr3_leaf_name_local(leaf, args->index);

fs/xfs/libxfs/xfs_attr_leaf.c

1671

name_rmt = xfs_attr3_leaf_name_remote(leaf, args->index);

fs/xfs/libxfs/xfs_attr_leaf.c

1683

XFS_DA_LOGRANGE(leaf, xfs_attr3_leaf_name(leaf, args->index),

fs/xfs/libxfs/xfs_attr_leaf.c

1684

xfs_attr_leaf_entsize(leaf, args->index)));

fs/xfs/libxfs/xfs_attr_leaf.c

1692

new_end = xfs_attr_leaf_entries_end(ichdr->count, leaf);

fs/xfs/libxfs/xfs_attr_leaf.c

1736

ichdr->usedbytes += xfs_attr_leaf_entsize(leaf, args->index);

fs/xfs/libxfs/xfs_attr_leaf.c

2148

struct xfs_attr_leafblock *leaf;

fs/xfs/libxfs/xfs_attr_leaf.c

2167

leaf = blk->bp->b_addr;

fs/xfs/libxfs/xfs_attr_leaf.c

2168

xfs_attr3_leaf_hdr_from_disk(state->args->geo, &ichdr, leaf);

fs/xfs/libxfs/xfs_attr_leaf.c

2169

bytes = xfs_attr_leaf_entries_end(ichdr.count, leaf) + ichdr.usedbytes;

fs/xfs/libxfs/xfs_attr_leaf.c

2228

leaf);

fs/xfs/libxfs/xfs_attr_leaf.c

2272

struct xfs_attr_leafblock *leaf;

fs/xfs/libxfs/xfs_attr_leaf.c

2285

leaf = bp->b_addr;

fs/xfs/libxfs/xfs_attr_leaf.c

2286

xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr, leaf);

fs/xfs/libxfs/xfs_attr_leaf.c

2290

ASSERT(ichdr.firstused >= xfs_attr_leaf_entries_end(ichdr.count, leaf));

fs/xfs/libxfs/xfs_attr_leaf.c

2292

entry = &xfs_attr3_leaf_entryp(leaf)[args->index];

fs/xfs/libxfs/xfs_attr_leaf.c

2303

tablesize = xfs_attr_leaf_entries_end(ichdr.count, leaf);

fs/xfs/libxfs/xfs_attr_leaf.c

2307

entsize = xfs_attr_leaf_entsize(leaf, args->index);

fs/xfs/libxfs/xfs_attr_leaf.c

2365

memset(xfs_attr3_leaf_name(leaf, args->index), 0, entsize);

fs/xfs/libxfs/xfs_attr_leaf.c

2368

XFS_DA_LOGRANGE(leaf, xfs_attr3_leaf_name(leaf, args->index),

fs/xfs/libxfs/xfs_attr_leaf.c

2375

XFS_DA_LOGRANGE(leaf, entry, tmp + sizeof(xfs_attr_leaf_entry_t)));

fs/xfs/libxfs/xfs_attr_leaf.c

2377

entry = &xfs_attr3_leaf_entryp(leaf)[ichdr.count];

fs/xfs/libxfs/xfs_attr_leaf.c

2388

entry = xfs_attr3_leaf_entryp(leaf);

fs/xfs/libxfs/xfs_attr_leaf.c

2401

xfs_attr3_leaf_hdr_to_disk(args->geo, leaf, &ichdr);

fs/xfs/libxfs/xfs_attr_leaf.c

2403

XFS_DA_LOGRANGE(leaf, &leaf->hdr,

fs/xfs/libxfs/xfs_attr_leaf.c

2404

xfs_attr3_leaf_hdr_size(leaf)));

fs/xfs/libxfs/xfs_attr_leaf.c

2410

tmp = ichdr.usedbytes + xfs_attr_leaf_entries_end(ichdr.count, leaf);

fs/xfs/libxfs/xfs_attr_leaf.c

2548

struct xfs_attr_leafblock *leaf;

fs/xfs/libxfs/xfs_attr_leaf.c

2560

leaf = bp->b_addr;

fs/xfs/libxfs/xfs_attr_leaf.c

2561

xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr, leaf);

fs/xfs/libxfs/xfs_attr_leaf.c

2562

entries = xfs_attr3_leaf_entryp(leaf);

fs/xfs/libxfs/xfs_attr_leaf.c

2621

name_loc = xfs_attr3_leaf_name_local(leaf, probe);

fs/xfs/libxfs/xfs_attr_leaf.c

2632

name_rmt = xfs_attr3_leaf_name_remote(leaf, probe);

fs/xfs/libxfs/xfs_attr_leaf.c

2663

struct xfs_attr_leafblock *leaf;

fs/xfs/libxfs/xfs_attr_leaf.c

2669

leaf = bp->b_addr;

fs/xfs/libxfs/xfs_attr_leaf.c

2670

xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr, leaf);

fs/xfs/libxfs/xfs_attr_leaf.c

2674

entry = &xfs_attr3_leaf_entryp(leaf)[args->index];

fs/xfs/libxfs/xfs_attr_leaf.c

2676

name_loc = xfs_attr3_leaf_name_local(leaf, args->index);

fs/xfs/libxfs/xfs_attr_leaf.c

2684

name_rmt = xfs_attr3_leaf_name_remote(leaf, args->index);

fs/xfs/libxfs/xfs_attr_leaf.c

2869

xfs_attr_leaf_entsize(xfs_attr_leafblock_t *leaf, int index)

fs/xfs/libxfs/xfs_attr_leaf.c

2876

entries = xfs_attr3_leaf_entryp(leaf);

fs/xfs/libxfs/xfs_attr_leaf.c

2878

name_loc = xfs_attr3_leaf_name_local(leaf, index);

fs/xfs/libxfs/xfs_attr_leaf.c

2882

name_rmt = xfs_attr3_leaf_name_remote(leaf, index);

fs/xfs/libxfs/xfs_attr_leaf.c

2924

struct xfs_attr_leafblock *leaf;

fs/xfs/libxfs/xfs_attr_leaf.c

2945

leaf = bp->b_addr;

fs/xfs/libxfs/xfs_attr_leaf.c

2946

entry = &xfs_attr3_leaf_entryp(leaf)[args->index];

fs/xfs/libxfs/xfs_attr_leaf.c

2950

xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr, leaf);

fs/xfs/libxfs/xfs_attr_leaf.c

2955

name_loc = xfs_attr3_leaf_name_local(leaf, args->index);

fs/xfs/libxfs/xfs_attr_leaf.c

2959

name_rmt = xfs_attr3_leaf_name_remote(leaf, args->index);

fs/xfs/libxfs/xfs_attr_leaf.c

2970

XFS_DA_LOGRANGE(leaf, entry, sizeof(*entry)));

fs/xfs/libxfs/xfs_attr_leaf.c

2974

name_rmt = xfs_attr3_leaf_name_remote(leaf, args->index);

fs/xfs/libxfs/xfs_attr_leaf.c

2978

XFS_DA_LOGRANGE(leaf, name_rmt, sizeof(*name_rmt)));

fs/xfs/libxfs/xfs_attr_leaf.c

299

struct xfs_attr_leafblock *leaf,

fs/xfs/libxfs/xfs_attr_leaf.c

2991

struct xfs_attr_leafblock *leaf;

fs/xfs/libxfs/xfs_attr_leaf.c

3010

leaf = bp->b_addr;

fs/xfs/libxfs/xfs_attr_leaf.c

3012

xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr, leaf);

fs/xfs/libxfs/xfs_attr_leaf.c

3016

entry = &xfs_attr3_leaf_entryp(leaf)[args->index];

fs/xfs/libxfs/xfs_attr_leaf.c

3021

XFS_DA_LOGRANGE(leaf, entry, sizeof(*entry)));

fs/xfs/libxfs/xfs_attr_leaf.c

3023

name_rmt = xfs_attr3_leaf_name_remote(leaf, args->index);

fs/xfs/libxfs/xfs_attr_leaf.c

3027

XFS_DA_LOGRANGE(leaf, name_rmt, sizeof(*name_rmt)));

fs/xfs/libxfs/xfs_attr_leaf.c

327

lentry = xfs_attr3_leaf_name_local(leaf, idx);

fs/xfs/libxfs/xfs_attr_leaf.c

334

rentry = xfs_attr3_leaf_name_remote(leaf, idx);

fs/xfs/libxfs/xfs_attr_leaf.c

373

struct xfs_attr_leafblock *leaf = bp->b_addr;

fs/xfs/libxfs/xfs_attr_leaf.c

382

xfs_attr3_leaf_hdr_from_disk(mp->m_attr_geo, &ichdr, leaf);

fs/xfs/libxfs/xfs_attr_leaf.c

394

if (ichdr.firstused < xfs_attr3_leaf_hdr_size(leaf))

fs/xfs/libxfs/xfs_attr_leaf.c

412

fa = xfs_attr3_leaf_verify_entry(mp, buf_end, leaf, &ichdr,

fs/xfs/libxfs/xfs_attr_leaf.c

445

fa = xfs_attr_leaf_ichdr_freemaps_verify(&ichdr, leaf);

fs/xfs/libxfs/xfs_attr_leaf.c

76

STATIC int xfs_attr_leaf_entsize(xfs_attr_leafblock_t *leaf, int index);

fs/xfs/libxfs/xfs_attr_leaf.c

82

const struct xfs_attr_leafblock *leaf)

fs/xfs/libxfs/xfs_attr_leaf.c

85

xfs_attr3_leaf_hdr_size(leaf);

fs/xfs/libxfs/xfs_attr_leaf.h

77

int xfs_attr3_leaf_lookup_int(struct xfs_buf *leaf,

fs/xfs/libxfs/xfs_bmap_btree.c

694

bool leaf)

fs/xfs/libxfs/xfs_bmap_btree.c

696

if (leaf)

fs/xfs/libxfs/xfs_bmap_btree.c

751

bool leaf)

fs/xfs/libxfs/xfs_bmap_btree.c

754

return xfs_bmbt_block_maxrecs(blocklen, leaf);

fs/xfs/libxfs/xfs_bmap_btree.c

785

int leaf)

fs/xfs/libxfs/xfs_bmap_btree.c

789

if (leaf)

fs/xfs/libxfs/xfs_bmap_btree.h

37

extern int xfs_bmdr_maxrecs(int blocklen, int leaf);

fs/xfs/libxfs/xfs_bmap_btree.h

39

bool leaf);

fs/xfs/libxfs/xfs_da_btree.c

735

struct xfs_dir2_leaf *leaf;

fs/xfs/libxfs/xfs_da_btree.c

770

leaf = (xfs_dir2_leaf_t *)oldroot;

fs/xfs/libxfs/xfs_da_btree.c

771

xfs_dir2_leaf_hdr_from_disk(dp->i_mount, &leafhdr, leaf);

fs/xfs/libxfs/xfs_da_btree.c

776

(char *)leaf);

fs/xfs/libxfs/xfs_dir2_block.c

941

xfs_dir2_leaf_t *leaf; /* leaf structure */

fs/xfs/libxfs/xfs_dir2_block.c

959

leaf = lbp->b_addr;

fs/xfs/libxfs/xfs_dir2_block.c

960

xfs_dir2_leaf_hdr_from_disk(mp, &leafhdr, leaf);

fs/xfs/libxfs/xfs_dir2_block.c

961

ltp = xfs_dir2_leaf_tail_p(args->geo, leaf);

fs/xfs/libxfs/xfs_dir2_leaf.c

1011

xfs_dir2_leaf_hdr_to_disk(dp->i_mount, leaf, leafhdr);

fs/xfs/libxfs/xfs_dir2_leaf.c

105

struct xfs_dir2_leaf *leaf = bp->b_addr;

fs/xfs/libxfs/xfs_dir2_leaf.c

108

xfs_dir2_leaf_hdr_from_disk(dp->i_mount, &leafhdr, leaf);

fs/xfs/libxfs/xfs_dir2_leaf.c

1123

struct xfs_dir2_leaf *leaf = bp->b_addr;

fs/xfs/libxfs/xfs_dir2_leaf.c

1126

ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAF1_MAGIC) ||

fs/xfs/libxfs/xfs_dir2_leaf.c

1127

leaf->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAF1_MAGIC));

fs/xfs/libxfs/xfs_dir2_leaf.c

1129

ltp = xfs_dir2_leaf_tail_p(args->geo, leaf);

fs/xfs/libxfs/xfs_dir2_leaf.c

1133

(uint)((char *)firstb - (char *)leaf),

fs/xfs/libxfs/xfs_dir2_leaf.c

1134

(uint)((char *)lastb - (char *)leaf + sizeof(*lastb) - 1));

fs/xfs/libxfs/xfs_dir2_leaf.c

1150

struct xfs_dir2_leaf *leaf = bp->b_addr;

fs/xfs/libxfs/xfs_dir2_leaf.c

1152

ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAF1_MAGIC) ||

fs/xfs/libxfs/xfs_dir2_leaf.c

1153

leaf->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAF1_MAGIC) ||

fs/xfs/libxfs/xfs_dir2_leaf.c

1154

leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC) ||

fs/xfs/libxfs/xfs_dir2_leaf.c

1155

leaf->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAFN_MAGIC));

fs/xfs/libxfs/xfs_dir2_leaf.c

1160

(uint)((char *)firstlep - (char *)leaf),

fs/xfs/libxfs/xfs_dir2_leaf.c

1161

(uint)((char *)lastlep - (char *)leaf + sizeof(*lastlep) - 1));

fs/xfs/libxfs/xfs_dir2_leaf.c

117

return xfs_dir3_leaf_check_int(dp->i_mount, &leafhdr, leaf, false);

fs/xfs/libxfs/xfs_dir2_leaf.c

1172

struct xfs_dir2_leaf *leaf = bp->b_addr;

fs/xfs/libxfs/xfs_dir2_leaf.c

1174

ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAF1_MAGIC) ||

fs/xfs/libxfs/xfs_dir2_leaf.c

1175

leaf->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAF1_MAGIC) ||

fs/xfs/libxfs/xfs_dir2_leaf.c

1176

leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC) ||

fs/xfs/libxfs/xfs_dir2_leaf.c

1177

leaf->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAFN_MAGIC));

fs/xfs/libxfs/xfs_dir2_leaf.c

1180

(uint)((char *)&leaf->hdr - (char *)leaf),

fs/xfs/libxfs/xfs_dir2_leaf.c

1192

struct xfs_dir2_leaf *leaf = bp->b_addr;

fs/xfs/libxfs/xfs_dir2_leaf.c

1195

ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAF1_MAGIC) ||

fs/xfs/libxfs/xfs_dir2_leaf.c

1196

leaf->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAF1_MAGIC) ||

fs/xfs/libxfs/xfs_dir2_leaf.c

1197

leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC) ||

fs/xfs/libxfs/xfs_dir2_leaf.c

1198

leaf->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAFN_MAGIC));

fs/xfs/libxfs/xfs_dir2_leaf.c

1200

ltp = xfs_dir2_leaf_tail_p(args->geo, leaf);

fs/xfs/libxfs/xfs_dir2_leaf.c

1201

xfs_trans_log_buf(args->trans, bp, (uint)((char *)ltp - (char *)leaf),

fs/xfs/libxfs/xfs_dir2_leaf.c

1281

xfs_dir2_leaf_t *leaf; /* leaf structure */

fs/xfs/libxfs/xfs_dir2_leaf.c

1298

leaf = lbp->b_addr;

fs/xfs/libxfs/xfs_dir2_leaf.c

1300

xfs_dir2_leaf_hdr_from_disk(mp, leafhdr, leaf);

fs/xfs/libxfs/xfs_dir2_leaf.c

1412

xfs_dir2_leaf_t *leaf; /* leaf structure */

fs/xfs/libxfs/xfs_dir2_leaf.c

143

struct xfs_dir2_leaf *leaf,

fs/xfs/libxfs/xfs_dir2_leaf.c

1431

leaf = lbp->b_addr;

fs/xfs/libxfs/xfs_dir2_leaf.c

1445

ltp = xfs_dir2_leaf_tail_p(geo, leaf);

fs/xfs/libxfs/xfs_dir2_leaf.c

1464

xfs_dir2_leaf_hdr_to_disk(dp->i_mount, leaf, &leafhdr);

fs/xfs/libxfs/xfs_dir2_leaf.c

153

ltp = xfs_dir2_leaf_tail_p(geo, leaf);

fs/xfs/libxfs/xfs_dir2_leaf.c

1660

xfs_dir2_leaf_t *leaf; /* leaf structure */

fs/xfs/libxfs/xfs_dir2_leaf.c

1674

leaf = lbp->b_addr;

fs/xfs/libxfs/xfs_dir2_leaf.c

1675

ltp = xfs_dir2_leaf_tail_p(geo, leaf);

fs/xfs/libxfs/xfs_dir2_leaf.c

1746

xfs_dir2_leaf_t *leaf; /* leaf structure */

fs/xfs/libxfs/xfs_dir2_leaf.c

1800

leaf = lbp->b_addr;

fs/xfs/libxfs/xfs_dir2_leaf.c

1801

xfs_dir2_leaf_hdr_from_disk(mp, &leafhdr, leaf);

fs/xfs/libxfs/xfs_dir2_leaf.c

1841

ltp = xfs_dir2_leaf_tail_p(args->geo, leaf);

fs/xfs/libxfs/xfs_dir2_leaf.c

1850

xfs_dir2_leaf_hdr_to_disk(mp, leaf, &leafhdr);

fs/xfs/libxfs/xfs_dir2_leaf.c

364

struct xfs_dir2_leaf *leaf = bp->b_addr;

fs/xfs/libxfs/xfs_dir2_leaf.c

380

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

fs/xfs/libxfs/xfs_dir2_leaf.c

381

leaf->hdr.info.magic = cpu_to_be16(type);

fs/xfs/libxfs/xfs_dir2_leaf.c

391

ltp = xfs_dir2_leaf_tail_p(mp->m_dir_geo, leaf);

fs/xfs/libxfs/xfs_dir2_leaf.c

447

xfs_dir2_leaf_t *leaf; /* leaf structure */

fs/xfs/libxfs/xfs_dir2_leaf.c

476

leaf = lbp->b_addr;

fs/xfs/libxfs/xfs_dir2_leaf.c

486

xfs_dir2_leaf_hdr_from_disk(dp->i_mount, &leafhdr, leaf);

fs/xfs/libxfs/xfs_dir2_leaf.c

489

xfs_dir2_leaf_hdr_to_disk(dp->i_mount, leaf, &leafhdr);

fs/xfs/libxfs/xfs_dir2_leaf.c

525

ltp = xfs_dir2_leaf_tail_p(args->geo, leaf);

fs/xfs/libxfs/xfs_dir2_leaf.c

674

struct xfs_dir2_leaf *leaf; /* leaf structure */

fs/xfs/libxfs/xfs_dir2_leaf.c

712

leaf = lbp->b_addr;

fs/xfs/libxfs/xfs_dir2_leaf.c

713

ltp = xfs_dir2_leaf_tail_p(args->geo, leaf);

fs/xfs/libxfs/xfs_dir2_leaf.c

714

xfs_dir2_leaf_hdr_from_disk(dp->i_mount, &leafhdr, leaf);

fs/xfs/libxfs/xfs_dir2_leaf.c

959

xfs_dir2_leaf_hdr_to_disk(dp->i_mount, leaf, &leafhdr);

fs/xfs/libxfs/xfs_dir2_leaf.c

978

xfs_dir2_leaf_t *leaf; /* leaf structure */

fs/xfs/libxfs/xfs_dir2_leaf.c

983

leaf = bp->b_addr;

fs/xfs/libxfs/xfs_dir2_node.c

1284

xfs_dir2_leaf_t *leaf; /* leaf structure */

fs/xfs/libxfs/xfs_dir2_node.c

1298

leaf = bp->b_addr;

fs/xfs/libxfs/xfs_dir2_node.c

1299

xfs_dir2_leaf_hdr_from_disk(dp->i_mount, &leafhdr, leaf);

fs/xfs/libxfs/xfs_dir2_node.c

1319

xfs_dir2_leaf_hdr_to_disk(dp->i_mount, leaf, &leafhdr);

fs/xfs/libxfs/xfs_dir2_node.c

1506

xfs_dir2_leaf_t *leaf; /* leaf structure */

fs/xfs/libxfs/xfs_dir2_node.c

1518

leaf = blk->bp->b_addr;

fs/xfs/libxfs/xfs_dir2_node.c

1519

xfs_dir2_leaf_hdr_from_disk(dp->i_mount, &leafhdr, leaf);

fs/xfs/libxfs/xfs_dir2_node.c

1581

leaf = bp->b_addr;

fs/xfs/libxfs/xfs_dir2_node.c

1582

xfs_dir2_leaf_hdr_from_disk(dp->i_mount, &hdr2, leaf);

fs/xfs/libxfs/xfs_dir2_node.c

421

xfs_dir2_leaf_t *leaf; /* leaf structure */

fs/xfs/libxfs/xfs_dir2_node.c

447

leaf = lbp->b_addr;

fs/xfs/libxfs/xfs_dir2_node.c

448

ltp = xfs_dir2_leaf_tail_p(args->geo, leaf);

fs/xfs/libxfs/xfs_dir2_node.c

484

if (leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAF1_MAGIC))

fs/xfs/libxfs/xfs_dir2_node.c

485

leaf->hdr.info.magic = cpu_to_be16(XFS_DIR2_LEAFN_MAGIC);

fs/xfs/libxfs/xfs_dir2_node.c

487

leaf->hdr.info.magic = cpu_to_be16(XFS_DIR3_LEAFN_MAGIC);

fs/xfs/libxfs/xfs_dir2_node.c

507

struct xfs_dir2_leaf *leaf = bp->b_addr;

fs/xfs/libxfs/xfs_dir2_node.c

518

xfs_dir2_leaf_hdr_from_disk(dp->i_mount, &leafhdr, leaf);

fs/xfs/libxfs/xfs_dir2_node.c

576

xfs_dir2_leaf_hdr_to_disk(dp->i_mount, leaf, &leafhdr);

fs/xfs/libxfs/xfs_dir2_node.c

647

xfs_dir2_leaf_t *leaf; /* leaf structure */

fs/xfs/libxfs/xfs_dir2_node.c

65

struct xfs_dir2_leaf *leaf = bp->b_addr;

fs/xfs/libxfs/xfs_dir2_node.c

659

leaf = bp->b_addr;

fs/xfs/libxfs/xfs_dir2_node.c

660

xfs_dir2_leaf_hdr_from_disk(mp, &leafhdr, leaf);

fs/xfs/libxfs/xfs_dir2_node.c

68

xfs_dir2_leaf_hdr_from_disk(dp->i_mount, &leafhdr, leaf);

fs/xfs/libxfs/xfs_dir2_node.c

77

return xfs_dir3_leaf_check_int(dp->i_mount, &leafhdr, leaf, false);

fs/xfs/libxfs/xfs_dir2_node.c

799

xfs_dir2_leaf_t *leaf; /* leaf structure */

fs/xfs/libxfs/xfs_dir2_node.c

810

leaf = bp->b_addr;

fs/xfs/libxfs/xfs_dir2_node.c

811

xfs_dir2_leaf_hdr_from_disk(mp, &leafhdr, leaf);

fs/xfs/libxfs/xfs_dir2_priv.h

131

struct xfs_dir3_icleaf_hdr *hdr, struct xfs_dir2_leaf *leaf,

fs/xfs/libxfs/xfs_ialloc_btree.c

566

bool leaf)

fs/xfs/libxfs/xfs_ialloc_btree.c

568

if (leaf)

fs/xfs/libxfs/xfs_ialloc_btree.c

580

bool leaf)

fs/xfs/libxfs/xfs_ialloc_btree.c

583

return xfs_inobt_block_maxrecs(blocklen, leaf);

fs/xfs/libxfs/xfs_ialloc_btree.h

54

bool leaf);

fs/xfs/libxfs/xfs_iext_tree.c

1011

new->br_startoff, 1, cur->leaf);

fs/xfs/libxfs/xfs_iext_tree.c

142

return &cur->leaf->recs[cur->pos];

fs/xfs/libxfs/xfs_iext_tree.c

148

if (!cur->leaf)

fs/xfs/libxfs/xfs_iext_tree.c

202

cur->leaf = xfs_iext_find_first_leaf(ifp);

fs/xfs/libxfs/xfs_iext_tree.c

212

cur->leaf = xfs_iext_find_last_leaf(ifp);

fs/xfs/libxfs/xfs_iext_tree.c

213

if (!cur->leaf) {

fs/xfs/libxfs/xfs_iext_tree.c

219

if (xfs_iext_rec_is_empty(&cur->leaf->recs[i]))

fs/xfs/libxfs/xfs_iext_tree.c

230

if (!cur->leaf) {

fs/xfs/libxfs/xfs_iext_tree.c

241

cur->leaf->next) {

fs/xfs/libxfs/xfs_iext_tree.c

242

cur->leaf = cur->leaf->next;

fs/xfs/libxfs/xfs_iext_tree.c

252

if (!cur->leaf) {

fs/xfs/libxfs/xfs_iext_tree.c

268

if (ifp->if_height > 1 && cur->leaf->prev) {

fs/xfs/libxfs/xfs_iext_tree.c

269

cur->leaf = cur->leaf->prev;

fs/xfs/libxfs/xfs_iext_tree.c

376

struct xfs_iext_leaf *leaf,

fs/xfs/libxfs/xfs_iext_tree.c

382

if (xfs_iext_rec_is_empty(&leaf->recs[i]))

fs/xfs/libxfs/xfs_iext_tree.c

391

struct xfs_iext_leaf *leaf,

fs/xfs/libxfs/xfs_iext_tree.c

394

return leaf->recs[n].lo & XFS_IEXT_STARTOFF_MASK;

fs/xfs/libxfs/xfs_iext_tree.c

551

struct xfs_iext_leaf *leaf = cur->leaf;

fs/xfs/libxfs/xfs_iext_tree.c

559

cur->leaf = new;

fs/xfs/libxfs/xfs_iext_tree.c

566

new->recs[i] = leaf->recs[nr_keep + i];

fs/xfs/libxfs/xfs_iext_tree.c

567

xfs_iext_rec_clear(&leaf->recs[nr_keep + i]);

fs/xfs/libxfs/xfs_iext_tree.c

571

cur->leaf = new;

fs/xfs/libxfs/xfs_iext_tree.c

578

if (leaf->next)

fs/xfs/libxfs/xfs_iext_tree.c

579

leaf->next->prev = new;

fs/xfs/libxfs/xfs_iext_tree.c

580

new->next = leaf->next;

fs/xfs/libxfs/xfs_iext_tree.c

581

new->prev = leaf;

fs/xfs/libxfs/xfs_iext_tree.c

582

leaf->next = new;

fs/xfs/libxfs/xfs_iext_tree.c

597

cur->leaf = ifp->if_data;

fs/xfs/libxfs/xfs_iext_tree.c

617

cur->leaf = new;

fs/xfs/libxfs/xfs_iext_tree.c

649

nr_entries = xfs_iext_leaf_nr_entries(ifp, cur->leaf, cur->pos);

fs/xfs/libxfs/xfs_iext_tree.c

661

if (cur->leaf != new && cur->pos == 0 && nr_entries > 0) {

fs/xfs/libxfs/xfs_iext_tree.c

662

xfs_iext_update_node(ifp, xfs_iext_leaf_key(cur->leaf, 0),

fs/xfs/libxfs/xfs_iext_tree.c

663

offset, 1, cur->leaf);

fs/xfs/libxfs/xfs_iext_tree.c

667

cur->leaf->recs[i] = cur->leaf->recs[i - 1];

fs/xfs/libxfs/xfs_iext_tree.c

808

struct xfs_iext_leaf *leaf,

fs/xfs/libxfs/xfs_iext_tree.c

820

if (leaf->prev) {

fs/xfs/libxfs/xfs_iext_tree.c

821

int nr_prev = xfs_iext_leaf_nr_entries(ifp, leaf->prev, 0), i;

fs/xfs/libxfs/xfs_iext_tree.c

825

leaf->prev->recs[nr_prev + i] = leaf->recs[i];

fs/xfs/libxfs/xfs_iext_tree.c

827

if (cur->leaf == leaf) {

fs/xfs/libxfs/xfs_iext_tree.c

828

cur->leaf = leaf->prev;

fs/xfs/libxfs/xfs_iext_tree.c

835

if (leaf->next) {

fs/xfs/libxfs/xfs_iext_tree.c

836

int nr_next = xfs_iext_leaf_nr_entries(ifp, leaf->next, 0), i;

fs/xfs/libxfs/xfs_iext_tree.c

845

leaf->recs[nr_entries + i] =

fs/xfs/libxfs/xfs_iext_tree.c

846

leaf->next->recs[i];

fs/xfs/libxfs/xfs_iext_tree.c

849

if (cur->leaf == leaf->next) {

fs/xfs/libxfs/xfs_iext_tree.c

850

cur->leaf = leaf;

fs/xfs/libxfs/xfs_iext_tree.c

854

offset = xfs_iext_leaf_key(leaf->next, 0);

fs/xfs/libxfs/xfs_iext_tree.c

855

leaf = leaf->next;

fs/xfs/libxfs/xfs_iext_tree.c

862

if (leaf->prev)

fs/xfs/libxfs/xfs_iext_tree.c

863

leaf->prev->next = leaf->next;

fs/xfs/libxfs/xfs_iext_tree.c

864

if (leaf->next)

fs/xfs/libxfs/xfs_iext_tree.c

865

leaf->next->prev = leaf->prev;

fs/xfs/libxfs/xfs_iext_tree.c

866

xfs_iext_remove_node(ifp, offset, leaf);

fs/xfs/libxfs/xfs_iext_tree.c

885

struct xfs_iext_leaf *leaf = cur->leaf;

fs/xfs/libxfs/xfs_iext_tree.c

886

xfs_fileoff_t offset = xfs_iext_leaf_key(leaf, 0);

fs/xfs/libxfs/xfs_iext_tree.c

897

nr_entries = xfs_iext_leaf_nr_entries(ifp, leaf, cur->pos) - 1;

fs/xfs/libxfs/xfs_iext_tree.c

899

leaf->recs[i] = leaf->recs[i + 1];

fs/xfs/libxfs/xfs_iext_tree.c

900

xfs_iext_rec_clear(&leaf->recs[nr_entries]);

fs/xfs/libxfs/xfs_iext_tree.c

904

xfs_iext_update_node(ifp, offset, xfs_iext_leaf_key(leaf, 0), 1,

fs/xfs/libxfs/xfs_iext_tree.c

905

leaf);

fs/xfs/libxfs/xfs_iext_tree.c

906

offset = xfs_iext_leaf_key(leaf, 0);

fs/xfs/libxfs/xfs_iext_tree.c

908

if (ifp->if_height > 1 && leaf->next)

fs/xfs/libxfs/xfs_iext_tree.c

909

cur->leaf = leaf->next;

fs/xfs/libxfs/xfs_iext_tree.c

911

cur->leaf = NULL;

fs/xfs/libxfs/xfs_iext_tree.c

919

xfs_iext_rebalance_leaf(ifp, cur, leaf, offset, nr_entries);

fs/xfs/libxfs/xfs_iext_tree.c

945

cur->leaf = xfs_iext_find_level(ifp, offset, 1);

fs/xfs/libxfs/xfs_iext_tree.c

946

if (!cur->leaf) {

fs/xfs/libxfs/xfs_iext_tree.c

961

if (ifp->if_height == 1 || !cur->leaf->next)

fs/xfs/libxfs/xfs_iext_tree.c

963

cur->leaf = cur->leaf->next;

fs/xfs/libxfs/xfs_refcount_btree.c

408

bool leaf)

fs/xfs/libxfs/xfs_refcount_btree.c

410

if (leaf)

fs/xfs/libxfs/xfs_refcount_btree.c

423

bool leaf)

fs/xfs/libxfs/xfs_refcount_btree.c

426

return xfs_refcountbt_block_maxrecs(blocklen, leaf);

fs/xfs/libxfs/xfs_refcount_btree.h

52

bool leaf);

fs/xfs/libxfs/xfs_rmap_btree.c

535

bool leaf)

fs/xfs/libxfs/xfs_rmap_btree.c

537

if (leaf)

fs/xfs/libxfs/xfs_rmap_btree.c

702

bool leaf)

fs/xfs/libxfs/xfs_rmap_btree.c

704

if (leaf)

fs/xfs/libxfs/xfs_rmap_btree.c

717

bool leaf)

fs/xfs/libxfs/xfs_rmap_btree.c

720

return xfs_rmapbt_block_maxrecs(blocklen, leaf);

fs/xfs/libxfs/xfs_rmap_btree.h

51

bool leaf);

fs/xfs/libxfs/xfs_rtrefcount_btree.c

458

bool leaf)

fs/xfs/libxfs/xfs_rtrefcount_btree.c

461

if (leaf)

fs/xfs/libxfs/xfs_rtrefcount_btree.c

474

bool leaf)

fs/xfs/libxfs/xfs_rtrefcount_btree.c

477

return xfs_rtrefcountbt_block_maxrecs(blocklen, leaf);

fs/xfs/libxfs/xfs_rtrefcount_btree.c

87

bool leaf)

fs/xfs/libxfs/xfs_rtrefcount_btree.c

91

if (leaf)

fs/xfs/libxfs/xfs_rtrefcount_btree.h

26

unsigned int blocklen, bool leaf);

fs/xfs/libxfs/xfs_rtrefcount_btree.h

28

unsigned int xfs_rtrefcountbt_droot_maxrecs(unsigned int blocklen, bool leaf);

fs/xfs/libxfs/xfs_rtrmap_btree.c

675

bool leaf)

fs/xfs/libxfs/xfs_rtrmap_btree.c

677

if (leaf)

fs/xfs/libxfs/xfs_rtrmap_btree.c

690

bool leaf)

fs/xfs/libxfs/xfs_rtrmap_btree.c

693

return xfs_rtrmapbt_block_maxrecs(blocklen, leaf);

fs/xfs/libxfs/xfs_rtrmap_btree.c

87

bool leaf)

fs/xfs/libxfs/xfs_rtrmap_btree.c

91

if (leaf)

fs/xfs/libxfs/xfs_rtrmap_btree.h

27

bool leaf);

fs/xfs/libxfs/xfs_rtrmap_btree.h

29

unsigned int xfs_rtrmapbt_droot_maxrecs(unsigned int blocklen, bool leaf);

fs/xfs/libxfs/xfs_types.h

146

struct xfs_iext_leaf *leaf;

fs/xfs/scrub/attr.c

299

struct xfs_attr_leafblock *leaf,

fs/xfs/scrub/attr.c

331

lentry = xfs_attr3_leaf_name_local(leaf, idx);

fs/xfs/scrub/attr.c

338

rentry = xfs_attr3_leaf_name_remote(leaf, idx);

fs/xfs/scrub/attr.c

367

struct xfs_attr_leafblock *leaf = bp->b_addr;

fs/xfs/scrub/attr.c

393

if (leaf->hdr.pad1 != 0 || leaf->hdr.info.pad != 0)

fs/xfs/scrub/attr.c

398

xfs_attr3_leaf_hdr_from_disk(mp->m_attr_geo, &leafhdr, leaf);

fs/xfs/scrub/attr.c

399

hdrsize = xfs_attr3_leaf_hdr_size(leaf);

fs/xfs/scrub/attr.c

426

entries = xfs_attr3_leaf_entryp(leaf);

fs/xfs/scrub/attr.c

427

if ((char *)&entries[leafhdr.count] > (char *)leaf + leafhdr.firstused)

fs/xfs/scrub/attr.c

436

off = (char *)ent - (char *)leaf;

fs/xfs/scrub/attr.c

444

xchk_xattr_entry(ds, level, buf_end, leaf, &leafhdr,

fs/xfs/scrub/attr_repair.c

395

struct xfs_attr_leafblock *leaf;

fs/xfs/scrub/attr_repair.c

411

leaf = bp->b_addr;

fs/xfs/scrub/attr_repair.c

412

xfs_attr3_leaf_hdr_from_disk(mp->m_attr_geo, &leafhdr, leaf);

fs/xfs/scrub/attr_repair.c

413

hdrsize = xfs_attr3_leaf_hdr_size(leaf);

fs/xfs/scrub/attr_repair.c

415

entries = xfs_attr3_leaf_entryp(leaf);

fs/xfs/scrub/attr_repair.c

423

off = (char *)ent - (char *)leaf;

fs/xfs/scrub/attr_repair.c

435

lentry = xfs_attr3_leaf_name_local(leaf, i);

fs/xfs/scrub/attr_repair.c

439

rentry = xfs_attr3_leaf_name_remote(leaf, i);

fs/xfs/scrub/dir.c

627

struct xfs_dir2_leaf *leaf;

fs/xfs/scrub/dir.c

646

leaf = bp->b_addr;

fs/xfs/scrub/dir.c

647

xfs_dir2_leaf_hdr_from_disk(sc->ip->i_mount, &leafhdr, leaf);

fs/xfs/scrub/dir.c

648

ltp = xfs_dir2_leaf_tail_p(geo, leaf);

fs/xfs/scrub/listxattr.c

230

struct xfs_attr_leafblock *leaf;

fs/xfs/scrub/listxattr.c

249

leaf = leaf_bp->b_addr;

fs/xfs/scrub/listxattr.c

250

xfs_attr3_leaf_hdr_from_disk(mp->m_attr_geo, &leafhdr, leaf);

fs/xfs/scrub/listxattr.c

63

struct xfs_attr_leafblock *leaf = bp->b_addr;

fs/xfs/scrub/listxattr.c

68

xfs_attr3_leaf_hdr_from_disk(mp->m_attr_geo, &ichdr, leaf);

fs/xfs/scrub/listxattr.c

69

entry = xfs_attr3_leaf_entryp(leaf);

fs/xfs/scrub/listxattr.c

79

name_loc = xfs_attr3_leaf_name_local(leaf, i);

fs/xfs/scrub/listxattr.c

87

name_rmt = xfs_attr3_leaf_name_remote(leaf, i);

fs/xfs/scrub/rcbag_btree.c

225

bool leaf)

fs/xfs/scrub/rcbag_btree.c

227

if (leaf)

fs/xfs/scrub/rcbag_btree.c

240

bool leaf)

fs/xfs/scrub/rcbag_btree.c

243

return rcbagbt_block_maxrecs(blocklen, leaf);

fs/xfs/scrub/rcbag_btree.h

55

bool leaf);

fs/xfs/xfs_attr_inactive.c

102

entry = xfs_attr3_leaf_entryp(leaf);

fs/xfs/xfs_attr_inactive.c

109

name_rmt = xfs_attr3_leaf_name_remote(leaf, i);

fs/xfs/xfs_attr_inactive.c

90

struct xfs_attr_leafblock *leaf = bp->b_addr;

fs/xfs/xfs_attr_inactive.c

96

xfs_attr3_leaf_hdr_from_disk(mp->m_attr_geo, &ichdr, leaf);

fs/xfs/xfs_attr_list.c

316

struct xfs_attr_leafblock *leaf;

fs/xfs/xfs_attr_list.c

361

leaf = bp->b_addr;

fs/xfs/xfs_attr_list.c

371

&leafhdr, leaf);

fs/xfs/xfs_attr_list.c

372

entries = xfs_attr3_leaf_entryp(leaf);

fs/xfs/xfs_attr_list.c

411

leaf = bp->b_addr;

fs/xfs/xfs_attr_list.c

415

xfs_attr3_leaf_hdr_from_disk(mp->m_attr_geo, &leafhdr, leaf);

fs/xfs/xfs_attr_list.c

438

struct xfs_attr_leafblock *leaf;

fs/xfs/xfs_attr_list.c

447

leaf = bp->b_addr;

fs/xfs/xfs_attr_list.c

448

xfs_attr3_leaf_hdr_from_disk(mp->m_attr_geo, &ichdr, leaf);

fs/xfs/xfs_attr_list.c

449

entries = xfs_attr3_leaf_entryp(leaf);

fs/xfs/xfs_attr_list.c

501

name_loc = xfs_attr3_leaf_name_local(leaf, i);

fs/xfs/xfs_attr_list.c

509

name_rmt = xfs_attr3_leaf_name_remote(leaf, i);

fs/xfs/xfs_trace.h

675

__field(void *, leaf)

fs/xfs/xfs_trace.h

692

__entry->leaf = cur->leaf;

fs/xfs/xfs_trace.h

706

__entry->leaf,

include/linux/assoc_array_priv.h

79

struct assoc_array_ptr *leaf;

include/linux/bootconfig.h

132

struct xbc_node *leaf);

include/linux/bootconfig.h

135

struct xbc_node **leaf);

include/net/ip6_fib.h

231

for (rt = rcu_dereference((fn)->leaf); rt; \

include/net/ip6_fib.h

235

for (rt = (w)->leaf; rt; \

include/net/ip6_fib.h

361

struct fib6_info *leaf;

include/net/ip6_fib.h

74

struct fib6_info __rcu *leaf;

include/net/sch_generic.h

273

struct Qdisc * (*leaf)(struct Qdisc *, unsigned long cl);

include/uapi/linux/kvm.h

481

__u64 leaf;

ipc/mqueue.c

193

struct posix_msg_tree_node *leaf;

ipc/mqueue.c

199

leaf = rb_entry(parent, struct posix_msg_tree_node, rb_node);

ipc/mqueue.c

201

if (likely(leaf->priority == msg->m_type))

ipc/mqueue.c

203

else if (msg->m_type < leaf->priority) {

ipc/mqueue.c

210

leaf = info->node_cache;

ipc/mqueue.c

213

leaf = kmalloc_obj(*leaf, GFP_ATOMIC);

ipc/mqueue.c

214

if (!leaf)

ipc/mqueue.c

216

INIT_LIST_HEAD(&leaf->msg_list);

ipc/mqueue.c

218

leaf->priority = msg->m_type;

ipc/mqueue.c

221

info->msg_tree_rightmost = &leaf->rb_node;

ipc/mqueue.c

223

rb_link_node(&leaf->rb_node, parent, p);

ipc/mqueue.c

224

rb_insert_color(&leaf->rb_node, &info->msg_tree);

ipc/mqueue.c

228

list_add_tail(&msg->m_list, &leaf->msg_list);

ipc/mqueue.c

232

static inline void msg_tree_erase(struct posix_msg_tree_node *leaf,

ipc/mqueue.c

235

struct rb_node *node = &leaf->rb_node;

ipc/mqueue.c

242

kfree(leaf);

ipc/mqueue.c

244

info->node_cache = leaf;

ipc/mqueue.c

250

struct posix_msg_tree_node *leaf;

ipc/mqueue.c

269

leaf = rb_entry(parent, struct posix_msg_tree_node, rb_node);

ipc/mqueue.c

270

if (unlikely(list_empty(&leaf->msg_list))) {

ipc/mqueue.c

274

msg_tree_erase(leaf, info);

ipc/mqueue.c

277

msg = list_first_entry(&leaf->msg_list,

ipc/mqueue.c

280

if (list_empty(&leaf->msg_list)) {

ipc/mqueue.c

281

msg_tree_erase(leaf, info);

kernel/liveupdate/kexec_handover.c

167

struct kho_radix_leaf *leaf;

kernel/liveupdate/kexec_handover.c

210

leaf = (struct kho_radix_leaf *)node;

kernel/liveupdate/kexec_handover.c

211

__set_bit(idx, leaf->bitmap);

kernel/liveupdate/kexec_handover.c

242

struct kho_radix_leaf *leaf;

kernel/liveupdate/kexec_handover.c

267

leaf = (struct kho_radix_leaf *)node;

kernel/liveupdate/kexec_handover.c

269

__clear_bit(idx, leaf->bitmap);

kernel/liveupdate/kexec_handover.c

273

static int kho_radix_walk_leaf(struct kho_radix_leaf *leaf,

kernel/liveupdate/kexec_handover.c

277

unsigned long *bitmap = (unsigned long *)leaf;

kernel/liveupdate/kexec_handover.c

298

struct kho_radix_leaf *leaf;

kernel/liveupdate/kexec_handover.c

318

leaf = (struct kho_radix_leaf *)node;

kernel/liveupdate/kexec_handover.c

319

err = kho_radix_walk_leaf(leaf, key, cb);

kernel/locking/lockdep.c

2410

print_shortest_lock_dependencies(struct lock_list *leaf,

kernel/locking/lockdep.c

2413

struct lock_list *entry = leaf;

kernel/locking/lockdep.c

2417

depth = get_lock_depth(leaf);

kernel/locking/lockdep.c

2456

print_shortest_lock_dependencies_backwards(struct lock_list *leaf,

kernel/locking/lockdep.c

2459

struct lock_list *entry = leaf;

kernel/locking/lockdep.c

2464

depth = get_lock_depth(leaf);

lib/assoc_array.c

1031

edit->leaf = assoc_array_leaf_to_ptr(object);

lib/assoc_array.c

1043

static int assoc_array_delete_collapse_iterator(const void *leaf,

lib/assoc_array.c

1048

if (leaf == collapse->skip_leaf)

lib/assoc_array.c

1053

collapse->node->slots[collapse->slot++] = assoc_array_leaf_to_ptr(leaf);

lib/assoc_array.c

1354

*edit->leaf_p = edit->leaf;

lib/assoc_array.c

21

int (*iterator)(const void *leaf,

lib/assoc_array.c

311

const void *leaf;

lib/assoc_array.c

330

leaf = assoc_array_ptr_to_leaf(ptr);

lib/assoc_array.c

331

if (ops->compare_object(leaf, index_key))

lib/assoc_array.c

332

return (void *)leaf;

lib/assoc_array.c

983

edit->leaf = assoc_array_leaf_to_ptr(object);

lib/bootconfig.c

393

struct xbc_node **leaf)

lib/bootconfig.c

396

if (WARN_ON(!leaf))

lib/bootconfig.c

399

*leaf = xbc_node_find_next_leaf(root, *leaf);

lib/bootconfig.c

400

if (!*leaf)

lib/bootconfig.c

402

if ((*leaf)->child)

lib/bootconfig.c

403

return xbc_node_get_data(xbc_node_get_child(*leaf));

lib/maple_tree.c

6483

bool leaf = mte_is_leaf(entry);

lib/maple_tree.c

6507

if (leaf)

lib/rhashtable.c

124

bool leaf)

lib/rhashtable.c

136

if (ntbl && leaf) {

net/ipv4/fib_trie.c

1028

hlist_for_each_entry_rcu(fa, &l->leaf, fa_list) {

net/ipv4/fib_trie.c

1166

hlist_for_each_entry(last, &l->leaf, fa_list) {

net/ipv4/fib_trie.c

1178

hlist_add_head_rcu(&new->fa_list, &l->leaf);

net/ipv4/fib_trie.c

1220

fa = l ? fib_find_alias(&l->leaf, slen, dscp, fi->fib_priority,

net/ipv4/fib_trie.c

128

struct hlist_head leaf;

net/ipv4/fib_trie.c

1294

if (fib_find_alias(&l->leaf, fa->fa_slen, 0, 0,

net/ipv4/fib_trie.c

1365

if (fib_find_alias(&l->leaf, new_fa->fa_slen, 0, 0, tb->tb_id, true) ==

net/ipv4/fib_trie.c

1549

hlist_for_each_entry_rcu(fa, &n->leaf, fa_list) {

net/ipv4/fib_trie.c

1609

res->fa_head = &n->leaf;

net/ipv4/fib_trie.c

1639

if (hlist_empty(&l->leaf)) {

net/ipv4/fib_trie.c

1706

fa = fib_find_alias(&l->leaf, slen, dscp, 0, tb->tb_id, false);

net/ipv4/fib_trie.c

1739

fib_notify_alias_delete(net, key, &l->leaf, fa_to_delete, extack);

net/ipv4/fib_trie.c

1857

hlist_for_each_entry_safe(fa, tmp, &n->leaf, fa_list) {

net/ipv4/fib_trie.c

1893

hlist_for_each_entry(fa, &l->leaf, fa_list) {

net/ipv4/fib_trie.c

1975

hlist_for_each_entry_safe(fa, tmp, &n->leaf, fa_list) {

net/ipv4/fib_trie.c

1992

if (hlist_empty(&n->leaf)) {

net/ipv4/fib_trie.c

2046

hlist_for_each_entry_safe(fa, tmp, &n->leaf, fa_list) {

net/ipv4/fib_trie.c

2065

fib_notify_alias_delete(net, n->key, &n->leaf, fa,

net/ipv4/fib_trie.c

2079

if (hlist_empty(&n->leaf)) {

net/ipv4/fib_trie.c

2125

hlist_for_each_entry(fa, &n->leaf, fa_list) {

net/ipv4/fib_trie.c

2160

hlist_for_each_entry_rcu(fa, &l->leaf, fa_list) {

net/ipv4/fib_trie.c

2260

hlist_for_each_entry_rcu(fa, &l->leaf, fa_list) {

net/ipv4/fib_trie.c

2514

hlist_for_each_entry_rcu(fa, &n->leaf, fa_list)

net/ipv4/fib_trie.c

2794

hlist_for_each_entry_rcu(fa, &n->leaf, fa_list) {

net/ipv4/fib_trie.c

2958

hlist_for_each_entry_rcu(fa, &l->leaf, fa_list) {

net/ipv4/fib_trie.c

365

INIT_HLIST_HEAD(&l->leaf);

net/ipv4/fib_trie.c

366

hlist_add_head(&fa->fa_list, &l->leaf);

net/ipv6/ip6_fib.c

1068

struct fib6_info *leaf = rcu_dereference_protected(fn->leaf,

net/ipv6/ip6_fib.c

1071

if (!(fn->fn_flags & RTN_RTINFO) && leaf == rt) {

net/ipv6/ip6_fib.c

1075

rcu_assign_pointer(fn->leaf, new_leaf);

net/ipv6/ip6_fib.c

1095

struct fib6_info *leaf = rcu_dereference_protected(fn->leaf,

net/ipv6/ip6_fib.c

1113

ins = &fn->leaf;

net/ipv6/ip6_fib.c

1115

for (iter = leaf; iter;

net/ipv6/ip6_fib.c

1198

if (ins == &fn->leaf)

net/ipv6/ip6_fib.c

1207

sibling = leaf;

net/ipv6/ip6_fib.c

1253

(notify_sibling_rt || ins == &fn->leaf)) {

net/ipv6/ip6_fib.c

1309

if (!info->skip_notify_kernel && ins == &fn->leaf) {

net/ipv6/ip6_fib.c

1483

rcu_assign_pointer(sfn->leaf,

net/ipv6/ip6_fib.c

1519

if (!rcu_access_pointer(fn->leaf)) {

net/ipv6/ip6_fib.c

1522

rcu_assign_pointer(fn->leaf,

net/ipv6/ip6_fib.c

1526

rcu_assign_pointer(fn->leaf, rt);

net/ipv6/ip6_fib.c

1563

rcu_dereference_protected(pn->leaf,

net/ipv6/ip6_fib.c

1567

RCU_INIT_POINTER(pn->leaf, NULL);

net/ipv6/ip6_fib.c

1577

rcu_assign_pointer(pn->leaf, pn_leaf);

net/ipv6/ip6_fib.c

1598

!rcu_access_pointer(fn->leaf))))

net/ipv6/ip6_fib.c

1647

struct fib6_info *leaf = rcu_dereference(fn->leaf);

net/ipv6/ip6_fib.c

1650

if (!leaf)

net/ipv6/ip6_fib.c

1653

key = (struct rt6key *) ((u8 *)leaf + args->offset);

net/ipv6/ip6_fib.c

1730

struct fib6_info *leaf = rcu_dereference(fn->leaf);

net/ipv6/ip6_fib.c

1734

if (!leaf) {

net/ipv6/ip6_fib.c

1741

key = (struct rt6key *)((u8 *)leaf + offset);

net/ipv6/ip6_fib.c

1825

return rcu_dereference_protected(child_left->leaf,

net/ipv6/ip6_fib.c

1828

return rcu_dereference_protected(child_right->leaf,

net/ipv6/ip6_fib.c

1854

rcu_assign_pointer(fn->leaf, net->ipv6.fib6_null_entry);

net/ipv6/ip6_fib.c

1869

struct fib6_info *fn_leaf = rcu_dereference_protected(fn->leaf,

net/ipv6/ip6_fib.c

1871

struct fib6_info *pn_leaf = rcu_dereference_protected(pn->leaf,

net/ipv6/ip6_fib.c

1907

rcu_assign_pointer(fn->leaf, new_fn_leaf);

net/ipv6/ip6_fib.c

1964

RCU_INIT_POINTER(pn->leaf, NULL);

net/ipv6/ip6_fib.c

1973

struct fib6_info *leaf, *replace_rt = NULL;

net/ipv6/ip6_fib.c

1984

leaf = rcu_dereference_protected(fn->leaf,

net/ipv6/ip6_fib.c

1986

if (leaf == rt && !rt->fib6_nsiblings) {

net/ipv6/ip6_fib.c

2013

if (rt->fib6_metric == leaf->fib6_metric &&

net/ipv6/ip6_fib.c

2014

rt6_qualify_for_ecmp(leaf))

net/ipv6/ip6_fib.c

2028

if (w->state == FWS_C && w->leaf == rt) {

net/ipv6/ip6_fib.c

2030

w->leaf = rcu_dereference_protected(rt->fib6_next,

net/ipv6/ip6_fib.c

2032

if (!w->leaf)

net/ipv6/ip6_fib.c

2042

if (!rcu_access_pointer(fn->leaf)) {

net/ipv6/ip6_fib.c

2089

for (rtp = &fn->leaf; *rtp; rtp = rtp_next) {

net/ipv6/ip6_fib.c

2168

w->leaf = rcu_dereference_protected(fn->leaf, 1);

net/ipv6/ip6_fib.c

2171

if (w->leaf && fn->fn_flags & RTN_RTINFO) {

net/ipv6/ip6_fib.c

2209

w->leaf = rcu_dereference_protected(w->node->leaf, 1);

net/ipv6/ip6_fib.c

2249

w->leaf = NULL;

net/ipv6/ip6_fib.c

2256

w->leaf = rt;

net/ipv6/ip6_fib.c

2277

w->leaf = rt;

net/ipv6/ip6_fib.c

240

rcu_assign_pointer(table->tb6_root.leaf,

net/ipv6/ip6_fib.c

2499

rcu_assign_pointer(net->ipv6.fib6_main_tbl->tb6_root.leaf,

net/ipv6/ip6_fib.c

2511

rcu_assign_pointer(net->ipv6.fib6_local_tbl->tb6_root.leaf,

net/ipv6/ip6_fib.c

2632

iter->w.leaf = NULL;

net/ipv6/ip6_fib.c

2644

iter->w.leaf = rcu_dereference_protected(

net/ipv6/ip6_fib.c

2645

iter->w.leaf->fib6_next,

net/ipv6/ip6_fib.c

2648

if (!iter->skip && iter->w.leaf)

net/ipv6/ip6_fib.c

2650

} while (iter->w.leaf);

net/ipv6/ip6_fib.c

2724

return iter->w.leaf;

net/ipv6/ip6_fib.c

2802

iter->w.leaf = NULL;

net/ipv6/ip6_fib.c

474

err = fib6_rt_dump(w->leaf, w->args);

net/ipv6/ip6_fib.c

475

w->leaf = NULL;

net/ipv6/ip6_fib.c

537

w->leaf = rt;

net/ipv6/ip6_fib.c

558

w->leaf = NULL;

net/ipv6/ip6_fib.c

784

struct fib6_info *leaf = rcu_dereference_protected(fn->leaf,

net/ipv6/ip6_fib.c

786

key = (struct rt6key *)((u8 *)leaf + offset);

net/ipv6/ip6_fib.c

812

RCU_INIT_POINTER(fn->leaf, NULL);

net/ipv6/ip6_fib.c

813

fib6_info_release(leaf);

net/ipv6/ip6_fib.c

816

rcu_access_pointer(fn->leaf) ==

net/ipv6/ip6_fib.c

818

RCU_INIT_POINTER(fn->leaf, NULL);

net/ipv6/ip6_fib.c

924

in->leaf = fn->leaf;

net/ipv6/ip6_fib.c

925

fib6_info_hold(rcu_dereference_protected(in->leaf,

net/ipv6/route.c

1265

res.f6i = rcu_dereference(fn->leaf);

net/ipv6/route.c

4037

if (rcu_access_pointer(fn->leaf) == rt) {

net/ipv6/route.c

423

iter = rcu_dereference(fn->leaf);

net/ipv6/route.c

4790

iter = rcu_dereference_protected(fn->leaf,

net/ipv6/route.c

5380

struct fib6_info *leaf;

net/ipv6/route.c

5388

leaf = rcu_dereference(fn->leaf);

net/ipv6/route.c

5389

if (!leaf)

net/ipv6/route.c

5392

if (rt == leaf ||

net/ipv6/route.c

5393

(rt_can_ecmp && rt->fib6_metric == leaf->fib6_metric &&

net/ipv6/route.c

5394

rt6_qualify_for_ecmp(leaf)))

net/ipv6/route.c

881

static void find_rr_leaf(struct fib6_node *fn, struct fib6_info *leaf,

net/ipv6/route.c

892

__find_rr_leaf(leaf, rr_head, metric, res, &cont,

net/ipv6/route.c

905

struct fib6_info *leaf = rcu_dereference(fn->leaf);

net/ipv6/route.c

913

if (!leaf || leaf == net->ipv6.fib6_null_entry)

net/ipv6/route.c

918

rt0 = leaf;

net/ipv6/route.c

933

find_rr_leaf(fn, leaf, rt0, oif, strict, &do_rr, res);

net/ipv6/route.c

939

next = leaf;

net/ipv6/route.c

942

spin_lock_bh(&leaf->fib6_table->tb6_lock);

net/ipv6/route.c

946

spin_unlock_bh(&leaf->fib6_table->tb6_lock);

net/sched/sch_api.c

1439

struct Qdisc *leaf;

net/sched/sch_api.c

1443

leaf = cops->leaf(q, cl);

net/sched/sch_api.c

1444

if (leaf) {

net/sched/sch_api.c

1445

if (leaf == arg->p || arg->depth > 7)

net/sched/sch_api.c

1447

return check_loop(leaf, arg->p, arg->depth + 1);

net/sched/sch_api.c

157

if (!(cops->find && cops->walk && cops->leaf))

net/sched/sch_api.c

355

return cops->leaf(p, cl);

net/sched/sch_cake.c

3213

.leaf = cake_leaf,

net/sched/sch_cake.c

3327

.leaf = mq_leaf,

net/sched/sch_cbs.c

529

.leaf = cbs_leaf,

net/sched/sch_drr.c

469

.leaf = drr_class_leaf,

net/sched/sch_dualpi2.c

1130

.leaf = dualpi2_leaf,

net/sched/sch_ets.c

807

.leaf = ets_class_leaf,

net/sched/sch_fq_codel.c

710

.leaf = fq_codel_leaf,

net/sched/sch_hfsc.c

1662

.leaf = hfsc_class_leaf,

net/sched/sch_htb.c

1011

if (cl->leaf.q && !q->offload)

net/sched/sch_htb.c

1012

qdisc_reset(cl->leaf.q);

net/sched/sch_htb.c

1255

if (!cl->level && cl->leaf.q)

net/sched/sch_htb.c

1256

tcm->tcm_info = cl->leaf.q->handle;

net/sched/sch_htb.c

128

} leaf;

net/sched/sch_htb.c

1313

bytes += u64_stats_read(&c->leaf.q->bstats.bytes);

net/sched/sch_htb.c

1314

packets += u64_stats_read(&c->leaf.q->bstats.packets);

net/sched/sch_htb.c

1332

if (!cl->level && cl->leaf.q)

net/sched/sch_htb.c

1333

qdisc_qstats_qlen_backlog(cl->leaf.q, &qlen, &qs.backlog);

net/sched/sch_htb.c

1342

if (cl->leaf.q)

net/sched/sch_htb.c

1343

cl->bstats = cl->leaf.q->bstats;

net/sched/sch_htb.c

1404

queue = cl->leaf.offload_queue;

net/sched/sch_htb.c

1405

if (!(cl->leaf.q->flags & TCQ_F_BUILTIN))

net/sched/sch_htb.c

1406

WARN_ON(cl->leaf.q->dev_queue != queue);

net/sched/sch_htb.c

1426

WARN_ON(qdisc != cl_old->leaf.q);

net/sched/sch_htb.c

1429

if (!(cl_old->leaf.q->flags & TCQ_F_BUILTIN))

net/sched/sch_htb.c

1430

cl_old->leaf.q->dev_queue = queue_new;

net/sched/sch_htb.c

1431

cl_old->leaf.offload_queue = queue_new;

net/sched/sch_htb.c

1436

qdisc = dev_graft_qdisc(queue_new, cl_old->leaf.q);

net/sched/sch_htb.c

1470

*old = qdisc_replace(sch, new, &cl->leaf.q);

net/sched/sch_htb.c

1483

return !cl->level ? cl->leaf.q : NULL;

net/sched/sch_htb.c

1510

WARN_ON(cl->level || !cl->leaf.q || cl->prio_activity);

net/sched/sch_htb.c

1518

parent->leaf.q = new_q ? new_q : &noop_qdisc;

net/sched/sch_htb.c

1524

parent->leaf.offload_queue = cl->leaf.offload_queue;

net/sched/sch_htb.c

1546

struct Qdisc *q = cl->leaf.q;

net/sched/sch_htb.c

1606

WARN_ON(!cl->leaf.q);

net/sched/sch_htb.c

1607

qdisc_put(cl->leaf.q);

net/sched/sch_htb.c

1736

qdisc_purge_queue(cl->leaf.q);

net/sched/sch_htb.c

1912

WARN_ON(old_q != parent->leaf.q);

net/sched/sch_htb.c

1949

qdisc_purge_queue(parent->leaf.q);

net/sched/sch_htb.c

1950

parent_qdisc = parent->leaf.q;

net/sched/sch_htb.c

1964

cl->leaf.q = new_q ? new_q : &noop_qdisc;

net/sched/sch_htb.c

1966

cl->leaf.offload_queue = dev_queue;

net/sched/sch_htb.c

1981

if (cl->leaf.q != &noop_qdisc)

net/sched/sch_htb.c

1982

qdisc_hash_add(cl->leaf.q, true);

net/sched/sch_htb.c

2126

.leaf = htb_leaf,

net/sched/sch_htb.c

595

WARN_ON(cl->level || !cl->leaf.q);

net/sched/sch_htb.c

642

} else if ((ret = qdisc_enqueue(skb, cl->leaf.q,

net/sched/sch_htb.c

895

if (unlikely(cl->leaf.q->q.qlen == 0)) {

net/sched/sch_htb.c

911

skb = cl->leaf.q->dequeue(cl->leaf.q);

net/sched/sch_htb.c

915

qdisc_warn_nonwc("htb", cl->leaf.q);

net/sched/sch_htb.c

924

cl->leaf.deficit[level] -= qdisc_pkt_len(skb);

net/sched/sch_htb.c

925

if (cl->leaf.deficit[level] < 0) {

net/sched/sch_htb.c

926

cl->leaf.deficit[level] += cl->quantum;

net/sched/sch_htb.c

933

if (!cl->leaf.q->q.qlen)

net/sched/sch_ingress.c

152

.leaf = ingress_leaf,

net/sched/sch_ingress.c

328

.leaf = ingress_leaf,

net/sched/sch_mq.c

284

.leaf = mq_leaf,

net/sched/sch_mqprio.c

755

.leaf = mqprio_leaf,

net/sched/sch_multiq.c

373

.leaf = multiq_leaf,

net/sched/sch_netem.c

1339

.leaf = netem_leaf,

net/sched/sch_prio.c

396

.leaf = prio_leaf,

net/sched/sch_qfq.c

1521

.leaf = qfq_class_leaf,

net/sched/sch_red.c

532

.leaf = red_leaf,

net/sched/sch_sfb.c

688

.leaf = sfb_leaf,

net/sched/sch_sfq.c

943

.leaf = sfq_leaf,

net/sched/sch_skbprio.c

273

.leaf = skbprio_leaf,

net/sched/sch_taprio.c

2523

.leaf = taprio_leaf,

net/sched/sch_tbf.c

597

.leaf = tbf_leaf,

scripts/dtc/libfdt/fdt_ro.c

321

const char *leaf;

scripts/dtc/libfdt/fdt_ro.c

322

leaf = strrchr(nameptr, '/');

scripts/dtc/libfdt/fdt_ro.c

323

if (leaf == NULL) {

scripts/dtc/libfdt/fdt_ro.c

327

nameptr = leaf+1;

tools/arch/x86/kcpuid/kcpuid.c

139

#define cpuid(leaf, a, b, c, d) \

tools/arch/x86/kcpuid/kcpuid.c

140

__cpuid_count(leaf, 0, a, b, c, d)

tools/arch/x86/kcpuid/kcpuid.c

142

#define cpuid_count(leaf, subleaf, a, b, c, d) \

tools/arch/x86/kcpuid/kcpuid.c

143

__cpuid_count(leaf, subleaf, a, b, c, d)

tools/arch/x86/kcpuid/kcpuid.c

160

static void leaf_print_raw(struct subleaf *leaf)

tools/arch/x86/kcpuid/kcpuid.c

162

if (has_subleafs(leaf->index)) {

tools/arch/x86/kcpuid/kcpuid.c

163

if (leaf->sub == 0)

tools/arch/x86/kcpuid/kcpuid.c

164

printf("0x%08x: subleafs:\n", leaf->index);

tools/arch/x86/kcpuid/kcpuid.c

166

printf(" %2d: EAX=0x%08x, EBX=0x%08x, ECX=0x%08x, EDX=0x%08x\n", leaf->sub,

tools/arch/x86/kcpuid/kcpuid.c

167

leaf->output[0], leaf->output[1], leaf->output[2], leaf->output[3]);

tools/arch/x86/kcpuid/kcpuid.c

169

printf("0x%08x: EAX=0x%08x, EBX=0x%08x, ECX=0x%08x, EDX=0x%08x\n", leaf->index,

tools/arch/x86/kcpuid/kcpuid.c

170

leaf->output[0], leaf->output[1], leaf->output[2], leaf->output[3]);

tools/arch/x86/kcpuid/kcpuid.c

179

struct subleaf *leaf;

tools/arch/x86/kcpuid/kcpuid.c

199

func->leafs = realloc(func->leafs, (s + 1) * sizeof(*leaf));

tools/arch/x86/kcpuid/kcpuid.c

206

leaf = &func->leafs[s];

tools/arch/x86/kcpuid/kcpuid.c

208

leaf->index = f;

tools/arch/x86/kcpuid/kcpuid.c

209

leaf->sub = subleaf;

tools/arch/x86/kcpuid/kcpuid.c

210

leaf->output[R_EAX] = a;

tools/arch/x86/kcpuid/kcpuid.c

211

leaf->output[R_EBX] = b;

tools/arch/x86/kcpuid/kcpuid.c

212

leaf->output[R_ECX] = c;

tools/arch/x86/kcpuid/kcpuid.c

213

leaf->output[R_EDX] = d;

tools/arch/x86/kcpuid/kcpuid.c

318

struct subleaf *leaf;

tools/arch/x86/kcpuid/kcpuid.c

412

leaf = &func->leafs[sub];

tools/arch/x86/kcpuid/kcpuid.c

413

reg = &leaf->info[reg_index];

tools/arch/x86/kcpuid/kcpuid.c

498

static void show_reg_header(bool has_entries, u32 leaf, u32 subleaf, const char *reg_name)

tools/arch/x86/kcpuid/kcpuid.c

501

printf("CPUID_0x%x_%s[0x%x]:\n", leaf, reg_name, subleaf);

tools/arch/x86/kcpuid/kcpuid.c

504

static void show_leaf(struct subleaf *leaf)

tools/arch/x86/kcpuid/kcpuid.c

507

leaf_print_raw(leaf);

tools/arch/x86/kcpuid/kcpuid.c

510

show_reg_header((leaf->info[i].nr > 0), leaf->index, leaf->sub, reg_names[i]);

tools/arch/x86/kcpuid/kcpuid.c

511

show_reg(&leaf->info[i], leaf->output[i]);

tools/bootconfig/main.c

118

struct xbc_node *leaf;

tools/bootconfig/main.c

122

xbc_for_each_key_value(leaf, val) {

tools/bootconfig/main.c

123

ret = xbc_node_compose_key(leaf, key, XBC_KEYLEN_MAX);

tools/bootconfig/main.c

133

xbc_show_value(xbc_node_get_child(leaf), false);

tools/include/uapi/linux/kvm.h

480

__u64 leaf;

tools/perf/tests/workloads/inlineloop.c

27

leaf(b);

tools/perf/tests/workloads/leafloop.c

28

leaf(b);

tools/perf/tests/workloads/leafloop.c

9

noinline void leaf(volatile int b);

tools/perf/ui/browsers/hists.c

1464

if (entry->leaf && row_offset) {

tools/perf/ui/browsers/hists.c

1587

if (entry->leaf && folded_sign == '-' && row != browser->b.rows) {

tools/perf/ui/browsers/hists.c

2006

if (h->unfolded && h->leaf) {

tools/perf/ui/browsers/hists.c

2028

if (h->unfolded && h->leaf) {

tools/perf/ui/browsers/hists.c

2065

if (h->unfolded && h->leaf)

tools/perf/ui/browsers/hists.c

2184

if (he->leaf && folded_sign == '-') {

tools/perf/ui/browsers/hists.c

280

if (he->leaf)

tools/perf/ui/browsers/hists.c

2975

if (!he->leaf || !hist_entry__has_callchains(he) || !symbol_conf.use_callchain)

tools/perf/ui/browsers/hists.c

387

if (he->leaf) {

tools/perf/ui/browsers/hists.c

464

if (he->leaf)

tools/perf/ui/browsers/hists.c

473

if (he->leaf)

tools/perf/ui/browsers/hists.c

483

if (!he->leaf && he->nr_rows == 0) {

tools/perf/ui/browsers/hists.c

499

if (he->leaf)

tools/perf/ui/browsers/hists.c

592

if (he->leaf)

tools/perf/ui/browsers/hists.c

624

if (he->leaf)

tools/perf/ui/browsers/hists.c

74

if (he->leaf && he->unfolded)

tools/perf/ui/gtk/hists.c

465

if (!he->leaf) {

tools/perf/ui/gtk/hists.c

485

if (he->leaf && hist_entry__has_callchains(he) && symbol_conf.use_callchain) {

tools/perf/ui/stdio/hist.c

531

if (he->leaf && hist_entry__has_callchains(he) && symbol_conf.use_callchain) {

tools/perf/ui/stdio/hist.c

894

if (!h->leaf && !hist_entry__has_hierarchy_children(h, min_pcnt)) {

tools/perf/util/hist.c

1722

new_he->leaf = true;

tools/perf/util/hist.c

1989

if (!he->leaf) {

tools/perf/util/hist.c

2149

if (he->leaf || hmd == HMD_FORCE_SIBLING)

tools/perf/util/hist.c

2209

if (he->leaf)

tools/perf/util/hist.c

2375

if (he->leaf || he->filtered)

tools/perf/util/hist.c

2758

if (!pos->leaf) {

tools/perf/util/hist.c

430

if (!he->leaf) {

tools/perf/util/hist.c

595

he->leaf = true;

tools/perf/util/hist.h

270

bool leaf;

tools/power/x86/x86_energy_perf_policy/x86_energy_perf_policy.c

1462

static void get_cpuid_or_exit(unsigned int leaf,

tools/power/x86/x86_energy_perf_policy/x86_energy_perf_policy.c

1466

if (!__get_cpuid(leaf, eax, ebx, ecx, edx))

tools/testing/selftests/bpf/progs/xdpwall.c

118

__u8 *leaf;

tools/testing/selftests/bpf/progs/xdpwall.c

120

leaf = bpf_map_lookup_elem(&v6_addr_map, ipv6addr);

tools/testing/selftests/bpf/progs/xdpwall.c

122

return leaf ? *leaf : 0;

tools/testing/selftests/bpf/progs/xdpwall.c

127

__u8 *leaf;

tools/testing/selftests/bpf/progs/xdpwall.c

129

leaf = bpf_map_lookup_elem(&v4_addr_map, &ipaddr);

tools/testing/selftests/bpf/progs/xdpwall.c

131

return leaf ? *leaf : 0;

tools/testing/selftests/bpf/progs/xdpwall.c

221

__u8 *leaf = bpf_map_lookup_elem(&tcp_port_map, &port);

tools/testing/selftests/bpf/progs/xdpwall.c

223

return leaf ? *leaf : 0;

tools/testing/selftests/bpf/progs/xdpwall.c

228

__u16 *leaf = bpf_map_lookup_elem(&udp_port_map, &port);

tools/testing/selftests/bpf/progs/xdpwall.c

230

return leaf ? *leaf : 0;

tools/testing/selftests/cgroup/test_cpu.c

486

struct cpu_hogger leaf[3] = {};

tools/testing/selftests/cgroup/test_cpu.c

517

for (i = 0; i < ARRAY_SIZE(leaf); i++) {

tools/testing/selftests/cgroup/test_cpu.c

528

leaf[i].cgroup = cg_name_indexed(ancestor, "cpucg_leaf", i);

tools/testing/selftests/cgroup/test_cpu.c

529

if (!leaf[i].cgroup)

tools/testing/selftests/cgroup/test_cpu.c

532

if (cg_create(leaf[i].cgroup))

tools/testing/selftests/cgroup/test_cpu.c

535

if (cg_write_numeric(leaf[i].cgroup, "cpu.weight", weight))

tools/testing/selftests/cgroup/test_cpu.c

539

for (i = 0; i < ARRAY_SIZE(leaf); i++) {

tools/testing/selftests/cgroup/test_cpu.c

550

pid = cg_run_nowait(leaf[i].cgroup, hog_cpus_timed,

tools/testing/selftests/cgroup/test_cpu.c

554

leaf[i].pid = pid;

tools/testing/selftests/cgroup/test_cpu.c

557

for (i = 0; i < ARRAY_SIZE(leaf); i++) {

tools/testing/selftests/cgroup/test_cpu.c

560

waitpid(leaf[i].pid, &retcode, 0);

tools/testing/selftests/cgroup/test_cpu.c

567

for (i = 0; i < ARRAY_SIZE(leaf); i++) {

tools/testing/selftests/cgroup/test_cpu.c

568

leaf[i].usage = cg_read_key_long(leaf[i].cgroup,

tools/testing/selftests/cgroup/test_cpu.c

570

if (leaf[i].usage <= 0)

tools/testing/selftests/cgroup/test_cpu.c

574

nested_leaf_usage = leaf[1].usage + leaf[2].usage;

tools/testing/selftests/cgroup/test_cpu.c

576

if (!values_close_report(leaf[0].usage, nested_leaf_usage, 15))

tools/testing/selftests/cgroup/test_cpu.c

578

} else if (!values_close_report(leaf[0].usage * 2, nested_leaf_usage, 15))

tools/testing/selftests/cgroup/test_cpu.c

590

for (i = 0; i < ARRAY_SIZE(leaf); i++) {

tools/testing/selftests/cgroup/test_cpu.c

591

cg_destroy(leaf[i].cgroup);

tools/testing/selftests/cgroup/test_cpu.c

592

free(leaf[i].cgroup);

tools/testing/selftests/mm/pkey-x86.h

125

int leaf;

tools/testing/selftests/mm/pkey-x86.h

128

leaf = XSTATE_PKEY_BIT;

tools/testing/selftests/mm/pkey-x86.h

130

__cpuid_count(XSTATE_CPUID, leaf, eax, ebx, ecx, edx);

tools/testing/selftests/mm/pkey-x86.h

132

if (leaf == XSTATE_PKEY_BIT) {