7 files changed, 55 insertions, 21 deletions

diff --git a/kernel/bpf/arraymap.c b/kernel/bpf/arraymap.c
index d771a3872500..96e9c5c1dfc9 100644
--- a/kernel/bpf/arraymap.c
+++ b/kernel/bpf/arraymap.c
@@ -49,13 +49,15 @@ static int bpf_array_alloc_percpu(struct bpf_array *array)
 static struct bpf_map *array_map_alloc(union bpf_attr *attr)
 {
         bool percpu = attr->map_type == BPF_MAP_TYPE_PERCPU_ARRAY;
+        int numa_node = bpf_map_attr_numa_node(attr);
         struct bpf_array *array;
         u64 array_size;
         u32 elem_size;
 
         /* check sanity of attributes */
         if (attr->max_entries == 0 || attr->key_size != 4 ||
-            attr->value_size == 0 || attr->map_flags)
+            attr->value_size == 0 || attr->map_flags & ~BPF_F_NUMA_NODE ||
+            (percpu && numa_node != NUMA_NO_NODE))
                 return ERR_PTR(-EINVAL);
 
         if (attr->value_size > KMALLOC_MAX_SIZE)
@@ -77,7 +79,7 @@ static struct bpf_map *array_map_alloc(union bpf_attr *attr)
                 return ERR_PTR(-ENOMEM);
 
         /* allocate all map elements and zero-initialize them */
-        array = bpf_map_area_alloc(array_size);
+        array = bpf_map_area_alloc(array_size, numa_node);
         if (!array)
                 return ERR_PTR(-ENOMEM);
 
@@ -87,6 +89,7 @@ static struct bpf_map *array_map_alloc(union bpf_attr *attr)
         array->map.value_size = attr->value_size;
         array->map.max_entries = attr->max_entries;
         array->map.map_flags = attr->map_flags;
+        array->map.numa_node = numa_node;
         array->elem_size = elem_size;
 
         if (!percpu)
diff --git a/kernel/bpf/devmap.c b/kernel/bpf/devmap.c
index 18a72a8add43..67f4f00ce33a 100644
--- a/kernel/bpf/devmap.c
+++ b/kernel/bpf/devmap.c
@@ -80,7 +80,7 @@ static struct bpf_map *dev_map_alloc(union bpf_attr *attr)
 
         /* check sanity of attributes */
         if (attr->max_entries == 0 || attr->key_size != 4 ||
-            attr->value_size != 4 || attr->map_flags)
+            attr->value_size != 4 || attr->map_flags & ~BPF_F_NUMA_NODE)
                 return ERR_PTR(-EINVAL);
 
         dtab = kzalloc(sizeof(*dtab), GFP_USER);
@@ -93,6 +93,7 @@ static struct bpf_map *dev_map_alloc(union bpf_attr *attr)
         dtab->map.value_size = attr->value_size;
         dtab->map.max_entries = attr->max_entries;
         dtab->map.map_flags = attr->map_flags;
+        dtab->map.numa_node = bpf_map_attr_numa_node(attr);
 
         err = -ENOMEM;
 
@@ -119,7 +120,8 @@ static struct bpf_map *dev_map_alloc(union bpf_attr *attr)
                 goto free_dtab;
 
         dtab->netdev_map = bpf_map_area_alloc(dtab->map.max_entries *
-                                              sizeof(struct bpf_dtab_netdev *));
+                                              sizeof(struct bpf_dtab_netdev *),
+                                              dtab->map.numa_node);
         if (!dtab->netdev_map)
                 goto free_dtab;
 
