bpf: Fix possible memleak when updating hash and local storage maps
Subsystems (3)
v2 cover bpf: Fix possible memleak when updating hash and local storage maps
In the discussion thread
"[PATCH bpf-next v9 0/7] bpf: Introduce BPF_F_CPU and BPF_F_ALL_CPUS flags for percpu maps"[1], it was pointed out that missing calls to bpf_obj_free_fields() could
lead to memory leaks.
A selftest was added to confirm that this is indeed a real issue - the memory referenced by BPF_KPTR_{REF,PERCPU} fields is not freed when bpf_obj_free_fields() is missing after copy_map_value[,_long]().
Further inspection of copy_map_value[,_long]() call sites revealed two locations affected by this issue:
1. pcpu_copy_value()
2. htab_map_update_elem() when used with BPF_F_LOCK
This series fixes the leaks by properly calling bpf_obj_free_fields() (or check_and_free_fields()) after copy_map_value[,_long]() and adds selftests to verify the fix.
Changes:
v1 -> v2:
* Add test to verify no memleak when updating cgroup local storage maps.
* Address review from AI bot:
* Fast path without bucket lock (around line 610) in
'bpf_local_storage.c'.
v1: https://lore.kernel.org/bpf/[email protected]/
Links:
[1] https://lore.kernel.org/bpf/[email protected]/
Leon Hwang (4):
bpf: Fix possible memleak in [lru_,]percpu_hash map update
bpf: Fix possible memleak when updating hash maps with BPF_F_LOCK
bpf: Fix possible memleak when updating local storage maps with
BPF_F_LOCK
selftests/bpf: Add tests to verify no memleak when updating hash and
cgrp storage maps
kernel/bpf/bpf_local_storage.c | 1 + kernel/bpf/hashtab.c | 4 + .../bpf/prog_tests/refcounted_kptr.c | 167 +++++++++++++++++- .../selftests/bpf/progs/refcounted_kptr.c | 160 +++++++++++++++++ 4 files changed, 331 insertions(+), 1 deletion(-)
--
2.51.0
PATCH v2 1/4 bpf: Fix possible memleak in [lru_,]percpu_hash map update
As [lru_,]percpu_hash maps support BPF_KPTR_{REF,PERCPU}, missing calls to 'bpf_obj_free_fields()' in 'pcpu_copy_value()' can leak memory referenced by BPF_KPTR_{REF,PERCPU} fields.
Fix this by calling 'bpf_obj_free_fields()' after 'copy_map_value[,_long]()' in 'pcpu_copy_value()'.
--- kernel/bpf/hashtab.c | 2 ++ 1 file changed, 2 insertions(+)
kernel/bpf/hashtab.c +2 -0
@@ -950,12 +950,14 @@ static void pcpu_copy_value(struct bpf_htab *htab, void __percpu *pptr,if (!onallcpus) {/* copy true value_size bytes */ copy_map_value (&htab->map,this_cpu_ptr (pptr), value); +bpf_obj_free_fields (htab->map.record,this_cpu_ptr (pptr)); }else {u32 size =round_up (htab->map.value_size,8 );int off =0 , cpu;for_each_possible_cpu (cpu) {copy_map_value_long (&htab->map,per_cpu_ptr (pptr, cpu), value + off); +bpf_obj_free_fields (htab->map.record,per_cpu_ptr (pptr, cpu)); off += size; } }
Signature · 1 line
2.51.0
PATCH v2 2/4 bpf: Fix possible memleak when updating hash maps with BPF_F_LOCK
In reply to Leon HwangWhen updating hash maps with BPF_F_LOCK, the special fields were not freed after being replaced. This could cause memory referenced by BPF_KPTR_{REF,PERCPU} fields to leak.
Fix this by calling 'check_and_free_fields()' after 'copy_map_value_locked()' to properly release the old fields.
--- kernel/bpf/hashtab.c | 2 ++ 1 file changed, 2 insertions(+)
kernel/bpf/hashtab.c +2 -0
@@ -1124,6 +1124,7 @@ static long htab_map_update_elem(struct bpf_map *map, void *key, void *value,copy_map_value_locked (map,htab_elem_value (l_old, key_size), value, false); +check_and_free_fields (htab, l_old);return 0 ; }/* fall through, grab the bucket lock and lookup again.
@@ -1152,6 +1153,7 @@ static long htab_map_update_elem(struct bpf_map *map, void *key, void *value,copy_map_value_locked (map,htab_elem_value (l_old, key_size), value, false); +check_and_free_fields (htab, l_old); ret =0 ; goto err; }
Signature · 1 line
2.51.0
PATCH v2 3/4 bpf: Fix possible memleak when updating local storage maps with BPF_F_LOCK
In reply to Leon HwangWhen updating local storage maps with BPF_F_LOCK, the special fields were not freed after being replaced. This could cause memory referenced by BPF_KPTR_{REF,PERCPU} fields to leak.
Fix this by calling 'bpf_obj_free_fields()' after 'copy_map_value_locked()' to properly release the old fields.
--- kernel/bpf/bpf_local_storage.c | 1 + 1 file changed, 1 insertion(+)
kernel/bpf/bpf_local_storage.c +1 -0
@@ -609,6 +609,7 @@ bpf_local_storage_update(void *owner, struct bpf_local_storage_map *smap,if (old_sdata &&selem_linked_to_storage_lockless (SELEM (old_sdata))) {copy_map_value_locked (&smap->map, old_sdata->data, value, false); +bpf_obj_free_fields (smap->map.record, old_sdata->data);return old_sdata; } }
Signature · 1 line
2.51.0
PATCH v2 4/4 selftests/bpf: Add tests to verify no memleak when updating hash and cgrp storage maps
In reply to Leon HwangAdd tests to verify that updating hash and local storage maps does not leak memory when BPF_KPTR_REF objects are involved.
The tests perform the following steps:
1. Call update_elem() to insert an initial value.
2. Use bpf_refcount_acquire() to increment the refcount.
3. Store the node pointer in the map value.
4. Add the node to a linked list.
5. Probe-read the refcount and verify it is *2*.
6. Call update_elem() again to trigger refcount decrement.
7. Probe-read the refcount and verify it is *1*.
--- .../bpf/prog_tests/refcounted_kptr.c | 167 +++++++++++++++++- .../selftests/bpf/progs/refcounted_kptr.c | 160 +++++++++++++++++ 2 files changed, 326 insertions(+), 1 deletion(-)
tools/testing/selftests/bpf/prog_tests/refcounted_kptr.c +166 -1
@@ -3,7 +3,7 @@#include <test_progs.h> #include <network_helpers.h> - +#include "cgroup_helpers.h" #include "refcounted_kptr.skel.h" #include "refcounted_kptr_fail.skel.h"
@@ -44,3 +44,168 @@ void test_refcounted_kptr_wrong_owner(void)ASSERT_OK (opts.retval,"rbtree_wrong_owner_remove_fail_a2 retval" );refcounted_kptr__destroy (skel); } + +static void test_refcnt_leak (void *values,size_t values_sz,u64 flags,struct bpf_map *map, +struct bpf_program *prog_leak,struct bpf_program *prog_check) +{ +int ret, fd, key =0 ; +LIBBPF_OPTS (bpf_test_run_opts, opts, + .data_in = &pkt_v4, + .data_size_in = sizeof(pkt_v4), + .repeat = 1, + ); + + ret =bpf_map__update_elem (map, &key,sizeof (key), values, values_sz, flags); +if (!ASSERT_OK (ret,"bpf_map__update_elem init" )) +return ; + + fd =bpf_program__fd (prog_leak); + ret =bpf_prog_test_run_opts (fd, &opts); +if (!ASSERT_OK (ret,"test_run_opts" )) +return ; +if (!ASSERT_EQ (opts.retval,2 ,"retval refcount" )) +return ; + + ret =bpf_map__update_elem (map, &key,sizeof (key), values, values_sz, flags); +if (!ASSERT_OK (ret,"bpf_map__update_elem dec refcount" )) +return ; + + fd =bpf_program__fd (prog_check); + ret =bpf_prog_test_run_opts (fd, &opts); +ASSERT_OK (ret,"test_run_opts" ); +ASSERT_EQ (opts.retval,1 ,"retval" ); +} + +static void test_percpu_hash_refcount_leak (void ) +{ +struct refcounted_kptr *skel; +size_t values_sz; +u64 *values; +int cpu_nr; + + cpu_nr =libbpf_num_possible_cpus (); +if (!ASSERT_GT (cpu_nr,0 ,"libbpf_num_possible_cpus" )) +return ; + + values =calloc (cpu_nr,sizeof (u64)); +if (!ASSERT_OK_PTR (values,"calloc values" )) +return ; + + skel =refcounted_kptr__open_and_load (); +if (!ASSERT_OK_PTR (skel,"refcounted_kptr__open_and_load" )) { +free (values); +return ; + } + + values_sz = cpu_nr *sizeof (u64); +memset (values,0 , values_sz); + +test_refcnt_leak (values, values_sz,0 , skel->maps.pcpu_hash, + skel->progs.pcpu_hash_refcount_leak, + skel->progs.check_pcpu_hash_refcount); + +refcounted_kptr__destroy (skel); +free (values); +} + +struct lock_map_value { +u64 kptr; +struct bpf_spin_lock lock; +int value; +}; + +static void test_hash_lock_refcount_leak (void ) +{ +struct lock_map_value value = {}; +struct refcounted_kptr *skel; + + skel =refcounted_kptr__open_and_load (); +if (!ASSERT_OK_PTR (skel,"refcounted_kptr__open_and_load" )) +return ; + +test_refcnt_leak (&value,sizeof (value),BPF_F_LOCK , skel->maps.lock_hash, + skel->progs.hash_lock_refcount_leak, + skel->progs.check_hash_lock_refcount); + +refcounted_kptr__destroy (skel); +} + +static void test_cgroup_storage_lock_refcount_leak (void ) +{ +int server_fd =-1 , client_fd =-1 ; +struct lock_map_value value = {}; +struct refcounted_kptr *skel; +u64 flags =BPF_F_LOCK ; +struct bpf_link *link; +struct bpf_map *map; +int cgroup, err; + + cgroup =test__join_cgroup ("/cg_refcount_leak" ); +if (!ASSERT_GE (cgroup,0 ,"test__join_cgroup" )) +return ; + + skel =refcounted_kptr__open_and_load (); +if (!ASSERT_OK_PTR (skel,"refcounted_kptr__open_and_load" )) + goto out; + + link =bpf_program__attach_cgroup (skel->progs.cgroup_storage_refcount_leak, cgroup); +if (!ASSERT_OK_PTR (link,"bpf_program__attach_cgroup" )) + goto out; + skel->links.cgroup_storage_refcount_leak = link; + + server_fd =start_server (AF_INET6 ,SOCK_STREAM ,"::1" ,0 ,0 ); +if (!ASSERT_GE (server_fd,0 ,"start_server" )) + goto out; + + client_fd =connect_to_fd (server_fd,0 ); +if (!ASSERT_GE (client_fd,0 ,"connect_to_fd" )) + goto out; + + map = skel->maps.cgrp_strg; + err =bpf_map__lookup_elem (map, &cgroup,sizeof (cgroup), &value,sizeof (value), flags); +if (!ASSERT_OK (err,"bpf_map__lookup_elem" )) + goto out; + +ASSERT_EQ (value.value,2 ,"refcount" ); + + err =bpf_map__update_elem (map, &cgroup,sizeof (cgroup), &value,sizeof (value), flags); +if (!ASSERT_OK (err,"bpf_map__update_elem" )) + goto out; + + err =bpf_link__detach (skel->links.cgroup_storage_refcount_leak); +if (!ASSERT_OK (err,"bpf_link__detach" )) + goto out; + + link =bpf_program__attach (skel->progs.check_cgroup_storage_refcount); +if (!ASSERT_OK_PTR (link,"bpf_program__attach" )) + goto out; + skel->links.check_cgroup_storage_refcount = link; + +close (client_fd); + client_fd =connect_to_fd (server_fd,0 ); +if (!ASSERT_GE (client_fd,0 ,"connect_to_fd" )) + goto out; + + err =bpf_map__lookup_elem (map, &cgroup,sizeof (cgroup), &value,sizeof (value), flags); +if (!ASSERT_OK (err,"bpf_map__lookup_elem" )) + goto out; + +ASSERT_EQ (value.value,1 ,"refcount" ); +out: +close (cgroup); +refcounted_kptr__destroy (skel); +if (client_fd >=0 ) +close (client_fd); +if (server_fd >=0 ) +close (server_fd); +} + +void test_kptr_refcount_leak (void ) +{ +if (test__start_subtest ("percpu_hash_refcount_leak" )) +test_percpu_hash_refcount_leak (); +if (test__start_subtest ("hash_lock_refcount_leak" )) +test_hash_lock_refcount_leak (); +if (test__start_subtest ("cgroup_storage_lock_refcount_leak" )) +test_cgroup_storage_lock_refcount_leak (); +}
tools/testing/selftests/bpf/progs/refcounted_kptr.c +160 -0
170 lines not on this page · raw message
Signature · 1 line
2.51.0