crypto/krb5/src/plugins/kdb/db2/libdb2/hash/hash.c

651

u_int32_t bucket;

crypto/krb5/src/plugins/kdb/db2/libdb2/hash/hash.c

673

bucket = __call_hash(hashp, (int8_t *)key->data, key->size);

crypto/krb5/src/plugins/kdb/db2/libdb2/hash/hash.c

678

cursor.bucket = bucket;

crypto/krb5/src/plugins/kdb/db2/libdb2/hash/hash.c

780

new_curs->bucket = 0;

crypto/krb5/src/plugins/kdb/db2/libdb2/hash/hash.c

850

cursorp->bucket++;

crypto/krb5/src/plugins/kdb/db2/libdb2/hash/hash.c

853

if (cursorp->bucket > hashp->hdr.max_bucket)

crypto/krb5/src/plugins/kdb/db2/libdb2/hash/hash.c

941

u_int32_t n, bucket;

crypto/krb5/src/plugins/kdb/db2/libdb2/hash/hash.c

944

bucket = n & hashp->hdr.high_mask;

crypto/krb5/src/plugins/kdb/db2/libdb2/hash/hash.c

945

if (bucket > hashp->hdr.max_bucket)

crypto/krb5/src/plugins/kdb/db2/libdb2/hash/hash.c

946

bucket = bucket & hashp->hdr.low_mask;

crypto/krb5/src/plugins/kdb/db2/libdb2/hash/hash.c

947

return (bucket);

crypto/krb5/src/plugins/kdb/db2/libdb2/hash/hash.h

173

db_pgno_t bucket;

crypto/krb5/src/plugins/kdb/db2/libdb2/hash/hash.h

53

db_pgno_t bucket;

crypto/krb5/src/plugins/kdb/db2/libdb2/hash/hash_debug.c

62

__dump_bucket(hashp, bucket)

crypto/krb5/src/plugins/kdb/db2/libdb2/hash/hash_debug.c

64

u_int32_t bucket;

crypto/krb5/src/plugins/kdb/db2/libdb2/hash/hash_debug.c

78

cursor.bucket = bucket;

crypto/krb5/src/plugins/kdb/db2/libdb2/hash/hash_page.c

148

item_info->bucket = cursorp->bucket;

crypto/krb5/src/plugins/kdb/db2/libdb2/hash/hash_page.c

164

cursorp->bucket = -1;

crypto/krb5/src/plugins/kdb/db2/libdb2/hash/hash_page.c

190

cursorp->bucket = 0;

crypto/krb5/src/plugins/kdb/db2/libdb2/hash/hash_page.c

365

pagep = __get_page(hashp, item_info->bucket, A_BUCKET);

crypto/krb5/src/plugins/kdb/db2/libdb2/hash/hash_page.c

420

old_ii.bucket = obucket;

crypto/krb5/src/plugins/kdb/db2/libdb2/hash/hash_page.c

421

new_ii.bucket = nbucket;

crypto/krb5/src/plugins/kdb/db2/libdb2/hash/hash_page.c

598

pagep = __get_page(hashp, item_info->bucket, A_BUCKET);

crypto/krb5/src/plugins/kdb/db2/libdb2/hash/hash_page.c

97

__get_page(hashp, cursorp->bucket, A_BUCKET);

lib/libc/db/hash/hash.c

701

u_int32_t bucket;

lib/libc/db/hash/hash.c

724

