Misc BPF improvements
Subsystems (11)
Daniel Borkmann
maintainerv3 cover Misc BPF improvements
This set adds various patches I still had in my queue, first two are test cases to provide coverage for the recent two fixes that went to bpf tree, then a small improvement on the error message for gpl helpers. Next, we expose prog and map id into fdinfo in order to allow for inspection of these objections currently used in applications. Patch after that removes a retpoline call for map lookup/update/delete helpers. A new helper is added in the subsequent patch to lookup the skb's socket's cgroup v2 id which can be used in an efficient way for e.g. lookups on egress side. Next one is a fix to fully clear state info in tunnel/xfrm helpers. Given this is full cap_sys_admin from init ns and has same priv requirements like tracing, bpf-next should be okay. A small bug fix for bpf_asm follows, and next a fix for context access in tracing which was recently reported. Lastly, a small update in the maintainer's file to add patchwork url and missing files.
Thanks!
v2 -> v3:
- Noticed a merge artefact inside uapi header comment, sigh, fixed now.
v1 -> v2:
- minor fix in getting context access work on 32 bit for tracing
- add paragraph to uapi helper doc to better describe kernel build deps for cggroup helper
Daniel Borkmann (11):
bpf: test case for map pointer poison with calls/branches
bpf: add also cbpf long jump test cases with heavy expansion
bpf: fixup error message from gpl helpers on license mismatch
bpf: show prog and map id in fdinfo
bpf: avoid retpoline for lookup/update/delete calls on maps
bpf: add bpf_skb_cgroup_id helper
bpf: make sure to clear unused fields in tunnel/xfrm state fetch
bpf: fix cbpf parser bug for octal numbers
bpf: fix context access in tracing progs on 32 bit archs
bpf: sync bpf uapi header with tools
bpf, doc: add missing patchwork url and libbpf to maintainers
MAINTAINERS | 2 + include/linux/filter.h | 43 ++++++- include/uapi/linux/bpf.h | 22 +++- kernel/bpf/hashtab.c | 12 +- kernel/bpf/syscall.c | 12 +- kernel/bpf/verifier.c | 72 ++++++++--- kernel/trace/bpf_trace.c | 10 +- lib/test_bpf.c | 63 ++++++++++ net/core/filter.c | 35 +++++- tools/bpf/bpf_exp.l | 2 +- tools/include/linux/filter.h | 10 ++ tools/include/uapi/linux/bpf.h | 22 +++- tools/testing/selftests/bpf/test_verifier.c | 185 ++++++++++++++++++++++++---- 13 files changed, 422 insertions(+), 68 deletions(-)
Signature · 1 line
2.9.5
Daniel Borkmann
maintainerPATCH v3 1/11 bpf: test case for map pointer poison with calls/branches
Add several test cases where the same or different map pointers originate from different paths in the program and execute a map lookup or tail call at a common location.
--- include/linux/filter.h | 10 ++ tools/include/linux/filter.h | 10 ++ tools/testing/selftests/bpf/test_verifier.c | 185 ++++++++++++++++++++++++---- 3 files changed, 178 insertions(+), 27 deletions(-)
include/linux/filter.h +10 -0
@@ -289,6 +289,16 @@ struct xdp_buff; .off = OFF, \ .imm = 0 }) +/* Relative call */ + +#define BPF_CALL_REL (TGT ) \ + ((struct bpf_insn) { \ + .code = BPF_JMP | BPF_CALL, \ + .dst_reg = 0, \ + .src_reg = BPF_PSEUDO_CALL, \ + .off = 0, \ + .imm = TGT }) +/* Function call */ #define BPF_EMIT_CALL (FUNC ) \
tools/include/linux/filter.h +10 -0
@@ -263,6 +263,16 @@#define BPF_LD_MAP_FD (DST ,MAP_FD ) \ BPF_LD_IMM64_RAW(DST, BPF_PSEUDO_MAP_FD, MAP_FD) +/* Relative call */ + +#define BPF_CALL_REL (TGT ) \ + ((struct bpf_insn) { \ + .code = BPF_JMP | BPF_CALL, \ + .dst_reg = 0, \ + .src_reg = BPF_PSEUDO_CALL, \ + .off = 0, \ + .imm = TGT }) +/* Program exit */ #define BPF_EXIT_INSN () \
tools/testing/selftests/bpf/test_verifier.c +158 -27
298 lines not on this page · raw message
Signature · 1 line
2.9.5
Daniel Borkmann
maintainerPATCH v3 2/11 bpf: add also cbpf long jump test cases with heavy expansion
In reply to Daniel BorkmannWe have one triggering on eBPF but lets also add a cBPF example to make sure we keep tracking them. Also add anther cBPF test running max number of MSH ops.
--- lib/test_bpf.c | 63 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 63 insertions(+)
lib/test_bpf.c +63 -0
@@ -356,6 +356,52 @@ static int bpf_fill_maxinsns11(struct bpf_test *self)return __bpf_fill_ja (self,BPF_MAXINSNS ,68 ); } +static int bpf_fill_maxinsns12 (struct bpf_test *self) +{ +unsigned int len =BPF_MAXINSNS ; +struct sock_filter *insn; +int i =0 ; + + insn =kmalloc_array (len,sizeof (*insn),GFP_KERNEL ); +if (!insn) +return -ENOMEM ; + + insn[0 ] =__BPF_JUMP (BPF_JMP |BPF_JA , len -2 ,0 ,0 ); + +for (i =1 ; i < len -1 ; i++) + insn[i] =__BPF_STMT (BPF_LDX |BPF_B |BPF_MSH ,0 ); + + insn[len -1 ] =__BPF_STMT (BPF_RET |BPF_K ,0xabababab ); + + self->u.ptr.insns = insn; + self->u.ptr.len = len; + +return 0 ; +} + +static int bpf_fill_maxinsns13 (struct bpf_test *self) +{ +unsigned int len =BPF_MAXINSNS ; +struct sock_filter *insn; +int i =0 ; + + insn =kmalloc_array (len,sizeof (*insn),GFP_KERNEL ); +if (!insn) +return -ENOMEM ; + +for (i =0 ; i < len -3 ; i++) + insn[i] =__BPF_STMT (BPF_LDX |BPF_B |BPF_MSH ,0 ); + + insn[len -3 ] =__BPF_STMT (BPF_LD |BPF_IMM ,0xabababab ); + insn[len -2 ] =__BPF_STMT (BPF_ALU |BPF_XOR |BPF_X ,0 ); + insn[len -1 ] =__BPF_STMT (BPF_RET |BPF_A ,0 ); + + self->u.ptr.insns = insn; + self->u.ptr.len = len; + +return 0 ; +} +static int bpf_fill_ja (struct bpf_test *self) {/* Hits exactly 11 passes on x86_64 JIT. */
@@ -5290,6 +5336,23 @@ static struct bpf_test tests[] = { .expected_errcode = -ENOTSUPP, }, { +"BPF_MAXINSNS: jump over MSH" , + { }, +CLASSIC |FLAG_EXPECTED_FAIL , + { 0xfa, 0xfb, 0xfc, 0xfd, }, + { { 4, 0xabababab } }, + .fill_helper = bpf_fill_maxinsns12, + .expected_errcode = -EINVAL, + }, + { +"BPF_MAXINSNS: exec all MSH" , + { }, +CLASSIC , + { 0xfa, 0xfb, 0xfc, 0xfd, }, + { { 4, 0xababab83 } }, + .fill_helper = bpf_fill_maxinsns13, + }, + {"BPF_MAXINSNS: ld_abs+get_processor_id" , { }, CLASSIC,
Signature · 1 line
2.9.5
Daniel Borkmann
maintainerPATCH v3 3/11 bpf: fixup error message from gpl helpers on license mismatch
In reply to Daniel BorkmannStating 'proprietary program' in the error is just silly since it can also be a different open source license than that which is just not compatible.
Reference: https://twitter.com/majek04/status/998531268039102465
--- kernel/bpf/verifier.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
kernel/bpf/verifier.c +1 -1
@@ -2462,7 +2462,7 @@ static int check_helper_call(struct bpf_verifier_env *env, int func_id, int insn/* eBPF programs must be GPL compatible to use GPL-ed functions */ if (!env->prog->gpl_compatible && fn->gpl_only) { -verbose (env,"cannot call GPL only function from proprietary program\n" ); +verbose (env,"cannot call GPL-restricted function from non-GPL compatible program\n" );return -EINVAL ; }
Signature · 1 line
2.9.5
Daniel Borkmann
maintainerPATCH v3 4/11 bpf: show prog and map id in fdinfo
In reply to Daniel BorkmannIts trivial and straight forward to expose it for scripts that can then use it along with bpftool in order to inspect an individual application's used maps and progs. Right now we dump some basic information in the fdinfo file but with the help of the map/prog id full introspection becomes possible now.
--- kernel/bpf/syscall.c | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-)
kernel/bpf/syscall.c +8 -4
@@ -327,13 +327,15 @@ static void bpf_map_show_fdinfo(struct seq_file *m, struct file *filp)"value_size:\t%u\n" "max_entries:\t%u\n" "map_flags:\t%#x\n" -"memlock:\t%llu\n" , +"memlock:\t%llu\n" +"map_id:\t%u\n" , map->map_type, map->key_size, map->value_size, map->max_entries, map->map_flags, - map->pages * 1ULL << PAGE_SHIFT); + map->pages *1ULL <<PAGE_SHIFT , + map->id);if (owner_prog_type) { seq_printf(m, "owner_prog_type:\t%u\n",
@@ -1070,11 +1072,13 @@ static void bpf_prog_show_fdinfo(struct seq_file *m, struct file *filp)"prog_type:\t%u\n" "prog_jited:\t%u\n" "prog_tag:\t%s\n" -"memlock:\t%llu\n" , +"memlock:\t%llu\n" +"prog_id:\t%u\n" , prog->type, prog->jited, prog_tag, - prog->pages * 1ULL << PAGE_SHIFT); + prog->pages *1ULL <<PAGE_SHIFT , + prog->aux->id); }#endif
Signature · 1 line
2.9.5
Daniel Borkmann
maintainerPATCH v3 5/11 bpf: avoid retpoline for lookup/update/delete calls on maps
In reply to Daniel BorkmannWhile some of the BPF map lookup helpers provide a ->map_gen_lookup() callback for inlining the map lookup altogether it is not available for every map, so the remaining ones have to call bpf_map_lookup_elem() helper which does a dispatch to map->ops->map_lookup_elem(). In times of retpolines, this will control and trap speculative execution rather than letting it do its work for the indirect call and will therefore cause a slowdown. Likewise, bpf_map_update_elem() and bpf_map_delete_elem() do not have an inlined version and need to call into their map->ops->map_update_elem() resp. map->ops->map_delete_elem() handlers.
Before:
# bpftool p d x i 1
0: (bf) r2 = r10
1: (07) r2 += -8
2: (7a) *(u64 *)(r2 +0) = 0
3: (18) r1 = map[id:1]
5: (85) call __htab_map_lookup_elem#232656
6: (15) if r0 == 0x0 goto pc+4
7: (71) r1 = *(u8 *)(r0 +35)
8: (55) if r1 != 0x0 goto pc+1
9: (72) *(u8 *)(r0 +35) = 1
10: (07) r0 += 56
11: (15) if r0 == 0x0 goto pc+4
12: (bf) r2 = r0
13: (18) r1 = map[id:1]
15: (85) call bpf_map_delete_elem#215008 <-- indirect call via
16: (95) exit helperAfter:
# bpftool p d x i 1
0: (bf) r2 = r10
1: (07) r2 += -8
2: (7a) *(u64 *)(r2 +0) = 0
3: (18) r1 = map[id:1]
5: (85) call __htab_map_lookup_elem#233328
6: (15) if r0 == 0x0 goto pc+4
7: (71) r1 = *(u8 *)(r0 +35)
8: (55) if r1 != 0x0 goto pc+1
9: (72) *(u8 *)(r0 +35) = 1
10: (07) r0 += 56
11: (15) if r0 == 0x0 goto pc+4
12: (bf) r2 = r0
13: (18) r1 = map[id:1]
15: (85) call htab_lru_map_delete_elem#238240 <-- direct call
16: (95) exitIn all three lookup/update/delete cases however we can use the actual address of the map callback directly if we find that there's only a single path with a map pointer leading to the helper call, meaning when the map pointer has not been poisoned from verifier side. Example code can be seen above for the delete case.
--- include/linux/filter.h | 3 +++ kernel/bpf/hashtab.c | 12 ++++++--- kernel/bpf/verifier.c | 67 +++++++++++++++++++++++++++++++++++++------------- 3 files changed, 62 insertions(+), 20 deletions(-)
include/linux/filter.h +3 -0
@@ -301,6 +301,9 @@ struct xdp_buff;/* Function call */ +#define BPF_CAST_CALL (x) \ + ((u64 (*)(u64, u64, u64, u64, u64))(x)) +#define BPF_EMIT_CALL (FUNC ) \ ((struct bpf_insn) { \ .code = BPF_JMP | BPF_CALL, \
kernel/bpf/hashtab.c +9 -3
@@ -503,7 +503,9 @@ static u32 htab_map_gen_lookup(struct bpf_map *map, struct bpf_insn *insn_buf)struct bpf_insn *insn = insn_buf;const int ret =BPF_REG_0 ; - *insn++ =BPF_EMIT_CALL ((u64 (*)(u64 ,u64 ,u64 ,u64 ,u64 ))__htab_map_lookup_elem); +BUILD_BUG_ON (!__same_type (&__htab_map_lookup_elem, + (void *(*)(struct bpf_map *map,void *key))NULL )); + *insn++ =BPF_EMIT_CALL (BPF_CAST_CALL (__htab_map_lookup_elem)); *insn++ =BPF_JMP_IMM (BPF_JEQ , ret,0 ,1 ); *insn++ = BPF_ALU64_IMM(BPF_ADD, ret, offsetof(struct htab_elem, key) +
@@ -530,7 +532,9 @@ static u32 htab_lru_map_gen_lookup(struct bpf_map *map,const int ret =BPF_REG_0 ;const int ref_reg =BPF_REG_1 ; - *insn++ =BPF_EMIT_CALL ((u64 (*)(u64 ,u64 ,u64 ,u64 ,u64 ))__htab_map_lookup_elem); +BUILD_BUG_ON (!__same_type (&__htab_map_lookup_elem, + (void *(*)(struct bpf_map *map,void *key))NULL )); + *insn++ =BPF_EMIT_CALL (BPF_CAST_CALL (__htab_map_lookup_elem)); *insn++ =BPF_JMP_IMM (BPF_JEQ , ret,0 ,4 ); *insn++ = BPF_LDX_MEM(BPF_B, ref_reg, ret, offsetof(struct htab_elem, lru_node) +
@@ -1369,7 +1373,9 @@ static u32 htab_of_map_gen_lookup(struct bpf_map *map,struct bpf_insn *insn = insn_buf;const int ret =BPF_REG_0 ; - *insn++ =BPF_EMIT_CALL ((u64 (*)(u64 ,u64 ,u64 ,u64 ,u64 ))__htab_map_lookup_elem); +BUILD_BUG_ON (!__same_type (&__htab_map_lookup_elem, + (void *(*)(struct bpf_map *map,void *key))NULL )); + *insn++ =BPF_EMIT_CALL (BPF_CAST_CALL (__htab_map_lookup_elem)); *insn++ =BPF_JMP_IMM (BPF_JEQ , ret,0 ,2 ); *insn++ = BPF_ALU64_IMM(BPF_ADD, ret, offsetof(struct htab_elem, key) +
kernel/bpf/verifier.c +50 -17
97 lines not on this page · raw message
Signature · 1 line
2.9.5
Re: [PATCH bpf-next v3 05/11] bpf: avoid retpoline for lookup/update/delete calls on maps
Quoted 3 lines · On Sat, 2 Jun 2018 23:06:35 +0200 Daniel Borkmann <[email protected]> wrote:
Before:
# bpftool p d x i 1
Could this please be changed to:
# bpftool prog dump xlated id 1
I requested this before, but you seem to have missed my feedback... This makes the command "self-documenting" and searchable by Google.
Quoted 16 lines
0: (bf) r2 = r10 1: (07) r2 += -8 2: (7a) *(u64 *)(r2 +0) = 0 3: (18) r1 = map[id:1] 5: (85) call __htab_map_lookup_elem#232656 6: (15) if r0 == 0x0 goto pc+4 7: (71) r1 = *(u8 *)(r0 +35) 8: (55) if r1 != 0x0 goto pc+1 9: (72) *(u8 *)(r0 +35) = 110: (07) r0 += 56
11: (15) if r0 ==0x0goto pc+4
12: (bf) r2 = r0
13: (18) r1 = map[id:1]
15: (85) call bpf_map_delete_elem#215008 <-- indirect call via
16: (95) exit helper
Signature · 4 lines
Best regards, Jesper Dangaard Brouer MSc.CS, Principal Kernel Engineer at Red Hat LinkedIn: http://www.linkedin.com/in/brouer
Daniel Borkmann
maintainerRe: [PATCH bpf-next v3 05/11] bpf: avoid retpoline for lookup/update/delete calls on maps
Quoted 5 lines · Jesper Dangaard Brouer
Quoted 2 lines · On Sat, 2 Jun 2018 23:06:35 +0200 Daniel Borkmann <[email protected]> wrote:
Before:
Quoted 8 lines
Quoted 1 line
# bpftool p d x i 1Could this please be changed to:
# bpftool prog dump xlated id 1I requested this before, but you seem to have missed my feedback... This makes the command "self-documenting" and searchable by Google.
I recently wrote a howto here, but there's also excellent documentation in terms of man pages for bpftool.
http://cilium.readthedocs.io/en/latest/bpf/#bpftool
My original thinking was that it might be okay to also show usage of short option matching, like in iproute2 probably few people only write 'ip address' but majority uses 'ip a' instead. But I'm fine either way if there are strong opinions ... thanks Alexei for fixing up!
Re: [PATCH bpf-next v3 05/11] bpf: avoid retpoline for lookup/update/delete calls on maps
Quoted 18 lines · On Sun, 3 Jun 2018 18:11:45 +0200 Daniel Borkmann <[email protected]> wrote:
Quoted 5 lines · Jesper Dangaard Brouer
Quoted 2 lines · On Sat, 2 Jun 2018 23:06:35 +0200 Daniel Borkmann <[email protected]> wrote:
Before:
Quoted 8 lines
Quoted 1 line
# bpftool p d x i 1Could this please be changed to:
# bpftool prog dump xlated id 1I requested this before, but you seem to have missed my feedback... This makes the command "self-documenting" and searchable by Google.
I recently wrote a howto here, but there's also excellent documentation in terms of man pages for bpftool.
Quoted 6 lines
http://cilium.readthedocs.io/en/latest/bpf/#bpftool
My original thinking was that it might be okay to also show usage of short option matching, like in iproute2 probably few people only write 'ip address' but majority uses 'ip a' instead. But I'm fine either way if there are strong opinions ... thanks Alexei for fixing up!
First of all I love your documentation effort.
Secondly I personally *hate* how the 'ip' does it's short options parsing and especially order/precedence ambiguity. Phil Sutter (Fedora/RHEL iproute2 maintainer) have a funny quiz illustrating the ambiguity issues.
Quiz: https://youtu.be/cymH9pcFGa0?t=7m10s
Code problem: https://youtu.be/cymH9pcFGa0?t=9m8s
I hope the maintainers and developers of bpftool make sure we don't end up in an ambiguity mess like we have with 'ip', pretty please.
Signature · 4 lines
Best regards, Jesper Dangaard Brouer MSc.CS, Principal Kernel Engineer at Red Hat LinkedIn: http://www.linkedin.com/in/brouer
Re: [PATCH bpf-next v3 05/11] bpf: avoid retpoline for lookup/update/delete calls on maps
Hi!
On Sun, Jun 03, 2018 at 07:08:55PM +0200, Jesper Dangaard Brouer wrote:
[...]
Quoted 4 lines
Secondly I personally *hate* how the 'ip' does it's short options parsing and especially order/precedence ambiguity. Phil Sutter (Fedora/RHEL iproute2 maintainer) have a funny quiz illustrating the ambiguity issues.
Hehe, yes. It's a classical case of something smart evolving into a
pain: At first there's only 'ip link', so you allow 'ip l' as a shortcut. Then someone implements 'ip l2tp' - so what do you do? Establish a policy of abbreviation having to be unique and break existing behaviour or accept the mess and head on.
My suggestion would be to not get into the abbreviated subcommands business at all but instead ship and maintain a bash-completion script.
Cheers, Phil
Re: [PATCH bpf-next v3 05/11] bpf: avoid retpoline for lookup/update/delete calls on maps
Quoted 9 lines · Phil Sutter
Quoted 4 lines · Jesper Dangaard Brouer
Secondly I personally *hate* how the 'ip' does it's short options parsing and especially order/precedence ambiguity. Phil Sutter (Fedora/RHEL iproute2 maintainer) have a funny quiz illustrating the ambiguity issues.
Hehe, yes. It's a classical case of something smart evolving into a
pain: At first there's only 'ip link', so you allow 'ip l' as a shortcut. Then someone implements 'ip l2tp' - so what do you do?
Good example, I like that "ip l" shows me the links because that's what 99.99% of people want when they type that command ;)
Quoted 2 lines
Establish a policy of abbreviation having to be unique and break existing behaviour or accept the mess and head on.
Commands are tested in order of addition so older ones take precedence.
The iproute2 behaviour was replicated in bpftool on purpose, because it should be very familiar to people. It is to me at least. And IMHO it's better to be consistent with a well known tool than have our own quirks and rules...
Quoted 2 lines
My suggestion would be to not get into the abbreviated subcommands business at all but instead ship and maintain a bash-completion script.
We prefer to have both :) Those of us who like to abbreviate can do that, and others can use completions. I personally think Quentin did an awesome job on the completions, they cover the entire syntax unlike the iproute2 ones and we intend to keep them that way!
Daniel Borkmann
maintainerRe: [PATCH bpf-next v3 05/11] bpf: avoid retpoline for lookup/update/delete calls on maps
On 06/04/2018 08:25 PM, Jakub Kicinski wrote:
[...]
Quoted 4 lines
We prefer to have both :) Those of us who like to abbreviate can do that, and others can use completions. I personally think Quentin did an awesome job on the completions, they cover the entire syntax unlike the iproute2 ones and we intend to keep them that way!
Fully agree, both make sense. Personally, I only use abbreviations on bpftool so far. :)
Re: [PATCH bpf-next v3 05/11] bpf: avoid retpoline for lookup/update/delete calls on maps
In reply to Jakub KicinskiQuoted 3 lines · Jakub Kicinski
that, and others can use completions. I personally think Quentin did an awesome job on the completions, they cover the entire syntax unlike the iproute2 ones and we intend to keep them that way!
iproute2 patches for completions would be welcomed if anyone has the time.
Daniel Borkmann
maintainerPATCH v3 6/11 bpf: add bpf_skb_cgroup_id helper
In reply to Daniel BorkmannAdd a new bpf_skb_cgroup_id() helper that allows to retrieve the cgroup id from the skb's socket. This is useful in particular to enable bpf_get_cgroup_classid()-like behavior for cgroup v1 in cgroup v2 by allowing ID based matching on egress. This can in particular be used in combination with applying policy e.g. from map lookups, and also complements the older bpf_skb_under_cgroup() interface. In user space the cgroup id for a given path can be retrieved through the f_handle as demonstrated in [0] recently.
[0] https://lkml.org/lkml/2018/5/22/1190
--- include/uapi/linux/bpf.h | 19 ++++++++++++++++++- net/core/filter.c | 29 +++++++++++++++++++++++++++-- 2 files changed, 45 insertions(+), 3 deletions(-)
include/uapi/linux/bpf.h +18 -1
@@ -2054,6 +2054,22 @@ union bpf_attr {* * Return * 0 +* +* uint64_t bpf_skb_cgroup_id(struct sk_buff *skb) +* Description +* Return the cgroup v2 id of the socket associated with the *skb*. +* This is roughly similar to the **bpf_get_cgroup_classid**\ () +* helper for cgroup v1 by providing a tag resp. identifier that +* can be matched on or used for map lookups e.g. to implement +* policy. The cgroup v2 id of a given path in the hierarchy is +* exposed in user space through the f_handle API in order to get +* to the same 64-bit id. +* +* This helper can be used on TC egress path, but not on ingress, +* and is available only if the kernel was compiled with the +* **CONFIG_SOCK_CGROUP_DATA** configuration option. +* Return +* The id is returned or 0 in case the id could not be retrieved. */ #define __BPF_FUNC_MAPPER (FN ) \ FN(unspec), \
@@ -2134,7 +2150,8 @@ union bpf_attr {FN (lwt_seg6_adjust_srh), \FN (lwt_seg6_action), \FN (rc_repeat), \ -FN (rc_keydown), +FN (rc_keydown), \ +FN (skb_cgroup_id),/* integer value in 'imm' field of BPF_CALL instruction selects which helper * function eBPF program intends to call
net/core/filter.c +27 -2
@@ -3661,6 +3661,27 @@ static const struct bpf_func_proto bpf_skb_under_cgroup_proto = { .arg3_type = ARG_ANYTHING, }; +#ifdef CONFIG_SOCK_CGROUP_DATA +BPF_CALL_1(bpf_skb_cgroup_id, const struct sk_buff *, skb) +{ +struct sock *sk =skb_to_full_sk (skb); +struct cgroup *cgrp; + +if (!sk || !sk_fullsock (sk)) +return 0 ; + + cgrp =sock_cgroup_ptr (&sk->sk_cgrp_data); +return cgrp->kn->id.id; +} + +static const struct bpf_func_proto bpf_skb_cgroup_id_proto = { + .func = bpf_skb_cgroup_id, + .gpl_only = false, + .ret_type =RET_INTEGER , + .arg1_type =ARG_PTR_TO_CTX , +}; +#endif +static unsigned long bpf_xdp_copy (void *dst_buff,const void *src_buff,unsigned long off,unsigned long len) {
@@ -4747,12 +4768,16 @@ tc_cls_act_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)return &bpf_get_socket_cookie_proto;case BPF_FUNC_get_socket_uid:return &bpf_get_socket_uid_proto; +case BPF_FUNC_fib_lookup: +return &bpf_skb_fib_lookup_proto;#ifdef CONFIG_XFRM case BPF_FUNC_skb_get_xfrm_state:return &bpf_skb_get_xfrm_state_proto;#endif -case BPF_FUNC_fib_lookup: -return &bpf_skb_fib_lookup_proto; +#ifdef CONFIG_SOCK_CGROUP_DATA +case BPF_FUNC_skb_cgroup_id: +return &bpf_skb_cgroup_id_proto; +#endif default :return bpf_base_func_proto (func_id); }
Signature · 1 line
2.9.5
Daniel Borkmann
maintainerPATCH v3 7/11 bpf: make sure to clear unused fields in tunnel/xfrm state fetch
In reply to Daniel BorkmannSince the remaining bits are not filled in struct bpf_tunnel_key resp. struct bpf_xfrm_state and originate from uninitialized stack space, we should make sure to clear them before handing control back to the program.
Also add a padding element to struct bpf_xfrm_state for future use similar as we have in struct bpf_tunnel_key and clear it as well.
struct bpf_xfrm_state {
__u32 reqid; /* 0 4 */
__u32 spi; /* 4 4 */
__u16 family; /* 8 2 */ /* XXX 2 bytes hole, try to pack */
union {
__u32 remote_ipv4; /* 4 */
__u32 remote_ipv6[4]; /* 16 */
}; /* 12 16 */
/* size: 28, cachelines: 1, members: 4 */
/* sum members: 26, holes: 1, sum holes: 2 */
/* last cacheline: 28 bytes */};
--- include/uapi/linux/bpf.h | 3 ++- net/core/filter.c | 6 ++++++ 2 files changed, 8 insertions(+), 1 deletion(-)
include/uapi/linux/bpf.h +2 -1
@@ -2268,7 +2268,7 @@ struct bpf_tunnel_key { };__u8 tunnel_tos;__u8 tunnel_ttl; -__u16 tunnel_ext; +__u16 tunnel_ext;/* Padding, future use. */ __u32 tunnel_label; };
@@ -2279,6 +2279,7 @@ struct bpf_xfrm_state {__u32 reqid;__u32 spi;/* Stored in network byte order */ __u16 family; +__u16 ext;/* Padding, future use. */ union {__u32 remote_ipv4;/* Stored in network byte order */ __u32 remote_ipv6[4 ];/* Stored in network byte order */
net/core/filter.c +6 -0
@@ -3445,6 +3445,7 @@ BPF_CALL_4(bpf_skb_get_tunnel_key, struct sk_buff *, skb, struct bpf_tunnel_key to->tunnel_id =be64_to_cpu (info->key.tun_id); to->tunnel_tos = info->key.tos; to->tunnel_ttl = info->key.ttl; + to->tunnel_ext =0 ;if (flags &BPF_F_TUNINFO_IPV6 ) { memcpy(to->remote_ipv6, &info->key.u.ipv6.src,
@@ -3452,6 +3453,8 @@ BPF_CALL_4(bpf_skb_get_tunnel_key, struct sk_buff *, skb, struct bpf_tunnel_key to->tunnel_label =be32_to_cpu (info->key.label); }else { to->remote_ipv4 =be32_to_cpu (info->key.u.ipv4.src); +memset (&to->remote_ipv6[1 ],0 ,sizeof (__u32) *3 ); + to->tunnel_label =0 ; }if (unlikely (size !=sizeof (struct bpf_tunnel_key )))
@@ -4047,11 +4050,14 @@ BPF_CALL_5(bpf_skb_get_xfrm_state, struct sk_buff *, skb, u32, index, to->reqid = x->props.reqid; to->spi = x->id.spi; to->family = x->props.family; + to->ext =0 ; +if (to->family ==AF_INET6 ) {memcpy (to->remote_ipv6, x->props.saddr.a6,sizeof (to->remote_ipv6)); }else { to->remote_ipv4 = x->props.saddr.a4; +memset (&to->remote_ipv6[1 ],0 ,sizeof (__u32) *3 ); }return 0 ;
Signature · 1 line
2.9.5
Daniel Borkmann
maintainerPATCH v3 8/11 bpf: fix cbpf parser bug for octal numbers
In reply to Daniel BorkmannRange is 0-7, not 0-9, otherwise parser silently excludes it from the strtol() rather than throwing an error.
--- tools/bpf/bpf_exp.l | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
tools/bpf/bpf_exp.l +1 -1
@@ -175,7 +175,7 @@ extern void yyerror(const char *str); yylval.number = strtol(yytext, NULL, 10); return number; } -([0][0-9]+) { +([0][0-7]+) { yylval.number = strtol(yytext + 1, NULL, 8); return number; }
Signature · 1 line
2.9.5
Daniel Borkmann
maintainerPATCH v3 9/11 bpf: fix context access in tracing progs on 32 bit archs
In reply to Daniel BorkmannWang reported that all the testcases for BPF_PROG_TYPE_PERF_EVENT program type in test_verifier report the following errors on x86_32:
172/p unpriv: spill/fill of different pointers ldx FAIL
Unexpected error message!
0: (bf) r6 = r10
1: (07) r6 += -8
2: (15) if r1 == 0x0 goto pc+3
R1=ctx(id=0,off=0,imm=0) R6=fp-8,call_-1 R10=fp0,call_-1
3: (bf) r2 = r10
4: (07) r2 += -76
5: (7b) *(u64 *)(r6 +0) = r2
6: (55) if r1 != 0x0 goto pc+1
R1=ctx(id=0,off=0,imm=0) R2=fp-76,call_-1 R6=fp-8,call_-1 R10=fp0,call_-1 fp-8=fp 7: (7b) *(u64 *)(r6 +0) = r1
8: (79) r1 = *(u64 *)(r6 +0)
9: (79) r1 = *(u64 *)(r1 +68)
invalid bpf_context access off=68 size=8
378/p check bpf_perf_event_data->sample_period byte load permitted FAIL Failed to load prog 'Permission denied'!
0: (b7) r0 = 0
1: (71) r0 = *(u8 *)(r1 +68)
invalid bpf_context access off=68 size=1
379/p check bpf_perf_event_data->sample_period half load permitted FAIL Failed to load prog 'Permission denied'!
0: (b7) r0 = 0
1: (69) r0 = *(u16 *)(r1 +68)
invalid bpf_context access off=68 size=2
380/p check bpf_perf_event_data->sample_period word load permitted FAIL Failed to load prog 'Permission denied'!
0: (b7) r0 = 0
1: (61) r0 = *(u32 *)(r1 +68)
invalid bpf_context access off=68 size=4
381/p check bpf_perf_event_data->sample_period dword load permitted FAIL Failed to load prog 'Permission denied'!
0: (b7) r0 = 0
1: (79) r0 = *(u64 *)(r1 +68)
invalid bpf_context access off=68 size=8
Reason is that struct pt_regs on x86_32 doesn't fully align to 8 byte boundary due to its size of 68 bytes. Therefore, bpf_ctx_narrow_access_ok() will then bail out saying that off & (size_default - 1) which is 68 & 7 doesn't cleanly align in the case of sample_period access from struct bpf_perf_event_data, hence verifier wrongly thinks we might be doing an unaligned access here though underlying arch can handle it just fine. Therefore adjust this down to machine size and check and rewrite the offset for narrow access on that basis. We also need to fix corresponding pe_prog_is_valid_access(), since we hit the check for off % size != 0 (e.g. 68 % 8 -> 4) in the first and last test. With that in place, progs for tracing work on x86_32.
--- include/linux/filter.h | 30 ++++++++++++++++++++++++------ kernel/bpf/verifier.c | 3 ++- kernel/trace/bpf_trace.c | 10 ++++++++-- 3 files changed, 34 insertions(+), 9 deletions(-)
include/linux/filter.h +24 -6
@@ -639,16 +639,34 @@ static inline bool bpf_prog_was_classic(const struct bpf_prog *prog)return prog->type ==BPF_PROG_TYPE_UNSPEC ; } -static inline bool -bpf_ctx_narrow_access_ok (u32 off,u32 size,const u32 size_default) +static inline u32 bpf_ctx_off_adjust_machine (u32 size) +{ +const u32 size_machine =sizeof (unsigned long ); + +if (size > size_machine && size % size_machine ==0 ) + size = size_machine; + +return size; +} + +static inline bool bpf_ctx_narrow_align_ok (u32 off,u32 size_access, +u32 size_default) { -bool off_ok; + size_default =bpf_ctx_off_adjust_machine (size_default); + size_access =bpf_ctx_off_adjust_machine (size_access); +#ifdef __LITTLE_ENDIAN - off_ok = (off & (size_default -1 )) ==0 ; +return (off & (size_default -1 )) ==0 ;#else - off_ok = (off & (size_default -1 )) + size == size_default; +return (off & (size_default -1 )) + size_access == size_default;#endif -return off_ok && size <= size_default && (size & (size -1 )) ==0 ; +} + +static inline bool +bpf_ctx_narrow_access_ok (u32 off,u32 size,u32 size_default) +{ +return bpf_ctx_narrow_align_ok (off, size, size_default) && + size <= size_default && (size & (size -1 )) ==0 ; }#define bpf_classic_proglen (fprog) (fprog->len * sizeof(fprog->filter[0]))
kernel/bpf/verifier.c +2 -1
@@ -5349,6 +5349,7 @@ static int convert_ctx_accesses(struct bpf_verifier_env *env)*/ is_narrower_load = size < ctx_field_size;if (is_narrower_load) { +u32 size_default =bpf_ctx_off_adjust_machine (ctx_field_size);u32 off = insn->off;u8 size_code;
@@ -5363,7 +5364,7 @@ static int convert_ctx_accesses(struct bpf_verifier_env *env)else if (ctx_field_size ==8 ) size_code =BPF_DW ; - insn->off = off & ~(ctx_field_size -1 ); + insn->off = off & ~(size_default -1 ); insn->code =BPF_LDX |BPF_MEM | size_code; }
kernel/trace/bpf_trace.c +8 -2
@@ -880,8 +880,14 @@ static bool pe_prog_is_valid_access(int off, int size, enum bpf_access_type typereturn false;if (type !=BPF_READ )return false; -if (off % size !=0 ) -return false; +if (off % size !=0 ) { +if (sizeof (unsigned long ) !=4 ) +return false; +if (size !=8 ) +return false; +if (off % size !=4 ) +return false; + }switch (off) { case bpf_ctx_range(struct bpf_perf_event_data, sample_period):
Signature · 1 line
2.9.5
Daniel Borkmann
maintainerPATCH v3 10/11 bpf: sync bpf uapi header with tools
In reply to Daniel BorkmannPull in recent changes from include/uapi/linux/bpf.h.
--- tools/include/uapi/linux/bpf.h | 22 ++++++++++++++++++++-- 1 file changed, 20 insertions(+), 2 deletions(-)
tools/include/uapi/linux/bpf.h +20 -2
@@ -2054,6 +2054,22 @@ union bpf_attr {* * Return * 0 +* +* uint64_t bpf_skb_cgroup_id(struct sk_buff *skb) +* Description +* Return the cgroup v2 id of the socket associated with the *skb*. +* This is roughly similar to the **bpf_get_cgroup_classid**\ () +* helper for cgroup v1 by providing a tag resp. identifier that +* can be matched on or used for map lookups e.g. to implement +* policy. The cgroup v2 id of a given path in the hierarchy is +* exposed in user space through the f_handle API in order to get +* to the same 64-bit id. +* +* This helper can be used on TC egress path, but not on ingress, +* and is available only if the kernel was compiled with the +* **CONFIG_SOCK_CGROUP_DATA** configuration option. +* Return +* The id is returned or 0 in case the id could not be retrieved. */ #define __BPF_FUNC_MAPPER (FN ) \ FN(unspec), \
@@ -2134,7 +2150,8 @@ union bpf_attr {FN (lwt_seg6_adjust_srh), \FN (lwt_seg6_action), \FN (rc_repeat), \ -FN (rc_keydown), +FN (rc_keydown), \ +FN (skb_cgroup_id),/* integer value in 'imm' field of BPF_CALL instruction selects which helper * function eBPF program intends to call
@@ -2251,7 +2268,7 @@ struct bpf_tunnel_key { };__u8 tunnel_tos;__u8 tunnel_ttl; -__u16 tunnel_ext; +__u16 tunnel_ext;/* Padding, future use. */ __u32 tunnel_label; };
@@ -2262,6 +2279,7 @@ struct bpf_xfrm_state {__u32 reqid;__u32 spi;/* Stored in network byte order */ __u16 family; +__u16 ext;/* Padding, future use. */ union {__u32 remote_ipv4;/* Stored in network byte order */ __u32 remote_ipv6[4 ];/* Stored in network byte order */
Signature · 1 line
2.9.5
Daniel Borkmann
maintainerPATCH v3 11/11 bpf, doc: add missing patchwork url and libbpf to maintainers
In reply to Daniel BorkmannAdd missing bits under tools/lib/bpf/ and also Q: entry in order to make it easier for people to retrieve current patch queue.
--- MAINTAINERS | 2 ++ 1 file changed, 2 insertions(+)
MAINTAINERS +2 -0
@@ -2722,6 +2722,7 @@ L: [email protected] L: [email protected] T: git git://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf.git T: git git://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git +Q: https://patchwork.ozlabs.org/project/netdev/list/?delegate=77147 S: Supported F: arch/x86/net/bpf_jit* F: Documentation/networking/filter.txt
@@ -2740,6 +2741,7 @@ F: net/sched/act_bpf.c F: net/sched/cls_bpf.c F: samples/bpf/ F: tools/bpf/ +F: tools/lib/bpf/ F: tools/testing/selftests/bpf/ BROADCOM B44 10/100 ETHERNET DRIVER
Signature · 1 line
2.9.5
Alexei Starovoitov
AppliedQuoted 18 lines · Daniel Borkmann
This set adds various patches I still had in my queue, first two are test cases to provide coverage for the recent two fixes that went to bpf tree, then a small improvement on the error message for gpl helpers. Next, we expose prog and map id into fdinfo in order to allow for inspection of these objections currently used in applications. Patch after that removes a retpoline call for map lookup/update/delete helpers. A new helper is added in the subsequent patch to lookup the skb's socket's cgroup v2 id which can be used in an efficient way for e.g. lookups on egress side. Next one is a fix to fully clear state info in tunnel/xfrm helpers. Given this is full
cap_sys_adminfrom init ns and has same priv requirements like tracing, bpf-next should be okay. A small bug fix forbpf_asmfollows, and next a fix for context access in tracing which was recently reported. Lastly, a small update in the maintainer's file to add patchwork url and missing files.Thanks!
Quoted 7 lines
v2 -> v3:
- Noticed a merge artefact inside uapi header comment, sigh, fixed now.
v1 -> v2:
- minor fix in getting context access work on 32 bit for tracing
- add paragraph to uapi helper doc to better describe kernel build deps for cggroup helper
Applied, Thanks Daniel.
fixed up commit log s/bpftool p d x i/bpftool prog dump xlated id/ while applying, since it was indeed a bit cryptic.