Make BPF CGROUP_STORAGE map usable by different programs at once
Subsystems (5)
v5 cover Make BPF CGROUP_STORAGE map usable by different programs at once
From: YiFei Zhu <[email protected]>
To access the storage in a CGROUP_STORAGE map, one uses bpf_get_local_storage helper, which is extremely fast due to its use of per-CPU variables. However, its whole code is built on the assumption that one map can only be used by one program at any time, and this prohibits any sharing of data between multiple programs using these maps, eliminating a lot of use cases, such as some per-cgroup configuration storage, written to by a setsockopt program and read by a cg_sock_addr program.
Why not use other map types? The great part of CGROUP_STORAGE map is that it is isolated by different cgroups its attached to. When one program uses bpf_get_local_storage, even on the same map, it gets different storages if it were run as a result of attaching to different cgroups. The kernel manages the storages, simplifying BPF program or userspace. In theory, one could probably use other maps like array or hash to do the same thing, but it would be a major overhead / complexity. Userspace needs to know when a cgroup is being freed in order to free up a space in the replacement map.
This patch set introduces a significant change to the semantics of CGROUP_STORAGE map type. Instead of each storage being tied to one single attachment, it is shared across different attachments to the same cgroup, and persists until either the map or the cgroup attached to is being freed.
User may use u64 as the key to the map, and the result would be that the attach type become ignored during key comparison, and programs of different attach types will share the same storage if the cgroups they are attached to are the same.
How could this break existing users?
* Users that uses detach & reattach / program replacement as a shortcut to zeroing the storage. Since we need sharing between programs, we cannot zero the storage. Users that expect this behavior should either attach a program with a new map, or explicitly zero the map with a syscall.
This case is dependent on undocumented implementation details, so the impact should be very minimal.
Patch 1 introduces a test on the old expected behavior of the map type.
Patch 2 introduces a test showing how two programs cannot share one such map.
Patch 3 implements the change of semantics to the map.
Patch 4 amends the new test such that it yields the behavior we expect from the change.
Patch 5 documents the map type.
Changes since RFC:
* Clarify commit message in patch 3 such that it says the lifetime of the storage is ended at the freeing of the cgroup_bpf, rather than the cgroup itself.
* Restored an -ENOMEM check in __cgroup_bpf_attach.
* Update selftests for recent change in network_helpers API.
Changes since v1:
* s/CHECK_FAIL/CHECK/
* s/bpf_prog_attach/bpf_program__attach_cgroup/
* Moved test__start_subtest to test_cg_storage_multi.
* Removed some redundant CHECK_FAIL where they are already CHECK-ed.
Changes since v2:
* Lock cgroup_mutex during map_free.
* Publish new storages only if attach is successful, by tracking exactly which storages are reused in an array of bools.
* Mention bpftool map dump showing a value of zero for attach_type in patch 3 commit message.
Changes since v3:
* Use a much simpler lookup and allocate-if-not-exist from the fact that cgroup_mutex is locked during attach.
* Removed an unnecessary spinlock hold.
Changes since v4:
* Changed semantics so that if the key type is struct bpf_cgroup_storage_key the map retains isolation between different attach types. Sharing between different attach types only occur when key type is u64.
* Adapted tests and docs for the above change.
YiFei Zhu (5):
selftests/bpf: Add test for CGROUP_STORAGE map on multiple attaches selftests/bpf: Test CGROUP_STORAGE map can't be used by multiple progs
bpf: Make cgroup storages shared between programs on the same cgroup selftests/bpf: Test CGROUP_STORAGE behavior on shared egress + ingress Documentation/bpf: Document CGROUP_STORAGE map type
Documentation/bpf/index.rst | 9 + Documentation/bpf/map_cgroup_storage.rst | 97 ++++ include/linux/bpf-cgroup.h | 12 +- kernel/bpf/cgroup.c | 67 +-- kernel/bpf/core.c | 12 - kernel/bpf/local_storage.c | 216 ++++----- .../bpf/prog_tests/cg_storage_multi.c | 417 ++++++++++++++++++ .../selftests/bpf/progs/cg_storage_multi.h | 13 + .../bpf/progs/cg_storage_multi_egress_only.c | 33 ++ .../bpf/progs/cg_storage_multi_isolated.c | 57 +++ .../bpf/progs/cg_storage_multi_shared.c | 57 +++ 11 files changed, 847 insertions(+), 143 deletions(-) create mode 100644 Documentation/bpf/map_cgroup_storage.rst create mode 100644 tools/testing/selftests/bpf/prog_tests/cg_storage_multi.c create mode 100644 tools/testing/selftests/bpf/progs/cg_storage_multi.h create mode 100644 tools/testing/selftests/bpf/progs/cg_storage_multi_egress_only.c create mode 100644 tools/testing/selftests/bpf/progs/cg_storage_multi_isolated.c create mode 100644 tools/testing/selftests/bpf/progs/cg_storage_multi_shared.c
Signature · 1 line
2.27.0
PATCH v5 1/5 selftests/bpf: Add test for CGROUP_STORAGE map on multiple attaches
From: YiFei Zhu <[email protected]>
This test creates a parent cgroup, and a child of that cgroup. It attaches a cgroup_skb/egress program that simply counts packets, to a global variable (ARRAY map), and to a CGROUP_STORAGE map. The program is first attached to the parent cgroup only, then to parent and child.
The test cases sends a message within the child cgroup, and because the program is inherited across parent / child cgroups, it will trigger the egress program for both the parent and child, if they exist. The program, when looking up a CGROUP_STORAGE map, uses the cgroup and attach type of the attachment parameters; therefore, both attaches uses different cgroup storages.
We assert that all packet counts returns what we expects.
--- .../bpf/prog_tests/cg_storage_multi.c | 163 ++++++++++++++++++ .../bpf/progs/cg_storage_multi_egress_only.c | 30 ++++ 2 files changed, 193 insertions(+) create mode 100644 tools/testing/selftests/bpf/prog_tests/cg_storage_multi.c create mode 100644 tools/testing/selftests/bpf/progs/cg_storage_multi_egress_only.c
tools/testing/selftests/bpf/prog_tests/cg_storage_multi.c new file +163 -0
@@ -0,0 +1,163 @@ +// SPDX-License-Identifier: GPL-2.0-only + +/* +* Copyright 2020 Google LLC. +*/ + +#include <test_progs.h> +#include <cgroup_helpers.h> +#include <network_helpers.h> + +#include "cg_storage_multi_egress_only.skel.h" + +#define PARENT_CGROUP "/cgroup_storage" +#define CHILD_CGROUP "/cgroup_storage/child" + +static int duration; + +static bool assert_storage (struct bpf_map *map,const char *cgroup_path, +__u32 expected) +{ +struct bpf_cgroup_storage_key key = {0 }; +__u32 value; +int map_fd; + + map_fd =bpf_map__fd (map); + + key.cgroup_inode_id =get_cgroup_id (cgroup_path); + key.attach_type =BPF_CGROUP_INET_EGRESS ; +if (CHECK (bpf_map_lookup_elem (map_fd, &key, &value) <0 , +"map-lookup" ,"errno %d" , errno)) +return true; +if (CHECK (value != expected, +"assert-storage" ,"got %u expected %u" , value, expected)) +return true; + +return false; +} + +static bool assert_storage_noexist (struct bpf_map *map,const char *cgroup_path) +{ +struct bpf_cgroup_storage_key key = {0 }; +__u32 value; +int map_fd; + + map_fd =bpf_map__fd (map); + + key.cgroup_inode_id =get_cgroup_id (cgroup_path); + key.attach_type =BPF_CGROUP_INET_EGRESS ; +if (CHECK (bpf_map_lookup_elem (map_fd, &key, &value) ==0 , +"map-lookup" ,"succeeded, expected ENOENT" )) +return true; +if (CHECK (errno !=ENOENT , +"map-lookup" ,"errno %d, expected ENOENT" , errno)) +return true; + +return false; +} + +static bool connect_send (const char *cgroup_path) +{ +bool res = true; +int server_fd =-1 , client_fd =-1 ; + +if (join_cgroup (cgroup_path)) + goto out_clean; + + server_fd =start_server (AF_INET ,SOCK_DGRAM ,NULL ,0 ,0 ); +if (server_fd <0 ) + goto out_clean; + + client_fd =connect_to_fd (server_fd,0 ); +if (client_fd <0 ) + goto out_clean; + +if (send (client_fd,"message" ,strlen ("message" ),0 ) <0 ) + goto out_clean; + + res = false; + +out_clean: +close (client_fd); +close (server_fd); +return res; +} + +static void test_egress_only (int parent_cgroup_fd,int child_cgroup_fd) +{ +struct cg_storage_multi_egress_only *obj; +struct bpf_link *parent_link =NULL , *child_link =NULL ; +bool err; + + obj =cg_storage_multi_egress_only__open_and_load (); +if (CHECK (!obj,"skel-load" ,"errno %d" , errno)) +return ; + +/* Attach to parent cgroup, trigger packet from child. +* Assert that there is only one run and in that run the storage is +* parent cgroup's storage. +* Also assert that child cgroup's storage does not exist +*/ + parent_link =bpf_program__attach_cgroup (obj->progs.egress, + parent_cgroup_fd); +if (CHECK (IS_ERR (parent_link),"parent-cg-attach" , +"err %ld" ,PTR_ERR (parent_link))) + goto close_bpf_object; + err =connect_send (CHILD_CGROUP ); +if (CHECK (err,"first-connect-send" ,"errno %d" , errno)) + goto close_bpf_object; +if (CHECK (obj->bss->invocations !=1 , +"first-invoke" ,"invocations=%d" , obj->bss->invocations)) + goto close_bpf_object; +if (assert_storage (obj->maps.cgroup_storage,PARENT_CGROUP ,1 )) + goto close_bpf_object; +if (assert_storage_noexist (obj->maps.cgroup_storage,CHILD_CGROUP )) + goto close_bpf_object; + +/* Attach to parent and child cgroup, trigger packet from child. +* Assert that there are two additional runs, one that run with parent +* cgroup's storage and one with child cgroup's storage. +*/ + child_link =bpf_program__attach_cgroup (obj->progs.egress, + child_cgroup_fd); +if (CHECK (IS_ERR (child_link),"child-cg-attach" , +"err %ld" ,PTR_ERR (child_link))) + goto close_bpf_object; + err =connect_send (CHILD_CGROUP ); +if (CHECK (err,"second-connect-send" ,"errno %d" , errno)) + goto close_bpf_object; +if (CHECK (obj->bss->invocations !=3 , +"second-invoke" ,"invocations=%d" , obj->bss->invocations)) + goto close_bpf_object; +if (assert_storage (obj->maps.cgroup_storage,PARENT_CGROUP ,2 )) + goto close_bpf_object; +if (assert_storage (obj->maps.cgroup_storage,CHILD_CGROUP ,1 )) + goto close_bpf_object; + +close_bpf_object: +if (parent_link) +bpf_link__destroy (parent_link); +if (child_link) +bpf_link__destroy (child_link); + +cg_storage_multi_egress_only__destroy (obj); +} + +void test_cg_storage_multi (void ) +{ +int parent_cgroup_fd =-1 , child_cgroup_fd =-1 ; + + parent_cgroup_fd =test__join_cgroup (PARENT_CGROUP ); +if (CHECK (parent_cgroup_fd <0 ,"cg-create-parent" ,"errno %d" , errno)) + goto close_cgroup_fd; + child_cgroup_fd =create_and_get_cgroup (CHILD_CGROUP ); +if (CHECK (child_cgroup_fd <0 ,"cg-create-child" ,"errno %d" , errno)) + goto close_cgroup_fd; + +if (test__start_subtest ("egress_only" )) +test_egress_only (parent_cgroup_fd, child_cgroup_fd); + +close_cgroup_fd: +close (child_cgroup_fd); +close (parent_cgroup_fd); +}
tools/testing/selftests/bpf/progs/cg_storage_multi_egress_only.c new file +30 -0
@@ -0,0 +1,30 @@ +// SPDX-License-Identifier: GPL-2.0-only + +/* +* Copyright 2020 Google LLC. +*/ + +#include <errno.h> +#include <linux/bpf.h> +#include <linux/ip.h> +#include <linux/udp.h> +#include <bpf/bpf_helpers.h> + +struct { + __uint(type, BPF_MAP_TYPE_CGROUP_STORAGE); + __type(key, struct bpf_cgroup_storage_key); + __type(value, __u32); +} cgroup_storage SEC(".maps"); + +__u32 invocations =0 ; + +SEC("cgroup_skb/egress") +int egress (struct __sk_buff *skb) +{ +__u32 *ptr_cg_storage =bpf_get_local_storage (&cgroup_storage,0 ); + +__sync_fetch_and_add (ptr_cg_storage,1 ); +__sync_fetch_and_add (&invocations,1 ); + +return 1 ; +}
Signature · 1 line
2.27.0
Re: [PATCH v5 bpf-next 1/5] selftests/bpf: Add test for CGROUP_STORAGE map on multiple attaches
Quoted 159 lines · YiFei Zhu
From: YiFei Zhu <[email protected]>
This test creates a parent cgroup, and a child of that cgroup. It attaches a cgroup_skb/egress program that simply counts packets, to a global variable (ARRAY map), and to a
CGROUP_STORAGEmap. The program is first attached to the parent cgroup only, then to parent and child.The test cases sends a message within the child cgroup, and because the program is inherited across parent / child cgroups, it will trigger the egress program for both the parent and child, if they exist. The program, when looking up a
CGROUP_STORAGEmap, uses the cgroup and attach type of the attachment parameters; therefore, both attaches uses different cgroup storages.We assert that all packet counts returns what we expects.
Signed-off-by YiFei Zhu <[email protected]>--- .../bpf/prog_tests/cg_storage_multi.c | 163 ++++++++++++++++++ .../bpf/progs/cg_storage_multi_egress_only.c | 30 ++++ 2 files changed, 193 insertions(+) create mode 100644 tools/testing/selftests/bpf/prog_tests/cg_storage_multi.c create mode 100644 tools/testing/selftests/bpf/progs/cg_storage_multi_egress_only.ctools/testing/selftests/bpf/prog_tests/cg_storage_multi.c new file +128
-0@@ -0,0 +1,163 @@ +// SPDX-License-Identifier: GPL-2.0-only + +/* +* Copyright 2020 Google LLC. +*/ + +#include <test_progs.h> +#include <cgroup_helpers.h> +#include <network_helpers.h> + +#include "cg_storage_multi_egress_only.skel.h" + +#define PARENT_CGROUP "/cgroup_storage" +#define CHILD_CGROUP "/cgroup_storage/child" + +static int duration; + +static bool assert_storage (struct bpf_map *map,const char *cgroup_path, +__u32 expected) +{ +struct bpf_cgroup_storage_key key = {0 }; +__u32 value; +int map_fd; + + map_fd =bpf_map__fd (map); + + key.cgroup_inode_id =get_cgroup_id (cgroup_path); + key.attach_type =BPF_CGROUP_INET_EGRESS ; +if (CHECK (bpf_map_lookup_elem (map_fd, &key, &value) <0 , +"map-lookup" ,"errno %d" , errno)) +return true; +if (CHECK (value != expected, +"assert-storage" ,"got %u expected %u" , value, expected)) +return true; + +return false; +} + +static bool assert_storage_noexist (struct bpf_map *map,const char *cgroup_path) +{ +struct bpf_cgroup_storage_key key = {0 }; +__u32 value; +int map_fd; + + map_fd =bpf_map__fd (map); + + key.cgroup_inode_id =get_cgroup_id (cgroup_path); + key.attach_type =BPF_CGROUP_INET_EGRESS ; +if (CHECK (bpf_map_lookup_elem (map_fd, &key, &value) ==0 , +"map-lookup" ,"succeeded, expected ENOENT" )) +return true; +if (CHECK (errno !=ENOENT , +"map-lookup" ,"errno %d, expected ENOENT" , errno)) +return true; + +return false; +} + +static bool connect_send (const char *cgroup_path) +{ +bool res = true; +int server_fd =-1 , client_fd =-1 ; + +if (join_cgroup (cgroup_path)) + goto out_clean; + + server_fd =start_server (AF_INET ,SOCK_DGRAM ,NULL ,0 ,0 ); +if (server_fd <0 ) + goto out_clean; + + client_fd =connect_to_fd (server_fd,0 ); +if (client_fd <0 ) + goto out_clean; + +if (send (client_fd,"message" ,strlen ("message" ),0 ) <0 ) + goto out_clean; + + res = false; + +out_clean: +close (client_fd); +close (server_fd); +return res; +} + +static void test_egress_only (int parent_cgroup_fd,int child_cgroup_fd) +{ +struct cg_storage_multi_egress_only *obj; +struct bpf_link *parent_link =NULL , *child_link =NULL ; +bool err; + + obj =cg_storage_multi_egress_only__open_and_load (); +if (CHECK (!obj,"skel-load" ,"errno %d" , errno)) +return ; + +/* Attach to parent cgroup, trigger packet from child. +* Assert that there is only one run and in that run the storage is +* parent cgroup's storage. +* Also assert that child cgroup's storage does not exist +*/ + parent_link =bpf_program__attach_cgroup (obj->progs.egress, + parent_cgroup_fd); +if (CHECK (IS_ERR (parent_link),"parent-cg-attach" , +"err %ld" ,PTR_ERR (parent_link))) + goto close_bpf_object; + err =connect_send (CHILD_CGROUP ); +if (CHECK (err,"first-connect-send" ,"errno %d" , errno)) + goto close_bpf_object; +if (CHECK (obj->bss->invocations !=1 , +"first-invoke" ,"invocations=%d" , obj->bss->invocations)) + goto close_bpf_object; +if (assert_storage (obj->maps.cgroup_storage,PARENT_CGROUP ,1 )) + goto close_bpf_object; +if (assert_storage_noexist (obj->maps.cgroup_storage,CHILD_CGROUP )) + goto close_bpf_object; + +/* Attach to parent and child cgroup, trigger packet from child. +* Assert that there are two additional runs, one that run with parent +* cgroup's storage and one with child cgroup's storage. +*/ + child_link =bpf_program__attach_cgroup (obj->progs.egress, + child_cgroup_fd); +if (CHECK (IS_ERR (child_link),"child-cg-attach" , +"err %ld" ,PTR_ERR (child_link))) + goto close_bpf_object; + err =connect_send (CHILD_CGROUP ); +if (CHECK (err,"second-connect-send" ,"errno %d" , errno)) + goto close_bpf_object;
tools/testing/selftests/bpf/prog_tests/cg_storage_multi.c line 138
Quoted 10 lines
tools/testing/selftests/bpf/prog_tests/cg_storage_multi.c new file +10
-0+if (CHECK (obj->bss->invocations !=3 , +"second-invoke" ,"invocations=%d" , obj->bss->invocations)) + goto close_bpf_object; +if (assert_storage (obj->maps.cgroup_storage,PARENT_CGROUP ,2 )) + goto close_bpf_object; +if (assert_storage (obj->maps.cgroup_storage,CHILD_CGROUP ,1 )) + goto close_bpf_object; + +close_bpf_object: +if (parent_link)
Nit. I think bpf_link__destroy() is already NULL safe.
Quoted 7 lines
tools/testing/selftests/bpf/prog_tests/cg_storage_multi.c new file +7
-0+bpf_link__destroy (parent_link); +if (child_link) +bpf_link__destroy (child_link); + +cg_storage_multi_egress_only__destroy (obj); +} +
PATCH v5 2/5 selftests/bpf: Test CGROUP_STORAGE map can't be used by multiple progs
In reply to YiFei ZhuFrom: YiFei Zhu <[email protected]>
The current assumption is that the lifetime of a cgroup storage is tied to the program's attachment. The storage is created in cgroup_bpf_attach, and released upon cgroup_bpf_detach and cgroup_bpf_release.
Because the current semantics is that each attachment gets a completely independent cgroup storage, and you can have multiple programs attached to the same (cgroup, attach type) pair, the key of the CGROUP_STORAGE map, looking up the map with this pair could yield multiple storages, and that is not permitted. Therefore, the kernel verifier checks that two programs cannot share the same CGROUP_STORAGE map, even if they have different expected attach types, considering that the actual attach type does not always have to be equal to the expected attach type.
The test creates a CGROUP_STORAGE map and make it shared across two different programs, one cgroup_skb/egress and one /ingress. It asserts that the two programs cannot be both loaded, due to verifier failure from the above reason.
--- .../bpf/prog_tests/cg_storage_multi.c | 42 +++++++++++++---- .../selftests/bpf/progs/cg_storage_multi.h | 13 ++++++ .../progs/cg_storage_multi_egress_ingress.c | 45 +++++++++++++++++++ .../bpf/progs/cg_storage_multi_egress_only.c | 9 ++-- 4 files changed, 98 insertions(+), 11 deletions(-) create mode 100644 tools/testing/selftests/bpf/progs/cg_storage_multi.h create mode 100644 tools/testing/selftests/bpf/progs/cg_storage_multi_egress_ingress.c
tools/testing/selftests/bpf/prog_tests/cg_storage_multi.c +34 -8
@@ -8,7 +8,10 @@#include <cgroup_helpers.h> #include <network_helpers.h> +#include "progs/cg_storage_multi.h" +#include "cg_storage_multi_egress_only.skel.h" +#include "cg_storage_multi_egress_ingress.skel.h" #define PARENT_CGROUP "/cgroup_storage"#define CHILD_CGROUP "/cgroup_storage/child"
@@ -16,10 +19,10 @@static int duration;static bool assert_storage (struct bpf_map *map,const char *cgroup_path, -__u32 expected) +struct cgroup_value *expected) {struct bpf_cgroup_storage_key key = {0 }; -__u32 value; +struct cgroup_value value;int map_fd; map_fd =bpf_map__fd (map);
@@ -29,8 +32,8 @@ static bool assert_storage(struct bpf_map *map, const char *cgroup_path,if (CHECK (bpf_map_lookup_elem (map_fd, &key, &value) <0 ,"map-lookup" ,"errno %d" , errno))return true; -if (CHECK (value != expected, -"assert-storage" ,"got %u expected %u" , value, expected)) +if (CHECK (memcmp (&value, expected,sizeof (struct cgroup_value )), +"assert-storage" ,"storages differ" ))return true;return false;
@@ -39,7 +42,7 @@ static bool assert_storage(struct bpf_map *map, const char *cgroup_path,static bool assert_storage_noexist (struct bpf_map *map,const char *cgroup_path) {struct bpf_cgroup_storage_key key = {0 }; -__u32 value; +struct cgroup_value value;int map_fd; map_fd =bpf_map__fd (map);
@@ -86,6 +89,7 @@ static bool connect_send(const char *cgroup_path)static void test_egress_only (int parent_cgroup_fd,int child_cgroup_fd) {struct cg_storage_multi_egress_only *obj; +struct cgroup_value expected_cgroup_value;struct bpf_link *parent_link =NULL , *child_link =NULL ;bool err;
@@ -109,7 +113,9 @@ static void test_egress_only(int parent_cgroup_fd, int child_cgroup_fd)if (CHECK (obj->bss->invocations !=1 ,"first-invoke" ,"invocations=%d" , obj->bss->invocations)) goto close_bpf_object; -if (assert_storage (obj->maps.cgroup_storage,PARENT_CGROUP ,1 )) + expected_cgroup_value = (struct cgroup_value ) { .egress_pkts =1 }; +if (assert_storage (obj->maps.cgroup_storage, +PARENT_CGROUP , &expected_cgroup_value)) goto close_bpf_object;if (assert_storage_noexist (obj->maps.cgroup_storage,CHILD_CGROUP )) goto close_bpf_object;
@@ -129,9 +135,13 @@ static void test_egress_only(int parent_cgroup_fd, int child_cgroup_fd)if (CHECK (obj->bss->invocations !=3 ,"second-invoke" ,"invocations=%d" , obj->bss->invocations)) goto close_bpf_object; -if (assert_storage (obj->maps.cgroup_storage,PARENT_CGROUP ,2 )) + expected_cgroup_value = (struct cgroup_value ) { .egress_pkts =2 }; +if (assert_storage (obj->maps.cgroup_storage, +PARENT_CGROUP , &expected_cgroup_value)) goto close_bpf_object; -if (assert_storage (obj->maps.cgroup_storage,CHILD_CGROUP ,1 )) + expected_cgroup_value = (struct cgroup_value ) { .egress_pkts =1 }; +if (assert_storage (obj->maps.cgroup_storage, +CHILD_CGROUP , &expected_cgroup_value)) goto close_bpf_object; close_bpf_object:
@@ -143,6 +153,19 @@ static void test_egress_only(int parent_cgroup_fd, int child_cgroup_fd)cg_storage_multi_egress_only__destroy (obj); } +static void test_egress_ingress (int parent_cgroup_fd,int child_cgroup_fd) +{ +struct cg_storage_multi_egress_ingress *obj; + +/* Cannot load both programs due to verifier failure: +* "only one cgroup storage of each type is allowed" +*/ + obj =cg_storage_multi_egress_ingress__open_and_load (); +if (CHECK (obj || errno !=EBUSY , +"skel-load" ,"errno %d, expected EBUSY" , errno)) +return ; +} +void test_cg_storage_multi (void ) {int parent_cgroup_fd =-1 , child_cgroup_fd =-1 ;
@@ -157,6 +180,9 @@ void test_cg_storage_multi(void)if (test__start_subtest ("egress_only" ))test_egress_only (parent_cgroup_fd, child_cgroup_fd); +if (test__start_subtest ("egress_ingress" )) +test_egress_ingress (parent_cgroup_fd, child_cgroup_fd); + close_cgroup_fd:close (child_cgroup_fd);close (parent_cgroup_fd);
tools/testing/selftests/bpf/progs/cg_storage_multi.h new file +13 -0
@@ -0,0 +1,13 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ + +#ifndef __PROGS_CG_STORAGE_MULTI_H +#define __PROGS_CG_STORAGE_MULTI_H + +#include <asm/types.h> + +struct cgroup_value { +__u32 egress_pkts; +__u32 ingress_pkts; +}; + +#endif
tools/testing/selftests/bpf/progs/cg_storage_multi_egress_ingress.c new file +45 -0
45 lines not on this page · raw message
tools/testing/selftests/bpf/progs/cg_storage_multi_egress_only.c +6 -3
@@ -10,10 +10,12 @@#include <linux/udp.h> #include <bpf/bpf_helpers.h> +#include "progs/cg_storage_multi.h" +struct { __uint(type, BPF_MAP_TYPE_CGROUP_STORAGE); __type(key, struct bpf_cgroup_storage_key); - __type(value, __u32); + __type(value, struct cgroup_value); } cgroup_storage SEC(".maps");__u32 invocations =0 ;
@@ -21,9 +23,10 @@ __u32 invocations = 0; SEC("cgroup_skb/egress")int egress (struct __sk_buff *skb) { -__u32 *ptr_cg_storage =bpf_get_local_storage (&cgroup_storage,0 ); +struct cgroup_value *ptr_cg_storage = +bpf_get_local_storage (&cgroup_storage,0 ); -__sync_fetch_and_add (ptr_cg_storage,1 ); +__sync_fetch_and_add (&ptr_cg_storage->egress_pkts,1 );__sync_fetch_and_add (&invocations,1 );return 1 ;
Signature · 1 line
2.27.0
Re: [PATCH v5 bpf-next 2/5] selftests/bpf: Test CGROUP_STORAGE map can't be used by multiple progs
Quoted 119 lines · YiFei Zhu
From: YiFei Zhu <[email protected]>
The current assumption is that the lifetime of a cgroup storage is tied to the program's attachment. The storage is created in
cgroup_bpf_attach, and released uponcgroup_bpf_detachandcgroup_bpf_release.Because the current semantics is that each attachment gets a completely independent cgroup storage, and you can have multiple programs attached to the same (cgroup, attach type) pair, the key of the
CGROUP_STORAGEmap, looking up the map with this pair could yield multiple storages, and that is not permitted. Therefore, the kernel verifier checks that two programs cannot share the sameCGROUP_STORAGEmap, even if they have different expected attach types, considering that the actual attach type does not always have to be equal to the expected attach type.The test creates a
CGROUP_STORAGEmap and make it shared across two different programs, one cgroup_skb/egress and one /ingress. It asserts that the two programs cannot be both loaded, due to verifier failure from the above reason.Signed-off-by YiFei Zhu <[email protected]>--- .../bpf/prog_tests/cg_storage_multi.c | 42 +++++++++++++---- .../selftests/bpf/progs/cg_storage_multi.h | 13 ++++++ .../progs/cg_storage_multi_egress_ingress.c | 45 +++++++++++++++++++ .../bpf/progs/cg_storage_multi_egress_only.c | 9 ++-- 4 files changed, 98 insertions(+), 11 deletions(-) create mode 100644 tools/testing/selftests/bpf/progs/cg_storage_multi.h create mode 100644 tools/testing/selftests/bpf/progs/cg_storage_multi_egress_ingress.ctools/testing/selftests/bpf/prog_tests/cg_storage_multi.c +18
-8@@ -8,7 +8,10 @@#include <cgroup_helpers.h> #include <network_helpers.h> +#include "progs/cg_storage_multi.h" +#include "cg_storage_multi_egress_only.skel.h" +#include "cg_storage_multi_egress_ingress.skel.h" #define PARENT_CGROUP "/cgroup_storage"#define CHILD_CGROUP "/cgroup_storage/child"@@ -16,10 +19,10 @@static int duration;static bool assert_storage (struct bpf_map *map,const char *cgroup_path, -__u32 expected) +struct cgroup_value *expected) {struct bpf_cgroup_storage_key key = {0 }; -__u32 value; +struct cgroup_value value;int map_fd; map_fd =bpf_map__fd (map);@@ -29,8 +32,8 @@ static bool assert_storage(struct bpf_map *map, const char *cgroup_path,if (CHECK (bpf_map_lookup_elem (map_fd, &key, &value) <0 ,"map-lookup" ,"errno %d" , errno))return true; -if (CHECK (value != expected, -"assert-storage" ,"got %u expected %u" , value, expected)) +if (CHECK (memcmp (&value, expected,sizeof (struct cgroup_value )), +"assert-storage" ,"storages differ" ))return true;return false;@@ -39,7 +42,7 @@ static bool assert_storage(struct bpf_map *map, const char *cgroup_path,static bool assert_storage_noexist (struct bpf_map *map,const char *cgroup_path) {struct bpf_cgroup_storage_key key = {0 }; -__u32 value; +struct cgroup_value value;int map_fd; map_fd =bpf_map__fd (map);@@ -86,6 +89,7 @@ static bool connect_send(const char *cgroup_path)static void test_egress_only (int parent_cgroup_fd,int child_cgroup_fd) {struct cg_storage_multi_egress_only *obj; +struct cgroup_value expected_cgroup_value;struct bpf_link *parent_link =NULL , *child_link =NULL ;bool err;@@ -109,7 +113,9 @@ static void test_egress_only(int parent_cgroup_fd, int child_cgroup_fd)if (CHECK (obj->bss->invocations !=1 ,"first-invoke" ,"invocations=%d" , obj->bss->invocations)) goto close_bpf_object; -if (assert_storage (obj->maps.cgroup_storage,PARENT_CGROUP ,1 )) + expected_cgroup_value = (struct cgroup_value ) { .egress_pkts =1 }; +if (assert_storage (obj->maps.cgroup_storage, +PARENT_CGROUP , &expected_cgroup_value)) goto close_bpf_object;if (assert_storage_noexist (obj->maps.cgroup_storage,CHILD_CGROUP )) goto close_bpf_object;@@ -129,9 +135,13 @@ static void test_egress_only(int parent_cgroup_fd, int child_cgroup_fd)if (CHECK (obj->bss->invocations !=3 ,"second-invoke" ,"invocations=%d" , obj->bss->invocations)) goto close_bpf_object; -if (assert_storage (obj->maps.cgroup_storage,PARENT_CGROUP ,2 )) + expected_cgroup_value = (struct cgroup_value ) { .egress_pkts =2 }; +if (assert_storage (obj->maps.cgroup_storage, +PARENT_CGROUP , &expected_cgroup_value)) goto close_bpf_object; -if (assert_storage (obj->maps.cgroup_storage,CHILD_CGROUP ,1 )) + expected_cgroup_value = (struct cgroup_value ) { .egress_pkts =1 }; +if (assert_storage (obj->maps.cgroup_storage, +CHILD_CGROUP , &expected_cgroup_value)) goto close_bpf_object; close_bpf_object:@@ -143,6 +153,19 @@ static void test_egress_only(int parent_cgroup_fd, int child_cgroup_fd)cg_storage_multi_egress_only__destroy (obj); }
tools/testing/selftests/bpf/prog_tests/cg_storage_multi.c static void test_egress_only(int parent_cgroup_fd, int child_cgroup_fd) · line 165
Quoted 10 lines
tools/testing/selftests/bpf/prog_tests/cg_storage_multi.c +10
-0+static void test_egress_ingress (int parent_cgroup_fd,int child_cgroup_fd) +{ +struct cg_storage_multi_egress_ingress *obj; + +/* Cannot load both programs due to verifier failure: +* "only one cgroup storage of each type is allowed" +*/ + obj =cg_storage_multi_egress_ingress__open_and_load (); +if (CHECK (obj || errno !=EBUSY , +"skel-load" ,"errno %d, expected EBUSY" , errno))
obj may theoretically need to be freed. Probably not big deal since this case will be gone in the latter test.
Quoted 3 lines
tools/testing/selftests/bpf/prog_tests/cg_storage_multi.c +3
-0+return ; +} +
PATCH v5 3/5 bpf: Make cgroup storages shared between programs on the same cgroup
In reply to YiFei ZhuFrom: YiFei Zhu <[email protected]>
This change comes in several parts:
One, the restriction that the CGROUP_STORAGE map can only be used by one program is removed. This results in the removal of the field 'aux' in struct bpf_cgroup_storage_map, and removal of relevant code associated with the field, and removal of now-noop functions bpf_free_cgroup_storage and bpf_cgroup_storage_release.
Second, we permit a key of type u64 as the key to the map. Providing such a key type indicates that the map should ignore attach type when comparing map keys. However, for simplicity newly linked storage will still have the attach type at link time in its key struct. cgroup_storage_check_btf is adapted to accept u64 as the type of the key.
Third, because the storages are now shared, the storages cannot be unconditionally freed on program detach. There could be two ways to solve this issue:
* A. Reference count the usage of the storages, and free when the last program is detached.
* B. Free only when the storage is impossible to be referred to again, i.e. when either the cgroup_bpf it is attached to, or the map itself, is freed.
Option A has the side effect that, when the user detach and reattach a program, whether the program gets a fresh storage depends on whether there is another program attached using that storage. This could trigger races if the user is multi-threaded, and since nondeterminism in data races is evil, go with option B.
The both the map and the cgroup_bpf now tracks their associated storages, and the storage unlink and free are removed from cgroup_bpf_detach and added to cgroup_bpf_release and cgroup_storage_map_free. The latter also new holds the cgroup_mutex to prevent any races with the former.
Fourth, on attach, we reuse the old storage if the key already exists in the map, via cgroup_storage_lookup. If the storage does not exist yet, we create a new one, and publish it at the last step in the attach process. This does not create a race condition because for the whole attach the cgroup_mutex is held. We keep track of an array of new storages that was allocated and if the process fails only the new storages would get freed.
--- include/linux/bpf-cgroup.h | 12 ++- kernel/bpf/cgroup.c | 67 +++++++----- kernel/bpf/core.c | 12 --- kernel/bpf/local_storage.c | 216 ++++++++++++++++++++----------------- 4 files changed, 164 insertions(+), 143 deletions(-)
include/linux/bpf-cgroup.h +8 -4
@@ -46,7 +46,8 @@ struct bpf_cgroup_storage { };struct bpf_cgroup_storage_map *map;struct bpf_cgroup_storage_key key; -struct list_head list; +struct list_head list_map; +struct list_head list_cg;struct rb_node node;struct rcu_head rcu; };
@@ -78,6 +79,9 @@ struct cgroup_bpf {struct list_head progs[MAX_BPF_ATTACH_TYPE ];u32 flags[MAX_BPF_ATTACH_TYPE ]; +/* list of cgroup shared storages */ +struct list_head storages; +/* temp storage for effective prog array used by prog_attach/detach */ struct bpf_prog_array *inactive;
@@ -161,6 +165,9 @@ static inline void bpf_cgroup_storage_set(struct bpf_cgroup_storagethis_cpu_write (bpf_cgroup_storage[stype], storage[stype]); } +struct bpf_cgroup_storage * +cgroup_storage_lookup (struct bpf_cgroup_storage_map *map, +void *key,bool locked);struct bpf_cgroup_storage *bpf_cgroup_storage_alloc (struct bpf_prog *prog,enum bpf_cgroup_storage_type stype);void bpf_cgroup_storage_free (struct bpf_cgroup_storage *storage);
@@ -169,7 +176,6 @@ void bpf_cgroup_storage_link(struct bpf_cgroup_storage *storage, enum bpf_attach_type type);void bpf_cgroup_storage_unlink (struct bpf_cgroup_storage *storage);int bpf_cgroup_storage_assign (struct bpf_prog_aux *aux,struct bpf_map *map); -void bpf_cgroup_storage_release (struct bpf_prog_aux *aux,struct bpf_map *map);int bpf_percpu_cgroup_storage_copy (struct bpf_map *map,void *key,void *value); int bpf_percpu_cgroup_storage_update(struct bpf_map *map, void *key,
@@ -383,8 +389,6 @@ static inline void bpf_cgroup_storage_set( struct bpf_cgroup_storage *storage[MAX_BPF_CGROUP_STORAGE_TYPE]) {}static inline int bpf_cgroup_storage_assign (struct bpf_prog_aux *aux,struct bpf_map *map) {return 0 ; } -static inline void bpf_cgroup_storage_release (struct bpf_prog_aux *aux, -struct bpf_map *map) {}static inline struct bpf_cgroup_storage *bpf_cgroup_storage_alloc (struct bpf_prog *prog,enum bpf_cgroup_storage_type stype) {return NULL ; } static inline void bpf_cgroup_storage_free(
kernel/bpf/cgroup.c +39 -28
164 lines not on this page · raw message
kernel/bpf/core.c +0 -12
@@ -2097,24 +2097,12 @@ int bpf_prog_array_copy_info(struct bpf_prog_array *array, : 0; } -static void bpf_free_cgroup_storage (struct bpf_prog_aux *aux) -{ -enum bpf_cgroup_storage_type stype; - -for_each_cgroup_storage_type (stype) { -if (!aux->cgroup_storage[stype]) -continue ; -bpf_cgroup_storage_release (aux, aux->cgroup_storage[stype]); - } -} -void __bpf_free_used_maps (struct bpf_prog_aux *aux,struct bpf_map **used_maps,u32 len) {struct bpf_map *map;u32 i; -bpf_free_cgroup_storage (aux);for (i =0 ; i < len; i++) { map = used_maps[i];if (map->ops->map_poke_untrack)
kernel/bpf/local_storage.c +117 -99
360 lines not on this page · raw message
Signature · 1 line
2.27.0
Re: [PATCH v5 bpf-next 3/5] bpf: Make cgroup storages shared between programs on the same cgroup
Quoted 45 lines · YiFei Zhu
From: YiFei Zhu <[email protected]>
This change comes in several parts:
One, the restriction that the
CGROUP_STORAGEmap can only be used by one program is removed. This results in the removal of the field 'aux' in structbpf_cgroup_storage_map, and removal of relevant code associated with the field, and removal of now-noop functionsbpf_free_cgroup_storageandbpf_cgroup_storage_release.Second, we permit a key of type u64 as the key to the map. Providing such a key type indicates that the map should ignore attach type when comparing map keys. However, for simplicity newly linked storage will still have the attach type at link time in its key struct.
cgroup_storage_check_btfis adapted to accept u64 as the type of the key.Third, because the storages are now shared, the storages cannot be unconditionally freed on program detach. There could be two ways to solve this issue:
* A. Reference count the usage of the storages, and free when the last program is detached.
* B. Free only when the storage is impossible to be referred to again, i.e. when either thecgroup_bpfit is attached to, or the map itself, is freed.
Option A has the side effect that, when the user detach and reattach a program, whether the program gets a fresh storage depends on whether there is another program attached using that storage. This could trigger races if the user is multi-threaded, and since nondeterminism in data races is evil, go with option B.The both the map and the
cgroup_bpfnow tracks their associated storages, and the storage unlink and free are removed fromcgroup_bpf_detachand added tocgroup_bpf_releaseandcgroup_storage_map_free. The latter also new holds thecgroup_mutexto prevent any races with the former.Fourth, on attach, we reuse the old storage if the key already exists in the map, via
cgroup_storage_lookup. If the storage does not exist yet, we create a new one, and publish it at the last step in the attach process. This does not create a race condition because for the whole attach thecgroup_mutexis held. We keep track of an array of new storages that was allocated and if the process fails only the new storages would get freed.
[ ... ]
Quoted 49 lines
kernel/bpf/local_storage.c +14
-12@@ -9,6 +9,8 @@#include <linux/slab.h> #include <uapi/linux/btf.h> +#include "../cgroup/cgroup-internal.h" + DEFINE_PER_CPU(struct bpf_cgroup_storage*, bpf_cgroup_storage[MAX_BPF_CGROUP_STORAGE_TYPE]);#ifdef CONFIG_CGROUP_BPF @@ -20,7 +22,6 @@ struct bpf_cgroup_storage_map {struct bpf_map map;spinlock_t lock; -struct bpf_prog_aux *aux;struct rb_root root;struct list_head list; };@@ -30,24 +31,41 @@ static struct bpf_cgroup_storage_map *map_to_storage(struct bpf_map *map) return container_of(map, struct bpf_cgroup_storage_map, map); } -static int bpf_cgroup_storage_key_cmp ( -const struct bpf_cgroup_storage_key *key1, -const struct bpf_cgroup_storage_key *key2) +static bool attach_type_isolated (const struct bpf_map *map) { -if (key1->cgroup_inode_id < key2->cgroup_inode_id) -return -1 ; -else if (key1->cgroup_inode_id > key2->cgroup_inode_id) -return 1 ; -else if (key1->attach_type < key2->attach_type) -return -1 ; -else if (key1->attach_type > key2->attach_type) -return 1 ; +return map->key_size ==sizeof (struct bpf_cgroup_storage_key ); +} + +static int bpf_cgroup_storage_key_cmp (const struct bpf_cgroup_storage_map *map, +const void *_key1,const void *_key2) +{ +if (attach_type_isolated (&map->map)) { +const struct bpf_cgroup_storage_key *key1 = _key1; +const struct bpf_cgroup_storage_key *key2 = _key2; + +if (key1->cgroup_inode_id < key2->cgroup_inode_id)
kernel/bpf/local_storage.c static struct bpf_cgroup_storage_map *map_to_storage(struct bpf_map *map) · line 56
Quoted 10 lines
kernel/bpf/local_storage.c +10
-0+return -1 ; + else if (key1->cgroup_inode_id > key2->cgroup_inode_id) + return 1; + else if (key1->attach_type < key2->attach_type) + return -1; + else if (key1->attach_type > key2->attach_type) + return 1; + }else { +const __u64 *key1 = _key1; +const __u64 *key2 = _key2;
Nit.
Instead of key1 and key2, a meaningful name will be easier to read and tell what it is comparing about later, like the key1->"cgroup_inode_id" in the "if" case above. May be:
__u64 cgroup_inode_id1 = *(__u64 *)_key1; __u64 cgroup_inode_id2 = *(__u64 *)_key2;
kernel/bpf/local_storage.c static struct bpf_cgroup_storage_map *map_to_storage(struct bpf_map *map) · line 65
Quoted 9 lines
kernel/bpf/local_storage.c +6
-0+ +if (*key1 < *key2) +return -1 ; +else if (*key1 > *key2) +return 1 ; + }return 0 ; }
Others LGTM
PATCH v5 4/5 selftests/bpf: Test CGROUP_STORAGE behavior on shared egress + ingress
In reply to YiFei ZhuFrom: YiFei Zhu <[email protected]>
This mirrors the original egress-only test. The cgroup_storage is now extended to have two packet counters, one for egress and one for ingress. We also extend to have two egress programs to test that egress will always share with other egress origrams in the same cgroup. The behavior of the counters are exactly the same as the original egress-only test.
The test is split into two, one "isolated" test that when the key type is struct bpf_cgroup_storage_key, which contains the attach type, programs of different attach types will see different storages. The other, "shared" test that when the key type is u64, programs of different attach types will see the same storage if they are attached to the same cgroup.
---
.../bpf/prog_tests/cg_storage_multi.c | 276 ++++++++++++++++--
..._ingress.c => cg_storage_multi_isolated.c} | 16 +-
.../bpf/progs/cg_storage_multi_shared.c | 57 ++++
3 files changed, 323 insertions(+), 26 deletions(-)
rename tools/testing/selftests/bpf/progs/{cg_storage_multi_egress_ingress.c => cg_storage_multi_isolated.c} (73%)
create mode 100644 tools/testing/selftests/bpf/progs/cg_storage_multi_shared.ctools/testing/selftests/bpf/prog_tests/cg_storage_multi.c +252 -24
@@ -11,25 +11,23 @@#include "progs/cg_storage_multi.h" #include "cg_storage_multi_egress_only.skel.h" -#include "cg_storage_multi_egress_ingress.skel.h" +#include "cg_storage_multi_isolated.skel.h" +#include "cg_storage_multi_shared.skel.h" #define PARENT_CGROUP "/cgroup_storage"#define CHILD_CGROUP "/cgroup_storage/child"static int duration; -static bool assert_storage (struct bpf_map *map,const char *cgroup_path, +static bool assert_storage (struct bpf_map *map,const void *key,struct cgroup_value *expected) { -struct bpf_cgroup_storage_key key = {0 };struct cgroup_value value;int map_fd; map_fd =bpf_map__fd (map); - key.cgroup_inode_id =get_cgroup_id (cgroup_path); - key.attach_type =BPF_CGROUP_INET_EGRESS ; -if (CHECK (bpf_map_lookup_elem (map_fd, &key, &value) <0 , +if (CHECK (bpf_map_lookup_elem (map_fd, key, &value) <0 ,"map-lookup" ,"errno %d" , errno))return true; if (CHECK(memcmp(&value, expected, sizeof(struct cgroup_value)),
@@ -39,17 +37,14 @@ static bool assert_storage(struct bpf_map *map, const char *cgroup_path,return false; } -static bool assert_storage_noexist (struct bpf_map *map,const char *cgroup_path) +static bool assert_storage_noexist (struct bpf_map *map,const void *key) { -struct bpf_cgroup_storage_key key = {0 };struct cgroup_value value;int map_fd; map_fd =bpf_map__fd (map); - key.cgroup_inode_id =get_cgroup_id (cgroup_path); - key.attach_type =BPF_CGROUP_INET_EGRESS ; -if (CHECK (bpf_map_lookup_elem (map_fd, &key, &value) ==0 , +if (CHECK (bpf_map_lookup_elem (map_fd, key, &value) ==0 ,"map-lookup" ,"succeeded, expected ENOENT" ))return true; if (CHECK(errno != ENOENT,
@@ -90,9 +85,12 @@ static void test_egress_only(int parent_cgroup_fd, int child_cgroup_fd) {struct cg_storage_multi_egress_only *obj;struct cgroup_value expected_cgroup_value; +struct bpf_cgroup_storage_key key;struct bpf_link *parent_link =NULL , *child_link =NULL ;bool err; + key.attach_type =BPF_CGROUP_INET_EGRESS ; + obj =cg_storage_multi_egress_only__open_and_load ();if (CHECK (!obj,"skel-load" ,"errno %d" , errno))return ;
@@ -113,11 +111,13 @@ static void test_egress_only(int parent_cgroup_fd, int child_cgroup_fd)if (CHECK (obj->bss->invocations !=1 ,"first-invoke" ,"invocations=%d" , obj->bss->invocations)) goto close_bpf_object; + key.cgroup_inode_id =get_cgroup_id (PARENT_CGROUP ); expected_cgroup_value = (struct cgroup_value ) { .egress_pkts =1 };if (assert_storage (obj->maps.cgroup_storage, -PARENT_CGROUP , &expected_cgroup_value)) + &key, &expected_cgroup_value)) goto close_bpf_object; -if (assert_storage_noexist (obj->maps.cgroup_storage,CHILD_CGROUP )) + key.cgroup_inode_id =get_cgroup_id (CHILD_CGROUP ); +if (assert_storage_noexist (obj->maps.cgroup_storage, &key)) goto close_bpf_object;/* Attach to parent and child cgroup, trigger packet from child.
@@ -135,13 +135,15 @@ static void test_egress_only(int parent_cgroup_fd, int child_cgroup_fd)if (CHECK (obj->bss->invocations !=3 ,"second-invoke" ,"invocations=%d" , obj->bss->invocations)) goto close_bpf_object; + key.cgroup_inode_id =get_cgroup_id (PARENT_CGROUP ); expected_cgroup_value = (struct cgroup_value ) { .egress_pkts =2 };if (assert_storage (obj->maps.cgroup_storage, -PARENT_CGROUP , &expected_cgroup_value)) + &key, &expected_cgroup_value)) goto close_bpf_object; + key.cgroup_inode_id =get_cgroup_id (CHILD_CGROUP ); expected_cgroup_value = (struct cgroup_value ) { .egress_pkts =1 };if (assert_storage (obj->maps.cgroup_storage, -CHILD_CGROUP , &expected_cgroup_value)) + &key, &expected_cgroup_value)) goto close_bpf_object; close_bpf_object:
@@ -153,17 +155,240 @@ static void test_egress_only(int parent_cgroup_fd, int child_cgroup_fd)cg_storage_multi_egress_only__destroy (obj); } -static void test_egress_ingress (int parent_cgroup_fd,int child_cgroup_fd) +static void test_isolated (int parent_cgroup_fd,int child_cgroup_fd) { -struct cg_storage_multi_egress_ingress *obj; +struct cg_storage_multi_isolated *obj; +struct cgroup_value expected_cgroup_value; +struct bpf_cgroup_storage_key key; +struct bpf_link *parent_egress1_link =NULL , *parent_egress2_link =NULL ; +struct bpf_link *child_egress1_link =NULL , *child_egress2_link =NULL ; +struct bpf_link *parent_ingress_link =NULL , *child_ingress_link =NULL ; +bool err; -/* Cannot load both programs due to verifier failure: -* "only one cgroup storage of each type is allowed" + obj =cg_storage_multi_isolated__open_and_load (); +if (CHECK (!obj,"skel-load" ,"errno %d" , errno)) +return ; + +/* Attach to parent cgroup, trigger packet from child. +* Assert that there is three runs, two with parent cgroup egress and +* one with parent cgroup ingress, stored in separate parent storages. +* Also assert that child cgroup's storages does not exist */ - obj =cg_storage_multi_egress_ingress__open_and_load (); -if (CHECK (obj || errno !=EBUSY , -"skel-load" ,"errno %d, expected EBUSY" , errno)) + parent_egress1_link =bpf_program__attach_cgroup (obj->progs.egress1, + parent_cgroup_fd); +if (CHECK (IS_ERR (parent_egress1_link),"parent-egress1-cg-attach" , +"err %ld" ,PTR_ERR (parent_egress1_link))) + goto close_bpf_object; + parent_egress2_link =bpf_program__attach_cgroup (obj->progs.egress2, + parent_cgroup_fd); +if (CHECK (IS_ERR (parent_egress2_link),"parent-egress2-cg-attach" , +"err %ld" ,PTR_ERR (parent_egress2_link))) + goto close_bpf_object; + parent_ingress_link =bpf_program__attach_cgroup (obj->progs.ingress, + parent_cgroup_fd); +if (CHECK (IS_ERR (parent_ingress_link),"parent-ingress-cg-attach" , +"err %ld" ,PTR_ERR (parent_ingress_link))) + goto close_bpf_object; + err =connect_send (CHILD_CGROUP ); +if (CHECK (err,"first-connect-send" ,"errno %d" , errno)) + goto close_bpf_object; +if (CHECK (obj->bss->invocations !=3 , +"first-invoke" ,"invocations=%d" , obj->bss->invocations)) + goto close_bpf_object; + key.cgroup_inode_id =get_cgroup_id (PARENT_CGROUP ); + key.attach_type =BPF_CGROUP_INET_EGRESS ; + expected_cgroup_value = (struct cgroup_value ) { .egress_pkts =2 }; +if (assert_storage (obj->maps.cgroup_storage, + &key, &expected_cgroup_value)) + goto close_bpf_object; + key.attach_type =BPF_CGROUP_INET_INGRESS ; + expected_cgroup_value = (struct cgroup_value ) { .ingress_pkts =1 }; +if (assert_storage (obj->maps.cgroup_storage, + &key, &expected_cgroup_value)) + goto close_bpf_object; + key.cgroup_inode_id =get_cgroup_id (CHILD_CGROUP ); + key.attach_type =BPF_CGROUP_INET_EGRESS ; +if (assert_storage_noexist (obj->maps.cgroup_storage, &key)) + goto close_bpf_object; + key.attach_type =BPF_CGROUP_INET_INGRESS ; +if (assert_storage_noexist (obj->maps.cgroup_storage, &key)) + goto close_bpf_object; + +/* Attach to parent and child cgroup, trigger packet from child. +* Assert that there is six additional runs, parent cgroup egresses and +* ingress, child cgroup egresses and ingress. +* Assert that egree and ingress storages are separate. +*/ + child_egress1_link =bpf_program__attach_cgroup (obj->progs.egress1, + child_cgroup_fd); +if (CHECK (IS_ERR (child_egress1_link),"child-egress1-cg-attach" , +"err %ld" ,PTR_ERR (child_egress1_link))) + goto close_bpf_object; + child_egress2_link =bpf_program__attach_cgroup (obj->progs.egress2, + child_cgroup_fd); +if (CHECK (IS_ERR (child_egress2_link),"child-egress2-cg-attach" , +"err %ld" ,PTR_ERR (child_egress2_link))) + goto close_bpf_object; + child_ingress_link =bpf_program__attach_cgroup (obj->progs.ingress, + child_cgroup_fd); +if (CHECK (IS_ERR (child_ingress_link),"child-ingress-cg-attach" , +"err %ld" ,PTR_ERR (child_ingress_link))) + goto close_bpf_object; + err =connect_send (CHILD_CGROUP ); +if (CHECK (err,"second-connect-send" ,"errno %d" , errno)) + goto close_bpf_object; +if (CHECK (obj->bss->invocations !=9 , +"second-invoke" ,"invocations=%d" , obj->bss->invocations)) + goto close_bpf_object; + key.cgroup_inode_id =get_cgroup_id (PARENT_CGROUP ); + key.attach_type =BPF_CGROUP_INET_EGRESS ; + expected_cgroup_value = (struct cgroup_value ) { .egress_pkts =4 }; +if (assert_storage (obj->maps.cgroup_storage, + &key, &expected_cgroup_value)) + goto close_bpf_object; + key.attach_type =BPF_CGROUP_INET_INGRESS ; + expected_cgroup_value = (struct cgroup_value ) { .ingress_pkts =2 }; +if (assert_storage (obj->maps.cgroup_storage, + &key, &expected_cgroup_value)) + goto close_bpf_object; + key.cgroup_inode_id =get_cgroup_id (CHILD_CGROUP ); + key.attach_type =BPF_CGROUP_INET_EGRESS ; + expected_cgroup_value = (struct cgroup_value ) { .egress_pkts =2 }; +if (assert_storage (obj->maps.cgroup_storage, + &key, &expected_cgroup_value)) + goto close_bpf_object; + key.attach_type =BPF_CGROUP_INET_INGRESS ; + expected_cgroup_value = (struct cgroup_value ) { .ingress_pkts =1 }; +if (assert_storage (obj->maps.cgroup_storage, + &key, &expected_cgroup_value)) + goto close_bpf_object; + +close_bpf_object: +if (parent_egress1_link) +bpf_link__destroy (parent_egress1_link); +if (parent_egress2_link) +bpf_link__destroy (parent_egress2_link); +if (parent_ingress_link) +bpf_link__destroy (parent_ingress_link); +if (child_egress1_link) +bpf_link__destroy (child_egress1_link); +if (child_egress2_link) +bpf_link__destroy (child_egress2_link); +if (child_ingress_link) +bpf_link__destroy (child_ingress_link); + +cg_storage_multi_isolated__destroy (obj); +} + +static void test_shared (int parent_cgroup_fd,int child_cgroup_fd) +{ +struct cg_storage_multi_shared *obj; +struct cgroup_value expected_cgroup_value; +__u64 key; +struct bpf_link *parent_egress1_link =NULL , *parent_egress2_link =NULL ; +struct bpf_link *child_egress1_link =NULL , *child_egress2_link =NULL ; +struct bpf_link *parent_ingress_link =NULL , *child_ingress_link =NULL ; +bool err; + + obj =cg_storage_multi_shared__open_and_load (); +if (CHECK (!obj,"skel-load" ,"errno %d" , errno))return ; + +/* Attach to parent cgroup, trigger packet from child. +* Assert that there is three runs, two with parent cgroup egress and +* one with parent cgroup ingress. +* Also assert that child cgroup's storage does not exist +*/ + parent_egress1_link =bpf_program__attach_cgroup (obj->progs.egress1, + parent_cgroup_fd); +if (CHECK (IS_ERR (parent_egress1_link),"parent-egress1-cg-attach" , +"err %ld" ,PTR_ERR (parent_egress1_link))) + goto close_bpf_object; + parent_egress2_link =bpf_program__attach_cgroup (obj->progs.egress2, + parent_cgroup_fd); +if (CHECK (IS_ERR (parent_egress2_link),"parent-egress2-cg-attach" , +"err %ld" ,PTR_ERR (parent_egress2_link))) + goto close_bpf_object; + parent_ingress_link =bpf_program__attach_cgroup (obj->progs.ingress, + parent_cgroup_fd); +if (CHECK (IS_ERR (parent_ingress_link),"parent-ingress-cg-attach" , +"err %ld" ,PTR_ERR (parent_ingress_link))) + goto close_bpf_object; + err =connect_send (CHILD_CGROUP ); +if (CHECK (err,"first-connect-send" ,"errno %d" , errno)) + goto close_bpf_object; +if (CHECK (obj->bss->invocations !=3 , +"first-invoke" ,"invocations=%d" , obj->bss->invocations)) + goto close_bpf_object; + key =get_cgroup_id (PARENT_CGROUP ); + expected_cgroup_value = (struct cgroup_value ) { + .egress_pkts =2 , + .ingress_pkts =1 , + }; +if (assert_storage (obj->maps.cgroup_storage, + &key, &expected_cgroup_value)) + goto close_bpf_object; + key =get_cgroup_id (CHILD_CGROUP ); +if (assert_storage_noexist (obj->maps.cgroup_storage, &key)) + goto close_bpf_object; + +/* Attach to parent and child cgroup, trigger packet from child. +* Assert that there is six additional runs, parent cgroup egresses and +* ingress, child cgroup egresses and ingress. +*/ + child_egress1_link =bpf_program__attach_cgroup (obj->progs.egress1, + child_cgroup_fd); +if (CHECK (IS_ERR (child_egress1_link),"child-egress1-cg-attach" , +"err %ld" ,PTR_ERR (child_egress1_link))) + goto close_bpf_object; + child_egress2_link =bpf_program__attach_cgroup (obj->progs.egress2, + child_cgroup_fd); +if (CHECK (IS_ERR (child_egress2_link),"child-egress2-cg-attach" , +"err %ld" ,PTR_ERR (child_egress2_link))) + goto close_bpf_object; + child_ingress_link =bpf_program__attach_cgroup (obj->progs.ingress, + child_cgroup_fd); +if (CHECK (IS_ERR (child_ingress_link),"child-ingress-cg-attach" , +"err %ld" ,PTR_ERR (child_ingress_link))) + goto close_bpf_object; + err =connect_send (CHILD_CGROUP ); +if (CHECK (err,"second-connect-send" ,"errno %d" , errno)) + goto close_bpf_object; +if (CHECK (obj->bss->invocations !=9 , +"second-invoke" ,"invocations=%d" , obj->bss->invocations)) + goto close_bpf_object; + key =get_cgroup_id (PARENT_CGROUP ); + expected_cgroup_value = (struct cgroup_value ) { + .egress_pkts =4 , + .ingress_pkts =2 , + }; +if (assert_storage (obj->maps.cgroup_storage, + &key, &expected_cgroup_value)) + goto close_bpf_object; + key =get_cgroup_id (CHILD_CGROUP ); + expected_cgroup_value = (struct cgroup_value ) { + .egress_pkts =2 , + .ingress_pkts =1 , + }; +if (assert_storage (obj->maps.cgroup_storage, + &key, &expected_cgroup_value)) + goto close_bpf_object; + +close_bpf_object: +if (parent_egress1_link) +bpf_link__destroy (parent_egress1_link); +if (parent_egress2_link) +bpf_link__destroy (parent_egress2_link); +if (parent_ingress_link) +bpf_link__destroy (parent_ingress_link); +if (child_egress1_link) +bpf_link__destroy (child_egress1_link); +if (child_egress2_link) +bpf_link__destroy (child_egress2_link); +if (child_ingress_link) +bpf_link__destroy (child_ingress_link); + +cg_storage_multi_shared__destroy (obj); }void test_cg_storage_multi (void )
@@ -180,8 +405,11 @@ void test_cg_storage_multi(void)if (test__start_subtest ("egress_only" ))test_egress_only (parent_cgroup_fd, child_cgroup_fd); -if (test__start_subtest ("egress_ingress" )) -test_egress_ingress (parent_cgroup_fd, child_cgroup_fd); +if (test__start_subtest ("isolated" )) +test_isolated (parent_cgroup_fd, child_cgroup_fd); + +if (test__start_subtest ("shared" )) +test_shared (parent_cgroup_fd, child_cgroup_fd); close_cgroup_fd:close (child_cgroup_fd);
tools/testing/selftests/bpf/progs/cg_storage_multi_isolated.c renamed from tools/testing/selftests/bpf/progs/cg_storage_multi_egress_ingress.c +14 -2
@@ -20,8 +20,20 @@ struct {__u32 invocations =0 ; -SEC("cgroup_skb/egress") -int egress (struct __sk_buff *skb) +SEC("cgroup_skb/egress/1") +int egress1 (struct __sk_buff *skb) +{ +struct cgroup_value *ptr_cg_storage = +bpf_get_local_storage (&cgroup_storage,0 ); + +__sync_fetch_and_add (&ptr_cg_storage->egress_pkts,1 ); +__sync_fetch_and_add (&invocations,1 ); + +return 1 ; +} + +SEC("cgroup_skb/egress/2") +int egress2 (struct __sk_buff *skb) {struct cgroup_value *ptr_cg_storage =bpf_get_local_storage (&cgroup_storage,0 );
tools/testing/selftests/bpf/progs/cg_storage_multi_shared.c new file +57 -0
57 lines not on this page · raw message
Signature · 1 line
2.27.0
PATCH v5 5/5 Documentation/bpf: Document CGROUP_STORAGE map type
In reply to YiFei ZhuFrom: YiFei Zhu <[email protected]>
The machanics and usage are not very straightforward. Given the changes it's better to document how it works and how to use it, rather than having to rely on the examples and implementation to infer what is going on.
--- Documentation/bpf/index.rst | 9 +++ Documentation/bpf/map_cgroup_storage.rst | 97 ++++++++++++++++++++++++ 2 files changed, 106 insertions(+) create mode 100644 Documentation/bpf/map_cgroup_storage.rst
Documentation/bpf/index.rst +9 -0
@@ -48,6 +48,15 @@ Program types bpf_lsm +Map types +========= + +.. toctree:: + :maxdepth: 1 + + map_cgroup_storage + + Testing and debugging BPF =========================
Documentation/bpf/map_cgroup_storage.rst new file +97 -0
97 lines not on this page · raw message
Signature · 1 line
2.27.0
Re: [PATCH v5 bpf-next 5/5] Documentation/bpf: Document CGROUP_STORAGE map type
Quoted 40 lines · YiFei Zhu
From: YiFei Zhu <[email protected]>
The machanics and usage are not very straightforward. Given the changes it's better to document how it works and how to use it, rather than having to rely on the examples and implementation to infer what is going on.
Signed-off-by YiFei Zhu <[email protected]>--- Documentation/bpf/index.rst | 9 +++ Documentation/bpf/map_cgroup_storage.rst | 97 ++++++++++++++++++++++++ 2 files changed, 106 insertions(+) create mode 100644 Documentation/bpf/map_cgroup_storage.rstDocumentation/bpf/index.rst +9
-0@@ -48,6 +48,15 @@ Program types bpf_lsm +Map types +========= + +.. toctree:: + :maxdepth: 1 + + map_cgroup_storage + + Testing and debugging BPF =========================Documentation/bpf/map_cgroup_storage.rst new file +0
-0
Documentation/bpf/map_cgroup_storage.rst line 10
Quoted 10 lines
Documentation/bpf/map_cgroup_storage.rst new file +10
-0@@ -0,0 +1,97 @@ +.. SPDX-License-Identifier: GPL-2.0-only +.. Copyright (C) 2020 Google LLC. + +=========================== +BPF_MAP_TYPE_CGROUP_STORAGE +=========================== + +The ``BPF_MAP_TYPE_CGROUP_STORAGE`` map type represents a local fix-sized +storage. It is only available with ``CONFIG_CGROUP_BPF``, and to programs that +attach to cgroups; the programs are made available by the same config. The
s/config/Kconfig/ could be more obvious.
It should describe what problem this map is solving and why/when it should be used instead of other general purpose map.
Something like,
provide a local storage at the cgroup that the bpf prog is attached to. It provides a faster access than the general purpose htab which requires a hashtable lookup.
Documentation/bpf/map_cgroup_storage.rst line 20
Quoted 10 lines
Documentation/bpf/map_cgroup_storage.rst new file +10
-0+storage is identified by the cgroup the program is attached to. + +This document describes the usage and semantics of the +``BPF_MAP_TYPE_CGROUP_STORAGE`` map type. Some of its behaviors was changed in +Linux 5.9 and this document will describe the differences. + +Usage +===== + +The map uses key of type of either ``__u64`` or
``__u64 cgroup_inode_id``
Documentation/bpf/map_cgroup_storage.rst line 31
Quoted 11 lines
Documentation/bpf/map_cgroup_storage.rst new file +11
-0+``struct bpf_cgroup_storage_key``, declared in ``linux/bpf.h``:: + + struct bpf_cgroup_storage_key { + __u64 cgroup_inode_id; + __u32 attach_type; + }; + +``cgroup_inode_id`` is the inode id of the cgroup directory. +``attach_type`` is the the program's attach type. + +Since Linux 5.9, if the type is ``__u64``, then all attach types of the
I think it needs to be more specific that ``__u64 cgroup_inode_id`` is supported since 5.9.
Documentation/bpf/map_cgroup_storage.rst line 44
Quoted 13 lines
Documentation/bpf/map_cgroup_storage.rst new file +13
-0+particular cgroup and map will share the same storage. If the type is +``struct bpf_cgroup_storage_key``, then programs of different attach types +be isolated and see different storages. + +To access the storage in a program, use ``bpf_get_local_storage``:: + + void *bpf_get_local_storage(void *map, u64 flags) + +``flags`` is reserved for future use and must be 0. + +There is no implicit synchronization. Storages of ``BPF_MAP_TYPE_CGROUP_STORAGE`` +can be accessed by multiple programs across different CPUs, and user should +take care of synchronization by themselves.
It sounds like the bpf prog author is on its own.
The bpf infra provides "struct bpf_spin_lock" to synchronize the storage. e.g. tools/testing/selftests/bpf/progs/test_spin_lock.c
Quoted 30 lines
Documentation/bpf/map_cgroup_storage.rst new file +30
-0+ +Example usage:: + + #include <linux/bpf.h> + + struct { + __uint(type, BPF_MAP_TYPE_CGROUP_STORAGE); + __type(key, struct bpf_cgroup_storage_key); + __type(value, __u32); + } cgroup_storage SEC(".maps"); + + int program(struct __sk_buff *skb) + { + __u32 *ptr = bpf_get_local_storage(&cgroup_storage, 0); + __sync_fetch_and_add(ptr, 1); + + return 0; + } + +Semantics +========= + +``BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE`` is a variant of this map type. This +per-CPU variant will have different memory regions for each CPU for each +storage. The non-per-CPU will have the same memory region for each storage. + +Prior to Linux 5.9, the lifetime of a storage is precisely per-attachment, and +for a single ``CGROUP_STORAGE`` map, there can be at most one program loaded +that uses the map. A program may be attached to multiple cgroups or have +multiple attach types, and each attach creates a fresh zeroed storage. The
Documentation/bpf/map_cgroup_storage.rst line 84
Quoted 10 lines
Documentation/bpf/map_cgroup_storage.rst new file +10
-0+storage is freed upon detach. + +Since Linux 5.9, storage can be shared by multiple programs. When a program is +attached to a cgroup, the kernel would create a new storage only if the map +does not already contain an entry for the cgroup and attach type pair, or else +the old storage is reused for the new attachment. If the map is attach type +shared, then attach type is simply ignored during comparison. Storage is freed +only when either the map or the cgroup attached to is being freed. Detaching +will not directly free the storage, but it may cause the reference to the map +to reach zero and indirectly freeing all storage in the map.
A few more things should be mentioned
<5.9:
- There is a one-to-one association between the map and bpf-prog during load/verification time.
Thus, each map can only be used by one bpf-prog and
each bpf-prog can only use one storage map.
- Because of a map can only be used by one bpf-prog,
sharing of this cgroup's storage with different bpf-progs were impossible.
Quoted 1 line
= 5.9:
- The map is not associated with any bpf-prog, that makes sharing possible.
- However, the bpf-prog can still only associate with one map. Thus, a bpf-prog cannot use more than one BPF_MAP_TYPE_CGROUP_STORAGE (i.e. each
bpf-prog can only use one cgroup's storage).
Documentation/bpf/map_cgroup_storage.rst line 91
Quoted 7 lines
Documentation/bpf/map_cgroup_storage.rst new file +7
-0+ +In all versions, userspace may use the the attach parameters of cgroup and +attach type pair in ``struct bpf_cgroup_storage_key`` as the key to the BPF map +APIs to read or update the storage for a given attachment. For Linux 5.9 +attach type shared storages, only the first value in the struct, cgroup inode +id, is used during comparison, so userspace may just specify a ``__u64`` +directly.
A sample map definition will be useful in the "Usage" section above.
Quoted 9 lines
Documentation/bpf/map_cgroup_storage.rst new file +6
-0+ +The storage is bound at attach time. Even if the program is attached to parent +and triggers in child, the storage still belongs to the parent. + +Userspace cannot create a new entry in the map or delete an existing entry. +Program test runs always use a temporary storage.Signature · 1 line
2.27.0
Quoted 79 lines · YiFei Zhu
From: YiFei Zhu <[email protected]>
To access the storage in a
CGROUP_STORAGEmap, one usesbpf_get_local_storagehelper, which is extremely fast due to its use of per-CPU variables. However, its whole code is built on the assumption that one map can only be used by one program at any time, and this prohibits any sharing of data between multiple programs using these maps, eliminating a lot of use cases, such as some per-cgroup configuration storage, written to by a setsockopt program and read by acg_sock_addrprogram.Why not use other map types? The great part of
CGROUP_STORAGEmap is that it is isolated by different cgroups its attached to. When one program usesbpf_get_local_storage, even on the same map, it gets different storages if it were run as a result of attaching to different cgroups. The kernel manages the storages, simplifying BPF program or userspace. In theory, one could probably use other maps like array or hash to do the same thing, but it would be a major overhead / complexity. Userspace needs to know when a cgroup is being freed in order to free up a space in the replacement map.This patch set introduces a significant change to the semantics of
CGROUP_STORAGEmap type. Instead of each storage being tied to one single attachment, it is shared across different attachments to the same cgroup, and persists until either the map or the cgroup attached to is being freed.User may use u64 as the key to the map, and the result would be that the attach type become ignored during key comparison, and programs of different attach types will share the same storage if the cgroups they are attached to are the same.
How could this break existing users?
* Users that uses detach & reattach / program replacement as a shortcut to zeroing the storage. Since we need sharing between programs, we cannot zero the storage. Users that expect this behavior should either attach a program with a new map, or explicitly zero the map with a syscall.
This case is dependent on undocumented implementation details, so the impact should be very minimal.Patch 1 introduces a test on the old expected behavior of the map type.
Patch 2 introduces a test showing how two programs cannot share one such map.
Patch 3 implements the change of semantics to the map.
Patch 4 amends the new test such that it yields the behavior we expect from the change.
Patch 5 documents the map type.
Changes since RFC:
* Clarify commit message in patch 3 such that it says the lifetime of the storage is ended at the freeing of thecgroup_bpf, rather than the cgroup itself.
* Restored an-ENOMEMcheck in__cgroup_bpf_attach.
* Update selftests for recent change innetwork_helpersAPI.Changes since v1:
* s/CHECK_FAIL/CHECK/
* s/bpf_prog_attach/bpf_program__attach_cgroup/
* Movedtest__start_subtesttotest_cg_storage_multi.
* Removed some redundantCHECK_FAILwhere they are already CHECK-ed.Changes since v2:
* Lockcgroup_mutexduringmap_free.
* Publish new storages only if attach is successful, by tracking exactly which storages are reused in an array of bools.
* Mention bpftool map dump showing a value of zero forattach_typein patch 3 commit message.Changes since v3:
* Use a much simpler lookup and allocate-if-not-exist from the fact thatcgroup_mutexis locked during attach.
* Removed an unnecessary spinlock hold.
Quoted 6 lines
Changes since v4:
* Changed semantics so that if the key type is structbpf_cgroup_storage_keythe map retains isolation between different attach types. Sharing between different attach types only occur when key type is u64.
* Adapted tests and docs for the above change.
Thank for the v5. Overall looks good. I left some nit comments for the code changes. The doc needs some more details. With that,