Lines Matching refs:elem
214 * extra elem. LRU itself can remove the least used element, so
215 * there is no need for an extra elem during map_update.
231 struct htab_elem *elem;
233 elem = get_htab_elem(htab, i);
235 htab_elem_value(elem, htab->map.key_size));
254 struct htab_elem *elem;
256 elem = get_htab_elem(htab, i);
258 void __percpu *pptr = htab_elem_get_ptr(elem, htab->map.key_size);
267 htab_elem_value(elem, htab->map.key_size));
474 struct htab_elem *elem = obj;
480 map_value = htab_elem_value(elem, hrec->key_size);
859 struct htab_elem *elem)
865 void __percpu *pptr = htab_elem_get_ptr(elem, htab->map.key_size);
871 void *map_value = htab_elem_value(elem, htab->map.key_size);
943 /* if next elem in this hash list is non-zero, just return it */
1084 else /* Since elem is preallocated, we cannot touch special fields */
1184 /* elem already exists */
1188 /* elem doesn't exist, cannot update it */
1274 * concurrent search will find it before old elem
1295 static void htab_lru_push_free(struct bpf_htab *htab, struct htab_elem *elem)
1297 check_and_cancel_fields(htab, elem);
1299 bpf_lru_push_free(&htab->lru, &elem->lru_node);
1347 * concurrent search will find it before old elem
1466 * spinlock because LRU's elem alloc may need
1467 * to remove older elem from htab and this removal
2138 struct htab_elem *elem;
2145 /* try to find next elem in the same bucket */
2151 elem = hlist_nulls_entry_safe(n, struct htab_elem, hash_node);
2152 if (elem)
2153 return elem;
2167 hlist_nulls_for_each_entry_rcu(elem, n, head, hash_node) {
2171 return elem;
2188 struct htab_elem *elem;
2190 elem = bpf_hash_map_seq_find_next(info, NULL);
2191 if (!elem)
2196 return elem;
2208 static int __bpf_hash_map_seq_show(struct seq_file *seq, struct htab_elem *elem)
2220 prog = bpf_iter_get_info(&meta, elem == NULL);
2224 if (elem) {
2225 ctx.key = elem->key;
2227 ctx.value = htab_elem_value(elem, map->key_size);
2230 pptr = htab_elem_get_ptr(elem, map->key_size);
2311 struct htab_elem *elem;
2334 hlist_nulls_for_each_entry_safe(elem, n, head, hash_node) {
2335 key = elem->key;
2338 pptr = htab_elem_get_ptr(elem, map->key_size);
2341 val = htab_elem_value(elem, map->key_size);
2910 struct rhtab_elem *elem = obj;
2916 rhtab_elem_value(elem, hrec->key_size));
2922 struct rhtab_elem *elem = ptr;
2924 bpf_map_free_internal_structs(&rhtab->map, rhtab_elem_value(elem, rhtab->map.key_size));
2925 bpf_mem_cache_free_rcu(&rhtab->ma, elem);
2958 static void rhtab_read_elem_value(struct bpf_map *map, void *dst, struct rhtab_elem *elem,
2961 void *src = rhtab_elem_value(elem, map->key_size);
2969 static int rhtab_delete_elem(struct bpf_rhtab *rhtab, struct rhtab_elem *elem, void *copy,
2983 err = rhashtable_remove_fast(&rhtab->ht, &elem->node, rhtab_params_long);
2985 err = rhashtable_remove_fast(&rhtab->ht, &elem->node, rhtab_params);
2993 rhtab_read_elem_value(&rhtab->map, copy, elem, flags);
2997 rhtab_elem_value(elem, rhtab->map.key_size));
2998 bpf_mem_cache_free_rcu(&rhtab->ma, elem);
3005 struct rhtab_elem *elem;
3009 elem = rhtab_lookup_elem(map, key);
3010 if (!elem)
3013 return rhtab_delete_elem(rhtab, elem, NULL, 0);
3019 struct rhtab_elem *elem;
3028 elem = rhtab_lookup_elem(map, key);
3029 if (!elem)
3032 return rhtab_delete_elem(rhtab, elem, value, flags);
3035 static long rhtab_map_update_existing(struct bpf_map *map, struct rhtab_elem *elem, void *value,
3038 void *old_val = rhtab_elem_value(elem, map->key_size);
3064 struct rhtab_elem *elem, *tmp;
3073 elem = rhtab_lookup_elem(map, key);
3074 if (elem)
3075 return rhtab_map_update_existing(map, elem, value, map_flags);
3092 elem = bpf_mem_cache_alloc(&rhtab->ma);
3093 if (!elem)
3096 memcpy(elem->data, key, map->key_size);
3097 copy_map_value(map, rhtab_elem_value(elem, map->key_size), value);
3103 tmp = rhashtable_lookup_get_insert_fast(&rhtab->ht, &elem->node, rhtab_params_long);
3105 tmp = rhashtable_lookup_get_insert_fast(&rhtab->ht, &elem->node, rhtab_params);
3110 bpf_mem_cache_free(&rhtab->ma, elem);
3151 struct rhtab_elem *elem;
3167 while ((elem = rhashtable_walk_next(&iter))) {
3168 if (IS_ERR(elem)) {
3169 if (PTR_ERR(elem) == -EAGAIN)
3174 bpf_map_free_internal_structs(map, rhtab_elem_value(elem, map->key_size));
3192 struct rhtab_elem *elem;
3194 elem = rhashtable_next_key(&rhtab->ht, key);
3197 if (PTR_ERR(elem) == -ENOENT)
3198 elem = rhashtable_next_key(&rhtab->ht, NULL);
3200 if (IS_ERR(elem))
3201 return PTR_ERR(elem);
3202 if (!elem)
3205 memcpy(next_key, elem->data, map->key_size);
3231 struct rhtab_elem *elem;
3246 while ((elem = rhashtable_next_key(&rhtab->ht, prev_key))) {
3247 if (IS_ERR(elem))
3251 (u64)(long)elem->data,
3252 (u64)(long)rhtab_elem_value(elem, map->key_size),
3257 prev_key = elem->data; /* valid while RCU held */
3287 struct rhtab_elem *elem;
3342 elem = rhtab_lookup_elem(map, cursor);
3343 if (!elem) {
3349 elem = rhashtable_next_key(&rhtab->ht, NULL);
3352 while (elem && !IS_ERR(elem) && total < max_count) {
3353 memcpy(dst_key, elem->data, key_size);
3354 rhtab_read_elem_value(map, dst_val, elem, elem_map_flags);
3358 del_elems[total] = elem;
3360 elem = rhashtable_next_key(&rhtab->ht, dst_key);
3370 if (elem && !IS_ERR(elem)) {
3372 memcpy(cursor, elem->data, key_size);
3434 struct rhtab_elem *elem;
3443 elem = rhashtable_walk_peek(&info->iter);
3444 } while (PTR_ERR(elem) == -EAGAIN);
3446 if (IS_ERR(elem))
3449 if (elem && *pos == 0)
3451 return elem;
3457 struct rhtab_elem *elem;
3463 elem = rhashtable_walk_next(&info->iter);
3464 } while (PTR_ERR(elem) == -EAGAIN);
3466 if (IS_ERR(elem))
3468 return elem;
3472 struct rhtab_elem *elem)
3481 prog = bpf_iter_get_info(&meta, elem == NULL);
3485 if (elem) {
3486 ctx.key = elem->data;
3487 ctx.value = rhtab_elem_value(elem, info->map->key_size);