bitmap_size
size_t bitmap_size; /* size of a single bitmap */
unsigned int bitmap_size = BITS_TO_LONGS(bits) * sizeof(long);
if (!bitmap_size)
if (bitmap_size > PAGE_SIZE) {
extensions = bitmap_size / PAGE_SIZE;
bitmap_size = PAGE_SIZE;
mapping->bitmap_size = bitmap_size;
mapping->bitmaps[0] = kzalloc(bitmap_size, GFP_KERNEL);
mapping->bits = BITS_PER_BYTE * bitmap_size;
mapping->bitmaps[next_bitmap] = kzalloc(mapping->bitmap_size,
int i, bitmap_size;
bitmap_size = rex_getbitmap(bm);
for (i = 0; i < bitmap_size; i++) {
const unsigned long *bitmap, u32 bitmap_size)
int idx = find_nth_bit(bitmap, bitmap_size, vector % dest_vcpus);
BUG_ON(idx >= bitmap_size);
size_t bitmap_size;
bitmap_size = BITS_TO_LONGS(user_range->nmsrs) * sizeof(long);
if (!bitmap_size || bitmap_size > KVM_MSR_FILTER_MAX_BITMAP_SIZE)
bitmap = memdup_user((__user u8*)user_range->bitmap, bitmap_size);
u64 bitmap_size = unaccepted_table->size;
u64 unaccepted_start = ULLONG_MAX, unaccepted_end = 0, bitmap_size;
if (end > bitmap_size * unit_size * BITS_PER_BYTE) {
phys_start = bitmap_size * unit_size * BITS_PER_BYTE +
end = bitmap_size * unit_size * BITS_PER_BYTE;
unsigned long bitmap_size;
bitmap_size = DIV_ROUND_UP(end, unit_size);
unaccepted_table->bitmap, bitmap_size) {
bitmap_size = DIV_ROUND_UP(unaccepted_end - unaccepted_start,
sizeof(*unaccepted_table) + bitmap_size,
unaccepted_table->size = bitmap_size;
memset(unaccepted_table->bitmap, 0, bitmap_size);
int count, bitmap_size;
bitmap_size = BITS_TO_LONGS(gdev->ngpio > count ?
struct_size(array_info, invert_mask, 3 * bitmap_size),
bitmap_size;
bitmap_size;
if (100UL * num_marked / dirty->bitmap_size >
pgoff_t end = dirty->bitmap_size;
bitmap_clear(&dirty->bitmap[0], 0, dirty->bitmap_size);
dirty->bitmap_size = num_pages;
dirty->start = dirty->bitmap_size;
unsigned long bitmap_size;
offset, dirty->bitmap_size,
offset, dirty->bitmap_size);
offset, dirty->bitmap_size,
dmap->dirty_words = kvzalloc(bitmap_size(nr_words), GFP_KERNEL);
dmap->dirty_regions = kvzalloc(bitmap_size(nr_regions), GFP_KERNEL);
cmd->region_map = kvmalloc(bitmap_size(cmd->nr_regions), GFP_KERNEL);
int bitmap_size;
bitmap_size = BITS_TO_LONGS(pages) * sizeof(long);
bitmap = kzalloc(bitmap_size, GFP_KERNEL);
return bitmap_size(size_mul(num_ssid, num_id));
size_t bitmap_size;
bitmap_size = DWC2_ELEMENTS_PER_LS_BITMAP *
bitmap_size *= urb->dev->tt->hub->maxchild;
dwc_tt = kzalloc(sizeof(*dwc_tt) + bitmap_size,
u64 bitmap_size, pages;
bitmap_size =
pages, bitmap_size);
if (bmp_bytes != bitmap_size) {
bmp_bytes, bitmap_size);
static int verify_bitmap_size(uint64_t npages, uint64_t bitmap_size)
if (!npages || !bitmap_size || (bitmap_size > DIRTY_BITMAP_SIZE_MAX) ||
(bitmap_size < DIRTY_BITMAP_BYTES(npages)))
u32 bitmap_size;
const unsigned int bitmap_size = btrfs_blocks_per_folio(fs_info, folio);
first_set = find_next_bit(delalloc_bitmap, bitmap_size, start_bit);
if (first_set >= bitmap_size)
first_zero = find_next_zero_bit(delalloc_bitmap, bitmap_size, first_set);
unsigned int bitmap_size = min(
bitmap_size) {
static unsigned long *alloc_bitmap(u32 bitmap_size)
u32 bitmap_rounded_size = round_up(bitmap_size, sizeof(unsigned long));
u32 bitmap_size, flags, expected_extent_count;
bitmap_size = free_space_bitmap_size(fs_info, block_group->length);
bitmap = alloc_bitmap(bitmap_size);
u32 bitmap_size, flags, expected_extent_count;
bitmap_size = free_space_bitmap_size(fs_info, block_group->length);
bitmap = alloc_bitmap(bitmap_size);
size_t bitmap_size;
bitmap_size = sizeof(struct btrfs_item) + BTRFS_FREE_SPACE_BITMAP_SIZE;
total_bitmap_size = num_bitmaps * bitmap_size;
unsigned long bitmap_size = sb->s_blocksize * 8;
if (bitmap_size <= offset)
next_zero_bit = ext4_find_next_zero_bit(bh->b_data, bitmap_size, offset);
return (next_zero_bit < bitmap_size ? next_zero_bit : 0);
int bitmap_size; /* bitmap size */
int bitmap_size = INLINE_DENTRY_BITMAP_SIZE(inode);
d->nr_bitmap = bitmap_size;
d->dentry = t + bitmap_size + reserved_size;
d->filename = t + bitmap_size + reserved_size +
unsigned int bitmap_size = f2fs_bitmap_size(MAIN_SECS(sbi));
memset(DIRTY_I(sbi)->pinned_secmap, 0, bitmap_size);
nm_i->bitmap_size = __bitmap_size(sbi, NAT_BITMAP);
nm_i->nat_bitmap = kmemdup(version_bitmap, nm_i->bitmap_size,
nm_i->nat_bitmap_mir = kmemdup(version_bitmap, nm_i->bitmap_size,
nm_i->bitmap_size))
memcpy(addr, nm_i->nat_bitmap, nm_i->bitmap_size);
unsigned int bitmap_size, main_bitmap_size, sit_bitmap_size;
bitmap_size = MAIN_SEGS(sbi) * SIT_VBLOCK_MAP_SIZE * (3 + discard_map);
bitmap_size = MAIN_SEGS(sbi) * SIT_VBLOCK_MAP_SIZE * (2 + discard_map);
sit_i->bitmap = f2fs_kvzalloc(sbi, bitmap_size, GFP_KERNEL);
sit_i->bitmap_size = sit_bitmap_size;
unsigned int bitmap_size, sec_bitmap_size;
bitmap_size = f2fs_bitmap_size(MAIN_SEGS(sbi));
free_i->free_segmap = f2fs_kvmalloc(sbi, bitmap_size, GFP_KERNEL);
memset(free_i->free_segmap, 0xff, bitmap_size);
unsigned int bitmap_size = f2fs_bitmap_size(MAIN_SECS(sbi));
dirty_i->victim_secmap = f2fs_kvzalloc(sbi, bitmap_size, GFP_KERNEL);
dirty_i->pinned_secmap = f2fs_kvzalloc(sbi, bitmap_size, GFP_KERNEL);
unsigned int bitmap_size, i;
bitmap_size = f2fs_bitmap_size(MAIN_SEGS(sbi));
dirty_i->dirty_segmap[i] = f2fs_kvzalloc(sbi, bitmap_size,
bitmap_size = f2fs_bitmap_size(MAIN_SECS(sbi));
bitmap_size, GFP_KERNEL);
unsigned int bitmap_size; /* SIT bitmap size */
sit_i->bitmap_size))
memcpy(dst_addr, sit_i->sit_bitmap, sit_i->bitmap_size);
unsigned int bitmap_size, array_size;
bitmap_size = DIV_ROUND_UP(sbi->s_num_blocks, 8);
array_size = DIV_ROUND_UP(bitmap_size, sb->s_blocksize);
for (count = bitmap_size; count > 0; count -= sb->s_blocksize) {
unsigned int bitmap_size = DIV_ROUND_UP(chunks, NBWORD);
(bitmap_size * sizeof_field(struct xfs_buf_log_format,
unsigned int len = bitmap_size(nbits);
unsigned int len = bitmap_size(nbits);
unsigned int len = bitmap_size(nbits);
memset(to + copy, 0, bitmap_size(size) - copy * sizeof(long));
unsigned long bitmap_size);
unsigned long bitmap_size);
return bitmap_size(large_cpumask_bits);
return cpumask_size() + bitmap_size(num_possible_cpus());
if (src__sz < bitmap_size(nr_cpu_ids))
unsigned long bitmap_size)
bitmap_size = ALIGN(bitmap_size, BITS_PER_COMPAT_LONG);
nr_compat_longs = BITS_TO_COMPAT_LONGS(bitmap_size);
if (!user_read_access_begin(umask, bitmap_size / 8))
unsigned long bitmap_size)
bitmap_size = ALIGN(bitmap_size, BITS_PER_COMPAT_LONG);
nr_compat_longs = BITS_TO_COMPAT_LONGS(bitmap_size);
if (!user_write_access_begin(umask, bitmap_size / 8))
const void *bitmap, size_t bitmap_size)
for (nr = 0; nr < bitmap_size; nr++) {
size_t bitmap_size,
if (unlikely(syscall_nr < 0 || syscall_nr >= bitmap_size))
syscall_nr = array_index_nospec(syscall_nr, bitmap_size);
size_t bitmap_size, int arch)
bitmap_copy(bitmap, bitmap_prev, bitmap_size);
bitmap_fill(bitmap, bitmap_size);
for (nr = 0; nr < bitmap_size; nr++) {
new = kmalloc(sizeof(*new) + bitmap_size(sz),
data->bitmap_size = data->component_bitmap_len / 8;
err = pldm_move_fw_offset(data, data->bitmap_size);
u16 bitmap_size;
for (i = 0; i < data->bitmap_size; i++)
priv->bitmap_size = nft_bitmap_size(set->klen);
u16 bitmap_size;
bitmap_size(nbits), is_mask); \
return calloc(1, bitmap_size(nbits));
memset(dst, 0, bitmap_size(nbits));
return malloc(bitmap_size(nbits));
unsigned long bitmap_size;
self->bitmap_size = variant->buffer_size / self->page_size;
size = DIV_ROUND_UP(self->bitmap_size, BITS_PER_BYTE);
self->bitmap, self->bitmap_size, 0, _metadata);
self->bitmap_size, 0, _metadata);
self->bitmap + 0xff1, self->bitmap_size, 0,
self->bitmap, self->bitmap_size,
self->bitmap_size,
self->bitmap + 0xff1, self->bitmap_size,
unsigned long bitmap_size = DIV_ROUND_UP(nbits, BITS_PER_BYTE);
memset(bitmap, 0, bitmap_size);
memset(bitmap, 0, bitmap_size);
memset(bitmap, 0, bitmap_size);
bitmap, bitmap_size, flags, _metadata) \
bitmap_size, flags, _metadata))