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

281

data->bucket = BUCKETS - 1;

drivers/cpuidle/governors/menu.c

475

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

drivers/cpuidle/governors/menu.c

497

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

2240

struct bucket *b;

drivers/md/bcache/super.c

2330

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

608

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

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

610

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

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

618

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

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

620

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

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

621

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

167

return vdo_allocate(map->bucket_count, struct bucket,

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

244

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

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

260

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

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

276

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

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

278

next_hop = bucket->next_hop;

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

282

bucket->next_hop = hop_offset;

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

293

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

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

323

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

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

324

struct bucket **previous_ptr)

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

326

struct bucket *previous = NULL;

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

327

unsigned int next_hop = bucket->first_hop;

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

334

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

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

357

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

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

391

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

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

422

static struct bucket *

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

423

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

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

429

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

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

430

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

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

431

struct bucket *entry;

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

433

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

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

453

static struct bucket *move_empty_bucket(struct bucket *hole)

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

461

struct bucket *bucket;

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

463

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

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

468

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

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

494

bucket->first_hop = new_hole->next_hop;

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

503

insert_in_hop_list(bucket, hole);

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

522

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

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

525

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

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

527

if (bucket == NULL) {

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

537

*old_value_ptr = bucket->value;

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

539

bucket->value = new_value;

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

556

static struct bucket *find_or_make_vacancy(struct int_map *map,

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

557

struct bucket *neighborhood)

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

560

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

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

607

struct bucket *neighborhood, *bucket;

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

630

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

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

651

bucket->key = key;

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

652

bucket->value = new_value;

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

653

insert_in_hop_list(neighborhood, bucket);

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

674

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

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

675

struct bucket *previous;

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

676

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

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

694

bucket->first_hop = victim->next_hop;

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

140

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

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

142

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

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

157

struct bucket *bucket;

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

173

bucket = &table->buckets[top_priority];

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

174

entry = bucket->queue.next;

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

178

if (list_empty(&bucket->queue))

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

179

mark_bucket_empty(table, bucket);

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

212

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

64

struct bucket, __func__, &table);

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

69

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

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

71

bucket->priority = priority;

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

72

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

1807

int bucket;

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

1814

bucket = id % hdl->nr_of_buckets;

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

1821

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

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

1862

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

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

1918

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

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

1919

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

1017

s32 bucket;

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

1045

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

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

1047

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

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

1052

bucket += 0x100;

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

1055

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

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

1067

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

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

1070

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

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

1120

s32 bucket;

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

1138

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

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

1140

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

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

1145

bucket += 0x100;

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

1151

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

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

1159

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

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

1160

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

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

1164

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

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

1172

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

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

1173

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

5673

int bucket;

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

5675

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

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

5676

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

drivers/net/gtp.c

2279

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

drivers/net/gtp.c

2299

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

drivers/net/gtp.c

2318

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

161

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

drivers/pwm/pwm-airoha.c

170

offset = bucket / AIROHA_PWM_BUCKET_PER_CYCLE_CFG;

drivers/pwm/pwm-airoha.c

171

shift = bucket % AIROHA_PWM_BUCKET_PER_CYCLE_CFG;

drivers/pwm/pwm-airoha.c

181

offset = bucket / AIROHA_PWM_BUCKET_PER_FLASH_PROD;

drivers/pwm/pwm-airoha.c

182

shift = bucket % AIROHA_PWM_BUCKET_PER_FLASH_PROD;

drivers/pwm/pwm-airoha.c

207

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

drivers/pwm/pwm-airoha.c

208

u32 bucket_period_ticks = bucket->period_ticks;

drivers/pwm/pwm-airoha.c

209

u32 bucket_duty_ticks = bucket->duty_ticks;

drivers/pwm/pwm-airoha.c

212

if (!bucket->used) {

drivers/pwm/pwm-airoha.c

271

int bucket;

drivers/pwm/pwm-airoha.c

277

bucket = pc->channel_bucket[hwpwm];

drivers/pwm/pwm-airoha.c

278

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

drivers/pwm/pwm-airoha.c

281

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

drivers/pwm/pwm-airoha.c

288

offset = bucket / AIROHA_PWM_BUCKET_PER_CYCLE_CFG;

drivers/pwm/pwm-airoha.c

289

shift = bucket % AIROHA_PWM_BUCKET_PER_CYCLE_CFG;

drivers/pwm/pwm-airoha.c

300

offset = bucket / AIROHA_PWM_BUCKET_PER_FLASH_PROD;

drivers/pwm/pwm-airoha.c

301

shift = bucket % AIROHA_PWM_BUCKET_PER_FLASH_PROD;

drivers/pwm/pwm-airoha.c

324

int bucket, ret;

drivers/pwm/pwm-airoha.c

331

bucket = airoha_pwm_get_generator(pc, duty_ticks, period_ticks);

drivers/pwm/pwm-airoha.c

332

if (bucket < 0)

drivers/pwm/pwm-airoha.c

333

return bucket;

drivers/pwm/pwm-airoha.c

338

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

drivers/pwm/pwm-airoha.c

340

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

drivers/pwm/pwm-airoha.c

343

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

drivers/pwm/pwm-airoha.c

344

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

drivers/pwm/pwm-airoha.c

345

ret = airoha_pwm_apply_bucket_config(pc, bucket,

drivers/pwm/pwm-airoha.c

349

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

drivers/pwm/pwm-airoha.c

354

return bucket;

drivers/pwm/pwm-airoha.c

453

int bucket, ret;

drivers/pwm/pwm-airoha.c

455

bucket = airoha_pwm_consume_generator(pc, duty_ticks, period_ticks,

drivers/pwm/pwm-airoha.c

457

if (bucket < 0)

drivers/pwm/pwm-airoha.c

458

return bucket;

drivers/pwm/pwm-airoha.c

460

ret = airoha_pwm_config_flash_map(pc, hwpwm, bucket);

drivers/pwm/pwm-airoha.c

462

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

drivers/pwm/pwm-airoha.c

467

pc->channel_bucket[hwpwm] = bucket;

drivers/pwm/pwm-airoha.c

552

u8 bucket;

drivers/pwm/pwm-airoha.c

566

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

drivers/pwm/pwm-airoha.c

567

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

9134

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

drivers/scsi/hpsa.c

9146

if (bucket[j] >= size) {

drivers/scsi/lpfc/lpfc_ct.c

3591

u32 cmd, hash, bucket;

drivers/scsi/lpfc/lpfc_ct.c

3671

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

5492

u32 bucket;

drivers/scsi/lpfc/lpfc_scsi.c

5503

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

991

u8 bucket;

fs/btrfs/compression.c

1308

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

fs/btrfs/compression.c

1309

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

fs/btrfs/compression.c

1441

struct bucket_item *bucket = ws->bucket;

fs/btrfs/compression.c

1444

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

fs/btrfs/compression.c

1447

coreset_sum += bucket[i].count;

fs/btrfs/compression.c

1452

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

fs/btrfs/compression.c

1453

coreset_sum += bucket[i].count;

fs/btrfs/compression.c

1480

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

fs/btrfs/compression.c

1490

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

fs/btrfs/compression.c

1588

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

fs/btrfs/compression.c

1592

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

fs/btrfs/compression.c

648

struct bucket_item *bucket;

fs/btrfs/compression.c

661

kfree(workspace->bucket);

fs/btrfs/compression.c

678

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

fs/btrfs/compression.c

679

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

876

int bucket;

fs/btrfs/raid56.c

880

bucket = rbio_bucket(rbio);

fs/btrfs/raid56.c

881

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

fs/crypto/keyring.c

244

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

fs/crypto/keyring.c

248

hlist_for_each_entry_safe(mk, tmp, bucket, mk_node) {

fs/crypto/keyring.c

293

struct hlist_head *bucket;

fs/crypto/keyring.c

306

bucket = fscrypt_mk_hash_bucket(keyring, mk_spec);

fs/crypto/keyring.c

310

hlist_for_each_entry_rcu(mk, bucket, mk_node) {

fs/crypto/keyring.c

321

hlist_for_each_entry_rcu(mk, bucket, mk_node) {

fs/fuse/dir.c

108

struct dentry_bucket *bucket)

fs/fuse/dir.c

111

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

fs/fuse/dir.c

119

struct dentry_bucket *bucket = get_dentry_bucket(dentry);

fs/fuse/dir.c

121

spin_lock(&bucket->lock);

fs/fuse/dir.c

122

__fuse_dentry_tree_del_node(fd, bucket);

fs/fuse/dir.c

123

spin_unlock(&bucket->lock);

fs/fuse/dir.c

129

struct dentry_bucket *bucket;

fs/fuse/dir.c

136

bucket = get_dentry_bucket(dentry);

fs/fuse/dir.c

138

spin_lock(&bucket->lock);

fs/fuse/dir.c

140

__fuse_dentry_tree_del_node(fd, bucket);

fs/fuse/dir.c

142

p = &bucket->tree.rb_node;

fs/fuse/dir.c

152

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

fs/fuse/dir.c

153

spin_unlock(&bucket->lock);

fs/fuse/file.c

1881

if (wpa->bucket)

fs/fuse/file.c

1882

fuse_sync_bucket_dec(wpa->bucket);

fs/fuse/file.c

2071

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

fs/fuse/file.c

2072

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

fs/fuse/file.c

439

struct fuse_sync_bucket *bucket;

fs/fuse/fuse_i.h

1126

static inline void fuse_sync_bucket_dec(struct fuse_sync_bucket *bucket)

fs/fuse/fuse_i.h

1130

if (atomic_dec_and_test(&bucket->count))

fs/fuse/fuse_i.h

1131

wake_up(&bucket->waitq);

fs/fuse/inode.c

1026

struct fuse_sync_bucket *bucket;

fs/fuse/inode.c

1039

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

fs/fuse/inode.c

1040

if (bucket) {

fs/fuse/inode.c

1041

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

fs/fuse/inode.c

1042

kfree(bucket);

fs/fuse/inode.c

685

struct fuse_sync_bucket *bucket;

fs/fuse/inode.c

687

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

fs/fuse/inode.c

688

if (bucket) {

fs/fuse/inode.c

689

init_waitqueue_head(&bucket->waitq);

fs/fuse/inode.c

691

atomic_set(&bucket->count, 1);

fs/fuse/inode.c

693

return bucket;

fs/fuse/inode.c

698

struct fuse_sync_bucket *bucket, *new_bucket;

fs/fuse/inode.c

703

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

fs/fuse/inode.c

704

count = atomic_read(&bucket->count);

fs/fuse/inode.c

725

atomic_dec(&bucket->count);

fs/fuse/inode.c

727

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

fs/fuse/inode.c

731

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

186

unsigned int bucket = fanotify_event_hash_bucket(group, new);

fs/notify/fanotify/fanotify.c

187

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

fs/notify/fanotify/fanotify.c

191

group, event, bucket);

fs/notify/fanotify/fanotify.c

911

unsigned int bucket = fanotify_event_hash_bucket(group, event);

fs/notify/fanotify/fanotify.c

912

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

fs/notify/fanotify/fanotify.c

920

group, event, bucket);

fs/ocfs2/dlm/dlmdebug.c

355

struct hlist_head *bucket;

fs/ocfs2/dlm/dlmdebug.c

364

bucket = dlm_master_hash(dlm, i);

fs/ocfs2/dlm/dlmdebug.c

365

hlist_for_each_entry(mle, bucket, master_hash_node) {

fs/ocfs2/dlm/dlmdomain.c

158

struct hlist_head *bucket;

fs/ocfs2/dlm/dlmdomain.c

162

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

fs/ocfs2/dlm/dlmdomain.c

167

hlist_add_head(&res->hash_node, bucket);

fs/ocfs2/dlm/dlmdomain.c

178

struct hlist_head *bucket;

fs/ocfs2/dlm/dlmdomain.c

185

bucket = dlm_lockres_hash(dlm, hash);

fs/ocfs2/dlm/dlmdomain.c

187

hlist_for_each_entry(res, bucket, hash_node) {

fs/ocfs2/dlm/dlmdomain.c

408

struct hlist_head *bucket;

fs/ocfs2/dlm/dlmdomain.c

418

bucket = dlm_lockres_hash(dlm, i);

fs/ocfs2/dlm/dlmdomain.c

419

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

3320

struct hlist_head *bucket;

fs/ocfs2/dlm/dlmmaster.c

333

bucket = dlm_master_hash(dlm, hash);

fs/ocfs2/dlm/dlmmaster.c

3331

bucket = dlm_master_hash(dlm, i);

fs/ocfs2/dlm/dlmmaster.c

3332

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

3520

struct hlist_head *bucket;

fs/ocfs2/dlm/dlmmaster.c

3537

bucket = dlm_master_hash(dlm, i);

fs/ocfs2/dlm/dlmmaster.c

3538

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

1785

unsigned int hash, unsigned long long bucket, \

fs/ocfs2/ocfs2_trace.h

1787

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

fs/ocfs2/xattr.c

1249

xs->bucket = ocfs2_xattr_bucket_new(inode);

fs/ocfs2/xattr.c

125

struct ocfs2_xattr_bucket *bucket;

fs/ocfs2/xattr.c

1250

if (!xs->bucket) {

fs/ocfs2/xattr.c

1280

bucket_xh(xs->bucket),

fs/ocfs2/xattr.c

1288

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

fs/ocfs2/xattr.c

1306

ocfs2_xattr_bucket_free(xs->bucket);

fs/ocfs2/xattr.c

1740

struct ocfs2_xattr_bucket *bucket = loc->xl_storage;

fs/ocfs2/xattr.c

1742

return ocfs2_xattr_bucket_journal_access(handle, bucket, type);

fs/ocfs2/xattr.c

1748

struct ocfs2_xattr_bucket *bucket = loc->xl_storage;

fs/ocfs2/xattr.c

1750

ocfs2_xattr_bucket_journal_dirty(handle, bucket);

fs/ocfs2/xattr.c

1756

struct ocfs2_xattr_bucket *bucket = loc->xl_storage;

fs/ocfs2/xattr.c

1763

return bucket_block(bucket, block) + block_offset;

fs/ocfs2/xattr.c

1775

struct ocfs2_xattr_bucket *bucket = loc->xl_storage;

fs/ocfs2/xattr.c

1776

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

fs/ocfs2/xattr.c

1897

struct ocfs2_xattr_bucket *bucket = loc->xl_storage;

fs/ocfs2/xattr.c

1907

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

fs/ocfs2/xattr.c

1910

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

fs/ocfs2/xattr.c

2339

struct ocfs2_xattr_bucket *bucket,

fs/ocfs2/xattr.c

2342

loc->xl_inode = bucket->bu_inode;

fs/ocfs2/xattr.c

2344

loc->xl_storage = bucket;

fs/ocfs2/xattr.c

2345

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

3127

bucket_xh(xbs->bucket),

fs/ocfs2/xattr.c

3130

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

3522

xbs.bucket = ocfs2_xattr_bucket_new(inode);

fs/ocfs2/xattr.c

3523

if (!xbs.bucket) {

fs/ocfs2/xattr.c

3548

ocfs2_xattr_bucket_free(xbs.bucket);

fs/ocfs2/xattr.c

3599

xbs.bucket = ocfs2_xattr_bucket_new(inode);

fs/ocfs2/xattr.c

3600

if (!xbs.bucket) {

fs/ocfs2/xattr.c

361

static int ocfs2_init_xattr_bucket(struct ocfs2_xattr_bucket *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

3708

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

3778

struct ocfs2_xattr_bucket *bucket,

fs/ocfs2/xattr.c

378

ocfs2_set_new_buffer_uptodate(INODE_CACHE(bucket->bu_inode),

fs/ocfs2/xattr.c

3782

struct ocfs2_xattr_bucket *bucket,

fs/ocfs2/xattr.c

379

bucket->bu_bhs[i]);

fs/ocfs2/xattr.c

3790

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

3824

xe_name = bucket_block(bucket, block_off) + new_offset;

fs/ocfs2/xattr.c

383

bucket->bu_bhs[i]);

fs/ocfs2/xattr.c

3859

int low_bucket = 0, bucket, high_bucket;

fs/ocfs2/xattr.c

3881

bucket = (low_bucket + high_bucket) / 2;

fs/ocfs2/xattr.c

3882

blkno = p_blkno + bucket * blk_per_bucket;

fs/ocfs2/xattr.c

389

ocfs2_xattr_bucket_relse(bucket);

fs/ocfs2/xattr.c

3892

high_bucket = bucket - 1;

fs/ocfs2/xattr.c

3908

low_bucket = bucket + 1;

fs/ocfs2/xattr.c

3932

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

fs/ocfs2/xattr.c

3938

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

fs/ocfs2/xattr.c

3939

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

fs/ocfs2/xattr.c

394

static int ocfs2_read_xattr_bucket(struct ocfs2_xattr_bucket *bucket,

fs/ocfs2/xattr.c

3946

(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

4009

struct ocfs2_xattr_bucket *bucket;

fs/ocfs2/xattr.c

4011

bucket = ocfs2_xattr_bucket_new(inode);

fs/ocfs2/xattr.c

4012

if (!bucket) {

fs/ocfs2/xattr.c

4021

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

fs/ocfs2/xattr.c

4022

ret = ocfs2_read_xattr_bucket(bucket, blkno);

fs/ocfs2/xattr.c

403

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

fs/ocfs2/xattr.c

4033

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

fs/ocfs2/xattr.c

4036

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

fs/ocfs2/xattr.c

4038

ret = func(inode, bucket, para);

fs/ocfs2/xattr.c

404

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

fs/ocfs2/xattr.c

4044

ocfs2_xattr_bucket_relse(bucket);

fs/ocfs2/xattr.c

4049

ocfs2_xattr_bucket_free(bucket);

fs/ocfs2/xattr.c

405

bucket->bu_bhs,

fs/ocfs2/xattr.c

406

bucket->bu_blocks,

fs/ocfs2/xattr.c

407

&bucket_xh(bucket)->xh_check);

fs/ocfs2/xattr.c

4079

struct ocfs2_xattr_bucket *bucket,

fs/ocfs2/xattr.c

408

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

fs/ocfs2/xattr.c

4087

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

fs/ocfs2/xattr.c

4088

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

fs/ocfs2/xattr.c

4092

bucket_xh(bucket),

fs/ocfs2/xattr.c

4099

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

4210

struct ocfs2_xattr_bucket *bucket)

fs/ocfs2/xattr.c

4219

struct ocfs2_xattr_header *xh = bucket_xh(bucket);

fs/ocfs2/xattr.c

4222

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

fs/ocfs2/xattr.c

4226

(unsigned long long)bucket_blkno(bucket));

fs/ocfs2/xattr.c

4229

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

fs/ocfs2/xattr.c

424

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

fs/ocfs2/xattr.c

4251

target = bucket_block(bucket, 0);

fs/ocfs2/xattr.c

426

INODE_CACHE(bucket->bu_inode),

fs/ocfs2/xattr.c

427

bucket->bu_bhs[i], type);

fs/ocfs2/xattr.c

4285

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

fs/ocfs2/xattr.c

4286

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

fs/ocfs2/xattr.c

4315

BUG_ON(!xs->bucket);

fs/ocfs2/xattr.c

4347

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

fs/ocfs2/xattr.c

4353

ret = ocfs2_xattr_bucket_journal_access(handle, xs->bucket,

fs/ocfs2/xattr.c

4360

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

fs/ocfs2/xattr.c

4361

ocfs2_xattr_bucket_journal_dirty(handle, xs->bucket);

fs/ocfs2/xattr.c

438

struct ocfs2_xattr_bucket *bucket)

fs/ocfs2/xattr.c

4411

struct ocfs2_xattr_bucket *bucket)

fs/ocfs2/xattr.c

4417

u64 blkno = bucket_blkno(bucket);

fs/ocfs2/xattr.c

442

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

fs/ocfs2/xattr.c

443

ocfs2_compute_meta_ecc_bhs(bucket->bu_inode->i_sb,

fs/ocfs2/xattr.c

4435

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

fs/ocfs2/xattr.c

4436

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

fs/ocfs2/xattr.c

4438

ret = ocfs2_xattr_bucket_journal_access(handle, bucket,

fs/ocfs2/xattr.c

444

bucket->bu_bhs, bucket->bu_blocks,

fs/ocfs2/xattr.c

445

&bucket_xh(bucket)->xh_check);

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

4505

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

fs/ocfs2/xattr.c

4506

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

fs/ocfs2/xattr.c

4507

ocfs2_xattr_bucket_journal_dirty(handle, bucket);

fs/ocfs2/xattr.c

5379

struct ocfs2_xattr_bucket *bucket,

fs/ocfs2/xattr.c

5387

struct ocfs2_xattr_header *xh = bucket_xh(bucket);

fs/ocfs2/xattr.c

5405

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

fs/ocfs2/xattr.c

5419

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

fs/ocfs2/xattr.c

5426

ret = ocfs2_xattr_bucket_journal_access(ctxt->handle, bucket,

fs/ocfs2/xattr.c

5435

ocfs2_xattr_bucket_journal_dirty(ctxt->handle, bucket);

fs/ocfs2/xattr.c

5543

struct ocfs2_xattr_bucket *bucket,

fs/ocfs2/xattr.c

5546

struct ocfs2_xattr_header *xh = bucket_xh(bucket);

fs/ocfs2/xattr.c

5556

(unsigned long long)bucket_blkno(bucket),

fs/ocfs2/xattr.c

5578

ocfs2_init_xattr_bucket_xa_loc(&loc, xs->bucket,

fs/ocfs2/xattr.c

5592

xs->bucket);

fs/ocfs2/xattr.c

5637

xs->bucket,

fs/ocfs2/xattr.c

5646

xs->bucket,

fs/ocfs2/xattr.c

5660

ocfs2_xattr_bucket_relse(xs->bucket);

fs/ocfs2/xattr.c

5678

struct ocfs2_xattr_bucket *bucket,

fs/ocfs2/xattr.c

5682

struct ocfs2_xattr_header *xh = bucket_xh(bucket);

fs/ocfs2/xattr.c

5700

ret = ocfs2_get_xattr_tree_value_root(inode->i_sb, bucket,

fs/ocfs2/xattr.c

5720

ret = ocfs2_xattr_bucket_value_truncate(inode, bucket,

fs/ocfs2/xattr.c

5754

struct ocfs2_xattr_bucket *bucket =

fs/ocfs2/xattr.c

5757

ret = ocfs2_xattr_bucket_journal_access(handle, bucket,

fs/ocfs2/xattr.c

5764

ocfs2_xattr_bucket_journal_dirty(handle, bucket);

fs/ocfs2/xattr.c

5800

struct ocfs2_xattr_bucket *bucket = NULL;

fs/ocfs2/xattr.c

5823

bucket_xh(xbs->bucket),

fs/ocfs2/xattr.c

5830

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

fs/ocfs2/xattr.c

5831

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

fs/ocfs2/xattr.c

5836

bucket = xbs->bucket;

fs/ocfs2/xattr.c

5837

refcount.credits = bucket->bu_blocks;

fs/ocfs2/xattr.c

5838

refcount.para = bucket;

fs/ocfs2/xattr.c

6025

struct ocfs2_xattr_bucket *bucket,

fs/ocfs2/xattr.c

6031

struct ocfs2_xattr_header *xh = bucket_xh(bucket);

fs/ocfs2/xattr.c

6036

bucket_xh(bucket),

fs/ocfs2/xattr.c

6045

base = bucket_block(bucket, block_off);

fs/ocfs2/xattr.c

6051

*bh = bucket->bu_bhs[block_off];

fs/ocfs2/xattr.c

6061

struct ocfs2_xattr_bucket *bucket,

fs/ocfs2/xattr.c

6069

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

fs/ocfs2/xattr.c

6075

.credits = bucket->bu_blocks,

fs/ocfs2/xattr.c

6076

.para = bucket,

fs/ocfs2/xattr.c

6086

(unsigned long long)bucket_blkno(bucket),

fs/ocfs2/xattr.c

6094

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

fs/ocfs2/xattr.c

6711

struct ocfs2_xattr_bucket *bucket;

fs/ocfs2/xattr.c

6714

bucket = args->old_bucket;

fs/ocfs2/xattr.c

6716

bucket = args->new_bucket;

fs/ocfs2/xattr.c

6718

return ocfs2_get_xattr_tree_value_root(sb, bucket, offset,

fs/ocfs2/xattr.c

6736

struct ocfs2_xattr_bucket *bucket =

fs/ocfs2/xattr.c

6739

return ocfs2_get_xattr_tree_value_root(sb, bucket, offset,

fs/ocfs2/xattr.c

6744

struct ocfs2_xattr_bucket *bucket,

fs/ocfs2/xattr.c

6750

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

fs/ocfs2/xattr.c

6753

metas->credits += bucket->bu_blocks;

fs/ocfs2/xattr.c

6754

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

fs/ocfs2/xattr.c

6758

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

125

static bool is_mostly_ascii(const struct bucket *bkt)

fs/smb/client/compress.c

148

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

fs/smb/client/compress.c

197

struct bucket *bkt = NULL;

fs/smb/client/compress.c

63

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

fs/smb/client/compress.c

98

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

fs/xfs/libxfs/xfs_ag.c

543

int bucket;

fs/xfs/libxfs/xfs_ag.c

552

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

fs/xfs/libxfs/xfs_ag.c

553

agfl_bno[bucket] = cpu_to_be32(NULLAGBLOCK);

fs/xfs/libxfs/xfs_ag.c

563

int bucket;

fs/xfs/libxfs/xfs_ag.c

581

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

fs/xfs/libxfs/xfs_ag.c

582

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

1142

unsigned int bucket;

fs/xfs/scrub/agheader_repair.c

1149

bucket = agino % XFS_AGI_UNLINKED_BUCKETS;

fs/xfs/scrub/agheader_repair.c

1151

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

fs/xfs/scrub/agheader_repair.c

1152

ragi->iunlink_heads[bucket], ip);

fs/xfs/scrub/agheader_repair.c

1159

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

fs/xfs/scrub/agheader_repair.c

1160

ragi->iunlink_heads[bucket] = agino;

fs/xfs/scrub/agheader_repair.c

1327

unsigned int bucket)

fs/xfs/scrub/agheader_repair.c

1332

xfs_agino_t next_agino = ragi->iunlink_heads[bucket];

fs/xfs/scrub/agheader_repair.c

1344

bucket, prev_agino, next_agino);

fs/xfs/scrub/agheader_repair.c

1350

if (next_agino % XFS_AGI_UNLINKED_BUCKETS != bucket) {

fs/xfs/scrub/agheader_repair.c

1356

bucket, prev_agino, next_agino);

fs/xfs/scrub/agheader_repair.c

1370

bucket, prev_agino, next_agino);

fs/xfs/scrub/agheader_repair.c

1375

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

fs/xfs/scrub/agheader_repair.c

1422

unsigned int bucket;

fs/xfs/scrub/agheader_repair.c

1425

bucket = agino % XFS_AGI_UNLINKED_BUCKETS;

fs/xfs/scrub/agheader_repair.c

1428

current_head = ragi->iunlink_heads[bucket];

fs/xfs/scrub/agheader_repair.c

1430

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

fs/xfs/scrub/agheader_repair.c

1444

ragi->iunlink_heads[bucket] = agino;

fs/xfs/scrub/trace.h

3431

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

fs/xfs/scrub/trace.h

3433

TP_ARGS(pag, bucket, bucket_agino, ip),

fs/xfs/scrub/trace.h

3438

__field(unsigned int, bucket)

fs/xfs/scrub/trace.h

3447

__entry->bucket = bucket;

fs/xfs/scrub/trace.h

3455

__entry->bucket,

fs/xfs/scrub/trace.h

3521

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

fs/xfs/scrub/trace.h

3523

TP_ARGS(pag, bucket, prev_agino, next_agino),

fs/xfs/scrub/trace.h

3527

__field(unsigned int, bucket)

fs/xfs/scrub/trace.h

3534

__entry->bucket = bucket;

fs/xfs/scrub/trace.h

3541

__entry->bucket,

fs/xfs/scrub/trace.h

3547

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

fs/xfs/scrub/trace.h

3549

TP_ARGS(pag, bucket, prev_agino, next_agino),

fs/xfs/scrub/trace.h

3553

__field(unsigned int, bucket)

fs/xfs/scrub/trace.h

3560

__entry->bucket = bucket;

fs/xfs/scrub/trace.h

3567

__entry->bucket,

fs/xfs/scrub/trace.h

3573

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

fs/xfs/scrub/trace.h

3575

TP_ARGS(pag, bucket, prev_agino, next_agino))

fs/xfs/scrub/trace.h

3634

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

fs/xfs/scrub/trace.h

3636

TP_ARGS(pag, bucket, agino, curr_head),

fs/xfs/scrub/trace.h

3640

__field(unsigned int, bucket)

fs/xfs/scrub/trace.h

3647

__entry->bucket = bucket;

fs/xfs/scrub/trace.h

3654

__entry->bucket,

fs/xfs/scrub/trace.h

3660

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

fs/xfs/scrub/trace.h

3662

TP_ARGS(pag, bucket, old_agino, agino),

fs/xfs/scrub/trace.h

3666

__field(unsigned int, bucket)

fs/xfs/scrub/trace.h

3673

__entry->bucket = bucket;

fs/xfs/scrub/trace.h

3680

__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

2865

unsigned int bucket;

fs/xfs/xfs_inode.c

2886

bucket = agino % XFS_AGI_UNLINKED_BUCKETS;

fs/xfs/xfs_inode.c

2896

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

fs/xfs/xfs_log_recover.c

2683

int bucket)

fs/xfs/xfs_log_recover.c

2701

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

fs/xfs/xfs_log_recover.c

2703

(sizeof(xfs_agino_t) * bucket);

fs/xfs/xfs_log_recover.c

2724

int bucket)

fs/xfs/xfs_log_recover.c

2732

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

fs/xfs/xfs_log_recover.c

2808

int bucket;

fs/xfs/xfs_log_recover.c

2833

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

fs/xfs/xfs_log_recover.c

2834

error = xlog_recover_iunlink_bucket(pag, agi, bucket);

fs/xfs/xfs_log_recover.c

2842

xlog_recover_clear_agi_bucket(pag, bucket);

fs/xfs/xfs_trace.h

4467

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

fs/xfs/xfs_trace.h

4469

TP_ARGS(pag, bucket, old_ptr, new_ptr),

fs/xfs/xfs_trace.h

4473

__field(unsigned int, bucket)

fs/xfs/xfs_trace.h

4480

__entry->bucket = bucket;

fs/xfs/xfs_trace.h

4487

__entry->bucket,

fs/xfs/xfs_trace.h

466

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

fs/xfs/xfs_trace.h

467

TP_ARGS(rtg, bucket),

fs/xfs/xfs_trace.h

472

__field(unsigned int, bucket)

fs/xfs/xfs_trace.h

478

__entry->bucket = bucket;

fs/xfs/xfs_trace.h

484

__entry->bucket)

fs/xfs/xfs_zone_gc.c

431

uint32_t bucket)

fs/xfs/xfs_zone_gc.c

438

if (!zi->zi_used_bucket_entries[bucket])

fs/xfs/xfs_zone_gc.c

441

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

fs/xfs/xfs_zone_gc.c

480

if (bucket == 0 &&

fs/xfs/xfs_zone_gc.c

500

unsigned int bucket;

fs/xfs/xfs_zone_gc.c

503

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

fs/xfs/xfs_zone_gc.c

504

victim_rtg = xfs_zone_gc_pick_victim_from(mp, bucket);

fs/xfs/xfs_zone_gc.c

513

trace_xfs_zone_gc_select_victim(victim_rtg, bucket);

include/linux/atalk.h

149

int bucket;

include/linux/rhashtable.h

340

struct rhash_lock_head __rcu **bucket,

include/linux/rhashtable.h

342

__acquires(__bitlock(0, bucket))

include/linux/rhashtable.h

347

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

include/net/llc.h

75

u32 bucket = hash_32(ifindex, LLC_SK_DEV_HASH_BITS);

include/net/llc.h

77

return &sap->sk_dev_hash[bucket];

include/net/neighbour.h

418

unsigned int bucket;

include/net/ping.h

40

int bucket;

include/net/raw.h

63

int bucket;

include/net/tcp.h

2366

int bucket, offset, sbucket, num;

include/net/transp_v6.h

48

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

include/net/transp_v6.h

51

__u16 destp, int bucket)

include/net/transp_v6.h

54

bucket);

include/net/udp.h

571

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

1174

struct bucket *b;

kernel/bpf/hashtab.c

1281

struct bucket *b;

kernel/bpf/hashtab.c

1358

struct bucket *b;

kernel/bpf/hashtab.c

1420

struct bucket *b;

kernel/bpf/hashtab.c

149

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

kernel/bpf/hashtab.c

1499

struct bucket *b;

kernel/bpf/hashtab.c

1534

struct bucket *b;

kernel/bpf/hashtab.c

161

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

kernel/bpf/hashtab.c

1680

struct bucket *b;

kernel/bpf/hashtab.c

1786

struct bucket *b;

kernel/bpf/hashtab.c

2093

struct bucket *b;

kernel/bpf/hashtab.c

2268

struct bucket *b;

kernel/bpf/hashtab.c

2322

sizeof(struct bucket) * htab->n_buckets;

kernel/bpf/hashtab.c

591

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

kernel/bpf/hashtab.c

600

sizeof(struct bucket),

kernel/bpf/hashtab.c

681

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

kernel/bpf/hashtab.c

866

struct bucket *b;

kernel/bpf/hashtab.c

89

struct bucket *buckets;

kernel/bpf/stackmap.c

253

struct stack_map_bucket *bucket, *new_bucket, *old_bucket;

kernel/bpf/stackmap.c

270

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

kernel/bpf/stackmap.c

272

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

kernel/bpf/stackmap.c

291

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

kernel/bpf/stackmap.c

292

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

kernel/bpf/stackmap.c

296

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

kernel/bpf/stackmap.c

301

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

kernel/bpf/stackmap.c

302

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

kernel/bpf/stackmap.c

304

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

kernel/bpf/stackmap.c

678

struct stack_map_bucket *bucket, *old_bucket;

kernel/bpf/stackmap.c

684

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

kernel/bpf/stackmap.c

685

if (!bucket)

kernel/bpf/stackmap.c

688

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

kernel/bpf/stackmap.c

689

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

kernel/bpf/stackmap.c

693

old_bucket = bucket;

kernel/bpf/stackmap.c

695

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

kernel/dma/debug.c

1071

put_hash_bucket(bucket, flags);

kernel/dma/debug.c

1121

struct hash_bucket *bucket;

kernel/dma/debug.c

1124

bucket = get_hash_bucket(ref, &flags);

kernel/dma/debug.c

1126

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

kernel/dma/debug.c

1188

put_hash_bucket(bucket, flags);

kernel/dma/debug.c

1268

struct hash_bucket *bucket;

kernel/dma/debug.c

1276

bucket = get_hash_bucket(&ref, &flags);

kernel/dma/debug.c

1278

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

kernel/dma/debug.c

1298

put_hash_bucket(bucket, flags);

kernel/dma/debug.c

1359

struct hash_bucket *bucket;

kernel/dma/debug.c

1363

bucket = get_hash_bucket(ref, &flags);

kernel/dma/debug.c

1364

entry = bucket_find_exact(bucket, ref);

kernel/dma/debug.c

1369

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

538

struct hash_bucket *bucket = &dma_entry_hash[idx];

kernel/dma/debug.c

542

spin_lock_irqsave(&bucket->lock, flags);

kernel/dma/debug.c

543

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

kernel/dma/debug.c

555

spin_unlock_irqrestore(&bucket->lock, flags);

kernel/dma/debug.c

570

struct hash_bucket *bucket = &dma_entry_hash[idx];

kernel/dma/debug.c

574

spin_lock_irqsave(&bucket->lock, flags);

kernel/dma/debug.c

575

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

kernel/dma/debug.c

587

spin_unlock_irqrestore(&bucket->lock, flags);

kernel/dma/debug.c

600

struct hash_bucket *bucket;

kernel/dma/debug.c

607

bucket = get_hash_bucket(entry, &flags);

kernel/dma/debug.c

608

hash_bucket_add(bucket, entry);

kernel/dma/debug.c

609

put_hash_bucket(bucket, flags);

kernel/dma/debug.c

982

struct hash_bucket *bucket;

kernel/dma/debug.c

985

bucket = get_hash_bucket(ref, &flags);

kernel/dma/debug.c

986

entry = bucket_find_exact(bucket, ref);

kernel/dma/debug.c

990

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

1560

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

kernel/sched/core.c

1568

if (!bucket[bucket_id].tasks)

kernel/sched/core.c

1570

return bucket[bucket_id].value;

kernel/sched/core.c

1680

struct uclamp_bucket *bucket;

kernel/sched/core.c

1687

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

kernel/sched/core.c

1688

bucket->tasks++;

kernel/sched/core.c

1697

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

kernel/sched/core.c

1698

bucket->value = uc_se->value;

kernel/sched/core.c

1718

struct uclamp_bucket *bucket;

kernel/sched/core.c

1750

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

kernel/sched/core.c

1752

WARN_ON_ONCE(!bucket->tasks);

kernel/sched/core.c

1753

if (likely(bucket->tasks))

kernel/sched/core.c

1754

bucket->tasks--;

kernel/sched/core.c

1764

if (likely(bucket->tasks))

kernel/sched/core.c

1772

WARN_ON_ONCE(bucket->value > rq_clamp);

kernel/sched/core.c

1773

if (bucket->value >= rq_clamp) {

kernel/sched/sched.h

1111

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

444

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

kernel/time/posix-timers.c

446

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

1213

return &ntbl[subhash].bucket;

lib/rhashtable.c

1253

return &ntbl[hash].bucket;

lib/rhashtable.c

138

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/appletalk/aarp.c

908

int ct = iter->bucket;

net/appletalk/aarp.c

918

iter->bucket = ct;

net/appletalk/aarp.c

945

iter->bucket = 0;

net/appletalk/aarp.c

967

++iter->bucket;

net/atm/proc.c

113

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

net/atm/proc.c

69

int bucket;

net/atm/proc.c

78

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

net/atm/proc.c

83

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

net/atm/proc.c

84

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

net/atm/proc.c

98

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

net/atm/proc.c

99

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

net/batman-adv/bat_iv_ogm.c

1979

int bucket = cb->args[0];

net/batman-adv/bat_iv_ogm.c

1984

while (bucket < hash->size) {

net/batman-adv/bat_iv_ogm.c

1985

head = &hash->table[bucket];

net/batman-adv/bat_iv_ogm.c

1993

bucket++;

net/batman-adv/bat_iv_ogm.c

1996

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

2199

struct batadv_hashtable *hash, unsigned int bucket,

net/batman-adv/bridge_loop_avoidance.c

2206

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

net/batman-adv/bridge_loop_avoidance.c

2209

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

net/batman-adv/bridge_loop_avoidance.c

2223

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

net/batman-adv/bridge_loop_avoidance.c

2241

int bucket = cb->args[0];

net/batman-adv/bridge_loop_avoidance.c

2258

while (bucket < hash->size) {

net/batman-adv/bridge_loop_avoidance.c

2260

hash, bucket, &idx))

net/batman-adv/bridge_loop_avoidance.c

2262

bucket++;

net/batman-adv/bridge_loop_avoidance.c

2265

cb->args[0] = bucket;

net/batman-adv/bridge_loop_avoidance.c

2361

unsigned int bucket, int *idx_skip)

net/batman-adv/bridge_loop_avoidance.c

2367

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

net/batman-adv/bridge_loop_avoidance.c

2370

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

net/batman-adv/bridge_loop_avoidance.c

2384

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

net/batman-adv/bridge_loop_avoidance.c

2402

int bucket = cb->args[0];

net/batman-adv/bridge_loop_avoidance.c

2419

while (bucket < hash->size) {

net/batman-adv/bridge_loop_avoidance.c

2421

hash, bucket, &idx))

net/batman-adv/bridge_loop_avoidance.c

2423

bucket++;

net/batman-adv/bridge_loop_avoidance.c

2426

cb->args[0] = bucket;

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

899

struct batadv_hashtable *hash, unsigned int bucket,

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

905

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

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

908

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

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

913

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

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

922

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

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

941

int bucket = cb->args[0];

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

958

while (bucket < hash->size) {

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

959

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

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

963

bucket++;

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

967

cb->args[0] = bucket;

net/batman-adv/fragmentation.c

144

u8 bucket;

net/batman-adv/fragmentation.c

157

bucket = seqno % BATADV_FRAG_BUFFER_COUNT;

net/batman-adv/fragmentation.c

170

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

1103

struct batadv_hashtable *hash, unsigned int bucket,

net/batman-adv/translation-table.c

1109

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

net/batman-adv/translation-table.c

1112

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

net/batman-adv/translation-table.c

1118

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

net/batman-adv/translation-table.c

1123

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

net/batman-adv/translation-table.c

1143

int bucket = cb->args[0];

net/batman-adv/translation-table.c

1161

while (bucket < hash->size) {

net/batman-adv/translation-table.c

1163

hash, bucket, &idx))

net/batman-adv/translation-table.c

1166

bucket++;

net/batman-adv/translation-table.c

1175

cb->args[0] = bucket;

net/batman-adv/translation-table.c

1911

int bucket = cb->args[0];

net/batman-adv/translation-table.c

1930

while (bucket < hash->size) {

net/batman-adv/translation-table.c

1931

head = &hash->table[bucket];

net/batman-adv/translation-table.c

1938

bucket++;

net/batman-adv/translation-table.c

1947

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

465

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

net/core/gro.c

467

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

net/core/gro.c

556

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

net/core/gro.c

557

__set_bit(bucket, &gro->bitmask);

net/core/gro.c

558

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

net/core/gro.c

559

__clear_bit(bucket, &gro->bitmask);

net/core/neighbour.c

3289

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

net/core/neighbour.c

3290

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

net/core/neighbour.c

3351

int bucket;

net/core/neighbour.c

3354

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

net/core/neighbour.c

3355

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

net/core/neighbour.c

3362

state->bucket = bucket;

net/core/neighbour.c

3380

if (++state->bucket > PNEIGH_HASHMASK)

net/core/neighbour.c

3383

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

net/core/neighbour.c

3432

state->bucket = -1;

net/core/sock_map.c

1018

bucket = sock_hash_select_bucket(htab, hash);

net/core/sock_map.c

1020

spin_lock_bh(&bucket->lock);

net/core/sock_map.c

1021

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

net/core/sock_map.c

1040

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

net/core/sock_map.c

1046

spin_unlock_bh(&bucket->lock);

net/core/sock_map.c

1049

spin_unlock_bh(&bucket->lock);

net/core/sock_map.c

1147

struct bpf_shtab_bucket *bucket;

net/core/sock_map.c

1159

bucket = sock_hash_select_bucket(htab, i);

net/core/sock_map.c

1167

spin_lock_bh(&bucket->lock);

net/core/sock_map.c

1168

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

net/core/sock_map.c

1170

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

net/core/sock_map.c

1171

spin_unlock_bh(&bucket->lock);

net/core/sock_map.c

1320

struct bpf_shtab_bucket *bucket;

net/core/sock_map.c

1336

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

net/core/sock_map.c

1337

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

net/core/sock_map.c

897

struct bpf_shtab_bucket *bucket;

net/core/sock_map.c

903

bucket = sock_hash_select_bucket(htab, hash);

net/core/sock_map.c

904

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

net/core/sock_map.c

921

struct bpf_shtab_bucket *bucket;

net/core/sock_map.c

924

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

net/core/sock_map.c

930

spin_lock_bh(&bucket->lock);

net/core/sock_map.c

931

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

net/core/sock_map.c

938

spin_unlock_bh(&bucket->lock);

net/core/sock_map.c

945

struct bpf_shtab_bucket *bucket;

net/core/sock_map.c

950

bucket = sock_hash_select_bucket(htab, hash);

net/core/sock_map.c

952

spin_lock_bh(&bucket->lock);

net/core/sock_map.c

953

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

net/core/sock_map.c

960

spin_unlock_bh(&bucket->lock);

net/core/sock_map.c

997

struct bpf_shtab_bucket *bucket;

net/ipv4/fib_semantics.c

1884

struct fnhe_hash_bucket *bucket;

net/ipv4/fib_semantics.c

1887

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

net/ipv4/fib_semantics.c

1888

if (!bucket)

net/ipv4/fib_semantics.c

1894

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

2361

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

net/ipv4/nexthop.c

2364

nhge = rtnl_dereference(bucket->nh_entry);

net/ipv4/nexthop.c

2379

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

net/ipv4/nexthop.c

2382

nhge = rtnl_dereference(bucket->nh_entry);

net/ipv4/nexthop.c

3746

struct nh_res_bucket *bucket;

net/ipv4/nexthop.c

3749

bucket = &res_table->nh_buckets[bucket_index];

net/ipv4/nexthop.c

3750

nhge = rtnl_dereference(bucket->nh_entry);

net/ipv4/nexthop.c

3759

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

net/ipv4/nexthop.c

4051

struct nh_res_bucket *bucket;

net/ipv4/nexthop.c

4069

bucket = &res_table->nh_buckets[bucket_index];

net/ipv4/nexthop.c

4070

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

net/ipv4/nexthop.c

4072

bucket->nh_flags |= RTNH_F_OFFLOAD;

net/ipv4/nexthop.c

4074

bucket->nh_flags |= RTNH_F_TRAP;

net/ipv4/ping.c

1021

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

net/ipv4/ping.c

1022

++state->bucket) {

net/ipv4/ping.c

1025

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

net/ipv4/ping.c

1051

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

net/ipv4/ping.c

1069

state->bucket = 0;

net/ipv4/ping.c

1105

int bucket)

net/ipv4/ping.c

1115

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

net/ipv4/ping.c

1135

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

net/ipv4/raw.c

1061

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

net/ipv4/raw.c

961

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

net/ipv4/raw.c

968

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

net/ipv4/raw.c

969

++state->bucket) {

net/ipv4/raw.c

970

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

net/ipv4/raw.c

988

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

net/ipv4/route.c

3087

struct fnhe_hash_bucket *bucket, int genid,

net/ipv4/route.c

3095

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

net/ipv4/route.c

3139

struct fnhe_hash_bucket *bucket;

net/ipv4/route.c

3146

bucket = rcu_dereference(nhc->nhc_exceptions);

net/ipv4/route.c

3148

if (bucket)

net/ipv4/route.c

3149

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

2558

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

net/ipv4/tcp_ipv4.c

2563

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

net/ipv4/tcp_ipv4.c

2601

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

net/ipv4/tcp_ipv4.c

2603

++st->bucket;

net/ipv4/tcp_ipv4.c

2612

st->bucket = 0;

net/ipv4/tcp_ipv4.c

2626

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

net/ipv4/tcp_ipv4.c

2639

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

net/ipv4/tcp_ipv4.c

2642

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

net/ipv4/tcp_ipv4.c

2651

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

net/ipv4/tcp_ipv4.c

2678

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

net/ipv4/tcp_ipv4.c

2679

++st->bucket;

net/ipv4/tcp_ipv4.c

2688

st->bucket = 0;

net/ipv4/tcp_ipv4.c

2718

int bucket = st->bucket;

net/ipv4/tcp_ipv4.c

2725

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

net/ipv4/tcp_ipv4.c

2728

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

net/ipv4/tcp_ipv4.c

2732

st->bucket = 0;

net/ipv4/tcp_ipv4.c

2736

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

net/ipv4/tcp_ipv4.c

2739

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

net/ipv4/tcp_ipv4.c

2761

st->bucket = 0;

net/ipv4/tcp_ipv4.c

2786

st->bucket = 0;

net/ipv4/tcp_ipv4.c

2810

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

net/ipv4/tcp_ipv4.c

2814

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

net/ipv4/tcp_ipv4.c

3048

int resume_bucket = st->bucket;

net/ipv4/tcp_ipv4.c

3052

++st->bucket;

net/ipv4/tcp_ipv4.c

3058

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

net/ipv4/tcp_ipv4.c

3062

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

net/ipv4/tcp_ipv4.c

3063

++st->bucket;

net/ipv4/tcp_ipv4.c

3078

int resume_bucket = st->bucket;

net/ipv4/tcp_ipv4.c

3082

++st->bucket;

net/ipv4/tcp_ipv4.c

3088

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

net/ipv4/tcp_ipv4.c

3092

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

net/ipv4/tcp_ipv4.c

3093

++st->bucket;

net/ipv4/tcp_ipv4.c

3112

st->bucket = 0;

net/ipv4/tcp_ipv4.c

3200

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

net/ipv4/tcp_ipv4.c

3202

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

net/ipv4/udp.c

3340

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

net/ipv4/udp.c

3341

++state->bucket) {

net/ipv4/udp.c

3342

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

net/ipv4/udp.c

3372

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

net/ipv4/udp.c

3373

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

net/ipv4/udp.c

3375

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

net/ipv4/udp.c

3393

state->bucket = MAX_UDP_PORTS;

net/ipv4/udp.c

3420

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

net/ipv4/udp.c

3421

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

net/ipv4/udp.c

3427

int bucket)

net/ipv4/udp.c

3437

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

net/ipv4/udp.c

3457

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

net/ipv4/udp.c

3468

int bucket __aligned(8);

net/ipv4/udp.c

3516

resume_bucket = state->bucket;

net/ipv4/udp.c

3520

state->bucket++;

net/ipv4/udp.c

3538

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

net/ipv4/udp.c

3539

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

net/ipv4/udp.c

3553

if (state->bucket == resume_bucket)

net/ipv4/udp.c

3653

struct udp_sock *udp_sk, uid_t uid, int bucket)

net/ipv4/udp.c

3661

ctx.bucket = bucket;

net/ipv4/udp.c

3687

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

net/ipv4/udp.c

3973

struct udp_sock *udp_sk, uid_t uid, int bucket)

net/ipv4/udp.c

4011

iter->state.bucket = -1;

net/ipv6/addrconf.c

4408

int bucket;

net/ipv6/addrconf.c

4421

state->bucket = 0;

net/ipv6/addrconf.c

4425

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

net/ipv6/addrconf.c

4426

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

net/ipv6/addrconf.c

4455

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

net/ipv6/addrconf.c

4457

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

net/ipv6/datagram.c

1060

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

net/ipv6/datagram.c

1069

bucket,

net/ipv6/ip6_flowlabel.c

746

int bucket;

net/ipv6/ip6_flowlabel.c

757

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

net/ipv6/ip6_flowlabel.c

758

for_each_fl_rcu(state->bucket, fl) {

net/ipv6/ip6_flowlabel.c

779

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

net/ipv6/ip6_flowlabel.c

780

for_each_fl_rcu(state->bucket, fl) {

net/ipv6/ping.c

238

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

net/ipv6/ping.c

242

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

net/ipv6/raw.c

1232

raw_seq_private(seq)->bucket);

net/ipv6/route.c

1504

static void rt6_remove_exception(struct rt6_exception_bucket *bucket,

net/ipv6/route.c

1509

if (!bucket || !rt6_ex)

net/ipv6/route.c

1523

WARN_ON_ONCE(!bucket->depth);

net/ipv6/route.c

1524

bucket->depth--;

net/ipv6/route.c

1530

static void rt6_exception_remove_oldest(struct rt6_exception_bucket *bucket)

net/ipv6/route.c

1534

if (!bucket)

net/ipv6/route.c

1537

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

net/ipv6/route.c

1541

rt6_remove_exception(bucket, oldest);

net/ipv6/route.c

1573

__rt6_find_exception_spinlock(struct rt6_exception_bucket **bucket,

net/ipv6/route.c

1580

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

net/ipv6/route.c

1584

*bucket += hval;

net/ipv6/route.c

1586

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

net/ipv6/route.c

1606

__rt6_find_exception_rcu(struct rt6_exception_bucket **bucket,

net/ipv6/route.c

1615

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

net/ipv6/route.c

1619

*bucket += hval;

net/ipv6/route.c

1621

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

net/ipv6/route.c

1668

struct rt6_exception_bucket *bucket;

net/ipv6/route.c

1671

bucket = rcu_dereference_protected(nh->rt6i_exception_bucket,

net/ipv6/route.c

1674

bucket = rcu_dereference(nh->rt6i_exception_bucket);

net/ipv6/route.c

1677

if (bucket) {

net/ipv6/route.c

1678

unsigned long p = (unsigned long)bucket;

net/ipv6/route.c

1681

bucket = (struct rt6_exception_bucket *)p;

net/ipv6/route.c

1684

return bucket;

net/ipv6/route.c

1687

static bool fib6_nh_excptn_bucket_flushed(struct rt6_exception_bucket *bucket)

net/ipv6/route.c

1689

unsigned long p = (unsigned long)bucket;

net/ipv6/route.c

1698

struct rt6_exception_bucket *bucket;

net/ipv6/route.c

1701

bucket = rcu_dereference_protected(nh->rt6i_exception_bucket,

net/ipv6/route.c

1704

p = (unsigned long)bucket;

net/ipv6/route.c

1706

bucket = (struct rt6_exception_bucket *)p;

net/ipv6/route.c

1707

rcu_assign_pointer(nh->rt6i_exception_bucket, bucket);

net/ipv6/route.c

1714

struct rt6_exception_bucket *bucket;

net/ipv6/route.c

1724

bucket = rcu_dereference_protected(nh->rt6i_exception_bucket,

net/ipv6/route.c

1726

if (!bucket) {

net/ipv6/route.c

1727

bucket = kzalloc_objs(*bucket, FIB6_EXCEPTION_BUCKET_SIZE,

net/ipv6/route.c

1729

if (!bucket) {

net/ipv6/route.c

1733

rcu_assign_pointer(nh->rt6i_exception_bucket, bucket);

net/ipv6/route.c

1734

} else if (fib6_nh_excptn_bucket_flushed(bucket)) {

net/ipv6/route.c

1758

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

net/ipv6/route.c

1761

rt6_remove_exception(bucket, rt6_ex);

net/ipv6/route.c

1770

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

net/ipv6/route.c

1771

bucket->depth++;

net/ipv6/route.c

1776

while (bucket->depth > max_depth)

net/ipv6/route.c

1777

rt6_exception_remove_oldest(bucket);

net/ipv6/route.c

1796

struct rt6_exception_bucket *bucket;

net/ipv6/route.c

1803

bucket = fib6_nh_get_excptn_bucket(nh, &rt6_exception_lock);

net/ipv6/route.c

1804

if (!bucket)

net/ipv6/route.c

1812

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

net/ipv6/route.c

1815

rt6_remove_exception(bucket, rt6_ex);

net/ipv6/route.c

1817

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

net/ipv6/route.c

1818

bucket++;

net/ipv6/route.c

1852

struct rt6_exception_bucket *bucket;

net/ipv6/route.c

1872

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

net/ipv6/route.c

1873

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

net/ipv6/route.c

1894

struct rt6_exception_bucket *bucket;

net/ipv6/route.c

1902

bucket = fib6_nh_get_excptn_bucket(nh, &rt6_exception_lock);

net/ipv6/route.c

1914

rt6_ex = __rt6_find_exception_spinlock(&bucket,

net/ipv6/route.c

1918

rt6_remove_exception(bucket, rt6_ex);

net/ipv6/route.c

1978

struct rt6_exception_bucket *bucket;

net/ipv6/route.c

1981

bucket = fib6_nh_get_excptn_bucket(nh, NULL);

net/ipv6/route.c

1992

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

net/ipv6/route.c

2077

struct rt6_exception_bucket *bucket;

net/ipv6/route.c

2081

bucket = fib6_nh_get_excptn_bucket(nh, &rt6_exception_lock);

net/ipv6/route.c

2082

if (!bucket)

net/ipv6/route.c

2086

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

net/ipv6/route.c

2097

bucket++;

net/ipv6/route.c

2106

struct rt6_exception_bucket *bucket;

net/ipv6/route.c

2115

bucket = fib6_nh_get_excptn_bucket(nh, &rt6_exception_lock);

net/ipv6/route.c

2116

if (bucket) {

net/ipv6/route.c

2119

&bucket->chain, hlist) {

net/ipv6/route.c

2126

rt6_remove_exception(bucket, rt6_ex);

net/ipv6/route.c

2129

bucket++;

net/ipv6/route.c

2136

static void rt6_age_examine_exception(struct rt6_exception_bucket *bucket,

net/ipv6/route.c

2153

rt6_remove_exception(bucket, rt6_ex);

net/ipv6/route.c

2158

rt6_remove_exception(bucket, rt6_ex);

net/ipv6/route.c

2170

rt6_remove_exception(bucket, rt6_ex);

net/ipv6/route.c

2182

struct rt6_exception_bucket *bucket;

net/ipv6/route.c

2192

bucket = fib6_nh_get_excptn_bucket(nh, &rt6_exception_lock);

net/ipv6/route.c

2193

if (bucket) {

net/ipv6/route.c

2196

&bucket->chain, hlist) {

net/ipv6/route.c

2197

rt6_age_examine_exception(bucket, rt6_ex,

net/ipv6/route.c

2200

bucket++;

net/ipv6/route.c

3709

struct rt6_exception_bucket *bucket;

net/ipv6/route.c

3714

bucket = fib6_nh_get_excptn_bucket(fib6_nh, NULL);

net/ipv6/route.c

3715

if (bucket) {

net/ipv6/route.c

3717

kfree(bucket);

net/ipv6/route.c

6002

struct rt6_exception_bucket *bucket;

net/ipv6/route.c

6006

bucket = fib6_nh_get_excptn_bucket(nh, NULL);

net/ipv6/route.c

6007

if (!bucket)

net/ipv6/route.c

6011

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

net/ipv6/route.c

6043

bucket++;

net/ipv6/udp.c

1865

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

net/ipv6/udp.c

1870

udp_rqueue_get(v), bucket);

net/llc/llc_proc.c

67

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

net/llc/llc_proc.c

72

while (++bucket < LLC_SK_LADDR_HASH_ENTRIES)

net/llc/llc_proc.c

73

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

net/mac80211/mesh.c

189

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

net/mac80211/mesh.c

204

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

net/mac80211/mesh.c

243

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

net/mac80211/mesh.c

261

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

88

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

net/netfilter/ipset/ip_set_hash_gen.h

91

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

net/netfilter/ipvs/ip_vs_conn.c

1048

unsigned int bucket;

net/netfilter/ipvs/ip_vs_conn.c

1057

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

net/netfilter/ipvs/ip_vs_conn.c

1065

iter->bucket = idx;

net/netfilter/ipvs/ip_vs_conn.c

1076

iter->bucket = idx;

net/netfilter/ipvs/ip_vs_conn.c

1088

iter->bucket = 0;

net/netfilter/ipvs/ip_vs_conn.c

1113

iter->bucket++;

net/netfilter/ipvs/ip_vs_ctl.c

2275

int bucket;

net/netfilter/ipvs/ip_vs_ctl.c

2311

iter->bucket = idx;

net/netfilter/ipvs/ip_vs_ctl.c

2323

iter->bucket = idx;

net/netfilter/ipvs/ip_vs_ctl.c

2359

while (++iter->bucket < IP_VS_SVC_TAB_SIZE) {

net/netfilter/ipvs/ip_vs_ctl.c

2361

&ip_vs_svc_table[iter->bucket],

net/netfilter/ipvs/ip_vs_ctl.c

2368

iter->bucket = -1;

net/netfilter/ipvs/ip_vs_ctl.c

2378

while (++iter->bucket < IP_VS_SVC_TAB_SIZE) {

net/netfilter/ipvs/ip_vs_ctl.c

2380

&ip_vs_svc_fwm_table[iter->bucket],

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

1468

unsigned int i, bucket;

net/netfilter/nf_conntrack_core.c

1477

bucket = reciprocal_scale(hash, hsize);

net/netfilter/nf_conntrack_core.c

1479

bucket = (bucket + 1) % hsize;

net/netfilter/nf_conntrack_core.c

1481

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

net/netfilter/nf_conntrack_core.c

2310

const struct nf_ct_iter_data *iter_data, unsigned int *bucket)

net/netfilter/nf_conntrack_core.c

2317

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

net/netfilter/nf_conntrack_core.c

2318

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

net/netfilter/nf_conntrack_core.c

2323

lockp = &nf_conntrack_locks[*bucket % CONNTRACK_LOCKS];

net/netfilter/nf_conntrack_core.c

2365

unsigned int bucket = 0;

net/netfilter/nf_conntrack_core.c

2371

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

net/netfilter/nf_conntrack_core.c

2550

int i, bucket;

net/netfilter/nf_conntrack_core.c

2591

bucket = __hash_conntrack(nf_ct_net(ct),

net/netfilter/nf_conntrack_core.c

2593

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

net/netfilter/nf_conntrack_core.c

741

unsigned int bucket, hsize;

net/netfilter/nf_conntrack_core.c

745

bucket = reciprocal_scale(hash, hsize);

net/netfilter/nf_conntrack_core.c

747

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

net/netfilter/nf_conntrack_core.c

764

if (get_nulls_value(n) != bucket) {

net/netfilter/nf_conntrack_expect.c

592

unsigned int bucket;

net/netfilter/nf_conntrack_expect.c

600

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

net/netfilter/nf_conntrack_expect.c

601

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

net/netfilter/nf_conntrack_expect.c

615

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

net/netfilter/nf_conntrack_expect.c

617

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

net/netfilter/nf_conntrack_standalone.c

109

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

net/netfilter/nf_conntrack_standalone.c

134

st->bucket = i;

net/netfilter/nf_conntrack_standalone.c

145

st->bucket = i;

net/netfilter/nf_conntrack_standalone.c

162

st->bucket = 0;

net/netfilter/nf_conntrack_standalone.c

98

unsigned int bucket;

net/netfilter/nfnetlink_log.c

1022

unsigned int bucket;

net/netfilter/nfnetlink_log.c

1033

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

net/netfilter/nfnetlink_log.c

1034

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

net/netfilter/nfnetlink_log.c

1050

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

net/netfilter/nfnetlink_log.c

1054

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

net/netfilter/nfnetlink_queue.c

1715

unsigned int bucket;

net/netfilter/nfnetlink_queue.c

1729

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

net/netfilter/nfnetlink_queue.c

1730

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

net/netfilter/nfnetlink_queue.c

1731

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

net/netfilter/nfnetlink_queue.c

1745

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

net/netfilter/nfnetlink_queue.c

1749

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

1058

unsigned int *bucket;

net/netfilter/xt_hashlimit.c

1064

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

net/netfilter/xt_hashlimit.c

1065

if (!bucket)

net/netfilter/xt_hashlimit.c

1068

*bucket = *pos;

net/netfilter/xt_hashlimit.c

1069

return bucket;

net/netfilter/xt_hashlimit.c

1075

unsigned int *bucket = v;

net/netfilter/xt_hashlimit.c

1077

*pos = ++(*bucket);

net/netfilter/xt_hashlimit.c

1082

return bucket;

net/netfilter/xt_hashlimit.c

1089

unsigned int *bucket = v;

net/netfilter/xt_hashlimit.c

1091

if (!IS_ERR(bucket))

net/netfilter/xt_hashlimit.c

1092

kfree(bucket);

net/netfilter/xt_hashlimit.c

1175

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

net/netfilter/xt_hashlimit.c

1178

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

net/netfilter/xt_hashlimit.c

1179

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

net/netfilter/xt_hashlimit.c

1189

unsigned int *bucket = v;

net/netfilter/xt_hashlimit.c

1192

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

net/netfilter/xt_hashlimit.c

1193

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

net/netfilter/xt_hashlimit.c

1203

unsigned int *bucket = v;

net/netfilter/xt_hashlimit.c

1206

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

net/netfilter/xt_hashlimit.c

1207

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

1508

u32 bucket, obj;

net/openvswitch/datapath.c

1510

bucket = cb->args[0];

net/openvswitch/datapath.c

1512

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

net/openvswitch/datapath.c

1522

cb->args[0] = bucket;

net/openvswitch/datapath.c

2516

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

net/openvswitch/datapath.c

2525

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

329

static struct sk_buff *dequeue_head(struct wdrr_bucket *bucket)

net/sched/sch_hhf.c

331

struct sk_buff *skb = bucket->head;

net/sched/sch_hhf.c

333

bucket->head = skb->next;

net/sched/sch_hhf.c

339

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

net/sched/sch_hhf.c

341

if (bucket->head == NULL)

net/sched/sch_hhf.c

342

bucket->head = skb;

net/sched/sch_hhf.c

344

bucket->tail->next = skb;

net/sched/sch_hhf.c

345

bucket->tail = skb;

net/sched/sch_hhf.c

352

struct wdrr_bucket *bucket;

net/sched/sch_hhf.c

355

bucket = &q->buckets[WDRR_BUCKET_FOR_HH];

net/sched/sch_hhf.c

356

if (!bucket->head)

net/sched/sch_hhf.c

357

bucket = &q->buckets[WDRR_BUCKET_FOR_NON_HH];

net/sched/sch_hhf.c

359

if (bucket->head) {

net/sched/sch_hhf.c

360

struct sk_buff *skb = dequeue_head(bucket);

net/sched/sch_hhf.c

368

return bucket - q->buckets;

net/sched/sch_hhf.c

376

struct wdrr_bucket *bucket;

net/sched/sch_hhf.c

381

bucket = &q->buckets[idx];

net/sched/sch_hhf.c

382

bucket_add(bucket, skb);

net/sched/sch_hhf.c

385

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

net/sched/sch_hhf.c

395

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

net/sched/sch_hhf.c

398

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

net/sched/sch_hhf.c

400

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

net/sched/sch_hhf.c

422

struct wdrr_bucket *bucket;

net/sched/sch_hhf.c

432

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

net/sched/sch_hhf.c

434

if (bucket->deficit <= 0) {

net/sched/sch_hhf.c

435

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

net/sched/sch_hhf.c

438

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

net/sched/sch_hhf.c

439

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

net/sched/sch_hhf.c

443

if (bucket->head) {

net/sched/sch_hhf.c

444

skb = dequeue_head(bucket);

net/sched/sch_hhf.c

452

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

net/sched/sch_hhf.c

454

list_del_init(&bucket->bucketchain);

net/sched/sch_hhf.c

458

bucket->deficit -= qdisc_pkt_len(skb);

net/sched/sch_hhf.c

647

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

net/sched/sch_hhf.c

649

INIT_LIST_HEAD(&bucket->bucketchain);

net/unix/af_unix.c

3454

unsigned long bucket = get_bucket(*pos);

net/unix/af_unix.c

3458

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

net/unix/af_unix.c

3469

unsigned long bucket = get_bucket(*pos);

net/unix/af_unix.c

3473

while (bucket < UNIX_HASH_SIZE) {

net/unix/af_unix.c

3474

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

net/unix/af_unix.c

3480

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

net/unix/af_unix.c

3482

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

net/unix/af_unix.c

3491

unsigned long bucket = get_bucket(*pos);

net/unix/af_unix.c

3498

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

net/unix/af_unix.c

3500

*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

194

vdso_info.bucket = &hash[2];

tools/testing/selftests/vDSO/parse_vdso.c

289

i = vdso_info.bucket[elf_hash(name) % vdso_info.nbucket];

tools/testing/selftests/vDSO/parse_vdso.c

58

ELF_HASH_ENTRY *bucket, *chain;

tools/tracing/rtla/src/osnoise_hist.c

106

int bucket;

tools/tracing/rtla/src/osnoise_hist.c

112

bucket = duration / data->bucket_size;

tools/tracing/rtla/src/osnoise_hist.c

122

if (bucket < entries)

tools/tracing/rtla/src/osnoise_hist.c

123

hist[bucket] += count;

tools/tracing/rtla/src/osnoise_hist.c

342

int bucket, cpu;

tools/tracing/rtla/src/osnoise_hist.c

347

for (bucket = 0; bucket < data->entries; bucket++) {

tools/tracing/rtla/src/osnoise_hist.c

352

bucket * data->bucket_size);

tools/tracing/rtla/src/osnoise_hist.c

359

total += data->hist[cpu].samples[bucket];

tools/tracing/rtla/src/osnoise_hist.c

360

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

144

int bucket;

tools/tracing/rtla/src/timerlat_hist.c

150

bucket = latency / data->bucket_size;

tools/tracing/rtla/src/timerlat_hist.c

172

if (bucket < entries)

tools/tracing/rtla/src/timerlat_hist.c

173

hist[bucket]++;

tools/tracing/rtla/src/timerlat_hist.c

618

int bucket, cpu;

tools/tracing/rtla/src/timerlat_hist.c

623

for (bucket = 0; bucket < data->entries; bucket++) {

tools/tracing/rtla/src/timerlat_hist.c

628

bucket * data->bucket_size);

tools/tracing/rtla/src/timerlat_hist.c

636

total += data->hist[cpu].irq[bucket];

tools/tracing/rtla/src/timerlat_hist.c

638

data->hist[cpu].irq[bucket]);

tools/tracing/rtla/src/timerlat_hist.c

642

total += data->hist[cpu].thread[bucket];

tools/tracing/rtla/src/timerlat_hist.c

644

data->hist[cpu].thread[bucket]);

tools/tracing/rtla/src/timerlat_hist.c

648

total += data->hist[cpu].user[bucket];

tools/tracing/rtla/src/timerlat_hist.c

650

data->hist[cpu].user[bucket]);