bpf: hashtab memory usage

htab_map_mem_usage() is introduced to calculate hashmap memory usage. In
this helper, some small memory allocations are ignore, as their size is
quite small compared with the total size. The inner_map_meta in
hash_of_map is also ignored.

The result for hashtab as follows,

- before this change
1: hash  name count_map  flags 0x1  <<<< no prealloc, fully set
        key 16B  value 24B  max_entries 1048576  memlock 41943040B
2: hash  name count_map  flags 0x1  <<<< no prealloc, none set
        key 16B  value 24B  max_entries 1048576  memlock 41943040B
3: hash  name count_map  flags 0x0  <<<< prealloc
        key 16B  value 24B  max_entries 1048576  memlock 41943040B

The memlock is always a fixed size whatever it is preallocated or
not, and whatever the count of allocated elements is.

- after this change
1: hash  name count_map  flags 0x1    <<<< non prealloc, fully set
        key 16B  value 24B  max_entries 1048576  memlock 117441536B
2: hash  name count_map  flags 0x1    <<<< non prealloc, non set
        key 16B  value 24B  max_entries 1048576  memlock 16778240B
3: hash  name count_map  flags 0x0    <<<< prealloc
        key 16B  value 24B  max_entries 1048576  memlock 109056000B

The memlock now is hashtab actually allocated.

The result for percpu hash map as follows,
- before this change
4: percpu_hash  name count_map  flags 0x0       <<<< prealloc
        key 16B  value 24B  max_entries 1048576  memlock 822083584B
5: percpu_hash  name count_map  flags 0x1       <<<< no prealloc
        key 16B  value 24B  max_entries 1048576  memlock 822083584B

- after this change
4: percpu_hash  name count_map  flags 0x0
        key 16B  value 24B  max_entries 1048576  memlock 897582080B
5: percpu_hash  name count_map  flags 0x1
        key 16B  value 24B  max_entries 1048576  memlock 922748736B

At worst, the difference can be 10x, for example,
- before this change
6: hash  name count_map  flags 0x0
        key 4B  value 4B  max_entries 1048576  memlock 8388608B

- after this change
6: hash  name count_map  flags 0x0
        key 4B  value 4B  max_entries 1048576  memlock 83889408B

Signed-off-by: Yafang Shao <laoar.shao@gmail.com>
Acked-by: Hou Tao <houtao1@huawei.com>
Link: https://lore.kernel.org/r/20230305124615.12358-4-laoar.shao@gmail.com
Signed-off-by: Alexei Starovoitov <ast@kernel.org>

diff --git a/kernel/bpf/hashtab.c b/kernel/bpf/hashtab.c
index 653aeb481c794b0ebc7c1b1eb3e888ced14ff3e8..0df4b0c10f5954141b84be871227d899e746de16 100644 (file)
--- a/kernel/bpf/hashtab.c
+++ b/kernel/bpf/hashtab.c
@@ -2190,6 +2190,44 @@ out:
        return num_elems;
 }
 
+static u64 htab_map_mem_usage(const struct bpf_map *map)
+{
+       struct bpf_htab *htab = container_of(map, struct bpf_htab, map);
+       u32 value_size = round_up(htab->map.value_size, 8);
+       bool prealloc = htab_is_prealloc(htab);
+       bool percpu = htab_is_percpu(htab);
+       bool lru = htab_is_lru(htab);
+       u64 num_entries;
+       u64 usage = sizeof(struct bpf_htab);
+
+       usage += sizeof(struct bucket) * htab->n_buckets;
+       usage += sizeof(int) * num_possible_cpus() * HASHTAB_MAP_LOCK_COUNT;
+       if (prealloc) {
+               num_entries = map->max_entries;
+               if (htab_has_extra_elems(htab))
+                       num_entries += num_possible_cpus();
+
+               usage += htab->elem_size * num_entries;
+
+               if (percpu)
+                       usage += value_size * num_possible_cpus() * num_entries;
+               else if (!lru)
+                       usage += sizeof(struct htab_elem *) * num_possible_cpus();
+       } else {
+#define LLIST_NODE_SZ sizeof(struct llist_node)
+
+               num_entries = htab->use_percpu_counter ?
+                                         percpu_counter_sum(&htab->pcount) :
+                                         atomic_read(&htab->count);
+               usage += (htab->elem_size + LLIST_NODE_SZ) * num_entries;
+               if (percpu) {
+                       usage += (LLIST_NODE_SZ + sizeof(void *)) * num_entries;
+                       usage += value_size * num_possible_cpus() * num_entries;
+               }
+       }
+       return usage;
+}
+
 BTF_ID_LIST_SINGLE(htab_map_btf_ids, struct, bpf_htab)
 const struct bpf_map_ops htab_map_ops = {
        .map_meta_equal = bpf_map_meta_equal,
@@ -2206,6 +2244,7 @@ const struct bpf_map_ops htab_map_ops = {
        .map_seq_show_elem = htab_map_seq_show_elem,
        .map_set_for_each_callback_args = map_set_for_each_callback_args,
        .map_for_each_callback = bpf_for_each_hash_elem,
+       .map_mem_usage = htab_map_mem_usage,
        BATCH_OPS(htab),
        .map_btf_id = &htab_map_btf_ids[0],
        .iter_seq_info = &iter_seq_info,
@@ -2227,6 +2266,7 @@ const struct bpf_map_ops htab_lru_map_ops = {
        .map_seq_show_elem = htab_map_seq_show_elem,
        .map_set_for_each_callback_args = map_set_for_each_callback_args,
        .map_for_each_callback = bpf_for_each_hash_elem,
+       .map_mem_usage = htab_map_mem_usage,
        BATCH_OPS(htab_lru),
        .map_btf_id = &htab_map_btf_ids[0],
        .iter_seq_info = &iter_seq_info,
@@ -2378,6 +2418,7 @@ const struct bpf_map_ops htab_percpu_map_ops = {
        .map_seq_show_elem = htab_percpu_map_seq_show_elem,
        .map_set_for_each_callback_args = map_set_for_each_callback_args,
        .map_for_each_callback = bpf_for_each_hash_elem,
+       .map_mem_usage = htab_map_mem_usage,
        BATCH_OPS(htab_percpu),
        .map_btf_id = &htab_map_btf_ids[0],
        .iter_seq_info = &iter_seq_info,
@@ -2397,6 +2438,7 @@ const struct bpf_map_ops htab_lru_percpu_map_ops = {
        .map_seq_show_elem = htab_percpu_map_seq_show_elem,
        .map_set_for_each_callback_args = map_set_for_each_callback_args,
        .map_for_each_callback = bpf_for_each_hash_elem,
+       .map_mem_usage = htab_map_mem_usage,
        BATCH_OPS(htab_lru_percpu),
        .map_btf_id = &htab_map_btf_ids[0],
        .iter_seq_info = &iter_seq_info,
@@ -2534,6 +2576,7 @@ const struct bpf_map_ops htab_of_maps_map_ops = {
        .map_fd_sys_lookup_elem = bpf_map_fd_sys_lookup_elem,
        .map_gen_lookup = htab_of_map_gen_lookup,
        .map_check_btf = map_check_no_btf,
+       .map_mem_usage = htab_map_mem_usage,
        BATCH_OPS(htab),
        .map_btf_id = &htab_map_btf_ids[0],
 };