Skip to contentSkip to conversation

bpf: getsockopt and setsockopt hooks

PATCH Superseded Stanislav Fomichev 4 participants 15 messages Jun 19, 2019 – Jun 21, 2019

Subsystems (11)

v7 of 9 Superseded Latest is v9 →

lore
Share & tools
lore
#0 lore raw

v7 cover bpf: getsockopt and setsockopt hooks

This series implements two new per-cgroup hooks: getsockopt and setsockopt along with a new sockopt program type. The idea is pretty similar to recently introduced cgroup sysctl hooks, but implementation is simpler (no need to convert to/from strings).

What this can be applied to:
* move business logic of what tos/priority/etc can be set by containers (either pass or reject)
* handle existing options (or introduce new ones) differently by propagating some information in cgroup/socket local storage

Compared to a simple syscall/{g,s}etsockopt tracepoint, those hooks are context aware. Meaning, they can access underlying socket and use cgroup and socket local storage.

Stanislav Fomichev (9):
bpf: implement getsockopt and setsockopt hooks
bpf: sync bpf.h to tools/
libbpf: support sockopt hooks
selftests/bpf: test sockopt section name selftests/bpf: add sockopt test
selftests/bpf: add sockopt test that exercises sk helpers selftests/bpf: add sockopt test that exercises BPF_F_ALLOW_MULTI
bpf: add sockopt documentation
bpftool: support cgroup sockopt

 Documentation/bpf/index.rst                   |   1 +
 Documentation/bpf/prog_cgroup_sockopt.rst     |  82 ++
 include/linux/bpf-cgroup.h                    |  43 +
 include/linux/bpf.h                           |   2 +
 include/linux/bpf_types.h                     |   1 +
 include/linux/filter.h                        |  14 +
 include/uapi/linux/bpf.h                      |  14 +
 kernel/bpf/cgroup.c                           | 317 +++++++
 kernel/bpf/core.c                             |   9 +
 kernel/bpf/syscall.c                          |  19 +
 kernel/bpf/verifier.c                         |  13 +
 net/core/filter.c                             |   2 +-
 net/socket.c                                  |  16 +
 .../bpftool/Documentation/bpftool-cgroup.rst  |   7 +-
 .../bpftool/Documentation/bpftool-prog.rst    |   2 +-
 tools/bpf/bpftool/bash-completion/bpftool     |   8 +-
 tools/bpf/bpftool/cgroup.c                    |   5 +-
 tools/bpf/bpftool/main.h                      |   1 +
 tools/bpf/bpftool/prog.c                      |   3 +-
 tools/include/uapi/linux/bpf.h                |  14 +
 tools/lib/bpf/libbpf.c                        |   5 +
 tools/lib/bpf/libbpf_probes.c                 |   1 +
 tools/testing/selftests/bpf/.gitignore        |   3 +
 tools/testing/selftests/bpf/Makefile          |   6 +-
 .../selftests/bpf/progs/sockopt_multi.c       |  53 ++
 .../testing/selftests/bpf/progs/sockopt_sk.c  |  91 ++
 .../selftests/bpf/test_section_names.c        |  10 +
 tools/testing/selftests/bpf/test_sockopt.c    | 892 ++++++++++++++++++
 .../selftests/bpf/test_sockopt_multi.c        | 276 ++++++
 tools/testing/selftests/bpf/test_sockopt_sk.c | 185 ++++
 30 files changed, 2085 insertions(+), 10 deletions(-)
 create mode 100644 Documentation/bpf/prog_cgroup_sockopt.rst
 create mode 100644 tools/testing/selftests/bpf/progs/sockopt_multi.c
 create mode 100644 tools/testing/selftests/bpf/progs/sockopt_sk.c
 create mode 100644 tools/testing/selftests/bpf/test_sockopt.c
 create mode 100644 tools/testing/selftests/bpf/test_sockopt_multi.c
 create mode 100644 tools/testing/selftests/bpf/test_sockopt_sk.c
Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog
#1 lore raw

PATCH v7 1/9 bpf: implement getsockopt and setsockopt hooks

Implement new BPF_PROG_TYPE_CGROUP_SOCKOPT program type and BPF_CGROUP_{G,S}ETSOCKOPT cgroup hooks.

BPF_CGROUP_SETSOCKOPT get a read-only view of the setsockopt arguments. BPF_CGROUP_GETSOCKOPT can modify the supplied buffer.
Both of them reuse existing PTR_TO_PACKET{,_END} infrastructure.

The buffer memory is pre-allocated (because I don't think there is a precedent for working with __user memory from bpf). This might be slow to do for each {s,g}etsockopt call, that's why I've added __cgroup_bpf_prog_array_is_empty that exits early if there is nothing attached to a cgroup. Note, however, that there is a race between __cgroup_bpf_prog_array_is_empty and BPF_PROG_RUN_ARRAY where cgroup program layout might have changed; this should not be a problem because in general there is a race between multiple calls to {s,g}etsocktop and user adding/removing bpf progs from a cgroup.

The return code of the BPF program is handled as follows:
* 0: EPERM
* 1: success, continue with next BPF program in the cgroup chain

v7:
* return only 0 or 1 (Alexei Starovoitov)
* always run all progs (Alexei Starovoitov)
* use optval=0 as kernel bypass in setsockopt (Alexei Starovoitov) (decided to use optval=-1 instead, optval=0 might be a valid input)
* call getsockopt hook after kernel handlers (Alexei Starovoitov)

v6:
* rework cgroup chaining; stop as soon as bpf program returns 0 or 2; see patch with the documentation for the details
* drop Andrii's and Martin's Acked-by (not sure they are comfortable with the new state of things)

v5:
* skip copy_to_user() and put_user() when ret == 0 (Martin Lau)

v4:
* don't export bpf_sk_fullsock helper (Martin Lau)
* size != sizeof(__u64) for uapi pointers (Martin Lau)
* offsetof instead of bpf_ctx_range when checking ctx access (Martin Lau)

v3:
* typos in BPF_PROG_CGROUP_SOCKOPT_RUN_ARRAY comments (Andrii Nakryiko)
* reverse christmas tree in BPF_PROG_CGROUP_SOCKOPT_RUN_ARRAY (Andrii Nakryiko)
* use __bpf_md_ptr instead of __u32 for optval{,_end} (Martin Lau)
* use BPF_FIELD_SIZEOF() for consistency (Martin Lau)
* new CG_SOCKOPT_ACCESS macro to wrap repeated parts

v2:
* moved bpf_sockopt_kern fields around to remove a hole (Martin Lau)
* aligned bpf_sockopt_kern->buf to 8 bytes (Martin Lau)
* bpf_prog_array_is_empty instead of bpf_prog_array_length (Martin Lau)
* added [0,2] return code check to verifier (Martin Lau)
* dropped unused buf[64] from the stack (Martin Lau)
* use PTR_TO_SOCKET for bpf_sockopt->sk (Martin Lau)
* dropped bpf_target_off from ctx rewrites (Martin Lau)
* use return code for kernel bypass (Martin Lau & Andrii Nakryiko)

---
 include/linux/bpf-cgroup.h |  43 +++++
 include/linux/bpf.h        |   2 +
 include/linux/bpf_types.h  |   1 +
 include/linux/filter.h     |  14 ++
 include/uapi/linux/bpf.h   |  14 ++
 kernel/bpf/cgroup.c        | 317 +++++++++++++++++++++++++++++++++++++
 kernel/bpf/core.c          |   9 ++
 kernel/bpf/syscall.c       |  19 +++
 kernel/bpf/verifier.c      |  13 ++
 net/core/filter.c          |   2 +-
 net/socket.c               |  16 ++
 11 files changed, 449 insertions(+), 1 deletion(-)
include/linux/bpf-cgroup.h +43 -0
index b631ee75762d..84bc98ecaa59 100644
@@ -124,6 +124,14 @@ int __cgroup_bpf_run_filter_sysctl(struct ctl_table_header *head,
 				   loff_t *ppos, void **new_buf,
 				   enum bpf_attach_type type);
 
+int __cgroup_bpf_run_filter_setsockopt(struct sock *sock, int level,
+				       int optname, char __user *optval,
+				       unsigned int optlen);
+int __cgroup_bpf_run_filter_getsockopt(struct sock *sk, int level,
+				       int optname, char __user *optval,
+				       int __user *optlen, int max_optlen,
+				       int retval);
+
 static inline enum bpf_cgroup_storage_type cgroup_storage_type(
 	struct bpf_map *map)
 {
@@ -280,6 +288,36 @@ int bpf_percpu_cgroup_storage_update(struct bpf_map *map, void *key,
 	__ret;								       \
 })
 
+#define BPF_CGROUP_RUN_PROG_SETSOCKOPT(sock, level, optname, optval, optlen)   \
+({									       \
+	int __ret = 0;							       \
+	if (cgroup_bpf_enabled)						       \
+		__ret = __cgroup_bpf_run_filter_setsockopt(sock, level,	       \
+							   optname, optval,    \
+							   optlen);	       \
+	__ret;								       \
+})
+
+#define BPF_CGROUP_GETSOCKOPT_MAX_OPTLEN(optlen)			       \
+({									       \
+	int __ret = 0;							       \
+	if (cgroup_bpf_enabled)						       \
+		get_user(__ret, optlen);				       \
+	__ret;								       \
+})
+
+#define BPF_CGROUP_RUN_PROG_GETSOCKOPT(sock, level, optname, optval, optlen,   \
+				       max_optlen, retval)		       \
+({									       \
+	int __ret = retval;						       \
+	if (cgroup_bpf_enabled)						       \
+		__ret = __cgroup_bpf_run_filter_getsockopt(sock, level,	       \
+							   optname, optval,    \
+							   optlen, max_optlen, \
+							   retval);	       \
+	__ret;								       \
+})
+
 int cgroup_bpf_prog_attach(const union bpf_attr *attr,
 			   enum bpf_prog_type ptype, struct bpf_prog *prog);
 int cgroup_bpf_prog_detach(const union bpf_attr *attr,
@@ -349,6 +387,11 @@ static inline int bpf_percpu_cgroup_storage_update(struct bpf_map *map,
 #define BPF_CGROUP_RUN_PROG_SOCK_OPS(sock_ops) ({ 0; })
 #define BPF_CGROUP_RUN_PROG_DEVICE_CGROUP(type,major,minor,access) ({ 0; })
 #define BPF_CGROUP_RUN_PROG_SYSCTL(head,table,write,buf,count,pos,nbuf) ({ 0; })
+#define BPF_CGROUP_GETSOCKOPT_MAX_OPTLEN(optlen) ({ 0; })
+#define BPF_CGROUP_RUN_PROG_GETSOCKOPT(sock, level, optname, optval, \
+				       optlen, max_optlen, retval) (retval)
+#define BPF_CGROUP_RUN_PROG_SETSOCKOPT(sock, level, optname, optval, \
+				       optlen) ({ 0; })
 
 #define for_each_cgroup_storage_type(stype) for (; false; )
 
