bpf: Remove redundant synchronize_rcu.

bpf_free_used_maps() or close(map_fd) will trigger map_free callback.
bpf_free_used_maps() is called after bpf prog is no longer executing:
bpf_prog_put->call_rcu->bpf_prog_free->bpf_free_used_maps.
Hence there is no need to call synchronize_rcu() to protect map elements.

Note that hash_of_maps and array_of_maps update/delete inner maps via
sys_bpf() that calls maybe_wait_bpf_programs() and synchronize_rcu().

Signed-off-by: Alexei Starovoitov <[email protected]>
Acked-by: Andrii Nakryiko <[email protected]>
Acked-by: Paul E. McKenney <[email protected]>
Link: https://lore.kernel.org/bpf/[email protected]

diff --git a/kernel/bpf/arraymap.c b/kernel/bpf/arraymap.c
index ec5cd11032aa50cc782ba974507286122e8b23fe..c66e8273fccda75d4a17f8734c198b3115ab2ab5 100644 (file)
--- a/kernel/bpf/arraymap.c
+++ b/kernel/bpf/arraymap.c
@@ -386,13 +386,6 @@ static void array_map_free(struct bpf_map *map)
 {
        struct bpf_array *array = container_of(map, struct bpf_array, map);
 
-       /* at this point bpf_prog->aux->refcnt == 0 and this map->refcnt == 0,
-        * so the programs (can be more than one that used this map) were
-        * disconnected from events. Wait for outstanding programs to complete
-        * and free the array
-        */
-       synchronize_rcu();
-
        if (array->map.map_type == BPF_MAP_TYPE_PERCPU_ARRAY)
                bpf_array_free_percpu(array);
 
@@ -546,8 +539,6 @@ static void fd_array_map_free(struct bpf_map *map)
        struct bpf_array *array = container_of(map, struct bpf_array, map);
        int i;
 
-       synchronize_rcu();
-
        /* make sure it's empty */
        for (i = 0; i < array->map.max_entries; i++)
                BUG_ON(array->ptrs[i] != NULL);

diff --git a/kernel/bpf/hashtab.c b/kernel/bpf/hashtab.c
index acd06081d81dc87536f2f6dbb0bf99d1080b0240..d4378d7d442b90be038f46cf1347d9baca2fdf7d 100644 (file)
--- a/kernel/bpf/hashtab.c
+++ b/kernel/bpf/hashtab.c
@@ -1290,12 +1290,10 @@ static void htab_map_free(struct bpf_map *map)
 {
        struct bpf_htab *htab = container_of(map, struct bpf_htab, map);
 
-       /* at this point bpf_prog->aux->refcnt == 0 and this map->refcnt == 0,
-        * so the programs (can be more than one that used this map) were
-        * disconnected from events. Wait for outstanding critical sections in
-        * these programs to complete
+       /* bpf_free_used_maps() or close(map_fd) will trigger this map_free callback.
+        * bpf_free_used_maps() is called after bpf prog is no longer executing.
+        * There is no need to synchronize_rcu() here to protect map elements.
         */
-       synchronize_rcu();
 
        /* some of free_htab_elem() callbacks for elements of this map may
         * not have executed. Wait for them.

diff --git a/kernel/bpf/lpm_trie.c b/kernel/bpf/lpm_trie.c
index 1abd4e3f906dea45399b8267cf1e873f43fa6f69..44474bf3ab7ad21f658236158e8e6402c434a428 100644 (file)
--- a/kernel/bpf/lpm_trie.c
+++ b/kernel/bpf/lpm_trie.c
@@ -589,11 +589,6 @@ static void trie_free(struct bpf_map *map)
        struct lpm_trie_node __rcu **slot;
        struct lpm_trie_node *node;
 
-       /* Wait for outstanding programs to complete
-        * update/lookup/delete/get_next_key and free the trie.
-        */
-       synchronize_rcu();
-
        /* Always start at the root and walk down to a node that has no
         * children. Then free that node, nullify its reference in the parent
         * and start over.

diff --git a/kernel/bpf/queue_stack_maps.c b/kernel/bpf/queue_stack_maps.c
index 80c66a6d7c548c76562305c2f0ff015f662ede07..44184f82916a938f6f487a54672fc7b42490b748 100644 (file)
--- a/kernel/bpf/queue_stack_maps.c
+++ b/kernel/bpf/queue_stack_maps.c
@@ -101,13 +101,6 @@ static void queue_stack_map_free(struct bpf_map *map)
 {
        struct bpf_queue_stack *qs = bpf_queue_stack(map);
 
-       /* at this point bpf_prog->aux->refcnt == 0 and this map->refcnt == 0,
-        * so the programs (can be more than one that used this map) were
-        * disconnected from events. Wait for outstanding critical sections in
-        * these programs to complete
-        */
-       synchronize_rcu();
-
        bpf_map_area_free(qs);
 }
 

diff --git a/kernel/bpf/reuseport_array.c b/kernel/bpf/reuseport_array.c
index a09922f656e40fbaf5772eb73a7158b61a50d256..3625c4fcc65c3925f1f4933f71896df50221d3b0 100644 (file)
--- a/kernel/bpf/reuseport_array.c
+++ b/kernel/bpf/reuseport_array.c
@@ -96,8 +96,6 @@ static void reuseport_array_free(struct bpf_map *map)
        struct sock *sk;
        u32 i;
 
-       synchronize_rcu();
-
        /*
         * ops->map_*_elem() will not be able to access this
         * array now. Hence, this function only races with

diff --git a/kernel/bpf/ringbuf.c b/kernel/bpf/ringbuf.c
index dbf37aff4827f87a200ca2c9bb1662facf822572..13a8d3967e07493d67ad0e3397f78491c0161977 100644 (file)
--- a/kernel/bpf/ringbuf.c
+++ b/kernel/bpf/ringbuf.c
@@ -215,13 +215,6 @@ static void ringbuf_map_free(struct bpf_map *map)
 {
        struct bpf_ringbuf_map *rb_map;
 
-       /* at this point bpf_prog->aux->refcnt == 0 and this map->refcnt == 0,
-        * so the programs (can be more than one that used this map) were
-        * disconnected from events. Wait for outstanding critical sections in
-        * these programs to complete
-        */
-       synchronize_rcu();
-
        rb_map = container_of(map, struct bpf_ringbuf_map, map);
        bpf_ringbuf_free(rb_map->rb);
        kfree(rb_map);

diff --git a/kernel/bpf/stackmap.c b/kernel/bpf/stackmap.c
index 27dc9b1b08a523af0ebd36fc046bace0271996d3..071f98d0f7c68344e57bbcb998596676d2e1b953 100644 (file)
--- a/kernel/bpf/stackmap.c
+++ b/kernel/bpf/stackmap.c
@@ -604,9 +604,6 @@ static void stack_map_free(struct bpf_map *map)
 {
        struct bpf_stack_map *smap = container_of(map, struct bpf_stack_map, map);
 
-       /* wait for bpf programs to complete before freeing stack map */
-       synchronize_rcu();
-
        bpf_map_area_free(smap->elems);
        pcpu_freelist_destroy(&smap->freelist);
        bpf_map_area_free(smap);