Transit between BPF TCP congestion controls.
Subsystems (8)
v6 cover Transit between BPF TCP congestion controls.
Major changes:
- Create bpf_links in the kernel for BPF struct_ops to register and unregister it.
- Enables switching between implementations of bpf-tcp-cc under a name instantly by replacing the backing struct_ops map of a bpf_link.
Previously, BPF struct_ops didn't go off, as even when the user program creating it was terminated, none of these ever were pinned. For instance, the TCP congestion control subsystem indirectly maintains a reference count on the struct_ops of any registered BPF implemented algorithm. Thus, the algorithm won't be deactivated until someone deliberately unregisters it. For compatibility with other BPF programs, bpf_links have been created to work in coordination with struct_ops maps. This ensures that the registration and unregistration of these respective maps is carried out at the start and end of the bpf_link.
We also faced complications when attempting to replace an existing TCP congestion control algorithm with a new implementation on the fly. A struct_ops map was used to register a TCP congestion control algorithm with a unique name. We had to either register the alternative implementation with a new name and move over or unregister the current one before being able to reregistration with the same name. To fix this problem, we can an option to migrate the registration of the algorithm from struct_ops maps to bpf_links. By modifying the backing map of a bpf_link, it suddenly becomes possible to replace an existing TCP congestion control algorithm with ease.
The major differences from v4:
- Rebase.
- Reorder patches and merge part 4 to part 2 of the v4.
The major differences from v3:
- Remove bpf_struct_ops_map_free_rcu(), and use synchronize_rcu().
- Improve the commit log of the part 1.
- Before transitioning to the READY state, we conduct a value check to ensure that struct_ops can be successfully utilized and links created later.
The major differences from v2:
- Simplify states
- Remove TOBEUNREG.
- Rename UNREG to READY.
- Stop using the refcnt of the kvalue of a struct_ops. Explicitly increase and decrease the refcount of struct_ops.
- Prepare kernel vdata during the load phase of libbpf.
The major differences from v1:
- Added bpf_struct_ops_link to replace the previous union-based approach.
- Added UNREG and TOBEUNREG to the state of bpf_struct_ops_map.
- bpf_struct_ops_transit_state() maintains state transitions.
- Fixed synchronization issue.
- Prepare kernel vdata of struct_ops during the loading phase of bpf_object.
- Merged previous patch 3 to patch 1.
v4: https://lore.kernel.org/all/[email protected]/
v3: https://lore.kernel.org/all/[email protected]/
v2: https://lore.kernel.org/bpf/[email protected]/
v1: https://lore.kernel.org/bpf/[email protected]/
Kui-Feng Lee (8):
bpf: Retire the struct_ops map kvalue->refcnt.
net: Update an existing TCP congestion control algorithm.
bpf: Create links for BPF struct_ops maps.
libbpf: Create a bpf_link in bpf_map__attach_struct_ops().
bpf: Update the struct_ops of a bpf_link.
libbpf: Update a bpf_link with another struct_ops.
libbpf: Use .struct_ops.link section to indicate a struct_ops with a
link.
selftests/bpf: Test switching TCP Congestion Control algorithms.
include/linux/bpf.h | 10 + include/net/tcp.h | 3 + include/uapi/linux/bpf.h | 20 +- kernel/bpf/bpf_struct_ops.c | 229 +++++++++++++++--- kernel/bpf/syscall.c | 49 +++- net/bpf/bpf_dummy_struct_ops.c | 6 + net/ipv4/bpf_tcp_ca.c | 14 +- net/ipv4/tcp_cong.c | 60 ++++- tools/include/uapi/linux/bpf.h | 20 +- tools/lib/bpf/libbpf.c | 180 +++++++++++--- tools/lib/bpf/libbpf.h | 1 + tools/lib/bpf/libbpf.map | 1 + .../selftests/bpf/prog_tests/bpf_tcp_ca.c | 91 +++++++ .../selftests/bpf/progs/tcp_ca_update.c | 80 ++++++ 14 files changed, 671 insertions(+), 93 deletions(-) create mode 100644 tools/testing/selftests/bpf/progs/tcp_ca_update.c
Signature · 1 line
2.34.1
PATCH v6 1/8 bpf: Retire the struct_ops map kvalue->refcnt.
We have replaced kvalue-refcnt with synchronize_rcu() to wait for an RCU grace period.
Maintenance of kvalue->refcnt was a complicated task, as we had to simultaneously keep track of two reference counts: one for the reference count of bpf_map. When the kvalue->refcnt reaches zero, we also have to reduce the reference count on bpf_map - yet these steps are not performed in an atomic manner and require us to be vigilant when managing them. By eliminating kvalue->refcnt, we can make our maintenance more straightforward as the refcount of bpf_map is now solely managed!
To prevent the trampoline image of a struct_ops from being released while it is still in use, we wait for an RCU grace period. The setsockopt(TCP_CONGESTION, "...") command allows you to change your socket's congestion control algorithm and can result in releasing the old struct_ops implementation. Moreover, since this function is exposed through bpf_setsockopt(), it may be accessed by BPF programs as well. To ensure that the trampoline image belonging to struct_op can be safely called while its method is in use, struct_ops is safeguarded with rcu_read_lock(). Doing so prevents any destruction of the associated images before returning from a trampoline and requires us to wait for an RCU grace period.
--- include/linux/bpf.h | 1 + kernel/bpf/bpf_struct_ops.c | 68 ++++++++++++++++++++----------------- kernel/bpf/syscall.c | 6 ++-- 3 files changed, 42 insertions(+), 33 deletions(-)
include/linux/bpf.h +1 -0
@@ -1938,6 +1938,7 @@ struct bpf_map *bpf_map_get_with_uref(u32 ufd);struct bpf_map *__bpf_map_get (struct fd f);void bpf_map_inc (struct bpf_map *map);void bpf_map_inc_with_uref (struct bpf_map *map); +struct bpf_map *__bpf_map_inc_not_zero (struct bpf_map *map,bool uref);struct bpf_map *__must_check bpf_map_inc_not_zero (struct bpf_map *map);void bpf_map_put_with_uref (struct bpf_map *map);void bpf_map_put (struct bpf_map *map);
kernel/bpf/bpf_struct_ops.c +37 -31
118 lines not on this page · raw message
kernel/bpf/syscall.c +4 -2
@@ -1287,8 +1287,10 @@ struct bpf_map *bpf_map_get_with_uref(u32 ufd)return map; } -/* map_idr_lock should have been held */ -static struct bpf_map *__bpf_map_inc_not_zero (struct bpf_map *map,bool uref) +/* map_idr_lock should have been held or the map should have been +* protected by rcu read lock. +*/ +struct bpf_map *__bpf_map_inc_not_zero (struct bpf_map *map,bool uref) {int refold;
Signature · 1 line
2.34.1
Martin KaFai Lau
reviewerRe: [PATCH bpf-next v6 1/8] bpf: Retire the struct_ops map kvalue->refcnt.
Quoted 12 lines · Kui-Feng Lee
We have replaced kvalue-refcnt with
synchronize_rcu()to wait for an RCU grace period.Maintenance of
kvalue->refcntwas a complicated task, as we had to simultaneously keep track of two reference counts: one for the reference count ofbpf_map. When thekvalue->refcntreaches zero, we also have to reduce the reference count onbpf_map- yet these steps are not performed in an atomic manner and require us to be vigilant when managing them. By eliminatingkvalue->refcnt, we can make our maintenance more straightforward as the refcount ofbpf_mapis now solely managed!
Quoted 5 lines
To prevent the trampoline image of a
struct_opsfrom being released while it is still in use, we wait for an RCU grace period. Thesetsockopt(TCP_CONGESTION, "...")command allows you to change your socket's congestion control algorithm and can result in releasing the oldstruct_opsimplementation.
If the setsockopt() above is referring to the syscall setsockopt(), then the old struct_ops is fine. The old struct_ops is protected by the struct_ops map's refcnt (or the current kvalue->refcnt). The sk in setsockopt(sk, ...) will no longer use the old struct_ops before the refcnt is decremented. This part should be the same as the tcp-cc kernel module.
Quoted 7 lines
Moreover, since this function is
exposed throughbpf_setsockopt(), it may be accessed by BPF programs as well. To ensure that the trampoline image belonging tostruct_opcan be safely called while its method is in use,struct_opsis safeguarded withrcu_read_lock(). Doing so prevents any destruction of the associated images before returning from a trampoline and requires us to wait for an RCU grace period.
The bpf_setsockopt(TCP_CONGESTION) is the reason that the trampoline image needs a grace period, but I noticed RCU grace period itself is not enough for trampoline image and more on this later.
Another reason the struct_ops map needs a RCU grace period is because of the bpf_try_module_get() (in tcp_set_default_congestion_control for example).
Quoted 23 lines
--- include/linux/bpf.h | 1 + kernel/bpf/bpf_struct_ops.c | 68 ++++++++++++++++++++----------------- kernel/bpf/syscall.c | 6 ++-- 3 files changed, 42 insertions(+), 33 deletions(-)include/linux/bpf.h +1
-0@@ -1938,6 +1938,7 @@ struct bpf_map *bpf_map_get_with_uref(u32 ufd);struct bpf_map *__bpf_map_get (struct fd f);void bpf_map_inc (struct bpf_map *map);void bpf_map_inc_with_uref (struct bpf_map *map); +struct bpf_map *__bpf_map_inc_not_zero (struct bpf_map *map,bool uref);struct bpf_map *__must_check bpf_map_inc_not_zero (struct bpf_map *map);void bpf_map_put_with_uref (struct bpf_map *map);void bpf_map_put (struct bpf_map *map);kernel/bpf/bpf_struct_ops.c +0
-0
kernel/bpf/bpf_struct_ops.c struct bpf_struct_ops_map { · line 64
Quoted 7 lines
kernel/bpf/bpf_struct_ops.c +4
-0@@ -58,6 +58,11 @@ struct bpf_struct_ops_map {struct bpf_struct_ops_value kvalue; }; +struct bpf_struct_ops_link { +struct bpf_link link; +struct bpf_map __rcu *map; +};
Comparing with v5, this is moved from patch 3 to patch 1. It is not used here, so it belongs to patch 3.
Quoted 6 lines
kernel/bpf/bpf_struct_ops.c +2
-0@@ -574,6 +585,19 @@ static void bpf_struct_ops_map_free(struct bpf_map *map) {struct bpf_struct_ops_map *st_map = (struct bpf_struct_ops_map *)map; +/* The struct_ops's function may switch to another struct_ops. +*
kernel/bpf/bpf_struct_ops.c static void bpf_struct_ops_map_free(struct bpf_map *map) · line 599
Quoted 10 lines
kernel/bpf/bpf_struct_ops.c +10
-0+* For example, bpf_tcp_cc_x->init() may switch to +* another tcp_cc_y by calling +* setsockopt(TCP_CONGESTION, "tcp_cc_y"). +* During the switch, bpf_struct_ops_put(tcp_cc_x) is called +* and its refcount may reach 0 which then free its +* trampoline image while tcp_cc_x is still running. +* +* Thus, a rcu grace period is needed here. +*/ +synchronize_rcu ();
After the trampoline image finished running a struct_ops's "prog", it still has a few insn need to execute in the trampoline image, so it also needs to wait for synchronize_rcu_tasks/call_rcu_tasks.
This is an old issue, only happens when the struct_ops prog calls bpf_setsockopt(TCP_CONGESTION) with CONFIG_PREEMPT and unlikely other upcoming struct_ops subsystem may need this, please help to do a follow up fix on it (separate from this set) to also wait for the rcu_tasks gp.
PATCH v6 2/8 net: Update an existing TCP congestion control algorithm.
In reply to Kui-Feng LeeThis feature lets you immediately transition to another congestion control algorithm or implementation with the same name. Once a name is updated, new connections will apply this new algorithm.
--- include/linux/bpf.h | 1 + include/net/tcp.h | 2 ++ net/bpf/bpf_dummy_struct_ops.c | 6 ++++ net/ipv4/bpf_tcp_ca.c | 6 ++++ net/ipv4/tcp_cong.c | 60 ++++++++++++++++++++++++++++++---- 5 files changed, 68 insertions(+), 7 deletions(-)
include/linux/bpf.h +1 -0
@@ -1511,6 +1511,7 @@ struct bpf_struct_ops { void *kdata, const void *udata);int (*reg)(void *kdata);void (*unreg)(void *kdata); +int (*update)(void *kdata,void *old_kdata);const struct btf_type *type;const struct btf_type *value_type;const char *name;
include/net/tcp.h +2 -0
@@ -1117,6 +1117,8 @@ struct tcp_congestion_ops {int tcp_register_congestion_control (struct tcp_congestion_ops *type);void tcp_unregister_congestion_control (struct tcp_congestion_ops *type); +int tcp_update_congestion_control (struct tcp_congestion_ops *type, +struct tcp_congestion_ops *old_type);void tcp_assign_congestion_control (struct sock *sk);void tcp_init_congestion_control (struct sock *sk);
net/bpf/bpf_dummy_struct_ops.c +6 -0
@@ -222,12 +222,18 @@ static void bpf_dummy_unreg(void *kdata) { } +static int bpf_dummy_update (void *kdata,void *old_kdata) +{ +return -EOPNOTSUPP ; +} +struct bpf_struct_ops bpf_bpf_dummy_ops = { .verifier_ops = &bpf_dummy_verifier_ops, .init = bpf_dummy_init, .check_member = bpf_dummy_ops_check_member, .init_member = bpf_dummy_init_member, .reg = bpf_dummy_reg, + .update = bpf_dummy_update, .unreg = bpf_dummy_unreg, .name ="bpf_dummy_ops" , };
net/ipv4/bpf_tcp_ca.c +6 -0
@@ -266,10 +266,16 @@ static void bpf_tcp_ca_unreg(void *kdata)tcp_unregister_congestion_control (kdata); } +static int bpf_tcp_ca_update (void *kdata,void *old_kdata) +{ +return tcp_update_congestion_control (kdata, old_kdata); +} +struct bpf_struct_ops bpf_tcp_congestion_ops = { .verifier_ops = &bpf_tcp_ca_verifier_ops, .reg = bpf_tcp_ca_reg, .unreg = bpf_tcp_ca_unreg, + .update = bpf_tcp_ca_update, .check_member = bpf_tcp_ca_check_member, .init_member = bpf_tcp_ca_init_member, .init = bpf_tcp_ca_init,
net/ipv4/tcp_cong.c +53 -7
79 lines not on this page · raw message
Signature · 1 line
2.34.1
Re: [PATCH bpf-next v6 2/8] net: Update an existing TCP congestion control algorithm.
Quoted 5 lines · On Thu, 9 Mar 2023 20:38:07 -0800 Kui-Feng Lee <[email protected]> wrote:
This feature lets you immediately transition to another congestion control algorithm or implementation with the same name. Once a name is updated, new connections will apply this new algorithm.
Signed-off-by Kui-Feng Lee <[email protected]>
What is the use case and userspace API for this?
The congestion control algorithm normally doesn't allow this because algorithm specific variables (current state of connection) may not work with another algorithm.
Seems like you are opening Pandora's box here.
Re: [PATCH bpf-next v6 2/8] net: Update an existing TCP congestion control algorithm.
Quoted 7 lines · Stephen Hemminger
Quoted 4 lines · On Thu, 9 Mar 2023 20:38:07 -0800 Kui-Feng Lee <[email protected]> wrote:
This feature lets you immediately transition to another congestion control algorithm or implementation with the same name. Once a name is updated, new connections will apply this new algorithm.
Quoted 6 lines
Quoted 1 line
Signed-off-by Kui-Feng Lee <[email protected]>What is the use case and userspace API for this?
The congestion control algorithm normally doesn't allow this because algorithm specific variables (current state of connection) may not work with another algorithm.
Only new connections will apply the new algorithm, while existing connections keep using the algorithm applied. It shouldn't have the per-connection state/variable issue you mentioned.
It will be used to upgrade an existing algorithm to a new version. The userspace API is used in the 8th patch of this patchset. One of examples in the testcase is
link = bpf_map__attach_struct_ops(skel->maps.ca_update_1); ....... err = bpf_link__update_map(link, skel->maps.ca_update_2);
Calling bpf_link__update_map(...) will register ca_pupdate_2 and unregister ca_update_1 with the same name
in one call. However, the existing connections that has applied ca_update_1 keep using the algorithm except someone call setsockopt(TCP_CONGESTION, ...) on them.
Quoted 2 lines
Seems like you are opening Pandora's box here.
Re: [PATCH bpf-next v6 2/8] net: Update an existing TCP congestion control algorithm.
Quoted 29 lines · Kui-Feng Lee
Quoted 7 lines · Stephen Hemminger
Quoted 4 lines · On Thu, 9 Mar 2023 20:38:07 -0800 Kui-Feng Lee <[email protected]> wrote:
This feature lets you immediately transition to another congestion control algorithm or implementation with the same name. Once a name is updated, new connections will apply this new algorithm.
Quoted 6 lines
Quoted 1 line
Signed-off-by Kui-Feng Lee <[email protected]>What is the use case and userspace API for this?
The congestion control algorithm normally doesn't allow this because algorithm specific variables (current state of connection) may not work with another algorithm.Only new connections will apply the new algorithm, while existing connections keep using the algorithm applied. It shouldn't have the per-connection state/variable issue you mentioned.
It will be used to upgrade an existing algorithm to a new version. The userspace API is used in the 8th patch of this patchset. One of examples in the testcase is
link =
bpf_map__attach_struct_ops(skel->maps.ca_update_1);
.......
err =bpf_link__update_map(link, skel->maps.ca_update_2);
Quoted 5 lines
Calling
bpf_link__update_map(...)will registerca_pupdate_2and unregisterca_update_1with the same name
in one call. However, the existing connections that has appliedca_update_1keep using the algorithm except someone callsetsockopt(TCP_CONGESTION, ...)on them.
FYI!
The thread head of the patchset is
https://lore.kernel.org/all/[email protected]/
Quoted 6 lines
Quoted 5 lines
Seems like you are opening Pandora's box here.
Martin KaFai Lau
reviewerRe: [PATCH bpf-next v6 2/8] net: Update an existing TCP congestion control algorithm.
In reply to Kui-Feng LeeQuoted 3 lines · Kui-Feng Lee
This feature lets you immediately transition to another congestion control algorithm or implementation with the same name. Once a name is updated, new connections will apply this new algorithm.
The commit message needs to explain why the change is needed and some major details on how the patch is doing it. In this case, why a later bpf patch needs it and what major changes are made to tcp_cong.c.
For example,
A later bpf patch will allow attaching a bpf_struct_ops (TCP Congestion Control implemented in bpf) to bpf_link. The later bpf patch will also use the existing bpf_link API to replace a bpf_struct_ops (ie. to replace an old tcp-cc with a new tcp-cc under the same name). This requires a helper function to replace a tcp-cc under a tcp_cong_list_lock. Thus, this patch adds a tcp_update_congestion_control() to replace the "old_ca" with a new "ca".
This patch also takes this chance to refactor the ca validation into the new tcp_validate_congestion_control() function.
Quoted 66 lines
Signed-off-by Kui-Feng Lee <[email protected]>--- include/linux/bpf.h | 1 + include/net/tcp.h | 2 ++ net/bpf/bpf_dummy_struct_ops.c | 6 ++++ net/ipv4/bpf_tcp_ca.c | 6 ++++ net/ipv4/tcp_cong.c | 60 ++++++++++++++++++++++++++++++---- 5 files changed, 68 insertions(+), 7 deletions(-)include/linux/bpf.h +1
-0@@ -1511,6 +1511,7 @@ struct bpf_struct_ops { void *kdata, const void *udata);int (*reg)(void *kdata);void (*unreg)(void *kdata); +int (*update)(void *kdata,void *old_kdata);const struct btf_type *type;const struct btf_type *value_type;const char *name;include/net/tcp.h +2
-0@@ -1117,6 +1117,8 @@ struct tcp_congestion_ops {int tcp_register_congestion_control (struct tcp_congestion_ops *type);void tcp_unregister_congestion_control (struct tcp_congestion_ops *type); +int tcp_update_congestion_control (struct tcp_congestion_ops *type, +struct tcp_congestion_ops *old_type);void tcp_assign_congestion_control (struct sock *sk);void tcp_init_congestion_control (struct sock *sk);net/bpf/bpf_dummy_struct_ops.c +6
-0@@ -222,12 +222,18 @@ static void bpf_dummy_unreg(void *kdata) { } +static int bpf_dummy_update (void *kdata,void *old_kdata) +{ +return -EOPNOTSUPP ; +} +struct bpf_struct_ops bpf_bpf_dummy_ops = { .verifier_ops = &bpf_dummy_verifier_ops, .init = bpf_dummy_init, .check_member = bpf_dummy_ops_check_member, .init_member = bpf_dummy_init_member, .reg = bpf_dummy_reg, + .update = bpf_dummy_update, .unreg = bpf_dummy_unreg, .name ="bpf_dummy_ops" , };net/ipv4/bpf_tcp_ca.c +0
-0@@ -266,10 +266,16 @@ static void bpf_tcp_ca_unreg(void *kdata)tcp_unregister_congestion_control (kdata); }
net/ipv4/bpf_tcp_ca.c static void bpf_tcp_ca_unreg(void *kdata) · line 278
Quoted 10 lines
net/ipv4/bpf_tcp_ca.c +6
-0+static int bpf_tcp_ca_update (void *kdata,void *old_kdata) +{ +return tcp_update_congestion_control (kdata, old_kdata); +} +struct bpf_struct_ops bpf_tcp_congestion_ops = { .verifier_ops = &bpf_tcp_ca_verifier_ops, .reg = bpf_tcp_ca_reg, .unreg = bpf_tcp_ca_unreg, + .update = bpf_tcp_ca_update,
In v5, a comment was given to move the ".update" related changes to patch 5 such that patch 2 will only have netdev change in tcp_cong.c for review purpose.
Please ensure the earlier review comment is addressed in the next revision or reply if the earlier review comment does not make sense. This will save time for the reviewer not to have to repeat the same comment again.
Quoted 3 lines
net/ipv4/bpf_tcp_ca.c +0
-0.check_member = bpf_tcp_ca_check_member, .init_member = bpf_tcp_ca_init_member, .init = bpf_tcp_ca_init,
Re: [PATCH bpf-next v6 2/8] net: Update an existing TCP congestion control algorithm.
Quoted 5 lines · Martin KaFai Lau
Quoted 3 lines · Kui-Feng Lee
This feature lets you immediately transition to another congestion control algorithm or implementation with the same name. Once a name is updated, new connections will apply this new algorithm.
Quoted 7 lines
The commit message needs to explain why the change is needed and some major details on how the patch is doing it. In this case, why a later bpf patch needs it and what major changes are made to
tcp_cong.c.For example,
A later bpf patch will allow attaching a
bpf_struct_ops(TCP Congestion Control implemented in bpf) tobpf_link. The later bpf patch will also use the existingbpf_linkAPI to replace abpf_struct_ops(ie. to replace an old tcp-cc with a new tcp-cc under the same name). This requires a helper function to replace a tcp-cc under atcp_cong_list_lock. Thus, this patch adds atcp_update_congestion_control()to replace the "old_ca" with a new "ca".This patch also takes this chance to refactor the ca validation into the new
tcp_validate_congestion_control()function.
Sure!
Quoted 76 lines
Quoted 63 lines
Signed-off-by Kui-Feng Lee <[email protected]>---
include/linux/bpf.h | 1 +
include/net/tcp.h | 2 ++net/bpf/bpf_dummy_struct_ops.c| 6 ++++ net/ipv4/bpf_tcp_ca.c | 6 ++++ net/ipv4/tcp_cong.c | 60 ++++++++++++++++++++++++++++++----5 files changed, 68 insertions(+), 7 deletions(-)include/linux/bpf.h +1
-0@@ -1511,6 +1511,7 @@ struct bpf_struct_ops { void *kdata, const void *udata); int (*reg)(void *kdata); void (*unreg)(void *kdata); + int (*update)(void *kdata, void *old_kdata); const struct btf_type *type; const struct btf_type *value_type; const char *name;include/net/tcp.h +2
-0@@ -1117,6 +1117,8 @@ struct tcp_congestion_ops { int tcp_register_congestion_control(struct tcp_congestion_ops *type); void tcp_unregister_congestion_control(struct tcp_congestion_ops *type); +int tcp_update_congestion_control (struct tcp_congestion_ops *type, + struct tcp_congestion_ops *old_type); void tcp_assign_congestion_control(struct sock *sk); void tcp_init_congestion_control(struct sock *sk);net/bpf/bpf_dummy_struct_ops.c +6
-0@@ -222,12 +222,18 @@ static void bpf_dummy_unreg(void *kdata) { } +static int bpf_dummy_update (void *kdata,void *old_kdata) +{ + return -EOPNOTSUPP; +} + struct bpf_struct_ops bpf_bpf_dummy_ops = { .verifier_ops = &bpf_dummy_verifier_ops, .init = bpf_dummy_init, .check_member = bpf_dummy_ops_check_member, .init_member = bpf_dummy_init_member, .reg = bpf_dummy_reg, + .update = bpf_dummy_update, .unreg = bpf_dummy_unreg, .name = "bpf_dummy_ops", };net/ipv4/bpf_tcp_ca.c +0
-0@@ -266,10 +266,16 @@ static void bpf_tcp_ca_unreg(void *kdata) tcp_unregister_congestion_control(kdata); }net/ipv4/bpf_tcp_ca.c static void bpf_tcp_ca_unreg(void *kdata) · line 277
Quoted 10 lines
net/ipv4/bpf_tcp_ca.c +6
-0+static int bpf_tcp_ca_update (void *kdata,void *old_kdata) +{ + return tcp_update_congestion_control(kdata, old_kdata); +} + struct bpf_struct_ops bpf_tcp_congestion_ops = { .verifier_ops = &bpf_tcp_ca_verifier_ops, .reg = bpf_tcp_ca_reg, .unreg = bpf_tcp_ca_unreg, + .update = bpf_tcp_ca_update,In v5, a comment was given to move the ".update" related changes to patch 5 such that patch 2 will only have netdev change in
tcp_cong.cfor review purpose.
Quoted 1 line
Please ensure the earlier review comment is addressed in the next revision or reply if the earlier review comment does not make sense. This will save time for the reviewer not to have to repeat the same comment again.
Sorry about this. I only addressed .validate and missed .update. Will fix this.
Quoted 6 lines
Quoted 4 lines
net/ipv4/bpf_tcp_ca.c +0
-0.check_member = bpf_tcp_ca_check_member, .init_member = bpf_tcp_ca_init_member, .init = bpf_tcp_ca_init,
PATCH v6 3/8 bpf: Create links for BPF struct_ops maps.
In reply to Kui-Feng LeeBPF struct_ops maps are employed directly to register TCP Congestion Control algorithms. Unlike other BPF programs that terminate when their links gone. The link of a BPF struct_ops map provides a uniform experience akin to other types of BPF programs.
bpf_links are responsible for registering their associated struct_ops. You can only use a struct_ops that has the BPF_F_LINK flag set to create a bpf_link, while a structs without this flag behaves in the same manner as before and is registered upon updating its value.
The BPF_LINK_TYPE_STRUCT_OPS serves a dual purpose. Not only is it used to craft the links for BPF struct_ops programs, but also to create links for BPF struct_ops them-self. Since the links of BPF struct_ops programs are only used to create trampolines internally, they are never seen in other contexts. Thus, they can be reused for struct_ops themself.
To maintain a reference to the map supporting this link, we add bpf_struct_ops_link as an additional type. The pointer of the map is RCU and won't be necessary until later in the patchset.
--- include/linux/bpf.h | 7 ++ include/net/tcp.h | 1 + include/uapi/linux/bpf.h | 12 ++- kernel/bpf/bpf_struct_ops.c | 133 ++++++++++++++++++++++++++++++++- kernel/bpf/syscall.c | 23 ++++-- net/ipv4/bpf_tcp_ca.c | 8 +- tools/include/uapi/linux/bpf.h | 12 ++- 7 files changed, 181 insertions(+), 15 deletions(-)
include/linux/bpf.h +7 -0
@@ -1512,6 +1512,7 @@ struct bpf_struct_ops {int (*reg)(void *kdata);void (*unreg)(void *kdata);int (*update)(void *kdata,void *old_kdata); +int (*validate)(void *kdata);const struct btf_type *type;const struct btf_type *value_type;const char *name;
@@ -1546,6 +1547,7 @@ static inline void bpf_module_put(const void *data, struct module *owner)else module_put (owner); } +int bpf_struct_ops_link_create (union bpf_attr *attr);#ifdef CONFIG_NET /* Define it here to avoid the use of forward declaration */
@@ -1586,6 +1588,11 @@ static inline int bpf_struct_ops_map_sys_lookup_elem(struct bpf_map *map, {return -EINVAL ; } +static inline int bpf_struct_ops_link_create (union bpf_attr *attr) +{ +return -EOPNOTSUPP ; +} +#endif #if defined(CONFIG_CGROUP_BPF ) && defined(CONFIG_BPF_LSM )
include/net/tcp.h +1 -0
@@ -1119,6 +1119,7 @@ int tcp_register_congestion_control(struct tcp_congestion_ops *type);void tcp_unregister_congestion_control (struct tcp_congestion_ops *type);int tcp_update_congestion_control (struct tcp_congestion_ops *type,struct tcp_congestion_ops *old_type); +int tcp_validate_congestion_control (struct tcp_congestion_ops *ca);void tcp_assign_congestion_control (struct sock *sk);void tcp_init_congestion_control (struct sock *sk);
include/uapi/linux/bpf.h +11 -1
@@ -1033,6 +1033,7 @@ enum bpf_attach_type {BPF_PERF_EVENT ,BPF_TRACE_KPROBE_MULTI ,BPF_LSM_CGROUP , +BPF_STRUCT_OPS , __MAX_BPF_ATTACH_TYPE };
@@ -1266,6 +1267,9 @@ enum {/* Create a map that is suitable to be an inner map with dynamic max entries */ BPF_F_INNER_MAP = (1U <<12 ), + +/* Create a map that will be registered/unregesitered by the backed bpf_link */ + BPF_F_LINK = (1U << 13), };/* Flags for BPF_PROG_QUERY. */
@@ -1507,7 +1511,10 @@ union bpf_attr { } task_fd_query;struct {/* struct used by BPF_LINK_CREATE command */ -__u32 prog_fd;/* eBPF program to attach */ +union { +__u32 prog_fd;/* eBPF program to attach */ +__u32 map_fd;/* struct_ops to attach */ + };union {__u32 target_fd;/* object to attach to */ __u32 target_ifindex;/* target ifindex */
@@ -6379,6 +6386,9 @@ struct bpf_link_info {struct {__u32 ifindex; } xdp; +struct { +__u32 map_id; + } struct_ops; }; } __attribute__((aligned(8)));
kernel/bpf/bpf_struct_ops.c +130 -3
170 lines not on this page · raw message
kernel/bpf/syscall.c +15 -8
@@ -2808,16 +2808,19 @@ static void bpf_link_show_fdinfo(struct seq_file *m, struct file *filp)const struct bpf_prog *prog = link->prog;char prog_tag[sizeof (prog->tag) *2 +1 ] = { }; -bin2hex (prog_tag, prog->tag,sizeof (prog->tag));seq_printf (m,"link_type:\t%s\n" -"link_id:\t%u\n" -"prog_tag:\t%s\n" -"prog_id:\t%u\n" , +"link_id:\t%u\n" , bpf_link_type_strs[link->type], - link->id, - prog_tag, - prog->aux->id); + link->id); +if (prog) { +bin2hex (prog_tag, prog->tag,sizeof (prog->tag)); +seq_printf (m, +"prog_tag:\t%s\n" +"prog_id:\t%u\n" , + prog_tag, + prog->aux->id); + }if (link->ops->show_fdinfo) link->ops->show_fdinfo (link, m); }
@@ -4292,7 +4295,8 @@ static int bpf_link_get_info_by_fd(struct file *file, info.type = link->type; info.id = link->id; - info.prog_id = link->prog->aux->id; +if (link->prog) + info.prog_id = link->prog->aux->id;if (link->ops->fill_link_info) { err = link->ops->fill_link_info (link, &info);
@@ -4555,6 +4559,9 @@ static int link_create(union bpf_attr *attr, bpfptr_t uattr)if (CHECK_ATTR (BPF_LINK_CREATE ))return -EINVAL ; +if (attr->link_create.attach_type ==BPF_STRUCT_OPS ) +return bpf_struct_ops_link_create (attr); + prog =bpf_prog_get (attr->link_create.prog_fd);if (IS_ERR (prog))return PTR_ERR (prog);
net/ipv4/bpf_tcp_ca.c +6 -2
@@ -239,8 +239,6 @@ static int bpf_tcp_ca_init_member(const struct btf_type *t,if (bpf_obj_name_cpy (tcp_ca->name, utcp_ca->name,sizeof (tcp_ca->name)) <=0 )return -EINVAL ; -if (tcp_ca_find (utcp_ca->name)) -return -EEXIST ;return 1 ; }
@@ -271,6 +269,11 @@ static int bpf_tcp_ca_update(void *kdata, void *old_kdata)return tcp_update_congestion_control (kdata, old_kdata); } +static int bpf_tcp_ca_validate (void *kdata) +{ +return tcp_validate_congestion_control (kdata); +} +struct bpf_struct_ops bpf_tcp_congestion_ops = { .verifier_ops = &bpf_tcp_ca_verifier_ops, .reg = bpf_tcp_ca_reg,
@@ -279,6 +282,7 @@ struct bpf_struct_ops bpf_tcp_congestion_ops = { .check_member = bpf_tcp_ca_check_member, .init_member = bpf_tcp_ca_init_member, .init = bpf_tcp_ca_init, + .validate = bpf_tcp_ca_validate, .name = "tcp_congestion_ops", };
tools/include/uapi/linux/bpf.h +11 -1
@@ -1033,6 +1033,7 @@ enum bpf_attach_type {BPF_PERF_EVENT ,BPF_TRACE_KPROBE_MULTI ,BPF_LSM_CGROUP , +BPF_STRUCT_OPS , __MAX_BPF_ATTACH_TYPE };
@@ -1266,6 +1267,9 @@ enum {/* Create a map that is suitable to be an inner map with dynamic max entries */ BPF_F_INNER_MAP = (1U <<12 ), + +/* Create a map that will be registered/unregesitered by the backed bpf_link */ + BPF_F_LINK = (1U << 13), };/* Flags for BPF_PROG_QUERY. */
@@ -1507,7 +1511,10 @@ union bpf_attr { } task_fd_query;struct {/* struct used by BPF_LINK_CREATE command */ -__u32 prog_fd;/* eBPF program to attach */ +union { +__u32 prog_fd;/* eBPF program to attach */ +__u32 map_fd;/* eBPF struct_ops to attach */ + };union {__u32 target_fd;/* object to attach to */ __u32 target_ifindex;/* target ifindex */
@@ -6379,6 +6386,9 @@ struct bpf_link_info {struct {__u32 ifindex; } xdp; +struct { +__u32 map_id; + } struct_ops; }; } __attribute__((aligned(8)));
Signature · 1 line
2.34.1
Martin KaFai Lau
reviewerRe: [PATCH bpf-next v6 3/8] bpf: Create links for BPF struct_ops maps.
Quoted 4 lines · Kui-Feng Lee
BPF
struct_opsmaps are employed directly to register TCP Congestion Control algorithms. Unlike other BPF programs that terminate when their links gone. The link of a BPFstruct_opsmap provides a uniform experience akin to other types of BPF programs.
This part is a little confusing to read. I think it is trying to explain how the current bpf struct_ops uses update_elem to do both "update" and "register". It was done before the bpf_link was introduced. With bpf_link, the prog attach is done at the link creation time and prog detach is done when the link is gone. It is a more consistent experience to do the same for bpf struct_ops: attach (register) bpf_struct_ops during bpf_link creation and detach (unregister) when the link is gone. This patch adds a new link type BPF_LINK_TYPE_STRUCT_OPS for attaching a bpf struct_ops to a subsystem.
Quoted 17 lines
bpf_linksare responsible for registering their associatedstruct_ops. You can only use astruct_opsthat has theBPF_F_LINKflag set to create abpf_link, while a structs without this flag behaves in the same manner as before and is registered upon updating its value.The
BPF_LINK_TYPE_STRUCT_OPSserves a dual purpose. Not only is it used to craft the links for BPFstruct_opsprograms, but also to create links for BPFstruct_opsthem-self. Since the links of BPFstruct_opsprograms are only used to create trampolines internally, they are never seen in other contexts. Thus, they can be reused forstruct_opsthemself.To maintain a reference to the map supporting this link, we add
bpf_struct_ops_linkas an additional type. The pointer of the map is RCU and won't be necessary until later in the patchset.
[ ... ]
include/net/tcp.h int tcp_register_congestion_control(struct tcp_congestion_ops *type); · line 1122
Quoted 9 lines
include/net/tcp.h +1
-0@@ -1119,6 +1119,7 @@ int tcp_register_congestion_control(struct tcp_congestion_ops *type);void tcp_unregister_congestion_control (struct tcp_congestion_ops *type);int tcp_update_congestion_control (struct tcp_congestion_ops *type,struct tcp_congestion_ops *old_type); +int tcp_validate_congestion_control (struct tcp_congestion_ops *ca);
I may not be clear in comment in v5. This is also tcp_cong.c changes and belongs to patch 2.
[ ... ]
Quoted 26 lines
kernel/bpf/bpf_struct_ops.c +10
-1@@ -16,6 +16,7 @@ enum bpf_struct_ops_state {BPF_STRUCT_OPS_STATE_INIT ,BPF_STRUCT_OPS_STATE_INUSE ,BPF_STRUCT_OPS_STATE_TOBEFREE , + BPF_STRUCT_OPS_STATE_READY, };#define BPF_STRUCT_OPS_COMMON_VALUE \@@ -504,11 +505,25 @@ static int bpf_struct_ops_map_update_elem(struct bpf_map *map, void *key, *(unsigned long *)(udata + moff) = prog->aux->id; } -bpf_map_inc (map); +if (st_map->map.map_flags &BPF_F_LINK ) { +if (st_ops->validate) { + err = st_ops->validate (kdata); +if (err) + goto reset_unlock; + } +set_memory_rox ((long )st_map->image,1 ); +/* Let bpf_link handle registration & unregistration. +*
kernel/bpf/bpf_struct_ops.c static int bpf_struct_ops_map_update_elem(struct bpf_map *map, void *key, · line 526
Quoted 10 lines
kernel/bpf/bpf_struct_ops.c +6
-0+* Pair with smp_load_acquire() during lookup_elem(). +*/ +smp_store_release (&kvalue->state,BPF_STRUCT_OPS_STATE_READY ); + goto unlock; + }set_memory_rox ((long )st_map->image,1 ); err = st_ops->reg (kdata);if (likely (!err)) { +bpf_map_inc (map);
The bpf_map_inc(map) line-move for the non BPF_F_LINK case has been spinning in my head since v5 because the bpf_map_inc is now done after publishing the map in reg(). I think it works considering only delete_elem() can remove this map at this point and delete_elem() cannot be run now. It is tricky, so please help to add some comments here.
Quoted 47 lines
kernel/bpf/bpf_struct_ops.c +17
-2/* Pair with smp_load_acquire() during lookup_elem(). * It ensures the above udata updates (e.g. prog->aux->id) * can be seen once BPF_STRUCT_OPS_STATE_INUSE is set. @@ -524,7 +539,6 @@ static int bpf_struct_ops_map_update_elem(struct bpf_map *map, void *key,*/ set_memory_nx ((long )st_map->image,1 );set_memory_rw ((long )st_map->image,1 ); -bpf_map_put (map); reset_unlock:bpf_struct_ops_map_put_progs (st_map);@@ -542,6 +556,9 @@ static int bpf_struct_ops_map_delete_elem(struct bpf_map *map, void *key)struct bpf_struct_ops_map *st_map; st_map = (struct bpf_struct_ops_map *)map; +if (st_map->map.map_flags &BPF_F_LINK ) +return -EOPNOTSUPP ; + prev_state =cmpxchg (&st_map->kvalue.state,BPF_STRUCT_OPS_STATE_INUSE ,BPF_STRUCT_OPS_STATE_TOBEFREE );@@ -609,7 +626,7 @@ static void bpf_struct_ops_map_free(struct bpf_map *map)static int bpf_struct_ops_map_alloc_check (union bpf_attr *attr) {if (attr->key_size !=sizeof (unsigned int ) || attr->max_entries !=1 || - attr->map_flags || !attr->btf_vmlinux_value_type_id) + (attr->map_flags & ~BPF_F_LINK ) || !attr->btf_vmlinux_value_type_id)return -EINVAL ;return 0 ; }@@ -720,3 +737,113 @@ void bpf_struct_ops_put(const void *kdata)bpf_map_put (&st_map->map); } + +static bool bpf_struct_ops_valid_to_reg (struct bpf_map *map) +{ +struct bpf_struct_ops_map *st_map = (struct bpf_struct_ops_map *)map; + +return map->map_type ==BPF_MAP_TYPE_STRUCT_OPS && + map->map_flags &BPF_F_LINK && +/* Pair with smp_store_release() during map_update */ +smp_load_acquire (&st_map->kvalue.state) ==BPF_STRUCT_OPS_STATE_READY ; +} + +static void bpf_struct_ops_map_link_dealloc (struct bpf_link *link) +{
kernel/bpf/bpf_struct_ops.c void bpf_struct_ops_put(const void *kdata) · line 762
Quoted 10 lines
kernel/bpf/bpf_struct_ops.c +10
-0+struct bpf_struct_ops_link *st_link; +struct bpf_struct_ops_map *st_map; + + st_link = container_of(link, struct bpf_struct_ops_link, link); + st_map = (struct bpf_struct_ops_map *) +rcu_dereference_protected (st_link->map, true); +if (st_map) { +/* st_link->map can be NULL if +* bpf_struct_ops_link_create() fails to register. +*/
Thanks for the comment. This helps the review a lot.
Quoted 6 lines
kernel/bpf/bpf_struct_ops.c +6
-0+ st_map->st_ops->unreg (&st_map->kvalue.data); +bpf_map_put (&st_map->map); + } +kfree (st_link); +} +
[ ... ]
Quoted 25 lines
kernel/bpf/bpf_struct_ops.c +25
-0+int bpf_struct_ops_link_create (union bpf_attr *attr) +{ +struct bpf_struct_ops_link *link =NULL ; +struct bpf_link_primer link_primer; +struct bpf_struct_ops_map *st_map; +struct bpf_map *map; +int err; + + map =bpf_map_get (attr->link_create.map_fd); +if (!map) +return -EINVAL ; + + st_map = (struct bpf_struct_ops_map *)map; + +if (!bpf_struct_ops_valid_to_reg (map)) { + err = -EINVAL ; + goto err_out; + } + + link =kzalloc (sizeof (*link),GFP_USER ); +if (!link) { + err = -ENOMEM ; + goto err_out; + } +bpf_link_init (&link->link,BPF_LINK_TYPE_STRUCT_OPS , &bpf_struct_ops_map_lops,NULL );
kernel/bpf/bpf_struct_ops.c void bpf_struct_ops_put(const void *kdata) · line 836
Quoted 10 lines
kernel/bpf/bpf_struct_ops.c +10
-0+RCU_INIT_POINTER (link->map, map); + + err =bpf_link_prime (&link->link, &link_primer); +if (err) + goto err_out; + + err = st_map->st_ops->reg (st_map->kvalue.data); +if (err) { +/* No RCU since no one has a chance to read this pointer yet. */ + link->map =NULL ;
RCU_INIT_POINTER(link->map, NULL). Otherwise, it will have the same sparse warning.
Others lgtm.
Quoted 13 lines
kernel/bpf/bpf_struct_ops.c +13
-0+bpf_link_cleanup (&link_primer); + link =NULL ; + goto err_out; + } + +return bpf_link_settle (&link_primer); + +err_out: +bpf_map_put (map); +kfree (link); +return err; +} +
Re: [PATCH bpf-next v6 3/8] bpf: Create links for BPF struct_ops maps.
Quoted 7 lines · Martin KaFai Lau
Quoted 4 lines · Kui-Feng Lee
BPF
struct_opsmaps are employed directly to register TCP Congestion Control algorithms. Unlike other BPF programs that terminate when their links gone. The link of a BPFstruct_opsmap provides a uniform experience akin to other types of BPF programs.This part is a little confusing to read. I think it is trying to explain how the current bpf
struct_opsusesupdate_elemto do both "update" and "register". It was done before thebpf_linkwas introduced. Withbpf_link, the prog attach is done at the link creation time and prog detach is done when the link is gone. It is a more consistent experience to do the same for bpfstruct_ops: attach (register)bpf_struct_opsduringbpf_linkcreation and detach (unregister) when the link is gone. This patch adds a new link typeBPF_LINK_TYPE_STRUCT_OPSfor attaching a bpfstruct_opsto a subsystem.
Will fix it.
Quoted 21 lines
Quoted 18 lines
bpf_linksare responsible for registering their associatedstruct_ops. You can only use astruct_opsthat has theBPF_F_LINKflag set to create abpf_link, while a structs without this flag behaves in the same manner as before and is registered upon updating its value.The
BPF_LINK_TYPE_STRUCT_OPSserves a dual purpose. Not only is it used to craft the links for BPFstruct_opsprograms, but also to create links for BPFstruct_opsthem-self. Since the links of BPFstruct_opsprograms are only used to create trampolines internally, they are never seen in other contexts. Thus, they can be reused forstruct_opsthemself.To maintain a reference to the map supporting this link, we add
bpf_struct_ops_linkas an additional type. The pointer of the map is RCU and won't be necessary until later in the patchset.[ ... ]
Quoted 12 lines
include/net/tcp.h int tcp_register_congestion_control(struct · line 1123
Quoted 10 lines
include/net/tcp.h +1
-0@@ -1119,6 +1119,7 @@ int tcp_register_congestion_control(struct tcp_congestion_ops *type); void tcp_unregister_congestion_control(struct tcp_congestion_ops *type); int tcp_update_congestion_control(struct tcp_congestion_ops *type, struct tcp_congestion_ops *old_type); +int tcp_validate_congestion_control (struct tcp_congestion_ops *ca);I may not be clear in comment in v5. This is also
tcp_cong.cchanges and belongs to patch 2.
Got it!
Quoted 31 lines
[ ... ]
Quoted 28 lines
kernel/bpf/bpf_struct_ops.c +13
-1@@ -16,6 +16,7 @@ enum bpf_struct_ops_state { BPF_STRUCT_OPS_STATE_INIT, BPF_STRUCT_OPS_STATE_INUSE, BPF_STRUCT_OPS_STATE_TOBEFREE, + BPF_STRUCT_OPS_STATE_READY, }; #define BPF_STRUCT_OPS_COMMON_VALUE \@@ -504,11 +505,25 @@ static int bpf_struct_ops_map_update_elem(struct bpf_map *map, void *key, *(unsigned long *)(udata + moff) = prog->aux->id; } - bpf_map_inc(map); + if (st_map->map.map_flags & BPF_F_LINK) { + if (st_ops->validate) { + err = st_ops->validate(kdata); + if (err) + goto reset_unlock; + } + set_memory_rox((long)st_map->image, 1); + /* Let bpf_link handle registration & unregistration. + * + * Pair with smp_load_acquire() during lookup_elem(). + */ + smp_store_release(&kvalue->state, BPF_STRUCT_OPS_STATE_READY);
Quoted 8 lines
kernel/bpf/bpf_struct_ops.c static int bpf_struct_ops_map_update_elem(struct bpf_map *map, void *key, · line 526
Quoted 6 lines
kernel/bpf/bpf_struct_ops.c +3
-0+ goto unlock; + } set_memory_rox((long)st_map->image, 1); err = st_ops->reg(kdata); if (likely(!err)) { + bpf_map_inc(map);The
bpf_map_inc(map)line-move for the nonBPF_F_LINKcase has been spinning in my head since v5 because thebpf_map_incis now done after publishing the map inreg(). I think it works considering onlydelete_elem()can remove this map at this point anddelete_elem()cannot be run now. It is tricky, so please help to add some comments here.
Yes, we have some assumptions here to make it work. I will put down these assumptions in a comment.
Quoted 104 lines
Quoted 52 lines
kernel/bpf/bpf_struct_ops.c +0
-1/* Pair with smp_load_acquire() during lookup_elem().* It ensures the above udata updates (e.g. prog->aux->id) * can be seen once BPF_STRUCT_OPS_STATE_INUSE is set. @@ -524,7 +539,6 @@ static int bpf_struct_ops_map_update_elem(structbpf_map *map, void *key, */ set_memory_nx((long)st_map->image, 1); set_memory_rw((long)st_map->image, 1); - bpf_map_put(map);
reset_unlock:
bpf_struct_ops_map_put_progs(st_map);kernel/bpf/bpf_struct_ops.c +3
-0@@ -542,6 +556,9 @@ static int bpf_struct_ops_map_delete_elem(struct bpf_map *map, void *key) struct bpf_struct_ops_map *st_map; st_map = (struct bpf_struct_ops_map *)map; + if (st_map->map.map_flags & BPF_F_LINK) + return -EOPNOTSUPP; + prev_state = cmpxchg(&st_map->kvalue.state, BPF_STRUCT_OPS_STATE_INUSE, BPF_STRUCT_OPS_STATE_TOBEFREE);@@ -609,7 +626,7 @@ static void bpf_struct_ops_map_free(struct bpf_map *map) static int bpf_struct_ops_map_alloc_check(union bpf_attr *attr) {if (
attr->key_size!= sizeof(unsigned int) ||attr->max_entries!= 1 || -attr->map_flags|| !attr->btf_vmlinux_value_type_id)
+ (attr->map_flags& ~BPF_F_LINK) || !attr->btf_vmlinux_value_type_id)
return-EINVAL;
return 0;
}kernel/bpf/bpf_struct_ops.c +9
-0@@ -720,3 +737,113 @@ void bpf_struct_ops_put(const void *kdata) bpf_map_put(&st_map->map); } + +static bool bpf_struct_ops_valid_to_reg (struct bpf_map *map) +{ + struct bpf_struct_ops_map *st_map = (struct bpf_struct_ops_map *)map; + + return map->map_type == BPF_MAP_TYPE_STRUCT_OPS && + map->map_flags & BPF_F_LINK && + /* Pair with smp_store_release() during map_update */ + smp_load_acquire(&st_map->kvalue.state) ==
BPF_STRUCT_OPS_STATE_READY;kernel/bpf/bpf_struct_ops.c +4
-0+} + +static void bpf_struct_ops_map_link_dealloc (struct bpf_link *link) +{kernel/bpf/bpf_struct_ops.c void bpf_struct_ops_put(const void *kdata) · line 762
Quoted 10 lines
kernel/bpf/bpf_struct_ops.c +10
-0+ struct bpf_struct_ops_link *st_link; + struct bpf_struct_ops_map *st_map; + + st_link = container_of(link, struct bpf_struct_ops_link, link); + st_map = (struct bpf_struct_ops_map *) + rcu_dereference_protected(st_link->map, true); + if (st_map) { + /* st_link->map can be NULL if +* bpf_struct_ops_link_create() fails to register. +*/ Thanks for the comment. This helps the review a lot.
Quoted 6 lines
+
st_map->st_ops->unreg(&st_map->kvalue.data); +bpf_map_put(&st_map->map);
+ }
+kfree(st_link);kernel/bpf/bpf_struct_ops.c +2
-0+} +[ ... ]
Quoted 30 lines
kernel/bpf/bpf_struct_ops.c +25
-0+int bpf_struct_ops_link_create (union bpf_attr *attr) +{ + struct bpf_struct_ops_link *link = NULL; + struct bpf_link_primer link_primer; + struct bpf_struct_ops_map *st_map; + struct bpf_map *map; + int err; + + map = bpf_map_get(attr->link_create.map_fd); + if (!map) + return -EINVAL; + + st_map = (struct bpf_struct_ops_map *)map; + + if (!bpf_struct_ops_valid_to_reg(map)) { + err = -EINVAL; + goto err_out; + } + + link = kzalloc(sizeof(*link), GFP_USER); + if (!link) { + err = -ENOMEM; + goto err_out; + } + bpf_link_init(&link->link, BPF_LINK_TYPE_STRUCT_OPS,
&bpf_struct_ops_map_lops, NULL);
+RCU_INIT_POINTER(link->map, map);
+
+ err =bpf_link_prime(&link->link, &link_primer); + if (err)
Quoted 8 lines
Quoted 6 lines
+ goto
err_out;
+
+ err =st_map->st_ops->reg(st_map->kvalue.data);
+ if (err) {
+ /* No RCU since no one has a chance to read this pointer yet. */ +link->map= NULL;
RCU_INIT_POINTER(link->map, NULL). Otherwise, it will have the same sparse warning.
Fixed
Quoted 18 lines
Others lgtm.
Quoted 13 lines
+
bpf_link_cleanup(&link_primer);
+ link = NULL;
+ gotoerr_out;
+ }kernel/bpf/bpf_struct_ops.c +9
-0+ + return bpf_link_settle(&link_primer); + +err_out: + bpf_map_put(map); + kfree(link); + return err; +} +
PATCH v6 4/8 libbpf: Create a bpf_link in bpf_map__attach_struct_ops().
In reply to Kui-Feng Leebpf_map__attach_struct_ops() was creating a dummy bpf_link as a placeholder, but now it is constructing an authentic one by calling bpf_link_create() if the map has the BPF_F_LINK flag.
You can flag a struct_ops map with BPF_F_LINK by calling bpf_map__set_map_flags().
--- tools/lib/bpf/libbpf.c | 90 +++++++++++++++++++++++++++++++----------- 1 file changed, 66 insertions(+), 24 deletions(-)
tools/lib/bpf/libbpf.c +66 -24
@@ -116,6 +116,7 @@ static const char * const attach_type_name[] = { [BPF_SK_REUSEPORT_SELECT_OR_MIGRATE] = "sk_reuseport_select_or_migrate", [BPF_PERF_EVENT] = "perf_event", [BPF_TRACE_KPROBE_MULTI] = "trace_kprobe_multi", + [BPF_STRUCT_OPS] = "struct_ops", };static const char *const link_type_name[] = {
@@ -7677,6 +7678,37 @@ static int bpf_object__resolve_externs(struct bpf_object *obj,return 0 ; } +static void bpf_map_prepare_vdata (const struct bpf_map *map) +{ +struct bpf_struct_ops *st_ops; +__u32 i; + + st_ops = map->st_ops; +for (i =0 ; i <btf_vlen (st_ops->type); i++) { +struct bpf_program *prog = st_ops->progs[i]; +void *kern_data; +int prog_fd; + +if (!prog) +continue ; + + prog_fd =bpf_program__fd (prog); + kern_data = st_ops->kern_vdata + st_ops->kern_func_off[i]; + *(unsigned long *)kern_data = prog_fd; + } +} + +static int bpf_object_prepare_struct_ops (struct bpf_object *obj) +{ +int i; + +for (i =0 ; i < obj->nr_maps; i++) +if (bpf_map__is_struct_ops (&obj->maps[i])) +bpf_map_prepare_vdata (&obj->maps[i]); + +return 0 ; +} +static int bpf_object_load (struct bpf_object *obj,int extra_log_level,const char *target_btf_path) {int err, i;
@@ -7702,6 +7734,7 @@ static int bpf_object_load(struct bpf_object *obj, int extra_log_level, const ch err = err ? :bpf_object__relocate (obj, obj->btf_custom_path ? : target_btf_path); err = err ? :bpf_object__load_progs (obj, extra_log_level); err = err ? :bpf_object_init_prog_arrays (obj); + err = err ? :bpf_object_prepare_struct_ops (obj);if (obj->gen_loader) {/* reset FDs */
@@ -11566,22 +11599,30 @@ struct bpf_link *bpf_program__attach(const struct bpf_program *prog)return link; } +struct bpf_link_struct_ops { +struct bpf_link link; +int map_fd; +}; +static int bpf_link__detach_struct_ops (struct bpf_link *link) { +struct bpf_link_struct_ops *st_link;__u32 zero =0 ; -if (bpf_map_delete_elem (link->fd, &zero)) -return -errno; + st_link = container_of(link, struct bpf_link_struct_ops, link); -return 0 ; +if (st_link->map_fd <0 ) +/* w/o a real link */ +return bpf_map_delete_elem (link->fd, &zero); + +return close (link->fd); }struct bpf_link *bpf_map__attach_struct_ops (const struct bpf_map *map) { -struct bpf_struct_ops *st_ops; -struct bpf_link *link; -__u32 i, zero =0 ; -int err; +struct bpf_link_struct_ops *link; +__u32 zero =0 ; +int err, fd;if (!bpf_map__is_struct_ops (map) || map->fd ==-1 )return libbpf_err_ptr (-EINVAL );
@@ -11590,31 +11631,32 @@ struct bpf_link *bpf_map__attach_struct_ops(const struct bpf_map *map)if (!link)return libbpf_err_ptr (-EINVAL ); - st_ops = map->st_ops; -for (i =0 ; i <btf_vlen (st_ops->type); i++) { -struct bpf_program *prog = st_ops->progs[i]; -void *kern_data; -int prog_fd; +/* kern_vdata should be prepared during the loading phase. */ + err =bpf_map_update_elem (map->fd, &zero, map->st_ops->kern_vdata,0 ); +if (err) { +free (link); +return libbpf_err_ptr (err); + } -if (!prog) -continue ; + link->link.detach = bpf_link__detach_struct_ops; - prog_fd =bpf_program__fd (prog); - kern_data = st_ops->kern_vdata + st_ops->kern_func_off[i]; - *(unsigned long *)kern_data = prog_fd; +if (!(map->def.map_flags &BPF_F_LINK )) { +/* w/o a real link */ + link->link.fd = map->fd; + link->map_fd =-1 ; +return &link->link; } - err =bpf_map_update_elem (map->fd, &zero, st_ops->kern_vdata,0 ); -if (err) { - err = -errno; + fd =bpf_link_create (map->fd,-1 ,BPF_STRUCT_OPS ,NULL ); +if (fd <0 ) {free (link); -return libbpf_err_ptr (err); +return libbpf_err_ptr (fd); } - link->detach = bpf_link__detach_struct_ops; - link->fd = map->fd; + link->link.fd = fd; + link->map_fd = map->fd; -return link; +return &link->link; } typedef enum bpf_perf_event_ret (*bpf_perf_event_print_t)(struct perf_event_header *hdr,
Signature · 1 line
2.34.1
PATCH v6 5/8 bpf: Update the struct_ops of a bpf_link.
In reply to Kui-Feng LeeBy improving the BPF_LINK_UPDATE command of bpf(), it should allow you to conveniently switch between different struct_ops on a single bpf_link. This would enable smoother transitions from one struct_ops to another.
The struct_ops maps passing along with BPF_LINK_UPDATE should have the BPF_F_LINK flag.
--- include/linux/bpf.h | 1 + include/uapi/linux/bpf.h | 8 +++++-- kernel/bpf/bpf_struct_ops.c | 40 ++++++++++++++++++++++++++++++++++ kernel/bpf/syscall.c | 20 +++++++++++++++++ tools/include/uapi/linux/bpf.h | 8 +++++-- 5 files changed, 73 insertions(+), 4 deletions(-)
include/linux/bpf.h +1 -0
@@ -1469,6 +1469,7 @@ struct bpf_link_ops {void (*show_fdinfo)(const struct bpf_link *link,struct seq_file *seq);int (*fill_link_info)(const struct bpf_link *link,struct bpf_link_info *info); +int (*update_map)(struct bpf_link *link,struct bpf_map *new_map); };struct bpf_tramp_link {
include/uapi/linux/bpf.h +6 -2
@@ -1555,8 +1555,12 @@ union bpf_attr {struct {/* struct used by BPF_LINK_UPDATE command */ __u32 link_fd;/* link fd */ -/* new program fd to update link with */ -__u32 new_prog_fd; +union { +/* new program fd to update link with */ +__u32 new_prog_fd; +/* new struct_ops map fd to update link with */ +__u32 new_map_fd; + };__u32 flags;/* extra flags */ /* expected link's program fd; is specified only if * BPF_F_REPLACE flag is set in flags */
kernel/bpf/bpf_struct_ops.c +40 -0
@@ -64,6 +64,8 @@ struct bpf_struct_ops_link {struct bpf_map __rcu *map; }; +static DEFINE_MUTEX (update_mutex); +#define VALUE_PREFIX "bpf_struct_ops_"#define VALUE_PREFIX_LEN (sizeof(VALUE_PREFIX) - 1)
@@ -793,10 +795,48 @@ static int bpf_struct_ops_map_link_fill_link_info(const struct bpf_link *link,return 0 ; } +static int bpf_struct_ops_map_link_update (struct bpf_link *link,struct bpf_map *new_map) +{ +struct bpf_struct_ops_map *st_map, *old_st_map; +struct bpf_struct_ops_link *st_link; +struct bpf_map *old_map; +int err =0 ; + + st_link = container_of(link, struct bpf_struct_ops_link, link); + st_map = container_of(new_map, struct bpf_struct_ops_map, map); + +if (!bpf_struct_ops_valid_to_reg (new_map)) +return -EINVAL ; + +mutex_lock (&update_mutex); + + old_map =rcu_dereference_protected (st_link->map,lockdep_is_held (&update_mutex)); + old_st_map = container_of(old_map, struct bpf_struct_ops_map, map); +/* The new and old struct_ops must be the same type. */ +if (st_map->st_ops != old_st_map->st_ops) { + err = -EINVAL ; + goto err_out; + } + + err = st_map->st_ops->update (st_map->kvalue.data, old_st_map->kvalue.data); +if (err) + goto err_out; + +bpf_map_inc (new_map); +rcu_assign_pointer (st_link->map, new_map); +bpf_map_put (old_map); + +err_out: +mutex_unlock (&update_mutex); + +return err; +} +static const struct bpf_link_ops bpf_struct_ops_map_lops = { .dealloc = bpf_struct_ops_map_link_dealloc, .show_fdinfo = bpf_struct_ops_map_link_show_fdinfo, .fill_link_info = bpf_struct_ops_map_link_fill_link_info, + .update_map = bpf_struct_ops_map_link_update, };int bpf_struct_ops_link_create (union bpf_attr *attr)
kernel/bpf/syscall.c +20 -0
@@ -4660,6 +4660,21 @@ static int link_create(union bpf_attr *attr, bpfptr_t uattr)return ret; } +static int link_update_map (struct bpf_link *link,union bpf_attr *attr) +{ +struct bpf_map *new_map; +int ret =0 ; + + new_map =bpf_map_get (attr->link_update.new_map_fd); +if (IS_ERR (new_map)) +return -EINVAL ; + + ret = link->ops->update_map (link, new_map); + +bpf_map_put (new_map); +return ret; +} +#define BPF_LINK_UPDATE_LAST_FIELD link_update.old_prog_fdstatic int link_update (union bpf_attr *attr)
@@ -4680,6 +4695,11 @@ static int link_update(union bpf_attr *attr)if (IS_ERR (link))return PTR_ERR (link); +if (link->ops->update_map) { + ret =link_update_map (link, attr); + goto out_put_link; + } + new_prog =bpf_prog_get (attr->link_update.new_prog_fd);if (IS_ERR (new_prog)) { ret =PTR_ERR (new_prog);
tools/include/uapi/linux/bpf.h +6 -2
@@ -1555,8 +1555,12 @@ union bpf_attr {struct {/* struct used by BPF_LINK_UPDATE command */ __u32 link_fd;/* link fd */ -/* new program fd to update link with */ -__u32 new_prog_fd; +union { +/* new program fd to update link with */ +__u32 new_prog_fd; +/* new struct_ops map fd to update link with */ +__u32 new_map_fd; + };__u32 flags;/* extra flags */ /* expected link's program fd; is specified only if * BPF_F_REPLACE flag is set in flags */
Signature · 1 line
2.34.1
PATCH v6 6/8 libbpf: Update a bpf_link with another struct_ops.
In reply to Kui-Feng LeeIntroduce bpf_link__update_map(), which allows to atomically update underlying struct_ops implementation for given struct_ops BPF link
--- tools/lib/bpf/libbpf.c | 30 ++++++++++++++++++++++++++++++ tools/lib/bpf/libbpf.h | 1 + tools/lib/bpf/libbpf.map | 1 + 3 files changed, 32 insertions(+)
tools/lib/bpf/libbpf.c +30 -0
@@ -11659,6 +11659,36 @@ struct bpf_link *bpf_map__attach_struct_ops(const struct bpf_map *map)return &link->link; } +/* +* Swap the back struct_ops of a link with a new struct_ops map. +*/ +int bpf_link__update_map (struct bpf_link *link,const struct bpf_map *map) +{ +struct bpf_link_struct_ops *st_ops_link; +__u32 zero =0 ; +int err, fd; + +if (!bpf_map__is_struct_ops (map) || map->fd <0 ) +return -EINVAL ; + + st_ops_link = container_of(link, struct bpf_link_struct_ops, link); +/* Ensure the type of a link is correct */ +if (st_ops_link->map_fd <0 ) +return -EINVAL ; + + err =bpf_map_update_elem (map->fd, &zero, map->st_ops->kern_vdata,0 ); +if (err && err != -EBUSY ) +return err; + + fd =bpf_link_update (link->fd, map->fd,NULL ); +if (fd <0 ) +return fd; + + st_ops_link->map_fd = map->fd; + +return 0 ; +} +typedef enum bpf_perf_event_ret (*bpf_perf_event_print_t )(struct perf_event_header *hdr,void *private_data);
tools/lib/bpf/libbpf.h +1 -0
@@ -719,6 +719,7 @@ bpf_program__attach_freplace(const struct bpf_program *prog,struct bpf_map ; LIBBPF_API struct bpf_link *bpf_map__attach_struct_ops(const struct bpf_map *map); +LIBBPF_API int bpf_link__update_map(struct bpf_link *link, const struct bpf_map *map);struct bpf_iter_attach_opts {size_t sz;/* size of this struct for forward/backward compatibility */
tools/lib/bpf/libbpf.map +1 -0
@@ -387,6 +387,7 @@ LIBBPF_1.2.0 { global: bpf_btf_get_info_by_fd; bpf_link_get_info_by_fd; + bpf_link__update_map; bpf_map_get_info_by_fd; bpf_prog_get_info_by_fd; } LIBBPF_1.1.0;
Signature · 1 line
2.34.1
PATCH v6 7/8 libbpf: Use .struct_ops.link section to indicate a struct_ops with a link.
In reply to Kui-Feng LeeFlags a struct_ops is to back a bpf_link by putting it to the ".struct_ops.link" section. Once it is flagged, the created struct_ops can be used to create a bpf_link or update a bpf_link that has been backed by another struct_ops.
--- tools/lib/bpf/libbpf.c | 60 +++++++++++++++++++++++++++++++----------- 1 file changed, 44 insertions(+), 16 deletions(-)
tools/lib/bpf/libbpf.c +44 -16
@@ -468,6 +468,7 @@ struct bpf_struct_ops {#define KCONFIG_SEC ".kconfig"#define KSYMS_SEC ".ksyms"#define STRUCT_OPS_SEC ".struct_ops" +#define STRUCT_OPS_LINK_SEC ".struct_ops.link"enum libbpf_map_type {LIBBPF_MAP_UNSPEC ,
@@ -597,6 +598,7 @@ struct elf_state {Elf64_Ehdr *ehdr;Elf_Data *symbols;Elf_Data *st_ops_data; +Elf_Data *st_ops_link_data;size_t shstrndx;/* section index for section name strings */ size_t strtabidx;struct elf_sec_desc *secs;
@@ -606,6 +608,7 @@ struct elf_state {int text_shndx;int symbols_shndx;int st_ops_shndx; +int st_ops_link_shndx; };struct usdt_manager ;
@@ -1119,7 +1122,8 @@ static int bpf_object__init_kern_struct_ops_maps(struct bpf_object *obj)return 0 ; } -static int bpf_object__init_struct_ops_maps (struct bpf_object *obj) +static int init_struct_ops_maps (struct bpf_object *obj,const char *sec_name, +int shndx,Elf_Data *data,__u32 map_flags) {const struct btf_type *type, *datasec;const struct btf_var_secinfo *vsi;
@@ -1130,15 +1134,15 @@ static int bpf_object__init_struct_ops_maps(struct bpf_object *obj)struct bpf_map *map;__u32 i; -if (obj->efile.st_ops_shndx ==-1 ) +if (shndx ==-1 )return 0 ; btf = obj->btf; - datasec_id =btf__find_by_name_kind (btf,STRUCT_OPS_SEC , + datasec_id =btf__find_by_name_kind (btf, sec_name,BTF_KIND_DATASEC );if (datasec_id <0 ) {pr_warn ("struct_ops init: DATASEC %s not found\n" , -STRUCT_OPS_SEC ); + sec_name);return -EINVAL ; }
@@ -1151,7 +1155,7 @@ static int bpf_object__init_struct_ops_maps(struct bpf_object *obj) type_id =btf__resolve_type (obj->btf, vsi->type);if (type_id <0 ) {pr_warn ("struct_ops init: Cannot resolve var type_id %u in DATASEC %s\n" , - vsi->type,STRUCT_OPS_SEC ); + vsi->type, sec_name);return -EINVAL ; }
@@ -1170,7 +1174,7 @@ static int bpf_object__init_struct_ops_maps(struct bpf_object *obj)if (IS_ERR (map))return PTR_ERR (map); - map->sec_idx = obj->efile.st_ops_shndx; + map->sec_idx = shndx; map->sec_offset = vsi->offset; map->name =strdup (var_name);if (!map->name)
@@ -1180,6 +1184,7 @@ static int bpf_object__init_struct_ops_maps(struct bpf_object *obj) map->def.key_size =sizeof (int ); map->def.value_size = type->size; map->def.max_entries =1 ; + map->def.map_flags = map_flags; map->st_ops =calloc (1 ,sizeof (*map->st_ops));if (!map->st_ops)
@@ -1192,14 +1197,14 @@ static int bpf_object__init_struct_ops_maps(struct bpf_object *obj)if (!st_ops->data || !st_ops->progs || !st_ops->kern_func_off)return -ENOMEM ; -if (vsi->offset + type->size > obj->efile.st_ops_data->d_size) { +if (vsi->offset + type->size > data->d_size) {pr_warn ("struct_ops init: var %s is beyond the end of DATASEC %s\n" , - var_name,STRUCT_OPS_SEC ); + var_name, sec_name);return -EINVAL ; }memcpy (st_ops->data, - obj->efile.st_ops_data->d_buf + vsi->offset, + data->d_buf + vsi->offset, type->size); st_ops->tname = tname; st_ops->type = type;
@@ -1212,6 +1217,19 @@ static int bpf_object__init_struct_ops_maps(struct bpf_object *obj)return 0 ; } +static int bpf_object_init_struct_ops (struct bpf_object *obj) +{ +int err; + + err =init_struct_ops_maps (obj,STRUCT_OPS_SEC , obj->efile.st_ops_shndx, + obj->efile.st_ops_data,0 ); + err = err ?:init_struct_ops_maps (obj,STRUCT_OPS_LINK_SEC , + obj->efile.st_ops_link_shndx, + obj->efile.st_ops_link_data, +BPF_F_LINK ); +return err; +} + static struct bpf_object *bpf_object__new(const char *path, const void *obj_buf, size_t obj_buf_sz,
@@ -1248,6 +1266,7 @@ static struct bpf_object *bpf_object__new(const char *path, obj->efile.obj_buf_sz = obj_buf_sz; obj->efile.btf_maps_shndx =-1 ; obj->efile.st_ops_shndx =-1 ; + obj->efile.st_ops_link_shndx =-1 ; obj->kconfig_map_idx =-1 ; obj->kern_version =get_kernel_version ();
@@ -1265,6 +1284,7 @@ static void bpf_object__elf_finish(struct bpf_object *obj) obj->efile.elf =NULL ; obj->efile.symbols =NULL ; obj->efile.st_ops_data =NULL ; + obj->efile.st_ops_link_data =NULL ;zfree (&obj->efile.secs); obj->efile.sec_cnt =0 ;
@@ -2619,7 +2639,7 @@ static int bpf_object__init_maps(struct bpf_object *obj, err =bpf_object__init_user_btf_maps (obj, strict, pin_root_path); err = err ?:bpf_object__init_global_data_maps (obj); err = err ?:bpf_object__init_kconfig_map (obj); - err = err ?:bpf_object__init_struct_ops_maps (obj); + err = err ?:bpf_object_init_struct_ops (obj);return err; }
@@ -2753,12 +2773,13 @@ static bool libbpf_needs_btf(const struct bpf_object *obj) {return obj->efile.btf_maps_shndx >=0 || obj->efile.st_ops_shndx >=0 || + obj->efile.st_ops_link_shndx >=0 || obj->nr_extern >0 ; }static bool kernel_needs_btf (const struct bpf_object *obj) { -return obj->efile.st_ops_shndx >=0 ; +return obj->efile.st_ops_shndx >=0 || obj->efile.st_ops_link_shndx >=0 ; } static int bpf_object__init_btf(struct bpf_object *obj,
@@ -3451,6 +3472,9 @@ static int bpf_object__elf_collect(struct bpf_object *obj) }else if (strcmp (name,STRUCT_OPS_SEC ) ==0 ) { obj->efile.st_ops_data = data; obj->efile.st_ops_shndx = idx; + }else if (strcmp (name,STRUCT_OPS_LINK_SEC ) ==0 ) { + obj->efile.st_ops_link_data = data; + obj->efile.st_ops_link_shndx = idx; }else {pr_info ("elf: skipping unrecognized data section(%d) %s\n" , idx, name);
@@ -3465,6 +3489,7 @@ static int bpf_object__elf_collect(struct bpf_object *obj)/* Only do relo for section with exec instructions */ if (!section_have_execinstr (obj, targ_sec_idx) &&strcmp (name,".rel" STRUCT_OPS_SEC ) && +strcmp (name,".rel" STRUCT_OPS_LINK_SEC ) &&strcmp (name,".rel" MAPS_ELF_SEC )) { pr_info("elf: skipping relo section(%d) %s for section(%d) %s\n", idx, name, targ_sec_idx,
@@ -6611,7 +6636,7 @@ static int bpf_object__collect_relos(struct bpf_object *obj)return -LIBBPF_ERRNO__INTERNAL ; } -if (idx == obj->efile.st_ops_shndx) +if (idx == obj->efile.st_ops_shndx || idx == obj->efile.st_ops_link_shndx) err =bpf_object__collect_st_ops_relos (obj, shdr, data);else if (idx == obj->efile.btf_maps_shndx) err =bpf_object__collect_map_relos (obj, shdr, data);
@@ -8844,6 +8869,7 @@ const char *libbpf_bpf_prog_type_str(enum bpf_prog_type t) }static struct bpf_map *find_struct_ops_map_by_offset (struct bpf_object *obj, +int sec_idx,size_t offset) {struct bpf_map *map;
@@ -8853,7 +8879,8 @@ static struct bpf_map *find_struct_ops_map_by_offset(struct bpf_object *obj, map = &obj->maps[i];if (!bpf_map__is_struct_ops (map))continue ; -if (map->sec_offset <= offset && +if (map->sec_idx == sec_idx && + map->sec_offset <= offset && offset - map->sec_offset < map->def.value_size)return map; }
@@ -8895,7 +8922,7 @@ static int bpf_object__collect_st_ops_relos(struct bpf_object *obj, } name =elf_sym_str (obj, sym->st_name) ?:"<?>" ; - map =find_struct_ops_map_by_offset (obj, rel->r_offset); + map =find_struct_ops_map_by_offset (obj, shdr->sh_info, rel->r_offset);if (!map) {pr_warn ("struct_ops reloc: cannot find map at rel->r_offset %zu\n" , (size_t )rel->r_offset);
@@ -8962,8 +8989,9 @@ static int bpf_object__collect_st_ops_relos(struct bpf_object *obj, }/* struct_ops BPF prog can be re-used between multiple -* .struct_ops as long as it's the same struct_ops struct -* definition and the same function pointer field +* .struct_ops & .struct_ops.link as long as it's the +* same struct_ops struct definition and the same +* function pointer field */ if (prog->attach_btf_id != st_ops->type_id || prog->expected_attach_type != member_idx) {
Signature · 1 line
2.34.1
PATCH v6 8/8 selftests/bpf: Test switching TCP Congestion Control algorithms.
In reply to Kui-Feng LeeCreate a pair of sockets that utilize the congestion control algorithm under a particular name. Then switch up this congestion control algorithm to another implementation and check whether newly created connections using the same cc name now run the new implementation.
--- .../selftests/bpf/prog_tests/bpf_tcp_ca.c | 91 +++++++++++++++++++ .../selftests/bpf/progs/tcp_ca_update.c | 80 ++++++++++++++++ 2 files changed, 171 insertions(+) create mode 100644 tools/testing/selftests/bpf/progs/tcp_ca_update.c
tools/testing/selftests/bpf/prog_tests/bpf_tcp_ca.c +91 -0
@@ -8,6 +8,7 @@#include "bpf_dctcp.skel.h" #include "bpf_cubic.skel.h" #include "bpf_tcp_nogpl.skel.h" +#include "tcp_ca_update.skel.h" #include "bpf_dctcp_release.skel.h" #include "tcp_ca_write_sk_pacing.skel.h" #include "tcp_ca_incompl_cong_ops.skel.h"
@@ -381,6 +382,90 @@ static void test_unsupp_cong_op(void)libbpf_set_print (old_print_fn); } +static void test_update_ca (void ) +{ +struct tcp_ca_update *skel; +struct bpf_link *link; +int saved_ca1_cnt; +int err; + + skel =tcp_ca_update__open_and_load (); +if (!ASSERT_OK_PTR (skel,"open" )) +return ; + + link =bpf_map__attach_struct_ops (skel->maps.ca_update_1); +ASSERT_OK_PTR (link,"attach_struct_ops" ); + +do_test ("tcp_ca_update" ,NULL ); + saved_ca1_cnt = skel->bss->ca1_cnt; +ASSERT_GT (saved_ca1_cnt,0 ,"ca1_ca1_cnt" ); + + err =bpf_link__update_map (link, skel->maps.ca_update_2); +ASSERT_OK (err,"update_map" ); + +do_test ("tcp_ca_update" ,NULL ); +ASSERT_EQ (skel->bss->ca1_cnt, saved_ca1_cnt,"ca2_ca1_cnt" ); +ASSERT_GT (skel->bss->ca2_cnt,0 ,"ca2_ca2_cnt" ); + +bpf_link__destroy (link); +tcp_ca_update__destroy (skel); +} + +static void test_update_wrong (void ) +{ +struct tcp_ca_update *skel; +struct bpf_link *link; +int saved_ca1_cnt; +int err; + + skel =tcp_ca_update__open_and_load (); +if (!ASSERT_OK_PTR (skel,"open" )) +return ; + + link =bpf_map__attach_struct_ops (skel->maps.ca_update_1); +ASSERT_OK_PTR (link,"attach_struct_ops" ); + +do_test ("tcp_ca_update" ,NULL ); + saved_ca1_cnt = skel->bss->ca1_cnt; +ASSERT_GT (saved_ca1_cnt,0 ,"ca1_ca1_cnt" ); + + err =bpf_link__update_map (link, skel->maps.ca_wrong); +ASSERT_ERR (err,"update_map" ); + +do_test ("tcp_ca_update" ,NULL ); +ASSERT_GT (skel->bss->ca1_cnt, saved_ca1_cnt,"ca2_ca1_cnt" ); + +bpf_link__destroy (link); +tcp_ca_update__destroy (skel); +} + +static void test_mixed_links (void ) +{ +struct tcp_ca_update *skel; +struct bpf_link *link, *link_nl; +int err; + + skel =tcp_ca_update__open_and_load (); +if (!ASSERT_OK_PTR (skel,"open" )) +return ; + + link_nl =bpf_map__attach_struct_ops (skel->maps.ca_no_link); +ASSERT_OK_PTR (link_nl,"attach_struct_ops_nl" ); + + link =bpf_map__attach_struct_ops (skel->maps.ca_update_1); +ASSERT_OK_PTR (link,"attach_struct_ops" ); + +do_test ("tcp_ca_update" ,NULL ); +ASSERT_GT (skel->bss->ca1_cnt,0 ,"ca1_ca1_cnt" ); + + err =bpf_link__update_map (link, skel->maps.ca_no_link); +ASSERT_ERR (err,"update_map" ); + +bpf_link__destroy (link); +bpf_link__destroy (link_nl); +tcp_ca_update__destroy (skel); +} +void test_bpf_tcp_ca (void ) {if (test__start_subtest ("dctcp" ))
@@ -399,4 +484,10 @@ void test_bpf_tcp_ca(void)test_incompl_cong_ops ();if (test__start_subtest ("unsupp_cong_op" ))test_unsupp_cong_op (); +if (test__start_subtest ("update_ca" )) +test_update_ca (); +if (test__start_subtest ("update_wrong" )) +test_update_wrong (); +if (test__start_subtest ("mixed_links" )) +test_mixed_links (); }
tools/testing/selftests/bpf/progs/tcp_ca_update.c new file +80 -0
80 lines not on this page · raw message
Signature · 1 line
2.34.1
Martin KaFai Lau
reviewerRe: [PATCH bpf-next v6 8/8] selftests/bpf: Test switching TCP Congestion Control algorithms.
Quoted 4 lines · Kui-Feng Lee
Create a pair of sockets that utilize the congestion control algorithm under a particular name. Then switch up this congestion control algorithm to another implementation and check whether newly created connections using the same cc name now run the new implementation.
Please update the commit message to include negative tests. Others lgtm.
Quoted 20 lines · Kui-Feng Lee
Major changes:
- Create
bpf_linksin the kernel for BPFstruct_opsto register and unregister it.- Enables switching between implementations of bpf-tcp-cc under a name instantly by replacing the backing
struct_opsmap of abpf_link.Previously, BPF
struct_opsdidn't go off, as even when the user program creating it was terminated, none of these ever were pinned. For instance, the TCP congestion control subsystem indirectly maintains a reference count on thestruct_opsof any registered BPF implemented algorithm. Thus, the algorithm won't be deactivated until someone deliberately unregisters it. For compatibility with other BPF programs,bpf_linkshave been created to work in coordination withstruct_opsmaps. This ensures that the registration and unregistration of these respective maps is carried out at the start and end of thebpf_link.
Quoted 10 lines
We also faced complications when attempting to replace an existing TCP congestion control algorithm with a new implementation on the fly. A
struct_opsmap was used to register a TCP congestion control algorithm with a unique name. We had to either register the alternative implementation with a new name and move over or unregister the current one before being able to reregistration with the same name. To fix this problem, we can an option to migrate the registration of the algorithm fromstruct_opsmaps tobpf_links. By modifying the backing map of abpf_link, it suddenly becomes possible to replace an existing TCP congestion control algorithm with ease.
The major differences from v5:
- Add a new step to bpf_object__load() to prepare vdata.
- Accept BPF_F_REPLACE.
- Check section IDs in find_struct_ops_map_by_offset()
- Add a test case to check mixing w/ & w/o link struct_ops.
- Add a test case of using struct_ops w/o link to update a link.
- Improve bpf_link__detach_struct_ops() to handle the w/ link case.
Quoted 37 lines
The major differences from v4:
- Rebase.
- Reorder patches and merge part 4 to part 2 of the v4.
The major differences from v3:
- Remove
bpf_struct_ops_map_free_rcu(), and usesynchronize_rcu().- Improve the commit log of the part 1.
- Before transitioning to the READY state, we conduct a value check to ensure that
struct_opscan be successfully utilized and links created later.The major differences from v2:
- Simplify states
- Remove TOBEUNREG.
- Rename UNREG to READY.
- Stop using the refcnt of the kvalue of a
struct_ops. Explicitly increase and decrease the refcount ofstruct_ops.- Prepare kernel vdata during the load phase of libbpf.
The major differences from v1:
- Added
bpf_struct_ops_linkto replace the previous union-based approach.- Added UNREG and TOBEUNREG to the state of
bpf_struct_ops_map.
Quoted 9 lines
-
bpf_struct_ops_transit_state()maintains state transitions.- Fixed synchronization issue.
- Prepare kernel vdata of
struct_opsduring the loading phase ofbpf_object.- Merged previous patch 3 to patch 1.
v5: https://lore.kernel.org/all/[email protected]/
Quoted 33 lines
v4: https://lore.kernel.org/all/[email protected]/
v3: https://lore.kernel.org/all/[email protected]/
v2: https://lore.kernel.org/bpf/[email protected]/
v1: https://lore.kernel.org/bpf/[email protected]/Kui-Feng Lee (8):
bpf: Retire thestruct_opsmapkvalue->refcnt.
net: Update an existing TCP congestion control algorithm.
bpf: Create links for BPFstruct_opsmaps.
libbpf: Create abpf_linkinbpf_map__attach_struct_ops().
bpf: Update thestruct_opsof abpf_link.
libbpf: Update abpf_linkwith anotherstruct_ops.
libbpf: Use .struct_ops.link section to indicate astruct_opswith a
link.
selftests/bpf: Test switching TCP Congestion Control algorithms.include/linux/bpf.h | 10 + include/net/tcp.h | 3 + include/uapi/linux/bpf.h | 20 +- kernel/bpf/bpf_struct_ops.c | 229 +++++++++++++++--- kernel/bpf/syscall.c | 49 +++- net/bpf/bpf_dummy_struct_ops.c | 6 + net/ipv4/bpf_tcp_ca.c | 14 +- net/ipv4/tcp_cong.c | 60 ++++- tools/include/uapi/linux/bpf.h | 20 +- tools/lib/bpf/libbpf.c | 180 +++++++++++--- tools/lib/bpf/libbpf.h | 1 + tools/lib/bpf/libbpf.map | 1 + .../selftests/bpf/prog_tests/bpf_tcp_ca.c | 91 +++++++ .../selftests/bpf/progs/tcp_ca_update.c | 80 ++++++ 14 files changed, 671 insertions(+), 93 deletions(-)create mode 100644
tools/testing/selftests/bpf/progs/tcp_ca_update.c