for (bucket = hashp->cbucket;

lib/libc/db/hash/hash.c

725

bucket <= hashp->MAX_BUCKET;

lib/libc/db/hash/hash.c

726

bucket++, hashp->cndx = 1) {

lib/libc/db/hash/hash.c

727

bufp = __get_buf(hashp, bucket, NULL, 0);

lib/libc/db/hash/hash.c

735

hashp->cbucket = bucket;

lib/libc/db/hash/hash.c

863

unsigned int n, bucket;

lib/libc/db/hash/hash.c

866

bucket = n & hashp->HIGH_MASK;

lib/libc/db/hash/hash.c

867

if (bucket > hashp->MAX_BUCKET)

lib/libc/db/hash/hash.c

868

bucket = bucket & hashp->LOW_MASK;

lib/libc/db/hash/hash.c

869

return (bucket);

lib/libc/db/hash/hash_page.c

514

__get_page(HTAB *hashp, char *p, u_int32_t bucket, int is_bucket, int is_disk,

lib/libc/db/hash/hash_page.c

528

page = BUCKET_TO_PAGE(bucket);

lib/libc/db/hash/hash_page.c

530

page = OADDR_TO_PAGE(bucket);

lib/libc/db/hash/hash_page.c

569

__put_page(HTAB *hashp, char *p, u_int32_t bucket, int is_bucket, int is_bitmap)

lib/libc/db/hash/hash_page.c

597

page = BUCKET_TO_PAGE(bucket);

lib/libc/db/hash/hash_page.c

599

page = OADDR_TO_PAGE(bucket);

lib/librss/librss.c

218

int bucket, cpuset_t *cs)

lib/librss/librss.c

221

if (bucket < 0 || bucket >= rc->rss_nbuckets) {

lib/librss/librss.c

237

CPU_SET(rc->rss_bucket_map[bucket], cs);

lib/librss/librss.h

73

rss_bucket_type_t btype, int bucket, cpuset_t *cs);

libexec/bootpd/hash.c

318

unsigned bucket;

libexec/bootpd/hash.c

333

bucket = hashtable->bucketnum + 1;

libexec/bootpd/hash.c

334

while ((bucket < hashtable->size) &&

libexec/bootpd/hash.c

335

!(memberptr = (hashtable->table)[bucket])) {

libexec/bootpd/hash.c

336

bucket++;

libexec/bootpd/hash.c

342

if (bucket >= hashtable->size) {

libexec/bootpd/hash.c

356

hashtable->bucketnum = bucket;

libexec/rtld-elf/rtld.c

5157

Elf32_Word bucket;

libexec/rtld-elf/rtld.c

5179

bucket = obj->buckets_gnu[req->hash_gnu % obj->nbuckets_gnu];

libexec/rtld-elf/rtld.c

5180

if (bucket == 0)

libexec/rtld-elf/rtld.c

5182

hashval = &obj->chain_zero_gnu[bucket];

libexec/rtld-elf/rtld_malloc.c

117

int bucket;

libexec/rtld-elf/rtld_malloc.c

131

bucket = 0;

libexec/rtld-elf/rtld_malloc.c

134

bucket++;

libexec/rtld-elf/rtld_malloc.c

135

if (amt == 0 || bucket >= NBUCKETS)

libexec/rtld-elf/rtld_malloc.c

142

if ((op = nextf[bucket]) == NULL) {

libexec/rtld-elf/rtld_malloc.c

143

morecore(bucket);

libexec/rtld-elf/rtld_malloc.c

144

if ((op = nextf[bucket]) == NULL)

libexec/rtld-elf/rtld_malloc.c

148

nextf[bucket] = op->ov_next;

libexec/rtld-elf/rtld_malloc.c

150

op->ov_index = bucket;

libexec/rtld-elf/rtld_malloc.c

196

morecore(int bucket)

libexec/rtld-elf/rtld_malloc.c

203

sz = FIRST_BUCKET_SIZE << bucket;

libexec/rtld-elf/rtld_malloc.c

223

nextf[bucket] = op;

libexec/rtld-elf/rtld_malloc.c

81

static void morecore(int bucket);

sbin/recoverdisk/recoverdisk.c

197

uint64_t j, bucket, fp, fe, k, now;

sbin/recoverdisk/recoverdisk.c

201

bucket = total_size / REPORTWID;

sbin/recoverdisk/recoverdisk.c

202

if (total_size > bucket * REPORTWID)

sbin/recoverdisk/recoverdisk.c

203

bucket += 1;

sbin/recoverdisk/recoverdisk.c

209

for (j = fp / bucket; fp < fe; j++) {

sbin/recoverdisk/recoverdisk.c

210

k = (j + 1) * bucket;

sbin/recoverdisk/recoverdisk.c

220

now = start / bucket;

sbin/recoverdisk/recoverdisk.c

222

a = round(8 * (double)hist[j] / bucket);

sys/dev/cxgbe/t4_clip.c

160

const int bucket = clip_hashfn(in6);

sys/dev/cxgbe/t4_clip.c

164

LIST_FOREACH(cde, &clip_db[bucket], link) {

sys/dev/cxgbe/t4_clip.c

173

LIST_INSERT_HEAD(&clip_db[bucket], cde, link);

sys/dev/cxgbe/t4_clip.c

188

const int bucket = clip_hashfn(in6);

sys/dev/cxgbe/t4_clip.c

196

LIST_FOREACH(ce, &sc->clip_table[bucket], link) {

sys/dev/cxgbe/t4_clip.c

205

LIST_INSERT_HEAD(&sc->clip_table[bucket], ce, link);

sys/dev/cxgbe/tom/t4_listen.c

408

int bucket = listen_hashfn(lctx->inp, td->listen_mask);

sys/dev/cxgbe/tom/t4_listen.c

411

LIST_INSERT_HEAD(&td->listen_hash[bucket], lctx, link);

sys/dev/cxgbe/tom/t4_listen.c

423

int bucket = listen_hashfn(inp, td->listen_mask);

sys/dev/cxgbe/tom/t4_listen.c

427

LIST_FOREACH(lctx, &td->listen_hash[bucket], link) {

sys/dev/cxgbe/tom/t4_listen.c

443

int bucket = listen_hashfn(inp, td->listen_mask);

sys/dev/cxgbe/tom/t4_listen.c

447

LIST_FOREACH_SAFE(lctx, &td->listen_hash[bucket], link, l) {

sys/dev/mlx5/mlx5_core/mlx5_eq.c

486

u8 bucket = vecidx - MLX5_EQ_VEC_COMP_BASE;

sys/dev/mlx5/mlx5_core/mlx5_eq.c

488

rss_getcpu(bucket % rss_getnumbuckets()));

sys/dev/sfxge/sfxge_rx.c

410

unsigned bucket;

sys/dev/sfxge/sfxge_rx.c

419

bucket = c->conn_hash & rxq->lro.conns_mask;

sys/dev/sfxge/sfxge_rx.c

420

KASSERT(rxq->lro.conns_n[bucket] > 0, ("LRO: bucket fill level wrong"));

sys/dev/sfxge/sfxge_rx.c

421

--rxq->lro.conns_n[bucket];

sys/dev/sfxge/sfxge_rx.c

422

TAILQ_REMOVE(&rxq->lro.conns[bucket], c, link);

sys/dev/sfxge/sfxge_rx.c

617

unsigned bucket = conn_hash & st->conns_mask;

sys/dev/sfxge/sfxge_rx.c

620

if (st->conns_n[bucket] >= lro_chain_max) {

sys/dev/sfxge/sfxge_rx.c

637

++st->conns_n[bucket];

sys/dev/sfxge/sfxge_rx.c

638

TAILQ_INSERT_HEAD(&st->conns[bucket], c, link);

sys/dev/sfxge/sfxge_rx.c

668

unsigned bucket;

sys/dev/sfxge/sfxge_rx.c

712

bucket = conn_hash & rxq->lro.conns_mask;

sys/dev/sfxge/sfxge_rx.c

714

TAILQ_FOREACH(c, &rxq->lro.conns[bucket], link) {

sys/dev/sfxge/sfxge_rx.c

736

TAILQ_REMOVE(&rxq->lro.conns[bucket], c, link);

sys/dev/sfxge/sfxge_rx.c

737

TAILQ_INSERT_HEAD(&rxq->lro.conns[bucket], c, link);

sys/dev/vmware/vmci/vmci_doorbell.c

251

uint32_t bucket;

sys/dev/vmware/vmci/vmci_doorbell.c

253

bucket = VMCI_DOORBELL_HASH(idx);

sys/dev/vmware/vmci/vmci_doorbell.c

255

vmci_list_scan(iter, &vmci_doorbell_it.entries[bucket], idx_list_item) {

sys/dev/vmware/vmci/vmci_doorbell.c

284

uint32_t bucket;

sys/dev/vmware/vmci/vmci_doorbell.c

333

bucket = VMCI_DOORBELL_HASH(entry->idx);

sys/dev/vmware/vmci/vmci_doorbell.c

334

vmci_list_insert(&vmci_doorbell_it.entries[bucket], entry,

sys/dev/vmware/vmci/vmci_doorbell.c

844

uint32_t bucket = VMCI_DOORBELL_HASH(notify_idx);

sys/dev/vmware/vmci/vmci_doorbell.c

848

vmci_list_scan(iter, &vmci_doorbell_it.entries[bucket], idx_list_item) {

sys/dev/vmware/vmci/vmci_doorbell.c

91

uint32_t bucket;

sys/dev/vmware/vmci/vmci_doorbell.c

93

for (bucket = 0; bucket < ARRAYSIZE(vmci_doorbell_it.entries);

sys/dev/vmware/vmci/vmci_doorbell.c

94

++bucket)

sys/dev/vmware/vmci/vmci_doorbell.c

95

vmci_list_init(&vmci_doorbell_it.entries[bucket]);

sys/dev/wg/wg_cookie.c

422

uint64_t bucket, tokens;

sys/dev/wg/wg_cookie.c

440

bucket = siphash13(rl->rl_secret, &key, len) & RATELIMIT_MASK;

sys/dev/wg/wg_cookie.c

443

LIST_FOREACH(r, &rl->rl_table[bucket], r_entry) {

sys/dev/wg/wg_cookie.c

484

LIST_INSERT_HEAD(&rl->rl_table[bucket], r, r_entry);

sys/kern/kern_timeout.c

589

int bucket;

sys/kern/kern_timeout.c

603

bucket = callout_get_bucket(c->c_time);

sys/kern/kern_timeout.c

607

LIST_INSERT_HEAD(&cc->cc_callwheel[bucket], c, c_links.le);

sys/kern/kern_timeout.c

608

if (cc->cc_bucket == bucket)

sys/net/if_epair.c

205

uint32_t bucket;

sys/net/if_epair.c

210

ret = rss_m2bucket(m, &bucket);

sys/net/if_epair.c

218

rss_soft_m2cpuid_v4(m, 0, &bucket);

sys/net/if_epair.c

223

rss_soft_m2cpuid_v6(m, 0, &bucket);

sys/net/if_epair.c

227

bucket = 0;

sys/net/if_epair.c

231

bucket %= sc->num_queues;

sys/net/if_epair.c

233

bucket = 0;

sys/net/if_epair.c

235

return (&sc->queues[bucket]);

sys/net/rss_config.c

381

rss_getcpu(u_int bucket)

sys/net/rss_config.c

384

return (rss_table[bucket].rte_cpu);

sys/net/rss_config.h

115

u_int rss_getcpu(u_int bucket);

sys/net80211/ieee80211_rssadapt.c

261

thrs = &ra->ra_rate_thresh[bucket(pktlen)];

sys/net80211/ieee80211_rssadapt.c

294

thrs = &ra->ra_rate_thresh[bucket(pktlen)];

sys/net80211/ieee80211_rssadapt.c

314

thrs = &ra->ra_rate_thresh[bucket(pktlen)];

sys/netgraph/ng_bridge.c

1011

const int bucket = HASH(addr, priv->hashMask);

sys/netgraph/ng_bridge.c

1014

SLIST_FOREACH(host, &priv->tab[bucket], next) {

sys/netgraph/ng_bridge.c

1028

const int bucket = HASH(addr, priv->hashMask);

sys/netgraph/ng_bridge.c

1072

SLIST_INSERT_HEAD(&priv->tab[bucket], host, next);

sys/netgraph/ng_bridge.c

1163

int bucket;

sys/netgraph/ng_bridge.c

1165

for (bucket = 0; bucket < priv->numBuckets; bucket++) {

sys/netgraph/ng_bridge.c

1166

struct ng_bridge_host **hptr = &SLIST_FIRST(&priv->tab[bucket]);

sys/netgraph/ng_bridge.c

1211

int bucket;

sys/netgraph/ng_bridge.c

1215

for (bucket = 0; bucket < priv->numBuckets; bucket++) {

sys/netgraph/ng_bridge.c

1216

struct ng_bridge_host **hptr = &SLIST_FIRST(&priv->tab[bucket]);

sys/netgraph/ng_bridge.c

638

int i = 0, bucket;

sys/netgraph/ng_bridge.c

648

for (bucket = 0; bucket < priv->numBuckets; bucket++) {

sys/netgraph/ng_bridge.c

649

SLIST_FOREACH(host, &priv->tab[bucket], next) {

sys/netinet/ip_reass.c

113

ipq_timeout(struct ipqbucket *bucket, struct ipq *fp)

sys/netinet/ip_reass.c

117

ipq_free(bucket, fp);

sys/netinet/ip_reass.c

121

ipq_drop(struct ipqbucket *bucket, struct ipq *fp)

sys/netinet/ip_reass.c

125

ipq_free(bucket, fp);

sys/netinet/ip_reass.c

126

ipreass_reschedule(bucket);

sys/netinet/ip_reass.c

590

struct ipqbucket *bucket = arg;

sys/netinet/ip_reass.c

593

IPQ_BUCKET_LOCK_ASSERT(bucket);

sys/netinet/ip_reass.c

596

CURVNET_SET(bucket->vnet);

sys/netinet/ip_reass.c

597

fp = TAILQ_LAST(&bucket->head, ipqhead);

sys/netinet/ip_reass.c

599

("%s: stray callout on bucket %p, %ju < %ju", __func__, bucket,

sys/netinet/ip_reass.c

603

ipq_timeout(bucket, fp);

sys/netinet/ip_reass.c

604

fp = TAILQ_LAST(&bucket->head, ipqhead);

sys/netinet/ip_reass.c

606

ipreass_reschedule(bucket);

sys/netinet/ip_reass.c

611

ipreass_reschedule(struct ipqbucket *bucket)

sys/netinet/ip_reass.c

615

IPQ_BUCKET_LOCK_ASSERT(bucket);

sys/netinet/ip_reass.c

617

if ((fp = TAILQ_LAST(&bucket->head, ipqhead)) != NULL) {

sys/netinet/ip_reass.c

623

callout_reset_sbt(&bucket->timer, SBT_1S * t, SBT_1S,

sys/netinet/ip_reass.c

624

ipreass_callout, bucket, 0);

sys/netinet/ip_reass.c

626

callout_stop(&bucket->timer);

sys/netinet/ip_reass.c

893

int bucket, i;

sys/netinet/ip_reass.c

898

bucket = (start + i) % V_ipq_hashsize;

sys/netinet/ip_reass.c

899

if (bucket != start && IPQ_TRYLOCK(bucket) == 0)

sys/netinet/ip_reass.c

901

fp = TAILQ_LAST(&V_ipq[bucket].head, ipqhead);

sys/netinet/ip_reass.c

912

TAILQ_REMOVE(&V_ipq[bucket].head, fp, ipq_list);

sys/netinet/ip_reass.c

913

V_ipq[bucket].count--;

sys/netinet/ip_reass.c

914

ipreass_reschedule(&V_ipq[bucket]);

sys/netinet/ip_reass.c

915

if (bucket != start)

sys/netinet/ip_reass.c

916

IPQ_UNLOCK(bucket);

sys/netinet/ip_reass.c

919

if (bucket != start)

sys/netinet/ip_reass.c

920

IPQ_UNLOCK(bucket);

sys/netinet/ip_reass.c

930

ipq_free(struct ipqbucket *bucket, struct ipq *fp)

sys/netinet/ip_reass.c

940

TAILQ_REMOVE(&bucket->head, fp, ipq_list);

sys/netinet/ip_reass.c

941

bucket->count--;

sys/netinet/sctp_pcb.c

145

struct sctp_vrflist *bucket;

sys/netinet/sctp_pcb.c

183

bucket = &SCTP_BASE_INFO(sctp_vrfhash)[(vrf_id & SCTP_BASE_INFO(hashvrfmark))];

sys/netinet/sctp_pcb.c

184

LIST_INSERT_HEAD(bucket, vrf, next_vrf);

sys/netinet/sctp_pcb.c

210

struct sctp_vrflist *bucket;

sys/netinet/sctp_pcb.c

213

bucket = &SCTP_BASE_INFO(sctp_vrfhash)[(vrf_id & SCTP_BASE_INFO(hashvrfmark))];

sys/netinet/sctp_pcb.c

214

LIST_FOREACH(liste, bucket, next_vrf) {

sys/netinet/tcp_lro.c

1287

struct lro_head *bucket;

sys/netinet/tcp_lro.c

1377

bucket = &lc->lro_hash[0];

sys/netinet/tcp_lro.c

1379

bucket = tcp_lro_rx_get_bucket(lc, m, pa);

sys/netinet/tcp_lro.c

1383

LIST_FOREACH(le, bucket, hash_next) {

sys/netinet/tcp_lro.c

1410

tcp_lro_active_insert(lc, bucket, le);

sys/netinet/tcp_lro.c

151

tcp_lro_active_insert(struct lro_ctrl *lc, struct lro_head *bucket,

sys/netinet/tcp_lro.c

156

LIST_INSERT_HEAD(bucket, le, hash_next);

sys/netinet6/frag6.c

1037

uint32_t bucket;

sys/netinet6/frag6.c

1041

for (bucket = 0; bucket < IP6REASS_NHASH; bucket++) {

sys/netinet6/frag6.c

1042

TAILQ_INIT(IP6QB_HEAD(bucket));

sys/netinet6/frag6.c

1043

mtx_init(&V_ip6qb[bucket].lock, "ip6qb", NULL, MTX_DEF);

sys/netinet6/frag6.c

1044

V_ip6qb[bucket].count = 0;

sys/netinet6/frag6.c

1066

uint32_t bucket;

sys/netinet6/frag6.c

1068

for (bucket = 0; bucket < IP6REASS_NHASH; bucket++) {

sys/netinet6/frag6.c

1069

IP6QB_LOCK(bucket);

sys/netinet6/frag6.c

1070

while ((q6 = TAILQ_FIRST(IP6QB_HEAD(bucket))) != NULL) {

sys/netinet6/frag6.c

1073

frag6_freef(q6, bucket);

sys/netinet6/frag6.c

1075

IP6QB_UNLOCK(bucket);

sys/netinet6/frag6.c

1100

uint32_t bucket;

sys/netinet6/frag6.c

1104

for (bucket = 0; bucket < IP6REASS_NHASH; bucket++) {

sys/netinet6/frag6.c

1105

KASSERT(V_ip6qb[bucket].count == 0,

sys/netinet6/frag6.c

1107

bucket, &V_ip6qb[bucket], V_ip6qb[bucket].count));

sys/netinet6/frag6.c

1108

mtx_destroy(&V_ip6qb[bucket].lock);

sys/netinet6/frag6.c

291

frag6_rmqueue(struct ip6q *q6, uint32_t bucket)

sys/netinet6/frag6.c

293

IP6QB_LOCK_ASSERT(bucket);

sys/netinet6/frag6.c

295

TAILQ_REMOVE(IP6QB_HEAD(bucket), q6, ip6q_tq);

sys/netinet6/frag6.c

296

V_ip6qb[bucket].count--;

sys/netinet6/frag6.c

308

frag6_freef(struct ip6q *q6, uint32_t bucket)

sys/netinet6/frag6.c

314

IP6QB_LOCK_ASSERT(bucket);

sys/netinet6/frag6.c

341

frag6_rmqueue(q6, bucket);

sys/netinet6/frag6.c

354

uint32_t bucket;

sys/netinet6/frag6.c

370

for (bucket = 0; bucket < IP6REASS_NHASH; bucket++) {

sys/netinet6/frag6.c

371

IP6QB_LOCK(bucket);

sys/netinet6/frag6.c

372

head = IP6QB_HEAD(bucket);

sys/netinet6/frag6.c

381

IP6QB_UNLOCK(bucket);

sys/netinet6/frag6.c

432

uint32_t bucket, *hashkeyp;

sys/netinet6/frag6.c

563

bucket = jenkins_hash32(hashkey, nitems(hashkey), V_ip6qb_hashseed);

sys/netinet6/frag6.c

564

bucket &= IP6REASS_HMASK;

sys/netinet6/frag6.c

565

IP6QB_LOCK(bucket);

sys/netinet6/frag6.c

566

head = IP6QB_HEAD(bucket);

sys/netinet6/frag6.c

592

else if (V_ip6qb[bucket].count >= V_ip6_maxfragbucketsize ||

sys/netinet6/frag6.c

621

V_ip6qb[bucket].count++;

sys/netinet6/frag6.c

648

frag6_rmqueue(q6, bucket);

sys/netinet6/frag6.c

649

IP6QB_UNLOCK(bucket);

sys/netinet6/frag6.c

658

frag6_rmqueue(q6, bucket);

sys/netinet6/frag6.c

659

IP6QB_UNLOCK(bucket);

sys/netinet6/frag6.c

771

frag6_freef(q6, bucket);

sys/netinet6/frag6.c

781

frag6_freef(q6, bucket);

sys/netinet6/frag6.c

809

frag6_freef(q6, bucket);

sys/netinet6/frag6.c

811

IP6QB_UNLOCK(bucket);

sys/netinet6/frag6.c

821

frag6_freef(q6, bucket);

sys/netinet6/frag6.c

823

IP6QB_UNLOCK(bucket);

sys/netinet6/frag6.c

855

frag6_freef(q6, bucket);

sys/netinet6/frag6.c

874

frag6_rmqueue(q6, bucket);

sys/netinet6/frag6.c

899

IP6QB_UNLOCK(bucket);

sys/netinet6/frag6.c

917

IP6QB_UNLOCK(bucket);

sys/netinet6/frag6.c

937

uint32_t bucket;

sys/netinet6/frag6.c

945

for (bucket = 0; bucket < IP6REASS_NHASH; bucket++) {

sys/netinet6/frag6.c

946

if (V_ip6qb[bucket].count == 0)

sys/netinet6/frag6.c

948

IP6QB_LOCK(bucket);

sys/netinet6/frag6.c

949

head = IP6QB_HEAD(bucket);

sys/netinet6/frag6.c

955

frag6_freef(q6, bucket);

sys/netinet6/frag6.c

968

V_ip6qb[bucket].count > V_ip6_maxfragbucketsize)) &&

sys/netinet6/frag6.c

972

frag6_freef(q6, bucket);

sys/netinet6/frag6.c

974

IP6QB_UNLOCK(bucket);

sys/netinet6/frag6.c

980

bucket = 0;

sys/netinet6/frag6.c

984

IP6QB_LOCK(bucket);

sys/netinet6/frag6.c

985

q6 = TAILQ_LAST(IP6QB_HEAD(bucket), ip6qhead);

sys/netinet6/frag6.c

989

frag6_freef(q6, bucket);

sys/netinet6/frag6.c

991

IP6QB_UNLOCK(bucket);

sys/netinet6/frag6.c

992

bucket = (bucket + 1) % IP6REASS_NHASH;

sys/netpfil/ipfw/dn_heap.c

529

dn_ht_scan_bucket(struct dn_ht *ht, int *bucket, int (*fn)(void *, void *),

sys/netpfil/ipfw/dn_heap.c

537

if (*bucket > ht->buckets)

sys/netpfil/ipfw/dn_heap.c

538

*bucket = 0;

sys/netpfil/ipfw/dn_heap.c

539

i = *bucket;

sys/netpfil/ipfw/ip_fw_compat.c

85

u_int32_t bucket; /* which bucket in hash table */

sys/netpfil/ipfw/ip_fw_dynamic.c

1065

uint32_t version, bucket;

sys/netpfil/ipfw/ip_fw_dynamic.c

1067

bucket = DYN_BUCKET(info->hashval, V_curr_dyn_buckets);

sys/netpfil/ipfw/ip_fw_dynamic.c

1068

info->version = DYN_BUCKET_VERSION(bucket, ipv4_add);

sys/netpfil/ipfw/ip_fw_dynamic.c

1070

version = DYN_BUCKET_VERSION(bucket, ipv4_del);

sys/netpfil/ipfw/ip_fw_dynamic.c

1071

CK_SLIST_FOREACH(s, &V_dyn_ipv4[bucket], entry) {

sys/netpfil/ipfw/ip_fw_dynamic.c

1073

if (version != DYN_BUCKET_VERSION(bucket, ipv4_del))

sys/netpfil/ipfw/ip_fw_dynamic.c

1103

const void *ulp, int pktlen, uint32_t bucket, uint32_t kidx)

sys/netpfil/ipfw/ip_fw_dynamic.c

1109

DYN_BUCKET_ASSERT(bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

1110

CK_SLIST_FOREACH(s, &V_dyn_ipv4[bucket], entry) {

sys/netpfil/ipfw/ip_fw_dynamic.c

1136

uint32_t version, bucket;

sys/netpfil/ipfw/ip_fw_dynamic.c

1138

bucket = DYN_BUCKET(hashval, V_curr_dyn_buckets);

sys/netpfil/ipfw/ip_fw_dynamic.c

1140

version = DYN_BUCKET_VERSION(bucket, ipv4_parent_del);

sys/netpfil/ipfw/ip_fw_dynamic.c

1141

CK_SLIST_FOREACH(s, &V_dyn_ipv4_parent[bucket], entry) {

sys/netpfil/ipfw/ip_fw_dynamic.c

1143

if (version != DYN_BUCKET_VERSION(bucket, ipv4_parent_del))

sys/netpfil/ipfw/ip_fw_dynamic.c

1169

const void *rule, uint32_t ruleid, uint32_t rulenum, uint32_t bucket)

sys/netpfil/ipfw/ip_fw_dynamic.c

1173

DYN_BUCKET_ASSERT(bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

1174

CK_SLIST_FOREACH(s, &V_dyn_ipv4_parent[bucket], entry) {

sys/netpfil/ipfw/ip_fw_dynamic.c

1212

uint32_t version, bucket;

sys/netpfil/ipfw/ip_fw_dynamic.c

1214

bucket = DYN_BUCKET(info->hashval, V_curr_dyn_buckets);

sys/netpfil/ipfw/ip_fw_dynamic.c

1215

info->version = DYN_BUCKET_VERSION(bucket, ipv6_add);

sys/netpfil/ipfw/ip_fw_dynamic.c

1217

version = DYN_BUCKET_VERSION(bucket, ipv6_del);

sys/netpfil/ipfw/ip_fw_dynamic.c

1218

CK_SLIST_FOREACH(s, &V_dyn_ipv6[bucket], entry) {

sys/netpfil/ipfw/ip_fw_dynamic.c

1220

if (version != DYN_BUCKET_VERSION(bucket, ipv6_del))

sys/netpfil/ipfw/ip_fw_dynamic.c

1251

const void *ulp, int pktlen, uint32_t bucket, uint32_t kidx)

sys/netpfil/ipfw/ip_fw_dynamic.c

1257

DYN_BUCKET_ASSERT(bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

1258

CK_SLIST_FOREACH(s, &V_dyn_ipv6[bucket], entry) {

sys/netpfil/ipfw/ip_fw_dynamic.c

1285

uint32_t version, bucket;

sys/netpfil/ipfw/ip_fw_dynamic.c

1287

bucket = DYN_BUCKET(hashval, V_curr_dyn_buckets);

sys/netpfil/ipfw/ip_fw_dynamic.c

1289

version = DYN_BUCKET_VERSION(bucket, ipv6_parent_del);

sys/netpfil/ipfw/ip_fw_dynamic.c

1290

CK_SLIST_FOREACH(s, &V_dyn_ipv6_parent[bucket], entry) {

sys/netpfil/ipfw/ip_fw_dynamic.c

1292

if (version != DYN_BUCKET_VERSION(bucket, ipv6_parent_del))

sys/netpfil/ipfw/ip_fw_dynamic.c

1319

const void *rule, uint32_t ruleid, uint32_t rulenum, uint32_t bucket)

sys/netpfil/ipfw/ip_fw_dynamic.c

1323

DYN_BUCKET_ASSERT(bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

1324

CK_SLIST_FOREACH(s, &V_dyn_ipv6_parent[bucket], entry) {

sys/netpfil/ipfw/ip_fw_dynamic.c

1594

uint32_t bucket;

sys/netpfil/ipfw/ip_fw_dynamic.c

1596

bucket = DYN_BUCKET(hashval, V_curr_dyn_buckets);

sys/netpfil/ipfw/ip_fw_dynamic.c

1597

DYN_BUCKET_LOCK(bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

1598

if (version != DYN_BUCKET_VERSION(bucket, ipv4_parent_add)) {

sys/netpfil/ipfw/ip_fw_dynamic.c

1604

rulenum, bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

1612

DYN_BUCKET_UNLOCK(bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

1619

DYN_BUCKET_UNLOCK(bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

1625

DYN_BUCKET_UNLOCK(bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

1631

CK_SLIST_INSERT_HEAD(&V_dyn_ipv4_parent[bucket], s, entry);

sys/netpfil/ipfw/ip_fw_dynamic.c

1633

DYN_BUCKET_VERSION_BUMP(bucket, ipv4_parent_add);

sys/netpfil/ipfw/ip_fw_dynamic.c

1636

DYN_BUCKET_UNLOCK(bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

1648

uint32_t bucket;

sys/netpfil/ipfw/ip_fw_dynamic.c

1650

bucket = DYN_BUCKET(hashval, V_curr_dyn_buckets);

sys/netpfil/ipfw/ip_fw_dynamic.c

1651

DYN_BUCKET_LOCK(bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

1655

info->version != DYN_BUCKET_VERSION(bucket, ipv4_add)) {

sys/netpfil/ipfw/ip_fw_dynamic.c

1661

bucket, kidx) != 0) {

sys/netpfil/ipfw/ip_fw_dynamic.c

1662

DYN_BUCKET_UNLOCK(bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

1670

DYN_BUCKET_UNLOCK(bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

1676

DYN_BUCKET_UNLOCK(bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

1682

CK_SLIST_INSERT_HEAD(&V_dyn_ipv4[bucket], s, entry);

sys/netpfil/ipfw/ip_fw_dynamic.c

1684

DYN_BUCKET_VERSION_BUMP(bucket, ipv4_add);

sys/netpfil/ipfw/ip_fw_dynamic.c

1685

DYN_BUCKET_UNLOCK(bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

1725

uint32_t bucket;

sys/netpfil/ipfw/ip_fw_dynamic.c

1727

bucket = DYN_BUCKET(hashval, V_curr_dyn_buckets);

sys/netpfil/ipfw/ip_fw_dynamic.c

1728

DYN_BUCKET_LOCK(bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

1729

if (version != DYN_BUCKET_VERSION(bucket, ipv6_parent_add)) {

sys/netpfil/ipfw/ip_fw_dynamic.c

1735

rulenum, bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

1743

DYN_BUCKET_UNLOCK(bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

1750

DYN_BUCKET_UNLOCK(bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

1756

DYN_BUCKET_UNLOCK(bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

1762

CK_SLIST_INSERT_HEAD(&V_dyn_ipv6_parent[bucket], s, entry);

sys/netpfil/ipfw/ip_fw_dynamic.c

1764

DYN_BUCKET_VERSION_BUMP(bucket, ipv6_parent_add);

sys/netpfil/ipfw/ip_fw_dynamic.c

1767

DYN_BUCKET_UNLOCK(bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

1779

uint32_t bucket;

sys/netpfil/ipfw/ip_fw_dynamic.c

1781

bucket = DYN_BUCKET(hashval, V_curr_dyn_buckets);

sys/netpfil/ipfw/ip_fw_dynamic.c

1782

DYN_BUCKET_LOCK(bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

1786

info->version != DYN_BUCKET_VERSION(bucket, ipv6_add)) {

sys/netpfil/ipfw/ip_fw_dynamic.c

1792

bucket, kidx) != 0) {

sys/netpfil/ipfw/ip_fw_dynamic.c

1793

DYN_BUCKET_UNLOCK(bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

1801

DYN_BUCKET_UNLOCK(bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

1807

DYN_BUCKET_UNLOCK(bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

1813

CK_SLIST_INSERT_HEAD(&V_dyn_ipv6[bucket], s, entry);

sys/netpfil/ipfw/ip_fw_dynamic.c

1815

DYN_BUCKET_VERSION_BUMP(bucket, ipv6_add);

sys/netpfil/ipfw/ip_fw_dynamic.c

1816

DYN_BUCKET_UNLOCK(bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

1828

uint32_t bucket, version;

sys/netpfil/ipfw/ip_fw_dynamic.c

1832

bucket = DYN_BUCKET(hashval, V_curr_dyn_buckets);

sys/netpfil/ipfw/ip_fw_dynamic.c

1837

version = DYN_BUCKET_VERSION(bucket, ipv4_parent_add);

sys/netpfil/ipfw/ip_fw_dynamic.c

1839

rule->rulenum, bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

1860

version = DYN_BUCKET_VERSION(bucket, ipv6_parent_add);

sys/netpfil/ipfw/ip_fw_dynamic.c

1862

rule->rulenum, bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

2302

int bucket, removed, length, max_length;

sys/netpfil/ipfw/ip_fw_dynamic.c

2324

s = CK_SLIST_FIRST(&V_dyn_ ## name [bucket]); \

sys/netpfil/ipfw/ip_fw_dynamic.c

2334

&V_dyn_ ## name [bucket], entry); \

sys/netpfil/ipfw/ip_fw_dynamic.c

2361

DYN_BUCKET_VERSION_BUMP(bucket, name ## _del); \

sys/netpfil/ipfw/ip_fw_dynamic.c

2371

for (bucket = 0; bucket < V_curr_dyn_buckets; bucket++) {

sys/netpfil/ipfw/ip_fw_dynamic.c

2372

DYN_BUCKET_LOCK(bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

2381

DYN_BUCKET_UNLOCK(bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

2498

uint32_t bucket;

sys/netpfil/ipfw/ip_fw_dynamic.c

2501

for (bucket = 0; bucket < V_curr_dyn_buckets; bucket++) {

sys/netpfil/ipfw/ip_fw_dynamic.c

2502

DYN_BUCKET_LOCK(bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

2503

CK_SLIST_FOREACH(s, &V_dyn_ipv4[bucket], entry) {

sys/netpfil/ipfw/ip_fw_dynamic.c

2515

DYN_BUCKET_UNLOCK(bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

2600

uint32_t bucket;

sys/netpfil/ipfw/ip_fw_dynamic.c

2603

for (bucket = 0; bucket < V_curr_dyn_buckets; bucket++) {

sys/netpfil/ipfw/ip_fw_dynamic.c

2604

DYN_BUCKET_LOCK(bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

2605

CK_SLIST_FOREACH(s, &V_dyn_ipv6[bucket], entry) {

sys/netpfil/ipfw/ip_fw_dynamic.c

2617

DYN_BUCKET_UNLOCK(bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

2637

uint32_t bucket;

sys/netpfil/ipfw/ip_fw_dynamic.c

2702

for (bucket = 0; bucket < new; bucket++) {

sys/netpfil/ipfw/ip_fw_dynamic.c

2703

DYN_BUCKET_LOCK_INIT(bucket_lock, bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

2704

CK_SLIST_INIT(&ipv4[bucket]);

sys/netpfil/ipfw/ip_fw_dynamic.c

2705

CK_SLIST_INIT(&ipv4_parent[bucket]);

sys/netpfil/ipfw/ip_fw_dynamic.c

2707

CK_SLIST_INIT(&ipv6[bucket]);

sys/netpfil/ipfw/ip_fw_dynamic.c

2708

CK_SLIST_INIT(&ipv6_parent[bucket]);

sys/netpfil/ipfw/ip_fw_dynamic.c

2725

for (bucket = 0; bucket < V_curr_dyn_buckets; bucket++) {

sys/netpfil/ipfw/ip_fw_dynamic.c

2726

DYN_RELINK_STATES(s4, data->hashval, bucket, ipv4, ipv4);

sys/netpfil/ipfw/ip_fw_dynamic.c

2727

DYN_RELINK_STATES(s4, limit->hashval, bucket, ipv4_parent,

sys/netpfil/ipfw/ip_fw_dynamic.c

2730

DYN_RELINK_STATES(s6, data->hashval, bucket, ipv6, ipv6);

sys/netpfil/ipfw/ip_fw_dynamic.c

2731

DYN_RELINK_STATES(s6, limit->hashval, bucket, ipv6_parent,

sys/netpfil/ipfw/ip_fw_dynamic.c

2758

bucket = V_curr_dyn_buckets;

sys/netpfil/ipfw/ip_fw_dynamic.c

2764

while (bucket-- != 0)

sys/netpfil/ipfw/ip_fw_dynamic.c

2765

DYN_BUCKET_LOCK_DESTROY(bucket_lock, bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

2869

uint32_t bucket;

sys/netpfil/ipfw/ip_fw_dynamic.c

2885

for (bucket = 0; bucket < V_curr_dyn_buckets; bucket++) {

sys/netpfil/ipfw/ip_fw_dynamic.c

2886

DYN_RESET_EACTION(s4, ipv4, bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

2888

DYN_RESET_EACTION(s6, ipv6, bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

2916

uint32_t bucket;

sys/netpfil/ipfw/ip_fw_dynamic.c

2933

for (bucket = 0; bucket < V_curr_dyn_buckets; bucket++) {

sys/netpfil/ipfw/ip_fw_dynamic.c

2934

DYN_COUNT_OBJECTS(s4, ipv4, bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

2936

DYN_COUNT_OBJECTS(s6, ipv6, bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

3094

uint32_t bucket;

sys/netpfil/ipfw/ip_fw_dynamic.c

3125

for (bucket = 0; bucket < V_curr_dyn_buckets; bucket++) {

sys/netpfil/ipfw/ip_fw_dynamic.c

3126

DYN_EXPORT_STATES(s4, ipv4, ipv4_parent, bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

3127

DYN_EXPORT_STATES(s4, ipv4, ipv4, bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

3129

DYN_EXPORT_STATES(s6, ipv6, ipv6_parent, bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

3130

DYN_EXPORT_STATES(s6, ipv6, ipv6, bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

3251

int bucket;

sys/netpfil/ipfw/ip_fw_dynamic.c

3270

for (bucket = 0; bucket < V_curr_dyn_buckets; bucket++) {

sys/netpfil/ipfw/ip_fw_dynamic.c

3271

DYN_BUCKET_LOCK_DESTROY(V_dyn_bucket_lock, bucket);

sys/netpfil/ipfw/ip_fw_dynamic.c

3273

DYN_FREE_STATES_FORCED(CK_, s4, ipv4, ipv4[bucket], entry);

sys/netpfil/ipfw/ip_fw_dynamic.c

3274

DYN_FREE_STATES_FORCED(CK_, s4, ipv4, ipv4_parent[bucket],

sys/netpfil/ipfw/ip_fw_dynamic.c

3277

DYN_FREE_STATES_FORCED(CK_, s6, ipv6, ipv6[bucket], entry);

sys/netpfil/ipfw/ip_fw_dynamic.c

3278

DYN_FREE_STATES_FORCED(CK_, s6, ipv6, ipv6_parent[bucket],

sys/netpfil/pf/pf_ioctl.c

1737

uint64_t bucket = SEC_TO_NSEC(pfstlim->pfstlim_rate.seconds);

sys/netpfil/pf/pf_ioctl.c

1743

bucket;

sys/netpfil/pf/pf_ioctl.c

1744

pfstlim->pfstlim_rate_token = bucket /

sys/netpfil/pf/pf_ioctl.c

1746

pfstlim->pfstlim_rate_bucket = bucket;

sys/netpfil/pf/pf_ioctl.c

2190

uint64_t bucket = pfsrlim->pfsrlim_rate.seconds * 1000000000ULL;

sys/netpfil/pf/pf_ioctl.c

2192

pfsrlim->pfsrlim_rate_token = bucket /

sys/netpfil/pf/pf_ioctl.c

2194

pfsrlim->pfsrlim_rate_bucket = bucket;

sys/ofed/drivers/infiniband/core/ib_fmr_pool.c

122

struct hlist_head *bucket;

sys/ofed/drivers/infiniband/core/ib_fmr_pool.c

128

bucket = pool->cache_bucket + ib_fmr_hash(*page_list);

sys/ofed/drivers/infiniband/core/ib_fmr_pool.c

130

hlist_for_each_entry(fmr, bucket, cache_node)

sys/vm/uma_core.c

1050

uma_bucket_t bucket;

sys/vm/uma_core.c

1069

if ((bucket = zone_fetch_bucket(zone, zdom, false)) != NULL)

sys/vm/uma_core.c

1070

return (bucket);

sys/vm/uma_core.c

1344

bucket_drain(uma_zone_t zone, uma_bucket_t bucket)

sys/vm/uma_core.c

1348

if (bucket->ub_cnt == 0)

sys/vm/uma_core.c

1352

bucket->ub_seq != SMR_SEQ_INVALID) {

sys/vm/uma_core.c

1353

smr_wait(zone->uz_smr, bucket->ub_seq);

sys/vm/uma_core.c

1354

bucket->ub_seq = SMR_SEQ_INVALID;

sys/vm/uma_core.c

1355

for (i = 0; i < bucket->ub_cnt; i++)

sys/vm/uma_core.c

1356

item_dtor(zone, bucket->ub_bucket[i],

sys/vm/uma_core.c

1360

for (i = 0; i < bucket->ub_cnt; i++) {

sys/vm/uma_core.c

1361

kasan_mark_item_valid(zone, bucket->ub_bucket[i]);

sys/vm/uma_core.c

1362

zone->uz_fini(bucket->ub_bucket[i], zone->uz_size);

sys/vm/uma_core.c

1363

kasan_mark_item_invalid(zone, bucket->ub_bucket[i]);

sys/vm/uma_core.c

1365

zone->uz_release(zone->uz_arg, bucket->ub_bucket, bucket->ub_cnt);

sys/vm/uma_core.c

1367

zone_free_limit(zone, bucket->ub_cnt);

sys/vm/uma_core.c

1369

bzero(bucket->ub_bucket, sizeof(void *) * bucket->ub_cnt);

sys/vm/uma_core.c

1371

bucket->ub_cnt = 0;

sys/vm/uma_core.c

1391

uma_bucket_t bucket;

sys/vm/uma_core.c

1408

bucket = cache_bucket_unload_alloc(cache);

sys/vm/uma_core.c

1409

if (bucket != NULL)

sys/vm/uma_core.c

1410

bucket_free(zone, bucket, NULL);

sys/vm/uma_core.c

1411

bucket = cache_bucket_unload_free(cache);

sys/vm/uma_core.c

1412

if (bucket != NULL) {

sys/vm/uma_core.c

1413

bucket->ub_seq = seq;

sys/vm/uma_core.c

1414

bucket_free(zone, bucket, NULL);

sys/vm/uma_core.c

1416

bucket = cache_bucket_unload_cross(cache);

sys/vm/uma_core.c

1417

if (bucket != NULL) {

sys/vm/uma_core.c

1418

bucket->ub_seq = seq;

sys/vm/uma_core.c

1419

bucket_free(zone, bucket, NULL);

sys/vm/uma_core.c

1519

uma_bucket_t bucket;

sys/vm/uma_core.c

1530

bucket = zdom->uzd_cross;

sys/vm/uma_core.c

1533

if (bucket != NULL)

sys/vm/uma_core.c

1534

bucket_free(zone, bucket, NULL);

sys/vm/uma_core.c

1557

while ((bucket = STAILQ_FIRST(&zdom->uzd_buckets)) != NULL &&

sys/vm/uma_core.c

1558

zdom->uzd_nitems >= target + bucket->ub_cnt) {

sys/vm/uma_core.c

1559

bucket = zone_fetch_bucket(zone, zdom, true);

sys/vm/uma_core.c

1560

if (bucket == NULL)

sys/vm/uma_core.c

1562

bucket_free(zone, bucket, NULL);

sys/vm/uma_core.c

303

static void zone_free_bucket(uma_zone_t zone, uma_bucket_t bucket, void *udata,

sys/vm/uma_core.c

3669

cache_alloc_item(uma_zone_t zone, uma_cache_t cache, uma_cache_bucket_t bucket,

sys/vm/uma_core.c

3675

item = cache_bucket_pop(cache, bucket);

sys/vm/uma_core.c

3685

uma_cache_bucket_t bucket;

sys/vm/uma_core.c

3690

bucket = &cache->uc_allocbucket;

sys/vm/uma_core.c

3691

if (__predict_false(bucket->ucb_cnt == 0))

sys/vm/uma_core.c

3693

return (cache_alloc_item(zone, cache, bucket, udata, flags));

sys/vm/uma_core.c

3711

uma_cache_bucket_t bucket;

sys/vm/uma_core.c

3728

bucket = &cache->uc_allocbucket;

sys/vm/uma_core.c

3729

if (__predict_false(bucket->ucb_cnt == 0))

sys/vm/uma_core.c

3731

return (cache_alloc_item(zone, cache, bucket, NULL, flags));

sys/vm/uma_core.c

3738

uma_cache_bucket_t bucket;

sys/vm/uma_core.c

3770

bucket = &cache->uc_allocbucket;

sys/vm/uma_core.c

3771

if (__predict_false(bucket->ucb_cnt == 0))

sys/vm/uma_core.c

3773

return (cache_alloc_item(zone, cache, bucket, udata, flags));

sys/vm/uma_core.c

3786

uma_bucket_t bucket;

sys/vm/uma_core.c

3809

bucket = cache_bucket_unload_alloc(cache);

sys/vm/uma_core.c

3812

if (bucket != NULL) {

sys/vm/uma_core.c

3813

KASSERT(bucket->ub_cnt == 0,

sys/vm/uma_core.c

3815

bucket_free(zone, bucket, udata);

sys/vm/uma_core.c

3831

bucket = cache_fetch_bucket(zone, cache, domain);

sys/vm/uma_core.c

3832

if (bucket == NULL && zone->uz_bucket_size != 0 && !bucketdisable) {

sys/vm/uma_core.c

3833

bucket = zone_alloc_bucket(zone, udata, domain, flags);

sys/vm/uma_core.c

3840

zone->uz_name, zone, bucket);

sys/vm/uma_core.c

3841

if (bucket == NULL) {

sys/vm/uma_core.c

3859

bucket->ub_cnt);

sys/vm/uma_core.c

3860

cache_bucket_load_alloc(cache, bucket);

sys/vm/uma_core.c

3868

zone_put_bucket(zone, domain, bucket, udata, !new);

sys/vm/uma_core.c

3878

uma_bucket_t bucket;

sys/vm/uma_core.c

3912

if ((bucket = zone_fetch_bucket(zone, zdom, false)) != NULL) {

sys/vm/uma_core.c

3913

item = bucket->ub_bucket[bucket->ub_cnt - 1];

sys/vm/uma_core.c

3915

bucket->ub_bucket[bucket->ub_cnt - 1] = NULL;

sys/vm/uma_core.c

3917

bucket->ub_cnt--;

sys/vm/uma_core.c

3918

zone_put_bucket(zone, domain, bucket, udata, true);

sys/vm/uma_core.c

4095

zone_import(void *arg, void **bucket, int max, int domain, int flags)

sys/vm/uma_core.c

4118

bucket[i++] = slab_alloc_item(keg, slab);

sys/vm/uma_core.c

4309

uma_bucket_t bucket;

sys/vm/uma_core.c

4330

bucket = bucket_alloc(zone, udata, M_NOWAIT | (flags & M_NOVM));

sys/vm/uma_core.c

4331

if (bucket == NULL) {

sys/vm/uma_core.c

4336

bucket->ub_cnt = zone->uz_import(zone->uz_arg, bucket->ub_bucket,

sys/vm/uma_core.c

4337

MIN(maxbucket, bucket->ub_entries), domain, flags);

sys/vm/uma_core.c

4342

if (bucket->ub_cnt != 0 && zone->uz_init != NULL) {

sys/vm/uma_core.c

4345

for (i = 0; i < bucket->ub_cnt; i++) {

sys/vm/uma_core.c

4346

kasan_mark_item_valid(zone, bucket->ub_bucket[i]);

sys/vm/uma_core.c

4347

error = zone->uz_init(bucket->ub_bucket[i],

sys/vm/uma_core.c

4349

kasan_mark_item_invalid(zone, bucket->ub_bucket[i]);

sys/vm/uma_core.c

4358

if (i != bucket->ub_cnt) {

sys/vm/uma_core.c

4359

zone->uz_release(zone->uz_arg, &bucket->ub_bucket[i],

sys/vm/uma_core.c

4360

bucket->ub_cnt - i);

sys/vm/uma_core.c

4362

bzero(&bucket->ub_bucket[i],

sys/vm/uma_core.c

4363

sizeof(void *) * (bucket->ub_cnt - i));

sys/vm/uma_core.c

4365

bucket->ub_cnt = i;

sys/vm/uma_core.c

4369

cnt = bucket->ub_cnt;

sys/vm/uma_core.c

4370

if (bucket->ub_cnt == 0) {

sys/vm/uma_core.c

4371

bucket_free(zone, bucket, udata);

sys/vm/uma_core.c

4373

bucket = NULL;

sys/vm/uma_core.c

4379

return (bucket);

sys/vm/uma_core.c

4457

uma_cache_bucket_t bucket;

sys/vm/uma_core.c

4485

bucket = &cache->uc_freebucket;

sys/vm/uma_core.c

4489

bucket = &cache->uc_crossbucket;

sys/vm/uma_core.c

4492

if (__predict_true(bucket->ucb_cnt < bucket->ucb_entries)) {

sys/vm/uma_core.c

4493

cache_bucket_push(cache, bucket, item);

sys/vm/uma_core.c

4511

uma_cache_bucket_t bucket;

sys/vm/uma_core.c

4575

bucket = &cache->uc_allocbucket;

sys/vm/uma_core.c

4579

bucket = &cache->uc_crossbucket;

sys/vm/uma_core.c

4582

if (bucket->ucb_cnt == bucket->ucb_entries &&

sys/vm/uma_core.c

4587

if (__predict_true(bucket->ucb_cnt < bucket->ucb_entries)) {

sys/vm/uma_core.c

4588

cache_bucket_push(cache, bucket, item);

sys/vm/uma_core.c

4608

zone_free_cross(uma_zone_t zone, uma_bucket_t bucket, void *udata)

sys/vm/uma_core.c

4619

zone->uz_name, zone, bucket);

sys/vm/uma_core.c

4637

for (; bucket->ub_cnt > 0; bucket->ub_cnt--) {

sys/vm/uma_core.c

4638

item = bucket->ub_bucket[bucket->ub_cnt - 1];

sys/vm/uma_core.c

466

uma_bucket_t bucket;

sys/vm/uma_core.c

4677

if (bucket->ub_cnt == 0)

sys/vm/uma_core.c

4678

bucket->ub_seq = SMR_SEQ_INVALID;

sys/vm/uma_core.c

4679

bucket_free(zone, bucket, udata);

sys/vm/uma_core.c

4694

zone_free_bucket(uma_zone_t zone, uma_bucket_t bucket, void *udata,

sys/vm/uma_core.c

4707

zone_free_cross(zone, bucket, udata);

sys/vm/uma_core.c

4717

zone->uz_name, zone, bucket);

sys/vm/uma_core.c

4721

zone_put_bucket(zone, itemdomain, bucket, udata, ws);

sys/vm/uma_core.c

4736

uma_bucket_t newbucket, bucket;

sys/vm/uma_core.c

4762

bucket = cache_bucket_unload(cbucket);

sys/vm/uma_core.c

4763

KASSERT(bucket == NULL || bucket->ub_cnt == bucket->ub_entries,

sys/vm/uma_core.c

4776

if (bucket != NULL)

sys/vm/uma_core.c

4777

bucket->ub_seq = smr_advance(zone->uz_smr);

sys/vm/uma_core.c

4779

if (newbucket == NULL && bucket != NULL) {

sys/vm/uma_core.c

4780

bucket_drain(zone, bucket);

sys/vm/uma_core.c

4781

newbucket = bucket;

sys/vm/uma_core.c

4782

bucket = NULL;

sys/vm/uma_core.c

4787

if (bucket != NULL)

sys/vm/uma_core.c

4788

zone_free_bucket(zone, bucket, udata, itemdomain, true);

sys/vm/uma_core.c

4791

if ((bucket = newbucket) == NULL)

sys/vm/uma_core.c

4803

cache_bucket_load_cross(cache, bucket);

sys/vm/uma_core.c

4813

bucket_free(zone, bucket, udata);

sys/vm/uma_core.c

4816

cache_bucket_load_free(cache, bucket);

sys/vm/uma_core.c

4852

zone_release(void *arg, void **bucket, int cnt)

sys/vm/uma_core.c

4868

item = bucket[i];

sys/vm/uma_core.c

496

bucket = uma_zalloc_arg(ubz->ubz_zone, udata, flags);

sys/vm/uma_core.c

497

if (bucket) {

sys/vm/uma_core.c

499

bzero(bucket->ub_bucket, sizeof(void *) * ubz->ubz_entries);

sys/vm/uma_core.c

501

bucket->ub_cnt = 0;

sys/vm/uma_core.c

502

bucket->ub_entries = min(ubz->ubz_entries,

sys/vm/uma_core.c

504

bucket->ub_seq = SMR_SEQ_INVALID;

sys/vm/uma_core.c

506

zone->uz_name, zone, bucket);

sys/vm/uma_core.c

509

return (bucket);

sys/vm/uma_core.c

513

bucket_free(uma_zone_t zone, uma_bucket_t bucket, void *udata)

sys/vm/uma_core.c

517

if (bucket->ub_cnt != 0)

sys/vm/uma_core.c

518

bucket_drain(zone, bucket);

sys/vm/uma_core.c

520

KASSERT(bucket->ub_cnt == 0,

sys/vm/uma_core.c

522

KASSERT(bucket->ub_seq == SMR_SEQ_INVALID,

sys/vm/uma_core.c

526

ubz = bucket_zone_lookup(bucket->ub_entries);

sys/vm/uma_core.c

527

uma_zfree_arg(ubz->ubz_zone, bucket, udata);

sys/vm/uma_core.c

792

uma_bucket_t bucket;

sys/vm/uma_core.c

799

if ((bucket = STAILQ_FIRST(&zdom->uzd_buckets)) == NULL)

sys/vm/uma_core.c

804

bucket->ub_seq != SMR_SEQ_INVALID) {

sys/vm/uma_core.c

805

if (!smr_poll(zone->uz_smr, bucket->ub_seq, false))

sys/vm/uma_core.c

807

bucket->ub_seq = SMR_SEQ_INVALID;

sys/vm/uma_core.c

809

if (STAILQ_NEXT(bucket, ub_link) != NULL)

sys/vm/uma_core.c

810

zdom->uzd_seq = STAILQ_NEXT(bucket, ub_link)->ub_seq;

sys/vm/uma_core.c

814

KASSERT(zdom->uzd_nitems >= bucket->ub_cnt,

sys/vm/uma_core.c

816

__func__, zdom->uzd_nitems, bucket->ub_cnt));

sys/vm/uma_core.c

817

KASSERT(bucket->ub_cnt > 0,

sys/vm/uma_core.c

819

zdom->uzd_nitems -= bucket->ub_cnt;

sys/vm/uma_core.c

826

cnt = lmin(zdom->uzd_bimin, bucket->ub_cnt);

sys/vm/uma_core.c

829

zdom->uzd_imin -= lmin(zdom->uzd_imin, bucket->ub_cnt);

sys/vm/uma_core.c

830

if (zdom->uzd_limin >= bucket->ub_cnt) {

sys/vm/uma_core.c

831

zdom->uzd_limin -= bucket->ub_cnt;

sys/vm/uma_core.c

844

for (i = 0; i < bucket->ub_cnt; i++)

sys/vm/uma_core.c

845

item_dtor(zone, bucket->ub_bucket[i], zone->uz_size,

sys/vm/uma_core.c

848

return (bucket);

sys/vm/uma_core.c

857

zone_put_bucket(uma_zone_t zone, int domain, uma_bucket_t bucket, void *udata,

sys/vm/uma_core.c

863

if (bucket->ub_cnt == 0)

sys/vm/uma_core.c

870

zdom->uzd_nitems += bucket->ub_cnt;

sys/vm/uma_core.c

879

atomic_add_long(&zdom->uzd_imax, bucket->ub_cnt);

sys/vm/uma_core.c

880

zdom->uzd_imin += bucket->ub_cnt;

sys/vm/uma_core.c

881

zdom->uzd_bimin += bucket->ub_cnt;

sys/vm/uma_core.c

882

zdom->uzd_limin += bucket->ub_cnt;

sys/vm/uma_core.c

885

zdom->uzd_seq = bucket->ub_seq;

sys/vm/uma_core.c

891

if (bucket->ub_seq == SMR_SEQ_INVALID)

sys/vm/uma_core.c

892

STAILQ_INSERT_HEAD(&zdom->uzd_buckets, bucket, ub_link);

sys/vm/uma_core.c

894

STAILQ_INSERT_TAIL(&zdom->uzd_buckets, bucket, ub_link);

sys/vm/uma_core.c

898

zdom->uzd_nitems -= bucket->ub_cnt;

sys/vm/uma_core.c

901

bucket_free(zone, bucket, udata);

sys/vm/uma_core.c

906

cache_bucket_pop(uma_cache_t cache, uma_cache_bucket_t bucket)

sys/vm/uma_core.c

912

bucket->ucb_cnt--;

sys/vm/uma_core.c

913

item = bucket->ucb_bucket->ub_bucket[bucket->ucb_cnt];

sys/vm/uma_core.c

915

bucket->ucb_bucket->ub_bucket[bucket->ucb_cnt] = NULL;

sys/vm/uma_core.c

925

cache_bucket_push(uma_cache_t cache, uma_cache_bucket_t bucket, void *item)

sys/vm/uma_core.c

929

KASSERT(bucket->ucb_bucket->ub_bucket[bucket->ucb_cnt] == NULL,

sys/vm/uma_core.c

932

bucket->ucb_bucket->ub_bucket[bucket->ucb_cnt] = item;

sys/vm/uma_core.c

933

bucket->ucb_cnt++;

sys/vm/uma_core.c

941

cache_bucket_unload(uma_cache_bucket_t bucket)

sys/vm/uma_core.c

945

b = bucket->ucb_bucket;

sys/vm/uma_core.c

947

MPASS(b->ub_entries == bucket->ucb_entries);

sys/vm/uma_core.c

948

b->ub_cnt = bucket->ucb_cnt;

sys/vm/uma_core.c

949

bucket->ucb_bucket = NULL;

sys/vm/uma_core.c

950

bucket->ucb_entries = bucket->ucb_cnt = 0;

sys/vm/uma_core.c

981

cache_bucket_load(uma_cache_bucket_t bucket, uma_bucket_t b)

sys/vm/uma_core.c

985

MPASS(bucket->ucb_bucket == NULL);

sys/vm/uma_core.c

988

bucket->ucb_bucket = b;

sys/vm/uma_core.c

989

bucket->ucb_cnt = b->ub_cnt;

sys/vm/uma_core.c

990

bucket->ucb_entries = b->ub_entries;

usr.bin/mkstr/mkstr.c

261

} *bucket[NBUCKETS];

usr.bin/mkstr/mkstr.c

280

for (hp = bucket[i]; hp != 0; hp = hp->hnext)

usr.bin/mkstr/mkstr.c

294

hp->hnext = bucket[i];

usr.bin/mkstr/mkstr.c

301

bucket[i] = hp;

usr.bin/xstr/xstr.c

327

} bucket[BUCKETS];

usr.bin/xstr/xstr.c

335

hp = hp0 = &bucket[lastchr(str) & 0177];

usr.bin/xstr/xstr.c

363

for (hp = bucket[i].hnext; hp != NULL; hp = hp->hnext)

usr.bin/xstr/xstr.c

374

for (hp = bucket[i].hnext; hp != NULL; hp = hp->hnext) {

usr.sbin/pmcstat/pmcpl_gprof.c

417

uintfptr_t bucket;

usr.sbin/pmcstat/pmcpl_gprof.c

498

bucket = (cc[0] - map->ppm_lowpc) / FUNCTION_ALIGNMENT;

usr.sbin/pmcstat/pmcpl_gprof.c

500

assert(bucket < pgf->pgf_nbuckets);

usr.sbin/pmcstat/pmcpl_gprof.c

507

if (whc[bucket] < WIDEHISTCOUNTER_MAX)

usr.sbin/pmcstat/pmcpl_gprof.c

508

whc[bucket]++;

usr.sbin/pmcstat/pmcpl_gprof.c

516

if (hc[bucket] < HISTCOUNTER_MAX)

usr.sbin/pmcstat/pmcpl_gprof.c

517

hc[bucket]++;

usr.sbin/ppp/mbuf.c

63

} *bucket[(M_MAXLEN + sizeof(struct mbuf)) / BUCKET_HASH];

usr.sbin/ppp/mbuf.c

66

#define M_BUCKET(sz) (bucket + M_BINDEX(sz))