bpf: bpf_{g,s}etsockopt for struct bpf_sock
Subsystems (6)
PATCH v2 1/1 bpf: bpf_{g,s}etsockopt for struct bpf_sock
Currently, bpf_getsocktop and bpf_setsockopt helpers operate on the 'struct bpf_sock_ops' context in BPF_PROG_TYPE_SOCK_OPS program. Let's generalize them and make the first argument be 'struct bpf_sock'. That way, in the future, we can allow those helpers in more places.
BPF_PROG_TYPE_SOCK_OPS still has the existing helpers that operate on 'struct bpf_sock_ops', but we add new bpf_{g,s}etsockopt that work on 'struct bpf_sock'. [Alternatively, for BPF_PROG_TYPE_SOCK_OPS, we can enable them both and teach verifier to pick the right one based on the context (bpf_sock_ops vs bpf_sock).]
As an example, let's allow those 'struct bpf_sock' based helpers to be called from the BPF_CGROUP_INET{4,6}_CONNECT hooks. That way we can override CC before the connection is made.
v2:
* s/BPF_PROG_TYPE_CGROUP_SOCKOPT/BPF_PROG_TYPE_SOCK_OPS/
--- include/uapi/linux/bpf.h | 12 +- net/core/filter.c | 113 ++++++++++++++---- tools/include/uapi/linux/bpf.h | 12 +- tools/testing/selftests/bpf/config | 1 + .../selftests/bpf/progs/connect4_prog.c | 46 +++++++ 5 files changed, 159 insertions(+), 25 deletions(-)
include/uapi/linux/bpf.h +10 -2
@@ -1564,7 +1564,7 @@ union bpf_attr {* Return * 0 * -* int bpf_setsockopt(struct bpf_sock_ops *bpf_socket, int level, int optname, void *optval, int optlen) +* int bpf_setsockopt(void *bpf_socket, int level, int optname, void *optval, int optlen) * Description * Emulate a call to **setsockopt()** on the socket associated to * *bpf_socket*, which must be a full socket. The *level* at
@@ -1572,6 +1572,10 @@ union bpf_attr {* must be specified, see **setsockopt(2)** for more information. * The option value of length *optlen* is pointed by *optval*. * +* *bpf_socket* should be one of the following: +* * **struct bpf_sock_ops** for **BPF_PROG_TYPE_SOCK_OPS**. +* * **struct bpf_sock** for the other types. +* * This helper actually implements a subset of **setsockopt()**. * It supports the following *level*\ s: *
@@ -1766,7 +1770,7 @@ union bpf_attr {* Return * 0 on success, or a negative error in case of failure. * -* int bpf_getsockopt(struct bpf_sock_ops *bpf_socket, int level, int optname, void *optval, int optlen) +* int bpf_getsockopt(void *bpf_socket, int level, int optname, void *optval, int optlen) * Description * Emulate a call to **getsockopt()** on the socket associated to * *bpf_socket*, which must be a full socket. The *level* at
@@ -1775,6 +1779,10 @@ union bpf_attr {* The retrieved value is stored in the structure pointed by * *opval* and of length *optlen*. * +* *bpf_socket* should be one of the following: +* * **struct bpf_sock_ops** for **BPF_PROG_TYPE_SOCK_OPS**. +* * **struct bpf_sock** for the other types. +* * This helper actually implements a subset of **getsockopt()**. * It supports the following *level*\ s: *
net/core/filter.c +92 -21
164 lines not on this page · raw message
tools/include/uapi/linux/bpf.h +10 -2
@@ -1564,7 +1564,7 @@ union bpf_attr {* Return * 0 * -* int bpf_setsockopt(struct bpf_sock_ops *bpf_socket, int level, int optname, void *optval, int optlen) +* int bpf_setsockopt(void *bpf_socket, int level, int optname, void *optval, int optlen) * Description * Emulate a call to **setsockopt()** on the socket associated to * *bpf_socket*, which must be a full socket. The *level* at
@@ -1572,6 +1572,10 @@ union bpf_attr {* must be specified, see **setsockopt(2)** for more information. * The option value of length *optlen* is pointed by *optval*. * +* *bpf_socket* should be one of the following: +* * **struct bpf_sock_ops** for **BPF_PROG_TYPE_SOCK_OPS**. +* * **struct bpf_sock** for the other types. +* * This helper actually implements a subset of **setsockopt()**. * It supports the following *level*\ s: *
@@ -1766,7 +1770,7 @@ union bpf_attr {* Return * 0 on success, or a negative error in case of failure. * -* int bpf_getsockopt(struct bpf_sock_ops *bpf_socket, int level, int optname, void *optval, int optlen) +* int bpf_getsockopt(void *bpf_socket, int level, int optname, void *optval, int optlen) * Description * Emulate a call to **getsockopt()** on the socket associated to * *bpf_socket*, which must be a full socket. The *level* at
@@ -1775,6 +1779,10 @@ union bpf_attr {* The retrieved value is stored in the structure pointed by * *opval* and of length *optlen*. * +* *bpf_socket* should be one of the following: +* * **struct bpf_sock_ops** for **BPF_PROG_TYPE_SOCK_OPS**. +* * **struct bpf_sock** for the other types. +* * This helper actually implements a subset of **getsockopt()**. * It supports the following *level*\ s: *
tools/testing/selftests/bpf/config +1 -0
@@ -37,3 +37,4 @@ CONFIG_IPV6_SIT=m CONFIG_BPF_JIT=y CONFIG_BPF_LSM=y CONFIG_SECURITY=y +CONFIG_TCP_CONG_DCTCP=y
tools/testing/selftests/bpf/progs/connect4_prog.c +46 -0
70 lines not on this page · raw message
Signature · 1 line
2.26.2.303.gf8c07b1a785-goog
Daniel Borkmann
maintainerQuoted 21 lines · Stanislav Fomichev
Currently,
bpf_getsocktopandbpf_setsockopthelpers operate on the 'structbpf_sock_ops' context inBPF_PROG_TYPE_SOCK_OPSprogram. Let's generalize them and make the first argument be 'structbpf_sock'. That way, in the future, we can allow those helpers in more places.
BPF_PROG_TYPE_SOCK_OPSstill has the existing helpers that operate on 'structbpf_sock_ops', but we add new bpf_{g,s}etsockopt that work on 'structbpf_sock'. [Alternatively, forBPF_PROG_TYPE_SOCK_OPS, we can enable them both and teach verifier to pick the right one based on the context (bpf_sock_opsvsbpf_sock).]As an example, let's allow those 'struct
bpf_sock' based helpers to be called from the BPF_CGROUP_INET{4,6}_CONNECT hooks. That way we can override CC before the connection is made.v2:
* s/BPF_PROG_TYPE_CGROUP_SOCKOPT/BPF_PROG_TYPE_SOCK_OPS/Acked-by John Fastabend <[email protected]>Acked-by Martin KaFai Lau <[email protected]>Signed-off-by Stanislav Fomichev <[email protected]>
[...]
Quoted 35 lines
net/core/filter.c +31
-0+BPF_CALL_5(bpf_setsockopt, struct sock *, sk, + int, level, int, optname, char *, optval, int, optlen) +{ +u32 flags =0 ; +return _bpf_setsockopt (sk, level, optname, optval, optlen, flags); +} + +static const struct bpf_func_proto bpf_setsockopt_proto = { + .func = bpf_setsockopt, + .gpl_only = false, + .ret_type =RET_INTEGER , + .arg1_type =ARG_PTR_TO_SOCKET , + .arg2_type =ARG_ANYTHING , + .arg3_type =ARG_ANYTHING , + .arg4_type =ARG_PTR_TO_MEM , + .arg5_type =ARG_CONST_SIZE , +}; + +BPF_CALL_5(bpf_getsockopt, struct sock *, sk, + int, level, int, optname, char *, optval, int, optlen) +{ +return _bpf_getsockopt (sk, level, optname, optval, optlen); +} +static const struct bpf_func_proto bpf_getsockopt_proto = { .func = bpf_getsockopt, .gpl_only = false, .ret_type =RET_INTEGER , + .arg1_type =ARG_PTR_TO_SOCKET , + .arg2_type =ARG_ANYTHING , + .arg3_type =ARG_ANYTHING , + .arg4_type =ARG_PTR_TO_UNINIT_MEM , + .arg5_type =ARG_CONST_SIZE , +}; +
[...]
net/core/filter.c sock_addr_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog) · line 6105
Quoted 9 lines
net/core/filter.c +5
-0@@ -6043,6 +6098,22 @@ sock_addr_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)return &bpf_sk_storage_get_proto;case BPF_FUNC_sk_storage_delete:return &bpf_sk_storage_delete_proto; +case BPF_FUNC_setsockopt: +switch (prog->expected_attach_type) { +case BPF_CGROUP_INET4_CONNECT : +case BPF_CGROUP_INET6_CONNECT : +return &bpf_setsockopt_proto;
Hm, I'm not sure this is safe. In the sock_addr_func_proto() we also have other helpers callable from connect hooks like sk_lookup_{tcp,udp} which return a PTR_TO_SOCKET_OR_NULL, and now we can pass those sockets also into bpf_{get,set}sockopt() helper after lookup to change various sk related stuff but w/o being under lock. Doesn't the sock_owned_by_me() yell here at minimum (I'd expect so)?
Quoted 12 lines
net/core/filter.c +11
-0+default : +return NULL ; + } +case BPF_FUNC_getsockopt: +switch (prog->expected_attach_type) { +case BPF_CGROUP_INET4_CONNECT : +case BPF_CGROUP_INET6_CONNECT : +return &bpf_getsockopt_proto; +default : +return NULL ; + }default :
Quoted 61 lines · Daniel Borkmann
Quoted 21 lines · Stanislav Fomichev
Currently,
bpf_getsocktopandbpf_setsockopthelpers operate on the 'structbpf_sock_ops' context inBPF_PROG_TYPE_SOCK_OPSprogram. Let's generalize them and make the first argument be 'structbpf_sock'. That way, in the future, we can allow those helpers in more places.
BPF_PROG_TYPE_SOCK_OPSstill has the existing helpers that operate on 'structbpf_sock_ops', but we add new bpf_{g,s}etsockopt that work on 'structbpf_sock'. [Alternatively, forBPF_PROG_TYPE_SOCK_OPS, we can enable them both and teach verifier to pick the right one based on the context (bpf_sock_opsvsbpf_sock).]As an example, let's allow those 'struct
bpf_sock' based helpers to be called from the BPF_CGROUP_INET{4,6}_CONNECT hooks. That way we can override CC before the connection is made.v2:
* s/BPF_PROG_TYPE_CGROUP_SOCKOPT/BPF_PROG_TYPE_SOCK_OPS/Acked-by John Fastabend <[email protected]>Acked-by Martin KaFai Lau <[email protected]>Signed-off-by Stanislav Fomichev <[email protected]>[...]
Quoted 35 lines
net/core/filter.c +31
-0+BPF_CALL_5(bpf_setsockopt, struct sock *, sk, + int, level, int, optname, char *, optval, int, optlen) +{ +u32 flags =0 ; +return _bpf_setsockopt (sk, level, optname, optval, optlen, flags); +} + +static const struct bpf_func_proto bpf_setsockopt_proto = { + .func = bpf_setsockopt, + .gpl_only = false, + .ret_type =RET_INTEGER , + .arg1_type =ARG_PTR_TO_SOCKET , + .arg2_type =ARG_ANYTHING , + .arg3_type =ARG_ANYTHING , + .arg4_type =ARG_PTR_TO_MEM , + .arg5_type =ARG_CONST_SIZE , +}; + +BPF_CALL_5(bpf_getsockopt, struct sock *, sk, + int, level, int, optname, char *, optval, int, optlen) +{ +return _bpf_getsockopt (sk, level, optname, optval, optlen); +} +static const struct bpf_func_proto bpf_getsockopt_proto = { .func = bpf_getsockopt, .gpl_only = false, .ret_type =RET_INTEGER , + .arg1_type =ARG_PTR_TO_SOCKET , + .arg2_type =ARG_ANYTHING , + .arg3_type =ARG_ANYTHING , + .arg4_type =ARG_PTR_TO_UNINIT_MEM , + .arg5_type =ARG_CONST_SIZE , +}; +[...]
Review sock_addr_func_proto(enum bpf_func_id func_id,
Quoted 1 line
(quoted diff) +0
-0@@ -6043,6 +6098,22 @@ sock_addr_func_proto(enum bpf_func_id func_id,const struct
bpf_prog*prog)
Quoted 15 lines
net/core/filter.c sock_addr_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog) · line 6105
Quoted 8 lines
net/core/filter.c +5
-0return &bpf_sk_storage_get_proto;case BPF_FUNC_sk_storage_delete:return &bpf_sk_storage_delete_proto; +case BPF_FUNC_setsockopt: +switch (prog->expected_attach_type) { +case BPF_CGROUP_INET4_CONNECT : +case BPF_CGROUP_INET6_CONNECT : +return &bpf_setsockopt_proto;Hm, I'm not sure this is safe. In the
sock_addr_func_proto()we also have other helpers callable from connect hooks like sk_lookup_{tcp,udp} which return aPTR_TO_SOCKET_OR_NULL, and now we can pass those sockets also into bpf_{get,set}sockopt() helper after lookup to change various sk related stuff but w/o being under lock. Doesn't thesock_owned_by_me()yell here at minimum (I'd expect so)?
Ugh, good point, I missed the fact that sk_lookup_{tcp,udp} are there for sock_addr :-( I can try to do a simple test case to verify that sock_owned_by_me triggers, but I'm pretty certain it should (I've been calling bpf_{s,g}etsockopt for context socket so it's quiet).
I don't think there is any helper similar to sock_owned_by_me() that I can call to verify that the socket is held by current thread (without the lockdep splat) and bail out?
In this case, is something like adding new PTR_TO_LOCKED_SOCKET_OR_NULL is the way to go? Any other ideas?
Quoted 85 lines · On Wed, Apr 29, 2020 at 04:33:12PM -0700, [email protected] wrote:
Quoted 71 lines · Daniel Borkmann
Quoted 21 lines · Stanislav Fomichev
Currently,
bpf_getsocktopandbpf_setsockopthelpers operate on the 'structbpf_sock_ops' context inBPF_PROG_TYPE_SOCK_OPSprogram. Let's generalize them and make the first argument be 'structbpf_sock'. That way, in the future, we can allow those helpers in more places.
BPF_PROG_TYPE_SOCK_OPSstill has the existing helpers that operate on 'structbpf_sock_ops', but we add new bpf_{g,s}etsockopt that work on 'structbpf_sock'. [Alternatively, forBPF_PROG_TYPE_SOCK_OPS, we can enable them both and teach verifier to pick the right one based on the context (bpf_sock_opsvsbpf_sock).]As an example, let's allow those 'struct
bpf_sock' based helpers to be called from the BPF_CGROUP_INET{4,6}_CONNECT hooks. That way we can override CC before the connection is made.v2:
* s/BPF_PROG_TYPE_CGROUP_SOCKOPT/BPF_PROG_TYPE_SOCK_OPS/Acked-by John Fastabend <[email protected]>Acked-by Martin KaFai Lau <[email protected]>Signed-off-by Stanislav Fomichev <[email protected]>[...]
Quoted 35 lines
net/core/filter.c +31
-0+BPF_CALL_5(bpf_setsockopt, struct sock *, sk, + int, level, int, optname, char *, optval, int, optlen) +{ +u32 flags =0 ; +return _bpf_setsockopt (sk, level, optname, optval, optlen, flags); +} + +static const struct bpf_func_proto bpf_setsockopt_proto = { + .func = bpf_setsockopt, + .gpl_only = false, + .ret_type =RET_INTEGER , + .arg1_type =ARG_PTR_TO_SOCKET , + .arg2_type =ARG_ANYTHING , + .arg3_type =ARG_ANYTHING , + .arg4_type =ARG_PTR_TO_MEM , + .arg5_type =ARG_CONST_SIZE , +}; + +BPF_CALL_5(bpf_getsockopt, struct sock *, sk, + int, level, int, optname, char *, optval, int, optlen) +{ +return _bpf_getsockopt (sk, level, optname, optval, optlen); +} +static const struct bpf_func_proto bpf_getsockopt_proto = { .func = bpf_getsockopt, .gpl_only = false, .ret_type =RET_INTEGER , + .arg1_type =ARG_PTR_TO_SOCKET , + .arg2_type =ARG_ANYTHING , + .arg3_type =ARG_ANYTHING , + .arg4_type =ARG_PTR_TO_UNINIT_MEM , + .arg5_type =ARG_CONST_SIZE , +}; +[...]
Review sock_addr_func_proto(enum bpf_func_id func_id,
Quoted 1 line
(quoted diff) +0
-0@@ -6043,6 +6098,22 @@ sock_addr_func_proto(enum bpf_func_id func_id,const struct
bpf_prog*prog)net/core/filter.c sock_addr_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog) · line 6105
Quoted 8 lines
net/core/filter.c +5
-0return &bpf_sk_storage_get_proto;case BPF_FUNC_sk_storage_delete:return &bpf_sk_storage_delete_proto; +case BPF_FUNC_setsockopt: +switch (prog->expected_attach_type) { +case BPF_CGROUP_INET4_CONNECT : +case BPF_CGROUP_INET6_CONNECT : +return &bpf_setsockopt_proto;Hm, I'm not sure this is safe. In the
sock_addr_func_proto()we also haveQuoted 8 lines
other helpers callable from connect hooks like sk_lookup_{tcp,udp} which return a
PTR_TO_SOCKET_OR_NULL, and now we can pass those sockets also into
bpf_{get,set}sockopt() helper after lookup to change various sk related stuff
but w/o being under lock. Doesn't thesock_owned_by_me()yell here at minimum
(I'd expect so)?Ugh, good point, I missed the fact that sk_lookup_{tcp,udp} are there for
sock_addr:-( I can try to do a simple test case to verify thatsock_owned_by_metriggers, but I'm pretty certain it should (I've been calling bpf_{s,g}etsockopt for context socket so it's quiet).
Quoted 6 lines
I don't think there is any helper similar to
sock_owned_by_me()that I can call to verify that the socket is held by current thread (without the lockdep splat) and bail out?In this case, is something like adding new
PTR_TO_LOCKED_SOCKET_OR_NULLis the way to go? Any other ideas?
Looks like networking will benefit from sleepable progs too. We could have just did lock_sock() inside bpf_setsockopt before setting cong control.
In the mean time how about introducing try_lock_sock() that will bail out if it cannot grab the lock?
For most practical cases that would work and eventually we can convert it to full lock_sock ?
Daniel Borkmann
maintainerQuoted 93 lines · Alexei Starovoitov
Quoted 85 lines · On Wed, Apr 29, 2020 at 04:33:12PM -0700, [email protected] wrote:
Quoted 71 lines · Daniel Borkmann
Quoted 21 lines · Stanislav Fomichev
Currently,
bpf_getsocktopandbpf_setsockopthelpers operate on the 'structbpf_sock_ops' context inBPF_PROG_TYPE_SOCK_OPSprogram. Let's generalize them and make the first argument be 'structbpf_sock'. That way, in the future, we can allow those helpers in more places.
BPF_PROG_TYPE_SOCK_OPSstill has the existing helpers that operate on 'structbpf_sock_ops', but we add new bpf_{g,s}etsockopt that work on 'structbpf_sock'. [Alternatively, forBPF_PROG_TYPE_SOCK_OPS, we can enable them both and teach verifier to pick the right one based on the context (bpf_sock_opsvsbpf_sock).]As an example, let's allow those 'struct
bpf_sock' based helpers to be called from the BPF_CGROUP_INET{4,6}_CONNECT hooks. That way we can override CC before the connection is made.v2:
* s/BPF_PROG_TYPE_CGROUP_SOCKOPT/BPF_PROG_TYPE_SOCK_OPS/Acked-by John Fastabend <[email protected]>Acked-by Martin KaFai Lau <[email protected]>Signed-off-by Stanislav Fomichev <[email protected]>[...]
Quoted 35 lines
net/core/filter.c +31
-0+BPF_CALL_5(bpf_setsockopt, struct sock *, sk, + int, level, int, optname, char *, optval, int, optlen) +{ +u32 flags =0 ; +return _bpf_setsockopt (sk, level, optname, optval, optlen, flags); +} + +static const struct bpf_func_proto bpf_setsockopt_proto = { + .func = bpf_setsockopt, + .gpl_only = false, + .ret_type =RET_INTEGER , + .arg1_type =ARG_PTR_TO_SOCKET , + .arg2_type =ARG_ANYTHING , + .arg3_type =ARG_ANYTHING , + .arg4_type =ARG_PTR_TO_MEM , + .arg5_type =ARG_CONST_SIZE , +}; + +BPF_CALL_5(bpf_getsockopt, struct sock *, sk, + int, level, int, optname, char *, optval, int, optlen) +{ +return _bpf_getsockopt (sk, level, optname, optval, optlen); +} +static const struct bpf_func_proto bpf_getsockopt_proto = { .func = bpf_getsockopt, .gpl_only = false, .ret_type =RET_INTEGER , + .arg1_type =ARG_PTR_TO_SOCKET , + .arg2_type =ARG_ANYTHING , + .arg3_type =ARG_ANYTHING , + .arg4_type =ARG_PTR_TO_UNINIT_MEM , + .arg5_type =ARG_CONST_SIZE , +}; +[...]
Review sock_addr_func_proto(enum bpf_func_id func_id,
Quoted 1 line
(quoted diff) +0
-0@@ -6043,6 +6098,22 @@ sock_addr_func_proto(enum bpf_func_id func_id,const struct
bpf_prog*prog)net/core/filter.c sock_addr_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog) · line 6105
Quoted 8 lines
net/core/filter.c +5
-0return &bpf_sk_storage_get_proto;case BPF_FUNC_sk_storage_delete:return &bpf_sk_storage_delete_proto; +case BPF_FUNC_setsockopt: +switch (prog->expected_attach_type) { +case BPF_CGROUP_INET4_CONNECT : +case BPF_CGROUP_INET6_CONNECT : +return &bpf_setsockopt_proto;Hm, I'm not sure this is safe. In the
sock_addr_func_proto()we also haveQuoted 8 lines
other helpers callable from connect hooks like sk_lookup_{tcp,udp} which return a
PTR_TO_SOCKET_OR_NULL, and now we can pass those sockets also into
bpf_{get,set}sockopt() helper after lookup to change various sk related stuff
but w/o being under lock. Doesn't thesock_owned_by_me()yell here at minimum
(I'd expect so)?Ugh, good point, I missed the fact that sk_lookup_{tcp,udp} are there for
sock_addr:-( I can try to do a simple test case to verify thatsock_owned_by_metriggers, but I'm pretty certain it should (I've been calling bpf_{s,g}etsockopt for context socket so it's quiet).Quoted 6 lines
I don't think there is any helper similar to
sock_owned_by_me()that I can call to verify that the socket is held by current thread (without the lockdep splat) and bail out?In this case, is something like adding new
PTR_TO_LOCKED_SOCKET_OR_NULLis the way to go? Any other ideas?
Quoted 7 lines
Looks like networking will benefit from sleepable progs too. We could have just did
lock_sock()insidebpf_setsockoptbefore setting cong control.
In the mean time how about introducingtry_lock_sock()that will bail out if it cannot grab the lock?
For most practical cases that would work and eventually we can convert it to fulllock_sock?
Right, also, worst case we could also go back to having ctx as input arg.
Thanks,
Daniel