arch/loongarch/kernel/paravirt.c

104

kvm_hypercall3(KVM_HCALL_FUNC_IPI, (unsigned long)bitmap,

arch/loongarch/kernel/paravirt.c

105

(unsigned long)(bitmap >> BITS_PER_LONG), min);

arch/loongarch/kernel/paravirt.c

107

bitmap = 0;

arch/loongarch/kernel/paravirt.c

109

__set_bit(cpu - min, (unsigned long *)&bitmap);

arch/loongarch/kernel/paravirt.c

112

if (bitmap)

arch/loongarch/kernel/paravirt.c

113

kvm_hypercall3(KVM_HCALL_FUNC_IPI, (unsigned long)bitmap,

arch/loongarch/kernel/paravirt.c

114

(unsigned long)(bitmap >> BITS_PER_LONG), min);

arch/loongarch/kernel/paravirt.c

71

__uint128_t bitmap = 0;

arch/loongarch/kernel/paravirt.c

90

if (!bitmap) {

arch/loongarch/kernel/paravirt.c

94

bitmap <<= min - cpu;

arch/mips/dec/prom/memory.c

72

if (bm->bitmap[i] == 0xff)

arch/mips/include/asm/dec/prom.h

73

unsigned char bitmap[];

arch/powerpc/include/asm/guest-state-buffer.h

269

DECLARE_BITMAP(bitmap, KVMPPC_GSE_IDEN_COUNT);

arch/powerpc/include/asm/guest-state-buffer.h

320

struct kvmppc_gs_bitmap bitmap;

arch/powerpc/include/asm/guest-state-buffer.h

818

bitmap_zero(gsbm->bitmap, KVMPPC_GSE_IDEN_COUNT);

arch/powerpc/include/asm/guest-state-buffer.h

827

bitmap_fill(gsbm->bitmap, KVMPPC_GSE_IDEN_COUNT);

arch/powerpc/include/asm/guest-state-buffer.h

828

clear_bit(0, gsbm->bitmap);

arch/powerpc/include/asm/guest-state-buffer.h

874

for (iden = kvmppc_gsbm_next(&gsm->bitmap, 0); iden != 0; \

arch/powerpc/include/asm/guest-state-buffer.h

875

iden = kvmppc_gsbm_next(&gsm->bitmap, iden))

arch/powerpc/include/asm/guest-state-buffer.h

896

kvmppc_gsbm_set(&gsm->bitmap, iden);

arch/powerpc/include/asm/guest-state-buffer.h

907

return kvmppc_gsbm_test(&gsm->bitmap, iden);

arch/powerpc/include/asm/guest-state-buffer.h

918

kvmppc_gsbm_fill(&gsm->bitmap);

arch/powerpc/include/asm/guest-state-buffer.h

928

kvmppc_gsbm_zero(&gsm->bitmap);

arch/powerpc/include/asm/msi_bitmap.h

14

unsigned long *bitmap;

arch/powerpc/kvm/book3s_hv_nestedv2.c

726

kvmppc_gsbm_clear(&vcore_message->bitmap, KVMPPC_GSID_LOGICAL_PVR);

arch/powerpc/kvm/guest-state-buffer.c

466

set_bit(kvmppc_gse_flatten_iden(iden), gsbm->bitmap);

arch/powerpc/kvm/guest-state-buffer.c

477

clear_bit(kvmppc_gse_flatten_iden(iden), gsbm->bitmap);

arch/powerpc/kvm/guest-state-buffer.c

488

return test_bit(kvmppc_gse_flatten_iden(iden), gsbm->bitmap);

arch/powerpc/kvm/guest-state-buffer.c

502

bit = find_next_bit(gsbm->bitmap, KVMPPC_GSE_IDEN_COUNT, pbit);

arch/powerpc/platforms/cell/spufs/sched.c

1091

__clear_bit(i, spu_prio->bitmap);

arch/powerpc/platforms/cell/spufs/sched.c

42

DECLARE_BITMAP(bitmap, MAX_PRIO);

arch/powerpc/platforms/cell/spufs/sched.c

492

set_bit(ctx->prio, spu_prio->bitmap);

arch/powerpc/platforms/cell/spufs/sched.c

515

clear_bit(prio, spu_prio->bitmap);

arch/powerpc/platforms/cell/spufs/sched.c

825

best = find_first_bit(spu_prio->bitmap, prio);

arch/powerpc/platforms/pseries/papr_scm.c

501

u64 bitmap = 0;

arch/powerpc/platforms/pseries/papr_scm.c

507

bitmap = ret[0] & ret[1];

arch/powerpc/platforms/pseries/papr_scm.c

521

bitmap = (bitmap & ~p->health_bitmap_inject_mask) |

arch/powerpc/platforms/pseries/papr_scm.c

523

WRITE_ONCE(p->health_bitmap, bitmap);

arch/powerpc/sysdev/fsl_msi.c

111

rc = msi_bitmap_alloc(&msi_data->bitmap, NR_MSI_IRQS_MAX,

arch/powerpc/sysdev/fsl_msi.c

121

msi_bitmap_reserve_hwirq(&msi_data->bitmap, hwirq);

arch/powerpc/sysdev/fsl_msi.c

138

msi_bitmap_free_hwirqs(&msi_data->bitmap, hwirq, 1);

arch/powerpc/sysdev/fsl_msi.c

238

hwirq = msi_bitmap_alloc_hwirqs(&msi_data->bitmap, 1);

arch/powerpc/sysdev/fsl_msi.c

253

msi_bitmap_free_hwirqs(&msi_data->bitmap, hwirq, 1);

arch/powerpc/sysdev/fsl_msi.c

341

if (msi->bitmap.bitmap)

arch/powerpc/sysdev/fsl_msi.c

342

msi_bitmap_free(&msi->bitmap);

arch/powerpc/sysdev/fsl_msi.c

386

msi_bitmap_free_hwirqs(&msi->bitmap,

arch/powerpc/sysdev/fsl_msi.h

41

struct msi_bitmap bitmap;

arch/powerpc/sysdev/mpic_msi.c

21

if (!mpic->msi_bitmap.bitmap)

arch/powerpc/sysdev/msi_bitmap.c

104

bitmap_release_region(bmp->bitmap, *p + j, 0);

arch/powerpc/sysdev/msi_bitmap.c

125

bmp->bitmap = kzalloc(size, GFP_KERNEL);

arch/powerpc/sysdev/msi_bitmap.c

127

bmp->bitmap = memblock_alloc_or_panic(size, SMP_CACHE_BYTES);

arch/powerpc/sysdev/msi_bitmap.c

129

kmemleak_not_leak(bmp->bitmap);

arch/powerpc/sysdev/msi_bitmap.c

132

if (!bmp->bitmap) {

arch/powerpc/sysdev/msi_bitmap.c

148

kfree(bmp->bitmap);

arch/powerpc/sysdev/msi_bitmap.c

150

bmp->bitmap = NULL;

arch/powerpc/sysdev/msi_bitmap.c

167

WARN_ON(bitmap_find_free_region(bmp.bitmap, size, get_count_order(size)));

arch/powerpc/sysdev/msi_bitmap.c

168

bitmap_release_region(bmp.bitmap, 0, get_count_order(size));

arch/powerpc/sysdev/msi_bitmap.c

174

WARN_ON(bitmap_find_free_region(bmp.bitmap, size, get_count_order(size)));

arch/powerpc/sysdev/msi_bitmap.c

175

bitmap_release_region(bmp.bitmap, 0, get_count_order(size));

arch/powerpc/sysdev/msi_bitmap.c

184

WARN_ON(bitmap_find_free_region(bmp.bitmap, size, 0) >= 0);

arch/powerpc/sysdev/msi_bitmap.c

212

WARN_ON(bmp.bitmap != NULL);

arch/powerpc/sysdev/msi_bitmap.c

22

offset = bitmap_find_next_zero_area(bmp->bitmap, bmp->irq_count, 0,

arch/powerpc/sysdev/msi_bitmap.c

238

WARN_ON(bitmap_find_free_region(bmp.bitmap, SIZE_EXPECTED,

arch/powerpc/sysdev/msi_bitmap.c

240

bitmap_release_region(bmp.bitmap, 0, get_count_order(SIZE_EXPECTED));

arch/powerpc/sysdev/msi_bitmap.c

257

WARN_ON(!bitmap_equal(expected, bmp.bitmap, SIZE_EXPECTED));

arch/powerpc/sysdev/msi_bitmap.c

260

kfree(bmp.bitmap);

arch/powerpc/sysdev/msi_bitmap.c

27

bitmap_set(bmp->bitmap, offset, num);

arch/powerpc/sysdev/msi_bitmap.c

48

bitmap_clear(bmp->bitmap, offset, num);

arch/powerpc/sysdev/msi_bitmap.c

60

bitmap_allocate_region(bmp->bitmap, hwirq, 0);

arch/powerpc/sysdev/msi_bitmap.c

96

bitmap_allocate_region(bmp->bitmap, 0, get_count_order(bmp->irq_count));

arch/powerpc/sysdev/xive/spapr.c

124

clear_bit(irq - xibm->base, xibm->bitmap);

arch/powerpc/sysdev/xive/spapr.c

42

unsigned long *bitmap;

arch/powerpc/sysdev/xive/spapr.c

62

xibm->bitmap = bitmap_zalloc(xibm->count, GFP_KERNEL);

arch/powerpc/sysdev/xive/spapr.c

63

if (!xibm->bitmap) {

arch/powerpc/sysdev/xive/spapr.c

677

bitmap_print_to_pagebuf(true, buf, xibm->bitmap, xibm->count);

arch/powerpc/sysdev/xive/spapr.c

80

bitmap_free(xibm->bitmap);

arch/powerpc/sysdev/xive/spapr.c

89

irq = find_first_zero_bit(xibm->bitmap, xibm->count);

arch/powerpc/sysdev/xive/spapr.c

91

set_bit(irq, xibm->bitmap);

arch/riscv/kernel/cpufeature.c

597

static void riscv_isa_set_ext(const struct riscv_isa_ext_data *ext, unsigned long *bitmap)

arch/riscv/kernel/cpufeature.c

600

set_bit(ext->id, bitmap);

arch/riscv/kernel/cpufeature.c

604

set_bit(ext->subset_ext_ids[i], bitmap);

arch/riscv/kernel/cpufeature.c

668

static void __init match_isa_ext(const char *name, const char *name_end, unsigned long *bitmap)

arch/riscv/kernel/cpufeature.c

675

riscv_isa_set_ext(ext, bitmap);

arch/riscv/kernel/cpufeature.c

681

static void __init riscv_parse_isa_string(const char *isa, unsigned long *bitmap)

arch/riscv/kernel/cpufeature.c

827

match_isa_ext(ext, ext_end, bitmap);

arch/sparc/mm/iommu.c

113

bitmap = kmalloc(IOMMU_NPTES>>3, GFP_KERNEL);

arch/sparc/mm/iommu.c

114

if (!bitmap) {

arch/sparc/mm/iommu.c

119

bit_map_init(&iommu->usemap, bitmap, IOMMU_NPTES);

arch/sparc/mm/iommu.c

62

unsigned long *bitmap;

arch/um/drivers/ubd_kern.c

1130

__u64 *cow_offset, unsigned long *bitmap,

arch/um/drivers/ubd_kern.c

1140

if(ubd_test_bit(sector + i, (unsigned char *) bitmap))

arch/um/drivers/ubd_kern.c

1144

ubd_set_bit(sector + i, (unsigned char *) bitmap);

arch/um/drivers/ubd_kern.c

1161

bitmap_words[0] = bitmap[*cow_offset];

arch/um/drivers/ubd_kern.c

1162

bitmap_words[1] = bitmap[*cow_offset + 1];

arch/um/drivers/ubd_kern.c

1169

unsigned long offset, unsigned long *bitmap,

arch/um/drivers/ubd_kern.c

1180

if(ubd_test_bit(sector + i, (unsigned char *) bitmap))

arch/um/drivers/ubd_kern.c

1186

&segment->cow_offset, bitmap, bitmap_offset,

arch/um/drivers/ubd_kern.c

1216

dev->cow.bitmap, dev->cow.bitmap_offset,

arch/um/drivers/ubd_kern.c

136

unsigned long *bitmap;

arch/um/drivers/ubd_kern.c

166

.bitmap = NULL, \

arch/um/drivers/ubd_kern.c

713

vfree(ubd_dev->cow.bitmap);

arch/um/drivers/ubd_kern.c

714

ubd_dev->cow.bitmap = NULL;

arch/um/drivers/ubd_kern.c

755

ubd_dev->cow.bitmap = vmalloc(ubd_dev->cow.bitmap_len);

arch/um/drivers/ubd_kern.c

756

if(ubd_dev->cow.bitmap == NULL){

arch/um/drivers/ubd_kern.c

761

err = read_cow_bitmap(ubd_dev->fd, ubd_dev->cow.bitmap,

arch/x86/boot/compressed/efi.h

105

unsigned long bitmap[];

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

87

if (test_bit(idx, iobm->bitmap))

arch/x86/include/asm/apic.h

521

static inline int apic_find_highest_vector(void *bitmap)

arch/x86/include/asm/apic.h

527

reg = bitmap + APIC_VECTOR_TO_REG_OFFSET(vec);

arch/x86/include/asm/apic.h

557

static inline void apic_clear_vector(int vec, void *bitmap)

arch/x86/include/asm/apic.h

559

clear_bit(APIC_VECTOR_TO_BIT_NUMBER(vec), bitmap + APIC_VECTOR_TO_REG_OFFSET(vec));

arch/x86/include/asm/apic.h

562

static inline void apic_set_vector(int vec, void *bitmap)

arch/x86/include/asm/apic.h

564

set_bit(APIC_VECTOR_TO_BIT_NUMBER(vec), bitmap + APIC_VECTOR_TO_REG_OFFSET(vec));

arch/x86/include/asm/apic.h

567

static inline int apic_test_vector(int vec, void *bitmap)

arch/x86/include/asm/apic.h

569

return test_bit(APIC_VECTOR_TO_BIT_NUMBER(vec), bitmap + APIC_VECTOR_TO_REG_OFFSET(vec));

arch/x86/include/asm/io_bitmap.h

13

unsigned long bitmap[IO_BITMAP_LONGS];

arch/x86/include/asm/kvm_host.h

1216

unsigned long *bitmap;

arch/x86/include/asm/pci_x86.h

79

u16 bitmap; /* Available IRQs */

arch/x86/include/asm/processor.h

338

(offsetof(struct tss_struct, io_bitmap.bitmap) - \

arch/x86/include/asm/processor.h

391

unsigned long bitmap[IO_BITMAP_LONGS + 1];

arch/x86/include/uapi/asm/kvm.h

221

__u8 *bitmap; /* a 1 bit allows the operations in flags, 0 denies */

arch/x86/kernel/apic/x2apic_savic.c

39

void *bitmap = get_reg_bitmap(cpu, offset);

arch/x86/kernel/apic/x2apic_savic.c

42

apic_set_vector(vector, bitmap);

arch/x86/kernel/apic/x2apic_savic.c

44

apic_clear_vector(vector, bitmap);

arch/x86/kernel/cpu/common.c

2394

memset(tss->io_bitmap.bitmap, 0xff, sizeof(tss->io_bitmap.bitmap));

arch/x86/kernel/ioport.c

128

bitmap_clear(iobm->bitmap, from, num);

arch/x86/kernel/ioport.c

130

bitmap_set(iobm->bitmap, from, num);

arch/x86/kernel/ioport.c

138

if (iobm->bitmap[i] != ~0UL)

arch/x86/kernel/ioport.c

97

memset(iobm->bitmap, 0xff, sizeof(iobm->bitmap));

arch/x86/kernel/process.c

456

memcpy(tss->io_bitmap.bitmap, iobm->bitmap,

arch/x86/kernel/ptrace.c

710

return membuf_write(&to, iobm->bitmap, IO_BITMAP_BYTES);

arch/x86/kernel/vm86_32.c

407

static inline int is_revectored(int nr, struct revectored_struct *bitmap)

arch/x86/kernel/vm86_32.c

409

return test_bit(nr, bitmap->__map);

arch/x86/kvm/hyperv.c

1803

u64 *bitmap;

arch/x86/kvm/hyperv.c

1813

bitmap = (u64 *)vcpu_mask;

arch/x86/kvm/hyperv.c

1815

bitmap = vp_bitmap;

arch/x86/kvm/hyperv.c

1822

memset(bitmap, 0, sizeof(vp_bitmap));

arch/x86/kvm/hyperv.c

1825

bitmap[bank] = sparse_banks[sbank++];

arch/x86/kvm/lapic.c

1100

const unsigned long *bitmap, u32 bitmap_size)

arch/x86/kvm/lapic.c

1102

int idx = find_nth_bit(bitmap, bitmap_size, vector % dest_vcpus);

arch/x86/kvm/lapic.c

1155

unsigned long *bitmap)

arch/x86/kvm/lapic.c

1161

*bitmap = 1;

arch/x86/kvm/lapic.c

1171

*bitmap = 0;

arch/x86/kvm/lapic.c

1175

*bitmap = 1;

arch/x86/kvm/lapic.c

1180

*bitmap = 0;

arch/x86/kvm/lapic.c

1182

(u16 *)bitmap))

arch/x86/kvm/lapic.c

1190

for_each_set_bit(i, bitmap, 16) {

arch/x86/kvm/lapic.c

1200

if (!*bitmap)

arch/x86/kvm/lapic.c

1203

lowest = kvm_vector_to_index(irq->vector, hweight16(*bitmap),

arch/x86/kvm/lapic.c

1204

bitmap, 16);

arch/x86/kvm/lapic.c

1208

*bitmap = 0;

arch/x86/kvm/lapic.c

1213

*bitmap = (lowest >= 0) ? 1 << lowest : 0;

arch/x86/kvm/lapic.c

1223

unsigned long bitmap;

arch/x86/kvm/lapic.c

1242

ret = kvm_apic_map_get_dest_lapic(kvm, &src, irq, map, &dst, &bitmap);

arch/x86/kvm/lapic.c

1245

for_each_set_bit(i, &bitmap, 16) {

arch/x86/kvm/lapic.c

1282

unsigned long bitmap;

arch/x86/kvm/lapic.c

1292

if (kvm_apic_map_get_dest_lapic(kvm, NULL, irq, map, &dst, &bitmap) &&

arch/x86/kvm/lapic.c

1293

hweight16(bitmap) == 1) {

arch/x86/kvm/lapic.c

1294

unsigned long i = find_first_bit(&bitmap, 16);

arch/x86/kvm/lapic.c

1506

unsigned long bitmap, i;

arch/x86/kvm/lapic.c

1514

&bitmap);

arch/x86/kvm/lapic.c

1516

for_each_set_bit(i, &bitmap, 16) {

arch/x86/kvm/lapic.c

1917

void *bitmap = apic->regs + APIC_ISR;

arch/x86/kvm/lapic.c

1920

bitmap = apic->regs + APIC_IRR;

arch/x86/kvm/lapic.c

1922

if (apic_test_vector(vec, bitmap))

arch/x86/kvm/lapic.c

650

static u8 count_vectors(void *bitmap)

arch/x86/kvm/lapic.c

657

reg = bitmap + APIC_VECTOR_TO_REG_OFFSET(vec);

arch/x86/kvm/pmu.c

1105

DECLARE_BITMAP(bitmap, X86_PMC_IDX_MAX);

arch/x86/kvm/pmu.c

1116

bitmap_copy(bitmap, event_pmcs, X86_PMC_IDX_MAX);

arch/x86/kvm/pmu.c

1117

else if (!bitmap_and(bitmap, event_pmcs,

arch/x86/kvm/pmu.c

1122

kvm_for_each_pmc(pmu, pmc, i, bitmap) {

arch/x86/kvm/pmu.c

636

DECLARE_BITMAP(bitmap, X86_PMC_IDX_MAX);

arch/x86/kvm/pmu.c

641

bitmap_copy(bitmap, pmu->reprogram_pmi, X86_PMC_IDX_MAX);

arch/x86/kvm/pmu.c

648

BUILD_BUG_ON(sizeof(bitmap) != sizeof(atomic64_t));

arch/x86/kvm/pmu.c

649

atomic64_andnot(*(s64 *)bitmap, &pmu->__reprogram_pmi);

arch/x86/kvm/pmu.c

651

kvm_for_each_pmc(pmu, pmc, bit, bitmap) {

arch/x86/kvm/pmu.c

670

kvm_for_each_pmc(pmu, pmc, bit, bitmap)

arch/x86/kvm/pmu.h

105

#define kvm_for_each_pmc(pmu, pmc, i, bitmap) \

arch/x86/kvm/pmu.h

106

for_each_set_bit(i, bitmap, X86_PMC_IDX_MAX) \

arch/x86/kvm/svm/avic.c

545

unsigned long bitmap, i;

arch/x86/kvm/svm/avic.c

550

bitmap = dest & 0xFFFF;

arch/x86/kvm/svm/avic.c

554

bitmap = dest;

arch/x86/kvm/svm/avic.c

558

bitmap = dest & 0xF;

arch/x86/kvm/svm/avic.c

563

if (unlikely(!bitmap))

arch/x86/kvm/svm/avic.c

576

for_each_set_bit(i, &bitmap, 16)

arch/x86/kvm/svm/svm.h

684

static inline rtype svm_##action##_msr_bitmap_##access(unsigned long *bitmap, \

arch/x86/kvm/svm/svm.h

693

return bitop##_bit(bit_nr + bit_rw, bitmap); \

arch/x86/kvm/vmx/nested.c

6227

gpa_t bitmap, last_bitmap;

arch/x86/kvm/vmx/nested.c

6235

bitmap = vmcs12->io_bitmap_a;

arch/x86/kvm/vmx/nested.c

6237

bitmap = vmcs12->io_bitmap_b;

arch/x86/kvm/vmx/nested.c

6240

bitmap += (port & 0x7fff) / 8;

arch/x86/kvm/vmx/nested.c

6242

if (last_bitmap != bitmap)

arch/x86/kvm/vmx/nested.c

6243

if (kvm_vcpu_read_guest(vcpu, bitmap, &b, 1))

arch/x86/kvm/vmx/nested.c

6250

last_bitmap = bitmap;

arch/x86/kvm/vmx/nested.c

6285

gpa_t bitmap;

arch/x86/kvm/vmx/nested.c

6301

bitmap = vmcs12->msr_bitmap;

arch/x86/kvm/vmx/nested.c

6304

bitmap += 2048;

arch/x86/kvm/vmx/nested.c

6307

bitmap += 1024;

arch/x86/kvm/vmx/nested.c

6313

if (kvm_vcpu_read_guest(vcpu, bitmap + msr_index/8, &b, 1))

arch/x86/kvm/vmx/nested.c

6411

struct vmcs12 *vmcs12, gpa_t bitmap)

arch/x86/kvm/vmx/nested.c

6428

if (kvm_vcpu_read_guest(vcpu, bitmap + field/8, &b, 1))

arch/x86/kvm/vmx/sgx.c

477

u64 bitmap = -1ull;

arch/x86/kvm/vmx/sgx.c

486

bitmap &= ~GENMASK_ULL(ETRACK, ECREATE);

arch/x86/kvm/vmx/sgx.c

488

bitmap |= (1 << ECREATE);

arch/x86/kvm/vmx/sgx.c

492

bitmap &= ~GENMASK_ULL(EMODT, EAUG);

arch/x86/kvm/vmx/sgx.c

502

bitmap |= (1 << EINIT);

arch/x86/kvm/vmx/sgx.c

507

bitmap |= vmcs12->encls_exiting_bitmap;

arch/x86/kvm/vmx/sgx.c

509

vmcs_write64(ENCLS_EXITING_BITMAP, bitmap);

arch/x86/kvm/vmx/vmx.h

438

static inline rtype vmx_##action##_msr_bitmap_##access(unsigned long *bitmap, \

arch/x86/kvm/vmx/vmx.h

444

return bitop##_bit(msr, bitmap + base / f); \

arch/x86/kvm/vmx/vmx.h

446

return bitop##_bit(msr & 0x1fff, bitmap + (base + 0x400) / f); \

arch/x86/kvm/x86.c

1827

unsigned long *bitmap = ranges[i].bitmap;

arch/x86/kvm/x86.c

1830

allowed = test_bit(index - start, bitmap);

arch/x86/kvm/x86.c

7012

kfree(msr_filter->ranges[i].bitmap);

arch/x86/kvm/x86.c

7020

unsigned long *bitmap;

arch/x86/kvm/x86.c

7036

bitmap = memdup_user((__user u8*)user_range->bitmap, bitmap_size);

arch/x86/kvm/x86.c

7037

if (IS_ERR(bitmap))

arch/x86/kvm/x86.c

7038

return PTR_ERR(bitmap);

arch/x86/kvm/x86.c

7044

.bitmap = bitmap,

arch/x86/kvm/x86.c

7105

__u32 bitmap;

arch/x86/kvm/x86.c

7142

.bitmap = (__u8 *)(ulong)cr->bitmap,

arch/x86/pci/irq.c

1428

mask = info->irq[pin - 1].bitmap;

arch/x86/pci/irq.c

224

DBG(" %d:%02x/%04x", j, e->irq[j].link, e->irq[j].bitmap);

arch/x86/xen/enlighten_pv.c

1022

.bitmap = NULL,

arch/x86/xen/enlighten_pv.c

1037

iobitmap.bitmap = (uint8_t *)(&tss->x86_tss) +

block/blk-mq-tag.c

266

static bool bt_iter(struct sbitmap *bitmap, unsigned int bitnr, void *data)

block/blk-mq-tag.c

338

static bool bt_tags_iter(struct sbitmap *bitmap, unsigned int bitnr, void *data)

drivers/accel/amdxdna/aie2_message.c

364

u32 *bitmap = arg;

drivers/accel/amdxdna/aie2_message.c

366

*bitmap |= GENMASK(hwctx->start_col + hwctx->num_col - 1, hwctx->start_col);

drivers/block/drbd/drbd_bitmap.c

1066

struct drbd_bitmap *b = device->bitmap;

drivers/block/drbd/drbd_bitmap.c

115

struct drbd_bitmap *b = device->bitmap;

drivers/block/drbd/drbd_bitmap.c

126

struct drbd_bitmap *b = device->bitmap;

drivers/block/drbd/drbd_bitmap.c

1295

struct drbd_bitmap *b = device->bitmap;

drivers/block/drbd/drbd_bitmap.c

1335

struct drbd_bitmap *b = device->bitmap;

drivers/block/drbd/drbd_bitmap.c

1389

struct drbd_bitmap *b = device->bitmap;

drivers/block/drbd/drbd_bitmap.c

1439

struct drbd_bitmap *b = device->bitmap;

drivers/block/drbd/drbd_bitmap.c

1511

struct drbd_bitmap *b = device->bitmap;

drivers/block/drbd/drbd_bitmap.c

153

struct drbd_bitmap *b = device->bitmap;

drivers/block/drbd/drbd_bitmap.c

1546

bm_set_full_words_within_one_page(device->bitmap, page_nr, first_word, last_word);

drivers/block/drbd/drbd_bitmap.c

1562

bm_set_full_words_within_one_page(device->bitmap, last_page, first_word, last_word);

drivers/block/drbd/drbd_bitmap.c

1584

struct drbd_bitmap *b = device->bitmap;

drivers/block/drbd/drbd_bitmap.c

159

if (!(BM_LOCKED_MASK & device->bitmap->bm_flags))

drivers/block/drbd/drbd_bitmap.c

1615

struct drbd_bitmap *b = device->bitmap;

drivers/block/drbd/drbd_bitmap.c

1669

struct drbd_bitmap *b = device->bitmap;

drivers/block/drbd/drbd_bitmap.c

213

struct drbd_bitmap *b = device->bitmap;

drivers/block/drbd/drbd_bitmap.c

220

struct drbd_bitmap *b = device->bitmap;

drivers/block/drbd/drbd_bitmap.c

223

wake_up(&device->bitmap->bm_io_wait);

drivers/block/drbd/drbd_bitmap.c

242

device->bitmap->n_bitmap_hints = 0;

drivers/block/drbd/drbd_bitmap.c

256

struct drbd_bitmap *b = device->bitmap;

drivers/block/drbd/drbd_bitmap.c

258

if (page_nr >= device->bitmap->bm_number_of_pages) {

drivers/block/drbd/drbd_bitmap.c

260

page_nr, (int)device->bitmap->bm_number_of_pages);

drivers/block/drbd/drbd_bitmap.c

263

page = device->bitmap->bm_pages[page_nr];

drivers/block/drbd/drbd_bitmap.c

435

struct drbd_bitmap *b = device->bitmap;

drivers/block/drbd/drbd_bitmap.c

444

device->bitmap = b;

drivers/block/drbd/drbd_bitmap.c

451

if (!expect(device, device->bitmap))

drivers/block/drbd/drbd_bitmap.c

453

return device->bitmap->bm_dev_capacity;

drivers/block/drbd/drbd_bitmap.c

460

if (!expect(device, device->bitmap))

drivers/block/drbd/drbd_bitmap.c

462

bm_free_pages(device->bitmap->bm_pages, device->bitmap->bm_number_of_pages);

drivers/block/drbd/drbd_bitmap.c

463

bm_vk_free(device->bitmap->bm_pages);

drivers/block/drbd/drbd_bitmap.c

464

kfree(device->bitmap);

drivers/block/drbd/drbd_bitmap.c

465

device->bitmap = NULL;

drivers/block/drbd/drbd_bitmap.c

632

struct drbd_bitmap *b = device->bitmap;

drivers/block/drbd/drbd_bitmap.c

756

struct drbd_bitmap *b = device->bitmap;

drivers/block/drbd/drbd_bitmap.c

785

struct drbd_bitmap *b = device->bitmap;

drivers/block/drbd/drbd_bitmap.c

796

struct drbd_bitmap *b = device->bitmap;

drivers/block/drbd/drbd_bitmap.c

811

struct drbd_bitmap *b = device->bitmap;

drivers/block/drbd/drbd_bitmap.c

860

struct drbd_bitmap *b = device->bitmap;

drivers/block/drbd/drbd_bitmap.c

896

struct drbd_bitmap *b = device->bitmap;

drivers/block/drbd/drbd_bitmap.c

912

struct drbd_bitmap *b = device->bitmap;

drivers/block/drbd/drbd_bitmap.c

941

struct drbd_bitmap *b = device->bitmap;

drivers/block/drbd/drbd_bitmap.c

994

struct drbd_bitmap *b = device->bitmap;

drivers/block/drbd/drbd_int.h

848

struct drbd_bitmap *bitmap;

drivers/block/drbd/drbd_main.c

1249

if (!expect(device, device->bitmap))

drivers/block/drbd/drbd_main.c

2030

if (device->bitmap) {

drivers/block/drbd/drbd_main.c

2185

if (device->bitmap) /* should no longer be there. */

drivers/block/drbd/drbd_nl.c

1926

if (!device->bitmap) {

drivers/block/drbd/drbd_nl.c

2305

if (!device->bitmap) {

drivers/block/drbd/drbd_worker.c

1957

if (device->bitmap && device->ldev) {

drivers/block/null_blk/main.c

1052

__clear_bit(NULLB_PAGE_LOCK, c_page->bitmap);

drivers/block/null_blk/main.c

1053

if (test_bit(NULLB_PAGE_FREE, c_page->bitmap)) {

drivers/block/null_blk/main.c

1071

if (test_bit(i, c_page->bitmap)) {

drivers/block/null_blk/main.c

1075

__set_bit(i, t_page->bitmap);

drivers/block/null_blk/main.c

1112

if (test_bit(NULLB_PAGE_LOCK, c_pages[i]->bitmap))

drivers/block/null_blk/main.c

1115

__set_bit(NULLB_PAGE_LOCK, c_pages[i]->bitmap);

drivers/block/null_blk/main.c

1165

__set_bit(sector & SECTOR_MASK, t_page->bitmap);

drivers/block/null_blk/main.c

63

DECLARE_BITMAP(bitmap, MAP_SZ);

drivers/block/null_blk/main.c

880

memset(t_page->bitmap, 0, sizeof(t_page->bitmap));

drivers/block/null_blk/main.c

886

__set_bit(NULLB_PAGE_FREE, t_page->bitmap);

drivers/block/null_blk/main.c

887

if (test_bit(NULLB_PAGE_LOCK, t_page->bitmap))

drivers/block/null_blk/main.c

897

return find_first_bit(page->bitmap, size) == size;

drivers/block/null_blk/main.c

914

__clear_bit(sector_bit, t_page->bitmap);

drivers/block/null_blk/main.c

987

if (t_page && (for_write || test_bit(sector_bit, t_page->bitmap)))

drivers/block/xen-blkfront.c

449

unsigned long *bitmap, *old;

drivers/block/xen-blkfront.c

451

bitmap = kcalloc(BITS_TO_LONGS(end), sizeof(*bitmap),

drivers/block/xen-blkfront.c

453

if (bitmap == NULL)

drivers/block/xen-blkfront.c

459

memcpy(bitmap, minors,

drivers/block/xen-blkfront.c

460

BITS_TO_LONGS(nr_minors) * sizeof(*bitmap));

drivers/block/xen-blkfront.c

461

minors = bitmap;

drivers/block/xen-blkfront.c

464

old = bitmap;

drivers/block/zram/zram_drv.c

694

kvfree(zram->bitmap);

drivers/block/zram/zram_drv.c

695

zram->bitmap = NULL;

drivers/block/zram/zram_drv.c

732

unsigned long nr_pages, *bitmap = NULL;

drivers/block/zram/zram_drv.c

776

bitmap = kvzalloc(bitmap_sz, GFP_KERNEL);

drivers/block/zram/zram_drv.c

777

if (!bitmap) {

drivers/block/zram/zram_drv.c

786

zram->bitmap = bitmap;

drivers/block/zram/zram_drv.c

794

kvfree(bitmap);

drivers/block/zram/zram_drv.c

808

blk_idx = find_next_zero_bit(zram->bitmap, zram->nr_pages, 0);

drivers/block/zram/zram_drv.c

812

set_bit(blk_idx, zram->bitmap);

drivers/block/zram/zram_drv.c

821

was_set = test_and_clear_bit(blk_idx, zram->bitmap);

drivers/block/zram/zram_drv.h

140

unsigned long *bitmap;

drivers/comedi/drivers/ni_usb6501.c

169

unsigned int val, u8 *bitmap)

drivers/comedi/drivers/ni_usb6501.c

177

if (command != SET_PORT_DIR && !bitmap)

drivers/comedi/drivers/ni_usb6501.c

194

tx[17] = *bitmap;

drivers/comedi/drivers/ni_usb6501.c

232

*bitmap = devpriv->usb_rx_buf[14];

drivers/comedi/drivers/ni_usb6501.c

366

u8 bitmap;

drivers/comedi/drivers/ni_usb6501.c

372

bitmap = (s->state >> port * 8) & 0xFF;

drivers/comedi/drivers/ni_usb6501.c

374

port, &bitmap);

drivers/comedi/drivers/ni_usb6501.c

383

ret = ni6501_port_command(dev, READ_PORT, port, &bitmap);

drivers/comedi/drivers/ni_usb6501.c

386

data[1] |= bitmap << port * 8;

drivers/cpufreq/speedstep-lib.c

39

u8 bitmap; /* power on configuration bits

drivers/cpufreq/speedstep-lib.c

62

u8 bitmap; /* power on configuration bits [18: 19]

drivers/cpufreq/speedstep-lib.c

82

while (msr_tmp != msr_decode_fsb[i].bitmap) {

drivers/cpufreq/speedstep-lib.c

83

if (msr_decode_fsb[i].bitmap == 0xff)

drivers/cpufreq/speedstep-lib.c

95

while (msr_lo != msr_decode_mult[j].bitmap) {

drivers/cpufreq/speedstep-lib.c

96

if (msr_decode_mult[j].bitmap == 0xff)

drivers/dma/idxd/init.c

909

unsigned long *saved_wq_enable_map __free(bitmap) =

drivers/edac/imh_base.c

150

unsigned long bitmap = get_imc_bitmap(cfg, d->pkg, north);

drivers/edac/imh_base.c

156

for_each_set_bit(i, &bitmap, sizeof(bitmap) * 8) {

drivers/firmware/arm_ffa/driver.c

1240

static int ffa_notification_bind(u16 dst_id, u64 bitmap, u32 flags)

drivers/firmware/arm_ffa/driver.c

1242

return ffa_notification_bind_common(dst_id, bitmap, flags, true);

drivers/firmware/arm_ffa/driver.c

1245

static int ffa_notification_unbind(u16 dst_id, u64 bitmap)

drivers/firmware/arm_ffa/driver.c

1247

return ffa_notification_bind_common(dst_id, bitmap, 0, false);

drivers/firmware/arm_ffa/driver.c

1446

static void handle_notif_callbacks(u64 bitmap, enum notify_type type)

drivers/firmware/arm_ffa/driver.c

1451

for (notify_id = 0; notify_id <= FFA_MAX_NOTIFICATIONS && bitmap;

drivers/firmware/arm_ffa/driver.c

1452

notify_id++, bitmap >>= 1) {

drivers/firmware/arm_ffa/driver.c

1453

if (!(bitmap & 1))

drivers/firmware/arm_ffa/driver.c

1465

static void handle_fwk_notif_callbacks(u32 bitmap)

drivers/firmware/arm_ffa/driver.c

1474

if (!(bitmap & FRAMEWORK_NOTIFY_RX_BUFFER_FULL))

drivers/firmware/arm_ffa/driver.c

879

static int ffa_notification_bind_common(u16 dst_id, u64 bitmap,

drivers/firmware/arm_ffa/driver.c

889

.a3 = NOTIFICATION_BITMAP_LOW(bitmap),

drivers/firmware/arm_ffa/driver.c

890

.a4 = NOTIFICATION_BITMAP_HIGH(bitmap),

drivers/firmware/arm_ffa/driver.c

902

int ffa_notification_set(u16 src_id, u16 dst_id, u32 flags, u64 bitmap)

drivers/firmware/arm_ffa/driver.c

909

.a3 = NOTIFICATION_BITMAP_LOW(bitmap),

drivers/firmware/arm_ffa/driver.c

910

.a4 = NOTIFICATION_BITMAP_HIGH(bitmap),

drivers/firmware/efi/libstub/unaccepted_memory.c

176

bitmap_set(unaccepted_table->bitmap,

drivers/firmware/efi/libstub/unaccepted_memory.c

213

unaccepted_table->bitmap, bitmap_size) {

drivers/firmware/efi/libstub/unaccepted_memory.c

220

bitmap_clear(unaccepted_table->bitmap,

drivers/firmware/efi/libstub/unaccepted_memory.c

77

memset(unaccepted_table->bitmap, 0, bitmap_size);

drivers/firmware/efi/unaccepted_memory.c

130

for_each_set_bitrange_from(range_start, range_end, unaccepted->bitmap,

drivers/firmware/efi/unaccepted_memory.c

153

bitmap_clear(unaccepted->bitmap, range_start, len);

drivers/firmware/efi/unaccepted_memory.c

206

if (test_bit(start / unit_size, unaccepted->bitmap)) {

drivers/gpio/gpio-aggregator.c

1360

unsigned long *bitmap __free(bitmap) =

drivers/gpio/gpio-aggregator.c

1362

if (!bitmap)

drivers/gpio/gpio-aggregator.c

1396

error = bitmap_parselist(offsets, bitmap, AGGREGATOR_MAX_GPIOS);

drivers/gpio/gpio-aggregator.c

1402

for_each_set_bit(i, bitmap, AGGREGATOR_MAX_GPIOS) {

drivers/gpio/gpio-usbio.c

18

u32 bitmap;

drivers/gpio/gpio-usbio.c

205

gpio->banks[bank].bitmap = le32_to_cpu(bank_desc[bank].bmap);

drivers/gpio/gpio-usbio.c

48

if (~bank->bitmap & BIT(pin)) {

drivers/gpio/gpio-virtuser.c

162

unsigned long *values __free(bitmap) = bitmap_zalloc(descs->ndescs,

drivers/gpio/gpio-virtuser.c

250

unsigned long *values __free(bitmap) = bitmap_zalloc(descs->ndescs,

drivers/gpu/drm/amd/amdgpu/amdgpu_gfx.h

313

uint32_t bitmap[AMDGPU_MAX_GC_INSTANCES][4][4];

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

1022

memcpy(&dev_info->cu_bitmap[0], &adev->gfx.cu_info.bitmap[0],

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

10056

u32 bitmap)

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

10060

if (!bitmap)

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

10063

data = bitmap << GC_USER_SHADER_ARRAY_CONFIG__INACTIVE_WGPS__SHIFT;

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

10111

u32 mask, bitmap, ao_bitmap, ao_cu_mask = 0;

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

10122

bitmap = i * adev->gfx.config.max_sh_per_se + j;

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

10131

((gfx_v10_3_get_disabled_sa(adev) >> bitmap) & 1))

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

10140

bitmap = gfx_v10_0_get_cu_active_bitmap_per_sh(adev);

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

10141

cu_info->bitmap[0][i][j] = bitmap;

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

10144

if (bitmap & mask) {

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

5105

u32 bitmap;

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

5112

bitmap = i * adev->gfx.config.max_sh_per_se + j;

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

5119

((gfx_v10_3_get_disabled_sa(adev) >> bitmap) & 1))

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

7432

u32 bitmap)

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

7436

if (!bitmap)

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

7439

data = bitmap << GC_USER_SHADER_ARRAY_CONFIG__INACTIVE_WGPS__SHIFT;

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

7482

u32 mask, bitmap;

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

7493

bitmap = i * adev->gfx.config.max_sh_per_se + j;

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

7494

if (!((gfx_v11_0_get_sa_active_bitmap(adev) >> bitmap) & 1))

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

7502

bitmap = gfx_v11_0_get_cu_active_bitmap_per_sh(adev);

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

7519

cu_info->bitmap[0][i % 4][j + (i / 4) * 2] = bitmap;

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

7522

if (bitmap & mask)

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

5666

u32 bitmap)

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

5670

if (!bitmap)

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

5673

data = bitmap << GC_USER_SHADER_ARRAY_CONFIG__INACTIVE_WGPS__SHIFT;

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

5716

u32 mask, bitmap;

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

5727

bitmap = i * adev->gfx.config.max_sh_per_se + j;

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

5728

if (!((gfx_v12_0_get_sa_active_bitmap(adev) >> bitmap) & 1))

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

5736

bitmap = gfx_v12_0_get_cu_active_bitmap_per_sh(adev);

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

5753

cu_info->bitmap[0][i % 4][j + (i / 4) * 2] = bitmap;

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

5756

if (bitmap & mask)

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

3927

u32 bitmap, int xcc_id)

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

3931

if (!bitmap)

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

3934

data = bitmap << GC_USER_SHADER_ARRAY_CONFIG__INACTIVE_WGPS__SHIFT;

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

3960

u32 mask, bitmap;

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

3983

bitmap = i * adev->gfx.config.max_sh_per_se + j;

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

3984

if (!((gfx_v12_1_get_sa_active_bitmap(adev, xcc_id) >> bitmap) & 1))

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

3993

bitmap = gfx_v12_1_get_cu_active_bitmap_per_sh(adev, xcc_id);

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

3995

cu_info->bitmap[xcc_id][i][j] = bitmap;

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

3998

if (bitmap & mask)

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

1521

u32 bitmap)

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

1525

if (!bitmap)

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

1528

data = bitmap << GC_USER_SHADER_ARRAY_CONFIG__INACTIVE_CUS__SHIFT;

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

3546

u32 mask, bitmap, ao_bitmap, ao_cu_mask = 0;

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

3570

bitmap = gfx_v6_0_get_cu_enabled(adev);

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

3571

cu_info->bitmap[0][i][j] = bitmap;

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

3574

if (bitmap & mask) {

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

3719

u32 bitmap)

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

3723

if (!bitmap)

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

3726

data = bitmap << GC_USER_SHADER_ARRAY_CONFIG__INACTIVE_CUS__SHIFT;

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

5054

u32 mask, bitmap, ao_bitmap, ao_cu_mask = 0;

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

5078

bitmap = gfx_v7_0_get_cu_active_bitmap(adev);

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

5079

cu_info->bitmap[0][i][j] = bitmap;

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

5082

if (bitmap & mask) {

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

7047

u32 bitmap)

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

7051

if (!bitmap)

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

7054

data = bitmap << GC_USER_SHADER_ARRAY_CONFIG__INACTIVE_CUS__SHIFT;

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

7075

u32 mask, bitmap, ao_bitmap, ao_cu_mask = 0;

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

7099

bitmap = gfx_v8_0_get_cu_active_bitmap(adev);

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

7100

cu_info->bitmap[0][i][j] = bitmap;

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

7103

if (bitmap & mask) {

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

1690

if (cu_info->bitmap[0][i][j] & mask) {

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

7814

u32 bitmap)

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

7818

if (!bitmap)

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

7821

data = bitmap << GC_USER_SHADER_ARRAY_CONFIG__INACTIVE_CUS__SHIFT;

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

7846

u32 mask, bitmap, ao_bitmap, ao_cu_mask = 0;

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

7872

bitmap = gfx_v9_0_get_cu_active_bitmap(adev);

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

7886

cu_info->bitmap[0][i % 4][j + i / 4] = bitmap;

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

7889

if (bitmap & mask) {

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

4860

u32 bitmap, int xcc_id)

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

4864

if (!bitmap)

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

4867

data = bitmap << GC_USER_SHADER_ARRAY_CONFIG__INACTIVE_CUS__SHIFT;

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

4892

u32 mask, bitmap, ao_bitmap, ao_cu_mask = 0, tmp;

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

4923

bitmap = gfx_v9_4_3_get_cu_active_bitmap(adev, xcc_id);

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

4925

cu_info->bitmap[xcc_id][i][j] = bitmap;

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

4928

if (bitmap & mask) {

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

686

uint32_t bitmap;

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

712

bitmap = 0x2 | (0x4 << (mapped_xcc % 4));

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

714

bitmap = bitmap << 8;

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

715

node->interrupt_bitmap |= bitmap;

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

152

cu_info->bitmap[xcc_inst][se % 4][sh + (se / 4) *

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

68

cu_info->bitmap[xcc_inst][se][sh]);

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

1512

unsigned long *bitmap, bool wait, bool flush_tlb)

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

1525

for_each_set_bit(gpuidx, bitmap, MAX_GPU_INSTANCE) {

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

1570

DECLARE_BITMAP(bitmap, MAX_GPU_INSTANCE);

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

1583

for_each_set_bit(gpuidx, ctx->bitmap, MAX_GPU_INSTANCE) {

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

1601

for_each_set_bit(gpuidx, ctx->bitmap, MAX_GPU_INSTANCE) {

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

1685

bitmap_zero(ctx->bitmap, MAX_GPU_INSTANCE);

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

1686

bitmap_set(ctx->bitmap, gpuidx, 1);

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

1688

bitmap_copy(ctx->bitmap, prange->bitmap_aip, MAX_GPU_INSTANCE);

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

1704

bitmap_set(ctx->bitmap, gpuidx, 1);

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

1711

if (bitmap_empty(ctx->bitmap, MAX_GPU_INSTANCE)) {

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

1714

bitmap_copy(ctx->bitmap, prange->bitmap_access, MAX_GPU_INSTANCE);

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

1717

bitmap_or(ctx->bitmap, prange->bitmap_access,

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

1721

if (bitmap_empty(ctx->bitmap, MAX_GPU_INSTANCE)) {

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

1740

owner = kfd_svm_page_owner(p, find_first_bit(ctx->bitmap,

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

1742

for_each_set_bit(idx, ctx->bitmap, MAX_GPU_INSTANCE) {

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

1806

r = svm_range_dma_map(prange, ctx->bitmap, offset, npages,

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

1838

ctx->bitmap, wait, flush_tlb);

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

207

svm_range_dma_map(struct svm_range *prange, unsigned long *bitmap,

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

217

for_each_set_bit(gpuidx, bitmap, MAX_GPU_INSTANCE) {

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

3503

DECLARE_BITMAP(bitmap, MAX_GPU_INSTANCE);

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

3528

bitmap_copy(bitmap, prange->bitmap_aip, MAX_GPU_INSTANCE);

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

3530

bitmap_or(bitmap, prange->bitmap_access, prange->bitmap_aip,

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

3533

for_each_set_bit(gpuidx, bitmap, MAX_GPU_INSTANCE) {

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

1702

if (cu_info->bitmap[start][i % 4][j % 4]) {

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

1704

cu_info->bitmap[start][i % 4][j % 4];

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

1765

cu_sibling_map_mask = cu_info->bitmap[xcc][i % 4][j + i / 4];

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

1830

cu_info->bitmap[xcc][i % 4][j + i / 4], ct,

drivers/gpu/drm/amd/pm/powerplay/hwmgr/vega10_hwmgr.c

2909

static int vega10_stop_dpm(struct pp_hwmgr *hwmgr, uint32_t bitmap)

drivers/gpu/drm/amd/pm/powerplay/hwmgr/vega10_hwmgr.c

2925

if (data->smu_features[i].smu_feature_bitmap & bitmap) {

drivers/gpu/drm/amd/pm/powerplay/hwmgr/vega10_hwmgr.c

2946

static int vega10_start_dpm(struct pp_hwmgr *hwmgr, uint32_t bitmap)

drivers/gpu/drm/amd/pm/powerplay/hwmgr/vega10_hwmgr.c

2952

if (data->smu_features[i].smu_feature_bitmap & bitmap) {

drivers/gpu/drm/i915/display/intel_display_device.c

1640

return sizeof(((struct intel_display_platforms *)0)->bitmap) * BITS_PER_BYTE;

drivers/gpu/drm/i915/display/intel_display_device.c

1646

return bitmap_weight(p->bitmap, display_platforms_num_bits());

drivers/gpu/drm/i915/display/intel_display_device.c

1653

bitmap_or(dst->bitmap, dst->bitmap, src->bitmap, display_platforms_num_bits());

drivers/gpu/drm/i915/display/intel_display_device.h

121

DECLARE_BITMAP(bitmap, __NUM_PLATFORMS);

drivers/gpu/drm/i915/i915_syncmap.c

189

if (!(p->bitmap & BIT(idx)))

drivers/gpu/drm/i915/i915_syncmap.c

206

p->bitmap = 0;

drivers/gpu/drm/i915/i915_syncmap.c

215

p->bitmap |= BIT(idx);

drivers/gpu/drm/i915/i915_syncmap.c

223

p->bitmap |= BIT(idx);

drivers/gpu/drm/i915/i915_syncmap.c

296

GEM_BUG_ON(!(p->parent->bitmap & BIT(idx)));

drivers/gpu/drm/i915/i915_syncmap.c

370

while ((i = ffs(p->bitmap))) {

drivers/gpu/drm/i915/i915_syncmap.c

371

p->bitmap &= ~0u << i;

drivers/gpu/drm/i915/i915_syncmap.c

76

unsigned int bitmap;

drivers/gpu/drm/i915/i915_syncmap.c

92

BUILD_BUG_ON(KSYNCMAP > BITS_PER_TYPE((*root)->bitmap));

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

183

if (hweight32((*sync)->bitmap) != 1) {

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

185

(*sync)->bitmap, hweight32((*sync)->bitmap));

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

189

err = check_seqno((*sync), ilog2((*sync)->bitmap), seqno);

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

252

if (hweight32((*sync)->bitmap) != 1) {

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

254

context, (*sync)->bitmap, hweight32((*sync)->bitmap));

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

258

err = check_seqno((*sync), ilog2((*sync)->bitmap), seqno);

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

314

if (hweight32(join->bitmap) != 2) {

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

316

join->bitmap, hweight32(join->bitmap));

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

432

if (sync->bitmap != BIT(idx + 1) - 1) {

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

435

sync->bitmap, hweight32(sync->bitmap),

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

498

if (sync->bitmap != BIT(KSYNCMAP) - 1) {

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

500

sync->bitmap, hweight32(sync->bitmap),

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/i915/selftests/i915_syncmap.c

62

for_each_set_bit(i, (unsigned long *)&p->bitmap, KSYNCMAP) {

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

77

for_each_set_bit(i, (unsigned long *)&p->bitmap, KSYNCMAP) {

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

80

last << 1 | ((p->bitmap >> (i + 1)) ? 1 : 0),

drivers/gpu/drm/loongson/lsdc_gfxpll.c

54

struct loongson_gfxpll_bitmap bitmap;

drivers/gpu/drm/loongson/lsdc_gfxpll.c

94

pparms->div_ref = gfxpll_reg.bitmap.div_ref;

drivers/gpu/drm/loongson/lsdc_gfxpll.c

95

pparms->loopc = gfxpll_reg.bitmap.loopc;

drivers/gpu/drm/loongson/lsdc_gfxpll.c

97

pparms->div_out_dc = gfxpll_reg.bitmap.div_out_dc;

drivers/gpu/drm/loongson/lsdc_gfxpll.c

98

pparms->div_out_gmc = gfxpll_reg.bitmap.div_out_gmc;

drivers/gpu/drm/loongson/lsdc_gfxpll.c

99

pparms->div_out_gpu = gfxpll_reg.bitmap.div_out_gpu;

drivers/gpu/drm/loongson/lsdc_pixpll.c

280

pixpll_reg.bitmap.powerdown = 0;

drivers/gpu/drm/loongson/lsdc_pixpll.c

291

pixpll_reg.bitmap.powerdown = 1;

drivers/gpu/drm/loongson/lsdc_pixpll.c

302

pixpll_reg.bitmap.sel_out = 1;

drivers/gpu/drm/loongson/lsdc_pixpll.c

313

pixpll_reg.bitmap.sel_out = 0;

drivers/gpu/drm/loongson/lsdc_pixpll.c

324

pixpll_reg.bitmap.bypass = 1;

drivers/gpu/drm/loongson/lsdc_pixpll.c

335

pixpll_reg.bitmap.bypass = 0;

drivers/gpu/drm/loongson/lsdc_pixpll.c

346

pixpll_reg.bitmap.set_param = 0;

drivers/gpu/drm/loongson/lsdc_pixpll.c

358

pixpll_reg.bitmap.div_ref = p->div_ref;

drivers/gpu/drm/loongson/lsdc_pixpll.c

359

pixpll_reg.bitmap.loopc = p->loopc;

drivers/gpu/drm/loongson/lsdc_pixpll.c

360

pixpll_reg.bitmap.div_out = p->div_out;

drivers/gpu/drm/loongson/lsdc_pixpll.c

371

pixpll_reg.bitmap.set_param = 1;

drivers/gpu/drm/loongson/lsdc_pixpll.c

384

if (pixpll_reg.bitmap.locked)

drivers/gpu/drm/loongson/lsdc_pixpll.c

40

struct lsdc_pixpll_reg bitmap;

drivers/gpu/drm/loongson/lsdc_pixpll.c

437

ppar->div_ref = pix_pll_reg.bitmap.div_ref;

drivers/gpu/drm/loongson/lsdc_pixpll.c

438

ppar->loopc = pix_pll_reg.bitmap.loopc;

drivers/gpu/drm/loongson/lsdc_pixpll.c

439

ppar->div_out = pix_pll_reg.bitmap.div_out;

drivers/gpu/drm/omapdrm/tcm-sita.c

161

ret = r2l_b2t_1d(num_slots, &pos, tcm->bitmap, tcm->map_size);

drivers/gpu/drm/omapdrm/tcm-sita.c

181

ret = l2r_t2b(w, h, align, offset, &pos, slot_bytes, tcm->bitmap,

drivers/gpu/drm/omapdrm/tcm-sita.c

215

free_slots(pos, w, h, tcm->bitmap, tcm->width);

drivers/gpu/drm/omapdrm/tcm-sita.c

241

tcm->bitmap = (unsigned long *)(tcm + 1);

drivers/gpu/drm/omapdrm/tcm-sita.c

242

bitmap_clear(tcm->bitmap, 0, width*height);

drivers/gpu/drm/omapdrm/tcm.h

63

unsigned long *bitmap;

drivers/gpu/drm/qxl/qxl_dev.h

513

QXLPHYSICAL bitmap;

drivers/gpu/drm/qxl/qxl_dev.h

847

struct qxl_bitmap bitmap;

drivers/gpu/drm/qxl/qxl_draw.c

239

drawable->u.copy.mask.bitmap = 0;

drivers/gpu/drm/qxl/qxl_image.c

207

image->u.bitmap.format = SPICE_BITMAP_FMT_1BIT_BE;

drivers/gpu/drm/qxl/qxl_image.c

210

image->u.bitmap.format = SPICE_BITMAP_FMT_24BIT;

drivers/gpu/drm/qxl/qxl_image.c

213

image->u.bitmap.format = SPICE_BITMAP_FMT_32BIT;

drivers/gpu/drm/qxl/qxl_image.c

220

image->u.bitmap.flags = QXL_BITMAP_TOP_DOWN;

drivers/gpu/drm/qxl/qxl_image.c

221

image->u.bitmap.x = width;

drivers/gpu/drm/qxl/qxl_image.c

222

image->u.bitmap.y = height;

drivers/gpu/drm/qxl/qxl_image.c

223

image->u.bitmap.stride = chunk_stride;

drivers/gpu/drm/qxl/qxl_image.c

224

image->u.bitmap.palette = 0;

drivers/gpu/drm/qxl/qxl_image.c

225

image->u.bitmap.data = qxl_bo_physical_address(qdev, chunk_bo, 0);

drivers/gpu/drm/stm/lvds.c

779

enum lvds_pixel (*bitmap)[7];

drivers/gpu/drm/stm/lvds.c

794

bitmap = lvds_bitmap_vesa_rgb888;

drivers/gpu/drm/stm/lvds.c

797

bitmap = lvds_bitmap_jeida_rgb888;

drivers/gpu/drm/stm/lvds.c

806

lvds_dmlcr = ((bitmap[i][0])

drivers/gpu/drm/stm/lvds.c

807

+ (bitmap[i][1] << 5)

drivers/gpu/drm/stm/lvds.c

808

+ (bitmap[i][2] << 10)

drivers/gpu/drm/stm/lvds.c

809

+ (bitmap[i][3] << 15));

drivers/gpu/drm/stm/lvds.c

810

lvds_dmmcr = ((bitmap[i][4])

drivers/gpu/drm/stm/lvds.c

811

+ (bitmap[i][5] << 5)

drivers/gpu/drm/stm/lvds.c

812

+ (bitmap[i][6] << 10));

drivers/gpu/drm/vmwgfx/vmwgfx_drv.c

324

const char *prefix, uint32_t bitmap,

drivers/gpu/drm/vmwgfx/vmwgfx_drv.c

332

if ((bitmap & bnames[i].value) != 0) {

drivers/gpu/drm/vmwgfx/vmwgfx_drv.c

336

bitmap &= ~bnames[i].value;

drivers/gpu/drm/vmwgfx/vmwgfx_drv.c

341

if (bitmap != 0)

drivers/gpu/drm/vmwgfx/vmwgfx_drv.c

342

drm_dbg(drm, "%s: unknown enums: %x\n", prefix, bitmap);

drivers/gpu/drm/vmwgfx/vmwgfx_page_dirty.c

132

&dirty->bitmap[0],

drivers/gpu/drm/vmwgfx/vmwgfx_page_dirty.c

134

bitmap_clear(&dirty->bitmap[0], 0, dirty->bitmap_size);

drivers/gpu/drm/vmwgfx/vmwgfx_page_dirty.c

136

bitmap_set(&dirty->bitmap[0], dirty->start,

drivers/gpu/drm/vmwgfx/vmwgfx_page_dirty.c

183

&dirty->bitmap[0], &dirty->start,

drivers/gpu/drm/vmwgfx/vmwgfx_page_dirty.c

251

&dirty->bitmap[0],

drivers/gpu/drm/vmwgfx/vmwgfx_page_dirty.c

318

start = find_next_bit(&dirty->bitmap[0], res_end, cur);

drivers/gpu/drm/vmwgfx/vmwgfx_page_dirty.c

322

end = find_next_zero_bit(&dirty->bitmap[0], res_end, start + 1);

drivers/gpu/drm/vmwgfx/vmwgfx_page_dirty.c

325

bitmap_clear(&dirty->bitmap[0], start, num);

drivers/gpu/drm/vmwgfx/vmwgfx_page_dirty.c

354

start = find_next_bit(&dirty->bitmap[0], res_end, cur);

drivers/gpu/drm/vmwgfx/vmwgfx_page_dirty.c

358

end = find_next_zero_bit(&dirty->bitmap[0], res_end, start + 1);

drivers/gpu/drm/vmwgfx/vmwgfx_page_dirty.c

361

bitmap_clear(&dirty->bitmap[0], start, num);

drivers/gpu/drm/vmwgfx/vmwgfx_page_dirty.c

393

bitmap_clear(&dirty->bitmap[0], res_start, res_end - res_start);

drivers/gpu/drm/vmwgfx/vmwgfx_page_dirty.c

429

!test_bit(page_offset, &vbo->dirty->bitmap[0])) {

drivers/gpu/drm/vmwgfx/vmwgfx_page_dirty.c

432

__set_bit(page_offset, &dirty->bitmap[0]);

drivers/gpu/drm/vmwgfx/vmwgfx_page_dirty.c

52

unsigned long bitmap[];

drivers/gpu/drm/vmwgfx/vmwgfx_page_dirty.c

78

offset, &dirty->bitmap[0],

drivers/gpu/drm/vmwgfx/vmwgfx_page_dirty.c

92

offset, &dirty->bitmap[0],

drivers/gpu/drm/xe/tests/xe_guc_id_mgr_test.c

47

KUNIT_EXPECT_NOT_NULL(test, idm->bitmap);

drivers/gpu/drm/xe/tests/xe_guc_id_mgr_test.c

50

KUNIT_EXPECT_NULL(test, idm->bitmap);

drivers/gpu/drm/xe/xe_guc_db_mgr.c

100

dbm->bitmap = bitmap_zalloc(count, GFP_KERNEL);

drivers/gpu/drm/xe/xe_guc_db_mgr.c

101

if (!dbm->bitmap)

drivers/gpu/drm/xe/xe_guc_db_mgr.c

129

used = bitmap_weight(dbm->bitmap, dbm->count);

drivers/gpu/drm/xe/xe_guc_db_mgr.c

134

index = bitmap_find_next_zero_area(dbm->bitmap, dbm->count, 0, count, 0);

drivers/gpu/drm/xe/xe_guc_db_mgr.c

138

bitmap_set(dbm->bitmap, index, count);

drivers/gpu/drm/xe/xe_guc_db_mgr.c

156

dbm_assert(dbm, test_bit(start + n, dbm->bitmap));

drivers/gpu/drm/xe/xe_guc_db_mgr.c

158

bitmap_clear(dbm->bitmap, start, count);

drivers/gpu/drm/xe/xe_guc_db_mgr.c

231

if (!dbm->bitmap)

drivers/gpu/drm/xe/xe_guc_db_mgr.c

235

for_each_clear_bitrange(rs, re, dbm->bitmap, dbm->count) {

drivers/gpu/drm/xe/xe_guc_db_mgr.c

243

for_each_set_bitrange(rs, re, dbm->bitmap, dbm->count) {

drivers/gpu/drm/xe/xe_guc_db_mgr.c

58

weight = bitmap_weight(dbm->bitmap, dbm->count);

drivers/gpu/drm/xe/xe_guc_db_mgr.c

67

bitmap_free(dbm->bitmap);

drivers/gpu/drm/xe/xe_guc_db_mgr.c

68

dbm->bitmap = NULL;

drivers/gpu/drm/xe/xe_guc_db_mgr.c

94

dbm_assert(dbm, !dbm->bitmap);

drivers/gpu/drm/xe/xe_guc_id_mgr.c

105

static unsigned int find_last_zero_area(unsigned long *bitmap,

drivers/gpu/drm/xe/xe_guc_id_mgr.c

112

for_each_clear_bitrange(rs, re, bitmap, total) {

drivers/gpu/drm/xe/xe_guc_id_mgr.c

142

id = find_last_zero_area(idm->bitmap, idm->total, count);

drivers/gpu/drm/xe/xe_guc_id_mgr.c

148

id = bitmap_find_next_zero_area(idm->bitmap, idm->total, 0, count, 0);

drivers/gpu/drm/xe/xe_guc_id_mgr.c

153

bitmap_set(idm->bitmap, id, count);

drivers/gpu/drm/xe/xe_guc_id_mgr.c

172

idm_assert(idm, test_bit(start + n, idm->bitmap));

drivers/gpu/drm/xe/xe_guc_id_mgr.c

174

bitmap_clear(idm->bitmap, start, count);

drivers/gpu/drm/xe/xe_guc_id_mgr.c

257

if (!idm->bitmap)

drivers/gpu/drm/xe/xe_guc_id_mgr.c

261

for_each_set_bitrange(rs, re, idm->bitmap, idm->total)

drivers/gpu/drm/xe/xe_guc_id_mgr.c

44

unsigned int weight = bitmap_weight(idm->bitmap, idm->total);

drivers/gpu/drm/xe/xe_guc_id_mgr.c

55

bitmap_free(idm->bitmap);

drivers/gpu/drm/xe/xe_guc_id_mgr.c

56

idm->bitmap = NULL;

drivers/gpu/drm/xe/xe_guc_id_mgr.c

80

idm_assert(idm, !idm->bitmap);

drivers/gpu/drm/xe/xe_guc_id_mgr.c

91

idm->bitmap = bitmap_zalloc(limit, GFP_KERNEL);

drivers/gpu/drm/xe/xe_guc_id_mgr.c

92

if (!idm->bitmap)

drivers/gpu/drm/xe/xe_guc_types.h

33

unsigned long *bitmap;

drivers/gpu/drm/xe/xe_guc_types.h

44

unsigned long *bitmap;

drivers/hid/hid-picolcd.h

122

u8 *bitmap; /* framebuffer */

drivers/hid/hid-picolcd_fb.c

141

static int picolcd_fb_update_tile(u8 *vbitmap, const u8 *bitmap, int bpp,

drivers/hid/hid-picolcd_fb.c

150

const u8 *bdata = bitmap + tile * 256 + chip * 8 + b * 32;

drivers/hid/hid-picolcd_fb.c

158

const u8 *bdata = bitmap + (tile * 256 + chip * 8 + b * 32) * 8;

drivers/hid/hid-picolcd_fb.c

211

memset(fbdata->bitmap, 0, PICOLCDFB_SIZE*fbdata->bpp);

drivers/hid/hid-picolcd_fb.c

250

fbdata->vbitmap, fbdata->bitmap,

drivers/hid/hid-picolcd_fb.c

338

o_fb = fbdata->bitmap;

drivers/hid/hid-picolcd_fb.c

511

fbdata->bitmap = vmalloc(PICOLCDFB_SIZE*8);

drivers/hid/hid-picolcd_fb.c

512

if (fbdata->bitmap == NULL) {

drivers/hid/hid-picolcd_fb.c

517

info->screen_buffer = fbdata->bitmap;

drivers/hid/hid-picolcd_fb.c

518

info->fix.smem_start = (unsigned long)fbdata->bitmap;

drivers/hid/hid-picolcd_fb.c

550

vfree(fbdata->bitmap);

drivers/hv/channel.c

621

unsigned long *bitmap;

drivers/hv/channel.c

627

bitmap = bitmap_zalloc(size, GFP_KERNEL);

drivers/hv/channel.c

628

if (!bitmap) {

drivers/hv/channel.c

634

rqstor->req_bitmap = bitmap;

drivers/hwtracing/stm/core.c

221

static int find_free_channels(unsigned long *bitmap, unsigned int start,

drivers/hwtracing/stm/core.c

228

pos = find_next_zero_bit(bitmap, end + 1, pos);

drivers/hwtracing/stm/core.c

235

for (i = 1; i < width && !test_bit(pos + i, bitmap); i++)

drivers/iio/adc/ad7191.c

318

DECLARE_BITMAP(bitmap, 2) = { };

drivers/iio/adc/ad7191.c

322

bitmap_write(bitmap, gain_index, 0, 2);

drivers/iio/adc/ad7191.c

324

return gpiod_multi_set_value_cansleep(st->pga_gpios, bitmap);

drivers/iio/adc/ad7191.c

329

DECLARE_BITMAP(bitmap, 2) = {};

drivers/iio/adc/ad7191.c

333

bitmap_write(bitmap, samp_freq_index, 0, 2);

drivers/iio/adc/ad7191.c

335

return gpiod_multi_set_value_cansleep(st->odr_gpios, bitmap);

drivers/iio/adc/ad7768-1.c

725

DECLARE_BITMAP(bitmap, ADAQ7768_PGA_PINS) = { };

drivers/iio/adc/ad7768-1.c

730

bitmap_write(bitmap, pgia_pins_value, 0, ADAQ7768_PGA_PINS);

drivers/iio/adc/ad7768-1.c

731

ret = gpiod_multi_set_value_cansleep(st->pga_gpios, bitmap);

drivers/iio/resolver/ad2s1210.c

1431

DECLARE_BITMAP(bitmap, 2) = { };

drivers/iio/resolver/ad2s1210.c

1475

bitmap_write(bitmap, st->resolution, 0, 2);

drivers/iio/resolver/ad2s1210.c

1477

ret = gpiod_multi_set_value_cansleep(resolution_gpios, bitmap);

drivers/iio/resolver/ad2s1210.c

179

DECLARE_BITMAP(bitmap, 2) = { };

drivers/iio/resolver/ad2s1210.c

184

bitmap_write(bitmap, mode, 0, 2);

drivers/iio/resolver/ad2s1210.c

186

return gpiod_multi_set_value_cansleep(gpios, bitmap);

drivers/infiniband/hw/erdma/erdma.h

171

unsigned long *bitmap;

drivers/infiniband/hw/erdma/erdma_main.c

452

dev->res_cb[i].bitmap =

drivers/infiniband/hw/erdma/erdma_main.c

454

if (!dev->res_cb[i].bitmap)

drivers/infiniband/hw/erdma/erdma_main.c

462

bitmap_free(dev->res_cb[j].bitmap);

drivers/infiniband/hw/erdma/erdma_main.c

472

bitmap_free(dev->res_cb[i].bitmap);

drivers/infiniband/hw/erdma/erdma_verbs.c

261

idx = find_next_zero_bit(res_cb->bitmap, res_cb->max_cap,

drivers/infiniband/hw/erdma/erdma_verbs.c

264

idx = find_first_zero_bit(res_cb->bitmap, res_cb->max_cap);

drivers/infiniband/hw/erdma/erdma_verbs.c

272

set_bit(idx, res_cb->bitmap);

drivers/infiniband/hw/erdma/erdma_verbs.c

285

used = __test_and_clear_bit(idx, res_cb->bitmap);

drivers/infiniband/hw/hns/hns_roce_device.h

449

unsigned long *bitmap;

drivers/infiniband/hw/hns/hns_roce_device.h

480

struct hns_roce_bitmap bitmap;

drivers/infiniband/hw/hns/hns_roce_hw_v2.c

1059

bitmap_clear(srq->idx_que.bitmap, wqe_index, 1);

drivers/infiniband/hw/hns/hns_roce_hw_v2.c

1098

pos = find_first_zero_bit(idx_que->bitmap, srq->wqe_cnt);

drivers/infiniband/hw/hns/hns_roce_hw_v2.c

1102

bitmap_set(idx_que->bitmap, pos, 1);

drivers/infiniband/hw/hns/hns_roce_srq.c

191

idx_que->bitmap = bitmap_zalloc(srq->wqe_cnt, GFP_KERNEL);

drivers/infiniband/hw/hns/hns_roce_srq.c

192

if (!idx_que->bitmap) {

drivers/infiniband/hw/hns/hns_roce_srq.c

213

bitmap_free(idx_que->bitmap);

drivers/infiniband/hw/hns/hns_roce_srq.c

214

idx_que->bitmap = NULL;

drivers/infiniband/hw/mlx5/main.c

2535

clear_bit(mentry->page_idx, var_table->bitmap);

drivers/infiniband/hw/mlx5/main.c

4156

page_idx = find_first_zero_bit(var_table->bitmap,

drivers/infiniband/hw/mlx5/main.c

4164

set_bit(page_idx, var_table->bitmap);

drivers/infiniband/hw/mlx5/main.c

4181

clear_bit(page_idx, var_table->bitmap);

drivers/infiniband/hw/mlx5/main.c

4629

var_table->bitmap = bitmap_zalloc(var_table->num_var_hw_entries,

drivers/infiniband/hw/mlx5/main.c

4631

return (var_table->bitmap) ? 0 : -ENOMEM;

drivers/infiniband/hw/mlx5/main.c

4675

bitmap_free(dev->var_table.bitmap);

drivers/infiniband/hw/mlx5/main.c

4740

bitmap_free(dev->var_table.bitmap);

drivers/infiniband/hw/mlx5/mlx5_ib.h

1138

unsigned long *bitmap;

drivers/infiniband/hw/mlx5/mlx5_ib.h

1805

unsigned long bitmap;

drivers/infiniband/hw/mlx5/mlx5_ib.h

1810

bitmap = GENMASK_ULL(max_log_entity_size_cap, min_log_entity_size_cap);

drivers/infiniband/hw/mlx5/mlx5_ib.h

1814

bitmap &= GENMASK_ULL(__ffs64(iova), 0);

drivers/infiniband/hw/mlx5/mlx5_ib.h

1816

return ib_umem_find_best_pgsz(umem, bitmap, iova);

drivers/input/input.c

1064

unsigned long *bitmap, int max)

drivers/input/input.c

1074

bitmap[i], skip_empty)) {

drivers/input/input.c

1385

static int input_print_bitmap(char *buf, int buf_size, const unsigned long *bitmap,

drivers/input/input.c

1477

static int input_print_bitmap(char *buf, int buf_size, const unsigned long *bitmap,

drivers/input/input.c

1486

bitmap[i], skip_empty);

drivers/input/input.c

1574

const char *name, const unsigned long *bitmap, int max)

drivers/input/input.c

1583

bitmap, max, false);

drivers/input/keyboard/gpio_keys.c

247

const unsigned long *bitmap = get_bm_events_by_type(ddata->input, type);

drivers/input/keyboard/gpio_keys.c

251

unsigned long *bits __free(bitmap) = bitmap_alloc(n_events, GFP_KERNEL);

drivers/input/keyboard/gpio_keys.c

260

if (!bitmap_subset(bits, bitmap, n_events))

drivers/iommu/generic_pt/iommu_pt.h

215

if (dirty->dirty->bitmap)

drivers/iommu/generic_pt/iommu_pt.h

216

iova_bitmap_set(dirty->dirty->bitmap, pts->range->va,

drivers/iommu/intel/iommu.h

508

unsigned long *bitmap;

drivers/iommu/intel/irq_remapping.c

128

index = bitmap_find_free_region(table->bitmap,

drivers/iommu/intel/irq_remapping.c

1593

if (!bitmap_empty(iommu->ir_table->bitmap,

drivers/iommu/intel/irq_remapping.c

244

bitmap_release_region(iommu->ir_table->bitmap, index,

drivers/iommu/intel/irq_remapping.c

449

bitmap_set(iommu->ir_table->bitmap, i, 1);

drivers/iommu/intel/irq_remapping.c

530

unsigned long *bitmap;

drivers/iommu/intel/irq_remapping.c

548

bitmap = bitmap_zalloc(INTR_REMAP_TABLE_ENTRIES, GFP_KERNEL);

drivers/iommu/intel/irq_remapping.c

549

if (bitmap == NULL) {

drivers/iommu/intel/irq_remapping.c

565

ir_table->bitmap = bitmap;

drivers/iommu/intel/irq_remapping.c

611

bitmap_free(bitmap);

drivers/iommu/intel/irq_remapping.c

635

bitmap_free(iommu->ir_table->bitmap);

drivers/iommu/iommufd/device.c

387

!test_bit(cur->id, igroup->required_sw_msi.bitmap))

drivers/iommu/iommufd/driver.c

202

BITS_PER_BYTE * sizeof_field(struct iommufd_sw_msi_maps, bitmap))

drivers/iommu/iommufd/driver.c

226

if (!test_bit(msi_map->id, hwpt_paging->present_sw_msi.bitmap)) {

drivers/iommu/iommufd/driver.c

235

__set_bit(msi_map->id, hwpt_paging->present_sw_msi.bitmap);

drivers/iommu/iommufd/driver.c

293

__set_bit(msi_map->id, handle->idev->igroup->required_sw_msi.bitmap);

drivers/iommu/iommufd/io_pagetable.c

536

static int __iommu_read_and_clear_dirty(struct iova_bitmap *bitmap,

drivers/iommu/iommufd/io_pagetable.c

568

struct iommu_hwpt_get_dirty_bitmap *bitmap)

drivers/iommu/iommufd/io_pagetable.c

580

iter = iova_bitmap_alloc(bitmap->iova, bitmap->length,

drivers/iommu/iommufd/io_pagetable.c

581

bitmap->page_size,

drivers/iommu/iommufd/io_pagetable.c

582

u64_to_user_ptr(bitmap->data));

drivers/iommu/iommufd/io_pagetable.c

603

struct iommu_hwpt_get_dirty_bitmap *bitmap)

drivers/iommu/iommufd/io_pagetable.c

608

if (check_add_overflow(bitmap->iova, bitmap->length - 1, &last_iova))

drivers/iommu/iommufd/io_pagetable.c

611

if (bitmap->iova > ULONG_MAX || last_iova > ULONG_MAX)

drivers/iommu/iommufd/io_pagetable.c

614

if ((bitmap->iova & (iommu_pgsize - 1)) ||

drivers/iommu/iommufd/io_pagetable.c

618

if (!bitmap->page_size)

drivers/iommu/iommufd/io_pagetable.c

621

if ((bitmap->iova & (bitmap->page_size - 1)) ||

drivers/iommu/iommufd/io_pagetable.c

622

((last_iova + 1) & (bitmap->page_size - 1)))

drivers/iommu/iommufd/io_pagetable.c

631

struct iommu_hwpt_get_dirty_bitmap *bitmap)

drivers/iommu/iommufd/io_pagetable.c

635

ret = iommufd_check_iova_range(iopt, bitmap);

drivers/iommu/iommufd/io_pagetable.c

640

ret = iommu_read_and_clear_dirty(domain, iopt, flags, bitmap);

drivers/iommu/iommufd/iommufd_private.h

125

struct iommu_hwpt_get_dirty_bitmap *bitmap);

drivers/iommu/iommufd/iommufd_private.h

34

DECLARE_BITMAP(bitmap, 64);

drivers/iommu/iommufd/iommufd_private.h

355

struct iommu_hwpt_get_dirty_bitmap *bitmap);

drivers/iommu/iommufd/iova_bitmap.c

106

u8 __user *bitmap;

drivers/iommu/iommufd/iova_bitmap.c

130

static unsigned long iova_bitmap_offset_to_index(struct iova_bitmap *bitmap,

drivers/iommu/iommufd/iova_bitmap.c

133

return (iova >> bitmap->mapped.pgshift) /

drivers/iommu/iommufd/iova_bitmap.c

134

BITS_PER_TYPE(*bitmap->bitmap);

drivers/iommu/iommufd/iova_bitmap.c

140

static unsigned long iova_bitmap_index_to_offset(struct iova_bitmap *bitmap,

drivers/iommu/iommufd/iova_bitmap.c

143

unsigned long pgshift = bitmap->mapped.pgshift;

drivers/iommu/iommufd/iova_bitmap.c

145

return (index * BITS_PER_TYPE(*bitmap->bitmap)) << pgshift;

drivers/iommu/iommufd/iova_bitmap.c

151

static unsigned long iova_bitmap_mapped_iova(struct iova_bitmap *bitmap)

drivers/iommu/iommufd/iova_bitmap.c

153

unsigned long skip = bitmap->mapped_base_index;

drivers/iommu/iommufd/iova_bitmap.c

155

return bitmap->iova + iova_bitmap_index_to_offset(bitmap, skip);

drivers/iommu/iommufd/iova_bitmap.c

158

static unsigned long iova_bitmap_mapped_length(struct iova_bitmap *bitmap);

drivers/iommu/iommufd/iova_bitmap.c

165

static int iova_bitmap_get(struct iova_bitmap *bitmap)

drivers/iommu/iommufd/iova_bitmap.c

167

struct iova_bitmap_map *mapped = &bitmap->mapped;

drivers/iommu/iommufd/iova_bitmap.c

178

npages = DIV_ROUND_UP((bitmap->mapped_total_index -

drivers/iommu/iommufd/iova_bitmap.c

179

bitmap->mapped_base_index) *

drivers/iommu/iommufd/iova_bitmap.c

180

sizeof(*bitmap->bitmap), PAGE_SIZE);

drivers/iommu/iommufd/iova_bitmap.c

186

addr = bitmap->bitmap + bitmap->mapped_base_index;

drivers/iommu/iommufd/iova_bitmap.c

202

mapped->iova = iova_bitmap_mapped_iova(bitmap);

drivers/iommu/iommufd/iova_bitmap.c

210

mapped->length = iova_bitmap_mapped_length(bitmap);

drivers/iommu/iommufd/iova_bitmap.c

219

static void iova_bitmap_put(struct iova_bitmap *bitmap)

drivers/iommu/iommufd/iova_bitmap.c

221

struct iova_bitmap_map *mapped = &bitmap->mapped;

drivers/iommu/iommufd/iova_bitmap.c

247

struct iova_bitmap *bitmap;

drivers/iommu/iommufd/iova_bitmap.c

250

bitmap = kzalloc_obj(*bitmap);

drivers/iommu/iommufd/iova_bitmap.c

251

if (!bitmap)

drivers/iommu/iommufd/iova_bitmap.c

254

mapped = &bitmap->mapped;

drivers/iommu/iommufd/iova_bitmap.c

256

bitmap->bitmap = (u8 __user *)data;

drivers/iommu/iommufd/iova_bitmap.c

257

bitmap->mapped_total_index =

drivers/iommu/iommufd/iova_bitmap.c

258

iova_bitmap_offset_to_index(bitmap, length - 1) + 1;

drivers/iommu/iommufd/iova_bitmap.c

259

bitmap->iova = iova;

drivers/iommu/iommufd/iova_bitmap.c

260

bitmap->length = length;

drivers/iommu/iommufd/iova_bitmap.c

268

return bitmap;

drivers/iommu/iommufd/iova_bitmap.c

271

iova_bitmap_free(bitmap);

drivers/iommu/iommufd/iova_bitmap.c

283

void iova_bitmap_free(struct iova_bitmap *bitmap)

drivers/iommu/iommufd/iova_bitmap.c

285

struct iova_bitmap_map *mapped = &bitmap->mapped;

drivers/iommu/iommufd/iova_bitmap.c

287

iova_bitmap_put(bitmap);

drivers/iommu/iommufd/iova_bitmap.c

294

kfree(bitmap);

drivers/iommu/iommufd/iova_bitmap.c

302

static unsigned long iova_bitmap_mapped_remaining(struct iova_bitmap *bitmap)

drivers/iommu/iommufd/iova_bitmap.c

306

bytes = (bitmap->mapped.npages << PAGE_SHIFT) - bitmap->mapped.pgoff;

drivers/iommu/iommufd/iova_bitmap.c

308

remaining = bitmap->mapped_total_index - bitmap->mapped_base_index;

drivers/iommu/iommufd/iova_bitmap.c

310

DIV_ROUND_UP(bytes, sizeof(*bitmap->bitmap)));

drivers/iommu/iommufd/iova_bitmap.c

318

static unsigned long iova_bitmap_mapped_length(struct iova_bitmap *bitmap)

drivers/iommu/iommufd/iova_bitmap.c

320

unsigned long max_iova = bitmap->iova + bitmap->length - 1;

drivers/iommu/iommufd/iova_bitmap.c

321

unsigned long iova = iova_bitmap_mapped_iova(bitmap);

drivers/iommu/iommufd/iova_bitmap.c

330

remaining = iova_bitmap_index_to_offset(bitmap,

drivers/iommu/iommufd/iova_bitmap.c

331

iova_bitmap_mapped_remaining(bitmap));

drivers/iommu/iommufd/iova_bitmap.c

355

static int iova_bitmap_advance_to(struct iova_bitmap *bitmap,

drivers/iommu/iommufd/iova_bitmap.c

360

index = iova_bitmap_offset_to_index(bitmap, iova - bitmap->iova);

drivers/iommu/iommufd/iova_bitmap.c

361

if (index >= bitmap->mapped_total_index)

drivers/iommu/iommufd/iova_bitmap.c

363

bitmap->mapped_base_index = index;

drivers/iommu/iommufd/iova_bitmap.c

365

iova_bitmap_put(bitmap);

drivers/iommu/iommufd/iova_bitmap.c

368

return iova_bitmap_get(bitmap);

drivers/iommu/iommufd/iova_bitmap.c

384

int iova_bitmap_for_each(struct iova_bitmap *bitmap, void *opaque,

drivers/iommu/iommufd/iova_bitmap.c

387

return fn(bitmap, bitmap->iova, bitmap->length, opaque);

drivers/iommu/iommufd/iova_bitmap.c

401

void iova_bitmap_set(struct iova_bitmap *bitmap,

drivers/iommu/iommufd/iova_bitmap.c

404

struct iova_bitmap_map *mapped = &bitmap->mapped;

drivers/iommu/iommufd/iova_bitmap.c

414

if (iova_bitmap_advance_to(bitmap, iova))

drivers/irqchip/irq-bcm2712-mip.c

258

mip->bitmap = bitmap_zalloc(mip->num_msis, GFP_KERNEL);

drivers/irqchip/irq-bcm2712-mip.c

259

if (!mip->bitmap) {

drivers/irqchip/irq-bcm2712-mip.c

274

bitmap_free(mip->bitmap);

drivers/irqchip/irq-bcm2712-mip.c

48

unsigned long *bitmap;

drivers/irqchip/irq-bcm2712-mip.c

75

return bitmap_find_free_region(mip->bitmap, mip->num_msis, ilog2(nr_irqs));

drivers/irqchip/irq-bcm2712-mip.c

82

bitmap_release_region(mip->bitmap, hwirq, ilog2(nr_irqs));

drivers/irqchip/irq-gic-v3-its.c

2219

unsigned long *bitmap = NULL;

drivers/irqchip/irq-gic-v3-its.c

2236

bitmap = bitmap_zalloc(nr_irqs, GFP_ATOMIC);

drivers/irqchip/irq-gic-v3-its.c

2237

if (!bitmap)

drivers/irqchip/irq-gic-v3-its.c

2243

if (!bitmap)

drivers/irqchip/irq-gic-v3-its.c

2246

return bitmap;

drivers/irqchip/irq-gic-v3-its.c

2249

static void its_lpi_free(unsigned long *bitmap, u32 base, u32 nr_ids)

drivers/irqchip/irq-gic-v3-its.c

2252

bitmap_free(bitmap);

drivers/irqchip/irq-gic-v3-its.c

4634

unsigned long *bitmap;

drivers/irqchip/irq-gic-v3-its.c

4638

bitmap = its_lpi_alloc(roundup_pow_of_two(nr_irqs), &base, &nr_ids);

drivers/irqchip/irq-gic-v3-its.c

4639

if (!bitmap)

drivers/irqchip/irq-gic-v3-its.c

4643

its_lpi_free(bitmap, base, nr_ids);

drivers/irqchip/irq-gic-v3-its.c

4649

its_lpi_free(bitmap, base, nr_ids);

drivers/irqchip/irq-gic-v3-its.c

4653

vm->db_bitmap = bitmap;

drivers/irqchip/irq-gic-v3-its.c

4673

set_bit(i, bitmap);

drivers/md/bcache/journal.c

175

__set_bit(b, bitmap); \

drivers/md/bcache/journal.c

184

DECLARE_BITMAP(bitmap, SB_JOURNAL_BUCKETS);

drivers/md/bcache/journal.c

188

bitmap_zero(bitmap, SB_JOURNAL_BUCKETS);

drivers/md/bcache/journal.c

203

if (test_bit(l, bitmap))

drivers/md/bcache/journal.c

216

for_each_clear_bit(l, bitmap, ca->sb.njournal_buckets)

drivers/md/bcache/journal.c

228

r = find_next_bit(bitmap, ca->sb.njournal_buckets, l + 1);

drivers/md/bcache/journal.c

260

if (test_bit(l, bitmap))

drivers/md/dm-integrity.c

355

unsigned long *bitmap;

drivers/md/dm-integrity.c

5295

bbs->bitmap = lowmem_page_address(ic->journal[pl_index].page) + pl_offset;

drivers/md/dm-integrity.c

585

static bool block_bitmap_op(struct dm_integrity_c *ic, struct page_list *bitmap,

drivers/md/dm-integrity.c

620

data = lowmem_page_address(bitmap[page].page);

drivers/md/dm-raid.c

4074

if (test_bit(RT_FLAG_RS_BITMAP_LOADED, &rs->runtime_flags) && mddev->bitmap &&

drivers/md/dm-zoned-metadata.c

2366

static unsigned int dmz_set_bits(unsigned long *bitmap,

drivers/md/dm-zoned-metadata.c

2377

addr = bitmap + BIT_WORD(bit);

drivers/md/dm-zoned-metadata.c

2386

if (!test_and_set_bit(bit, bitmap))

drivers/md/dm-zoned-metadata.c

2524

static int dmz_clear_bits(unsigned long *bitmap, int bit, int nr_bits)

drivers/md/dm-zoned-metadata.c

2534

addr = bitmap + BIT_WORD(bit);

drivers/md/dm-zoned-metadata.c

2543

if (test_and_clear_bit(bit, bitmap))

drivers/md/dm-zoned-metadata.c

2635

unsigned long *bitmap;

drivers/md/dm-zoned-metadata.c

2647

bitmap = (unsigned long *) mblk->data;

drivers/md/dm-zoned-metadata.c

2651

set_bit = find_next_bit(bitmap, zone_bits, bit);

drivers/md/dm-zoned-metadata.c

2653

set_bit = find_next_zero_bit(bitmap, zone_bits, bit);

drivers/md/dm-zoned-metadata.c

2712

static int dmz_count_bits(void *bitmap, int bit, int nr_bits)

drivers/md/dm-zoned-metadata.c

2721

addr = (unsigned long *)bitmap + BIT_WORD(bit);

drivers/md/dm-zoned-metadata.c

2729

if (test_bit(bit, bitmap))

drivers/md/dm-zoned-metadata.c

2746

void *bitmap;

drivers/md/dm-zoned-metadata.c

2758

bitmap = mblk->data;

drivers/md/dm-zoned-metadata.c

2761

n += dmz_count_bits(bitmap, bit, nr_bits);

drivers/md/md-bitmap.c

1095

static void md_bitmap_file_kick(struct bitmap *bitmap)

drivers/md/md-bitmap.c

1097

if (!test_and_set_bit(BITMAP_STALE, &bitmap->flags)) {

drivers/md/md-bitmap.c

1098

bitmap_update_sb(bitmap);

drivers/md/md-bitmap.c

1100

if (bitmap->storage.file) {

drivers/md/md-bitmap.c

1102

bmname(bitmap), bitmap->storage.file);

drivers/md/md-bitmap.c

1106

bmname(bitmap));

drivers/md/md-bitmap.c

1117

static inline void set_page_attr(struct bitmap *bitmap, int pnum,

drivers/md/md-bitmap.c

1120

set_bit((pnum<<2) + attr, bitmap->storage.filemap_attr);

drivers/md/md-bitmap.c

1123

static inline void clear_page_attr(struct bitmap *bitmap, int pnum,

drivers/md/md-bitmap.c

1126

clear_bit((pnum<<2) + attr, bitmap->storage.filemap_attr);

drivers/md/md-bitmap.c

1129

static inline int test_page_attr(struct bitmap *bitmap, int pnum,

drivers/md/md-bitmap.c

1132

return test_bit((pnum<<2) + attr, bitmap->storage.filemap_attr);

drivers/md/md-bitmap.c

1135

static inline int test_and_clear_page_attr(struct bitmap *bitmap, int pnum,

drivers/md/md-bitmap.c

1139

bitmap->storage.filemap_attr);

drivers/md/md-bitmap.c

1148

static void md_bitmap_file_set_bit(struct bitmap *bitmap, sector_t block)

drivers/md/md-bitmap.c

1153

unsigned long chunk = block >> bitmap->counts.chunkshift;

drivers/md/md-bitmap.c

1154

struct bitmap_storage *store = &bitmap->storage;

drivers/md/md-bitmap.c

1159

if (mddev_is_clustered(bitmap->mddev))

drivers/md/md-bitmap.c

1160

node_offset = bitmap->cluster_slot * store->file_pages;

drivers/md/md-bitmap.c

1162

page = filemap_get_page(&bitmap->storage, chunk);

drivers/md/md-bitmap.c

1165

bit = file_page_offset(&bitmap->storage, chunk);

drivers/md/md-bitmap.c

1169

if (test_bit(BITMAP_HOSTENDIAN, &bitmap->flags))

drivers/md/md-bitmap.c

1176

set_page_attr(bitmap, index - node_offset, BITMAP_PAGE_DIRTY);

drivers/md/md-bitmap.c

1179

static void md_bitmap_file_clear_bit(struct bitmap *bitmap, sector_t block)

drivers/md/md-bitmap.c

1184

unsigned long chunk = block >> bitmap->counts.chunkshift;

drivers/md/md-bitmap.c

1185

struct bitmap_storage *store = &bitmap->storage;

drivers/md/md-bitmap.c

1190

if (mddev_is_clustered(bitmap->mddev))

drivers/md/md-bitmap.c

1191

node_offset = bitmap->cluster_slot * store->file_pages;

drivers/md/md-bitmap.c

1193

page = filemap_get_page(&bitmap->storage, chunk);

drivers/md/md-bitmap.c

1196

bit = file_page_offset(&bitmap->storage, chunk);

drivers/md/md-bitmap.c

1198

if (test_bit(BITMAP_HOSTENDIAN, &bitmap->flags))

drivers/md/md-bitmap.c

1203

if (!test_page_attr(bitmap, index - node_offset, BITMAP_PAGE_NEEDWRITE)) {

drivers/md/md-bitmap.c

1204

set_page_attr(bitmap, index - node_offset, BITMAP_PAGE_PENDING);

drivers/md/md-bitmap.c

1205

bitmap->allclean = 0;

drivers/md/md-bitmap.c

1209

static int md_bitmap_file_test_bit(struct bitmap *bitmap, sector_t block)

drivers/md/md-bitmap.c

1214

unsigned long chunk = block >> bitmap->counts.chunkshift;

drivers/md/md-bitmap.c

1217

page = filemap_get_page(&bitmap->storage, chunk);

drivers/md/md-bitmap.c

1220

bit = file_page_offset(&bitmap->storage, chunk);

drivers/md/md-bitmap.c

1222

if (test_bit(BITMAP_HOSTENDIAN, &bitmap->flags))

drivers/md/md-bitmap.c

1233

static void __bitmap_unplug(struct bitmap *bitmap)

drivers/md/md-bitmap.c

1239

if (!bitmap_enabled(bitmap, true))

drivers/md/md-bitmap.c

1244

for (i = 0; i < bitmap->storage.file_pages; i++) {

drivers/md/md-bitmap.c

1245

dirty = test_and_clear_page_attr(bitmap, i, BITMAP_PAGE_DIRTY);

drivers/md/md-bitmap.c

1246

need_write = test_and_clear_page_attr(bitmap, i,

drivers/md/md-bitmap.c

1250

md_bitmap_wait_writes(bitmap);

drivers/md/md-bitmap.c

1251

mddev_add_trace_msg(bitmap->mddev,

drivers/md/md-bitmap.c

1254

clear_page_attr(bitmap, i, BITMAP_PAGE_PENDING);

drivers/md/md-bitmap.c

1255

filemap_write_page(bitmap, i, false);

drivers/md/md-bitmap.c

1260

md_bitmap_wait_writes(bitmap);

drivers/md/md-bitmap.c

1262

if (test_bit(BITMAP_WRITE_ERROR, &bitmap->flags))

drivers/md/md-bitmap.c

1263

md_bitmap_file_kick(bitmap);

drivers/md/md-bitmap.c

1268

struct bitmap *bitmap;

drivers/md/md-bitmap.c

1277

__bitmap_unplug(unplug_work->bitmap);

drivers/md/md-bitmap.c

1281

static void bitmap_unplug_async(struct bitmap *bitmap)

drivers/md/md-bitmap.c

1287

unplug_work.bitmap = bitmap;

drivers/md/md-bitmap.c

1297

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

1299

if (!bitmap)

drivers/md/md-bitmap.c

1303

__bitmap_unplug(bitmap);

drivers/md/md-bitmap.c

1305

bitmap_unplug_async(bitmap);

drivers/md/md-bitmap.c

1308

static void md_bitmap_set_memory_bits(struct bitmap *bitmap, sector_t offset, int needed);

drivers/md/md-bitmap.c

1321

static int md_bitmap_init_from_disk(struct bitmap *bitmap, sector_t start)

drivers/md/md-bitmap.c

1323

bool outofdate = test_bit(BITMAP_STALE, &bitmap->flags);

drivers/md/md-bitmap.c

1324

struct mddev *mddev = bitmap->mddev;

drivers/md/md-bitmap.c

1325

unsigned long chunks = bitmap->counts.chunks;

drivers/md/md-bitmap.c

1326

struct bitmap_storage *store = &bitmap->storage;

drivers/md/md-bitmap.c

1339

int needed = ((sector_t)(i+1) << (bitmap->counts.chunkshift)

drivers/md/md-bitmap.c

1341

md_bitmap_set_memory_bits(bitmap,

drivers/md/md-bitmap.c

1342

(sector_t)i << bitmap->counts.chunkshift,

drivers/md/md-bitmap.c

1350

bmname(bitmap),

drivers/md/md-bitmap.c

1358

node_offset = bitmap->cluster_slot * (DIV_ROUND_UP(store->bytes, PAGE_SIZE));

drivers/md/md-bitmap.c

1371

ret = read_file_page(file, i, bitmap, count, page);

drivers/md/md-bitmap.c

1381

bmname(bitmap));

drivers/md/md-bitmap.c

1399

filemap_write_page(bitmap, i, true);

drivers/md/md-bitmap.c

1400

if (test_bit(BITMAP_WRITE_ERROR, &bitmap->flags)) {

drivers/md/md-bitmap.c

1408

struct page *page = filemap_get_page(&bitmap->storage, i);

drivers/md/md-bitmap.c

1409

unsigned long bit = file_page_offset(&bitmap->storage, i);

drivers/md/md-bitmap.c

1414

if (test_bit(BITMAP_HOSTENDIAN, &bitmap->flags))

drivers/md/md-bitmap.c

1422

int needed = ((sector_t)(i+1) << bitmap->counts.chunkshift

drivers/md/md-bitmap.c

1424

md_bitmap_set_memory_bits(bitmap,

drivers/md/md-bitmap.c

1425

(sector_t)i << bitmap->counts.chunkshift,

drivers/md/md-bitmap.c

1432

bmname(bitmap), store->file_pages,

drivers/md/md-bitmap.c

1439

bmname(bitmap), ret);

drivers/md/md-bitmap.c

1447

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

1449

if (!bitmap || !bitmap->storage.filemap)

drivers/md/md-bitmap.c

1453

if (bitmap->storage.file)

drivers/md/md-bitmap.c

1456

for (i = 0; i < bitmap->storage.file_pages; i++)

drivers/md/md-bitmap.c

1457

set_page_attr(bitmap, i, BITMAP_PAGE_NEEDWRITE);

drivers/md/md-bitmap.c

1458

bitmap->allclean = 0;

drivers/md/md-bitmap.c

1461

static void md_bitmap_count_page(struct bitmap_counts *bitmap,

drivers/md/md-bitmap.c

1464

sector_t chunk = offset >> bitmap->chunkshift;

drivers/md/md-bitmap.c

1466

bitmap->bp[page].count += inc;

drivers/md/md-bitmap.c

1467

md_bitmap_checkfree(bitmap, page);

drivers/md/md-bitmap.c

1470

static void md_bitmap_set_pending(struct bitmap_counts *bitmap, sector_t offset)

drivers/md/md-bitmap.c

1472

sector_t chunk = offset >> bitmap->chunkshift;

drivers/md/md-bitmap.c

1474

struct bitmap_page *bp = &bitmap->bp[page];

drivers/md/md-bitmap.c

1480

static bitmap_counter_t *md_bitmap_get_counter(struct bitmap_counts *bitmap,

drivers/md/md-bitmap.c

1508

struct bitmap *bitmap;

drivers/md/md-bitmap.c

1518

bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

1519

if (bitmap == NULL) {

drivers/md/md-bitmap.c

1523

if (time_before(jiffies, bitmap->daemon_lastrun

drivers/md/md-bitmap.c

1527

bitmap->daemon_lastrun = jiffies;

drivers/md/md-bitmap.c

1528

if (bitmap->allclean) {

drivers/md/md-bitmap.c

1532

bitmap->allclean = 1;

drivers/md/md-bitmap.c

1534

mddev_add_trace_msg(bitmap->mddev, "md bitmap_daemon_work");

drivers/md/md-bitmap.c

1540

for (j = 0; j < bitmap->storage.file_pages; j++)

drivers/md/md-bitmap.c

1541

if (test_and_clear_page_attr(bitmap, j,

drivers/md/md-bitmap.c

1543

set_page_attr(bitmap, j,

drivers/md/md-bitmap.c

1546

if (bitmap->need_sync &&

drivers/md/md-bitmap.c

1551

bitmap->need_sync = 0;

drivers/md/md-bitmap.c

1552

if (bitmap->storage.filemap) {

drivers/md/md-bitmap.c

1553

sb = kmap_local_page(bitmap->storage.sb_page);

drivers/md/md-bitmap.c

1555

cpu_to_le64(bitmap->events_cleared);

drivers/md/md-bitmap.c

1557

set_page_attr(bitmap, 0,

drivers/md/md-bitmap.c

1564

counts = &bitmap->counts;

drivers/md/md-bitmap.c

1585

if (*bmc == 1 && !bitmap->need_sync) {

drivers/md/md-bitmap.c

1589

md_bitmap_file_clear_bit(bitmap, block);

drivers/md/md-bitmap.c

1593

bitmap->allclean = 0;

drivers/md/md-bitmap.c

1598

md_bitmap_wait_writes(bitmap);

drivers/md/md-bitmap.c

1608

j < bitmap->storage.file_pages

drivers/md/md-bitmap.c

1609

&& !test_bit(BITMAP_STALE, &bitmap->flags);

drivers/md/md-bitmap.c

1611

if (test_page_attr(bitmap, j,

drivers/md/md-bitmap.c

1615

if (bitmap->storage.filemap &&

drivers/md/md-bitmap.c

1616

test_and_clear_page_attr(bitmap, j,

drivers/md/md-bitmap.c

1618

filemap_write_page(bitmap, j, false);

drivers/md/md-bitmap.c

1622

if (bitmap->allclean == 0)

drivers/md/md-bitmap.c

1627

static bitmap_counter_t *md_bitmap_get_counter(struct bitmap_counts *bitmap,

drivers/md/md-bitmap.c

1630

__releases(bitmap->lock)

drivers/md/md-bitmap.c

1631

__acquires(bitmap->lock)

drivers/md/md-bitmap.c

1637

sector_t chunk = offset >> bitmap->chunkshift;

drivers/md/md-bitmap.c

1640

sector_t csize = ((sector_t)1) << bitmap->chunkshift;

drivers/md/md-bitmap.c

1643

if (page >= bitmap->pages) {

drivers/md/md-bitmap.c

1652

err = md_bitmap_checkpage(bitmap, page, create, 0);

drivers/md/md-bitmap.c

1654

if (bitmap->bp[page].hijacked ||

drivers/md/md-bitmap.c

1655

bitmap->bp[page].map == NULL)

drivers/md/md-bitmap.c

1656

csize = ((sector_t)1) << (bitmap->chunkshift +

drivers/md/md-bitmap.c

1666

if (bitmap->bp[page].hijacked) { /* hijacked pointer */

drivers/md/md-bitmap.c

1671

&bitmap->bp[page].map)[hi];

drivers/md/md-bitmap.c

1674

&(bitmap->bp[page].map[pageoff]);

drivers/md/md-bitmap.c

1680

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

1682

if (!bitmap)

drivers/md/md-bitmap.c

1689

spin_lock_irq(&bitmap->counts.lock);

drivers/md/md-bitmap.c

1690

bmc = md_bitmap_get_counter(&bitmap->counts, offset, &blocks, 1);

drivers/md/md-bitmap.c

1692

spin_unlock_irq(&bitmap->counts.lock);

drivers/md/md-bitmap.c

1702

prepare_to_wait(&bitmap->overflow_wait, &__wait,

drivers/md/md-bitmap.c

1704

spin_unlock_irq(&bitmap->counts.lock);

drivers/md/md-bitmap.c

1706

finish_wait(&bitmap->overflow_wait, &__wait);

drivers/md/md-bitmap.c

1712

md_bitmap_file_set_bit(bitmap, offset);

drivers/md/md-bitmap.c

1713

md_bitmap_count_page(&bitmap->counts, offset, 1);

drivers/md/md-bitmap.c

1721

spin_unlock_irq(&bitmap->counts.lock);

drivers/md/md-bitmap.c

1734

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

1736

if (!bitmap)

drivers/md/md-bitmap.c

1744

spin_lock_irqsave(&bitmap->counts.lock, flags);

drivers/md/md-bitmap.c

1745

bmc = md_bitmap_get_counter(&bitmap->counts, offset, &blocks, 0);

drivers/md/md-bitmap.c

1747

spin_unlock_irqrestore(&bitmap->counts.lock, flags);

drivers/md/md-bitmap.c

1751

if (!bitmap->mddev->degraded) {

drivers/md/md-bitmap.c

1752

if (bitmap->events_cleared < bitmap->mddev->events) {

drivers/md/md-bitmap.c

1753

bitmap->events_cleared = bitmap->mddev->events;

drivers/md/md-bitmap.c

1754

bitmap->need_sync = 1;

drivers/md/md-bitmap.c

1756

bitmap->sysfs_can_clear);

drivers/md/md-bitmap.c

1763

wake_up(&bitmap->overflow_wait);

drivers/md/md-bitmap.c

1767

md_bitmap_set_pending(&bitmap->counts, offset);

drivers/md/md-bitmap.c

1768

bitmap->allclean = 0;

drivers/md/md-bitmap.c

1770

spin_unlock_irqrestore(&bitmap->counts.lock, flags);

drivers/md/md-bitmap.c

1779

static bool __bitmap_start_sync(struct bitmap *bitmap, sector_t offset,

drivers/md/md-bitmap.c

1785

spin_lock_irq(&bitmap->counts.lock);

drivers/md/md-bitmap.c

1786

bmc = md_bitmap_get_counter(&bitmap->counts, offset, blocks, 0);

drivers/md/md-bitmap.c

1799

spin_unlock_irq(&bitmap->counts.lock);

drivers/md/md-bitmap.c

1819

rv |= __bitmap_start_sync(mddev->bitmap, offset,

drivers/md/md-bitmap.c

1828

static void __bitmap_end_sync(struct bitmap *bitmap, sector_t offset,

drivers/md/md-bitmap.c

1834

spin_lock_irqsave(&bitmap->counts.lock, flags);

drivers/md/md-bitmap.c

1835

bmc = md_bitmap_get_counter(&bitmap->counts, offset, blocks, 0);

drivers/md/md-bitmap.c

1846

md_bitmap_set_pending(&bitmap->counts, offset);

drivers/md/md-bitmap.c

1847

bitmap->allclean = 0;

drivers/md/md-bitmap.c

1852

spin_unlock_irqrestore(&bitmap->counts.lock, flags);

drivers/md/md-bitmap.c

1858

__bitmap_end_sync(mddev->bitmap, offset, blocks, true);

drivers/md/md-bitmap.c

1869

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

1871

if (!bitmap)

drivers/md/md-bitmap.c

1874

while (sector < bitmap->mddev->resync_max_sectors) {

drivers/md/md-bitmap.c

1875

__bitmap_end_sync(bitmap, sector, &blocks, false);

drivers/md/md-bitmap.c

1885

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

1887

if (!bitmap)

drivers/md/md-bitmap.c

1890

bitmap->last_end_sync = jiffies;

drivers/md/md-bitmap.c

1893

if (!force && time_before(jiffies, (bitmap->last_end_sync

drivers/md/md-bitmap.c

1894

+ bitmap->mddev->bitmap_info.daemon_sleep)))

drivers/md/md-bitmap.c

1896

wait_event(bitmap->mddev->recovery_wait,

drivers/md/md-bitmap.c

1897

atomic_read(&bitmap->mddev->recovery_active) == 0);

drivers/md/md-bitmap.c

1899

bitmap->mddev->curr_resync_completed = sector;

drivers/md/md-bitmap.c

1900

set_bit(MD_SB_CHANGE_CLEAN, &bitmap->mddev->sb_flags);

drivers/md/md-bitmap.c

1901

sector &= ~((1ULL << bitmap->counts.chunkshift) - 1);

drivers/md/md-bitmap.c

1903

while (s < sector && s < bitmap->mddev->resync_max_sectors) {

drivers/md/md-bitmap.c

1904

__bitmap_end_sync(bitmap, s, &blocks, false);

drivers/md/md-bitmap.c

1907

bitmap->last_end_sync = jiffies;

drivers/md/md-bitmap.c

1908

sysfs_notify_dirent_safe(bitmap->mddev->sysfs_completed);

drivers/md/md-bitmap.c

1915

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

1919

__bitmap_end_sync(bitmap, sector, &blocks, false);

drivers/md/md-bitmap.c

1931

static void md_bitmap_set_memory_bits(struct bitmap *bitmap, sector_t offset, int needed)

drivers/md/md-bitmap.c

1940

spin_lock_irq(&bitmap->counts.lock);

drivers/md/md-bitmap.c

1941

bmc = md_bitmap_get_counter(&bitmap->counts, offset, &secs, 1);

drivers/md/md-bitmap.c

1943

spin_unlock_irq(&bitmap->counts.lock);

drivers/md/md-bitmap.c

1948

md_bitmap_count_page(&bitmap->counts, offset, 1);

drivers/md/md-bitmap.c

1949

md_bitmap_set_pending(&bitmap->counts, offset);

drivers/md/md-bitmap.c

1950

bitmap->allclean = 0;

drivers/md/md-bitmap.c

1954

spin_unlock_irq(&bitmap->counts.lock);

drivers/md/md-bitmap.c

1962

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

1964

if (!bitmap)

drivers/md/md-bitmap.c

1968

sector_t sec = (sector_t)chunk << bitmap->counts.chunkshift;

drivers/md/md-bitmap.c

1970

md_bitmap_set_memory_bits(bitmap, sec, 1);

drivers/md/md-bitmap.c

1971

md_bitmap_file_set_bit(bitmap, sec);

drivers/md/md-bitmap.c

1972

if (sec < bitmap->mddev->resync_offset)

drivers/md/md-bitmap.c

1977

bitmap->mddev->resync_offset = sec;

drivers/md/md-bitmap.c

1983

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

1986

if (!bitmap) /* there was no bitmap */

drivers/md/md-bitmap.c

1993

bitmap->daemon_lastrun -= sleep;

drivers/md/md-bitmap.c

1995

bitmap->daemon_lastrun -= sleep;

drivers/md/md-bitmap.c

1997

bitmap->daemon_lastrun -= sleep;

drivers/md/md-bitmap.c

2001

bitmap_update_sb(bitmap);

drivers/md/md-bitmap.c

2008

struct bitmap *bitmap = data;

drivers/md/md-bitmap.c

2010

if (!bitmap) /* there was no bitmap */

drivers/md/md-bitmap.c

2013

if (bitmap->sysfs_can_clear)

drivers/md/md-bitmap.c

2014

sysfs_put(bitmap->sysfs_can_clear);

drivers/md/md-bitmap.c

2016

if (mddev_is_clustered(bitmap->mddev) && bitmap->mddev->cluster_info &&

drivers/md/md-bitmap.c

2017

bitmap->cluster_slot == bitmap->mddev->cluster_ops->slot_number(bitmap->mddev))

drivers/md/md-bitmap.c

2018

md_cluster_stop(bitmap->mddev);

drivers/md/md-bitmap.c

2021

wait_event(bitmap->write_wait,

drivers/md/md-bitmap.c

2022

atomic_read(&bitmap->pending_writes) == 0);

drivers/md/md-bitmap.c

2025

md_bitmap_file_unmap(&bitmap->storage);

drivers/md/md-bitmap.c

2027

bp = bitmap->counts.bp;

drivers/md/md-bitmap.c

2028

pages = bitmap->counts.pages;

drivers/md/md-bitmap.c

2037

kfree(bitmap);

drivers/md/md-bitmap.c

2042

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

2045

atomic_inc(&bitmap->behind_writes);

drivers/md/md-bitmap.c

2046

bw = atomic_read(&bitmap->behind_writes);

drivers/md/md-bitmap.c

2047

if (bw > bitmap->behind_writes_used)

drivers/md/md-bitmap.c

2048

bitmap->behind_writes_used = bw;

drivers/md/md-bitmap.c

2051

bw, bitmap->mddev->bitmap_info.max_write_behind);

drivers/md/md-bitmap.c

2056

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

2058

if (atomic_dec_and_test(&bitmap->behind_writes))

drivers/md/md-bitmap.c

2059

wake_up(&bitmap->behind_wait);

drivers/md/md-bitmap.c

2061

atomic_read(&bitmap->behind_writes),

drivers/md/md-bitmap.c

2062

bitmap->mddev->bitmap_info.max_write_behind);

drivers/md/md-bitmap.c

2067

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

2070

if (bitmap && atomic_read(&bitmap->behind_writes) > 0) {

drivers/md/md-bitmap.c

2074

wait_event(bitmap->behind_wait,

drivers/md/md-bitmap.c

2075

atomic_read(&bitmap->behind_writes) == 0);

drivers/md/md-bitmap.c

2081

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

2083

if (!bitmap) /* there was no bitmap */

drivers/md/md-bitmap.c

2092

mddev->bitmap = NULL; /* disconnect from the md device */

drivers/md/md-bitmap.c

2097

md_bitmap_free(bitmap);

drivers/md/md-bitmap.c

2105

static struct bitmap *__bitmap_create(struct mddev *mddev, int slot)

drivers/md/md-bitmap.c

2107

struct bitmap *bitmap;

drivers/md/md-bitmap.c

2123

bitmap = kzalloc_obj(*bitmap);

drivers/md/md-bitmap.c

2124

if (!bitmap)

drivers/md/md-bitmap.c

2127

spin_lock_init(&bitmap->counts.lock);

drivers/md/md-bitmap.c

2128

atomic_set(&bitmap->pending_writes, 0);

drivers/md/md-bitmap.c

2129

init_waitqueue_head(&bitmap->write_wait);

drivers/md/md-bitmap.c

2130

init_waitqueue_head(&bitmap->overflow_wait);

drivers/md/md-bitmap.c

2131

init_waitqueue_head(&bitmap->behind_wait);

drivers/md/md-bitmap.c

2133

bitmap->mddev = mddev;

drivers/md/md-bitmap.c

2134

bitmap->cluster_slot = slot;

drivers/md/md-bitmap.c

2139

bitmap->sysfs_can_clear = sysfs_get_dirent(bm, "can_clear");

drivers/md/md-bitmap.c

2142

bitmap->sysfs_can_clear = NULL;

drivers/md/md-bitmap.c

2144

bitmap->storage.file = file;

drivers/md/md-bitmap.c

2160

err = md_bitmap_new_disk_sb(bitmap);

drivers/md/md-bitmap.c

2162

err = md_bitmap_read_sb(bitmap);

drivers/md/md-bitmap.c

2174

bitmap->daemon_lastrun = jiffies;

drivers/md/md-bitmap.c

2175

err = __bitmap_resize(bitmap, blocks, mddev->bitmap_info.chunksize,

drivers/md/md-bitmap.c

2181

bitmap->counts.pages, bmname(bitmap));

drivers/md/md-bitmap.c

2183

err = test_bit(BITMAP_WRITE_ERROR, &bitmap->flags) ? -EIO : 0;

drivers/md/md-bitmap.c

2187

return bitmap;

drivers/md/md-bitmap.c

2189

md_bitmap_free(bitmap);

drivers/md/md-bitmap.c

2195

struct bitmap *bitmap = __bitmap_create(mddev, -1);

drivers/md/md-bitmap.c

2197

if (IS_ERR(bitmap))

drivers/md/md-bitmap.c

2198

return PTR_ERR(bitmap);

drivers/md/md-bitmap.c

220

static int __bitmap_resize(struct bitmap *bitmap, sector_t blocks,

drivers/md/md-bitmap.c

2200

mddev->bitmap = bitmap;

drivers/md/md-bitmap.c

2209

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

2212

if (!bitmap)

drivers/md/md-bitmap.c

223

static inline char *bmname(struct bitmap *bitmap)

drivers/md/md-bitmap.c

2234

|| bitmap->events_cleared == mddev->events)

drivers/md/md-bitmap.c

2240

err = md_bitmap_init_from_disk(bitmap, start);

drivers/md/md-bitmap.c

2245

clear_bit(BITMAP_STALE, &bitmap->flags);

drivers/md/md-bitmap.c

2248

set_bit(MD_RECOVERY_NEEDED, &bitmap->mddev->recovery);

drivers/md/md-bitmap.c

225

return bitmap->mddev ? mdname(bitmap->mddev) : "mdX";

drivers/md/md-bitmap.c

2253

bitmap_update_sb(bitmap);

drivers/md/md-bitmap.c

2255

if (test_bit(BITMAP_WRITE_ERROR, &bitmap->flags))

drivers/md/md-bitmap.c

2265

struct bitmap *bitmap;

drivers/md/md-bitmap.c

2267

bitmap = __bitmap_create(mddev, slot);

drivers/md/md-bitmap.c

2268

if (IS_ERR(bitmap)) {

drivers/md/md-bitmap.c

2269

rv = PTR_ERR(bitmap);

drivers/md/md-bitmap.c

2273

rv = md_bitmap_init_from_disk(bitmap, 0);

drivers/md/md-bitmap.c

2275

md_bitmap_free(bitmap);

drivers/md/md-bitmap.c

2279

return bitmap;

drivers/md/md-bitmap.c

2291

struct bitmap *bitmap;

drivers/md/md-bitmap.c

2293

bitmap = bitmap_get_from_slot(mddev, slot);

drivers/md/md-bitmap.c

2294

if (IS_ERR(bitmap)) {

drivers/md/md-bitmap.c

2299

counts = &bitmap->counts;

drivers/md/md-bitmap.c

230

struct bitmap *bitmap = data;

drivers/md/md-bitmap.c

2302

if (md_bitmap_file_test_bit(bitmap, block)) {

drivers/md/md-bitmap.c

2306

md_bitmap_file_clear_bit(bitmap, block);

drivers/md/md-bitmap.c

2307

md_bitmap_set_memory_bits(mddev->bitmap, block, 1);

drivers/md/md-bitmap.c

2308

md_bitmap_file_set_bit(mddev->bitmap, block);

drivers/md/md-bitmap.c

2313

bitmap_update_sb(bitmap);

drivers/md/md-bitmap.c

2316

for (i = 0; i < bitmap->storage.file_pages; i++)

drivers/md/md-bitmap.c

2317

if (test_page_attr(bitmap, i, BITMAP_PAGE_PENDING))

drivers/md/md-bitmap.c

2318

set_page_attr(bitmap, i, BITMAP_PAGE_NEEDWRITE);

drivers/md/md-bitmap.c

2319

__bitmap_unplug(bitmap);

drivers/md/md-bitmap.c

2321

__bitmap_unplug(mddev->bitmap);

drivers/md/md-bitmap.c

2324

md_bitmap_free(bitmap);

drivers/md/md-bitmap.c

2331

struct bitmap *bitmap = data;

drivers/md/md-bitmap.c

2333

bitmap->counts.pages = pages;

drivers/md/md-bitmap.c

2340

struct bitmap *bitmap = data;

drivers/md/md-bitmap.c

2343

if (!bitmap)

drivers/md/md-bitmap.c

2345

if (!bitmap->storage.sb_page)

drivers/md/md-bitmap.c

2347

sb = kmap_local_page(bitmap->storage.sb_page);

drivers/md/md-bitmap.c

2351

counts = &bitmap->counts;

drivers/md/md-bitmap.c

2355

storage = &bitmap->storage;

drivers/md/md-bitmap.c

2359

stats->behind_writes = atomic_read(&bitmap->behind_writes);

drivers/md/md-bitmap.c

2360

stats->behind_wait = wq_has_sleeper(&bitmap->behind_wait);

drivers/md/md-bitmap.c

2361

stats->events_cleared = bitmap->events_cleared;

drivers/md/md-bitmap.c

2365

static int __bitmap_resize(struct bitmap *bitmap, sector_t blocks,

drivers/md/md-bitmap.c

2388

if (bitmap->storage.file && !init) {

drivers/md/md-bitmap.c

239

return !test_bit(BITMAP_STALE, &bitmap->flags) &&

drivers/md/md-bitmap.c

2398

long space = bitmap->mddev->bitmap_info.space;

drivers/md/md-bitmap.c

240

bitmap->storage.filemap != NULL;

drivers/md/md-bitmap.c

2404

bytes = DIV_ROUND_UP(bitmap->counts.chunks, 8);

drivers/md/md-bitmap.c

2405

if (!bitmap->mddev->bitmap_info.external)

drivers/md/md-bitmap.c

2408

bitmap->mddev->bitmap_info.space = space;

drivers/md/md-bitmap.c

2410

chunkshift = bitmap->counts.chunkshift;

drivers/md/md-bitmap.c

2417

if (!bitmap->mddev->bitmap_info.external)

drivers/md/md-bitmap.c

2426

if (bitmap->mddev->bitmap_info.offset || bitmap->mddev->bitmap_info.file)

drivers/md/md-bitmap.c

2428

!bitmap->mddev->bitmap_info.external,

drivers/md/md-bitmap.c

2429

mddev_is_clustered(bitmap->mddev)

drivers/md/md-bitmap.c

2430

? bitmap->cluster_slot : 0);

drivers/md/md-bitmap.c

2446

bitmap->mddev->pers->quiesce(bitmap->mddev, 1);

drivers/md/md-bitmap.c

2448

store.file = bitmap->storage.file;

drivers/md/md-bitmap.c

2449

bitmap->storage.file = NULL;

drivers/md/md-bitmap.c

2451

if (store.sb_page && bitmap->storage.sb_page)

drivers/md/md-bitmap.c

2453

page_address(bitmap->storage.sb_page),

drivers/md/md-bitmap.c

2455

mutex_lock(&bitmap->mddev->bitmap_info.mutex);

drivers/md/md-bitmap.c

2456

spin_lock_irq(&bitmap->counts.lock);

drivers/md/md-bitmap.c

2457

md_bitmap_file_unmap(&bitmap->storage);

drivers/md/md-bitmap.c

2458

bitmap->storage = store;

drivers/md/md-bitmap.c

2460

old_counts = bitmap->counts;

drivers/md/md-bitmap.c

2461

bitmap->counts.bp = new_bp;

drivers/md/md-bitmap.c

2462

bitmap->counts.pages = pages;

drivers/md/md-bitmap.c

2463

bitmap->counts.missing_pages = pages;

drivers/md/md-bitmap.c

2464

bitmap->counts.chunkshift = chunkshift;

drivers/md/md-bitmap.c

2465

bitmap->counts.chunks = chunks;

drivers/md/md-bitmap.c

2466

bitmap->mddev->bitmap_info.chunksize = 1UL << (chunkshift +

drivers/md/md-bitmap.c

2473

if (mddev_is_clustered(bitmap->mddev)) {

drivers/md/md-bitmap.c

2476

ret = md_bitmap_checkpage(&bitmap->counts, page, 1, 1);

drivers/md/md-bitmap.c

2487

bitmap->counts.bp = old_counts.bp;

drivers/md/md-bitmap.c

2488

bitmap->counts.pages = old_counts.pages;

drivers/md/md-bitmap.c

2489

bitmap->counts.missing_pages = old_counts.pages;

drivers/md/md-bitmap.c

2490

bitmap->counts.chunkshift = old_counts.chunkshift;

drivers/md/md-bitmap.c

2491

bitmap->counts.chunks = old_counts.chunks;

drivers/md/md-bitmap.c

2492

bitmap->mddev->bitmap_info.chunksize =

drivers/md/md-bitmap.c

2498

bitmap->counts.bp[page].count += 1;

drivers/md/md-bitmap.c

2510

bmc_new = md_bitmap_get_counter(&bitmap->counts, block, &new_blocks, 1);

drivers/md/md-bitmap.c

2519

md_bitmap_file_set_bit(bitmap, block);

drivers/md/md-bitmap.c

2523

md_bitmap_count_page(&bitmap->counts, block, 1);

drivers/md/md-bitmap.c

2524

md_bitmap_set_pending(&bitmap->counts, block);

drivers/md/md-bitmap.c

253

static int md_bitmap_checkpage(struct bitmap_counts *bitmap,

drivers/md/md-bitmap.c

2534

if (bitmap->counts.bp != old_counts.bp) {

drivers/md/md-bitmap.c

2546

bmc = md_bitmap_get_counter(&bitmap->counts, block, &new_blocks, 1);

drivers/md/md-bitmap.c

255

__releases(bitmap->lock)

drivers/md/md-bitmap.c

2553

md_bitmap_count_page(&bitmap->counts, block, 1);

drivers/md/md-bitmap.c

2554

md_bitmap_set_pending(&bitmap->counts, block);

drivers/md/md-bitmap.c

2559

for (i = 0; i < bitmap->storage.file_pages; i++)

drivers/md/md-bitmap.c

256

__acquires(bitmap->lock)

drivers/md/md-bitmap.c

2560

set_page_attr(bitmap, i, BITMAP_PAGE_DIRTY);

drivers/md/md-bitmap.c

2562

spin_unlock_irq(&bitmap->counts.lock);

drivers/md/md-bitmap.c

2563

mutex_unlock(&bitmap->mddev->bitmap_info.mutex);

drivers/md/md-bitmap.c

2565

__bitmap_unplug(bitmap);

drivers/md/md-bitmap.c

2566

bitmap->mddev->pers->quiesce(bitmap->mddev, 0);

drivers/md/md-bitmap.c

2575

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

2577

if (!bitmap)

drivers/md/md-bitmap.c

2580

return __bitmap_resize(bitmap, blocks, chunksize, false);

drivers/md/md-bitmap.c

260

WARN_ON_ONCE(page >= bitmap->pages);

drivers/md/md-bitmap.c

261

if (bitmap->bp[page].hijacked) /* it's hijacked, don't try to alloc */

drivers/md/md-bitmap.c

2613

if (mddev->bitmap || mddev->bitmap_info.file ||

drivers/md/md-bitmap.c

264

if (bitmap->bp[page].map) /* page is already allocated, just return */

drivers/md/md-bitmap.c

2700

struct bitmap *bitmap;

drivers/md/md-bitmap.c

2711

bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

2712

if (bitmap && sectors < (bitmap->storage.bytes + 511) >> 9)

drivers/md/md-bitmap.c

272

spin_unlock_irq(&bitmap->lock);

drivers/md/md-bitmap.c

2820

bitmap_update_sb(mddev->bitmap);

drivers/md/md-bitmap.c

2841

if (mddev->bitmap)

drivers/md/md-bitmap.c

2869

if (mddev->bitmap ||

drivers/md/md-bitmap.c

287

spin_lock_irq(&bitmap->lock);

drivers/md/md-bitmap.c

2889

struct bitmap *bitmap;

drivers/md/md-bitmap.c

2892

bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

2893

if (bitmap)

drivers/md/md-bitmap.c

2894

len = sprintf(page, "%s\n", (bitmap->need_sync ? "false" :

drivers/md/md-bitmap.c

2904

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

2906

if (!bitmap)

drivers/md/md-bitmap.c

2910

bitmap->need_sync = 1;

drivers/md/md-bitmap.c

2917

bitmap->need_sync = 0;

drivers/md/md-bitmap.c

2931

struct bitmap *bitmap;

drivers/md/md-bitmap.c

2934

bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

2935

if (!bitmap)

drivers/md/md-bitmap.c

2938

ret = sprintf(page, "%lu\n", bitmap->behind_writes_used);

drivers/md/md-bitmap.c

2947

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

2949

if (bitmap)

drivers/md/md-bitmap.c

2950

bitmap->behind_writes_used = 0;

drivers/md/md-bitmap.c

296

if (!bitmap->bp[page].map)

drivers/md/md-bitmap.c

297

bitmap->bp[page].hijacked = 1;

drivers/md/md-bitmap.c

298

} else if (bitmap->bp[page].map ||

drivers/md/md-bitmap.c

299

bitmap->bp[page].hijacked) {

drivers/md/md-bitmap.c

306

bitmap->bp[page].map = mappage;

drivers/md/md-bitmap.c

307

bitmap->missing_pages--;

drivers/md/md-bitmap.c

315

static void md_bitmap_checkfree(struct bitmap_counts *bitmap, unsigned long page)

drivers/md/md-bitmap.c

319

if (bitmap->bp[page].count) /* page is still busy */

drivers/md/md-bitmap.c

324

if (bitmap->bp[page].hijacked) { /* page was hijacked, undo this now */

drivers/md/md-bitmap.c

325

bitmap->bp[page].hijacked = 0;

drivers/md/md-bitmap.c

326

bitmap->bp[page].map = NULL;

drivers/md/md-bitmap.c

329

ptr = bitmap->bp[page].map;

drivers/md/md-bitmap.c

330

bitmap->bp[page].map = NULL;

drivers/md/md-bitmap.c

331

bitmap->missing_pages++;

drivers/md/md-bitmap.c

427

static int __write_sb_page(struct md_rdev *rdev, struct bitmap *bitmap,

drivers/md/md-bitmap.c

431

struct mddev *mddev = bitmap->mddev;

drivers/md/md-bitmap.c

432

struct bitmap_storage *store = &bitmap->storage;

drivers/md/md-bitmap.c

433

unsigned long num_pages = bitmap->storage.file_pages;

drivers/md/md-bitmap.c

484

static void write_sb_page(struct bitmap *bitmap, unsigned long pg_index,

drivers/md/md-bitmap.c

487

struct mddev *mddev = bitmap->mddev;

drivers/md/md-bitmap.c

493

if (__write_sb_page(rdev, bitmap, pg_index, page) < 0) {

drivers/md/md-bitmap.c

494

set_bit(BITMAP_WRITE_ERROR, &bitmap->flags);

drivers/md/md-bitmap.c

501

static void md_bitmap_file_kick(struct bitmap *bitmap);

drivers/md/md-bitmap.c

504

static void write_file_page(struct bitmap *bitmap, struct page *page, int wait)

drivers/md/md-bitmap.c

509

atomic_inc(&bitmap->pending_writes);

drivers/md/md-bitmap.c

517

wait_event(bitmap->write_wait,

drivers/md/md-bitmap.c

518

atomic_read(&bitmap->pending_writes) == 0);

drivers/md/md-bitmap.c

523

struct bitmap *bitmap = bh->b_private;

drivers/md/md-bitmap.c

526

set_bit(BITMAP_WRITE_ERROR, &bitmap->flags);

drivers/md/md-bitmap.c

527

if (atomic_dec_and_test(&bitmap->pending_writes))

drivers/md/md-bitmap.c

528

wake_up(&bitmap->write_wait);

drivers/md/md-bitmap.c

556

struct bitmap *bitmap, unsigned long count, struct page *page)

drivers/md/md-bitmap.c

595

bh->b_private = bitmap;

drivers/md/md-bitmap.c

596

atomic_inc(&bitmap->pending_writes);

drivers/md/md-bitmap.c

605

wait_event(bitmap->write_wait,

drivers/md/md-bitmap.c

606

atomic_read(&bitmap->pending_writes)==0);

drivers/md/md-bitmap.c

607

if (test_bit(BITMAP_WRITE_ERROR, &bitmap->flags))

drivers/md/md-bitmap.c

618

static void write_file_page(struct bitmap *bitmap, struct page *page, int wait)

drivers/md/md-bitmap.c

622

struct bitmap *bitmap, unsigned long count, struct page *page)

drivers/md/md-bitmap.c

639

static void filemap_write_page(struct bitmap *bitmap, unsigned long pg_index,

drivers/md/md-bitmap.c

642

struct bitmap_storage *store = &bitmap->storage;

drivers/md/md-bitmap.c

645

if (mddev_is_clustered(bitmap->mddev)) {

drivers/md/md-bitmap.c

651

write_file_page(bitmap, page, wait);

drivers/md/md-bitmap.c

653

write_sb_page(bitmap, pg_index, page, wait);

drivers/md/md-bitmap.c

661

static void md_bitmap_wait_writes(struct bitmap *bitmap)

drivers/md/md-bitmap.c

663

if (bitmap->storage.file)

drivers/md/md-bitmap.c

664

wait_event(bitmap->write_wait,

drivers/md/md-bitmap.c

665

atomic_read(&bitmap->pending_writes)==0);

drivers/md/md-bitmap.c

674

md_super_wait(bitmap->mddev);

drivers/md/md-bitmap.c

682

struct bitmap *bitmap = data;

drivers/md/md-bitmap.c

684

if (!bitmap || !bitmap->mddev) /* no bitmap for this array */

drivers/md/md-bitmap.c

686

if (bitmap->mddev->bitmap_info.external)

drivers/md/md-bitmap.c

688

if (!bitmap->storage.sb_page) /* no superblock */

drivers/md/md-bitmap.c

690

sb = kmap_local_page(bitmap->storage.sb_page);

drivers/md/md-bitmap.c

691

sb->events = cpu_to_le64(bitmap->mddev->events);

drivers/md/md-bitmap.c

692

if (bitmap->mddev->events < bitmap->events_cleared)

drivers/md/md-bitmap.c

694

bitmap->events_cleared = bitmap->mddev->events;

drivers/md/md-bitmap.c

695

sb->events_cleared = cpu_to_le64(bitmap->events_cleared);

drivers/md/md-bitmap.c

700

sb->state = cpu_to_le32(bitmap->flags & ~BIT(BITMAP_WRITE_ERROR));

drivers/md/md-bitmap.c

702

sb->daemon_sleep = cpu_to_le32(bitmap->mddev->bitmap_info.daemon_sleep/HZ);

drivers/md/md-bitmap.c

703

sb->write_behind = cpu_to_le32(bitmap->mddev->bitmap_info.max_write_behind);

drivers/md/md-bitmap.c

705

sb->sync_size = cpu_to_le64(bitmap->mddev->resync_max_sectors);

drivers/md/md-bitmap.c

706

sb->chunksize = cpu_to_le32(bitmap->mddev->bitmap_info.chunksize);

drivers/md/md-bitmap.c

707

sb->nodes = cpu_to_le32(bitmap->mddev->bitmap_info.nodes);

drivers/md/md-bitmap.c

708

sb->sectors_reserved = cpu_to_le32(bitmap->mddev->

drivers/md/md-bitmap.c

712

if (bitmap->storage.file)

drivers/md/md-bitmap.c

713

write_file_page(bitmap, bitmap->storage.sb_page, 1);

drivers/md/md-bitmap.c

715

write_sb_page(bitmap, bitmap->storage.sb_index,

drivers/md/md-bitmap.c

716

bitmap->storage.sb_page, 1);

drivers/md/md-bitmap.c

719

static void bitmap_print_sb(struct bitmap *bitmap)

drivers/md/md-bitmap.c

723

if (!bitmap || !bitmap->storage.sb_page)

drivers/md/md-bitmap.c

725

sb = kmap_local_page(bitmap->storage.sb_page);

drivers/md/md-bitmap.c

726

pr_debug("%s: bitmap file superblock:\n", bmname(bitmap));

drivers/md/md-bitmap.c

758

static int md_bitmap_new_disk_sb(struct bitmap *bitmap)

drivers/md/md-bitmap.c

763

bitmap->storage.sb_page = alloc_page(GFP_KERNEL | __GFP_ZERO);

drivers/md/md-bitmap.c

764

if (bitmap->storage.sb_page == NULL)

drivers/md/md-bitmap.c

766

bitmap->storage.sb_index = 0;

drivers/md/md-bitmap.c

768

sb = kmap_local_page(bitmap->storage.sb_page);

drivers/md/md-bitmap.c

773

chunksize = bitmap->mddev->bitmap_info.chunksize;

drivers/md/md-bitmap.c

782

daemon_sleep = bitmap->mddev->bitmap_info.daemon_sleep;

drivers/md/md-bitmap.c

788

bitmap->mddev->bitmap_info.daemon_sleep = daemon_sleep;

drivers/md/md-bitmap.c

794

write_behind = bitmap->mddev->bitmap_info.max_write_behind;

drivers/md/md-bitmap.c

798

bitmap->mddev->bitmap_info.max_write_behind = write_behind;

drivers/md/md-bitmap.c

801

sb->sync_size = cpu_to_le64(bitmap->mddev->resync_max_sectors);

drivers/md/md-bitmap.c

803

memcpy(sb->uuid, bitmap->mddev->uuid, 16);

drivers/md/md-bitmap.c

805

set_bit(BITMAP_STALE, &bitmap->flags);

drivers/md/md-bitmap.c

806

sb->state = cpu_to_le32(bitmap->flags);

drivers/md/md-bitmap.c

807

bitmap->events_cleared = bitmap->mddev->events;

drivers/md/md-bitmap.c

808

sb->events_cleared = cpu_to_le64(bitmap->mddev->events);

drivers/md/md-bitmap.c

809

bitmap->mddev->bitmap_info.nodes = 0;

drivers/md/md-bitmap.c

817

static int md_bitmap_read_sb(struct bitmap *bitmap)

drivers/md/md-bitmap.c

829

if (!bitmap->storage.file && !bitmap->mddev->bitmap_info.offset) {

drivers/md/md-bitmap.c

833

set_bit(BITMAP_STALE, &bitmap->flags);

drivers/md/md-bitmap.c

841

bitmap->storage.sb_page = sb_page;

drivers/md/md-bitmap.c

845

if (bitmap->cluster_slot >= 0) {

drivers/md/md-bitmap.c

846

sector_t bm_blocks = bitmap->mddev->resync_max_sectors;

drivers/md/md-bitmap.c

849

(bitmap->mddev->bitmap_info.chunksize >> 9));

drivers/md/md-bitmap.c

854

offset = bitmap->cluster_slot * (bm_blocks << 3);

drivers/md/md-bitmap.c

856

bitmap->cluster_slot, offset);

drivers/md/md-bitmap.c

859

if (bitmap->storage.file) {

drivers/md/md-bitmap.c

860

loff_t isize = i_size_read(bitmap->storage.file->f_mapping->host);

drivers/md/md-bitmap.c

863

err = read_file_page(bitmap->storage.file, 0,

drivers/md/md-bitmap.c

864

bitmap, bytes, sb_page);

drivers/md/md-bitmap.c

866

err = read_sb_page(bitmap->mddev, offset, sb_page, 0,

drivers/md/md-bitmap.c

896

bmname(bitmap), reason);

drivers/md/md-bitmap.c

906

strscpy(bitmap->mddev->bitmap_info.cluster_name,

drivers/md/md-bitmap.c

911

sb->sync_size = cpu_to_le64(bitmap->mddev->resync_max_sectors);

drivers/md/md-bitmap.c

913

if (bitmap->mddev->persistent) {

drivers/md/md-bitmap.c

918

if (memcmp(sb->uuid, bitmap->mddev->uuid, 16)) {

drivers/md/md-bitmap.c

920

bmname(bitmap));

drivers/md/md-bitmap.c

924

if (!nodes && (events < bitmap->mddev->events)) {

drivers/md/md-bitmap.c

926

bmname(bitmap), events,

drivers/md/md-bitmap.c

927

(unsigned long long) bitmap->mddev->events);

drivers/md/md-bitmap.c

928

set_bit(BITMAP_STALE, &bitmap->flags);

drivers/md/md-bitmap.c

933

bitmap->flags |= le32_to_cpu(sb->state);

drivers/md/md-bitmap.c

935

set_bit(BITMAP_HOSTENDIAN, &bitmap->flags);

drivers/md/md-bitmap.c

936

bitmap->events_cleared = le64_to_cpu(sb->events_cleared);

drivers/md/md-bitmap.c

941

if (err == 0 && nodes && (bitmap->cluster_slot < 0)) {

drivers/md/md-bitmap.c

943

bitmap->mddev->bitmap_info.chunksize = chunksize;

drivers/md/md-bitmap.c

944

err = md_setup_cluster(bitmap->mddev, nodes);

drivers/md/md-bitmap.c

947

bmname(bitmap), err);

drivers/md/md-bitmap.c

950

bitmap->cluster_slot = bitmap->mddev->cluster_ops->slot_number(bitmap->mddev);

drivers/md/md-bitmap.c

956

if (test_bit(BITMAP_STALE, &bitmap->flags))

drivers/md/md-bitmap.c

957

bitmap->events_cleared = bitmap->mddev->events;

drivers/md/md-bitmap.c

958

bitmap->mddev->bitmap_info.chunksize = chunksize;

drivers/md/md-bitmap.c

959

bitmap->mddev->bitmap_info.daemon_sleep = daemon_sleep;

drivers/md/md-bitmap.c

960

bitmap->mddev->bitmap_info.max_write_behind = write_behind;

drivers/md/md-bitmap.c

961

bitmap->mddev->bitmap_info.nodes = nodes;

drivers/md/md-bitmap.c

962

if (bitmap->mddev->bitmap_info.space == 0 ||

drivers/md/md-bitmap.c

963

bitmap->mddev->bitmap_info.space > sectors_reserved)

drivers/md/md-bitmap.c

964

bitmap->mddev->bitmap_info.space = sectors_reserved;

drivers/md/md-bitmap.c

966

bitmap_print_sb(bitmap);

drivers/md/md-bitmap.c

967

if (bitmap->cluster_slot < 0)

drivers/md/md-bitmap.c

968

md_cluster_stop(bitmap->mddev);

drivers/md/md-bitmap.h

143

if (!mddev->bitmap)

drivers/md/md-bitmap.h

146

return mddev->bitmap_ops->enabled(mddev->bitmap, flush);

drivers/md/md-cluster.c

1152

void *bitmap = mddev->bitmap;

drivers/md/md-cluster.c

1157

rv = mddev->bitmap_ops->get_stats(bitmap, &stats);

drivers/md/md-cluster.c

1177

bitmap = mddev->bitmap_ops->get_from_slot(mddev, i);

drivers/md/md-cluster.c

1178

if (IS_ERR(bitmap)) {

drivers/md/md-cluster.c

1180

bitmap = NULL;

drivers/md/md-cluster.c

1184

rv = mddev->bitmap_ops->get_stats(bitmap, &stats);

drivers/md/md-cluster.c

1200

mddev->bitmap_ops->set_pages(bitmap, my_pages);

drivers/md/md-cluster.c

1209

mddev->bitmap_ops->free(bitmap);

drivers/md/md-cluster.c

1214

mddev->bitmap_ops->free(bitmap);

drivers/md/md-cluster.c

1228

void *bitmap = mddev->bitmap;

drivers/md/md-cluster.c

1234

rv = mddev->bitmap_ops->get_stats(bitmap, &stats);

drivers/md/md-cluster.c

1244

bitmap = mddev->bitmap_ops->get_from_slot(mddev, i);

drivers/md/md-cluster.c

1245

if (IS_ERR(bitmap)) {

drivers/md/md-cluster.c

1258

mddev->bitmap_ops->free(bitmap);

drivers/md/md-cluster.c

1264

mddev->bitmap_ops->update_sb(bitmap);

drivers/md/md-cluster.c

1267

rv = mddev->bitmap_ops->get_stats(bitmap, &stats);

drivers/md/md-cluster.c

1269

mddev->bitmap_ops->free(bitmap);

drivers/md/md-cluster.c

1276

mddev->bitmap_ops->free(bitmap);

drivers/md/md-cluster.c

1279

mddev->bitmap_ops->free(bitmap);

drivers/md/md-llbitmap.c

1004

mddev->bitmap = NULL;

drivers/md/md-llbitmap.c

1012

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1035

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1046

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1057

mddev->bitmap = NULL;

drivers/md/md-llbitmap.c

1066

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1083

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1098

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1115

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1164

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1192

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1211

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1227

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1236

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1261

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1277

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1288

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1309

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1342

llbitmap_state_machine(mddev->bitmap, s, e, BitmapActionStartwrite);

drivers/md/md-llbitmap.c

1409

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1421

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1428

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1436

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1453

llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1489

llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1530

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1538

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

999

mddev->bitmap = llbitmap;

drivers/md/md.c

10557

mddev->bitmap_ops->update_sb(mddev->bitmap);

drivers/md/md.c

1460

err = mddev->bitmap_ops->get_stats(mddev->bitmap, &stats);

drivers/md/md.c

1555

} else if (mddev->bitmap) {

drivers/md/md.c

1666

if (mddev->bitmap && mddev->bitmap_info.file == NULL)

drivers/md/md.c

2089

} else if (mddev->bitmap) {

drivers/md/md.c

2228

if (mddev->bitmap && mddev->bitmap_info.file == NULL) {

drivers/md/md.c

2239

if (rdev->saved_raid_disk >= 0 && mddev->bitmap)

drivers/md/md.c

2449

err = mddev->bitmap_ops->get_stats(mddev->bitmap, &stats);

drivers/md/md.c

2916

mddev->bitmap_ops->update_sb(mddev->bitmap);

drivers/md/md.c

4874

if (!mddev->bitmap)

drivers/md/md.c

5826

} else if (mddev->bitmap) {

drivers/md/md.c

7217

if (mddev->bitmap && mddev->bitmap_info.offset)

drivers/md/md.c

7415

if (has_journal || mddev->bitmap) {

drivers/md/md.c

7639

if (mddev->bitmap || mddev->bitmap_info.file)

drivers/md/md.c

7678

} else if (mddev->bitmap == NULL)

drivers/md/md.c

7926

if (mddev->bitmap && mddev->bitmap_info.offset)

drivers/md/md.c

7987

if (mddev->bitmap) {

drivers/md/md.c

8008

rv = mddev->bitmap_ops->get_stats(mddev->bitmap, &stats);

drivers/md/md.c

8812

err = mddev->bitmap_ops->get_stats(mddev->bitmap, &stats);

drivers/md/md.c

9383

if (!mddev->bitmap)

drivers/md/md.c

9420

if (mddev->bitmap) {

drivers/md/md.h

576

void *bitmap; /* the bitmap for the device */

drivers/md/persistent-data/dm-space-map-common.c

515

void *bitmap;

drivers/md/persistent-data/dm-space-map-common.c

523

ic->bitmap = NULL;

drivers/md/persistent-data/dm-space-map-common.c

620

ic->bitmap = dm_bitmap_data(ic->bitmap_block);

drivers/md/persistent-data/dm-space-map-common.c

638

ic->bitmap = dm_bitmap_data(ic->bitmap_block);

drivers/md/persistent-data/dm-space-map-common.c

666

old = sm_lookup_bitmap(ic->bitmap, bit);

drivers/md/persistent-data/dm-space-map-common.c

670

sm_set_bitmap(ic->bitmap, bit, 1);

drivers/md/persistent-data/dm-space-map-common.c

680

sm_set_bitmap(ic->bitmap, bit, 2);

drivers/md/persistent-data/dm-space-map-common.c

685

sm_set_bitmap(ic->bitmap, bit, 3);

drivers/md/persistent-data/dm-space-map-common.c

858

old = sm_lookup_bitmap(ic->bitmap, bit);

drivers/md/persistent-data/dm-space-map-common.c

866

sm_set_bitmap(ic->bitmap, bit, 0);

drivers/md/persistent-data/dm-space-map-common.c

876

sm_set_bitmap(ic->bitmap, bit, 1);

drivers/md/persistent-data/dm-space-map-common.c

889

sm_set_bitmap(ic->bitmap, bit, 2);

drivers/md/raid0.c

774

if (mddev->bitmap) {

drivers/md/raid1.c

1461

err = mddev->bitmap_ops->get_stats(mddev->bitmap, &stats);

drivers/md/raid1.c

1600

if (write_behind && mddev->bitmap)

drivers/md/raid1.c

2808

if (mddev->bitmap == NULL &&

drivers/md/raid10.c

3165

if (mddev->bitmap == NULL &&

drivers/md/raid10.c

3211

if ((!mddev->bitmap || conf->fullsync)

drivers/md/raid10.c

4429

if (mddev->delta_disks && mddev->bitmap) {

drivers/md/raid5.c

3540

if (conf->mddev->bitmap && firstwrite && !sh->batch_head) {

drivers/md/raid5.c

5757

if (conf->mddev->bitmap) {

drivers/media/pci/ivtv/ivtv-ioctl.c

450

winfmt->bitmap = NULL;

drivers/media/platform/nuvoton/npcm-video.c

176

static DECLARE_BITMAP(bitmap, BITMAP_SIZE);

drivers/media/platform/nuvoton/npcm-video.c

513

bitmap_from_arr32(bitmap, &value, BITMAP_SIZE);

drivers/media/platform/nuvoton/npcm-video.c

515

for_each_set_bit(bit, bitmap, BITMAP_SIZE) {

drivers/media/platform/ti/omap/omap_vout.c

786

win->bitmap = NULL;

drivers/media/platform/ti/omap/omap_voutlib.c

101

new_win->bitmap = NULL;

drivers/media/v4l2-core/v4l2-common.c

697

unsigned long *bitmap)

drivers/media/v4l2-core/v4l2-common.c

701

*bitmap = 0;

drivers/media/v4l2-core/v4l2-common.c

717

*bitmap |= BIT(j);

drivers/media/v4l2-core/v4l2-common.c

722

if (!*bitmap) {

drivers/media/v4l2-core/v4l2-compat-ioctl32.c

47

compat_caddr_t bitmap; /* always NULL */

drivers/media/v4l2-core/v4l2-compat-ioctl32.c

65

.bitmap = NULL,

drivers/media/v4l2-core/v4l2-compat-ioctl32.c

84

.bitmap = 0,

drivers/media/v4l2-core/v4l2-ioctl.c

1784

p->fmt.win.bitmap = NULL;

drivers/media/v4l2-core/v4l2-ioctl.c

1818

p->fmt.win.bitmap = NULL;

drivers/media/v4l2-core/v4l2-ioctl.c

1892

p->fmt.win.bitmap = NULL;

drivers/media/v4l2-core/v4l2-ioctl.c

1926

p->fmt.win.bitmap = NULL;

drivers/misc/vmw_vmci/vmci_doorbell.c

363

void vmci_dbell_scan_notification_entries(u8 *bitmap)

drivers/misc/vmw_vmci/vmci_doorbell.c

368

if (bitmap[idx] & 0x1) {

drivers/misc/vmw_vmci/vmci_doorbell.c

369

bitmap[idx] &= ~1;

drivers/misc/vmw_vmci/vmci_doorbell.h

41

void vmci_dbell_scan_notification_entries(u8 *bitmap);

drivers/mmc/host/renesas_sdhi_core.c

642

unsigned long *bitmap;

drivers/mmc/host/renesas_sdhi_core.c

666

bitmap = priv->smpcmp;

drivers/mmc/host/renesas_sdhi_core.c

669

bitmap = priv->taps;

drivers/mmc/host/renesas_sdhi_core.c

678

for_each_set_bitrange(rs, re, bitmap, taps_size) {

drivers/mtd/nand/core.c

36

const unsigned char *bitmap = buf;

drivers/mtd/nand/core.c

40

for (; len && ((uintptr_t)bitmap) % sizeof(long);

drivers/mtd/nand/core.c

41

len--, bitmap++) {

drivers/mtd/nand/core.c

42

weight = hweight8(*bitmap);

drivers/mtd/nand/core.c

49

len -= sizeof(long), bitmap += sizeof(long)) {

drivers/mtd/nand/core.c

50

unsigned long d = *((unsigned long *)bitmap);

drivers/mtd/nand/core.c

59

for (; len > 0; len--, bitmap++) {

drivers/mtd/nand/core.c

60

weight = hweight8(*bitmap);

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_cmd.c

180

hclge_comm_capability_to_bitmap(unsigned long *bitmap, __le32 *caps)

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_cmd.c

189

bitmap_from_arr32(bitmap, val,

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_debugfs.c

1019

req.bitmap = (u8)le32_to_cpu(desc.data[1]);

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_debugfs.c

1046

req.bitmap = (u8)le32_to_cpu(desc.data[1]);

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_debugfs.c

1069

req.bitmap = (u8)le32_to_cpu(desc.data[1]);

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_debugfs.c

1117

req.bitmap = (u8)le32_to_cpu(desc.data[1]);

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_debugfs.h

52

u8 bitmap;

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_err.c

3381

unsigned long *bitmap)

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_err.c

3388

func_id = find_first_bit(bitmap, HCLGE_VPORT_NUM);

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_err.c

3419

clear_bit(func_id, bitmap);

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_err.c

3420

func_id = find_first_bit(bitmap, HCLGE_VPORT_NUM);

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_err.c

3427

unsigned long *bitmap)

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_err.c

3437

memcpy(bitmap, desc[0].data, HCLGE_FIR_FAULT_BYTES);

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_err.c

3438

buff = (u8 *)bitmap + HCLGE_FIR_FAULT_BYTES;

drivers/net/ethernet/intel/ice/ice_ptp.c

2400

DECLARE_BITMAP(bitmap, GPIO_NA);

drivers/net/ethernet/intel/ice/ice_ptp.c

2405

*bitmap = FIELD_GET(ICE_AQC_NVM_SDP_AC_PIN_M, entry);

drivers/net/ethernet/intel/ice/ice_ptp.c

2408

if (bitmap_empty(bitmap, GPIO_NA))

drivers/net/ethernet/intel/ice/ice_sched.c

2795

unsigned long bitmap = tc_bitmap;

drivers/net/ethernet/intel/ice/ice_sched.c

2799

status = ice_sched_cfg_agg(pi, agg_id, agg_type, &bitmap);

drivers/net/ethernet/intel/ice/ice_sched.c

2801

status = ice_save_agg_tc_bitmap(pi, agg_id, &bitmap);

drivers/net/ethernet/intel/ice/ice_sched.c

3067

unsigned long bitmap = tc_bitmap;

drivers/net/ethernet/intel/ice/ice_sched.c

3072

(unsigned long *)&bitmap);

drivers/net/ethernet/intel/ice/ice_sched.c

3075

(unsigned long *)&bitmap);

drivers/net/ethernet/intel/ice/ice_type.h

24

static inline bool ice_is_tc_ena(unsigned long bitmap, u8 tc)

drivers/net/ethernet/intel/ice/ice_type.h

26

return test_bit(tc, &bitmap);

drivers/net/ethernet/marvell/octeontx2/af/rvu_debugfs.c

3580

u8 bitmap = 0;

drivers/net/ethernet/marvell/octeontx2/af/rvu_debugfs.c

3609

bitmap = 0;

drivers/net/ethernet/marvell/octeontx2/af/rvu_debugfs.c

3617

bitmap |= BIT(j);

drivers/net/ethernet/marvell/octeontx2/af/rvu_debugfs.c

3621

if (!bitmap)

drivers/net/ethernet/marvell/octeontx2/af/rvu_debugfs.c

3626

if (!(bitmap & BIT(j))) {

drivers/net/ethernet/marvell/prestera/prestera_ethtool.c

434

u64 bitmap;

drivers/net/ethernet/marvell/prestera/prestera_ethtool.c

444

bitmap = state->lmode_bmap;

drivers/net/ethernet/marvell/prestera/prestera_ethtool.c

447

bitmap, 0, PRESTERA_PORT_TYPE_NONE);

drivers/net/ethernet/mellanox/mlx4/alloc.c

100

if (test_bit(i, bitmap) || ((u32)i & skip_mask)) {

drivers/net/ethernet/mellanox/mlx4/alloc.c

109

u32 mlx4_bitmap_alloc_range(struct mlx4_bitmap *bitmap, int cnt,

drivers/net/ethernet/mellanox/mlx4/alloc.c

115

return mlx4_bitmap_alloc(bitmap);

drivers/net/ethernet/mellanox/mlx4/alloc.c

117

spin_lock(&bitmap->lock);

drivers/net/ethernet/mellanox/mlx4/alloc.c

119

obj = find_aligned_range(bitmap->table, bitmap->last,

drivers/net/ethernet/mellanox/mlx4/alloc.c

120

bitmap->max, cnt, align, skip_mask);

drivers/net/ethernet/mellanox/mlx4/alloc.c

121

if (obj >= bitmap->max) {

drivers/net/ethernet/mellanox/mlx4/alloc.c

122

bitmap->top = (bitmap->top + bitmap->max + bitmap->reserved_top)

drivers/net/ethernet/mellanox/mlx4/alloc.c

123

& bitmap->mask;

drivers/net/ethernet/mellanox/mlx4/alloc.c

124

obj = find_aligned_range(bitmap->table, 0, bitmap->max,

drivers/net/ethernet/mellanox/mlx4/alloc.c

128

if (obj < bitmap->max) {

drivers/net/ethernet/mellanox/mlx4/alloc.c

129

bitmap_set(bitmap->table, obj, cnt);

drivers/net/ethernet/mellanox/mlx4/alloc.c

130

if (obj == bitmap->last) {

drivers/net/ethernet/mellanox/mlx4/alloc.c

131

bitmap->last = (obj + cnt);

drivers/net/ethernet/mellanox/mlx4/alloc.c

132

if (bitmap->last >= bitmap->max)

drivers/net/ethernet/mellanox/mlx4/alloc.c

133

bitmap->last = 0;

drivers/net/ethernet/mellanox/mlx4/alloc.c

135

obj |= bitmap->top;

drivers/net/ethernet/mellanox/mlx4/alloc.c

140

bitmap->avail -= cnt;

drivers/net/ethernet/mellanox/mlx4/alloc.c

142

spin_unlock(&bitmap->lock);

drivers/net/ethernet/mellanox/mlx4/alloc.c

147

u32 mlx4_bitmap_avail(struct mlx4_bitmap *bitmap)

drivers/net/ethernet/mellanox/mlx4/alloc.c

149

return bitmap->avail;

drivers/net/ethernet/mellanox/mlx4/alloc.c

152

static u32 mlx4_bitmap_masked_value(struct mlx4_bitmap *bitmap, u32 obj)

drivers/net/ethernet/mellanox/mlx4/alloc.c

154

return obj & (bitmap->max + bitmap->reserved_top - 1);

drivers/net/ethernet/mellanox/mlx4/alloc.c

157

void mlx4_bitmap_free_range(struct mlx4_bitmap *bitmap, u32 obj, int cnt,

drivers/net/ethernet/mellanox/mlx4/alloc.c

160

obj &= bitmap->max + bitmap->reserved_top - 1;

drivers/net/ethernet/mellanox/mlx4/alloc.c

162

spin_lock(&bitmap->lock);

drivers/net/ethernet/mellanox/mlx4/alloc.c

164

bitmap->last = min(bitmap->last, obj);

drivers/net/ethernet/mellanox/mlx4/alloc.c

165

bitmap->top = (bitmap->top + bitmap->max + bitmap->reserved_top)

drivers/net/ethernet/mellanox/mlx4/alloc.c

166

& bitmap->mask;

drivers/net/ethernet/mellanox/mlx4/alloc.c

168

bitmap_clear(bitmap->table, obj, cnt);

drivers/net/ethernet/mellanox/mlx4/alloc.c

169

bitmap->avail += cnt;

drivers/net/ethernet/mellanox/mlx4/alloc.c

170

spin_unlock(&bitmap->lock);

drivers/net/ethernet/mellanox/mlx4/alloc.c

173

int mlx4_bitmap_init(struct mlx4_bitmap *bitmap, u32 num, u32 mask,

drivers/net/ethernet/mellanox/mlx4/alloc.c

180

bitmap->last = 0;

drivers/net/ethernet/mellanox/mlx4/alloc.c

181

bitmap->top = 0;

drivers/net/ethernet/mellanox/mlx4/alloc.c

182

bitmap->max = num - reserved_top;

drivers/net/ethernet/mellanox/mlx4/alloc.c

183

bitmap->mask = mask;

drivers/net/ethernet/mellanox/mlx4/alloc.c

184

bitmap->reserved_top = reserved_top;

drivers/net/ethernet/mellanox/mlx4/alloc.c

185

bitmap->avail = num - reserved_top - reserved_bot;

drivers/net/ethernet/mellanox/mlx4/alloc.c

186

bitmap->effective_len = bitmap->avail;

drivers/net/ethernet/mellanox/mlx4/alloc.c

187

spin_lock_init(&bitmap->lock);

drivers/net/ethernet/mellanox/mlx4/alloc.c

188

bitmap->table = bitmap_zalloc(bitmap->max, GFP_KERNEL);

drivers/net/ethernet/mellanox/mlx4/alloc.c

189

if (!bitmap->table)

drivers/net/ethernet/mellanox/mlx4/alloc.c

192

bitmap_set(bitmap->table, 0, reserved_bot);

drivers/net/ethernet/mellanox/mlx4/alloc.c

197

void mlx4_bitmap_cleanup(struct mlx4_bitmap *bitmap)

drivers/net/ethernet/mellanox/mlx4/alloc.c

199

bitmap_free(bitmap->table);

drivers/net/ethernet/mellanox/mlx4/alloc.c

217

struct mlx4_bitmap *bitmap;

drivers/net/ethernet/mellanox/mlx4/alloc.c

242

struct mlx4_bitmap *bitmap,

drivers/net/ethernet/mellanox/mlx4/alloc.c

248

u32 mask = mlx4_bitmap_masked_value(bitmap, (u32)-1);

drivers/net/ethernet/mellanox/mlx4/alloc.c

256

zone->bitmap = bitmap;

drivers/net/ethernet/mellanox/mlx4/alloc.c

310

u32 cur_mask = mlx4_bitmap_masked_value(it->bitmap, (u32)-1);

drivers/net/ethernet/mellanox/mlx4/alloc.c

344

res = mlx4_bitmap_alloc_range(zone->bitmap, count,

drivers/net/ethernet/mellanox/mlx4/alloc.c

362

res = mlx4_bitmap_alloc_range(it->bitmap, count,

drivers/net/ethernet/mellanox/mlx4/alloc.c

382

res = mlx4_bitmap_alloc_range(it->bitmap, count,

drivers/net/ethernet/mellanox/mlx4/alloc.c

401

res = mlx4_bitmap_alloc_range(curr_node->bitmap, count,

drivers/net/ethernet/mellanox/mlx4/alloc.c

421

mlx4_bitmap_free_range(zone->bitmap, obj - zone->offset, count, zone->use_rr);

drivers/net/ethernet/mellanox/mlx4/alloc.c

44

u32 mlx4_bitmap_alloc(struct mlx4_bitmap *bitmap)

drivers/net/ethernet/mellanox/mlx4/alloc.c

441

struct mlx4_bitmap *bitmap;

drivers/net/ethernet/mellanox/mlx4/alloc.c

447

bitmap = zone == NULL ? NULL : zone->bitmap;

drivers/net/ethernet/mellanox/mlx4/alloc.c

451

return bitmap;

drivers/net/ethernet/mellanox/mlx4/alloc.c

48

spin_lock(&bitmap->lock);

drivers/net/ethernet/mellanox/mlx4/alloc.c

494

if (mobj < zone->bitmap->max) {

drivers/net/ethernet/mellanox/mlx4/alloc.c

495

u32 curr_dist = zone->bitmap->effective_len;

drivers/net/ethernet/mellanox/mlx4/alloc.c

50

obj = find_next_zero_bit(bitmap->table, bitmap->max, bitmap->last);

drivers/net/ethernet/mellanox/mlx4/alloc.c

51

if (obj >= bitmap->max) {

drivers/net/ethernet/mellanox/mlx4/alloc.c

52

bitmap->top = (bitmap->top + bitmap->max + bitmap->reserved_top)

drivers/net/ethernet/mellanox/mlx4/alloc.c

53

& bitmap->mask;

drivers/net/ethernet/mellanox/mlx4/alloc.c

54

obj = find_first_zero_bit(bitmap->table, bitmap->max);

drivers/net/ethernet/mellanox/mlx4/alloc.c

57

if (obj < bitmap->max) {

drivers/net/ethernet/mellanox/mlx4/alloc.c

58

set_bit(obj, bitmap->table);

drivers/net/ethernet/mellanox/mlx4/alloc.c

59

bitmap->last = (obj + 1);

drivers/net/ethernet/mellanox/mlx4/alloc.c

60

if (bitmap->last == bitmap->max)

drivers/net/ethernet/mellanox/mlx4/alloc.c

61

bitmap->last = 0;

drivers/net/ethernet/mellanox/mlx4/alloc.c

62

obj |= bitmap->top;

drivers/net/ethernet/mellanox/mlx4/alloc.c

67

--bitmap->avail;

drivers/net/ethernet/mellanox/mlx4/alloc.c

69

spin_unlock(&bitmap->lock);

drivers/net/ethernet/mellanox/mlx4/alloc.c

74

void mlx4_bitmap_free(struct mlx4_bitmap *bitmap, u32 obj, int use_rr)

drivers/net/ethernet/mellanox/mlx4/alloc.c

76

mlx4_bitmap_free_range(bitmap, obj, 1, use_rr);

drivers/net/ethernet/mellanox/mlx4/alloc.c

79

static unsigned long find_aligned_range(unsigned long *bitmap,

drivers/net/ethernet/mellanox/mlx4/alloc.c

88

while ((start < nbits) && (test_bit(start, bitmap) ||

drivers/net/ethernet/mellanox/mlx4/cq.c

223

*cqn = mlx4_bitmap_alloc(&cq_table->bitmap);

drivers/net/ethernet/mellanox/mlx4/cq.c

240

mlx4_bitmap_free(&cq_table->bitmap, *cqn, MLX4_NO_RR);

drivers/net/ethernet/mellanox/mlx4/cq.c

271

mlx4_bitmap_free(&cq_table->bitmap, cqn, MLX4_NO_RR);

drivers/net/ethernet/mellanox/mlx4/cq.c

472

return mlx4_bitmap_init(&cq_table->bitmap, dev->caps.num_cqs,

drivers/net/ethernet/mellanox/mlx4/cq.c

481

mlx4_bitmap_cleanup(&mlx4_priv(dev)->cq_table.bitmap);

drivers/net/ethernet/mellanox/mlx4/en_ethtool.c

1103

bitmap_iterator_init(&it, priv->stats_bitmap.bitmap, NUM_ALL_STATS);

drivers/net/ethernet/mellanox/mlx4/en_ethtool.c

1107

priv->stats_bitmap.bitmap))

drivers/net/ethernet/mellanox/mlx4/en_ethtool.c

1110

priv->stats_bitmap.bitmap))

drivers/net/ethernet/mellanox/mlx4/en_ethtool.c

349

bitmap_iterator_init(&it, priv->stats_bitmap.bitmap, NUM_ALL_STATS);

drivers/net/ethernet/mellanox/mlx4/en_ethtool.c

374

bitmap_iterator_init(&it, priv->stats_bitmap.bitmap, NUM_ALL_STATS);

drivers/net/ethernet/mellanox/mlx4/en_ethtool.c

456

bitmap_iterator_init(&it, priv->stats_bitmap.bitmap, NUM_ALL_STATS);

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

3011

bitmap_clear(stats_bitmap->bitmap, last_i, NUM_FLOW_STATS);

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

3014

bitmap_set(stats_bitmap->bitmap, last_i,

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

3019

bitmap_set(stats_bitmap->bitmap, last_i,

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

3024

bitmap_set(stats_bitmap->bitmap, last_i,

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

3029

bitmap_set(stats_bitmap->bitmap, last_i,

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

3045

bitmap_zero(stats_bitmap->bitmap, NUM_ALL_STATS);

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

3048

bitmap_set(stats_bitmap->bitmap, last_i +

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

3050

bitmap_set(stats_bitmap->bitmap, last_i +

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

3052

bitmap_set(stats_bitmap->bitmap, last_i +

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

3054

bitmap_set(stats_bitmap->bitmap, last_i +

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

3056

bitmap_set(stats_bitmap->bitmap, last_i +

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

3058

bitmap_set(stats_bitmap->bitmap, last_i +

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

3061

bitmap_set(stats_bitmap->bitmap, last_i, NUM_MAIN_STATS);

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

3065

bitmap_set(stats_bitmap->bitmap, last_i, NUM_PORT_STATS);

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

3069

bitmap_set(stats_bitmap->bitmap, last_i,

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

3079

bitmap_set(stats_bitmap->bitmap, last_i, NUM_PKT_STATS);

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

3082

bitmap_set(stats_bitmap->bitmap, last_i, NUM_XDP_STATS);

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

3086

bitmap_set(stats_bitmap->bitmap, last_i, NUM_PHY_STATS);

drivers/net/ethernet/mellanox/mlx4/eq.c

1018

eq->eqn = mlx4_bitmap_alloc(&priv->eq_table.bitmap);

drivers/net/ethernet/mellanox/mlx4/eq.c

1068

mlx4_bitmap_free(&priv->eq_table.bitmap, eq->eqn, MLX4_USE_RR);

drivers/net/ethernet/mellanox/mlx4/eq.c

1112

mlx4_bitmap_free(&priv->eq_table.bitmap, eq->eqn, MLX4_USE_RR);

drivers/net/ethernet/mellanox/mlx4/eq.c

1186

err = mlx4_bitmap_init(&priv->eq_table.bitmap,

drivers/net/ethernet/mellanox/mlx4/eq.c

1320

mlx4_bitmap_cleanup(&priv->eq_table.bitmap);

drivers/net/ethernet/mellanox/mlx4/eq.c

1353

mlx4_bitmap_cleanup(&priv->eq_table.bitmap);

drivers/net/ethernet/mellanox/mlx4/mcg.c

1138

index = mlx4_bitmap_alloc(&priv->mcg_table.bitmap);

drivers/net/ethernet/mellanox/mlx4/mcg.c

1205

mlx4_bitmap_free(&priv->mcg_table.bitmap,

drivers/net/ethernet/mellanox/mlx4/mcg.c

1301

mlx4_bitmap_free(&priv->mcg_table.bitmap,

drivers/net/ethernet/mellanox/mlx4/mcg.c

1321

mlx4_bitmap_free(&priv->mcg_table.bitmap,

drivers/net/ethernet/mellanox/mlx4/mcg.c

1634

err = mlx4_bitmap_init(&priv->mcg_table.bitmap, dev->caps.num_amgms,

drivers/net/ethernet/mellanox/mlx4/mcg.c

1648

mlx4_bitmap_cleanup(&mlx4_priv(dev)->mcg_table.bitmap);

drivers/net/ethernet/mellanox/mlx4/mlx4.h

1459

struct mlx4_bitmap *bitmap,

drivers/net/ethernet/mellanox/mlx4/mlx4.h

670

struct mlx4_bitmap bitmap;

drivers/net/ethernet/mellanox/mlx4/mlx4.h

683

struct mlx4_bitmap bitmap;

drivers/net/ethernet/mellanox/mlx4/mlx4.h

691

struct mlx4_bitmap bitmap;

drivers/net/ethernet/mellanox/mlx4/mlx4.h

704

struct mlx4_bitmap bitmap;

drivers/net/ethernet/mellanox/mlx4/mlx4.h

734

struct mlx4_bitmap bitmap;

drivers/net/ethernet/mellanox/mlx4/mlx4.h

946

u32 mlx4_bitmap_alloc(struct mlx4_bitmap *bitmap);

drivers/net/ethernet/mellanox/mlx4/mlx4.h

947

void mlx4_bitmap_free(struct mlx4_bitmap *bitmap, u32 obj, int use_rr);

drivers/net/ethernet/mellanox/mlx4/mlx4.h

948

u32 mlx4_bitmap_alloc_range(struct mlx4_bitmap *bitmap, int cnt,

drivers/net/ethernet/mellanox/mlx4/mlx4.h

950

void mlx4_bitmap_free_range(struct mlx4_bitmap *bitmap, u32 obj, int cnt,

drivers/net/ethernet/mellanox/mlx4/mlx4.h

952

u32 mlx4_bitmap_avail(struct mlx4_bitmap *bitmap);

drivers/net/ethernet/mellanox/mlx4/mlx4.h

953

int mlx4_bitmap_init(struct mlx4_bitmap *bitmap, u32 num, u32 mask,

drivers/net/ethernet/mellanox/mlx4/mlx4.h

955

void mlx4_bitmap_cleanup(struct mlx4_bitmap *bitmap);

drivers/net/ethernet/mellanox/mlx4/mlx4_en.h

521

DECLARE_BITMAP(bitmap, NUM_ALL_STATS);

drivers/net/ethernet/mellanox/mlx4/pd.c

149

uar->index = mlx4_bitmap_alloc(&mlx4_priv(dev)->uar_table.bitmap);

drivers/net/ethernet/mellanox/mlx4/pd.c

168

mlx4_bitmap_free(&mlx4_priv(dev)->uar_table.bitmap, uar->index, MLX4_USE_RR);

drivers/net/ethernet/mellanox/mlx4/pd.c

186

if (mlx4_bitmap_avail(&priv->uar_table.bitmap) < MLX4_NUM_RESERVED_UARS) {

drivers/net/ethernet/mellanox/mlx4/pd.c

287

return mlx4_bitmap_init(&mlx4_priv(dev)->uar_table.bitmap,

drivers/net/ethernet/mellanox/mlx4/pd.c

294

mlx4_bitmap_cleanup(&mlx4_priv(dev)->uar_table.bitmap);

drivers/net/ethernet/mellanox/mlx4/qp.c

556

struct mlx4_bitmap (*bitmap)[MLX4_QP_TABLE_ZONE_NUM] = NULL;

drivers/net/ethernet/mellanox/mlx4/qp.c

567

bitmap = kmalloc_obj(*bitmap);

drivers/net/ethernet/mellanox/mlx4/qp.c

569

if (NULL == bitmap) {

drivers/net/ethernet/mellanox/mlx4/qp.c

574

err = mlx4_bitmap_init(*bitmap + MLX4_QP_TABLE_ZONE_GENERAL, dev->caps.num_qps,

drivers/net/ethernet/mellanox/mlx4/qp.c

583

err = mlx4_zone_add_one(qp_table->zones, *bitmap + MLX4_QP_TABLE_ZONE_GENERAL,

drivers/net/ethernet/mellanox/mlx4/qp.c

591

err = mlx4_bitmap_init(*bitmap + MLX4_QP_TABLE_ZONE_RSS,

drivers/net/ethernet/mellanox/mlx4/qp.c

602

err = mlx4_zone_add_one(qp_table->zones, *bitmap + MLX4_QP_TABLE_ZONE_RSS,

drivers/net/ethernet/mellanox/mlx4/qp.c

620

for (k = MLX4_QP_TABLE_ZONE_RSS + 1; k < sizeof(*bitmap)/sizeof((*bitmap)[0]);

drivers/net/ethernet/mellanox/mlx4/qp.c

683

*bitmap + MLX4_QP_TABLE_ZONE_RSS,

drivers/net/ethernet/mellanox/mlx4/qp.c

694

err = mlx4_bitmap_init(*bitmap + k, roundup_pow_of_two(size),

drivers/net/ethernet/mellanox/mlx4/qp.c

701

err = mlx4_bitmap_init(*bitmap + k, 1,

drivers/net/ethernet/mellanox/mlx4/qp.c

705

mlx4_bitmap_alloc_range(*bitmap + k, 1, 1, 0);

drivers/net/ethernet/mellanox/mlx4/qp.c

713

err = mlx4_zone_add_one(qp_table->zones, *bitmap + k,

drivers/net/ethernet/mellanox/mlx4/qp.c

726

qp_table->bitmap_gen = *bitmap;

drivers/net/ethernet/mellanox/mlx4/qp.c

732

mlx4_bitmap_cleanup(*bitmap + k);

drivers/net/ethernet/mellanox/mlx4/qp.c

733

kfree(bitmap);

drivers/net/ethernet/mellanox/mlx4/qp.c

749

struct mlx4_bitmap *bitmap =

drivers/net/ethernet/mellanox/mlx4/qp.c

754

if (NULL == bitmap)

drivers/net/ethernet/mellanox/mlx4/qp.c

757

mlx4_bitmap_cleanup(bitmap);

drivers/net/ethernet/mellanox/mlx4/srq.c

116

mlx4_bitmap_free(&srq_table->bitmap, *srqn, MLX4_NO_RR);

drivers/net/ethernet/mellanox/mlx4/srq.c

144

mlx4_bitmap_free(&srq_table->bitmap, srqn, MLX4_NO_RR);

drivers/net/ethernet/mellanox/mlx4/srq.c

281

return mlx4_bitmap_init(&srq_table->bitmap, dev->caps.num_srqs,

drivers/net/ethernet/mellanox/mlx4/srq.c

289

mlx4_bitmap_cleanup(&mlx4_priv(dev)->srq_table.bitmap);

drivers/net/ethernet/mellanox/mlx4/srq.c

99

*srqn = mlx4_bitmap_alloc(&srq_table->bitmap);

drivers/net/ethernet/mellanox/mlx5/core/alloc.c

142

pgdir->bitmap = bitmap_zalloc_node(db_per_page, GFP_KERNEL, node);

drivers/net/ethernet/mellanox/mlx5/core/alloc.c

143

if (!pgdir->bitmap) {

drivers/net/ethernet/mellanox/mlx5/core/alloc.c

148

bitmap_fill(pgdir->bitmap, db_per_page);

drivers/net/ethernet/mellanox/mlx5/core/alloc.c

153

bitmap_free(pgdir->bitmap);

drivers/net/ethernet/mellanox/mlx5/core/alloc.c

168

i = find_first_bit(pgdir->bitmap, db_per_page);

drivers/net/ethernet/mellanox/mlx5/core/alloc.c

172

__clear_bit(i, pgdir->bitmap);

drivers/net/ethernet/mellanox/mlx5/core/alloc.c

221

__set_bit(db->index, db->u.pgdir->bitmap);

drivers/net/ethernet/mellanox/mlx5/core/alloc.c

223

if (bitmap_full(db->u.pgdir->bitmap, db_per_page)) {

drivers/net/ethernet/mellanox/mlx5/core/alloc.c

227

bitmap_free(db->u.pgdir->bitmap);

drivers/net/ethernet/mellanox/mlx5/core/alloc.c

46

unsigned long *bitmap;

drivers/net/ethernet/mellanox/mlx5/core/lib/mpfs.c

112

mpfs->bitmap = bitmap_zalloc(l2table_size, GFP_KERNEL);

drivers/net/ethernet/mellanox/mlx5/core/lib/mpfs.c

113

if (!mpfs->bitmap) {

drivers/net/ethernet/mellanox/mlx5/core/lib/mpfs.c

132

bitmap_free(mpfs->bitmap);

drivers/net/ethernet/mellanox/mlx5/core/lib/mpfs.c

77

unsigned long *bitmap;

drivers/net/ethernet/mellanox/mlx5/core/lib/mpfs.c

84

*ix = find_first_zero_bit(l2table->bitmap, l2table->size);

drivers/net/ethernet/mellanox/mlx5/core/lib/mpfs.c

88

__set_bit(*ix, l2table->bitmap);

drivers/net/ethernet/mellanox/mlx5/core/lib/mpfs.c

95

__clear_bit(ix, l2table->bitmap);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/buddy.c

121

bitmap_clear(buddy->bitmap[order_iter], seg, 1);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/buddy.c

127

bitmap_set(buddy->bitmap[order_iter], seg ^ 1, 1);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/buddy.c

13

buddy->bitmap = kcalloc(buddy->max_order + 1,

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/buddy.c

14

sizeof(*buddy->bitmap),

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/buddy.c

140

while (test_bit(seg ^ 1, buddy->bitmap[order])) {

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/buddy.c

141

bitmap_clear(buddy->bitmap[order], seg ^ 1, 1);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/buddy.c

147

bitmap_set(buddy->bitmap[order], seg, 1);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/buddy.c

16

if (!buddy->bitmap)

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/buddy.c

30

buddy->bitmap[i] = bitmap_zalloc(s, GFP_KERNEL);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/buddy.c

31

if (!buddy->bitmap[i]) {

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/buddy.c

37

bitmap_set(buddy->bitmap[buddy->max_order], 0, 1);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/buddy.c

44

bitmap_free(buddy->bitmap[i]);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/buddy.c

49

kfree(buddy->bitmap);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/buddy.c

76

bitmap_free(buddy->bitmap[i]);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/buddy.c

79

kfree(buddy->bitmap);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/buddy.c

95

seg = find_first_bit(buddy->bitmap[order_iter], m);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/buddy.h

8

unsigned long **bitmap;

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.c

196

unsigned long *bitmap;

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.c

198

bitmap = bitmap_zalloc(1 << log_range, GFP_KERNEL);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.c

199

if (!bitmap)

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.c

202

bitmap_fill(bitmap, 1 << log_range);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.c

204

return bitmap;

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.c

209

unsigned long *bitmap;

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.c

211

bitmap = hws_pool_create_and_init_bitmap(pool->alloc_log_sz);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.c

212

if (!bitmap) {

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.c

221

bitmap_free(bitmap);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.c

225

pool->db.bitmap = bitmap;

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.c

233

unsigned long *bitmap, size;

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.c

240

bitmap = pool->db.bitmap;

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.c

241

if (!bitmap) {

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.c

248

chunk->offset = find_first_bit(bitmap, size);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.c

252

bitmap_clear(bitmap, chunk->offset, 1);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.c

260

unsigned long *bitmap;

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.c

262

bitmap = pool->db.bitmap;

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.c

263

if (!bitmap) {

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.c

268

bitmap_set(bitmap, chunk->offset, 1);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.c

273

unsigned long *bitmap;

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.c

275

bitmap = pool->db.bitmap;

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.c

276

if (bitmap) {

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.c

277

bitmap_free(bitmap);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.c

278

pool->db.bitmap = NULL;

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.h

58

unsigned long *bitmap;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_buddy.c

126

bitmap_clear(buddy->bitmap[order_iter], seg, 1);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_buddy.c

136

bitmap_set(buddy->bitmap[order_iter], seg ^ 1, 1);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_buddy.c

154

while (test_bit(seg ^ 1, buddy->bitmap[order])) {

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_buddy.c

155

bitmap_clear(buddy->bitmap[order], seg ^ 1, 1);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_buddy.c

160

bitmap_set(buddy->bitmap[order], seg, 1);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_buddy.c

19

buddy->bitmap = kzalloc_objs(*buddy->bitmap, buddy->max_order + 1);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_buddy.c

22

if (!buddy->bitmap || !buddy->num_free)

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_buddy.c

30

buddy->bitmap[i] = bitmap_zalloc(size, GFP_KERNEL);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_buddy.c

31

if (!buddy->bitmap[i])

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_buddy.c

39

bitmap_set(buddy->bitmap[buddy->max_order], 0, 1);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_buddy.c

47

bitmap_free(buddy->bitmap[i]);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_buddy.c

51

kfree(buddy->bitmap);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_buddy.c

62

bitmap_free(buddy->bitmap[i]);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_buddy.c

65

kfree(buddy->bitmap);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_buddy.c

81

seg = find_first_bit(buddy->bitmap[order_iter], m);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/mlx5dr.h

169

unsigned long **bitmap;

drivers/net/ethernet/mellanox/mlx5/core/uar.c

210

unsigned long *bitmap;

drivers/net/ethernet/mellanox/mlx5/core/uar.c

236

bitmap = up->fp_bitmap;

drivers/net/ethernet/mellanox/mlx5/core/uar.c

239

bitmap = up->reg_bitmap;

drivers/net/ethernet/mellanox/mlx5/core/uar.c

242

dbi = find_first_bit(bitmap, up->bfregs);

drivers/net/ethernet/mellanox/mlx5/core/uar.c

243

clear_bit(dbi, bitmap);

drivers/net/ethernet/mellanox/mlx5/core/uar.c

297

unsigned long *bitmap;

drivers/net/ethernet/mellanox/mlx5/core/uar.c

313

bitmap = up->fp_bitmap;

drivers/net/ethernet/mellanox/mlx5/core/uar.c

316

bitmap = up->reg_bitmap;

drivers/net/ethernet/mellanox/mlx5/core/uar.c

320

set_bit(dbi, bitmap);

drivers/net/ethernet/mellanox/mlxsw/spectrum.h

390

unsigned long *bitmap;

drivers/net/ethernet/mellanox/mlxsw/spectrum.h

401

ports_bm->bitmap = bitmap_zalloc(nbits, GFP_KERNEL);

drivers/net/ethernet/mellanox/mlxsw/spectrum.h

402

if (!ports_bm->bitmap)

drivers/net/ethernet/mellanox/mlxsw/spectrum.h

411

bitmap_free(ports_bm->bitmap);

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_erp.c

169

__set_bit(bit, mask->bitmap);

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_erp.c

177

__clear_bit(bit, mask->bitmap);

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_erp.c

190

bitmap_to_arr32((u32 *) master_mask, erp_table->master_mask.bitmap,

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_erp.c

49

DECLARE_BITMAP(bitmap, MLXSW_SP_ACL_TCAM_MASK_LEN);

drivers/net/ethernet/mellanox/mlxsw/spectrum_switchdev.c

1930

set_bit(bridge_port->system_port, ports_bm->bitmap);

drivers/net/ethernet/mellanox/mlxsw/spectrum_switchdev.c

1940

ports_bm->bitmap);

drivers/net/ethernet/mellanox/mlxsw/spectrum_switchdev.c

1969

for_each_set_bit(i, ports_bm->bitmap, nbits) {

drivers/net/ethernet/mellanox/mlxsw/spectrum_switchdev.c

1982

for_each_set_bit(i, ports_bm->bitmap, nbits)

drivers/net/ethernet/mellanox/mlxsw/spectrum_switchdev.c

1993

for_each_set_bit(i, ports_bm->bitmap, ports_bm->nbits)

drivers/net/ethernet/qlogic/qed/qed_iwarp.c

1298

weight = bitmap_weight(bmap->bitmap, bmap->max_count);

drivers/net/ethernet/qlogic/qed/qed_iwarp.c

1312

weight = bitmap_weight(bmap->bitmap, bmap->max_count);

drivers/net/ethernet/qlogic/qed/qed_rdma.c

1016

p_info->toggle_bits.bitmap);

drivers/net/ethernet/qlogic/qed/qed_rdma.c

104

return test_bit(id_num, bmap->bitmap);

drivers/net/ethernet/qlogic/qed/qed_rdma.c

109

return bitmap_empty(bmap->bitmap, bmap->max_count);

drivers/net/ethernet/qlogic/qed/qed_rdma.c

1857

if (!p_hwfn->p_rdma_info->cid_map.bitmap)

drivers/net/ethernet/qlogic/qed/qed_rdma.c

291

kfree(p_rdma_info->srq_map.bitmap);

drivers/net/ethernet/qlogic/qed/qed_rdma.c

293

kfree(p_rdma_info->xrc_srq_map.bitmap);

drivers/net/ethernet/qlogic/qed/qed_rdma.c

295

kfree(p_rdma_info->real_cid_map.bitmap);

drivers/net/ethernet/qlogic/qed/qed_rdma.c

297

kfree(p_rdma_info->cid_map.bitmap);

drivers/net/ethernet/qlogic/qed/qed_rdma.c

299

kfree(p_rdma_info->tid_map.bitmap);

drivers/net/ethernet/qlogic/qed/qed_rdma.c

301

kfree(p_rdma_info->toggle_bits.bitmap);

drivers/net/ethernet/qlogic/qed/qed_rdma.c

303

kfree(p_rdma_info->cq_map.bitmap);

drivers/net/ethernet/qlogic/qed/qed_rdma.c

305

kfree(p_rdma_info->dpi_map.bitmap);

drivers/net/ethernet/qlogic/qed/qed_rdma.c

307

kfree(p_rdma_info->xrcd_map.bitmap);

drivers/net/ethernet/qlogic/qed/qed_rdma.c

309

kfree(p_rdma_info->pd_map.bitmap);

drivers/net/ethernet/qlogic/qed/qed_rdma.c

327

weight = bitmap_weight(bmap->bitmap, bmap->max_count);

drivers/net/ethernet/qlogic/qed/qed_rdma.c

336

b = bmap->bitmap + BITS_TO_LONGS(bit);

drivers/net/ethernet/qlogic/qed/qed_rdma.c

345

bitmap_free(bmap->bitmap);

drivers/net/ethernet/qlogic/qed/qed_rdma.c

346

bmap->bitmap = NULL;

drivers/net/ethernet/qlogic/qed/qed_rdma.c

45

bmap->bitmap = bitmap_zalloc(max_count, GFP_KERNEL);

drivers/net/ethernet/qlogic/qed/qed_rdma.c

46

if (!bmap->bitmap)

drivers/net/ethernet/qlogic/qed/qed_rdma.c

58

*id_num = find_first_zero_bit(bmap->bitmap, bmap->max_count);

drivers/net/ethernet/qlogic/qed/qed_rdma.c

62

__set_bit(*id_num, bmap->bitmap);

drivers/net/ethernet/qlogic/qed/qed_rdma.c

76

__set_bit(id_num, bmap->bitmap);

drivers/net/ethernet/qlogic/qed/qed_rdma.c

87

b_acquired = test_and_clear_bit(id_num, bmap->bitmap);

drivers/net/ethernet/qlogic/qed/qed_rdma.h

52

unsigned long *bitmap;

drivers/net/ethernet/qlogic/qed/qed_roce.c

79

while (!bitmap_empty(rcid_map->bitmap, rcid_map->max_count)) {

drivers/net/phy/mscc/mscc_macsec.c

603

unsigned long *bitmap = bank == MACSEC_INGR ?

drivers/net/phy/mscc/mscc_macsec.c

608

index = find_first_zero_bit(bitmap, MSCC_MS_MAX_FLOWS);

drivers/net/phy/mscc/mscc_macsec.c

617

set_bit(index, bitmap);

drivers/net/phy/mscc/mscc_macsec.c

630

unsigned long *bitmap = flow->bank == MACSEC_INGR ?

drivers/net/phy/mscc/mscc_macsec.c

634

clear_bit(flow->index, bitmap);

drivers/net/virtio_net.c

4501

u64 bitmap[3];

drivers/net/virtio_net.c

4526

ctx->bitmap[queue_type] |= VIRTIO_NET_STATS_TYPE_RX_BASIC;

drivers/net/virtio_net.c

4532

ctx->bitmap[queue_type] |= VIRTIO_NET_STATS_TYPE_RX_CSUM;

drivers/net/virtio_net.c

4538

ctx->bitmap[queue_type] |= VIRTIO_NET_STATS_TYPE_RX_GSO;

drivers/net/virtio_net.c

4544

ctx->bitmap[queue_type] |= VIRTIO_NET_STATS_TYPE_RX_SPEED;

drivers/net/virtio_net.c

4552

ctx->bitmap[queue_type] |= VIRTIO_NET_STATS_TYPE_TX_BASIC;

drivers/net/virtio_net.c

4558

ctx->bitmap[queue_type] |= VIRTIO_NET_STATS_TYPE_TX_CSUM;

drivers/net/virtio_net.c

4564

ctx->bitmap[queue_type] |= VIRTIO_NET_STATS_TYPE_TX_GSO;

drivers/net/virtio_net.c

4570

ctx->bitmap[queue_type] |= VIRTIO_NET_STATS_TYPE_TX_SPEED;

drivers/net/virtio_net.c

4584

ctx->bitmap[queue_type] |= VIRTIO_NET_STATS_TYPE_CVQ;

drivers/net/virtio_net.c

4592

ctx->bitmap[queue_type] |= VIRTIO_NET_STATS_TYPE_RX_BASIC;

drivers/net/virtio_net.c

4598

ctx->bitmap[queue_type] |= VIRTIO_NET_STATS_TYPE_RX_CSUM;

drivers/net/virtio_net.c

4604

ctx->bitmap[queue_type] |= VIRTIO_NET_STATS_TYPE_RX_SPEED;

drivers/net/virtio_net.c

4612

ctx->bitmap[queue_type] |= VIRTIO_NET_STATS_TYPE_TX_BASIC;

drivers/net/virtio_net.c

4618

ctx->bitmap[queue_type] |= VIRTIO_NET_STATS_TYPE_TX_GSO;

drivers/net/virtio_net.c

4624

ctx->bitmap[queue_type] |= VIRTIO_NET_STATS_TYPE_TX_SPEED;

drivers/net/virtio_net.c

4679

u64 offset, bitmap;

drivers/net/virtio_net.c

4685

bitmap = ctx->bitmap[queue_type];

drivers/net/virtio_net.c

4704

if (bitmap & VIRTIO_NET_STATS_TYPE_RX_BASIC) {

drivers/net/virtio_net.c

4711

if (bitmap & VIRTIO_NET_STATS_TYPE_RX_CSUM) {

drivers/net/virtio_net.c

4718

if (bitmap & VIRTIO_NET_STATS_TYPE_RX_GSO) {

drivers/net/virtio_net.c

4725

if (bitmap & VIRTIO_NET_STATS_TYPE_RX_SPEED) {

drivers/net/virtio_net.c

4732

if (bitmap & VIRTIO_NET_STATS_TYPE_TX_BASIC) {

drivers/net/virtio_net.c

4739

if (bitmap & VIRTIO_NET_STATS_TYPE_TX_CSUM) {

drivers/net/virtio_net.c

4746

if (bitmap & VIRTIO_NET_STATS_TYPE_TX_GSO) {

drivers/net/virtio_net.c

4753

if (bitmap & VIRTIO_NET_STATS_TYPE_TX_SPEED) {

drivers/net/virtio_net.c

4787

u64 offset, bitmap;

drivers/net/virtio_net.c

4799

bitmap = ctx->bitmap[queue_type];

drivers/net/virtio_net.c

4827

if (bitmap & VIRTIO_NET_STATS_TYPE_CVQ) {

drivers/net/virtio_net.c

4836

if (bitmap & VIRTIO_NET_STATS_TYPE_RX_BASIC) {

drivers/net/virtio_net.c

4845

if (bitmap & VIRTIO_NET_STATS_TYPE_RX_CSUM) {

drivers/net/virtio_net.c

4854

if (bitmap & VIRTIO_NET_STATS_TYPE_RX_SPEED) {

drivers/net/virtio_net.c

4863

if (bitmap & VIRTIO_NET_STATS_TYPE_TX_BASIC) {

drivers/net/virtio_net.c

4872

if (bitmap & VIRTIO_NET_STATS_TYPE_TX_GSO) {

drivers/net/virtio_net.c

4881

if (bitmap & VIRTIO_NET_STATS_TYPE_TX_SPEED) {

drivers/net/virtio_net.c

4943

u64 bitmap = ctx->bitmap[qtype];

drivers/net/virtio_net.c

4945

if (!bitmap)

drivers/net/virtio_net.c

4949

req->stats[*idx].types_bitmap[0] = cpu_to_le64(bitmap);

drivers/net/virtio_net.c

4982

if (ctx->bitmap[qtype]) {

drivers/net/virtio_net.c

4988

if (enable_cvq && ctx->bitmap[VIRTNET_Q_TYPE_CQ]) {

drivers/net/wireless/ath/ath10k/mac.c

8125

u32 bitmap;

drivers/net/wireless/ath/ath10k/mac.c

8129

bitmap = ~(1 << WMI_MGMT_TID);

drivers/net/wireless/ath/ath10k/mac.c

8133

arvif->bssid, bitmap);

drivers/net/wireless/ath/ath10k/wmi-tlv.c

3741

struct wmi_tlv_wow_bitmap_pattern *bitmap;

drivers/net/wireless/ath/ath10k/wmi-tlv.c

3749

sizeof(*tlv) + sizeof(*bitmap) + /* bitmap */

drivers/net/wireless/ath/ath10k/wmi-tlv.c

3777

tlv->len = __cpu_to_le16(sizeof(*tlv) + sizeof(*bitmap));

drivers/net/wireless/ath/ath10k/wmi-tlv.c

3783

tlv->len = __cpu_to_le16(sizeof(*bitmap));

drivers/net/wireless/ath/ath10k/wmi-tlv.c

3784

bitmap = (void *)tlv->value;

drivers/net/wireless/ath/ath10k/wmi-tlv.c

3786

memcpy(bitmap->patternbuf, pattern, pattern_len);

drivers/net/wireless/ath/ath10k/wmi-tlv.c

3787

memcpy(bitmap->bitmaskbuf, bitmask, pattern_len);

drivers/net/wireless/ath/ath10k/wmi-tlv.c

3788

bitmap->pattern_offset = __cpu_to_le32(pattern_offset);

drivers/net/wireless/ath/ath10k/wmi-tlv.c

3789

bitmap->pattern_len = __cpu_to_le32(pattern_len);

drivers/net/wireless/ath/ath10k/wmi-tlv.c

3790

bitmap->bitmask_len = __cpu_to_le32(pattern_len);

drivers/net/wireless/ath/ath10k/wmi-tlv.c

3791

bitmap->pattern_id = __cpu_to_le32(pattern_id);

drivers/net/wireless/ath/ath10k/wmi-tlv.c

3794

ptr += sizeof(*bitmap);

drivers/net/wireless/ath/ath11k/mac.c

3345

u32 bitmap[2], param_id, param_val, pdev_id;

drivers/net/wireless/ath/ath11k/mac.c

3434

memcpy(bitmap, he_obss_pd->bss_color_bitmap, sizeof(bitmap));

drivers/net/wireless/ath/ath11k/mac.c

3435

ret = ath11k_wmi_pdev_set_srg_bss_color_bitmap(ar, bitmap);

drivers/net/wireless/ath/ath11k/mac.c

3444

memcpy(bitmap, he_obss_pd->partial_bssid_bitmap, sizeof(bitmap));

drivers/net/wireless/ath/ath11k/mac.c

3445

ret = ath11k_wmi_pdev_set_srg_patial_bssid_bitmap(ar, bitmap);

drivers/net/wireless/ath/ath11k/mac.c

3453

memset(bitmap, 0xff, sizeof(bitmap));

drivers/net/wireless/ath/ath11k/mac.c

3456

ret = ath11k_wmi_pdev_srg_obss_color_enable_bitmap(ar, bitmap);

drivers/net/wireless/ath/ath11k/mac.c

3465

ret = ath11k_wmi_pdev_srg_obss_bssid_enable_bitmap(ar, bitmap);

drivers/net/wireless/ath/ath11k/mac.c

3474

ret = ath11k_wmi_pdev_non_srg_obss_color_enable_bitmap(ar, bitmap);

drivers/net/wireless/ath/ath11k/mac.c

3483

ret = ath11k_wmi_pdev_non_srg_obss_bssid_enable_bitmap(ar, bitmap);

drivers/net/wireless/ath/ath11k/wmi.c

3595

ath11k_wmi_pdev_set_srg_bss_color_bitmap(struct ath11k *ar, u32 *bitmap)

drivers/net/wireless/ath/ath11k/wmi.c

3614

memcpy(cmd->bitmap, bitmap, sizeof(cmd->bitmap));

drivers/net/wireless/ath/ath11k/wmi.c

3627

cmd->pdev_id, cmd->bitmap[0], cmd->bitmap[1]);

drivers/net/wireless/ath/ath11k/wmi.c

3633

ath11k_wmi_pdev_set_srg_patial_bssid_bitmap(struct ath11k *ar, u32 *bitmap)

drivers/net/wireless/ath/ath11k/wmi.c

3653

memcpy(cmd->bitmap, bitmap, sizeof(cmd->bitmap));

drivers/net/wireless/ath/ath11k/wmi.c

3666

cmd->pdev_id, cmd->bitmap[0], cmd->bitmap[1]);

drivers/net/wireless/ath/ath11k/wmi.c

3672

ath11k_wmi_pdev_srg_obss_color_enable_bitmap(struct ath11k *ar, u32 *bitmap)

drivers/net/wireless/ath/ath11k/wmi.c

3692

memcpy(cmd->bitmap, bitmap, sizeof(cmd->bitmap));

drivers/net/wireless/ath/ath11k/wmi.c

3705

cmd->pdev_id, cmd->bitmap[0], cmd->bitmap[1]);

drivers/net/wireless/ath/ath11k/wmi.c

3711

ath11k_wmi_pdev_srg_obss_bssid_enable_bitmap(struct ath11k *ar, u32 *bitmap)

drivers/net/wireless/ath/ath11k/wmi.c

3731

memcpy(cmd->bitmap, bitmap, sizeof(cmd->bitmap));

drivers/net/wireless/ath/ath11k/wmi.c

3744

cmd->pdev_id, cmd->bitmap[0], cmd->bitmap[1]);

drivers/net/wireless/ath/ath11k/wmi.c

3750

ath11k_wmi_pdev_non_srg_obss_color_enable_bitmap(struct ath11k *ar, u32 *bitmap)

drivers/net/wireless/ath/ath11k/wmi.c

3770

memcpy(cmd->bitmap, bitmap, sizeof(cmd->bitmap));

drivers/net/wireless/ath/ath11k/wmi.c

3783

cmd->pdev_id, cmd->bitmap[0], cmd->bitmap[1]);

drivers/net/wireless/ath/ath11k/wmi.c

3789

ath11k_wmi_pdev_non_srg_obss_bssid_enable_bitmap(struct ath11k *ar, u32 *bitmap)

drivers/net/wireless/ath/ath11k/wmi.c

3809

memcpy(cmd->bitmap, bitmap, sizeof(cmd->bitmap));

drivers/net/wireless/ath/ath11k/wmi.c

3822

cmd->pdev_id, cmd->bitmap[0], cmd->bitmap[1]);

drivers/net/wireless/ath/ath11k/wmi.c

9433

struct wmi_wow_bitmap_pattern *bitmap;

drivers/net/wireless/ath/ath11k/wmi.c

9441

sizeof(*bitmap) + /* bitmap */

drivers/net/wireless/ath/ath11k/wmi.c

9469

FIELD_PREP(WMI_TLV_LEN, sizeof(*bitmap));

drivers/net/wireless/ath/ath11k/wmi.c

9473

bitmap = (struct wmi_wow_bitmap_pattern *)ptr;

drivers/net/wireless/ath/ath11k/wmi.c

9474

bitmap->tlv_header = FIELD_PREP(WMI_TLV_TAG,

drivers/net/wireless/ath/ath11k/wmi.c

9476

FIELD_PREP(WMI_TLV_LEN, sizeof(*bitmap) - TLV_HDR_SIZE);

drivers/net/wireless/ath/ath11k/wmi.c

9478

memcpy(bitmap->patternbuf, pattern, pattern_len);

drivers/net/wireless/ath/ath11k/wmi.c

9479

ath11k_ce_byte_swap(bitmap->patternbuf, roundup(pattern_len, 4));

drivers/net/wireless/ath/ath11k/wmi.c

9480

memcpy(bitmap->bitmaskbuf, mask, pattern_len);

drivers/net/wireless/ath/ath11k/wmi.c

9481

ath11k_ce_byte_swap(bitmap->bitmaskbuf, roundup(pattern_len, 4));

drivers/net/wireless/ath/ath11k/wmi.c

9482

bitmap->pattern_offset = pattern_offset;

drivers/net/wireless/ath/ath11k/wmi.c

9483

bitmap->pattern_len = pattern_len;

drivers/net/wireless/ath/ath11k/wmi.c

9484

bitmap->bitmask_len = pattern_len;

drivers/net/wireless/ath/ath11k/wmi.c

9485

bitmap->pattern_id = pattern_id;

drivers/net/wireless/ath/ath11k/wmi.c

9487

ptr += sizeof(*bitmap);

drivers/net/wireless/ath/ath11k/wmi.h

5558

u32 bitmap[2];

drivers/net/wireless/ath/ath11k/wmi.h

6562

int ath11k_wmi_pdev_set_srg_bss_color_bitmap(struct ath11k *ar, u32 *bitmap);

drivers/net/wireless/ath/ath11k/wmi.h

6563

int ath11k_wmi_pdev_set_srg_patial_bssid_bitmap(struct ath11k *ar, u32 *bitmap);

drivers/net/wireless/ath/ath11k/wmi.h

6565

u32 *bitmap);

drivers/net/wireless/ath/ath11k/wmi.h

6567

u32 *bitmap);

drivers/net/wireless/ath/ath11k/wmi.h

6569

u32 *bitmap);

drivers/net/wireless/ath/ath11k/wmi.h

6571

u32 *bitmap);

drivers/net/wireless/ath/ath11k/wow.c

536

u32 bitmap;

drivers/net/wireless/ath/ath11k/wow.c

542

bitmap = WMI_HW_DATA_FILTER_DROP_NON_ICMPV6_MC |

drivers/net/wireless/ath/ath11k/wow.c

545

bitmap,

drivers/net/wireless/ath/ath12k/wmi.c

10363

struct wmi_wow_bitmap_pattern_params *bitmap;

drivers/net/wireless/ath/ath12k/wmi.c

10371

sizeof(*bitmap) + /* bitmap */

drivers/net/wireless/ath/ath12k/wmi.c

10395

tlv->header = ath12k_wmi_tlv_hdr(WMI_TAG_ARRAY_STRUCT, sizeof(*bitmap));

drivers/net/wireless/ath/ath12k/wmi.c

10399

bitmap = ptr;

drivers/net/wireless/ath/ath12k/wmi.c

10400

bitmap->tlv_header = ath12k_wmi_tlv_cmd_hdr(WMI_TAG_WOW_BITMAP_PATTERN_T,

drivers/net/wireless/ath/ath12k/wmi.c

10401

sizeof(*bitmap));

drivers/net/wireless/ath/ath12k/wmi.c

10402

memcpy(bitmap->patternbuf, pattern, pattern_len);

drivers/net/wireless/ath/ath12k/wmi.c

10403

memcpy(bitmap->bitmaskbuf, mask, pattern_len);

drivers/net/wireless/ath/ath12k/wmi.c

10404

bitmap->pattern_offset = cpu_to_le32(pattern_offset);

drivers/net/wireless/ath/ath12k/wmi.c

10405

bitmap->pattern_len = cpu_to_le32(pattern_len);

drivers/net/wireless/ath/ath12k/wmi.c

10406

bitmap->bitmask_len = cpu_to_le32(pattern_len);

drivers/net/wireless/ath/ath12k/wmi.c

10407

bitmap->pattern_id = cpu_to_le32(pattern_id);

drivers/net/wireless/ath/ath12k/wmi.c

10409

ptr += sizeof(*bitmap);

drivers/net/wireless/ath/ath12k/wmi.c

10443

bitmap->patternbuf, pattern_len);

drivers/net/wireless/ath/ath12k/wmi.c

10445

bitmap->bitmaskbuf, pattern_len);

drivers/net/wireless/ath/ath12k/wmi.c

133

const u32 *bitmap;

drivers/net/wireless/ath/ath12k/wmi.c

3606

memcpy(cmd->bitmap, arg->bitmap, sizeof(cmd->bitmap));

drivers/net/wireless/ath/ath12k/wmi.c

3610

arg->pdev_id, arg->label, arg->bitmap[0], arg->bitmap[1]);

drivers/net/wireless/ath/ath12k/wmi.c

3622

u32 pdev_id, const u32 *bitmap)

drivers/net/wireless/ath/ath12k/wmi.c

3628

.bitmap = bitmap,

drivers/net/wireless/ath/ath12k/wmi.c

3636

u32 pdev_id, const u32 *bitmap)

drivers/net/wireless/ath/ath12k/wmi.c

3642

.bitmap = bitmap,

drivers/net/wireless/ath/ath12k/wmi.c

3650

u32 pdev_id, const u32 *bitmap)

drivers/net/wireless/ath/ath12k/wmi.c

3656

.bitmap = bitmap,

drivers/net/wireless/ath/ath12k/wmi.c

3664

u32 pdev_id, const u32 *bitmap)

drivers/net/wireless/ath/ath12k/wmi.c

3670

.bitmap = bitmap,

drivers/net/wireless/ath/ath12k/wmi.c

3678

u32 pdev_id, const u32 *bitmap)

drivers/net/wireless/ath/ath12k/wmi.c

3684

.bitmap = bitmap,

drivers/net/wireless/ath/ath12k/wmi.c

3692

u32 pdev_id, const u32 *bitmap)

drivers/net/wireless/ath/ath12k/wmi.c

3698

.bitmap = bitmap,

drivers/net/wireless/ath/ath12k/wmi.c

3914

u64 bitmap;

drivers/net/wireless/ath/ath12k/wmi.c

3931

bitmap = le64_to_cpu(ev->obss_color_bitmap);

drivers/net/wireless/ath/ath12k/wmi.c

3945

bitmap,

drivers/net/wireless/ath/ath12k/wmi.c

3949

vdev_id, evt_type, bitmap);

drivers/net/wireless/ath/ath12k/wmi.h

4947

__le32 bitmap[2];

drivers/net/wireless/ath/ath12k/wmi.h

6471

const u32 *bitmap);

drivers/net/wireless/ath/ath12k/wmi.h

6473

const u32 *bitmap);

drivers/net/wireless/ath/ath12k/wmi.h

6475

const u32 *bitmap);

drivers/net/wireless/ath/ath12k/wmi.h

6477

const u32 *bitmap);

drivers/net/wireless/ath/ath12k/wmi.h

6479

const u32 *bitmap);

drivers/net/wireless/ath/ath12k/wmi.h

6481

const u32 *bitmap);

drivers/net/wireless/ath/ath6kl/wmi.c

3454

u16 aid, u16 bitmap, u32 flags)

drivers/net/wireless/ath/ath6kl/wmi.c

3465

cmd->bitmap = cpu_to_le16(bitmap);

drivers/net/wireless/ath/ath6kl/wmi.h

2321

__le16 bitmap;

drivers/net/wireless/ath/ath6kl/wmi.h

2672

u16 bitmap, u32 flags);

drivers/net/wireless/ath/carl9170/carl9170.h

135

unsigned long bitmap[CARL9170_BAW_SIZE];

drivers/net/wireless/ath/carl9170/debug.c

314

CARL9170_BAW_BITS, iter->bitmap);

drivers/net/wireless/ath/carl9170/main.c

1466

bitmap_zero(tid_info->bitmap, CARL9170_BAW_SIZE);

drivers/net/wireless/ath/carl9170/tx.c

1428

if (WARN_ON_ONCE(test_and_set_bit(off, agg->bitmap)))

drivers/net/wireless/ath/carl9170/tx.c

363

WARN_ON_ONCE(!test_and_clear_bit(off, tid_info->bitmap));

drivers/net/wireless/ath/carl9170/tx.c

369

off = min(off, find_first_bit(tid_info->bitmap, off));

drivers/net/wireless/ath/carl9170/tx.c

374

bitmap_shift_right(tid_info->bitmap, tid_info->bitmap,

drivers/net/wireless/ath/wcn36xx/firmware.c

109

return (bitmap[arr_idx] & (1 << bit_idx)) ? 1 : 0;

drivers/net/wireless/ath/wcn36xx/firmware.c

112

void wcn36xx_firmware_clear_feat_caps(u32 *bitmap,

drivers/net/wireless/ath/wcn36xx/firmware.c

124

bitmap[arr_idx] &= ~(1 << bit_idx);

drivers/net/wireless/ath/wcn36xx/firmware.c

81

void wcn36xx_firmware_set_feat_caps(u32 *bitmap,

drivers/net/wireless/ath/wcn36xx/firmware.c

93

bitmap[arr_idx] |= (1 << bit_idx);

drivers/net/wireless/ath/wcn36xx/firmware.c

96

int wcn36xx_firmware_get_feat_caps(u32 *bitmap,

drivers/net/wireless/ath/wcn36xx/firmware.h

74

void wcn36xx_firmware_set_feat_caps(u32 *bitmap,

drivers/net/wireless/ath/wcn36xx/firmware.h

76

int wcn36xx_firmware_get_feat_caps(u32 *bitmap,

drivers/net/wireless/ath/wcn36xx/firmware.h

78

void wcn36xx_firmware_clear_feat_caps(u32 *bitmap,

drivers/net/wireless/broadcom/brcm80211/brcmsmac/ampdu.c

809

u8 bitmap[8], queue, tid;

drivers/net/wireless/broadcom/brcm80211/brcmsmac/ampdu.c

833

memset(bitmap, 0, sizeof(bitmap));

drivers/net/wireless/broadcom/brcm80211/brcmsmac/ampdu.c

840

bitmap[0] = (txs->status & TX_STATUS_BA_BMAP03_MASK) >>

drivers/net/wireless/broadcom/brcm80211/brcmsmac/ampdu.c

846

bitmap[0] |=

drivers/net/wireless/broadcom/brcm80211/brcmsmac/ampdu.c

849

bitmap[1] = (s1 >> 8) & 0xff;

drivers/net/wireless/broadcom/brcm80211/brcmsmac/ampdu.c

850

bitmap[2] = (s1 >> 16) & 0xff;

drivers/net/wireless/broadcom/brcm80211/brcmsmac/ampdu.c

851

bitmap[3] = (s1 >> 24) & 0xff;

drivers/net/wireless/broadcom/brcm80211/brcmsmac/ampdu.c

853

bitmap[4] = s2 & 0xff;

drivers/net/wireless/broadcom/brcm80211/brcmsmac/ampdu.c

854

bitmap[5] = (s2 >> 8) & 0xff;

drivers/net/wireless/broadcom/brcm80211/brcmsmac/ampdu.c

855

bitmap[6] = (s2 >> 16) & 0xff;

drivers/net/wireless/broadcom/brcm80211/brcmsmac/ampdu.c

856

bitmap[7] = (s2 >> 24) & 0xff;

drivers/net/wireless/broadcom/brcm80211/brcmsmac/ampdu.c

917

block_acked = isset(bitmap, bindex);

drivers/net/wireless/broadcom/brcm80211/include/brcmu_wifi.h

189

static inline bool ac_bitmap_tst(u8 bitmap, int prec)

drivers/net/wireless/broadcom/brcm80211/include/brcmu_wifi.h

191

return (bitmap & (1 << (prec))) != 0;

drivers/net/wireless/intel/iwlegacy/4965-mac.c

2505

u64 bitmap, sent_bitmap;

drivers/net/wireless/intel/iwlegacy/4965-mac.c

2508

if (unlikely(ba_resp->bitmap))

drivers/net/wireless/intel/iwlegacy/4965-mac.c

2528

bitmap = le64_to_cpu(ba_resp->bitmap) >> sh;

drivers/net/wireless/intel/iwlegacy/4965-mac.c

2532

sent_bitmap = bitmap & agg->bitmap;

drivers/net/wireless/intel/iwlegacy/4965-mac.c

2546

D_TX_REPLY("Bitmap %llx\n", (unsigned long long)bitmap);

drivers/net/wireless/intel/iwlegacy/4965-mac.c

2663

agg->bitmap = 0;

drivers/net/wireless/intel/iwlegacy/4965-mac.c

2687

u64 bitmap = 0;

drivers/net/wireless/intel/iwlegacy/4965-mac.c

2726

bitmap = bitmap << sh;

drivers/net/wireless/intel/iwlegacy/4965-mac.c

2734

bitmap = bitmap << sh;

drivers/net/wireless/intel/iwlegacy/4965-mac.c

2737

bitmap |= 1ULL << sh;

drivers/net/wireless/intel/iwlegacy/4965-mac.c

2739

(unsigned long long)bitmap);

drivers/net/wireless/intel/iwlegacy/4965-mac.c

2742

agg->bitmap = bitmap;

drivers/net/wireless/intel/iwlegacy/4965-mac.c

2746

(unsigned long long)agg->bitmap);

drivers/net/wireless/intel/iwlegacy/4965-mac.c

2748

if (bitmap)

drivers/net/wireless/intel/iwlegacy/4965-mac.c

2955

(unsigned long long)le64_to_cpu(ba_resp->bitmap),

drivers/net/wireless/intel/iwlegacy/4965-mac.c

2958

(unsigned long long)agg->bitmap);

drivers/net/wireless/intel/iwlegacy/commands.h

1744

__le64 bitmap;

drivers/net/wireless/intel/iwlegacy/common.h

647

u64 bitmap;

drivers/net/wireless/intel/iwlegacy/debug.c

434

station->tid[j].agg.bitmap,

drivers/net/wireless/intel/iwlwifi/dvm/commands.h

1444

__le64 bitmap;

drivers/net/wireless/intel/iwlwifi/dvm/tx.c

1295

if (unlikely(ba_resp->bitmap))

drivers/net/wireless/intel/iwlwifi/dvm/tx.c

1331

(unsigned long long)le64_to_cpu(ba_resp->bitmap),

drivers/net/wireless/intel/iwlwifi/fw/api/rx.h

987

__le64 bitmap[BA_WINDOW_STREAMS_MAX];

drivers/net/wireless/intel/iwlwifi/fw/api/tx.h

640

__le64 bitmap;

drivers/net/wireless/intel/iwlwifi/mvm/rx.c

1204

BUILD_BUG_ON(ARRAY_SIZE(notif->bitmap) != BA_WINDOW_STREAMS_MAX);

drivers/net/wireless/intel/iwlwifi/mvm/rx.c

1211

u64 bitmap;

drivers/net/wireless/intel/iwlwifi/mvm/rx.c

1232

bitmap = le64_to_cpu(notif->bitmap[i]);

drivers/net/wireless/intel/iwlwifi/mvm/rx.c

1236

ieee80211_mark_rx_ba_filtered_frames(sta, tid, ssn, bitmap,

drivers/net/wireless/intel/iwlwifi/mvm/scan.c

1618

u8 *bitmap = cp->adwell_ch_override_bitmap;

drivers/net/wireless/intel/iwlwifi/mvm/scan.c

1635

cfg->v2.band, bitmap,

drivers/net/wireless/intel/iwlwifi/mvm/tx.c

2156

le64_to_cpu(ba_notif->bitmap), txq, index,

drivers/net/wireless/marvell/libertas/host.h

742

__le16 bitmap;

drivers/net/wireless/marvell/mwifiex/11n_rxreorder.c

959

if (tlv_rxba->bitmap[i] & (1 << j)) {

drivers/net/wireless/marvell/mwifiex/fw.h

816

u8 bitmap[];

drivers/net/wireless/marvell/mwifiex/sdio.c

1994

u32 bitmap;

drivers/net/wireless/marvell/mwifiex/sdio.c

2049

bitmap = (u32) card->mp_regs[reg->wr_bitmap_l];

drivers/net/wireless/marvell/mwifiex/sdio.c

2050

bitmap |= ((u32) card->mp_regs[reg->wr_bitmap_u]) << 8;

drivers/net/wireless/marvell/mwifiex/sdio.c

2052

bitmap |=

drivers/net/wireless/marvell/mwifiex/sdio.c

2054

bitmap |=

drivers/net/wireless/marvell/mwifiex/sdio.c

2057

card->mp_wr_bitmap = bitmap;

drivers/net/wireless/marvell/mwifiex/sdio.c

2085

bitmap = (u32) card->mp_regs[reg->rd_bitmap_l];

drivers/net/wireless/marvell/mwifiex/sdio.c

2086

bitmap |= ((u32) card->mp_regs[reg->rd_bitmap_u]) << 8;

drivers/net/wireless/marvell/mwifiex/sdio.c

2088

bitmap |=

drivers/net/wireless/marvell/mwifiex/sdio.c

2090

bitmap |=

drivers/net/wireless/marvell/mwifiex/sdio.c

2093

card->mp_rd_bitmap = bitmap;

drivers/net/wireless/marvell/mwl8k.c

2204

u32 bitmap);

drivers/net/wireless/marvell/mwl8k.c

2223

u32 bitmap = 0;

drivers/net/wireless/marvell/mwl8k.c

2246

bitmap = priv->running_bsses;

drivers/net/wireless/marvell/mwl8k.c

2247

mwl8k_enable_bsses(hw, false, bitmap);

drivers/net/wireless/marvell/mwl8k.c

2300

if (bitmap)

drivers/net/wireless/marvell/mwl8k.c

2301

mwl8k_enable_bsses(hw, true, bitmap);

drivers/net/wireless/marvell/mwl8k.c

3860

u8 bitmap;

drivers/net/wireless/marvell/mwl8k.c

3863

static int mwl8k_cmd_get_watchdog_bitmap(struct ieee80211_hw *hw, u8 *bitmap)

drivers/net/wireless/marvell/mwl8k.c

3877

*bitmap = cmd->bitmap;

drivers/net/wireless/marvell/mwl8k.c

3892

u8 bitmap = 0, stream_index;

drivers/net/wireless/marvell/mwl8k.c

3902

rc = mwl8k_cmd_get_watchdog_bitmap(priv->hw, &bitmap);

drivers/net/wireless/marvell/mwl8k.c

3910

if (bitmap & (1 << i)) {

drivers/net/wireless/marvell/mwl8k.c

3977

static void mwl8k_enable_bsses(struct ieee80211_hw *hw, bool enable, u32 bitmap)

drivers/net/wireless/marvell/mwl8k.c

3986

if (!(bitmap & (1 << mwl8k_vif->macid)))

drivers/net/wireless/mediatek/mt76/mt7915/mcu.c

1873

mbss->bitmap = cpu_to_le32(1);

drivers/net/wireless/mediatek/mt76/mt7915/mcu.c

1905

mbss->bitmap |= cpu_to_le32(BIT(idx->bssid_index));

drivers/net/wireless/mediatek/mt76/mt7915/mcu.c

2950

__le16 bitmap;

drivers/net/wireless/mediatek/mt76/mt7915/mcu.c

3786

} __packed bitmap;

drivers/net/wireless/mediatek/mt76/mt7915/mcu.c

3794

u32 bitmap;

drivers/net/wireless/mediatek/mt76/mt7915/mcu.c

3796

memcpy(&bitmap, he_obss_pd->bss_color_bitmap, sizeof(bitmap));

drivers/net/wireless/mediatek/mt76/mt7915/mcu.c

3797

req.bitmap.color_l[req.ctrl.band_idx] = cpu_to_le32(bitmap);

drivers/net/wireless/mediatek/mt76/mt7915/mcu.c

3799

memcpy(&bitmap, he_obss_pd->bss_color_bitmap + 4, sizeof(bitmap));

drivers/net/wireless/mediatek/mt76/mt7915/mcu.c

3800

req.bitmap.color_h[req.ctrl.band_idx] = cpu_to_le32(bitmap);

drivers/net/wireless/mediatek/mt76/mt7915/mcu.c

3802

memcpy(&bitmap, he_obss_pd->partial_bssid_bitmap, sizeof(bitmap));

drivers/net/wireless/mediatek/mt76/mt7915/mcu.c

3803

req.bitmap.bssid_l[req.ctrl.band_idx] = cpu_to_le32(bitmap);

drivers/net/wireless/mediatek/mt76/mt7915/mcu.c

3805

memcpy(&bitmap, he_obss_pd->partial_bssid_bitmap + 4, sizeof(bitmap));

drivers/net/wireless/mediatek/mt76/mt7915/mcu.c

3806

req.bitmap.bssid_h[req.ctrl.band_idx] = cpu_to_le32(bitmap);

drivers/net/wireless/mediatek/mt76/mt7915/mcu.h

377

__le32 bitmap;

drivers/net/wireless/mediatek/mt76/mt7996/mcu.c

2694

mbss->bitmap = cpu_to_le32(1);

drivers/net/wireless/mediatek/mt76/mt7996/mcu.c

2726

mbss->bitmap |= cpu_to_le32(BIT(idx->bssid_index));

drivers/net/wireless/mediatek/mt76/mt7996/mcu.c

4374

u32 bitmap;

drivers/net/wireless/mediatek/mt76/mt7996/mcu.c

4376

memcpy(&bitmap, he_obss_pd->bss_color_bitmap, sizeof(bitmap));

drivers/net/wireless/mediatek/mt76/mt7996/mcu.c

4377

req.color_l[req.band_idx] = cpu_to_le32(bitmap);

drivers/net/wireless/mediatek/mt76/mt7996/mcu.c

4379

memcpy(&bitmap, he_obss_pd->bss_color_bitmap + 4, sizeof(bitmap));

drivers/net/wireless/mediatek/mt76/mt7996/mcu.c

4380

req.color_h[req.band_idx] = cpu_to_le32(bitmap);

drivers/net/wireless/mediatek/mt76/mt7996/mcu.c

4382

memcpy(&bitmap, he_obss_pd->partial_bssid_bitmap, sizeof(bitmap));

drivers/net/wireless/mediatek/mt76/mt7996/mcu.c

4383

req.bssid_l[req.band_idx] = cpu_to_le32(bitmap);

drivers/net/wireless/mediatek/mt76/mt7996/mcu.c

4385

memcpy(&bitmap, he_obss_pd->partial_bssid_bitmap + 4, sizeof(bitmap));

drivers/net/wireless/mediatek/mt76/mt7996/mcu.c

4386

req.bssid_h[req.band_idx] = cpu_to_le32(bitmap);

drivers/net/wireless/mediatek/mt76/mt7996/mcu.h

423

__le32 bitmap;

drivers/net/wireless/realtek/rtlwifi/cam.c

261

u32 bitmap = (rtlpriv->sec.hwsec_cam_bitmap) >> 4;

drivers/net/wireless/realtek/rtlwifi/cam.c

277

if ((bitmap & BIT(0)) == 0) {

drivers/net/wireless/realtek/rtlwifi/cam.c

285

bitmap = bitmap >> 1;

drivers/net/wireless/realtek/rtlwifi/cam.c

294

u32 bitmap;

drivers/net/wireless/realtek/rtlwifi/cam.c

309

bitmap = (rtlpriv->sec.hwsec_cam_bitmap) >> i;

drivers/net/wireless/realtek/rtlwifi/cam.c

310

if (((bitmap & BIT(0)) == BIT(0)) &&

drivers/net/wireless/realtek/rtlwifi/wifi.h

1387

u64 bitmap;

drivers/net/wireless/realtek/rtw88/coex.c

355

static void rtw_coex_set_wl_pri_mask(struct rtw_dev *rtwdev, u8 bitmap,

drivers/net/wireless/realtek/rtw88/coex.c

360

addr = REG_BT_COEX_TABLE_H + (bitmap / 8);

drivers/net/wireless/realtek/rtw88/coex.c

361

bitmap = bitmap % 8;

drivers/net/wireless/realtek/rtw88/coex.c

363

rtw_write8_mask(rtwdev, addr, BIT(bitmap), data);

drivers/net/wireless/realtek/rtw88/rtw8723x.c

572

u32 bitmap = 0;

drivers/net/wireless/realtek/rtw88/rtw8723x.c

587

if ((i == IQK_S1_RX_X || i == IQK_S0_RX_X) && !bitmap) {

drivers/net/wireless/realtek/rtw88/rtw8723x.c

593

bitmap |= BIT(i);

drivers/net/wireless/realtek/rtw88/rtw8723x.c

595

bitmap |= BIT(i);

drivers/net/wireless/realtek/rtw88/rtw8723x.c

599

if (bitmap != 0)

drivers/net/wireless/realtek/rtw88/rtw8723x.c

616

if (bitmap & GENMASK(j + 1, j))

drivers/net/wireless/realtek/rtw89/chan.c

821

u32 bitmap = 0;

drivers/net/wireless/realtek/rtw89/chan.c

830

bitmap |= BIT(macid);

drivers/net/wireless/realtek/rtw89/chan.c

835

return bitmap;

drivers/net/wireless/realtek/rtw89/fw.c

10142

u8 *bitmap)

drivers/net/wireless/realtek/rtw89/fw.c

10164

RTW89_SET_FWCMD_MCC_MACID_BITMAP_BITMAP(skb->data, bitmap, map_len);

drivers/net/wireless/realtek/rtw89/fw.c

1186

u32 bitmap;

drivers/net/wireless/realtek/rtw89/fw.c

1196

bitmap = le32_to_cpu(elm->u.txpwr_trk.bitmap);

drivers/net/wireless/realtek/rtw89/fw.c

1198

if ((bitmap & needed_bitmap) != needed_bitmap) {

drivers/net/wireless/realtek/rtw89/fw.c

1200

needed_bitmap, bitmap);

drivers/net/wireless/realtek/rtw89/fw.c

1208

for (type = 0; bitmap; type++, bitmap >>= 1) {

drivers/net/wireless/realtek/rtw89/fw.c

1209

if (!(bitmap & BIT(0)))

drivers/net/wireless/realtek/rtw89/fw.h

3468

u8 *bitmap, u8 len)

drivers/net/wireless/realtek/rtw89/fw.h

3470

memcpy((__le32 *)cmd + 1, bitmap, len);

drivers/net/wireless/realtek/rtw89/fw.h

4422

__le32 bitmap; /* bitmap of enum rtw89_fw_txpwr_trk_type */

drivers/net/wireless/realtek/rtw89/fw.h

5440

u8 *bitmap);

drivers/net/wireless/realtek/rtw89/pci.c

4537

bitmap_or(rtwdev->quirks, rtwdev->quirks, &ssid_quirks->bitmap,

drivers/net/wireless/realtek/rtw89/pci.h

1372

unsigned long bitmap; /* bitmap of rtw89_quirks */

drivers/net/wireless/realtek/rtw89/rtw8851b.c

2239

u32 bitmap;

drivers/net/wireless/realtek/rtw89/rtw8851b.c

2245

bitmap = B_BTC_PRI_MASK_TX_RESP_V1;

drivers/net/wireless/realtek/rtw89/rtw8851b.c

2249

bitmap = B_AX_PTA_WL_PRI_MASK_BCNQ;

drivers/net/wireless/realtek/rtw89/rtw8851b.c

2253

bitmap = B_BTC_PRI_MASK_RXCCK_V1;

drivers/net/wireless/realtek/rtw89/rtw8851b.c

2260

rtw89_write32_set(rtwdev, reg, bitmap);

drivers/net/wireless/realtek/rtw89/rtw8851b.c

2262

rtw89_write32_clr(rtwdev, reg, bitmap);

drivers/net/wireless/realtek/rtw89/rtw8852a.c

1906

u32 bitmap = 0;

drivers/net/wireless/realtek/rtw89/rtw8852a.c

1912

bitmap = B_BTC_PRI_MASK_TX_RESP_V1;

drivers/net/wireless/realtek/rtw89/rtw8852a.c

1916

bitmap = B_AX_PTA_WL_PRI_MASK_BCNQ;

drivers/net/wireless/realtek/rtw89/rtw8852a.c

1923

rtw89_write32_set(rtwdev, reg, bitmap);

drivers/net/wireless/realtek/rtw89/rtw8852a.c

1925

rtw89_write32_clr(rtwdev, reg, bitmap);

drivers/net/wireless/realtek/rtw89/rtw8852b_common.c

1847

u32 bitmap;

drivers/net/wireless/realtek/rtw89/rtw8852b_common.c

1853

bitmap = B_BTC_PRI_MASK_TX_RESP_V1;

drivers/net/wireless/realtek/rtw89/rtw8852b_common.c

1857

bitmap = B_AX_PTA_WL_PRI_MASK_BCNQ;

drivers/net/wireless/realtek/rtw89/rtw8852b_common.c

1861

bitmap = B_BTC_PRI_MASK_RXCCK_V1;

drivers/net/wireless/realtek/rtw89/rtw8852b_common.c

1868

rtw89_write32_set(rtwdev, reg, bitmap);

drivers/net/wireless/realtek/rtw89/rtw8852b_common.c

1870

rtw89_write32_clr(rtwdev, reg, bitmap);

drivers/net/wireless/realtek/rtw89/rtw8852bte.c

14

.bitmap = BIT(RTW89_QUIRK_THERMAL_PROT_110C)},

drivers/net/wireless/realtek/rtw89/rtw8852c.c

2712

u32 bitmap = 0;

drivers/net/wireless/realtek/rtw89/rtw8852c.c

2718

bitmap = B_BTC_RSP_ACK_HI;

drivers/net/wireless/realtek/rtw89/rtw8852c.c

2722

bitmap = B_BTC_TX_BCN_HI;

drivers/net/wireless/realtek/rtw89/rtw8852c.c

2729

rtw89_write32_set(rtwdev, reg, bitmap);

drivers/net/wireless/realtek/rtw89/rtw8852c.c

2731

rtw89_write32_clr(rtwdev, reg, bitmap);

drivers/net/wireless/realtek/rtw89/rtw8922ae.c

14

.bitmap = BIT(RTW89_QUIRK_THERMAL_PROT_120C)},

drivers/net/wireless/silabs/wfx/hif_api_cmd.h

256

u8 bitmap:1;

drivers/net/wireless/ti/wl1251/cmd.c

129

void *bitmap, u16 bitmap_len, u8 bitmap_control)

drivers/net/wireless/ti/wl1251/cmd.c

147

memcpy(vbm->tim.pvb_field, bitmap, bitmap_len);

drivers/net/wireless/ti/wl1251/cmd.h

22

void *bitmap, u16 bitmap_len, u8 bitmap_control);

drivers/pci/controller/pci-xgene-msi.c

174

hwirq = find_first_zero_bit(msi->bitmap, NR_MSI_VEC);

drivers/pci/controller/pci-xgene-msi.c

176

set_bit(hwirq, msi->bitmap);

drivers/pci/controller/pci-xgene-msi.c

199

clear_bit(d->hwirq, msi->bitmap);

drivers/pci/controller/pci-xgene-msi.c

236

xgene_msi_ctrl->bitmap = devm_bitmap_zalloc(dev, NR_MSI_VEC, GFP_KERNEL);

drivers/pci/controller/pci-xgene-msi.c

237

if (!xgene_msi_ctrl->bitmap)

drivers/pci/controller/pci-xgene-msi.c

40

unsigned long *bitmap;

drivers/pci/controller/pcie-apple.c

188

unsigned long *bitmap;

drivers/pci/controller/pcie-apple.c

245

hwirq = bitmap_find_free_region(pcie->bitmap, pcie->nvecs,

drivers/pci/controller/pcie-apple.c

275

bitmap_release_region(pcie->bitmap, d->hwirq, order_base_2(nr_irqs));

drivers/pci/controller/pcie-apple.c

706

pcie->bitmap = devm_bitmap_zalloc(pcie->dev, pcie->nvecs, GFP_KERNEL);

drivers/pci/controller/pcie-apple.c

707

if (!pcie->bitmap)

drivers/pci/controller/pcie-iproc-msi.c

100

unsigned long *bitmap;

drivers/pci/controller/pcie-iproc-msi.c

263

hwirq = bitmap_find_free_region(msi->bitmap, msi->nr_msi_vecs,

drivers/pci/controller/pcie-iproc-msi.c

291

bitmap_release_region(msi->bitmap, hwirq,

drivers/pci/controller/pcie-iproc-msi.c

587

msi->bitmap = devm_bitmap_zalloc(pcie->dev, msi->nr_msi_vecs,

drivers/pci/controller/pcie-iproc-msi.c

589

if (!msi->bitmap)

drivers/pci/controller/pcie-rzg3s-host.c

466

DECLARE_BITMAP(bitmap, RZG3S_PCI_MSI_INT_NR) = {0};

drivers/pci/controller/pcie-rzg3s-host.c

485

bitmap_write(bitmap, status, reg_id * RZG3S_PCI_MSI_INT_PER_REG,

drivers/pci/controller/pcie-rzg3s-host.c

489

for_each_set_bit(bit, bitmap, RZG3S_PCI_MSI_INT_NR) {

drivers/pci/controller/pcie-xilinx-dma-pl.c

413

bit = bitmap_find_free_region(msi->bitmap, XILINX_NUM_MSI_IRQS,

drivers/pci/controller/pcie-xilinx-dma-pl.c

438

bitmap_release_region(msi->bitmap, data->hwirq,

drivers/pci/controller/pcie-xilinx-dma-pl.c

480

msi->bitmap = kzalloc(size, GFP_KERNEL);

drivers/pci/controller/pcie-xilinx-dma-pl.c

481

if (!msi->bitmap)

drivers/pci/controller/pcie-xilinx-dma-pl.c

94

unsigned long *bitmap;

drivers/pci/controller/pcie-xilinx-nwl.c

149

DECLARE_BITMAP(bitmap, INT_PCI_MSI_NR);

drivers/pci/controller/pcie-xilinx-nwl.c

463

bit = bitmap_find_free_region(msi->bitmap, INT_PCI_MSI_NR,

drivers/pci/controller/pcie-xilinx-nwl.c

487

bitmap_release_region(msi->bitmap, data->hwirq,

drivers/pci/endpoint/pci-epc-mem.c

109

kfree(mem->bitmap);

drivers/pci/endpoint/pci-epc-mem.c

158

kfree(mem->bitmap);

drivers/pci/endpoint/pci-epc-mem.c

198

pageno = bitmap_find_free_region(mem->bitmap, mem->pages,

drivers/pci/endpoint/pci-epc-mem.c

206

bitmap_release_region(mem->bitmap,

drivers/pci/endpoint/pci-epc-mem.c

269

bitmap_release_region(mem->bitmap, pageno, order);

drivers/pci/endpoint/pci-epc-mem.c

52

unsigned long *bitmap = NULL;

drivers/pci/endpoint/pci-epc-mem.c

84

bitmap = kzalloc(bitmap_size, GFP_KERNEL);

drivers/pci/endpoint/pci-epc-mem.c

85

if (!bitmap) {

drivers/pci/endpoint/pci-epc-mem.c

95

mem->bitmap = bitmap;

drivers/pci/hotplug/ibmphp_core.c

152

rtable->slots[loop].irq[0].bitmap);

drivers/pci/hotplug/ibmphp_core.c

154

rtable->slots[loop].irq[1].bitmap);

drivers/pci/hotplug/ibmphp_core.c

156

rtable->slots[loop].irq[2].bitmap);

drivers/pci/hotplug/ibmphp_core.c

158

rtable->slots[loop].irq[3].bitmap);

drivers/pci/pci.h

883

u32 bitmap;

drivers/pci/pcie/rcec.c

168

&rcec_ea->bitmap);

drivers/pci/pcie/rcec.c

26

unsigned long bitmap = rcec->rcec_ea->bitmap;

drivers/pci/pcie/rcec.c

34

for_each_set_bit(devn, &bitmap, 32)

drivers/perf/arm-ccn.c

581

static int arm_ccn_pmu_alloc_bit(unsigned long *bitmap, unsigned long size)

drivers/perf/arm-ccn.c

586

bit = find_first_zero_bit(bitmap, size);

drivers/perf/arm-ccn.c

589

} while (test_and_set_bit(bit, bitmap));

drivers/pinctrl/pinctrl-zynqmp.c

581

unsigned long *used_pins __free(bitmap) =

drivers/platform/x86/amd/hfi/hfi.c

168

u32 bitmap = amd_hfi_data->shmem->table_data[i];

drivers/platform/x86/amd/hfi/hfi.c

175

if (!(bitmap & BIT(j)))

drivers/s390/cio/chp.h

34

static inline int chp_test_bit(u8 *bitmap, int num)

drivers/s390/cio/chp.h

39

return (bitmap[byte] & mask) ? 1 : 0;

drivers/s390/cio/idset.c

101

bitmap_or(to->bitmap, to->bitmap, from->bitmap, len);

drivers/s390/cio/idset.c

16

unsigned long bitmap[];

drivers/s390/cio/idset.c

33

memset(set->bitmap, 0, idset_bitmap_size(num_ssid, num_id));

drivers/s390/cio/idset.c

45

memset(set->bitmap, 0xff,

drivers/s390/cio/idset.c

51

set_bit(ssid * set->num_id + id, set->bitmap);

drivers/s390/cio/idset.c

56

clear_bit(ssid * set->num_id + id, set->bitmap);

drivers/s390/cio/idset.c

61

return test_bit(ssid * set->num_id + id, set->bitmap);

drivers/s390/cio/idset.c

84

bitmap_clear(set->bitmap, pos, set->num_id - schid.sch_no);

drivers/s390/cio/idset.c

94

return bitmap_empty(set->bitmap, set->num_ssid * set->num_id);

drivers/s390/crypto/ap_bus.c

1192

int ap_hex2bitmap(const char *str, unsigned long *bitmap, int bits)

drivers/s390/crypto/ap_bus.c

1209

set_bit_inv(i + n, bitmap);

drivers/s390/crypto/ap_bus.c

1238

static int modify_bitmap(const char *str, unsigned long *bitmap, int bits)

drivers/s390/crypto/ap_bus.c

1263

set_bit_inv(i, bitmap);

drivers/s390/crypto/ap_bus.c

1265

clear_bit_inv(i, bitmap);

drivers/s390/crypto/ap_bus.c

1273

static int ap_parse_bitmap_str(const char *str, unsigned long *bitmap, int bits,

drivers/s390/crypto/ap_bus.c

1281

memcpy(newmap, bitmap, size);

drivers/s390/crypto/ap_bus.c

1291

unsigned long *bitmap, int bits,

drivers/s390/crypto/ap_bus.c

1309

rc = ap_parse_bitmap_str(str, bitmap, bits, newmap);

drivers/s390/crypto/ap_bus.c

1311

memcpy(bitmap, newmap, size);

drivers/s390/crypto/vfio_ap_ops.c

1636

static ssize_t write_ap_bitmap(unsigned long *bitmap, char *buf, int offset, char sep)

drivers/s390/crypto/vfio_ap_ops.c

1639

bitmap[0], bitmap[1], bitmap[2], bitmap[3], sep);

drivers/s390/crypto/vfio_ap_ops.c

1660

static int parse_bitmap(char **strbufptr, unsigned long *bitmap, int nbits)

drivers/s390/crypto/vfio_ap_ops.c

1668

bitmap_clear(bitmap, 0, nbits);

drivers/s390/crypto/vfio_ap_ops.c

1669

return ap_hex2bitmap(curmask, bitmap, nbits);

drivers/scsi/53c700.c

512

bitmap_to_number(__u8 bitmap)

drivers/scsi/53c700.c

516

for(i=0; i<8 && !(bitmap &(1<<i)); i++)

drivers/scsi/fnic/fdls_disc.c

137

idx = find_next_zero_bit(oxid_pool->bitmap, FNIC_OXID_POOL_SZ, oxid_pool->next_idx);

drivers/scsi/fnic/fdls_disc.c

145

WARN_ON(test_and_set_bit(idx, oxid_pool->bitmap));

drivers/scsi/fnic/fdls_disc.c

175

WARN_ON(!test_and_clear_bit(oxid_idx, oxid_pool->bitmap));

drivers/scsi/fnic/fnic_fdls.h

232

unsigned long *bitmap;

drivers/scsi/fnic/fnic_fdls.h

237

DECLARE_BITMAP(bitmap, FNIC_OXID_POOL_SZ);

drivers/scsi/hisi_sas/hisi_sas_main.c

189

void *bitmap = hisi_hba->slot_index_tags;

drivers/scsi/hisi_sas/hisi_sas_main.c

191

__clear_bit(slot_idx, bitmap);

drivers/scsi/hisi_sas/hisi_sas_main.c

206

void *bitmap = hisi_hba->slot_index_tags;

drivers/scsi/hisi_sas/hisi_sas_main.c

208

__set_bit(slot_idx, bitmap);

drivers/scsi/hisi_sas/hisi_sas_main.c

215

void *bitmap = hisi_hba->slot_index_tags;

drivers/scsi/hisi_sas/hisi_sas_main.c

221

index = find_next_zero_bit(bitmap, HISI_SAS_RESERVED_IPTT,

drivers/scsi/hisi_sas/hisi_sas_main.c

224

index = find_next_zero_bit(bitmap,

drivers/scsi/hisi_sas/hisi_sas_v1_hw.c

852

int i, bitmap = 0;

drivers/scsi/hisi_sas/hisi_sas_v1_hw.c

857

bitmap |= 1 << i;

drivers/scsi/hisi_sas/hisi_sas_v1_hw.c

859

return bitmap;

drivers/scsi/hisi_sas/hisi_sas_v2_hw.c

1623

int i, bitmap = 0;

drivers/scsi/hisi_sas/hisi_sas_v2_hw.c

1630

bitmap |= 1 << i;

drivers/scsi/hisi_sas/hisi_sas_v2_hw.c

1638

bitmap |= 1 << 9;

drivers/scsi/hisi_sas/hisi_sas_v2_hw.c

1641

return bitmap;

drivers/scsi/hisi_sas/hisi_sas_v2_hw.c

772

void *bitmap = hisi_hba->slot_index_tags;

drivers/scsi/hisi_sas/hisi_sas_v2_hw.c

801

start = find_next_zero_bit(bitmap,

drivers/scsi/hisi_sas/hisi_sas_v2_hw.c

815

set_bit(start, bitmap);

drivers/scsi/hisi_sas/hisi_sas_v2_hw.c

824

void *bitmap = hisi_hba->sata_dev_bitmap;

drivers/scsi/hisi_sas/hisi_sas_v2_hw.c

826

index = find_first_zero_bit(bitmap, HISI_MAX_SATA_SUPPORT_V2_HW);

drivers/scsi/hisi_sas/hisi_sas_v2_hw.c

832

set_bit(index, bitmap);

drivers/scsi/hisi_sas/hisi_sas_v3_hw.c

1150

int i, bitmap = 0;

drivers/scsi/hisi_sas/hisi_sas_v3_hw.c

1158

bitmap |= BIT(i);

drivers/scsi/hisi_sas/hisi_sas_v3_hw.c

1160

return bitmap;

drivers/scsi/mvsas/mv_sas.c

25

void *bitmap = mvi->rsvd_tags;

drivers/scsi/mvsas/mv_sas.c

26

clear_bit(tag, bitmap);

drivers/scsi/mvsas/mv_sas.c

39

void *bitmap = mvi->rsvd_tags;

drivers/scsi/mvsas/mv_sas.c

40

set_bit(tag, bitmap);

drivers/scsi/mvsas/mv_sas.c

46

void *bitmap = mvi->rsvd_tags;

drivers/scsi/mvsas/mv_sas.c

48

index = find_first_zero_bit(bitmap, MVS_RSVD_SLOTS);

drivers/scsi/mvumi.c

1654

ar_bitmap = (const unsigned long *) param->bitmap;

drivers/scsi/mvumi.c

1655

re_bitmap = (const unsigned long *) &param->bitmap[size >> 3];

drivers/scsi/mvumi.h

133

u8 bitmap[];

drivers/scsi/pm8001/pm8001_sas.c

68

void *bitmap = pm8001_ha->rsvd_tags;

drivers/scsi/pm8001/pm8001_sas.c

75

__clear_bit(tag, bitmap);

drivers/scsi/pm8001/pm8001_sas.c

86

void *bitmap = pm8001_ha->rsvd_tags;

drivers/scsi/pm8001/pm8001_sas.c

91

tag = find_first_zero_bit(bitmap, PM8001_RESERVE_SLOT);

drivers/scsi/pm8001/pm8001_sas.c

96

__set_bit(tag, bitmap);

drivers/scsi/qla2xxx/qla_def.h

5163

uint8_t bitmap; /* 28xx only */

drivers/scsi/qla2xxx/qla_init.c

8163

image_status->bitmap,

drivers/scsi/qla2xxx/qla_init.c

8203

return aux->bitmap & bitmask ?

drivers/sh/clk/core.c

43

unsigned long *bitmap)

drivers/sh/clk/core.c

61

if (!div || !mult || (bitmap && !test_bit(i, bitmap)))

drivers/soc/apple/rtkit.c

158

unsigned long bitmap = FIELD_GET(APPLE_RTKIT_MGMT_EPMAP_BITMAP, msg);

drivers/soc/apple/rtkit.c

163

bitmap, base);

drivers/soc/apple/rtkit.c

165

for_each_set_bit(i, &bitmap, 32) {

drivers/soc/qcom/llcc-qcom.c

4544

if (test_bit(desc->slice_id, drv_data->bitmap)) {

drivers/soc/qcom/llcc-qcom.c

4558

__set_bit(desc->slice_id, drv_data->bitmap);

drivers/soc/qcom/llcc-qcom.c

4584

if (!test_bit(desc->slice_id, drv_data->bitmap)) {

drivers/soc/qcom/llcc-qcom.c

4597

__clear_bit(desc->slice_id, drv_data->bitmap);

drivers/soc/qcom/llcc-qcom.c

5109

drv_data->bitmap = devm_bitmap_zalloc(dev, drv_data->max_slices,

drivers/soc/qcom/llcc-qcom.c

5111

if (!drv_data->bitmap) {

drivers/soc/qcom/qcom-pbs.c

100

if (!(bitmap & BIT(bit_pos)))

drivers/soc/qcom/qcom-pbs.c

131

return regmap_update_bits(pbs->regmap, pbs->base + PBS_CLIENT_SCRATCH1, bitmap, 0);

drivers/soc/qcom/qcom-pbs.c

75

int qcom_pbs_trigger_event(struct pbs_dev *pbs, u8 bitmap)

drivers/soc/qcom/qcom-pbs.c

81

if (WARN_ON(!bitmap))

drivers/staging/media/atomisp/pci/atomisp_cmd.c

4536

int *bitmap, bit;

drivers/staging/media/atomisp/pci/atomisp_cmd.c

4543

bitmap = asd->raw_buffer_bitmap + exp_id / 32;

drivers/staging/media/atomisp/pci/atomisp_cmd.c

4546

ret = ((*bitmap) & (1 << bit));

drivers/staging/media/atomisp/pci/atomisp_cmd.c

4553

int *bitmap, bit;

drivers/staging/media/atomisp/pci/atomisp_cmd.c

4559

bitmap = asd->raw_buffer_bitmap + exp_id / 32;

drivers/staging/media/atomisp/pci/atomisp_cmd.c

4562

(*bitmap) &= ~(1 << bit);

drivers/staging/rtl8723bs/core/rtw_wlan_util.c

432

cam_ctl->bitmap = 0;

drivers/staging/rtl8723bs/core/rtw_wlan_util.c

521

if (!(cam_ctl->bitmap & BIT(cam_id)))

drivers/staging/rtl8723bs/core/rtw_wlan_util.c

611

if (!(cam_ctl->bitmap & BIT(i)))

drivers/staging/rtl8723bs/core/rtw_wlan_util.c

633

cam_ctl->bitmap |= BIT(cam_id);

drivers/staging/rtl8723bs/core/rtw_wlan_util.c

648

cam_ctl->bitmap &= ~(BIT(cam_id));

drivers/staging/rtl8723bs/hal/hal_intf.c

216

void rtw_hal_add_ra_tid(struct adapter *padapter, u32 bitmap, u8 *arg, u8 rssi_level)

drivers/staging/rtl8723bs/hal/hal_intf.c

218

rtl8723b_Add_RateATid(padapter, bitmap, arg, rssi_level);

drivers/staging/rtl8723bs/hal/rtl8723b_cmd.c

713

u32 bitmap,

drivers/staging/rtl8723bs/hal/rtl8723b_cmd.c

726

u32 mask = bitmap&0x0FFFFFFF;

drivers/staging/rtl8723bs/include/drv_types.h

196

u64 bitmap;

drivers/staging/rtl8723bs/include/hal_intf.h

222

void rtw_hal_add_ra_tid(struct adapter *padapter, u32 bitmap, u8 *arg, u8 rssi_level);

drivers/staging/rtl8723bs/include/rtl8723b_cmd.h

169

void rtl8723b_Add_RateATid(struct adapter *padapter, u32 bitmap, u8 *arg, u8 rssi_level);

drivers/target/target_core_user.c

810

static inline size_t spc_bitmap_free(unsigned long *bitmap, uint32_t thresh)

drivers/target/target_core_user.c

812

return thresh - bitmap_weight(bitmap, thresh);

drivers/tee/optee/notif.c

107

set_bit(key, optee->notif.bitmap);

drivers/tee/optee/notif.c

118

optee->notif.bitmap = bitmap_zalloc(max_key, GFP_KERNEL);

drivers/tee/optee/notif.c

119

if (!optee->notif.bitmap)

drivers/tee/optee/notif.c

129

bitmap_free(optee->notif.bitmap);

drivers/tee/optee/notif.c

53

if (test_bit(key, optee->notif.bitmap)) {

drivers/tee/optee/notif.c

54

clear_bit(key, optee->notif.bitmap);

drivers/tee/optee/optee_private.h

84

u_long *bitmap;

drivers/ufs/core/ufshcd.c

666

static void ufshcd_print_tmrs(struct ufs_hba *hba, unsigned long bitmap)

drivers/ufs/core/ufshcd.c

670

for_each_set_bit(tag, &bitmap, hba->nutmrs) {

drivers/ufs/core/ufshcd.c

7699

static void ufshcd_set_req_abort_skip(struct ufs_hba *hba, unsigned long bitmap)

drivers/ufs/core/ufshcd.c

7703

for_each_set_bit(tag, &bitmap, hba->nutrs) {

drivers/usb/mtu3/mtu3.h

147

DECLARE_BITMAP(bitmap, MTU3_FIFO_BIT_SIZE);

drivers/usb/mtu3/mtu3_core.c

36

start_bit = bitmap_find_next_zero_area(fifo->bitmap,

drivers/usb/mtu3/mtu3_core.c

41

bitmap_set(fifo->bitmap, start_bit, num_bits);

drivers/usb/mtu3/mtu3_core.c

552

bitmap_zero(tx_fifo->bitmap, MTU3_FIFO_BIT_SIZE);

drivers/usb/mtu3/mtu3_core.c

558

bitmap_zero(rx_fifo->bitmap, MTU3_FIFO_BIT_SIZE);

drivers/usb/mtu3/mtu3_core.c

565

bitmap_zero(tx_fifo->bitmap, MTU3_FIFO_BIT_SIZE);

drivers/usb/mtu3/mtu3_core.c

571

bitmap_zero(rx_fifo->bitmap, MTU3_FIFO_BIT_SIZE);

drivers/usb/mtu3/mtu3_core.c

62

bitmap_clear(fifo->bitmap, start_bit, bits);

drivers/vfio/vfio_iommu_type1.c

100

unsigned long *bitmap;

drivers/vfio/vfio_iommu_type1.c

1271

static int update_user_bitmap(u64 __user *bitmap, struct vfio_iommu *iommu,

drivers/vfio/vfio_iommu_type1.c

1287

bitmap_set(dma->bitmap, 0, nbits);

drivers/vfio/vfio_iommu_type1.c

1290

bitmap_shift_left(dma->bitmap, dma->bitmap, shift,

drivers/vfio/vfio_iommu_type1.c

1294

(void __user *)(bitmap + copy_offset),

drivers/vfio/vfio_iommu_type1.c

1298

bitmap_or(dma->bitmap, dma->bitmap, &leftover, shift);

drivers/vfio/vfio_iommu_type1.c

1301

if (copy_to_user((void __user *)(bitmap + copy_offset), dma->bitmap,

drivers/vfio/vfio_iommu_type1.c

1308

static int vfio_iova_dirty_bitmap(u64 __user *bitmap, struct vfio_iommu *iommu,

drivers/vfio/vfio_iommu_type1.c

1339

ret = update_user_bitmap(bitmap, iommu, dma, iova, pgsize);

drivers/vfio/vfio_iommu_type1.c

1348

bitmap_clear(dma->bitmap, 0, dma->size >> pgshift);

drivers/vfio/vfio_iommu_type1.c

1394

struct vfio_bitmap *bitmap)

drivers/vfio/vfio_iommu_type1.c

1442

(!iommu->dirty_page_tracking || (bitmap->pgsize != pgsize))) {

drivers/vfio/vfio_iommu_type1.c

1534

ret = update_user_bitmap(bitmap->data, iommu, dma,

drivers/vfio/vfio_iommu_type1.c

254

dma->bitmap = kvzalloc(DIRTY_BITMAP_BYTES(npages) + sizeof(u64),

drivers/vfio/vfio_iommu_type1.c

256

if (!dma->bitmap)

drivers/vfio/vfio_iommu_type1.c

264

kvfree(dma->bitmap);

drivers/vfio/vfio_iommu_type1.c

265

dma->bitmap = NULL;

drivers/vfio/vfio_iommu_type1.c

276

bitmap_set(dma->bitmap, (vpfn->iova - dma->iova) >> pgshift, 1);

drivers/vfio/vfio_iommu_type1.c

288

bitmap_set(dma->bitmap, 0, dma->size >> pgshift);

drivers/vfio/vfio_iommu_type1.c

2919

struct vfio_bitmap bitmap = { 0 };

drivers/vfio/vfio_iommu_type1.c

2942

if (unmap.argsz < (minsz + sizeof(bitmap)))

drivers/vfio/vfio_iommu_type1.c

2945

if (copy_from_user(&bitmap,

drivers/vfio/vfio_iommu_type1.c

2947

sizeof(bitmap)))

drivers/vfio/vfio_iommu_type1.c

2950

if (!access_ok((void __user *)bitmap.data, bitmap.size))

drivers/vfio/vfio_iommu_type1.c

2953

pgshift = __ffs(bitmap.pgsize);

drivers/vfio/vfio_iommu_type1.c

2955

bitmap.size);

drivers/vfio/vfio_iommu_type1.c

2960

ret = vfio_dma_do_unmap(iommu, &unmap, &bitmap);

drivers/vfio/vfio_iommu_type1.c

3039

if (!access_ok((void __user *)range.bitmap.data,

drivers/vfio/vfio_iommu_type1.c

3040

range.bitmap.size))

drivers/vfio/vfio_iommu_type1.c

3043

pgshift = __ffs(range.bitmap.pgsize);

drivers/vfio/vfio_iommu_type1.c

3045

range.bitmap.size);

drivers/vfio/vfio_iommu_type1.c

3054

if (range.bitmap.pgsize != iommu_pgsize) {

drivers/vfio/vfio_iommu_type1.c

3068

ret = vfio_iova_dirty_bitmap(range.bitmap.data,

drivers/vfio/vfio_iommu_type1.c

3070

range.bitmap.pgsize);

drivers/vfio/vfio_iommu_type1.c

3185

bitmap_set(dma->bitmap, offset >> pgshift,

drivers/vfio/vfio_iommu_type1.c

991

bitmap_set(dma->bitmap,

drivers/vfio/vfio_main.c

1167

bitmap);

drivers/vfio/vfio_main.c

1194

u64_to_user_ptr(report.bitmap));

drivers/video/fbdev/pm2fb.c

1324

u8 *bitmap = (u8 *)cursor->image.data;

drivers/video/fbdev/pm2fb.c

1336

u8 data = *bitmap ^ *mask;

drivers/video/fbdev/pm2fb.c

1339

data = *mask & *bitmap;

drivers/video/fbdev/pm2fb.c

1348

bitmap++;

drivers/video/fbdev/pm2fb.c

1431

u8 *bitmap = (u8 *)cursor->image.data;

drivers/video/fbdev/pm2fb.c

1444

u8 data = *bitmap ^ *mask;

drivers/video/fbdev/pm2fb.c

1447

data = *mask & *bitmap;

drivers/video/fbdev/pm2fb.c

1450

bitmap++;

drivers/video/fbdev/pm3fb.c

680

u8 *bitmap = (u8 *)cursor->image.data;

drivers/video/fbdev/pm3fb.c

690

u8 data = *bitmap ^ *mask;

drivers/video/fbdev/pm3fb.c

693

data = *mask & *bitmap;

drivers/video/fbdev/pm3fb.c

702

bitmap++;

drivers/video/fbdev/tdfxfb.c

1115

u8 *bitmap = (u8 *)cursor->image.data;

drivers/video/fbdev/tdfxfb.c

1126

u8 data = *mask ^ *bitmap;

drivers/video/fbdev/tdfxfb.c

1128

data = *mask & *bitmap;

drivers/video/fbdev/tdfxfb.c

1134

bitmap++;

drivers/virtio/virtio_input.c

163

u.bitmap),

fs/afs/dir.c

387

if (!(block->hdr.bitmap[slot / 8] &

fs/afs/dir.c

422

if (!(block->hdr.bitmap[xslot / 8] & (1 << (xslot % 8)))) {

fs/afs/dir_edit.c

100

block->hdr.bitmap[2] &= ~(u8)(mask >> 2 * 8);

fs/afs/dir_edit.c

101

block->hdr.bitmap[3] &= ~(u8)(mask >> 3 * 8);

fs/afs/dir_edit.c

102

block->hdr.bitmap[4] &= ~(u8)(mask >> 4 * 8);

fs/afs/dir_edit.c

103

block->hdr.bitmap[5] &= ~(u8)(mask >> 5 * 8);

fs/afs/dir_edit.c

104

block->hdr.bitmap[6] &= ~(u8)(mask >> 6 * 8);

fs/afs/dir_edit.c

105

block->hdr.bitmap[7] &= ~(u8)(mask >> 7 * 8);

fs/afs/dir_edit.c

169

u64 bitmap;

fs/afs/dir_edit.c

174

bitmap = (u64)block->hdr.bitmap[0] << 0 * 8;

fs/afs/dir_edit.c

175

bitmap |= (u64)block->hdr.bitmap[1] << 1 * 8;

fs/afs/dir_edit.c

176

bitmap |= (u64)block->hdr.bitmap[2] << 2 * 8;

fs/afs/dir_edit.c

177

bitmap |= (u64)block->hdr.bitmap[3] << 3 * 8;

fs/afs/dir_edit.c

178

bitmap |= (u64)block->hdr.bitmap[4] << 4 * 8;

fs/afs/dir_edit.c

179

bitmap |= (u64)block->hdr.bitmap[5] << 5 * 8;

fs/afs/dir_edit.c

180

bitmap |= (u64)block->hdr.bitmap[6] << 6 * 8;

fs/afs/dir_edit.c

181

bitmap |= (u64)block->hdr.bitmap[7] << 7 * 8;

fs/afs/dir_edit.c

186

if (!((bitmap >> d) & 1))

fs/afs/dir_edit.c

216

block->hdr.bitmap[0] = 1;

fs/afs/dir_edit.c

219

block->hdr.bitmap[0] = 0xff;

fs/afs/dir_edit.c

220

block->hdr.bitmap[1] = 0x1f;

fs/afs/dir_edit.c

26

u64 bitmap;

fs/afs/dir_edit.c

30

bitmap = (u64)block->hdr.bitmap[0] << 0 * 8;

fs/afs/dir_edit.c

31

bitmap |= (u64)block->hdr.bitmap[1] << 1 * 8;

fs/afs/dir_edit.c

32

bitmap |= (u64)block->hdr.bitmap[2] << 2 * 8;

fs/afs/dir_edit.c

33

bitmap |= (u64)block->hdr.bitmap[3] << 3 * 8;

fs/afs/dir_edit.c

34

bitmap |= (u64)block->hdr.bitmap[4] << 4 * 8;

fs/afs/dir_edit.c

35

bitmap |= (u64)block->hdr.bitmap[5] << 5 * 8;

fs/afs/dir_edit.c

36

bitmap |= (u64)block->hdr.bitmap[6] << 6 * 8;

fs/afs/dir_edit.c

37

bitmap |= (u64)block->hdr.bitmap[7] << 7 * 8;

fs/afs/dir_edit.c

38

bitmap >>= 1; /* The first entry is metadata */

fs/afs/dir_edit.c

44

n = ffz(bitmap);

fs/afs/dir_edit.c

46

n = ((u32)bitmap) != 0 ?

fs/afs/dir_edit.c

47

ffz((u32)bitmap) :

fs/afs/dir_edit.c

48

ffz((u32)(bitmap >> 32)) + 32;

fs/afs/dir_edit.c

49

bitmap >>= n;

fs/afs/dir_edit.c

52

if ((bitmap & mask) == 0) {

fs/afs/dir_edit.c

58

n = __ffs(bitmap);

fs/afs/dir_edit.c

59

bitmap >>= n;

fs/afs/dir_edit.c

61

} while (bitmap);

fs/afs/dir_edit.c

77

block->hdr.bitmap[0] |= (u8)(mask >> 0 * 8);

fs/afs/dir_edit.c

78

block->hdr.bitmap[1] |= (u8)(mask >> 1 * 8);

fs/afs/dir_edit.c

79

block->hdr.bitmap[2] |= (u8)(mask >> 2 * 8);

fs/afs/dir_edit.c

80

block->hdr.bitmap[3] |= (u8)(mask >> 3 * 8);

fs/afs/dir_edit.c

81

block->hdr.bitmap[4] |= (u8)(mask >> 4 * 8);

fs/afs/dir_edit.c

82

block->hdr.bitmap[5] |= (u8)(mask >> 5 * 8);

fs/afs/dir_edit.c

83

block->hdr.bitmap[6] |= (u8)(mask >> 6 * 8);

fs/afs/dir_edit.c

84

block->hdr.bitmap[7] |= (u8)(mask >> 7 * 8);

fs/afs/dir_edit.c

98

block->hdr.bitmap[0] &= ~(u8)(mask >> 0 * 8);

fs/afs/dir_edit.c

99

block->hdr.bitmap[1] &= ~(u8)(mask >> 1 * 8);

fs/afs/xdr_fs.h

79

u8 bitmap[8];

fs/btrfs/free-space-cache.c

1103

e->bitmap);

fs/btrfs/free-space-cache.c

1107

if (e->bitmap) {

fs/btrfs/free-space-cache.c

1249

ret = io_ctl_add_bitmap(io_ctl, entry->bitmap);

fs/btrfs/free-space-cache.c

1626

if (new_entry->bitmap) {

fs/btrfs/free-space-cache.c

1627

if (info->bitmap) {

fs/btrfs/free-space-cache.c

1633

if (!info->bitmap) {

fs/btrfs/free-space-cache.c

1674

if (entry->bitmap && entry->max_extent_size)

fs/btrfs/free-space-cache.c

1726

if (entry->bitmap)

fs/btrfs/free-space-cache.c

1740

WARN_ON(!entry->bitmap);

fs/btrfs/free-space-cache.c

1743

if (entry->bitmap) {

fs/btrfs/free-space-cache.c

1752

if (!prev->bitmap &&

fs/btrfs/free-space-cache.c

1779

if (entry->bitmap) {

fs/btrfs/free-space-cache.c

1784

if (!prev->bitmap &&

fs/btrfs/free-space-cache.c

1801

if (entry->bitmap) {

fs/btrfs/free-space-cache.c

1823

if (!info->bitmap && !btrfs_free_space_trimmed(info)) {

fs/btrfs/free-space-cache.c

1839

ASSERT(info->bytes || info->bitmap);

fs/btrfs/free-space-cache.c

1846

if (!info->bitmap && !btrfs_free_space_trimmed(info)) {

fs/btrfs/free-space-cache.c

1859

ASSERT(info->bitmap);

fs/btrfs/free-space-cache.c

1886

bitmap_clear(info->bitmap, start, count);

fs/btrfs/free-space-cache.c

1894

if (start && test_bit(start - 1, info->bitmap))

fs/btrfs/free-space-cache.c

1897

if (end < BITS_PER_BITMAP && test_bit(end, info->bitmap))

fs/btrfs/free-space-cache.c

1922

bitmap_set(info->bitmap, start, count);

fs/btrfs/free-space-cache.c

1934

if (start && test_bit(start - 1, info->bitmap))

fs/btrfs/free-space-cache.c

1937

if (end < BITS_PER_BITMAP && test_bit(end, info->bitmap))

fs/btrfs/free-space-cache.c

1976

for_each_set_bit_from(i, bitmap_info->bitmap, BITS_PER_BITMAP) {

fs/btrfs/free-space-cache.c

1981

next_zero = find_next_zero_bit(bitmap_info->bitmap,

fs/btrfs/free-space-cache.c

2079

if (entry->bitmap) {

fs/btrfs/free-space-cache.c

2141

kmem_cache_free(btrfs_free_space_bitmap_cachep, bitmap_info->bitmap);

fs/btrfs/free-space-cache.c

2201

if (!bitmap_info->bitmap)

fs/btrfs/free-space-cache.c

2348

if (!entry->bitmap) {

fs/btrfs/free-space-cache.c

2387

if (info && info->bitmap) {

fs/btrfs/free-space-cache.c

2407

info->bitmap = kmem_cache_zalloc(btrfs_free_space_bitmap_cachep,

fs/btrfs/free-space-cache.c

2411

if (!info->bitmap) {

fs/btrfs/free-space-cache.c

2420

if (info->bitmap)

fs/btrfs/free-space-cache.c

2422

info->bitmap);

fs/btrfs/free-space-cache.c

2471

if (right_info && !right_info->bitmap &&

fs/btrfs/free-space-cache.c

2480

if (left_info && !left_info->bitmap &&

fs/btrfs/free-space-cache.c

2497

struct btrfs_free_space *bitmap;

fs/btrfs/free-space-cache.c

2504

bitmap = tree_search_offset(ctl, bitmap_offset, 1, 0);

fs/btrfs/free-space-cache.c

2505

if (!bitmap)

fs/btrfs/free-space-cache.c

2508

i = offset_to_bit(bitmap->offset, ctl->unit, end);

fs/btrfs/free-space-cache.c

2509

j = find_next_zero_bit(bitmap->bitmap, BITS_PER_BITMAP, i);

fs/btrfs/free-space-cache.c

2516

if (!btrfs_free_space_trimmed(bitmap))

fs/btrfs/free-space-cache.c

2519

bitmap_clear_bits(ctl, bitmap, end, bytes, update_stat);

fs/btrfs/free-space-cache.c

2521

if (!bitmap->bytes)

fs/btrfs/free-space-cache.c

2522

free_bitmap(ctl, bitmap);

fs/btrfs/free-space-cache.c

2531

struct btrfs_free_space *bitmap;

fs/btrfs/free-space-cache.c

2546

bitmap = tree_search_offset(ctl, bitmap_offset, 1, 0);

fs/btrfs/free-space-cache.c

2547

if (!bitmap)

fs/btrfs/free-space-cache.c

2550

i = offset_to_bit(bitmap->offset, ctl->unit, info->offset) - 1;

fs/btrfs/free-space-cache.c

2553

for_each_clear_bit_from(j, bitmap->bitmap, BITS_PER_BITMAP) {

fs/btrfs/free-space-cache.c

2570

if (!btrfs_free_space_trimmed(bitmap))

fs/btrfs/free-space-cache.c

2573

bitmap_clear_bits(ctl, bitmap, info->offset, bytes, update_stat);

fs/btrfs/free-space-cache.c

2575

if (!bitmap->bytes)

fs/btrfs/free-space-cache.c

2576

free_bitmap(ctl, bitmap);

fs/btrfs/free-space-cache.c

2600

ASSERT(!info->bitmap);

fs/btrfs/free-space-cache.c

2852

if (!info->bitmap) {

fs/btrfs/free-space-cache.c

2937

info->offset, info->bytes, str_yes_no(info->bitmap));

fs/btrfs/free-space-cache.c

3003

if (!entry->bitmap) {

fs/btrfs/free-space-cache.c

3112

if (entry->bitmap) {

fs/btrfs/free-space-cache.c

3255

(!entry->bitmap && entry->offset < min_start)) {

fs/btrfs/free-space-cache.c

3264

if (entry->bitmap) {

fs/btrfs/free-space-cache.c

3299

if (!entry->bitmap && !btrfs_free_space_trimmed(entry))

fs/btrfs/free-space-cache.c

3306

if (entry->bitmap) {

fs/btrfs/free-space-cache.c

3308

entry->bitmap);

fs/btrfs/free-space-cache.c

3356

for_each_set_bit_from(i, entry->bitmap, BITS_PER_BITMAP) {

fs/btrfs/free-space-cache.c

3357

next_zero = find_next_zero_bit(entry->bitmap,

fs/btrfs/free-space-cache.c

3441

while (entry->bitmap || entry->bytes < min_bytes) {

fs/btrfs/free-space-cache.c

3442

if (entry->bitmap && list_empty(&entry->list))

fs/btrfs/free-space-cache.c

3459

if (entry->bitmap) {

fs/btrfs/free-space-cache.c

3490

if (entry->bitmap || entry->bytes < min_bytes)

fs/btrfs/free-space-cache.c

3747

while (entry->bitmap ||

fs/btrfs/free-space-cache.c

4240

u64 offset, u64 bytes, bool bitmap)

fs/btrfs/free-space-cache.c

4256

if (!bitmap) {

fs/btrfs/free-space-cache.c

4280

info->bitmap = map;

fs/btrfs/free-space-cache.c

4326

if (info->bitmap) {

fs/btrfs/free-space-cache.c

579

void *bitmap)

fs/btrfs/free-space-cache.c

589

entry->type = (bitmap) ? BTRFS_FREE_SPACE_BITMAP :

fs/btrfs/free-space-cache.c

608

static int io_ctl_add_bitmap(struct btrfs_io_ctl *io_ctl, void *bitmap)

fs/btrfs/free-space-cache.c

624

copy_page(io_ctl->cur, bitmap);

fs/btrfs/free-space-cache.c

684

copy_page(entry->bitmap, io_ctl->cur);

fs/btrfs/free-space-cache.c

72

if (!info->bitmap) {

fs/btrfs/free-space-cache.c

845

e->bitmap = kmem_cache_zalloc(

fs/btrfs/free-space-cache.c

847

if (!e->bitmap) {

fs/btrfs/free-space-cache.c

859

kmem_cache_free(btrfs_free_space_bitmap_cachep, e->bitmap);

fs/btrfs/free-space-cache.c

908

if (!info->bitmap) {

fs/btrfs/free-space-cache.h

176

u64 offset, u64 bytes, bool bitmap);

fs/btrfs/free-space-cache.h

43

unsigned long *bitmap;

fs/btrfs/free-space-tree.c

206

unsigned long *bitmap;

fs/btrfs/free-space-tree.c

216

bitmap = alloc_bitmap(bitmap_size);

fs/btrfs/free-space-tree.c

217

if (unlikely(!bitmap))

fs/btrfs/free-space-tree.c

256

le_bitmap_set(bitmap, first, last - first);

fs/btrfs/free-space-tree.c

299

bitmap_cursor = (char *)bitmap;

fs/btrfs/free-space-tree.c

333

kvfree(bitmap);

fs/btrfs/free-space-tree.c

347

unsigned long *bitmap;

fs/btrfs/free-space-tree.c

356

bitmap = alloc_bitmap(bitmap_size);

fs/btrfs/free-space-tree.c

357

if (unlikely(!bitmap))

fs/btrfs/free-space-tree.c

397

bitmap_cursor = ((char *)bitmap) + bitmap_pos;

fs/btrfs/free-space-tree.c

436

start_bit = find_next_bit_le(bitmap, nrbits, 0);

fs/btrfs/free-space-tree.c

439

end_bit = find_next_zero_bit_le(bitmap, nrbits, start_bit);

fs/btrfs/free-space-tree.c

455

start_bit = find_next_bit_le(bitmap, nrbits, end_bit);

fs/btrfs/free-space-tree.c

470

kvfree(bitmap);

fs/btrfs/relocation.c

3904

static void parse_bitmap(u64 block_size, const unsigned long *bitmap,

fs/btrfs/relocation.c

3911

pos = find_first_bit(bitmap, size);

fs/btrfs/relocation.c

3916

end = find_next_zero_bit(bitmap, size, pos);

fs/btrfs/relocation.c

3934

pos = find_next_bit(bitmap, size, end + 1);

fs/btrfs/relocation.c

4502

void *bitmap;

fs/btrfs/relocation.c

4510

bitmap = kmalloc(data_size, GFP_NOFS);

fs/btrfs/relocation.c

4511

if (!bitmap) {

fs/btrfs/relocation.c

4517

read_extent_buffer(leaf, bitmap, offset, data_size);

fs/btrfs/relocation.c

4519

parse_bitmap(fs_info->sectorsize, bitmap,

fs/btrfs/relocation.c

4526

kfree(bitmap);

fs/btrfs/scrub.c

296

unsigned long bitmap = scrub_bitmap_read_##name(stripe); \

fs/btrfs/scrub.c

298

return bitmap_empty(&bitmap, stripe->nr_sectors); \

fs/btrfs/scrub.c

302

unsigned long bitmap = scrub_bitmap_read_##name(stripe); \

fs/btrfs/scrub.c

304

return bitmap_weight(&bitmap, stripe->nr_sectors); \

fs/btrfs/scrub.c

859

static void scrub_verify_one_stripe(struct scrub_stripe *stripe, unsigned long bitmap)

fs/btrfs/scrub.c

865

for_each_set_bit(sector_nr, &bitmap, stripe->nr_sectors) {

fs/btrfs/subpage.c

308

struct folio *folio, unsigned long bitmap)

fs/btrfs/subpage.c

330

for_each_set_bit(bit, &bitmap, blocks_per_folio) {

fs/btrfs/subpage.c

677

unsigned long bitmap; \

fs/btrfs/subpage.c

680

GET_SUBPAGE_BITMAP(fs_info, folio, name, &bitmap); \

fs/btrfs/subpage.c

683

start, len, folio_pos(folio), __bpf, &bitmap); \

fs/btrfs/subpage.h

136

struct folio *folio, unsigned long bitmap);

fs/btrfs/tests/extent-io-tests.c

341

static int check_eb_bitmap(unsigned long *bitmap, struct extent_buffer *eb)

fs/btrfs/tests/extent-io-tests.c

348

bit_set = test_bit(i, bitmap);

fs/btrfs/tests/extent-io-tests.c

355

expect = bitmap_get_value8(bitmap, ALIGN(i, BITS_PER_BYTE));

fs/btrfs/tests/extent-io-tests.c

370

expect = bitmap_get_value8(bitmap, ALIGN(i, BITS_PER_BYTE));

fs/btrfs/tests/extent-io-tests.c

382

static int test_bitmap_set(const char *name, unsigned long *bitmap,

fs/btrfs/tests/extent-io-tests.c

389

bitmap_set(bitmap, byte_start * BITS_PER_BYTE + bit_start, bit_len);

fs/btrfs/tests/extent-io-tests.c

391

ret = check_eb_bitmap(bitmap, eb);

fs/btrfs/tests/extent-io-tests.c

397

static int test_bitmap_clear(const char *name, unsigned long *bitmap,

fs/btrfs/tests/extent-io-tests.c

404

bitmap_clear(bitmap, byte_start * BITS_PER_BYTE + bit_start, bit_len);

fs/btrfs/tests/extent-io-tests.c

406

ret = check_eb_bitmap(bitmap, eb);

fs/btrfs/tests/extent-io-tests.c

411

static int __test_eb_bitmaps(unsigned long *bitmap, struct extent_buffer *eb)

fs/btrfs/tests/extent-io-tests.c

418

ret = test_bitmap_clear("clear all run 1", bitmap, eb, 0, 0,

fs/btrfs/tests/extent-io-tests.c

423

ret = test_bitmap_set("set all", bitmap, eb, 0, 0, byte_len * BITS_PER_BYTE);

fs/btrfs/tests/extent-io-tests.c

427

ret = test_bitmap_clear("clear all run 2", bitmap, eb, 0, 0,

fs/btrfs/tests/extent-io-tests.c

432

ret = test_bitmap_set("same byte set", bitmap, eb, 0, 2, 4);

fs/btrfs/tests/extent-io-tests.c

436

ret = test_bitmap_clear("same byte partial clear", bitmap, eb, 0, 4, 1);

fs/btrfs/tests/extent-io-tests.c

440

ret = test_bitmap_set("cross byte set", bitmap, eb, 2, 4, 8);

fs/btrfs/tests/extent-io-tests.c

444

ret = test_bitmap_set("cross multi byte set", bitmap, eb, 4, 4, 24);

fs/btrfs/tests/extent-io-tests.c

448

ret = test_bitmap_clear("cross byte clear", bitmap, eb, 2, 6, 4);

fs/btrfs/tests/extent-io-tests.c

452

ret = test_bitmap_clear("cross multi byte clear", bitmap, eb, 4, 6, 20);

fs/btrfs/tests/extent-io-tests.c

458

ret = test_bitmap_set("cross page set", bitmap, eb,

fs/btrfs/tests/extent-io-tests.c

464

ret = test_bitmap_set("cross page set all", bitmap, eb, 0, 0,

fs/btrfs/tests/extent-io-tests.c

469

ret = test_bitmap_clear("cross page clear", bitmap, eb,

fs/btrfs/tests/extent-io-tests.c

481

ret = test_bitmap_clear("clear all run 3", bitmap, eb, 0, 0,

fs/btrfs/tests/extent-io-tests.c

490

bitmap_set(bitmap, i * 32 + j, 1);

fs/btrfs/tests/extent-io-tests.c

496

ret = check_eb_bitmap(bitmap, eb);

fs/btrfs/tests/extent-io-tests.c

508

unsigned long AUTO_KFREE(bitmap);

fs/btrfs/tests/extent-io-tests.c

520

bitmap = kmalloc(nodesize, GFP_KERNEL);

fs/btrfs/tests/extent-io-tests.c

521

if (!bitmap) {

fs/btrfs/tests/extent-io-tests.c

534

ret = __test_eb_bitmaps(bitmap, eb);

fs/btrfs/tests/extent-io-tests.c

551

ret = __test_eb_bitmaps(bitmap, eb);

fs/exfat/balloc.c

155

ep->dentry.bitmap.flags == 0x0) {

fs/exfat/balloc.c

304

unsigned long *bitmap, clu_bits;

fs/exfat/balloc.c

308

bitmap = (void *)(sbi->vol_amap[map_i]->b_data + map_b);

fs/exfat/balloc.c

309

count += hweight_long(*bitmap);

fs/exfat/balloc.c

318

bitmap = (void *)(sbi->vol_amap[map_i]->b_data + map_b);

fs/exfat/balloc.c

319

clu_bits = lel_to_cpu(*(__le_long *)bitmap);

fs/exfat/balloc.c

83

sbi->map_clu = le32_to_cpu(ep->dentry.bitmap.start_clu);

fs/exfat/balloc.c

84

map_size = le64_to_cpu(ep->dentry.bitmap.size);

fs/exfat/exfat_raw.h

155

} __packed bitmap; /* allocation bitmap directory entry */

fs/ext4/bitmap.c

14

unsigned int ext4_count_free(char *bitmap, unsigned int numchars)

fs/ext4/bitmap.c

16

return numchars * BITS_PER_BYTE - memweight(bitmap, numchars);

fs/ext4/ext4.h

2766

extern unsigned int ext4_count_free(char *bitmap, unsigned numchars);

fs/ext4/ext4.h

2962

extern void ext4_mark_bitmap_end(int start_bit, int end_bit, char *bitmap);

fs/ext4/ialloc.c

55

void ext4_mark_bitmap_end(int start_bit, int end_bit, char *bitmap)

fs/ext4/ialloc.c

64

ext4_set_bit(i, bitmap);

fs/ext4/ialloc.c

66

memset(bitmap + (i >> 3), 0xff, (end_bit - i) >> 3);

fs/ext4/ialloc.c

726

struct buffer_head *bitmap, unsigned long *ino)

fs/ext4/ialloc.c

733

bitmap->b_data,

fs/ext4/mballoc-test.c

487

void *bitmap;

fs/ext4/mballoc-test.c

495

bitmap = mbt_ctx_bitmap(sb, i);

fs/ext4/mballoc-test.c

496

bit = mb_find_next_zero_bit_test(bitmap, max, 0);

fs/ext4/mballoc-test.c

501

bitmap = mbt_ctx_bitmap(sb, goal_group);

fs/ext4/mballoc-test.c

502

bit = mb_find_next_zero_bit_test(bitmap, max, 0);

fs/ext4/mballoc-test.c

505

bit = mb_find_next_bit_test(bitmap, max, bit + 1);

fs/ext4/mballoc-test.c

557

void *bitmap;

fs/ext4/mballoc-test.c

568

bitmap = mbt_ctx_bitmap(sb, TEST_GOAL_GROUP);

fs/ext4/mballoc-test.c

569

memset(bitmap, 0, sb->s_blocksize);

fs/ext4/mballoc-test.c

574

i = mb_find_next_bit_test(bitmap, max, 0);

fs/ext4/mballoc-test.c

576

i = mb_find_next_zero_bit_test(bitmap, max, i + 1);

fs/ext4/mballoc-test.c

578

i = mb_find_next_bit_test(bitmap, max, i + 1);

fs/ext4/mballoc-test.c

606

void *bitmap, struct ext4_group_info *grp)

fs/ext4/mballoc-test.c

617

bb = bitmap;

fs/ext4/mballoc-test.c

660

off = mb_find_next_zero_bit_test(bitmap, max, 0);

fs/ext4/mballoc-test.c

664

off = mb_find_next_bit_test(bitmap, max, off + 1);

fs/ext4/mballoc-test.c

668

off = mb_find_next_zero_bit_test(bitmap, max, off + 1);

fs/ext4/mballoc-test.c

697

do_test_generate_buddy(struct kunit *test, struct super_block *sb, void *bitmap,

fs/ext4/mballoc-test.c

703

mbt_generate_buddy(sb, mbt_buddy, bitmap, mbt_grp);

fs/ext4/mballoc-test.c

710

ext4_mb_generate_buddy_test(sb, ext4_buddy, bitmap, TEST_GOAL_GROUP,

fs/ext4/mballoc-test.c

721

void *bitmap, *expected_bb, *generate_bb;

fs/ext4/mballoc-test.c

726

bitmap = kunit_kzalloc(test, sb->s_blocksize, GFP_KERNEL);

fs/ext4/mballoc-test.c

727

KUNIT_ASSERT_NOT_ERR_OR_NULL(test, bitmap);

fs/ext4/mballoc-test.c

740

mb_set_bits(bitmap, ranges[i].start, ranges[i].len);

fs/ext4/mballoc-test.c

741

do_test_generate_buddy(test, sb, bitmap, expected_bb,

fs/ext4/mballoc-test.c

748

ext4_grpblk_t start, ext4_grpblk_t len, void *bitmap,

fs/ext4/mballoc-test.c

767

mb_set_bits(bitmap, start, len);

fs/ext4/mballoc-test.c

773

ext4_mb_generate_buddy_test(sb, buddy, bitmap, 0, grp);

fs/ext4/mballoc-test.c

784

void *bitmap, *buddy;

fs/ext4/mballoc-test.c

794

bitmap = kunit_kzalloc(test, sb->s_blocksize, GFP_KERNEL);

fs/ext4/mballoc-test.c

795

KUNIT_ASSERT_NOT_ERR_OR_NULL(test, bitmap);

fs/ext4/mballoc-test.c

811

ranges[i].len, bitmap, buddy, grp);

fs/ext4/mballoc-test.c

818

ext4_grpblk_t start, ext4_grpblk_t len, void *bitmap,

fs/ext4/mballoc-test.c

832

mb_clear_bits_test(bitmap, start, len);

fs/ext4/mballoc-test.c

838

ext4_mb_generate_buddy_test(sb, buddy, bitmap, 0, grp);

fs/ext4/mballoc-test.c

850

void *bitmap, *buddy;

fs/ext4/mballoc-test.c

861

bitmap = kunit_kzalloc(test, sb->s_blocksize, GFP_KERNEL);

fs/ext4/mballoc-test.c

862

KUNIT_ASSERT_NOT_ERR_OR_NULL(test, bitmap);

fs/ext4/mballoc-test.c

883

memset(bitmap, 0xff, sb->s_blocksize);

fs/ext4/mballoc-test.c

888

ranges[i].len, bitmap, buddy, grp);

fs/ext4/mballoc.c

1282

void *buddy, void *bitmap, ext4_group_t group,

fs/ext4/mballoc.c

1296

i = mb_find_next_zero_bit(bitmap, max, 0);

fs/ext4/mballoc.c

1301

i = mb_find_next_bit(bitmap, max, i);

fs/ext4/mballoc.c

1309

i = mb_find_next_zero_bit(bitmap, max, i);

fs/ext4/mballoc.c

1388

char *bitmap;

fs/ext4/mballoc.c

1472

bitmap = bh[group - first_group]->b_data;

fs/ext4/mballoc.c

1511

memcpy(data, bitmap, blocksize);

fs/ext4/mballoc.c

1928

static inline int mb_buddy_adjust_border(int* bit, void* bitmap, int side)

fs/ext4/mballoc.c

1930

if (mb_test_bit(*bit + side, bitmap)) {

fs/ext4/mballoc.c

1931

mb_clear_bit(*bit, bitmap);

fs/ext4/mballoc.c

1937

mb_set_bit(*bit, bitmap);

fs/ext4/mballoc.c

2561

void *bitmap = e4b->bd_bitmap;

fs/ext4/mballoc.c

2573

i = mb_find_next_zero_bit(bitmap,

fs/ext4/mballoc.c

2597

j = mb_find_next_bit(bitmap,

fs/ext4/mballoc.c

2645

void *bitmap = e4b->bd_bitmap;

fs/ext4/mballoc.c

2664

if (!mb_test_bit(i, bitmap)) {

fs/ext4/mballoc.c

424

static void ext4_mb_generate_from_pa(struct super_block *sb, void *bitmap,

fs/ext4/mballoc.c

5087

void ext4_mb_generate_from_pa(struct super_block *sb, void *bitmap,

fs/ext4/mballoc.c

5119

mb_set_bits(bitmap, start, len);

fs/ext4/mballoc.c

598

static void mb_cmp_bitmaps(struct ext4_buddy *e4b, void *bitmap)

fs/ext4/mballoc.c

602

if (memcmp(e4b->bd_info->bb_bitmap, bitmap, e4b->bd_sb->s_blocksize)) {

fs/ext4/mballoc.c

606

b2 = (unsigned char *) bitmap;

fs/ext4/mballoc.c

656

static inline void mb_cmp_bitmaps(struct ext4_buddy *e4b, void *bitmap)

fs/ext4/mballoc.c

6932

void *bitmap;

fs/ext4/mballoc.c

6938

bitmap = e4b->bd_bitmap;

fs/ext4/mballoc.c

6947

start = mb_find_next_zero_bit(bitmap, max + 1, start);

fs/ext4/mballoc.c

6951

next = mb_find_next_bit(bitmap, last + 1, start);

fs/ext4/mballoc.c

7144

void *bitmap;

fs/ext4/mballoc.c

7152

bitmap = e4b.bd_bitmap;

fs/ext4/mballoc.c

7170

start = mb_find_next_zero_bit(bitmap, end + 1, start);

fs/ext4/mballoc.c

7173

next = mb_find_next_bit(bitmap, end + 1, start);

fs/ext4/mballoc.c

7244

void *bitmap, ext4_group_t group,

fs/ext4/mballoc.c

7247

ext4_mb_generate_buddy(sb, buddy, bitmap, group, grp);

fs/ext4/mballoc.h

293

void *buddy, void *bitmap, ext4_group_t group,

fs/f2fs/dir.c

239

if (!test_bit_le(bit_pos, d->bitmap)) {

fs/f2fs/dir.c

621

int f2fs_room_for_filename(const void *bitmap, int slots, int max_slots)

fs/f2fs/dir.c

626

zero_start = find_next_zero_bit_le(bitmap, max_slots, bit_start);

fs/f2fs/dir.c

630

zero_end = find_next_bit_le(bitmap, max_slots, zero_start);

fs/f2fs/dir.c

650

bit_pos = f2fs_room_for_filename(d.bitmap, slots, d.max);

fs/f2fs/dir.c

670

__set_bit_le(bit_pos + i, (void *)d->bitmap);

fs/f2fs/dir.c

992

bit_pos = find_next_bit_le(d->bitmap, d->max, bit_pos);

fs/f2fs/f2fs.h

3858

int f2fs_room_for_filename(const void *bitmap, int slots, int max_slots);

fs/f2fs/f2fs.h

651

void *bitmap;

fs/f2fs/f2fs.h

664

d->bitmap = t->dentry_bitmap;

fs/f2fs/f2fs.h

679

d->bitmap = t;

fs/f2fs/inline.c

455

memcpy(dst.bitmap, src.bitmap, src.nr_bitmap);

fs/f2fs/inline.c

499

if (!test_bit_le(bit_pos, d.bitmap)) {

fs/f2fs/inline.c

656

bit_pos = f2fs_room_for_filename(d.bitmap, slots, d.max);

fs/f2fs/inline.c

719

__clear_bit_le(bit_pos + i, d.bitmap);

fs/f2fs/inline.c

746

bit_pos = find_next_bit_le(d.bitmap, d.max, bit_pos);

fs/f2fs/segment.c

4648

unsigned long *bitmap = SIT_I(sbi)->dirty_sentries_bitmap;

fs/f2fs/segment.c

4651

for_each_set_bit(segno, bitmap, MAIN_SEGS(sbi))

fs/f2fs/segment.c

4683

unsigned long *bitmap = sit_i->dirty_sentries_bitmap;

fs/f2fs/segment.c

4737

for_each_set_bit_from(segno, bitmap, end) {

fs/f2fs/segment.c

4777

__clear_bit(segno, bitmap);

fs/f2fs/segment.c

4812

char *src_bitmap, *bitmap;

fs/f2fs/segment.c

4841

sit_i->bitmap = f2fs_kvzalloc(sbi, bitmap_size, GFP_KERNEL);

fs/f2fs/segment.c

4842

if (!sit_i->bitmap)

fs/f2fs/segment.c

4845

bitmap = sit_i->bitmap;

fs/f2fs/segment.c

4848

sit_i->sentries[start].cur_valid_map = bitmap;

fs/f2fs/segment.c

4849

bitmap += SIT_VBLOCK_MAP_SIZE;

fs/f2fs/segment.c

4851

sit_i->sentries[start].ckpt_valid_map = bitmap;

fs/f2fs/segment.c

4852

bitmap += SIT_VBLOCK_MAP_SIZE;

fs/f2fs/segment.c

4855

sit_i->sentries[start].cur_valid_map_mir = bitmap;

fs/f2fs/segment.c

4856

bitmap += SIT_VBLOCK_MAP_SIZE;

fs/f2fs/segment.c

4860

sit_i->sentries[start].discard_map = bitmap;

fs/f2fs/segment.c

4861

bitmap += SIT_VBLOCK_MAP_SIZE;

fs/f2fs/segment.c

5847

kvfree(sit_i->bitmap);

fs/f2fs/segment.h

209

char *bitmap; /* all bitmaps pointer */

fs/hfs/bitmap.c

108

*max = (curr - bitmap) * 32 + i - start;

fs/hfs/bitmap.c

141

void *bitmap;

fs/hfs/bitmap.c

149

bitmap = HFS_SB(sb)->bitmap;

fs/hfs/bitmap.c

151

pos = hfs_find_set_zero_bits(bitmap, HFS_SB(sb)->fs_ablocks, goal, num_bits);

fs/hfs/bitmap.c

154

pos = hfs_find_set_zero_bits(bitmap, goal, 0, num_bits);

fs/hfs/bitmap.c

210

curr = HFS_SB(sb)->bitmap + (start / 32);

fs/hfs/bitmap.c

29

static u32 hfs_find_set_zero_bits(__be32 *bitmap, u32 size, u32 offset, u32 *max)

fs/hfs/bitmap.c

40

curr = bitmap + (offset / 32);

fs/hfs/bitmap.c

41

end = bitmap + ((size + 31) / 32);

fs/hfs/bitmap.c

70

start = (curr - bitmap) * 32 + i;

fs/hfs/hfs_fs.h

77

__be32 *bitmap; /* The page holding the

fs/hfs/mdb.c

204

HFS_SB(sb)->bitmap = kzalloc(8192, GFP_KERNEL);

fs/hfs/mdb.c

205

if (!HFS_SB(sb)->bitmap)

fs/hfs/mdb.c

212

ptr = (u8 *)HFS_SB(sb)->bitmap;

fs/hfs/mdb.c

342

ptr = (u8 *)HFS_SB(sb)->bitmap;

fs/hfs/mdb.c

393

kfree(HFS_SB(sb)->bitmap);

fs/jfs/jfs_imap.c

853

u32 bitmap, mask;

fs/jfs/jfs_imap.c

927

bitmap = le32_to_cpu(iagp->wmap[extno]) & ~mask;

fs/jfs/jfs_imap.c

940

if (bitmap ||

fs/jfs/jfs_imap.c

998

iagp->wmap[extno] = cpu_to_le32(bitmap);

fs/nfs/callback.h

49

uint32_t bitmap[3];

fs/nfs/callback.h

54

uint32_t bitmap[3];

fs/nfs/callback_proc.c

40

memset(res->bitmap, 0, sizeof(res->bitmap));

fs/nfs/callback_proc.c

71

res->bitmap[0] = (FATTR4_WORD0_CHANGE | FATTR4_WORD0_SIZE) &

fs/nfs/callback_proc.c

72

args->bitmap[0];

fs/nfs/callback_proc.c

73

res->bitmap[1] = (FATTR4_WORD1_TIME_ACCESS |

fs/nfs/callback_proc.c

75

FATTR4_WORD1_TIME_MODIFY) & args->bitmap[1];

fs/nfs/callback_proc.c

76

res->bitmap[2] = (FATTR4_WORD2_TIME_DELEG_ACCESS |

fs/nfs/callback_proc.c

77

FATTR4_WORD2_TIME_DELEG_MODIFY) & args->bitmap[2];

fs/nfs/callback_xdr.c

104

static __be32 decode_bitmap(struct xdr_stream *xdr, uint32_t *bitmap)

fs/nfs/callback_xdr.c

117

bitmap[0] = ntohl(*p++);

fs/nfs/callback_xdr.c

119

bitmap[1] = ntohl(*p++);

fs/nfs/callback_xdr.c

121

bitmap[2] = ntohl(*p);

fs/nfs/callback_xdr.c

186

return decode_bitmap(xdr, args->bitmap);

fs/nfs/callback_xdr.c

448

uint32_t bitmap[3];

fs/nfs/callback_xdr.c

455

status = decode_bitmap(xdr, bitmap);

fs/nfs/callback_xdr.c

458

args->craa_type_mask = bitmap[0];

fs/nfs/callback_xdr.c

592

static __be32 encode_attr_bitmap(struct xdr_stream *xdr, const uint32_t *bitmap, size_t sz)

fs/nfs/callback_xdr.c

594

if (xdr_stream_encode_uint32_array(xdr, bitmap, sz) < 0)

fs/nfs/callback_xdr.c

599

static __be32 encode_attr_change(struct xdr_stream *xdr, const uint32_t *bitmap, uint64_t change)

fs/nfs/callback_xdr.c

603

if (!(bitmap[0] & FATTR4_WORD0_CHANGE))

fs/nfs/callback_xdr.c

612

static __be32 encode_attr_size(struct xdr_stream *xdr, const uint32_t *bitmap, uint64_t size)

fs/nfs/callback_xdr.c

616

if (!(bitmap[0] & FATTR4_WORD0_SIZE))

fs/nfs/callback_xdr.c

637

static __be32 encode_attr_atime(struct xdr_stream *xdr, const uint32_t *bitmap, const struct timespec64 *time)

fs/nfs/callback_xdr.c

639

if (!(bitmap[1] & FATTR4_WORD1_TIME_ACCESS))

fs/nfs/callback_xdr.c

644

static __be32 encode_attr_ctime(struct xdr_stream *xdr, const uint32_t *bitmap, const struct timespec64 *time)

fs/nfs/callback_xdr.c

646

if (!(bitmap[1] & FATTR4_WORD1_TIME_METADATA))

fs/nfs/callback_xdr.c

651

static __be32 encode_attr_mtime(struct xdr_stream *xdr, const uint32_t *bitmap, const struct timespec64 *time)

fs/nfs/callback_xdr.c

653

if (!(bitmap[1] & FATTR4_WORD1_TIME_MODIFY))

fs/nfs/callback_xdr.c

659

const uint32_t *bitmap,

fs/nfs/callback_xdr.c

662

if (!(bitmap[2] & FATTR4_WORD2_TIME_DELEG_ACCESS))

fs/nfs/callback_xdr.c

668

const uint32_t *bitmap,

fs/nfs/callback_xdr.c

671

if (!(bitmap[2] & FATTR4_WORD2_TIME_DELEG_MODIFY))

fs/nfs/callback_xdr.c

713

status = encode_attr_bitmap(xdr, res->bitmap, ARRAY_SIZE(res->bitmap));

fs/nfs/callback_xdr.c

720

status = encode_attr_change(xdr, res->bitmap, res->change_attr);

fs/nfs/callback_xdr.c

723

status = encode_attr_size(xdr, res->bitmap, res->size);

fs/nfs/callback_xdr.c

726

status = encode_attr_atime(xdr, res->bitmap, &res->atime);

fs/nfs/callback_xdr.c

729

status = encode_attr_ctime(xdr, res->bitmap, &res->ctime);

fs/nfs/callback_xdr.c

732

status = encode_attr_mtime(xdr, res->bitmap, &res->mtime);

fs/nfs/callback_xdr.c

735

status = encode_attr_delegatime(xdr, res->bitmap, &res->atime);

fs/nfs/callback_xdr.c

738

status = encode_attr_delegmtime(xdr, res->bitmap, &res->mtime);

fs/nfs/nfs4xdr.c

1001

ret = xdr_stream_encode_uint32_array(xdr, bitmap, len);

fs/nfs/nfs4xdr.c

1007

static size_t mask_bitmap4(const __u32 *bitmap, const __u32 *mask,

fs/nfs/nfs4xdr.c

1013

while (len > 0 && (bitmap[len-1] == 0 || mask[len-1] == 0))

fs/nfs/nfs4xdr.c

1016

tmp = bitmap[i] & mask[i];

fs/nfs/nfs4xdr.c

1258

const __u32 *bitmap, const __u32 *mask, size_t len,

fs/nfs/nfs4xdr.c

1267

len = mask_bitmap4(bitmap, mask, masked_bitmap, len);

fs/nfs/nfs4xdr.c

1268

bitmap = masked_bitmap;

fs/nfs/nfs4xdr.c

1270

xdr_encode_bitmap4(xdr, bitmap, len);

fs/nfs/nfs4xdr.c

1696

static void nfs4_acltype_to_bitmap(enum nfs4_acl_type type, __u32 bitmap[2])

fs/nfs/nfs4xdr.c

1700

bitmap[0] = FATTR4_WORD0_ACL;

fs/nfs/nfs4xdr.c

1701

bitmap[1] = 0;

fs/nfs/nfs4xdr.c

1704

bitmap[0] = 0;

fs/nfs/nfs4xdr.c

1705

bitmap[1] = FATTR4_WORD1_DACL;

fs/nfs/nfs4xdr.c

1708

bitmap[0] = 0;

fs/nfs/nfs4xdr.c

1709

bitmap[1] = FATTR4_WORD1_SACL;

fs/nfs/nfs4xdr.c

1717

__u32 bitmap[2];

fs/nfs/nfs4xdr.c

1719

nfs4_acltype_to_bitmap(arg->acl_type, bitmap);

fs/nfs/nfs4xdr.c

1723

xdr_encode_bitmap4(xdr, bitmap, ARRAY_SIZE(bitmap));

fs/nfs/nfs4xdr.c

1747

uint32_t bitmap[3] = { 0 };

fs/nfs/nfs4xdr.c

1754

bitmap[2] |= FATTR4_WORD2_TIME_DELEG_ACCESS;

fs/nfs/nfs4xdr.c

1758

bitmap[2] |= FATTR4_WORD2_TIME_DELEG_MODIFY;

fs/nfs/nfs4xdr.c

1761

xdr_encode_bitmap4(xdr, bitmap, ARRAY_SIZE(bitmap));

fs/nfs/nfs4xdr.c

1763

if (bitmap[2] & FATTR4_WORD2_TIME_DELEG_ACCESS)

fs/nfs/nfs4xdr.c

1765

if (bitmap[2] & FATTR4_WORD2_TIME_DELEG_MODIFY)

fs/nfs/nfs4xdr.c

3309

decode_bitmap4(struct xdr_stream *xdr, uint32_t *bitmap, size_t sz)

fs/nfs/nfs4xdr.c

3313

ret = xdr_stream_decode_uint32_array(xdr, bitmap, sz);

fs/nfs/nfs4xdr.c

3321

static int decode_attr_bitmap(struct xdr_stream *xdr, uint32_t *bitmap)

fs/nfs/nfs4xdr.c

3324

ret = decode_bitmap4(xdr, bitmap, 3);

fs/nfs/nfs4xdr.c

3340

static int decode_attr_supported(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *bitmask)

fs/nfs/nfs4xdr.c

3342

if (likely(bitmap[0] & FATTR4_WORD0_SUPPORTED_ATTRS)) {

fs/nfs/nfs4xdr.c

3347

bitmap[0] &= ~FATTR4_WORD0_SUPPORTED_ATTRS;

fs/nfs/nfs4xdr.c

3355

static int decode_attr_type(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *type)

fs/nfs/nfs4xdr.c

3361

if (unlikely(bitmap[0] & (FATTR4_WORD0_TYPE - 1U)))

fs/nfs/nfs4xdr.c

3363

if (likely(bitmap[0] & FATTR4_WORD0_TYPE)) {

fs/nfs/nfs4xdr.c

3372

bitmap[0] &= ~FATTR4_WORD0_TYPE;

fs/nfs/nfs4xdr.c

3380

uint32_t *bitmap, uint32_t *type)

fs/nfs/nfs4xdr.c

3385

if (unlikely(bitmap[0] & (FATTR4_WORD0_FH_EXPIRE_TYPE - 1U)))

fs/nfs/nfs4xdr.c

3387

if (likely(bitmap[0] & FATTR4_WORD0_FH_EXPIRE_TYPE)) {

fs/nfs/nfs4xdr.c

3392

bitmap[0] &= ~FATTR4_WORD0_FH_EXPIRE_TYPE;

fs/nfs/nfs4xdr.c

3398

static int decode_attr_change(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *change)

fs/nfs/nfs4xdr.c

3404

if (unlikely(bitmap[0] & (FATTR4_WORD0_CHANGE - 1U)))

fs/nfs/nfs4xdr.c

3406

if (likely(bitmap[0] & FATTR4_WORD0_CHANGE)) {

fs/nfs/nfs4xdr.c

3411

bitmap[0] &= ~FATTR4_WORD0_CHANGE;

fs/nfs/nfs4xdr.c

3419

static int decode_attr_size(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *size)

fs/nfs/nfs4xdr.c

3425

if (unlikely(bitmap[0] & (FATTR4_WORD0_SIZE - 1U)))

fs/nfs/nfs4xdr.c

3427

if (likely(bitmap[0] & FATTR4_WORD0_SIZE)) {

fs/nfs/nfs4xdr.c

3432

bitmap[0] &= ~FATTR4_WORD0_SIZE;

fs/nfs/nfs4xdr.c

3439

static int decode_attr_link_support(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)

fs/nfs/nfs4xdr.c

3444

if (unlikely(bitmap[0] & (FATTR4_WORD0_LINK_SUPPORT - 1U)))

fs/nfs/nfs4xdr.c

3446

if (likely(bitmap[0] & FATTR4_WORD0_LINK_SUPPORT)) {

fs/nfs/nfs4xdr.c

3451

bitmap[0] &= ~FATTR4_WORD0_LINK_SUPPORT;

fs/nfs/nfs4xdr.c

3457

static int decode_attr_symlink_support(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)

fs/nfs/nfs4xdr.c

3462

if (unlikely(bitmap[0] & (FATTR4_WORD0_SYMLINK_SUPPORT - 1U)))

fs/nfs/nfs4xdr.c

3464

if (likely(bitmap[0] & FATTR4_WORD0_SYMLINK_SUPPORT)) {

fs/nfs/nfs4xdr.c

3469

bitmap[0] &= ~FATTR4_WORD0_SYMLINK_SUPPORT;

fs/nfs/nfs4xdr.c

3475

static int decode_attr_fsid(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs_fsid *fsid)

fs/nfs/nfs4xdr.c

3482

if (unlikely(bitmap[0] & (FATTR4_WORD0_FSID - 1U)))

fs/nfs/nfs4xdr.c

3484

if (likely(bitmap[0] & FATTR4_WORD0_FSID)) {

fs/nfs/nfs4xdr.c

3490

bitmap[0] &= ~FATTR4_WORD0_FSID;

fs/nfs/nfs4xdr.c

3499

static int decode_attr_lease_time(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)

fs/nfs/nfs4xdr.c

3504

if (unlikely(bitmap[0] & (FATTR4_WORD0_LEASE_TIME - 1U)))

fs/nfs/nfs4xdr.c

3506

if (likely(bitmap[0] & FATTR4_WORD0_LEASE_TIME)) {

fs/nfs/nfs4xdr.c

3511

bitmap[0] &= ~FATTR4_WORD0_LEASE_TIME;

fs/nfs/nfs4xdr.c

3517

static int decode_attr_error(struct xdr_stream *xdr, uint32_t *bitmap, int32_t *res)

fs/nfs/nfs4xdr.c

3521

if (unlikely(bitmap[0] & (FATTR4_WORD0_RDATTR_ERROR - 1U)))

fs/nfs/nfs4xdr.c

3523

if (likely(bitmap[0] & FATTR4_WORD0_RDATTR_ERROR)) {

fs/nfs/nfs4xdr.c

3527

bitmap[0] &= ~FATTR4_WORD0_RDATTR_ERROR;

fs/nfs/nfs4xdr.c

3534

uint32_t *bitmap, uint32_t *bitmask)

fs/nfs/nfs4xdr.c

3536

if (likely(bitmap[2] & FATTR4_WORD2_SUPPATTR_EXCLCREAT)) {

fs/nfs/nfs4xdr.c

3541

bitmap[2] &= ~FATTR4_WORD2_SUPPATTR_EXCLCREAT;

fs/nfs/nfs4xdr.c

3549

static int decode_attr_filehandle(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs_fh *fh)

fs/nfs/nfs4xdr.c

3557

if (unlikely(bitmap[0] & (FATTR4_WORD0_FILEHANDLE - 1U)))

fs/nfs/nfs4xdr.c

3559

if (likely(bitmap[0] & FATTR4_WORD0_FILEHANDLE)) {

fs/nfs/nfs4xdr.c

3576

bitmap[0] &= ~FATTR4_WORD0_FILEHANDLE;

fs/nfs/nfs4xdr.c

3581

static int decode_attr_aclsupport(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)

fs/nfs/nfs4xdr.c

3586

if (unlikely(bitmap[0] & (FATTR4_WORD0_ACLSUPPORT - 1U)))

fs/nfs/nfs4xdr.c

3588

if (likely(bitmap[0] & FATTR4_WORD0_ACLSUPPORT)) {

fs/nfs/nfs4xdr.c

3593

bitmap[0] &= ~FATTR4_WORD0_ACLSUPPORT;

fs/nfs/nfs4xdr.c

3599

static int decode_attr_case_insensitive(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)

fs/nfs/nfs4xdr.c

3604

if (unlikely(bitmap[0] & (FATTR4_WORD0_CASE_INSENSITIVE - 1U)))

fs/nfs/nfs4xdr.c

3606

if (likely(bitmap[0] & FATTR4_WORD0_CASE_INSENSITIVE)) {

fs/nfs/nfs4xdr.c

3611

bitmap[0] &= ~FATTR4_WORD0_CASE_INSENSITIVE;

fs/nfs/nfs4xdr.c

3617

static int decode_attr_case_preserving(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)

fs/nfs/nfs4xdr.c

3622

if (unlikely(bitmap[0] & (FATTR4_WORD0_CASE_PRESERVING - 1U)))

fs/nfs/nfs4xdr.c

3624

if (likely(bitmap[0] & FATTR4_WORD0_CASE_PRESERVING)) {

fs/nfs/nfs4xdr.c

3629

bitmap[0] &= ~FATTR4_WORD0_CASE_PRESERVING;

fs/nfs/nfs4xdr.c

3635

static int decode_attr_fileid(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *fileid)

fs/nfs/nfs4xdr.c

3641

if (unlikely(bitmap[0] & (FATTR4_WORD0_FILEID - 1U)))

fs/nfs/nfs4xdr.c

3643

if (likely(bitmap[0] & FATTR4_WORD0_FILEID)) {

fs/nfs/nfs4xdr.c

3648

bitmap[0] &= ~FATTR4_WORD0_FILEID;

fs/nfs/nfs4xdr.c

3655

static int decode_attr_mounted_on_fileid(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *fileid)

fs/nfs/nfs4xdr.c

3661

if (unlikely(bitmap[1] & (FATTR4_WORD1_MOUNTED_ON_FILEID - 1U)))

fs/nfs/nfs4xdr.c

3663

if (likely(bitmap[1] & FATTR4_WORD1_MOUNTED_ON_FILEID)) {

fs/nfs/nfs4xdr.c

3668

bitmap[1] &= ~FATTR4_WORD1_MOUNTED_ON_FILEID;

fs/nfs/nfs4xdr.c

3675

static int decode_attr_files_avail(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)

fs/nfs/nfs4xdr.c

3681

if (unlikely(bitmap[0] & (FATTR4_WORD0_FILES_AVAIL - 1U)))

fs/nfs/nfs4xdr.c

3683

if (likely(bitmap[0] & FATTR4_WORD0_FILES_AVAIL)) {

fs/nfs/nfs4xdr.c

3688

bitmap[0] &= ~FATTR4_WORD0_FILES_AVAIL;

fs/nfs/nfs4xdr.c

3694

static int decode_attr_files_free(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)

fs/nfs/nfs4xdr.c

3700

if (unlikely(bitmap[0] & (FATTR4_WORD0_FILES_FREE - 1U)))

fs/nfs/nfs4xdr.c

3702

if (likely(bitmap[0] & FATTR4_WORD0_FILES_FREE)) {

fs/nfs/nfs4xdr.c

3707

bitmap[0] &= ~FATTR4_WORD0_FILES_FREE;

fs/nfs/nfs4xdr.c

3713

static int decode_attr_files_total(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)

fs/nfs/nfs4xdr.c

3719

if (unlikely(bitmap[0] & (FATTR4_WORD0_FILES_TOTAL - 1U)))

fs/nfs/nfs4xdr.c

3721

if (likely(bitmap[0] & FATTR4_WORD0_FILES_TOTAL)) {

fs/nfs/nfs4xdr.c

3726

bitmap[0] &= ~FATTR4_WORD0_FILES_TOTAL;

fs/nfs/nfs4xdr.c

3774

static int decode_attr_fs_locations(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs4_fs_locations *res)

fs/nfs/nfs4xdr.c

3780

if (unlikely(bitmap[0] & (FATTR4_WORD0_FS_LOCATIONS -1U)))

fs/nfs/nfs4xdr.c

3783

if (unlikely(!(bitmap[0] & FATTR4_WORD0_FS_LOCATIONS)))

fs/nfs/nfs4xdr.c

3785

bitmap[0] &= ~FATTR4_WORD0_FS_LOCATIONS;

fs/nfs/nfs4xdr.c

3850

static int decode_attr_maxfilesize(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)

fs/nfs/nfs4xdr.c

3856

if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXFILESIZE - 1U)))

fs/nfs/nfs4xdr.c

3858

if (likely(bitmap[0] & FATTR4_WORD0_MAXFILESIZE)) {

fs/nfs/nfs4xdr.c

3863

bitmap[0] &= ~FATTR4_WORD0_MAXFILESIZE;

fs/nfs/nfs4xdr.c

3869

static int decode_attr_maxlink(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *maxlink)

fs/nfs/nfs4xdr.c

3875

if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXLINK - 1U)))

fs/nfs/nfs4xdr.c

3877

if (likely(bitmap[0] & FATTR4_WORD0_MAXLINK)) {

fs/nfs/nfs4xdr.c

3882

bitmap[0] &= ~FATTR4_WORD0_MAXLINK;

fs/nfs/nfs4xdr.c

3888

static int decode_attr_maxname(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *maxname)

fs/nfs/nfs4xdr.c

3894

if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXNAME - 1U)))

fs/nfs/nfs4xdr.c

3896

if (likely(bitmap[0] & FATTR4_WORD0_MAXNAME)) {

fs/nfs/nfs4xdr.c

3901

bitmap[0] &= ~FATTR4_WORD0_MAXNAME;

fs/nfs/nfs4xdr.c

3907

static int decode_attr_maxread(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)

fs/nfs/nfs4xdr.c

3913

if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXREAD - 1U)))

fs/nfs/nfs4xdr.c

3915

if (likely(bitmap[0] & FATTR4_WORD0_MAXREAD)) {

fs/nfs/nfs4xdr.c

3924

bitmap[0] &= ~FATTR4_WORD0_MAXREAD;

fs/nfs/nfs4xdr.c

3930

static int decode_attr_maxwrite(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)

fs/nfs/nfs4xdr.c

3936

if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXWRITE - 1U)))

fs/nfs/nfs4xdr.c

3938

if (likely(bitmap[0] & FATTR4_WORD0_MAXWRITE)) {

fs/nfs/nfs4xdr.c

3947

bitmap[0] &= ~FATTR4_WORD0_MAXWRITE;

fs/nfs/nfs4xdr.c

3953

static int decode_attr_mode(struct xdr_stream *xdr, uint32_t *bitmap, umode_t *mode)

fs/nfs/nfs4xdr.c

3960

if (unlikely(bitmap[1] & (FATTR4_WORD1_MODE - 1U)))

fs/nfs/nfs4xdr.c

3962

if (likely(bitmap[1] & FATTR4_WORD1_MODE)) {

fs/nfs/nfs4xdr.c

3968

bitmap[1] &= ~FATTR4_WORD1_MODE;

fs/nfs/nfs4xdr.c

3975

static int decode_attr_nlink(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *nlink)

fs/nfs/nfs4xdr.c

3981

if (unlikely(bitmap[1] & (FATTR4_WORD1_NUMLINKS - 1U)))

fs/nfs/nfs4xdr.c

3983

if (likely(bitmap[1] & FATTR4_WORD1_NUMLINKS)) {

fs/nfs/nfs4xdr.c

3988

bitmap[1] &= ~FATTR4_WORD1_NUMLINKS;

fs/nfs/nfs4xdr.c

4008

static int decode_attr_owner(struct xdr_stream *xdr, uint32_t *bitmap,

fs/nfs/nfs4xdr.c

4016

if (unlikely(bitmap[1] & (FATTR4_WORD1_OWNER - 1U)))

fs/nfs/nfs4xdr.c

4018

if (!(bitmap[1] & FATTR4_WORD1_OWNER))

fs/nfs/nfs4xdr.c

4020

bitmap[1] &= ~FATTR4_WORD1_OWNER;

fs/nfs/nfs4xdr.c

4042

static int decode_attr_group(struct xdr_stream *xdr, uint32_t *bitmap,

fs/nfs/nfs4xdr.c

4050

if (unlikely(bitmap[1] & (FATTR4_WORD1_OWNER_GROUP - 1U)))

fs/nfs/nfs4xdr.c

4052

if (!(bitmap[1] & FATTR4_WORD1_OWNER_GROUP))

fs/nfs/nfs4xdr.c

4054

bitmap[1] &= ~FATTR4_WORD1_OWNER_GROUP;

fs/nfs/nfs4xdr.c

4076

static int decode_attr_rdev(struct xdr_stream *xdr, uint32_t *bitmap, dev_t *rdev)

fs/nfs/nfs4xdr.c

4083

if (unlikely(bitmap[1] & (FATTR4_WORD1_RAWDEV - 1U)))

fs/nfs/nfs4xdr.c

4085

if (likely(bitmap[1] & FATTR4_WORD1_RAWDEV)) {

fs/nfs/nfs4xdr.c

4096

bitmap[1] &= ~ FATTR4_WORD1_RAWDEV;

fs/nfs/nfs4xdr.c

4103

static int decode_attr_space_avail(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)

fs/nfs/nfs4xdr.c

4109

if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_AVAIL - 1U)))

fs/nfs/nfs4xdr.c

4111

if (likely(bitmap[1] & FATTR4_WORD1_SPACE_AVAIL)) {

fs/nfs/nfs4xdr.c

4116

bitmap[1] &= ~FATTR4_WORD1_SPACE_AVAIL;

fs/nfs/nfs4xdr.c

4122

static int decode_attr_space_free(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)

fs/nfs/nfs4xdr.c

4128

if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_FREE - 1U)))

fs/nfs/nfs4xdr.c

4130

if (likely(bitmap[1] & FATTR4_WORD1_SPACE_FREE)) {

fs/nfs/nfs4xdr.c

4135

bitmap[1] &= ~FATTR4_WORD1_SPACE_FREE;

fs/nfs/nfs4xdr.c

4141

static int decode_attr_space_total(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)

fs/nfs/nfs4xdr.c

4147

if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_TOTAL - 1U)))

fs/nfs/nfs4xdr.c

4149

if (likely(bitmap[1] & FATTR4_WORD1_SPACE_TOTAL)) {

fs/nfs/nfs4xdr.c

4154

bitmap[1] &= ~FATTR4_WORD1_SPACE_TOTAL;

fs/nfs/nfs4xdr.c

4160

static int decode_attr_space_used(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *used)

fs/nfs/nfs4xdr.c

4166

if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_USED - 1U)))

fs/nfs/nfs4xdr.c

4168

if (likely(bitmap[1] & FATTR4_WORD1_SPACE_USED)) {

fs/nfs/nfs4xdr.c

4173

bitmap[1] &= ~FATTR4_WORD1_SPACE_USED;

fs/nfs/nfs4xdr.c

4203

static int decode_attr_time_access(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec64 *time)

fs/nfs/nfs4xdr.c

4209

if (unlikely(bitmap[1] & (FATTR4_WORD1_TIME_ACCESS - 1U)))

fs/nfs/nfs4xdr.c

4211

if (likely(bitmap[1] & FATTR4_WORD1_TIME_ACCESS)) {

fs/nfs/nfs4xdr.c

4215

bitmap[1] &= ~FATTR4_WORD1_TIME_ACCESS;

fs/nfs/nfs4xdr.c

4221

static int decode_attr_time_create(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec64 *time)

fs/nfs/nfs4xdr.c

4227

if (unlikely(bitmap[1] & (FATTR4_WORD1_TIME_CREATE - 1U)))

fs/nfs/nfs4xdr.c

4229

if (likely(bitmap[1] & FATTR4_WORD1_TIME_CREATE)) {

fs/nfs/nfs4xdr.c

4233

bitmap[1] &= ~FATTR4_WORD1_TIME_CREATE;

fs/nfs/nfs4xdr.c

4239

static int decode_attr_time_metadata(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec64 *time)

fs/nfs/nfs4xdr.c

4245

if (unlikely(bitmap[1] & (FATTR4_WORD1_TIME_METADATA - 1U)))

fs/nfs/nfs4xdr.c

4247

if (likely(bitmap[1] & FATTR4_WORD1_TIME_METADATA)) {

fs/nfs/nfs4xdr.c

4251

bitmap[1] &= ~FATTR4_WORD1_TIME_METADATA;

fs/nfs/nfs4xdr.c

4257

static int decode_attr_time_delta(struct xdr_stream *xdr, uint32_t *bitmap,

fs/nfs/nfs4xdr.c

4264

if (unlikely(bitmap[1] & (FATTR4_WORD1_TIME_DELTA - 1U)))

fs/nfs/nfs4xdr.c

4266

if (likely(bitmap[1] & FATTR4_WORD1_TIME_DELTA)) {

fs/nfs/nfs4xdr.c

4268

bitmap[1] &= ~FATTR4_WORD1_TIME_DELTA;

fs/nfs/nfs4xdr.c

4275

static int decode_attr_security_label(struct xdr_stream *xdr, uint32_t *bitmap,

fs/nfs/nfs4xdr.c

4284

if (unlikely(bitmap[2] & (FATTR4_WORD2_SECURITY_LABEL - 1U)))

fs/nfs/nfs4xdr.c

4286

if (likely(bitmap[2] & FATTR4_WORD2_SECURITY_LABEL)) {

fs/nfs/nfs4xdr.c

4302

bitmap[2] &= ~FATTR4_WORD2_SECURITY_LABEL;

fs/nfs/nfs4xdr.c

4324

static int decode_attr_time_modify(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec64 *time)

fs/nfs/nfs4xdr.c

4330

if (unlikely(bitmap[1] & (FATTR4_WORD1_TIME_MODIFY - 1U)))

fs/nfs/nfs4xdr.c

4332

if (likely(bitmap[1] & FATTR4_WORD1_TIME_MODIFY)) {

fs/nfs/nfs4xdr.c

4336

bitmap[1] &= ~FATTR4_WORD1_TIME_MODIFY;

fs/nfs/nfs4xdr.c

4342

static int decode_attr_xattrsupport(struct xdr_stream *xdr, uint32_t *bitmap,

fs/nfs/nfs4xdr.c

4348

if (unlikely(bitmap[2] & (FATTR4_WORD2_XATTR_SUPPORT - 1U)))

fs/nfs/nfs4xdr.c

4350

if (likely(bitmap[2] & FATTR4_WORD2_XATTR_SUPPORT)) {

fs/nfs/nfs4xdr.c

4355

bitmap[2] &= ~FATTR4_WORD2_XATTR_SUPPORT;

fs/nfs/nfs4xdr.c

4361

static int decode_attr_open_arguments(struct xdr_stream *xdr, uint32_t *bitmap,

fs/nfs/nfs4xdr.c

4365

if (unlikely(bitmap[2] & (FATTR4_WORD2_OPEN_ARGUMENTS - 1U)))

fs/nfs/nfs4xdr.c

4367

if (likely(bitmap[2] & FATTR4_WORD2_OPEN_ARGUMENTS)) {

fs/nfs/nfs4xdr.c

4378

bitmap[2] &= ~FATTR4_WORD2_OPEN_ARGUMENTS;

fs/nfs/nfs4xdr.c

4522

uint32_t attrlen, bitmap[3] = {0};

fs/nfs/nfs4xdr.c

4527

if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)

fs/nfs/nfs4xdr.c

4531

if ((status = decode_attr_supported(xdr, bitmap, res->attr_bitmask)) != 0)

fs/nfs/nfs4xdr.c

4533

if ((status = decode_attr_fh_expire_type(xdr, bitmap,

fs/nfs/nfs4xdr.c

4536

if ((status = decode_attr_link_support(xdr, bitmap, &res->has_links)) != 0)

fs/nfs/nfs4xdr.c

4538

if ((status = decode_attr_symlink_support(xdr, bitmap, &res->has_symlinks)) != 0)

fs/nfs/nfs4xdr.c

4540

if ((status = decode_attr_aclsupport(xdr, bitmap, &res->acl_bitmask)) != 0)

fs/nfs/nfs4xdr.c

4542

if ((status = decode_attr_case_insensitive(xdr, bitmap, &res->case_insensitive)) != 0)

fs/nfs/nfs4xdr.c

4544

if ((status = decode_attr_case_preserving(xdr, bitmap, &res->case_preserving)) != 0)

fs/nfs/nfs4xdr.c

4546

if ((status = decode_attr_exclcreat_supported(xdr, bitmap,

fs/nfs/nfs4xdr.c

4549

if ((status = decode_attr_open_arguments(xdr, bitmap, &res->open_caps)) != 0)

fs/nfs/nfs4xdr.c

4560

uint32_t attrlen, bitmap[3] = {0};

fs/nfs/nfs4xdr.c

4565

if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)

fs/nfs/nfs4xdr.c

4570

if ((status = decode_attr_files_avail(xdr, bitmap, &fsstat->afiles)) != 0)

fs/nfs/nfs4xdr.c

4572

if ((status = decode_attr_files_free(xdr, bitmap, &fsstat->ffiles)) != 0)

fs/nfs/nfs4xdr.c

4574

if ((status = decode_attr_files_total(xdr, bitmap, &fsstat->tfiles)) != 0)

fs/nfs/nfs4xdr.c

4578

if (unlikely(bitmap[0]))

fs/nfs/nfs4xdr.c

4581

if ((status = decode_attr_space_avail(xdr, bitmap, &fsstat->abytes)) != 0)

fs/nfs/nfs4xdr.c

4583

if ((status = decode_attr_space_free(xdr, bitmap, &fsstat->fbytes)) != 0)

fs/nfs/nfs4xdr.c

4585

if ((status = decode_attr_space_total(xdr, bitmap, &fsstat->tbytes)) != 0)

fs/nfs/nfs4xdr.c

4597

uint32_t attrlen, bitmap[3] = {0};

fs/nfs/nfs4xdr.c

4602

if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)

fs/nfs/nfs4xdr.c

4607

if ((status = decode_attr_maxlink(xdr, bitmap, &pathconf->max_link)) != 0)

fs/nfs/nfs4xdr.c

4609

if ((status = decode_attr_maxname(xdr, bitmap, &pathconf->max_namelen)) != 0)

fs/nfs/nfs4xdr.c

4619

uint32_t *bitmap,

fs/nfs/nfs4xdr.c

4626

if (likely(bitmap[0] & hint_bit)) {

fs/nfs/nfs4xdr.c

4640

uint32_t bitmap[3] = {0,}, attrlen;

fs/nfs/nfs4xdr.c

4650

status = decode_attr_bitmap(xdr, bitmap);

fs/nfs/nfs4xdr.c

4659

status = decode_threshold_hint(xdr, bitmap, &res->rd_sz, THRESHOLD_RD);

fs/nfs/nfs4xdr.c

4662

status = decode_threshold_hint(xdr, bitmap, &res->wr_sz, THRESHOLD_WR);

fs/nfs/nfs4xdr.c

4665

status = decode_threshold_hint(xdr, bitmap, &res->rd_io_sz,

fs/nfs/nfs4xdr.c

4669

status = decode_threshold_hint(xdr, bitmap, &res->wr_io_sz,

fs/nfs/nfs4xdr.c

4675

res->bm = bitmap[0];

fs/nfs/nfs4xdr.c

4689

uint32_t *bitmap,

fs/nfs/nfs4xdr.c

4696

if (unlikely(bitmap[2] & (FATTR4_WORD2_MDSTHRESHOLD - 1U)))

fs/nfs/nfs4xdr.c

4698

if (bitmap[2] & FATTR4_WORD2_MDSTHRESHOLD) {

fs/nfs/nfs4xdr.c

4714

bitmap[2] &= ~FATTR4_WORD2_MDSTHRESHOLD;

fs/nfs/nfs4xdr.c

4719

static int decode_getfattr_attrs(struct xdr_stream *xdr, uint32_t *bitmap,

fs/nfs/nfs4xdr.c

4728

status = decode_attr_type(xdr, bitmap, &type);

fs/nfs/nfs4xdr.c

4737

status = decode_attr_change(xdr, bitmap, &fattr->change_attr);

fs/nfs/nfs4xdr.c

4742

status = decode_attr_size(xdr, bitmap, &fattr->size);

fs/nfs/nfs4xdr.c

4747

status = decode_attr_fsid(xdr, bitmap, &fattr->fsid);

fs/nfs/nfs4xdr.c

4753

status = decode_attr_error(xdr, bitmap, &err);

fs/nfs/nfs4xdr.c

4757

status = decode_attr_filehandle(xdr, bitmap, fh);

fs/nfs/nfs4xdr.c

4761

status = decode_attr_fileid(xdr, bitmap, &fattr->fileid);

fs/nfs/nfs4xdr.c

4766

status = decode_attr_fs_locations(xdr, bitmap, fs_loc);

fs/nfs/nfs4xdr.c

4772

if (unlikely(bitmap[0]))

fs/nfs/nfs4xdr.c

4775

status = decode_attr_mode(xdr, bitmap, &fmode);

fs/nfs/nfs4xdr.c

4783

status = decode_attr_nlink(xdr, bitmap, &fattr->nlink);

fs/nfs/nfs4xdr.c

4788

status = decode_attr_owner(xdr, bitmap, server, &fattr->uid, fattr->owner_name);

fs/nfs/nfs4xdr.c

4793

status = decode_attr_group(xdr, bitmap, server, &fattr->gid, fattr->group_name);

fs/nfs/nfs4xdr.c

4798

status = decode_attr_rdev(xdr, bitmap, &fattr->rdev);

fs/nfs/nfs4xdr.c

4803

status = decode_attr_space_used(xdr, bitmap, &fattr->du.nfs3.used);

fs/nfs/nfs4xdr.c

4808

status = decode_attr_time_access(xdr, bitmap, &fattr->atime);

fs/nfs/nfs4xdr.c

4813

status = decode_attr_time_create(xdr, bitmap, &fattr->btime);

fs/nfs/nfs4xdr.c

4818

status = decode_attr_time_metadata(xdr, bitmap, &fattr->ctime);

fs/nfs/nfs4xdr.c

4823

status = decode_attr_time_modify(xdr, bitmap, &fattr->mtime);

fs/nfs/nfs4xdr.c

4828

status = decode_attr_mounted_on_fileid(xdr, bitmap, &fattr->mounted_on_fileid);

fs/nfs/nfs4xdr.c

4834

if (unlikely(bitmap[1]))

fs/nfs/nfs4xdr.c

4837

status = decode_attr_mdsthreshold(xdr, bitmap, fattr->mdsthreshold);

fs/nfs/nfs4xdr.c

4841

status = decode_attr_security_label(xdr, bitmap, fattr->label);

fs/nfs/nfs4xdr.c

4857

bitmap[3] = {0};

fs/nfs/nfs4xdr.c

4864

status = decode_attr_bitmap(xdr, bitmap);

fs/nfs/nfs4xdr.c

4872

status = decode_getfattr_attrs(xdr, bitmap, fattr, fh, fs_loc, server);

fs/nfs/nfs4xdr.c

4927

static int decode_attr_pnfstype(struct xdr_stream *xdr, uint32_t *bitmap,

fs/nfs/nfs4xdr.c

4932

dprintk("%s: bitmap is %x\n", __func__, bitmap[1]);

fs/nfs/nfs4xdr.c

4933

if (unlikely(bitmap[1] & (FATTR4_WORD1_FS_LAYOUT_TYPES - 1U)))

fs/nfs/nfs4xdr.c

4935

if (bitmap[1] & FATTR4_WORD1_FS_LAYOUT_TYPES) {

fs/nfs/nfs4xdr.c

4937

bitmap[1] &= ~FATTR4_WORD1_FS_LAYOUT_TYPES;

fs/nfs/nfs4xdr.c

4945

static int decode_attr_layout_blksize(struct xdr_stream *xdr, uint32_t *bitmap,

fs/nfs/nfs4xdr.c

4950

dprintk("%s: bitmap is %x\n", __func__, bitmap[2]);

fs/nfs/nfs4xdr.c

4952

if (bitmap[2] & FATTR4_WORD2_LAYOUT_BLKSIZE) {

fs/nfs/nfs4xdr.c

4957

bitmap[2] &= ~FATTR4_WORD2_LAYOUT_BLKSIZE;

fs/nfs/nfs4xdr.c

4965

static int decode_attr_clone_blksize(struct xdr_stream *xdr, uint32_t *bitmap,

fs/nfs/nfs4xdr.c

4970

dprintk("%s: bitmap is %x\n", __func__, bitmap[2]);

fs/nfs/nfs4xdr.c

4972

if (bitmap[2] & FATTR4_WORD2_CLONE_BLKSIZE) {

fs/nfs/nfs4xdr.c

4977

bitmap[2] &= ~FATTR4_WORD2_CLONE_BLKSIZE;

fs/nfs/nfs4xdr.c

4983

uint32_t *bitmap,

fs/nfs/nfs4xdr.c

4988

dprintk("%s: bitmap is %x\n", __func__, bitmap[2]);

fs/nfs/nfs4xdr.c

4989

if (bitmap[2] & FATTR4_WORD2_CHANGE_ATTR_TYPE) {

fs/nfs/nfs4xdr.c

4992

bitmap[2] &= ~FATTR4_WORD2_CHANGE_ATTR_TYPE;

fs/nfs/nfs4xdr.c

5011

uint32_t attrlen, bitmap[3];

fs/nfs/nfs4xdr.c

5016

if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)

fs/nfs/nfs4xdr.c

5023

if ((status = decode_attr_lease_time(xdr, bitmap, &fsinfo->lease_time)) != 0)

fs/nfs/nfs4xdr.c

5025

if ((status = decode_attr_maxfilesize(xdr, bitmap, &fsinfo->maxfilesize)) != 0)

fs/nfs/nfs4xdr.c

5027

if ((status = decode_attr_maxread(xdr, bitmap, &fsinfo->rtmax)) != 0)

fs/nfs/nfs4xdr.c

5030

if ((status = decode_attr_maxwrite(xdr, bitmap, &fsinfo->wtmax)) != 0)

fs/nfs/nfs4xdr.c

5035

if (unlikely(bitmap[0]))

fs/nfs/nfs4xdr.c

5038

status = decode_attr_time_delta(xdr, bitmap, &fsinfo->time_delta);

fs/nfs/nfs4xdr.c

5041

status = decode_attr_pnfstype(xdr, bitmap, fsinfo);

fs/nfs/nfs4xdr.c

5046

if (unlikely(bitmap[1]))

fs/nfs/nfs4xdr.c

5049

status = decode_attr_layout_blksize(xdr, bitmap, &fsinfo->blksize);

fs/nfs/nfs4xdr.c

5052

status = decode_attr_clone_blksize(xdr, bitmap, &fsinfo->clone_blksize);

fs/nfs/nfs4xdr.c

5056

status = decode_attr_change_attr_type(xdr, bitmap,

fs/nfs/nfs4xdr.c

5061

status = decode_attr_xattrsupport(xdr, bitmap,

fs/nfs/nfs4xdr.c

5496

bitmap[3] = {0};

fs/nfs/nfs4xdr.c

5505

if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)

fs/nfs/nfs4xdr.c

5512

if (unlikely(bitmap[0] & (FATTR4_WORD0_ACL - 1U)))

fs/nfs/nfs4xdr.c

5514

if (!(bitmap[0] & FATTR4_WORD0_ACL))

fs/nfs/nfs4xdr.c

5518

if (unlikely(bitmap[0] || bitmap[1] & (FATTR4_WORD1_DACL - 1U)))

fs/nfs/nfs4xdr.c

5520

if (!(bitmap[1] & FATTR4_WORD1_DACL))

fs/nfs/nfs4xdr.c

5524

if (unlikely(bitmap[0] || bitmap[1] & (FATTR4_WORD1_SACL - 1U)))

fs/nfs/nfs4xdr.c

5526

if (!(bitmap[1] & FATTR4_WORD1_SACL))

fs/nfs/nfs4xdr.c

6007

u32 bitmap[1];

fs/nfs/nfs4xdr.c

6029

status = decode_bitmap4(xdr, bitmap, ARRAY_SIZE(bitmap));

fs/nfs/nfs4xdr.c

6034

status = decode_bitmap4(xdr, bitmap, ARRAY_SIZE(bitmap));

fs/nfs/nfs4xdr.c

6039

status = decode_bitmap4(xdr, bitmap, ARRAY_SIZE(bitmap));

fs/nfs/nfs4xdr.c

7609

uint32_t bitmap[3] = {0};

fs/nfs/nfs4xdr.c

7644

if (decode_attr_bitmap(xdr, bitmap) < 0)

fs/nfs/nfs4xdr.c

7650

if (decode_getfattr_attrs(xdr, bitmap, entry->fattr, entry->fh,

fs/nfs/nfs4xdr.c

994

const __u32 *bitmap, size_t len)

fs/nfs/nfs4xdr.c

999

while (len > 0 && bitmap[len-1] == 0)

fs/nfsd/nfs4callback.c

100

if (bitmap[0] & FATTR4_WORD0_CHANGE)

fs/nfsd/nfs4callback.c

103

if (bitmap[0] & FATTR4_WORD0_SIZE)

fs/nfsd/nfs4callback.c

106

if (bitmap[2] & FATTR4_WORD2_TIME_DELEG_ACCESS) {

fs/nfsd/nfs4callback.c

115

if (bitmap[2] & FATTR4_WORD2_TIME_DELEG_MODIFY) {

fs/nfsd/nfs4callback.c

694

u32 bitmap[3] = {0};

fs/nfsd/nfs4callback.c

710

if (xdr_stream_decode_uint32_array(xdr, bitmap, 3) < 0)

fs/nfsd/nfs4callback.c

715

if (bitmap[2] != 0)

fs/nfsd/nfs4callback.c

720

status = decode_cb_fattr4(xdr, bitmap, ncf);

fs/nfsd/nfs4callback.c

84

static void encode_bitmap4(struct xdr_stream *xdr, const __u32 *bitmap,

fs/nfsd/nfs4callback.c

87

xdr_stream_encode_uint32_array(xdr, bitmap, len);

fs/nfsd/nfs4callback.c

90

static int decode_cb_fattr4(struct xdr_stream *xdr, uint32_t *bitmap,

fs/nilfs2/alloc.c

440

static int nilfs_palloc_find_available_slot(unsigned char *bitmap,

fs/nilfs2/alloc.c

450

pos = nilfs_find_next_zero_bit(bitmap, end, pos);

fs/nilfs2/alloc.c

453

if (!nilfs_set_bit_atomic(lock, pos, bitmap))

fs/nilfs2/alloc.c

464

pos = nilfs_find_next_zero_bit(bitmap, end, pos);

fs/nilfs2/alloc.c

467

if (!nilfs_set_bit_atomic(lock, pos, bitmap))

fs/nilfs2/alloc.c

586

unsigned char *bitmap;

fs/nilfs2/alloc.c

635

bitmap = kmap_local_folio(bitmap_bh->b_folio, boff);

fs/nilfs2/alloc.c

637

bitmap, group_offset, entries_per_group, lock,

fs/nilfs2/alloc.c

645

kunmap_local(bitmap);

fs/nilfs2/alloc.c

697

unsigned char *bitmap;

fs/nilfs2/alloc.c

705

bitmap = kmap_local_folio(req->pr_bitmap_bh->b_folio, boff);

fs/nilfs2/alloc.c

708

if (!nilfs_clear_bit_atomic(lock, group_offset, bitmap))

fs/nilfs2/alloc.c

716

kunmap_local(bitmap);

fs/nilfs2/alloc.c

737

unsigned char *bitmap;

fs/nilfs2/alloc.c

746

bitmap = kmap_local_folio(req->pr_bitmap_bh->b_folio, boff);

fs/nilfs2/alloc.c

749

if (!nilfs_clear_bit_atomic(lock, group_offset, bitmap))

fs/nilfs2/alloc.c

757

kunmap_local(bitmap);

fs/nilfs2/alloc.c

825

unsigned char *bitmap;

fs/nilfs2/alloc.c

855

bitmap = kmap_local_folio(bitmap_bh->b_folio, boff);

fs/nilfs2/alloc.c

862

bitmap)) {

fs/nilfs2/alloc.c

886

pos = nilfs_find_next_bit(bitmap, end, entry_start);

fs/nilfs2/alloc.c

900

kunmap_local(bitmap);

fs/ntfs3/attrib.c

619

free = wnd_zeroes(&sbi->used.bitmap);

fs/ntfs3/bitmap.c

1424

struct wnd_bitmap *wnd = &sbi->used.bitmap;

fs/ntfs3/bitmap.c

1549

unsigned int ntfs_bitmap_weight_le(const void *bitmap, int bits)

fs/ntfs3/bitmap.c

1551

const ulong *bmp = bitmap;

fs/ntfs3/bitmap.c

1559

w += hweight_long(ul_to_cpu(((bitmap_ulong *)bitmap)[k]) &

fs/ntfs3/file.c

624

wnd_zeroes(&sbi->used.bitmap)) {

fs/ntfs3/frecord.c

1993

if (cend > wnd_zeroes(&sbi->used.bitmap)) {

fs/ntfs3/fsntfs.c

2483

struct wnd_bitmap *wnd = &sbi->used.bitmap;

fs/ntfs3/fsntfs.c

360

struct wnd_bitmap *wnd = &sbi->used.bitmap;

fs/ntfs3/fsntfs.c

459

wnd = &sbi->used.bitmap;

fs/ntfs3/fsntfs.c

488

wnd = &sbi->mft.bitmap;

fs/ntfs3/fsntfs.c

528

struct wnd_bitmap *wnd = &sbi->mft.bitmap;

fs/ntfs3/fsntfs.c

550

err = attr_set_size(ni, ATTR_BITMAP, NULL, 0, &sbi->mft.bitmap.run,

fs/ntfs3/fsntfs.c

554

down_write_nested(&sbi->used.bitmap.rw_lock, BITMAP_MUTEX_CLUSTERS);

fs/ntfs3/fsntfs.c

558

up_write(&sbi->used.bitmap.rw_lock);

fs/ntfs3/fsntfs.c

587

struct wnd_bitmap *wnd = &sbi->mft.bitmap;

fs/ntfs3/fsntfs.c

723

if (sbi->mft.next_free >= sbi->mft.bitmap.nbits) {

fs/ntfs3/fsntfs.c

725

sbi->mft.next_free = sbi->mft.bitmap.nbits;

fs/ntfs3/fsntfs.c

762

struct wnd_bitmap *wnd = &sbi->mft.bitmap;

fs/ntfs3/fsntfs.c

840

struct wnd_bitmap *wnd = &sbi->used.bitmap;

fs/ntfs3/fsntfs.c

848

(u64)sbi->mft.bitmap.nbits << sbi->record_bits);

fs/ntfs3/index.c

1438

struct ATTRIB *bitmap;

fs/ntfs3/index.c

1462

in->name, in->name_len, &bitmap, NULL, NULL);

fs/ntfs3/index.c

358

static int scan_nres_bitmap(struct ntfs_inode *ni, struct ATTRIB *bitmap,

fs/ntfs3/index.c

370

u64 valid_size = le64_to_cpu(bitmap->nres.valid_size);

fs/ntfs3/index.c

371

u64 data_size = le64_to_cpu(bitmap->nres.data_size);

fs/ntfs3/index.c

473

size_t *bit, struct ATTRIB **bitmap)

fs/ntfs3/index.c

486

*bitmap = b;

fs/ntfs3/inode.c

269

run = ino == MFT_REC_BITMAP ? &sbi->used.bitmap.run :

fs/ntfs3/inode.c

323

run = &sbi->mft.bitmap.run;

fs/ntfs3/ntfs_fs.h

261

struct wnd_bitmap bitmap; // $MFT::Bitmap

fs/ntfs3/ntfs_fs.h

276

struct wnd_bitmap bitmap; // $Bitmap::Data

fs/ntfs3/ntfs_fs.h

924

unsigned int ntfs_bitmap_weight_le(const void *bitmap, int bits);

fs/ntfs3/run.c

1062

if (lcn != SPARSE_LCN64 && lcn + len > sbi->used.bitmap.nbits) {

fs/ntfs3/run.c

1120

if (!sbi->used.bitmap.sb || !run || run == RUN_DEALLOCATE)

fs/ntfs3/run.c

1127

wnd = &sbi->used.bitmap;

fs/ntfs3/super.c

1165

sbi->used.bitmap.nbits = clusters;

fs/ntfs3/super.c

1429

err = wnd_init(&sbi->mft.bitmap, sb, tt);

fs/ntfs3/super.c

1459

tt = sbi->used.bitmap.nbits;

fs/ntfs3/super.c

1466

err = wnd_init(&sbi->used.bitmap, sb, tt);

fs/ntfs3/super.c

1502

if (wnd_set_used_safe(&sbi->used.bitmap, lcn, len, &tt) || tt) {

fs/ntfs3/super.c

499

sbi->cluster_size, sbi->used.bitmap.nbits,

fs/ntfs3/super.c

500

sbi->mft.bitmap.nbits,

fs/ntfs3/super.c

501

sbi->mft.bitmap.nbits - wnd_zeroes(&sbi->mft.bitmap),

fs/ntfs3/super.c

668

wnd_close(&sbi->mft.bitmap);

fs/ntfs3/super.c

669

wnd_close(&sbi->used.bitmap);

fs/ntfs3/super.c

738

struct wnd_bitmap *wnd = &sbi->used.bitmap;

fs/ocfs2/alloc.c

7513

void *bitmap = gd->bg_bitmap;

fs/ocfs2/alloc.c

7522

start = ocfs2_find_next_zero_bit(bitmap, max, start);

fs/ocfs2/alloc.c

7525

next = ocfs2_find_next_bit(bitmap, max, start);

fs/ocfs2/localalloc.c

723

void *bitmap;

fs/ocfs2/localalloc.c

742

bitmap = la->la_bitmap;

fs/ocfs2/localalloc.c

759

ocfs2_set_bit(start++, bitmap);

fs/ocfs2/localalloc.c

779

void *bitmap;

fs/ocfs2/localalloc.c

789

bitmap = la->la_bitmap;

fs/ocfs2/localalloc.c

803

ocfs2_clear_bit(start++, bitmap);

fs/ocfs2/localalloc.c

831

void *bitmap = NULL;

fs/ocfs2/localalloc.c

863

bitmap = OCFS2_LOCAL_ALLOC(alloc)->la_bitmap;

fs/ocfs2/localalloc.c

867

while ((bitoff = ocfs2_find_next_zero_bit(bitmap, left, startoff)) <

fs/ocfs2/localalloc.c

917

static void ocfs2_verify_zero_bits(unsigned long *bitmap,

fs/ocfs2/localalloc.c

923

if (ocfs2_test_bit(start + tmp, bitmap)) {

fs/ocfs2/localalloc.c

950

void *bitmap;

fs/ocfs2/localalloc.c

968

bitmap = la->la_bitmap;

fs/ocfs2/localalloc.c

973

bit_off = ocfs2_find_next_zero_bit(bitmap, left, start);

fs/ocfs2/ocfs2.h

930

static inline void _ocfs2_set_bit(unsigned int bit, unsigned long *bitmap)

fs/ocfs2/ocfs2.h

932

__set_bit_le(bit, bitmap);

fs/ocfs2/ocfs2.h

936

static inline void _ocfs2_clear_bit(unsigned int bit, unsigned long *bitmap)

fs/ocfs2/ocfs2.h

938

__clear_bit_le(bit, bitmap);

fs/ocfs2/ocfs2.h

960

static inline void ocfs2_set_bit_unaligned(int bit, void *bitmap)

fs/ocfs2/ocfs2.h

962

bitmap = correct_addr_and_bit_unaligned(&bit, bitmap);

fs/ocfs2/ocfs2.h

963

ocfs2_set_bit(bit, bitmap);

fs/ocfs2/ocfs2.h

966

static inline void ocfs2_clear_bit_unaligned(int bit, void *bitmap)

fs/ocfs2/ocfs2.h

968

bitmap = correct_addr_and_bit_unaligned(&bit, bitmap);

fs/ocfs2/ocfs2.h

969

ocfs2_clear_bit(bit, bitmap);

fs/ocfs2/ocfs2.h

972

static inline int ocfs2_test_bit_unaligned(int bit, void *bitmap)

fs/ocfs2/ocfs2.h

974

bitmap = correct_addr_and_bit_unaligned(&bit, bitmap);

fs/ocfs2/ocfs2.h

975

return ocfs2_test_bit(bit, bitmap);

fs/ocfs2/ocfs2.h

978

static inline int ocfs2_find_next_zero_bit_unaligned(void *bitmap, int max,

fs/ocfs2/ocfs2.h

982

bitmap = correct_addr_and_bit_unaligned(&fix, bitmap);

fs/ocfs2/ocfs2.h

986

ret = ocfs2_find_next_zero_bit(bitmap, tmpmax, start) - fix;

fs/ocfs2/reservations.c

406

void *bitmap = resmap->m_disk_bitmap;

fs/ocfs2/reservations.c

416

while ((offset = ocfs2_find_next_zero_bit(bitmap, resmap->m_bitmap_len,

fs/ocfs2/suballoc.c

1350

u16 ocfs2_find_max_contig_free_bits(void *bitmap,

fs/ocfs2/suballoc.c

1357

offset = ocfs2_find_next_zero_bit(bitmap, total_bits, start);

fs/ocfs2/suballoc.c

1361

start = ocfs2_find_next_bit(bitmap, total_bits, offset);

fs/ocfs2/suballoc.c

1376

void *bitmap;

fs/ocfs2/suballoc.c

1387

bitmap = bg->bg_bitmap;

fs/ocfs2/suballoc.c

1389

while ((offset = ocfs2_find_next_zero_bit(bitmap, total_bits, start)) <

fs/ocfs2/suballoc.c

1442

void *bitmap = bg->bg_bitmap;

fs/ocfs2/suballoc.c

1476

ocfs2_set_bit(bit_off++, bitmap);

fs/ocfs2/suballoc.c

1491

contig_bits = ocfs2_find_max_contig_free_bits(bitmap,

fs/ocfs2/suballoc.c

2839

unsigned long *bitmap))

fs/ocfs2/suballoc.c

2950

unsigned long *bitmap))

fs/ocfs2/suballoc.h

83

u16 ocfs2_find_max_contig_free_bits(void *bitmap,

fs/udf/balloc.c

120

struct udf_bitmap *bitmap,

fs/udf/balloc.c

150

bitmap_nr = load_block_bitmap(sb, bitmap, block_group);

fs/udf/balloc.c

154

bh = bitmap->s_block_bitmap[bitmap_nr];

fs/udf/balloc.c

175

struct udf_bitmap *bitmap,

fs/udf/balloc.c

198

bitmap_nr = load_block_bitmap(sb, bitmap, block_group);

fs/udf/balloc.c

201

bh = bitmap->s_block_bitmap[bitmap_nr];

fs/udf/balloc.c

223

struct udf_bitmap *bitmap, uint16_t partition,

fs/udf/balloc.c

242

nr_groups = bitmap->s_nr_groups;

fs/udf/balloc.c

247

bitmap_nr = load_block_bitmap(sb, bitmap, block_group);

fs/udf/balloc.c

250

bh = bitmap->s_block_bitmap[bitmap_nr];

fs/udf/balloc.c

286

bitmap_nr = load_block_bitmap(sb, bitmap, block_group);

fs/udf/balloc.c

289

bh = bitmap->s_block_bitmap[bitmap_nr];

fs/udf/balloc.c

32

struct udf_bitmap *bitmap, unsigned int block,

fs/udf/balloc.c

40

loc.logicalBlockNum = bitmap->s_extPosition;

fs/udf/balloc.c

44

bitmap->s_block_bitmap[bitmap_nr] = bh;

fs/udf/balloc.c

52

count = min(max_bits - off, bitmap->s_nr_groups);

fs/udf/balloc.c

59

(bitmap->s_nr_groups >> (sb->s_blocksize_bits + 3)) + 2)

fs/udf/balloc.c

62

count = bitmap->s_nr_groups - bitmap_nr * max_bits +

fs/udf/balloc.c

69

bitmap->s_block_bitmap[bitmap_nr] =

fs/udf/balloc.c

78

struct udf_bitmap *bitmap,

fs/udf/balloc.c

82

int nr_groups = bitmap->s_nr_groups;

fs/udf/balloc.c

89

if (bitmap->s_block_bitmap[block_group]) {

fs/udf/balloc.c

94

if (IS_ERR(bitmap->s_block_bitmap[block_group]))

fs/udf/balloc.c

95

return PTR_ERR(bitmap->s_block_bitmap[block_group]);

fs/udf/balloc.c

99

retval = read_block_bitmap(sb, bitmap, block_group, block_group);

fs/udf/ecma_167.h

744

uint8_t bitmap[];

fs/udf/super.c

1047

struct udf_bitmap *bitmap;

fs/udf/super.c

1050

bitmap = kvzalloc_flex(*bitmap, s_block_bitmap, nr_groups);

fs/udf/super.c

1051

if (!bitmap)

fs/udf/super.c

1054

bitmap->s_nr_groups = nr_groups;

fs/udf/super.c

1055

return bitmap;

fs/udf/super.c

1174

struct udf_bitmap *bitmap = udf_sb_alloc_bitmap(sb, p_index);

fs/udf/super.c

1175

if (!bitmap)

fs/udf/super.c

1177

map->s_uspace.s_bitmap = bitmap;

fs/udf/super.c

1178

bitmap->s_extPosition = le32_to_cpu(

fs/udf/super.c

1190

p_index, bitmap->s_extPosition);

fs/udf/super.c

2433

struct udf_bitmap *bitmap)

fs/udf/super.c

2445

loc.logicalBlockNum = bitmap->s_extPosition;

fs/udf/super.c

333

static void udf_sb_free_bitmap(struct udf_bitmap *bitmap)

fs/udf/super.c

336

int nr_groups = bitmap->s_nr_groups;

fs/udf/super.c

339

if (!IS_ERR_OR_NULL(bitmap->s_block_bitmap[i]))

fs/udf/super.c

340

brelse(bitmap->s_block_bitmap[i]);

fs/udf/super.c

342

kvfree(bitmap);

fs/ufs/util.h

403

static inline unsigned find_last_zero_bit (unsigned char * bitmap,

fs/ufs/util.h

410

mapp = bitmap + (size >> 3);

fs/xfs/libxfs/xfs_ialloc_btree.c

645

uint64_t bitmap = 0;

fs/xfs/libxfs/xfs_ialloc_btree.c

675

bitmap |= (inodespbit <<

fs/xfs/libxfs/xfs_ialloc_btree.c

681

return bitmap;

fs/xfs/scrub/agb_bitmap.c

58

struct xagb_bitmap *bitmap = priv;

fs/xfs/scrub/agb_bitmap.c

70

return xagb_bitmap_set(bitmap, agbno, 1);

fs/xfs/scrub/agb_bitmap.c

76

struct xagb_bitmap *bitmap,

fs/xfs/scrub/agb_bitmap.c

80

XFS_BTREE_VISIT_ALL, bitmap);

fs/xfs/scrub/agb_bitmap.c

90

struct xagb_bitmap *bitmap,

fs/xfs/scrub/agb_bitmap.c

97

error = xagb_bitmap_visit_btblock(cur, i, bitmap);

fs/xfs/scrub/agb_bitmap.h

15

static inline void xagb_bitmap_init(struct xagb_bitmap *bitmap)

fs/xfs/scrub/agb_bitmap.h

17

xbitmap32_init(&bitmap->agbitmap);

fs/xfs/scrub/agb_bitmap.h

20

static inline void xagb_bitmap_destroy(struct xagb_bitmap *bitmap)

fs/xfs/scrub/agb_bitmap.h

22

xbitmap32_destroy(&bitmap->agbitmap);

fs/xfs/scrub/agb_bitmap.h

25

static inline int xagb_bitmap_clear(struct xagb_bitmap *bitmap,

fs/xfs/scrub/agb_bitmap.h

28

return xbitmap32_clear(&bitmap->agbitmap, start, len);

fs/xfs/scrub/agb_bitmap.h

30

static inline int xagb_bitmap_set(struct xagb_bitmap *bitmap,

fs/xfs/scrub/agb_bitmap.h

33

return xbitmap32_set(&bitmap->agbitmap, start, len);

fs/xfs/scrub/agb_bitmap.h

36

static inline bool xagb_bitmap_test(struct xagb_bitmap *bitmap,

fs/xfs/scrub/agb_bitmap.h

39

return xbitmap32_test(&bitmap->agbitmap, start, len);

fs/xfs/scrub/agb_bitmap.h

42

static inline int xagb_bitmap_disunion(struct xagb_bitmap *bitmap,

fs/xfs/scrub/agb_bitmap.h

45

return xbitmap32_disunion(&bitmap->agbitmap, &sub->agbitmap);

fs/xfs/scrub/agb_bitmap.h

48

static inline uint32_t xagb_bitmap_hweight(struct xagb_bitmap *bitmap)

fs/xfs/scrub/agb_bitmap.h

50

return xbitmap32_hweight(&bitmap->agbitmap);

fs/xfs/scrub/agb_bitmap.h

52

static inline bool xagb_bitmap_empty(struct xagb_bitmap *bitmap)

fs/xfs/scrub/agb_bitmap.h

54

return xbitmap32_empty(&bitmap->agbitmap);

fs/xfs/scrub/agb_bitmap.h

57

static inline int xagb_bitmap_walk(struct xagb_bitmap *bitmap,

fs/xfs/scrub/agb_bitmap.h

60

return xbitmap32_walk(&bitmap->agbitmap, fn, priv);

fs/xfs/scrub/agb_bitmap.h

63

int xagb_bitmap_set_btblocks(struct xagb_bitmap *bitmap,

fs/xfs/scrub/agb_bitmap.h

65

int xagb_bitmap_set_btcur_path(struct xagb_bitmap *bitmap,

fs/xfs/scrub/agino_bitmap.h

15

static inline void xagino_bitmap_init(struct xagino_bitmap *bitmap)

fs/xfs/scrub/agino_bitmap.h

17

xbitmap32_init(&bitmap->aginobitmap);

fs/xfs/scrub/agino_bitmap.h

20

static inline void xagino_bitmap_destroy(struct xagino_bitmap *bitmap)

fs/xfs/scrub/agino_bitmap.h

22

xbitmap32_destroy(&bitmap->aginobitmap);

fs/xfs/scrub/agino_bitmap.h

25

static inline int xagino_bitmap_clear(struct xagino_bitmap *bitmap,

fs/xfs/scrub/agino_bitmap.h

28

return xbitmap32_clear(&bitmap->aginobitmap, agino, len);

fs/xfs/scrub/agino_bitmap.h

31

static inline int xagino_bitmap_set(struct xagino_bitmap *bitmap,

fs/xfs/scrub/agino_bitmap.h

34

return xbitmap32_set(&bitmap->aginobitmap, agino, len);

fs/xfs/scrub/agino_bitmap.h

37

static inline bool xagino_bitmap_test(struct xagino_bitmap *bitmap,

fs/xfs/scrub/agino_bitmap.h

40

return xbitmap32_test(&bitmap->aginobitmap, agino, len);

fs/xfs/scrub/agino_bitmap.h

43

static inline int xagino_bitmap_walk(struct xagino_bitmap *bitmap,

fs/xfs/scrub/agino_bitmap.h

46

return xbitmap32_walk(&bitmap->aginobitmap, fn, priv);

fs/xfs/scrub/bitmap.c

101

xbitmap64_tree_insert(bn, &bitmap->xb_root);

fs/xfs/scrub/bitmap.c

104

xbitmap64_tree_remove(bn, &bitmap->xb_root);

fs/xfs/scrub/bitmap.c

106

xbitmap64_tree_insert(bn, &bitmap->xb_root);

fs/xfs/scrub/bitmap.c

110

xbitmap64_tree_remove(bn, &bitmap->xb_root);

fs/xfs/scrub/bitmap.c

121

struct xbitmap64 *bitmap,

fs/xfs/scrub/bitmap.c

131

left = xbitmap64_tree_iter_first(&bitmap->xb_root, start, last);

fs/xfs/scrub/bitmap.c

136

error = xbitmap64_clear(bitmap, start, len);

fs/xfs/scrub/bitmap.c

141

left = xbitmap64_tree_iter_first(&bitmap->xb_root, start - 1, start - 1);

fs/xfs/scrub/bitmap.c

145

right = xbitmap64_tree_iter_first(&bitmap->xb_root, last + 1, last + 1);

fs/xfs/scrub/bitmap.c

150

xbitmap64_tree_remove(left, &bitmap->xb_root);

fs/xfs/scrub/bitmap.c

151

xbitmap64_tree_remove(right, &bitmap->xb_root);

fs/xfs/scrub/bitmap.c

153

xbitmap64_tree_insert(left, &bitmap->xb_root);

fs/xfs/scrub/bitmap.c

157

xbitmap64_tree_remove(left, &bitmap->xb_root);

fs/xfs/scrub/bitmap.c

159

xbitmap64_tree_insert(left, &bitmap->xb_root);

fs/xfs/scrub/bitmap.c

162

xbitmap64_tree_remove(right, &bitmap->xb_root);

fs/xfs/scrub/bitmap.c

164

xbitmap64_tree_insert(right, &bitmap->xb_root);

fs/xfs/scrub/bitmap.c

172

xbitmap64_tree_insert(left, &bitmap->xb_root);

fs/xfs/scrub/bitmap.c

181

struct xbitmap64 *bitmap)

fs/xfs/scrub/bitmap.c

185

while ((bn = xbitmap64_tree_iter_first(&bitmap->xb_root, 0, -1ULL))) {

fs/xfs/scrub/bitmap.c

186

xbitmap64_tree_remove(bn, &bitmap->xb_root);

fs/xfs/scrub/bitmap.c

194

struct xbitmap64 *bitmap)

fs/xfs/scrub/bitmap.c

196

bitmap->xb_root = RB_ROOT_CACHED;

fs/xfs/scrub/bitmap.c

215

struct xbitmap64 *bitmap,

fs/xfs/scrub/bitmap.c

221

if (xbitmap64_empty(bitmap) || xbitmap64_empty(sub))

fs/xfs/scrub/bitmap.c

225

error = xbitmap64_clear(bitmap, bn->bn_start,

fs/xfs/scrub/bitmap.c

237

struct xbitmap64 *bitmap)

fs/xfs/scrub/bitmap.c

242

for_each_xbitmap64_extent(bn, bitmap)

fs/xfs/scrub/bitmap.c

251

struct xbitmap64 *bitmap,

fs/xfs/scrub/bitmap.c

258

for_each_xbitmap64_extent(bn, bitmap) {

fs/xfs/scrub/bitmap.c

270

struct xbitmap64 *bitmap)

fs/xfs/scrub/bitmap.c

272

return bitmap->xb_root.rb_root.rb_node == NULL;

fs/xfs/scrub/bitmap.c

278

struct xbitmap64 *bitmap,

fs/xfs/scrub/bitmap.c

285

bn = xbitmap64_tree_iter_first(&bitmap->xb_root, start, last);

fs/xfs/scrub/bitmap.c

337

#define for_each_xbitmap32_extent(bn, bitmap) \

fs/xfs/scrub/bitmap.c

338

for ((bn) = rb_entry_safe(rb_first(&(bitmap)->xb_root.rb_root), \

fs/xfs/scrub/bitmap.c

347

struct xbitmap32 *bitmap,

fs/xfs/scrub/bitmap.c

355

while ((bn = xbitmap32_tree_iter_first(&bitmap->xb_root, start, last))) {

fs/xfs/scrub/bitmap.c

360

xbitmap32_tree_remove(bn, &bitmap->xb_root);

fs/xfs/scrub/bitmap.c

362

xbitmap32_tree_insert(bn, &bitmap->xb_root);

fs/xfs/scrub/bitmap.c

371

xbitmap32_tree_insert(new_bn, &bitmap->xb_root);

fs/xfs/scrub/bitmap.c

374

xbitmap32_tree_remove(bn, &bitmap->xb_root);

fs/xfs/scrub/bitmap.c

376

xbitmap32_tree_insert(bn, &bitmap->xb_root);

fs/xfs/scrub/bitmap.c

379

xbitmap32_tree_remove(bn, &bitmap->xb_root);

fs/xfs/scrub/bitmap.c

381

xbitmap32_tree_insert(bn, &bitmap->xb_root);

fs/xfs/scrub/bitmap.c

385

xbitmap32_tree_remove(bn, &bitmap->xb_root);

fs/xfs/scrub/bitmap.c

396

struct xbitmap32 *bitmap,

fs/xfs/scrub/bitmap.c

406

left = xbitmap32_tree_iter_first(&bitmap->xb_root, start, last);

fs/xfs/scrub/bitmap.c

411

error = xbitmap32_clear(bitmap, start, len);

fs/xfs/scrub/bitmap.c

416

left = xbitmap32_tree_iter_first(&bitmap->xb_root, start - 1, start - 1);

fs/xfs/scrub/bitmap.c

420

right = xbitmap32_tree_iter_first(&bitmap->xb_root, last + 1, last + 1);

fs/xfs/scrub/bitmap.c

425

xbitmap32_tree_remove(left, &bitmap->xb_root);

fs/xfs/scrub/bitmap.c

426

xbitmap32_tree_remove(right, &bitmap->xb_root);

fs/xfs/scrub/bitmap.c

428

xbitmap32_tree_insert(left, &bitmap->xb_root);

fs/xfs/scrub/bitmap.c

432

xbitmap32_tree_remove(left, &bitmap->xb_root);

fs/xfs/scrub/bitmap.c

434

xbitmap32_tree_insert(left, &bitmap->xb_root);

fs/xfs/scrub/bitmap.c

437

xbitmap32_tree_remove(right, &bitmap->xb_root);

fs/xfs/scrub/bitmap.c

439

xbitmap32_tree_insert(right, &bitmap->xb_root);

fs/xfs/scrub/bitmap.c

447

xbitmap32_tree_insert(left, &bitmap->xb_root);

fs/xfs/scrub/bitmap.c

456

struct xbitmap32 *bitmap)

fs/xfs/scrub/bitmap.c

460

while ((bn = xbitmap32_tree_iter_first(&bitmap->xb_root, 0, -1U))) {

fs/xfs/scrub/bitmap.c

461

xbitmap32_tree_remove(bn, &bitmap->xb_root);

fs/xfs/scrub/bitmap.c

469

struct xbitmap32 *bitmap)

fs/xfs/scrub/bitmap.c

471

bitmap->xb_root = RB_ROOT_CACHED;

fs/xfs/scrub/bitmap.c

490

struct xbitmap32 *bitmap,

fs/xfs/scrub/bitmap.c

496

if (xbitmap32_empty(bitmap) || xbitmap32_empty(sub))

fs/xfs/scrub/bitmap.c

500

error = xbitmap32_clear(bitmap, bn->bn_start,

fs/xfs/scrub/bitmap.c

512

struct xbitmap32 *bitmap)

fs/xfs/scrub/bitmap.c

517

for_each_xbitmap32_extent(bn, bitmap)

fs/xfs/scrub/bitmap.c

526

struct xbitmap32 *bitmap,

fs/xfs/scrub/bitmap.c

533

for_each_xbitmap32_extent(bn, bitmap) {

fs/xfs/scrub/bitmap.c

545

struct xbitmap32 *bitmap)

fs/xfs/scrub/bitmap.c

547

return bitmap->xb_root.rb_root.rb_node == NULL;

fs/xfs/scrub/bitmap.c

553

struct xbitmap32 *bitmap,

fs/xfs/scrub/bitmap.c

560

bn = xbitmap32_tree_iter_first(&bitmap->xb_root, start, last);

fs/xfs/scrub/bitmap.c

575

struct xbitmap32 *bitmap)

fs/xfs/scrub/bitmap.c

580

for_each_xbitmap32_extent(bn, bitmap)

fs/xfs/scrub/bitmap.c

62

#define for_each_xbitmap64_extent(bn, bitmap) \

fs/xfs/scrub/bitmap.c

63

for ((bn) = rb_entry_safe(rb_first(&(bitmap)->xb_root.rb_root), \

fs/xfs/scrub/bitmap.c

72

struct xbitmap64 *bitmap,

fs/xfs/scrub/bitmap.c

80

while ((bn = xbitmap64_tree_iter_first(&bitmap->xb_root, start, last))) {

fs/xfs/scrub/bitmap.c

85

xbitmap64_tree_remove(bn, &bitmap->xb_root);

fs/xfs/scrub/bitmap.c

87

xbitmap64_tree_insert(bn, &bitmap->xb_root);

fs/xfs/scrub/bitmap.c

96

xbitmap64_tree_insert(new_bn, &bitmap->xb_root);

fs/xfs/scrub/bitmap.c

99

xbitmap64_tree_remove(bn, &bitmap->xb_root);

fs/xfs/scrub/bitmap.h

15

void xbitmap64_init(struct xbitmap64 *bitmap);

fs/xfs/scrub/bitmap.h

16

void xbitmap64_destroy(struct xbitmap64 *bitmap);

fs/xfs/scrub/bitmap.h

18

int xbitmap64_clear(struct xbitmap64 *bitmap, uint64_t start, uint64_t len);

fs/xfs/scrub/bitmap.h

19

int xbitmap64_set(struct xbitmap64 *bitmap, uint64_t start, uint64_t len);

fs/xfs/scrub/bitmap.h

20

int xbitmap64_disunion(struct xbitmap64 *bitmap, struct xbitmap64 *sub);

fs/xfs/scrub/bitmap.h

21

uint64_t xbitmap64_hweight(struct xbitmap64 *bitmap);

fs/xfs/scrub/bitmap.h

31

int xbitmap64_walk(struct xbitmap64 *bitmap, xbitmap64_walk_fn fn,

fs/xfs/scrub/bitmap.h

34

bool xbitmap64_empty(struct xbitmap64 *bitmap);

fs/xfs/scrub/bitmap.h

35

bool xbitmap64_test(struct xbitmap64 *bitmap, uint64_t start, uint64_t *len);

fs/xfs/scrub/bitmap.h

43

void xbitmap32_init(struct xbitmap32 *bitmap);

fs/xfs/scrub/bitmap.h

44

void xbitmap32_destroy(struct xbitmap32 *bitmap);

fs/xfs/scrub/bitmap.h

46

int xbitmap32_clear(struct xbitmap32 *bitmap, uint32_t start, uint32_t len);

fs/xfs/scrub/bitmap.h

47

int xbitmap32_set(struct xbitmap32 *bitmap, uint32_t start, uint32_t len);

fs/xfs/scrub/bitmap.h

48

int xbitmap32_disunion(struct xbitmap32 *bitmap, struct xbitmap32 *sub);

fs/xfs/scrub/bitmap.h

49

uint32_t xbitmap32_hweight(struct xbitmap32 *bitmap);

fs/xfs/scrub/bitmap.h

59

int xbitmap32_walk(struct xbitmap32 *bitmap, xbitmap32_walk_fn fn,

fs/xfs/scrub/bitmap.h

62

bool xbitmap32_empty(struct xbitmap32 *bitmap);

fs/xfs/scrub/bitmap.h

63

bool xbitmap32_test(struct xbitmap32 *bitmap, uint32_t start, uint32_t *len);

fs/xfs/scrub/bitmap.h

65

uint32_t xbitmap32_count_set_regions(struct xbitmap32 *bitmap);

fs/xfs/scrub/dab_bitmap.h

15

static inline void xdab_bitmap_init(struct xdab_bitmap *bitmap)

fs/xfs/scrub/dab_bitmap.h

17

xbitmap32_init(&bitmap->dabitmap);

fs/xfs/scrub/dab_bitmap.h

20

static inline void xdab_bitmap_destroy(struct xdab_bitmap *bitmap)

fs/xfs/scrub/dab_bitmap.h

22

xbitmap32_destroy(&bitmap->dabitmap);

fs/xfs/scrub/dab_bitmap.h

25

static inline int xdab_bitmap_set(struct xdab_bitmap *bitmap,

fs/xfs/scrub/dab_bitmap.h

28

return xbitmap32_set(&bitmap->dabitmap, dabno, len);

fs/xfs/scrub/dab_bitmap.h

31

static inline bool xdab_bitmap_test(struct xdab_bitmap *bitmap,

fs/xfs/scrub/dab_bitmap.h

34

return xbitmap32_test(&bitmap->dabitmap, dabno, len);

fs/xfs/scrub/fsb_bitmap.h

15

static inline void xfsb_bitmap_init(struct xfsb_bitmap *bitmap)

fs/xfs/scrub/fsb_bitmap.h

17

xbitmap64_init(&bitmap->fsbitmap);

fs/xfs/scrub/fsb_bitmap.h

20

static inline void xfsb_bitmap_destroy(struct xfsb_bitmap *bitmap)

fs/xfs/scrub/fsb_bitmap.h

22

xbitmap64_destroy(&bitmap->fsbitmap);

fs/xfs/scrub/fsb_bitmap.h

25

static inline int xfsb_bitmap_set(struct xfsb_bitmap *bitmap,

fs/xfs/scrub/fsb_bitmap.h

28

return xbitmap64_set(&bitmap->fsbitmap, start, len);

fs/xfs/scrub/fsb_bitmap.h

31

static inline int xfsb_bitmap_walk(struct xfsb_bitmap *bitmap,

fs/xfs/scrub/fsb_bitmap.h

34

return xbitmap64_walk(&bitmap->fsbitmap, fn, priv);

fs/xfs/scrub/ino_bitmap.h

15

static inline void xino_bitmap_init(struct xino_bitmap *bitmap)

fs/xfs/scrub/ino_bitmap.h

17

xbitmap64_init(&bitmap->inobitmap);

fs/xfs/scrub/ino_bitmap.h

20

static inline void xino_bitmap_destroy(struct xino_bitmap *bitmap)

fs/xfs/scrub/ino_bitmap.h

22

xbitmap64_destroy(&bitmap->inobitmap);

fs/xfs/scrub/ino_bitmap.h

25

static inline int xino_bitmap_set(struct xino_bitmap *bitmap, xfs_ino_t ino)

fs/xfs/scrub/ino_bitmap.h

27

return xbitmap64_set(&bitmap->inobitmap, ino, 1);

fs/xfs/scrub/ino_bitmap.h

30

static inline int xino_bitmap_test(struct xino_bitmap *bitmap, xfs_ino_t ino)

fs/xfs/scrub/ino_bitmap.h

34

return xbitmap64_test(&bitmap->inobitmap, ino, &len);

fs/xfs/scrub/off_bitmap.h

15

static inline void xoff_bitmap_init(struct xoff_bitmap *bitmap)

fs/xfs/scrub/off_bitmap.h

17

xbitmap64_init(&bitmap->offbitmap);

fs/xfs/scrub/off_bitmap.h

20

static inline void xoff_bitmap_destroy(struct xoff_bitmap *bitmap)

fs/xfs/scrub/off_bitmap.h

22

xbitmap64_destroy(&bitmap->offbitmap);

fs/xfs/scrub/off_bitmap.h

25

static inline int xoff_bitmap_set(struct xoff_bitmap *bitmap,

fs/xfs/scrub/off_bitmap.h

28

return xbitmap64_set(&bitmap->offbitmap, off, len);

fs/xfs/scrub/off_bitmap.h

31

static inline int xoff_bitmap_walk(struct xoff_bitmap *bitmap,

fs/xfs/scrub/off_bitmap.h

34

return xbitmap64_walk(&bitmap->offbitmap, fn, priv);

fs/xfs/scrub/reap.c

1155

struct xrtb_bitmap *bitmap,

fs/xfs/scrub/reap.c

1170

error = xrtb_bitmap_walk(bitmap, xreap_rtmeta_extent, &rs);

fs/xfs/scrub/reap.c

1188

struct xfsb_bitmap *bitmap)

fs/xfs/scrub/reap.c

1209

error = xfsb_bitmap_walk(bitmap, xreap_fsmeta_extent, &rs);

fs/xfs/scrub/reap.c

756

struct xagb_bitmap *bitmap,

fs/xfs/scrub/reap.c

771

error = xagb_bitmap_walk(bitmap, xreap_agmeta_extent, &rs);

fs/xfs/scrub/reap.c

870

struct xfsb_bitmap *bitmap,

fs/xfs/scrub/reap.c

887

error = xfsb_bitmap_walk(bitmap, xreap_fsmeta_extent, &rs);

fs/xfs/scrub/reap.h

12

int xrep_reap_agblocks(struct xfs_scrub *sc, struct xagb_bitmap *bitmap,

fs/xfs/scrub/reap.h

14

int xrep_reap_fsblocks(struct xfs_scrub *sc, struct xfsb_bitmap *bitmap,

fs/xfs/scrub/reap.h

18

struct xfsb_bitmap *bitmap);

fs/xfs/scrub/reap.h

21

int xrep_reap_rtblocks(struct xfs_scrub *sc, struct xrtb_bitmap *bitmap,

fs/xfs/scrub/rgb_bitmap.h

15

static inline void xrgb_bitmap_init(struct xrgb_bitmap *bitmap)

fs/xfs/scrub/rgb_bitmap.h

17

xbitmap32_init(&bitmap->rgbitmap);

fs/xfs/scrub/rgb_bitmap.h

20

static inline void xrgb_bitmap_destroy(struct xrgb_bitmap *bitmap)

fs/xfs/scrub/rgb_bitmap.h

22

xbitmap32_destroy(&bitmap->rgbitmap);

fs/xfs/scrub/rgb_bitmap.h

25

static inline int xrgb_bitmap_set(struct xrgb_bitmap *bitmap,

fs/xfs/scrub/rgb_bitmap.h

28

return xbitmap32_set(&bitmap->rgbitmap, start, len);

fs/xfs/scrub/rgb_bitmap.h

31

static inline int xrgb_bitmap_walk(struct xrgb_bitmap *bitmap,

fs/xfs/scrub/rgb_bitmap.h

34

return xbitmap32_walk(&bitmap->rgbitmap, fn, priv);

fs/xfs/scrub/rmap.c

381

struct xagb_bitmap *bitmap = priv;

fs/xfs/scrub/rmap.c

383

return xagb_bitmap_set(bitmap, agbno, 1);

fs/xfs/scrub/rmap_repair.c

1010

struct xagb_bitmap *bitmap;

fs/xfs/scrub/rmap_repair.c

1023

return xagb_bitmap_set(ra->bitmap, agbno, 1);

fs/xfs/scrub/rmap_repair.c

1042

.bitmap = freesp_blocks,

fs/xfs/scrub/rmap_repair.c

283

struct xagb_bitmap *bitmap,

fs/xfs/scrub/rmap_repair.c

297

return xagb_bitmap_walk(bitmap, xrep_rmap_stash_run, &rsr);

fs/xfs/scrub/rmap_repair.c

790

struct xagb_bitmap *bitmap = priv;

fs/xfs/scrub/rmap_repair.c

796

return xagb_bitmap_set(bitmap, irec->rc_startblock, irec->rc_blockcount);

fs/xfs/scrub/rtb_bitmap.h

15

static inline void xrtb_bitmap_init(struct xrtb_bitmap *bitmap)

fs/xfs/scrub/rtb_bitmap.h

17

xbitmap64_init(&bitmap->rtbitmap);

fs/xfs/scrub/rtb_bitmap.h

20

static inline void xrtb_bitmap_destroy(struct xrtb_bitmap *bitmap)

fs/xfs/scrub/rtb_bitmap.h

22

xbitmap64_destroy(&bitmap->rtbitmap);

fs/xfs/scrub/rtb_bitmap.h

25

static inline int xrtb_bitmap_set(struct xrtb_bitmap *bitmap,

fs/xfs/scrub/rtb_bitmap.h

28

return xbitmap64_set(&bitmap->rtbitmap, start, len);

fs/xfs/scrub/rtb_bitmap.h

31

static inline int xrtb_bitmap_walk(struct xrtb_bitmap *bitmap,

fs/xfs/scrub/rtb_bitmap.h

34

return xbitmap64_walk(&bitmap->rtbitmap, fn, priv);

fs/xfs/scrub/rtrmap_repair.c

450

struct xrgb_bitmap *bitmap,

fs/xfs/scrub/rtrmap_repair.c

458

return xrgb_bitmap_walk(bitmap, xrep_rtrmap_stash_run, &rsr);

fs/xfs/scrub/rtrmap_repair.c

468

struct xrgb_bitmap *bitmap = priv;

fs/xfs/scrub/rtrmap_repair.c

474

return xrgb_bitmap_set(bitmap, irec->rc_startblock,

include/linux/bitmap.h

137

void bitmap_free(const unsigned long *bitmap);

include/linux/bitmap.h

139

DEFINE_FREE(bitmap, unsigned long *, if (_T) bitmap_free(_T))

include/linux/bitmap.h

182

unsigned int __bitmap_weight(const unsigned long *bitmap, unsigned int nbits);

include/linux/bitmap.h

297

void bitmap_from_arr32(unsigned long *bitmap, const u32 *buf,

include/linux/bitmap.h

299

void bitmap_to_arr32(u32 *buf, const unsigned long *bitmap,

include/linux/bitmap.h

302

#define bitmap_from_arr32(bitmap, buf, nbits) \

include/linux/bitmap.h

303

bitmap_copy_clear_tail((unsigned long *) (bitmap), \

include/linux/bitmap.h

305

#define bitmap_to_arr32(buf, bitmap, nbits) \

include/linux/bitmap.h

307

(const unsigned long *) (bitmap), (nbits))

include/linux/bitmap.h

315

void bitmap_from_arr64(unsigned long *bitmap, const u64 *buf, unsigned int nbits);

include/linux/bitmap.h

316

void bitmap_to_arr64(u64 *buf, const unsigned long *bitmap, unsigned int nbits);

include/linux/bitmap.h

318

#define bitmap_from_arr64(bitmap, buf, nbits) \

include/linux/bitmap.h

319

bitmap_copy_clear_tail((unsigned long *)(bitmap), (const unsigned long *)(buf), (nbits))

include/linux/bitmap.h

320

#define bitmap_to_arr64(buf, bitmap, nbits) \

include/linux/bitmap.h

321

bitmap_copy_clear_tail((unsigned long *)(buf), (const unsigned long *)(bitmap), (nbits))

include/linux/bitmap.h

653

void bitmap_next_set_region(unsigned long *bitmap, unsigned int *rs,

include/linux/bitmap.h

656

*rs = find_next_bit(bitmap, end, *rs);

include/linux/bitmap.h

657

*re = find_next_zero_bit(bitmap, end, *rs + 1);

include/linux/bitmap.h

670

void bitmap_release_region(unsigned long *bitmap, unsigned int pos, int order)

include/linux/bitmap.h

672

bitmap_clear(bitmap, pos, BIT(order));

include/linux/bitmap.h

687

int bitmap_allocate_region(unsigned long *bitmap, unsigned int pos, int order)

include/linux/bitmap.h

691

if (find_next_bit(bitmap, pos + len, pos) < pos + len)

include/linux/bitmap.h

693

bitmap_set(bitmap, pos, len);

include/linux/bitmap.h

712

int bitmap_find_free_region(unsigned long *bitmap, unsigned int bits, int order)

include/linux/bitmap.h

717

if (!bitmap_allocate_region(bitmap, pos, order))

include/linux/cpumask.h

1178

#define to_cpumask(bitmap) \

include/linux/cpumask.h

1179

((struct cpumask *)(1 ? (bitmap) \

include/linux/cpumask.h

1180

: (void *)sizeof(__check_is_bitmap(bitmap))))

include/linux/cpumask.h

1182

static __always_inline int __check_is_bitmap(const unsigned long *bitmap)

include/linux/efi.h

551

unsigned long bitmap[];

include/linux/find.h

469

unsigned long __for_each_wrap(const unsigned long *bitmap, unsigned long size,

include/linux/find.h

477

bit = find_next_bit(bitmap, size, n);

include/linux/find.h

486

bit = find_next_bit(bitmap, start, n);

include/linux/idr.h

260

unsigned long bitmap[IDA_BITMAP_LONGS];

include/linux/io_uring_types.h

67

unsigned long *bitmap;

include/linux/iommu.h

1067

struct iova_bitmap *bitmap,

include/linux/iommu.h

1073

dirty->bitmap = bitmap;

include/linux/iommu.h

1081

if (dirty->bitmap)

include/linux/iommu.h

1082

iova_bitmap_set(dirty->bitmap, iova, length);

include/linux/iommu.h

1415

struct iova_bitmap *bitmap,

include/linux/iommu.h

372

struct iova_bitmap *bitmap;

include/linux/iova_bitmap.h

14

typedef int (*iova_bitmap_fn_t)(struct iova_bitmap *bitmap,

include/linux/iova_bitmap.h

22

void iova_bitmap_free(struct iova_bitmap *bitmap);

include/linux/iova_bitmap.h

23

int iova_bitmap_for_each(struct iova_bitmap *bitmap, void *opaque,

include/linux/iova_bitmap.h

25

void iova_bitmap_set(struct iova_bitmap *bitmap,

include/linux/iova_bitmap.h

36

static inline void iova_bitmap_free(struct iova_bitmap *bitmap)

include/linux/iova_bitmap.h

40

static inline int iova_bitmap_for_each(struct iova_bitmap *bitmap, void *opaque,

include/linux/iova_bitmap.h

46

static inline void iova_bitmap_set(struct iova_bitmap *bitmap,

include/linux/mm.h

1011

unsigned long *bitmap = vma->flags.__vma_flags;

include/linux/mm.h

1015

set_bit((__force int)bit, bitmap);

include/linux/mm.h

1036

unsigned long *bitmap = flags->__vma_flags;

include/linux/mm.h

1038

__set_bit((__force int)bit, bitmap);

include/linux/mm.h

1069

const unsigned long *bitmap = flags->__vma_flags;

include/linux/mm.h

1072

return bitmap_intersects(bitmap_to_test, bitmap, NUM_VMA_FLAG_BITS);

include/linux/mm.h

1087

const unsigned long *bitmap = flags->__vma_flags;

include/linux/mm.h

1090

return bitmap_subset(bitmap_to_test, bitmap, NUM_VMA_FLAG_BITS);

include/linux/mm.h

1104

unsigned long *bitmap = flags->__vma_flags;

include/linux/mm.h

1107

bitmap_or(bitmap, bitmap, bitmap_to_set, NUM_VMA_FLAG_BITS);

include/linux/mm.h

1121

unsigned long *bitmap = flags->__vma_flags;

include/linux/mm.h

1124

bitmap_andnot(bitmap, bitmap, bitmap_to_clear, NUM_VMA_FLAG_BITS);

include/linux/mm.h

4735

unsigned long *bitmap,

include/linux/mm.h

950

unsigned long *bitmap = vma->flags.__vma_flags;

include/linux/mm.h

952

bitmap_zero(&bitmap[1], NUM_VMA_FLAG_BITS - BITS_PER_LONG);

include/linux/mm_types.h

1072

unsigned long *bitmap = flags->__vma_flags;

include/linux/mm_types.h

1074

bitmap[0] = value;

include/linux/mm_types.h

1085

unsigned long *bitmap = flags->__vma_flags;

include/linux/mm_types.h

1087

WRITE_ONCE(*bitmap, value);

include/linux/mm_types.h

1093

unsigned long *bitmap = flags->__vma_flags;

include/linux/mm_types.h

1095

*bitmap |= value;

include/linux/mm_types.h

1101

unsigned long *bitmap = flags->__vma_flags;

include/linux/mm_types.h

1103

*bitmap &= ~value;

include/linux/mm_types.h

1364

unsigned long bitmap;

include/linux/mm_types.h

1408

unsigned long *bitmap = ACCESS_PRIVATE(&mm->flags, __mm_flags);

include/linux/mm_types.h

1410

set_mask_bits(bitmap, mask, bits);

include/linux/mm_types.h

1457

mm->lru_gen.bitmap = 0;

include/linux/mm_types.h

1470

WRITE_ONCE(mm->lru_gen.bitmap, -1);

include/linux/mm_types.h

1523

unsigned long bitmap = (unsigned long)mm;

include/linux/mm_types.h

1525

bitmap += offsetof(struct mm_struct, flexible_array);

include/linux/mm_types.h

1527

bitmap += cpumask_size();

include/linux/mm_types.h

1528

return (struct cpumask *)bitmap;

include/linux/pci-epc.h

142

unsigned long *bitmap;

include/linux/sh_clk.h

101

unsigned long *bitmap);

include/linux/soc/qcom/llcc-qcom.h

172

unsigned long *bitmap;

include/linux/soc/qcom/qcom-pbs.h

16

int qcom_pbs_trigger_event(struct pbs_dev *pbs, u8 bitmap);

include/linux/soc/qcom/qcom-pbs.h

19

static inline int qcom_pbs_trigger_event(struct pbs_dev *pbs, u8 bitmap)

include/media/v4l2-common.h

633

unsigned long *bitmap);

include/net/netlabel.h

155

u64 bitmap[NETLBL_CATMAP_MAPCNT];

include/net/netlabel.h

453

unsigned long *bitmap);

include/net/netlabel.h

463

unsigned long bitmap,

include/net/netlabel.h

468

int netlbl_bitmap_walk(const unsigned char *bitmap, u32 bitmap_len,

include/net/netlabel.h

470

void netlbl_bitmap_setbit(unsigned char *bitmap, u32 bit, u8 state);

include/net/netlabel.h

594

unsigned long *bitmap)

include/net/netlabel.h

613

unsigned long bitmap,

include/trace/events/btrfs.h

1449

u64 size, int bitmap),

include/trace/events/btrfs.h

1451

TP_ARGS(block_group, cluster, size, bitmap),

include/trace/events/btrfs.h

1459

__field( int, bitmap )

include/trace/events/btrfs.h

1468

__entry->bitmap = bitmap;

include/trace/events/btrfs.h

1477

__entry->size, __entry->max_size, __entry->bitmap)

include/uapi/linux/kvm.h

1104

__u64 bitmap;

include/uapi/linux/vfio.h

1447

__aligned_u64 bitmap;

include/uapi/linux/vfio.h

1722

struct vfio_bitmap bitmap;

include/uapi/linux/videodev2.h

1341

void __user *bitmap;

include/uapi/linux/virtio_input.h

64

__u8 bitmap[128];

include/uapi/linux/xfrm.h

88

__u32 bitmap;

include/xen/interface/physdev.h

81

uint8_t * bitmap;

io_uring/filetable.c

22

if (!table->bitmap)

io_uring/filetable.c

30

ret = find_next_zero_bit(table->bitmap, nr, table->alloc_hint);

io_uring/filetable.c

48

table->bitmap = bitmap_zalloc(nr_files, GFP_KERNEL_ACCOUNT);

io_uring/filetable.c

49

if (table->bitmap)

io_uring/filetable.c

58

bitmap_free(table->bitmap);

io_uring/filetable.c

59

table->bitmap = NULL;

io_uring/filetable.h

24

WARN_ON_ONCE(!test_bit(bit, table->bitmap));

io_uring/filetable.h

25

__clear_bit(bit, table->bitmap);

io_uring/filetable.h

31

WARN_ON_ONCE(test_bit(bit, table->bitmap));

io_uring/filetable.h

32

__set_bit(bit, table->bitmap);

kernel/bpf/core.c

1011

bitmap_clear(pack->bitmap, pos, nbits);

kernel/bpf/core.c

1012

if (bitmap_find_next_zero_area(pack->bitmap, BPF_PROG_CHUNK_COUNT, 0,

kernel/bpf/core.c

879

unsigned long bitmap[];

kernel/bpf/core.c

913

pack = kzalloc_flex(*pack, bitmap, BITS_TO_LONGS(BPF_PROG_CHUNK_COUNT));

kernel/bpf/core.c

920

bitmap_zero(pack->bitmap, BPF_PROG_PACK_SIZE / BPF_PROG_CHUNK_SIZE);

kernel/bpf/core.c

962

pos = bitmap_find_next_zero_area(pack->bitmap, BPF_PROG_CHUNK_COUNT, 0,

kernel/bpf/core.c

975

bitmap_set(pack->bitmap, pos, nbits);

kernel/dma/coherent.c

155

pageno = bitmap_find_free_region(mem->bitmap, mem->size, order);

kernel/dma/coherent.c

18

unsigned long *bitmap;

kernel/dma/coherent.c

208

bitmap_release_region(mem->bitmap, page, order);

kernel/dma/coherent.c

55

dma_mem->bitmap = bitmap_zalloc(pages, GFP_KERNEL);

kernel/dma/coherent.c

56

if (!dma_mem->bitmap)

kernel/dma/coherent.c

83

bitmap_free(mem->bitmap);

kernel/events/uprobes.c

111

unsigned long *bitmap; /* 0 = free slot */

kernel/events/uprobes.c

1762

area->bitmap = kcalloc(BITS_TO_LONGS(UINSNS_PER_PAGE), sizeof(long),

kernel/events/uprobes.c

1764

if (!area->bitmap)

kernel/events/uprobes.c

1774

set_bit(0, area->bitmap);

kernel/events/uprobes.c

1783

kfree(area->bitmap);

kernel/events/uprobes.c

1834

kfree(area->bitmap);

kernel/events/uprobes.c

1861

slot_nr = find_first_zero_bit(area->bitmap, UINSNS_PER_PAGE);

kernel/events/uprobes.c

1863

if (!test_and_set_bit(slot_nr, area->bitmap))

kernel/events/uprobes.c

1904

clear_bit(slot_nr, area->bitmap);

kernel/irq/irq_sim.c

210

unsigned long *pending __free(bitmap) = bitmap_zalloc(num_irqs, GFP_KERNEL);

kernel/liveupdate/kexec_handover.c

340

DECLARE_KHOSER_PTR(bitmap, struct kho_mem_phys_bits *);

kernel/liveupdate/kexec_handover.c

447

KHOSER_STORE_PTR(elm->bitmap, bits);

kernel/liveupdate/kexec_handover.c

463

struct kho_mem_phys_bits *bitmap = KHOSER_LOAD_PTR(elm->bitmap);

kernel/liveupdate/kexec_handover.c

466

for_each_set_bit(bit, bitmap->preserve, PRESERVE_BITS) {

kernel/sched/rt.c

1107

sched_find_first_bit(array->bitmap);

kernel/sched/rt.c

1217

__clear_bit(rt_se_prio(rt_se), array->bitmap);

kernel/sched/rt.c

1352

__set_bit(rt_se_prio(rt_se), array->bitmap);

kernel/sched/rt.c

1678

idx = sched_find_first_bit(array->bitmap);

kernel/sched/rt.c

76

__clear_bit(i, array->bitmap);

kernel/sched/rt.c

79

__set_bit(MAX_RT_PRIO, array->bitmap);

kernel/sched/sched.h

312

DECLARE_BITMAP(bitmap, MAX_RT_PRIO+1); /* include 1 bit for delimiter */

kernel/sched/topology.c

1969

unsigned long *distance_map __free(bitmap) = NULL;

kernel/seccomp.c

2518

const void *bitmap, size_t bitmap_size)

kernel/seccomp.c

2523

bool cached = test_bit(nr, bitmap);

kernel/seccomp.c

349

static inline bool seccomp_cache_check_allow_bitmap(const void *bitmap,

kernel/seccomp.c

357

return test_bit(syscall_nr, bitmap);

kernel/seccomp.c

848

void *bitmap, const void *bitmap_prev,

kernel/seccomp.c

857

bitmap_copy(bitmap, bitmap_prev, bitmap_size);

kernel/seccomp.c

860

bitmap_fill(bitmap, bitmap_size);

kernel/seccomp.c

865

if (!test_bit(nr, bitmap))

kernel/seccomp.c

879

__clear_bit(nr, bitmap);

kernel/sysctl.c

1119

unsigned long *bitmap = *(unsigned long **) table->data;

kernel/sysctl.c

1123

if (!bitmap || !bitmap_len || !left || (*ppos && SYSCTL_KERN_TO_USER(dir))) {

kernel/sysctl.c

1209

bit_a = find_next_bit(bitmap, bitmap_len, bit_b);

kernel/sysctl.c

1212

bit_b = find_next_zero_bit(bitmap, bitmap_len,

kernel/sysctl.c

1231

bitmap_or(bitmap, bitmap, tmp_bitmap, bitmap_len);

kernel/sysctl.c

1233

bitmap_copy(bitmap, tmp_bitmap, bitmap_len);

kernel/trace/fgraph.c

269

set_bitmap(struct task_struct *t, int offset, unsigned long bitmap)

kernel/trace/fgraph.c

271

t->ret_stack[offset] = (bitmap << FGRAPH_INDEX_SHIFT) |

kernel/trace/fgraph.c

657

unsigned long bitmap = 0;

kernel/trace/fgraph.c

678

bitmap |= BIT(fgraph_direct_gops->idx);

kernel/trace/fgraph.c

696

bitmap |= BIT(i);

kernel/trace/fgraph.c

703

if (!bitmap)

kernel/trace/fgraph.c

710

set_bitmap(current, offset, bitmap | BIT(0));

kernel/trace/fgraph.c

816

unsigned long bitmap;

kernel/trace/fgraph.c

847

bitmap = get_bitmap_bits(current, offset);

kernel/trace/fgraph.c

851

if (test_bit(fgraph_direct_gops->idx, &bitmap))

kernel/trace/fgraph.c

856

for_each_set_bit(i, &bitmap, sizeof(bitmap) * BITS_PER_BYTE) {

kernel/watch_queue.c

241

unsigned long *bitmap;

kernel/watch_queue.c

292

bitmap = bitmap_alloc(nr_notes, GFP_KERNEL);

kernel/watch_queue.c

293

if (!bitmap)

kernel/watch_queue.c

296

bitmap_fill(bitmap, nr_notes);

kernel/watch_queue.c

298

wqueue->notes_bitmap = bitmap;

lib/bitmap-str.c

220

static void bitmap_set_region(const struct region *r, unsigned long *bitmap)

lib/bitmap-str.c

225

bitmap_set(bitmap, start, min(r->end - start + 1, r->off));

lib/bitmap-str.c

478

u32 *bitmap = (u32 *)maskp;

lib/bitmap-str.c

491

end = bitmap_get_x32_reverse(start, end, &bitmap[chunk ^ 1]);

lib/bitmap-str.c

493

end = bitmap_get_x32_reverse(start, end, &bitmap[chunk]);

lib/bitmap.c

338

unsigned int __bitmap_weight(const unsigned long *bitmap, unsigned int bits)

lib/bitmap.c

340

return BITMAP_WEIGHT(bitmap[idx], bits);

lib/bitmap.c

749

void bitmap_free(const unsigned long *bitmap)

lib/bitmap.c

751

kfree(bitmap);

lib/bitmap.c

757

unsigned long *bitmap = data;

lib/bitmap.c

759

bitmap_free(bitmap);

lib/bitmap.c

765

unsigned long *bitmap;

lib/bitmap.c

768

bitmap = bitmap_alloc(nbits, flags);

lib/bitmap.c

769

if (!bitmap)

lib/bitmap.c

772

ret = devm_add_action_or_reset(dev, devm_bitmap_free, bitmap);

lib/bitmap.c

776

return bitmap;

lib/bitmap.c

794

void bitmap_from_arr32(unsigned long *bitmap, const u32 *buf, unsigned int nbits)

lib/bitmap.c

800

bitmap[i/2] = (unsigned long) buf[i];

lib/bitmap.c

802

bitmap[i/2] |= ((unsigned long) buf[i]) << 32;

lib/bitmap.c

807

bitmap[(halfwords - 1) / 2] &= BITMAP_LAST_WORD_MASK(nbits);

lib/bitmap.c

817

void bitmap_to_arr32(u32 *buf, const unsigned long *bitmap, unsigned int nbits)

lib/bitmap.c

823

buf[i] = (u32) (bitmap[i/2] & UINT_MAX);

lib/bitmap.c

825

buf[i] = (u32) (bitmap[i/2] >> 32);

lib/bitmap.c

842

void bitmap_from_arr64(unsigned long *bitmap, const u64 *buf, unsigned int nbits)

lib/bitmap.c

849

*bitmap++ = val;

lib/bitmap.c

851

*bitmap++ = val >> 32;

lib/bitmap.c

862

bitmap[-1] &= BITMAP_LAST_WORD_MASK(nbits);

lib/bitmap.c

872

void bitmap_to_arr64(u64 *buf, const unsigned long *bitmap, unsigned int nbits)

lib/bitmap.c

874

const unsigned long *end = bitmap + BITS_TO_LONGS(nbits);

lib/bitmap.c

876

while (bitmap < end) {

lib/bitmap.c

877

*buf = *bitmap++;

lib/bitmap.c

878

if (bitmap < end)

lib/bitmap.c

879

*buf |= (u64)(*bitmap++) << 32;

lib/find_bit_benchmark.c

107

l = find_last_bit(bitmap, len);

lib/find_bit_benchmark.c

118

static int __init test_find_nth_bit(const unsigned long *bitmap, unsigned long len)

lib/find_bit_benchmark.c

120

unsigned long l, n, w = bitmap_weight(bitmap, len);

lib/find_bit_benchmark.c

125

l = find_nth_bit(bitmap, len, n);

lib/find_bit_benchmark.c

134

static int __init test_find_next_and_bit(const void *bitmap,

lib/find_bit_benchmark.c

142

i = find_next_and_bit(bitmap, bitmap2, BITMAP_LEN, i + 1);

lib/find_bit_benchmark.c

155

get_random_bytes(bitmap, sizeof(bitmap));

lib/find_bit_benchmark.c

158

test_find_next_bit(bitmap, BITMAP_LEN);

lib/find_bit_benchmark.c

159

test_find_next_zero_bit(bitmap, BITMAP_LEN);

lib/find_bit_benchmark.c

160

test_find_last_bit(bitmap, BITMAP_LEN);

lib/find_bit_benchmark.c

161

test_find_nth_bit(bitmap, BITMAP_LEN / 10);

lib/find_bit_benchmark.c

167

test_find_first_bit(bitmap, BITMAP_LEN / 10);

lib/find_bit_benchmark.c

168

test_find_first_and_bit(bitmap, bitmap2, BITMAP_LEN / 2);

lib/find_bit_benchmark.c

169

test_find_next_and_bit(bitmap, bitmap2, BITMAP_LEN);

lib/find_bit_benchmark.c

173

bitmap_zero(bitmap, BITMAP_LEN);

lib/find_bit_benchmark.c

177

__set_bit(get_random_u32_below(BITMAP_LEN), bitmap);

lib/find_bit_benchmark.c

181

test_find_next_bit(bitmap, BITMAP_LEN);

lib/find_bit_benchmark.c

182

test_find_next_zero_bit(bitmap, BITMAP_LEN);

lib/find_bit_benchmark.c

183

test_find_last_bit(bitmap, BITMAP_LEN);

lib/find_bit_benchmark.c

184

test_find_nth_bit(bitmap, BITMAP_LEN);

lib/find_bit_benchmark.c

185

test_find_first_bit(bitmap, BITMAP_LEN);

lib/find_bit_benchmark.c

186

test_find_first_and_bit(bitmap, bitmap2, BITMAP_LEN);

lib/find_bit_benchmark.c

187

test_find_next_and_bit(bitmap, bitmap2, BITMAP_LEN);

lib/find_bit_benchmark.c

29

static DECLARE_BITMAP(bitmap, BITMAP_LEN) __initdata;

lib/find_bit_benchmark.c

36

static int __init test_find_first_bit(void *bitmap, unsigned long len)

lib/find_bit_benchmark.c

43

i = find_first_bit(bitmap, len);

lib/find_bit_benchmark.c

44

__clear_bit(i, bitmap);

lib/find_bit_benchmark.c

52

static int __init test_find_first_and_bit(void *bitmap, const void *bitmap2, unsigned long len)

lib/find_bit_benchmark.c

58

bitmap_copy(cp, bitmap, BITMAP_LEN);

lib/find_bit_benchmark.c

71

static int __init test_find_next_bit(const void *bitmap, unsigned long len)

lib/find_bit_benchmark.c

78

i = find_next_bit(bitmap, BITMAP_LEN, i) + 1;

lib/find_bit_benchmark.c

85

static int __init test_find_next_zero_bit(const void *bitmap, unsigned long len)

lib/find_bit_benchmark.c

92

i = find_next_zero_bit(bitmap, len, i) + 1;

lib/find_bit_benchmark.c

99

static int __init test_find_last_bit(const void *bitmap, unsigned long len)

lib/idr.c

388

struct ida_bitmap *bitmap, *alloc = NULL;

lib/idr.c

399

bitmap = xas_find_marked(&xas, max / IDA_BITMAP_BITS, XA_FREE_MARK);

lib/idr.c

405

if (xa_is_value(bitmap)) {

lib/idr.c

406

unsigned long tmp = xa_to_value(bitmap);

lib/idr.c

418

bitmap = alloc;

lib/idr.c

419

if (!bitmap)

lib/idr.c

420

bitmap = kzalloc_obj(*bitmap, GFP_NOWAIT);

lib/idr.c

421

if (!bitmap)

lib/idr.c

423

bitmap->bitmap[0] = tmp;

lib/idr.c

424

xas_store(&xas, bitmap);

lib/idr.c

426

bitmap->bitmap[0] = 0;

lib/idr.c

431

if (bitmap) {

lib/idr.c

432

bit = find_next_zero_bit(bitmap->bitmap, IDA_BITMAP_BITS, bit);

lib/idr.c

438

__set_bit(bit, bitmap->bitmap);

lib/idr.c

439

if (bitmap_full(bitmap->bitmap, IDA_BITMAP_BITS))

lib/idr.c

443

bitmap = xa_mk_value(1UL << bit);

lib/idr.c

445

bitmap = alloc;

lib/idr.c

446

if (!bitmap)

lib/idr.c

447

bitmap = kzalloc_obj(*bitmap, GFP_NOWAIT);

lib/idr.c

448

if (!bitmap)

lib/idr.c

450

__set_bit(bit, bitmap->bitmap);

lib/idr.c

452

xas_store(&xas, bitmap);

lib/idr.c

461

if (bitmap != alloc)

lib/idr.c

468

alloc = kzalloc_obj(*bitmap, gfp);

lib/idr.c

528

addr = ((struct ida_bitmap *)entry)->bitmap;

lib/idr.c

560

struct ida_bitmap *bitmap;

lib/idr.c

567

bitmap = xas_load(&xas);

lib/idr.c

569

if (xa_is_value(bitmap)) {

lib/idr.c

570

unsigned long v = xa_to_value(bitmap);

lib/idr.c

580

if (!bitmap || !test_bit(bit, bitmap->bitmap))

lib/idr.c

582

__clear_bit(bit, bitmap->bitmap);

lib/idr.c

584

if (bitmap_empty(bitmap->bitmap, IDA_BITMAP_BITS)) {

lib/idr.c

585

kfree(bitmap);

lib/idr.c

613

struct ida_bitmap *bitmap;

lib/idr.c

617

xas_for_each(&xas, bitmap, ULONG_MAX) {

lib/idr.c

618

if (!xa_is_value(bitmap))

lib/idr.c

619

kfree(bitmap);

lib/idr.c

651

struct ida_bitmap *bitmap = entry;

lib/idr.c

654

pr_cont("bitmap: %p data", bitmap);

lib/idr.c

656

pr_cont(" %lx", bitmap->bitmap[i]);

lib/memweight.c

15

const unsigned char *bitmap = ptr;

lib/memweight.c

17

for (; bytes > 0 && ((unsigned long)bitmap) % sizeof(long);

lib/memweight.c

18

bytes--, bitmap++)

lib/memweight.c

19

ret += hweight8(*bitmap);

lib/memweight.c

24

ret += bitmap_weight((unsigned long *)bitmap,

lib/memweight.c

27

bitmap += longs * sizeof(long);

lib/memweight.c

34

for (; bytes > 0; bytes--, bitmap++)

lib/memweight.c

35

ret += hweight8(*bitmap);

lib/pldmfw/pldmfw.c

750

unsigned long *bitmap = data->matching_record->component_bitmap;

lib/pldmfw/pldmfw.c

758

if (!test_bit(index, bitmap))

lib/pldmfw/pldmfw.c

767

if (index == find_first_bit(bitmap, data->component_bitmap_len))

lib/pldmfw/pldmfw.c

769

if (index == find_last_bit(bitmap, data->component_bitmap_len))

lib/pldmfw/pldmfw.c

795

unsigned long *bitmap = data->matching_record->component_bitmap;

lib/pldmfw/pldmfw.c

803

if (!test_bit(index, bitmap))

lib/test_bitmap.c

1068

const unsigned long *bitmap;

lib/test_bitmap.c

1180

n = bitmap_print_bitmask_to_buf(print_buf, t->bitmap, t->nbits,

lib/test_bitmap.c

1185

n = bitmap_print_list_to_buf(print_buf, t->bitmap, t->nbits,

lib/test_bitmap.c

1192

n = bitmap_print_list_to_buf(print_buf, t->bitmap, t->nbits,

lib/test_bitmap.c

1206

DECLARE_BITMAP(bitmap, BITS_PER_LONG);

lib/test_bitmap.c

1221

bitmap_clear(bitmap, 0, BITS_PER_LONG);

lib/test_bitmap.c

1222

if (!test_bit(7, bitmap))

lib/test_bitmap.c

1223

bitmap_set(bitmap, 5, 2);

lib/test_bitmap.c

1235

res = bitmap_weight(bitmap, 20);

lib/test_bitmap.c

1274

DECLARE_BITMAP(bitmap, TEST_BIT_LEN);

lib/test_bitmap.c

1291

bitmap_copy(bitmap, pat_bitmap, TEST_BIT_LEN);

lib/test_bitmap.c

1294

bitmap_write(bitmap, bit, i, 1);

lib/test_bitmap.c

1296

expect_eq_bitmap(exp_bitmap, bitmap,

lib/test_bitmap.c

1302

bitmap_copy(bitmap, pat_bitmap, TEST_BIT_LEN);

lib/test_bitmap.c

1305

bitmap_write(bitmap, ~0UL, i, 0);

lib/test_bitmap.c

1306

expect_eq_bitmap(exp_bitmap, bitmap, TEST_BIT_LEN);

lib/test_bitmap.c

1314

bitmap_copy(bitmap, pat_bitmap, TEST_BIT_LEN);

lib/test_bitmap.c

1318

bitmap_write(bitmap, w, i, nbits);

lib/test_bitmap.c

1319

expect_eq_bitmap(exp_bitmap, bitmap, TEST_BIT_LEN);

lib/test_bitmap.c

1320

r = bitmap_read(bitmap, i, nbits);

lib/test_bitmap.c

1329

DECLARE_BITMAP(bitmap, TEST_BIT_LEN);

lib/test_bitmap.c

1357

bitmap_zero(bitmap, TEST_BIT_LEN);

lib/test_bitmap.c

1359

bitmap_write(bitmap, 0b10101UL, i, 5);

lib/test_bitmap.c

1360

val = bitmap_read(bitmap, i, 5);

lib/test_bitmap.c

1363

bitmap_write(bitmap, 0b101UL, i + 5, 3);

lib/test_bitmap.c

1364

val = bitmap_read(bitmap, i + 5, 3);

lib/test_bitmap.c

1367

val = bitmap_read(bitmap, i, 8);

lib/test_bitmap.c

1377

DECLARE_BITMAP(bitmap, TEST_BIT_LEN);

lib/test_bitmap.c

1382

bitmap_fill(bitmap, TEST_BIT_LEN);

lib/test_bitmap.c

1393

WRITE_ONCE(val, bitmap_read(bitmap, i, nbits));

lib/test_bitmap.c

1403

DECLARE_BITMAP(bitmap, TEST_BIT_LEN);

lib/test_bitmap.c

1408

bitmap_zero(bitmap, TEST_BIT_LEN);

lib/test_bitmap.c

1415

bitmap_write(bitmap, val, i, nbits);

lib/test_bitmap.c

161

#define expect_eq_bitmap(...) __expect_eq(bitmap, ##__VA_ARGS__)

lib/test_bitmap.c

91

const unsigned long *bitmap, unsigned int nbits)

lib/test_bitmap.c

93

snprintf(pbl_buffer, sizeof(pbl_buffer), "%*pbl", nbits, bitmap);

lib/tests/bitops_kunit.c

101

KUNIT_EXPECT_TRUE(test, test_and_clear_bit(params->nr, bitmap));

lib/tests/bitops_kunit.c

102

KUNIT_EXPECT_FALSE(test, test_bit(params->nr, bitmap));

lib/tests/bitops_kunit.c

104

KUNIT_EXPECT_FALSE(test, test_and_clear_bit(params->nr, bitmap));

lib/tests/bitops_kunit.c

105

KUNIT_EXPECT_FALSE(test, test_bit(params->nr, bitmap));

lib/tests/bitops_kunit.c

107

bit_set = find_first_bit(bitmap, BITOPS_LENGTH);

lib/tests/bitops_kunit.c

114

DECLARE_BITMAP(bitmap, BITOPS_LENGTH);

lib/tests/bitops_kunit.c

117

bitmap_zero(bitmap, BITOPS_LENGTH);

lib/tests/bitops_kunit.c

119

KUNIT_EXPECT_FALSE(test, test_and_change_bit(params->nr, bitmap));

lib/tests/bitops_kunit.c

120

KUNIT_EXPECT_TRUE(test, test_bit(params->nr, bitmap));

lib/tests/bitops_kunit.c

122

KUNIT_EXPECT_TRUE(test, test_and_change_bit(params->nr, bitmap));

lib/tests/bitops_kunit.c

123

KUNIT_EXPECT_FALSE(test, test_bit(params->nr, bitmap));

lib/tests/bitops_kunit.c

125

bit_set = find_first_bit(bitmap, BITOPS_LENGTH);

lib/tests/bitops_kunit.c

54

DECLARE_BITMAP(bitmap, BITOPS_LENGTH);

lib/tests/bitops_kunit.c

57

bitmap_zero(bitmap, BITOPS_LENGTH);

lib/tests/bitops_kunit.c

59

set_bit(params->nr, bitmap);

lib/tests/bitops_kunit.c

60

KUNIT_EXPECT_TRUE(test, test_bit(params->nr, bitmap));

lib/tests/bitops_kunit.c

62

clear_bit(params->nr, bitmap);

lib/tests/bitops_kunit.c

63

KUNIT_EXPECT_FALSE(test, test_bit(params->nr, bitmap));

lib/tests/bitops_kunit.c

65

bit_set = find_first_bit(bitmap, BITOPS_LENGTH);

lib/tests/bitops_kunit.c

72

DECLARE_BITMAP(bitmap, BITOPS_LENGTH);

lib/tests/bitops_kunit.c

75

bitmap_zero(bitmap, BITOPS_LENGTH);

lib/tests/bitops_kunit.c

77

change_bit(params->nr, bitmap);

lib/tests/bitops_kunit.c

78

KUNIT_EXPECT_TRUE(test, test_bit(params->nr, bitmap));

lib/tests/bitops_kunit.c

80

change_bit(params->nr, bitmap);

lib/tests/bitops_kunit.c

81

KUNIT_EXPECT_FALSE(test, test_bit(params->nr, bitmap));

lib/tests/bitops_kunit.c

83

bit_set = find_first_bit(bitmap, BITOPS_LENGTH);

lib/tests/bitops_kunit.c

90

DECLARE_BITMAP(bitmap, BITOPS_LENGTH);

lib/tests/bitops_kunit.c

93

bitmap_zero(bitmap, BITOPS_LENGTH);

lib/tests/bitops_kunit.c

95

KUNIT_EXPECT_FALSE(test, test_and_set_bit(params->nr, bitmap));

lib/tests/bitops_kunit.c

96

KUNIT_EXPECT_TRUE(test, test_bit(params->nr, bitmap));

lib/tests/bitops_kunit.c

98

KUNIT_EXPECT_TRUE(test, test_and_set_bit(params->nr, bitmap));

lib/tests/bitops_kunit.c

99

KUNIT_EXPECT_TRUE(test, test_bit(params->nr, bitmap));

lib/tests/printf_kunit.c

814

KUNIT_CASE(bitmap),

lib/vsprintf.c

1232

char *bitmap_string(char *buf, char *end, const unsigned long *bitmap,

lib/vsprintf.c

1240

if (check_pointer(&buf, end, bitmap, spec))

lib/vsprintf.c

1258

val = (bitmap[word] >> bit) & chunkmask;

lib/vsprintf.c

1276

char *bitmap_list_string(char *buf, char *end, const unsigned long *bitmap,

lib/vsprintf.c

1283

if (check_pointer(&buf, end, bitmap, spec))

lib/vsprintf.c

1286

for_each_set_bitrange(rbot, rtop, bitmap, nr_bits) {

mm/cma.c

150

cmr->bitmap = bitmap_zalloc(cma_bitmap_maxno(cma, cmr),

mm/cma.c

152

if (!cmr->bitmap)

mm/cma.c

164

bitmap_set(cmr->bitmap, 0, bitmap_count);

mm/cma.c

186

bitmap_free(cma->ranges[r].bitmap);

mm/cma.c

769

for_each_clear_bitrange(start, end, cmr->bitmap, nbits) {

mm/cma.c

807

bitmap_no = bitmap_find_next_zero_area_off(cmr->bitmap,

mm/cma.c

830

bitmap_set(cmr->bitmap, bitmap_no, bitmap_count);

mm/cma.c

92

bitmap_clear(cmr->bitmap, bitmap_no, bitmap_count);

mm/cma.h

31

unsigned long *bitmap;

mm/cma_debug.c

185

cmr->dfs_bitmap.array = (u32 *)cmr->bitmap;

mm/cma_debug.c

59

for_each_clear_bitrange(start, end, cmr->bitmap, bitmap_maxno)

mm/mapping_dirty_helpers.c

109

__set_bit(pgoff, cwalk->bitmap);

mm/mapping_dirty_helpers.c

316

unsigned long *bitmap,

mm/mapping_dirty_helpers.c

324

.bitmap = bitmap,

mm/mapping_dirty_helpers.c

68

unsigned long *bitmap;

mm/page_alloc.c

392

unsigned long *bitmap;

mm/page_alloc.c

403

bitmap = get_pageblock_bitmap(page, pfn);

mm/page_alloc.c

407

*bitmap_word = &bitmap[word_bitidx];

mm/page_idle.c

201

__BIN_ATTR(bitmap, 0600,

mm/vmscan.c

2893

key = pgdat->node_id % BITS_PER_TYPE(mm->lru_gen.bitmap);

mm/vmscan.c

2895

if (!walk->force_scan && !test_bit(key, &mm->lru_gen.bitmap))

mm/vmscan.c

2898

clear_bit(key, &mm->lru_gen.bitmap);

mm/vmscan.c

3573

struct mm_walk *args, unsigned long *bitmap, unsigned long *first)

mm/vmscan.c

3591

bitmap_zero(bitmap, MIN_LRU_BATCH);

mm/vmscan.c

3597

__set_bit(i - 1, bitmap);

mm/vmscan.c

3649

i = i > MIN_LRU_BATCH ? 0 : find_next_bit(bitmap, MIN_LRU_BATCH, i) + 1;

mm/vmscan.c

3668

DECLARE_BITMAP(bitmap, MIN_LRU_BATCH);

mm/vmscan.c

3701

walk_pmd_range_locked(pud, addr, vma, args, bitmap, &first);

mm/vmscan.c

3710

walk_pmd_range_locked(pud, addr, vma, args, bitmap, &first);

mm/vmscan.c

3727

walk_pmd_range_locked(pud, -1, vma, args, bitmap, &first);

net/batman-adv/bat_iv_ogm.c

1231

unsigned long *bitmap;

net/batman-adv/bat_iv_ogm.c

1279

bitmap = neigh_ifinfo->bat_iv.real_bits;

net/batman-adv/bat_iv_ogm.c

1280

need_update |= batadv_bit_get_packet(bat_priv, bitmap,

net/batman-adv/bat_iv_ogm.c

1283

packet_count = bitmap_weight(bitmap,

net/bridge/br.c

350

unsigned long bitmap = bm->optmask;

net/bridge/br.c

354

opt_id = find_next_bit(&bitmap, BITS_PER_LONG, BR_BOOLOPT_MAX);

net/bridge/br.c

361

for_each_set_bit(opt_id, &bitmap, BR_BOOLOPT_MAX) {

net/devlink/rate.c

345

unsigned long *bitmap,

net/devlink/rate.c

371

if (test_and_set_bit(tc_index, bitmap)) {

net/devlink/rate.c

386

DECLARE_BITMAP(bitmap, DEVLINK_RATE_TCS_MAX) = {};

net/devlink/rate.c

395

err = devlink_nl_rate_tc_bw_parse(attr, tc_bw, bitmap,

net/devlink/rate.c

402

if (!test_bit(i, bitmap)) {

net/ethtool/bitset.c

448

ethnl_update_bitset32_verbose(u32 *bitmap, unsigned int nbits,

net/ethtool/bitset.c

482

memcpy(saved_bitmap, bitmap, nbytes);

net/ethtool/bitset.c

483

ethnl_bitmap32_clear(bitmap, 0, nbits, &dummy);

net/ethtool/bitset.c

502

old_val = bitmap[idx / 32] & ((u32)1 << (idx % 32));

net/ethtool/bitset.c

505

bitmap[idx / 32] |= ((u32)1 << (idx % 32));

net/ethtool/bitset.c

507

bitmap[idx / 32] &= ~((u32)1 << (idx % 32));

net/ethtool/bitset.c

513

if (no_mask && !ethnl_bitmap32_equal(saved_bitmap, bitmap, nbits))

net/ethtool/bitset.c

592

int ethnl_update_bitset32(u32 *bitmap, unsigned int nbits,

net/ethtool/bitset.c

609

return ethnl_update_bitset32_verbose(bitmap, nbits, attr, tb,

net/ethtool/bitset.c

618

ethnl_bitmap32_update(bitmap, change_bits,

net/ethtool/bitset.c

624

ethnl_bitmap32_clear(bitmap, change_bits, nbits, mod);

net/ethtool/bitset.c

811

int ethnl_update_bitset(unsigned long *bitmap, unsigned int nbits,

net/ethtool/bitset.c

828

bitmap_to_arr32(bitmap32, bitmap, nbits);

net/ethtool/bitset.c

832

bitmap_from_arr32(bitmap, bitmap32, nbits);

net/ethtool/bitset.c

865

int ethnl_update_bitset(unsigned long *bitmap, unsigned int nbits,

net/ethtool/bitset.c

869

return ethnl_update_bitset32((u32 *)bitmap, nbits, attr, names, extack,

net/ethtool/bitset.h

23

int ethnl_update_bitset(unsigned long *bitmap, unsigned int nbits,

net/ethtool/bitset.h

26

int ethnl_update_bitset32(u32 *bitmap, unsigned int nbits,

net/ipv4/cipso_ipv4.c

736

const unsigned char *bitmap,

net/ipv4/cipso_ipv4.c

751

cat = netlbl_bitmap_walk(bitmap,

net/ipv4/udp.c

143

unsigned long *bitmap,

net/ipv4/udp.c

152

(bitmap || udp_sk(sk2)->udp_port_hash == num) &&

net/ipv4/udp.c

160

if (!bitmap)

net/ipv4/udp.c

163

if (!bitmap)

net/ipv4/udp.c

166

bitmap);

net/ipv4/udp.c

248

DECLARE_BITMAP(bitmap, PORTS_PER_CHAIN);

net/ipv4/udp.c

265

bitmap_zero(bitmap, PORTS_PER_CHAIN);

net/ipv4/udp.c

267

udp_lib_lport_inuse(net, snum, hslot, bitmap, sk,

net/ipv4/udp.c

278

!test_bit(snum >> udptable->log, bitmap) &&

net/key/af_key.c

1145

(sizeof(x->replay.bitmap) * 8));

net/mptcp/pm_userspace.c

626

} *bitmap;

net/mptcp/pm_userspace.c

635

bitmap = (struct id_bitmap *)cb->ctx;

net/mptcp/pm_userspace.c

646

if (test_bit(entry->addr.id, bitmap->map))

net/mptcp/pm_userspace.c

652

__set_bit(entry->addr.id, bitmap->map);

net/ncsi/internal.h

135

u64 bitmap;

net/ncsi/internal.h

141

u64 bitmap;

net/ncsi/ncsi-manage.c

605

void *bitmap;

net/ncsi/ncsi-manage.c

610

bitmap = &ncf->bitmap;

net/ncsi/ncsi-manage.c

613

index = find_first_bit(bitmap, ncf->n_vids);

net/ncsi/ncsi-manage.c

620

clear_bit(index, bitmap);

net/ncsi/ncsi-manage.c

642

void *bitmap;

net/ncsi/ncsi-manage.c

649

bitmap = &ncf->bitmap;

net/ncsi/ncsi-manage.c

672

index = find_first_zero_bit(bitmap, ncf->n_vids);

net/ncsi/ncsi-manage.c

682

set_bit(index, bitmap);

net/ncsi/ncsi-netlink.c

83

while ((i = find_next_bit((void *)&ncf->bitmap, ncf->n_vids,

net/ncsi/ncsi-rsp.c

367

void *bitmap;

net/ncsi/ncsi-rsp.c

383

bitmap = &ncf->bitmap;

net/ncsi/ncsi-rsp.c

385

if (test_and_clear_bit(cmd->index - 1, bitmap))

net/ncsi/ncsi-rsp.c

388

set_bit(cmd->index - 1, bitmap);

net/ncsi/ncsi-rsp.c

456

void *bitmap;

net/ncsi/ncsi-rsp.c

474

bitmap = &ncf->bitmap;

net/ncsi/ncsi-rsp.c

483

set_bit(cmd->index - 1, bitmap);

net/ncsi/ncsi-rsp.c

486

clear_bit(cmd->index - 1, bitmap);

net/ncsi/ncsi-rsp.c

831

nc->vlan_filter.bitmap = U64_MAX;

net/ncsi/ncsi-rsp.c

848

void *bitmap;

net/ncsi/ncsi-rsp.c

885

bitmap = &ncmf->bitmap;

net/ncsi/ncsi-rsp.c

888

clear_bit(i, bitmap);

net/ncsi/ncsi-rsp.c

890

set_bit(i, bitmap);

net/ncsi/ncsi-rsp.c

899

bitmap = &ncvf->bitmap;

net/ncsi/ncsi-rsp.c

903

clear_bit(i, bitmap);

net/ncsi/ncsi-rsp.c

905

set_bit(i, bitmap);

net/netfilter/nft_set_bitmap.c

150

priv->bitmap[idx] |= (genmask << off);

net/netfilter/nft_set_bitmap.c

166

priv->bitmap[idx] &= ~(genmask << off);

net/netfilter/nft_set_bitmap.c

181

priv->bitmap[idx] |= (genmask << off);

net/netfilter/nft_set_bitmap.c

196

priv->bitmap[idx] &= ~(genmask << off);

net/netfilter/nft_set_bitmap.c

216

priv->bitmap[idx] &= ~(genmask << off);

net/netfilter/nft_set_bitmap.c

49

u8 bitmap[];

net/netfilter/nft_set_bitmap.c

72

nft_bitmap_active(const u8 *bitmap, u32 idx, u32 off, u8 genmask)

net/netfilter/nft_set_bitmap.c

74

return (bitmap[idx] & (0x3 << off)) & (genmask << off);

net/netfilter/nft_set_bitmap.c

89

if (nft_bitmap_active(priv->bitmap, idx, off, genmask))

net/netlabel/netlabel_kapi.c

613

u64 bitmap;

net/netlabel/netlabel_kapi.c

626

bitmap = iter->bitmap[idx] >> bit;

net/netlabel/netlabel_kapi.c

629

if (bitmap != 0) {

net/netlabel/netlabel_kapi.c

630

while ((bitmap & NETLBL_CATMAP_BIT) == 0) {

net/netlabel/netlabel_kapi.c

631

bitmap >>= 1;

net/netlabel/netlabel_kapi.c

644

bitmap = iter->bitmap[idx];

net/netlabel/netlabel_kapi.c

670

u64 bitmap;

net/netlabel/netlabel_kapi.c

686

bitmap = iter->bitmap[idx];

net/netlabel/netlabel_kapi.c

687

while (bitmask != 0 && (bitmap & bitmask) != 0) {

net/netlabel/netlabel_kapi.c

727

unsigned long *bitmap)

net/netlabel/netlabel_kapi.c

759

*bitmap = iter->bitmap[idx] >> (off % NETLBL_CATMAP_MAPSIZE);

net/netlabel/netlabel_kapi.c

788

iter->bitmap[idx] |= NETLBL_CATMAP_BIT << (bit % NETLBL_CATMAP_MAPSIZE);

net/netlabel/netlabel_kapi.c

844

unsigned long bitmap,

net/netlabel/netlabel_kapi.c

860

iter->bitmap[idx] |= (u64)bitmap

net/netlabel/netlabel_kapi.c

881

int netlbl_bitmap_walk(const unsigned char *bitmap, u32 bitmap_len,

net/netlabel/netlabel_kapi.c

892

byte = bitmap[byte_offset];

net/netlabel/netlabel_kapi.c

905

byte = bitmap[++byte_offset];

net/netlabel/netlabel_kapi.c

924

void netlbl_bitmap_setbit(unsigned char *bitmap, u32 bit, u8 state)

net/netlabel/netlabel_kapi.c

933

bitmap[byte_spot] |= bitmask;

net/netlabel/netlabel_kapi.c

935

bitmap[byte_spot] &= ~bitmask;

net/sched/sch_qfq.c

748

unsigned long bitmap)

net/sched/sch_qfq.c

750

int index = __ffs(bitmap);

net/sched/sch_qfq.c

754

static inline unsigned long mask_from(unsigned long bitmap, int from)

net/sched/sch_qfq.c

756

return bitmap & ~((1UL << from) - 1);

net/xfrm/xfrm_replay.c

142

if (x->replay.bitmap & (1U << diff)) {

net/xfrm/xfrm_replay.c

176

x->replay.bitmap = ((x->replay.bitmap) << diff) | 1;

net/xfrm/xfrm_replay.c

178

x->replay.bitmap = 1;

net/xfrm/xfrm_replay.c

182

x->replay.bitmap |= (1U << diff);

net/xfrm/xfrm_user.c

514

if (replay->seq || replay->bitmap) {

net/xfrm/xfrm_user.c

821

sizeof(x->replay.bitmap) * 8);

security/selinux/ss/ebitmap.c

166

unsigned long bitmap;

security/selinux/ss/ebitmap.c

169

rc = netlbl_catmap_getlong(catmap, &offset, &bitmap);

security/selinux/ss/ebitmap.c

176

if (bitmap == 0) {

security/selinux/ss/ebitmap.c

198

e_iter->maps[idx] = bitmap;

sound/pci/oxygen/oxygen_lib.c

745

static inline int is_bit_set(const u32 *bitmap, unsigned int bit)

sound/pci/oxygen/oxygen_lib.c

747

return bitmap[bit / 32] & (1 << (bit & 31));

sound/usb/mixer_scarlett2.c

5913

u16 bitmap;

sound/usb/mixer_scarlett2.c

5923

1, &bitmap);

sound/usb/mixer_scarlett2.c

5926

for (i = 0; i < private->num_mix_out; i++, bitmap >>= 1)

sound/usb/mixer_scarlett2.c

5927

private->talkback_map[i] = bitmap & 1;

sound/usb/mixer_scarlett2.c

6187

u16 bitmap = 0;

sound/usb/mixer_scarlett2.c

6203

bitmap |= private->talkback_map[i] << i;

sound/usb/mixer_scarlett2.c

6207

0, bitmap);

tools/arch/x86/include/uapi/asm/kvm.h

221

__u8 *bitmap; /* a 1 bit allows the operations in flags, 0 denies */

tools/include/linux/bitmap.h

115

static inline void bitmap_free(unsigned long *bitmap)

tools/include/linux/bitmap.h

117

free(bitmap);

tools/include/linux/bitmap.h

127

size_t bitmap_scnprintf(unsigned long *bitmap, unsigned int nbits,

tools/include/linux/bitmap.h

16

unsigned int __bitmap_weight(const unsigned long *bitmap, int bits);

tools/include/uapi/linux/kvm.h

1104

__u64 bitmap;

tools/lib/bitmap.c

13

w += hweight_long(bitmap[k]);

tools/lib/bitmap.c

16

w += hweight_long(bitmap[k] & BITMAP_LAST_WORD_MASK(bits));

tools/lib/bitmap.c

31

size_t bitmap_scnprintf(unsigned long *bitmap, unsigned int nbits,

tools/lib/bitmap.c

39

rbot = cur = find_first_bit(bitmap, nbits);

tools/lib/bitmap.c

42

cur = find_next_bit(bitmap, nbits, cur + 1);

tools/lib/bitmap.c

8

unsigned int __bitmap_weight(const unsigned long *bitmap, int bits)

tools/perf/builtin-kwork.c

248

if (!bitmap_full(page->bitmap, NR_ATOM_PER_PAGE)) {

tools/perf/builtin-kwork.c

249

i = find_first_zero_bit(page->bitmap, NR_ATOM_PER_PAGE);

tools/perf/builtin-kwork.c

270

__set_bit(i, page->bitmap);

tools/perf/builtin-kwork.c

284

((struct kwork_atom_page *)atom->page_addr)->bitmap);

tools/perf/util/cpumap.c

43

int i, unsigned long *bitmap)

tools/perf/util/cpumap.c

47

bitmap[0] = data->mask32_data.mask[i];

tools/perf/util/cpumap.c

49

bitmap[0] = data->mask64_data.mask[i];

tools/perf/util/cpumap.c

52

bitmap[0] = data->mask32_data.mask[i];

tools/perf/util/cpumap.c

53

bitmap[1] = 0;

tools/perf/util/cpumap.c

56

bitmap[0] = (unsigned long)(data->mask64_data.mask[i] >> 32);

tools/perf/util/cpumap.c

57

bitmap[1] = (unsigned long)data->mask64_data.mask[i];

tools/perf/util/cpumap.c

59

bitmap[0] = (unsigned long)data->mask64_data.mask[i];

tools/perf/util/cpumap.c

60

bitmap[1] = (unsigned long)(data->mask64_data.mask[i] >> 32);

tools/perf/util/cpumap.c

684

unsigned char *bitmap;

tools/perf/util/cpumap.c

695

bitmap = zalloc(last_cpu.cpu / 8 + 1);

tools/perf/util/cpumap.c

696

if (bitmap == NULL) {

tools/perf/util/cpumap.c

702

bitmap[c.cpu / 8] |= 1 << (c.cpu % 8);

tools/perf/util/cpumap.c

705

unsigned char bits = bitmap[cpu / 8];

tools/perf/util/cpumap.c

717

free(bitmap);

tools/perf/util/kwork.h

94

DECLARE_BITMAP(bitmap, NR_ATOM_PER_PAGE);

tools/sched_ext/include/scx/common.bpf.h

389

const struct cpumask *bitmap; \

tools/sched_ext/include/scx/common.bpf.h

396

it->bitmap = scx_bpf_get_##name##_cpumask(); \

tools/sched_ext/include/scx/common.bpf.h

397

return bpf_iter_bits_new(&it->it, (const u64 *)it->bitmap, \

tools/sched_ext/include/scx/common.bpf.h

408

scx_bpf_put_cpumask(it->bitmap); \

tools/testing/radix-tree/idr-test.c

500

DECLARE_BITMAP(bitmap, 2048);

tools/testing/radix-tree/idr-test.c

505

memset(bitmap, 0, sizeof(bitmap));

tools/testing/radix-tree/idr-test.c

509

if (test_bit(bit, bitmap)) {

tools/testing/radix-tree/idr-test.c

510

__clear_bit(bit, bitmap);

tools/testing/radix-tree/idr-test.c

513

__set_bit(bit, bitmap);

tools/testing/selftests/bpf/prog_tests/test_xsk.c

1092

unsigned long *bitmap)

tools/testing/selftests/bpf/prog_tests/test_xsk.c

1097

__set_bit(sock_num, bitmap);

tools/testing/selftests/bpf/prog_tests/test_xsk.c

1102

__set_bit(sock_num, bitmap);

tools/testing/selftests/bpf/prog_tests/test_xsk.c

1103

if (bitmap_full(bitmap, test->nb_sockets))

tools/testing/selftests/bpf/prog_tests/test_xsk.c

1113

DECLARE_BITMAP(bitmap, test->nb_sockets);

tools/testing/selftests/bpf/prog_tests/test_xsk.c

1118

bitmap_zero(bitmap, test->nb_sockets);

tools/testing/selftests/bpf/prog_tests/test_xsk.c

1129

if ((all_packets_received(test, xsk, sock_num, bitmap)))

tools/testing/selftests/bpf/prog_tests/test_xsk.c

1299

bool all_packets_sent(struct test_spec *test, unsigned long *bitmap)

tools/testing/selftests/bpf/prog_tests/test_xsk.c

1301

return bitmap_full(bitmap, test->nb_sockets);

tools/testing/selftests/bpf/prog_tests/test_xsk.c

1307

DECLARE_BITMAP(bitmap, test->nb_sockets);

tools/testing/selftests/bpf/prog_tests/test_xsk.c

1310

bitmap_zero(bitmap, test->nb_sockets);

tools/testing/selftests/bpf/prog_tests/test_xsk.c

1312

while (!(all_packets_sent(test, bitmap))) {

tools/testing/selftests/bpf/prog_tests/test_xsk.c

1318

__set_bit(i, bitmap);

tools/testing/selftests/drivers/net/hw/toeplitz.c

501

unsigned long bitmap;

tools/testing/selftests/drivers/net/hw/toeplitz.c

504

bitmap = strtoul(arg, NULL, 0);

tools/testing/selftests/drivers/net/hw/toeplitz.c

506

if (bitmap & ~((1UL << RPS_MAX_CPUS) - 1))

tools/testing/selftests/drivers/net/hw/toeplitz.c

508

bitmap, RPS_MAX_CPUS - 1);

tools/testing/selftests/drivers/net/hw/toeplitz.c

511

if (bitmap & 1UL << i)

tools/testing/selftests/iommu/iommufd.c

2087

void *bitmap;

tools/testing/selftests/iommu/iommufd.c

2155

rc = posix_memalign(&self->bitmap, PAGE_SIZE, size + PAGE_SIZE);

tools/testing/selftests/iommu/iommufd.c

2157

assert(self->bitmap);

tools/testing/selftests/iommu/iommufd.c

2158

assert((uintptr_t)self->bitmap % PAGE_SIZE == 0);

tools/testing/selftests/iommu/iommufd.c

2178

free(self->bitmap);

tools/testing/selftests/iommu/iommufd.c

2319

self->bitmap, self->bitmap_size, 0, _metadata);

tools/testing/selftests/iommu/iommufd.c

2324

self->bitmap + MOCK_PAGE_SIZE,

tools/testing/selftests/iommu/iommufd.c

2330

self->bitmap + 0xff1, self->bitmap_size, 0,

tools/testing/selftests/iommu/iommufd.c

2362

self->bitmap, self->bitmap_size,

tools/testing/selftests/iommu/iommufd.c

2369

self->bitmap + MOCK_PAGE_SIZE,

tools/testing/selftests/iommu/iommufd.c

2377

self->bitmap + 0xff1, self->bitmap_size,

tools/testing/selftests/iommu/iommufd_utils.h

406

__u64 *bitmap, __u32 flags)

tools/testing/selftests/iommu/iommufd_utils.h

415

.data = (uintptr_t)bitmap,

tools/testing/selftests/iommu/iommufd_utils.h

426

bitmap, flags) \

tools/testing/selftests/iommu/iommufd_utils.h

428

page_size, bitmap, flags))

tools/testing/selftests/iommu/iommufd_utils.h

432

__u64 *bitmap, __u64 *dirty)

tools/testing/selftests/iommu/iommufd_utils.h

442

.uptr = (uintptr_t)bitmap,

tools/testing/selftests/iommu/iommufd_utils.h

456

bitmap, nr) \

tools/testing/selftests/iommu/iommufd_utils.h

459

page_size, bitmap, nr))

tools/testing/selftests/iommu/iommufd_utils.h

463

size_t pte_page_size, __u64 *bitmap,

tools/testing/selftests/iommu/iommufd_utils.h

473

memset(bitmap, 0, bitmap_size);

tools/testing/selftests/iommu/iommufd_utils.h

475

set_bit(i, (unsigned long *)bitmap);

tools/testing/selftests/iommu/iommufd_utils.h

478

bitmap, &out_dirty);

tools/testing/selftests/iommu/iommufd_utils.h

482

memset(bitmap, 0, bitmap_size);

tools/testing/selftests/iommu/iommufd_utils.h

483

test_cmd_get_dirty_bitmap(fd, hwpt_id, length, iova, page_size, bitmap,

tools/testing/selftests/iommu/iommufd_utils.h

489

test_bit(i + j, (unsigned long *)bitmap));

tools/testing/selftests/iommu/iommufd_utils.h

491

ASSERT_EQ(!(i % pteset), test_bit(i, (unsigned long *)bitmap));

tools/testing/selftests/iommu/iommufd_utils.h

494

memset(bitmap, 0, bitmap_size);

tools/testing/selftests/iommu/iommufd_utils.h

495

test_cmd_get_dirty_bitmap(fd, hwpt_id, length, iova, page_size, bitmap,

tools/testing/selftests/iommu/iommufd_utils.h

505

test_bit(i + j, (unsigned long *)bitmap));

tools/testing/selftests/iommu/iommufd_utils.h

512

bitmap, bitmap_size, flags, _metadata) \

tools/testing/selftests/iommu/iommufd_utils.h

514

page_size, pte_size, bitmap, \

tools/testing/selftests/kvm/dirty_log_test.c

258

void *bitmap, uint32_t num_pages,

tools/testing/selftests/kvm/dirty_log_test.c

261

kvm_vm_get_dirty_log(vcpu->vm, slot, bitmap);

tools/testing/selftests/kvm/dirty_log_test.c

265

void *bitmap, uint32_t num_pages,

tools/testing/selftests/kvm/dirty_log_test.c

268

kvm_vm_get_dirty_log(vcpu->vm, slot, bitmap);

tools/testing/selftests/kvm/dirty_log_test.c

269

kvm_vm_clear_dirty_log(vcpu->vm, slot, bitmap, 0, num_pages);

tools/testing/selftests/kvm/dirty_log_test.c

337

int slot, void *bitmap,

tools/testing/selftests/kvm/dirty_log_test.c

351

__set_bit_le(cur->offset, bitmap);

tools/testing/selftests/kvm/dirty_log_test.c

362

void *bitmap, uint32_t num_pages,

tools/testing/selftests/kvm/dirty_log_test.c

369

slot, bitmap, num_pages,

tools/testing/selftests/kvm/dirty_log_test.c

407

void *bitmap, uint32_t num_pages,

tools/testing/selftests/kvm/dirty_log_test.c

462

void *bitmap, uint32_t num_pages,

tools/testing/selftests/kvm/dirty_log_test.c

469

mode->collect_dirty_pages(vcpu, slot, bitmap, num_pages, ring_buf_idx);

tools/testing/selftests/kvm/x86/pmu_event_filter_test.c

748

uint32_t action, uint32_t bitmap)

tools/testing/selftests/kvm/x86/pmu_event_filter_test.c

752

.fixed_counter_bitmap = bitmap,

tools/testing/selftests/kvm/x86/pmu_event_filter_test.c

761

uint32_t bitmap)

tools/testing/selftests/kvm/x86/pmu_event_filter_test.c

766

f.fixed_counter_bitmap = bitmap;

tools/testing/selftests/kvm/x86/pmu_event_filter_test.c

776

uint32_t bitmap;

tools/testing/selftests/kvm/x86/pmu_event_filter_test.c

779

TEST_ASSERT(nr_fixed_counters < sizeof(bitmap) * 8,

tools/testing/selftests/kvm/x86/pmu_event_filter_test.c

790

bitmap = BIT(i);

tools/testing/selftests/kvm/x86/pmu_event_filter_test.c

792

bitmap);

tools/testing/selftests/kvm/x86/pmu_event_filter_test.c

793

TEST_ASSERT_EQ(!!count, !!(bitmap & BIT(idx)));

tools/testing/selftests/kvm/x86/pmu_event_filter_test.c

796

bitmap);

tools/testing/selftests/kvm/x86/pmu_event_filter_test.c

797

TEST_ASSERT_EQ(!!count, !(bitmap & BIT(idx)));

tools/testing/selftests/kvm/x86/pmu_event_filter_test.c

805

bitmap);

tools/testing/selftests/kvm/x86/pmu_event_filter_test.c

806

TEST_ASSERT_EQ(!!count, !!(bitmap & BIT(idx)));

tools/testing/selftests/kvm/x86/pmu_event_filter_test.c

810

bitmap);

tools/testing/selftests/kvm/x86/pmu_event_filter_test.c

811

TEST_ASSERT_EQ(!!count, !(bitmap & BIT(idx)));

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

107

.bitmap = bitmap_00000000,

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

112

.bitmap = bitmap_00000000_write,

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

117

.bitmap = bitmap_40000000,

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

122

.bitmap = bitmap_c0000000_read,

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

127

.bitmap = bitmap_c0000000,

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

132

.bitmap = bitmap_deadbeef,

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

26

.bitmap = (uint8_t*)&deny_bits,

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

33

.bitmap = (uint8_t*)&deny_bits,

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

40

.bitmap = (uint8_t*)&deny_bits,

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

52

.bitmap = (uint8_t*)&deny_bits,

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

64

.bitmap = (uint8_t*)&deny_bits,

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

735

.bitmap = (uint8_t *)&deny_bits,

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

80

static void deny_msr(uint8_t *bitmap, u32 msr)

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

84

bitmap[idx / 8] &= ~(1 << (idx % 8));

tools/testing/vma/include/dup.h

762

unsigned long *bitmap = ACCESS_PRIVATE(flags, __vma_flags);

tools/testing/vma/include/dup.h

764

WRITE_ONCE(*bitmap, value);

tools/testing/vma/include/dup.h

770

unsigned long *bitmap = ACCESS_PRIVATE(flags, __vma_flags);

tools/testing/vma/include/dup.h

772

*bitmap |= value;

tools/testing/vma/include/dup.h

778

unsigned long *bitmap = ACCESS_PRIVATE(flags, __vma_flags);

tools/testing/vma/include/dup.h

780

*bitmap &= ~value;

tools/testing/vma/include/dup.h

790

unsigned long *bitmap = ACCESS_PRIVATE(flags, __vma_flags);

tools/testing/vma/include/dup.h

792

__set_bit((__force int)bit, bitmap);

tools/testing/vma/include/dup.h

849

const unsigned long *bitmap = flags->__vma_flags;

tools/testing/vma/include/dup.h

852

return bitmap_intersects(bitmap_to_test, bitmap, NUM_VMA_FLAG_BITS);

tools/testing/vma/include/dup.h

861

const unsigned long *bitmap = flags->__vma_flags;

tools/testing/vma/include/dup.h

864

return bitmap_subset(bitmap_to_test, bitmap, NUM_VMA_FLAG_BITS);

tools/testing/vma/include/dup.h

872

unsigned long *bitmap = flags->__vma_flags;

tools/testing/vma/include/dup.h

875

bitmap_or(bitmap, bitmap, bitmap_to_set, NUM_VMA_FLAG_BITS);

tools/testing/vma/include/dup.h

883

unsigned long *bitmap = flags->__vma_flags;

tools/testing/vma/include/dup.h

886

bitmap_andnot(bitmap, bitmap, bitmap_to_clear, NUM_VMA_FLAG_BITS);