find_next_bit
bit = find_next_bit(info->vq_map, SVE_VQ_MAX,
msg = find_next_bit(ops, BITS_PER_LONG, msg+1);
#define find_next_bit find_next_bit
return find_next_bit(tbl->it_map, tbl->it_size, start) != tbl->it_size;
if (find_next_bit(tbl->it_map, end, start) != end)
return find_next_bit(tbl->it_map, end, start) != end;
priority = find_next_bit(pending,
priority = find_next_bit(pending,
bit = find_next_bit(gsbm->bitmap, KVMPPC_GSE_IDEN_COUNT, pbit);
irq = find_next_bit(q->queue, opp->max_irq, irq + 1);
bit = find_next_bit(txch_free, MAX_TXCH, start);
while ((i = find_next_bit(pe_alloc, phb->ioda.total_pe_num, i + 1)) <
offset = find_next_bit(perf_ibs->offset_mask,
for (id = find_next_bit(map, end, lvlid); id < end; id = find_next_bit(map, end, ++id))
asid = find_next_bit(sev_reclaim_asid_bitmap, nr_asids, min_asid);
if (find_next_bit(xrs->rgp.resbit, XRS_MAX_COL, col) >= col + ncols)
slot = find_next_bit(port->cmds_to_issue,
bit = find_next_bit(sess->cpu_queues_bm, nr_cpu_ids, cpu);
if (find_next_bit(minors, end, minor) >= end) {
while ((t = find_next_bit(destinations[cur],
chan = find_next_bit((unsigned long *)regs,
lch = find_next_bit(od->lch_bitmap, od->lch_count, lch + 1);
*offset = find_next_bit(dptun_info_regs, 64, *offset);
return find_next_bit(sseu->subslice_mask.xehp,
bit = find_next_bit(map, num_bits, *pos);
next_bit = find_next_bit(dirty, max_num, i + 1);
while ((hit = find_next_bit(&cbs->dirty, VMW_BINDING_NUM_BITS, hit))
next_bit = find_next_bit(dirty, max_num, i + 1);
start = find_next_bit(&dirty->bitmap[0], res_end, cur);
start = find_next_bit(&dirty->bitmap[0], res_end, cur);
return find_next_bit(mask, XE_MAX_DSS_FUSE_BITS, groupnum * groupsize);
next_client_index = find_next_bit(dev->fw_clients_map,
bank_idx = find_next_bit((unsigned long *)&vpset->valid_bank_mask,
vp_bank_idx = find_next_bit((unsigned long *)bank_contents,
in_ind = find_next_bit(indio_dev->active_scan_mask,
in_ind = find_next_bit(indio_dev->active_scan_mask,
while ((i = find_next_bit(pbundle->uobj_finalize, key_bitmap_len,
while ((i = find_next_bit(pbundle->spec_finalize, key_bitmap_len,
bit = find_next_bit(fault->opcodes, bitsize, zero);
reg = find_next_bit(rdesc->presense_map,
return find_next_bit(item->subpacket_map, RMI_REG_DESC_PRESENSE_BITS,
r = find_next_bit(bitmap, ca->sb.njournal_buckets, l + 1);
stripe = find_next_bit(dc->disk.full_dirty_stripes,
new_size = to_cblock(find_next_bit(cache->dirty_bitset,
word = find_next_bit(dmap->dirty_words, cmd->nr_words, word);
i = find_next_bit(wc->dirty_bitmap, bitmap_bits, i);
set_bit = find_next_bit(bitmap, zone_bits, bit);
addr = find_next_bit(dev->me_clients_map, MEI_CLIENTS_MAX, start_idx);
fid = find_next_bit(chip->fid_bitmap, MV88E6XXX_N_FID, fid + 1);
vlan = find_next_bit(active_vlans,
vf_id = find_next_bit(bp->pf.vf_event_bmap, active_vfs, i);
next_ftid = find_next_bit(t->hpftid_bmap, t->nhpftids, idx);
next_ftid = find_next_bit(t->ftid_bmap, t->nftids, idx);
i = find_next_bit(adapter->tids.hpftid_bmap,
i = find_next_bit(adapter->tids.ftid_bmap,
vid = find_next_bit(nic_dev->vlan_bitmap, VLAN_N_VID, vid + 1);
vid = find_next_bit(nic_dev->vlan_bitmap, VLAN_N_VID, vid + 1);
vid = find_next_bit(nic_dev->vlan_bitmap, VLAN_N_VID, vid + 1);
vid = find_next_bit(interface->active_vlans, vid_limit, ++vid);
next_q = find_next_bit(&linklistmap, size, next_q + 1);
while ((i = find_next_bit((unsigned long *)®, 64, i + 1)) < 64) {
next = find_next_bit(map, end, index);
next = find_next_bit(map, end, index);
index = find_next_bit(mcam->bmap, mcam->bmap_entries, entry);
index = find_next_bit(mcam->bmap, mcam->bmap_entries, entry);
slave = find_next_bit((const unsigned long *)&lbit_vec, nmbr_bits, slave);
while ((bit = find_next_bit(part->usage, nr_entries, bit + 1))
next = find_next_bit(free_list, LAN966X_TAPRIO_NUM_GCL,
n = find_next_bit(sec->cam_map, RTW_MAX_SEC_CAM_NUM, offset);
roll = find_next_bit(hal->entity_map, NUM_OF_RTW89_CHANCTX,
unsigned int bit = find_next_bit((_fw)->feature_map, \
pos = find_next_bit(&val, MAX_MSI_IRQS_PER_CTRL, pos);
used_cntr = find_next_bit(used_mask, L3C_CNTR_EXT_H(i), L3C_CNTR_EXT_L(i));
used_cntr = find_next_bit(used_mask, L3C_CNTR_EXT_H(i), L3C_CNTR_EXT_L(i));
res->start = find_next_bit(rule->map.bits, PNP_IRQ_NR, 16);
destid = find_next_bit(idtab->table, idtab->max, from);
next = find_next_bit(sip->map_storep, map_size, index);
set = find_next_bit(drv->tcs_in_use, max, tcs->offset);
index = find_next_bit(fmts_bitmap, MAX_FORMAT_NUM, index);
eol = find_next_bit(ldata->read_flags, size, tail);
if (find_next_bit(dev->keybit, BTN_MISC, KEY_RESERVED) <
if (find_next_bit(dev->keybit, KEY_BRL_DOT10 + 1,
vc->state.x = find_next_bit(vc->vc_tab_stop,
return find_next_bit(vm->sbm.sb_states, bit + count, bit) >=
from = find_next_bit(gnttab_free_bitmap, gnttab_size, to + 1)) {
first_set = find_next_bit(delalloc_bitmap, bitmap_size, start_bit);
found_set = find_next_bit(addr, start + nbits, start);
pos = find_next_bit(bitmap, size, end + 1);
unit_no = find_next_bit(dirty_bitmap,
start = find_next_bit(prefree_map, MAIN_SEGS(sbi), end + 1);
ret = find_next_bit(free_i->free_segmap, max, segno);
next = find_next_bit(free_i->free_segmap,
next = find_next_bit(free_i->free_segmap,
for (fd = find_next_bit(fdt->open_fds, max_fd + 1, fd);
fd = find_next_bit(fdt->open_fds, max_fd + 1, fd + 1)) {
return find_next_bit(ifs->state, blks + end_blk + 1,
return find_next_bit(ifs->state, end_blk + 1, start_blk);
while ((i = find_next_bit(live_node_bitmap,
while((i = find_next_bit(configured_nodes,
while ((i = find_next_bit(map, db->db_len, i + 1)) < db->db_len)
while ((i = find_next_bit(live_node_bitmap,
while ((i = find_next_bit(map, O2NM_MAX_NODES, i + 1)) < O2NM_MAX_NODES)
bit = find_next_bit(iter->node_map, O2NM_MAX_NODES, iter->curnode+1);
while ((i = find_next_bit(nodemap, maxnodes, i + 1)) < maxnodes)
bit = find_next_bit(res->refmap, O2NM_MAX_NODES, bit);
while ((i = find_next_bit(node_map, O2NM_MAX_NODES,
while ((i = find_next_bit(node_map, O2NM_MAX_NODES,
while ((node = find_next_bit(node_map, O2NM_MAX_NODES,
while ((node = find_next_bit(node_map, O2NM_MAX_NODES,
while ((node = find_next_bit(ctxt->live_map, O2NM_MAX_NODES,
while ((node = find_next_bit(dlm->domain_map, O2NM_MAX_NODES,
node = find_next_bit(dlm->domain_map, O2NM_MAX_NODES, node + 1);
while ((node = find_next_bit(dlm->domain_map, O2NM_MAX_NODES,
bit = find_next_bit(iter->diff_bm, O2NM_MAX_NODES,
lowest = find_next_bit(mle->maybe_map,
while ((nn = find_next_bit (mle->response_map, O2NM_MAX_NODES,
bit = find_next_bit(nodemap, O2NM_MAX_NODES,
bit = find_next_bit(res->refmap, O2NM_MAX_NODES, bit);
noderef = find_next_bit(res->refmap, O2NM_MAX_NODES,
num = find_next_bit (dlm->reco.node_map, O2NM_MAX_NODES, num);
while ((i = find_next_bit(hbmap, O2NM_MAX_NODES,
x = find_next_bit(*addr, nbits, bit);
(find_next_bit(&val, cbm_len, zero_bit) < cbm_len)) {
idx = find_next_bit(d->rmid_busy_llc, idx_limit, cur_idx);
if (find_next_bit(map, mapsize, start) < start + len)
*rs = find_next_bit(bitmap, end, *rs);
if (find_next_bit(bitmap, pos + len, pos) < pos + len)
return find_next_bit(cpumask_bits(srcp), small_cpumask_bits, n + 1);
unsigned long bit = find_next_bit(addr, size, offset);
bit = find_next_bit(bitmap, size, n);
bit = find_next_bit(bitmap, start, n);
#ifndef find_next_bit
return find_next_bit(addr, size, offset);
for ((bit) = 0; (bit) = find_next_bit((addr), (size), (bit)), (bit) < (size); (bit)++)
for (; (bit) = find_next_bit((addr), (size), (bit)), (bit) < (size); (bit)++)
(b) = find_next_bit((addr), (size), b), \
(b) = find_next_bit((addr), (size), (b)), \
(e) = find_next_bit((addr), (size), (b) + 1), \
(e) = find_next_bit((addr), (size), (b) + 1), \
bit = find_next_bit(usage->subsection_map, SUBSECTIONS_PER_SECTION, idx);
return find_next_bit(srcp, nr_bits, n + 1);
return find_next_bit(src1p, nr_bits, n + 1);
return find_next_bit(src2p, nr_bits, n + 1);
return min(MAX_NUMNODES, find_next_bit(srcp->bits, MAX_NUMNODES, n+1));
nr = find_next_bit(&word, depth, nr);
return find_next_bit(addr, XA_CHUNK_SIZE, offset);
bit = find_next_bit(bits, nr_bits, bit + 1);
offset = find_next_bit(work_ctx->pending,
i = find_next_bit(lock_chains_in_use, ARRAY_SIZE(lock_chains), i + 1);
bit = find_next_bit(bm->cur.node->data, bits,
((rnp)->grplo + find_next_bit(&(mask), BITS_PER_LONG, (cpu)))
j = find_next_bit(distance_map, NR_DISTANCE_VALUES, j);
bit_a = find_next_bit(bitmap, bitmap_len, bit_b);
pos = find_next_bit(base->pending_map, end, start);
pos = find_next_bit(base->pending_map, start, offset);
lower = find_next_bit(lower_chunk->data, LOWER_MAX,
if (find_next_bit(maskp, unset_bit, nmaskbits) != unset_bit)
i = find_next_bit(map, end, index);
#ifndef find_next_bit
offset = find_next_bit(addr, size, offset);
i = find_next_bit(bitmap, BITMAP_LEN, i) + 1;
unsigned long next_bit = find_next_bit(map, size, index + nr);
bit = find_next_bit(addr, size, offset);
for (y = 2UL; y < sz; y = find_next_bit(new->primes, sz, y + 1))
x = find_next_bit(p->primes, p->last, x + 1);
next_bit = find_next_bit(bmap2,
next_bit = find_next_bit(bmap2, round_up(nbits, BITS_PER_LONG), nbits);
if (find_next_bit(marks, limit, xas->xa_offset + 1) != limit) {
end = find_next_bit(chunk->bound_map, last_alloc,
end = find_next_bit(chunk->alloc_map, last_alloc,
end = find_next_bit(pcpu_index_alloc_map(chunk, e_index),
end = find_next_bit(chunk->populated, end, start + 1);
i = find_next_bit(map, end, index);
end = find_next_bit(chunk->bound_map, pcpu_chunk_map_bits(chunk),
return find_next_bit(sis->zeromap, end, start) - start;
i = i > MIN_LRU_BATCH ? 0 : find_next_bit(bitmap, MIN_LRU_BATCH, i) + 1;
opt_id = find_next_bit(&bitmap, BITS_PER_LONG, BR_BOOLOPT_MAX);
val = find_next_bit(flags, __IP_TUNNEL_FLAG_NUM,
return find_next_bit(src, __ETHTOOL_LINK_MODE_MASK_NBITS, 32) ==
*channel = find_next_bit((const unsigned long *)&scan_req->channels,
while ((i = find_next_bit((void *)&ncf->bitmap, ncf->n_vids,
row = find_next_bit(kd->avail, IPVS_EST_NTICKS, crow);
next_tree = find_next_bit(data->pending_trees, CONNCOUNT_SLOTS, next_tree);
i = find_next_bit(map, len, off);
#ifdef find_next_bit
return find_next_bit(addr, size, offset);
ofs = find_next_bit((*n)->maps, EBITMAP_SIZE, bit - (*n)->startbit + 1);
nbidx = find_next_bit(&dl_mask, FSL_SAI_DL_NUM, fbidx + 1);
(bit) = find_next_bit((addr), (size), (bit) + 1))
for ((bit) = find_next_bit((addr), (size), (bit)); \
(bit) = find_next_bit((addr), (size), (bit) + 1))
#ifndef find_next_bit
cur = find_next_bit(bitmap, nbits, cur + 1);
#ifndef find_next_bit