1 files changed, 59 insertions, 44 deletions

diff --git a/kernel/bpf/hashtab.c b/kernel/bpf/hashtab.c
index 3905d4bc5b80..b76828f23b49 100644
--- a/kernel/bpf/hashtab.c
+++ b/kernel/bpf/hashtab.c
@@ -227,7 +227,7 @@ static int alloc_extra_elems(struct bpf_htab *htab)
 }
 
 /* Called from syscall */
-static struct bpf_map *htab_map_alloc(union bpf_attr *attr)
+static int htab_map_alloc_check(union bpf_attr *attr)
 {
         bool percpu = (attr->map_type == BPF_MAP_TYPE_PERCPU_HASH ||
                        attr->map_type == BPF_MAP_TYPE_LRU_PERCPU_HASH);
@@ -241,9 +241,6 @@ static struct bpf_map *htab_map_alloc(union bpf_attr *attr)
         bool percpu_lru = (attr->map_flags & BPF_F_NO_COMMON_LRU);
         bool prealloc = !(attr->map_flags & BPF_F_NO_PREALLOC);
         int numa_node = bpf_map_attr_numa_node(attr);
-        struct bpf_htab *htab;
-        int err, i;
-        u64 cost;
 
         BUILD_BUG_ON(offsetof(struct htab_elem, htab) !=
                      offsetof(struct htab_elem, hash_node.pprev));
@@ -254,40 +251,68 @@ static struct bpf_map *htab_map_alloc(union bpf_attr *attr)
                 /* LRU implementation is much complicated than other
                  * maps.  Hence, limit to CAP_SYS_ADMIN for now.
                  */
-                return ERR_PTR(-EPERM);
+                return -EPERM;
 
         if (attr->map_flags & ~HTAB_CREATE_FLAG_MASK)
                 /* reserved bits should not be used */
-                return ERR_PTR(-EINVAL);
+                return -EINVAL;
 
         if (!lru && percpu_lru)
-                return ERR_PTR(-EINVAL);
+                return -EINVAL;
 
         if (lru && !prealloc)
-                return ERR_PTR(-ENOTSUPP);
+                return -ENOTSUPP;
 
         if (numa_node != NUMA_NO_NODE && (percpu || percpu_lru))
-                return ERR_PTR(-EINVAL);
+                return -EINVAL;
+
+        /* check sanity of attributes.
+         * value_size == 0 may be allowed in the future to use map as a set
+         */
+        if (attr->max_entries == 0 || attr->key_size == 0 ||
+            attr->value_size == 0)
+                return -EINVAL;
+
+        if (attr->key_size > MAX_BPF_STACK)
+                /* eBPF programs initialize keys on stack, so they cannot be
+                 * larger than max stack size
+                 */
+                return -E2BIG;
+
+        if (attr->value_size >= KMALLOC_MAX_SIZE -
+            MAX_BPF_STACK - sizeof(struct htab_elem))
+                /* if value_size is bigger, the user space won't be able to
+                 * access the elements via bpf syscall. This check also makes
+                 * sure that the elem_size doesn't overflow and it's
+                 * kmalloc-able later in htab_map_update_elem()
+                 */
+                return -E2BIG;
+
+        return 0;
+}
+
+static struct bpf_map *htab_map_alloc(union bpf_attr *attr)
+{
+        bool percpu = (attr->map_type == BPF_MAP_TYPE_PERCPU_HASH ||
+                       attr->map_type == BPF_MAP_TYPE_LRU_PERCPU_HASH);
+        bool lru = (attr->map_type == BPF_MAP_TYPE_LRU_HASH ||
+                    attr->map_type == BPF_MAP_TYPE_LRU_PERCPU_HASH);
+        /* percpu_lru means each cpu has its own LRU list.
+         * it is different from BPF_MAP_TYPE_PERCPU_HASH where
+         * the map's value itself is percpu.  percpu_lru has
+         * nothing to do with the map's value.
+         */
+        bool percpu_lru = (attr->map_flags & BPF_F_NO_COMMON_LRU);
+        bool prealloc = !(attr->map_flags & BPF_F_NO_PREALLOC);
+        struct bpf_htab *htab;
+        int err, i;
+        u64 cost;
 
         htab = kzalloc(sizeof(*htab), GFP_USER);
         if (!htab)
                 return ERR_PTR(-ENOMEM);
 
-        /* mandatory map attributes */
-        htab->map.map_type = attr->map_type;
-        htab->map.key_size = attr->key_size;
-        htab->map.value_size = attr->value_size;
-        htab->map.max_entries = attr->max_entries;
-        htab->map.map_flags = attr->map_flags;
-        htab->map.numa_node = numa_node;
-
-        /* check sanity of attributes.
-         * value_size == 0 may be allowed in the future to use map as a set
-         */
-        err = -EINVAL;
-        if (htab->map.max_entries == 0 || htab->map.key_size == 0 ||
-            htab->map.value_size == 0)
-                goto free_htab;
+        bpf_map_init_from_attr(&htab->map, attr);
 
         if (percpu_lru) {
                 /* ensure each CPU's lru list has >=1 elements.
@@ -304,22 +329,6 @@ static struct bpf_map *htab_map_alloc(union bpf_attr *attr)
         /* hash table size must be power of 2 */
         htab->n_buckets = roundup_pow_of_two(htab->map.max_entries);
 
-        err = -E2BIG;
-        if (htab->map.key_size > MAX_BPF_STACK)
-                /* eBPF programs initialize keys on stack, so they cannot be
-                 * larger than max stack size
-                 */
-                goto free_htab;
-
-        if (htab->map.value_size >= KMALLOC_MAX_SIZE -
-            MAX_BPF_STACK - sizeof(struct htab_elem))
-                /* if value_size is bigger, the user space won't be able to
-                 * access the elements via bpf syscall. This check also makes
-                 * sure that the elem_size doesn't overflow and it's
-                 * kmalloc-able later in htab_map_update_elem()
-                 */
-                goto free_htab;
-
         htab->elem_size = sizeof(struct htab_elem) +
                           round_up(htab->map.key_size, 8);
         if (percpu)
@@ -327,6 +336,7 @@ static struct bpf_map *htab_map_alloc(union bpf_attr *attr)
         else
                 htab->elem_size += round_up(htab->map.value_size, 8);
 
+        err = -E2BIG;
         /* prevent zero size kmalloc and check for u32 overflow */
         if (htab->n_buckets == 0 ||
             htab->n_buckets > U32_MAX / sizeof(struct bucket))
@@ -1143,6 +1153,7 @@ static void htab_map_free(struct bpf_map *map)
 }
 
 const struct bpf_map_ops htab_map_ops = {
+        .map_alloc_check = htab_map_alloc_check,
         .map_alloc = htab_map_alloc,
         .map_free = htab_map_free,
         .map_get_next_key = htab_map_get_next_key,
@@ -1153,6 +1164,7 @@ const struct bpf_map_ops htab_map_ops = {
 };
 
 const struct bpf_map_ops htab_lru_map_ops = {
+        .map_alloc_check = htab_map_alloc_check,
         .map_alloc = htab_map_alloc,
         .map_free = htab_map_free,
         .map_get_next_key = htab_map_get_next_key,
@@ -1236,6 +1248,7 @@ int bpf_percpu_hash_update(struct bpf_map *map, void *key, void *value,
 }
 
 const struct bpf_map_ops htab_percpu_map_ops = {
+        .map_alloc_check = htab_map_alloc_check,
         .map_alloc = htab_map_alloc,
         .map_free = htab_map_free,
         .map_get_next_key = htab_map_get_next_key,
@@ -1245,6 +1258,7 @@ const struct bpf_map_ops htab_percpu_map_ops = {
 };
 
 const struct bpf_map_ops htab_lru_percpu_map_ops = {
+        .map_alloc_check = htab_map_alloc_check,
         .map_alloc = htab_map_alloc,
         .map_free = htab_map_free,
         .map_get_next_key = htab_map_get_next_key,
@@ -1253,11 +1267,11 @@ const struct bpf_map_ops htab_lru_percpu_map_ops = {
         .map_delete_elem = htab_lru_map_delete_elem,
 };
 
-static struct bpf_map *fd_htab_map_alloc(union bpf_attr *attr)
+static int fd_htab_map_alloc_check(union bpf_attr *attr)
 {
         if (attr->value_size != sizeof(u32))
-                return ERR_PTR(-EINVAL);
-        return htab_map_alloc(attr);
+                return -EINVAL;
+        return htab_map_alloc_check(attr);
 }
 
 static void fd_htab_map_free(struct bpf_map *map)
@@ -1328,7 +1342,7 @@ static struct bpf_map *htab_of_map_alloc(union bpf_attr *attr)
         if (IS_ERR(inner_map_meta))
                 return inner_map_meta;
 
-        map = fd_htab_map_alloc(attr);
+        map = htab_map_alloc(attr);
         if (IS_ERR(map)) {
                 bpf_map_meta_free(inner_map_meta);
                 return map;
@@ -1372,6 +1386,7 @@ static void htab_of_map_free(struct bpf_map *map)
 }
 
 const struct bpf_map_ops htab_of_maps_map_ops = {
+        .map_alloc_check = fd_htab_map_alloc_check,
         .map_alloc = htab_of_map_alloc,
         .map_free = htab_of_map_free,
         .map_get_next_key = htab_map_get_next_key,