Make BPF CGROUP_STORAGE map usable by different programs at once
Subsystems (5)
v4 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.
The attach_type field of the map key struct bpf_cgroup_storage_key is now unused. If userspace reads it it will always be zero. If userspace sends us a non-zero value it will be ignored.
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.
* Programs that expect isolation from different attach types. In reality, attaching the same program to different attach types, relying on that expected_attach_type not being enforced, should rarely happen, if at all.
* Userspace that does memcmp on the storage key when fetching map keys. In reality, if user wants to use a fixed key they would use {delete,lookup,update}_elem, rather than get_next_key.
These cases are 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.
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 across attaches 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 | 95 +++++++ include/linux/bpf-cgroup.h | 15 +- include/uapi/linux/bpf.h | 2 +- kernel/bpf/cgroup.c | 69 +++-- kernel/bpf/core.c | 12 - kernel/bpf/local_storage.c | 73 ++--- tools/include/uapi/linux/bpf.h | 2 +- .../bpf/prog_tests/cg_storage_multi.c | 265 ++++++++++++++++++ .../selftests/bpf/progs/cg_storage_multi.h | 13 + .../progs/cg_storage_multi_egress_ingress.c | 45 +++ .../bpf/progs/cg_storage_multi_egress_only.c | 33 +++ 12 files changed, 536 insertions(+), 97 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_ingress.c create mode 100644 tools/testing/selftests/bpf/progs/cg_storage_multi_egress_only.c
Signature · 1 line
2.27.0
PATCH v4 2/5 selftests/bpf: Test CGROUP_STORAGE map can't be used by multiple progs
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 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
PATCH v4 1/5 selftests/bpf: Add test for CGROUP_STORAGE map on multiple attaches
In reply to YiFei ZhuFrom: 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
PATCH v4 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. The behavior of the counters are exactly the same as the original egress-only test, only that the total number of invocations doubles from having both egress and ingress being counted.
The field attach_type in the map key is ignored in the kernel; however, keeping it is pointless here and we are demonstrating the expected usage of the map, so it is removed. That said, keeping the field will not fail the test, for backwards compatibility reasons. In other words, the original egress-only test is not affected by the change in CGROUP_STORAGE behavior and will pass in both cases.
--- .../bpf/prog_tests/cg_storage_multi.c | 90 +++++++++++++++++-- 1 file changed, 83 insertions(+), 7 deletions(-)
tools/testing/selftests/bpf/prog_tests/cg_storage_multi.c +83 -7
@@ -28,7 +28,6 @@ static bool assert_storage(struct bpf_map *map, const char *cgroup_path, 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;
@@ -48,7 +47,6 @@ static bool assert_storage_noexist(struct bpf_map *map, const char *cgroup_path) 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;
@@ -156,14 +154,92 @@ static void test_egress_only(int parent_cgroup_fd, int child_cgroup_fd)static void test_egress_ingress (int parent_cgroup_fd,int child_cgroup_fd) {struct cg_storage_multi_egress_ingress *obj; +struct cgroup_value expected_cgroup_value; +struct bpf_link *parent_egress_link =NULL , *parent_ingress_link =NULL ; +struct bpf_link *child_egress_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_egress_ingress__open_and_load (); -if (CHECK (obj || errno !=EBUSY , -"skel-load" ,"errno %d, expected EBUSY" , errno)) +if (CHECK (!obj,"skel-load" ,"errno %d" , errno))return ; + +/* Attach to parent cgroup, trigger packet from child. +* Assert that there is two runs, one with parent cgroup egress and +* one with parent cgroup ingress. +* Also assert that child cgroup's storage does not exist +*/ + parent_egress_link =bpf_program__attach_cgroup (obj->progs.egress, + parent_cgroup_fd); +if (CHECK (IS_ERR (parent_egress_link),"parent-egress-cg-attach" , +"err %ld" ,PTR_ERR (parent_egress_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 !=2 , +"first-invoke" ,"invocations=%d" , obj->bss->invocations)) + goto close_bpf_object; + expected_cgroup_value = (struct cgroup_value ) { + .egress_pkts =1 , + .ingress_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; + +/* Attach to parent and child cgroup, trigger packet from child. +* Assert that there is four additional runs, parent cgroup egress and +* ingress, child cgroup egress and ingress. +*/ + child_egress_link =bpf_program__attach_cgroup (obj->progs.egress, + child_cgroup_fd); +if (CHECK (IS_ERR (child_egress_link),"child-egress-cg-attach" , +"err %ld" ,PTR_ERR (child_egress_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 !=6 , +"second-invoke" ,"invocations=%d" , obj->bss->invocations)) + goto close_bpf_object; + expected_cgroup_value = (struct cgroup_value ) { + .egress_pkts =2 , + .ingress_pkts =2 , + }; +if (assert_storage (obj->maps.cgroup_storage, +PARENT_CGROUP , &expected_cgroup_value)) + goto close_bpf_object; + expected_cgroup_value = (struct cgroup_value ) { + .egress_pkts =1 , + .ingress_pkts =1 , + }; +if (assert_storage (obj->maps.cgroup_storage, +CHILD_CGROUP , &expected_cgroup_value)) + goto close_bpf_object; + +close_bpf_object: +if (parent_egress_link) +bpf_link__destroy (parent_egress_link); +if (parent_ingress_link) +bpf_link__destroy (parent_ingress_link); +if (child_egress_link) +bpf_link__destroy (child_egress_link); +if (child_ingress_link) +bpf_link__destroy (child_ingress_link); + +cg_storage_multi_egress_ingress__destroy (obj); }void test_cg_storage_multi (void )
Signature · 1 line
2.27.0
PATCH v4 3/5 bpf: Make cgroup storages shared across attaches 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, because there could be multiple attach types to the same cgroup, the attach type is completely ignored on comparison in the map key. Newly added keys have it zeroed. The only value in the key that still matters is the cgroup inode. bpftool map dump will also show an attach type of zero.
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 | 15 ++++--- include/uapi/linux/bpf.h | 2 +- kernel/bpf/cgroup.c | 69 ++++++++++++++++++-------------- kernel/bpf/core.c | 12 ------ kernel/bpf/local_storage.c | 73 ++++++++++++---------------------- tools/include/uapi/linux/bpf.h | 2 +- 6 files changed, 76 insertions(+), 97 deletions(-)
include/linux/bpf-cgroup.h +9 -6
@@ -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,15 +165,16 @@ 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, +struct bpf_cgroup_storage_key *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);void bpf_cgroup_storage_link (struct bpf_cgroup_storage *storage, -struct cgroup *cgroup, -enum bpf_attach_type type); +struct cgroup *cgroup);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 +388,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(
include/uapi/linux/bpf.h +1 -1
@@ -78,7 +78,7 @@ struct bpf_lpm_trie_key {struct bpf_cgroup_storage_key {__u64 cgroup_inode_id;/* cgroup inode id */ -__u32 attach_type;/* program attach type */ +__u32 attach_type;/* program attach type, unused */ };/* BPF syscall commands, see bpf(2) man-page for details. */
kernel/bpf/cgroup.c +39 -30
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 +26 -47
154 lines not on this page · raw message
tools/include/uapi/linux/bpf.h +1 -1
@@ -78,7 +78,7 @@ struct bpf_lpm_trie_key {struct bpf_cgroup_storage_key {__u64 cgroup_inode_id;/* cgroup inode id */ -__u32 attach_type;/* program attach type */ +__u32 attach_type;/* program attach type, unused */ };/* BPF syscall commands, see bpf(2) man-page for details. */
Signature · 1 line
2.27.0
PATCH v4 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 | 95 ++++++++++++++++++++++++ 2 files changed, 104 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 +95 -0
95 lines not on this page · raw message
Signature · 1 line
2.27.0
Re: [PATCH v4 bpf-next 3/5] bpf: Make cgroup storages shared across attaches on the same cgroup
In reply to YiFei ZhuQuoted 10 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.
Quoted 5 lines
Second, because there could be multiple attach types to the same cgroup, the attach type is completely ignored on comparison in the map key. Newly added keys have it zeroed. The only value in the key that still matters is the cgroup inode. bpftool map dump will also show an attach type of zero.
I quickly checked zero is actually BPF_CGROUP_INET_INGRESS instead of UNSPEC for attach_type. It will be confusing on the syscall side. e.g. map dumping with key.attach_type == BPF_CGROUP_INET_INGRESS while the only cgroup program is actually attaching to BPF_CGROUP_INET_EGRESS.
I don't have a clean way out for this. Adding a non-zero UNSPEC to "enum bpf_attach_type" seems wrong also.
One possible way out is to allow the bpf_cgroup_storage_map to have a smaller key size (i.e. allow both sizeof(cgroup_inode_id) and the existing sizeof(struct bpf_cgroup_storage_key). That will completely remove attach_type from the picture if the user specified to use sizeof(cgroup_inode_id) as the key_size. If sizeof(struct bpf_cgroup_storage_key) is specified, the attach_type is still used in cmp().
The bpf_cgroup_storage_key_cmp() need to do cmp accordingly.
Same changes is needed to lookup_elem, delete_elem, check_btf, map_alloc...etc.
[ ... ]
kernel/bpf/local_storage.c line 12
Quoted 9 lines
kernel/bpf/local_storage.c +1
-0@@ -9,6 +9,8 @@#include <linux/slab.h> #include <uapi/linux/btf.h> +#include "../cgroup/cgroup-internal.h"
Why?
Others LGTM.
Re: [PATCH v4 bpf-next 3/5] bpf: Make cgroup storages shared across attaches on the same cgroup
Quoted 15 lines · Martin KaFai Lau
I quickly checked zero is actually
BPF_CGROUP_INET_INGRESSinstead of UNSPEC forattach_type. It will be confusing on the syscall side. e.g. map dumping with key.attach_type ==BPF_CGROUP_INET_INGRESSwhile the only cgroup program is actually attaching toBPF_CGROUP_INET_EGRESS.I don't have a clean way out for this. Adding a non-zero UNSPEC to "enum
bpf_attach_type" seems wrong also.
One possible way out is to allow thebpf_cgroup_storage_mapto have a smaller key size (i.e. allow bothsizeof(cgroup_inode_id)and the existingsizeof(struct bpf_cgroup_storage_key). That will completely removeattach_typefrom the picture if the user specified to usesizeof(cgroup_inode_id)as thekey_size. Ifsizeof(struct bpf_cgroup_storage_key)is specified, theattach_typeis still used incmp().
Quoted 2 lines
The
bpf_cgroup_storage_key_cmp()need to do cmp accordingly.
Same changes is needed tolookup_elem,delete_elem,check_btf, map_alloc...etc.
ACK. Considering that the cgroup_inode_id is the first field of struct bpf_cgroup_storage_key, I can probably just use this fact and directly use the user-provided map key (after it's copied to kernel space) and cast the pointer to a __u64 - or are there any architectures where the first field is not at offset zero? If this is done then we can change all the kernel internal APIs to use __u64 cgroup_inode_id, ignoring the existence of the struct aside from the map creation (size checking and BTF checking).
Quoted 2 lines
Quoted 1 line
+#include "
../cgroup/cgroup-internal.h"Why?
cgroup_mutex is declared in this header.
YiFei Zhu
Re: [PATCH v4 bpf-next 3/5] bpf: Make cgroup storages shared across attaches on the same cgroup
Quoted 19 lines · YiFei Zhu
Quoted 15 lines · Martin KaFai Lau
I quickly checked zero is actually
BPF_CGROUP_INET_INGRESSinstead of UNSPEC forattach_type. It will be confusing on the syscall side. e.g. map dumping with key.attach_type ==BPF_CGROUP_INET_INGRESSwhile the only cgroup program is actually attaching toBPF_CGROUP_INET_EGRESS.I don't have a clean way out for this. Adding a non-zero UNSPEC to "enum
bpf_attach_type" seems wrong also.
One possible way out is to allow thebpf_cgroup_storage_mapto have a smaller key size (i.e. allow bothsizeof(cgroup_inode_id)and the existingsizeof(struct bpf_cgroup_storage_key). That will completely removeattach_typefrom the picture if the user specified to usesizeof(cgroup_inode_id)as thekey_size. Ifsizeof(struct bpf_cgroup_storage_key)is specified, theattach_typeis still used incmp().Quoted 2 lines
The
bpf_cgroup_storage_key_cmp()need to do cmp accordingly.
Same changes is needed tolookup_elem,delete_elem,check_btf, map_alloc...etc.
Quoted 8 lines
ACK. Considering that the
cgroup_inode_idis the first field of structbpf_cgroup_storage_key, I can probably just use this fact and directly use the user-provided map key (after it's copied to kernel space) and cast the pointer to a__u64- or are there any architectures where the first field is not at offset zero? If this is done then we can change all the kernel internal APIs to use__u64cgroup_inode_id, ignoring the existence of the struct aside from the map creation (size checking and BTF checking).
Just to be clear. The problem is the userspace is expecting the whole key (cgroup_id, attach_type) to be meaningful and we cannot stop supporting this existing key type now.
This patch essentially sets all attach_type to 0 to mean unused/UNSPEC/dont_care but 0 is actually BPF_CGROUP_INET_INGRESS in bpf's uapi. "map dump" will be an issue as mentioned earlier. Also, as a key of a map,
it is logical for the user to assume that different attach_type will have different storage. e.g. If user lookup by (cgroup_id, 1), what does it mean to quietly return the storage created by (cgroup_id, 0/2/3/4/5)?
I think from the map's perspective, it makes more sense to have different "key-cmp" operation for different key type. When the map is created with key_size == (cgroup_id, attach_type), the "cmp" will stay as is to compare the attach_type also. Then the storage will be sharable among the same cgroup and the
same attach_type.
Then add support for the new key_size == (cgroup_id) which the "cmp" will only compare the "cgroup_id" as this patch does so that the storage can be shared among all attach_types of the same cgroup.
Does it make sense?
Re: [PATCH v4 bpf-next 3/5] bpf: Make cgroup storages shared across attaches on the same cgroup
Quoted 30 lines · Martin KaFai Lau
Quoted 5 lines · YiFei Zhu
Quoted 4 lines · Martin KaFai Lau
I quickly checked zero is actually
BPF_CGROUP_INET_INGRESSinstead of UNSPEC forattach_type. It will be confusing on the syscall side. e.g. map dumping with key.attach_type ==BPF_CGROUP_INET_INGRESSwhile the only cgroup program is actually attaching to
BPF_CGROUP_INET_EGRESS.Quoted 11 lines
Quoted 11 lines
I don't have a clean way out for this. Adding a non-zero UNSPEC to "enum
bpf_attach_type" seems wrong also.
One possible way out is to allow thebpf_cgroup_storage_mapto have a smaller key size (i.e. allow bothsizeof(cgroup_inode_id)and the existingsizeof(struct bpf_cgroup_storage_key). That will completely removeattach_typefrom the picture if the user specified to usesizeof(cgroup_inode_id)as thekey_size. Ifsizeof(struct bpf_cgroup_storage_key)is specified, theattach_typeis still used incmp().Quoted 2 lines
Quoted 2 lines
The
bpf_cgroup_storage_key_cmp()need to do cmp accordingly. Same changes is needed tolookup_elem,delete_elem,check_btf,map_alloc...etc.
Quoted 9 lines
ACK. Considering that the
cgroup_inode_idis the first field of structbpf_cgroup_storage_key, I can probably just use this fact and directly use the user-provided map key (after it's copied to kernel space) and cast the pointer to a__u64- or are there any architectures where the first field is not at offset zero? If this is done then we can change all the kernel internal APIs to use__u64cgroup_inode_id, ignoring the existence of the struct aside from the map creation (size checking and BTF checking).
Quoted 3 lines
Just to be clear. The problem is the userspace is expecting the whole key (
cgroup_id,attach_type) to be meaningful and we cannot stop supporting this existing key type now.
To step back a bit. I think in the commit message we mentioned that attach_type is essentially (mostly) meaningless right now. If I want to share cgroup storage between BPF_CGROUP_INET_INGRESS and BPF_CGROUP_INET_EGRESS, the verifier will refuse to load those programs. So doing lookup with different attach_type for the same storage shouldn't really happen.
Except. There is one use-case where it does make sense. If you take the same loaded program and attach it to both ingress and egress, each one will get a separate storage copy. And only in this case attach_type really has any meaning.
But since more and more attach types started to require expected_attach_type, it seems that the case where the same prog is attached to two different hooks should be almost non-existent. That's why we've decided to go with the idea of completely ignoring it.
So the question is: is it really worth it trying to preserve that obscure use-case (and have more complex implementation) or we can safely assume that nobody is doing that sort of thing in the wild (and can simplify the internal logic a bit)?
Re: [PATCH v4 bpf-next 3/5] bpf: Make cgroup storages shared across attaches on the same cgroup
Quoted 34 lines · On Tue, Jul 21, 2020 at 03:56:36PM -0700, [email protected] wrote:
Quoted 30 lines · Martin KaFai Lau
Quoted 5 lines · YiFei Zhu
Quoted 4 lines · Martin KaFai Lau
I quickly checked zero is actually
BPF_CGROUP_INET_INGRESSinstead of UNSPEC forattach_type. It will be confusing on the syscall side. e.g. map dumping with key.attach_type ==BPF_CGROUP_INET_INGRESSwhile the only cgroup program is actually attaching to
BPF_CGROUP_INET_EGRESS.Quoted 11 lines
Quoted 11 lines
I don't have a clean way out for this. Adding a non-zero UNSPEC to "enum
bpf_attach_type" seems wrong also.
One possible way out is to allow thebpf_cgroup_storage_mapto have a smaller key size (i.e. allow bothsizeof(cgroup_inode_id)and the existingsizeof(struct bpf_cgroup_storage_key). That will completely removeattach_typefrom the picture if the user specified to usesizeof(cgroup_inode_id)as thekey_size. Ifsizeof(struct bpf_cgroup_storage_key)is specified, theattach_typeis still used incmp().Quoted 2 lines
Quoted 2 lines
The
bpf_cgroup_storage_key_cmp()need to do cmp accordingly. Same changes is needed tolookup_elem,delete_elem,check_btf,map_alloc...etc.
Quoted 9 lines
ACK. Considering that the
cgroup_inode_idis the first field of structbpf_cgroup_storage_key, I can probably just use this fact and directly use the user-provided map key (after it's copied to kernel space) and cast the pointer to a__u64- or are there any architectures where the first field is not at offset zero? If this is done then we can change all the kernel internal APIs to use__u64cgroup_inode_id, ignoring the existence of the struct aside from the map creation (size checking and BTF checking).Quoted 3 lines
Just to be clear. The problem is the userspace is expecting the whole key (
cgroup_id,attach_type) to be meaningful and we cannot stop supporting this existing key type now.
Quoted 6 lines
To step back a bit. I think in the commit message we mentioned that
attach_typeis essentially (mostly) meaningless right now. If I want to share cgroup storage betweenBPF_CGROUP_INET_INGRESSandBPF_CGROUP_INET_EGRESS, the verifier will refuse to load those programs. So doing lookup with differentattach_typefor the same storage shouldn't really happen.
I think we are talking about the existing map->aux check in bpf_cgroup_storage_assign()? Right, the map is dedicated for only one bpf prog which usually has only one expected_attach_type. Thus, the attach_type of the key is not really useful since it will always be the same. However, it does not mean the exposed attach_type (of the key) is meaningless or the value is invalid. The exposed value is valid.
I am trying to say attach_type is still part of the key and exposed to userspace (e.g. in map dump) but it is sort of invalid after this change because I am not sure what that "0" means now.
Also, as part of the key, it is intuitive for user to think the storage is unique per (cgroup, attach_type). This uniqueness is always true now because of the map->aux logic and guaranteed by the verifier. With this patch, this "key" intuition is gone where the kernel quietly ignore the attach_type.
Quoted 12 lines
Except. There is one use-case where it does make sense. If you take the same loaded program and attach it to both ingress and egress, each one will get a separate storage copy. And only in this case
attach_typereally has any meaning.But since more and more attach types started to require
expected_attach_type, it seems that the case where the same prog is attached to two different hooks should be almost non-existent. That's why we've decided to go with the idea of completely ignoring it.
Quoted 4 lines
So the question is: is it really worth it trying to preserve that obscure use-case (and have more complex implementation) or we can safely assume that nobody is doing that sort of thing in the wild (and can simplify the internal logic a bit)?
I think it is a reasonable expectation for map-dump to show a meaningful attach_type if it is indeed part of the key.
Re: [PATCH v4 bpf-next 3/5] bpf: Make cgroup storages shared across attaches on the same cgroup
Quoted 13 lines · Martin KaFai Lau
I think we are talking about the existing
map->auxcheck inbpf_cgroup_storage_assign()? Right, the map is dedicated for only one bpf prog which usually has only oneexpected_attach_type. Thus, theattach_typeof the key is not really useful since it will always be the same. However, it does not mean the exposedattach_type(of the key) is meaningless or the value is invalid. The exposed value is valid.I am trying to say
attach_typeis still part of the key and exposed to userspace (e.g. in map dump) but it is sort of invalid after this change because I am not sure what that "0" means now.
Quoted 4 lines
Also, as part of the key, it is intuitive for user to think the storage is unique per (cgroup,
attach_type). This uniqueness is always true now because of themap->auxlogic and guaranteed by the verifier. With this patch, this "key" intuition is gone where the kernel quietly ignore theattach_type.
Right. It is indeed non-intuitive for part of the "key" to be completely ignored in cmp. However, what would a sane solution be instead? I could at attach time, use the attach type to also perform the lookup, and store the attach type as the key, if and only if the size of the key == sizeof(struct cgroup_storage_key). This storage will not be shared across different attach types, only across different programs of the same attach type. The lifetime will still bound to the (map, cgroup_bpf) pair, rather than the program, as the implementation prior to this patch did.
YiFei Zhu
Re: [PATCH v4 bpf-next 3/5] bpf: Make cgroup storages shared across attaches on the same cgroup
Quoted 19 lines · YiFei Zhu
Quoted 13 lines · Martin KaFai Lau
I think we are talking about the existing
map->auxcheck inbpf_cgroup_storage_assign()? Right, the map is dedicated for only one bpf prog which usually has only oneexpected_attach_type. Thus, theattach_typeof the key is not really useful since it will always be the same. However, it does not mean the exposedattach_type(of the key) is meaningless or the value is invalid. The exposed value is valid.I am trying to say
attach_typeis still part of the key and exposed to userspace (e.g. in map dump) but it is sort of invalid after this change because I am not sure what that "0" means now.Quoted 4 lines
Also, as part of the key, it is intuitive for user to think the storage is unique per (cgroup,
attach_type). This uniqueness is always true now because of themap->auxlogic and guaranteed by the verifier. With this patch, this "key" intuition is gone where the kernel quietly ignore theattach_type.
Quoted 5 lines
Right. It is indeed non-intuitive for part of the "key" to be completely ignored in cmp. However, what would a sane solution be instead? I could at attach time, use the attach type to also perform the lookup, and store the attach type as the key, if and only if the size of the key ==
sizeof(struct cgroup_storage_key).
Yes, that makes sense. cgroup_storage_lookup() has the map which has the key_size, so it can decide which part of the key to use for lookup. bpf_cgroup_storages_alloc() does not need to know the details and it just populates everything in bpf_cgroup_storage_key and let cgroup_storage_lookup() to decide.
Thus, it should not be a big change on this patch.
Quoted 5 lines
This storage
will not be shared across different attach types, only across different programs of the same attach type. The lifetime will still bound to the (map,cgroup_bpf) pair, rather than the program, as the implementation prior to this patch did.
Right, the lifetime of the storage should be the same regardless of the key.
The major idea of this patch is to make storage sharable across different bpf-progs and this part does not change. How sharable is defined by the map's key.
The key of the map should behave like a normal map's key. sharable among (cgroup_id, attach_type) or sharable among (cgroup_id)
Then all lookup/update/map-dump will behave like a normal
map without an invalid value "0" (BPF_CGROUP_INET_INGRESS) in the attach_type.
Thus, I don't expect a big change in this patch.
May be restoring the original bpf_cgroup_storage_key_cmp() behavior and a few key_size check in the map_ops's lookup/update/check_btf...etc.