bpf: allow rewriting to ports under ip_unprivileged_port_start
Subsystems (6)
PATCH v4 1/2 bpf: allow rewriting to ports under ip_unprivileged_port_start
At the moment, BPF_CGROUP_INET{4,6}_BIND hooks can rewrite user_port to the privileged ones (< ip_unprivileged_port_start), but it will be rejected later on in the __inet_bind or __inet6_bind.
Let's add another return value to indicate that CAP_NET_BIND_SERVICE check should be ignored. Use the same idea as we currently use in cgroup/egress where bit #1 indicates CN. Instead, for cgroup/bind{4,6}, bit #1 indicates that CAP_NET_BIND_SERVICE should be bypassed.
v4:
- Add missing IPv6 support (Martin KaFai Lau)
v3:
- Update description (Martin KaFai Lau)
- Fix capability restore in selftest (Martin KaFai Lau)
v2:
- Switch to explicit return code (Martin KaFai Lau)
--- include/linux/bpf-cgroup.h | 38 ++++++++++++++++++++++++--------- include/linux/bpf.h | 43 ++++++++++++++++++++++---------------- include/net/inet_common.h | 3 +++ kernel/bpf/cgroup.c | 8 +++++-- kernel/bpf/verifier.c | 3 +++ net/ipv4/af_inet.c | 9 +++++--- net/ipv6/af_inet6.c | 9 +++++--- 7 files changed, 77 insertions(+), 36 deletions(-)
include/linux/bpf-cgroup.h +28 -10
@@ -125,7 +125,8 @@ int __cgroup_bpf_run_filter_sk(struct sock *sk,int __cgroup_bpf_run_filter_sock_addr (struct sock *sk,struct sockaddr *uaddr,enum bpf_attach_type type, -void *t_ctx); +void *t_ctx, +u32 *flags); int __cgroup_bpf_run_filter_sock_ops(struct sock *sk, struct bpf_sock_ops_kern *sock_ops,
@@ -231,30 +232,48 @@ int bpf_percpu_cgroup_storage_update(struct bpf_map *map, void *key,#define BPF_CGROUP_RUN_SA_PROG (sk, uaddr, type) \ ({ \ + u32 __unused_flags; \ int __ret = 0; \ if (cgroup_bpf_enabled(type)) \ __ret = __cgroup_bpf_run_filter_sock_addr(sk, uaddr, type, \ - NULL); \ + NULL, \ + &__unused_flags); \ __ret; \ })#define BPF_CGROUP_RUN_SA_PROG_LOCK (sk, uaddr, type, t_ctx) \ ({ \ + u32 __unused_flags; \ int __ret = 0; \ if (cgroup_bpf_enabled(type)) { \ lock_sock(sk); \ __ret = __cgroup_bpf_run_filter_sock_addr(sk, uaddr, type, \ - t_ctx); \ + t_ctx, \ + &__unused_flags); \ release_sock(sk); \ } \ __ret; \ }) -#define BPF_CGROUP_RUN_PROG_INET4_BIND_LOCK (sk, uaddr) \ - BPF_CGROUP_RUN_SA_PROG_LOCK(sk, uaddr, BPF_CGROUP_INET4_BIND, NULL) - -#define BPF_CGROUP_RUN_PROG_INET6_BIND_LOCK (sk, uaddr) \ - BPF_CGROUP_RUN_SA_PROG_LOCK(sk, uaddr, BPF_CGROUP_INET6_BIND, NULL) +/* BPF_CGROUP_INET4_BIND and BPF_CGROUP_INET6_BIND can return extra flags +* via upper bits of return code. The only flag that is supported +* (at bit position 0) is to indicate CAP_NET_BIND_SERVICE capability check +* should be bypassed. +*/ +#define BPF_CGROUP_RUN_PROG_INET_BIND_LOCK (sk, uaddr, type, flags) \ +({ \ + u32 __flags = 0; \ + int __ret = 0; \ + if (cgroup_bpf_enabled(type)) { \ + lock_sock(sk); \ + __ret = __cgroup_bpf_run_filter_sock_addr(sk, uaddr, type, \ + NULL, &__flags); \ + release_sock(sk); \ + if (__flags & 1) \ + *flags |= BIND_NO_CAP_NET_BIND_SERVICE; \ + } \ + __ret; \ +})#define BPF_CGROUP_PRE_CONNECT_ENABLED (sk) \ ((cgroup_bpf_enabled(BPF_CGROUP_INET4_CONNECT) || \
@@ -453,8 +472,7 @@ static inline int bpf_percpu_cgroup_storage_update(struct bpf_map *map,#define BPF_CGROUP_RUN_PROG_INET_EGRESS (sk,skb) ({ 0; })#define BPF_CGROUP_RUN_PROG_INET_SOCK (sk) ({ 0; })#define BPF_CGROUP_RUN_PROG_INET_SOCK_RELEASE (sk) ({ 0; }) -#define BPF_CGROUP_RUN_PROG_INET4_BIND_LOCK (sk, uaddr) ({ 0; }) -#define BPF_CGROUP_RUN_PROG_INET6_BIND_LOCK (sk, uaddr) ({ 0; }) +#define BPF_CGROUP_RUN_PROG_INET_BIND_LOCK (sk, uaddr, type, flags) ({ 0; })#define BPF_CGROUP_RUN_PROG_INET4_POST_BIND (sk) ({ 0; })#define BPF_CGROUP_RUN_PROG_INET6_POST_BIND (sk) ({ 0; })#define BPF_CGROUP_RUN_PROG_INET4_CONNECT (sk, uaddr) ({ 0; })
include/linux/bpf.h +25 -18
56 lines not on this page · raw message
include/net/inet_common.h +3 -0
@@ -41,6 +41,9 @@ int inet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len);#define BIND_WITH_LOCK (1 << 1)/* Called from BPF program. */ #define BIND_FROM_BPF (1 << 2) +/* Skip CAP_NET_BIND_SERVICE check. */ +#define BIND_NO_CAP_NET_BIND_SERVICE (1 << 3) +int __inet_bind (struct sock *sk,struct sockaddr *uaddr,int addr_len,u32 flags); int inet_getname(struct socket *sock, struct sockaddr *uaddr,
kernel/bpf/cgroup.c +6 -2
@@ -1055,6 +1055,8 @@ EXPORT_SYMBOL(__cgroup_bpf_run_filter_sk);* @uaddr: sockaddr struct provided by user * @type: The type of program to be exectuted * @t_ctx: Pointer to attach type specific context +* @flags: Pointer to u32 which contains higher bits of BPF program +* return value (OR'ed together). * * socket is expected to be of type INET or INET6. *
@@ -1064,7 +1066,8 @@ EXPORT_SYMBOL(__cgroup_bpf_run_filter_sk);int __cgroup_bpf_run_filter_sock_addr (struct sock *sk,struct sockaddr *uaddr,enum bpf_attach_type type, -void *t_ctx) +void *t_ctx, +u32 *flags) {struct bpf_sock_addr_kern ctx = { .sk = sk,
@@ -1087,7 +1090,8 @@ int __cgroup_bpf_run_filter_sock_addr(struct sock *sk, } cgrp =sock_cgroup_ptr (&sk->sk_cgrp_data); - ret =BPF_PROG_RUN_ARRAY (cgrp->bpf.effective[type], &ctx,BPF_PROG_RUN ); + ret =BPF_PROG_RUN_ARRAY_FLAGS (cgrp->bpf.effective[type], &ctx, +BPF_PROG_RUN , flags);return ret ==1 ?0 : -EPERM ; }
kernel/bpf/verifier.c +3 -0
@@ -7986,6 +7986,9 @@ static int check_return_code(struct bpf_verifier_env *env) env->prog->expected_attach_type == BPF_CGROUP_INET4_GETSOCKNAME || env->prog->expected_attach_type == BPF_CGROUP_INET6_GETSOCKNAME) range =tnum_range (1 ,1 ); +if (env->prog->expected_attach_type ==BPF_CGROUP_INET4_BIND || + env->prog->expected_attach_type ==BPF_CGROUP_INET6_BIND ) + range =tnum_range (0 ,3 );break ;case BPF_PROG_TYPE_CGROUP_SKB :if (env->prog->expected_attach_type ==BPF_CGROUP_INET_EGRESS ) {
net/ipv4/af_inet.c +6 -3
@@ -438,6 +438,7 @@ EXPORT_SYMBOL(inet_release);int inet_bind (struct socket *sock,struct sockaddr *uaddr,int addr_len) {struct sock *sk = sock->sk; +u32 flags =BIND_WITH_LOCK ;int err;/* If the socket has its own bind function then use it. (RAW) */
@@ -450,11 +451,12 @@ int inet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)/* BPF prog is run before any checks are done so that if the prog * changes context in a wrong way it will be caught. */ - err =BPF_CGROUP_RUN_PROG_INET4_BIND_LOCK (sk, uaddr); + err =BPF_CGROUP_RUN_PROG_INET_BIND_LOCK (sk, uaddr, +BPF_CGROUP_INET4_BIND , &flags);if (err)return err; -return __inet_bind (sk, uaddr, addr_len,BIND_WITH_LOCK ); +return __inet_bind (sk, uaddr, addr_len, flags); }EXPORT_SYMBOL (inet_bind);
@@ -499,7 +501,8 @@ int __inet_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len, snum =ntohs (addr->sin_port); err = -EACCES ; -if (snum &&inet_port_requires_bind_service (net, snum) && +if (!(flags &BIND_NO_CAP_NET_BIND_SERVICE ) && + snum &&inet_port_requires_bind_service (net, snum) && !ns_capable (net->user_ns,CAP_NET_BIND_SERVICE )) goto out;
net/ipv6/af_inet6.c +6 -3
@@ -295,7 +295,8 @@ static int __inet6_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len,return -EINVAL ; snum =ntohs (addr->sin6_port); -if (snum &&inet_port_requires_bind_service (net, snum) && +if (!(flags &BIND_NO_CAP_NET_BIND_SERVICE ) && + snum &&inet_port_requires_bind_service (net, snum) && !ns_capable (net->user_ns,CAP_NET_BIND_SERVICE ))return -EACCES ;
@@ -439,6 +440,7 @@ static int __inet6_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len,int inet6_bind (struct socket *sock,struct sockaddr *uaddr,int addr_len) {struct sock *sk = sock->sk; +u32 flags =BIND_WITH_LOCK ;int err =0 ;/* If the socket has its own bind function then use it. */
@@ -451,11 +453,12 @@ int inet6_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)/* BPF prog is run before any checks are done so that if the prog * changes context in a wrong way it will be caught. */ - err =BPF_CGROUP_RUN_PROG_INET6_BIND_LOCK (sk, uaddr); + err =BPF_CGROUP_RUN_PROG_INET_BIND_LOCK (sk, uaddr, +BPF_CGROUP_INET6_BIND , &flags);if (err)return err; -return __inet6_bind (sk, uaddr, addr_len,BIND_WITH_LOCK ); +return __inet6_bind (sk, uaddr, addr_len, flags); }EXPORT_SYMBOL (inet6_bind);
Signature · 1 line
2.30.0.280.ga3ce27912f-goog
PATCH v4 2/2 selftests/bpf: verify that rebinding to port < 1024 from BPF works
Return 3 to indicate that permission check for port 111 should be skipped.
--- .../selftests/bpf/prog_tests/bind_perm.c | 109 ++++++++++++++++++ tools/testing/selftests/bpf/progs/bind_perm.c | 45 ++++++++ 2 files changed, 154 insertions(+) create mode 100644 tools/testing/selftests/bpf/prog_tests/bind_perm.c create mode 100644 tools/testing/selftests/bpf/progs/bind_perm.c
tools/testing/selftests/bpf/prog_tests/bind_perm.c new file +109 -0
@@ -0,0 +1,109 @@ +// SPDX-License-Identifier: GPL-2.0 +#include <test_progs.h> +#include "bind_perm.skel.h" + +#include <sys/types.h> +#include <sys/socket.h> +#include <sys/capability.h> + +static int duration; + +void try_bind (int family,int port,int expected_errno) +{ +struct sockaddr_storage addr = {}; +struct sockaddr_in6 *sin6; +struct sockaddr_in *sin; +int fd =-1 ; + + fd =socket (family,SOCK_STREAM ,0 ); +if (CHECK (fd <0 ,"fd" ,"errno %d" , errno)) + goto close_socket; + +if (family ==AF_INET ) { + sin = (struct sockaddr_in *)&addr; + sin->sin_family = family; + sin->sin_port =htons (port); + }else { + sin6 = (struct sockaddr_in6 *)&addr; + sin6->sin6_family = family; + sin6->sin6_port =htons (port); + } + + errno =0 ; +bind (fd, (struct sockaddr *)&addr,sizeof (addr)); +ASSERT_EQ (errno, expected_errno,"bind" ); + +close_socket: +if (fd >=0 ) +close (fd); +} + +bool cap_net_bind_service (cap_flag_value_t flag) +{ +const cap_value_t cap_net_bind_service =CAP_NET_BIND_SERVICE ; +cap_flag_value_t original_value; +bool was_effective = false; +cap_t caps; + + caps =cap_get_proc (); +if (CHECK (!caps,"cap_get_proc" ,"errno %d" , errno)) + goto free_caps; + +if (CHECK (cap_get_flag (caps,CAP_NET_BIND_SERVICE ,CAP_EFFECTIVE , + &original_value), +"cap_get_flag" ,"errno %d" , errno)) + goto free_caps; + + was_effective = (original_value ==CAP_SET ); + +if (CHECK (cap_set_flag (caps,CAP_EFFECTIVE ,1 , &cap_net_bind_service, + flag), +"cap_set_flag" ,"errno %d" , errno)) + goto free_caps; + +if (CHECK (cap_set_proc (caps),"cap_set_proc" ,"errno %d" , errno)) + goto free_caps; + +free_caps: +CHECK (cap_free (caps),"cap_free" ,"errno %d" , errno); +return was_effective; +} + +void test_bind_perm (void ) +{ +bool cap_was_effective; +struct bind_perm *skel; +int cgroup_fd; + + cgroup_fd =test__join_cgroup ("/bind_perm" ); +if (CHECK (cgroup_fd <0 ,"cg-join" ,"errno %d" , errno)) +return ; + + skel =bind_perm__open_and_load (); +if (!ASSERT_OK_PTR (skel,"skel" )) + goto close_cgroup_fd; + + skel->links.bind_v4_prog =bpf_program__attach_cgroup (skel->progs.bind_v4_prog, cgroup_fd); +if (!ASSERT_OK_PTR (skel,"bind_v4_prog" )) + goto close_skeleton; + + skel->links.bind_v6_prog =bpf_program__attach_cgroup (skel->progs.bind_v6_prog, cgroup_fd); +if (!ASSERT_OK_PTR (skel,"bind_v6_prog" )) + goto close_skeleton; + + cap_was_effective =cap_net_bind_service (CAP_CLEAR ); + +try_bind (AF_INET ,110 ,EACCES ); +try_bind (AF_INET6 ,110 ,EACCES ); + +try_bind (AF_INET ,111 ,0 ); +try_bind (AF_INET6 ,111 ,0 ); + +if (cap_was_effective) +cap_net_bind_service (CAP_SET ); + +close_skeleton: +bind_perm__destroy (skel); +close_cgroup_fd: +close (cgroup_fd); +}
tools/testing/selftests/bpf/progs/bind_perm.c new file +45 -0
45 lines not on this page · raw message
Signature · 1 line
2.30.0.280.ga3ce27912f-goog
Re: [PATCH bpf-next v4 2/2] selftests/bpf: verify that rebinding to port < 1024 from BPF works
Quoted 2 lines · Stanislav Fomichev
Return 3 to indicate that permission check for port 111 should be skipped.
Quoted 13 lines · Stanislav Fomichev
At the moment, BPF_CGROUP_INET{4,6}_BIND hooks can rewrite
user_portto the privileged ones (<ip_unprivileged_port_start), but it will be rejected later on in the__inet_bindor__inet6_bind.Let's add another return value to indicate that
CAP_NET_BIND_SERVICEcheck should be ignored. Use the same idea as we currently use in cgroup/egress where bit #1 indicates CN. Instead, for cgroup/bind{4,6}, bit #1 indicates thatCAP_NET_BIND_SERVICEshould be bypassed.v4:
- Add missing IPv6 support (Martin KaFai Lau)
Quoted 6 lines
v3:
- Update description (Martin KaFai Lau)
- Fix capability restore in selftest (Martin KaFai Lau)v2:
- Switch to explicit return code (Martin KaFai Lau)
Stanislav Fomichev <[email protected]> [Tue, 2021-01-26 11:36 -0800]:
Quoted 17 lines
At the moment, BPF_CGROUP_INET{4,6}_BIND hooks can rewrite
user_portto the privileged ones (<ip_unprivileged_port_start), but it will be rejected later on in the__inet_bindor__inet6_bind.Let's add another return value to indicate that
CAP_NET_BIND_SERVICEcheck should be ignored. Use the same idea as we currently use in cgroup/egress where bit #1 indicates CN. Instead, for cgroup/bind{4,6}, bit #1 indicates thatCAP_NET_BIND_SERVICEshould be bypassed.v4:
- Add missing IPv6 support (Martin KaFai Lau)v3:
- Update description (Martin KaFai Lau)
- Fix capability restore in selftest (Martin KaFai Lau)
Quoted 6 lines
v2:
- Switch to explicit return code (Martin KaFai Lau)Cc Andrey Ignatov <[email protected]>Cc Martin KaFai Lau <[email protected]>Signed-off-by Stanislav Fomichev <[email protected]>
Explicit return code looks much cleaner than both what v1 did and what I proposed earlier (compare port before/after).
Just one nit from me but otherwide looks good.
...
Quoted 40 lines
include/linux/bpf-cgroup.h +12
-7@@ -231,30 +232,48 @@ int bpf_percpu_cgroup_storage_update(struct bpf_map *map, void *key,#define BPF_CGROUP_RUN_SA_PROG (sk, uaddr, type) \ ({ \ + u32 __unused_flags; \ int __ret = 0; \ if (cgroup_bpf_enabled(type)) \ __ret = __cgroup_bpf_run_filter_sock_addr(sk, uaddr, type, \ - NULL); \ + NULL, \ + &__unused_flags); \ __ret; \ })#define BPF_CGROUP_RUN_SA_PROG_LOCK (sk, uaddr, type, t_ctx) \ ({ \ + u32 __unused_flags; \ int __ret = 0; \ if (cgroup_bpf_enabled(type)) { \ lock_sock(sk); \ __ret = __cgroup_bpf_run_filter_sock_addr(sk, uaddr, type, \ - t_ctx); \ + t_ctx, \ + &__unused_flags); \ release_sock(sk); \ } \ __ret; \ }) -#define BPF_CGROUP_RUN_PROG_INET4_BIND_LOCK (sk, uaddr) \ - BPF_CGROUP_RUN_SA_PROG_LOCK(sk, uaddr, BPF_CGROUP_INET4_BIND, NULL) - -#define BPF_CGROUP_RUN_PROG_INET6_BIND_LOCK (sk, uaddr) \ - BPF_CGROUP_RUN_SA_PROG_LOCK(sk, uaddr, BPF_CGROUP_INET6_BIND, NULL) +/* BPF_CGROUP_INET4_BIND and BPF_CGROUP_INET6_BIND can return extra flags +* via upper bits of return code. The only flag that is supported +* (at bit position 0) is to indicate CAP_NET_BIND_SERVICE capability check +* should be bypassed. +*/ +#define BPF_CGROUP_RUN_PROG_INET_BIND_LOCK (sk, uaddr, type, flags) \
include/linux/bpf-cgroup.h int bpf_percpu_cgroup_storage_update(struct bpf_map *map, void *key, · line 273
Quoted 10 lines
include/linux/bpf-cgroup.h +10
-0+({ \ + u32 __flags = 0; \ + int __ret = 0; \ + if (cgroup_bpf_enabled(type)) { \ + lock_sock(sk); \ + __ret = __cgroup_bpf_run_filter_sock_addr(sk, uaddr, type, \ + NULL, &__flags); \ + release_sock(sk); \ + if (__flags & 1) \ + *flags |= BIND_NO_CAP_NET_BIND_SERVICE; \
Nit: It took me some time to realize that there are two different "flags": one to pass to __cgroup_bpf_run_filter_sock_addr() and another to pass to __inet{,6}_bind/BPF_CGROUP_RUN_PROG_INET_BIND_LOCK that both carry "BIND_NO_CAP_NET_BIND_SERVICE" flag but do it differently:
* hard-coded 0x1 in the former case;
* and BIND_NO_CAP_NET_BIND_SERVICE == (1 << 3) in the latter.
I'm not sure how to make it more readable: maybe name flags and __flags differently to highlight the difference (bind_flags and __flags?) and add a #define for the "1" here?
In anycase IMO it's not worth a respin and can be addressed by a follow-up if you agree.
Quoted 6 lines
include/linux/bpf-cgroup.h +3
-0+ } \ + __ret; \ +})#define BPF_CGROUP_PRE_CONNECT_ENABLED (sk) \ ((cgroup_bpf_enabled(BPF_CGROUP_INET4_CONNECT) || \
Signature · 1 line
Andrey Ignatov
Quoted 92 lines · Andrey Ignatov
Stanislav Fomichev <[email protected]> [Tue, 2021-01-26 11:36 -0800]:
Quoted 17 lines
At the moment, BPF_CGROUP_INET{4,6}_BIND hooks can rewrite
user_portto the privileged ones (<ip_unprivileged_port_start), but it will be rejected later on in the__inet_bindor__inet6_bind.Let's add another return value to indicate that
CAP_NET_BIND_SERVICEcheck should be ignored. Use the same idea as we currently use in cgroup/egress where bit #1 indicates CN. Instead, for cgroup/bind{4,6}, bit #1 indicates thatCAP_NET_BIND_SERVICEshould be bypassed.v4:
- Add missing IPv6 support (Martin KaFai Lau)v3:
- Update description (Martin KaFai Lau)
- Fix capability restore in selftest (Martin KaFai Lau)Quoted 6 lines
v2:
- Switch to explicit return code (Martin KaFai Lau)Cc Andrey Ignatov <[email protected]>Cc Martin KaFai Lau <[email protected]>Signed-off-by Stanislav Fomichev <[email protected]>Explicit return code looks much cleaner than both what v1 did and what I proposed earlier (compare port before/after).
Just one nit from me but otherwide looks good.
Acked-by Andrey Ignatov <[email protected]>...
Quoted 40 lines
include/linux/bpf-cgroup.h +12
-7@@ -231,30 +232,48 @@ int bpf_percpu_cgroup_storage_update(struct bpf_map *map, void *key,#define BPF_CGROUP_RUN_SA_PROG (sk, uaddr, type) \ ({ \ + u32 __unused_flags; \ int __ret = 0; \ if (cgroup_bpf_enabled(type)) \ __ret = __cgroup_bpf_run_filter_sock_addr(sk, uaddr, type, \ - NULL); \ + NULL, \ + &__unused_flags); \ __ret; \ })#define BPF_CGROUP_RUN_SA_PROG_LOCK (sk, uaddr, type, t_ctx) \ ({ \ + u32 __unused_flags; \ int __ret = 0; \ if (cgroup_bpf_enabled(type)) { \ lock_sock(sk); \ __ret = __cgroup_bpf_run_filter_sock_addr(sk, uaddr, type, \ - t_ctx); \ + t_ctx, \ + &__unused_flags); \ release_sock(sk); \ } \ __ret; \ }) -#define BPF_CGROUP_RUN_PROG_INET4_BIND_LOCK (sk, uaddr) \ - BPF_CGROUP_RUN_SA_PROG_LOCK(sk, uaddr, BPF_CGROUP_INET4_BIND, NULL) - -#define BPF_CGROUP_RUN_PROG_INET6_BIND_LOCK (sk, uaddr) \ - BPF_CGROUP_RUN_SA_PROG_LOCK(sk, uaddr, BPF_CGROUP_INET6_BIND, NULL) +/* BPF_CGROUP_INET4_BIND and BPF_CGROUP_INET6_BIND can return extra flags +* via upper bits of return code. The only flag that is supported +* (at bit position 0) is to indicate CAP_NET_BIND_SERVICE capability check +* should be bypassed. +*/ +#define BPF_CGROUP_RUN_PROG_INET_BIND_LOCK (sk, uaddr, type, flags) \include/linux/bpf-cgroup.h int bpf_percpu_cgroup_storage_update(struct bpf_map *map, void *key, · line 273
Quoted 10 lines
include/linux/bpf-cgroup.h +10
-0+({ \ + u32 __flags = 0; \ + int __ret = 0; \ + if (cgroup_bpf_enabled(type)) { \ + lock_sock(sk); \ + __ret = __cgroup_bpf_run_filter_sock_addr(sk, uaddr, type, \ + NULL, &__flags); \ + release_sock(sk); \ + if (__flags & 1) \ + *flags |= BIND_NO_CAP_NET_BIND_SERVICE; \Nit: It took me some time to realize that there are two different "flags": one to pass to
__cgroup_bpf_run_filter_sock_addr()and another to pass to __inet{,6}_bind/BPF_CGROUP_RUN_PROG_INET_BIND_LOCK that both carry "BIND_NO_CAP_NET_BIND_SERVICE" flag but do it differently:
* hard-coded0x1in the former case;
* andBIND_NO_CAP_NET_BIND_SERVICE== (1 << 3) in the latter.
Quoted 6 lines
I'm not sure how to make it more readable: maybe name
flagsand__flagsdifferently to highlight the difference (bind_flagsand__flags?) and add a #define for the "1" here?In anycase IMO it's not worth a respin and can be addressed by a follow-up if you agree.
Yeah, I agree, I didn't stress too much about it because we also have ret and _ret in BPF_PROG_CGROUP_INET_EGRESS_RUN_ARRAY (and now BPF_PROG_RUN_ARRAY_FLAGS), but it looks confusing. Let me respin with bind_flags, shouldn't be too much work and can help with the readability in the future. Thanks for the review!