bpf: Eliminate rlimit-based memory accounting infra for bpf maps

[linux-2.6-microblaze.git] / kernel / bpf / syscall.c

diff --git a/kernel/bpf/syscall.c b/kernel/bpf/syscall.c
index dff3a5f..29096d9 100644 (file)
--- a/kernel/bpf/syscall.c
+++ b/kernel/bpf/syscall.c
@@ -128,7 +128,7 @@ static struct bpf_map *find_and_alloc_map(union bpf_attr *attr)
        return map;
 }
 
-static u32 bpf_map_value_size(struct bpf_map *map)
+static u32 bpf_map_value_size(const struct bpf_map *map)
 {
        if (map->map_type == BPF_MAP_TYPE_PERCPU_HASH ||
            map->map_type == BPF_MAP_TYPE_LRU_PERCPU_HASH ||
@@ -346,77 +346,6 @@ void bpf_map_init_from_attr(struct bpf_map *map, union bpf_attr *attr)
        map->numa_node = bpf_map_attr_numa_node(attr);
 }
 
-static int bpf_charge_memlock(struct user_struct *user, u32 pages)
-{
-       unsigned long memlock_limit = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT;
-
-       if (atomic_long_add_return(pages, &user->locked_vm) > memlock_limit) {
-               atomic_long_sub(pages, &user->locked_vm);
-               return -EPERM;
-       }
-       return 0;
-}
-
-static void bpf_uncharge_memlock(struct user_struct *user, u32 pages)
-{
-       if (user)
-               atomic_long_sub(pages, &user->locked_vm);
-}
-
-int bpf_map_charge_init(struct bpf_map_memory *mem, u64 size)
-{
-       u32 pages = round_up(size, PAGE_SIZE) >> PAGE_SHIFT;
-       struct user_struct *user;
-       int ret;
-
-       if (size >= U32_MAX - PAGE_SIZE)
-               return -E2BIG;
-
-       user = get_current_user();
-       ret = bpf_charge_memlock(user, pages);
-       if (ret) {
-               free_uid(user);
-               return ret;
-       }
-
-       mem->pages = pages;
-       mem->user = user;
-
-       return 0;
-}
-
-void bpf_map_charge_finish(struct bpf_map_memory *mem)
-{
-       bpf_uncharge_memlock(mem->user, mem->pages);
-       free_uid(mem->user);
-}
-
-void bpf_map_charge_move(struct bpf_map_memory *dst,
-                        struct bpf_map_memory *src)
-{
-       *dst = *src;
-
-       /* Make sure src will not be used for the redundant uncharging. */
-       memset(src, 0, sizeof(struct bpf_map_memory));
-}
-
-int bpf_map_charge_memlock(struct bpf_map *map, u32 pages)
-{
-       int ret;
-
-       ret = bpf_charge_memlock(map->memory.user, pages);
-       if (ret)
-               return ret;
-       map->memory.pages += pages;
-       return ret;
-}
-
-void bpf_map_uncharge_memlock(struct bpf_map *map, u32 pages)
-{
-       bpf_uncharge_memlock(map->memory.user, pages);
-       map->memory.pages -= pages;
-}
-
 static int bpf_map_alloc_id(struct bpf_map *map)
 {
        int id;
@@ -524,14 +453,11 @@ static void bpf_map_release_memcg(struct bpf_map *map)
 static void bpf_map_free_deferred(struct work_struct *work)
 {
        struct bpf_map *map = container_of(work, struct bpf_map, work);
-       struct bpf_map_memory mem;
 
-       bpf_map_charge_move(&mem, &map->memory);
        security_bpf_map_free(map);
        bpf_map_release_memcg(map);
        /* implementation dependent freeing */
        map->ops->map_free(map);
-       bpf_map_charge_finish(&mem);
 }
 
 static void bpf_map_put_uref(struct bpf_map *map)
@@ -592,6 +518,19 @@ static fmode_t map_get_sys_perms(struct bpf_map *map, struct fd f)
 }
 
 #ifdef CONFIG_PROC_FS
+/* Provides an approximation of the map's memory footprint.
+ * Used only to provide a backward compatibility and display
+ * a reasonable "memlock" info.
+ */
+static unsigned long bpf_map_memory_footprint(const struct bpf_map *map)
+{
+       unsigned long size;
+
+       size = round_up(map->key_size + bpf_map_value_size(map), 8);
+
+       return round_up(map->max_entries * size, PAGE_SIZE);
+}
+
 static void bpf_map_show_fdinfo(struct seq_file *m, struct file *filp)
 {
        const struct bpf_map *map = filp->private_data;
@@ -610,7 +549,7 @@ static void bpf_map_show_fdinfo(struct seq_file *m, struct file *filp)
                   "value_size:\t%u\n"
                   "max_entries:\t%u\n"
                   "map_flags:\t%#x\n"
-                  "memlock:\t%llu\n"
+                  "memlock:\t%lu\n"
                   "map_id:\t%u\n"
                   "frozen:\t%u\n",
                   map->map_type,
@@ -618,7 +557,7 @@ static void bpf_map_show_fdinfo(struct seq_file *m, struct file *filp)
                   map->value_size,
                   map->max_entries,
                   map->map_flags,
-                  map->memory.pages * 1ULL << PAGE_SHIFT,
+                  bpf_map_memory_footprint(map),
                   map->id,
                   READ_ONCE(map->frozen));
        if (type) {
@@ -861,7 +800,6 @@ static int map_check_btf(struct bpf_map *map, const struct btf *btf,
 static int map_create(union bpf_attr *attr)
 {
        int numa_node = bpf_map_attr_numa_node(attr);
-       struct bpf_map_memory mem;
        struct bpf_map *map;
        int f_flags;
        int err;
@@ -960,9 +898,7 @@ free_map_sec:
        security_bpf_map_free(map);
 free_map:
        btf_put(map->btf);
-       bpf_map_charge_move(&mem, &map->memory);
        map->ops->map_free(map);
-       bpf_map_charge_finish(&mem);
        return err;
 }