arch/hexagon/kernel/ptrace.c

108

INEXT(&bucket, cause);

arch/hexagon/kernel/ptrace.c

109

INEXT(&bucket, badva);

arch/hexagon/kernel/ptrace.c

78

unsigned long bucket;

arch/riscv/kernel/module.c

21

struct hlist_head *bucket;

arch/riscv/kernel/module.c

632

bucket_iter->bucket, node) {

arch/riscv/kernel/module.c

663

struct used_bucket *bucket;

arch/riscv/kernel/module.c

711

bucket =

arch/riscv/kernel/module.c

714

if (!bucket) {

arch/riscv/kernel/module.c

720

INIT_LIST_HEAD(&bucket->head);

arch/riscv/kernel/module.c

721

bucket->bucket = current_head;

arch/riscv/kernel/module.c

722

list_add(&bucket->head, used_buckets_list);

arch/sparc/kernel/irq_64.c

206

struct ino_bucket bucket;

arch/sparc/kernel/irq_64.c

257

struct ino_bucket *bucket;

arch/sparc/kernel/irq_64.c

268

bucket = (struct ino_bucket *) __va(cookie);

arch/sparc/kernel/irq_64.c

269

irq = bucket->__irq;

arch/sparc/kernel/irq_64.c

278

struct ino_bucket *bucket;

arch/sparc/kernel/irq_64.c

281

bucket = &ivector_table[sysino];

arch/sparc/kernel/irq_64.c

282

irq = bucket_get_irq(__pa(bucket));

arch/sparc/kernel/irq_64.c

611

struct ino_bucket *bucket;

arch/sparc/kernel/irq_64.c

618

bucket = &ivector_table[ino];

arch/sparc/kernel/irq_64.c

619

irq = bucket_get_irq(__pa(bucket));

arch/sparc/kernel/irq_64.c

622

bucket_set_irq(__pa(bucket), irq);

arch/sparc/kernel/irq_64.c

683

ihd->bucket.__irq = irq;

arch/sparc/kernel/irq_64.c

684

cookie = ~__pa(&ihd->bucket);

arch/sparc/kernel/irq_64.c

734

struct ino_bucket *bucket;

arch/sparc/kernel/irq_64.c

739

bucket = &ivector_table[sysino];

arch/sparc/kernel/irq_64.c

740

bucket_set_irq(__pa(bucket), irq);

arch/x86/kernel/apm_32.c

910

unsigned int bucket;

arch/x86/kernel/apm_32.c

930

bucket = IDLE_LEAKY_MAX;

arch/x86/kernel/apm_32.c

941

if (bucket) {

arch/x86/kernel/apm_32.c

942

bucket = IDLE_LEAKY_MAX;

arch/x86/kernel/apm_32.c

945

} else if (bucket) {

arch/x86/kernel/apm_32.c

946

bucket--;

block/blk-stat.c

135

unsigned int bucket;

block/blk-stat.c

143

for (bucket = 0; bucket < cb->buckets; bucket++)

block/blk-stat.c

144

blk_rq_stat_init(&cpu_stat[bucket]);

block/blk-stat.c

55

int bucket, cpu;

block/blk-stat.c

66

bucket = cb->bucket_fn(rq);

block/blk-stat.c

67

if (bucket < 0)

block/blk-stat.c

70

stat = &per_cpu_ptr(cb->cpu_stat, cpu)[bucket];

block/blk-stat.c

80

unsigned int bucket;

block/blk-stat.c

83

for (bucket = 0; bucket < cb->buckets; bucket++)

block/blk-stat.c

84

blk_rq_stat_init(&cb->stat[bucket]);

block/blk-stat.c

90

for (bucket = 0; bucket < cb->buckets; bucket++) {

block/blk-stat.c

91

blk_rq_stat_sum(&cb->stat[bucket], &cpu_stat[bucket]);

block/blk-stat.c

92

blk_rq_stat_init(&cpu_stat[bucket]);

block/kyber-iosched.c

209

unsigned int bucket;

block/kyber-iosched.c

211

for (bucket = 0; bucket < KYBER_LATENCY_BUCKETS; bucket++)

block/kyber-iosched.c

212

buckets[bucket] += atomic_xchg(&cpu_buckets[bucket], 0);

block/kyber-iosched.c

224

unsigned int bucket, samples = 0, percentile_samples;

block/kyber-iosched.c

226

for (bucket = 0; bucket < KYBER_LATENCY_BUCKETS; bucket++)

block/kyber-iosched.c

227

samples += buckets[bucket];

block/kyber-iosched.c

245

for (bucket = 0; bucket < KYBER_LATENCY_BUCKETS - 1; bucket++) {

block/kyber-iosched.c

246

if (buckets[bucket] >= percentile_samples)

block/kyber-iosched.c

248

percentile_samples -= buckets[bucket];

block/kyber-iosched.c

254

bucket + 1, 1 << KYBER_LATENCY_SHIFT, samples);

block/kyber-iosched.c

256

return bucket;

block/kyber-iosched.c

611

unsigned int bucket;

block/kyber-iosched.c

616

bucket = min_t(unsigned int, div64_u64(latency - 1, divisor),

block/kyber-iosched.c

619

bucket = 0;

block/kyber-iosched.c

622

atomic_inc(&cpu_latency->buckets[sched_domain][type][bucket]);

drivers/cpuidle/governors/menu.c

253

data->bucket = which_bucket(data->next_timer_ns);

drivers/cpuidle/governors/menu.c

258

data->correction_factor[data->bucket],

drivers/cpuidle/governors/menu.c

284

data->bucket = BUCKETS - 1;

drivers/cpuidle/governors/menu.c

478

new_factor = data->correction_factor[data->bucket];

drivers/cpuidle/governors/menu.c

500

data->correction_factor[data->bucket] = new_factor;

drivers/cpuidle/governors/menu.c

75

unsigned int bucket;

drivers/cpuidle/governors/menu.c

83

int bucket = 0;

drivers/cpuidle/governors/menu.c

86

return bucket;

drivers/cpuidle/governors/menu.c

88

return bucket + 1;

drivers/cpuidle/governors/menu.c

90

return bucket + 2;

drivers/cpuidle/governors/menu.c

92

return bucket + 3;

drivers/cpuidle/governors/menu.c

94

return bucket + 4;

drivers/cpuidle/governors/menu.c

95

return bucket + 5;

drivers/crypto/nx/nx-common-pseries.c

155

int bucket = fls(time);

drivers/crypto/nx/nx-common-pseries.c

157

if (bucket)

drivers/crypto/nx/nx-common-pseries.c

158

bucket = min((NX842_HIST_SLOTS - 1), bucket - 1);

drivers/crypto/nx/nx-common-pseries.c

160

atomic64_inc(&times[bucket]);

drivers/gpu/drm/radeon/radeon_cs.c

48

struct list_head bucket[RADEON_CS_NUM_BUCKETS];

drivers/gpu/drm/radeon/radeon_cs.c

56

INIT_LIST_HEAD(&b->bucket[i]);

drivers/gpu/drm/radeon/radeon_cs.c

67

list_add_tail(item, &b->bucket[min(priority, RADEON_CS_MAX_PRIORITY)]);

drivers/gpu/drm/radeon/radeon_cs.c

77

list_splice(&b->bucket[i], out_list);

drivers/infiniband/sw/rdmavt/trace_qp.h

18

TP_PROTO(struct rvt_qp *qp, u32 bucket),

drivers/infiniband/sw/rdmavt/trace_qp.h

19

TP_ARGS(qp, bucket),

drivers/infiniband/sw/rdmavt/trace_qp.h

23

__field(u32, bucket)

drivers/infiniband/sw/rdmavt/trace_qp.h

28

__entry->bucket = bucket;

drivers/infiniband/sw/rdmavt/trace_qp.h

34

__entry->bucket

drivers/infiniband/sw/rdmavt/trace_qp.h

39

TP_PROTO(struct rvt_qp *qp, u32 bucket),

drivers/infiniband/sw/rdmavt/trace_qp.h

40

TP_ARGS(qp, bucket));

drivers/infiniband/sw/rdmavt/trace_qp.h

43

TP_PROTO(struct rvt_qp *qp, u32 bucket),

drivers/infiniband/sw/rdmavt/trace_qp.h

44

TP_ARGS(qp, bucket));

drivers/interconnect/qcom/bcm-voter.c

102

temp = bcm_div(node->sum_avg[bucket] * bcm->aux_data.width,

drivers/interconnect/qcom/bcm-voter.c

104

agg_avg[bucket] = max(agg_avg[bucket], temp);

drivers/interconnect/qcom/bcm-voter.c

106

temp = bcm_div(node->max_peak[bucket] * bcm->aux_data.width,

drivers/interconnect/qcom/bcm-voter.c

108

agg_peak[bucket] = max(agg_peak[bucket], temp);

drivers/interconnect/qcom/bcm-voter.c

111

temp = agg_avg[bucket] * bcm->vote_scale;

drivers/interconnect/qcom/bcm-voter.c

112

bcm->vote_x[bucket] = bcm_div(temp, bcm->aux_data.unit);

drivers/interconnect/qcom/bcm-voter.c

114

temp = agg_peak[bucket] * bcm->vote_scale;

drivers/interconnect/qcom/bcm-voter.c

115

bcm->vote_y[bucket] = bcm_div(temp, bcm->aux_data.unit);

drivers/interconnect/qcom/bcm-voter.c

156

static void tcs_list_gen(struct bcm_voter *voter, int bucket,

drivers/interconnect/qcom/bcm-voter.c

176

wait = commit && (voter->tcs_wait & BIT(bucket));

drivers/interconnect/qcom/bcm-voter.c

178

tcs_cmd_gen(&tcs_list[idx], bcm->vote_x[bucket],

drivers/interconnect/qcom/bcm-voter.c

179

bcm->vote_y[bucket], bcm->addr, commit, wait);

drivers/interconnect/qcom/bcm-voter.c

65

int bucket, i;

drivers/interconnect/qcom/bcm-voter.c

67

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

drivers/interconnect/qcom/bcm-voter.c

68

bcm->vote_x[bucket] = 0;

drivers/interconnect/qcom/bcm-voter.c

69

bcm->vote_y[bucket] = 0;

drivers/interconnect/qcom/bcm-voter.c

75

if (node->sum_avg[bucket] || node->max_peak[bucket]) {

drivers/interconnect/qcom/bcm-voter.c

76

bcm->vote_x[bucket] = 0;

drivers/interconnect/qcom/bcm-voter.c

77

bcm->vote_y[bucket] = bcm->enable_mask;

drivers/interconnect/qcom/bcm-voter.c

94

size_t i, bucket;

drivers/interconnect/qcom/bcm-voter.c

99

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

drivers/md/bcache/alloc.c

121

static inline bool can_inc_bucket_gen(struct bucket *b)

drivers/md/bcache/alloc.c

126

bool bch_can_invalidate_bucket(struct cache *ca, struct bucket *b)

drivers/md/bcache/alloc.c

133

void __bch_invalidate_one_bucket(struct cache *ca, struct bucket *b)

drivers/md/bcache/alloc.c

147

static void bch_invalidate_one_bucket(struct cache *ca, struct bucket *b)

drivers/md/bcache/alloc.c

175

struct bucket *b;

drivers/md/bcache/alloc.c

212

struct bucket *b;

drivers/md/bcache/alloc.c

235

struct bucket *b;

drivers/md/bcache/alloc.c

296

static int bch_allocator_push(struct cache *ca, long bucket)

drivers/md/bcache/alloc.c

301

if (fifo_push(&ca->free[RESERVE_PRIO], bucket))

drivers/md/bcache/alloc.c

305

if (fifo_push(&ca->free[i], bucket))

drivers/md/bcache/alloc.c

323

long bucket;

drivers/md/bcache/alloc.c

325

if (!fifo_pop(&ca->free_inc, bucket))

drivers/md/bcache/alloc.c

328

allocator_wait(ca, bch_allocator_push(ca, bucket));

drivers/md/bcache/alloc.c

379

struct bucket *b;

drivers/md/bcache/alloc.c

457

void __bch_bucket_free(struct cache *ca, struct bucket *b)

drivers/md/bcache/alloc.c

73

uint8_t bch_inc_gen(struct cache *ca, struct bucket *b)

drivers/md/bcache/alloc.c

86

struct bucket *b;

drivers/md/bcache/bcache.h

211

BITMASK(GC_MARK, struct bucket, gc_mark, 0, 2);

drivers/md/bcache/bcache.h

217

BITMASK(GC_SECTORS_USED, struct bucket, gc_mark, 2, GC_SECTORS_USED_SIZE);

drivers/md/bcache/bcache.h

218

BITMASK(GC_MOVE, struct bucket, gc_mark, 15, 1);

drivers/md/bcache/bcache.h

460

struct bucket *buckets;

drivers/md/bcache/bcache.h

462

DECLARE_HEAP(struct bucket *, heap);

drivers/md/bcache/bcache.h

827

static inline struct bucket *PTR_BUCKET(struct cache_set *c,

drivers/md/bcache/bcache.h

923

static inline uint8_t bucket_gc_gen(struct bucket *b)

drivers/md/bcache/bcache.h

987

uint8_t bch_inc_gen(struct cache *ca, struct bucket *b);

drivers/md/bcache/bcache.h

990

bool bch_can_invalidate_bucket(struct cache *ca, struct bucket *b);

drivers/md/bcache/bcache.h

991

void __bch_invalidate_one_bucket(struct cache *ca, struct bucket *b);

drivers/md/bcache/bcache.h

993

void __bch_bucket_free(struct cache *ca, struct bucket *b);

drivers/md/bcache/btree.c

1231

struct bucket *g;

drivers/md/bcache/btree.c

1287

struct bucket *b = PTR_BUCKET(c, k, i);

drivers/md/bcache/btree.c

1734

struct bucket *b;

drivers/md/bcache/btree.c

1760

struct bucket *b;

drivers/md/bcache/btree.c

2128

struct bucket *b;

drivers/md/bcache/extents.c

177

struct bucket *g;

drivers/md/bcache/extents.c

510

struct bucket *g = PTR_BUCKET(b->c, k, ptr);

drivers/md/bcache/extents.c

54

size_t bucket = PTR_BUCKET_NR(c, k, i);

drivers/md/bcache/extents.c

58

bucket < ca->sb.first_bucket ||

drivers/md/bcache/extents.c

59

bucket >= ca->sb.nbuckets)

drivers/md/bcache/extents.c

75

size_t bucket = PTR_BUCKET_NR(c, k, i);

drivers/md/bcache/extents.c

80

if (bucket < ca->sb.first_bucket)

drivers/md/bcache/extents.c

82

if (bucket >= ca->sb.nbuckets)

drivers/md/bcache/journal.c

46

sector_t bucket = bucket_to_sector(ca->set, ca->sb.d[bucket_index]);

drivers/md/bcache/journal.c

57

bio->bi_iter.bi_sector = bucket + offset;

drivers/md/bcache/movinggc.c

185

static bool bucket_cmp(struct bucket *l, struct bucket *r)

drivers/md/bcache/movinggc.c

192

struct bucket *b;

drivers/md/bcache/movinggc.c

200

struct bucket *b;

drivers/md/bcache/super.c

2248

struct bucket *b;

drivers/md/bcache/super.c

2338

ca->buckets = vzalloc(array_size(sizeof(struct bucket),

drivers/md/bcache/super.c

590

static void prio_io(struct cache *ca, uint64_t bucket, blk_opf_t opf)

drivers/md/bcache/super.c

597

bio->bi_iter.bi_sector = bucket * ca->sb.bucket_size;

drivers/md/bcache/super.c

613

struct bucket *b;

drivers/md/bcache/super.c

643

long bucket;

drivers/md/bcache/super.c

659

bucket = bch_bucket_alloc(ca, RESERVE_PRIO, wait);

drivers/md/bcache/super.c

660

BUG_ON(bucket == -1);

drivers/md/bcache/super.c

663

prio_io(ca, bucket, REQ_OP_WRITE);

drivers/md/bcache/super.c

666

ca->prio_buckets[i] = bucket;

drivers/md/bcache/super.c

667

atomic_dec_bug(&ca->buckets[bucket].pin);

drivers/md/bcache/super.c

691

static int prio_read(struct cache *ca, uint64_t bucket)

drivers/md/bcache/super.c

695

struct bucket *b;

drivers/md/bcache/super.c

703

ca->prio_buckets[bucket_nr] = bucket;

drivers/md/bcache/super.c

704

ca->prio_last_buckets[bucket_nr] = bucket;

drivers/md/bcache/super.c

707

prio_io(ca, bucket, REQ_OP_READ);

drivers/md/bcache/super.c

720

bucket = p->next_bucket;

drivers/md/bcache/sysfs.c

1054

struct bucket *b;

drivers/md/dm-cache-policy-smq.c

618

static struct entry *h_head(struct smq_hash_table *ht, unsigned int bucket)

drivers/md/dm-cache-policy-smq.c

620

return to_entry(ht->es, ht->buckets[bucket]);

drivers/md/dm-cache-policy-smq.c

628

static void __h_insert(struct smq_hash_table *ht, unsigned int bucket, struct entry *e)

drivers/md/dm-cache-policy-smq.c

630

e->hash_next = ht->buckets[bucket];

drivers/md/dm-cache-policy-smq.c

631

ht->buckets[bucket] = to_index(ht->es, e);

drivers/md/dm-clone-target.c

1020

struct hash_table_bucket *bucket;

drivers/md/dm-clone-target.c

1032

bucket = get_hash_table_bucket(clone, offset);

drivers/md/dm-clone-target.c

1033

bucket_lock_irq(bucket);

drivers/md/dm-clone-target.c

1036

!__hash_find(bucket, offset)) {

drivers/md/dm-clone-target.c

1038

__insert_region_hydration(bucket, hd);

drivers/md/dm-clone-target.c

1039

bucket_unlock_irq(bucket);

drivers/md/dm-clone-target.c

1047

bucket_unlock_irq(bucket);

drivers/md/dm-clone-target.c

564

#define bucket_lock_irqsave(bucket, flags) \

drivers/md/dm-clone-target.c

565

spin_lock_irqsave(&(bucket)->lock, flags)

drivers/md/dm-clone-target.c

567

#define bucket_unlock_irqrestore(bucket, flags) \

drivers/md/dm-clone-target.c

568

spin_unlock_irqrestore(&(bucket)->lock, flags)

drivers/md/dm-clone-target.c

570

#define bucket_lock_irq(bucket) \

drivers/md/dm-clone-target.c

571

spin_lock_irq(&(bucket)->lock)

drivers/md/dm-clone-target.c

573

#define bucket_unlock_irq(bucket) \

drivers/md/dm-clone-target.c

574

spin_unlock_irq(&(bucket)->lock)

drivers/md/dm-clone-target.c

579

struct hash_table_bucket *bucket;

drivers/md/dm-clone-target.c

588

bucket = clone->ht + i;

drivers/md/dm-clone-target.c

590

INIT_HLIST_HEAD(&bucket->head);

drivers/md/dm-clone-target.c

591

spin_lock_init(&bucket->lock);

drivers/md/dm-clone-target.c

613

static struct dm_clone_region_hydration *__hash_find(struct hash_table_bucket *bucket,

drivers/md/dm-clone-target.c

618

hlist_for_each_entry(hd, &bucket->head, h) {

drivers/md/dm-clone-target.c

631

static inline void __insert_region_hydration(struct hash_table_bucket *bucket,

drivers/md/dm-clone-target.c

634

hlist_add_head(&hd->h, &bucket->head);

drivers/md/dm-clone-target.c

645

__find_or_insert_region_hydration(struct hash_table_bucket *bucket,

drivers/md/dm-clone-target.c

650

hd2 = __hash_find(bucket, hd->region_nr);

drivers/md/dm-clone-target.c

654

__insert_region_hydration(bucket, hd);

drivers/md/dm-clone-target.c

703

struct hash_table_bucket *bucket;

drivers/md/dm-clone-target.c

713

bucket = get_hash_table_bucket(clone, hd->region_nr);

drivers/md/dm-clone-target.c

716

bucket_lock_irqsave(bucket, flags);

drivers/md/dm-clone-target.c

718

bucket_unlock_irqrestore(bucket, flags);

drivers/md/dm-clone-target.c

877

struct hash_table_bucket *bucket;

drivers/md/dm-clone-target.c

881

bucket = get_hash_table_bucket(clone, region_nr);

drivers/md/dm-clone-target.c

883

bucket_lock_irq(bucket);

drivers/md/dm-clone-target.c

885

hd = __hash_find(bucket, region_nr);

drivers/md/dm-clone-target.c

889

bucket_unlock_irq(bucket);

drivers/md/dm-clone-target.c

895

bucket_unlock_irq(bucket);

drivers/md/dm-clone-target.c

904

bucket_unlock_irq(bucket);

drivers/md/dm-clone-target.c

909

bucket_lock_irq(bucket);

drivers/md/dm-clone-target.c

913

bucket_unlock_irq(bucket);

drivers/md/dm-clone-target.c

919

hd2 = __find_or_insert_region_hydration(bucket, hd);

drivers/md/dm-clone-target.c

923

bucket_unlock_irq(bucket);

drivers/md/dm-clone-target.c

935

bucket_unlock_irq(bucket);

drivers/md/dm-clone-target.c

949

bucket_unlock_irq(bucket);

drivers/md/dm-clone-target.c

953

bucket_unlock_irq(bucket);

drivers/md/dm-ps-historical-service-time.c

150

int bucket = clamp(delta >> HST_BUCKET_SHIFT, 0ULL,

drivers/md/dm-ps-historical-service-time.c

153

return s->weights[bucket];

drivers/md/dm-region-hash.c

277

struct list_head *bucket = rh->buckets + rh_hash(rh, region);

drivers/md/dm-region-hash.c

279

list_for_each_entry(reg, bucket, hash_list)

drivers/md/dm-vdo/int-map.c

102

struct bucket *buckets;

drivers/md/dm-vdo/int-map.c

243

static struct bucket *dereference_hop(struct bucket *neighborhood, unsigned int hop_offset)

drivers/md/dm-vdo/int-map.c

259

static void insert_in_hop_list(struct bucket *neighborhood, struct bucket *new_bucket)

drivers/md/dm-vdo/int-map.c

275

struct bucket *bucket = dereference_hop(neighborhood, next_hop);

drivers/md/dm-vdo/int-map.c

277

next_hop = bucket->next_hop;

drivers/md/dm-vdo/int-map.c

281

bucket->next_hop = hop_offset;

drivers/md/dm-vdo/int-map.c

292

static struct bucket *select_bucket(const struct int_map *map, u64 key)

drivers/md/dm-vdo/int-map.c

322

static struct bucket *search_hop_list(struct bucket *bucket, u64 key,

drivers/md/dm-vdo/int-map.c

323

struct bucket **previous_ptr)

drivers/md/dm-vdo/int-map.c

325

struct bucket *previous = NULL;

drivers/md/dm-vdo/int-map.c

326

unsigned int next_hop = bucket->first_hop;

drivers/md/dm-vdo/int-map.c

333

struct bucket *entry = dereference_hop(bucket, next_hop);

drivers/md/dm-vdo/int-map.c

356

struct bucket *match = search_hop_list(select_bucket(map, key), key, NULL);

drivers/md/dm-vdo/int-map.c

390

struct bucket *entry = &old_map.buckets[i];

drivers/md/dm-vdo/int-map.c

421

static struct bucket *

drivers/md/dm-vdo/int-map.c

422

find_empty_bucket(struct int_map *map, struct bucket *bucket, unsigned int max_probes)

drivers/md/dm-vdo/int-map.c

428

ptrdiff_t remaining = &map->buckets[map->bucket_count] - bucket;

drivers/md/dm-vdo/int-map.c

429

struct bucket *sentinel = &bucket[min_t(ptrdiff_t, remaining, max_probes)];

drivers/md/dm-vdo/int-map.c

430

struct bucket *entry;

drivers/md/dm-vdo/int-map.c

432

for (entry = bucket; entry < sentinel; entry++) {

drivers/md/dm-vdo/int-map.c

452

static struct bucket *move_empty_bucket(struct bucket *hole)

drivers/md/dm-vdo/int-map.c

460

struct bucket *bucket;

drivers/md/dm-vdo/int-map.c

462

for (bucket = &hole[1 - NEIGHBORHOOD]; bucket < hole; bucket++) {

drivers/md/dm-vdo/int-map.c

467

struct bucket *new_hole = dereference_hop(bucket, bucket->first_hop);

drivers/md/dm-vdo/int-map.c

493

bucket->first_hop = new_hole->next_hop;

drivers/md/dm-vdo/int-map.c

502

insert_in_hop_list(bucket, hole);

drivers/md/dm-vdo/int-map.c

521

static bool update_mapping(struct bucket *neighborhood, u64 key, void *new_value,

drivers/md/dm-vdo/int-map.c

524

struct bucket *bucket = search_hop_list(neighborhood, key, NULL);

drivers/md/dm-vdo/int-map.c

526

if (bucket == NULL) {

drivers/md/dm-vdo/int-map.c

536

*old_value_ptr = bucket->value;

drivers/md/dm-vdo/int-map.c

538

bucket->value = new_value;

drivers/md/dm-vdo/int-map.c

555

static struct bucket *find_or_make_vacancy(struct int_map *map,

drivers/md/dm-vdo/int-map.c

556

struct bucket *neighborhood)

drivers/md/dm-vdo/int-map.c

559

struct bucket *hole = find_empty_bucket(map, neighborhood, MAX_PROBES);

drivers/md/dm-vdo/int-map.c

606

struct bucket *neighborhood, *bucket;

drivers/md/dm-vdo/int-map.c

629

while ((bucket = find_or_make_vacancy(map, neighborhood)) == NULL) {

drivers/md/dm-vdo/int-map.c

650

bucket->key = key;

drivers/md/dm-vdo/int-map.c

651

bucket->value = new_value;

drivers/md/dm-vdo/int-map.c

652

insert_in_hop_list(neighborhood, bucket);

drivers/md/dm-vdo/int-map.c

673

struct bucket *bucket = select_bucket(map, key);

drivers/md/dm-vdo/int-map.c

674

struct bucket *previous;

drivers/md/dm-vdo/int-map.c

675

struct bucket *victim = search_hop_list(bucket, key, &previous);

drivers/md/dm-vdo/int-map.c

693

bucket->first_hop = victim->next_hop;

drivers/md/dm-vdo/priority-table.c

139

static inline void mark_bucket_empty(struct priority_table *table, struct bucket *bucket)

drivers/md/dm-vdo/priority-table.c

141

table->search_vector &= ~(1ULL << bucket->priority);

drivers/md/dm-vdo/priority-table.c

156

struct bucket *bucket;

drivers/md/dm-vdo/priority-table.c

172

bucket = &table->buckets[top_priority];

drivers/md/dm-vdo/priority-table.c

173

entry = bucket->queue.next;

drivers/md/dm-vdo/priority-table.c

177

if (list_empty(&bucket->queue))

drivers/md/dm-vdo/priority-table.c

178

mark_bucket_empty(table, bucket);

drivers/md/dm-vdo/priority-table.c

211

mark_bucket_empty(table, list_entry(next_entry, struct bucket, queue));

drivers/md/dm-vdo/priority-table.c

44

struct bucket buckets[];

drivers/md/dm-vdo/priority-table.c

68

struct bucket *bucket = &table->buckets[priority];

drivers/md/dm-vdo/priority-table.c

70

bucket->priority = priority;

drivers/md/dm-vdo/priority-table.c

71

INIT_LIST_HEAD(&bucket->queue);

drivers/md/persistent-data/dm-transaction-manager.c

109

unsigned int bucket = dm_hash_block(b, DM_HASH_MASK);

drivers/md/persistent-data/dm-transaction-manager.c

113

node = &tm->buckets[bucket].rb_node;

drivers/md/persistent-data/dm-transaction-manager.c

137

unsigned int bucket;

drivers/md/persistent-data/dm-transaction-manager.c

144

bucket = dm_hash_block(b, DM_HASH_MASK);

drivers/md/persistent-data/dm-transaction-manager.c

147

node = &tm->buckets[bucket].rb_node;

drivers/md/persistent-data/dm-transaction-manager.c

159

rb_insert_color(&si->node, &tm->buckets[bucket]);

drivers/media/v4l2-core/v4l2-ctrls-core.c

1820

int bucket;

drivers/media/v4l2-core/v4l2-ctrls-core.c

1827

bucket = id % hdl->nr_of_buckets;

drivers/media/v4l2-core/v4l2-ctrls-core.c

1834

ref = hdl->buckets ? hdl->buckets[bucket] : NULL;

drivers/media/v4l2-core/v4l2-ctrls-core.c

1875

int bucket = id % hdl->nr_of_buckets; /* which bucket to use */

drivers/media/v4l2-core/v4l2-ctrls-core.c

1931

new_ref->next = hdl->buckets[bucket];

drivers/media/v4l2-core/v4l2-ctrls-core.c

1932

hdl->buckets[bucket] = new_ref;

drivers/misc/vmw_vmci/vmci_doorbell.c

120

u32 bucket = VMCI_DOORBELL_HASH(idx);

drivers/misc/vmw_vmci/vmci_doorbell.c

123

hlist_for_each_entry(dbell, &vmci_doorbell_it.entries[bucket],

drivers/misc/vmw_vmci/vmci_doorbell.c

139

u32 bucket;

drivers/misc/vmw_vmci/vmci_doorbell.c

187

bucket = VMCI_DOORBELL_HASH(entry->idx);

drivers/misc/vmw_vmci/vmci_doorbell.c

188

hlist_add_head(&entry->node, &vmci_doorbell_it.entries[bucket]);

drivers/misc/vmw_vmci/vmci_doorbell.c

338

u32 bucket = VMCI_DOORBELL_HASH(notify_idx);

drivers/misc/vmw_vmci/vmci_doorbell.c

343

hlist_for_each_entry(dbell, &vmci_doorbell_it.entries[bucket], node) {

drivers/net/dsa/vitesse-vsc73xx-core.c

2071

int bucket, ret;

drivers/net/dsa/vitesse-vsc73xx-core.c

2079

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

drivers/net/dsa/vitesse-vsc73xx-core.c

2080

if (fdb[bucket].valid && fdb[bucket].port == port &&

drivers/net/dsa/vitesse-vsc73xx-core.c

2081

ether_addr_equal(addr, fdb[bucket].mac))

drivers/net/dsa/vitesse-vsc73xx-core.c

2085

if (bucket == VSC73XX_NUM_BUCKETS) {

drivers/net/dsa/vitesse-vsc73xx-core.c

2104

int bucket, ret;

drivers/net/dsa/vitesse-vsc73xx-core.c

2113

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

drivers/net/dsa/vitesse-vsc73xx-core.c

2114

if (!fdb[bucket].valid)

drivers/net/dsa/vitesse-vsc73xx-core.c

2118

if (bucket == VSC73XX_NUM_BUCKETS) {

drivers/net/dsa/vitesse-vsc73xx-core.c

2184

u16 i, bucket;

drivers/net/dsa/vitesse-vsc73xx-core.c

2194

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

drivers/net/dsa/vitesse-vsc73xx-core.c

2195

if (!fdb[bucket].valid || fdb[bucket].port != port)

drivers/net/dsa/vitesse-vsc73xx-core.c

2199

if (vid_is_dsa_8021q(fdb[bucket].vid))

drivers/net/dsa/vitesse-vsc73xx-core.c

2200

fdb[bucket].vid = 0;

drivers/net/dsa/vitesse-vsc73xx-core.c

2202

err = cb(fdb[bucket].mac, fdb[bucket].vid, false, data);

drivers/net/ethernet/freescale/fman/fman_dtsec.c

1024

s32 bucket;

drivers/net/ethernet/freescale/fman/fman_dtsec.c

1052

bucket = (s32)((crc >> 23) & 0x1ff);

drivers/net/ethernet/freescale/fman/fman_dtsec.c

1054

bucket = (s32)((crc >> 24) & 0xff);

drivers/net/ethernet/freescale/fman/fman_dtsec.c

1059

bucket += 0x100;

drivers/net/ethernet/freescale/fman/fman_dtsec.c

1062

set_bucket(dtsec->regs, bucket, true);

drivers/net/ethernet/freescale/fman/fman_dtsec.c

1074

&dtsec->multicast_addr_hash->lsts[bucket]);

drivers/net/ethernet/freescale/fman/fman_dtsec.c

1077

&dtsec->unicast_addr_hash->lsts[bucket]);

drivers/net/ethernet/freescale/fman/fman_dtsec.c

1127

s32 bucket;

drivers/net/ethernet/freescale/fman/fman_dtsec.c

1145

bucket = (s32)((crc >> 23) & 0x1ff);

drivers/net/ethernet/freescale/fman/fman_dtsec.c

1147

bucket = (s32)((crc >> 24) & 0xff);

drivers/net/ethernet/freescale/fman/fman_dtsec.c

1152

bucket += 0x100;

drivers/net/ethernet/freescale/fman/fman_dtsec.c

1158

&dtsec->multicast_addr_hash->lsts[bucket]) {

drivers/net/ethernet/freescale/fman/fman_dtsec.c

1166

if (list_empty(&dtsec->multicast_addr_hash->lsts[bucket]))

drivers/net/ethernet/freescale/fman/fman_dtsec.c

1167

set_bucket(dtsec->regs, bucket, false);

drivers/net/ethernet/freescale/fman/fman_dtsec.c

1171

&dtsec->unicast_addr_hash->lsts[bucket]) {

drivers/net/ethernet/freescale/fman/fman_dtsec.c

1179

if (list_empty(&dtsec->unicast_addr_hash->lsts[bucket]))

drivers/net/ethernet/freescale/fman/fman_dtsec.c

1180

set_bucket(dtsec->regs, bucket, false);

drivers/net/ethernet/freescale/fman/fman_dtsec.c

458

static void set_bucket(struct dtsec_regs __iomem *regs, int bucket,

drivers/net/ethernet/freescale/fman/fman_dtsec.c

461

int reg_idx = (bucket >> 5) & 0xf;

drivers/net/ethernet/freescale/fman/fman_dtsec.c

462

int bit_idx = bucket & 0x1f;

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_tm.c

440

enum hclge_shap_bucket bucket, u8 pg_id,

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_tm.c

447

opcode = bucket ? HCLGE_OPC_TM_PG_P_SHAPPING :

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_tm.c

496

enum hclge_shap_bucket bucket, u8 pri_id,

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_tm.c

503

opcode = bucket ? HCLGE_OPC_TM_PRI_P_SHAPPING :

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

1148

struct hlist_head *bucket;

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

1159

bucket = &priv->mac_hash[i];

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

1160

hlist_for_each_entry_safe(entry, tmp, bucket, hlist) {

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

1203

bucket = &priv->mac_hash[ha->addr[MLX4_EN_MAC_HASH_IDX]];

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

1204

hlist_for_each_entry(entry, bucket, hlist) {

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

1244

bucket = &priv->mac_hash[mac_hash];

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

1245

hlist_add_head_rcu(&entry->hlist, bucket);

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

1348

struct hlist_head *bucket;

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

1353

bucket = &priv->mac_hash[i];

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

1354

hlist_for_each_entry_safe(entry, tmp, bucket, hlist) {

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

710

struct hlist_head *bucket;

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

716

bucket = &priv->mac_hash[prev_mac[MLX4_EN_MAC_HASH_IDX]];

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

717

hlist_for_each_entry_safe(entry, tmp, bucket, hlist) {

drivers/net/ethernet/mellanox/mlx4/en_rx.c

762

struct hlist_head *bucket;

drivers/net/ethernet/mellanox/mlx4/en_rx.c

767

bucket = &priv->mac_hash[mac_hash];

drivers/net/ethernet/mellanox/mlx4/en_rx.c

768

hlist_for_each_entry_rcu_bh(entry, bucket, hlist) {

drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c

5674

int bucket;

drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c

5676

for (bucket = 0; bucket < nhgi->count; bucket++) {

drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c

5677

struct mlxsw_sp_nexthop *nh = &nhgi->nexthops[bucket];

drivers/net/gtp.c

2280

int i, j, bucket = cb->args[0], skip = cb->args[1];

drivers/net/gtp.c

2300

for (i = bucket; i < gtp->hash_size; i++) {

drivers/net/gtp.c

2319

bucket = 0;

drivers/net/wireguard/ratelimiter.c

104

bucket = &table_v6[hsiphash_3u32(net_word, ip >> 32, ip, &key) &

drivers/net/wireguard/ratelimiter.c

111

hlist_for_each_entry_rcu(entry, bucket, hash) {

drivers/net/wireguard/ratelimiter.c

149

hlist_add_head_rcu(&entry->hash, bucket);

drivers/net/wireguard/ratelimiter.c

92

struct hlist_head *bucket;

drivers/net/wireguard/ratelimiter.c

97

bucket = &table_v4[hsiphash_2u32(net_word, ip, &key) &

drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c

1191

u32 bucket;

drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c

1237

bucket = __ffs(cfg->int_escan_map);

drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c

1238

cfg->int_escan_map &= ~BIT(bucket);

drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c

1240

bucket);

drivers/net/wireless/broadcom/brcm80211/brcmfmac/fwil_types.h

1217

struct brcmf_gscan_bucket_config bucket[] __counted_by(count_of_channel_buckets);

drivers/net/wireless/broadcom/brcm80211/brcmfmac/pno.c

408

gsz = struct_size(gscan_cfg, bucket, n_buckets);

drivers/net/wireless/broadcom/brcm80211/brcmfmac/pno.c

437

memcpy(gscan_cfg->bucket, buckets,

drivers/net/wireless/broadcom/brcm80211/brcmfmac/pno.c

552

u64 brcmf_pno_find_reqid_by_bucket(struct brcmf_pno_info *pi, u32 bucket)

drivers/net/wireless/broadcom/brcm80211/brcmfmac/pno.c

558

if (bucket < pi->n_reqs)

drivers/net/wireless/broadcom/brcm80211/brcmfmac/pno.c

559

reqid = pi->reqs[bucket]->reqid;

drivers/net/wireless/broadcom/brcm80211/brcmfmac/pno.h

61

u64 brcmf_pno_find_reqid_by_bucket(struct brcmf_pno_info *pi, u32 bucket);

drivers/pwm/pwm-airoha.c

160

static int airoha_pwm_get_bucket(struct airoha_pwm *pc, int bucket,

drivers/pwm/pwm-airoha.c

169

offset = bucket / AIROHA_PWM_BUCKET_PER_CYCLE_CFG;

drivers/pwm/pwm-airoha.c

170

shift = bucket % AIROHA_PWM_BUCKET_PER_CYCLE_CFG;

drivers/pwm/pwm-airoha.c

180

offset = bucket / AIROHA_PWM_BUCKET_PER_FLASH_PROD;

drivers/pwm/pwm-airoha.c

181

shift = bucket % AIROHA_PWM_BUCKET_PER_FLASH_PROD;

drivers/pwm/pwm-airoha.c

206

struct airoha_pwm_bucket *bucket = &pc->buckets[i];

drivers/pwm/pwm-airoha.c

207

u32 bucket_period_ticks = bucket->period_ticks;

drivers/pwm/pwm-airoha.c

208

u32 bucket_duty_ticks = bucket->duty_ticks;

drivers/pwm/pwm-airoha.c

211

if (!bucket->used) {

drivers/pwm/pwm-airoha.c

270

int bucket;

drivers/pwm/pwm-airoha.c

276

bucket = pc->channel_bucket[hwpwm];

drivers/pwm/pwm-airoha.c

277

pc->buckets[bucket].used--;

drivers/pwm/pwm-airoha.c

280

static int airoha_pwm_apply_bucket_config(struct airoha_pwm *pc, unsigned int bucket,

drivers/pwm/pwm-airoha.c

287

offset = bucket / AIROHA_PWM_BUCKET_PER_CYCLE_CFG;

drivers/pwm/pwm-airoha.c

288

shift = bucket % AIROHA_PWM_BUCKET_PER_CYCLE_CFG;

drivers/pwm/pwm-airoha.c

299

offset = bucket / AIROHA_PWM_BUCKET_PER_FLASH_PROD;

drivers/pwm/pwm-airoha.c

300

shift = bucket % AIROHA_PWM_BUCKET_PER_FLASH_PROD;

drivers/pwm/pwm-airoha.c

323

int bucket, ret;

drivers/pwm/pwm-airoha.c

330

bucket = airoha_pwm_get_generator(pc, duty_ticks, period_ticks);

drivers/pwm/pwm-airoha.c

331

if (bucket < 0)

drivers/pwm/pwm-airoha.c

332

return bucket;

drivers/pwm/pwm-airoha.c

337

if (!pc->buckets[bucket].used)

drivers/pwm/pwm-airoha.c

339

pc->buckets[bucket].used++;

drivers/pwm/pwm-airoha.c

342

pc->buckets[bucket].period_ticks = period_ticks;

drivers/pwm/pwm-airoha.c

343

pc->buckets[bucket].duty_ticks = duty_ticks;

drivers/pwm/pwm-airoha.c

344

ret = airoha_pwm_apply_bucket_config(pc, bucket,

drivers/pwm/pwm-airoha.c

348

pc->buckets[bucket].used--;

drivers/pwm/pwm-airoha.c

353

return bucket;

drivers/pwm/pwm-airoha.c

452

int bucket, ret;

drivers/pwm/pwm-airoha.c

454

bucket = airoha_pwm_consume_generator(pc, duty_ticks, period_ticks,

drivers/pwm/pwm-airoha.c

456

if (bucket < 0)

drivers/pwm/pwm-airoha.c

457

return bucket;

drivers/pwm/pwm-airoha.c

459

ret = airoha_pwm_config_flash_map(pc, hwpwm, bucket);

drivers/pwm/pwm-airoha.c

461

pc->buckets[bucket].used--;

drivers/pwm/pwm-airoha.c

466

pc->channel_bucket[hwpwm] = bucket;

drivers/pwm/pwm-airoha.c

551

u8 bucket;

drivers/pwm/pwm-airoha.c

565

bucket = FIELD_GET(AIROHA_PWM_GPIO_FLASH_SET_ID, val >> shift);

drivers/pwm/pwm-airoha.c

566

return airoha_pwm_get_bucket(pc, bucket, &state->period,

drivers/scsi/hpsa.c

298

static void calc_bucket_map(int *bucket, int num_buckets,

drivers/scsi/hpsa.c

9138

static void calc_bucket_map(int bucket[], int num_buckets,

drivers/scsi/hpsa.c

9150

if (bucket[j] >= size) {

drivers/scsi/lpfc/lpfc_ct.c

3592

u32 cmd, hash, bucket;

drivers/scsi/lpfc/lpfc_ct.c

3672

hash_for_each(vport->hash_table, bucket, cur, hnode)

drivers/scsi/lpfc/lpfc_hbadisc.c

319

u32 difftime = 0, r, bucket;

drivers/scsi/lpfc/lpfc_hbadisc.c

330

hash_for_each(vport->hash_table, bucket, vmp, hnode) {

drivers/scsi/lpfc/lpfc_scsi.c

5491

u32 bucket;

drivers/scsi/lpfc/lpfc_scsi.c

5502

hash_for_each(vport->hash_table, bucket, cur, hnode)

drivers/scsi/lpfc/lpfc_vmid.c

300

u32 bucket, i, cpu;

drivers/scsi/lpfc/lpfc_vmid.c

322

hash_for_each_safe(vport->hash_table, bucket, tmp, cur, hnode)

drivers/scsi/mpi3mr/mpi/mpi30_cnfg.h

1167

struct mpi3_iounit12_bucket bucket[MPI3_IOUNIT12_BUCKET_MAX];

drivers/target/iscsi/cxgbit/cxgbit_cm.c

101

int stid = -1, bucket = cxgbit_np_hashfn(cnp);

drivers/target/iscsi/cxgbit/cxgbit_cm.c

105

for (p = cdev->np_hash_tab[bucket]; p; p = p->next) {

drivers/target/iscsi/cxgbit/cxgbit_cm.c

118

int stid = -1, bucket = cxgbit_np_hashfn(cnp);

drivers/target/iscsi/cxgbit/cxgbit_cm.c

119

struct np_info *p, **prev = &cdev->np_hash_tab[bucket];

drivers/target/iscsi/cxgbit/cxgbit_cm.c

85

int bucket = cxgbit_np_hashfn(cnp);

drivers/target/iscsi/cxgbit/cxgbit_cm.c

90

p->next = cdev->np_hash_tab[bucket];

drivers/target/iscsi/cxgbit/cxgbit_cm.c

91

cdev->np_hash_tab[bucket] = p;

fs/afs/dir_edit.c

358

iter.bucket = afs_dir_hash_name(name);

fs/afs/dir_edit.c

359

de->u.hash_next = meta->meta.hashtable[iter.bucket];

fs/afs/dir_edit.c

360

meta->meta.hashtable[iter.bucket] = htons(entry);

fs/afs/dir_edit.c

467

__be16 prev_next = meta->meta.hashtable[iter.bucket];

fs/afs/dir_edit.c

472

iter.bucket, iter.prev_entry, prev_next, entry,

fs/afs/dir_edit.c

476

meta->meta.hashtable[iter.bucket] = next;

fs/afs/dir_edit.c

491

iter.bucket, iter.prev_entry, prev_next, entry,

fs/afs/dir_search.c

134

entry = ntohs(meta->meta.hashtable[iter->bucket & (AFS_DIR_HASHTBL_SIZE - 1)]);

fs/afs/dir_search.c

135

_enter("%x,%x", iter->bucket, entry);

fs/afs/dir_search.c

148

iter->bucket, resv, slot, slot + iter->nr_slots - 1);

fs/afs/dir_search.c

169

kdebug("dir chain loop h=%x", iter->bucket);

fs/afs/dir_search.c

25

int bucket;

fs/afs/dir_search.c

29

bucket = hash & (AFS_DIR_HASHTBL_SIZE - 1);

fs/afs/dir_search.c

31

bucket = AFS_DIR_HASHTBL_SIZE - bucket;

fs/afs/dir_search.c

32

bucket &= (AFS_DIR_HASHTBL_SIZE - 1);

fs/afs/dir_search.c

34

return bucket;

fs/afs/dir_search.c

60

iter->bucket = afs_dir_hash_name(name);

fs/afs/internal.h

999

u8 bucket;

fs/btrfs/compression.c

1298

for (i = 0; i < BUCKET_SIZE && ws->bucket[i].count > 0; i++) {

fs/btrfs/compression.c

1299

p = ws->bucket[i].count;

fs/btrfs/compression.c

1431

struct bucket_item *bucket = ws->bucket;

fs/btrfs/compression.c

1434

radix_sort(ws->bucket, ws->bucket_b, BUCKET_SIZE);

fs/btrfs/compression.c

1437

coreset_sum += bucket[i].count;

fs/btrfs/compression.c

1442

for (; i < BYTE_CORE_SET_HIGH && bucket[i].count > 0; i++) {

fs/btrfs/compression.c

1443

coreset_sum += bucket[i].count;

fs/btrfs/compression.c

1470

if (ws->bucket[i].count > 0)

fs/btrfs/compression.c

1480

if (ws->bucket[i].count > 0) {

fs/btrfs/compression.c

1578

memset(ws->bucket, 0, sizeof(*ws->bucket)*BUCKET_SIZE);

fs/btrfs/compression.c

1582

ws->bucket[byte].count++;

fs/btrfs/compression.c

654

struct bucket_item *bucket;

fs/btrfs/compression.c

667

kfree(workspace->bucket);

fs/btrfs/compression.c

684

ws->bucket = kzalloc_objs(*ws->bucket, BUCKET_SIZE);

fs/btrfs/compression.c

685

if (!ws->bucket)

fs/btrfs/raid56.c

466

int bucket = rbio_bucket(rbio);

fs/btrfs/raid56.c

478

h = table->table + bucket;

fs/btrfs/raid56.c

856

int bucket;

fs/btrfs/raid56.c

860

bucket = rbio_bucket(rbio);

fs/btrfs/raid56.c

861

h = rbio->bioc->fs_info->stripe_hash_table->table + bucket;

fs/crypto/keyring.c

223

struct hlist_head *bucket = &keyring->key_hashtable[i];

fs/crypto/keyring.c

227

hlist_for_each_entry_safe(mk, tmp, bucket, mk_node) {

fs/crypto/keyring.c

272

struct hlist_head *bucket;

fs/crypto/keyring.c

285

bucket = fscrypt_mk_hash_bucket(keyring, mk_spec);

fs/crypto/keyring.c

289

hlist_for_each_entry_rcu(mk, bucket, mk_node) {

fs/crypto/keyring.c

300

hlist_for_each_entry_rcu(mk, bucket, mk_node) {

fs/fuse/dir.c

107

struct dentry_bucket *bucket)

fs/fuse/dir.c

110

rb_erase(&fd->node, &bucket->tree);

fs/fuse/dir.c

118

struct dentry_bucket *bucket = get_dentry_bucket(dentry);

fs/fuse/dir.c

120

spin_lock(&bucket->lock);

fs/fuse/dir.c

121

__fuse_dentry_tree_del_node(fd, bucket);

fs/fuse/dir.c

122

spin_unlock(&bucket->lock);

fs/fuse/dir.c

128

struct dentry_bucket *bucket;

fs/fuse/dir.c

135

bucket = get_dentry_bucket(dentry);

fs/fuse/dir.c

137

spin_lock(&bucket->lock);

fs/fuse/dir.c

139

__fuse_dentry_tree_del_node(fd, bucket);

fs/fuse/dir.c

141

p = &bucket->tree.rb_node;

fs/fuse/dir.c

151

rb_insert_color(&fd->node, &bucket->tree);

fs/fuse/dir.c

152

spin_unlock(&bucket->lock);

fs/fuse/file.c

1908

if (wpa->bucket)

fs/fuse/file.c

1909

fuse_sync_bucket_dec(wpa->bucket);

fs/fuse/file.c

2097

wpa->bucket = rcu_dereference(fc->curr_bucket);

fs/fuse/file.c

2098

} while (unlikely(!atomic_inc_not_zero(&wpa->bucket->count)));

fs/fuse/file.c

449

struct fuse_sync_bucket *bucket;

fs/fuse/fuse_i.h

893

static inline void fuse_sync_bucket_dec(struct fuse_sync_bucket *bucket)

fs/fuse/fuse_i.h

897

if (atomic_dec_and_test(&bucket->count))

fs/fuse/fuse_i.h

898

wake_up(&bucket->waitq);

fs/fuse/inode.c

1002

struct fuse_sync_bucket *bucket;

fs/fuse/inode.c

1012

bucket = rcu_dereference_protected(fc->curr_bucket, 1);

fs/fuse/inode.c

1013

if (bucket) {

fs/fuse/inode.c

1014

WARN_ON(atomic_read(&bucket->count) != 1);

fs/fuse/inode.c

1015

kfree(bucket);

fs/fuse/inode.c

674

struct fuse_sync_bucket *bucket;

fs/fuse/inode.c

676

bucket = kzalloc_obj(*bucket, GFP_KERNEL | __GFP_NOFAIL);

fs/fuse/inode.c

677

init_waitqueue_head(&bucket->waitq);

fs/fuse/inode.c

679

atomic_set(&bucket->count, 1);

fs/fuse/inode.c

680

return bucket;

fs/fuse/inode.c

685

struct fuse_sync_bucket *bucket, *new_bucket;

fs/fuse/inode.c

690

bucket = rcu_dereference_protected(fc->curr_bucket, 1);

fs/fuse/inode.c

691

count = atomic_read(&bucket->count);

fs/fuse/inode.c

712

atomic_dec(&bucket->count);

fs/fuse/inode.c

714

wait_event(bucket->waitq, atomic_read(&bucket->count) == 0);

fs/fuse/inode.c

718

kfree_rcu(bucket, rcu);

fs/jffs2/gc.c

141

int bucket, want_ino;

fs/jffs2/gc.c

158

for (bucket = c->check_ino % c->inocache_hashsize ; bucket < c->inocache_hashsize; bucket++) {

fs/jffs2/gc.c

159

for (ic = c->inocache_list[bucket]; ic; ic = ic->next) {

fs/netfs/fscache_cookie.c

406

unsigned int bucket;

fs/netfs/fscache_cookie.c

408

bucket = candidate->key_hash & (ARRAY_SIZE(fscache_cookie_hash) - 1);

fs/netfs/fscache_cookie.c

409

h = &fscache_cookie_hash[bucket];

fs/netfs/fscache_cookie.c

936

unsigned int bucket;

fs/netfs/fscache_cookie.c

938

bucket = cookie->key_hash & (ARRAY_SIZE(fscache_cookie_hash) - 1);

fs/netfs/fscache_cookie.c

939

h = &fscache_cookie_hash[bucket];

fs/netfs/fscache_volume.c

178

unsigned int bucket, collidee_debug_id = 0;

fs/netfs/fscache_volume.c

180

bucket = candidate->key_hash & (ARRAY_SIZE(fscache_volume_hash) - 1);

fs/netfs/fscache_volume.c

181

h = &fscache_volume_hash[bucket];

fs/netfs/fscache_volume.c

374

unsigned int bucket;

fs/netfs/fscache_volume.c

376

bucket = volume->key_hash & (ARRAY_SIZE(fscache_volume_hash) - 1);

fs/netfs/fscache_volume.c

377

h = &fscache_volume_hash[bucket];

fs/nfs/nfs42xattr.c

238

entry->bucket = NULL;

fs/nfs/nfs42xattr.c

388

struct nfs4_xattr_bucket *bucket;

fs/nfs/nfs42xattr.c

394

bucket = &cache->buckets[i];

fs/nfs/nfs42xattr.c

396

spin_lock(&bucket->lock);

fs/nfs/nfs42xattr.c

397

bucket->draining = true;

fs/nfs/nfs42xattr.c

398

hlist_for_each_entry_safe(entry, n, &bucket->hlist, hnode) {

fs/nfs/nfs42xattr.c

403

spin_unlock(&bucket->lock);

fs/nfs/nfs42xattr.c

511

nfs4_xattr_get_entry(struct nfs4_xattr_bucket *bucket, const char *name)

fs/nfs/nfs42xattr.c

517

hlist_for_each_entry(entry, &bucket->hlist, hnode) {

fs/nfs/nfs42xattr.c

529

struct nfs4_xattr_bucket *bucket;

fs/nfs/nfs42xattr.c

533

bucket = nfs4_xattr_hash_bucket(cache, entry->xattr_name);

fs/nfs/nfs42xattr.c

534

entry->bucket = bucket;

fs/nfs/nfs42xattr.c

536

spin_lock(&bucket->lock);

fs/nfs/nfs42xattr.c

538

if (bucket->draining) {

fs/nfs/nfs42xattr.c

543

oldentry = nfs4_xattr_get_entry(bucket, entry->xattr_name);

fs/nfs/nfs42xattr.c

551

hlist_add_head(&entry->hnode, &bucket->hlist);

fs/nfs/nfs42xattr.c

555

spin_unlock(&bucket->lock);

fs/nfs/nfs42xattr.c

566

struct nfs4_xattr_bucket *bucket;

fs/nfs/nfs42xattr.c

569

bucket = nfs4_xattr_hash_bucket(cache, name);

fs/nfs/nfs42xattr.c

571

spin_lock(&bucket->lock);

fs/nfs/nfs42xattr.c

573

entry = nfs4_xattr_get_entry(bucket, name);

fs/nfs/nfs42xattr.c

580

spin_unlock(&bucket->lock);

fs/nfs/nfs42xattr.c

589

struct nfs4_xattr_bucket *bucket;

fs/nfs/nfs42xattr.c

592

bucket = nfs4_xattr_hash_bucket(cache, name);

fs/nfs/nfs42xattr.c

594

spin_lock(&bucket->lock);

fs/nfs/nfs42xattr.c

596

entry = nfs4_xattr_get_entry(bucket, name);

fs/nfs/nfs42xattr.c

600

spin_unlock(&bucket->lock);

fs/nfs/nfs42xattr.c

758

entry->bucket = &cache->buckets[0];

fs/nfs/nfs42xattr.c

87

struct nfs4_xattr_bucket *bucket;

fs/nfs/nfs42xattr.c

873

struct nfs4_xattr_bucket *bucket;

fs/nfs/nfs42xattr.c

878

bucket = entry->bucket;

fs/nfs/nfs42xattr.c

879

cache = bucket->cache;

fs/nfs/nfs42xattr.c

892

if (!spin_trylock(&bucket->lock))

fs/nfs/nfs42xattr.c

901

spin_unlock(&bucket->lock);

fs/nfs/pnfs_nfs.c

1181

struct pnfs_commit_bucket *bucket;

fs/nfs/pnfs_nfs.c

1187

bucket = &array->buckets[ds_commit_idx];

fs/nfs/pnfs_nfs.c

1188

list = &bucket->written;

fs/nfs/pnfs_nfs.c

1195

if (!bucket->lseg)

fs/nfs/pnfs_nfs.c

1196

bucket->lseg = pnfs_get_lseg(lseg);

fs/nfs/pnfs_nfs.c

243

pnfs_bucket_scan_ds_commit_list(struct pnfs_commit_bucket *bucket,

fs/nfs/pnfs_nfs.c

247

struct list_head *src = &bucket->written;

fs/nfs/pnfs_nfs.c

248

struct list_head *dst = &bucket->committing;

fs/nfs/pnfs_nfs.c

358

struct pnfs_commit_bucket *bucket,

fs/nfs/pnfs_nfs.c

364

list_for_each(pos, &bucket->committing)

fs/nfs/pnfs_nfs.c

366

list_splice_init(&bucket->committing, head);

fs/nfs/pnfs_nfs.c

367

lseg = pnfs_free_bucket_lseg(bucket);

fs/nfs/pnfs_nfs.c

369

lseg = pnfs_get_lseg(bucket->lseg);

fs/nfs/pnfs_nfs.c

374

pnfs_bucket_fetch_commitdata(struct pnfs_commit_bucket *bucket,

fs/nfs/pnfs_nfs.c

381

data->lseg = pnfs_bucket_get_committing(&data->pages, bucket, cinfo);

fs/nfs/pnfs_nfs.c

390

struct pnfs_commit_bucket *bucket;

fs/nfs/pnfs_nfs.c

394

for (bucket = buckets; idx < nbuckets; bucket++, idx++) {

fs/nfs/pnfs_nfs.c

395

if (list_empty(&bucket->committing))

fs/nfs/pnfs_nfs.c

398

freeme = pnfs_bucket_get_committing(&pages, bucket, cinfo);

fs/nfs/pnfs_nfs.c

411

struct pnfs_commit_bucket *bucket;

fs/nfs/pnfs_nfs.c

416

for (i = 0, bucket = buckets; i < nbuckets; i++, bucket++) {

fs/nfs/pnfs_nfs.c

417

if (list_empty(&bucket->committing))

fs/nfs/pnfs_nfs.c

420

if (!list_empty(&bucket->committing)) {

fs/nfs/pnfs_nfs.c

421

data = pnfs_bucket_fetch_commitdata(bucket, cinfo);

fs/nfs/pnfs_nfs.c

65

pnfs_free_bucket_lseg(struct pnfs_commit_bucket *bucket)

fs/nfs/pnfs_nfs.c

67

if (list_empty(&bucket->committing) && list_empty(&bucket->written)) {

fs/nfs/pnfs_nfs.c

68

struct pnfs_layout_segment *freeme = bucket->lseg;

fs/nfs/pnfs_nfs.c

69

bucket->lseg = NULL;

fs/nfs/pnfs_nfs.c

83

struct pnfs_commit_bucket *bucket = NULL;

fs/nfs/pnfs_nfs.c

89

bucket = list_first_entry(&req->wb_list,

fs/nfs/pnfs_nfs.c

93

if (bucket)

fs/nfs/pnfs_nfs.c

94

pnfs_put_lseg(pnfs_free_bucket_lseg(bucket));

fs/notify/fanotify/fanotify.c

184

unsigned int bucket = fanotify_event_hash_bucket(group, new);

fs/notify/fanotify/fanotify.c

185

struct hlist_head *hlist = &group->fanotify_data.merge_hash[bucket];

fs/notify/fanotify/fanotify.c

189

group, event, bucket);

fs/notify/fanotify/fanotify.c

913

unsigned int bucket = fanotify_event_hash_bucket(group, event);

fs/notify/fanotify/fanotify.c

914

struct hlist_head *hlist = &group->fanotify_data.merge_hash[bucket];

fs/notify/fanotify/fanotify.c

922

group, event, bucket);

fs/ocfs2/dlm/dlmdebug.c

353

struct hlist_head *bucket;

fs/ocfs2/dlm/dlmdebug.c

362

bucket = dlm_master_hash(dlm, i);

fs/ocfs2/dlm/dlmdebug.c

363

hlist_for_each_entry(mle, bucket, master_hash_node) {

fs/ocfs2/dlm/dlmdomain.c

160

struct hlist_head *bucket;

fs/ocfs2/dlm/dlmdomain.c

164

bucket = dlm_lockres_hash(dlm, res->lockname.hash);

fs/ocfs2/dlm/dlmdomain.c

169

hlist_add_head(&res->hash_node, bucket);

fs/ocfs2/dlm/dlmdomain.c

180

struct hlist_head *bucket;

fs/ocfs2/dlm/dlmdomain.c

187

bucket = dlm_lockres_hash(dlm, hash);

fs/ocfs2/dlm/dlmdomain.c

189

hlist_for_each_entry(res, bucket, hash_node) {

fs/ocfs2/dlm/dlmdomain.c

410

struct hlist_head *bucket;

fs/ocfs2/dlm/dlmdomain.c

420

bucket = dlm_lockres_hash(dlm, i);

fs/ocfs2/dlm/dlmdomain.c

421

iter = bucket->first;

fs/ocfs2/dlm/dlmmaster.c

313

struct hlist_head *bucket;

fs/ocfs2/dlm/dlmmaster.c

317

bucket = dlm_master_hash(dlm, mle->mnamehash);

fs/ocfs2/dlm/dlmmaster.c

318

hlist_add_head(&mle->master_hash_node, bucket);

fs/ocfs2/dlm/dlmmaster.c

327

struct hlist_head *bucket;

fs/ocfs2/dlm/dlmmaster.c

3318

struct hlist_head *bucket;

fs/ocfs2/dlm/dlmmaster.c

3329

bucket = dlm_master_hash(dlm, i);

fs/ocfs2/dlm/dlmmaster.c

333

bucket = dlm_master_hash(dlm, hash);

fs/ocfs2/dlm/dlmmaster.c

3330

hlist_for_each_entry_safe(mle, tmp, bucket, master_hash_node) {

fs/ocfs2/dlm/dlmmaster.c

334

hlist_for_each_entry(tmpmle, bucket, master_hash_node) {

fs/ocfs2/dlm/dlmmaster.c

3518

struct hlist_head *bucket;

fs/ocfs2/dlm/dlmmaster.c

3535

bucket = dlm_master_hash(dlm, i);

fs/ocfs2/dlm/dlmmaster.c

3536

hlist_for_each_entry_safe(mle, tmp, bucket, master_hash_node) {

fs/ocfs2/dlm/dlmrecovery.c

2130

struct hlist_head *bucket;

fs/ocfs2/dlm/dlmrecovery.c

2159

bucket = dlm_lockres_hash(dlm, i);

fs/ocfs2/dlm/dlmrecovery.c

2160

hlist_for_each_entry(res, bucket, hash_node) {

fs/ocfs2/dlm/dlmrecovery.c

2322

struct hlist_head *bucket;

fs/ocfs2/dlm/dlmrecovery.c

2345

bucket = dlm_lockres_hash(dlm, i);

fs/ocfs2/dlm/dlmrecovery.c

2346

hlist_for_each_entry_safe(res, tmp, bucket, hash_node) {

fs/ocfs2/ocfs2_trace.h

1783

unsigned int hash, unsigned long long bucket, \

fs/ocfs2/ocfs2_trace.h

1785

TP_ARGS(ino, name, name_index, hash, bucket, xe_index))

fs/ocfs2/xattr.c

125

struct ocfs2_xattr_bucket *bucket;

fs/ocfs2/xattr.c

1260

xs->bucket = ocfs2_xattr_bucket_new(inode);

fs/ocfs2/xattr.c

1261

if (!xs->bucket) {

fs/ocfs2/xattr.c

1291

bucket_xh(xs->bucket),

fs/ocfs2/xattr.c

1299

xs->base = bucket_block(xs->bucket, block_off);

fs/ocfs2/xattr.c

1317

ocfs2_xattr_bucket_free(xs->bucket);

fs/ocfs2/xattr.c

1751

struct ocfs2_xattr_bucket *bucket = loc->xl_storage;

fs/ocfs2/xattr.c

1753

return ocfs2_xattr_bucket_journal_access(handle, bucket, type);

fs/ocfs2/xattr.c

1759

struct ocfs2_xattr_bucket *bucket = loc->xl_storage;

fs/ocfs2/xattr.c

1761

ocfs2_xattr_bucket_journal_dirty(handle, bucket);

fs/ocfs2/xattr.c

1767

struct ocfs2_xattr_bucket *bucket = loc->xl_storage;

fs/ocfs2/xattr.c

1774

return bucket_block(bucket, block) + block_offset;

fs/ocfs2/xattr.c

1786

struct ocfs2_xattr_bucket *bucket = loc->xl_storage;

fs/ocfs2/xattr.c

1787

return le16_to_cpu(bucket_xh(bucket)->xh_free_start);

fs/ocfs2/xattr.c

1908

struct ocfs2_xattr_bucket *bucket = loc->xl_storage;

fs/ocfs2/xattr.c

1918

BUG_ON(!bucket->bu_bhs[block_offset]);

fs/ocfs2/xattr.c

1921

vb->vb_bh = bucket->bu_bhs[block_offset];

fs/ocfs2/xattr.c

2350

struct ocfs2_xattr_bucket *bucket,

fs/ocfs2/xattr.c

2353

loc->xl_inode = bucket->bu_inode;

fs/ocfs2/xattr.c

2355

loc->xl_storage = bucket;

fs/ocfs2/xattr.c

2356

loc->xl_header = bucket_xh(bucket);

fs/ocfs2/xattr.c

279

struct ocfs2_xattr_bucket *bucket,

fs/ocfs2/xattr.c

301

struct ocfs2_xattr_bucket *bucket,

fs/ocfs2/xattr.c

3140

bucket_xh(xbs->bucket),

fs/ocfs2/xattr.c

3143

base = bucket_block(xbs->bucket, block_off);

fs/ocfs2/xattr.c

322

struct ocfs2_xattr_bucket *bucket;

fs/ocfs2/xattr.c

327

bucket = kzalloc_obj(struct ocfs2_xattr_bucket, GFP_NOFS);

fs/ocfs2/xattr.c

328

if (bucket) {

fs/ocfs2/xattr.c

329

bucket->bu_inode = inode;

fs/ocfs2/xattr.c

330

bucket->bu_blocks = blks;

fs/ocfs2/xattr.c

333

return bucket;

fs/ocfs2/xattr.c

336

static void ocfs2_xattr_bucket_relse(struct ocfs2_xattr_bucket *bucket)

fs/ocfs2/xattr.c

340

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

fs/ocfs2/xattr.c

341

brelse(bucket->bu_bhs[i]);

fs/ocfs2/xattr.c

342

bucket->bu_bhs[i] = NULL;

fs/ocfs2/xattr.c

346

static void ocfs2_xattr_bucket_free(struct ocfs2_xattr_bucket *bucket)

fs/ocfs2/xattr.c

348

if (bucket) {

fs/ocfs2/xattr.c

349

ocfs2_xattr_bucket_relse(bucket);

fs/ocfs2/xattr.c

350

bucket->bu_inode = NULL;

fs/ocfs2/xattr.c

351

kfree(bucket);

fs/ocfs2/xattr.c

3535

xbs.bucket = ocfs2_xattr_bucket_new(inode);

fs/ocfs2/xattr.c

3536

if (!xbs.bucket) {

fs/ocfs2/xattr.c

3561

ocfs2_xattr_bucket_free(xbs.bucket);

fs/ocfs2/xattr.c

361

static int ocfs2_init_xattr_bucket(struct ocfs2_xattr_bucket *bucket,

fs/ocfs2/xattr.c

3612

xbs.bucket = ocfs2_xattr_bucket_new(inode);

fs/ocfs2/xattr.c

3613

if (!xbs.bucket) {

fs/ocfs2/xattr.c

366

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

fs/ocfs2/xattr.c

367

bucket->bu_bhs[i] = sb_getblk(bucket->bu_inode->i_sb,

fs/ocfs2/xattr.c

369

if (!bucket->bu_bhs[i]) {

fs/ocfs2/xattr.c

3721

ocfs2_xattr_bucket_free(xbs.bucket);

fs/ocfs2/xattr.c

375

if (!ocfs2_buffer_uptodate(INODE_CACHE(bucket->bu_inode),

fs/ocfs2/xattr.c

376

bucket->bu_bhs[i])) {

fs/ocfs2/xattr.c

378

ocfs2_set_new_buffer_uptodate(INODE_CACHE(bucket->bu_inode),

fs/ocfs2/xattr.c

379

bucket->bu_bhs[i]);

fs/ocfs2/xattr.c

3791

struct ocfs2_xattr_bucket *bucket,

fs/ocfs2/xattr.c

3795

struct ocfs2_xattr_bucket *bucket,

fs/ocfs2/xattr.c

3803

struct ocfs2_xattr_header *xh = bucket_xh(bucket);

fs/ocfs2/xattr.c

381

set_buffer_uptodate(bucket->bu_bhs[i]);

fs/ocfs2/xattr.c

382

ocfs2_set_buffer_uptodate(INODE_CACHE(bucket->bu_inode),

fs/ocfs2/xattr.c

383

bucket->bu_bhs[i]);

fs/ocfs2/xattr.c

3837

xe_name = bucket_block(bucket, block_off) + new_offset;

fs/ocfs2/xattr.c

3872

int low_bucket = 0, bucket, high_bucket;

fs/ocfs2/xattr.c

389

ocfs2_xattr_bucket_relse(bucket);

fs/ocfs2/xattr.c

3894

bucket = (low_bucket + high_bucket) / 2;

fs/ocfs2/xattr.c

3895

blkno = p_blkno + bucket * blk_per_bucket;

fs/ocfs2/xattr.c

3905

high_bucket = bucket - 1;

fs/ocfs2/xattr.c

3921

low_bucket = bucket + 1;

fs/ocfs2/xattr.c

394

static int ocfs2_read_xattr_bucket(struct ocfs2_xattr_bucket *bucket,

fs/ocfs2/xattr.c

3945

ret = ocfs2_read_xattr_bucket(xs->bucket, lower_blkno);

fs/ocfs2/xattr.c

3951

xs->header = bucket_xh(xs->bucket);

fs/ocfs2/xattr.c

3952

xs->base = bucket_block(xs->bucket, 0);

fs/ocfs2/xattr.c

3959

(unsigned long long)bucket_blkno(xs->bucket),

fs/ocfs2/xattr.c

399

rc = ocfs2_read_blocks(INODE_CACHE(bucket->bu_inode), xb_blkno,

fs/ocfs2/xattr.c

400

bucket->bu_blocks, bucket->bu_bhs, 0,

fs/ocfs2/xattr.c

4022

struct ocfs2_xattr_bucket *bucket;

fs/ocfs2/xattr.c

4024

bucket = ocfs2_xattr_bucket_new(inode);

fs/ocfs2/xattr.c

4025

if (!bucket) {

fs/ocfs2/xattr.c

403

spin_lock(&OCFS2_SB(bucket->bu_inode->i_sb)->osb_xattr_lock);

fs/ocfs2/xattr.c

4034

for (i = 0; i < num_buckets; i++, blkno += bucket->bu_blocks) {

fs/ocfs2/xattr.c

4035

ret = ocfs2_read_xattr_bucket(bucket, blkno);

fs/ocfs2/xattr.c

404

rc = ocfs2_validate_meta_ecc_bhs(bucket->bu_inode->i_sb,

fs/ocfs2/xattr.c

4046

num_buckets = le16_to_cpu(bucket_xh(bucket)->xh_num_buckets);

fs/ocfs2/xattr.c

4049

le32_to_cpu(bucket_xh(bucket)->xh_entries[0].xe_name_hash));

fs/ocfs2/xattr.c

405

bucket->bu_bhs,

fs/ocfs2/xattr.c

4051

ret = func(inode, bucket, para);

fs/ocfs2/xattr.c

4057

ocfs2_xattr_bucket_relse(bucket);

fs/ocfs2/xattr.c

406

bucket->bu_blocks,

fs/ocfs2/xattr.c

4062

ocfs2_xattr_bucket_free(bucket);

fs/ocfs2/xattr.c

407

&bucket_xh(bucket)->xh_check);

fs/ocfs2/xattr.c

408

spin_unlock(&OCFS2_SB(bucket->bu_inode->i_sb)->osb_xattr_lock);

fs/ocfs2/xattr.c

4092

struct ocfs2_xattr_bucket *bucket,

fs/ocfs2/xattr.c

4100

for (i = 0 ; i < le16_to_cpu(bucket_xh(bucket)->xh_count); i++) {

fs/ocfs2/xattr.c

4101

struct ocfs2_xattr_entry *entry = &bucket_xh(bucket)->xh_entries[i];

fs/ocfs2/xattr.c

4105

bucket_xh(bucket),

fs/ocfs2/xattr.c

4112

name = (const char *)bucket_block(bucket, block_off) +

fs/ocfs2/xattr.c

414

ocfs2_xattr_bucket_relse(bucket);

fs/ocfs2/xattr.c

419

struct ocfs2_xattr_bucket *bucket,

fs/ocfs2/xattr.c

4223

struct ocfs2_xattr_bucket *bucket)

fs/ocfs2/xattr.c

4232

struct ocfs2_xattr_header *xh = bucket_xh(bucket);

fs/ocfs2/xattr.c

4235

char *target = bucket_block(bucket, blks - 1);

fs/ocfs2/xattr.c

4239

(unsigned long long)bucket_blkno(bucket));

fs/ocfs2/xattr.c

424

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

fs/ocfs2/xattr.c

4242

memset(bucket_block(bucket, i), 0, blocksize);

fs/ocfs2/xattr.c

426

INODE_CACHE(bucket->bu_inode),

fs/ocfs2/xattr.c

4264

target = bucket_block(bucket, 0);

fs/ocfs2/xattr.c

427

bucket->bu_bhs[i], type);

fs/ocfs2/xattr.c

4298

xs->header = bucket_xh(xs->bucket);

fs/ocfs2/xattr.c

4299

xs->base = bucket_block(xs->bucket, 0);

fs/ocfs2/xattr.c

4328

BUG_ON(!xs->bucket);

fs/ocfs2/xattr.c

4360

ret = ocfs2_init_xattr_bucket(xs->bucket, blkno, 1);

fs/ocfs2/xattr.c

4366

ret = ocfs2_xattr_bucket_journal_access(handle, xs->bucket,

fs/ocfs2/xattr.c

4373

ocfs2_cp_xattr_block_to_bucket(inode, xb_bh, xs->bucket);

fs/ocfs2/xattr.c

4374

ocfs2_xattr_bucket_journal_dirty(handle, xs->bucket);

fs/ocfs2/xattr.c

438

struct ocfs2_xattr_bucket *bucket)

fs/ocfs2/xattr.c

442

spin_lock(&OCFS2_SB(bucket->bu_inode->i_sb)->osb_xattr_lock);

fs/ocfs2/xattr.c

4424

struct ocfs2_xattr_bucket *bucket)

fs/ocfs2/xattr.c

443

ocfs2_compute_meta_ecc_bhs(bucket->bu_inode->i_sb,

fs/ocfs2/xattr.c

4430

u64 blkno = bucket_blkno(bucket);

fs/ocfs2/xattr.c

444

bucket->bu_bhs, bucket->bu_blocks,

fs/ocfs2/xattr.c

4448

for (i = 0; i < bucket->bu_blocks; i++, buf += blocksize)

fs/ocfs2/xattr.c

4449

memcpy(buf, bucket_block(bucket, i), blocksize);

fs/ocfs2/xattr.c

445

&bucket_xh(bucket)->xh_check);

fs/ocfs2/xattr.c

4451

ret = ocfs2_xattr_bucket_journal_access(handle, bucket,

fs/ocfs2/xattr.c

446

spin_unlock(&OCFS2_SB(bucket->bu_inode->i_sb)->osb_xattr_lock);

fs/ocfs2/xattr.c

448

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

fs/ocfs2/xattr.c

449

ocfs2_journal_dirty(handle, bucket->bu_bhs[i]);

fs/ocfs2/xattr.c

4518

for (i = 0; i < bucket->bu_blocks; i++, buf += blocksize)

fs/ocfs2/xattr.c

4519

memcpy(bucket_block(bucket, i), buf, blocksize);

fs/ocfs2/xattr.c

4520

ocfs2_xattr_bucket_journal_dirty(handle, bucket);

fs/ocfs2/xattr.c

5392

struct ocfs2_xattr_bucket *bucket,

fs/ocfs2/xattr.c

5400

struct ocfs2_xattr_header *xh = bucket_xh(bucket);

fs/ocfs2/xattr.c

5418

vb.vb_bh = bucket->bu_bhs[value_blk];

fs/ocfs2/xattr.c

5432

(unsigned long long)bucket_blkno(bucket), xe_off, len);

fs/ocfs2/xattr.c

5439

ret = ocfs2_xattr_bucket_journal_access(ctxt->handle, bucket,

fs/ocfs2/xattr.c

5448

ocfs2_xattr_bucket_journal_dirty(ctxt->handle, bucket);

fs/ocfs2/xattr.c

5556

struct ocfs2_xattr_bucket *bucket,

fs/ocfs2/xattr.c

5559

struct ocfs2_xattr_header *xh = bucket_xh(bucket);

fs/ocfs2/xattr.c

5569

(unsigned long long)bucket_blkno(bucket),

fs/ocfs2/xattr.c

5591

ocfs2_init_xattr_bucket_xa_loc(&loc, xs->bucket,

fs/ocfs2/xattr.c

5605

xs->bucket);

fs/ocfs2/xattr.c

5650

xs->bucket,

fs/ocfs2/xattr.c

5659

xs->bucket,

fs/ocfs2/xattr.c

5673

ocfs2_xattr_bucket_relse(xs->bucket);

fs/ocfs2/xattr.c

5691

struct ocfs2_xattr_bucket *bucket,

fs/ocfs2/xattr.c

5695

struct ocfs2_xattr_header *xh = bucket_xh(bucket);

fs/ocfs2/xattr.c

5713

ret = ocfs2_get_xattr_tree_value_root(inode->i_sb, bucket,

fs/ocfs2/xattr.c

5733

ret = ocfs2_xattr_bucket_value_truncate(inode, bucket,

fs/ocfs2/xattr.c

5767

struct ocfs2_xattr_bucket *bucket =

fs/ocfs2/xattr.c

5770

ret = ocfs2_xattr_bucket_journal_access(handle, bucket,

fs/ocfs2/xattr.c

5777

ocfs2_xattr_bucket_journal_dirty(handle, bucket);

fs/ocfs2/xattr.c

5813

struct ocfs2_xattr_bucket *bucket = NULL;

fs/ocfs2/xattr.c

5836

bucket_xh(xbs->bucket),

fs/ocfs2/xattr.c

5843

base = bucket_block(xbs->bucket, block_off);

fs/ocfs2/xattr.c

5844

vb.vb_bh = xbs->bucket->bu_bhs[block_off];

fs/ocfs2/xattr.c

5849

bucket = xbs->bucket;

fs/ocfs2/xattr.c

5850

refcount.credits = bucket->bu_blocks;

fs/ocfs2/xattr.c

5851

refcount.para = bucket;

fs/ocfs2/xattr.c

6041

struct ocfs2_xattr_bucket *bucket,

fs/ocfs2/xattr.c

6047

struct ocfs2_xattr_header *xh = bucket_xh(bucket);

fs/ocfs2/xattr.c

6052

bucket_xh(bucket),

fs/ocfs2/xattr.c

6061

base = bucket_block(bucket, block_off);

fs/ocfs2/xattr.c

6067

*bh = bucket->bu_bhs[block_off];

fs/ocfs2/xattr.c

6077

struct ocfs2_xattr_bucket *bucket,

fs/ocfs2/xattr.c

6085

(struct ocfs2_xattr_header *)bucket->bu_bhs[0]->b_data;

fs/ocfs2/xattr.c

6091

.credits = bucket->bu_blocks,

fs/ocfs2/xattr.c

6092

.para = bucket,

fs/ocfs2/xattr.c

6102

(unsigned long long)bucket_blkno(bucket),

fs/ocfs2/xattr.c

6110

ret = ocfs2_get_xattr_tree_value_root(inode->i_sb, bucket, i,

fs/ocfs2/xattr.c

6734

struct ocfs2_xattr_bucket *bucket;

fs/ocfs2/xattr.c

6737

bucket = args->old_bucket;

fs/ocfs2/xattr.c

6739

bucket = args->new_bucket;

fs/ocfs2/xattr.c

6741

return ocfs2_get_xattr_tree_value_root(sb, bucket, offset,

fs/ocfs2/xattr.c

6759

struct ocfs2_xattr_bucket *bucket =

fs/ocfs2/xattr.c

6762

return ocfs2_get_xattr_tree_value_root(sb, bucket, offset,

fs/ocfs2/xattr.c

6767

struct ocfs2_xattr_bucket *bucket,

fs/ocfs2/xattr.c

6773

(struct ocfs2_xattr_header *)bucket->bu_bhs[0]->b_data;

fs/ocfs2/xattr.c

6776

metas->credits += bucket->bu_blocks;

fs/ocfs2/xattr.c

6777

return ocfs2_value_metas_in_xattr_header(inode->i_sb, bucket->bu_bhs[0],

fs/ocfs2/xattr.c

6781

bucket);

fs/omfs/dir.c

28

int bucket = omfs_hash(name, namelen, nbuckets);

fs/omfs/dir.c

30

*ofs = OMFS_DIR_START + bucket * 8;

fs/seq_file.c

1132

struct hlist_head *bucket = per_cpu_ptr(head, *cpu);

fs/seq_file.c

1134

if (!hlist_empty(bucket))

fs/seq_file.c

1135

return bucket->first;

fs/smb/client/compress.c

102

static int calc_byte_distribution(struct bucket *bkt, size_t slen)

fs/smb/client/compress.c

129

static bool is_mostly_ascii(const struct bucket *bkt)

fs/smb/client/compress.c

152

const struct bucket *a = _a, *b = _b;

fs/smb/client/compress.c

201

struct bucket *bkt = NULL;

fs/smb/client/compress.c

68

static bool has_low_entropy(struct bucket *bkt, size_t slen)

fs/xfs/libxfs/xfs_ag.c

534

int bucket;

fs/xfs/libxfs/xfs_ag.c

543

for (bucket = 0; bucket < xfs_agfl_size(mp); bucket++)

fs/xfs/libxfs/xfs_ag.c

544

agfl_bno[bucket] = cpu_to_be32(NULLAGBLOCK);

fs/xfs/libxfs/xfs_ag.c

554

int bucket;

fs/xfs/libxfs/xfs_ag.c

572

for (bucket = 0; bucket < XFS_AGI_UNLINKED_BUCKETS; bucket++)

fs/xfs/libxfs/xfs_ag.c

573

agi->agi_unlinked[bucket] = cpu_to_be32(NULLAGINO);

fs/xfs/scrub/agheader_repair.c

1081

unsigned int bucket)

fs/xfs/scrub/agheader_repair.c

1089

next_agino = be32_to_cpu(agi->agi_unlinked[bucket]);

fs/xfs/scrub/agheader_repair.c

1096

trace_xrep_iunlink_walk_ondisk_bucket(sc->sa.pag, bucket,

fs/xfs/scrub/agheader_repair.c

1099

if (bucket != agino % XFS_AGI_UNLINKED_BUCKETS)

fs/xfs/scrub/agheader_repair.c

1139

unsigned int bucket = agino % XFS_AGI_UNLINKED_BUCKETS;

fs/xfs/scrub/agheader_repair.c

1145

trace_xrep_iunlink_visit(ragi->sc->sa.pag, bucket,

fs/xfs/scrub/agheader_repair.c

1146

ragi->iunlink_heads[bucket], ip);

fs/xfs/scrub/agheader_repair.c

1153

if (ragi->iunlink_heads[bucket] == NULLAGINO)

fs/xfs/scrub/agheader_repair.c

1154

ragi->iunlink_heads[bucket] = agino;

fs/xfs/scrub/agheader_repair.c

1321

unsigned int bucket)

fs/xfs/scrub/agheader_repair.c

1326

xfs_agino_t next_agino = ragi->iunlink_heads[bucket];

fs/xfs/scrub/agheader_repair.c

1338

bucket, prev_agino, next_agino);

fs/xfs/scrub/agheader_repair.c

1344

if (next_agino % XFS_AGI_UNLINKED_BUCKETS != bucket) {

fs/xfs/scrub/agheader_repair.c

1350

bucket, prev_agino, next_agino);

fs/xfs/scrub/agheader_repair.c

1364

bucket, prev_agino, next_agino);

fs/xfs/scrub/agheader_repair.c

1369

trace_xrep_iunlink_resolve_ok(sc->sa.pag, bucket, prev_agino,

fs/xfs/scrub/agheader_repair.c

1416

unsigned int bucket;

fs/xfs/scrub/agheader_repair.c

1419

bucket = agino % XFS_AGI_UNLINKED_BUCKETS;

fs/xfs/scrub/agheader_repair.c

1422

current_head = ragi->iunlink_heads[bucket];

fs/xfs/scrub/agheader_repair.c

1424

trace_xrep_iunlink_add_to_bucket(ragi->sc->sa.pag, bucket, agino,

fs/xfs/scrub/agheader_repair.c

1438

ragi->iunlink_heads[bucket] = agino;

fs/xfs/scrub/trace.h

3396

TP_PROTO(const struct xfs_perag *pag, unsigned int bucket,

fs/xfs/scrub/trace.h

3398

TP_ARGS(pag, bucket, bucket_agino, ip),

fs/xfs/scrub/trace.h

3403

__field(unsigned int, bucket)

fs/xfs/scrub/trace.h

3412

__entry->bucket = bucket;

fs/xfs/scrub/trace.h

3420

__entry->bucket,

fs/xfs/scrub/trace.h

3486

TP_PROTO(const struct xfs_perag *pag, unsigned int bucket,

fs/xfs/scrub/trace.h

3488

TP_ARGS(pag, bucket, prev_agino, next_agino),

fs/xfs/scrub/trace.h

3492

__field(unsigned int, bucket)

fs/xfs/scrub/trace.h

3499

__entry->bucket = bucket;

fs/xfs/scrub/trace.h

3506

__entry->bucket,

fs/xfs/scrub/trace.h

3512

TP_PROTO(const struct xfs_perag *pag, unsigned int bucket,

fs/xfs/scrub/trace.h

3514

TP_ARGS(pag, bucket, prev_agino, next_agino),

fs/xfs/scrub/trace.h

3518

__field(unsigned int, bucket)

fs/xfs/scrub/trace.h

3525

__entry->bucket = bucket;

fs/xfs/scrub/trace.h

3532

__entry->bucket,

fs/xfs/scrub/trace.h

3538

TP_PROTO(const struct xfs_perag *pag, unsigned int bucket, \

fs/xfs/scrub/trace.h

3540

TP_ARGS(pag, bucket, prev_agino, next_agino))

fs/xfs/scrub/trace.h

3599

TP_PROTO(const struct xfs_perag *pag, unsigned int bucket,

fs/xfs/scrub/trace.h

3601

TP_ARGS(pag, bucket, agino, curr_head),

fs/xfs/scrub/trace.h

3605

__field(unsigned int, bucket)

fs/xfs/scrub/trace.h

3612

__entry->bucket = bucket;

fs/xfs/scrub/trace.h

3619

__entry->bucket,

fs/xfs/scrub/trace.h

3625

TP_PROTO(const struct xfs_perag *pag, unsigned int bucket,

fs/xfs/scrub/trace.h

3627

TP_ARGS(pag, bucket, old_agino, agino),

fs/xfs/scrub/trace.h

3631

__field(unsigned int, bucket)

fs/xfs/scrub/trace.h

3638

__entry->bucket = bucket;

fs/xfs/scrub/trace.h

3645

__entry->bucket,

fs/xfs/xfs_buf_item_recover.c

57

struct list_head *bucket;

fs/xfs/xfs_buf_item_recover.c

63

bucket = XLOG_BUF_CANCEL_BUCKET(log, blkno);

fs/xfs/xfs_buf_item_recover.c

64

list_for_each_entry(bcp, bucket, bc_list) {

fs/xfs/xfs_inode.c

2870

unsigned int bucket;

fs/xfs/xfs_inode.c

2891

bucket = agino % XFS_AGI_UNLINKED_BUCKETS;

fs/xfs/xfs_inode.c

2901

next_agino = be32_to_cpu(agi->agi_unlinked[bucket]);

fs/xfs/xfs_log_recover.c

2694

int bucket)

fs/xfs/xfs_log_recover.c

2712

agi->agi_unlinked[bucket] = cpu_to_be32(NULLAGINO);

fs/xfs/xfs_log_recover.c

2714

(sizeof(xfs_agino_t) * bucket);

fs/xfs/xfs_log_recover.c

2735

int bucket)

fs/xfs/xfs_log_recover.c

2743

agino = be32_to_cpu(agi->agi_unlinked[bucket]);

fs/xfs/xfs_log_recover.c

2819

int bucket;

fs/xfs/xfs_log_recover.c

2844

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

fs/xfs/xfs_log_recover.c

2845

error = xlog_recover_iunlink_bucket(pag, agi, bucket);

fs/xfs/xfs_log_recover.c

2853

xlog_recover_clear_agi_bucket(pag, bucket);

fs/xfs/xfs_trace.h

4469

TP_PROTO(const struct xfs_perag *pag, unsigned int bucket,

fs/xfs/xfs_trace.h

4471

TP_ARGS(pag, bucket, old_ptr, new_ptr),

fs/xfs/xfs_trace.h

4475

__field(unsigned int, bucket)

fs/xfs/xfs_trace.h

4482

__entry->bucket = bucket;

fs/xfs/xfs_trace.h

4489

__entry->bucket,

fs/xfs/xfs_trace.h

468

TP_PROTO(struct xfs_rtgroup *rtg, unsigned int bucket),

fs/xfs/xfs_trace.h

469

TP_ARGS(rtg, bucket),

fs/xfs/xfs_trace.h

474

__field(unsigned int, bucket)

fs/xfs/xfs_trace.h

480

__entry->bucket = bucket;

fs/xfs/xfs_trace.h

486

__entry->bucket)

fs/xfs/xfs_zone_gc.c

441

uint32_t bucket)

fs/xfs/xfs_zone_gc.c

448

if (!zi->zi_used_bucket_entries[bucket])

fs/xfs/xfs_zone_gc.c

451

for_each_set_bit(bit, zi->zi_used_bucket_bitmap[bucket],

fs/xfs/xfs_zone_gc.c

490

if (bucket == 0 &&

fs/xfs/xfs_zone_gc.c

510

unsigned int bucket;

fs/xfs/xfs_zone_gc.c

513

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

fs/xfs/xfs_zone_gc.c

514

victim_rtg = xfs_zone_gc_pick_victim_from(mp, bucket);

fs/xfs/xfs_zone_gc.c

523

trace_xfs_zone_gc_select_victim(victim_rtg, bucket);

include/linux/rhashtable.h

336

struct rhash_lock_head __rcu **bucket,

include/linux/rhashtable.h

338

__acquires(__bitlock(0, bucket))

include/linux/rhashtable.h

343

bit_spin_lock(0, (unsigned long *)bucket);

include/net/ip_vs.h

564

#define ip_vs_rht_for_each_bucket(t, bucket, head) \

include/net/ip_vs.h

565

for (bucket = 0, head = (t)->buckets; \

include/net/ip_vs.h

566

bucket < t->size; bucket++, head++)

include/net/ip_vs.h

576

#define ip_vs_rht_for_bucket_retry(t, bucket, sc, seq, retry) \

include/net/ip_vs.h

577

for (retry = 1, sc = &(t)->seqc[(bucket) & (t)->seqc_mask]; \

include/net/ip_vs.h

632

#define ip_vs_rht_walk_bucket_rcu(t, bucket, head) \

include/net/ip_vs.h

633

if (({ head = (t)->buckets + ((bucket) & (t)->mask); 0; })) \

include/net/ip_vs.h

636

ip_vs_rht_for_bucket_retry(t, (bucket), _sc, _seq, _retry)

include/net/llc.h

69

u32 bucket = hash_32(ifindex, LLC_SK_DEV_HASH_BITS);

include/net/llc.h

71

return &sap->sk_dev_hash[bucket];

include/net/neighbour.h

418

unsigned int bucket;

include/net/ping.h

39

int bucket;

include/net/raw.h

63

int bucket;

include/net/tcp.h

2418

int bucket, offset, sbucket, num;

include/net/transp_v6.h

45

__u16 srcp, __u16 destp, int rqueue, int bucket);

include/net/transp_v6.h

48

__u16 destp, int bucket)

include/net/transp_v6.h

51

bucket);

include/net/udp.h

557

int bucket;

include/trace/events/bcache.h

267

__field(size_t, bucket )

include/trace/events/bcache.h

273

__entry->bucket = PTR_BUCKET_NR(b->c, &b->key, 0);

include/trace/events/bcache.h

279

__entry->bucket, __entry->block, __entry->keys)

include/trace/events/bcache.h

370

__field(size_t, bucket )

include/trace/events/bcache.h

375

__entry->bucket = PTR_BUCKET_NR(b->c, &b->key, 0);

include/trace/events/bcache.h

379

TP_printk("bucket %zu keys %u", __entry->bucket, __entry->keys)

include/trace/events/bcache.h

429

TP_PROTO(struct cache *ca, size_t bucket),

include/trace/events/bcache.h

430

TP_ARGS(ca, bucket),

include/trace/events/bcache.h

440

__entry->offset = bucket << ca->set->bucket_bits;

include/trace/events/bcache.h

441

__entry->sectors = GC_SECTORS_USED(&ca->buckets[bucket]);

include/trace/events/bcache.h

450

TP_PROTO(struct cache *ca, size_t bucket),

include/trace/events/bcache.h

451

TP_ARGS(ca, bucket),

include/trace/events/bcache.h

460

__entry->offset = bucket << ca->set->bucket_bits;

include/trace/events/bcache.h

68

__field(size_t, bucket )

include/trace/events/bcache.h

72

__entry->bucket = PTR_BUCKET_NR(b->c, &b->key, 0);

include/trace/events/bcache.h

75

TP_printk("bucket %zu", __entry->bucket)

kernel/bpf/hashtab.c

1181

struct bucket *b;

kernel/bpf/hashtab.c

1288

struct bucket *b;

kernel/bpf/hashtab.c

1365

struct bucket *b;

kernel/bpf/hashtab.c

1427

struct bucket *b;

kernel/bpf/hashtab.c

150

static inline int htab_lock_bucket(struct bucket *b, unsigned long *pflags)

kernel/bpf/hashtab.c

1506

struct bucket *b;

kernel/bpf/hashtab.c

1541

struct bucket *b;

kernel/bpf/hashtab.c

162

static inline void htab_unlock_bucket(struct bucket *b, unsigned long flags)

kernel/bpf/hashtab.c

1687

struct bucket *b;

kernel/bpf/hashtab.c

1793

struct bucket *b;

kernel/bpf/hashtab.c

2100

struct bucket *b;

kernel/bpf/hashtab.c

2275

struct bucket *b;

kernel/bpf/hashtab.c

2329

sizeof(struct bucket) * htab->n_buckets;

kernel/bpf/hashtab.c

594

if (htab->n_buckets > U32_MAX / sizeof(struct bucket))

kernel/bpf/hashtab.c

603

sizeof(struct bucket),

kernel/bpf/hashtab.c

684

static inline struct bucket *__select_bucket(struct bpf_htab *htab, u32 hash)

kernel/bpf/hashtab.c

869

struct bucket *b;

kernel/bpf/hashtab.c

90

struct bucket *buckets;

kernel/bpf/stackmap.c

511

struct stack_map_bucket *bucket, *new_bucket, *old_bucket;

kernel/bpf/stackmap.c

528

bucket = READ_ONCE(smap->buckets[id]);

kernel/bpf/stackmap.c

530

hash_matches = bucket && bucket->hash == hash;

kernel/bpf/stackmap.c

549

if (hash_matches && bucket->nr == trace_nr &&

kernel/bpf/stackmap.c

550

memcmp(bucket->data, new_bucket->data, trace_len) == 0) {

kernel/bpf/stackmap.c

554

if (bucket && !(flags & BPF_F_REUSE_STACKID)) {

kernel/bpf/stackmap.c

559

if (hash_matches && bucket->nr == trace_nr &&

kernel/bpf/stackmap.c

560

memcmp(bucket->data, ips, trace_len) == 0)

kernel/bpf/stackmap.c

562

if (bucket && !(flags & BPF_F_REUSE_STACKID))

kernel/bpf/stackmap.c

936

struct stack_map_bucket *bucket, *old_bucket;

kernel/bpf/stackmap.c

942

bucket = xchg(&smap->buckets[id], NULL);

kernel/bpf/stackmap.c

943

if (!bucket)

kernel/bpf/stackmap.c

946

trace_len = bucket->nr * stack_map_data_size(map);

kernel/bpf/stackmap.c

947

memcpy(value, bucket->data, trace_len);

kernel/bpf/stackmap.c

951

old_bucket = bucket;

kernel/bpf/stackmap.c

953

old_bucket = xchg(&smap->buckets[id], bucket);

kernel/dma/debug.c

1101

put_hash_bucket(bucket, flags);

kernel/dma/debug.c

1151

struct hash_bucket *bucket;

kernel/dma/debug.c

1154

bucket = get_hash_bucket(ref, &flags);

kernel/dma/debug.c

1156

entry = bucket_find_contain(&bucket, ref, &flags);

kernel/dma/debug.c

1218

put_hash_bucket(bucket, flags);

kernel/dma/debug.c

1306

struct hash_bucket *bucket;

kernel/dma/debug.c

1314

bucket = get_hash_bucket(&ref, &flags);

kernel/dma/debug.c

1316

list_for_each_entry(entry, &bucket->list, list) {

kernel/dma/debug.c

1336

put_hash_bucket(bucket, flags);

kernel/dma/debug.c

1399

struct hash_bucket *bucket;

kernel/dma/debug.c

1403

bucket = get_hash_bucket(ref, &flags);

kernel/dma/debug.c

1404

entry = bucket_find_exact(bucket, ref);

kernel/dma/debug.c

1409

put_hash_bucket(bucket, flags);

kernel/dma/debug.c

268

static void put_hash_bucket(struct hash_bucket *bucket,

kernel/dma/debug.c

270

__releases(&bucket->lock)

kernel/dma/debug.c

272

spin_unlock_irqrestore(&bucket->lock, flags);

kernel/dma/debug.c

297

static struct dma_debug_entry *__hash_bucket_find(struct hash_bucket *bucket,

kernel/dma/debug.c

304

list_for_each_entry(entry, &bucket->list, list) {

kernel/dma/debug.c

347

static struct dma_debug_entry *bucket_find_exact(struct hash_bucket *bucket,

kernel/dma/debug.c

350

return __hash_bucket_find(bucket, ref, exact_match);

kernel/dma/debug.c

353

static struct dma_debug_entry *bucket_find_contain(struct hash_bucket **bucket,

kernel/dma/debug.c

362

entry = __hash_bucket_find(*bucket, ref, containing_match);

kernel/dma/debug.c

370

put_hash_bucket(*bucket, *flags);

kernel/dma/debug.c

372

*bucket = get_hash_bucket(&index, flags);

kernel/dma/debug.c

381

static void hash_bucket_add(struct hash_bucket *bucket,

kernel/dma/debug.c

384

list_add_tail(&entry->list, &bucket->list);

kernel/dma/debug.c

544

struct hash_bucket *bucket = &dma_entry_hash[idx];

kernel/dma/debug.c

548

spin_lock_irqsave(&bucket->lock, flags);

kernel/dma/debug.c

549

list_for_each_entry(entry, &bucket->list, list) {

kernel/dma/debug.c

562

spin_unlock_irqrestore(&bucket->lock, flags);

kernel/dma/debug.c

577

struct hash_bucket *bucket = &dma_entry_hash[idx];

kernel/dma/debug.c

581

spin_lock_irqsave(&bucket->lock, flags);

kernel/dma/debug.c

582

list_for_each_entry(entry, &bucket->list, list) {

kernel/dma/debug.c

595

spin_unlock_irqrestore(&bucket->lock, flags);

kernel/dma/debug.c

609

struct hash_bucket *bucket;

kernel/dma/debug.c

613

bucket = get_hash_bucket(entry, &flags);

kernel/dma/debug.c

614

hash_bucket_add(bucket, entry);

kernel/dma/debug.c

615

put_hash_bucket(bucket, flags);

kernel/dma/debug.c

989

struct hash_bucket *bucket;

kernel/dma/debug.c

992

bucket = get_hash_bucket(ref, &flags);

kernel/dma/debug.c

993

entry = bucket_find_exact(bucket, ref);

kernel/dma/debug.c

997

put_hash_bucket(bucket, flags);

kernel/locking/lockdep.c

3368

#define for_each_chain_block(bucket, prev, curr) \

kernel/locking/lockdep.c

3369

for ((prev) = -1, (curr) = chain_block_buckets[bucket]; \

kernel/locking/lockdep.c

3400

static inline void init_chain_block(int offset, int next, int bucket, int size)

kernel/locking/lockdep.c

3405

if (size && !bucket) {

kernel/locking/lockdep.c

3413

int bucket = size_to_bucket(size);

kernel/locking/lockdep.c

3414

int next = chain_block_buckets[bucket];

kernel/locking/lockdep.c

3431

if (!bucket) {

kernel/locking/lockdep.c

3451

init_chain_block(offset, next, bucket, size);

kernel/locking/lockdep.c

3452

chain_block_buckets[bucket] = offset;

kernel/locking/lockdep.c

3466

static inline void del_chain_block(int bucket, int size, int next)

kernel/locking/lockdep.c

3469

chain_block_buckets[bucket] = next;

kernel/locking/lockdep.c

3471

if (!bucket)

kernel/locking/lockdep.c

3493

int bucket, curr, size;

kernel/locking/lockdep.c

3511

bucket = size_to_bucket(req);

kernel/locking/lockdep.c

3512

curr = chain_block_buckets[bucket];

kernel/locking/lockdep.c

3514

if (bucket) {

kernel/locking/lockdep.c

3516

del_chain_block(bucket, req, chain_block_next(curr));

kernel/locking/lockdep.c

3541

bucket = size_to_bucket(size);

kernel/locking/lockdep.c

3542

curr = chain_block_buckets[bucket];

kernel/locking/lockdep.c

3546

del_chain_block(bucket, size, chain_block_next(curr));

kernel/sched/core.c

1637

struct uclamp_bucket *bucket = rq->uclamp[clamp_id].bucket;

kernel/sched/core.c

1645

if (!bucket[bucket_id].tasks)

kernel/sched/core.c

1647

return bucket[bucket_id].value;

kernel/sched/core.c

1757

struct uclamp_bucket *bucket;

kernel/sched/core.c

1764

bucket = &uc_rq->bucket[uc_se->bucket_id];

kernel/sched/core.c

1765

bucket->tasks++;

kernel/sched/core.c

1774

if (bucket->tasks == 1 || uc_se->value > bucket->value)

kernel/sched/core.c

1775

bucket->value = uc_se->value;

kernel/sched/core.c

1795

struct uclamp_bucket *bucket;

kernel/sched/core.c

1827

bucket = &uc_rq->bucket[uc_se->bucket_id];

kernel/sched/core.c

1829

WARN_ON_ONCE(!bucket->tasks);

kernel/sched/core.c

1830

if (likely(bucket->tasks))

kernel/sched/core.c

1831

bucket->tasks--;

kernel/sched/core.c

1841

if (likely(bucket->tasks))

kernel/sched/core.c

1849

WARN_ON_ONCE(bucket->value > rq_clamp);

kernel/sched/core.c

1850

if (bucket->value >= rq_clamp) {

kernel/sched/sched.h

1122

struct uclamp_bucket bucket[UCLAMP_BUCKETS];

kernel/time/posix-timers.c

114

static bool posix_timer_hashed(struct timer_hash_bucket *bucket, struct signal_struct *sig,

kernel/time/posix-timers.c

117

struct hlist_head *head = &bucket->head;

kernel/time/posix-timers.c

120

hlist_for_each_entry_rcu(timer, head, t_hash, lockdep_is_held(&bucket->lock)) {

kernel/time/posix-timers.c

129

struct timer_hash_bucket *bucket = hash_bucket(sig, id);

kernel/time/posix-timers.c

131

scoped_guard (spinlock, &bucket->lock) {

kernel/time/posix-timers.c

137

if (!posix_timer_hashed(bucket, sig, id)) {

kernel/time/posix-timers.c

150

hlist_add_head_rcu(&timer->t_hash, &bucket->head);

kernel/time/posix-timers.c

452

struct timer_hash_bucket *bucket = hash_bucket(posix_sig_owner(tmr), tmr->it_id);

kernel/time/posix-timers.c

454

scoped_guard (spinlock, &bucket->lock)

kernel/time/posix-timers.c

92

struct timer_hash_bucket *bucket = hash_bucket(sig, id);

kernel/time/posix-timers.c

95

hlist_for_each_entry_rcu(timer, &bucket->head, t_hash) {

lib/rhashtable.c

1364

return &ntbl[subhash].bucket;

lib/rhashtable.c

1404

return &ntbl[hash].bucket;

lib/rhashtable.c

146

INIT_RHT_NULLS_HEAD(ntbl[i].bucket);

lib/rhashtable.c

34

struct rhash_lock_head __rcu *bucket;

lib/stackdepot.c

592

static inline struct stack_record *find_stack(struct list_head *bucket,

lib/stackdepot.c

609

list_for_each_entry_rcu(stack, bucket, hash_list) {

lib/stackdepot.c

646

struct list_head *bucket;

lib/stackdepot.c

673

bucket = &stack_table[hash & stack_hash_mask];

lib/stackdepot.c

676

found = find_stack(bucket, entries, nr_entries, hash, depot_flags);

lib/stackdepot.c

703

found = find_stack(bucket, entries, nr_entries, hash, depot_flags);

lib/stackdepot.c

713

list_add_rcu(&new->hash_list, bucket);

lib/zstd/compress/zstd_compress_internal.h

330

ldmEntry_t* bucket;

lib/zstd/compress/zstd_ldm.c

398

candidates[n].bucket = ZSTD_ldm_getBucket(ldmState, hash, params->bucketSizeLog);

lib/zstd/compress/zstd_ldm.c

399

PREFETCH_L1(candidates[n].bucket);

lib/zstd/compress/zstd_ldm.c

409

ldmEntry_t* const bucket = candidates[n].bucket;

lib/zstd/compress/zstd_ldm.c

425

for (cur = bucket; cur < bucket + entsPerBucket; cur++) {

net/8021q/vlan_dev.c

178

u32 bucket = skb_prio & 0xF;

net/8021q/vlan_dev.c

182

mpp = &vlan->egress_priority_map[bucket];

net/8021q/vlan_dev.c

209

RCU_INIT_POINTER(np->next, rtnl_dereference(vlan->egress_priority_map[bucket]));

net/8021q/vlan_dev.c

210

rcu_assign_pointer(vlan->egress_priority_map[bucket], np);

net/atm/proc.c

110

return __vcc_walk(&state->sk, family, &state->bucket, l) ?

net/atm/proc.c

66

int bucket;

net/atm/proc.c

75

static int __vcc_walk(struct sock **sock, int family, int *bucket, loff_t l)

net/atm/proc.c

80

for (*bucket = 0; *bucket < VCC_HTABLE_SIZE; ++*bucket) {

net/atm/proc.c

81

struct hlist_head *head = &vcc_hash[*bucket];

net/atm/proc.c

95

if (!sk && ++*bucket < VCC_HTABLE_SIZE) {

net/atm/proc.c

96

sk = sk_head(&vcc_hash[*bucket]);

net/batman-adv/bat_iv_ogm.c

2074

int bucket = cb->args[0];

net/batman-adv/bat_iv_ogm.c

2079

while (bucket < hash->size) {

net/batman-adv/bat_iv_ogm.c

2080

head = &hash->table[bucket];

net/batman-adv/bat_iv_ogm.c

2088

bucket++;

net/batman-adv/bat_iv_ogm.c

2091

cb->args[0] = bucket;

net/batman-adv/bat_v.c

425

int bucket = cb->args[0];

net/batman-adv/bat_v.c

430

while (bucket < hash->size) {

net/batman-adv/bat_v.c

431

head = &hash->table[bucket];

net/batman-adv/bat_v.c

439

bucket++;

net/batman-adv/bat_v.c

442

cb->args[0] = bucket;

net/batman-adv/bridge_loop_avoidance.c

2246

struct batadv_hashtable *hash, unsigned int bucket,

net/batman-adv/bridge_loop_avoidance.c

2253

spin_lock_bh(&hash->list_locks[bucket]);

net/batman-adv/bridge_loop_avoidance.c

2256

hlist_for_each_entry(claim, &hash->table[bucket], hash_entry) {

net/batman-adv/bridge_loop_avoidance.c

2270

spin_unlock_bh(&hash->list_locks[bucket]);

net/batman-adv/bridge_loop_avoidance.c

2288

int bucket = cb->args[0];

net/batman-adv/bridge_loop_avoidance.c

2305

while (bucket < hash->size) {

net/batman-adv/bridge_loop_avoidance.c

2307

hash, bucket, &idx))

net/batman-adv/bridge_loop_avoidance.c

2309

bucket++;

net/batman-adv/bridge_loop_avoidance.c

2312

cb->args[0] = bucket;

net/batman-adv/bridge_loop_avoidance.c

2408

unsigned int bucket, int *idx_skip)

net/batman-adv/bridge_loop_avoidance.c

2414

spin_lock_bh(&hash->list_locks[bucket]);

net/batman-adv/bridge_loop_avoidance.c

2417

hlist_for_each_entry(backbone_gw, &hash->table[bucket], hash_entry) {

net/batman-adv/bridge_loop_avoidance.c

2431

spin_unlock_bh(&hash->list_locks[bucket]);

net/batman-adv/bridge_loop_avoidance.c

2449

int bucket = cb->args[0];

net/batman-adv/bridge_loop_avoidance.c

2466

while (bucket < hash->size) {

net/batman-adv/bridge_loop_avoidance.c

2468

hash, bucket, &idx))

net/batman-adv/bridge_loop_avoidance.c

2470

bucket++;

net/batman-adv/bridge_loop_avoidance.c

2473

cb->args[0] = bucket;

net/batman-adv/distributed-arp-table.c

909

struct batadv_hashtable *hash, unsigned int bucket,

net/batman-adv/distributed-arp-table.c

915

spin_lock_bh(&hash->list_locks[bucket]);

net/batman-adv/distributed-arp-table.c

918

hlist_for_each_entry(dat_entry, &hash->table[bucket], hash_entry) {

net/batman-adv/distributed-arp-table.c

923

spin_unlock_bh(&hash->list_locks[bucket]);

net/batman-adv/distributed-arp-table.c

932

spin_unlock_bh(&hash->list_locks[bucket]);

net/batman-adv/distributed-arp-table.c

951

int bucket = cb->args[0];

net/batman-adv/distributed-arp-table.c

968

while (bucket < hash->size) {

net/batman-adv/distributed-arp-table.c

969

if (batadv_dat_cache_dump_bucket(msg, portid, cb, hash, bucket,

net/batman-adv/distributed-arp-table.c

973

bucket++;

net/batman-adv/distributed-arp-table.c

977

cb->args[0] = bucket;

net/batman-adv/fragmentation.c

146

u8 bucket;

net/batman-adv/fragmentation.c

162

bucket = seqno % BATADV_FRAG_BUFFER_COUNT;

net/batman-adv/fragmentation.c

175

chain = &orig_node->fragments[bucket];

net/batman-adv/multicast.c

2025

unsigned int bucket, long *idx_skip)

net/batman-adv/multicast.c

2030

spin_lock_bh(&hash->list_locks[bucket]);

net/batman-adv/multicast.c

2033

hlist_for_each_entry(orig_node, &hash->table[bucket], hash_entry) {

net/batman-adv/multicast.c

2042

spin_unlock_bh(&hash->list_locks[bucket]);

net/batman-adv/multicast.c

2051

spin_unlock_bh(&hash->list_locks[bucket]);

net/batman-adv/multicast.c

2070

struct batadv_priv *bat_priv, long *bucket, long *idx)

net/batman-adv/multicast.c

2073

long bucket_tmp = *bucket;

net/batman-adv/multicast.c

2085

*bucket = bucket_tmp;

net/batman-adv/multicast.c

2143

long *bucket = &cb->args[0];

net/batman-adv/multicast.c

2152

ret = __batadv_mcast_flags_dump(msg, portid, cb, bat_priv, bucket, idx);

net/batman-adv/translation-table.c

1149

struct batadv_hashtable *hash, unsigned int bucket,

net/batman-adv/translation-table.c

1155

spin_lock_bh(&hash->list_locks[bucket]);

net/batman-adv/translation-table.c

1158

hlist_for_each_entry(common, &hash->table[bucket], hash_entry) {

net/batman-adv/translation-table.c

1164

spin_unlock_bh(&hash->list_locks[bucket]);

net/batman-adv/translation-table.c

1169

spin_unlock_bh(&hash->list_locks[bucket]);

net/batman-adv/translation-table.c

1189

int bucket = cb->args[0];

net/batman-adv/translation-table.c

1207

while (bucket < hash->size) {

net/batman-adv/translation-table.c

1209

hash, bucket, &idx))

net/batman-adv/translation-table.c

1212

bucket++;

net/batman-adv/translation-table.c

1221

cb->args[0] = bucket;

net/batman-adv/translation-table.c

1957

int bucket = cb->args[0];

net/batman-adv/translation-table.c

1976

while (bucket < hash->size) {

net/batman-adv/translation-table.c

1977

head = &hash->table[bucket];

net/batman-adv/translation-table.c

1984

bucket++;

net/batman-adv/translation-table.c

1993

cb->args[0] = bucket;

net/ceph/crush/mapper.c

100

for (i = 1; i < bucket->size; i++)

net/ceph/crush/mapper.c

112

if (p < bucket->size - 1) {

net/ceph/crush/mapper.c

113

i = crush_hash32_3(bucket->hash, x, bucket->id, p) %

net/ceph/crush/mapper.c

114

(bucket->size - p);

net/ceph/crush/mapper.c

124

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

net/ceph/crush/mapper.c

129

dprintk(" perm_choose %d sz=%d x=%d r=%d (%d) s=%d\n", bucket->id,

net/ceph/crush/mapper.c

130

bucket->size, x, r, pr, s);

net/ceph/crush/mapper.c

131

return bucket->items[s];

net/ceph/crush/mapper.c

135

static int bucket_uniform_choose(const struct crush_bucket_uniform *bucket,

net/ceph/crush/mapper.c

138

return bucket_perm_choose(&bucket->h, work, x, r);

net/ceph/crush/mapper.c

142

static int bucket_list_choose(const struct crush_bucket_list *bucket,

net/ceph/crush/mapper.c

147

for (i = bucket->h.size-1; i >= 0; i--) {

net/ceph/crush/mapper.c

148

__u64 w = crush_hash32_4(bucket->h.hash, x, bucket->h.items[i],

net/ceph/crush/mapper.c

149

r, bucket->h.id);

net/ceph/crush/mapper.c

153

i, x, r, bucket->h.items[i], bucket->item_weights[i],

net/ceph/crush/mapper.c

154

bucket->sum_weights[i], w);

net/ceph/crush/mapper.c

155

w *= bucket->sum_weights[i];

net/ceph/crush/mapper.c

158

if (w < bucket->item_weights[i]) {

net/ceph/crush/mapper.c

159

return bucket->h.items[i];

net/ceph/crush/mapper.c

163

dprintk("bad list sums for bucket %d\n", bucket->h.id);

net/ceph/crush/mapper.c

164

return bucket->h.items[0];

net/ceph/crush/mapper.c

196

static int bucket_tree_choose(const struct crush_bucket_tree *bucket,

net/ceph/crush/mapper.c

204

n = bucket->num_nodes >> 1;

net/ceph/crush/mapper.c

209

w = bucket->node_weights[n];

net/ceph/crush/mapper.c

210

t = (__u64)crush_hash32_4(bucket->h.hash, x, n, r,

net/ceph/crush/mapper.c

211

bucket->h.id) * (__u64)w;

net/ceph/crush/mapper.c

216

if (t < bucket->node_weights[l])

net/ceph/crush/mapper.c

222

return bucket->h.items[n >> 1];

net/ceph/crush/mapper.c

228

static int bucket_straw_choose(const struct crush_bucket_straw *bucket,

net/ceph/crush/mapper.c

236

for (i = 0; i < bucket->h.size; i++) {

net/ceph/crush/mapper.c

237

draw = crush_hash32_3(bucket->h.hash, x, bucket->h.items[i], r);

net/ceph/crush/mapper.c

239

draw *= bucket->straws[i];

net/ceph/crush/mapper.c

245

return bucket->h.items[high];

net/ceph/crush/mapper.c

305

static __u32 *get_choose_arg_weights(const struct crush_bucket_straw2 *bucket,

net/ceph/crush/mapper.c

310

return bucket->item_weights;

net/ceph/crush/mapper.c

317

static __s32 *get_choose_arg_ids(const struct crush_bucket_straw2 *bucket,

net/ceph/crush/mapper.c

321

return bucket->h.items;

net/ceph/crush/mapper.c

326

static int bucket_straw2_choose(const struct crush_bucket_straw2 *bucket,

net/ceph/crush/mapper.c

334

__u32 *weights = get_choose_arg_weights(bucket, arg, position);

net/ceph/crush/mapper.c

335

__s32 *ids = get_choose_arg_ids(bucket, arg);

net/ceph/crush/mapper.c

337

for (i = 0; i < bucket->h.size; i++) {

net/ceph/crush/mapper.c

340

u = crush_hash32_3(bucket->h.hash, x, ids[i], r);

net/ceph/crush/mapper.c

372

return bucket->h.items[high];

net/ceph/crush/mapper.c

455

const struct crush_bucket *bucket,

net/ceph/crush/mapper.c

474

const struct crush_bucket *in = bucket;

net/ceph/crush/mapper.c

484

bucket->id, x, outpos, numrep,

net/ceph/crush/mapper.c

494

in = bucket; /* initial bucket */

net/ceph/crush/mapper.c

648

const struct crush_bucket *bucket,

net/ceph/crush/mapper.c

659

const struct crush_bucket *in = bucket;

net/ceph/crush/mapper.c

670

bucket->id, x, outpos, numrep);

net/ceph/crush/mapper.c

698

in = bucket; /* initial bucket */

net/ceph/crush/mapper.c

74

static int bucket_perm_choose(const struct crush_bucket *bucket,

net/ceph/crush/mapper.c

78

unsigned int pr = r % bucket->size;

net/ceph/crush/mapper.c

83

dprintk("bucket %d new x=%d\n", bucket->id, x);

net/ceph/crush/mapper.c

88

s = crush_hash32_3(bucket->hash, x, bucket->id, 0) %

net/ceph/crush/mapper.c

89

bucket->size;

net/ceph/crush/mapper.c

95

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

net/core/gro.c

479

u32 bucket = skb_get_hash_raw(skb) & (GRO_HASH_BUCKETS - 1);

net/core/gro.c

481

struct gro_list *gro_list = &gro->hash[bucket];

net/core/gro.c

570

if (!test_bit(bucket, &gro->bitmask))

net/core/gro.c

571

__set_bit(bucket, &gro->bitmask);

net/core/gro.c

572

} else if (test_bit(bucket, &gro->bitmask)) {

net/core/gro.c

573

__clear_bit(bucket, &gro->bitmask);

net/core/neighbour.c

3281

while (++state->bucket < (1 << nht->hash_shift)) {

net/core/neighbour.c

3282

neigh_for_each_in_bucket(n, &nht->hash_heads[state->bucket]) {

net/core/neighbour.c

3343

int bucket;

net/core/neighbour.c

3346

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

net/core/neighbour.c

3347

pn = rcu_dereference(tbl->phash_buckets[bucket]);

net/core/neighbour.c

3354

state->bucket = bucket;

net/core/neighbour.c

3372

if (++state->bucket > PNEIGH_HASHMASK)

net/core/neighbour.c

3375

pn = rcu_dereference(tbl->phash_buckets[state->bucket]);

net/core/neighbour.c

3424

state->bucket = -1;

net/core/sock_map.c

1020

bucket = sock_hash_select_bucket(htab, hash);

net/core/sock_map.c

1022

spin_lock_bh(&bucket->lock);

net/core/sock_map.c

1023

elem = sock_hash_lookup_elem_raw(&bucket->head, hash, key, key_size);

net/core/sock_map.c

1042

hlist_add_head_rcu(&elem_new->node, &bucket->head);

net/core/sock_map.c

1048

spin_unlock_bh(&bucket->lock);

net/core/sock_map.c

1051

spin_unlock_bh(&bucket->lock);

net/core/sock_map.c

1149

struct bpf_shtab_bucket *bucket;

net/core/sock_map.c

1161

bucket = sock_hash_select_bucket(htab, i);

net/core/sock_map.c

1169

spin_lock_bh(&bucket->lock);

net/core/sock_map.c

1170

hlist_for_each_entry(elem, &bucket->head, node)

net/core/sock_map.c

1172

hlist_move_list(&bucket->head, &unlink_list);

net/core/sock_map.c

1173

spin_unlock_bh(&bucket->lock);

net/core/sock_map.c

1322

struct bpf_shtab_bucket *bucket;

net/core/sock_map.c

1338

bucket = &htab->buckets[info->bucket_id];

net/core/sock_map.c

1339

node = rcu_dereference(hlist_first_rcu(&bucket->head));

net/core/sock_map.c

899

struct bpf_shtab_bucket *bucket;

net/core/sock_map.c

905

bucket = sock_hash_select_bucket(htab, hash);

net/core/sock_map.c

906

elem = sock_hash_lookup_elem_raw(&bucket->head, hash, key, key_size);

net/core/sock_map.c

923

struct bpf_shtab_bucket *bucket;

net/core/sock_map.c

926

bucket = sock_hash_select_bucket(htab, elem->hash);

net/core/sock_map.c

932

spin_lock_bh(&bucket->lock);

net/core/sock_map.c

933

elem_probe = sock_hash_lookup_elem_raw(&bucket->head, elem->hash,

net/core/sock_map.c

940

spin_unlock_bh(&bucket->lock);

net/core/sock_map.c

947

struct bpf_shtab_bucket *bucket;

net/core/sock_map.c

952

bucket = sock_hash_select_bucket(htab, hash);

net/core/sock_map.c

954

spin_lock_bh(&bucket->lock);

net/core/sock_map.c

955

elem = sock_hash_lookup_elem_raw(&bucket->head, hash, key, key_size);

net/core/sock_map.c

962

spin_unlock_bh(&bucket->lock);

net/core/sock_map.c

999

struct bpf_shtab_bucket *bucket;

net/ipv4/fib_semantics.c

1879

struct fnhe_hash_bucket *bucket;

net/ipv4/fib_semantics.c

1882

bucket = rcu_dereference_protected(nhc->nhc_exceptions, 1);

net/ipv4/fib_semantics.c

1883

if (!bucket)

net/ipv4/fib_semantics.c

1889

for (fnhe = rcu_dereference_protected(bucket[i].chain, 1);

net/ipv4/nexthop.c

1108

static unsigned long nh_res_bucket_used_time(const struct nh_res_bucket *bucket)

net/ipv4/nexthop.c

1110

return (unsigned long)atomic_long_read(&bucket->used_time);

net/ipv4/nexthop.c

1115

const struct nh_res_bucket *bucket,

net/ipv4/nexthop.c

1118

unsigned long time = nh_res_bucket_used_time(bucket);

net/ipv4/nexthop.c

1121

if (time == bucket->migrated_time)

net/ipv4/nexthop.c

1134

struct nh_res_bucket *bucket)

net/ipv4/nexthop.c

1138

atomic_long_set(&bucket->used_time, (long)now);

net/ipv4/nexthop.c

1139

bucket->migrated_time = now;

net/ipv4/nexthop.c

1142

static void nh_res_bucket_set_busy(struct nh_res_bucket *bucket)

net/ipv4/nexthop.c

1144

atomic_long_set(&bucket->used_time, (long)jiffies);

net/ipv4/nexthop.c

1147

static clock_t nh_res_bucket_idle_time(const struct nh_res_bucket *bucket)

net/ipv4/nexthop.c

1149

unsigned long used_time = nh_res_bucket_used_time(bucket);

net/ipv4/nexthop.c

1155

struct nh_res_bucket *bucket, u16 bucket_index,

net/ipv4/nexthop.c

1160

struct nh_grp_entry *nhge = nh_res_dereference(bucket->nh_entry);

net/ipv4/nexthop.c

1171

nhm->nh_flags = bucket->nh_flags;

net/ipv4/nexthop.c

1186

nh_res_bucket_idle_time(bucket),

net/ipv4/nexthop.c

1204

struct nh_res_bucket *bucket = &res_table->nh_buckets[bucket_index];

net/ipv4/nexthop.c

1205

struct nh_grp_entry *nhge = nh_res_dereference(bucket->nh_entry);

net/ipv4/nexthop.c

1214

err = nh_fill_res_bucket(skb, nh, bucket, bucket_index,

net/ipv4/nexthop.c

1480

struct nh_res_bucket *bucket;

net/ipv4/nexthop.c

1486

bucket = &res_table->nh_buckets[bucket_index];

net/ipv4/nexthop.c

1487

nh_res_bucket_set_busy(bucket);

net/ipv4/nexthop.c

1488

nhge = rcu_dereference(bucket->nh_entry);

net/ipv4/nexthop.c

1707

static void nh_res_bucket_unset_nh(struct nh_res_bucket *bucket)

net/ipv4/nexthop.c

1711

if (bucket->occupied) {

net/ipv4/nexthop.c

1712

nhge = nh_res_dereference(bucket->nh_entry);

net/ipv4/nexthop.c

1714

bucket->occupied = false;

net/ipv4/nexthop.c

1718

static void nh_res_bucket_set_nh(struct nh_res_bucket *bucket,

net/ipv4/nexthop.c

1721

nh_res_bucket_unset_nh(bucket);

net/ipv4/nexthop.c

1723

bucket->occupied = true;

net/ipv4/nexthop.c

1724

rcu_assign_pointer(bucket->nh_entry, nhge);

net/ipv4/nexthop.c

1729

struct nh_res_bucket *bucket,

net/ipv4/nexthop.c

1736

if (!bucket->occupied) {

net/ipv4/nexthop.c

1744

nhge = nh_res_dereference(bucket->nh_entry);

net/ipv4/nexthop.c

1757

idle_point = nh_res_bucket_idle_point(res_table, bucket, now);

net/ipv4/nexthop.c

1790

struct nh_res_bucket *bucket = &res_table->nh_buckets[bucket_index];

net/ipv4/nexthop.c

180

struct nh_res_bucket *bucket = &res_table->nh_buckets[i];

net/ipv4/nexthop.c

1809

old_nhge = nh_res_dereference(bucket->nh_entry);

net/ipv4/nexthop.c

1824

bucket->nh_flags &= ~(RTNH_F_OFFLOAD | RTNH_F_TRAP);

net/ipv4/nexthop.c

1828

nh_res_bucket_set_nh(bucket, new_nhge);

net/ipv4/nexthop.c

1829

nh_res_bucket_set_idle(res_table, bucket);

net/ipv4/nexthop.c

184

nhge = rtnl_dereference(bucket->nh_entry);

net/ipv4/nexthop.c

1861

struct nh_res_bucket *bucket = &res_table->nh_buckets[i];

net/ipv4/nexthop.c

1864

if (nh_res_bucket_should_migrate(res_table, bucket,

net/ipv4/nexthop.c

1876

nh_res_bucket_set_busy(bucket);

net/ipv4/nexthop.c

1878

bucket,

net/ipv4/nexthop.c

1959

struct nh_res_bucket *bucket = &res_table->nh_buckets[i];

net/ipv4/nexthop.c

1960

u32 id = rtnl_dereference(bucket->nh_entry)->nh->id;

net/ipv4/nexthop.c

1968

nh_res_bucket_set_nh(bucket, nhge);

net/ipv4/nexthop.c

1975

nh_res_bucket_unset_nh(bucket);

net/ipv4/nexthop.c

2381

struct nh_res_bucket *bucket = &res_table->nh_buckets[i];

net/ipv4/nexthop.c

2384

nhge = rtnl_dereference(bucket->nh_entry);

net/ipv4/nexthop.c

2399

struct nh_res_bucket *bucket = &res_table->nh_buckets[i];

net/ipv4/nexthop.c

2402

nhge = rtnl_dereference(bucket->nh_entry);

net/ipv4/nexthop.c

3772

struct nh_res_bucket *bucket;

net/ipv4/nexthop.c

3775

bucket = &res_table->nh_buckets[bucket_index];

net/ipv4/nexthop.c

3776

nhge = rtnl_dereference(bucket->nh_entry);

net/ipv4/nexthop.c

3785

err = nh_fill_res_bucket(skb, nh, bucket, bucket_index,

net/ipv4/nexthop.c

4077

struct nh_res_bucket *bucket;

net/ipv4/nexthop.c

4095

bucket = &res_table->nh_buckets[bucket_index];

net/ipv4/nexthop.c

4096

bucket->nh_flags &= ~(RTNH_F_OFFLOAD | RTNH_F_TRAP);

net/ipv4/nexthop.c

4098

bucket->nh_flags |= RTNH_F_OFFLOAD;

net/ipv4/nexthop.c

4100

bucket->nh_flags |= RTNH_F_TRAP;

net/ipv4/ping.c

1008

for (state->bucket = start; state->bucket < PING_HTABLE_SIZE;

net/ipv4/ping.c

1009

++state->bucket) {

net/ipv4/ping.c

1012

hslot = &ping_table.hash[state->bucket];

net/ipv4/ping.c

1038

return ping_get_first(seq, state->bucket + 1);

net/ipv4/ping.c

1056

state->bucket = 0;

net/ipv4/ping.c

1089

int bucket)

net/ipv4/ping.c

1099

bucket, src, srcp, dest, destp, sp->sk_state,

net/ipv4/ping.c

1119

ping_v4_format_sock(v, seq, state->bucket);

net/ipv4/raw.c

1065

raw_sock_seq_show(seq, v, raw_seq_private(seq)->bucket);

net/ipv4/raw.c

968

static struct sock *raw_get_first(struct seq_file *seq, int bucket)

net/ipv4/raw.c

975

for (state->bucket = bucket; state->bucket < RAW_HTABLE_SIZE;

net/ipv4/raw.c

976

++state->bucket) {

net/ipv4/raw.c

977

hlist = &h->ht[state->bucket];

net/ipv4/raw.c

995

return raw_get_first(seq, state->bucket + 1);

net/ipv4/route.c

3084

struct fnhe_hash_bucket *bucket, int genid,

net/ipv4/route.c

3092

for (fnhe = rcu_dereference(bucket[i].chain); fnhe;

net/ipv4/route.c

3136

struct fnhe_hash_bucket *bucket;

net/ipv4/route.c

3143

bucket = rcu_dereference(nhc->nhc_exceptions);

net/ipv4/route.c

3145

if (bucket)

net/ipv4/route.c

3146

err = fnhe_dump_bucket(net, skb, cb, table_id, bucket,

net/ipv4/route.c

472

u32 bucket, old, now = (u32)jiffies;

net/ipv4/route.c

477

bucket = hash & ip_idents_mask;

net/ipv4/route.c

478

p_tstamp = ip_tstamps + bucket;

net/ipv4/route.c

479

p_id = ip_idents + bucket;

net/ipv4/tcp_ipv4.c

2485

for (; st->bucket <= hinfo->lhash2_mask; st->bucket++) {

net/ipv4/tcp_ipv4.c

2490

ilb2 = &hinfo->lhash2[st->bucket];

net/ipv4/tcp_ipv4.c

2528

ilb2 = &hinfo->lhash2[st->bucket];

net/ipv4/tcp_ipv4.c

2530

++st->bucket;

net/ipv4/tcp_ipv4.c

2539

st->bucket = 0;

net/ipv4/tcp_ipv4.c

2553

return hlist_nulls_empty(&hinfo->ehash[st->bucket].chain);

net/ipv4/tcp_ipv4.c

2566

for (; st->bucket <= hinfo->ehash_mask; ++st->bucket) {

net/ipv4/tcp_ipv4.c

2569

spinlock_t *lock = inet_ehash_lockp(hinfo, st->bucket);

net/ipv4/tcp_ipv4.c

2578

sk_nulls_for_each(sk, node, &hinfo->ehash[st->bucket].chain) {

net/ipv4/tcp_ipv4.c

2605

spin_unlock_bh(inet_ehash_lockp(hinfo, st->bucket));

net/ipv4/tcp_ipv4.c

2606

++st->bucket;

net/ipv4/tcp_ipv4.c

2615

st->bucket = 0;

net/ipv4/tcp_ipv4.c

2645

int bucket = st->bucket;

net/ipv4/tcp_ipv4.c

2652

if (st->bucket > hinfo->lhash2_mask)

net/ipv4/tcp_ipv4.c

2655

while (offset-- && rc && bucket == st->bucket)

net/ipv4/tcp_ipv4.c

2659

st->bucket = 0;

net/ipv4/tcp_ipv4.c

2663

if (st->bucket > hinfo->ehash_mask)

net/ipv4/tcp_ipv4.c

2666

while (offset-- && rc && bucket == st->bucket)

net/ipv4/tcp_ipv4.c

2688

st->bucket = 0;

net/ipv4/tcp_ipv4.c

2712

st->bucket = 0;

net/ipv4/tcp_ipv4.c

2735

spin_unlock(&hinfo->lhash2[st->bucket].lock);

net/ipv4/tcp_ipv4.c

2739

spin_unlock_bh(inet_ehash_lockp(hinfo, st->bucket));

net/ipv4/tcp_ipv4.c

2972

int resume_bucket = st->bucket;

net/ipv4/tcp_ipv4.c

2976

++st->bucket;

net/ipv4/tcp_ipv4.c

2982

if (sk && st->bucket == resume_bucket && end_cookie) {

net/ipv4/tcp_ipv4.c

2986

spin_unlock(&hinfo->lhash2[st->bucket].lock);

net/ipv4/tcp_ipv4.c

2987

++st->bucket;

net/ipv4/tcp_ipv4.c

3002

int resume_bucket = st->bucket;

net/ipv4/tcp_ipv4.c

3006

++st->bucket;

net/ipv4/tcp_ipv4.c

3012

if (sk && st->bucket == resume_bucket && end_cookie) {

net/ipv4/tcp_ipv4.c

3016

spin_unlock_bh(inet_ehash_lockp(hinfo, st->bucket));

net/ipv4/tcp_ipv4.c

3017

++st->bucket;

net/ipv4/tcp_ipv4.c

3036

st->bucket = 0;

net/ipv4/tcp_ipv4.c

3124

spin_unlock(&hinfo->lhash2[st->bucket].lock);

net/ipv4/tcp_ipv4.c

3126

spin_unlock_bh(inet_ehash_lockp(hinfo, st->bucket));

net/ipv4/udp.c

3171

for (state->bucket = start; state->bucket <= udptable->mask;

net/ipv4/udp.c

3172

++state->bucket) {

net/ipv4/udp.c

3173

struct udp_hslot *hslot = &udptable->hash[state->bucket];

net/ipv4/udp.c

3203

if (state->bucket <= udptable->mask)

net/ipv4/udp.c

3204

spin_unlock_bh(&udptable->hash[state->bucket].lock);

net/ipv4/udp.c

3206

return udp_get_first(seq, state->bucket + 1);

net/ipv4/udp.c

3224

state->bucket = MAX_UDP_PORTS;

net/ipv4/udp.c

3249

if (state->bucket <= udptable->mask)

net/ipv4/udp.c

3250

spin_unlock_bh(&udptable->hash[state->bucket].lock);

net/ipv4/udp.c

3255

int bucket)

net/ipv4/udp.c

3265

bucket, src, srcp, dest, destp, sp->sk_state,

net/ipv4/udp.c

3285

udp4_format_sock(v, seq, state->bucket);

net/ipv4/udp.c

3296

int bucket __aligned(8);

net/ipv4/udp.c

3344

resume_bucket = state->bucket;

net/ipv4/udp.c

3348

state->bucket++;

net/ipv4/udp.c

3366

for (; state->bucket <= udptable->mask; state->bucket++) {

net/ipv4/udp.c

3367

struct udp_hslot *hslot2 = &udptable->hash2[state->bucket].hslot;

net/ipv4/udp.c

3381

if (state->bucket == resume_bucket)

net/ipv4/udp.c

3481

struct udp_sock *udp_sk, uid_t uid, int bucket)

net/ipv4/udp.c

3489

ctx.bucket = bucket;

net/ipv4/udp.c

3515

ret = udp_prog_seq_show(prog, &meta, v, uid, state->bucket);

net/ipv4/udp.c

3799

struct udp_sock *udp_sk, uid_t uid, int bucket)

net/ipv4/udp.c

3837

iter->state.bucket = -1;

net/ipv6/addrconf.c

4439

int bucket;

net/ipv6/addrconf.c

4452

state->bucket = 0;

net/ipv6/addrconf.c

4456

for (; state->bucket < IN6_ADDR_HSIZE; ++state->bucket) {

net/ipv6/addrconf.c

4457

hlist_for_each_entry_rcu(ifa, &net->ipv6.inet6_addr_lst[state->bucket],

net/ipv6/addrconf.c

4486

while (++state->bucket < IN6_ADDR_HSIZE) {

net/ipv6/addrconf.c

4488

&net->ipv6.inet6_addr_lst[state->bucket], addr_lst) {

net/ipv6/datagram.c

1097

__u16 srcp, __u16 destp, int rqueue, int bucket)

net/ipv6/datagram.c

1106

bucket,

net/ipv6/ip6_flowlabel.c

762

int bucket;

net/ipv6/ip6_flowlabel.c

773

for (state->bucket = 0; state->bucket <= FL_HASH_MASK; ++state->bucket) {

net/ipv6/ip6_flowlabel.c

774

for_each_fl_rcu(state->bucket, fl) {

net/ipv6/ip6_flowlabel.c

795

if (++state->bucket <= FL_HASH_MASK) {

net/ipv6/ip6_flowlabel.c

796

for_each_fl_rcu(state->bucket, fl) {

net/ipv6/ping.c

237

int bucket = ((struct ping_iter_state *) seq->private)->bucket;

net/ipv6/ping.c

241

ip6_dgram_sock_seq_show(seq, v, srcp, destp, bucket);

net/ipv6/raw.c

1233

raw_seq_private(seq)->bucket);

net/ipv6/route.c

1508

static void rt6_remove_exception(struct rt6_exception_bucket *bucket,

net/ipv6/route.c

1513

if (!bucket || !rt6_ex)

net/ipv6/route.c

1527

WARN_ON_ONCE(!bucket->depth);

net/ipv6/route.c

1528

bucket->depth--;

net/ipv6/route.c

1534

static void rt6_exception_remove_oldest(struct rt6_exception_bucket *bucket)

net/ipv6/route.c

1538

if (!bucket)

net/ipv6/route.c

1541

hlist_for_each_entry(rt6_ex, &bucket->chain, hlist) {

net/ipv6/route.c

1545

rt6_remove_exception(bucket, oldest);

net/ipv6/route.c

1577

__rt6_find_exception_spinlock(struct rt6_exception_bucket **bucket,

net/ipv6/route.c

1584

if (!(*bucket) || !daddr)

net/ipv6/route.c

1588

*bucket += hval;

net/ipv6/route.c

1590

hlist_for_each_entry(rt6_ex, &(*bucket)->chain, hlist) {

net/ipv6/route.c

1610

__rt6_find_exception_rcu(struct rt6_exception_bucket **bucket,

net/ipv6/route.c

1619

if (!(*bucket) || !daddr)

net/ipv6/route.c

1623

*bucket += hval;

net/ipv6/route.c

1625

hlist_for_each_entry_rcu(rt6_ex, &(*bucket)->chain, hlist) {

net/ipv6/route.c

1676

struct rt6_exception_bucket *bucket;

net/ipv6/route.c

1679

bucket = rcu_dereference_protected(nh->rt6i_exception_bucket,

net/ipv6/route.c

1682

bucket = rcu_dereference(nh->rt6i_exception_bucket);

net/ipv6/route.c

1685

if (bucket) {

net/ipv6/route.c

1686

unsigned long p = (unsigned long)bucket;

net/ipv6/route.c

1689

bucket = (struct rt6_exception_bucket *)p;

net/ipv6/route.c

1692

return bucket;

net/ipv6/route.c

1695

static bool fib6_nh_excptn_bucket_flushed(struct rt6_exception_bucket *bucket)

net/ipv6/route.c

1697

unsigned long p = (unsigned long)bucket;

net/ipv6/route.c

1706

struct rt6_exception_bucket *bucket;

net/ipv6/route.c

1709

bucket = rcu_dereference_protected(nh->rt6i_exception_bucket,

net/ipv6/route.c

1712

p = (unsigned long)bucket;

net/ipv6/route.c

1714

bucket = (struct rt6_exception_bucket *)p;

net/ipv6/route.c

1715

rcu_assign_pointer(nh->rt6i_exception_bucket, bucket);

net/ipv6/route.c

1722

struct rt6_exception_bucket *bucket;

net/ipv6/route.c

1732

bucket = rcu_dereference_protected(nh->rt6i_exception_bucket,

net/ipv6/route.c

1734

if (!bucket) {

net/ipv6/route.c

1735

bucket = kzalloc_objs(*bucket, FIB6_EXCEPTION_BUCKET_SIZE,

net/ipv6/route.c

1737

if (!bucket) {

net/ipv6/route.c

1741

rcu_assign_pointer(nh->rt6i_exception_bucket, bucket);

net/ipv6/route.c

1742

} else if (fib6_nh_excptn_bucket_flushed(bucket)) {

net/ipv6/route.c

1766

rt6_ex = __rt6_find_exception_spinlock(&bucket, &nrt->rt6i_dst.addr,

net/ipv6/route.c

1769

rt6_remove_exception(bucket, rt6_ex);

net/ipv6/route.c

1778

hlist_add_head_rcu(&rt6_ex->hlist, &bucket->chain);

net/ipv6/route.c

1779

bucket->depth++;

net/ipv6/route.c

1784

while (bucket->depth > max_depth)

net/ipv6/route.c

1785

rt6_exception_remove_oldest(bucket);

net/ipv6/route.c

1804

struct rt6_exception_bucket *bucket;

net/ipv6/route.c

1811

bucket = fib6_nh_get_excptn_bucket(nh, &rt6_exception_lock);

net/ipv6/route.c

1812

if (!bucket)

net/ipv6/route.c

1820

hlist_for_each_entry_safe(rt6_ex, tmp, &bucket->chain, hlist) {

net/ipv6/route.c

1823

rt6_remove_exception(bucket, rt6_ex);

net/ipv6/route.c

1825

WARN_ON_ONCE(!from && bucket->depth);

net/ipv6/route.c

1826

bucket++;

net/ipv6/route.c

1860

struct rt6_exception_bucket *bucket;

net/ipv6/route.c

1880

bucket = fib6_nh_get_excptn_bucket(res->nh, NULL);

net/ipv6/route.c

1881

rt6_ex = __rt6_find_exception_rcu(&bucket, daddr, src_key);

net/ipv6/route.c

1902

struct rt6_exception_bucket *bucket;

net/ipv6/route.c

1910

bucket = fib6_nh_get_excptn_bucket(nh, &rt6_exception_lock);

net/ipv6/route.c

1922

rt6_ex = __rt6_find_exception_spinlock(&bucket,

net/ipv6/route.c

1926

rt6_remove_exception(bucket, rt6_ex);

net/ipv6/route.c

1986

struct rt6_exception_bucket *bucket;

net/ipv6/route.c

1989

bucket = fib6_nh_get_excptn_bucket(nh, NULL);

net/ipv6/route.c

2000

rt6_ex = __rt6_find_exception_rcu(&bucket, &rt->rt6i_dst.addr, src_key);

net/ipv6/route.c

2085

struct rt6_exception_bucket *bucket;

net/ipv6/route.c

2089

bucket = fib6_nh_get_excptn_bucket(nh, &rt6_exception_lock);

net/ipv6/route.c

2090

if (!bucket)

net/ipv6/route.c

2094

hlist_for_each_entry(rt6_ex, &bucket->chain, hlist) {

net/ipv6/route.c

2105

bucket++;

net/ipv6/route.c

2114

struct rt6_exception_bucket *bucket;

net/ipv6/route.c

2123

bucket = fib6_nh_get_excptn_bucket(nh, &rt6_exception_lock);

net/ipv6/route.c

2124

if (bucket) {

net/ipv6/route.c

2127

&bucket->chain, hlist) {

net/ipv6/route.c

2134

rt6_remove_exception(bucket, rt6_ex);

net/ipv6/route.c

2137

bucket++;

net/ipv6/route.c

2144

static void rt6_age_examine_exception(struct rt6_exception_bucket *bucket,

net/ipv6/route.c

2161

rt6_remove_exception(bucket, rt6_ex);

net/ipv6/route.c

2166

rt6_remove_exception(bucket, rt6_ex);

net/ipv6/route.c

2178

rt6_remove_exception(bucket, rt6_ex);

net/ipv6/route.c

2190

struct rt6_exception_bucket *bucket;

net/ipv6/route.c

2200

bucket = fib6_nh_get_excptn_bucket(nh, &rt6_exception_lock);

net/ipv6/route.c

2201

if (bucket) {

net/ipv6/route.c

2204

&bucket->chain, hlist) {

net/ipv6/route.c

2205

rt6_age_examine_exception(bucket, rt6_ex,

net/ipv6/route.c

2208

bucket++;

net/ipv6/route.c

3724

struct rt6_exception_bucket *bucket;

net/ipv6/route.c

3729

bucket = fib6_nh_get_excptn_bucket(fib6_nh, NULL);

net/ipv6/route.c

3730

if (bucket) {

net/ipv6/route.c

3732

kfree(bucket);

net/ipv6/route.c

6023

struct rt6_exception_bucket *bucket;

net/ipv6/route.c

6027

bucket = fib6_nh_get_excptn_bucket(nh, NULL);

net/ipv6/route.c

6028

if (!bucket)

net/ipv6/route.c

6032

hlist_for_each_entry(rt6_ex, &bucket->chain, hlist) {

net/ipv6/route.c

6064

bucket++;

net/ipv6/udp.c

1842

int bucket = ((struct udp_iter_state *)seq->private)->bucket;

net/ipv6/udp.c

1847

udp_rqueue_get(v), bucket);

net/llc/llc_proc.c

61

static struct sock *laddr_hash_next(struct llc_sap *sap, int bucket)

net/llc/llc_proc.c

66

while (++bucket < LLC_SK_LADDR_HASH_ENTRIES)

net/llc/llc_proc.c

67

sk_nulls_for_each(sk, node, &sap->sk_laddr_hash[bucket])

net/mac80211/mesh.c

188

INIT_HLIST_HEAD(&sdata->u.mesh.rmc->bucket[i]);

net/mac80211/mesh.c

203

hlist_for_each_entry_safe(p, n, &rmc->bucket[i], list) {

net/mac80211/mesh.c

242

hlist_for_each_entry_safe(p, n, &rmc->bucket[idx], list) {

net/mac80211/mesh.c

260

hlist_add_head(&p->list, &rmc->bucket[idx]);

net/mac80211/mesh.h

217

struct hlist_head bucket[RMC_BUCKETS];

net/mptcp/token.c

111

struct token_bucket *bucket;

net/mptcp/token.c

122

bucket = token_bucket(token);

net/mptcp/token.c

123

spin_lock_bh(&bucket->lock);

net/mptcp/token.c

124

if (__token_bucket_busy(bucket, token)) {

net/mptcp/token.c

125

spin_unlock_bh(&bucket->lock);

net/mptcp/token.c

129

hlist_nulls_add_head_rcu(&subflow_req->token_node, &bucket->req_chain);

net/mptcp/token.c

130

bucket->chain_len++;

net/mptcp/token.c

131

spin_unlock_bh(&bucket->lock);

net/mptcp/token.c

157

struct token_bucket *bucket;

net/mptcp/token.c

163

bucket = token_bucket(subflow->token);

net/mptcp/token.c

164

spin_lock_bh(&bucket->lock);

net/mptcp/token.c

165

if (__token_bucket_busy(bucket, subflow->token)) {

net/mptcp/token.c

166

spin_unlock_bh(&bucket->lock);

net/mptcp/token.c

176

__sk_nulls_add_node_rcu((struct sock *)msk, &bucket->msk_chain);

net/mptcp/token.c

177

bucket->chain_len++;

net/mptcp/token.c

178

spin_unlock_bh(&bucket->lock);

net/mptcp/token.c

196

struct token_bucket *bucket;

net/mptcp/token.c

199

bucket = token_bucket(req->token);

net/mptcp/token.c

200

spin_lock_bh(&bucket->lock);

net/mptcp/token.c

203

pos = __token_lookup_req(bucket, req->token);

net/mptcp/token.c

206

__sk_nulls_add_node_rcu((struct sock *)msk, &bucket->msk_chain);

net/mptcp/token.c

207

spin_unlock_bh(&bucket->lock);

net/mptcp/token.c

213

struct token_bucket *bucket;

net/mptcp/token.c

218

bucket = token_bucket(token);

net/mptcp/token.c

221

sk_nulls_for_each_rcu(sk, pos, &bucket->msk_chain) {

net/mptcp/token.c

249

struct token_bucket *bucket;

net/mptcp/token.c

254

bucket = token_bucket(token);

net/mptcp/token.c

257

sk_nulls_for_each_rcu(sk, pos, &bucket->msk_chain) {

net/mptcp/token.c

307

struct token_bucket *bucket = &token_hash[slot];

net/mptcp/token.c

312

if (hlist_nulls_empty(&bucket->msk_chain))

net/mptcp/token.c

316

sk_nulls_for_each_rcu(sk, pos, &bucket->msk_chain) {

net/mptcp/token.c

356

struct token_bucket *bucket;

net/mptcp/token.c

361

bucket = token_bucket(subflow_req->token);

net/mptcp/token.c

362

spin_lock_bh(&bucket->lock);

net/mptcp/token.c

363

pos = __token_lookup_req(bucket, subflow_req->token);

net/mptcp/token.c

366

bucket->chain_len--;

net/mptcp/token.c

368

spin_unlock_bh(&bucket->lock);

net/mptcp/token.c

380

struct token_bucket *bucket;

net/mptcp/token.c

387

bucket = token_bucket(msk->token);

net/mptcp/token.c

388

spin_lock_bh(&bucket->lock);

net/mptcp/token.c

389

pos = __token_lookup_msk(bucket, msk->token);

net/mptcp/token.c

392

bucket->chain_len--;

net/mptcp/token.c

394

spin_unlock_bh(&bucket->lock);

net/netfilter/ipset/ip_set_hash_gen.h

90

struct hbucket __rcu *bucket[]; /* hashtable buckets */

net/netfilter/ipset/ip_set_hash_gen.h

93

#define hbucket(h, i) ((h)->bucket[i])

net/netfilter/ipvs/ip_vs_conn.c

1477

u32 bucket;

net/netfilter/ipvs/ip_vs_conn.c

1493

for (idx = iter->bucket; idx < t->size; idx++) {

net/netfilter/ipvs/ip_vs_conn.c

1505

iter->bucket = idx;

net/netfilter/ipvs/ip_vs_conn.c

1521

iter->bucket = idx;

net/netfilter/ipvs/ip_vs_conn.c

1538

iter->bucket = 0;

net/netfilter/ipvs/ip_vs_conn.c

1572

iter->bucket++;

net/netfilter/ipvs/ip_vs_conn.c

814

u32 bucket;

net/netfilter/ipvs/ip_vs_conn.c

849

ip_vs_rht_for_each_bucket(t, bucket, head) {

net/netfilter/ipvs/ip_vs_conn.c

870

spin_lock_bh(&t->lock[bucket & t->lock_mask].l);

net/netfilter/ipvs/ip_vs_conn.c

872

write_seqcount_begin(&t->seqc[bucket & t->seqc_mask]);

net/netfilter/ipvs/ip_vs_conn.c

898

write_seqcount_end(&t->seqc[bucket & t->seqc_mask]);

net/netfilter/ipvs/ip_vs_conn.c

900

spin_unlock_bh(&t->lock[bucket & t->lock_mask].l);

net/netfilter/ipvs/ip_vs_ctl.c

2873

u32 bucket;

net/netfilter/ipvs/ip_vs_ctl.c

2912

iter->bucket = idx;

net/netfilter/ipvs/ip_vs_ctl.c

2957

while (++iter->bucket < t->size) {

net/netfilter/ipvs/ip_vs_ctl.c

2958

hlist_bl_for_each_entry_rcu(svc, e, &t->buckets[iter->bucket],

net/netfilter/ipvs/ip_vs_ctl.c

3159

u32 bucket;

net/netfilter/ipvs/ip_vs_ctl.c

3184

for (bucket = 0; bucket < t->size; bucket++) {

net/netfilter/ipvs/ip_vs_ctl.c

3189

ip_vs_rht_walk_bucket_rcu(t, bucket, head) {

net/netfilter/ipvs/ip_vs_ctl.c

3248

for (bucket = 0; bucket < t->size; bucket++) {

net/netfilter/ipvs/ip_vs_ctl.c

3253

ip_vs_rht_walk_bucket_rcu(t, bucket, head) {

net/netfilter/ipvs/ip_vs_ctl.c

684

u32 bucket;

net/netfilter/ipvs/ip_vs_ctl.c

723

ip_vs_rht_for_each_bucket(t, bucket, head) {

net/netfilter/ipvs/ip_vs_ctl.c

743

sc = &t->seqc[bucket & t->seqc_mask];

net/netfilter/ipvs/ip_vs_lblc.c

102

struct hlist_head bucket[IP_VS_LBLC_TAB_SIZE]; /* hash bucket */

net/netfilter/ipvs/ip_vs_lblc.c

170

hlist_add_head_rcu(&en->list, &tbl->bucket[hash]);

net/netfilter/ipvs/ip_vs_lblc.c

183

hlist_for_each_entry_rcu(en, &tbl->bucket[hash], list)

net/netfilter/ipvs/ip_vs_lblc.c

237

hlist_for_each_entry_safe(en, next, &tbl->bucket[i], list) {

net/netfilter/ipvs/ip_vs_lblc.c

266

hlist_for_each_entry_safe(en, next, &tbl->bucket[j], list) {

net/netfilter/ipvs/ip_vs_lblc.c

323

hlist_for_each_entry_safe(en, next, &tbl->bucket[j], list) {

net/netfilter/ipvs/ip_vs_lblc.c

362

INIT_HLIST_HEAD(&tbl->bucket[i]);

net/netfilter/ipvs/ip_vs_lblcr.c

272

struct hlist_head bucket[IP_VS_LBLCR_TAB_SIZE]; /* hash bucket */

net/netfilter/ipvs/ip_vs_lblcr.c

333

hlist_add_head_rcu(&en->list, &tbl->bucket[hash]);

net/netfilter/ipvs/ip_vs_lblcr.c

346

hlist_for_each_entry_rcu(en, &tbl->bucket[hash], list)

net/netfilter/ipvs/ip_vs_lblcr.c

403

hlist_for_each_entry_safe(en, next, &tbl->bucket[i], list) {

net/netfilter/ipvs/ip_vs_lblcr.c

431

hlist_for_each_entry_safe(en, next, &tbl->bucket[j], list) {

net/netfilter/ipvs/ip_vs_lblcr.c

487

hlist_for_each_entry_safe(en, next, &tbl->bucket[j], list) {

net/netfilter/ipvs/ip_vs_lblcr.c

525

INIT_HLIST_HEAD(&tbl->bucket[i]);

net/netfilter/nf_conntrack_core.c

1429

unsigned int i, bucket;

net/netfilter/nf_conntrack_core.c

1438

bucket = reciprocal_scale(hash, hsize);

net/netfilter/nf_conntrack_core.c

1440

bucket = (bucket + 1) % hsize;

net/netfilter/nf_conntrack_core.c

1442

drops = early_drop_list(net, &ct_hash[bucket]);

net/netfilter/nf_conntrack_core.c

2305

const struct nf_ct_iter_data *iter_data, unsigned int *bucket)

net/netfilter/nf_conntrack_core.c

2312

for (; *bucket < nf_conntrack_htable_size; (*bucket)++) {

net/netfilter/nf_conntrack_core.c

2313

struct hlist_nulls_head *hslot = &nf_conntrack_hash[*bucket];

net/netfilter/nf_conntrack_core.c

2318

lockp = &nf_conntrack_locks[*bucket % CONNTRACK_LOCKS];

net/netfilter/nf_conntrack_core.c

2360

unsigned int bucket = 0;

net/netfilter/nf_conntrack_core.c

2366

while ((ct = get_next_corpse(iter, iter_data, &bucket)) != NULL) {

net/netfilter/nf_conntrack_core.c

2544

int i, bucket;

net/netfilter/nf_conntrack_core.c

2585

bucket = __hash_conntrack(nf_ct_net(ct),

net/netfilter/nf_conntrack_core.c

2587

hlist_nulls_add_head_rcu(&h->hnnode, &hash[bucket]);

net/netfilter/nf_conntrack_core.c

759

unsigned int bucket, hsize;

net/netfilter/nf_conntrack_core.c

763

bucket = reciprocal_scale(hash, hsize);

net/netfilter/nf_conntrack_core.c

765

hlist_nulls_for_each_entry_rcu(h, n, &ct_hash[bucket], hnnode) {

net/netfilter/nf_conntrack_core.c

782

if (get_nulls_value(n) != bucket) {

net/netfilter/nf_conntrack_expect.c

602

unsigned int bucket;

net/netfilter/nf_conntrack_expect.c

610

for (st->bucket = 0; st->bucket < nf_ct_expect_hsize; st->bucket++) {

net/netfilter/nf_conntrack_expect.c

611

n = rcu_dereference(hlist_first_rcu(&nf_ct_expect_hash[st->bucket]));

net/netfilter/nf_conntrack_expect.c

625

if (++st->bucket >= nf_ct_expect_hsize)

net/netfilter/nf_conntrack_expect.c

627

head = rcu_dereference(hlist_first_rcu(&nf_ct_expect_hash[st->bucket]));

net/netfilter/nf_conntrack_standalone.c

108

for (i = st->bucket; i < st->htable_size; i++) {

net/netfilter/nf_conntrack_standalone.c

133

st->bucket = i;

net/netfilter/nf_conntrack_standalone.c

144

st->bucket = i;

net/netfilter/nf_conntrack_standalone.c

161

st->bucket = 0;

net/netfilter/nf_conntrack_standalone.c

97

unsigned int bucket;

net/netfilter/nfnetlink_log.c

1055

unsigned int bucket;

net/netfilter/nfnetlink_log.c

1066

for (st->bucket = 0; st->bucket < INSTANCE_BUCKETS; st->bucket++) {

net/netfilter/nfnetlink_log.c

1067

struct hlist_head *head = &log->instance_table[st->bucket];

net/netfilter/nfnetlink_log.c

1083

if (++st->bucket >= INSTANCE_BUCKETS)

net/netfilter/nfnetlink_log.c

1087

head = &log->instance_table[st->bucket];

net/netfilter/nfnetlink_queue.c

1961

unsigned int bucket;

net/netfilter/nfnetlink_queue.c

1975

for (st->bucket = 0; st->bucket < INSTANCE_BUCKETS; st->bucket++) {

net/netfilter/nfnetlink_queue.c

1976

if (!hlist_empty(&q->instance_table[st->bucket]))

net/netfilter/nfnetlink_queue.c

1977

return q->instance_table[st->bucket].first;

net/netfilter/nfnetlink_queue.c

1991

if (++st->bucket >= INSTANCE_BUCKETS)

net/netfilter/nfnetlink_queue.c

1995

h = q->instance_table[st->bucket].first;

net/netfilter/nft_set_pipapo.c

716

int group, bucket, err;

net/netfilter/nft_set_pipapo.c

748

for (bucket = 0; bucket < NFT_PIPAPO_BUCKETS(f->bb); bucket++) {

net/netfilter/xt_hashlimit.c

1060

unsigned int *bucket;

net/netfilter/xt_hashlimit.c

1066

bucket = kmalloc(sizeof(unsigned int), GFP_ATOMIC);

net/netfilter/xt_hashlimit.c

1067

if (!bucket)

net/netfilter/xt_hashlimit.c

1070

*bucket = *pos;

net/netfilter/xt_hashlimit.c

1071

return bucket;

net/netfilter/xt_hashlimit.c

1077

unsigned int *bucket = v;

net/netfilter/xt_hashlimit.c

1079

*pos = ++(*bucket);

net/netfilter/xt_hashlimit.c

1084

return bucket;

net/netfilter/xt_hashlimit.c

1091

unsigned int *bucket = v;

net/netfilter/xt_hashlimit.c

1093

if (!IS_ERR(bucket))

net/netfilter/xt_hashlimit.c

1094

kfree(bucket);

net/netfilter/xt_hashlimit.c

1177

unsigned int *bucket = (unsigned int *)v;

net/netfilter/xt_hashlimit.c

1180

if (!hlist_empty(&htable->hash[*bucket])) {

net/netfilter/xt_hashlimit.c

1181

hlist_for_each_entry(ent, &htable->hash[*bucket], node)

net/netfilter/xt_hashlimit.c

1191

unsigned int *bucket = v;

net/netfilter/xt_hashlimit.c

1194

if (!hlist_empty(&htable->hash[*bucket])) {

net/netfilter/xt_hashlimit.c

1195

hlist_for_each_entry(ent, &htable->hash[*bucket], node)

net/netfilter/xt_hashlimit.c

1205

unsigned int *bucket = v;

net/netfilter/xt_hashlimit.c

1208

if (!hlist_empty(&htable->hash[*bucket])) {

net/netfilter/xt_hashlimit.c

1209

hlist_for_each_entry(ent, &htable->hash[*bucket], node)

net/netfilter/xt_recent.c

476

unsigned int bucket;

net/netfilter/xt_recent.c

489

for (st->bucket = 0; st->bucket < ip_list_hash_size; st->bucket++)

net/netfilter/xt_recent.c

490

list_for_each_entry(e, &t->iphash[st->bucket], list)

net/netfilter/xt_recent.c

504

while (head == &t->iphash[st->bucket]) {

net/netfilter/xt_recent.c

505

if (++st->bucket >= ip_list_hash_size)

net/netfilter/xt_recent.c

507

head = t->iphash[st->bucket].next;

net/openvswitch/datapath.c

1512

u32 bucket, obj;

net/openvswitch/datapath.c

1514

bucket = cb->args[0];

net/openvswitch/datapath.c

1516

flow = ovs_flow_tbl_dump_next(ti, &bucket, &obj);

net/openvswitch/datapath.c

1526

cb->args[0] = bucket;

net/openvswitch/datapath.c

2551

int bucket = cb->args[0], skip = cb->args[1];

net/openvswitch/datapath.c

2560

for (i = bucket; i < DP_VPORT_HASH_BUCKETS; i++) {

net/openvswitch/flow_table.c

524

u32 *bucket, u32 *last)

net/openvswitch/flow_table.c

532

while (*bucket < ti->n_buckets) {

net/openvswitch/flow_table.c

534

head = &ti->buckets[*bucket];

net/openvswitch/flow_table.c

543

(*bucket)++;

net/openvswitch/flow_table.h

92

u32 *bucket, u32 *idx);

net/openvswitch/meter.c

392

band->bucket = band->burst_size * 1000ULL;

net/openvswitch/meter.c

393

band_max_delta_t = div_u64(band->bucket, band->rate);

net/openvswitch/meter.c

653

band->bucket += delta_ms * band->rate;

net/openvswitch/meter.c

654

if (band->bucket > max_bucket_size)

net/openvswitch/meter.c

655

band->bucket = max_bucket_size;

net/openvswitch/meter.c

657

if (band->bucket >= cost) {

net/openvswitch/meter.c

658

band->bucket -= cost;

net/openvswitch/meter.h

28

u64 bucket; /* 1/1000 packets, or in bits */

net/openvswitch/vport.c

211

struct hlist_head *bucket;

net/openvswitch/vport.c

222

bucket = hash_bucket(ovs_dp_get_net(vport->dp),

net/openvswitch/vport.c

224

hlist_add_head_rcu(&vport->hash_node, bucket);

net/openvswitch/vport.c

96

struct hlist_head *bucket = hash_bucket(net, name);

net/openvswitch/vport.c

99

hlist_for_each_entry_rcu(vport, bucket, hash_node,

net/rxrpc/proc.c

320

unsigned int bucket, n;

net/rxrpc/proc.c

330

bucket = *_pos >> shift;

net/rxrpc/proc.c

332

if (bucket >= HASH_SIZE(rxnet->peer_hash)) {

net/rxrpc/proc.c

337

if (bucket == 0)

net/rxrpc/proc.c

343

p = seq_hlist_start_rcu(&rxnet->peer_hash[bucket], n - 1);

net/rxrpc/proc.c

346

bucket++;

net/rxrpc/proc.c

348

*_pos = (bucket << shift) | n;

net/rxrpc/proc.c

355

unsigned int bucket, n;

net/rxrpc/proc.c

362

bucket = *_pos >> shift;

net/rxrpc/proc.c

364

p = seq_hlist_next_rcu(v, &rxnet->peer_hash[bucket], _pos);

net/rxrpc/proc.c

369

bucket++;

net/rxrpc/proc.c

371

*_pos = (bucket << shift) | n;

net/rxrpc/proc.c

373

if (bucket >= HASH_SIZE(rxnet->peer_hash)) {

net/rxrpc/proc.c

382

p = seq_hlist_start_rcu(&rxnet->peer_hash[bucket], n - 1);

net/sched/sch_hhf.c

330

static struct sk_buff *dequeue_head(struct wdrr_bucket *bucket)

net/sched/sch_hhf.c

332

struct sk_buff *skb = bucket->head;

net/sched/sch_hhf.c

334

bucket->head = skb->next;

net/sched/sch_hhf.c

340

static void bucket_add(struct wdrr_bucket *bucket, struct sk_buff *skb)

net/sched/sch_hhf.c

342

if (bucket->head == NULL)

net/sched/sch_hhf.c

343

bucket->head = skb;

net/sched/sch_hhf.c

345

bucket->tail->next = skb;

net/sched/sch_hhf.c

346

bucket->tail = skb;

net/sched/sch_hhf.c

353

struct wdrr_bucket *bucket;

net/sched/sch_hhf.c

356

bucket = &q->buckets[WDRR_BUCKET_FOR_HH];

net/sched/sch_hhf.c

357

if (!bucket->head)

net/sched/sch_hhf.c

358

bucket = &q->buckets[WDRR_BUCKET_FOR_NON_HH];

net/sched/sch_hhf.c

360

if (bucket->head) {

net/sched/sch_hhf.c

361

struct sk_buff *skb = dequeue_head(bucket);

net/sched/sch_hhf.c

369

return bucket - q->buckets;

net/sched/sch_hhf.c

377

struct wdrr_bucket *bucket;

net/sched/sch_hhf.c

382

bucket = &q->buckets[idx];

net/sched/sch_hhf.c

383

bucket_add(bucket, skb);

net/sched/sch_hhf.c

386

if (list_empty(&bucket->bucketchain)) {

net/sched/sch_hhf.c

396

list_add_tail(&bucket->bucketchain, &q->old_buckets);

net/sched/sch_hhf.c

399

list_add_tail(&bucket->bucketchain, &q->new_buckets);

net/sched/sch_hhf.c

401

bucket->deficit = weight * q->quantum;

net/sched/sch_hhf.c

424

struct wdrr_bucket *bucket;

net/sched/sch_hhf.c

434

bucket = list_first_entry(head, struct wdrr_bucket, bucketchain);

net/sched/sch_hhf.c

436

if (bucket->deficit <= 0) {

net/sched/sch_hhf.c

437

int weight = (bucket - q->buckets == WDRR_BUCKET_FOR_HH) ?

net/sched/sch_hhf.c

440

bucket->deficit += weight * q->quantum;

net/sched/sch_hhf.c

441

list_move_tail(&bucket->bucketchain, &q->old_buckets);

net/sched/sch_hhf.c

445

if (bucket->head) {

net/sched/sch_hhf.c

446

skb = dequeue_head(bucket);

net/sched/sch_hhf.c

454

list_move_tail(&bucket->bucketchain, &q->old_buckets);

net/sched/sch_hhf.c

456

list_del_init(&bucket->bucketchain);

net/sched/sch_hhf.c

460

bucket->deficit -= qdisc_pkt_len(skb);

net/sched/sch_hhf.c

676

struct wdrr_bucket *bucket = q->buckets + i;

net/sched/sch_hhf.c

678

INIT_LIST_HEAD(&bucket->bucketchain);

net/unix/af_unix.c

3469

unsigned long bucket = get_bucket(*pos);

net/unix/af_unix.c

3473

for (sk = sk_head(&seq_file_net(seq)->unx.table.buckets[bucket]);

net/unix/af_unix.c

3484

unsigned long bucket = get_bucket(*pos);

net/unix/af_unix.c

3488

while (bucket < UNIX_HASH_SIZE) {

net/unix/af_unix.c

3489

spin_lock(&net->unx.table.locks[bucket]);

net/unix/af_unix.c

3495

spin_unlock(&net->unx.table.locks[bucket]);

net/unix/af_unix.c

3497

*pos = set_bucket_offset(++bucket, 1);

net/unix/af_unix.c

3506

unsigned long bucket = get_bucket(*pos);

net/unix/af_unix.c

3513

spin_unlock(&seq_file_net(seq)->unx.table.locks[bucket]);

net/unix/af_unix.c

3515

*pos = set_bucket_offset(++bucket, 1);

net/vmw_vsock/diag.c

102

while (bucket < ARRAY_SIZE(vsock_connected_table)) {

net/vmw_vsock/diag.c

103

struct list_head *head = &vsock_connected_table[bucket];

net/vmw_vsock/diag.c

128

bucket++;

net/vmw_vsock/diag.c

135

cb->args[1] = bucket;

net/vmw_vsock/diag.c

52

unsigned int bucket;

net/vmw_vsock/diag.c

63

bucket = cb->args[1];

net/vmw_vsock/diag.c

72

while (bucket < ARRAY_SIZE(vsock_bind_table)) {

net/vmw_vsock/diag.c

73

struct list_head *head = &vsock_bind_table[bucket];

net/vmw_vsock/diag.c

94

bucket++;

net/vmw_vsock/diag.c

98

bucket = 0;

security/safesetid/securityfs.c

100

int bucket;

security/safesetid/securityfs.c

104

hash_for_each(pol->rules, bucket, rule, next) {

security/safesetid/securityfs.c

74

int bucket;

security/safesetid/securityfs.c

78

hash_for_each_safe(pol->rules, bucket, tmp, rule, next)

tools/testing/selftests/bpf/prog_tests/sock_iter_batch.c

957

if (skel->bss->bucket[0] != skel->bss->bucket[1])

tools/testing/selftests/bpf/progs/bpf_iter_udp4.c

58

ctx->bucket, src, srcp, dest, destp);

tools/testing/selftests/bpf/progs/bpf_iter_udp6.c

62

ctx->bucket,

tools/testing/selftests/bpf/progs/sock_iter_batch.c

126

bucket[idx] = udp_sk(sk)->udp_portaddr_hash & udptable->mask;

tools/testing/selftests/bpf/progs/sock_iter_batch.c

28

unsigned int bucket[2];

tools/testing/selftests/bpf/progs/sock_iter_batch.c

66

bucket[idx] = hash & hinfo->lhash2_mask;

tools/testing/selftests/bpf/test_kmods/bpf_test_rqspinlock.c

131

u32 bucket = rqsl_hist_bucket_idx(delta_ms);

tools/testing/selftests/bpf/test_kmods/bpf_test_rqspinlock.c

134

atomic64_inc(&buckets[bucket]);

tools/testing/selftests/vDSO/parse_vdso.c

193

vdso_info.bucket = &hash[2];

tools/testing/selftests/vDSO/parse_vdso.c

288

i = vdso_info.bucket[elf_hash(name) % vdso_info.nbucket];

tools/testing/selftests/vDSO/parse_vdso.c

57

ELF_HASH_ENTRY *bucket, *chain;

tools/tracing/rtla/src/osnoise_hist.c

104

int bucket;

tools/tracing/rtla/src/osnoise_hist.c

110

bucket = duration / data->bucket_size;

tools/tracing/rtla/src/osnoise_hist.c

120

if (bucket < entries)

tools/tracing/rtla/src/osnoise_hist.c

121

hist[bucket] += count;

tools/tracing/rtla/src/osnoise_hist.c

339

int bucket, cpu;

tools/tracing/rtla/src/osnoise_hist.c

344

for (bucket = 0; bucket < data->entries; bucket++) {

tools/tracing/rtla/src/osnoise_hist.c

349

bucket * data->bucket_size);

tools/tracing/rtla/src/osnoise_hist.c

356

total += data->hist[cpu].samples[bucket];

tools/tracing/rtla/src/osnoise_hist.c

357

trace_seq_printf(trace->seq, "%9d ", data->hist[cpu].samples[bucket]);

tools/tracing/rtla/src/timerlat.bpf.c

101

int bucket)

tools/tracing/rtla/src/timerlat.bpf.c

109

if (bucket >= entries)

tools/tracing/rtla/src/timerlat.bpf.c

144

int bucket;

tools/tracing/rtla/src/timerlat.bpf.c

151

bucket = latency / bucket_size;

tools/tracing/rtla/src/timerlat.bpf.c

154

update_main_hist(&hist_irq, bucket);

tools/tracing/rtla/src/timerlat.bpf.c

155

update_summary(&summary_irq, latency, bucket);

tools/tracing/rtla/src/timerlat.bpf.c

160

update_main_hist(&hist_thread, bucket);

tools/tracing/rtla/src/timerlat.bpf.c

161

update_summary(&summary_thread, latency, bucket);

tools/tracing/rtla/src/timerlat.bpf.c

166

update_main_hist(&hist_user, bucket);

tools/tracing/rtla/src/timerlat.bpf.c

167

update_summary(&summary_user, latency, bucket);

tools/tracing/rtla/src/timerlat.bpf.c

86

int bucket)

tools/tracing/rtla/src/timerlat.bpf.c

92

if (bucket >= entries)

tools/tracing/rtla/src/timerlat.bpf.c

96

map_increment(map, bucket);

tools/tracing/rtla/src/timerlat_hist.c

143

int bucket;

tools/tracing/rtla/src/timerlat_hist.c

149

bucket = latency / data->bucket_size;

tools/tracing/rtla/src/timerlat_hist.c

171

if (bucket < entries)

tools/tracing/rtla/src/timerlat_hist.c

172

hist[bucket]++;

tools/tracing/rtla/src/timerlat_hist.c

612

int bucket, cpu;

tools/tracing/rtla/src/timerlat_hist.c

617

for (bucket = 0; bucket < data->entries; bucket++) {

tools/tracing/rtla/src/timerlat_hist.c

622

bucket * data->bucket_size);

tools/tracing/rtla/src/timerlat_hist.c

630

total += data->hist[cpu].irq[bucket];

tools/tracing/rtla/src/timerlat_hist.c

632

data->hist[cpu].irq[bucket]);

tools/tracing/rtla/src/timerlat_hist.c

636

total += data->hist[cpu].thread[bucket];

tools/tracing/rtla/src/timerlat_hist.c

638

data->hist[cpu].thread[bucket]);

tools/tracing/rtla/src/timerlat_hist.c

642

total += data->hist[cpu].user[bucket];

tools/tracing/rtla/src/timerlat_hist.c

644

data->hist[cpu].user[bucket]);