New nf_conntrack kfuncs for insertion, changing timeout, status
Subsystems (10)
Kumar Kartikeya Dwivedi
maintainerv7 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:
----------
v6 -> v7:
v6: https://lore.kernel.org/bpf/[email protected]
* Use .long to encode flags (Alexei)
* Fix description of KF_RET_NULL in documentation (Toke)
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 8-byte BTF set
tools/resolve_btfids: Add support for 8-byte BTF sets
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 | 170 ++++++++ include/linux/bpf.h | 3 +- include/linux/btf.h | 65 ++-- include/linux/btf_ids.h | 68 +++- include/net/netfilter/nf_conntrack_core.h | 19 + kernel/bpf/btf.c | 123 +++--- 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 | 40 +- .../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, 1139 insertions(+), 349 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 v7 1/13 bpf: Introduce 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 resolve_btfids change is split into a separate patch.
--- include/linux/btf_ids.h | 68 ++++++++++++++++++++++++++++++++++++++--- 1 file changed, 64 insertions(+), 4 deletions(-)
include/linux/btf_ids.h +64 -4
@@ -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 */
@@ -25,7 +34,7 @@ struct btf_id_set {#define BTF_IDS_SECTION ".BTF_ids" -#define ____BTF_ID (symbol) \ +#define ____BTF_ID (symbol, word) \ asm( \ ".pushsection " BTF_IDS_SECTION ",\"a\"; \n" \ ".local " #symbol " ; \n" \
@@ -33,10 +42,11 @@ asm( \ ".size " #symbol ", 4; \n" \ #symbol ": \n" \ ".zero 4 \n" \ +word \ ".popsection; \n"); -#define __BTF_ID (symbol) \ - ____BTF_ID(symbol) +#define __BTF_ID (symbol, word) \ + ____BTF_ID(symbol, word)#define __ID (prefix) \ __PASTE(prefix, __COUNTER__)
@@ -46,7 +56,14 @@ asm( \* to 4 zero bytes. */ #define BTF_ID (prefix, name) \ - __BTF_ID(__ID(__BTF_ID__##prefix##__##name##__)) + __BTF_ID(__ID(__BTF_ID__##prefix##__##name##__), "") + +#define ____BTF_ID_FLAGS (prefix, name, flags) \ + __BTF_ID(__ID(__BTF_ID__##prefix##__##name##__), ".long " #flags "\n") +#define __BTF_ID_FLAGS (prefix, name, flags, ...) \ + ____BTF_ID_FLAGS(prefix, name, flags) +#define BTF_ID_FLAGS (prefix, name, ...) \ + __BTF_ID_FLAGS(prefix, name, ##__VA_ARGS__, 0)/* * The BTF_ID_LIST macro defines pure (unsorted) list
@@ -145,10 +162,51 @@ 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 +* .word (1 << 0) | (1 << 2) +* __BTF_ID__type2__name2__5: +* .zero 4 +* .word (1 << 3) | (1 << 1) | (1 << 2) +* +*/ +#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, flags)#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 +214,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
Kumar Kartikeya Dwivedi
maintainerPATCH v7 2/13 tools/resolve_btfids: Add support for 8-byte BTF sets
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 adjust the sorting code so that it passes size as 8 bytes for 8-byte BTF sets.
--- tools/bpf/resolve_btfids/main.c | 40 ++++++++++++++++++++++++++++----- 1 file changed, 34 insertions(+), 6 deletions(-)
tools/bpf/resolve_btfids/main.c +34 -6
@@ -45,6 +45,19 @@* .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 +* .word (1 << 0) | (1 << 2) +* __BTF_ID__func__vfs_fallocate__5: +* .zero 4 +* .word (1 << 3) | (1 << 1) | (1 << 2) */ #define _GNU_SOURCE
@@ -72,6 +85,7 @@#define BTF_TYPEDEF "typedef"#define BTF_FUNC "func"#define BTF_SET "set" +#define BTF_SET8 "set8"#define ADDR_CNT 100
@@ -84,6 +98,7 @@ struct btf_id { };int addr_cnt;bool is_set; +bool is_set8;Elf64_Addr addr[ADDR_CNT ]; };
@@ -231,14 +246,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) {
@@ -444,9 +459,21 @@ 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 ); +/* 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
@@ -571,7 +598,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, id->id may be 0 */ +if (!id->id && !id->is_set && !id->is_set8)pr_err ("WARN: resolve_btfids: unresolved symbol %s\n" , id->name);for (i =0 ; i < id->addr_cnt; i++) {
@@ -643,13 +671,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); }
Signature · 1 line
2.34.1
Re: [PATCH bpf-next v7 02/13] tools/resolve_btfids: Add support for 8-byte BTF sets
Quoted 7 lines · Kumar Kartikeya Dwivedi
A 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 adjust the sorting code so that it passes size as 8 bytes for 8-byte BTF sets.
Cc Jiri Olsa <[email protected]>Signed-off-by Kumar Kartikeya Dwivedi <[email protected]>
jirka
Quoted 113 lines
--- tools/bpf/resolve_btfids/main.c | 40 ++++++++++++++++++++++++++++----- 1 file changed, 34 insertions(+), 6 deletions(-)tools/bpf/resolve_btfids/main.c +34
-6@@ -45,6 +45,19 @@* .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 +* .word (1 << 0) | (1 << 2) +* __BTF_ID__func__vfs_fallocate__5: +* .zero 4 +* .word (1 << 3) | (1 << 1) | (1 << 2) */ #define _GNU_SOURCE@@ -72,6 +85,7 @@#define BTF_TYPEDEF "typedef"#define BTF_FUNC "func"#define BTF_SET "set" +#define BTF_SET8 "set8"#define ADDR_CNT 100@@ -84,6 +98,7 @@ struct btf_id { };int addr_cnt;bool is_set; +bool is_set8;Elf64_Addr addr[ADDR_CNT ]; };@@ -231,14 +246,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) {@@ -444,9 +459,21 @@ 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 ); +/* 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 @@ -571,7 +598,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, id->id may be 0 */ +if (!id->id && !id->is_set && !id->is_set8)pr_err ("WARN: resolve_btfids: unresolved symbol %s\n" , id->name);for (i =0 ; i < id->addr_cnt; i++) {@@ -643,13 +671,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); }Signature · 1 line
2.34.1
Kumar Kartikeya Dwivedi
maintainerPATCH v7 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 | 33 ++---- kernel/bpf/btf.c | 106 ++++++++---------- 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 +10 -23
@@ -12,14 +12,11 @@#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 need to be macros, as the expressions are used in assembler input */ +#define KF_ACQUIRE (1 << 0)/* kfunc is an acquire function */ +#define KF_RELEASE (1 << 1)/* kfunc is a release function */ +#define KF_RET_NULL (1 << 2)/* kfunc returns a pointer that may be NULL */ +#define KF_KPTR_GET (1 << 3)/* kfunc returns reference to a kptr */ struct btf ;struct btf_member ;
@@ -30,16 +27,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 +366,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 +385,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 +48 -58
230 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 v7 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
@@ -17,6 +17,38 @@#define KF_RELEASE (1 << 1)/* kfunc is a release function */ #define KF_RET_NULL (1 << 2)/* kfunc returns a pointer that may be NULL */ #define KF_KPTR_GET (1 << 3)/* 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 (1 << 4)/* 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
Re: [PATCH bpf-next v7 04/13] bpf: Add support for forcing kfunc args to be trusted
Quoted 17 lines · Kumar Kartikeya Dwivedi
+/* 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
Quoted 8 lines
+ *
+ * If a kfuncset_foo_data()wants to operate only on the allocated object, it
+ * will set theKF_TRUSTED_ARGSflag, 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
I think you meant to swap above two comments ?
That's what I did while applying.
Also fixed typo in Fixes tag in patch 13. It was missing a letter in sha.
Since there are 3 other pending patchsets in patchwork that add new kfuncs this cleanup of kfunc registration couldn't have come at better time.
Thank you for doing this work.
Kumar Kartikeya Dwivedi
maintainerRe: [PATCH bpf-next v7 04/13] bpf: Add support for forcing kfunc args to be trusted
Quoted 31 lines · Alexei Starovoitov
Quoted 21 lines · Kumar Kartikeya Dwivedi
+/* 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 kfuncset_foo_data()wants to operate only on the allocated object, it
+ * will set theKF_TRUSTED_ARGSflag, which will prevent unsafe usage like:
+ *Quoted 4 lines
+ * 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 typeI think you meant to swap above two comments ?
That's what I did while applying.
Quoted 6 lines
Also fixed typo in Fixes tag in patch 13. It was missing a letter in sha.
Since there are 3 other pending patchsets in patchwork that add new kfuncs this cleanup of kfunc registration couldn't have come at better time.
Thank you for doing this work.
Thank you for doing the fixups!
RE: [PATCH bpf-next v7 04/13] bpf: Add support for forcing kfunc args to be trusted
In reply to Kumar Kartikeya DwivediQuoted 58 lines
From: Kumar Kartikeya Dwivedi [mailto:[email protected]]
Sent: Thursday, July 21, 2022 3:43 PM
Teach the verifier to detect a newKF_TRUSTED_ARGSkfunc flag, which means each pointer argument must be trusted, which we define as a pointer that is referenced (has non-zeroref_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_IDwith 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) andOBJ_RELEASEoffset checks (ensuring they are zero) are used for trusted pointer arguments.Signed-off-by Kumar Kartikeya Dwivedi <[email protected]>--- 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 +1
-0@@ -17,6 +17,38 @@#define KF_RELEASE (1 << 1)/* kfunc is a release function */ #define KF_RET_NULL (1 << 2)/* kfunc returns a pointer that may be NULL */ #define KF_KPTR_GET (1 << 3)/* 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 kfuncset_foo_data()wants to operate only on the allocated object, it
+ * will set theKF_TRUSTED_ARGSflag, 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
Quoted 8 lines
+ *
+ * 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.
+ */
+#defineKF_TRUSTED_ARGS(1 << 4) /* kfunc only takes trusted pointer arguments */
Hi Kumar
would it make sense to introduce per-parameter flags? I have a function that has several parameters, but only one is referenced.
Thanks
Roberto
Kumar Kartikeya Dwivedi
maintainerRe: [PATCH bpf-next v7 04/13] bpf: Add support for forcing kfunc args to be trusted
Quoted 70 lines · Roberto Sassu
Quoted 59 lines
From: Kumar Kartikeya Dwivedi [mailto:[email protected]]
Sent: Thursday, July 21, 2022 3:43 PM
Teach the verifier to detect a newKF_TRUSTED_ARGSkfunc flag, which means each pointer argument must be trusted, which we define as a pointer that is referenced (has non-zeroref_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_IDwith 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) andOBJ_RELEASEoffset checks (ensuring they are zero) are used for trusted pointer arguments.Signed-off-by Kumar Kartikeya Dwivedi <[email protected]>--- 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 +1
-0@@ -17,6 +17,38 @@#define KF_RELEASE (1 << 1)/* kfunc is a release function */ #define KF_RET_NULL (1 << 2)/* kfunc returns a pointer that may be NULL */ #define KF_KPTR_GET (1 << 3)/* 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 kfuncset_foo_data()wants to operate only on the allocated object, it
+ * will set theKF_TRUSTED_ARGSflag, 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 typeQuoted 8 lines
+ *
+ * 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.
+ */
+#defineKF_TRUSTED_ARGS(1 << 4) /* kfunc only takes trusted pointer arguments */Hi Kumar
Quoted 3 lines
would it make sense to introduce per-parameter flags? I have a function that has several parameters, but only one is referenced.
I have a patch for that in my local branch, I can fix it up and post it. But first, can you give an example of where you think you need it?
Quoted 3 lines
Thanks
Roberto
RE: [PATCH bpf-next v7 04/13] bpf: Add support for forcing kfunc args to be trusted
Quoted 78 lines
From: Kumar Kartikeya Dwivedi [mailto:[email protected]]
Sent: Tuesday, July 26, 2022 11:30 AMQuoted 25 lines · Roberto Sassu
Quoted 25 lines
From: Kumar Kartikeya Dwivedi [mailto:[email protected]]
Sent: Thursday, July 21, 2022 3:43 PM
Teach the verifier to detect a newKF_TRUSTED_ARGSkfunc flag, which means each pointer argument must be trusted, which we define as a pointer that is referenced (has non-zeroref_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_IDwith 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) andOBJ_RELEASEoffset checks (ensuring they are zero) are used for trusted pointer arguments.Signed-off-by Kumar Kartikeya Dwivedi <[email protected]>--- include/linux/btf.h | 32 ++++++++++++++++++++++++++++++++ kernel/bpf/btf.c | 17 ++++++++++++++--- net/bpf/test_run.c | 5 +++++ 3 files changed, 51 insertions(+), 3 deletions(-)Quoted 7 lines
include/linux/btf.h line 18
Quoted 7 lines
include/linux/btf.h +0
-0@@ -17,6 +17,38 @@#define KF_RELEASE (1 << 1)/* kfunc is a release function */ #define KF_RET_NULL (1 << 2)/* kfunc returns a pointer that may be NULL */
Quoted 2 lines
include/linux/btf.h line 20
Quoted 2 lines
include/linux/btf.h +1
-0#define KF_KPTR_GET (1 << 3)/* kfunc returns reference to a kptr */ +/* Trusted arguments are those which are meant to be referenced arguments
Quoted 2 lines
Quoted 2 lines
with
+ * unchanged offset. It is used to enforce that pointers obtained fromacquire
Quoted 1 line
Quoted 1 line
+ * kfuncs remain unmodified when being passed to helpers taking trusted
args.
Quoted 8 lines
Quoted 8 lines
+ *
+ * Consider
+ * struct foo {
+ * int data;
+ * struct foo *next;
+ * };
+ *
+ * struct bar {Quoted 8 lines
Quoted 8 lines
+ * int data;
+ * struct foo f;
+ * };
+ *
+ * struct foo *f =alloc_foo(); // Acquire kfunc
+ * struct bar *b =alloc_bar(); // Acquire kfunc
+ *
+ * If a kfuncset_foo_data()wants to operate only on the allocated object,it
Quoted 10 lines
Quoted 10 lines
+ * will set the
KF_TRUSTED_ARGSflag, 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 notdone
Quoted 5 lines
Quoted 4 lines
+ * for this case.
+ */
+#defineKF_TRUSTED_ARGS(1 << 4) /* kfunc only takes trusted pointer arguments */
Quoted 8 lines
Quoted 5 lines
Hi Kumar
would it make sense to introduce per-parameter flags? I have a function that has several parameters, but only one is referenced.
I have a patch for that in my local branch, I can fix it up and post it. But first, can you give an example of where you think you need it?
I have pushed the complete patch set here, for testing:
https://github.com/robertosassu/vmtest/tree/bpf-verify-sig-v9/travis-ci/diffs
I rebased to bpf-next/master, and introduced KF_SLEEPABLE (similar functionality of " btf: Add a new kfunc set which allows to mark a function to be sleepable" from Benjamin Tissoires).
The patch where I would use per-parameter KF_TRUSTED_ARGS is number 8. I also used your new API in patch 7 and it works well.
I didn't repost, as I'm waiting for comments on v8.
Thanks
Roberto
Kumar Kartikeya Dwivedi
maintainerRe: [PATCH bpf-next v7 04/13] bpf: Add support for forcing kfunc args to be trusted
Quoted 90 lines · Roberto Sassu
Quoted 79 lines
From: Kumar Kartikeya Dwivedi [mailto:[email protected]]
Sent: Tuesday, July 26, 2022 11:30 AMQuoted 25 lines · Roberto Sassu
Quoted 25 lines
From: Kumar Kartikeya Dwivedi [mailto:[email protected]]
Sent: Thursday, July 21, 2022 3:43 PM
Teach the verifier to detect a newKF_TRUSTED_ARGSkfunc flag, which means each pointer argument must be trusted, which we define as a pointer that is referenced (has non-zeroref_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_IDwith 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) andOBJ_RELEASEoffset checks (ensuring they are zero) are used for trusted pointer arguments.Signed-off-by Kumar Kartikeya Dwivedi <[email protected]>--- include/linux/btf.h | 32 ++++++++++++++++++++++++++++++++ kernel/bpf/btf.c | 17 ++++++++++++++--- net/bpf/test_run.c | 5 +++++ 3 files changed, 51 insertions(+), 3 deletions(-)Quoted 7 lines
include/linux/btf.h line 18
Quoted 7 lines
include/linux/btf.h +0
-0@@ -17,6 +17,38 @@#define KF_RELEASE (1 << 1)/* kfunc is a release function */ #define KF_RET_NULL (1 << 2)/* kfunc returns a pointer that may be NULL */
Quoted 2 lines
include/linux/btf.h line 20
Quoted 2 lines
include/linux/btf.h +1
-0#define KF_KPTR_GET (1 << 3)/* kfunc returns reference to a kptr */ +/* Trusted arguments are those which are meant to be referenced arguments
Quoted 2 lines
Quoted 2 lines
with
+ * unchanged offset. It is used to enforce that pointers obtained fromacquire
Quoted 1 line
Quoted 1 line
+ * kfuncs remain unmodified when being passed to helpers taking trusted
args.
Quoted 8 lines
Quoted 8 lines
+ *
+ * Consider
+ * struct foo {
+ * int data;
+ * struct foo *next;
+ * };
+ *
+ * struct bar {Quoted 8 lines
Quoted 8 lines
+ * int data;
+ * struct foo f;
+ * };
+ *
+ * struct foo *f =alloc_foo(); // Acquire kfunc
+ * struct bar *b =alloc_bar(); // Acquire kfunc
+ *
+ * If a kfuncset_foo_data()wants to operate only on the allocated object,it
Quoted 10 lines
Quoted 10 lines
+ * will set the
KF_TRUSTED_ARGSflag, 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 notdone
Quoted 5 lines
Quoted 4 lines
+ * for this case.
+ */
+#defineKF_TRUSTED_ARGS(1 << 4) /* kfunc only takes trusted pointer arguments */Quoted 8 lines
Quoted 5 lines
Hi Kumar
would it make sense to introduce per-parameter flags? I have a function that has several parameters, but only one is referenced.
I have a patch for that in my local branch, I can fix it up and post it. But first, can you give an example of where you think you need it?
I have pushed the complete patch set here, for testing:
Quoted 9 lines
https://github.com/robertosassu/vmtest/tree/bpf-verify-sig-v9/travis-ci/diffs
I rebased to bpf-next/master, and introduced
KF_SLEEPABLE(similar functionality of " btf: Add a new kfunc set which allows to mark a function to be sleepable" from Benjamin Tissoires).The patch where I would use per-parameter
KF_TRUSTED_ARGSis number 8. I also used your new API in patch 7 and it works well.
Ok, looks like you'll need it for the struct key * argument as there are multiple pointers in the argument list and not all of them need to be trusted. I will clean up and post the patch with a test later today to the list.
Quoted 5 lines
I didn't repost, as I'm waiting for comments on v8.
Thanks
Roberto
RE: [PATCH bpf-next v7 04/13] bpf: Add support for forcing kfunc args to be trusted
Quoted 106 lines
From: Kumar Kartikeya Dwivedi [mailto:[email protected]]
Sent: Tuesday, July 26, 2022 2:56 PMQuoted 15 lines · Roberto Sassu
Quoted 15 lines
From: Kumar Kartikeya Dwivedi [mailto:[email protected]]
Sent: Tuesday, July 26, 2022 11:30 AMQuoted 10 lines · Roberto Sassu
Quoted 10 lines
From: Kumar Kartikeya Dwivedi [mailto:[email protected]]
Sent: Thursday, July 21, 2022 3:43 PM
Teach the verifier to detect a newKF_TRUSTED_ARGSkfunc flag, which means each pointer argument must be trusted, which we define as a pointer that is referenced (has non-zeroref_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.Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
This is required to ensure that kfunc that operate on some object only work on acquired pointers and not normal
PTR_TO_BTF_IDwith sametype
Quoted 13 lines
Quoted 13 lines
Quoted 13 lines
Quoted 13 lines
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_RELEASEoffset checks (ensuring they are zero) are used for trusted pointer arguments.Signed-off-by Kumar Kartikeya Dwivedi <[email protected]>--- include/linux/btf.h | 32 ++++++++++++++++++++++++++++++++ kernel/bpf/btf.c | 17 ++++++++++++++--- net/bpf/test_run.c | 5 +++++ 3 files changed, 51 insertions(+), 3 deletions(-)Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
include/linux/btf.h line 18
Quoted 7 lines
include/linux/btf.h +0
-0@@ -17,6 +17,38 @@#define KF_RELEASE (1 << 1)/* kfunc is a release function */ #define KF_RET_NULL (1 << 2)/* kfunc returns a pointer that may be NULL
Quoted 8 lines
Quoted 8 lines
*/
Quoted 2 lines
include/linux/btf.h line 20
Quoted 2 lines
include/linux/btf.h +1
-0#define KF_KPTR_GET (1 << 3)/* kfunc returns reference to a kptr */ +/* Trusted arguments are those which are meant to be referenced arguments
Quoted 2 lines
Quoted 2 lines
with
+ * unchanged offset. It is used to enforce that pointers obtained fromacquire
Quoted 1 line
Quoted 1 line
+ * kfuncs remain unmodified when being passed to helpers taking
trusted
Quoted 17 lines
Quoted 17 lines
args.
Quoted 16 lines
Quoted 16 lines
+ *
+ * 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 kfuncset_foo_data()wants to operate only on the allocatedobject,
Quoted 2 lines
Quoted 2 lines
it
Quoted 1 line
Quoted 1 line
+ * will set the
KF_TRUSTED_ARGSflag, which will prevent unsafe usagelike:
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
+ *
+ * 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 isdeduced
Quoted 25 lines
Quoted 8 lines
Quoted 2 lines
Quoted 2 lines
+ * 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 notdone
Quoted 5 lines
Quoted 4 lines
+ * for this case.
+ */
+#defineKF_TRUSTED_ARGS(1 << 4) /* kfunc only takes trusted pointer arguments */Quoted 8 lines
Quoted 5 lines
Hi Kumar
would it make sense to introduce per-parameter flags? I have a function that has several parameters, but only one is referenced.
I have a patch for that in my local branch, I can fix it up and post it. But first, can you give an example of where you think you need it?
I have pushed the complete patch set here, for testing:
https://github.com/robertosassu/vmtest/tree/bpf-verify-sig-v9/travis-ci/diffs
I rebased to bpf-next/master, and introduced
KF_SLEEPABLE(similar functionality of " btf: Add a new kfunc set which allows to mark a function to be sleepable" from Benjamin Tissoires).
Quoted 8 lines
Quoted 3 lines
The patch where I would use per-parameter
KF_TRUSTED_ARGSis number 8. I also used your new API in patch 7 and it works well.Ok, looks like you'll need it for the struct key * argument as there are multiple pointers in the argument list and not all of them need to be trusted. I will clean up and post the patch with a test later today to the list.
Yes, thanks a lot!
Roberto
Kumar Kartikeya Dwivedi
maintainerPATCH v7 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 | 170 +++++++++++++++++++++++++++++++++++ 2 files changed, 171 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 +170 -0
170 lines not on this page · raw message
Signature · 1 line
2.34.1
Kumar Kartikeya Dwivedi
maintainerPATCH v7 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 v7 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
Pablo Neira Ayuso
maintainerRe: [PATCH bpf-next v7 07/13] net: netfilter: Add kfuncs to allocate and insert CT
Hi,
include/net/netfilter/nf_conntrack_core.h void nf_conntrack_lock(spinlock_t *lock); · line 91
Quoted 13 lines · Kumar Kartikeya Dwivedi
include/net/netfilter/nf_conntrack_core.h +5
-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 ))
There must be a better way to do this without ifdef pollution?
Could you fix this?
Kumar Kartikeya Dwivedi
maintainerRe: [PATCH bpf-next v7 07/13] net: netfilter: Add kfuncs to allocate and insert CT
Quoted 20 lines · Pablo Neira Ayuso
Hi,
include/net/netfilter/nf_conntrack_core.h void nf_conntrack_lock(spinlock_t *lock); · line 91
Quoted 13 lines · Kumar Kartikeya Dwivedi
include/net/netfilter/nf_conntrack_core.h +5
-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 ))There must be a better way to do this without ifdef pollution?
Quoted 1 line
Could you fix this?
I can just remove the ifdefs completely. The first part of the ifdef is the correct way to detect BPF support for nf_conntrack, the second is for ct netlink. These are the only two users. But it's not a lot of code, so until it grows too much we can compile it unconditionally.
Or do you have anything else in mind (like defining a macro for the bpf one and making the ifdef look less ugly)?
Pablo Neira Ayuso
maintainerRe: [PATCH bpf-next v7 07/13] net: netfilter: Add kfuncs to allocate and insert CT
Quoted 21 lines · Kumar Kartikeya Dwivedi
Quoted 20 lines · Pablo Neira Ayuso
Hi,
include/net/netfilter/nf_conntrack_core.h void nf_conntrack_lock(spinlock_t *lock); · line 91
Quoted 13 lines · Kumar Kartikeya Dwivedi
include/net/netfilter/nf_conntrack_core.h +5
-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 ))There must be a better way to do this without ifdef pollution?
Quoted 6 lines
Quoted 1 line
Could you fix this?
I can just remove the ifdefs completely. The first part of the ifdef is the correct way to detect BPF support for
nf_conntrack, the second is for ct netlink. These are the only two users. But it's not a lot of code, so until it grows too much we can compile it unconditionally.
I would suggest to compile in these small functions unconditionally.
Quoted 2 lines
Or do you have anything else in mind (like defining a macro for the bpf one and making the ifdef look less ugly)?
it's the ifdef pollution that it would be good to avoid IMO.
Kumar Kartikeya Dwivedi
maintainerRe: [PATCH bpf-next v7 07/13] net: netfilter: Add kfuncs to allocate and insert CT
Quoted 30 lines · Pablo Neira Ayuso
Quoted 21 lines · Kumar Kartikeya Dwivedi
Quoted 20 lines · Pablo Neira Ayuso
Hi,
include/net/netfilter/nf_conntrack_core.h void nf_conntrack_lock(spinlock_t *lock); · line 91
Quoted 13 lines · Kumar Kartikeya Dwivedi
include/net/netfilter/nf_conntrack_core.h +5
-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 ))There must be a better way to do this without ifdef pollution?
Quoted 6 lines
Quoted 1 line
Could you fix this?
I can just remove the ifdefs completely. The first part of the ifdef is the correct way to detect BPF support for
nf_conntrack, the second is for ct netlink. These are the only two users. But it's not a lot of code, so until it grows too much we can compile it unconditionally.
Quoted 6 lines
I would suggest to compile in these small functions unconditionally.
Quoted 2 lines
Or do you have anything else in mind (like defining a macro for the bpf one and making the ifdef look less ugly)?
it's the ifdef pollution that it would be good to avoid IMO.
Ok, I have sent a fix to remove these ifdefs. We can revisit this when more shared functions appear.
Kumar Kartikeya Dwivedi
maintainerPATCH v7 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 v7 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 v7 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 v7 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 v7 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 v7 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
Quoted 7 lines · Kumar Kartikeya Dwivedi
Introduce the following new kfuncs:
- bpf_{xdp,skb}_ct_alloc
-bpf_ct_insert_entry
- bpf_ct_{set,change}_timeout
- bpf_ct_{set,change}_status
Quoted 6 lines
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.
Is it expected that using these helpers and the kernel's conntrack to manage connection state from XDP will outperform using maps and eBPF timers (for XDP use cases that don't have a userspace component that also needs the information in conntrack)? Have you done any benchmarking on the performance of using conntrack from XDP?
Thanks!
--Zvi
Quoted 96 lines
Changelog:
----------
v6 -> v7:
v6: https://lore.kernel.org/bpf/[email protected]* Use .long to encode flags (Alexei)
* Fix description ofKF_RET_NULLin documentation (Toke)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 explainingTRUSTED_ARGSkfunc flag (Alexei)
* Fix missing offset check for trusted arguments (Alexei)
* Changenf_conntracktest minimum delta value to 8v4 -> v5:
v4: https://lore.kernel.org/bpf/[email protected]* Drop read-only
PTR_TO_BTF_IDapproach, use structnf_conn___init(Alexei)
* Drop acquire release pair code that is no longer required (Alexei)
* Disable writes intonf_conn, use dedicated helpers (Florian, Alexei)
* Refactor and share ctnetlink code for setting timeout and status
* Do strict type matching on finding__refsuffix on argument to prevent passingnf_conn___initasnf_conn(offset = 0, match on walk)
* Removebpf_ct_optsparameter frombpf_ct_insert_entry
* Update selftests for new additions, add more negative testsv3 -> v4:
v3: https://lore.kernel.org/bpf/[email protected]* split
bpf_xdp_ct_addin bpf_xdp_ct_alloc/bpf_skb_ct_alloc andbpf_ct_insert_entry
* add verifier code to properly populate/configure ct entry
* improve selftestsv2 -> v3:
v2: https://lore.kernel.org/bpf/[email protected]* add
bpf_xdp_ct_addandbpf_ct_refresh_timeoutkfunc helpers
* remove conntrack dependency from selftests
* add support for forcing kfunc args to be referenced and related selftestsv1 -> v2:
v1: https://lore.kernel.org/bpf/1327f8f5696ff2bc60400e8f3b79047914ccc837.1651595019.git.lorenzo@kernel.org* add
bpf_ct_refresh_timeoutkfunc selftestKumar Kartikeya Dwivedi (10):
bpf: Introduce 8-byte BTF settools/resolve_btfids: Add support for 8-byte BTF sets
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 newnf_conntrackkfuncs selftests/bpf: Fixtest_verifierfailed test in unprivileged modeLorenzo 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 newnf_conntrackkfuncs
Documentation/bpf/index.rst| 1 +Documentation/bpf/kfuncs.rst| 170 ++++++++include/linux/bpf.h| 3 +-include/linux/btf.h| 65 ++--include/linux/btf_ids.h| 68 +++-include/net/netfilter/nf_conntrack_core.h| 19 +kernel/bpf/btf.c| 123 +++---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| 40 +-.../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, 1139 insertions(+), 349 deletions(-)create mode 100644
Documentation/bpf/kfuncs.rst
create mode 100644tools/testing/selftests/bpf/progs/test_bpf_nf_fail.c--
2.34.1
Kumar Kartikeya Dwivedi
maintainerQuoted 17 lines · Zvi Effron
Quoted 7 lines · Kumar Kartikeya Dwivedi
Introduce the following new kfuncs:
- bpf_{xdp,skb}_ct_alloc
-bpf_ct_insert_entry
- bpf_ct_{set,change}_timeout
- bpf_ct_{set,change}_statusQuoted 6 lines
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.
Quoted 6 lines
Is it expected that using these helpers and the kernel's conntrack to manage connection state from XDP will outperform using maps and eBPF timers (for XDP use cases that don't have a userspace component that also needs the information in conntrack)? Have you done any benchmarking on the performance of using conntrack from XDP?
No, I haven't done any benchmarking against a BPF based conntrack. The goal here is to give XDP and TC programs access to kernel's existing conntrack, so that in cases where implementing one in BPF is not desired/needed, the user can leverage the existing implementation in the kernel.
Quoted 99 lines
Thanks!
--ZviQuoted 96 lines
Changelog:
----------
v6 -> v7:
v6: https://lore.kernel.org/bpf/[email protected]* Use .long to encode flags (Alexei)
* Fix description ofKF_RET_NULLin documentation (Toke)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 explainingTRUSTED_ARGSkfunc flag (Alexei)
* Fix missing offset check for trusted arguments (Alexei)
* Changenf_conntracktest minimum delta value to 8v4 -> v5:
v4: https://lore.kernel.org/bpf/[email protected]* Drop read-only
PTR_TO_BTF_IDapproach, use structnf_conn___init(Alexei)
* Drop acquire release pair code that is no longer required (Alexei)
* Disable writes intonf_conn, use dedicated helpers (Florian, Alexei)
* Refactor and share ctnetlink code for setting timeout and status
* Do strict type matching on finding__refsuffix on argument to prevent passingnf_conn___initasnf_conn(offset = 0, match on walk)
* Removebpf_ct_optsparameter frombpf_ct_insert_entry
* Update selftests for new additions, add more negative testsv3 -> v4:
v3: https://lore.kernel.org/bpf/[email protected]* split
bpf_xdp_ct_addin bpf_xdp_ct_alloc/bpf_skb_ct_alloc andbpf_ct_insert_entry
* add verifier code to properly populate/configure ct entry
* improve selftestsv2 -> v3:
v2: https://lore.kernel.org/bpf/[email protected]* add
bpf_xdp_ct_addandbpf_ct_refresh_timeoutkfunc helpers
* remove conntrack dependency from selftests
* add support for forcing kfunc args to be referenced and related selftestsv1 -> v2:
v1: https://lore.kernel.org/bpf/1327f8f5696ff2bc60400e8f3b79047914ccc837.1651595019.git.lorenzo@kernel.org* add
bpf_ct_refresh_timeoutkfunc selftestKumar Kartikeya Dwivedi (10):
bpf: Introduce 8-byte BTF settools/resolve_btfids: Add support for 8-byte BTF sets
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 newnf_conntrackkfuncs selftests/bpf: Fixtest_verifierfailed test in unprivileged modeLorenzo 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 newnf_conntrackkfuncs
Documentation/bpf/index.rst| 1 +Documentation/bpf/kfuncs.rst| 170 ++++++++include/linux/bpf.h| 3 +-include/linux/btf.h| 65 ++--include/linux/btf_ids.h| 68 +++-include/net/netfilter/nf_conntrack_core.h| 19 +kernel/bpf/btf.c| 123 +++---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| 40 +-.../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, 1139 insertions(+), 349 deletions(-)create mode 100644
Documentation/bpf/kfuncs.rst
create mode 100644tools/testing/selftests/bpf/progs/test_bpf_nf_fail.c--
2.34.1
This series was applied to bpf/bpf-next.git (master) by Alexei Starovoitov <[email protected]>:
Hello:
This series was applied to bpf/bpf-next.git (master) by Alexei Starovoitov <[email protected]>:
Quoted 6 lines · On Thu, 21 Jul 2022 15:42:32 +0200 you wrote:
Introduce the following new kfuncs:
- bpf_{xdp,skb}_ct_alloc
-bpf_ct_insert_entry
- bpf_ct_{set,change}_timeout
- bpf_ct_{set,change}_status
Quoted 7 lines
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.
[...]
Here is the summary with links:
- [bpf-next,v7,01/13] bpf: Introduce 8-byte BTF set
https://git.kernel.org/bpf/bpf-next/c/ab21d6063c01 - [bpf-next,v7,02/13] tools/resolve_btfids: Add support for 8-byte BTF sets https://git.kernel.org/bpf/bpf-next/c/ef2c6f370a63 - [bpf-next,v7,03/13] bpf: Switch to new kfunc flags infrastructure https://git.kernel.org/bpf/bpf-next/c/a4703e318432 - [bpf-next,v7,04/13] bpf: Add support for forcing kfunc args to be trusted https://git.kernel.org/bpf/bpf-next/c/56e948ffc098 - [bpf-next,v7,05/13] bpf: Add documentation for kfuncs https://git.kernel.org/bpf/bpf-next/c/63e564ebd1fd - [bpf-next,v7,06/13] net: netfilter: Deduplicate code in bpf_{xdp,skb}_ct_lookup https://git.kernel.org/bpf/bpf-next/c/aed8ee7feb44 - [bpf-next,v7,07/13] net: netfilter: Add kfuncs to allocate and insert CT https://git.kernel.org/bpf/bpf-next/c/d7e79c97c00c - [bpf-next,v7,08/13] net: netfilter: Add kfuncs to set and change CT timeout https://git.kernel.org/bpf/bpf-next/c/0b3892364431 - [bpf-next,v7,09/13] net: netfilter: Add kfuncs to set and change CT status https://git.kernel.org/bpf/bpf-next/c/ef69aa3a986e - [bpf-next,v7,10/13] selftests/bpf: Add verifier tests for trusted kfunc args https://git.kernel.org/bpf/bpf-next/c/8dd5e75683f7 - [bpf-next,v7,11/13] selftests/bpf: Add tests for new nf_conntrack kfuncs https://git.kernel.org/bpf/bpf-next/c/6eb7fba007a7 - [bpf-next,v7,12/13] selftests/bpf: Add negative tests for new nf_conntrack kfuncs https://git.kernel.org/bpf/bpf-next/c/c6f420ac9d25 - [bpf-next,v7,13/13] selftests/bpf: Fix test_verifier failed test in unprivileged mode https://git.kernel.org/bpf/bpf-next/c/e3fa4735f04d
You are awesome, thank you!
Signature · 2 lines
Deet-doot-dot, I am a bot. https://korg.docs.kernel.org/patchwork/pwbot.html