include/linux/bpf.h +2 -0
index b15fb5fcb741..c9d4625831f2 100644
@@ -521,6 +521,7 @@ struct bpf_prog_array {
 struct bpf_prog_array *bpf_prog_array_alloc(u32 prog_cnt, gfp_t flags);
 void bpf_prog_array_free(struct bpf_prog_array *progs);
 int bpf_prog_array_length(struct bpf_prog_array *progs);
+bool bpf_prog_array_is_empty(struct bpf_prog_array *array);
 int bpf_prog_array_copy_to_user(struct bpf_prog_array *progs,
 				__u32 __user *prog_ids, u32 cnt);
 
@@ -1055,6 +1056,7 @@ extern const struct bpf_func_proto bpf_spin_unlock_proto;
 extern const struct bpf_func_proto bpf_get_local_storage_proto;
 extern const struct bpf_func_proto bpf_strtol_proto;
 extern const struct bpf_func_proto bpf_strtoul_proto;
+extern const struct bpf_func_proto bpf_tcp_sock_proto;
 
 /* Shared helpers among cBPF and eBPF. */
 void bpf_user_rnd_init_once(void);
include/linux/bpf_types.h +1 -0
index 5a9975678d6f..eec5aeeeaf92 100644
@@ -30,6 +30,7 @@ BPF_PROG_TYPE(BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE, raw_tracepoint_writable)
 #ifdef CONFIG_CGROUP_BPF
 BPF_PROG_TYPE(BPF_PROG_TYPE_CGROUP_DEVICE, cg_dev)
 BPF_PROG_TYPE(BPF_PROG_TYPE_CGROUP_SYSCTL, cg_sysctl)
+BPF_PROG_TYPE(BPF_PROG_TYPE_CGROUP_SOCKOPT, cg_sockopt)
 #endif
 #ifdef CONFIG_BPF_LIRC_MODE2
 BPF_PROG_TYPE(BPF_PROG_TYPE_LIRC_MODE2, lirc_mode2)
include/linux/filter.h +14 -0
index 43b45d6db36d..f4274f6337f0 100644
@@ -1199,4 +1199,18 @@ struct bpf_sysctl_kern {
 	u64 tmp_reg;
 };
 
+struct bpf_sockopt_kern {
+	struct sock	*sk;
+	u8		*optval;
+	u8		*optval_end;
+	s32		level;
+	s32		optname;
+	u32		optlen;
+	s32		retval;
+
+	/* Small on-stack optval buffer to avoid small allocations.
+	 */
+	u8 buf[64] __aligned(8);
+};
+
 #endif /* __LINUX_FILTER_H__ */
include/uapi/linux/bpf.h +14 -0
index d0a23476f887..67059b4c663f 100644
@@ -170,6 +170,7 @@ enum bpf_prog_type {
 	BPF_PROG_TYPE_FLOW_DISSECTOR,
 	BPF_PROG_TYPE_CGROUP_SYSCTL,
 	BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE,
+	BPF_PROG_TYPE_CGROUP_SOCKOPT,
 };
 
 enum bpf_attach_type {
@@ -192,6 +193,8 @@ enum bpf_attach_type {
 	BPF_LIRC_MODE2,
 	BPF_FLOW_DISSECTOR,
 	BPF_CGROUP_SYSCTL,
+	BPF_CGROUP_GETSOCKOPT,
+	BPF_CGROUP_SETSOCKOPT,
 	__MAX_BPF_ATTACH_TYPE
 };
 
@@ -3539,4 +3542,15 @@ struct bpf_sysctl {
 				 */
 };
 
+struct bpf_sockopt {
+	__bpf_md_ptr(struct bpf_sock *, sk);
+	__bpf_md_ptr(void *, optval);
+	__bpf_md_ptr(void *, optval_end);
+
+	__s32	level;
+	__s32	optname;
+	__u32	optlen;
+	__s32	retval;
+};
+
 #endif /* _UAPI__LINUX_BPF_H__ */
kernel/bpf/cgroup.c +317 -0

332 lines not on this page · raw message

kernel/bpf/core.c +9 -0
index 33fb292f2e30..e9152ebd66bc 100644
@@ -1813,6 +1813,15 @@ int bpf_prog_array_length(struct bpf_prog_array *array)
 	return cnt;
 }
 
+bool bpf_prog_array_is_empty(struct bpf_prog_array *array)
+{
+	struct bpf_prog_array_item *item;
+
+	for (item = array->items; item->prog; item++)
+		if (item->prog != &dummy_bpf_prog.prog)
+			return false;
+	return true;
+}
 
 static bool bpf_prog_array_copy_core(struct bpf_prog_array *array,
 				     u32 *prog_ids,
kernel/bpf/syscall.c +19 -0
index 4c53cbd3329d..4ad2b5f1905f 100644
@@ -1596,6 +1596,14 @@ bpf_prog_load_check_attach_type(enum bpf_prog_type prog_type,
 		default:
 			return -EINVAL;
 		}
+	case BPF_PROG_TYPE_CGROUP_SOCKOPT:
+		switch (expected_attach_type) {
+		case BPF_CGROUP_SETSOCKOPT:
+		case BPF_CGROUP_GETSOCKOPT:
+			return 0;
+		default:
+			return -EINVAL;
+		}
 	default:
 		return 0;
 	}
@@ -1846,6 +1854,7 @@ static int bpf_prog_attach_check_attach_type(const struct bpf_prog *prog,
 	switch (prog->type) {
 	case BPF_PROG_TYPE_CGROUP_SOCK:
 	case BPF_PROG_TYPE_CGROUP_SOCK_ADDR:
+	case BPF_PROG_TYPE_CGROUP_SOCKOPT:
 		return attach_type == prog->expected_attach_type ? 0 : -EINVAL;
 	case BPF_PROG_TYPE_CGROUP_SKB:
 		return prog->enforce_expected_attach_type &&
@@ -1916,6 +1925,10 @@ static int bpf_prog_attach(const union bpf_attr *attr)
 	case BPF_CGROUP_SYSCTL:
 		ptype = BPF_PROG_TYPE_CGROUP_SYSCTL;
 		break;
+	case BPF_CGROUP_GETSOCKOPT:
+	case BPF_CGROUP_SETSOCKOPT:
+		ptype = BPF_PROG_TYPE_CGROUP_SOCKOPT;
+		break;
 	default:
 		return -EINVAL;
 	}
@@ -1997,6 +2010,10 @@ static int bpf_prog_detach(const union bpf_attr *attr)
 	case BPF_CGROUP_SYSCTL:
 		ptype = BPF_PROG_TYPE_CGROUP_SYSCTL;
 		break;
+	case BPF_CGROUP_GETSOCKOPT:
+	case BPF_CGROUP_SETSOCKOPT:
+		ptype = BPF_PROG_TYPE_CGROUP_SOCKOPT;
+		break;
 	default:
 		return -EINVAL;
 	}
@@ -2031,6 +2048,8 @@ static int bpf_prog_query(const union bpf_attr *attr,
 	case BPF_CGROUP_SOCK_OPS:
 	case BPF_CGROUP_DEVICE:
 	case BPF_CGROUP_SYSCTL:
+	case BPF_CGROUP_GETSOCKOPT:
+	case BPF_CGROUP_SETSOCKOPT:
 		break;
 	case BPF_LIRC_MODE2:
 		return lirc_prog_query(attr, uattr);
kernel/bpf/verifier.c +13 -0
index 8d1786357a09..95ce6cea2e23 100644
@@ -1720,6 +1720,18 @@ static bool may_access_direct_pkt_data(struct bpf_verifier_env *env,
 
 		env->seen_direct_write = true;
 		return true;
+
+	case BPF_PROG_TYPE_CGROUP_SOCKOPT:
+		if (t == BPF_WRITE) {
+			if (env->prog->expected_attach_type ==
+			    BPF_CGROUP_GETSOCKOPT) {
+				env->seen_direct_write = true;
+				return true;
+			}
+			return false;
+		}
+		return true;
+
 	default:
 		return false;
 	}
@@ -5540,6 +5552,7 @@ static int check_return_code(struct bpf_verifier_env *env)
 	case BPF_PROG_TYPE_SOCK_OPS:
 	case BPF_PROG_TYPE_CGROUP_DEVICE:
 	case BPF_PROG_TYPE_CGROUP_SYSCTL:
+	case BPF_PROG_TYPE_CGROUP_SOCKOPT:
 		break;
 	default:
 		return 0;
net/core/filter.c +1 -1
index 8c18f2781afa..e2ad8144cf6e 100644
@@ -5636,7 +5636,7 @@ BPF_CALL_1(bpf_tcp_sock, struct sock *, sk)
 	return (unsigned long)NULL;
 }
 
-static const struct bpf_func_proto bpf_tcp_sock_proto = {
+const struct bpf_func_proto bpf_tcp_sock_proto = {
 	.func		= bpf_tcp_sock,
 	.gpl_only	= false,
 	.ret_type	= RET_PTR_TO_TCP_SOCK_OR_NULL,
net/socket.c +16 -0
index 72372dc5dd70..79eb12016685 100644
@@ -2069,6 +2069,15 @@ static int __sys_setsockopt(int fd, int level, int optname,
 		if (err)
 			goto out_put;
 
+		err = BPF_CGROUP_RUN_PROG_SETSOCKOPT(sock->sk, level, optname,
+						     optval, optlen);
+		if (err < 0) {
+			goto out_put;
+		} else if (err > 0) {
+			err = 0;
+			goto out_put;
+		}
+
 		if (level == SOL_SOCKET)
 			err =
 			    sock_setsockopt(sock, level, optname, optval,
@@ -2099,6 +2108,7 @@ static int __sys_getsockopt(int fd, int level, int optname,
 {
 	int err, fput_needed;
 	struct socket *sock;
+	int max_optlen;
 
 	sock = sockfd_lookup_light(fd, &err, &fput_needed);
 	if (sock != NULL) {
@@ -2106,6 +2116,8 @@ static int __sys_getsockopt(int fd, int level, int optname,
 		if (err)
 			goto out_put;
 
+		max_optlen = BPF_CGROUP_GETSOCKOPT_MAX_OPTLEN(optlen);
+
 		if (level == SOL_SOCKET)
 			err =
 			    sock_getsockopt(sock, level, optname, optval,
@@ -2114,6 +2126,10 @@ static int __sys_getsockopt(int fd, int level, int optname,
 			err =
 			    sock->ops->getsockopt(sock, level, optname, optval,
 						  optlen);
+
+		err = BPF_CGROUP_RUN_PROG_GETSOCKOPT(sock->sk, level, optname,
+						     optval, optlen,
+						     max_optlen, err);
 out_put:
 		fput_light(sock->file, fput_needed);
 	}
Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog
#2 lore raw

Re: [PATCH bpf-next v7 1/9] bpf: implement getsockopt and setsockopt hooks

Quoted 29 lines · Stanislav Fomichev

Implement new BPF_PROG_TYPE_CGROUP_SOCKOPT program type and BPF_CGROUP_{G,S}ETSOCKOPT cgroup hooks.

BPF_CGROUP_SETSOCKOPT get a read-only view of the setsockopt arguments. BPF_CGROUP_GETSOCKOPT can modify the supplied buffer.
Both of them reuse existing PTR_TO_PACKET{,_END} infrastructure.

The buffer memory is pre-allocated (because I don't think there is a precedent for working with __user memory from bpf). This might be slow to do for each {s,g}etsockopt call, that's why I've added __cgroup_bpf_prog_array_is_empty that exits early if there is nothing attached to a cgroup. Note, however, that there is a race between __cgroup_bpf_prog_array_is_empty and BPF_PROG_RUN_ARRAY where cgroup program layout might have changed; this should not be a problem because in general there is a race between multiple calls to {s,g}etsocktop and user adding/removing bpf progs from a cgroup.

The return code of the BPF program is handled as follows:
* 0: EPERM
* 1: success, continue with next BPF program in the cgroup chain

v7:
* return only 0 or 1 (Alexei Starovoitov)
* always run all progs (Alexei Starovoitov)
* use optval=0 as kernel bypass in setsockopt (Alexei Starovoitov) (decided to use optval=-1 instead, optval=0 might be a valid input)
* call getsockopt hook after kernel handlers (Alexei Starovoitov)

Quoted 5 lines

v6:
* rework cgroup chaining; stop as soon as bpf program returns 0 or 2; see patch with the documentation for the details
* drop Andrii's and Martin's Acked-by (not sure they are comfortable with the new state of things)

I like the general approach, just overall unclear about seemingly artificial restrictions I mentioned below.

Quoted 30 lines

v5:
* skip copy_to_user() and put_user() when ret == 0 (Martin Lau)

v4:
* don't export bpf_sk_fullsock helper (Martin Lau)
* size != sizeof(__u64) for uapi pointers (Martin Lau)
* offsetof instead of bpf_ctx_range when checking ctx access (Martin Lau)

v3:
* typos in BPF_PROG_CGROUP_SOCKOPT_RUN_ARRAY comments (Andrii Nakryiko)
* reverse christmas tree in BPF_PROG_CGROUP_SOCKOPT_RUN_ARRAY (Andrii Nakryiko)
* use __bpf_md_ptr instead of __u32 for optval{,_end} (Martin Lau)
* use BPF_FIELD_SIZEOF() for consistency (Martin Lau)
* new CG_SOCKOPT_ACCESS macro to wrap repeated parts

v2:
* moved bpf_sockopt_kern fields around to remove a hole (Martin Lau)
* aligned bpf_sockopt_kern->buf to 8 bytes (Martin Lau)
* bpf_prog_array_is_empty instead of bpf_prog_array_length (Martin Lau)
* added [0,2] return code check to verifier (Martin Lau)
* dropped unused buf[64] from the stack (Martin Lau)
* use PTR_TO_SOCKET for bpf_sockopt->sk (Martin Lau)
* dropped bpf_target_off from ctx rewrites (Martin Lau)
* use return code for kernel bypass (Martin Lau & Andrii Nakryiko)

---

<snip>

include/linux/filter.h struct bpf_sysctl_kern { · line 1208

Quoted 8 lines
include/linux/filter.h +7 -0
+struct bpf_sockopt_kern {
+       struct sock     *sk;
+       u8              *optval;
+       u8              *optval_end;
+       s32             level;
+       s32             optname;
+       u32             optlen;

Optlen is used below as signed integer, so switch it to s32?

Quoted 7 lines
include/linux/filter.h +7 -0
+       s32             retval;
+
+       /* Small on-stack optval buffer to avoid small allocations.
+        */
+       u8 buf[64] __aligned(8);
+};
+

<snip>

include/uapi/linux/bpf.h struct bpf_sysctl { · line 3552

Quoted 9 lines
include/uapi/linux/bpf.h +8 -0
+struct bpf_sockopt {
+       __bpf_md_ptr(struct bpf_sock *, sk);
+       __bpf_md_ptr(void *, optval);
+       __bpf_md_ptr(void *, optval_end);
+
+       __s32   level;
+       __s32   optname;
+       __u32   optlen;

Same as above, we expect BPF program to be able to set it to -1, so __s32?

Quoted 5 lines
include/uapi/linux/bpf.h +3 -0
+       __s32   retval;
+};
+
 #endif /* _UAPI__LINUX_BPF_H__ */
kernel/bpf/cgroup.c +0 -0

<snip>

kernel/bpf/cgroup.c int __cgroup_bpf_run_filter_sysctl(struct ctl_table_header *head, · line 1014

Quoted 10 lines
kernel/bpf/cgroup.c +10 -0
+
+       if (ctx.optlen == -1)
+               /* optlen set to -1, bypass kernel */
+               ret = 1;
+       else if (ctx.optlen == optlen)
+               /* optlen not changed, run kernel handler */
+               ret = 0;
+       else
+               /* any other value is rejected */
+               ret = -EFAULT;

I'm consufed about this assymetry between getsockopt and setsockopt behavior. Why we are disallowing setsockopt from changing optlen (and value itself)? Is there any harm in allowing that? Imagining some use case that provides transparent "support" for some option, you'd need to be able to intercept and provide custom values both for setsockopt and getsockopt. So unless I'm missing some security implications, why not make both sides able to write?

Similar will apply w.r.t. retval, why can't setsockopt return EINVAL to reject some options? This seems very useful and very similar to what sysctl BPF hooks do.

Quoted 12 lines
kernel/bpf/cgroup.c +12 -0
+
+out:
+       sockopt_free_buf(&ctx);
+       return ret;
+}
+EXPORT_SYMBOL(__cgroup_bpf_run_filter_setsockopt);
+
+int __cgroup_bpf_run_filter_getsockopt(struct sock *sk, int level,
+                                      int optname, char __user *optval,
+                                      int __user *optlen, int max_optlen,
+                                      int retval)
+{

<snip>

kernel/bpf/cgroup.c int __cgroup_bpf_run_filter_sysctl(struct ctl_table_header *head, · line 1088

Quoted 10 lines
kernel/bpf/cgroup.c +10 -0
+
+       if (ctx.optlen > max_optlen) {
+               ret = -EFAULT;
+               goto out;
+       }
+
+       /* BPF programs only allowed to set retval to 0, not some
+        * arbitrary value.
+        */
+       if (ctx.retval != 0 && ctx.retval != retval) {

Lookin at manpage of getsockopt, seems like at least two error codes are relevant and generally useful for BPF program to be able to
return: EINVAL and ENOPROTOOPT? Why we are disallowing anything but 0 (or preserving original retval)?

Quoted 18 lines
kernel/bpf/cgroup.c +18 -0
+               ret = -EFAULT;
+               goto out;
+       }
+
+       if (copy_to_user(optval, ctx.optval, ctx.optlen) ||
+           put_user(ctx.optlen, optlen)) {
+               ret = -EFAULT;
+               goto out;
+       }
+
+       ret = ctx.retval;
+
+out:
+       sockopt_free_buf(&ctx);
+       return ret;
+}
+EXPORT_SYMBOL(__cgroup_bpf_run_filter_getsockopt);
+

<snip>

#3 lore raw

Re: [PATCH bpf-next v7 1/9] bpf: implement getsockopt and setsockopt hooks

Quoted 81 lines · Andrii Nakryiko
Quoted 29 lines · Stanislav Fomichev

Implement new BPF_PROG_TYPE_CGROUP_SOCKOPT program type and BPF_CGROUP_{G,S}ETSOCKOPT cgroup hooks.

BPF_CGROUP_SETSOCKOPT get a read-only view of the setsockopt arguments. BPF_CGROUP_GETSOCKOPT can modify the supplied buffer.
Both of them reuse existing PTR_TO_PACKET{,_END} infrastructure.

The buffer memory is pre-allocated (because I don't think there is a precedent for working with __user memory from bpf). This might be slow to do for each {s,g}etsockopt call, that's why I've added __cgroup_bpf_prog_array_is_empty that exits early if there is nothing attached to a cgroup. Note, however, that there is a race between __cgroup_bpf_prog_array_is_empty and BPF_PROG_RUN_ARRAY where cgroup program layout might have changed; this should not be a problem because in general there is a race between multiple calls to {s,g}etsocktop and user adding/removing bpf progs from a cgroup.

The return code of the BPF program is handled as follows:
* 0: EPERM
* 1: success, continue with next BPF program in the cgroup chain

v7:
* return only 0 or 1 (Alexei Starovoitov)
* always run all progs (Alexei Starovoitov)
* use optval=0 as kernel bypass in setsockopt (Alexei Starovoitov) (decided to use optval=-1 instead, optval=0 might be a valid input)
* call getsockopt hook after kernel handlers (Alexei Starovoitov)

Quoted 5 lines

v6:
* rework cgroup chaining; stop as soon as bpf program returns 0 or 2; see patch with the documentation for the details
* drop Andrii's and Martin's Acked-by (not sure they are comfortable with the new state of things)

I like the general approach, just overall unclear about seemingly artificial restrictions I mentioned below.

Quoted 30 lines

v5:
* skip copy_to_user() and put_user() when ret == 0 (Martin Lau)

v4:
* don't export bpf_sk_fullsock helper (Martin Lau)
* size != sizeof(__u64) for uapi pointers (Martin Lau)
* offsetof instead of bpf_ctx_range when checking ctx access (Martin Lau)

v3:
* typos in BPF_PROG_CGROUP_SOCKOPT_RUN_ARRAY comments (Andrii Nakryiko)
* reverse christmas tree in BPF_PROG_CGROUP_SOCKOPT_RUN_ARRAY (Andrii Nakryiko)
* use __bpf_md_ptr instead of __u32 for optval{,_end} (Martin Lau)
* use BPF_FIELD_SIZEOF() for consistency (Martin Lau)
* new CG_SOCKOPT_ACCESS macro to wrap repeated parts

v2:
* moved bpf_sockopt_kern fields around to remove a hole (Martin Lau)
* aligned bpf_sockopt_kern->buf to 8 bytes (Martin Lau)
* bpf_prog_array_is_empty instead of bpf_prog_array_length (Martin Lau)
* added [0,2] return code check to verifier (Martin Lau)
* dropped unused buf[64] from the stack (Martin Lau)
* use PTR_TO_SOCKET for bpf_sockopt->sk (Martin Lau)
* dropped bpf_target_off from ctx rewrites (Martin Lau)
* use return code for kernel bypass (Martin Lau & Andrii Nakryiko)

---

<snip>

include/linux/filter.h struct bpf_sysctl_kern { · line 1208

Quoted 8 lines
include/linux/filter.h +7 -0
+struct bpf_sockopt_kern {
+       struct sock     *sk;
+       u8              *optval;
+       u8              *optval_end;
+       s32             level;
+       s32             optname;
+       u32             optlen;
Quoted 1 line

Optlen is used below as signed integer, so switch it to s32?

Good catch, should be s32 here and below, thanks!

Quoted 41 lines
Quoted 7 lines
include/linux/filter.h +7 -0
+       s32             retval;
+
+       /* Small on-stack optval buffer to avoid small allocations.
+        */
+       u8 buf[64] __aligned(8);
+};
+

<snip>

include/uapi/linux/bpf.h struct bpf_sysctl { · line 3552

Quoted 9 lines
include/uapi/linux/bpf.h +8 -0
+struct bpf_sockopt {
+       __bpf_md_ptr(struct bpf_sock *, sk);
+       __bpf_md_ptr(void *, optval);
+       __bpf_md_ptr(void *, optval_end);
+
+       __s32   level;
+       __s32   optname;
+       __u32   optlen;

Same as above, we expect BPF program to be able to set it to -1, so __s32?

Quoted 5 lines
include/uapi/linux/bpf.h +3 -0
+       __s32   retval;
+};
+
 #endif /* _UAPI__LINUX_BPF_H__ */
kernel/bpf/cgroup.c +0 -0

<snip>

kernel/bpf/cgroup.c int __cgroup_bpf_run_filter_sysctl(struct ctl_table_header *head, · line 1014

Quoted 10 lines
kernel/bpf/cgroup.c +10 -0
+
+       if (ctx.optlen == -1)
+               /* optlen set to -1, bypass kernel */
+               ret = 1;
+       else if (ctx.optlen == optlen)
+               /* optlen not changed, run kernel handler */
+               ret = 0;
+       else
+               /* any other value is rejected */
+               ret = -EFAULT;
Quoted 7 lines

I'm consufed about this assymetry between getsockopt and setsockopt behavior. Why we are disallowing setsockopt from changing optlen (and value itself)? Is there any harm in allowing that? Imagining some use case that provides transparent "support" for some option, you'd need to be able to intercept and provide custom values both for setsockopt and getsockopt. So unless I'm missing some security implications, why not make both sides able to write?

Because kernel setsockopt handlers use get_user to read the data. We can definitely allow changing optval+optlen, but we'd have to copy that data back to userspace to let kernel handle it. I'm not sure how userspace might feel about it. Can it be a buffer in the readonly elf section?

Quoted 3 lines

Similar will apply w.r.t. retval, why can't setsockopt return EINVAL to reject some options? This seems very useful and very similar to what sysctl BPF hooks do.

I was just being defensive because I'm not sure what's the use-case. We can already return EPERM, why do we need to return a different error code? Are we comfortable letting progs return arbitrary number? Or you just want to allow a bunch of pre-defined error codes?

I haven't seen the ability to return arbitrary error from the sysctl hooks, but maybe I didn't look hard enough.

Quoted 15 lines
Quoted 12 lines
kernel/bpf/cgroup.c +12 -0
+
+out:
+       sockopt_free_buf(&ctx);
+       return ret;
+}
+EXPORT_SYMBOL(__cgroup_bpf_run_filter_setsockopt);
+
+int __cgroup_bpf_run_filter_getsockopt(struct sock *sk, int level,
+                                      int optname, char __user *optval,
+                                      int __user *optlen, int max_optlen,
+                                      int retval)
+{

<snip>

Quoted 15 lines

kernel/bpf/cgroup.c int __cgroup_bpf_run_filter_sysctl(struct ctl_table_header *head, · line 1088

Quoted 10 lines
kernel/bpf/cgroup.c +10 -0
+
+       if (ctx.optlen > max_optlen) {
+               ret = -EFAULT;
+               goto out;
+       }
+
+       /* BPF programs only allowed to set retval to 0, not some
+        * arbitrary value.
+        */
+       if (ctx.retval != 0 && ctx.retval != retval) {

Lookin at manpage of getsockopt, seems like at least two error codes are relevant and generally useful for BPF program to be able to
return: EINVAL and ENOPROTOOPT? Why we are disallowing anything but 0 (or preserving original retval)?

I was thinking about simple use-case where it's either BPF that handles the opt or the kernel. And then it's BFP returning success or EPERM. I don't think I understand why BPF needs to be able to return different error codes. We can certainly do that if you think that it makes sense; alternatively, we can start with 0 or kernel retval and relax the requirements if someone really needs that in the future.

(I don't have a strong opinion here tbh).

Quoted 20 lines
Quoted 18 lines
kernel/bpf/cgroup.c +18 -0
+               ret = -EFAULT;
+               goto out;
+       }
+
+       if (copy_to_user(optval, ctx.optval, ctx.optlen) ||
+           put_user(ctx.optlen, optlen)) {
+               ret = -EFAULT;
+               goto out;
+       }
+
+       ret = ctx.retval;
+
+out:
+       sockopt_free_buf(&ctx);
+       return ret;
+}
+EXPORT_SYMBOL(__cgroup_bpf_run_filter_getsockopt);
+

<snip>

#4 lore raw

Re: [PATCH bpf-next v7 1/9] bpf: implement getsockopt and setsockopt hooks

Quoted 134 lines · Stanislav Fomichev
Quoted 81 lines · Andrii Nakryiko
Quoted 29 lines · Stanislav Fomichev

Implement new BPF_PROG_TYPE_CGROUP_SOCKOPT program type and BPF_CGROUP_{G,S}ETSOCKOPT cgroup hooks.

BPF_CGROUP_SETSOCKOPT get a read-only view of the setsockopt arguments. BPF_CGROUP_GETSOCKOPT can modify the supplied buffer.
Both of them reuse existing PTR_TO_PACKET{,_END} infrastructure.

The buffer memory is pre-allocated (because I don't think there is a precedent for working with __user memory from bpf). This might be slow to do for each {s,g}etsockopt call, that's why I've added __cgroup_bpf_prog_array_is_empty that exits early if there is nothing attached to a cgroup. Note, however, that there is a race between __cgroup_bpf_prog_array_is_empty and BPF_PROG_RUN_ARRAY where cgroup program layout might have changed; this should not be a problem because in general there is a race between multiple calls to {s,g}etsocktop and user adding/removing bpf progs from a cgroup.

The return code of the BPF program is handled as follows:
* 0: EPERM
* 1: success, continue with next BPF program in the cgroup chain

v7:
* return only 0 or 1 (Alexei Starovoitov)
* always run all progs (Alexei Starovoitov)
* use optval=0 as kernel bypass in setsockopt (Alexei Starovoitov) (decided to use optval=-1 instead, optval=0 might be a valid input)
* call getsockopt hook after kernel handlers (Alexei Starovoitov)

Quoted 5 lines

v6:
* rework cgroup chaining; stop as soon as bpf program returns 0 or 2; see patch with the documentation for the details
* drop Andrii's and Martin's Acked-by (not sure they are comfortable with the new state of things)

I like the general approach, just overall unclear about seemingly artificial restrictions I mentioned below.

Quoted 30 lines

v5:
* skip copy_to_user() and put_user() when ret == 0 (Martin Lau)

v4:
* don't export bpf_sk_fullsock helper (Martin Lau)
* size != sizeof(__u64) for uapi pointers (Martin Lau)
* offsetof instead of bpf_ctx_range when checking ctx access (Martin Lau)

v3:
* typos in BPF_PROG_CGROUP_SOCKOPT_RUN_ARRAY comments (Andrii Nakryiko)
* reverse christmas tree in BPF_PROG_CGROUP_SOCKOPT_RUN_ARRAY (Andrii Nakryiko)
* use __bpf_md_ptr instead of __u32 for optval{,_end} (Martin Lau)
* use BPF_FIELD_SIZEOF() for consistency (Martin Lau)
* new CG_SOCKOPT_ACCESS macro to wrap repeated parts

v2:
* moved bpf_sockopt_kern fields around to remove a hole (Martin Lau)
* aligned bpf_sockopt_kern->buf to 8 bytes (Martin Lau)
* bpf_prog_array_is_empty instead of bpf_prog_array_length (Martin Lau)
* added [0,2] return code check to verifier (Martin Lau)
* dropped unused buf[64] from the stack (Martin Lau)
* use PTR_TO_SOCKET for bpf_sockopt->sk (Martin Lau)
* dropped bpf_target_off from ctx rewrites (Martin Lau)
* use return code for kernel bypass (Martin Lau & Andrii Nakryiko)

---

<snip>

include/linux/filter.h struct bpf_sysctl_kern { · line 1208

Quoted 8 lines
include/linux/filter.h +7 -0
+struct bpf_sockopt_kern {
+       struct sock     *sk;
+       u8              *optval;
+       u8              *optval_end;
+       s32             level;
+       s32             optname;
+       u32             optlen;
Quoted 1 line

Optlen is used below as signed integer, so switch it to s32?

Good catch, should be s32 here and below, thanks!

Quoted 41 lines
Quoted 7 lines
include/linux/filter.h +7 -0
+       s32             retval;
+
+       /* Small on-stack optval buffer to avoid small allocations.
+        */
+       u8 buf[64] __aligned(8);
+};
+

<snip>

include/uapi/linux/bpf.h struct bpf_sysctl { · line 3552

Quoted 9 lines
include/uapi/linux/bpf.h +8 -0
+struct bpf_sockopt {
+       __bpf_md_ptr(struct bpf_sock *, sk);
+       __bpf_md_ptr(void *, optval);
+       __bpf_md_ptr(void *, optval_end);
+
+       __s32   level;
+       __s32   optname;
+       __u32   optlen;

Same as above, we expect BPF program to be able to set it to -1, so __s32?

Quoted 5 lines
include/uapi/linux/bpf.h +3 -0
+       __s32   retval;
+};
+
 #endif /* _UAPI__LINUX_BPF_H__ */
kernel/bpf/cgroup.c +0 -0

<snip>

kernel/bpf/cgroup.c int __cgroup_bpf_run_filter_sysctl(struct ctl_table_header *head, · line 1014

Quoted 10 lines
kernel/bpf/cgroup.c +10 -0
+
+       if (ctx.optlen == -1)
+               /* optlen set to -1, bypass kernel */
+               ret = 1;
+       else if (ctx.optlen == optlen)
+               /* optlen not changed, run kernel handler */
+               ret = 0;
+       else
+               /* any other value is rejected */
+               ret = -EFAULT;
Quoted 7 lines

I'm consufed about this assymetry between getsockopt and setsockopt behavior. Why we are disallowing setsockopt from changing optlen (and value itself)? Is there any harm in allowing that? Imagining some use case that provides transparent "support" for some option, you'd need to be able to intercept and provide custom values both for setsockopt and getsockopt. So unless I'm missing some security implications, why not make both sides able to write?

Quoted 5 lines

Because kernel setsockopt handlers use get_user to read the data. We can definitely allow changing optval+optlen, but we'd have to copy that data back to userspace to let kernel handle it. I'm not sure how userspace might feel about it. Can it be a buffer in the readonly elf section?

Ah, ok, now I see why :) Yeah, I guess it can be in read-only section. Alright, I don't see an easy solution to that, I guess we can live with that for now.

Quoted 11 lines
Quoted 4 lines

Similar will apply w.r.t. retval, why can't setsockopt return EINVAL to reject some options? This seems very useful and very similar to what sysctl BPF hooks do.

I was just being defensive because I'm not sure what's the use-case. We can already return EPERM, why do we need to return a different error code? Are we comfortable letting progs return arbitrary number? Or you just want to allow a bunch of pre-defined error codes?

I haven't seen the ability to return arbitrary error from the sysctl hooks, but maybe I didn't look hard enough.

Yeah, seems like sysctl is only 0 or EPERM. I missed for a moment that there is return value from BPF program and retval from the context. I think it's good enough as is.

Quoted 31 lines
Quoted 16 lines
Quoted 13 lines
kernel/bpf/cgroup.c +12 -0
+
+out:
+       sockopt_free_buf(&ctx);
+       return ret;
+}
+EXPORT_SYMBOL(__cgroup_bpf_run_filter_setsockopt);
+
+int __cgroup_bpf_run_filter_getsockopt(struct sock *sk, int level,
+                                      int optname, char __user *optval,
+                                      int __user *optlen, int max_optlen,
+                                      int retval)
+{

<snip>

Quoted 15 lines

kernel/bpf/cgroup.c int __cgroup_bpf_run_filter_sysctl(struct ctl_table_header *head, · line 1088

Quoted 10 lines
kernel/bpf/cgroup.c +10 -0
+
+       if (ctx.optlen > max_optlen) {
+               ret = -EFAULT;
+               goto out;
+       }
+
+       /* BPF programs only allowed to set retval to 0, not some
+        * arbitrary value.
+        */
+       if (ctx.retval != 0 && ctx.retval != retval) {

Lookin at manpage of getsockopt, seems like at least two error codes are relevant and generally useful for BPF program to be able to
return: EINVAL and ENOPROTOOPT? Why we are disallowing anything but 0 (or preserving original retval)?

Quoted 8 lines

I was thinking about simple use-case where it's either BPF that handles the opt or the kernel. And then it's BFP returning success or EPERM. I don't think I understand why BPF needs to be able to return different error codes. We can certainly do that if you think that it makes sense; alternatively, we can start with 0 or kernel retval and relax the requirements if someone really needs that in the future.

(I don't have a strong opinion here tbh).

As replied above, EPERM is probably good enough for practical purposes, I was being a bit pedantic :)

Quoted 21 lines
Quoted 21 lines
Quoted 19 lines
kernel/bpf/cgroup.c +18 -0
+               ret = -EFAULT;
+               goto out;
+       }
+
+       if (copy_to_user(optval, ctx.optval, ctx.optlen) ||
+           put_user(ctx.optlen, optlen)) {
+               ret = -EFAULT;
+               goto out;
+       }
+
+       ret = ctx.retval;
+
+out:
+       sockopt_free_buf(&ctx);
+       return ret;
+}
+EXPORT_SYMBOL(__cgroup_bpf_run_filter_getsockopt);
+

<snip>

#5 lore raw

Re: [PATCH bpf-next v7 1/9] bpf: implement getsockopt and setsockopt hooks

Quoted 199 lines · Andrii Nakryiko
Quoted 134 lines · Stanislav Fomichev
Quoted 81 lines · Andrii Nakryiko
Quoted 29 lines · Stanislav Fomichev

Implement new BPF_PROG_TYPE_CGROUP_SOCKOPT program type and BPF_CGROUP_{G,S}ETSOCKOPT cgroup hooks.

BPF_CGROUP_SETSOCKOPT get a read-only view of the setsockopt arguments. BPF_CGROUP_GETSOCKOPT can modify the supplied buffer.
Both of them reuse existing PTR_TO_PACKET{,_END} infrastructure.

The buffer memory is pre-allocated (because I don't think there is a precedent for working with __user memory from bpf). This might be slow to do for each {s,g}etsockopt call, that's why I've added __cgroup_bpf_prog_array_is_empty that exits early if there is nothing attached to a cgroup. Note, however, that there is a race between __cgroup_bpf_prog_array_is_empty and BPF_PROG_RUN_ARRAY where cgroup program layout might have changed; this should not be a problem because in general there is a race between multiple calls to {s,g}etsocktop and user adding/removing bpf progs from a cgroup.

The return code of the BPF program is handled as follows:
* 0: EPERM
* 1: success, continue with next BPF program in the cgroup chain

v7:
* return only 0 or 1 (Alexei Starovoitov)
* always run all progs (Alexei Starovoitov)
* use optval=0 as kernel bypass in setsockopt (Alexei Starovoitov) (decided to use optval=-1 instead, optval=0 might be a valid input)
* call getsockopt hook after kernel handlers (Alexei Starovoitov)

Quoted 5 lines

v6:
* rework cgroup chaining; stop as soon as bpf program returns 0 or 2; see patch with the documentation for the details
* drop Andrii's and Martin's Acked-by (not sure they are comfortable with the new state of things)

I like the general approach, just overall unclear about seemingly artificial restrictions I mentioned below.

Quoted 30 lines

v5:
* skip copy_to_user() and put_user() when ret == 0 (Martin Lau)

v4:
* don't export bpf_sk_fullsock helper (Martin Lau)
* size != sizeof(__u64) for uapi pointers (Martin Lau)
* offsetof instead of bpf_ctx_range when checking ctx access (Martin Lau)

v3:
* typos in BPF_PROG_CGROUP_SOCKOPT_RUN_ARRAY comments (Andrii Nakryiko)
* reverse christmas tree in BPF_PROG_CGROUP_SOCKOPT_RUN_ARRAY (Andrii Nakryiko)
* use __bpf_md_ptr instead of __u32 for optval{,_end} (Martin Lau)
* use BPF_FIELD_SIZEOF() for consistency (Martin Lau)
* new CG_SOCKOPT_ACCESS macro to wrap repeated parts

v2:
* moved bpf_sockopt_kern fields around to remove a hole (Martin Lau)
* aligned bpf_sockopt_kern->buf to 8 bytes (Martin Lau)
* bpf_prog_array_is_empty instead of bpf_prog_array_length (Martin Lau)
* added [0,2] return code check to verifier (Martin Lau)
* dropped unused buf[64] from the stack (Martin Lau)
* use PTR_TO_SOCKET for bpf_sockopt->sk (Martin Lau)
* dropped bpf_target_off from ctx rewrites (Martin Lau)
* use return code for kernel bypass (Martin Lau & Andrii Nakryiko)

---

<snip>

include/linux/filter.h struct bpf_sysctl_kern { · line 1208

Quoted 8 lines
include/linux/filter.h +7 -0
+struct bpf_sockopt_kern {
+       struct sock     *sk;
+       u8              *optval;
+       u8              *optval_end;
+       s32             level;
+       s32             optname;
+       u32             optlen;
Quoted 1 line

Optlen is used below as signed integer, so switch it to s32?

Good catch, should be s32 here and below, thanks!

Quoted 41 lines
Quoted 7 lines
include/linux/filter.h +7 -0
+       s32             retval;
+
+       /* Small on-stack optval buffer to avoid small allocations.
+        */
+       u8 buf[64] __aligned(8);
+};
+

<snip>

include/uapi/linux/bpf.h struct bpf_sysctl { · line 3552

Quoted 9 lines
include/uapi/linux/bpf.h +8 -0
+struct bpf_sockopt {
+       __bpf_md_ptr(struct bpf_sock *, sk);
+       __bpf_md_ptr(void *, optval);
+       __bpf_md_ptr(void *, optval_end);
+
+       __s32   level;
+       __s32   optname;
+       __u32   optlen;

Same as above, we expect BPF program to be able to set it to -1, so __s32?

Quoted 5 lines
include/uapi/linux/bpf.h +3 -0
+       __s32   retval;
+};
+
 #endif /* _UAPI__LINUX_BPF_H__ */
kernel/bpf/cgroup.c +0 -0

<snip>

kernel/bpf/cgroup.c int __cgroup_bpf_run_filter_sysctl(struct ctl_table_header *head, · line 1014

Quoted 10 lines
kernel/bpf/cgroup.c +10 -0
+
+       if (ctx.optlen == -1)
+               /* optlen set to -1, bypass kernel */
+               ret = 1;
+       else if (ctx.optlen == optlen)
+               /* optlen not changed, run kernel handler */
+               ret = 0;
+       else
+               /* any other value is rejected */
+               ret = -EFAULT;
Quoted 7 lines

I'm consufed about this assymetry between getsockopt and setsockopt behavior. Why we are disallowing setsockopt from changing optlen (and value itself)? Is there any harm in allowing that? Imagining some use case that provides transparent "support" for some option, you'd need to be able to intercept and provide custom values both for setsockopt and getsockopt. So unless I'm missing some security implications, why not make both sides able to write?

Quoted 5 lines

Because kernel setsockopt handlers use get_user to read the data. We can definitely allow changing optval+optlen, but we'd have to copy that data back to userspace to let kernel handle it. I'm not sure how userspace might feel about it. Can it be a buffer in the readonly elf section?

Ah, ok, now I see why :) Yeah, I guess it can be in read-only section. Alright, I don't see an easy solution to that, I guess we can live with that for now.

Quoted 11 lines
Quoted 4 lines

Similar will apply w.r.t. retval, why can't setsockopt return EINVAL to reject some options? This seems very useful and very similar to what sysctl BPF hooks do.

I was just being defensive because I'm not sure what's the use-case. We can already return EPERM, why do we need to return a different error code? Are we comfortable letting progs return arbitrary number? Or you just want to allow a bunch of pre-defined error codes?

I haven't seen the ability to return arbitrary error from the sysctl hooks, but maybe I didn't look hard enough.

Yeah, seems like sysctl is only 0 or EPERM. I missed for a moment that there is return value from BPF program and retval from the context. I think it's good enough as is.

Quoted 38 lines
Quoted 16 lines
Quoted 13 lines
kernel/bpf/cgroup.c +12 -0
+
+out:
+       sockopt_free_buf(&ctx);
+       return ret;
+}
+EXPORT_SYMBOL(__cgroup_bpf_run_filter_setsockopt);
+
+int __cgroup_bpf_run_filter_getsockopt(struct sock *sk, int level,
+                                      int optname, char __user *optval,
+                                      int __user *optlen, int max_optlen,
+                                      int retval)
+{

<snip>

Quoted 15 lines

kernel/bpf/cgroup.c int __cgroup_bpf_run_filter_sysctl(struct ctl_table_header *head, · line 1088

Quoted 10 lines
kernel/bpf/cgroup.c +10 -0
+
+       if (ctx.optlen > max_optlen) {
+               ret = -EFAULT;
+               goto out;
+       }
+
+       /* BPF programs only allowed to set retval to 0, not some
+        * arbitrary value.
+        */
+       if (ctx.retval != 0 && ctx.retval != retval) {

Lookin at manpage of getsockopt, seems like at least two error codes are relevant and generally useful for BPF program to be able to
return: EINVAL and ENOPROTOOPT? Why we are disallowing anything but 0 (or preserving original retval)?

I was thinking about simple use-case where it's either BPF that handles the opt or the kernel. And then it's BFP returning success or EPERM. I don't think I understand why BPF needs to be able to return different error codes. We can certainly do that if you think that it makes sense; alternatively, we can start with 0 or kernel retval and relax the requirements if someone really needs that in the future.

Quoted 4 lines
Quoted 1 line

(I don't have a strong opinion here tbh).

As replied above, EPERM is probably good enough for practical purposes, I was being a bit pedantic :)

Sounds good! I was also debating whether to allow BPF programs to set arbitrary retval, but didn't find any good example on why we need it :-)

Quoted 20 lines
Quoted 20 lines
Quoted 20 lines
Quoted 18 lines
kernel/bpf/cgroup.c +18 -0
+               ret = -EFAULT;
+               goto out;
+       }
+
+       if (copy_to_user(optval, ctx.optval, ctx.optlen) ||
+           put_user(ctx.optlen, optlen)) {
+               ret = -EFAULT;
+               goto out;
+       }
+
+       ret = ctx.retval;
+
+out:
+       sockopt_free_buf(&ctx);
+       return ret;
+}
+EXPORT_SYMBOL(__cgroup_bpf_run_filter_getsockopt);
+

<snip>

#6 lore raw

Re: [PATCH bpf-next v7 1/9] bpf: implement getsockopt and setsockopt hooks

In reply to Stanislav Fomichev
Thank you for the patch! Perhaps something to improve:

Hi Stanislav,

Thank you for the patch! Perhaps something to improve:

[auto build test WARNING on bpf-next/master]

url:    https://github.com/0day-ci/linux/commits/Stanislav-Fomichev/bpf-implement-getsockopt-and-setsockopt-hooks/20190621-064924
base:   https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git master
config: arm64-defconfig (attached as .config)
compiler: clang version 9.0.0 (git://gitmirror/llvm_project ca42687d62a81fb09fe0187e5f2788077eb6a841)

reproduce:
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# save the attached .config to linux build tree
make.cross ARCH=arm64

If you fix the issue, kindly add following tag

All warnings (new ones prefixed by >>):

In file included from net/socket.c:109:
In file included from include/net/busy_poll.h:30:
In file included from include/net/ip.h:32:
In file included from include/net/route.h:28:
In file included from include/net/inetpeer.h:16:
include/net/ipv6.h:378:8: warning: explicitly assigning value of variable of type 'struct ipv6_txoptions *' to itself [-Wself-assign]

      opt = (opt);
      ~~~ ^  ~~~
>> net/socket.c:2130:7: warning: explicitly assigning value of variable of type 'int' to itself [-Wself-assign]
     err = (err);
     ~~~ ^  ~~~

2 warnings generated.

vim +/int +2130 net/socket.c

2100
2101 /*
2102 * Get a socket option. Because we don't know the option lengths we have
2103 * to pass a user mode parameter for the protocols to sort out.
2104 */
2105
2106 static int __sys_getsockopt(int fd, int level, int optname,
2107 char __user *optval, int __user *optlen)
2108 {
2109 int err, fput_needed;
2110 struct socket *sock;
2111 int max_optlen;
2112
2113 sock = sockfd_lookup_light(fd, &err, &fput_needed);
2114 if (sock != NULL) {
2115 err = security_socket_getsockopt(sock, level, optname);
2116 if (err)
2117 goto out_put;
2118
2119 max_optlen = BPF_CGROUP_GETSOCKOPT_MAX_OPTLEN(optlen);
2120
2121 if (level == SOL_SOCKET)
2122 err =
2123 sock_getsockopt(sock, level, optname, optval,
2124 optlen);
2125 else
2126 err =
2127 sock->ops->getsockopt(sock, level, optname, optval,
2128 optlen);
2129

> 2130			err = BPF_CGROUP_RUN_PROG_GETSOCKOPT(sock->sk, level, optname,

2131 optval, optlen,
2132 max_optlen, err);
2133 out_put:
2134 fput_light(sock->file, fput_needed);
2135 }
2136 return err;
2137 }
2138

---
0-DAY kernel test infrastructure Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all Intel Corporation

#7 lore raw

PATCH v7 2/9 bpf: sync bpf.h to tools/

In reply to Stanislav Fomichev

Export new prog type and hook points to the libbpf.

---
 tools/include/uapi/linux/bpf.h | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
tools/include/uapi/linux/bpf.h +14 -0
index d0a23476f887..67059b4c663f 100644
@@ -170,6 +170,7 @@ enum bpf_prog_type {
 	BPF_PROG_TYPE_FLOW_DISSECTOR,
 	BPF_PROG_TYPE_CGROUP_SYSCTL,
 	BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE,
+	BPF_PROG_TYPE_CGROUP_SOCKOPT,
 };
 
 enum bpf_attach_type {
@@ -192,6 +193,8 @@ enum bpf_attach_type {
 	BPF_LIRC_MODE2,
 	BPF_FLOW_DISSECTOR,
 	BPF_CGROUP_SYSCTL,
+	BPF_CGROUP_GETSOCKOPT,
+	BPF_CGROUP_SETSOCKOPT,
 	__MAX_BPF_ATTACH_TYPE
 };
 
@@ -3539,4 +3542,15 @@ struct bpf_sysctl {
 				 */
 };
 
+struct bpf_sockopt {
+	__bpf_md_ptr(struct bpf_sock *, sk);
+	__bpf_md_ptr(void *, optval);
+	__bpf_md_ptr(void *, optval_end);
+
+	__s32	level;
+	__s32	optname;
+	__u32	optlen;
+	__s32	retval;
+};
+
 #endif /* _UAPI__LINUX_BPF_H__ */
Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog
#8 lore raw

PATCH v7 3/9 libbpf: support sockopt hooks

In reply to Stanislav Fomichev

Make libbpf aware of new sockopt hooks so it can derive prog type and hook point from the section names.

---
 tools/lib/bpf/libbpf.c        | 5 +++++
 tools/lib/bpf/libbpf_probes.c | 1 +
 2 files changed, 6 insertions(+)
tools/lib/bpf/libbpf.c +5 -0
index e725fa86b189..98457fc6bb76 100644
@@ -2244,6 +2244,7 @@ static bool bpf_prog_type__needs_kver(enum bpf_prog_type type)
 	case BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE:
 	case BPF_PROG_TYPE_PERF_EVENT:
 	case BPF_PROG_TYPE_CGROUP_SYSCTL:
+	case BPF_PROG_TYPE_CGROUP_SOCKOPT:
 		return false;
 	case BPF_PROG_TYPE_KPROBE:
 	default:
@@ -3197,6 +3198,10 @@ static const struct {
 						BPF_CGROUP_UDP6_SENDMSG),
 	BPF_EAPROG_SEC("cgroup/sysctl",		BPF_PROG_TYPE_CGROUP_SYSCTL,
 						BPF_CGROUP_SYSCTL),
+	BPF_EAPROG_SEC("cgroup/getsockopt",	BPF_PROG_TYPE_CGROUP_SOCKOPT,
+						BPF_CGROUP_GETSOCKOPT),
+	BPF_EAPROG_SEC("cgroup/setsockopt",	BPF_PROG_TYPE_CGROUP_SOCKOPT,
+						BPF_CGROUP_SETSOCKOPT),
 };
 
 #undef BPF_PROG_SEC_IMPL
tools/lib/bpf/libbpf_probes.c +1 -0
index 5e2aa83f637a..7e21db11dde8 100644
@@ -101,6 +101,7 @@ probe_load(enum bpf_prog_type prog_type, const struct bpf_insn *insns,
 	case BPF_PROG_TYPE_SK_REUSEPORT:
 	case BPF_PROG_TYPE_FLOW_DISSECTOR:
 	case BPF_PROG_TYPE_CGROUP_SYSCTL:
+	case BPF_PROG_TYPE_CGROUP_SOCKOPT:
 	default:
 		break;
 	}
Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog
#9 lore raw

PATCH v7 4/9 selftests/bpf: test sockopt section name

In reply to Stanislav Fomichev

Add tests that make sure libbpf section detection works.

---
 tools/testing/selftests/bpf/test_section_names.c | 10 ++++++++++
 1 file changed, 10 insertions(+)
tools/testing/selftests/bpf/test_section_names.c +10 -0
index bebd4fbca1f4..5f84b3b8c90b 100644
@@ -124,6 +124,16 @@ static struct sec_name_test tests[] = {
 		{0, BPF_PROG_TYPE_CGROUP_SYSCTL, BPF_CGROUP_SYSCTL},
 		{0, BPF_CGROUP_SYSCTL},
 	},
+	{
+		"cgroup/getsockopt",
+		{0, BPF_PROG_TYPE_CGROUP_SOCKOPT, BPF_CGROUP_GETSOCKOPT},
+		{0, BPF_CGROUP_GETSOCKOPT},
+	},
+	{
+		"cgroup/setsockopt",
+		{0, BPF_PROG_TYPE_CGROUP_SOCKOPT, BPF_CGROUP_SETSOCKOPT},
+		{0, BPF_CGROUP_SETSOCKOPT},
+	},
 };
 
 static int test_prog_type_by_name(const struct sec_name_test *test)
Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog
#10 lore raw

PATCH v7 5/9 selftests/bpf: add sockopt test

In reply to Stanislav Fomichev

Add sockopt selftests:
* require proper expected_attach_type
* enforce context field read/write access
* test bpf_sockopt_handled handler
* test EPERM
* test limiting optlen from getsockopt
* test out-of-bounds access

v7:
* remove return 2; test retval=0 and optlen=-1

v3:
* use DW for optval{,_end} loads

v2:
* use return code 2 for kernel bypass

---
 tools/testing/selftests/bpf/.gitignore     |   1 +
 tools/testing/selftests/bpf/Makefile       |   3 +-
 tools/testing/selftests/bpf/test_sockopt.c | 892 +++++++++++++++++++++
 3 files changed, 895 insertions(+), 1 deletion(-)
 create mode 100644 tools/testing/selftests/bpf/test_sockopt.c
tools/testing/selftests/bpf/.gitignore +1 -0
index 7470327edcfe..3fe92601223d 100644
@@ -39,3 +39,4 @@ libbpf.so.*
 test_hashmap
 test_btf_dump
 xdping
+test_sockopt
tools/testing/selftests/bpf/Makefile +2 -1
index 44fb61f4d502..4ff4401a4024 100644
@@ -26,7 +26,7 @@ TEST_GEN_PROGS = test_verifier test_tag test_maps test_lru_map test_lpm_map test
 	test_sock test_btf test_sockmap test_lirc_mode2_user get_cgroup_id_user \
 	test_socket_cookie test_cgroup_storage test_select_reuseport test_section_names \
 	test_netcnt test_tcpnotify_user test_sock_fields test_sysctl test_hashmap \
-	test_btf_dump test_cgroup_attach xdping
+	test_btf_dump test_cgroup_attach xdping test_sockopt
 
 BPF_OBJ_FILES = $(patsubst %.c,%.o, $(notdir $(wildcard progs/*.c)))
 TEST_GEN_FILES = $(BPF_OBJ_FILES)
@@ -101,6 +101,7 @@ $(OUTPUT)/test_netcnt: cgroup_helpers.c
 $(OUTPUT)/test_sock_fields: cgroup_helpers.c
 $(OUTPUT)/test_sysctl: cgroup_helpers.c
 $(OUTPUT)/test_cgroup_attach: cgroup_helpers.c
+$(OUTPUT)/test_sockopt: cgroup_helpers.c
 
 .PHONY: force
 
tools/testing/selftests/bpf/test_sockopt.c new file +892 -0

892 lines not on this page · raw message

Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog
#11 lore raw

PATCH v7 6/9 selftests/bpf: add sockopt test that exercises sk helpers

In reply to Stanislav Fomichev

socktop test that introduces new SOL_CUSTOM sockopt level and stores whatever users sets in sk storage. Whenever getsockopt is called, the original value is retrieved.

v7:
* use retval=0 and optlen-1

v6:
* test 'ret=1' use-case as well (Alexei Starovoitov)

v4:
* don't call bpf_sk_fullsock helper

v3:
* drop (__u8 *)(long) casts for optval{,_end}

v2:
* new test

---
 tools/testing/selftests/bpf/.gitignore        |   1 +
 tools/testing/selftests/bpf/Makefile          |   3 +-
 .../testing/selftests/bpf/progs/sockopt_sk.c  |  91 +++++++++
 tools/testing/selftests/bpf/test_sockopt_sk.c | 185 ++++++++++++++++++
 4 files changed, 279 insertions(+), 1 deletion(-)
 create mode 100644 tools/testing/selftests/bpf/progs/sockopt_sk.c
 create mode 100644 tools/testing/selftests/bpf/test_sockopt_sk.c
tools/testing/selftests/bpf/.gitignore +1 -0
index 3fe92601223d..8ac076c311d4 100644
@@ -40,3 +40,4 @@ test_hashmap
 test_btf_dump
 xdping
 test_sockopt
+test_sockopt_sk
tools/testing/selftests/bpf/Makefile +2 -1
index 4ff4401a4024..33aa4f97af28 100644
@@ -26,7 +26,7 @@ TEST_GEN_PROGS = test_verifier test_tag test_maps test_lru_map test_lpm_map test
 	test_sock test_btf test_sockmap test_lirc_mode2_user get_cgroup_id_user \
 	test_socket_cookie test_cgroup_storage test_select_reuseport test_section_names \
 	test_netcnt test_tcpnotify_user test_sock_fields test_sysctl test_hashmap \
-	test_btf_dump test_cgroup_attach xdping test_sockopt
+	test_btf_dump test_cgroup_attach xdping test_sockopt test_sockopt_sk
 
 BPF_OBJ_FILES = $(patsubst %.c,%.o, $(notdir $(wildcard progs/*.c)))
 TEST_GEN_FILES = $(BPF_OBJ_FILES)
@@ -102,6 +102,7 @@ $(OUTPUT)/test_sock_fields: cgroup_helpers.c
 $(OUTPUT)/test_sysctl: cgroup_helpers.c
 $(OUTPUT)/test_cgroup_attach: cgroup_helpers.c
 $(OUTPUT)/test_sockopt: cgroup_helpers.c
+$(OUTPUT)/test_sockopt_sk: cgroup_helpers.c
 
 .PHONY: force
 
tools/testing/selftests/bpf/progs/sockopt_sk.c new file +91 -0

91 lines not on this page · raw message

tools/testing/selftests/bpf/test_sockopt_sk.c new file +185 -0

185 lines not on this page · raw message

Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog
#12 lore raw

PATCH v7 7/9 selftests/bpf: add sockopt test that exercises BPF_F_ALLOW_MULTI

In reply to Stanislav Fomichev

sockopt test that verifies chaining behavior.

v7:
* rework the test to verify cgroup getsockopt chaining

---
 tools/testing/selftests/bpf/.gitignore        |   1 +
 tools/testing/selftests/bpf/Makefile          |   4 +-
 .../selftests/bpf/progs/sockopt_multi.c       |  53 ++++
 .../selftests/bpf/test_sockopt_multi.c        | 276 ++++++++++++++++++
 4 files changed, 333 insertions(+), 1 deletion(-)
 create mode 100644 tools/testing/selftests/bpf/progs/sockopt_multi.c
 create mode 100644 tools/testing/selftests/bpf/test_sockopt_multi.c
tools/testing/selftests/bpf/.gitignore +1 -0
index 8ac076c311d4..a2f7f79c7908 100644
@@ -41,3 +41,4 @@ test_btf_dump
 xdping
 test_sockopt
 test_sockopt_sk
+test_sockopt_multi
tools/testing/selftests/bpf/Makefile +3 -1
index 33aa4f97af28..d3a5b6f9080d 100644
@@ -26,7 +26,8 @@ TEST_GEN_PROGS = test_verifier test_tag test_maps test_lru_map test_lpm_map test
 	test_sock test_btf test_sockmap test_lirc_mode2_user get_cgroup_id_user \
 	test_socket_cookie test_cgroup_storage test_select_reuseport test_section_names \
 	test_netcnt test_tcpnotify_user test_sock_fields test_sysctl test_hashmap \
-	test_btf_dump test_cgroup_attach xdping test_sockopt test_sockopt_sk
+	test_btf_dump test_cgroup_attach xdping test_sockopt test_sockopt_sk \
+	test_sockopt_multi
 
 BPF_OBJ_FILES = $(patsubst %.c,%.o, $(notdir $(wildcard progs/*.c)))
 TEST_GEN_FILES = $(BPF_OBJ_FILES)
@@ -103,6 +104,7 @@ $(OUTPUT)/test_sysctl: cgroup_helpers.c
 $(OUTPUT)/test_cgroup_attach: cgroup_helpers.c
 $(OUTPUT)/test_sockopt: cgroup_helpers.c
 $(OUTPUT)/test_sockopt_sk: cgroup_helpers.c
+$(OUTPUT)/test_sockopt_multi: cgroup_helpers.c
 
 .PHONY: force
 
tools/testing/selftests/bpf/progs/sockopt_multi.c new file +53 -0

53 lines not on this page · raw message

tools/testing/selftests/bpf/test_sockopt_multi.c new file +276 -0

276 lines not on this page · raw message

Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog
#13 lore raw

PATCH v7 8/9 bpf: add sockopt documentation

In reply to Stanislav Fomichev

Provide user documentation about sockopt prog type and cgroup hooks.

v7:
* add description for retval=0 and optlen=-1

v6:
* describe cgroup chaining, add example

v2:
* use return code 2 for kernel bypass

---
 Documentation/bpf/index.rst               |  1 +
 Documentation/bpf/prog_cgroup_sockopt.rst | 82 +++++++++++++++++++++++
 2 files changed, 83 insertions(+)
 create mode 100644 Documentation/bpf/prog_cgroup_sockopt.rst
Documentation/bpf/index.rst +1 -0
index d3fe4cac0c90..801a6ed3f2e5 100644
@@ -42,6 +42,7 @@ Program types
 .. toctree::
    :maxdepth: 1
 
+   prog_cgroup_sockopt
    prog_cgroup_sysctl
    prog_flow_dissector
 
Documentation/bpf/prog_cgroup_sockopt.rst new file +82 -0

82 lines not on this page · raw message

Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog
#14 lore raw

PATCH v7 9/9 bpftool: support cgroup sockopt

In reply to Stanislav Fomichev

Support sockopt prog type and cgroup hooks in the bpftool.

---
 tools/bpf/bpftool/Documentation/bpftool-cgroup.rst | 7 +++++--
 tools/bpf/bpftool/Documentation/bpftool-prog.rst   | 2 +-
 tools/bpf/bpftool/bash-completion/bpftool          | 8 +++++---
 tools/bpf/bpftool/cgroup.c                         | 5 ++++-
 tools/bpf/bpftool/main.h                           | 1 +
 tools/bpf/bpftool/prog.c                           | 3 ++-
 6 files changed, 18 insertions(+), 8 deletions(-)
tools/bpf/bpftool/Documentation/bpftool-cgroup.rst +5 -2
index 36807735e2a5..cac088a320a6 100644
@@ -29,7 +29,8 @@ CGROUP COMMANDS
 |	*PROG* := { **id** *PROG_ID* | **pinned** *FILE* | **tag** *PROG_TAG* }
 |	*ATTACH_TYPE* := { **ingress** | **egress** | **sock_create** | **sock_ops** | **device** |
 |		**bind4** | **bind6** | **post_bind4** | **post_bind6** | **connect4** | **connect6** |
-|		**sendmsg4** | **sendmsg6** | **sysctl** }
+|		**sendmsg4** | **sendmsg6** | **sysctl** | **getsockopt** |
+|		**setsockopt** }
 |	*ATTACH_FLAGS* := { **multi** | **override** }
 
 DESCRIPTION
@@ -86,7 +87,9 @@ DESCRIPTION
 		  unconnected udp4 socket (since 4.18);
 		  **sendmsg6** call to sendto(2), sendmsg(2), sendmmsg(2) for an
 		  unconnected udp6 socket (since 4.18);
-		  **sysctl** sysctl access (since 5.2).
+		  **sysctl** sysctl access (since 5.2);
+		  **getsockopt** call to getsockopt (since 5.3);
+		  **setsockopt** call to setsockopt (since 5.3).
 
 	**bpftool cgroup detach** *CGROUP* *ATTACH_TYPE* *PROG*
 		  Detach *PROG* from the cgroup *CGROUP* and attach type
tools/bpf/bpftool/Documentation/bpftool-prog.rst +1 -1
index 228a5c863cc7..c6bade35032c 100644
@@ -40,7 +40,7 @@ PROG COMMANDS
 |		**lwt_seg6local** | **sockops** | **sk_skb** | **sk_msg** | **lirc_mode2** |
 |		**cgroup/bind4** | **cgroup/bind6** | **cgroup/post_bind4** | **cgroup/post_bind6** |
 |		**cgroup/connect4** | **cgroup/connect6** | **cgroup/sendmsg4** | **cgroup/sendmsg6** |
-|		**cgroup/sysctl**
+|		**cgroup/sysctl** | **cgroup/getsockopt** | **cgroup/setsockopt**
 |	}
 |       *ATTACH_TYPE* := {
 |		**msg_verdict** | **stream_verdict** | **stream_parser** | **flow_dissector**
tools/bpf/bpftool/bash-completion/bpftool +5 -3
index 2725e27dfa42..7afb8b6fbaaa 100644
@@ -378,7 +378,8 @@ _bpftool()
                                 cgroup/connect4 cgroup/connect6 \
                                 cgroup/sendmsg4 cgroup/sendmsg6 \
                                 cgroup/post_bind4 cgroup/post_bind6 \
-                                cgroup/sysctl" -- \
+                                cgroup/sysctl cgroup/getsockopt \
+                                cgroup/setsockopt" -- \
                                                    "$cur" ) )
                             return 0
                             ;;
@@ -688,7 +689,8 @@ _bpftool()
                 attach|detach)
                     local ATTACH_TYPES='ingress egress sock_create sock_ops \
                         device bind4 bind6 post_bind4 post_bind6 connect4 \
-                        connect6 sendmsg4 sendmsg6 sysctl'
+                        connect6 sendmsg4 sendmsg6 sysctl getsockopt \
+                        setsockopt'
                     local ATTACH_FLAGS='multi override'
                     local PROG_TYPE='id pinned tag'
                     case $prev in
@@ -698,7 +700,7 @@ _bpftool()
                             ;;
                         ingress|egress|sock_create|sock_ops|device|bind4|bind6|\
                         post_bind4|post_bind6|connect4|connect6|sendmsg4|\
-                        sendmsg6|sysctl)
+                        sendmsg6|sysctl|getsockopt|setsockopt)
                             COMPREPLY=( $( compgen -W "$PROG_TYPE" -- \
                                 "$cur" ) )
                             return 0
tools/bpf/bpftool/cgroup.c +4 -1
index 7e22f115c8c1..3083f2e4886e 100644
@@ -25,7 +25,8 @@
 	"       ATTACH_TYPE := { ingress | egress | sock_create |\n"	       \
 	"                        sock_ops | device | bind4 | bind6 |\n"	       \
 	"                        post_bind4 | post_bind6 | connect4 |\n"       \
-	"                        connect6 | sendmsg4 | sendmsg6 | sysctl }"
+	"                        connect6 | sendmsg4 | sendmsg6 | sysctl |\n"  \
+	"                        getsockopt | setsockopt }"
 
 static const char * const attach_type_strings[] = {
 	[BPF_CGROUP_INET_INGRESS] = "ingress",
@@ -42,6 +43,8 @@ static const char * const attach_type_strings[] = {
 	[BPF_CGROUP_UDP4_SENDMSG] = "sendmsg4",
 	[BPF_CGROUP_UDP6_SENDMSG] = "sendmsg6",
 	[BPF_CGROUP_SYSCTL] = "sysctl",
+	[BPF_CGROUP_GETSOCKOPT] = "getsockopt",
+	[BPF_CGROUP_SETSOCKOPT] = "setsockopt",
 	[__MAX_BPF_ATTACH_TYPE] = NULL,
 };
 
tools/bpf/bpftool/main.h +1 -0
index 28a2a5857e14..9c5d9c80f71e 100644
@@ -74,6 +74,7 @@ static const char * const prog_type_name[] = {
 	[BPF_PROG_TYPE_SK_REUSEPORT]		= "sk_reuseport",
 	[BPF_PROG_TYPE_FLOW_DISSECTOR]		= "flow_dissector",
 	[BPF_PROG_TYPE_CGROUP_SYSCTL]		= "cgroup_sysctl",
+	[BPF_PROG_TYPE_CGROUP_SOCKOPT]		= "cgroup_sockopt",
 };
 
 extern const char * const map_type_name[];
tools/bpf/bpftool/prog.c +2 -1
index 1f209c80d906..a201e1c83346 100644
@@ -1070,7 +1070,8 @@ static int do_help(int argc, char **argv)
 		"                 sk_reuseport | flow_dissector | cgroup/sysctl |\n"
 		"                 cgroup/bind4 | cgroup/bind6 | cgroup/post_bind4 |\n"
 		"                 cgroup/post_bind6 | cgroup/connect4 | cgroup/connect6 |\n"
-		"                 cgroup/sendmsg4 | cgroup/sendmsg6 }\n"
+		"                 cgroup/sendmsg4 | cgroup/sendmsg6 | cgroup/getsockopt |\n"
+		"                 cgroup/setsockopt }\n"
 		"       ATTACH_TYPE := { msg_verdict | stream_verdict | stream_parser |\n"
 		"                        flow_dissector }\n"
 		"       " HELP_SPEC_OPTIONS "\n"
Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog