htable
asmlinkage void gcm_init_htable(unsigned char htable[], unsigned char Xi[]);
hash_add_rcu(vxlan->htable, &vxlanp->hlist, port);
hash_init(vxlan->htable);
WARN_ON(!hash_empty(vxlan->htable));
hash_for_each_safe(vxlan->htable, bkt, tmp, vxlanp, hlist) {
DECLARE_HASHTABLE(htable, 4);
hash_for_each_possible_rcu(vxlan->htable, vxlanp, hlist, port)
hash_for_each_possible(vxlan->htable, vxlanp, hlist, port)
u32 *htable, hash, flag_count = 0;
htable = kvcalloc(LZ77_HASH_SIZE, sizeof(*htable), GFP_KERNEL);
if (!htable)
htable[hash] = 0;
match = src + htable[cur_hash];
htable[cur_hash] = srcp - src;
kvfree(htable);
u64 htable[4][2];
hash_init((p)->htable##b); \
hash_for_each_possible(p->htable##b, _n, node, p->data##b[n]) { \
hash_add((p)->htable##b, &_n->node, _n->data); \
void gcm_init_p8(u64 htable[4][2], const u8 h[16]);
void gcm_gmult_p8(u8 Xi[16], const u64 htable[4][2]);
void gcm_ghash_p8(u8 Xi[16], const u64 htable[4][2], const u8 *in, size_t len);
gcm_init_p8(key->htable, raw_key);
key->htable[0][0] = 0;
key->htable[0][1] = 0xc200000000000000;
key->htable[1][0] = 0;
key->htable[1][1] = le64_to_cpu(key->h.lo);
key->htable[2][0] = le64_to_cpu(key->h.lo);
key->htable[2][1] = le64_to_cpu(key->h.hi);
key->htable[3][0] = le64_to_cpu(key->h.hi);
key->htable[3][1] = 0;
gcm_gmult_p8(ghash_acc, key->htable);
gcm_ghash_p8(ghash_acc, key->htable, data,
struct htable *t;
if ((INT_MAX - sizeof(struct htable)) / sizeof(struct hbucket *)
struct htable *t = rcu_dereference_bh(h->table);
return hsize * sizeof(struct hbucket *) + sizeof(struct htable);
struct htable *t;
const struct htable *t;
struct htable *t;
t = (struct htable *)cb->args[IPSET_CB_PRIVATE];
const struct htable *t;
t = (const struct htable *)cb->args[IPSET_CB_PRIVATE];
struct htable *t;
struct htable __rcu *table; /* the hash table */
mtype_ahash_memsize(const struct htype *h, const struct htable *t)
struct htable *t;
mtype_ahash_destroy(struct ip_set *set, struct htable *t, bool ext_destroy)
struct htable *t = (__force struct htable *)h->table;
mtype_gc_do(struct ip_set *set, struct htype *h, struct htable *t, u32 r)
struct htable *t;
struct htable *t, *orig;
const struct htable *t;
struct htable *t;
__acquires(htable->lock)
struct xt_hashlimit_htable *htable = pde_data(file_inode(s->file));
spin_lock_bh(&htable->lock);
if (*pos >= htable->cfg.size)
struct xt_hashlimit_htable *htable = pde_data(file_inode(s->file));
if (*pos >= htable->cfg.size) {
__releases(htable->lock)
struct xt_hashlimit_htable *htable = pde_data(file_inode(s->file));
spin_unlock_bh(&htable->lock);
struct xt_hashlimit_htable *htable = pde_data(file_inode(s->file));
if (!hlist_empty(&htable->hash[*bucket])) {
hlist_for_each_entry(ent, &htable->hash[*bucket], node)
if (dl_seq_real_show_v2(ent, htable->family, s))
struct xt_hashlimit_htable *htable = pde_data(file_inode(s->file));
if (!hlist_empty(&htable->hash[*bucket])) {
hlist_for_each_entry(ent, &htable->hash[*bucket], node)
if (dl_seq_real_show_v1(ent, htable->family, s))
struct xt_hashlimit_htable *htable = pde_data(file_inode(s->file));
if (!hlist_empty(&htable->hash[*bucket])) {
hlist_for_each_entry(ent, &htable->hash[*bucket], node)
if (dl_seq_real_show(ent, htable->family, s))
struct hlist_head *htable;
htable = rcu_dereference(ima_htable);
hlist_for_each_entry_rcu(qe, &htable[key], hnext) {
struct hlist_head *htable;
htable = rcu_dereference_protected(ima_htable,
hlist_add_head_rcu(&qe->hnext, &htable[key]);
newnode = avtab_insert_node(h, prev ? &prev->next : &h->htable[hvalue],
for (prev = NULL, cur = h->htable[hvalue]; cur;
return avtab_insert_node(h, prev ? &prev->next : &h->htable[hvalue],
for (cur = h->htable[hvalue]; cur; cur = cur->next) {
cur = h->htable[i];
kvfree(h->htable);
h->htable = NULL;
h->htable = NULL;
h->htable = kvcalloc(nslot, sizeof(void *), GFP_KERNEL);
if (!h->htable)
cur = h->htable[i];
for (cur = a->htable[i]; cur; cur = cur->next) {
for (prev = NULL, cur = h->htable[hvalue]; cur;
struct avtab_node **htable;
cur = h->htable[i];
new->htable = kzalloc_objs(*new->htable, orig->size);
if (!new->htable)
for (orig_cur = orig->htable[i]; orig_cur;
new->htable[i] = tmp;
for (cur = new->htable[i]; cur; cur = tmp) {
kfree(new->htable);
h->htable = NULL;
h->htable = kzalloc_objs(*h->htable, size,
if (!h->htable)
cur = h->htable[i];
h->htable[i] = NULL;
kfree(h->htable);
h->htable = NULL;
cur = h->htable[i];
cur = h->htable[hvalue];
struct hashtab_node **htable; /* hash table */
cur = h->htable[hvalue];
return __hashtab_insert(h, prev ? &prev->next : &h->htable[hvalue], key,