nr_slots
.nr_slots = 1,
.nr_slots = 1,
.nr_slots = 1,
.nr_slots = 0,
mmc1_data.nr_slots = 2;
int nr_slots;
nr_slots = atomic_read(&kvm->nr_memslots_dirty_logging);
if ((enable && nr_slots == 1) || !nr_slots)
u32 syncval, u32 nr_slots)
nr_slots);
u32 syncpt_incrs, u32 syncval, u32 nr_slots);
u32 syncpt_incrs, u32 syncval, u32 nr_slots)
nr_slots = nr_regions;
if (sector_div(nr_slots, sctx->region_entries_per_slot))
nr_slots++;
if (nr_slots > ULONG_MAX / sizeof(region_table_slot_t)) {
sctx->region_table = vmalloc_array(nr_slots,
sector_t nr_slots;
unsigned int nr_slots;
nr_slots = 0;
nr_slots++;
nr_slots++;
if (!nr_slots) {
host->mapbase, irq, nr_slots);
if (pdata->nr_slots == 0) {
host->nr_slots = pdata->nr_slots;
for (i = 0; i < pdata->nr_slots; i++) {
for (i = 0; i < host->nr_slots; i++)
int nr_slots;
for (i = 0; i < host->nr_slots; i++) {
BUG_ON(num >= host->nr_slots);
if (host->nr_slots == 0 || !host->slots[num])
if (slot == ring->nr_slots - 1)
if (unlikely(!ring || *slot < 0 || *slot >= ring->nr_slots)) {
firstused = ring->nr_slots + firstused;
B43_WARN_ON(slot < 0 || slot >= ring->nr_slots);
B43_WARN_ON(!(current_slot >= 0 && current_slot < ring->nr_slots));
B43_WARN_ON(!(slot >= 0 && slot < ring->nr_slots));
if (slot == ring->nr_slots - 1)
return (ring->nr_slots - ring->used_slots);
B43_WARN_ON(!(slot >= -1 && slot <= ring->nr_slots - 1));
if (slot == ring->nr_slots - 1)
B43_WARN_ON(!(slot >= 0 && slot <= ring->nr_slots - 1));
return ring->nr_slots - 1;
for (i = 0; i < ring->nr_slots; i++) {
ring->used_slots = ring->nr_slots;
b43_dma_write(ring, B43_DMA64_RXINDEX, ring->nr_slots *
b43_dma_write(ring, B43_DMA32_RXINDEX, ring->nr_slots *
for (i = 0; i < ring->nr_slots; i++) {
size_t nr_slots;
nr_slots = B43_TXRING_SLOTS;
nr_slots = B43_RXRING_SLOTS;
ring = kzalloc_flex(*ring, meta, nr_slots);
ring->nr_slots = nr_slots;
for (i = 0; i < ring->nr_slots; i++)
ring->txhdr_cache = kcalloc(ring->nr_slots / TX_SLOTS_PER_FRAME,
ring->txhdr_cache = kcalloc(ring->nr_slots / TX_SLOTS_PER_FRAME,
B43_WARN_ON(!(slot >= 0 && slot < ring->nr_slots));
ring->nr_slots,
int nr_slots;
struct b43_dmadesc_meta meta[] __counted_by(nr_slots);
firstused = ring->nr_slots + firstused;
B43legacy_WARN_ON(!(slot >= 0 && slot < ring->nr_slots));
return (ring->nr_slots - ring->used_slots);
B43legacy_WARN_ON(!(slot >= -1 && slot <= ring->nr_slots - 1));
if (slot == ring->nr_slots - 1)
ring->nr_slots));
for (i = 0; i < ring->nr_slots; i++) {
ring->used_slots = ring->nr_slots;
for (i = 0; i < ring->nr_slots; i++) {
B43legacy_WARN_ON(!(slot >= 0 && slot < ring->nr_slots));
int nr_slots;
nr_slots = B43legacy_RXRING_SLOTS;
nr_slots = B43legacy_TXRING_SLOTS;
ring->meta = kzalloc_objs(struct b43legacy_dmadesc_meta, nr_slots);
ring->txhdr_cache = kcalloc(nr_slots,
ring->txhdr_cache = kcalloc(nr_slots,
if (slot == ring->nr_slots - 1)
ring->nr_slots = nr_slots;
ring->nr_slots);
B43legacy_WARN_ON(!(ring && *slot >= 0 && *slot < ring->nr_slots));
int nr_slots;
unsigned int nr_slots;
nr_slots = shinfo->nr_frags + frag_overflow + 1;
nr_slots--;
for (shinfo->nr_frags = 0; nr_slots > 0 && shinfo->nr_frags < MAX_SKB_FRAGS;
nr_slots--) {
if (nr_slots > 0) {
for (shinfo->nr_frags = 0; shinfo->nr_frags < nr_slots; ++txp) {
int nr_slots;
bridge->nr_slots++;
sun = bridge->nr_slots;
bridge->nr_slots--;
unsigned int blknum, base, hdr, pos, next, nr_slots;
nr_slots = afs_dir_calc_slots(nlen);
next = slot + nr_slots;
for (tmp = 1; tmp < nr_slots; tmp++) {
base + slot, tmp, nr_slots);
static int afs_find_contig_bits(union afs_xdr_dir_block *block, unsigned int nr_slots)
iter.nr_slots = afs_dir_calc_slots(name->len);
meta->meta.alloc_ctrs[b] < iter.nr_slots)
slot = afs_find_contig_bits(block, iter.nr_slots);
afs_set_contig_bits(block, slot, iter.nr_slots);
meta->meta.alloc_ctrs[b] -= iter.nr_slots;
mask = (1 << nr_slots) - 1;
afs_clear_contig_bits(block, slot, iter.nr_slots);
meta->meta.alloc_ctrs[b] += iter.nr_slots;
memset(de, 0, sizeof(*de) * iter.nr_slots);
if (bit > 64 - nr_slots)
int bit, unsigned int nr_slots)
mask = (1 << nr_slots) - 1;
int bit, unsigned int nr_slots)
mask = (1 << nr_slots) - 1;
iter->bucket, resv, slot, slot + iter->nr_slots - 1);
if (slot + iter->nr_slots <= AFS_DIR_SLOTS_PER_BLOCK &&
iter->nr_slots = afs_dir_calc_slots(name->len);
u8 nr_slots;
sinfo->nr_slots = 1;
sinfo->nr_slots = 1;
static int __fat_remove_entries(struct inode *dir, loff_t pos, int nr_slots)
while (nr_slots) {
orig_slots = nr_slots;
while (nr_slots && de < endp) {
nr_slots--;
pos += ((orig_slots - nr_slots) * sizeof(*de)) - sizeof(*de);
int err = 0, nr_slots;
nr_slots = sinfo->nr_slots;
while (nr_slots && de >= (struct msdos_dir_entry *)bh->b_data) {
nr_slots--;
if (nr_slots) {
err = __fat_remove_entries(dir, sinfo->slot_off, nr_slots);
static int fat_add_new_entries(struct inode *dir, void *slots, int nr_slots,
size = nr_slots * sizeof(struct msdos_dir_entry);
int fat_add_entries(struct inode *dir, void *slots, int nr_slots,
sinfo->nr_slots = nr_slots;
if (free_slots == nr_slots)
nr_slots -= free_slots;
int long_bhs = nr_bhs - (nr_slots == 0);
if (nr_slots) {
cluster = fat_add_new_entries(dir, slots, nr_slots, &nr_cluster,
wchar_t **unicode, unsigned char *nr_slots)
*nr_slots = slots;
*nr_slots = 0;
unsigned char nr_slots;
nr_slots = 0;
&unicode, &nr_slots);
if (nr_slots) {
nr_slots++; /* include the de */
sinfo->slot_off = cpos - nr_slots * sizeof(*de);
sinfo->nr_slots = nr_slots;
unsigned char nr_slots;
nr_slots = 0;
&unicode, &nr_slots);
if (nr_slots) {
ctx->pos = cpos - (nr_slots + 1) * sizeof(struct msdos_dir_entry);
int nr_slots; /* number of slots + 1(de) in filename */
extern int fat_add_entries(struct inode *dir, void *slots, int nr_slots,
struct msdos_dir_slot *slots, int *nr_slots)
*nr_slots = 0;
*nr_slots = usize / 13;
for (ps = slots, i = *nr_slots; i > 0; i--, ps++) {
(*nr_slots)++;
int err, nr_slots;
slots, &nr_slots);
err = fat_add_entries(dir, slots, nr_slots, sinfo);
int pipe_resize_ring(struct pipe_inode_info *pipe, unsigned int nr_slots)
if (unlikely(nr_slots > (pipe_index_t)-1u))
bufs = kzalloc_objs(*bufs, nr_slots, GFP_KERNEL_ACCOUNT | __GFP_NOWARN);
if (nr_slots < n) {
pipe->ring_size = nr_slots;
if (pipe->max_usage > nr_slots)
pipe->max_usage = nr_slots;
pipe->max_usage = nr_slots;
pipe->nr_accounted = nr_slots;
unsigned int nr_slots, size;
nr_slots = size >> PAGE_SHIFT;
if (!nr_slots)
if (nr_slots > pipe->max_usage &&
user_bufs = account_pipe_buffers(pipe->user, pipe->nr_accounted, nr_slots);
if (nr_slots > pipe->max_usage &&
ret = pipe_resize_ring(pipe, nr_slots);
(void) account_pipe_buffers(pipe->user, nr_slots, pipe->nr_accounted);
int pipe_resize_ring(struct pipe_inode_info *pipe, unsigned int nr_slots);
unsigned nr_slots:2;
struct bpf_reg_state *reg, int nr_slots)
spi = iter_get_spi(env, reg, nr_slots);
for (i = 0; i < nr_slots; i++) {
struct btf *btf, u32 btf_id, int nr_slots)
spi = iter_get_spi(env, reg, nr_slots);
for (i = 0; i < nr_slots; i++) {
int spi, int nr_slots)
for (i = 0; i < nr_slots; i++)
static bool is_spi_bounds_valid(struct bpf_func_state *state, int spi, int nr_slots)
return spi - nr_slots + 1 >= 0 && spi < allocated_slots;
const char *obj_kind, int nr_slots)
if (spi + 1 < nr_slots) {
if (!is_spi_bounds_valid(bpf_func(env, reg), spi, nr_slots))
static int iter_get_spi(struct bpf_verifier_env *env, struct bpf_reg_state *reg, int nr_slots)
return stack_slot_obj_get_spi(env, reg, "iter", nr_slots);
int spi, err, i, nr_slots, btf_id;
nr_slots = t->size / BPF_REG_SIZE;
if (!is_iter_reg_valid_uninit(env, reg, nr_slots)) {
for (i = 0; i < nr_slots * 8; i += BPF_REG_SIZE) {
err = mark_stack_slots_iter(env, meta, reg, insn_idx, meta->btf, btf_id, nr_slots);
err = is_iter_reg_valid_init(env, reg, meta->btf, btf_id, nr_slots);
spi = iter_get_spi(env, reg, nr_slots);
mark_stack_slots_scratched(env, spi, nr_slots);
err = unmark_stack_slots_iter(env, reg, nr_slots);
struct btf *btf, u32 btf_id, int nr_slots)
spi = iter_get_spi(env, reg, nr_slots);
for (i = 0; i < nr_slots; i++) {
struct bpf_reg_state *reg, int nr_slots)
spi = iter_get_spi(env, reg, nr_slots);
for (i = 0; i < nr_slots; i++) {
unsigned int nslots = nr_slots(alloc_size), stride;
nr_slots(tbl_dma_addr),
nslabs = nr_slots(alloc_size);
for (i = 0; i < (nr_slots(size) - pad_slots); i++)
nslots = nr_slots(mem->slots[index].alloc_size + offset);
unsigned int nr_slots, i;
nr_slots = *sizep = roundup(*sizep, PAGE_SIZE / sizeof(struct hlist_nulls_head));
if (nr_slots > (INT_MAX / sizeof(struct hlist_nulls_head)))
hash = kvzalloc_objs(struct hlist_nulls_head, nr_slots);
for (i = 0; i < nr_slots; i++)