New nf_conntrack kfuncs for insertion, changing timeout, status
Subsystems (10)
Kumar Kartikeya Dwivedi
maintainerv6 cover New nf_conntrack kfuncs for insertion, changing timeout, status
Introduce the following new kfuncs:
- bpf_{xdp,skb}_ct_alloc
- bpf_ct_insert_entry
- bpf_ct_{set,change}_timeout
- bpf_ct_{set,change}_status
The setting of timeout and status on allocated or inserted/looked up CT is same as the ctnetlink interface, hence code is refactored and shared with the kfuncs. It is ensured allocated CT cannot be passed to kfuncs that expected inserted CT, and vice versa. Please see individual patches for details.
Changelog:
----------
v5 -> v6:
v5: https://lore.kernel.org/bpf/[email protected]
* Introduce kfunc flags, rework verifier to work with them
* Add documentation for kfuncs
* Add comment explaining TRUSTED_ARGS kfunc flag (Alexei)
* Fix missing offset check for trusted arguments (Alexei)
* Change nf_conntrack test minimum delta value to 8
v4 -> v5:
v4: https://lore.kernel.org/bpf/[email protected]
* Drop read-only PTR_TO_BTF_ID approach, use struct nf_conn___init (Alexei)
* Drop acquire release pair code that is no longer required (Alexei)
* Disable writes into nf_conn, use dedicated helpers (Florian, Alexei)
* Refactor and share ctnetlink code for setting timeout and status
* Do strict type matching on finding __ref suffix on argument to prevent passing nf_conn___init as nf_conn (offset = 0, match on walk)
* Remove bpf_ct_opts parameter from bpf_ct_insert_entry
* Update selftests for new additions, add more negative tests
v3 -> v4:
v3: https://lore.kernel.org/bpf/[email protected]
* split bpf_xdp_ct_add in bpf_xdp_ct_alloc/bpf_skb_ct_alloc and bpf_ct_insert_entry
* add verifier code to properly populate/configure ct entry
* improve selftests
v2 -> v3:
v2: https://lore.kernel.org/bpf/[email protected]
* add bpf_xdp_ct_add and bpf_ct_refresh_timeout kfunc helpers
* remove conntrack dependency from selftests
* add support for forcing kfunc args to be referenced and related selftests
v1 -> v2:
v1: https://lore.kernel.org/bpf/1327f8f5696ff2bc60400e8f3b79047914ccc837.1651595019.git.lorenzo@kernel.org
* add bpf_ct_refresh_timeout kfunc selftest
Kumar Kartikeya Dwivedi (10):
bpf: Introduce BTF ID flags and 8-byte BTF set tools/resolve_btfids: Add support for resolving kfunc flags
bpf: Switch to new kfunc flags infrastructure
bpf: Add support for forcing kfunc args to be trusted
bpf: Add documentation for kfuncs
net: netfilter: Deduplicate code in bpf_{xdp,skb}_ct_lookup
net: netfilter: Add kfuncs to set and change CT timeout selftests/bpf: Add verifier tests for trusted kfunc args selftests/bpf: Add negative tests for new nf_conntrack kfuncs selftests/bpf: Fix test_verifier failed test in unprivileged mode
Lorenzo Bianconi (3):
net: netfilter: Add kfuncs to allocate and insert CT
net: netfilter: Add kfuncs to set and change CT status selftests/bpf: Add tests for new nf_conntrack kfuncs
Documentation/bpf/index.rst | 1 + Documentation/bpf/kfuncs.rst | 171 ++++++++ include/linux/bpf.h | 3 +- include/linux/btf.h | 68 ++-- include/linux/btf_ids.h | 64 +++ include/net/netfilter/nf_conntrack_core.h | 19 + kernel/bpf/btf.c | 120 +++--- kernel/bpf/verifier.c | 14 +- net/bpf/test_run.c | 75 ++-- net/ipv4/bpf_tcp_ca.c | 18 +- net/ipv4/tcp_bbr.c | 24 +- net/ipv4/tcp_cubic.c | 20 +- net/ipv4/tcp_dctcp.c | 20 +- net/netfilter/nf_conntrack_bpf.c | 365 +++++++++++++----- net/netfilter/nf_conntrack_core.c | 62 +++ net/netfilter/nf_conntrack_netlink.c | 54 +-- tools/bpf/resolve_btfids/main.c | 115 +++++- .../selftests/bpf/bpf_testmod/bpf_testmod.c | 10 +- .../testing/selftests/bpf/prog_tests/bpf_nf.c | 64 ++- .../testing/selftests/bpf/progs/test_bpf_nf.c | 85 +++- .../selftests/bpf/progs/test_bpf_nf_fail.c | 134 +++++++ .../selftests/bpf/verifier/bpf_loop_inline.c | 1 + tools/testing/selftests/bpf/verifier/calls.c | 53 +++ 23 files changed, 1214 insertions(+), 346 deletions(-) create mode 100644 Documentation/bpf/kfuncs.rst create mode 100644 tools/testing/selftests/bpf/progs/test_bpf_nf_fail.c
Signature · 1 line
2.34.1
Kumar Kartikeya Dwivedi
maintainerPATCH v6 1/13 bpf: Introduce BTF ID flags and 8-byte BTF set
Introduce support for defining flags for kfuncs using a new set of macros, BTF_SET8_START/BTF_SET8_END, which define a set which contains 8 byte elements (each of which consists of a pair of BTF ID and flags), using a new BTF_ID_FLAGS macro.
This will be used to tag kfuncs registered for a certain program type as acquire, release, sleepable, ret_null, etc. without having to create more and more sets which was proving to be an unscalable solution.
Now, when looking up whether a kfunc is allowed for a certain program, we can also obtain its kfunc flags in the same call and avoid further lookups.
The way flags for BTF IDs are constructed requires substituting the flag value as a string into the symbol name, concatenating the set of flags (currently limited to 5, but easily extendable to a higher limit), and then consuming the list from resolve_btfids which can then store the final flag value by ORing each individual flag into the final result.
The resolve_btfids change is split into a separate patch.
--- include/linux/btf_ids.h | 64 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 64 insertions(+)
include/linux/btf_ids.h +64 -0
@@ -8,6 +8,15 @@ struct btf_id_set {u32 ids[]; }; +struct btf_id_set8 { +u32 cnt; +u32 flags; +struct { +u32 id; +u32 flags; + } pairs[]; +}; +#ifdef CONFIG_DEBUG_INFO_BTF #include <linux/compiler.h> /* for __PASTE */
@@ -48,6 +57,16 @@ asm( \#define BTF_ID (prefix, name) \ __BTF_ID(__ID(__BTF_ID__##prefix##__##name##__)) +#define ____BTF_ID_FLAGS_LIST (_0, _1, _2, _3, _4, _5,N , ...) _1##_##_2##_##_3##_##_4##_##_5##__ +#define __BTF_ID_FLAGS_LIST (...) ____BTF_ID_FLAGS_LIST(0x0, ##__VA_ARGS__, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0) + +#define __FLAGS (prefix, ...) \ + __PASTE(prefix, __BTF_ID_FLAGS_LIST(__VA_ARGS__)) + +#define BTF_ID_FLAGS (prefix, name, ...) \ + BTF_ID(prefix, name) \ + __BTF_ID(__ID(__FLAGS(__BTF_ID__flags__, ##__VA_ARGS__))) +/* * The BTF_ID_LIST macro defines pure (unsorted) list * of BTF IDs, with following layout:
@@ -145,10 +164,53 @@ asm( \ ".popsection; \n"); \extern struct btf_id_set name; +/* +* The BTF_SET8_START/END macros pair defines sorted list of +* BTF IDs and their flags plus its members count, with the +* following layout: +* +* BTF_SET8_START(list) +* BTF_ID_FLAGS(type1, name1, flags...) +* BTF_ID_FLAGS(type2, name2, flags...) +* BTF_SET8_END(list) +* +* __BTF_ID__set8__list: +* .zero 8 +* list: +* __BTF_ID__type1__name1__3: +* .zero 4 +* __BTF_ID__flags__0x0_0x0_0x0_0x0_0x0__4: +* .zero 4 +* __BTF_ID__type2__name2__5: +* .zero 4 +* __BTF_ID__flags__0x0_0x0_0x0_0x0_0x0__6: +* .zero 4 +* +*/ +#define __BTF_SET8_START (name, scope) \ +asm( \ +".pushsection " BTF_IDS_SECTION ",\"a\"; \n" \ +"." #scope " __BTF_ID__set8__" #name "; \n" \ +"__BTF_ID__set8__" #name ":; \n" \ +".zero 8 \n" \ +".popsection; \n"); + +#define BTF_SET8_START (name) \ +__BTF_ID_LIST(name, local) \ +__BTF_SET8_START(name, local) + +#define BTF_SET8_END (name) \ +asm( \ +".pushsection " BTF_IDS_SECTION ",\"a\"; \n" \ +".size __BTF_ID__set8__" #name ", .-" #name " \n" \ +".popsection; \n"); \ +extern struct btf_id_set8 name; +#else #define BTF_ID_LIST (name) static u32 __maybe_unused name[5];#define BTF_ID (prefix, name) +#define BTF_ID_FLAGS (prefix, name, ...)#define BTF_ID_UNUSED #define BTF_ID_LIST_GLOBAL (name, n) u32 __maybe_unused name[n];#define BTF_ID_LIST_SINGLE (name, prefix, typename) static u32 __maybe_unused name[1];
@@ -156,6 +218,8 @@ extern struct btf_id_set name;#define BTF_SET_START (name) static struct btf_id_set __maybe_unused name = { 0 };#define BTF_SET_START_GLOBAL (name) static struct btf_id_set __maybe_unused name = { 0 };#define BTF_SET_END (name) +#define BTF_SET8_START (name) static struct btf_id_set8 __maybe_unused name = { 0 }; +#define BTF_SET8_END (name) static struct btf_id_set8 __maybe_unused name = { 0 };#endif /* CONFIG_DEBUG_INFO_BTF */
Signature · 1 line
2.34.1
Re: [PATCH bpf-next v6 01/13] bpf: Introduce BTF ID flags and 8-byte BTF set
Quoted 25 lines · Kumar Kartikeya Dwivedi
include/linux/btf_ids.h +17
-0+#define ____BTF_ID_FLAGS_LIST (_0, _1, _2, _3, _4, _5,N , ...) _1##_##_2##_##_3##_##_4##_##_5##__ +#define __BTF_ID_FLAGS_LIST (...) ____BTF_ID_FLAGS_LIST(0x0, ##__VA_ARGS__, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0) + +#define __FLAGS (prefix, ...) \ + __PASTE(prefix, __BTF_ID_FLAGS_LIST(__VA_ARGS__)) + +#define BTF_ID_FLAGS (prefix, name, ...) \ + BTF_ID(prefix, name) \ + __BTF_ID(__ID(__FLAGS(__BTF_ID__flags__, ##__VA_ARGS__))) +/* * The BTF_ID_LIST macro defines pure (unsorted) list * of BTF IDs, with following layout: @@ -145,10 +164,53 @@ asm( \ ".popsection; \n"); \extern struct btf_id_set name; +/* +* The BTF_SET8_START/END macros pair defines sorted list of +* BTF IDs and their flags plus its members count, with the +* following layout: +* +* BTF_SET8_START(list) +* BTF_ID_FLAGS(type1, name1, flags...)
include/linux/btf_ids.h asm( \ · line 183
Quoted 10 lines
include/linux/btf_ids.h +10
-0+* BTF_ID_FLAGS(type2, name2, flags...) +* BTF_SET8_END(list) +* +* __BTF_ID__set8__list: +* .zero 8 +* list: +* __BTF_ID__type1__name1__3: +* .zero 4 +* __BTF_ID__flags__0x0_0x0_0x0_0x0_0x0__4: +* .zero 4
Overall looks great,
but why encode flags into a name?
Why reuse ____BTF_ID for flags and complicate resolve_btfid? Instead of .zero 4 insert the actual flags as .word ?
The usage will be slightly different.
Instead of:BTF_ID_FLAGS(func, bpf_get_task_pid, KF_ACQUIRE, KF_RET_NULL) it will beBTF_ID_FLAGS(func, bpf_get_task_pid, KF_ACQUIRE | KF_RET_NULL)
Kumar Kartikeya Dwivedi
maintainerRe: [PATCH bpf-next v6 01/13] bpf: Introduce BTF ID flags and 8-byte BTF set
Quoted 43 lines · Alexei Starovoitov
Quoted 25 lines · Kumar Kartikeya Dwivedi
include/linux/btf_ids.h +17
-0+#define ____BTF_ID_FLAGS_LIST (_0, _1, _2, _3, _4, _5,N , ...) _1##_##_2##_##_3##_##_4##_##_5##__ +#define __BTF_ID_FLAGS_LIST (...) ____BTF_ID_FLAGS_LIST(0x0, ##__VA_ARGS__, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0) + +#define __FLAGS (prefix, ...) \ + __PASTE(prefix, __BTF_ID_FLAGS_LIST(__VA_ARGS__)) + +#define BTF_ID_FLAGS (prefix, name, ...) \ + BTF_ID(prefix, name) \ + __BTF_ID(__ID(__FLAGS(__BTF_ID__flags__, ##__VA_ARGS__))) +/* * The BTF_ID_LIST macro defines pure (unsorted) list * of BTF IDs, with following layout: @@ -145,10 +164,53 @@ asm( \ ".popsection; \n"); \extern struct btf_id_set name; +/* +* The BTF_SET8_START/END macros pair defines sorted list of +* BTF IDs and their flags plus its members count, with the +* following layout: +* +* BTF_SET8_START(list) +* BTF_ID_FLAGS(type1, name1, flags...) include/linux/btf_ids.h asm( \ · line 183
Quoted 10 lines
include/linux/btf_ids.h +10
-0+* BTF_ID_FLAGS(type2, name2, flags...) +* BTF_SET8_END(list) +* +* __BTF_ID__set8__list: +* .zero 8 +* list: +* __BTF_ID__type1__name1__3: +* .zero 4 +* __BTF_ID__flags__0x0_0x0_0x0_0x0_0x0__4: +* .zero 4 Overall looks great,
but why encode flags into a name?
Why reuse____BTF_IDfor flags and complicateresolve_btfid? Instead of .zero 4 insert the actual flags as .word ?
Quoted 5 lines
The usage will be slightly different.
Instead of:BTF_ID_FLAGS(func, bpf_get_task_pid, KF_ACQUIRE, KF_RET_NULL)it will beBTF_ID_FLAGS(func, bpf_get_task_pid, KF_ACQUIRE | KF_RET_NULL)
Nice, I didn't know you could do complex expressions like this for asm directives like .word, but it makes sense now. TIL. I'm not very well versed with GNU as. I will rework this and drop the resolve_btfids changes for flags. Thanks a lot!
Kumar Kartikeya Dwivedi
maintainerPATCH v6 2/13 tools/resolve_btfids: Add support for resolving kfunc flags
In reply to Kumar Kartikeya DwivediA flag is a 4-byte symbol that may follow a BTF ID in a set8. This is used in the kernel to tag kfuncs in BTF sets with certain flags. Add support to resolve_btfids to resolve and patch these in so they are available for lookup in the kernel by directly searching into the BTF set.
Since we don't need lookup support for the flags, we can simply store them in a list instead of rbtree.
--- tools/bpf/resolve_btfids/main.c | 115 ++++++++++++++++++++++++++++++-- 1 file changed, 108 insertions(+), 7 deletions(-)
tools/bpf/resolve_btfids/main.c +108 -7
@@ -35,6 +35,10 @@* __BTF_ID__typedef__pid_t__1: * .zero 4 * +* flags - store specified flag values after ORing them into the data: +* __BTF_ID__flags__0x0_0x0_0x0_0x0_0x0__1: +* .zero 4 +* * set - store symbol size into first 4 bytes and sort following * ID list *
@@ -45,6 +49,21 @@* .zero 4 * __BTF_ID__func__vfs_fallocate__4: * .zero 4 +* +* set8 - store symbol size into first 4 bytes and sort following +* ID list +* +* __BTF_ID__set8__list: +* .zero 8 +* list: +* __BTF_ID__func__vfs_getattr__3: +* .zero 4 +* __BTF_ID__flags__0x0_0x0_0x0_0x0_0x0__4: +* .zero 4 +* __BTF_ID__func__vfs_fallocate__5: +* .zero 4 +* __BTF_ID__flags__0x0_0x0_0x0_0x0_0x0__6: +* .zero 4 */ #define _GNU_SOURCE
@@ -57,6 +76,7 @@#include <sys/stat.h> #include <fcntl.h> #include <errno.h> +#include <linux/list.h> #include <linux/rbtree.h> #include <linux/zalloc.h> #include <linux/err.h>
@@ -71,12 +91,17 @@#define BTF_UNION "union"#define BTF_TYPEDEF "typedef"#define BTF_FUNC "func" +#define BTF_FLAGS "flags"#define BTF_SET "set" +#define BTF_SET8 "set8"#define ADDR_CNT 100struct btf_id { -struct rb_node rb_node; +union { +struct rb_node rb_node; +struct list_head ls_node; + };char *name;union {int id;
@@ -84,6 +109,8 @@ struct btf_id { };int addr_cnt;bool is_set; +bool is_set8; +bool is_flag;Elf64_Addr addr[ADDR_CNT ]; };
@@ -109,6 +136,8 @@ struct object {struct rb_root typedefs;struct rb_root funcs; +struct list_head flags; +int nr_funcs;int nr_structs;int nr_unions;
@@ -198,6 +227,20 @@ btf_id__add(struct rb_root *root, char *name, bool unique)return id; } +static struct btf_id * +btf_id_flags__add (struct list_head *list,char *name) +{ +struct btf_id *id; + + id =zalloc (sizeof (*id)); +if (id) { +pr_debug ("adding flags %s\n" , name); + id->name = name; +list_add (&id->ls_node, list); + } +return id; +} +static char *get_id (const char *prefix_end) {/*
@@ -231,14 +274,14 @@ static char *get_id(const char *prefix_end)return id; } -static struct btf_id *add_set (struct object *obj,char *name) +static struct btf_id *add_set (struct object *obj,char *name,bool is_set8) {/* * __BTF_ID__set__name * name = ^ * id = ^ */ -char *id = name +sizeof (BTF_SET "__" ) -1 ; +char *id = name + (is_set8 ?sizeof (BTF_SET8 "__" ) :sizeof (BTF_SET "__" )) -1 ;int len =strlen (name);if (id >= name + len) {
@@ -262,6 +305,19 @@ static struct btf_id *add_symbol(struct rb_root *root, char *name, size_t size)return btf_id__add (root, id, false); } +static struct btf_id *add_flags (struct list_head *list,char *name,size_t size) +{ +char *id; + + id =get_id (name + size); +if (!id) { +pr_err ("FAILED to parse symbol name: %s\n" , name); +return NULL ; + } + +return btf_id_flags__add (list, id); +} +/* Older libelf.h and glibc elf.h might not yet define the ELF compression types. */ #ifndef SHF_COMPRESSED #define SHF_COMPRESSED (1 << 11)/* Section with compressed data. */
@@ -444,9 +500,26 @@ static int symbols_collect(struct object *obj) }else if (!strncmp (prefix,BTF_FUNC ,sizeof (BTF_FUNC ) -1 )) { obj->nr_funcs++; id =add_symbol (&obj->funcs, prefix,sizeof (BTF_FUNC ) -1 ); +/* flags */ + }else if (!strncmp (prefix,BTF_FLAGS ,sizeof (BTF_FLAGS ) -1 )) { + id =add_flags (&obj->flags, prefix,sizeof (BTF_FLAGS ) -1 ); +if (id) + id->is_flag = true; +/* set8 */ + }else if (!strncmp (prefix,BTF_SET8 ,sizeof (BTF_SET8 ) -1 )) { + id =add_set (obj, prefix, true); +/* +* SET8 objects store list's count, which is encoded +* in symbol's size, together with 'cnt' field hence +* that - 1. +*/ +if (id) { + id->cnt = sym.st_size /sizeof (uint64_t ) -1 ; + id->is_set8 = true; + }/* set */ }else if (!strncmp (prefix,BTF_SET ,sizeof (BTF_SET ) -1 )) { - id =add_set (obj, prefix); + id =add_set (obj, prefix, false);/* * SET objects store list's count, which is encoded * in symbol's size, together with 'cnt' field hence
@@ -482,6 +555,7 @@ static int symbols_resolve(struct object *obj)int nr_unions = obj->nr_unions;int nr_funcs = obj->nr_funcs;struct btf *base_btf =NULL ; +struct btf_id *flags_id;int err, type_id;struct btf *btf;__u32 nr_types;
@@ -558,6 +632,17 @@ static int symbols_resolve(struct object *obj) } } +/* Resolve all the BTF ID flags */ +list_for_each_entry (flags_id, &obj->flags, ls_node) { +int f1, f2, f3, f4, f5; + +if (sscanf (flags_id->name,"0x%x_0x%x_0x%x_0x%x_0x%x" , &f1, &f2, &f3, &f4, &f5) !=5 ) { +pr_err ("FAILED: malformed flags, can't resolve: %s\n" , flags_id->name); + goto out; + } + flags_id->id = f1 | f2 | f3 | f4 | f5; + } + err =0 ; out:btf__free (base_btf);
@@ -571,7 +656,8 @@ static int id_patch(struct object *obj, struct btf_id *id)int *ptr = data->d_buf;int i; -if (!id->id && !id->is_set) +/* For set, set8, and flags, id->id may be 0 */ +if (!id->id && !id->is_set && !id->is_set8 && !id->is_flag)pr_err ("WARN: resolve_btfids: unresolved symbol %s\n" , id->name);for (i =0 ; i < id->addr_cnt; i++) {
@@ -611,6 +697,17 @@ static int __symbols_patch(struct object *obj, struct rb_root *root)return 0 ; } +static int flags_patch (struct object *obj) +{ +struct btf_id *flags_id; + +list_for_each_entry (flags_id, &obj->flags, ls_node) { +if (id_patch (obj, flags_id)) +return -1 ; + } +return 0 ; +} +static int cmp_id (const void *pa,const void *pb) {const int *a = pa, *b = pb;
@@ -643,13 +740,13 @@ static int sets_patch(struct object *obj) } idx = idx /sizeof (int ); - base = &ptr[idx] +1 ; + base = &ptr[idx] + (id->is_set8 ?2 :1 ); cnt = ptr[idx];pr_debug ("sorting addr %5lu: cnt %6d [%s]\n" , (idx +1 ) *sizeof (int ), cnt, id->name); -qsort (base, cnt,sizeof (int ), cmp_id); +qsort (base, cnt, id->is_set8 ?sizeof (uint64_t ) :sizeof (int ), cmp_id); next =rb_next (next); }
@@ -667,6 +764,9 @@ static int symbols_patch(struct object *obj) __symbols_patch(obj, &obj->sets))return -1 ; +if (flags_patch (obj)) +return -1 ; +if (sets_patch (obj))return -1 ;
@@ -715,6 +815,7 @@ int main(int argc, const char **argv) };int err =-1 ; +INIT_LIST_HEAD (&obj.flags); argc =parse_options (argc, argv, btfid_options, resolve_btfids_usage,PARSE_OPT_STOP_AT_NON_OPTION );if (argc !=1 )
Signature · 1 line
2.34.1
Kumar Kartikeya Dwivedi
maintainerPATCH v6 3/13 bpf: Switch to new kfunc flags infrastructure
In reply to Kumar Kartikeya DwivediInstead of populating multiple sets to indicate some attribute and then researching the same BTF ID in them, prepare a single unified BTF set which indicates whether a kfunc is allowed to be called, and also its attributes if any at the same time. Now, only one call is needed to perform the lookup for both kfunc availability and its attributes.
--- include/linux/bpf.h | 3 +- include/linux/btf.h | 36 +++--- kernel/bpf/btf.c | 103 ++++++++---------- kernel/bpf/verifier.c | 14 +-- net/bpf/test_run.c | 70 ++++-------- net/ipv4/bpf_tcp_ca.c | 18 +-- net/ipv4/tcp_bbr.c | 24 ++-- net/ipv4/tcp_cubic.c | 20 ++-- net/ipv4/tcp_dctcp.c | 20 ++-- net/netfilter/nf_conntrack_bpf.c | 49 ++------- .../selftests/bpf/bpf_testmod/bpf_testmod.c | 10 +- 11 files changed, 145 insertions(+), 222 deletions(-)
include/linux/bpf.h +2 -1
@@ -1920,7 +1920,8 @@ int btf_check_subprog_arg_match(struct bpf_verifier_env *env, int subprog, struct bpf_reg_state *regs);int btf_check_kfunc_arg_match (struct bpf_verifier_env *env,const struct btf *btf,u32 func_id, -struct bpf_reg_state *regs); +struct bpf_reg_state *regs, +u32 kfunc_flags);int btf_prepare_func_args (struct bpf_verifier_env *env,int subprog,struct bpf_reg_state *reg); int btf_check_type_match(struct bpf_verifier_log *log, const struct bpf_prog *prog,
include/linux/btf.h +13 -23
@@ -12,14 +12,14 @@#define BTF_TYPE_EMIT (type) ((void)(type *)0)#define BTF_TYPE_EMIT_ENUM (enum_val) ((void)enum_val) -enum btf_kfunc_type { -BTF_KFUNC_TYPE_CHECK , -BTF_KFUNC_TYPE_ACQUIRE , -BTF_KFUNC_TYPE_RELEASE , -BTF_KFUNC_TYPE_RET_NULL , -BTF_KFUNC_TYPE_KPTR_ACQUIRE , -BTF_KFUNC_TYPE_MAX , -}; +/* These kfunc flags need to be macros, as we substitute the flag value as a +* string into the flags symbol name, which is then parsed and patched in by +* resolve_btfids. +*/ +#define KF_ACQUIRE 0x00000001/* kfunc is an acquire function */ +#define KF_RELEASE 0x00000002/* kfunc is a release function */ +#define KF_RET_NULL 0x00000004/* kfunc returns a pointer that may be NULL */ +#define KF_KPTR_GET 0x00000008/* kfunc returns reference to a kptr */ struct btf ;struct btf_member ;
@@ -30,16 +30,7 @@ struct btf_id_set;struct btf_kfunc_id_set {struct module *owner; -union { -struct { -struct btf_id_set *check_set; -struct btf_id_set *acquire_set; -struct btf_id_set *release_set; -struct btf_id_set *ret_null_set; -struct btf_id_set *kptr_acquire_set; - }; -struct btf_id_set *sets[BTF_KFUNC_TYPE_MAX ]; - }; +struct btf_id_set8 *set; };struct btf_id_dtor_kfunc {
@@ -378,9 +369,9 @@ const struct btf_type *btf_type_by_id(const struct btf *btf, u32 type_id);const char *btf_name_by_offset (const struct btf *btf,u32 offset);struct btf *btf_parse_vmlinux (void );struct btf *bpf_prog_get_target_btf (const struct bpf_prog *prog); -bool btf_kfunc_id_set_contains (const struct btf *btf, +u32 *btf_kfunc_id_set_contains (const struct btf *btf,enum bpf_prog_type prog_type, -enum btf_kfunc_type type,u32 kfunc_btf_id); +u32 kfunc_btf_id);int register_btf_kfunc_id_set (enum bpf_prog_type prog_type,const struct btf_kfunc_id_set *s);s32 btf_find_dtor_kfunc (struct btf *btf,u32 btf_id);
@@ -397,12 +388,11 @@ static inline const char *btf_name_by_offset(const struct btf *btf, {return NULL ; } -static inline bool btf_kfunc_id_set_contains (const struct btf *btf, +static inline u32 *btf_kfunc_id_set_contains (const struct btf *btf,enum bpf_prog_type prog_type, -enum btf_kfunc_type type,u32 kfunc_btf_id) { -return false; +return NULL ; }static inline int register_btf_kfunc_id_set (enum bpf_prog_type prog_type,const struct btf_kfunc_id_set *s)
kernel/bpf/btf.c +45 -58
227 lines not on this page · raw message
kernel/bpf/verifier.c +6 -8
@@ -7560,6 +7560,7 @@ static int check_kfunc_call(struct bpf_verifier_env *env, struct bpf_insn *insn,int err, insn_idx = *insn_idx_p;const struct btf_param *args;struct btf *desc_btf; +u32 *kfunc_flags;bool acq;/* skip for now, but return error when we find this in fixup_kfunc_call */
@@ -7575,18 +7576,16 @@ static int check_kfunc_call(struct bpf_verifier_env *env, struct bpf_insn *insn, func_name =btf_name_by_offset (desc_btf, func->name_off); func_proto =btf_type_by_id (desc_btf, func->type); -if (!btf_kfunc_id_set_contains (desc_btf,resolve_prog_type (env->prog), -BTF_KFUNC_TYPE_CHECK , func_id)) { + kfunc_flags =btf_kfunc_id_set_contains (desc_btf,resolve_prog_type (env->prog), func_id); +if (!kfunc_flags) {verbose (env,"calling kernel function %s is not allowed\n" , func_name);return -EACCES ; } - - acq =btf_kfunc_id_set_contains (desc_btf,resolve_prog_type (env->prog), -BTF_KFUNC_TYPE_ACQUIRE , func_id); + acq = *kfunc_flags &KF_ACQUIRE ;/* Check the arguments */ - err =btf_check_kfunc_arg_match (env, desc_btf, func_id, regs); + err =btf_check_kfunc_arg_match (env, desc_btf, func_id, regs, *kfunc_flags);if (err <0 )return err;/* In case of release function, we get register number of refcounted
@@ -7630,8 +7629,7 @@ static int check_kfunc_call(struct bpf_verifier_env *env, struct bpf_insn *insn, regs[BPF_REG_0 ].btf = desc_btf; regs[BPF_REG_0 ].type =PTR_TO_BTF_ID ; regs[BPF_REG_0 ].btf_id = ptr_type_id; -if (btf_kfunc_id_set_contains (desc_btf,resolve_prog_type (env->prog), -BTF_KFUNC_TYPE_RET_NULL , func_id)) { +if (*kfunc_flags &KF_RET_NULL ) { regs[BPF_REG_0 ].type |=PTR_MAYBE_NULL ;/* For mark_ptr_or_null_reg, see 93c230e3f5bd6 */ regs[BPF_REG_0 ].id = ++env->id_gen;
net/bpf/test_run.c +22 -48
82 lines not on this page · raw message
net/ipv4/bpf_tcp_ca.c +9 -9
@@ -197,17 +197,17 @@ bpf_tcp_ca_get_func_proto(enum bpf_func_id func_id, } } -BTF_SET_START (bpf_tcp_ca_check_kfunc_ids) -BTF_ID (func ,tcp_reno_ssthresh ) -BTF_ID (func, tcp_reno_cong_avoid) -BTF_ID (func, tcp_reno_undo_cwnd) -BTF_ID (func, tcp_slow_start) -BTF_ID (func, tcp_cong_avoid_ai) -BTF_SET_END (bpf_tcp_ca_check_kfunc_ids) +BTF_SET8_START (bpf_tcp_ca_check_kfunc_ids) +BTF_ID_FLAGS (func ,tcp_reno_ssthresh ) +BTF_ID_FLAGS (func, tcp_reno_cong_avoid) +BTF_ID_FLAGS (func, tcp_reno_undo_cwnd) +BTF_ID_FLAGS (func, tcp_slow_start) +BTF_ID_FLAGS (func, tcp_cong_avoid_ai) +BTF_SET8_END (bpf_tcp_ca_check_kfunc_ids) static const struct btf_kfunc_id_set bpf_tcp_ca_kfunc_set = { - .owner =THIS_MODULE , - .check_set = &bpf_tcp_ca_check_kfunc_ids, + .owner =THIS_MODULE , + .set = &bpf_tcp_ca_check_kfunc_ids, };static const struct bpf_verifier_ops bpf_tcp_ca_verifier_ops = {
net/ipv4/tcp_bbr.c +12 -12
@@ -1154,24 +1154,24 @@ static struct tcp_congestion_ops tcp_bbr_cong_ops __read_mostly = { .set_state = bbr_set_state, }; -BTF_SET_START(tcp_bbr_check_kfunc_ids) +BTF_SET8_START(tcp_bbr_check_kfunc_ids)#ifdef CONFIG_X86 #ifdef CONFIG_DYNAMIC_FTRACE -BTF_ID(func, bbr_init) -BTF_ID(func, bbr_main) -BTF_ID(func, bbr_sndbuf_expand) -BTF_ID(func, bbr_undo_cwnd) -BTF_ID(func, bbr_cwnd_event) -BTF_ID(func, bbr_ssthresh) -BTF_ID(func, bbr_min_tso_segs) -BTF_ID(func, bbr_set_state) +BTF_ID_FLAGS(func, bbr_init) +BTF_ID_FLAGS(func, bbr_main) +BTF_ID_FLAGS(func, bbr_sndbuf_expand) +BTF_ID_FLAGS(func, bbr_undo_cwnd) +BTF_ID_FLAGS(func, bbr_cwnd_event) +BTF_ID_FLAGS(func, bbr_ssthresh) +BTF_ID_FLAGS(func, bbr_min_tso_segs) +BTF_ID_FLAGS(func, bbr_set_state)#endif #endif -BTF_SET_END (tcp_bbr_check_kfunc_ids) +BTF_SET8_END (tcp_bbr_check_kfunc_ids) static const struct btf_kfunc_id_set tcp_bbr_kfunc_set = { - .owner =THIS_MODULE , - .check_set = &tcp_bbr_check_kfunc_ids, + .owner =THIS_MODULE , + .set = &tcp_bbr_check_kfunc_ids, };static int __init bbr_register (void )
net/ipv4/tcp_cubic.c +10 -10
@@ -485,22 +485,22 @@ static struct tcp_congestion_ops cubictcp __read_mostly = { .name = "cubic", }; -BTF_SET_START(tcp_cubic_check_kfunc_ids) +BTF_SET8_START(tcp_cubic_check_kfunc_ids)#ifdef CONFIG_X86 #ifdef CONFIG_DYNAMIC_FTRACE -BTF_ID(func, cubictcp_init) -BTF_ID(func, cubictcp_recalc_ssthresh) -BTF_ID(func, cubictcp_cong_avoid) -BTF_ID(func, cubictcp_state) -BTF_ID(func, cubictcp_cwnd_event) -BTF_ID(func, cubictcp_acked) +BTF_ID_FLAGS(func, cubictcp_init) +BTF_ID_FLAGS(func, cubictcp_recalc_ssthresh) +BTF_ID_FLAGS(func, cubictcp_cong_avoid) +BTF_ID_FLAGS(func, cubictcp_state) +BTF_ID_FLAGS(func, cubictcp_cwnd_event) +BTF_ID_FLAGS(func, cubictcp_acked)#endif #endif -BTF_SET_END (tcp_cubic_check_kfunc_ids) +BTF_SET8_END (tcp_cubic_check_kfunc_ids) static const struct btf_kfunc_id_set tcp_cubic_kfunc_set = { - .owner =THIS_MODULE , - .check_set = &tcp_cubic_check_kfunc_ids, + .owner =THIS_MODULE , + .set = &tcp_cubic_check_kfunc_ids, };static int __init cubictcp_register (void )
net/ipv4/tcp_dctcp.c +10 -10
@@ -239,22 +239,22 @@ static struct tcp_congestion_ops dctcp_reno __read_mostly = { .name = "dctcp-reno", }; -BTF_SET_START(tcp_dctcp_check_kfunc_ids) +BTF_SET8_START(tcp_dctcp_check_kfunc_ids)#ifdef CONFIG_X86 #ifdef CONFIG_DYNAMIC_FTRACE -BTF_ID(func, dctcp_init) -BTF_ID(func, dctcp_update_alpha) -BTF_ID(func, dctcp_cwnd_event) -BTF_ID(func, dctcp_ssthresh) -BTF_ID(func, dctcp_cwnd_undo) -BTF_ID(func, dctcp_state) +BTF_ID_FLAGS(func, dctcp_init) +BTF_ID_FLAGS(func, dctcp_update_alpha) +BTF_ID_FLAGS(func, dctcp_cwnd_event) +BTF_ID_FLAGS(func, dctcp_ssthresh) +BTF_ID_FLAGS(func, dctcp_cwnd_undo) +BTF_ID_FLAGS(func, dctcp_state)#endif #endif -BTF_SET_END (tcp_dctcp_check_kfunc_ids) +BTF_SET8_END (tcp_dctcp_check_kfunc_ids) static const struct btf_kfunc_id_set tcp_dctcp_kfunc_set = { - .owner =THIS_MODULE , - .check_set = &tcp_dctcp_check_kfunc_ids, + .owner =THIS_MODULE , + .set = &tcp_dctcp_check_kfunc_ids, };static int __init dctcp_register (void )
net/netfilter/nf_conntrack_bpf.c +11 -38
59 lines not on this page · raw message
tools/testing/selftests/bpf/bpf_testmod/bpf_testmod.c +5 -5
@@ -148,13 +148,13 @@ static struct bin_attribute bin_attr_bpf_testmod_file __ro_after_init = { .write = bpf_testmod_test_write, }; -BTF_SET_START (bpf_testmod_check_kfunc_ids) -BTF_ID (func ,bpf_testmod_test_mod_kfunc ) -BTF_SET_END (bpf_testmod_check_kfunc_ids) +BTF_SET8_START (bpf_testmod_check_kfunc_ids) +BTF_ID_FLAGS (func ,bpf_testmod_test_mod_kfunc ) +BTF_SET8_END (bpf_testmod_check_kfunc_ids) static const struct btf_kfunc_id_set bpf_testmod_kfunc_set = { - .owner =THIS_MODULE , - .check_set = &bpf_testmod_check_kfunc_ids, + .owner =THIS_MODULE , + .set = &bpf_testmod_check_kfunc_ids, };extern int bpf_fentry_test1 (int a);
Signature · 1 line
2.34.1
Kumar Kartikeya Dwivedi
maintainerPATCH v6 4/13 bpf: Add support for forcing kfunc args to be trusted
In reply to Kumar Kartikeya DwivediTeach the verifier to detect a new KF_TRUSTED_ARGS kfunc flag, which means each pointer argument must be trusted, which we define as a pointer that is referenced (has non-zero ref_obj_id) and also needs to have its offset unchanged, similar to how release functions expect their argument. This allows a kfunc to receive pointer arguments unchanged from the result of the acquire kfunc.
This is required to ensure that kfunc that operate on some object only work on acquired pointers and not normal PTR_TO_BTF_ID with same type which can be obtained by pointer walking. The restrictions applied to release arguments also apply to trusted arguments. This implies that strict type matching (not deducing type by recursively following members at offset) and OBJ_RELEASE offset checks (ensuring they are zero) are used for trusted pointer arguments.
--- include/linux/btf.h | 32 ++++++++++++++++++++++++++++++++ kernel/bpf/btf.c | 17 ++++++++++++++--- net/bpf/test_run.c | 5 +++++ 3 files changed, 51 insertions(+), 3 deletions(-)
include/linux/btf.h +32 -0
@@ -20,6 +20,38 @@#define KF_RELEASE 0x00000002/* kfunc is a release function */ #define KF_RET_NULL 0x00000004/* kfunc returns a pointer that may be NULL */ #define KF_KPTR_GET 0x00000008/* kfunc returns reference to a kptr */ +/* Trusted arguments are those which are meant to be referenced arguments with +* unchanged offset. It is used to enforce that pointers obtained from acquire +* kfuncs remain unmodified when being passed to helpers taking trusted args. +* +* Consider +* struct foo { +* int data; +* struct foo *next; +* }; +* +* struct bar { +* int data; +* struct foo f; +* }; +* +* struct foo *f = alloc_foo(); // Acquire kfunc +* struct bar *b = alloc_bar(); // Acquire kfunc +* +* If a kfunc set_foo_data() wants to operate only on the allocated object, it +* will set the KF_TRUSTED_ARGS flag, which will prevent unsafe usage like: +* +* set_foo_data(f, 42); // Allowed +* set_foo_data(f->next, 42); // Rejected, non-referenced pointer +* set_foo_data(&f->next, 42);// Rejected, referenced, but bad offset +* set_foo_data(&b->f, 42); // Rejected, referenced, but wrong type +* +* In the final case, usually for the purposes of type matching, it is deduced +* by looking at the type of the member at the offset, but due to the +* requirement of trusted argument, this deduction will be strict and not done +* for this case. +*/ +#define KF_TRUSTED_ARGS 0x00000010/* kfunc only takes trusted pointer arguments */ struct btf ;struct btf_member ;
kernel/bpf/btf.c +14 -3
@@ -6174,10 +6174,10 @@ static int btf_check_func_arg_match(struct bpf_verifier_env *env, u32 kfunc_flags) {enum bpf_prog_type prog_type =resolve_prog_type (env->prog); +bool rel = false, kptr_get = false, trusted_arg = false;struct bpf_verifier_log *log = &env->log;u32 i, nargs, ref_id, ref_obj_id =0 ;bool is_kfunc =btf_is_kernel (btf); -bool rel = false, kptr_get = false;const char *func_name, *ref_tname;const struct btf_type *t, *ref_t;const struct btf_param *args;
@@ -6211,6 +6211,7 @@ static int btf_check_func_arg_match(struct bpf_verifier_env *env,/* Only kfunc can be release func */ rel = kfunc_flags &KF_RELEASE ; kptr_get = kfunc_flags &KF_KPTR_GET ; + trusted_arg = kfunc_flags &KF_TRUSTED_ARGS ; }/* check that BTF function arguments match actual types that the
@@ -6235,10 +6236,19 @@ static int btf_check_func_arg_match(struct bpf_verifier_env *env,return -EINVAL ; } +/* Check if argument must be a referenced pointer, args + i has +* been verified to be a pointer (after skipping modifiers). +*/ +if (is_kfunc && trusted_arg && !reg->ref_obj_id) { +bpf_log (log,"R%d must be referenced\n" , regno); +return -EINVAL ; + } + ref_t =btf_type_skip_modifiers (btf, t->type, &ref_id); ref_tname =btf_name_by_offset (btf, ref_t->name_off); -if (rel && reg->ref_obj_id) +/* Trusted args have the same offset checks as release arguments */ +if (trusted_arg || (rel && reg->ref_obj_id)) arg_type |=OBJ_RELEASE ; ret =check_func_arg_reg_off (env, reg, regno, arg_type);if (ret <0 )
@@ -6336,7 +6346,8 @@ static int btf_check_func_arg_match(struct bpf_verifier_env *env, reg_ref_tname =btf_name_by_offset (reg_btf, reg_ref_t->name_off);if (!btf_struct_ids_match (log, reg_btf, reg_ref_id, - reg->off, btf, ref_id, rel && reg->ref_obj_id)) { + reg->off, btf, ref_id, + trusted_arg || (rel && reg->ref_obj_id))) { bpf_log(log, "kernel function %s args#%d expected pointer to %s %s but R%d has a pointer to %s %s\n", func_name, i, btf_type_str(ref_t), ref_tname,
net/bpf/test_run.c +5 -0
@@ -691,6 +691,10 @@ noinline void bpf_kfunc_call_test_mem_len_fail2(u64 *mem, int len) { } +noinline void bpf_kfunc_call_test_ref(struct prog_test_ref_kfunc *p) +{ +} +__diag_pop ();ALLOW_ERROR_INJECTION (bpf_modify_return_test,ERRNO );
@@ -714,6 +718,7 @@ BTF_ID_FLAGS(func, bpf_kfunc_call_test_fail3) BTF_ID_FLAGS(func, bpf_kfunc_call_test_mem_len_pass1) BTF_ID_FLAGS(func, bpf_kfunc_call_test_mem_len_fail1) BTF_ID_FLAGS(func, bpf_kfunc_call_test_mem_len_fail2) +BTF_ID_FLAGS(func, bpf_kfunc_call_test_ref, KF_TRUSTED_ARGS)BTF_SET8_END (test_sk_check_kfunc_ids) static void *bpf_test_init(const union bpf_attr *kattr, u32 user_size,
Signature · 1 line
2.34.1
Kumar Kartikeya Dwivedi
maintainerPATCH v6 5/13 bpf: Add documentation for kfuncs
In reply to Kumar Kartikeya DwivediAs the usage of kfuncs grows, we are starting to form consensus on the kinds of attributes and annotations that kfuncs can have. To better help developers make sense of the various options available at their disposal to present an unstable API to the BPF users, document the various kfunc flags and annotations, their expected usage, and explain the process of defining and registering a kfunc set.
--- Documentation/bpf/index.rst | 1 + Documentation/bpf/kfuncs.rst | 171 +++++++++++++++++++++++++++++++++++ 2 files changed, 172 insertions(+) create mode 100644 Documentation/bpf/kfuncs.rst
Documentation/bpf/index.rst +1 -0
@@ -19,6 +19,7 @@ that goes into great technical depth about the BPF Architecture. faq syscall_api helpers + kfuncs programs maps bpf_prog_run
Documentation/bpf/kfuncs.rst new file +171 -0
171 lines not on this page · raw message
Signature · 1 line
2.34.1
Re: [PATCH bpf-next v6 05/13] bpf: Add documentation for kfuncs
Quoted 6 lines · Kumar Kartikeya Dwivedi
As the usage of kfuncs grows, we are starting to form consensus on the kinds of attributes and annotations that kfuncs can have. To better help developers make sense of the various options available at their disposal to present an unstable API to the BPF users, document the various kfunc flags and annotations, their expected usage, and explain the process of defining and registering a kfunc set.
[...]
Documentation/bpf/kfuncs.rst line 118
Quoted 8 lines
+2.4.2
KF_RET_NULLflag
+----------------------Documentation/bpf/kfuncs.rst new file +6
-0+ +The KF_RET_NULL flag is used to indicate that the pointer returned by the kfunc +may be NULL. Hence, it forces the user to do a NULL check on the pointer +returned from the kfunc before making use of it (dereferencing or passing to +another helper). This flag is often used in pairing with KF_ACQUIRE flag, but +both are mutually exclusive.
That last sentence is contradicting itself. "Mutually exclusive" means "can't be used together". I think you mean "orthogonal" or something to that effect?
-Toke
Kumar Kartikeya Dwivedi
maintainerRe: [PATCH bpf-next v6 05/13] bpf: Add documentation for kfuncs
Quoted 12 lines · Toke Høiland-Jørgensen
Quoted 6 lines · Kumar Kartikeya Dwivedi
As the usage of kfuncs grows, we are starting to form consensus on the kinds of attributes and annotations that kfuncs can have. To better help developers make sense of the various options available at their disposal to present an unstable API to the BPF users, document the various kfunc flags and annotations, their expected usage, and explain the process of defining and registering a kfunc set.
[...]
Quoted 12 lines
Documentation/bpf/kfuncs.rst line 118
Quoted 8 lines
+2.4.2
KF_RET_NULLflag
+----------------------Documentation/bpf/kfuncs.rst new file +6
-0+ +The KF_RET_NULL flag is used to indicate that the pointer returned by the kfunc +may be NULL. Hence, it forces the user to do a NULL check on the pointer +returned from the kfunc before making use of it (dereferencing or passing to +another helper). This flag is often used in pairing with KF_ACQUIRE flag, but +both are mutually exclusive.That last sentence is contradicting itself. "Mutually exclusive" means "can't be used together". I think you mean "orthogonal" or something to that effect?
Right, my bad. Mutually exclusive is totally incorrect here. I will use 'orthogonal' instead.
Quoted 3 lines
-Toke
Kumar Kartikeya Dwivedi
maintainerPATCH v6 6/13 net: netfilter: Deduplicate code in bpf_{xdp,skb}_ct_lookup
In reply to Kumar Kartikeya DwivediMove common checks inside the common function, and maintain the only difference the two being how to obtain the struct net * from ctx. No functional change intended.
--- net/netfilter/nf_conntrack_bpf.c | 52 +++++++++++--------------------- 1 file changed, 18 insertions(+), 34 deletions(-)
net/netfilter/nf_conntrack_bpf.c +18 -34
@@ -57,16 +57,19 @@ enum {static struct nf_conn *__bpf_nf_ct_lookup (struct net *net,struct bpf_sock_tuple *bpf_tuple, -u32 tuple_len,u8 protonum, -s32 netns_id,u8 *dir) +u32 tuple_len,struct bpf_ct_opts *opts, +u32 opts_len) {struct nf_conntrack_tuple_hash *hash;struct nf_conntrack_tuple tuple;struct nf_conn *ct; -if (unlikely (protonum !=IPPROTO_TCP && protonum !=IPPROTO_UDP )) +if (!opts || !bpf_tuple || opts->reserved[0 ] || opts->reserved[1 ] || + opts_len !=NF_BPF_CT_OPTS_SZ ) +return ERR_PTR (-EINVAL ); +if (unlikely (opts->l4proto !=IPPROTO_TCP && opts->l4proto !=IPPROTO_UDP ))return ERR_PTR (-EPROTO ); -if (unlikely (netns_id <BPF_F_CURRENT_NETNS )) +if (unlikely (opts->netns_id <BPF_F_CURRENT_NETNS ))return ERR_PTR (-EINVAL );memset (&tuple,0 ,sizeof (tuple));
@@ -89,23 +92,22 @@ static struct nf_conn *__bpf_nf_ct_lookup(struct net *net,return ERR_PTR (-EAFNOSUPPORT ); } - tuple.dst.protonum = protonum; + tuple.dst.protonum = opts->l4proto; -if (netns_id >=0 ) { - net =get_net_ns_by_id (net, netns_id); +if (opts->netns_id >=0 ) { + net =get_net_ns_by_id (net, opts->netns_id);if (unlikely (!net))return ERR_PTR (-ENONET ); } hash =nf_conntrack_find_get (net, &nf_ct_zone_dflt, &tuple); -if (netns_id >=0 ) +if (opts->netns_id >=0 )put_net (net);if (!hash)return ERR_PTR (-ENOENT ); ct =nf_ct_tuplehash_to_ctrack (hash); -if (dir) - *dir =NF_CT_DIRECTION (hash); + opts->dir =NF_CT_DIRECTION (hash);return ct; }
@@ -138,20 +140,11 @@ bpf_xdp_ct_lookup(struct xdp_md *xdp_ctx, struct bpf_sock_tuple *bpf_tuple,struct net *caller_net;struct nf_conn *nfct; -BUILD_BUG_ON (sizeof (struct bpf_ct_opts ) !=NF_BPF_CT_OPTS_SZ ); - -if (!opts) -return NULL ; -if (!bpf_tuple || opts->reserved[0 ] || opts->reserved[1 ] || - opts__sz !=NF_BPF_CT_OPTS_SZ ) { - opts->error = -EINVAL ; -return NULL ; - } caller_net =dev_net (ctx->rxq->dev); - nfct =__bpf_nf_ct_lookup (caller_net, bpf_tuple, tuple__sz, opts->l4proto, - opts->netns_id, &opts->dir); + nfct =__bpf_nf_ct_lookup (caller_net, bpf_tuple, tuple__sz, opts, opts__sz);if (IS_ERR (nfct)) { - opts->error =PTR_ERR (nfct); +if (opts) + opts->error =PTR_ERR (nfct);return NULL ; }return nfct;
@@ -181,20 +174,11 @@ bpf_skb_ct_lookup(struct __sk_buff *skb_ctx, struct bpf_sock_tuple *bpf_tuple,struct net *caller_net;struct nf_conn *nfct; -BUILD_BUG_ON (sizeof (struct bpf_ct_opts ) !=NF_BPF_CT_OPTS_SZ ); - -if (!opts) -return NULL ; -if (!bpf_tuple || opts->reserved[0 ] || opts->reserved[1 ] || - opts__sz !=NF_BPF_CT_OPTS_SZ ) { - opts->error = -EINVAL ; -return NULL ; - } caller_net = skb->dev ?dev_net (skb->dev) :sock_net (skb->sk); - nfct =__bpf_nf_ct_lookup (caller_net, bpf_tuple, tuple__sz, opts->l4proto, - opts->netns_id, &opts->dir); + nfct =__bpf_nf_ct_lookup (caller_net, bpf_tuple, tuple__sz, opts, opts__sz);if (IS_ERR (nfct)) { - opts->error =PTR_ERR (nfct); +if (opts) + opts->error =PTR_ERR (nfct);return NULL ; }return nfct;
Signature · 1 line
2.34.1
Kumar Kartikeya Dwivedi
maintainerPATCH v6 7/13 net: netfilter: Add kfuncs to allocate and insert CT
In reply to Kumar Kartikeya DwivediFrom: Lorenzo Bianconi <[email protected]>
Introduce bpf_xdp_ct_alloc, bpf_skb_ct_alloc and bpf_ct_insert_entry kfuncs in order to insert a new entry from XDP and TC programs. Introduce bpf_nf_ct_tuple_parse utility routine to consolidate common code.
We extract out a helper __nf_ct_set_timeout, used by the ctnetlink and nf_conntrack_bpf code, extract it out to nf_conntrack_core, so that nf_conntrack_bpf doesn't need a dependency on CONFIG_NF_CT_NETLINK. Later this helper will be reused as a helper to set timeout of allocated but not yet inserted CT entry.
The allocation functions return struct nf_conn___init instead of nf_conn, to distinguish allocated CT from an already inserted or looked up CT. This is later used to enforce restrictions on what kfuncs allocated CT can be used with.
--- include/net/netfilter/nf_conntrack_core.h | 15 ++ net/netfilter/nf_conntrack_bpf.c | 208 +++++++++++++++++++--- net/netfilter/nf_conntrack_netlink.c | 8 +- 3 files changed, 204 insertions(+), 27 deletions(-)
include/net/netfilter/nf_conntrack_core.h +15 -0
@@ -84,4 +84,19 @@ void nf_conntrack_lock(spinlock_t *lock);extern spinlock_t nf_conntrack_expect_lock; +/* ctnetlink code shared by both ctnetlink and nf_conntrack_bpf */ + +#if (IS_BUILTIN (CONFIG_NF_CONNTRACK ) &&IS_ENABLED (CONFIG_DEBUG_INFO_BTF )) || \ + (IS_MODULE (CONFIG_NF_CONNTRACK ) &&IS_ENABLED (CONFIG_DEBUG_INFO_BTF_MODULES ) || \ +IS_ENABLED (CONFIG_NF_CT_NETLINK )) + +static inline void __nf_ct_set_timeout (struct nf_conn *ct,u64 timeout) +{ +if (timeout >INT_MAX ) + timeout =INT_MAX ; +WRITE_ONCE (ct->timeout, nfct_time_stamp + (u32 )timeout); +} + +#endif +#endif /* _NF_CONNTRACK_CORE_H */
net/netfilter/nf_conntrack_bpf.c +187 -21
252 lines not on this page · raw message
net/netfilter/nf_conntrack_netlink.c +2 -6
@@ -2025,9 +2025,7 @@ static int ctnetlink_change_timeout(struct nf_conn *ct, {u64 timeout = (u64 )ntohl (nla_get_be32 (cda[CTA_TIMEOUT ])) *HZ ; -if (timeout >INT_MAX ) - timeout =INT_MAX ; -WRITE_ONCE (ct->timeout, nfct_time_stamp + (u32 )timeout); +__nf_ct_set_timeout (ct, timeout);if (test_bit (IPS_DYING_BIT , &ct->status))return -ETIME ;
@@ -2292,9 +2290,7 @@ ctnetlink_create_conntrack(struct net *net, goto err1; timeout = (u64 )ntohl (nla_get_be32 (cda[CTA_TIMEOUT ])) *HZ ; -if (timeout >INT_MAX ) - timeout =INT_MAX ; - ct->timeout = (u32 )timeout + nfct_time_stamp; +__nf_ct_set_timeout (ct, timeout);rcu_read_lock ();if (cda[CTA_HELP ]) {
Signature · 1 line
2.34.1
Kumar Kartikeya Dwivedi
maintainerPATCH v6 8/13 net: netfilter: Add kfuncs to set and change CT timeout
In reply to Kumar Kartikeya DwivediIntroduce bpf_ct_set_timeout and bpf_ct_change_timeout kfunc helpers in order to change nf_conn timeout. This is same as ctnetlink_change_timeout, hence code is shared between both by extracting it out to __nf_ct_change_timeout. It is also updated to return an error when it sees IPS_FIXED_TIMEOUT_BIT bit in ct->status, as that check was missing.
It is required to introduce two kfuncs taking nf_conn___init and nf_conn instead of sharing one because KF_TRUSTED_ARGS flag causes strict type checking. This would disallow passing nf_conn___init to kfunc taking nf_conn, and vice versa. We cannot remove the KF_TRUSTED_ARGS flag as we only want to accept refcounted pointers and not e.g. ct->master.
Apart from this, bpf_ct_set_timeout is only called for newly allocated CT so it doesn't need to inspect the status field just yet. Sharing the helpers even if it was possible would make timeout setting helper sensitive to order of setting status and timeout after allocation.
Hence, bpf_ct_set_* kfuncs are meant to be used on allocated CT, and bpf_ct_change_* kfuncs are meant to be used on inserted or looked up CT entry.
--- include/net/netfilter/nf_conntrack_core.h | 2 ++ net/netfilter/nf_conntrack_bpf.c | 38 +++++++++++++++++++++-- net/netfilter/nf_conntrack_core.c | 22 +++++++++++++ net/netfilter/nf_conntrack_netlink.c | 9 +----- 4 files changed, 60 insertions(+), 11 deletions(-)
include/net/netfilter/nf_conntrack_core.h +2 -0
@@ -97,6 +97,8 @@ static inline void __nf_ct_set_timeout(struct nf_conn *ct, u64 timeout)WRITE_ONCE (ct->timeout, nfct_time_stamp + (u32 )timeout); } +int __nf_ct_change_timeout (struct nf_conn *ct,u64 cta_timeout); +#endif #endif /* _NF_CONNTRACK_CORE_H */
net/netfilter/nf_conntrack_bpf.c +35 -3
@@ -331,12 +331,12 @@ bpf_skb_ct_lookup(struct __sk_buff *skb_ctx, struct bpf_sock_tuple *bpf_tuple,* * This must be invoked for referenced PTR_TO_BTF_ID. * -* @nfct__ref - Pointer to referenced nf_conn___init object, obtained +* @nfct - Pointer to referenced nf_conn___init object, obtained * using bpf_xdp_ct_alloc or bpf_skb_ct_alloc. */ -struct nf_conn *bpf_ct_insert_entry (struct nf_conn___init *nfct__ref) +struct nf_conn *bpf_ct_insert_entry (struct nf_conn___init *nfct_i) { -struct nf_conn *nfct = (struct nf_conn *)nfct__ref; +struct nf_conn *nfct = (struct nf_conn *)nfct_i;int err; err =nf_conntrack_hash_check_insert (nfct);
@@ -364,6 +364,36 @@ void bpf_ct_release(struct nf_conn *nfct)nf_ct_put (nfct); } +/* bpf_ct_set_timeout - Set timeout of allocated nf_conn +* +* Sets the default timeout of newly allocated nf_conn before insertion. +* This helper must be invoked for refcounted pointer to nf_conn___init. +* +* Parameters: +* @nfct - Pointer to referenced nf_conn object, obtained using +* bpf_xdp_ct_alloc or bpf_skb_ct_alloc. +* @timeout - Timeout in msecs. +*/ +void bpf_ct_set_timeout (struct nf_conn___init *nfct,u32 timeout) +{ +__nf_ct_set_timeout ((struct nf_conn *)nfct,msecs_to_jiffies (timeout)); +} + +/* bpf_ct_change_timeout - Change timeout of inserted nf_conn +* +* Change timeout associated of the inserted or looked up nf_conn. +* This helper must be invoked for refcounted pointer to nf_conn. +* +* Parameters: +* @nfct - Pointer to referenced nf_conn object, obtained using +* bpf_ct_insert_entry, bpf_xdp_ct_lookup, or bpf_skb_ct_lookup. +* @timeout - New timeout in msecs. +*/ +int bpf_ct_change_timeout (struct nf_conn *nfct,u32 timeout) +{ +return __nf_ct_change_timeout (nfct,msecs_to_jiffies (timeout)); +} + __diag_pop()BTF_SET8_START (nf_ct_kfunc_set)
@@ -373,6 +403,8 @@ BTF_ID_FLAGS(func, bpf_skb_ct_alloc, KF_ACQUIRE, KF_RET_NULL) BTF_ID_FLAGS(func, bpf_skb_ct_lookup, KF_ACQUIRE, KF_RET_NULL) BTF_ID_FLAGS(func, bpf_ct_insert_entry, KF_ACQUIRE, KF_RET_NULL, KF_RELEASE) BTF_ID_FLAGS(func, bpf_ct_release, KF_RELEASE) +BTF_ID_FLAGS(func, bpf_ct_set_timeout, KF_TRUSTED_ARGS) +BTF_ID_FLAGS(func, bpf_ct_change_timeout, KF_TRUSTED_ARGS)BTF_SET8_END (nf_ct_kfunc_set) static const struct btf_kfunc_id_set nf_conntrack_kfunc_set = {
net/netfilter/nf_conntrack_core.c +22 -0
@@ -2786,3 +2786,25 @@ int nf_conntrack_init_net(struct net *net)free_percpu (net->ct.stat);return ret; } + +#if (IS_BUILTIN (CONFIG_NF_CONNTRACK ) &&IS_ENABLED (CONFIG_DEBUG_INFO_BTF )) || \ + (IS_MODULE (CONFIG_NF_CONNTRACK ) &&IS_ENABLED (CONFIG_DEBUG_INFO_BTF_MODULES ) || \ +IS_ENABLED (CONFIG_NF_CT_NETLINK )) + +/* ctnetlink code shared by both ctnetlink and nf_conntrack_bpf */ + +int __nf_ct_change_timeout (struct nf_conn *ct,u64 timeout) +{ +if (test_bit (IPS_FIXED_TIMEOUT_BIT , &ct->status)) +return -EPERM ; + +__nf_ct_set_timeout (ct, timeout); + +if (test_bit (IPS_DYING_BIT , &ct->status)) +return -ETIME ; + +return 0 ; +} +EXPORT_SYMBOL_GPL (__nf_ct_change_timeout); + +#endif
net/netfilter/nf_conntrack_netlink.c +1 -8
@@ -2023,14 +2023,7 @@ static int ctnetlink_change_helper(struct nf_conn *ct,static int ctnetlink_change_timeout (struct nf_conn *ct,const struct nlattr *const cda[]) { -u64 timeout = (u64 )ntohl (nla_get_be32 (cda[CTA_TIMEOUT ])) *HZ ; - -__nf_ct_set_timeout (ct, timeout); - -if (test_bit (IPS_DYING_BIT , &ct->status)) -return -ETIME ; - -return 0 ; +return __nf_ct_change_timeout (ct, (u64 )ntohl (nla_get_be32 (cda[CTA_TIMEOUT ])) *HZ ); }#if defined(CONFIG_NF_CONNTRACK_MARK )
Signature · 1 line
2.34.1
Kumar Kartikeya Dwivedi
maintainerPATCH v6 9/13 net: netfilter: Add kfuncs to set and change CT status
In reply to Kumar Kartikeya DwivediFrom: Lorenzo Bianconi <[email protected]>
Introduce bpf_ct_set_status and bpf_ct_change_status kfunc helpers in order to set nf_conn field of allocated entry or update nf_conn status field of existing inserted entry. Use nf_ct_change_status_common to share the permitted status field changes between netlink and BPF side by refactoring ctnetlink_change_status.
It is required to introduce two kfuncs taking nf_conn___init and nf_conn instead of sharing one because KF_TRUSTED_ARGS flag causes strict type checking. This would disallow passing nf_conn___init to kfunc taking nf_conn, and vice versa. We cannot remove the KF_TRUSTED_ARGS flag as we only want to accept refcounted pointers and not e.g. ct->master.
Hence, bpf_ct_set_* kfuncs are meant to be used on allocated CT, and bpf_ct_change_* kfuncs are meant to be used on inserted or looked up CT entry.
--- include/net/netfilter/nf_conntrack_core.h | 2 ++ net/netfilter/nf_conntrack_bpf.c | 32 ++++++++++++++++++ net/netfilter/nf_conntrack_core.c | 40 +++++++++++++++++++++++ net/netfilter/nf_conntrack_netlink.c | 39 ++-------------------- 4 files changed, 76 insertions(+), 37 deletions(-)
include/net/netfilter/nf_conntrack_core.h +2 -0
@@ -98,6 +98,8 @@ static inline void __nf_ct_set_timeout(struct nf_conn *ct, u64 timeout) }int __nf_ct_change_timeout (struct nf_conn *ct,u64 cta_timeout); +void __nf_ct_change_status (struct nf_conn *ct,unsigned long on,unsigned long off); +int nf_ct_change_status_common (struct nf_conn *ct,unsigned int status);#endif
net/netfilter/nf_conntrack_bpf.c +32 -0
@@ -394,6 +394,36 @@ int bpf_ct_change_timeout(struct nf_conn *nfct, u32 timeout)return __nf_ct_change_timeout (nfct,msecs_to_jiffies (timeout)); } +/* bpf_ct_set_status - Set status field of allocated nf_conn +* +* Set the status field of the newly allocated nf_conn before insertion. +* This must be invoked for referenced PTR_TO_BTF_ID to nf_conn___init. +* +* Parameters: +* @nfct - Pointer to referenced nf_conn object, obtained using +* bpf_xdp_ct_alloc or bpf_skb_ct_alloc. +* @status - New status value. +*/ +int bpf_ct_set_status (const struct nf_conn___init *nfct,u32 status) +{ +return nf_ct_change_status_common ((struct nf_conn *)nfct, status); +} + +/* bpf_ct_change_status - Change status of inserted nf_conn +* +* Change the status field of the provided connection tracking entry. +* This must be invoked for referenced PTR_TO_BTF_ID to nf_conn. +* +* Parameters: +* @nfct - Pointer to referenced nf_conn object, obtained using +* bpf_ct_insert_entry, bpf_xdp_ct_lookup or bpf_skb_ct_lookup. +* @status - New status value. +*/ +int bpf_ct_change_status (struct nf_conn *nfct,u32 status) +{ +return nf_ct_change_status_common (nfct, status); +} + __diag_pop()BTF_SET8_START (nf_ct_kfunc_set)
@@ -405,6 +435,8 @@ BTF_ID_FLAGS(func, bpf_ct_insert_entry, KF_ACQUIRE, KF_RET_NULL, KF_RELEASE) BTF_ID_FLAGS(func, bpf_ct_release, KF_RELEASE) BTF_ID_FLAGS(func, bpf_ct_set_timeout, KF_TRUSTED_ARGS) BTF_ID_FLAGS(func, bpf_ct_change_timeout, KF_TRUSTED_ARGS) +BTF_ID_FLAGS(func, bpf_ct_set_status, KF_TRUSTED_ARGS) +BTF_ID_FLAGS(func, bpf_ct_change_status, KF_TRUSTED_ARGS)BTF_SET8_END (nf_ct_kfunc_set) static const struct btf_kfunc_id_set nf_conntrack_kfunc_set = {
net/netfilter/nf_conntrack_core.c +40 -0
@@ -2807,4 +2807,44 @@ int __nf_ct_change_timeout(struct nf_conn *ct, u64 timeout) }EXPORT_SYMBOL_GPL (__nf_ct_change_timeout); +void __nf_ct_change_status (struct nf_conn *ct,unsigned long on,unsigned long off) +{ +unsigned int bit; + +/* Ignore these unchangable bits */ + on &= ~IPS_UNCHANGEABLE_MASK ; + off &= ~IPS_UNCHANGEABLE_MASK ; + +for (bit =0 ; bit < __IPS_MAX_BIT; bit++) { +if (on & (1 << bit)) +set_bit (bit, &ct->status); +else if (off & (1 << bit)) +clear_bit (bit, &ct->status); + } +} +EXPORT_SYMBOL_GPL (__nf_ct_change_status); + +int nf_ct_change_status_common (struct nf_conn *ct,unsigned int status) +{ +unsigned long d; + + d = ct->status ^ status; + +if (d & (IPS_EXPECTED |IPS_CONFIRMED |IPS_DYING )) +/* unchangeable */ +return -EBUSY ; + +if (d &IPS_SEEN_REPLY && !(status &IPS_SEEN_REPLY )) +/* SEEN_REPLY bit can only be set */ +return -EBUSY ; + +if (d &IPS_ASSURED && !(status &IPS_ASSURED )) +/* ASSURED bit can only be set */ +return -EBUSY ; + +__nf_ct_change_status (ct, status,0 ); +return 0 ; +} +EXPORT_SYMBOL_GPL (nf_ct_change_status_common); +#endif
net/netfilter/nf_conntrack_netlink.c +2 -37
@@ -1890,45 +1890,10 @@ ctnetlink_parse_nat_setup(struct nf_conn *ct, }#endif -static void -__ctnetlink_change_status (struct nf_conn *ct,unsigned long on, -unsigned long off) -{ -unsigned int bit; - -/* Ignore these unchangable bits */ - on &= ~IPS_UNCHANGEABLE_MASK ; - off &= ~IPS_UNCHANGEABLE_MASK ; - -for (bit =0 ; bit < __IPS_MAX_BIT; bit++) { -if (on & (1 << bit)) -set_bit (bit, &ct->status); -else if (off & (1 << bit)) -clear_bit (bit, &ct->status); - } -} -static int ctnetlink_change_status (struct nf_conn *ct,const struct nlattr *const cda[]) { -unsigned long d; -unsigned int status =ntohl (nla_get_be32 (cda[CTA_STATUS ])); - d = ct->status ^ status; - -if (d & (IPS_EXPECTED |IPS_CONFIRMED |IPS_DYING )) -/* unchangeable */ -return -EBUSY ; - -if (d &IPS_SEEN_REPLY && !(status &IPS_SEEN_REPLY )) -/* SEEN_REPLY bit can only be set */ -return -EBUSY ; - -if (d &IPS_ASSURED && !(status &IPS_ASSURED )) -/* ASSURED bit can only be set */ -return -EBUSY ; - -__ctnetlink_change_status (ct, status,0 ); -return 0 ; +return nf_ct_change_status_common (ct,ntohl (nla_get_be32 (cda[CTA_STATUS ]))); } static int
@@ -2825,7 +2790,7 @@ ctnetlink_update_status(struct nf_conn *ct, const struct nlattr * const cda[])* unchangeable bits but do not error out. Also user programs * are allowed to clear the bits that they are allowed to change. */ -__ctnetlink_change_status (ct, status, ~status); +__nf_ct_change_status (ct, status, ~status);return 0 ; }
Signature · 1 line
2.34.1
Kumar Kartikeya Dwivedi
maintainerPATCH v6 10/13 selftests/bpf: Add verifier tests for trusted kfunc args
In reply to Kumar Kartikeya DwivediMake sure verifier rejects the bad cases and ensure the good case keeps working. The selftests make use of the bpf_kfunc_call_test_ref kfunc added in the previous patch only for verification.
--- tools/testing/selftests/bpf/verifier/calls.c | 53 ++++++++++++++++++++ 1 file changed, 53 insertions(+)
tools/testing/selftests/bpf/verifier/calls.c +53 -0
@@ -218,6 +218,59 @@ .result = REJECT, .errstr = "variable ptr_ access var_off=(0x0; 0x7) disallowed", }, +{ + "calls: invalid kfunc call: referenced arg needs refcounted PTR_TO_BTF_ID", + .insns = { +BPF_MOV64_REG (BPF_REG_1 ,BPF_REG_10 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_1 ,-8 ), +BPF_ST_MEM (BPF_DW ,BPF_REG_1 ,0 ,0 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,BPF_PSEUDO_KFUNC_CALL ,0 ,0 ), +BPF_JMP_IMM (BPF_JNE ,BPF_REG_0 ,0 ,1 ), +BPF_EXIT_INSN (), +BPF_MOV64_REG (BPF_REG_6 ,BPF_REG_0 ), +BPF_MOV64_REG (BPF_REG_1 ,BPF_REG_0 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,BPF_PSEUDO_KFUNC_CALL ,0 ,0 ), +BPF_LDX_MEM (BPF_DW ,BPF_REG_1 ,BPF_REG_6 ,16 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,BPF_PSEUDO_KFUNC_CALL ,0 ,0 ), +BPF_MOV64_IMM (BPF_REG_0 ,0 ), + BPF_EXIT_INSN(), + }, + .prog_type =BPF_PROG_TYPE_SCHED_CLS , + .fixup_kfunc_btf_id = { + { "bpf_kfunc_call_test_acquire", 3 }, + { "bpf_kfunc_call_test_ref", 8 }, + { "bpf_kfunc_call_test_ref", 10 }, + }, + .result_unpriv = REJECT, + .result = REJECT, + .errstr = "R1 must be referenced", +}, +{ +"calls: valid kfunc call: referenced arg needs refcounted PTR_TO_BTF_ID" , + .insns = { +BPF_MOV64_REG (BPF_REG_1 ,BPF_REG_10 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_1 ,-8 ), +BPF_ST_MEM (BPF_DW ,BPF_REG_1 ,0 ,0 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,BPF_PSEUDO_KFUNC_CALL ,0 ,0 ), +BPF_JMP_IMM (BPF_JNE ,BPF_REG_0 ,0 ,1 ), +BPF_EXIT_INSN (), +BPF_MOV64_REG (BPF_REG_6 ,BPF_REG_0 ), +BPF_MOV64_REG (BPF_REG_1 ,BPF_REG_0 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,BPF_PSEUDO_KFUNC_CALL ,0 ,0 ), +BPF_MOV64_REG (BPF_REG_1 ,BPF_REG_6 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,BPF_PSEUDO_KFUNC_CALL ,0 ,0 ), +BPF_MOV64_IMM (BPF_REG_0 ,0 ), + BPF_EXIT_INSN(), + }, + .prog_type =BPF_PROG_TYPE_SCHED_CLS , + .fixup_kfunc_btf_id = { + { "bpf_kfunc_call_test_acquire", 3 }, + { "bpf_kfunc_call_test_ref", 8 }, + { "bpf_kfunc_call_test_release", 10 }, + }, + .result_unpriv = REJECT, + .result = ACCEPT, +}, {"calls: basic sanity" , .insns = {
Signature · 1 line
2.34.1
Kumar Kartikeya Dwivedi
maintainerPATCH v6 11/13 selftests/bpf: Add tests for new nf_conntrack kfuncs
In reply to Kumar Kartikeya DwivediFrom: Lorenzo Bianconi <[email protected]>
Introduce selftests for the following kfunc helpers:
- bpf_xdp_ct_alloc
- bpf_skb_ct_alloc
- bpf_ct_insert_entry
- bpf_ct_set_timeout
- bpf_ct_change_timeout
- bpf_ct_set_status
- bpf_ct_change_status
--- .../testing/selftests/bpf/prog_tests/bpf_nf.c | 8 ++ .../testing/selftests/bpf/progs/test_bpf_nf.c | 85 ++++++++++++++++--- 2 files changed, 81 insertions(+), 12 deletions(-)
tools/testing/selftests/bpf/prog_tests/bpf_nf.c +8 -0
@@ -39,6 +39,14 @@ void test_bpf_nf_ct(int mode)ASSERT_EQ (skel->bss->test_enonet_netns_id, -ENONET ,"Test ENONET for bad but valid netns_id" );ASSERT_EQ (skel->bss->test_enoent_lookup, -ENOENT ,"Test ENOENT for failed lookup" );ASSERT_EQ (skel->bss->test_eafnosupport, -EAFNOSUPPORT ,"Test EAFNOSUPPORT for invalid len__tuple" ); +ASSERT_EQ (skel->data->test_alloc_entry,0 ,"Test for alloc new entry" ); +ASSERT_EQ (skel->data->test_insert_entry,0 ,"Test for insert new entry" ); +ASSERT_EQ (skel->data->test_succ_lookup,0 ,"Test for successful lookup" ); +/* allow some tolerance for test_delta_timeout value to avoid races. */ +ASSERT_GT (skel->bss->test_delta_timeout,8 ,"Test for min ct timeout update" ); +ASSERT_LE (skel->bss->test_delta_timeout,10 ,"Test for max ct timeout update" ); +/* expected status is IPS_SEEN_REPLY */ +ASSERT_EQ (skel->bss->test_status,2 ,"Test for ct status update " ); end:test_bpf_nf__destroy (skel); }
tools/testing/selftests/bpf/progs/test_bpf_nf.c +73 -12
174 lines not on this page · raw message
Signature · 1 line
2.34.1
Kumar Kartikeya Dwivedi
maintainerPATCH v6 12/13 selftests/bpf: Add negative tests for new nf_conntrack kfuncs
In reply to Kumar Kartikeya DwivediTest cases we care about and ensure improper usage is caught and rejected by the verifier.
--- .../testing/selftests/bpf/prog_tests/bpf_nf.c | 56 +++++++- .../selftests/bpf/progs/test_bpf_nf_fail.c | 134 ++++++++++++++++++ 2 files changed, 189 insertions(+), 1 deletion(-) create mode 100644 tools/testing/selftests/bpf/progs/test_bpf_nf_fail.c
tools/testing/selftests/bpf/prog_tests/bpf_nf.c +55 -1
@@ -2,13 +2,29 @@#include <test_progs.h> #include <network_helpers.h> #include "test_bpf_nf.skel.h" +#include "test_bpf_nf_fail.skel.h" + +static char log_buf[1024 *1024 ]; + +struct { +const char *prog_name; +const char *err_msg; +} test_bpf_nf_fail_tests[] = { + {"alloc_release" ,"kernel function bpf_ct_release args#0 expected pointer to STRUCT nf_conn but" }, + {"insert_insert" ,"kernel function bpf_ct_insert_entry args#0 expected pointer to STRUCT nf_conn___init but" }, + {"lookup_insert" ,"kernel function bpf_ct_insert_entry args#0 expected pointer to STRUCT nf_conn___init but" }, + {"set_timeout_after_insert" ,"kernel function bpf_ct_set_timeout args#0 expected pointer to STRUCT nf_conn___init but" }, + {"set_status_after_insert" ,"kernel function bpf_ct_set_status args#0 expected pointer to STRUCT nf_conn___init but" }, + {"change_timeout_after_alloc" ,"kernel function bpf_ct_change_timeout args#0 expected pointer to STRUCT nf_conn but" }, + {"change_status_after_alloc" ,"kernel function bpf_ct_change_status args#0 expected pointer to STRUCT nf_conn but" }, +};enum {TEST_XDP ,TEST_TC_BPF , }; -void test_bpf_nf_ct (int mode) +static void test_bpf_nf_ct (int mode) {struct test_bpf_nf *skel;int prog_fd, err;
@@ -51,10 +67,48 @@ void test_bpf_nf_ct(int mode)test_bpf_nf__destroy (skel); } +static void test_bpf_nf_ct_fail (const char *prog_name,const char *err_msg) +{ + LIBBPF_OPTS(bpf_object_open_opts, opts, .kernel_log_buf = log_buf, + .kernel_log_size = sizeof(log_buf), + .kernel_log_level = 1); +struct test_bpf_nf_fail *skel; +struct bpf_program *prog; +int ret; + + skel =test_bpf_nf_fail__open_opts (&opts); +if (!ASSERT_OK_PTR (skel,"test_bpf_nf_fail__open" )) +return ; + + prog =bpf_object__find_program_by_name (skel->obj, prog_name); +if (!ASSERT_OK_PTR (prog,"bpf_object__find_program_by_name" )) + goto end; + +bpf_program__set_autoload (prog, true); + + ret =test_bpf_nf_fail__load (skel); +if (!ASSERT_ERR (ret,"test_bpf_nf_fail__load must fail" )) + goto end; + +if (!ASSERT_OK_PTR (strstr (log_buf, err_msg),"expected error message" )) { +fprintf (stderr,"Expected: %s\n" , err_msg); +fprintf (stderr,"Verifier: %s\n" , log_buf); + } + +end: +test_bpf_nf_fail__destroy (skel); +} +void test_bpf_nf (void ) { +int i;if (test__start_subtest ("xdp-ct" ))test_bpf_nf_ct (TEST_XDP );if (test__start_subtest ("tc-bpf-ct" ))test_bpf_nf_ct (TEST_TC_BPF ); +for (i =0 ; i <ARRAY_SIZE (test_bpf_nf_fail_tests); i++) { +if (test__start_subtest (test_bpf_nf_fail_tests[i].prog_name)) +test_bpf_nf_ct_fail (test_bpf_nf_fail_tests[i].prog_name, + test_bpf_nf_fail_tests[i].err_msg); + } }
tools/testing/selftests/bpf/progs/test_bpf_nf_fail.c new file +134 -0
134 lines not on this page · raw message
Signature · 1 line
2.34.1
Kumar Kartikeya Dwivedi
maintainerPATCH v6 13/13 selftests/bpf: Fix test_verifier failed test in unprivileged mode
In reply to Kumar Kartikeya DwivediLoading the BTF won't be permitted without privileges, hence only test for privileged mode by setting the prog type. This makes the test_verifier show 0 failures when unprivileged BPF is enabled.
--- tools/testing/selftests/bpf/verifier/bpf_loop_inline.c | 1 + 1 file changed, 1 insertion(+)
tools/testing/selftests/bpf/verifier/bpf_loop_inline.c +1 -0
@@ -251,6 +251,7 @@ .expected_insns = { PSEUDO_CALL_INSN() }, .unexpected_insns = { HELPER_CALL_INSN() }, .result = ACCEPT, + .prog_type = BPF_PROG_TYPE_TRACEPOINT, .func_info = { { 0, MAIN_TYPE }, { 16, CALLBACK_TYPE } }, .func_info_cnt = 2,BTF_TYPES
Signature · 1 line
2.34.1