bpf: Implement mprog API on top of existing cgroup progs
Subsystems (6)
Yonghong Song
reviewerv2 cover bpf: Implement mprog API on top of existing cgroup progs
Current cgroup prog ordering is appending at attachment time. This is not ideal. In some cases, users want specific ordering at a particular cgroup level. For example, in Meta, we have a case where three different applications all have cgroup/setsockopt progs and they require specific ordering. Current approach is to use a bpfchainer where one bpf prog contains multiple global functions and each global function can be freplaced by a prog for a specific application. The ordering of global functions decides the ordering of those application specific bpf progs. Using bpfchainer is a centralized approach and is not desirable as one of applications acts as a daemon. The decentralized attachment approach is more favorable for those applications.
To address this, the existing mprog API ([2]) seems an ideal solution with supporting BPF_F_BEFORE and BPF_F_AFTER flags on top of existing cgroup bpf implementation. More specifically, the support is added for prog/link attachment with BPF_F_BEFORE and BPF_F_AFTER. The kernel mprog interface ([2]) is not used and the implementation is directly done in cgroup bpf code base. The mprog 'revision' is also implemented in attach/detach/replace, so users can query revision number to check the change of cgroup prog list.
The patch set contains 4 patches. Patch 1 adds revision support for cgroup bpf progs. Patch 2 implements mprog API implementation for prog/link attach and revision update. Patch 3 adds a new libbpf API to do cgroup link attach with flags like BPF_F_BEFORE/BPF_F_AFTER. Patch 4 adds two tests to validate the implementation.
[1] https://lore.kernel.org/r/[email protected]
[2] https://lore.kernel.org/r/[email protected]
Changelogs:
v1 -> v2:
- v1: https://lore.kernel.org/bpf/[email protected]/
- Change cgroup_bpf.revisions from atomic64_t to u64.
- Added missing bpf_prog_put in various places.
- Rename get_cmp_prog() to get_anchor_prog(). The implementation tries to find the anchor prog regardless of whether id_or_fd is non-NULL or not.
- Rename bpf_cgroup_prog_attached() to is_cgroup_prog_type() and handle BPF_PROG_TYPE_LSM properly (with BPF_LSM_CGROUP attach type).
- I kept 'id || id_or_fd' condition as the condition 'id' is also used in mprog.c so I assume it is okay in cgroup.c as well.
Yonghong Song (4):
cgroup: Add bpf prog revisions to struct cgroup_bpf
bpf: Implement mprog API on top of existing cgroup progs
libbpf: Support link-based cgroup attach with options selftests/bpf: Add two selftests for mprog API based cgroup progs
include/linux/bpf-cgroup-defs.h | 1 + include/uapi/linux/bpf.h | 7 + kernel/bpf/cgroup.c | 144 +++- kernel/bpf/syscall.c | 44 +- kernel/cgroup/cgroup.c | 5 + tools/include/uapi/linux/bpf.h | 7 + tools/lib/bpf/bpf.c | 44 + tools/lib/bpf/bpf.h | 5 + tools/lib/bpf/libbpf.c | 28 + tools/lib/bpf/libbpf.h | 15 + tools/lib/bpf/libbpf.map | 1 + .../bpf/prog_tests/cgroup_mprog_opts.c | 752 ++++++++++++++++++ .../bpf/prog_tests/cgroup_mprog_ordering.c | 77 ++ .../selftests/bpf/progs/cgroup_mprog.c | 30 + 14 files changed, 1123 insertions(+), 37 deletions(-) create mode 100644 tools/testing/selftests/bpf/prog_tests/cgroup_mprog_opts.c create mode 100644 tools/testing/selftests/bpf/prog_tests/cgroup_mprog_ordering.c create mode 100644 tools/testing/selftests/bpf/progs/cgroup_mprog.c
Signature · 1 line
2.47.1
Yonghong Song
reviewerPATCH v2 1/4 cgroup: Add bpf prog revisions to struct cgroup_bpf
One of key items in mprog API is revision for prog list. The revision number will be increased if the prog list changed, e.g., attach, detach or replace.
Add 'revisions' field to struct cgroup_bpf, representing revisions for all cgroup related attachment types. The initial revision value is set to 1, the same as kernel mprog implementations.
--- include/linux/bpf-cgroup-defs.h | 1 + kernel/cgroup/cgroup.c | 5 +++++ 2 files changed, 6 insertions(+)
include/linux/bpf-cgroup-defs.h +1 -0
@@ -63,6 +63,7 @@ struct cgroup_bpf {*/ struct hlist_head progs[MAX_CGROUP_BPF_ATTACH_TYPE ];u8 flags[MAX_CGROUP_BPF_ATTACH_TYPE ]; +u64 revisions[MAX_CGROUP_BPF_ATTACH_TYPE ];/* list of cgroup shared storages */ struct list_head storages;
kernel/cgroup/cgroup.c +5 -0
@@ -2071,6 +2071,11 @@ static void init_cgroup_housekeeping(struct cgroup *cgrp)for_each_subsys (ss, ssid)INIT_LIST_HEAD (&cgrp->e_csets[ssid]); +#ifdef CONFIG_CGROUP_BPF +for (int i =0 ; i <ARRAY_SIZE (cgrp->bpf.revisions); i++) + cgrp->bpf.revisions[i] =1 ; +#endif +init_waitqueue_head (&cgrp->offline_waitq);INIT_WORK (&cgrp->release_agent_work, cgroup1_release_agent); }
Signature · 1 line
2.47.1
Re: [PATCH bpf-next v2 1/4] cgroup: Add bpf prog revisions to struct cgroup_bpf
Quoted 9 lines · Yonghong Song
One of key items in mprog API is revision for prog list. The revision number will be increased if the prog list changed, e.g., attach, detach or replace.
Add 'revisions' field to struct
cgroup_bpf, representing revisions for all cgroup related attachment types. The initial revision value is set to 1, the same as kernel mprog implementations.
Quoted 6 lines
Signed-off-by Yonghong Song <[email protected]>--- include/linux/bpf-cgroup-defs.h | 1 + kernel/cgroup/cgroup.c | 5 +++++ 2 files changed, 6 insertions(+)
LGTM
Quoted 31 lines
include/linux/bpf-cgroup-defs.h +1
-0@@ -63,6 +63,7 @@ struct cgroup_bpf {*/ struct hlist_head progs[MAX_CGROUP_BPF_ATTACH_TYPE ];u8 flags[MAX_CGROUP_BPF_ATTACH_TYPE ]; +u64 revisions[MAX_CGROUP_BPF_ATTACH_TYPE ];/* list of cgroup shared storages */ struct list_head storages;kernel/cgroup/cgroup.c +5
-1@@ -2071,6 +2071,11 @@ static void init_cgroup_housekeeping(struct cgroup *cgrp)for_each_subsys (ss, ssid)INIT_LIST_HEAD (&cgrp->e_csets[ssid]); +#ifdef CONFIG_CGROUP_BPF +for (int i =0 ; i <ARRAY_SIZE (cgrp->bpf.revisions); i++) + cgrp->bpf.revisions[i] =1 ; +#endif +init_waitqueue_head (&cgrp->offline_waitq);INIT_WORK (&cgrp->release_agent_work, cgroup1_release_agent); } --2.47.1
Yonghong Song
reviewerPATCH v2 2/4 bpf: Implement mprog API on top of existing cgroup progs
In reply to Yonghong SongCurrent cgroup prog ordering is appending at attachment time. This is not ideal. In some cases, users want specific ordering at a particular cgroup level. To address this, the existing mprog API seems an ideal solution with supporting BPF_F_BEFORE and BPF_F_AFTER flags.
But there are a few obstacles to directly use kernel mprog interface. Currently cgroup bpf progs already support prog attach/detach/replace and link-based attach/detach/replace. For example, in struct bpf_prog_array_item, the cgroup_storage field needs to be together with bpf prog. But the mprog API struct bpf_mprog_fp only has bpf_prog as the member, which makes it difficult to use kernel mprog interface.
In another case, the current cgroup prog detach tries to use the same flag as in attach. This is different from mprog kernel interface which uses flags passed from user space.
So to avoid modifying existing behavior, I made the following changes to support mprog API for cgroup progs:
- The support is for prog list at cgroup level. Cross-level prog list (a.k.a. effective prog list) is not supported.
- Previously, BPF_F_PREORDER is supported only for prog attach, now BPF_F_PREORDER is also supported by link-based attach.
- For attach, BPF_F_BEFORE/BPF_F_AFTER/BPF_F_ID is supported similar to kernel mprog but with different implementation.
- For detach and replace, use the existing implementation.
- For attach, detach and replace, the revision for a particular prog list, associated with a particular attach type, will be updated by increasing count by 1.
--- include/uapi/linux/bpf.h | 7 ++ kernel/bpf/cgroup.c | 144 ++++++++++++++++++++++++++++----- kernel/bpf/syscall.c | 44 ++++++---- tools/include/uapi/linux/bpf.h | 7 ++ 4 files changed, 165 insertions(+), 37 deletions(-)
include/uapi/linux/bpf.h +7 -0
@@ -1794,6 +1794,13 @@ union bpf_attr { };__u64 expected_revision; } netkit; +struct { +union { +__u32 relative_fd; +__u32 relative_id; + }; +__u64 expected_revision; + } cgroup; }; } link_create;
kernel/bpf/cgroup.c +122 -22
285 lines not on this page · raw message
kernel/bpf/syscall.c +29 -15
74 lines not on this page · raw message
tools/include/uapi/linux/bpf.h +7 -0
@@ -1794,6 +1794,13 @@ union bpf_attr { };__u64 expected_revision; } netkit; +struct { +union { +__u32 relative_fd; +__u32 relative_id; + }; +__u64 expected_revision; + } cgroup; }; } link_create;
Signature · 1 line
2.47.1
Quoted 38 lines · Yonghong Song
Current cgroup prog ordering is appending at attachment time. This is not ideal. In some cases, users want specific ordering at a particular cgroup level. To address this, the existing mprog API seems an ideal solution with supporting
BPF_F_BEFOREandBPF_F_AFTERflags.But there are a few obstacles to directly use kernel mprog interface. Currently cgroup bpf progs already support prog attach/detach/replace and link-based attach/detach/replace. For example, in struct
bpf_prog_array_item, thecgroup_storagefield needs to be together with bpf prog. But the mprog API structbpf_mprog_fponly hasbpf_progas the member, which makes it difficult to use kernel mprog interface.In another case, the current cgroup prog detach tries to use the same flag as in attach. This is different from mprog kernel interface which uses flags passed from user space.
So to avoid modifying existing behavior, I made the following changes to support mprog API for cgroup progs:
- The support is for prog list at cgroup level. Cross-level prog list (a.k.a. effective prog list) is not supported.
- Previously,BPF_F_PREORDERis supported only for prog attach, nowBPF_F_PREORDERis also supported by link-based attach.
- For attach, BPF_F_BEFORE/BPF_F_AFTER/BPF_F_ID is supported similar to kernel mprog but with different implementation.
- For detach and replace, use the existing implementation.
- For attach, detach and replace, the revision for a particular prog list, associated with a particular attach type, will be updated by increasing count by 1.Signed-off-by Yonghong Song <[email protected]>--- include/uapi/linux/bpf.h | 7 ++ kernel/bpf/cgroup.c | 144 ++++++++++++++++++++++++++++----- kernel/bpf/syscall.c | 44 ++++++---- tools/include/uapi/linux/bpf.h | 7 ++ 4 files changed, 165 insertions(+), 37 deletions(-)
[...]
kernel/bpf/cgroup.c static struct bpf_prog_list *find_attach_entry(struct hlist_head *progs, · line 655
Quoted 5 lines
kernel/bpf/cgroup.c +5
-0+if (!anchor_prog) { +hlist_for_each_entry (pltmp, progs, node) { +if ((flags &BPF_F_BEFORE ) && *ppltmp) +break ; + *ppltmp = pltmp;
This is be correct, but it's less obvious why because of all the loops, breaks, and NULL anchor prog. The idea here is to find the very first pl for BPF_F_BEFORE or the very last for BPF_F_AFTER, right? So wouldn't this be more obviously correct:
hlist_for_each_entry(pltmp, progs, node) {
if (flags & BPF_F_BEFORE) {
*ppltmp = pltmp;
return NULL;
}
*ppltmp = pltmp;
}return NULL;
I.e., once you know the result, just return as early as possible and don't require tracing through the rest of code just to eventually return all the same (but now somewhat disguised) values.
Though see my point about anchor_prog below, which will simplify this to just return pltmp;
I'd also add a comment that if there is no anchor_prog, then BPF_F_PREORDER doesn't matter because we either prepend or append to a combined list of progs and end up with correct result
Quoted 23 lines
kernel/bpf/cgroup.c +23
-0+ } + }else { +hlist_for_each_entry (pltmp, progs, node) { + pltmp_prog = pltmp->link ? pltmp->link->link.prog : pltmp->prog; +if (pltmp_prog != anchor_prog) +continue ; +if (!!(pltmp->flags &BPF_F_PREORDER ) != preorder) + goto out; + *ppltmp = pltmp; +break ; + } +if (!*ppltmp) { + ret = -ENOENT ; + goto out; + } + } + +return anchor_prog; + +out: +bpf_prog_put (anchor_prog); +return ERR_PTR (ret); +}
kernel/bpf/cgroup.c static struct bpf_prog_list *find_attach_entry(struct hlist_head *progs, · line 688
Quoted 10 lines
kernel/bpf/cgroup.c +10
-0+ +static int insert_pl_to_hlist (struct bpf_prog_list *pl,struct hlist_head *progs, +struct bpf_prog *prog,u32 flags,u32 id_or_fd) +{ +struct bpf_prog_list *pltmp =NULL ; +struct bpf_prog *anchor_prog; + +/* flags cannot have both BPF_F_BEFORE and BPF_F_AFTER */ +if ((flags &BPF_F_BEFORE ) && (flags &BPF_F_AFTER )) +return -EINVAL ;
I think this should be handled by get_anchor_prog(), both BPF_F_AFTER and BPF_F_BEFORE will just result in no valid anchor program and we'll error out below
kernel/bpf/cgroup.c static struct bpf_prog_list *find_attach_entry(struct hlist_head *progs, · line 692
Quoted 4 lines
kernel/bpf/cgroup.c +4
-0+ + anchor_prog =get_anchor_prog (progs, prog, flags, id_or_fd, &pltmp); +if (IS_ERR (anchor_prog)) +return PTR_ERR (anchor_prog);
it's confusing that we return anchor_prog but actually never use it, no? wouldn't it make more sense to just return struct bpf_prog_list * for an anchor then?
Quoted 44 lines
kernel/bpf/cgroup.c +18
-1+ +if (hlist_empty (progs)) +hlist_add_head (&pl->node, progs); +else if (flags &BPF_F_BEFORE ) +hlist_add_before (&pl->node, &pltmp->node); +else +hlist_add_behind (&pl->node, &pltmp->node); + +return 0 ; +} +/** * __cgroup_bpf_attach() - Attach the program or the link to a cgroup, and * propagate the change to descendants @@ -633,6 +710,8 @@ static struct bpf_prog_list *find_attach_entry(struct hlist_head *progs,* @replace_prog: Previously attached program to replace if BPF_F_REPLACE is set * @type: Type of attach operation * @flags: Option flags +* @id_or_fd: Relative prog id or fd +* @revision: bpf_prog_list revision * * Exactly one of @prog or @link can be non-null. * Must be called with cgroup_mutex held. @@ -640,7 +719,8 @@ static struct bpf_prog_list *find_attach_entry(struct hlist_head *progs,static int __cgroup_bpf_attach (struct cgroup *cgrp,struct bpf_prog *prog,struct bpf_prog *replace_prog,struct bpf_cgroup_link *link, -enum bpf_attach_type type,u32 flags) +enum bpf_attach_type type,u32 flags,u32 id_or_fd, +u64 revision) {u32 saved_flags = (flags & (BPF_F_ALLOW_OVERRIDE |BPF_F_ALLOW_MULTI ));struct bpf_prog *old_prog =NULL ;@@ -656,6 +736,9 @@ static int __cgroup_bpf_attach(struct cgroup *cgrp, ((flags & BPF_F_REPLACE) && !(flags & BPF_F_ALLOW_MULTI)))/* invalid combination */ return -EINVAL ; +if ((flags &BPF_F_REPLACE ) && (flags & (BPF_F_BEFORE |BPF_F_AFTER ))) +/* only either replace or insertion with before/after */ +return -EINVAL ;if (link && (prog || replace_prog))/* only either link or prog/replace_prog can be specified */ return -EINVAL ;
kernel/bpf/cgroup.c static int __cgroup_bpf_attach(struct cgroup *cgrp, · line 749
Quoted 4 lines
kernel/bpf/cgroup.c +1
-0@@ -663,9 +746,12 @@ static int __cgroup_bpf_attach(struct cgroup *cgrp,/* replace_prog implies BPF_F_REPLACE, and vice versa */ return -EINVAL ; +
nit: unnecessary empty line?
Quoted 8 lines
kernel/bpf/cgroup.c +2
-0atype =bpf_cgroup_atype_find (type, new_prog->aux->attach_btf_id);if (atype <0 )return -EINVAL ; +if (revision && revision != cgrp->bpf.revisions[atype]) +return -ESTALE ; progs = &cgrp->bpf.progs[atype];
[...]
kernel/bpf/cgroup.c int cgroup_bpf_link_attach(const union bpf_attr *attr, struct bpf_prog *prog) · line 1413
Quoted 7 lines
kernel/bpf/cgroup.c +2
-1@@ -1312,7 +1409,8 @@ int cgroup_bpf_link_attach(const union bpf_attr *attr, struct bpf_prog *prog)struct cgroup *cgrp;int err; -if (attr->link_create.flags) +if (attr->link_create.flags && + (attr->link_create.flags & (~(BPF_F_ID |BPF_F_BEFORE |BPF_F_AFTER |BPF_F_PREORDER ))))
why the attr->link_create.flags && check, seems unnecessary
also looking at BPF_F_ATTACH_MASK_MPROG, not allowing BPF_F_REPLACE makes sense, but BPF_F_LINK makes sense for ordering, no?
Quoted 45 lines
kernel/bpf/cgroup.c +3
-1return -EINVAL ; cgrp =cgroup_get_from_fd (attr->link_create.target_fd);@@ -1336,7 +1434,9 @@ int cgroup_bpf_link_attach(const union bpf_attr *attr, struct bpf_prog *prog) } err =cgroup_bpf_attach (cgrp,NULL ,NULL , link, - link->type,BPF_F_ALLOW_MULTI ); + link->type,BPF_F_ALLOW_MULTI | attr->link_create.flags, + attr->link_create.cgroup.relative_fd, + attr->link_create.cgroup.expected_revision);if (err) {bpf_link_cleanup (&link_primer); goto out_put_cgroup;kernel/bpf/syscall.c +19
-0@@ -4184,6 +4184,25 @@ static int bpf_prog_attach_check_attach_type(const struct bpf_prog *prog, } } +static bool is_cgroup_prog_type (enum bpf_prog_type ptype,enum bpf_attach_type atype, +bool check_atype) +{ +switch (ptype) { +case BPF_PROG_TYPE_CGROUP_DEVICE : +case BPF_PROG_TYPE_CGROUP_SKB : +case BPF_PROG_TYPE_CGROUP_SOCK : +case BPF_PROG_TYPE_CGROUP_SOCK_ADDR : +case BPF_PROG_TYPE_CGROUP_SOCKOPT : +case BPF_PROG_TYPE_CGROUP_SYSCTL : +case BPF_PROG_TYPE_SOCK_OPS : +return true; +case BPF_PROG_TYPE_LSM : +return check_atype ? atype ==BPF_LSM_CGROUP : true; +default : +return false; + } +} +#define BPF_PROG_ATTACH_LAST_FIELD expected_revision#define BPF_F_ATTACH_MASK_BASE \
kernel/bpf/syscall.c static int bpf_prog_attach(const union bpf_attr *attr) · line 4238
Quoted 6 lines
kernel/bpf/syscall.c +3
-0@@ -4214,6 +4233,9 @@ static int bpf_prog_attach(const union bpf_attr *attr)if (bpf_mprog_supported (ptype)) {if (attr->attach_flags & ~BPF_F_ATTACH_MASK_MPROG )return -EINVAL ; + }else if (is_cgroup_prog_type (ptype,0 , false)) { +if (attr->attach_flags &BPF_F_LINK ) +return -EINVAL ;
Why disable BPF_F_LINK? It's just a matter of using FD/ID for link vs program to specify the place to attach. It doesn't mean that we need to attach through BPF link interface. Or am I misremembering?
Quoted 36 lines
kernel/bpf/syscall.c +4
-15}else {if (attr->attach_flags & ~BPF_F_ATTACH_MASK_BASE )return -EINVAL ;@@ -4242,20 +4264,6 @@ static int bpf_prog_attach(const union bpf_attr *attr)case BPF_PROG_TYPE_FLOW_DISSECTOR : ret =netns_bpf_prog_attach (attr, prog);break ; -case BPF_PROG_TYPE_CGROUP_DEVICE : -case BPF_PROG_TYPE_CGROUP_SKB : -case BPF_PROG_TYPE_CGROUP_SOCK : -case BPF_PROG_TYPE_CGROUP_SOCK_ADDR : -case BPF_PROG_TYPE_CGROUP_SOCKOPT : -case BPF_PROG_TYPE_CGROUP_SYSCTL : -case BPF_PROG_TYPE_SOCK_OPS : -case BPF_PROG_TYPE_LSM : -if (ptype ==BPF_PROG_TYPE_LSM && - prog->expected_attach_type !=BPF_LSM_CGROUP ) - ret = -EINVAL ; -else - ret =cgroup_bpf_prog_attach (attr, ptype, prog); -break ;case BPF_PROG_TYPE_SCHED_CLS :if (attr->attach_type ==BPF_TCX_INGRESS || attr->attach_type ==BPF_TCX_EGRESS )@@ -4264,7 +4272,10 @@ static int bpf_prog_attach(const union bpf_attr *attr) ret =netkit_prog_attach (attr, prog);break ;default : - ret = -EINVAL ; +if (!is_cgroup_prog_type (ptype, prog->expected_attach_type, true)) + ret = -EINVAL ; +else + ret =cgroup_bpf_prog_attach (attr, ptype, prog); }if (ret)
[...]
Quoted 106 lines · Andrii Nakryiko
Quoted 38 lines · Yonghong Song
Current cgroup prog ordering is appending at attachment time. This is not ideal. In some cases, users want specific ordering at a particular cgroup level. To address this, the existing mprog API seems an ideal solution with supporting
BPF_F_BEFOREandBPF_F_AFTERflags.But there are a few obstacles to directly use kernel mprog interface. Currently cgroup bpf progs already support prog attach/detach/replace and link-based attach/detach/replace. For example, in struct
bpf_prog_array_item, thecgroup_storagefield needs to be together with bpf prog. But the mprog API structbpf_mprog_fponly hasbpf_progas the member, which makes it difficult to use kernel mprog interface.In another case, the current cgroup prog detach tries to use the same flag as in attach. This is different from mprog kernel interface which uses flags passed from user space.
So to avoid modifying existing behavior, I made the following changes to support mprog API for cgroup progs:
- The support is for prog list at cgroup level. Cross-level prog list (a.k.a. effective prog list) is not supported.
- Previously,BPF_F_PREORDERis supported only for prog attach, nowBPF_F_PREORDERis also supported by link-based attach.
- For attach, BPF_F_BEFORE/BPF_F_AFTER/BPF_F_ID is supported similar to kernel mprog but with different implementation.
- For detach and replace, use the existing implementation.
- For attach, detach and replace, the revision for a particular prog list, associated with a particular attach type, will be updated by increasing count by 1.Signed-off-by Yonghong Song <[email protected]>--- include/uapi/linux/bpf.h | 7 ++ kernel/bpf/cgroup.c | 144 ++++++++++++++++++++++++++++----- kernel/bpf/syscall.c | 44 ++++++---- tools/include/uapi/linux/bpf.h | 7 ++ 4 files changed, 165 insertions(+), 37 deletions(-)[...]
kernel/bpf/cgroup.c static struct bpf_prog_list *find_attach_entry(struct hlist_head *progs, · line 655
Quoted 5 lines
kernel/bpf/cgroup.c +5
-0+if (!anchor_prog) { +hlist_for_each_entry (pltmp, progs, node) { +if ((flags &BPF_F_BEFORE ) && *ppltmp) +break ; + *ppltmp = pltmp;This is be correct, but it's less obvious why because of all the loops, breaks, and NULL anchor prog. The idea here is to find the very first pl for
BPF_F_BEFOREor the very last forBPF_F_AFTER, right? So wouldn't this be more obviously correct:hlist_for_each_entry(pltmp, progs, node) { if (flags & BPF_F_BEFORE) { *ppltmp = pltmp; return NULL; } *ppltmp = pltmp; }return NULL;
I.e., once you know the result, just return as early as possible and don't require tracing through the rest of code just to eventually return all the same (but now somewhat disguised) values.
Though see my point about
anchor_progbelow, which will simplify this to justreturn pltmp;I'd also add a comment that if there is no
anchor_prog, thenBPF_F_PREORDERdoesn't matter because we either prepend or append to a combined list of progs and end up with correct resultQuoted 29 lines
kernel/bpf/cgroup.c +29
-0+ } + }else { +hlist_for_each_entry (pltmp, progs, node) { + pltmp_prog = pltmp->link ? pltmp->link->link.prog : pltmp->prog; +if (pltmp_prog != anchor_prog) +continue ; +if (!!(pltmp->flags &BPF_F_PREORDER ) != preorder) + goto out; + *ppltmp = pltmp; +break ; + } +if (!*ppltmp) { + ret = -ENOENT ; + goto out; + } + } + +return anchor_prog; + +out: +bpf_prog_put (anchor_prog); +return ERR_PTR (ret); +} + +static int insert_pl_to_hlist (struct bpf_prog_list *pl,struct hlist_head *progs, +struct bpf_prog *prog,u32 flags,u32 id_or_fd) +{ +struct bpf_prog_list *pltmp =NULL ; +struct bpf_prog *anchor_prog;
Quoted 8 lines
kernel/bpf/cgroup.c static struct bpf_prog_list *find_attach_entry(struct hlist_head *progs, · line 688
Quoted 4 lines
kernel/bpf/cgroup.c +4
-0+ +/* flags cannot have both BPF_F_BEFORE and BPF_F_AFTER */ +if ((flags &BPF_F_BEFORE ) && (flags &BPF_F_AFTER )) +return -EINVAL ;I think this should be handled by
get_anchor_prog(), bothBPF_F_AFTERandBPF_F_BEFOREwill just result in no valid anchor program and we'll error out below
Oh, I just randomly realized that there is a special case that I think is allowed by Daniel's mprog implementation, and it might be important for some users. If both BPF_F_BEFORE and BPF_F_AFTER are specified and there is no ID/FD, then this combination would succeed if and only if the currently attached list of progs is empty. Check bpf_mprog_attach() and how it handles BPF_F_BEFORE and BPF_F_AFTER completely independently calculating tidx. If tidx ends up being consistent (which should be -1 for empty list), then that's where the prog/link is inserted (-1 result in prepending into an empty list).
Daniel, can you please double check and generally take a look at this patch set, given you have the most detailed knowledge of mprog interface? Thanks!
Quoted 180 lines
kernel/bpf/cgroup.c static struct bpf_prog_list *find_attach_entry(struct hlist_head *progs, · line 692
Quoted 5 lines
kernel/bpf/cgroup.c +4
-0+ + anchor_prog =get_anchor_prog (progs, prog, flags, id_or_fd, &pltmp); +if (IS_ERR (anchor_prog)) +return PTR_ERR (anchor_prog);it's confusing that we return
anchor_progbut actually never use it, no? wouldn't it make more sense to just return structbpf_prog_list* for an anchor then?Quoted 44 lines
kernel/bpf/cgroup.c +18
-1+ +if (hlist_empty (progs)) +hlist_add_head (&pl->node, progs); +else if (flags &BPF_F_BEFORE ) +hlist_add_before (&pl->node, &pltmp->node); +else +hlist_add_behind (&pl->node, &pltmp->node); + +return 0 ; +} +/** * __cgroup_bpf_attach() - Attach the program or the link to a cgroup, and * propagate the change to descendants @@ -633,6 +710,8 @@ static struct bpf_prog_list *find_attach_entry(struct hlist_head *progs,* @replace_prog: Previously attached program to replace if BPF_F_REPLACE is set * @type: Type of attach operation * @flags: Option flags +* @id_or_fd: Relative prog id or fd +* @revision: bpf_prog_list revision * * Exactly one of @prog or @link can be non-null. * Must be called with cgroup_mutex held. @@ -640,7 +719,8 @@ static struct bpf_prog_list *find_attach_entry(struct hlist_head *progs,static int __cgroup_bpf_attach (struct cgroup *cgrp,struct bpf_prog *prog,struct bpf_prog *replace_prog,struct bpf_cgroup_link *link, -enum bpf_attach_type type,u32 flags) +enum bpf_attach_type type,u32 flags,u32 id_or_fd, +u64 revision) {u32 saved_flags = (flags & (BPF_F_ALLOW_OVERRIDE |BPF_F_ALLOW_MULTI ));struct bpf_prog *old_prog =NULL ;@@ -656,6 +736,9 @@ static int __cgroup_bpf_attach(struct cgroup *cgrp, ((flags & BPF_F_REPLACE) && !(flags & BPF_F_ALLOW_MULTI)))/* invalid combination */ return -EINVAL ; +if ((flags &BPF_F_REPLACE ) && (flags & (BPF_F_BEFORE |BPF_F_AFTER ))) +/* only either replace or insertion with before/after */ +return -EINVAL ;if (link && (prog || replace_prog))/* only either link or prog/replace_prog can be specified */ return -EINVAL ;kernel/bpf/cgroup.c static int __cgroup_bpf_attach(struct cgroup *cgrp, · line 749
Quoted 4 lines
kernel/bpf/cgroup.c +1
-0@@ -663,9 +746,12 @@ static int __cgroup_bpf_attach(struct cgroup *cgrp,/* replace_prog implies BPF_F_REPLACE, and vice versa */ return -EINVAL ; +nit: unnecessary empty line?
Quoted 8 lines
kernel/bpf/cgroup.c +2
-0atype =bpf_cgroup_atype_find (type, new_prog->aux->attach_btf_id);if (atype <0 )return -EINVAL ; +if (revision && revision != cgrp->bpf.revisions[atype]) +return -ESTALE ; progs = &cgrp->bpf.progs[atype];[...]
kernel/bpf/cgroup.c int cgroup_bpf_link_attach(const union bpf_attr *attr, struct bpf_prog *prog) · line 1413
Quoted 7 lines
kernel/bpf/cgroup.c +2
-1@@ -1312,7 +1409,8 @@ int cgroup_bpf_link_attach(const union bpf_attr *attr, struct bpf_prog *prog)struct cgroup *cgrp;int err; -if (attr->link_create.flags) +if (attr->link_create.flags && + (attr->link_create.flags & (~(BPF_F_ID |BPF_F_BEFORE |BPF_F_AFTER |BPF_F_PREORDER ))))why the
attr->link_create.flags &&check, seems unnecessaryalso looking at
BPF_F_ATTACH_MASK_MPROG, not allowingBPF_F_REPLACEmakes sense, butBPF_F_LINKmakes sense for ordering, no?Quoted 45 lines
kernel/bpf/cgroup.c +3
-1return -EINVAL ; cgrp =cgroup_get_from_fd (attr->link_create.target_fd);@@ -1336,7 +1434,9 @@ int cgroup_bpf_link_attach(const union bpf_attr *attr, struct bpf_prog *prog) } err =cgroup_bpf_attach (cgrp,NULL ,NULL , link, - link->type,BPF_F_ALLOW_MULTI ); + link->type,BPF_F_ALLOW_MULTI | attr->link_create.flags, + attr->link_create.cgroup.relative_fd, + attr->link_create.cgroup.expected_revision);if (err) {bpf_link_cleanup (&link_primer); goto out_put_cgroup;kernel/bpf/syscall.c +19
-0@@ -4184,6 +4184,25 @@ static int bpf_prog_attach_check_attach_type(const struct bpf_prog *prog, } } +static bool is_cgroup_prog_type (enum bpf_prog_type ptype,enum bpf_attach_type atype, +bool check_atype) +{ +switch (ptype) { +case BPF_PROG_TYPE_CGROUP_DEVICE : +case BPF_PROG_TYPE_CGROUP_SKB : +case BPF_PROG_TYPE_CGROUP_SOCK : +case BPF_PROG_TYPE_CGROUP_SOCK_ADDR : +case BPF_PROG_TYPE_CGROUP_SOCKOPT : +case BPF_PROG_TYPE_CGROUP_SYSCTL : +case BPF_PROG_TYPE_SOCK_OPS : +return true; +case BPF_PROG_TYPE_LSM : +return check_atype ? atype ==BPF_LSM_CGROUP : true; +default : +return false; + } +} +#define BPF_PROG_ATTACH_LAST_FIELD expected_revision#define BPF_F_ATTACH_MASK_BASE \kernel/bpf/syscall.c static int bpf_prog_attach(const union bpf_attr *attr) · line 4238
Quoted 6 lines
kernel/bpf/syscall.c +3
-0@@ -4214,6 +4233,9 @@ static int bpf_prog_attach(const union bpf_attr *attr)if (bpf_mprog_supported (ptype)) {if (attr->attach_flags & ~BPF_F_ATTACH_MASK_MPROG )return -EINVAL ; + }else if (is_cgroup_prog_type (ptype,0 , false)) { +if (attr->attach_flags &BPF_F_LINK ) +return -EINVAL ;Why disable
BPF_F_LINK? It's just a matter of using FD/ID for link vs program to specify the place to attach. It doesn't mean that we need to attach through BPF link interface. Or am I misremembering?Quoted 36 lines
kernel/bpf/syscall.c +4
-15}else {if (attr->attach_flags & ~BPF_F_ATTACH_MASK_BASE )return -EINVAL ;@@ -4242,20 +4264,6 @@ static int bpf_prog_attach(const union bpf_attr *attr)case BPF_PROG_TYPE_FLOW_DISSECTOR : ret =netns_bpf_prog_attach (attr, prog);break ; -case BPF_PROG_TYPE_CGROUP_DEVICE : -case BPF_PROG_TYPE_CGROUP_SKB : -case BPF_PROG_TYPE_CGROUP_SOCK : -case BPF_PROG_TYPE_CGROUP_SOCK_ADDR : -case BPF_PROG_TYPE_CGROUP_SOCKOPT : -case BPF_PROG_TYPE_CGROUP_SYSCTL : -case BPF_PROG_TYPE_SOCK_OPS : -case BPF_PROG_TYPE_LSM : -if (ptype ==BPF_PROG_TYPE_LSM && - prog->expected_attach_type !=BPF_LSM_CGROUP ) - ret = -EINVAL ; -else - ret =cgroup_bpf_prog_attach (attr, ptype, prog); -break ;case BPF_PROG_TYPE_SCHED_CLS :if (attr->attach_type ==BPF_TCX_INGRESS || attr->attach_type ==BPF_TCX_EGRESS )@@ -4264,7 +4272,10 @@ static int bpf_prog_attach(const union bpf_attr *attr) ret =netkit_prog_attach (attr, prog);break ;default : - ret = -EINVAL ; +if (!is_cgroup_prog_type (ptype, prog->expected_attach_type, true)) + ret = -EINVAL ; +else + ret =cgroup_bpf_prog_attach (attr, ptype, prog); }if (ret)[...]
Yonghong Song
reviewerQuoted 111 lines · Andrii Nakryiko
Quoted 101 lines · Andrii Nakryiko
Quoted 37 lines · Yonghong Song
Current cgroup prog ordering is appending at attachment time. This is not ideal. In some cases, users want specific ordering at a particular cgroup level. To address this, the existing mprog API seems an ideal solution with supporting
BPF_F_BEFOREandBPF_F_AFTERflags.But there are a few obstacles to directly use kernel mprog interface. Currently cgroup bpf progs already support prog attach/detach/replace and link-based attach/detach/replace. For example, in struct
bpf_prog_array_item, thecgroup_storagefield needs to be together with bpf prog. But the mprog API structbpf_mprog_fponly hasbpf_progas the member, which makes it difficult to use kernel mprog interface.In another case, the current cgroup prog detach tries to use the same flag as in attach. This is different from mprog kernel interface which uses flags passed from user space.
So to avoid modifying existing behavior, I made the following changes to support mprog API for cgroup progs:
- The support is for prog list at cgroup level. Cross-level prog list (a.k.a. effective prog list) is not supported.
- Previously,BPF_F_PREORDERis supported only for prog attach, nowBPF_F_PREORDERis also supported by link-based attach.
- For attach, BPF_F_BEFORE/BPF_F_AFTER/BPF_F_ID is supported similar to kernel mprog but with different implementation.
- For detach and replace, use the existing implementation.
- For attach, detach and replace, the revision for a particular prog list, associated with a particular attach type, will be updated by increasing count by 1.Signed-off-by Yonghong Song <[email protected]>--- include/uapi/linux/bpf.h | 7 ++ kernel/bpf/cgroup.c | 144 ++++++++++++++++++++++++++++----- kernel/bpf/syscall.c | 44 ++++++---- tools/include/uapi/linux/bpf.h | 7 ++ 4 files changed, 165 insertions(+), 37 deletions(-)[...]
kernel/bpf/cgroup.c static struct bpf_prog_list *find_attach_entry(struct hlist_head *progs, · line 655
Quoted 5 lines
kernel/bpf/cgroup.c +5
-0+if (!anchor_prog) { +hlist_for_each_entry (pltmp, progs, node) { +if ((flags &BPF_F_BEFORE ) && *ppltmp) +break ; + *ppltmp = pltmp;This is be correct, but it's less obvious why because of all the loops, breaks, and NULL anchor prog. The idea here is to find the very first pl for
BPF_F_BEFOREor the very last forBPF_F_AFTER, right? So wouldn't this be more obviously correct:hlist_for_each_entry(pltmp, progs, node) { if (flags & BPF_F_BEFORE) { *ppltmp = pltmp; return NULL; } *ppltmp = pltmp; }return NULL;
I.e., once you know the result, just return as early as possible and don't require tracing through the rest of code just to eventually return all the same (but now somewhat disguised) values.
Though see my point about
anchor_progbelow, which will simplify this to justreturn pltmp;I'd also add a comment that if there is no
anchor_prog, thenBPF_F_PREORDERdoesn't matter because we either prepend or append to a combined list of progs and end up with correct resultQuoted 28 lines
kernel/bpf/cgroup.c +28
-0+ } + }else { +hlist_for_each_entry (pltmp, progs, node) { + pltmp_prog = pltmp->link ? pltmp->link->link.prog : pltmp->prog; +if (pltmp_prog != anchor_prog) +continue ; +if (!!(pltmp->flags &BPF_F_PREORDER ) != preorder) + goto out; + *ppltmp = pltmp; +break ; + } +if (!*ppltmp) { + ret = -ENOENT ; + goto out; + } + } + +return anchor_prog; + +out: +bpf_prog_put (anchor_prog); +return ERR_PTR (ret); +} + +static int insert_pl_to_hlist (struct bpf_prog_list *pl,struct hlist_head *progs, +struct bpf_prog *prog,u32 flags,u32 id_or_fd) +{ +struct bpf_prog_list *pltmp =NULL ;Quoted 8 lines
kernel/bpf/cgroup.c static struct bpf_prog_list *find_attach_entry(struct hlist_head *progs, · line 688
Quoted 5 lines
kernel/bpf/cgroup.c +5
-0+struct bpf_prog *anchor_prog; + +/* flags cannot have both BPF_F_BEFORE and BPF_F_AFTER */ +if ((flags &BPF_F_BEFORE ) && (flags &BPF_F_AFTER )) +return -EINVAL ;I think this should be handled by
get_anchor_prog(), bothBPF_F_AFTERandBPF_F_BEFOREwill just result in no valid anchor program and we'll error out below
Quoted 9 lines
Oh, I just randomly realized that there is a special case that I think is allowed by Daniel's mprog implementation, and it might be important for some users. If both
BPF_F_BEFOREandBPF_F_AFTERare specified and there is no ID/FD, then this combination would succeed if and only if the currently attached list of progs is empty. Checkbpf_mprog_attach()and how it handlesBPF_F_BEFOREandBPF_F_AFTERcompletely independently calculating tidx. If tidx ends up being consistent (which should be -1 for empty list), then that's where the prog/link is inserted (-1 result in prepending into an empty list).
I will add this support in the next revision.
Quoted 5 lines
Daniel, can you please double check and generally take a look at this patch set, given you have the most detailed knowledge of mprog interface? Thanks!
Daniel, I will have another revision (v3) soon. Hopefully you can review it as well. Thanks!
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
kernel/bpf/cgroup.c +4
-0+ + anchor_prog =get_anchor_prog (progs, prog, flags, id_or_fd, &pltmp); +if (IS_ERR (anchor_prog)) +return PTR_ERR (anchor_prog);
[...]
Yonghong Song
reviewerQuoted 60 lines · Andrii Nakryiko
Quoted 37 lines · Yonghong Song
Current cgroup prog ordering is appending at attachment time. This is not ideal. In some cases, users want specific ordering at a particular cgroup level. To address this, the existing mprog API seems an ideal solution with supporting
BPF_F_BEFOREandBPF_F_AFTERflags.But there are a few obstacles to directly use kernel mprog interface. Currently cgroup bpf progs already support prog attach/detach/replace and link-based attach/detach/replace. For example, in struct
bpf_prog_array_item, thecgroup_storagefield needs to be together with bpf prog. But the mprog API structbpf_mprog_fponly hasbpf_progas the member, which makes it difficult to use kernel mprog interface.In another case, the current cgroup prog detach tries to use the same flag as in attach. This is different from mprog kernel interface which uses flags passed from user space.
So to avoid modifying existing behavior, I made the following changes to support mprog API for cgroup progs:
- The support is for prog list at cgroup level. Cross-level prog list (a.k.a. effective prog list) is not supported.
- Previously,BPF_F_PREORDERis supported only for prog attach, nowBPF_F_PREORDERis also supported by link-based attach.
- For attach, BPF_F_BEFORE/BPF_F_AFTER/BPF_F_ID is supported similar to kernel mprog but with different implementation.
- For detach and replace, use the existing implementation.
- For attach, detach and replace, the revision for a particular prog list, associated with a particular attach type, will be updated by increasing count by 1.Signed-off-by Yonghong Song <[email protected]>--- include/uapi/linux/bpf.h | 7 ++ kernel/bpf/cgroup.c | 144 ++++++++++++++++++++++++++++----- kernel/bpf/syscall.c | 44 ++++++---- tools/include/uapi/linux/bpf.h | 7 ++ 4 files changed, 165 insertions(+), 37 deletions(-)[...]
kernel/bpf/cgroup.c static struct bpf_prog_list *find_attach_entry(struct hlist_head *progs, · line 655
Quoted 5 lines
kernel/bpf/cgroup.c +5
-0+if (!anchor_prog) { +hlist_for_each_entry (pltmp, progs, node) { +if ((flags &BPF_F_BEFORE ) && *ppltmp) +break ; + *ppltmp = pltmp;This is be correct, but it's less obvious why because of all the loops, breaks, and NULL anchor prog. The idea here is to find the very first pl for
BPF_F_BEFOREor the very last forBPF_F_AFTER, right? So wouldn't this be more obviously correct:hlist_for_each_entry(pltmp, progs, node) { if (flags & BPF_F_BEFORE) { *ppltmp = pltmp; return NULL; } *ppltmp = pltmp; }return NULL;
Quoted 7 lines
I.e., once you know the result, just return as early as possible and don't require tracing through the rest of code just to eventually return all the same (but now somewhat disguised) values.
Though see my point about
anchor_progbelow, which will simplify this to justreturn pltmp;
Indeed, returning pltmp sounds a better idea. I will do that.
Quoted 5 lines
I'd also add a comment that if there is no
anchor_prog, thenBPF_F_PREORDERdoesn't matter because we either prepend or append to a combined list of progs and end up with correct result
Okay, will add such comments.
Quoted 29 lines
Quoted 29 lines
kernel/bpf/cgroup.c +28
-0+ } + }else { +hlist_for_each_entry (pltmp, progs, node) { + pltmp_prog = pltmp->link ? pltmp->link->link.prog : pltmp->prog; +if (pltmp_prog != anchor_prog) +continue ; +if (!!(pltmp->flags &BPF_F_PREORDER ) != preorder) + goto out; + *ppltmp = pltmp; +break ; + } +if (!*ppltmp) { + ret = -ENOENT ; + goto out; + } + } + +return anchor_prog; + +out: +bpf_prog_put (anchor_prog); +return ERR_PTR (ret); +} + +static int insert_pl_to_hlist (struct bpf_prog_list *pl,struct hlist_head *progs, +struct bpf_prog *prog,u32 flags,u32 id_or_fd) +{ +struct bpf_prog_list *pltmp =NULL ;
Quoted 8 lines
kernel/bpf/cgroup.c static struct bpf_prog_list *find_attach_entry(struct hlist_head *progs, · line 688
Quoted 5 lines
kernel/bpf/cgroup.c +5
-0+struct bpf_prog *anchor_prog; + +/* flags cannot have both BPF_F_BEFORE and BPF_F_AFTER */ +if ((flags &BPF_F_BEFORE ) && (flags &BPF_F_AFTER )) +return -EINVAL ;I think this should be handled by
get_anchor_prog(), bothBPF_F_AFTERandBPF_F_BEFOREwill just result in no valid anchor program and we'll error out below
Yes. I will move the above flags checking to get_anchor_prog().
Quoted 8 lines
kernel/bpf/cgroup.c static struct bpf_prog_list *find_attach_entry(struct hlist_head *progs, · line 692
Quoted 5 lines
kernel/bpf/cgroup.c +4
-0+ + anchor_prog =get_anchor_prog (progs, prog, flags, id_or_fd, &pltmp); +if (IS_ERR (anchor_prog)) +return PTR_ERR (anchor_prog);it's confusing that we return
anchor_progbut actually never use it, no? wouldn't it make more sense to just return structbpf_prog_list* for an anchor then?
Totally agree. Will return 'struct bpf_prog_list *'.
Quoted 48 lines
Quoted 48 lines
kernel/bpf/cgroup.c +18
-1+ +if (hlist_empty (progs)) +hlist_add_head (&pl->node, progs); +else if (flags &BPF_F_BEFORE ) +hlist_add_before (&pl->node, &pltmp->node); +else +hlist_add_behind (&pl->node, &pltmp->node); + +return 0 ; +} +/** * __cgroup_bpf_attach() - Attach the program or the link to a cgroup, and * propagate the change to descendants @@ -633,6 +710,8 @@ static struct bpf_prog_list *find_attach_entry(struct hlist_head *progs,* @replace_prog: Previously attached program to replace if BPF_F_REPLACE is set * @type: Type of attach operation * @flags: Option flags +* @id_or_fd: Relative prog id or fd +* @revision: bpf_prog_list revision * * Exactly one of @prog or @link can be non-null. * Must be called with cgroup_mutex held. @@ -640,7 +719,8 @@ static struct bpf_prog_list *find_attach_entry(struct hlist_head *progs,static int __cgroup_bpf_attach (struct cgroup *cgrp,struct bpf_prog *prog,struct bpf_prog *replace_prog,struct bpf_cgroup_link *link, -enum bpf_attach_type type,u32 flags) +enum bpf_attach_type type,u32 flags,u32 id_or_fd, +u64 revision) {u32 saved_flags = (flags & (BPF_F_ALLOW_OVERRIDE |BPF_F_ALLOW_MULTI ));struct bpf_prog *old_prog =NULL ;@@ -656,6 +736,9 @@ static int __cgroup_bpf_attach(struct cgroup *cgrp, ((flags & BPF_F_REPLACE) && !(flags & BPF_F_ALLOW_MULTI)))/* invalid combination */ return -EINVAL ; +if ((flags &BPF_F_REPLACE ) && (flags & (BPF_F_BEFORE |BPF_F_AFTER ))) +/* only either replace or insertion with before/after */ +return -EINVAL ;if (link && (prog || replace_prog))/* only either link or prog/replace_prog can be specified */ return -EINVAL ;@@ -663,9 +746,12 @@ static int __cgroup_bpf_attach(struct cgroup *cgrp,/* replace_prog implies BPF_F_REPLACE, and vice versa */ return -EINVAL ;
Quoted 2 lines
Review static int __cgroup_bpf_attach(struct cgroup *cgrp, · line 749
Quoted 1 line
(quoted diff) +1
-0+nit: unnecessary empty line?
Ack
Quoted 15 lines
Quoted 9 lines
kernel/bpf/cgroup.c +2
-0atype =bpf_cgroup_atype_find (type, new_prog->aux->attach_btf_id);if (atype <0 )return -EINVAL ; +if (revision && revision != cgrp->bpf.revisions[atype]) +return -ESTALE ; progs = &cgrp->bpf.progs[atype];[...]
Quoted 4 lines
kernel/bpf/cgroup.c +0
-0@@ -1312,7 +1409,8 @@ int cgroup_bpf_link_attach(const union bpf_attr *attr, struct bpf_prog *prog)struct cgroup *cgrp;int err;
Quoted 8 lines
kernel/bpf/cgroup.c int cgroup_bpf_link_attach(const union bpf_attr *attr, struct bpf_prog *prog) · line 1413
Quoted 3 lines
kernel/bpf/cgroup.c +2
-1-if (attr->link_create.flags) +if (attr->link_create.flags && + (attr->link_create.flags & (~(BPF_F_ID |BPF_F_BEFORE |BPF_F_AFTER |BPF_F_PREORDER ))))why the
attr->link_create.flags &&check, seems unnecessaryalso looking at
BPF_F_ATTACH_MASK_MPROG, not allowingBPF_F_REPLACEmakes sense, butBPF_F_LINKmakes sense for ordering, no?
I didn't add BPF_F_LINK as my current implementation didn't support it. But as you mentioned, mprog API does support it (to find anchor prog). I will add support in the next revision.
Quoted 44 lines
Quoted 44 lines
kernel/bpf/cgroup.c +3
-1return -EINVAL ; cgrp =cgroup_get_from_fd (attr->link_create.target_fd);@@ -1336,7 +1434,9 @@ int cgroup_bpf_link_attach(const union bpf_attr *attr, struct bpf_prog *prog) } err =cgroup_bpf_attach (cgrp,NULL ,NULL , link, - link->type,BPF_F_ALLOW_MULTI ); + link->type,BPF_F_ALLOW_MULTI | attr->link_create.flags, + attr->link_create.cgroup.relative_fd, + attr->link_create.cgroup.expected_revision);if (err) {bpf_link_cleanup (&link_primer); goto out_put_cgroup;kernel/bpf/syscall.c +19
-0@@ -4184,6 +4184,25 @@ static int bpf_prog_attach_check_attach_type(const struct bpf_prog *prog, } } +static bool is_cgroup_prog_type (enum bpf_prog_type ptype,enum bpf_attach_type atype, +bool check_atype) +{ +switch (ptype) { +case BPF_PROG_TYPE_CGROUP_DEVICE : +case BPF_PROG_TYPE_CGROUP_SKB : +case BPF_PROG_TYPE_CGROUP_SOCK : +case BPF_PROG_TYPE_CGROUP_SOCK_ADDR : +case BPF_PROG_TYPE_CGROUP_SOCKOPT : +case BPF_PROG_TYPE_CGROUP_SYSCTL : +case BPF_PROG_TYPE_SOCK_OPS : +return true; +case BPF_PROG_TYPE_LSM : +return check_atype ? atype ==BPF_LSM_CGROUP : true; +default : +return false; + } +} +#define BPF_PROG_ATTACH_LAST_FIELD expected_revision
Quoted 11 lines
kernel/bpf/syscall.c static int bpf_prog_attach(const union bpf_attr *attr) · line 4238
Quoted 8 lines
kernel/bpf/syscall.c +3
-0#define BPF_F_ATTACH_MASK_BASE \@@ -4214,6 +4233,9 @@ static int bpf_prog_attach(const union bpf_attr *attr)if (bpf_mprog_supported (ptype)) {if (attr->attach_flags & ~BPF_F_ATTACH_MASK_MPROG )return -EINVAL ; + }else if (is_cgroup_prog_type (ptype,0 , false)) { +if (attr->attach_flags &BPF_F_LINK ) +return -EINVAL ;Why disable
BPF_F_LINK? It's just a matter of using FD/ID for link vs program to specify the place to attach. It doesn't mean that we need to attach through BPF link interface. Or am I misremembering?
Again, I didn't implement it. Will add support in the next revision.
Quoted 38 lines
Quoted 37 lines
kernel/bpf/syscall.c +4
-15}else {if (attr->attach_flags & ~BPF_F_ATTACH_MASK_BASE )return -EINVAL ;@@ -4242,20 +4264,6 @@ static int bpf_prog_attach(const union bpf_attr *attr)case BPF_PROG_TYPE_FLOW_DISSECTOR : ret =netns_bpf_prog_attach (attr, prog);break ; -case BPF_PROG_TYPE_CGROUP_DEVICE : -case BPF_PROG_TYPE_CGROUP_SKB : -case BPF_PROG_TYPE_CGROUP_SOCK : -case BPF_PROG_TYPE_CGROUP_SOCK_ADDR : -case BPF_PROG_TYPE_CGROUP_SOCKOPT : -case BPF_PROG_TYPE_CGROUP_SYSCTL : -case BPF_PROG_TYPE_SOCK_OPS : -case BPF_PROG_TYPE_LSM : -if (ptype ==BPF_PROG_TYPE_LSM && - prog->expected_attach_type !=BPF_LSM_CGROUP ) - ret = -EINVAL ; -else - ret =cgroup_bpf_prog_attach (attr, ptype, prog); -break ;case BPF_PROG_TYPE_SCHED_CLS :if (attr->attach_type ==BPF_TCX_INGRESS || attr->attach_type ==BPF_TCX_EGRESS )@@ -4264,7 +4272,10 @@ static int bpf_prog_attach(const union bpf_attr *attr) ret =netkit_prog_attach (attr, prog);break ;default : - ret = -EINVAL ; +if (!is_cgroup_prog_type (ptype, prog->expected_attach_type, true)) + ret = -EINVAL ; +else + ret =cgroup_bpf_prog_attach (attr, ptype, prog); }if (ret)[...]
Yonghong Song
reviewerPATCH v2 3/4 libbpf: Support link-based cgroup attach with options
In reply to Yonghong SongCurrently libbpf supports bpf_program__attach_cgroup() with signature:
LIBBPF_API struct bpf_link *
bpf_program__attach_cgroup(const struct bpf_program *prog, int cgroup_fd);
To support mprog style attachment, additionsl fields like flags, relative_{fd,id} and expected_revision are needed.
Add a new API:
LIBBPF_API struct bpf_link * bpf_program__attach_cgroup_opts(const struct bpf_program *prog, int cgroup_fd,
const struct bpf_cgroup_opts *opts);
where bpf_cgroup_opts contains all above needed fields.
--- tools/lib/bpf/bpf.c | 44 ++++++++++++++++++++++++++++++++++++++++ tools/lib/bpf/bpf.h | 5 +++++ tools/lib/bpf/libbpf.c | 28 +++++++++++++++++++++++++ tools/lib/bpf/libbpf.h | 15 ++++++++++++++ tools/lib/bpf/libbpf.map | 1 + 5 files changed, 93 insertions(+)
tools/lib/bpf/bpf.c +44 -0
@@ -837,6 +837,50 @@ int bpf_link_create(int prog_fd, int target_fd,if (!OPTS_ZEROED (opts, netkit))return libbpf_err (-EINVAL );break ; +case BPF_CGROUP_INET_INGRESS : +case BPF_CGROUP_INET_EGRESS : +case BPF_CGROUP_INET_SOCK_CREATE : +case BPF_CGROUP_INET_SOCK_RELEASE : +case BPF_CGROUP_INET4_BIND : +case BPF_CGROUP_INET6_BIND : +case BPF_CGROUP_INET4_POST_BIND : +case BPF_CGROUP_INET6_POST_BIND : +case BPF_CGROUP_INET4_CONNECT : +case BPF_CGROUP_INET6_CONNECT : +case BPF_CGROUP_UNIX_CONNECT : +case BPF_CGROUP_INET4_GETPEERNAME : +case BPF_CGROUP_INET6_GETPEERNAME : +case BPF_CGROUP_UNIX_GETPEERNAME : +case BPF_CGROUP_INET4_GETSOCKNAME : +case BPF_CGROUP_INET6_GETSOCKNAME : +case BPF_CGROUP_UNIX_GETSOCKNAME : +case BPF_CGROUP_UDP4_SENDMSG : +case BPF_CGROUP_UDP6_SENDMSG : +case BPF_CGROUP_UNIX_SENDMSG : +case BPF_CGROUP_UDP4_RECVMSG : +case BPF_CGROUP_UDP6_RECVMSG : +case BPF_CGROUP_UNIX_RECVMSG : +case BPF_CGROUP_SOCK_OPS : +case BPF_CGROUP_DEVICE : +case BPF_CGROUP_SYSCTL : +case BPF_CGROUP_GETSOCKOPT : +case BPF_CGROUP_SETSOCKOPT : +case BPF_LSM_CGROUP : + relative_fd =OPTS_GET (opts, cgroup.relative_fd,0 ); + relative_id =OPTS_GET (opts, cgroup.relative_id,0 ); +if (relative_fd && relative_id) +return libbpf_err (-EINVAL ); +if (relative_id) { + attr.link_create.cgroup.relative_id = relative_id; + attr.link_create.flags |=BPF_F_ID ; + }else { + attr.link_create.cgroup.relative_fd = relative_fd; + } + attr.link_create.cgroup.expected_revision = +OPTS_GET (opts, cgroup.expected_revision,0 ); +if (!OPTS_ZEROED (opts, cgroup)) +return libbpf_err (-EINVAL ); +break ;default :if (!OPTS_ZEROED (opts, flags))return libbpf_err (-EINVAL );
tools/lib/bpf/bpf.h +5 -0
@@ -438,6 +438,11 @@ struct bpf_link_create_opts {__u32 relative_id;__u64 expected_revision; } netkit; +struct { +__u32 relative_fd; +__u32 relative_id; +__u64 expected_revision; + } cgroup; }; size_t :0; };
tools/lib/bpf/libbpf.c +28 -0
@@ -12837,6 +12837,34 @@ struct bpf_link *bpf_program__attach_xdp(const struct bpf_program *prog, int ifireturn bpf_program_attach_fd (prog, ifindex,"xdp" ,NULL ); } +struct bpf_link * +bpf_program__attach_cgroup_opts (const struct bpf_program *prog,int cgroup_fd, +const struct bpf_cgroup_opts *opts) +{ +LIBBPF_OPTS (bpf_link_create_opts, link_create_opts); +__u32 relative_id; +int relative_fd; + +if (!OPTS_VALID (opts, bpf_cgroup_opts)) +return libbpf_err_ptr (-EINVAL ); + + relative_id =OPTS_GET (opts, relative_id,0 ); + relative_fd =OPTS_GET (opts, relative_fd,0 ); + +if (relative_fd && relative_id) { +pr_warn ("prog '%s': relative_fd and relative_id cannot be set at the same time\n" , + prog->name); +return libbpf_err_ptr (-EINVAL ); + } + + link_create_opts.cgroup.expected_revision =OPTS_GET (opts, expected_revision,0 ); + link_create_opts.cgroup.relative_fd = relative_fd; + link_create_opts.cgroup.relative_id = relative_id; + link_create_opts.flags =OPTS_GET (opts, flags,0 ); + +return bpf_program_attach_fd (prog, cgroup_fd,"cgroup" , &link_create_opts); +} +struct bpf_link *bpf_program__attach_tcx (const struct bpf_program *prog,int ifindex,const struct bpf_tcx_opts *opts)
tools/lib/bpf/libbpf.h +15 -0
@@ -877,6 +877,21 @@ LIBBPF_API struct bpf_link * bpf_program__attach_netkit(const struct bpf_program *prog, int ifindex, const struct bpf_netkit_opts *opts); +struct bpf_cgroup_opts { +/* size of this struct, for forward/backward compatibility */ +size_t sz; +__u32 flags; +__u32 relative_fd; +__u32 relative_id; +__u64 expected_revision; + size_t :0; +}; +#define bpf_cgroup_opts__last_field expected_revision + +LIBBPF_API struct bpf_link * +bpf_program__attach_cgroup_opts (const struct bpf_program *prog,int cgroup_fd, +const struct bpf_cgroup_opts *opts); +struct bpf_map ; LIBBPF_API struct bpf_link *bpf_map__attach_struct_ops(const struct bpf_map *map);
tools/lib/bpf/libbpf.map +1 -0
@@ -437,6 +437,7 @@ LIBBPF_1.6.0 { bpf_linker__add_fd; bpf_linker__new_fd; bpf_object__prepare; + bpf_program__attach_cgroup_opts; bpf_program__func_info; bpf_program__func_info_cnt; bpf_program__line_info;
Signature · 1 line
2.47.1
Re: [PATCH bpf-next v2 3/4] libbpf: Support link-based cgroup attach with options
Quoted 14 lines · Yonghong Song
Currently libbpf supports
bpf_program__attach_cgroup()with signature:
LIBBPF_APIstructbpf_link*
bpf_program__attach_cgroup(const struct bpf_program *prog, int cgroup_fd);To support mprog style attachment, additionsl fields like flags, relative_{fd,id} and
expected_revisionare needed.Add a new API:
LIBBPF_APIstructbpf_link* bpf_program__attach_cgroup_opts(const structbpf_program*prog, intcgroup_fd,const struct bpf_cgroup_opts *opts);where
bpf_cgroup_optscontains all above needed fields.
Quoted 9 lines
Signed-off-by Yonghong Song <[email protected]>--- tools/lib/bpf/bpf.c | 44 ++++++++++++++++++++++++++++++++++++++++ tools/lib/bpf/bpf.h | 5 +++++ tools/lib/bpf/libbpf.c | 28 +++++++++++++++++++++++++ tools/lib/bpf/libbpf.h | 15 ++++++++++++++ tools/lib/bpf/libbpf.map | 1 + 5 files changed, 93 insertions(+)
LGTM
[...]
Yonghong Song
reviewerPATCH v2 4/4 selftests/bpf: Add two selftests for mprog API based cgroup progs
In reply to Yonghong SongTwo tests are added:
- cgroup_mprog_opts, which mimics tc_opts.c ([1]). Both prog and link attach are tested. Some negative tests are also included.
- cgroup_mprog_ordering, which actually runs the program with some mprog API flags.
[1] https://github.com/torvalds/linux/blob/master/tools/testing/selftests/bpf/prog_tests/tc_opts.c
--- .../bpf/prog_tests/cgroup_mprog_opts.c | 752 ++++++++++++++++++ .../bpf/prog_tests/cgroup_mprog_ordering.c | 77 ++ .../selftests/bpf/progs/cgroup_mprog.c | 30 + 3 files changed, 859 insertions(+) create mode 100644 tools/testing/selftests/bpf/prog_tests/cgroup_mprog_opts.c create mode 100644 tools/testing/selftests/bpf/prog_tests/cgroup_mprog_ordering.c create mode 100644 tools/testing/selftests/bpf/progs/cgroup_mprog.c
tools/testing/selftests/bpf/prog_tests/cgroup_mprog_opts.c new file +752 -0
@@ -0,0 +1,752 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright (c) 2025 Meta Platforms, Inc. and affiliates. */ +#include <test_progs.h> +#include "cgroup_helpers.h" +#include "cgroup_mprog.skel.h" + +static __u32 id_from_prog_fd (int fd) +{ +struct bpf_prog_info prog_info = {}; +__u32 prog_info_len =sizeof (prog_info); +int err; + + err =bpf_obj_get_info_by_fd (fd, &prog_info, &prog_info_len); +if (!ASSERT_OK (err,"id_from_prog_fd" )) +return 0 ; + +ASSERT_NEQ (prog_info.id,0 ,"prog_info.id" ); +return prog_info.id; +} + +static void assert_mprog_count (int cg,int atype,int expected) +{ +__u32 count =0 , attach_flags =0 ; +int err; + + err =bpf_prog_query (cg, atype,0 , &attach_flags, +NULL , &count); +ASSERT_EQ (count, expected,"count" ); +ASSERT_EQ (err,0 ,"prog_query" ); +} + +static void test_prog_attach_detach (int atype) +{ +LIBBPF_OPTS (bpf_prog_attach_opts, opta); +LIBBPF_OPTS (bpf_prog_detach_opts, optd); +LIBBPF_OPTS (bpf_prog_query_opts, optq); +__u32 fd1, fd2, fd3, fd4, id1, id2, id3, id4; +struct cgroup_mprog *skel; +__u32 prog_ids[10 ]; +int cg, err; + + cg =test__join_cgroup ("/prog_attach_detach" ); +if (!ASSERT_GE (cg,0 ,"join_cgroup /prog_attach_detach" )) +return ; + + skel =cgroup_mprog__open_and_load (); +if (!ASSERT_OK_PTR (skel,"skel_load" )) + goto cleanup; + + fd1 =bpf_program__fd (skel->progs.getsockopt_1); + fd2 =bpf_program__fd (skel->progs.getsockopt_2); + fd3 =bpf_program__fd (skel->progs.getsockopt_3); + fd4 =bpf_program__fd (skel->progs.getsockopt_4); + + id1 =id_from_prog_fd (fd1); + id2 =id_from_prog_fd (fd2); + id3 =id_from_prog_fd (fd3); + id4 =id_from_prog_fd (fd4); + +assert_mprog_count (cg, atype,0 ); + + LIBBPF_OPTS_RESET(opta, + .flags = BPF_F_ALLOW_MULTI, + .expected_revision = 1, + ); + +/* ordering: [fd1] */ + err =bpf_prog_attach_opts (fd1, cg, atype, &opta); +if (!ASSERT_EQ (err,0 ,"prog_attach" )) + goto cleanup; + +assert_mprog_count (cg, atype,1 ); + + LIBBPF_OPTS_RESET(opta, + .flags = BPF_F_ALLOW_MULTI | BPF_F_BEFORE, + .expected_revision = 2, + ); + +/* ordering: [fd2, fd1] */ + err =bpf_prog_attach_opts (fd2, cg, atype, &opta); +if (!ASSERT_EQ (err,0 ,"prog_attach" )) + goto cleanup1; + +assert_mprog_count (cg, atype,2 ); + + LIBBPF_OPTS_RESET(opta, + .flags = BPF_F_ALLOW_MULTI | BPF_F_AFTER, + .relative_fd = fd2, + .expected_revision = 3, + ); + +/* ordering: [fd2, fd3, fd1] */ + err =bpf_prog_attach_opts (fd3, cg, atype, &opta); +if (!ASSERT_EQ (err,0 ,"prog_attach" )) + goto cleanup2; + +assert_mprog_count (cg, atype,3 ); + + LIBBPF_OPTS_RESET(opta, + .flags = BPF_F_ALLOW_MULTI, + .expected_revision = 4, + ); + +/* ordering: [fd2, fd3, fd1, fd4] */ + err =bpf_prog_attach_opts (fd4, cg, atype, &opta); +if (!ASSERT_EQ (err,0 ,"prog_attach" )) + goto cleanup3; + +assert_mprog_count (cg, atype,4 ); + +/* retrieve optq.prog_cnt */ + err =bpf_prog_query_opts (cg, atype, &optq); +if (!ASSERT_OK (err,"prog_query" )) + goto cleanup4; + +/* optq.prog_cnt will be used in below query */ +memset (prog_ids,0 ,sizeof (prog_ids)); + optq.prog_ids = prog_ids; + err =bpf_prog_query_opts (cg, atype, &optq); +if (!ASSERT_OK (err,"prog_query" )) + goto cleanup4; + +ASSERT_EQ (optq.count,4 ,"count" ); +ASSERT_EQ (optq.revision,5 ,"revision" ); +ASSERT_EQ (optq.prog_ids[0 ], id2,"prog_ids[0]" ); +ASSERT_EQ (optq.prog_ids[1 ], id3,"prog_ids[1]" ); +ASSERT_EQ (optq.prog_ids[2 ], id1,"prog_ids[2]" ); +ASSERT_EQ (optq.prog_ids[3 ], id4,"prog_ids[3]" ); +ASSERT_EQ (optq.prog_ids[4 ],0 ,"prog_ids[4]" ); +ASSERT_EQ (optq.link_ids,NULL ,"link_ids" ); + +cleanup4: + optd.expected_revision =5 ; + err =bpf_prog_detach_opts (fd4, cg, atype, &optd); +ASSERT_OK (err,"prog_detach" ); +assert_mprog_count (cg, atype,3 ); + +cleanup3: +LIBBPF_OPTS_RESET (optd); + err =bpf_prog_detach_opts (fd3, cg, atype, &optd); +ASSERT_OK (err,"prog_detach" ); +assert_mprog_count (cg, atype,2 ); + +/* Check revision after two detach operations */ + err =bpf_prog_query_opts (cg, atype, &optq); +ASSERT_OK (err,"prog_query" ); +ASSERT_EQ (optq.revision,7 ,"revision" ); + +cleanup2: + err =bpf_prog_detach_opts (fd2, cg, atype, &optd); +ASSERT_OK (err,"prog_detach" ); +assert_mprog_count (cg, atype,1 ); + +cleanup1: + err =bpf_prog_detach_opts (fd1, cg, atype, &optd); +ASSERT_OK (err,"prog_detach" ); +assert_mprog_count (cg, atype,0 ); + +cleanup: +cgroup_mprog__destroy (skel); +close (cg); +} + +static void test_link_attach_detach (int atype) +{ +LIBBPF_OPTS (bpf_cgroup_opts, opta); +LIBBPF_OPTS (bpf_cgroup_opts, optd); +LIBBPF_OPTS (bpf_prog_query_opts, optq); +struct bpf_link *link1, *link2, *link3, *link4; +__u32 fd1, fd2, fd3, fd4, id1, id2, id3, id4; +struct cgroup_mprog *skel; +__u32 prog_ids[10 ]; +int cg, err; + + cg =test__join_cgroup ("/link_attach_detach" ); +if (!ASSERT_GE (cg,0 ,"join_cgroup /link_attach_detach" )) +return ; + + skel =cgroup_mprog__open_and_load (); +if (!ASSERT_OK_PTR (skel,"skel_load" )) + goto cleanup; + + fd1 =bpf_program__fd (skel->progs.getsockopt_1); + fd2 =bpf_program__fd (skel->progs.getsockopt_2); + fd3 =bpf_program__fd (skel->progs.getsockopt_3); + fd4 =bpf_program__fd (skel->progs.getsockopt_4); + + id1 =id_from_prog_fd (fd1); + id2 =id_from_prog_fd (fd2); + id3 =id_from_prog_fd (fd3); + id4 =id_from_prog_fd (fd4); + +assert_mprog_count (cg, atype,0 ); + + LIBBPF_OPTS_RESET(opta, + .expected_revision = 1, + ); + +/* ordering: [fd1] */ + link1 =bpf_program__attach_cgroup_opts (skel->progs.getsockopt_1, cg, &opta); +if (!ASSERT_OK_PTR (link1,"link_attach" )) + goto cleanup; + +assert_mprog_count (cg, atype,1 ); + + LIBBPF_OPTS_RESET(opta, + .flags = BPF_F_BEFORE, + .expected_revision = 2, + ); + +/* ordering: [fd2, fd1] */ + link2 =bpf_program__attach_cgroup_opts (skel->progs.getsockopt_2, cg, &opta); +if (!ASSERT_OK_PTR (link2,"link_attach" )) + goto cleanup1; + +assert_mprog_count (cg, atype,2 ); + + LIBBPF_OPTS_RESET(opta, + .flags = BPF_F_AFTER, + .relative_fd = fd2, + .expected_revision = 3, + ); + +/* ordering: [fd2, fd3, fd1] */ + link3 =bpf_program__attach_cgroup_opts (skel->progs.getsockopt_3, cg, &opta); +if (!ASSERT_OK_PTR (link3,"link_attach" )) + goto cleanup2; + +assert_mprog_count (cg, atype,3 ); + + LIBBPF_OPTS_RESET(opta, + .expected_revision = 4, + ); + +/* ordering: [fd2, fd3, fd1, fd4] */ + link4 =bpf_program__attach_cgroup_opts (skel->progs.getsockopt_4, cg, &opta); +if (!ASSERT_OK_PTR (link4,"link_attach" )) + goto cleanup3; + +assert_mprog_count (cg, atype,4 ); + +/* retrieve optq.prog_cnt */ + err =bpf_prog_query_opts (cg, atype, &optq); +if (!ASSERT_OK (err,"prog_query" )) + goto cleanup4; + +/* optq.prog_cnt will be used in below query */ +memset (prog_ids,0 ,sizeof (prog_ids)); + optq.prog_ids = prog_ids; + err =bpf_prog_query_opts (cg, atype, &optq); +if (!ASSERT_OK (err,"prog_query" )) + goto cleanup4; + +ASSERT_EQ (optq.count,4 ,"count" ); +ASSERT_EQ (optq.revision,5 ,"revision" ); +ASSERT_EQ (optq.prog_ids[0 ], id2,"prog_ids[0]" ); +ASSERT_EQ (optq.prog_ids[1 ], id3,"prog_ids[1]" ); +ASSERT_EQ (optq.prog_ids[2 ], id1,"prog_ids[2]" ); +ASSERT_EQ (optq.prog_ids[3 ], id4,"prog_ids[3]" ); +ASSERT_EQ (optq.prog_ids[4 ],0 ,"prog_ids[4]" ); +ASSERT_EQ (optq.link_ids,NULL ,"link_ids" ); + +cleanup4: +bpf_link__destroy (link4); +assert_mprog_count (cg, atype,3 ); + +cleanup3: +bpf_link__destroy (link3); +assert_mprog_count (cg, atype,2 ); + +/* Check revision after two detach operations */ + err =bpf_prog_query_opts (cg, atype, &optq); +ASSERT_OK (err,"prog_query" ); +ASSERT_EQ (optq.revision,7 ,"revision" ); + +cleanup2: +bpf_link__destroy (link2); +assert_mprog_count (cg, atype,1 ); + +cleanup1: +bpf_link__destroy (link1); +assert_mprog_count (cg, atype,0 ); + +cleanup: +cgroup_mprog__destroy (skel); +close (cg); +} + +static void test_mix_attach_detach (int atype) +{ +LIBBPF_OPTS (bpf_cgroup_opts, lopta); +LIBBPF_OPTS (bpf_cgroup_opts, loptd); +LIBBPF_OPTS (bpf_prog_attach_opts, opta); +LIBBPF_OPTS (bpf_prog_detach_opts, optd); +LIBBPF_OPTS (bpf_prog_query_opts, optq); +__u32 fd1, fd2, fd3, fd4, id1, id2, id3, id4; +struct bpf_link *link2, *link4; +struct cgroup_mprog *skel; +__u32 prog_ids[10 ]; +int cg, err; + + cg =test__join_cgroup ("/mix_attach_detach" ); +if (!ASSERT_GE (cg,0 ,"join_cgroup /mix_attach_detach" )) +return ; + + skel =cgroup_mprog__open_and_load (); +if (!ASSERT_OK_PTR (skel,"skel_load" )) + goto cleanup; + + fd1 =bpf_program__fd (skel->progs.getsockopt_1); + fd2 =bpf_program__fd (skel->progs.getsockopt_2); + fd3 =bpf_program__fd (skel->progs.getsockopt_3); + fd4 =bpf_program__fd (skel->progs.getsockopt_4); + + id1 =id_from_prog_fd (fd1); + id2 =id_from_prog_fd (fd2); + id3 =id_from_prog_fd (fd3); + id4 =id_from_prog_fd (fd4); + +assert_mprog_count (cg, atype,0 ); + + LIBBPF_OPTS_RESET(opta, + .flags = BPF_F_ALLOW_MULTI, + .expected_revision = 1, + ); + +/* ordering: [fd1] */ + err =bpf_prog_attach_opts (fd1, cg, atype, &opta); +if (!ASSERT_EQ (err,0 ,"prog_attach" )) + goto cleanup; + +assert_mprog_count (cg, atype,1 ); + + LIBBPF_OPTS_RESET(lopta, + .flags = BPF_F_BEFORE, + .expected_revision = 2, + ); + +/* ordering: [fd2, fd1] */ + link2 =bpf_program__attach_cgroup_opts (skel->progs.getsockopt_2, cg, &lopta); +if (!ASSERT_OK_PTR (link2,"link_attach" )) + goto cleanup1; + +assert_mprog_count (cg, atype,2 ); + + LIBBPF_OPTS_RESET(opta, + .flags = BPF_F_ALLOW_MULTI | BPF_F_AFTER, + .relative_fd = fd2, + .expected_revision = 3, + ); + +/* ordering: [fd2, fd3, fd1] */ + err =bpf_prog_attach_opts (fd3, cg, atype, &opta); +if (!ASSERT_EQ (err,0 ,"prog_attach" )) + goto cleanup2; + +assert_mprog_count (cg, atype,3 ); + + LIBBPF_OPTS_RESET(lopta, + .expected_revision = 4, + ); + +/* ordering: [fd2, fd3, fd1, fd4] */ + link4 =bpf_program__attach_cgroup_opts (skel->progs.getsockopt_4, cg, &lopta); +if (!ASSERT_OK_PTR (link4,"link_attach" )) + goto cleanup3; + +assert_mprog_count (cg, atype,4 ); + +/* retrieve optq.prog_cnt */ + err =bpf_prog_query_opts (cg, atype, &optq); +if (!ASSERT_OK (err,"prog_query" )) + goto cleanup4; + +/* optq.prog_cnt will be used in below query */ +memset (prog_ids,0 ,sizeof (prog_ids)); + optq.prog_ids = prog_ids; + err =bpf_prog_query_opts (cg, atype, &optq); +if (!ASSERT_OK (err,"prog_query" )) + goto cleanup4; + +ASSERT_EQ (optq.count,4 ,"count" ); +ASSERT_EQ (optq.revision,5 ,"revision" ); +ASSERT_EQ (optq.prog_ids[0 ], id2,"prog_ids[0]" ); +ASSERT_EQ (optq.prog_ids[1 ], id3,"prog_ids[1]" ); +ASSERT_EQ (optq.prog_ids[2 ], id1,"prog_ids[2]" ); +ASSERT_EQ (optq.prog_ids[3 ], id4,"prog_ids[3]" ); +ASSERT_EQ (optq.prog_ids[4 ],0 ,"prog_ids[4]" ); +ASSERT_EQ (optq.link_ids,NULL ,"link_ids" ); + +cleanup4: +bpf_link__destroy (link4); +assert_mprog_count (cg, atype,3 ); + +cleanup3: + err =bpf_prog_detach_opts (fd3, cg, atype, &optd); +ASSERT_OK (err,"prog_detach" ); +assert_mprog_count (cg, atype,2 ); + +/* Check revision after two detach operations */ + err =bpf_prog_query_opts (cg, atype, &optq); +ASSERT_OK (err,"prog_query" ); +ASSERT_EQ (optq.revision,7 ,"revision" ); + +cleanup2: +bpf_link__destroy (link2); +assert_mprog_count (cg, atype,1 ); + +cleanup1: + err =bpf_prog_detach_opts (fd1, cg, atype, &optd); +ASSERT_OK (err,"prog_detach" ); +assert_mprog_count (cg, atype,0 ); + +cleanup: +cgroup_mprog__destroy (skel); +close (cg); +} + +static void test_preorder_prog_attach_detach (int atype) +{ +LIBBPF_OPTS (bpf_prog_attach_opts, opta); +LIBBPF_OPTS (bpf_prog_detach_opts, optd); +__u32 fd1, fd2, fd3, fd4; +struct cgroup_mprog *skel; +int cg, err; + + cg =test__join_cgroup ("/preorder_prog_attach_detach" ); +if (!ASSERT_GE (cg,0 ,"join_cgroup /preorder_prog_attach_detach" )) +return ; + + skel =cgroup_mprog__open_and_load (); +if (!ASSERT_OK_PTR (skel,"skel_load" )) + goto cleanup; + + fd1 =bpf_program__fd (skel->progs.getsockopt_1); + fd2 =bpf_program__fd (skel->progs.getsockopt_2); + fd3 =bpf_program__fd (skel->progs.getsockopt_3); + fd4 =bpf_program__fd (skel->progs.getsockopt_4); + +assert_mprog_count (cg, atype,0 ); + + LIBBPF_OPTS_RESET(opta, + .flags = BPF_F_ALLOW_MULTI, + .expected_revision = 1, + ); + +/* ordering: [fd1] */ + err =bpf_prog_attach_opts (fd1, cg, atype, &opta); +if (!ASSERT_EQ (err,0 ,"prog_attach" )) + goto cleanup; + +assert_mprog_count (cg, atype,1 ); + + LIBBPF_OPTS_RESET(opta, + .flags = BPF_F_ALLOW_MULTI | BPF_F_PREORDER, + .expected_revision = 2, + ); + +/* ordering: [fd1, fd2] */ + err =bpf_prog_attach_opts (fd2, cg, atype, &opta); +if (!ASSERT_EQ (err,0 ,"prog_attach" )) + goto cleanup1; + +assert_mprog_count (cg, atype,2 ); + + LIBBPF_OPTS_RESET(opta, + .flags = BPF_F_ALLOW_MULTI | BPF_F_AFTER, + .relative_fd = fd2, + .expected_revision = 3, + ); + + err =bpf_prog_attach_opts (fd3, cg, atype, &opta); +if (!ASSERT_EQ (err, -EINVAL ,"prog_attach" )) + goto cleanup2; + +assert_mprog_count (cg, atype,2 ); + + LIBBPF_OPTS_RESET(opta, + .flags = BPF_F_ALLOW_MULTI | BPF_F_AFTER | BPF_F_PREORDER, + .relative_fd = fd2, + .expected_revision = 3, + ); + +/* ordering: [fd1, fd2, fd3] */ + err =bpf_prog_attach_opts (fd3, cg, atype, &opta); +if (!ASSERT_EQ (err,0 ,"prog_attach" )) + goto cleanup2; + +assert_mprog_count (cg, atype,3 ); + + LIBBPF_OPTS_RESET(opta, + .flags = BPF_F_ALLOW_MULTI, + .expected_revision = 4, + ); + +/* ordering: [fd2, fd3, fd1, fd4] */ + err =bpf_prog_attach_opts (fd4, cg, atype, &opta); +if (!ASSERT_EQ (err,0 ,"prog_attach" )) + goto cleanup3; + +assert_mprog_count (cg, atype,4 ); + + err =bpf_prog_detach_opts (fd4, cg, atype, &optd); +ASSERT_OK (err,"prog_detach" ); +assert_mprog_count (cg, atype,3 ); + +cleanup3: + err =bpf_prog_detach_opts (fd3, cg, atype, &optd); +ASSERT_OK (err,"prog_detach" ); +assert_mprog_count (cg, atype,2 ); + +cleanup2: + err =bpf_prog_detach_opts (fd2, cg, atype, &optd); +ASSERT_OK (err,"prog_detach" ); +assert_mprog_count (cg, atype,1 ); + +cleanup1: + err =bpf_prog_detach_opts (fd1, cg, atype, &optd); +ASSERT_OK (err,"prog_detach" ); +assert_mprog_count (cg, atype,0 ); + +cleanup: +cgroup_mprog__destroy (skel); +close (cg); +} + +static void test_preorder_link_attach_detach (int atype) +{ +LIBBPF_OPTS (bpf_cgroup_opts, opta); +struct bpf_link *link1, *link2, *link3, *link4; +struct cgroup_mprog *skel; +__u32 fd2; +int cg; + + cg =test__join_cgroup ("/preorder_link_attach_detach" ); +if (!ASSERT_GE (cg,0 ,"join_cgroup /preorder_link_attach_detach" )) +return ; + + skel =cgroup_mprog__open_and_load (); +if (!ASSERT_OK_PTR (skel,"skel_load" )) + goto cleanup; + + fd2 =bpf_program__fd (skel->progs.getsockopt_2); + +assert_mprog_count (cg, atype,0 ); + + LIBBPF_OPTS_RESET(opta, + .expected_revision = 1, + ); + +/* ordering: [fd1] */ + link1 =bpf_program__attach_cgroup_opts (skel->progs.getsockopt_1, cg, &opta); +if (!ASSERT_OK_PTR (link1,"link_attach" )) + goto cleanup; + +assert_mprog_count (cg, atype,1 ); + + LIBBPF_OPTS_RESET(opta, + .flags = BPF_F_PREORDER, + .expected_revision = 2, + ); + +/* ordering: [fd1, fd2] */ + link2 =bpf_program__attach_cgroup_opts (skel->progs.getsockopt_2, cg, &opta); +if (!ASSERT_OK_PTR (link2,"link_attach" )) + goto cleanup1; + +assert_mprog_count (cg, atype,2 ); + + LIBBPF_OPTS_RESET(opta, + .flags = BPF_F_AFTER, + .relative_fd = fd2, + .expected_revision = 3, + ); + + link3 =bpf_program__attach_cgroup_opts (skel->progs.getsockopt_3, cg, &opta); +if (!ASSERT_ERR_PTR (link3,"link_attach" )) + goto cleanup2; + +assert_mprog_count (cg, atype,2 ); + + LIBBPF_OPTS_RESET(opta, + .flags = BPF_F_AFTER | BPF_F_PREORDER, + .relative_fd = fd2, + .expected_revision = 3, + ); + +/* ordering: [fd1, fd2, fd3] */ + link3 =bpf_program__attach_cgroup_opts (skel->progs.getsockopt_3, cg, &opta); +if (!ASSERT_OK_PTR (link3,"link_attach" )) + goto cleanup2; + +assert_mprog_count (cg, atype,3 ); + + LIBBPF_OPTS_RESET(opta, + .expected_revision = 4, + ); + +/* ordering: [fd2, fd3, fd1, fd4] */ + link4 =bpf_program__attach_cgroup_opts (skel->progs.getsockopt_4, cg, &opta); +if (!ASSERT_OK_PTR (link4,"prog_attach" )) + goto cleanup3; + +assert_mprog_count (cg, atype,4 ); + +bpf_link__destroy (link4); +assert_mprog_count (cg, atype,3 ); + +cleanup3: +bpf_link__destroy (link3); +assert_mprog_count (cg, atype,2 ); + +cleanup2: +bpf_link__destroy (link2); +assert_mprog_count (cg, atype,1 ); + +cleanup1: +bpf_link__destroy (link1); +assert_mprog_count (cg, atype,0 ); + +cleanup: +cgroup_mprog__destroy (skel); +close (cg); +} + +static void test_invalid_attach_detach (int atype) +{ +LIBBPF_OPTS (bpf_prog_attach_opts, opta); +__u32 fd1, fd2, id2; +struct cgroup_mprog *skel; +int cg, err; + + cg =test__join_cgroup ("/invalid_attach_detach" ); +if (!ASSERT_GE (cg,0 ,"join_cgroup /invalid_attach_detach" )) +return ; + + skel =cgroup_mprog__open_and_load (); +if (!ASSERT_OK_PTR (skel,"skel_load" )) + goto cleanup; + + fd1 =bpf_program__fd (skel->progs.getsockopt_1); + fd2 =bpf_program__fd (skel->progs.getsockopt_2); + + id2 =id_from_prog_fd (fd2); + +assert_mprog_count (cg, atype,0 ); + + LIBBPF_OPTS_RESET(opta, + .flags = BPF_F_ALLOW_MULTI | BPF_F_BEFORE | BPF_F_AFTER, + ); + + err =bpf_prog_attach_opts (fd1, cg, atype, &opta); +ASSERT_EQ (err, -EINVAL ,"prog_attach" ); +assert_mprog_count (cg, atype,0 ); + + LIBBPF_OPTS_RESET(opta, + .flags = BPF_F_ALLOW_MULTI | BPF_F_BEFORE | BPF_F_ID, + ); + + err =bpf_prog_attach_opts (fd1, cg, atype, &opta); +ASSERT_EQ (err, -ENOENT ,"prog_attach" ); +assert_mprog_count (cg, atype,0 ); + + LIBBPF_OPTS_RESET(opta, + .flags = BPF_F_ALLOW_MULTI | BPF_F_AFTER | BPF_F_ID, + ); + + err =bpf_prog_attach_opts (fd1, cg, atype, &opta); +ASSERT_EQ (err, -ENOENT ,"prog_attach" ); +assert_mprog_count (cg, atype,0 ); + + LIBBPF_OPTS_RESET(opta, + .flags = BPF_F_ALLOW_MULTI | BPF_F_BEFORE | BPF_F_AFTER, + .relative_id = id2, + ); + + err =bpf_prog_attach_opts (fd1, cg, atype, &opta); +ASSERT_EQ (err, -EINVAL ,"prog_attach" ); +assert_mprog_count (cg, atype,0 ); + + LIBBPF_OPTS_RESET(opta, + .flags = BPF_F_ALLOW_MULTI | BPF_F_ID, + .relative_id = id2, + ); + + err =bpf_prog_attach_opts (fd1, cg, atype, &opta); +ASSERT_EQ (err, -EINVAL ,"prog_attach" ); +assert_mprog_count (cg, atype,0 ); + + LIBBPF_OPTS_RESET(opta, + .flags = BPF_F_ALLOW_MULTI | BPF_F_BEFORE, + .relative_fd = fd1, + ); + + err =bpf_prog_attach_opts (fd1, cg, atype, &opta); +ASSERT_EQ (err, -ENOENT ,"prog_attach" ); +assert_mprog_count (cg, atype,0 ); + + LIBBPF_OPTS_RESET(opta, + .flags = BPF_F_ALLOW_MULTI | BPF_F_AFTER, + .relative_fd = fd1, + ); + + err =bpf_prog_attach_opts (fd1, cg, atype, &opta); +ASSERT_EQ (err, -ENOENT ,"prog_attach" ); +assert_mprog_count (cg, atype,0 ); + + LIBBPF_OPTS_RESET(opta, + .flags = BPF_F_ALLOW_MULTI, + ); + + err =bpf_prog_attach_opts (fd1, cg, atype, &opta); +if (!ASSERT_EQ (err,0 ,"prog_attach" )) + goto cleanup; +assert_mprog_count (cg, atype,1 ); + + LIBBPF_OPTS_RESET(opta, + .flags = BPF_F_ALLOW_MULTI | BPF_F_AFTER, + ); + + err =bpf_prog_attach_opts (fd1, cg, atype, &opta); +ASSERT_EQ (err, -EINVAL ,"prog_attach" ); +assert_mprog_count (cg, atype,1 ); + + LIBBPF_OPTS_RESET(opta, + .flags = BPF_F_ALLOW_MULTI | BPF_F_REPLACE | BPF_F_AFTER, + .replace_prog_fd = fd1, + ); + + err =bpf_prog_attach_opts (fd1, cg, atype, &opta); +ASSERT_EQ (err, -EINVAL ,"prog_attach" ); +assert_mprog_count (cg, atype,1 ); +cleanup: +cgroup_mprog__destroy (skel); +close (cg); +} + +void test_cgroup_mprog_opts (void ) +{ +if (test__start_subtest ("prog_attach_detach" )) +test_prog_attach_detach (BPF_CGROUP_GETSOCKOPT ); +if (test__start_subtest ("link_attach_detach" )) +test_link_attach_detach (BPF_CGROUP_GETSOCKOPT ); +if (test__start_subtest ("mix_attach_detach" )) +test_mix_attach_detach (BPF_CGROUP_GETSOCKOPT ); +if (test__start_subtest ("preorder_prog_attach_detach" )) +test_preorder_prog_attach_detach (BPF_CGROUP_GETSOCKOPT ); +if (test__start_subtest ("preorder_link_attach_detach" )) +test_preorder_link_attach_detach (BPF_CGROUP_GETSOCKOPT ); +if (test__start_subtest ("invalid_attach_detach" )) +test_invalid_attach_detach (BPF_CGROUP_GETSOCKOPT ); +}
tools/testing/selftests/bpf/prog_tests/cgroup_mprog_ordering.c new file +77 -0
77 lines not on this page · raw message
tools/testing/selftests/bpf/progs/cgroup_mprog.c new file +30 -0
@@ -0,0 +1,30 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright (c) 2025 Meta Platforms, Inc. and affiliates. */ +#include <vmlinux.h> +#include <bpf/bpf_helpers.h> + +char _license[] SEC("license") = "GPL"; + +SEC("cgroup/getsockopt") +int getsockopt_1 (struct bpf_sockopt *ctx) +{ +return 1 ; +} + +SEC("cgroup/getsockopt") +int getsockopt_2 (struct bpf_sockopt *ctx) +{ +return 1 ; +} + +SEC("cgroup/getsockopt") +int getsockopt_3 (struct bpf_sockopt *ctx) +{ +return 1 ; +} + +SEC("cgroup/getsockopt") +int getsockopt_4 (struct bpf_sockopt *ctx) +{ +return 1 ; +}
Signature · 1 line
2.47.1