[PATCH bpf-next 13/35] bpf: eliminate rlimit-based memory accounting for arraymap maps

[Roman Gushchin]

Do not use rlimit-based memory accounting for arraymap maps.
It has been replaced with the memcg-based memory accounting.

Signed-off-by: Roman Gushchin <g...@fb.com>
---
 kernel/bpf/arraymap.c | 24 ++++--------------------
 1 file changed, 4 insertions(+), 20 deletions(-)

diff --git a/kernel/bpf/arraymap.c b/kernel/bpf/arraymap.c
index 9597fecff8da..41581c38b31d 100644
--- a/kernel/bpf/arraymap.c
+++ b/kernel/bpf/arraymap.c
@@ -75,11 +75,10 @@ int array_map_alloc_check(union bpf_attr *attr)
 static struct bpf_map *array_map_alloc(union bpf_attr *attr)
 {
        bool percpu = attr->map_type == BPF_MAP_TYPE_PERCPU_ARRAY;
-       int ret, numa_node = bpf_map_attr_numa_node(attr);
+       int numa_node = bpf_map_attr_numa_node(attr);
        u32 elem_size, index_mask, max_entries;
        bool bypass_spec_v1 = bpf_bypass_spec_v1();
-       u64 cost, array_size, mask64;
-       struct bpf_map_memory mem;
+       u64 array_size, mask64;
        struct bpf_array *array;
 
        elem_size = round_up(attr->value_size, 8);
@@ -120,44 +119,29 @@ static struct bpf_map *array_map_alloc(union bpf_attr 
*attr)
                }
        }
 
-       /* make sure there is no u32 overflow later in round_up() */
-       cost = array_size;
-       if (percpu)
-               cost += (u64)attr->max_entries * elem_size * 
num_possible_cpus();
-
-       ret = bpf_map_charge_init(&mem, cost);
-       if (ret < 0)
-               return ERR_PTR(ret);
-
        /* allocate all map elements and zero-initialize them */
        if (attr->map_flags & BPF_F_MMAPABLE) {
                void *data;
 
                /* kmalloc'ed memory can't be mmap'ed, use explicit vmalloc */
                data = bpf_map_area_mmapable_alloc(array_size, numa_node);
-               if (!data) {
-                       bpf_map_charge_finish(&mem);
+               if (!data)
                        return ERR_PTR(-ENOMEM);
-               }
                array = data + PAGE_ALIGN(sizeof(struct bpf_array))
                        - offsetof(struct bpf_array, value);
        } else {
                array = bpf_map_area_alloc(array_size, numa_node);
        }
-       if (!array) {
-               bpf_map_charge_finish(&mem);
+       if (!array)
                return ERR_PTR(-ENOMEM);
-       }
        array->index_mask = index_mask;
        array->map.bypass_spec_v1 = bypass_spec_v1;
 
        /* copy mandatory map attributes */
        bpf_map_init_from_attr(&array->map, attr);
-       bpf_map_charge_move(&array->map.memory, &mem);
        array->elem_size = elem_size;
 
        if (percpu && bpf_array_alloc_percpu(array)) {
-               bpf_map_charge_finish(&array->map.memory);
                bpf_map_area_free(array);
                return ERR_PTR(-ENOMEM);
        }
-- 
2.26.2