bpf: export bpf_sock for BPF_PROG_TYPE_CGROUP_SOCK_ADDR prog type
Subsystems (6)
PATCH 1/4 bpf: export bpf_sock for BPF_PROG_TYPE_CGROUP_SOCK_ADDR prog type
And let it use bpf_sk_storage_{get,delete} helpers to access socket storage. Kernel context (struct bpf_sock_addr_kern) already has sk member, so I just expose it to the BPF hooks. Using PTR_TO_SOCKET instead of PTR_TO_SOCK_COMMON should be safe because the hook is called on bind/connect.
--- include/uapi/linux/bpf.h | 1 + net/core/filter.c | 16 ++++++++++++++++ 2 files changed, 17 insertions(+)
include/uapi/linux/bpf.h +1 -0
@@ -3247,6 +3247,7 @@ struct bpf_sock_addr {__u32 msg_src_ip6[4 ];/* Allows 1,2,4-byte read an 4-byte write. * Stored in network byte order. */ + __bpf_md_ptr(struct bpf_sock *, sk); };/* User bpf_sock_ops struct to access socket values and specify request ops
net/core/filter.c +16 -0
@@ -5922,6 +5922,10 @@ sock_addr_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)case BPF_FUNC_skc_lookup_tcp:return &bpf_sock_addr_skc_lookup_tcp_proto;#endif /* CONFIG_INET */ +case BPF_FUNC_sk_storage_get: +return &bpf_sk_storage_get_proto; +case BPF_FUNC_sk_storage_delete: +return &bpf_sk_storage_delete_proto;default :return bpf_base_func_proto (func_id); }
@@ -6828,6 +6832,13 @@ static bool sock_addr_is_valid_access(int off, int size,if (size != size_default)return false;break ; +case offsetof(struct bpf_sock_addr , sk): +if (type !=BPF_READ ) +return false; +if (size !=sizeof (__u64)) +return false; + info->reg_type =PTR_TO_SOCKET ; +break ;default :if (type ==BPF_READ ) {if (size != size_default)
@@ -7778,6 +7789,11 @@ static u32 sock_addr_convert_ctx_access(enum bpf_access_type type, struct bpf_sock_addr_kern, struct in6_addr, t_ctx, s6_addr32[0], BPF_SIZE(si->code), off, tmp_reg);break ; +case offsetof(struct bpf_sock_addr , sk): + *insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF(struct bpf_sock_addr_kern, sk), + si->dst_reg, si->src_reg, + offsetof(struct bpf_sock_addr_kern , sk)); +break ; }return insn - insn_buf;
Signature · 1 line
2.22.0.rc2.383.gf4fbbf30c2-goog
PATCH 2/4 bpf: export bpf_sock for BPF_PROG_TYPE_SOCK_OPS prog type
And let it use bpf_sk_storage_{get,delete} helpers to access socket storage. Kernel context (struct bpf_sock_ops_kern) already has sk member, so I just expose it to the BPF hooks. I use PTR_TO_SOCKET_OR_NULL and return NULL in !is_fullsock case.
I also export bpf_tcp_sock to make it possible to access tcp socket stats.
--- include/uapi/linux/bpf.h | 1 + net/core/filter.c | 26 ++++++++++++++++++++++++++ 2 files changed, 27 insertions(+)
include/uapi/linux/bpf.h +1 -0
@@ -3299,6 +3299,7 @@ struct bpf_sock_ops {__u32 sk_txhash;__u64 bytes_received;__u64 bytes_acked; + __bpf_md_ptr(struct bpf_sock *, sk); };/* Definitions for bpf_sock_ops_cb_flags */
net/core/filter.c +26 -0
@@ -6147,6 +6147,14 @@ sock_ops_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)return &bpf_get_local_storage_proto;case BPF_FUNC_perf_event_output:return &bpf_sockopt_event_output_proto; +case BPF_FUNC_sk_storage_get: +return &bpf_sk_storage_get_proto; +case BPF_FUNC_sk_storage_delete: +return &bpf_sk_storage_delete_proto; +#ifdef CONFIG_INET +case BPF_FUNC_tcp_sock: +return &bpf_tcp_sock_proto; +#endif /* CONFIG_INET */ default :return bpf_base_func_proto (func_id); }
@@ -6882,6 +6890,11 @@ static bool sock_ops_is_valid_access(int off, int size,if (size !=sizeof (__u64))return false;break ; +case offsetof(struct bpf_sock_ops , sk): +if (size !=sizeof (__u64)) +return false; + info->reg_type =PTR_TO_SOCKET_OR_NULL ; +break ;default :if (size != size_default)return false;
@@ -8053,6 +8066,19 @@ static u32 sock_ops_convert_ctx_access(enum bpf_access_type type,SOCK_OPS_GET_OR_SET_FIELD (sk_txhash, sk_txhash, struct sock, type);break ; +case offsetof(struct bpf_sock_ops , sk): + *insn++ =BPF_LDX_MEM (BPF_FIELD_SIZEOF ( + struct bpf_sock_ops_kern, + is_fullsock), + si->dst_reg, si->src_reg, + offsetof(struct bpf_sock_ops_kern , + is_fullsock)); + *insn++ =BPF_JMP_IMM (BPF_JEQ , si->dst_reg,0 ,1 ); + *insn++ =BPF_LDX_MEM (BPF_FIELD_SIZEOF ( + struct bpf_sock_ops_kern, sk), + si->dst_reg, si->src_reg, + offsetof(struct bpf_sock_ops_kern , sk)); +break ; }return insn - insn_buf; }
Signature · 1 line
2.22.0.rc2.383.gf4fbbf30c2-goog
PATCH 3/4 bpf/tools: sync bpf.h
In reply to Stanislav FomichevAdd sk to struct bpf_sock_addr and struct bpf_sock_ops.
--- tools/include/uapi/linux/bpf.h | 2 ++ 1 file changed, 2 insertions(+)
tools/include/uapi/linux/bpf.h +2 -0
@@ -3247,6 +3247,7 @@ struct bpf_sock_addr {__u32 msg_src_ip6[4 ];/* Allows 1,2,4-byte read an 4-byte write. * Stored in network byte order. */ + __bpf_md_ptr(struct bpf_sock *, sk); };/* User bpf_sock_ops struct to access socket values and specify request ops
@@ -3298,6 +3299,7 @@ struct bpf_sock_ops {__u32 sk_txhash;__u64 bytes_received;__u64 bytes_acked; + __bpf_md_ptr(struct bpf_sock *, sk); };/* Definitions for bpf_sock_ops_cb_flags */
Signature · 1 line
2.22.0.rc2.383.gf4fbbf30c2-goog
PATCH 4/4 selftests/bpf: convert socket_cookie test to sk storage
In reply to Stanislav FomichevThis lets us test that both BPF_PROG_TYPE_CGROUP_SOCK_ADDR and BPF_PROG_TYPE_SOCK_OPS can access underlying bpf_sock.
--- .../selftests/bpf/progs/socket_cookie_prog.c | 46 ++++++++++++------- .../selftests/bpf/test_socket_cookie.c | 24 ++++------ 2 files changed, 38 insertions(+), 32 deletions(-)
tools/testing/selftests/bpf/progs/socket_cookie_prog.c +29 -17
@@ -7,25 +7,35 @@#include "bpf_helpers.h" #include "bpf_endian.h" +struct socket_cookie { +__u64 cookie_key; +__u32 cookie_value; +}; + struct bpf_map_def SEC("maps") socket_cookies = { - .type = BPF_MAP_TYPE_HASH, - .key_size = sizeof(__u64), - .value_size = sizeof(__u32), - .max_entries = 1 << 8, + .type = BPF_MAP_TYPE_SK_STORAGE, + .key_size = sizeof(int), + .value_size = sizeof(struct socket_cookie), + .map_flags = BPF_F_NO_PREALLOC, }; +BPF_ANNOTATE_KV_PAIR(socket_cookies, int, struct socket_cookie); + SEC("cgroup/connect6")int set_cookie (struct bpf_sock_addr *ctx) { -__u32 cookie_value =0xFF ; -__u64 cookie_key; +struct socket_cookie *p;if (ctx->family !=AF_INET6 || ctx->user_family !=AF_INET6 )return 1 ; - cookie_key =bpf_get_socket_cookie (ctx); -if (bpf_map_update_elem (&socket_cookies, &cookie_key, &cookie_value,0 )) -return 0 ; + p =bpf_sk_storage_get (&socket_cookies, ctx->sk,0 , +BPF_SK_STORAGE_GET_F_CREATE ); +if (!p) +return 1 ; + + p->cookie_value =0xFF ; + p->cookie_key =bpf_get_socket_cookie (ctx);return 1 ; }
@@ -33,9 +43,8 @@ int set_cookie(struct bpf_sock_addr *ctx) SEC("sockops")int update_cookie (struct bpf_sock_ops *ctx) { -__u32 new_cookie_value; -__u32 *cookie_value; -__u64 cookie_key; +struct bpf_sock *sk; +struct socket_cookie *p;if (ctx->family !=AF_INET6 )return 1 ;
@@ -43,14 +52,17 @@ int update_cookie(struct bpf_sock_ops *ctx)if (ctx->op !=BPF_SOCK_OPS_TCP_CONNECT_CB )return 1 ; - cookie_key =bpf_get_socket_cookie (ctx); +if (!ctx->sk) +return 1 ; + + p =bpf_sk_storage_get (&socket_cookies, ctx->sk,0 ,0 ); +if (!p) +return 1 ; - cookie_value =bpf_map_lookup_elem (&socket_cookies, &cookie_key); -if (!cookie_value) +if (p->cookie_key !=bpf_get_socket_cookie (ctx))return 1 ; - new_cookie_value = (ctx->local_port <<8 ) | *cookie_value; -bpf_map_update_elem (&socket_cookies, &cookie_key, &new_cookie_value,0 ); + p->cookie_value = (ctx->local_port <<8 ) | p->cookie_value;return 1 ; }
tools/testing/selftests/bpf/test_socket_cookie.c +9 -15
@@ -18,6 +18,11 @@#define CG_PATH "/foo"#define SOCKET_COOKIE_PROG "./socket_cookie_prog.o" +struct socket_cookie { +__u64 cookie_key; +__u32 cookie_value; +}; +static int start_server (void ) {struct sockaddr_in6 addr;
@@ -89,8 +94,7 @@ static int validate_map(struct bpf_map *map, int client_fd)__u32 cookie_expected_value;struct sockaddr_in6 addr;socklen_t len =sizeof (addr); -__u32 cookie_value; -__u64 cookie_key; +struct socket_cookie val;int err =0 ;int map_fd;
@@ -101,17 +105,7 @@ static int validate_map(struct bpf_map *map, int client_fd) map_fd =bpf_map__fd (map); - err =bpf_map_get_next_key (map_fd,NULL , &cookie_key); -if (err) { -log_err ("Can't get cookie key from map" ); - goto out; - } - - err =bpf_map_lookup_elem (map_fd, &cookie_key, &cookie_value); -if (err) { -log_err ("Can't get cookie value from map" ); - goto out; - } + err =bpf_map_lookup_elem (map_fd, &client_fd, &val); err =getsockname (client_fd, (struct sockaddr *)&addr, &len);if (err) {
@@ -120,8 +114,8 @@ static int validate_map(struct bpf_map *map, int client_fd) } cookie_expected_value = (ntohs (addr.sin6_port) <<8 ) |0xFF ; -if (cookie_value != cookie_expected_value) { -log_err ("Unexpected value in map: %x != %x" , cookie_value, +if (val.cookie_value != cookie_expected_value) { +log_err ("Unexpected value in map: %x != %x" , val.cookie_value, cookie_expected_value); goto err; }
Signature · 1 line
2.22.0.rc2.383.gf4fbbf30c2-goog
Daniel Borkmann
maintainerQuoted 8 lines · Stanislav Fomichev
And let it use bpf_sk_storage_{get,delete} helpers to access socket storage. Kernel context (struct
bpf_sock_addr_kern) already has sk member, so I just expose it to the BPF hooks. UsingPTR_TO_SOCKETinstead ofPTR_TO_SOCK_COMMONshould be safe because the hook is called on bind/connect.Cc Martin Lau <[email protected]>Signed-off-by Stanislav Fomichev <[email protected]>
Looks good, applied, thanks!