@@ -344,7 +346,8 @@ static int dev_map_update_elem(struct bpf_map *map, void *key, void *value,
         if (!ifindex) {
                 dev = NULL;
         } else {
-                dev = kmalloc(sizeof(*dev), GFP_ATOMIC | __GFP_NOWARN);
+                dev = kmalloc_node(sizeof(*dev), GFP_ATOMIC | __GFP_NOWARN,
+                                   map->numa_node);
                 if (!dev)
                         return -ENOMEM;
 
diff --git a/kernel/bpf/hashtab.c b/kernel/bpf/hashtab.c
index 4fb463172aa8..47ae748c3a49 100644
--- a/kernel/bpf/hashtab.c
+++ b/kernel/bpf/hashtab.c
@@ -18,6 +18,9 @@
 #include "bpf_lru_list.h"
 #include "map_in_map.h"
 
+#define HTAB_CREATE_FLAG_MASK \
+        (BPF_F_NO_PREALLOC | BPF_F_NO_COMMON_LRU | BPF_F_NUMA_NODE)
+
 struct bucket {
         struct hlist_nulls_head head;
         raw_spinlock_t lock;
@@ -138,7 +141,8 @@ static int prealloc_init(struct bpf_htab *htab)
         if (!htab_is_percpu(htab) && !htab_is_lru(htab))
                 num_entries += num_possible_cpus();
 
-        htab->elems = bpf_map_area_alloc(htab->elem_size * num_entries);
+        htab->elems = bpf_map_area_alloc(htab->elem_size * num_entries,
+                                         htab->map.numa_node);
         if (!htab->elems)
                 return -ENOMEM;
 
@@ -233,6 +237,7 @@ 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;
@@ -248,7 +253,7 @@ static struct bpf_map *htab_map_alloc(union bpf_attr *attr)
                  */
                 return ERR_PTR(-EPERM);
 
-        if (attr->map_flags & ~(BPF_F_NO_PREALLOC | BPF_F_NO_COMMON_LRU))
+        if (attr->map_flags & ~HTAB_CREATE_FLAG_MASK)
                 /* reserved bits should not be used */
                 return ERR_PTR(-EINVAL);
 
@@ -258,6 +263,9 @@ static struct bpf_map *htab_map_alloc(union bpf_attr *attr)
         if (lru && !prealloc)
                 return ERR_PTR(-ENOTSUPP);
 
+        if (numa_node != NUMA_NO_NODE && (percpu || percpu_lru))
+                return ERR_PTR(-EINVAL);
+
         htab = kzalloc(sizeof(*htab), GFP_USER);
         if (!htab)
                 return ERR_PTR(-ENOMEM);
@@ -268,6 +276,7 @@ static struct bpf_map *htab_map_alloc(union bpf_attr *attr)
         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
@@ -346,7 +355,8 @@ static struct bpf_map *htab_map_alloc(union bpf_attr *attr)
 
         err = -ENOMEM;
         htab->buckets = bpf_map_area_alloc(htab->n_buckets *
-                                           sizeof(struct bucket));
+                                           sizeof(struct bucket),
+                                           htab->map.numa_node);
         if (!htab->buckets)
                 goto free_htab;
 
@@ -689,7 +699,8 @@ static struct htab_elem *alloc_htab_elem(struct bpf_htab *htab, void *key,
                                 atomic_dec(&htab->count);
                                 return ERR_PTR(-E2BIG);
                         }
-                l_new = kmalloc(htab->elem_size, GFP_ATOMIC | __GFP_NOWARN);
+                l_new = kmalloc_node(htab->elem_size, GFP_ATOMIC | __GFP_NOWARN,
+                                     htab->map.numa_node);
                 if (!l_new)
                         return ERR_PTR(-ENOMEM);
         }
diff --git a/kernel/bpf/lpm_trie.c b/kernel/bpf/lpm_trie.c
index b09185f0f17d..1b767844a76f 100644
--- a/kernel/bpf/lpm_trie.c
+++ b/kernel/bpf/lpm_trie.c
@@ -244,7 +244,8 @@ static struct lpm_trie_node *lpm_trie_node_alloc(const struct lpm_trie *trie,
         if (value)
                 size += trie->map.value_size;
 
-        node = kmalloc(size, GFP_ATOMIC | __GFP_NOWARN);
+        node = kmalloc_node(size, GFP_ATOMIC | __GFP_NOWARN,
+                            trie->map.numa_node);
         if (!node)
                 return NULL;
 
@@ -405,6 +406,8 @@ static int trie_delete_elem(struct bpf_map *map, void *key)
 #define LPM_KEY_SIZE_MAX        LPM_KEY_SIZE(LPM_DATA_SIZE_MAX)
 #define LPM_KEY_SIZE_MIN        LPM_KEY_SIZE(LPM_DATA_SIZE_MIN)
 
+#define LPM_CREATE_FLAG_MASK    (BPF_F_NO_PREALLOC | BPF_F_NUMA_NODE)
+
 static struct bpf_map *trie_alloc(union bpf_attr *attr)
 {
         struct lpm_trie *trie;
@@ -416,7 +419,8 @@ static struct bpf_map *trie_alloc(union bpf_attr *attr)
 
         /* check sanity of attributes */
         if (attr->max_entries == 0 ||
-            attr->map_flags != BPF_F_NO_PREALLOC ||
+            !(attr->map_flags & BPF_F_NO_PREALLOC) ||
+            attr->map_flags & ~LPM_CREATE_FLAG_MASK ||
             attr->key_size < LPM_KEY_SIZE_MIN ||
             attr->key_size > LPM_KEY_SIZE_MAX ||
             attr->value_size < LPM_VAL_SIZE_MIN ||
@@ -433,6 +437,7 @@ static struct bpf_map *trie_alloc(union bpf_attr *attr)
         trie->map.value_size = attr->value_size;
         trie->map.max_entries = attr->max_entries;
         trie->map.map_flags = attr->map_flags;
+        trie->map.numa_node = bpf_map_attr_numa_node(attr);
         trie->data_size = attr->key_size -
                           offsetof(struct bpf_lpm_trie_key, data);
         trie->max_prefixlen = trie->data_size * 8;
diff --git a/kernel/bpf/sockmap.c b/kernel/bpf/sockmap.c
index 39de541fbcdc..78b2bb9370ac 100644
--- a/kernel/bpf/sockmap.c
+++ b/kernel/bpf/sockmap.c
@@ -443,7 +443,9 @@ static struct smap_psock *smap_init_psock(struct sock *sock,
 {
         struct smap_psock *psock;
 
-        psock = kzalloc(sizeof(struct smap_psock), GFP_ATOMIC | __GFP_NOWARN);
+        psock = kzalloc_node(sizeof(struct smap_psock),
+                             GFP_ATOMIC | __GFP_NOWARN,
+                             stab->map.numa_node);
         if (!psock)
                 return ERR_PTR(-ENOMEM);
 
@@ -465,7 +467,7 @@ static struct bpf_map *sock_map_alloc(union bpf_attr *attr)
 
         /* check sanity of attributes */
         if (attr->max_entries == 0 || attr->key_size != 4 ||
-            attr->value_size != 4 || attr->map_flags)
+            attr->value_size != 4 || attr->map_flags & ~BPF_F_NUMA_NODE)
                 return ERR_PTR(-EINVAL);
 
         if (attr->value_size > KMALLOC_MAX_SIZE)
@@ -481,6 +483,7 @@ static struct bpf_map *sock_map_alloc(union bpf_attr *attr)
         stab->map.value_size = attr->value_size;
         stab->map.max_entries = attr->max_entries;
         stab->map.map_flags = attr->map_flags;
+        stab->map.numa_node = bpf_map_attr_numa_node(attr);
 
         /* make sure page count doesn't overflow */
         cost = (u64) stab->map.max_entries * sizeof(struct sock *);
@@ -495,7 +498,8 @@ static struct bpf_map *sock_map_alloc(union bpf_attr *attr)
                 goto free_stab;
 
         stab->sock_map = bpf_map_area_alloc(stab->map.max_entries *
-                                            sizeof(struct sock *));
+                                            sizeof(struct sock *),
+                                            stab->map.numa_node);
         if (!stab->sock_map)
                 goto free_stab;
 
diff --git a/kernel/bpf/stackmap.c b/kernel/bpf/stackmap.c
index 31147d730abf..135be433e9a0 100644
--- a/kernel/bpf/stackmap.c
+++ b/kernel/bpf/stackmap.c
@@ -31,7 +31,8 @@ static int prealloc_elems_and_freelist(struct bpf_stack_map *smap)
         u32 elem_size = sizeof(struct stack_map_bucket) + smap->map.value_size;
         int err;
 
-        smap->elems = bpf_map_area_alloc(elem_size * smap->map.max_entries);
+        smap->elems = bpf_map_area_alloc(elem_size * smap->map.max_entries,
+                                         smap->map.numa_node);
         if (!smap->elems)
                 return -ENOMEM;
 
@@ -59,7 +60,7 @@ static struct bpf_map *stack_map_alloc(union bpf_attr *attr)
         if (!capable(CAP_SYS_ADMIN))
                 return ERR_PTR(-EPERM);
 
-        if (attr->map_flags)
+        if (attr->map_flags & ~BPF_F_NUMA_NODE)
                 return ERR_PTR(-EINVAL);
 
         /* check sanity of attributes */
@@ -75,7 +76,7 @@ static struct bpf_map *stack_map_alloc(union bpf_attr *attr)
         if (cost >= U32_MAX - PAGE_SIZE)
                 return ERR_PTR(-E2BIG);
 
-        smap = bpf_map_area_alloc(cost);
+        smap = bpf_map_area_alloc(cost, bpf_map_attr_numa_node(attr));
         if (!smap)
                 return ERR_PTR(-ENOMEM);
 
@@ -91,6 +92,7 @@ static struct bpf_map *stack_map_alloc(union bpf_attr *attr)
         smap->map.map_flags = attr->map_flags;
         smap->n_buckets = n_buckets;
         smap->map.pages = round_up(cost, PAGE_SIZE) >> PAGE_SHIFT;
+        smap->map.numa_node = bpf_map_attr_numa_node(attr);
 
         err = bpf_map_precharge_memlock(smap->map.pages);
         if (err)
diff --git a/kernel/bpf/syscall.c b/kernel/bpf/syscall.c
index b8cb1b3c9bfb..9378f3ba2cbf 100644
--- a/kernel/bpf/syscall.c
+++ b/kernel/bpf/syscall.c
@@ -105,7 +105,7 @@ static struct bpf_map *find_and_alloc_map(union bpf_attr *attr)
         return map;
 }
 
-void *bpf_map_area_alloc(size_t size)
+void *bpf_map_area_alloc(size_t size, int numa_node)
 {
         /* We definitely need __GFP_NORETRY, so OOM killer doesn't
          * trigger under memory pressure as we really just want to
@@ -115,12 +115,13 @@ void *bpf_map_area_alloc(size_t size)
         void *area;
 
         if (size <= (PAGE_SIZE << PAGE_ALLOC_COSTLY_ORDER)) {
-                area = kmalloc(size, GFP_USER | flags);
+                area = kmalloc_node(size, GFP_USER | flags, numa_node);
                 if (area != NULL)
                         return area;
         }
 
-        return __vmalloc(size, GFP_KERNEL | flags, PAGE_KERNEL);
+        return __vmalloc_node_flags_caller(size, numa_node, GFP_KERNEL | flags,
+                                           __builtin_return_address(0));
 }
 
 void bpf_map_area_free(void *area)
@@ -309,10 +310,11 @@ int bpf_map_new_fd(struct bpf_map *map)
                    offsetof(union bpf_attr, CMD##_LAST_FIELD) - \
                    sizeof(attr->CMD##_LAST_FIELD)) != NULL
 
-#define BPF_MAP_CREATE_LAST_FIELD inner_map_fd
+#define BPF_MAP_CREATE_LAST_FIELD numa_node
 /* called via syscall */
 static int map_create(union bpf_attr *attr)
 {
+        int numa_node = bpf_map_attr_numa_node(attr);
         struct bpf_map *map;
         int err;
 
@@ -320,6 +322,10 @@ static int map_create(union bpf_attr *attr)
         if (err)
                 return -EINVAL;
 
+        if (numa_node != NUMA_NO_NODE &&
+            (numa_node >= nr_node_ids || !node_online(numa_node)))
+                return -EINVAL;
+
         /* find map type and init map: hashtable vs rbtree vs bloom vs ... */
         map = find_and_alloc_map(attr);
         if (IS_ERR(map))