Add __sk_buff->sk, bpf_tcp_sock, BPF_FUNC_tcp_sock and BPF_FUNC_sk_fullsock
Subsystems (7)
v2 cover Add __sk_buff->sk, bpf_tcp_sock, BPF_FUNC_tcp_sock and BPF_FUNC_sk_fullsock
This series adds __sk_buff->sk, "struct bpf_tcp_sock", BPF_FUNC_sk_fullsock and BPF_FUNC_tcp_sock. Together, they provide a common way to expose the members of "struct tcp_sock" and "struct bpf_sock" for the bpf_prog to access.
The patch series first adds a bpf_sock pointer to __sk_buff and a new helper BPF_FUNC_sk_fullsock.
It then adds BPF_FUNC_tcp_sock to get a bpf_tcp_sock pointer from a bpf_sock pointer.
The current use case is to allow a cg_skb_bpf_prog to provide per cgroup traffic policing/shaping.
Please see individual patch for details.
v2:
- Patch 1 depends on
commit d623876646be ("bpf: Fix narrow load on a bpf_sock returned from sk_lookup()") in the bpf branch.
- Add sk_to_full_sk() to bpf_sk_fullsock() and bpf_tcp_sock()
such that there is a way to access the listener's sk and tcp_sk
when __sk_buff->sk is a request_sock.
The comments in the uapi bpf.h is updated accordingly.
- bpf_ctx_range_till() is used in bpf_sock_common_is_valid_access()
in patch 1. Saved a few lines.
- Patch 2 is new in v2 and it adds "state", "dst_ip4", "dst_ip6" and "dst_port" to the bpf_sock. Narrow load is allowed on them.
The "state" (i.e. sk_state) has already been used in
INET_DIAG (e.g. ss -t) and getsockopt(TCP_INFO).
- While at it in the new patch 2, also allow narrow load on some existing fields of the bpf_sock, which are "family", "type", "protocol" and "src_port". Only allow loading from first byte for now.
i.e. does not allow narrow load starting from the 2nd byte.
- Add some narrow load tests to the test_verifier's sock.c
Martin KaFai Lau (7):
bpf: Add a bpf_sock pointer to __sk_buff and a bpf_sk_fullsock helper
bpf: Add state, dst_ip4, dst_ip6 and dst_port to bpf_sock
bpf: Refactor sock_ops_convert_ctx_access
bpf: Add struct bpf_tcp_sock and BPF_FUNC_tcp_sock
bpf: Sync bpf.h to tools/
bpf: Add skb->sk, bpf_sk_fullsock and bpf_tcp_sock tests to
test_verifer
bpf: Add test_sock_fields for skb->sk and bpf_tcp_sock
include/linux/bpf.h | 42 ++ include/uapi/linux/bpf.h | 72 ++- kernel/bpf/verifier.c | 159 ++++-- net/core/filter.c | 495 +++++++++++------- tools/include/uapi/linux/bpf.h | 72 ++- tools/testing/selftests/bpf/Makefile | 6 +- tools/testing/selftests/bpf/bpf_helpers.h | 4 + tools/testing/selftests/bpf/bpf_util.h | 9 + .../testing/selftests/bpf/test_sock_fields.c | 327 ++++++++++++ .../selftests/bpf/test_sock_fields_kern.c | 152 ++++++ .../selftests/bpf/verifier/ref_tracking.c | 4 +- tools/testing/selftests/bpf/verifier/sock.c | 384 ++++++++++++++ tools/testing/selftests/bpf/verifier/unpriv.c | 2 +- 13 files changed, 1493 insertions(+), 235 deletions(-) create mode 100644 tools/testing/selftests/bpf/test_sock_fields.c create mode 100644 tools/testing/selftests/bpf/test_sock_fields_kern.c create mode 100644 tools/testing/selftests/bpf/verifier/sock.c
Signature · 1 line
2.17.1
PATCH v2 1/7 bpf: Add a bpf_sock pointer to __sk_buff and a bpf_sk_fullsock helper
In kernel, it is common to check "skb->sk && sk_fullsock(skb->sk)" before accessing the fields in sock. For example, in __netdev_pick_tx:
static u16 __netdev_pick_tx(struct net_device *dev, struct sk_buff *skb,
struct net_device *sb_dev)
{
/* ... */
struct sock *sk = skb->sk;
if (queue_index != new_index && sk &&
sk_fullsock(sk) &&
rcu_access_pointer(sk->sk_dst_cache))
sk_tx_queue_set(sk, new_index);
/* ... */
return queue_index;
}This patch adds a "struct bpf_sock *sk" pointer to the "struct __sk_buff" where a few of the convert_ctx_access() in filter.c has already been accessing the skb->sk sock_common's fields,
e.g. sock_ops_convert_ctx_access().
"__sk_buff->sk" is a PTR_TO_SOCK_COMMON_OR_NULL in the verifier. Some of the fileds in "bpf_sock" will not be directly accessible through the "__sk_buff->sk" pointer. It is limited by the new "bpf_sock_common_is_valid_access()".
e.g. The existing "type", "protocol", "mark" and "priority" in bpf_sock
are not allowed.
The newly added "struct bpf_sock *bpf_sk_fullsock(struct bpf_sock *sk)" can be used to get a sk with all accessible fields in "bpf_sock". This helper is added to both cg_skb and sched_(cls|act).
int cg_skb_foo(struct __sk_buff *skb) {
struct bpf_sock *sk;
sk = skb->sk;
if (!sk)
return 1;
sk = bpf_sk_fullsock(sk);
if (!sk)
return 1;
if (sk->family != AF_INET6 || sk->protocol != IPPROTO_TCP)
return 1;
/* some_traffic_shaping(); */
return 1;
}(1) The sk is read only
(2) There is no new "struct bpf_sock_common" introduced.
(3) Future kernel sock's members could be added to bpf_sock only instead of repeatedly adding at multiple places like currently in bpf_sock_ops_md, bpf_sock_addr_md, sk_reuseport_md...etc.
(4) After "sk = skb->sk", the reg holding sk is in type PTR_TO_SOCK_COMMON_OR_NULL.
(5) After bpf_sk_fullsock(), the return type will be in type PTR_TO_SOCKET_OR_NULL which is the same as the return type of bpf_sk_lookup_xxx().
However, bpf_sk_fullsock() does not take refcnt. The acquire_reference_state() is only depending on the return type now. To avoid it, a new is_acquire_function() is checked before calling acquire_reference_state().
(6) The WARN_ON in "release_reference_state()" is no longer an internal verifier bug.
When reg->id is not found in state->refs[], it means the bpf_prog does something wrong like "bpf_sk_release(bpf_sk_fullsock(skb->sk))" where reference has never been acquired by calling "bpf_sk_fullsock(skb->sk)".
A -EINVAL and a verbose are done instead of WARN_ON. A test is added to the test_verifier in a later patch.
Since the WARN_ON in "release_reference_state()" is no longer needed, "__release_reference_state()" is folded into "release_reference_state()" also.
--- include/linux/bpf.h | 12 ++++ include/uapi/linux/bpf.h | 12 +++- kernel/bpf/verifier.c | 132 +++++++++++++++++++++++++++------------ net/core/filter.c | 42 +++++++++++++ 4 files changed, 157 insertions(+), 41 deletions(-)
include/linux/bpf.h +12 -0
@@ -194,6 +194,7 @@ enum bpf_arg_type {ARG_ANYTHING ,/* any (initialized) argument is ok */ ARG_PTR_TO_SOCKET ,/* pointer to bpf_sock */ ARG_PTR_TO_SPIN_LOCK ,/* pointer to bpf_spin_lock */ + ARG_PTR_TO_SOCK_COMMON, /* pointer to sock_common */ };/* type of values returned from helper functions */
@@ -256,6 +257,8 @@ enum bpf_reg_type {PTR_TO_FLOW_KEYS ,/* reg points to bpf_flow_keys */ PTR_TO_SOCKET ,/* reg points to struct bpf_sock */ PTR_TO_SOCKET_OR_NULL ,/* reg points to struct bpf_sock or NULL */ +PTR_TO_SOCK_COMMON ,/* reg points to sock_common */ + PTR_TO_SOCK_COMMON_OR_NULL, /* reg points to sock_common or NULL */ };/* The information passed from prog-specific *_is_valid_access
@@ -920,6 +923,9 @@ void bpf_user_rnd_init_once(void);u64 bpf_user_rnd_u32 (u64 r1,u64 r2,u64 r3,u64 r4,u64 r5);#if defined(CONFIG_NET ) +bool bpf_sock_common_is_valid_access (int off,int size, +enum bpf_access_type type, +struct bpf_insn_access_aux *info);bool bpf_sock_is_valid_access (int off,int size,enum bpf_access_type type,struct bpf_insn_access_aux *info); u32 bpf_sock_convert_ctx_access(enum bpf_access_type type,
@@ -928,6 +934,12 @@ u32 bpf_sock_convert_ctx_access(enum bpf_access_type type,struct bpf_prog *prog, u32 *target_size);#else +static inline bool bpf_sock_common_is_valid_access (int off,int size, +enum bpf_access_type type, +struct bpf_insn_access_aux *info) +{ +return false; +}static inline bool bpf_sock_is_valid_access (int off,int size,enum bpf_access_type type,struct bpf_insn_access_aux *info)
include/uapi/linux/bpf.h +11 -1
@@ -2329,6 +2329,14 @@ union bpf_attr {* "**y**". * Return * 0 +* +* struct bpf_sock *bpf_sk_fullsock(struct bpf_sock *sk) +* Description +* This helper gets a **struct bpf_sock** pointer such +* that all the fields in bpf_sock can be accessed. +* Return +* A **struct bpf_sock** pointer on success, or NULL in +* case of failure. */ #define __BPF_FUNC_MAPPER (FN ) \ FN(unspec), \
@@ -2425,7 +2433,8 @@ union bpf_attr {FN (msg_pop_data), \FN (rc_pointer_rel), \FN (spin_lock), \ -FN (spin_unlock), +FN (spin_unlock), \ +FN (sk_fullsock),/* integer value in 'imm' field of BPF_CALL instruction selects which helper * function eBPF program intends to call
@@ -2545,6 +2554,7 @@ struct __sk_buff {__u64 tstamp;__u32 wire_len;__u32 gso_segs; + __bpf_md_ptr(struct bpf_sock *, sk); };struct bpf_tunnel_key {
kernel/bpf/verifier.c +92 -40
286 lines not on this page · raw message
net/core/filter.c +42 -0
78 lines not on this page · raw message
Signature · 1 line
2.17.1
PATCH v2 2/7 bpf: Add state, dst_ip4, dst_ip6 and dst_port to bpf_sock
In reply to Martin KaFai LauThis patch adds "state", "dst_ip4", "dst_ip6" and "dst_port" to the bpf_sock. The userspace has already been using "state", e.g. inet_diag (ss -t) and getsockopt(TCP_INFO).
This patch also allows narrow load on the following existing fields:
"family", "type", "protocol" and "src_port". Unlike IP address, the load offset is resticted to the first byte for them but it can be relaxed later if there is a use case.
This patch also folds __sock_filter_check_size() into bpf_sock_is_valid_access() since it is not called by any where else. All bpf_sock checking is in one place.
--- include/uapi/linux/bpf.h | 17 ++++--- net/core/filter.c | 99 +++++++++++++++++++++++++++++++--------- 2 files changed, 85 insertions(+), 31 deletions(-)
include/uapi/linux/bpf.h +8 -9
@@ -2606,15 +2606,14 @@ struct bpf_sock {__u32 protocol;__u32 mark;__u32 priority; -__u32 src_ip4;/* Allows 1,2,4-byte read. -* Stored in network byte order. -*/ -__u32 src_ip6[4 ];/* Allows 1,2,4-byte read. -* Stored in network byte order. -*/ -__u32 src_port;/* Allows 4-byte read. -* Stored in host byte order -*/ +/* IP address also allows 1 and 2 bytes access */ +__u32 src_ip4; +__u32 src_ip6[4 ]; +__u32 src_port;/* host byte order */ +__u32 dst_port;/* network byte order */ +__u32 dst_ip4; +__u32 dst_ip6[4 ]; +__u32 state; };struct bpf_sock_tuple {
net/core/filter.c +77 -22
153 lines not on this page · raw message
Signature · 1 line
2.17.1
PATCH v2 3/7 bpf: Refactor sock_ops_convert_ctx_access
In reply to Martin KaFai LauThe next patch will introduce a new "struct bpf_tcp_sock" which exposes the same tcp_sock's fields already exposed in "struct bpf_sock_ops".
This patch refactor the existing convert_ctx_access() codes for "struct bpf_sock_ops" to get them ready to be reused for "struct bpf_tcp_sock". The "rtt_min" is not refactored in this patch because its handling is different from other fields.
The SOCK_OPS_GET_TCP_SOCK_FIELD is new. All other SOCK_OPS_XXX_FIELD changes are code move only.
--- net/core/filter.c | 287 ++++++++++++++++++++-------------------------- 1 file changed, 127 insertions(+), 160 deletions(-)
net/core/filter.c +127 -160
@@ -5030,6 +5030,54 @@ static const struct bpf_func_proto bpf_lwt_seg6_adjust_srh_proto = { };#endif /* CONFIG_IPV6_SEG6_BPF */ +#define CONVERT_COMMON_TCP_SOCK_FIELDS (md_type,CONVERT ) \ +do { \ + switch (si->off) { \ + case offsetof(md_type, snd_cwnd): \ + CONVERT(snd_cwnd); break; \ + case offsetof(md_type, srtt_us): \ + CONVERT(srtt_us); break; \ + case offsetof(md_type, snd_ssthresh): \ + CONVERT(snd_ssthresh); break; \ + case offsetof(md_type, rcv_nxt): \ + CONVERT(rcv_nxt); break; \ + case offsetof(md_type, snd_nxt): \ + CONVERT(snd_nxt); break; \ + case offsetof(md_type, snd_una): \ + CONVERT(snd_una); break; \ + case offsetof(md_type, mss_cache): \ + CONVERT(mss_cache); break; \ + case offsetof(md_type, ecn_flags): \ + CONVERT(ecn_flags); break; \ + case offsetof(md_type, rate_delivered): \ + CONVERT(rate_delivered); break; \ + case offsetof(md_type, rate_interval_us): \ + CONVERT(rate_interval_us); break; \ + case offsetof(md_type, packets_out): \ + CONVERT(packets_out); break; \ + case offsetof(md_type, retrans_out): \ + CONVERT(retrans_out); break; \ + case offsetof(md_type, total_retrans): \ + CONVERT(total_retrans); break; \ + case offsetof(md_type, segs_in): \ + CONVERT(segs_in); break; \ + case offsetof(md_type, data_segs_in): \ + CONVERT(data_segs_in); break; \ + case offsetof(md_type, segs_out): \ + CONVERT(segs_out); break; \ + case offsetof(md_type, data_segs_out): \ + CONVERT(data_segs_out); break; \ + case offsetof(md_type, lost_out): \ + CONVERT(lost_out); break; \ + case offsetof(md_type, sacked_out): \ + CONVERT(sacked_out); break; \ + case offsetof(md_type, bytes_received): \ + CONVERT(bytes_received); break; \ + case offsetof(md_type, bytes_acked): \ + CONVERT(bytes_acked); break; \ + } \ +} while (0) +#ifdef CONFIG_INET static struct sock *sk_lookup (struct net *net,struct bpf_sock_tuple *tuple,int dif,int sdif,u8 family,u8 proto)
@@ -7196,6 +7244,85 @@ static u32 sock_ops_convert_ctx_access(enum bpf_access_type type,struct bpf_insn *insn = insn_buf;int off; +/* Helper macro for adding read access to tcp_sock or sock fields. */ +#define SOCK_OPS_GET_FIELD (BPF_FIELD ,OBJ_FIELD ,OBJ ) \ + do { \ + BUILD_BUG_ON(FIELD_SIZEOF(OBJ, OBJ_FIELD) > \ + FIELD_SIZEOF(struct bpf_sock_ops, BPF_FIELD)); \ + *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, 2); \ + *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));\ + *insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF(OBJ, \ + OBJ_FIELD), \ + si->dst_reg, si->dst_reg, \ + offsetof(OBJ, OBJ_FIELD)); \ + } while (0) + +#define SOCK_OPS_GET_TCP_SOCK_FIELD (FIELD ) \ + SOCK_OPS_GET_FIELD(FIELD, FIELD, struct tcp_sock) + +/* Helper macro for adding write access to tcp_sock or sock fields. +* The macro is called with two registers, dst_reg which contains a pointer +* to ctx (context) and src_reg which contains the value that should be +* stored. However, we need an additional register since we cannot overwrite +* dst_reg because it may be used later in the program. +* Instead we "borrow" one of the other register. We first save its value +* into a new (temp) field in bpf_sock_ops_kern, use it, and then restore +* it at the end of the macro. +*/ +#define SOCK_OPS_SET_FIELD (BPF_FIELD ,OBJ_FIELD ,OBJ ) \ + do { \ + int reg = BPF_REG_9; \ + BUILD_BUG_ON(FIELD_SIZEOF(OBJ, OBJ_FIELD) > \ + FIELD_SIZEOF(struct bpf_sock_ops, BPF_FIELD)); \ + if (si->dst_reg == reg || si->src_reg == reg) \ + reg--; \ + if (si->dst_reg == reg || si->src_reg == reg) \ + reg--; \ + *insn++ = BPF_STX_MEM(BPF_DW, si->dst_reg, reg, \ + offsetof(struct bpf_sock_ops_kern, \ + temp)); \ + *insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF( \ + struct bpf_sock_ops_kern, \ + is_fullsock), \ + reg, si->dst_reg, \ + offsetof(struct bpf_sock_ops_kern, \ + is_fullsock)); \ + *insn++ = BPF_JMP_IMM(BPF_JEQ, reg, 0, 2); \ + *insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF( \ + struct bpf_sock_ops_kern, sk),\ + reg, si->dst_reg, \ + offsetof(struct bpf_sock_ops_kern, sk));\ + *insn++ = BPF_STX_MEM(BPF_FIELD_SIZEOF(OBJ, OBJ_FIELD), \ + reg, si->src_reg, \ + offsetof(OBJ, OBJ_FIELD)); \ + *insn++ = BPF_LDX_MEM(BPF_DW, reg, si->dst_reg, \ + offsetof(struct bpf_sock_ops_kern, \ + temp)); \ + } while (0) + +#define SOCK_OPS_GET_OR_SET_FIELD (BPF_FIELD ,OBJ_FIELD ,OBJ ,TYPE ) \ + do { \ + if (TYPE == BPF_WRITE) \ + SOCK_OPS_SET_FIELD(BPF_FIELD, OBJ_FIELD, OBJ); \ + else \ + SOCK_OPS_GET_FIELD(BPF_FIELD, OBJ_FIELD, OBJ); \ + } while (0) + + CONVERT_COMMON_TCP_SOCK_FIELDS(struct bpf_sock_ops, + SOCK_OPS_GET_TCP_SOCK_FIELD); + +if (insn > insn_buf) +return insn - insn_buf; +switch (si->off) { case offsetof(struct bpf_sock_ops, op) ... offsetof(struct bpf_sock_ops, replylong[3]):
@@ -7353,175 +7480,15 @@ static u32 sock_ops_convert_ctx_access(enum bpf_access_type type, FIELD_SIZEOF(struct minmax_sample, t));break ; -/* Helper macro for adding read access to tcp_sock or sock fields. */ -#define SOCK_OPS_GET_FIELD (BPF_FIELD ,OBJ_FIELD ,OBJ ) \ - do { \ - BUILD_BUG_ON(FIELD_SIZEOF(OBJ, OBJ_FIELD) > \ - FIELD_SIZEOF(struct bpf_sock_ops, BPF_FIELD)); \ - *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, 2); \ - *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));\ - *insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF(OBJ, \ - OBJ_FIELD), \ - si->dst_reg, si->dst_reg, \ - offsetof(OBJ, OBJ_FIELD)); \ - } while (0) - -/* Helper macro for adding write access to tcp_sock or sock fields. -* The macro is called with two registers, dst_reg which contains a pointer -* to ctx (context) and src_reg which contains the value that should be -* stored. However, we need an additional register since we cannot overwrite -* dst_reg because it may be used later in the program. -* Instead we "borrow" one of the other register. We first save its value -* into a new (temp) field in bpf_sock_ops_kern, use it, and then restore -* it at the end of the macro. -*/ -#define SOCK_OPS_SET_FIELD (BPF_FIELD ,OBJ_FIELD ,OBJ ) \ - do { \ - int reg = BPF_REG_9; \ - BUILD_BUG_ON(FIELD_SIZEOF(OBJ, OBJ_FIELD) > \ - FIELD_SIZEOF(struct bpf_sock_ops, BPF_FIELD)); \ - if (si->dst_reg == reg || si->src_reg == reg) \ - reg--; \ - if (si->dst_reg == reg || si->src_reg == reg) \ - reg--; \ - *insn++ = BPF_STX_MEM(BPF_DW, si->dst_reg, reg, \ - offsetof(struct bpf_sock_ops_kern, \ - temp)); \ - *insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF( \ - struct bpf_sock_ops_kern, \ - is_fullsock), \ - reg, si->dst_reg, \ - offsetof(struct bpf_sock_ops_kern, \ - is_fullsock)); \ - *insn++ = BPF_JMP_IMM(BPF_JEQ, reg, 0, 2); \ - *insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF( \ - struct bpf_sock_ops_kern, sk),\ - reg, si->dst_reg, \ - offsetof(struct bpf_sock_ops_kern, sk));\ - *insn++ = BPF_STX_MEM(BPF_FIELD_SIZEOF(OBJ, OBJ_FIELD), \ - reg, si->src_reg, \ - offsetof(OBJ, OBJ_FIELD)); \ - *insn++ = BPF_LDX_MEM(BPF_DW, reg, si->dst_reg, \ - offsetof(struct bpf_sock_ops_kern, \ - temp)); \ - } while (0) - -#define SOCK_OPS_GET_OR_SET_FIELD (BPF_FIELD ,OBJ_FIELD ,OBJ ,TYPE ) \ - do { \ - if (TYPE == BPF_WRITE) \ - SOCK_OPS_SET_FIELD(BPF_FIELD, OBJ_FIELD, OBJ); \ - else \ - SOCK_OPS_GET_FIELD(BPF_FIELD, OBJ_FIELD, OBJ); \ - } while (0) - -case offsetof(struct bpf_sock_ops , snd_cwnd): - SOCK_OPS_GET_FIELD(snd_cwnd, snd_cwnd, struct tcp_sock); -break ; - -case offsetof(struct bpf_sock_ops , srtt_us): - SOCK_OPS_GET_FIELD(srtt_us, srtt_us, struct tcp_sock); -break ; -case offsetof(struct bpf_sock_ops , bpf_sock_ops_cb_flags):SOCK_OPS_GET_FIELD (bpf_sock_ops_cb_flags, bpf_sock_ops_cb_flags, struct tcp_sock);break ; -case offsetof(struct bpf_sock_ops , snd_ssthresh): - SOCK_OPS_GET_FIELD(snd_ssthresh, snd_ssthresh, struct tcp_sock); -break ; - -case offsetof(struct bpf_sock_ops , rcv_nxt): - SOCK_OPS_GET_FIELD(rcv_nxt, rcv_nxt, struct tcp_sock); -break ; - -case offsetof(struct bpf_sock_ops , snd_nxt): - SOCK_OPS_GET_FIELD(snd_nxt, snd_nxt, struct tcp_sock); -break ; - -case offsetof(struct bpf_sock_ops , snd_una): - SOCK_OPS_GET_FIELD(snd_una, snd_una, struct tcp_sock); -break ; - -case offsetof(struct bpf_sock_ops , mss_cache): - SOCK_OPS_GET_FIELD(mss_cache, mss_cache, struct tcp_sock); -break ; - -case offsetof(struct bpf_sock_ops , ecn_flags): - SOCK_OPS_GET_FIELD(ecn_flags, ecn_flags, struct tcp_sock); -break ; - -case offsetof(struct bpf_sock_ops , rate_delivered): -SOCK_OPS_GET_FIELD (rate_delivered, rate_delivered, - struct tcp_sock); -break ; - -case offsetof(struct bpf_sock_ops , rate_interval_us): -SOCK_OPS_GET_FIELD (rate_interval_us, rate_interval_us, - struct tcp_sock); -break ; - -case offsetof(struct bpf_sock_ops , packets_out): - SOCK_OPS_GET_FIELD(packets_out, packets_out, struct tcp_sock); -break ; - -case offsetof(struct bpf_sock_ops , retrans_out): - SOCK_OPS_GET_FIELD(retrans_out, retrans_out, struct tcp_sock); -break ; - -case offsetof(struct bpf_sock_ops , total_retrans): -SOCK_OPS_GET_FIELD (total_retrans, total_retrans, - struct tcp_sock); -break ; - -case offsetof(struct bpf_sock_ops , segs_in): - SOCK_OPS_GET_FIELD(segs_in, segs_in, struct tcp_sock); -break ; - -case offsetof(struct bpf_sock_ops , data_segs_in): - SOCK_OPS_GET_FIELD(data_segs_in, data_segs_in, struct tcp_sock); -break ; - -case offsetof(struct bpf_sock_ops , segs_out): - SOCK_OPS_GET_FIELD(segs_out, segs_out, struct tcp_sock); -break ; - -case offsetof(struct bpf_sock_ops , data_segs_out): -SOCK_OPS_GET_FIELD (data_segs_out, data_segs_out, - struct tcp_sock); -break ; - -case offsetof(struct bpf_sock_ops , lost_out): - SOCK_OPS_GET_FIELD(lost_out, lost_out, struct tcp_sock); -break ; - -case offsetof(struct bpf_sock_ops , sacked_out): - SOCK_OPS_GET_FIELD(sacked_out, sacked_out, struct tcp_sock); -break ; -case offsetof(struct bpf_sock_ops , sk_txhash):SOCK_OPS_GET_OR_SET_FIELD (sk_txhash, sk_txhash, struct sock, type);break ; - -case offsetof(struct bpf_sock_ops , bytes_received): -SOCK_OPS_GET_FIELD (bytes_received, bytes_received, - struct tcp_sock); -break ; - -case offsetof(struct bpf_sock_ops , bytes_acked): - SOCK_OPS_GET_FIELD(bytes_acked, bytes_acked, struct tcp_sock); -break ; - }return insn - insn_buf; }
Signature · 1 line
2.17.1
PATCH v2 4/7 bpf: Add struct bpf_tcp_sock and BPF_FUNC_tcp_sock
In reply to Martin KaFai LauThis patch adds a helper function BPF_FUNC_tcp_sock and it is currently available for cg_skb and sched_(cls|act):
struct bpf_tcp_sock *bpf_tcp_sock(struct bpf_sock *sk);
int cg_skb_foo(struct __sk_buff *skb) {
struct bpf_tcp_sock *tp;
struct bpf_sock *sk;
__u32 snd_cwnd;
sk = skb->sk;
if (!sk)
return 1;
tp = bpf_tcp_sock(sk);
if (!tp)
return 1;
snd_cwnd = tp->snd_cwnd;
/* ... */
return 1;
}A 'struct bpf_tcp_sock' is also added to the uapi bpf.h to provide read-only access. bpf_tcp_sock has all the existing tcp_sock's fields that has already been exposed by the bpf_sock_ops.
i.e. no new tcp_sock's fields are exposed in bpf.h.
This helper returns a pointer to the tcp_sock. If it is not a tcp_sock or it cannot be traced back to a tcp_sock by sk_to_full_sk(), it returns NULL. Hence, the caller needs to check for NULL before accessing it.
The current use case is to expose members from tcp_sock to allow a cg_skb_bpf_prog to provide per cgroup traffic policing/shaping.
--- include/linux/bpf.h | 30 +++++++++++++++ include/uapi/linux/bpf.h | 51 +++++++++++++++++++++++++- kernel/bpf/verifier.c | 31 +++++++++++++++- net/core/filter.c | 79 ++++++++++++++++++++++++++++++++++++++++ 4 files changed, 188 insertions(+), 3 deletions(-)
include/linux/bpf.h +30 -0
@@ -204,6 +204,7 @@ enum bpf_return_type {RET_PTR_TO_MAP_VALUE ,/* returns a pointer to map elem value */ RET_PTR_TO_MAP_VALUE_OR_NULL ,/* returns a pointer to map elem value or NULL */ RET_PTR_TO_SOCKET_OR_NULL ,/* returns a pointer to a socket or NULL */ + RET_PTR_TO_TCP_SOCK_OR_NULL, /* returns a pointer to a tcp_sock or NULL */ };/* eBPF function prototype used by verifier to allow BPF_CALLs from eBPF programs
@@ -259,6 +260,8 @@ enum bpf_reg_type {PTR_TO_SOCKET_OR_NULL ,/* reg points to struct bpf_sock or NULL */ PTR_TO_SOCK_COMMON ,/* reg points to sock_common */ PTR_TO_SOCK_COMMON_OR_NULL ,/* reg points to sock_common or NULL */ +PTR_TO_TCP_SOCK ,/* reg points to struct tcp_sock */ + PTR_TO_TCP_SOCK_OR_NULL, /* reg points to struct tcp_sock or NULL */ };/* The information passed from prog-specific *_is_valid_access
@@ -956,4 +959,31 @@ static inline u32 bpf_sock_convert_ctx_access(enum bpf_access_type type, }#endif +#ifdef CONFIG_INET +bool bpf_tcp_sock_is_valid_access (int off,int size,enum bpf_access_type type, +struct bpf_insn_access_aux *info); + +u32 bpf_tcp_sock_convert_ctx_access (enum bpf_access_type type, +const struct bpf_insn *si, +struct bpf_insn *insn_buf, +struct bpf_prog *prog, +u32 *target_size); +#else +static inline bool bpf_tcp_sock_is_valid_access (int off,int size, +enum bpf_access_type type, +struct bpf_insn_access_aux *info) +{ +return false; +} + +static inline u32 bpf_tcp_sock_convert_ctx_access (enum bpf_access_type type, +const struct bpf_insn *si, +struct bpf_insn *insn_buf, +struct bpf_prog *prog, +u32 *target_size) +{ +return 0 ; +} +#endif /* CONFIG_INET */ +#endif /* _LINUX_BPF_H */
include/uapi/linux/bpf.h +50 -1
69 lines not on this page · raw message
kernel/bpf/verifier.c +29 -2
@@ -334,14 +334,16 @@ static bool type_is_pkt_pointer(enum bpf_reg_type type)static bool type_is_sk_pointer (enum bpf_reg_type type) {return type ==PTR_TO_SOCKET || - type ==PTR_TO_SOCK_COMMON ; + type ==PTR_TO_SOCK_COMMON || + type ==PTR_TO_TCP_SOCK ; }static bool reg_type_may_be_null (enum bpf_reg_type type) {return type ==PTR_TO_MAP_VALUE_OR_NULL || type ==PTR_TO_SOCKET_OR_NULL || - type ==PTR_TO_SOCK_COMMON_OR_NULL ; + type ==PTR_TO_SOCK_COMMON_OR_NULL || + type ==PTR_TO_TCP_SOCK_OR_NULL ; }static bool type_is_refcounted (enum bpf_reg_type type)
@@ -407,6 +409,8 @@ static const char * const reg_type_str[] = { [PTR_TO_SOCKET_OR_NULL] = "sock_or_null", [PTR_TO_SOCK_COMMON] = "sock_common", [PTR_TO_SOCK_COMMON_OR_NULL] = "sock_common_or_null", + [PTR_TO_TCP_SOCK] = "tcp_sock", + [PTR_TO_TCP_SOCK_OR_NULL] = "tcp_sock_or_null", };static char slot_type_char[] = {
@@ -1209,6 +1213,8 @@ static bool is_spillable_regtype(enum bpf_reg_type type)case PTR_TO_SOCKET_OR_NULL :case PTR_TO_SOCK_COMMON :case PTR_TO_SOCK_COMMON_OR_NULL : +case PTR_TO_TCP_SOCK : +case PTR_TO_TCP_SOCK_OR_NULL :return true;default :return false;
@@ -1662,6 +1668,9 @@ static int check_sock_access(struct bpf_verifier_env *env, int insn_idx,case PTR_TO_SOCKET : valid =bpf_sock_is_valid_access (off, size, t, &info);break ; +case PTR_TO_TCP_SOCK : + valid =bpf_tcp_sock_is_valid_access (off, size, t, &info); +break ;default : valid = false; }
@@ -1823,6 +1832,9 @@ static int check_ptr_alignment(struct bpf_verifier_env *env,case PTR_TO_SOCK_COMMON : pointer_desc ="sock_common " ;break ; +case PTR_TO_TCP_SOCK : + pointer_desc ="tcp_sock " ; +break ;default :break ; }
@@ -3148,6 +3160,10 @@ static int check_helper_call(struct bpf_verifier_env *env, int func_id, int insn/* For mark_ptr_or_null_reg() */ regs[BPF_REG_0 ].id = ++env->id_gen; } + }else if (fn->ret_type ==RET_PTR_TO_TCP_SOCK_OR_NULL ) { +mark_reg_known_zero (env, regs,BPF_REG_0 ); + regs[BPF_REG_0 ].type =PTR_TO_TCP_SOCK_OR_NULL ; + regs[BPF_REG_0 ].id = ++env->id_gen; }else {verbose (env,"unknown return type %d of func %s#%d\n" , fn->ret_type,func_id_name (func_id), func_id);
@@ -3409,6 +3425,8 @@ static int adjust_ptr_min_max_vals(struct bpf_verifier_env *env,case PTR_TO_SOCKET_OR_NULL :case PTR_TO_SOCK_COMMON :case PTR_TO_SOCK_COMMON_OR_NULL : +case PTR_TO_TCP_SOCK : +case PTR_TO_TCP_SOCK_OR_NULL :verbose (env,"R%d pointer arithmetic on %s prohibited\n" , dst, reg_type_str[ptr_reg->type]);return -EACCES ;
@@ -4644,6 +4662,8 @@ static void mark_ptr_or_null_reg(struct bpf_func_state *state, reg->type =PTR_TO_SOCKET ; }else if (reg->type ==PTR_TO_SOCK_COMMON_OR_NULL ) { reg->type =PTR_TO_SOCK_COMMON ; + }else if (reg->type ==PTR_TO_TCP_SOCK_OR_NULL ) { + reg->type =PTR_TO_TCP_SOCK ; }if (is_null || !(reg_is_refcounted (reg) ||reg_may_point_to_spin_lock (reg))) {
@@ -5839,6 +5859,8 @@ static bool regsafe(struct bpf_reg_state *rold, struct bpf_reg_state *rcur,case PTR_TO_SOCKET_OR_NULL :case PTR_TO_SOCK_COMMON :case PTR_TO_SOCK_COMMON_OR_NULL : +case PTR_TO_TCP_SOCK : +case PTR_TO_TCP_SOCK_OR_NULL :/* Only valid matches are exact, which memcmp() above * would have accepted */
@@ -6161,6 +6183,8 @@ static bool reg_type_mismatch_ok(enum bpf_reg_type type)case PTR_TO_SOCKET_OR_NULL :case PTR_TO_SOCK_COMMON :case PTR_TO_SOCK_COMMON_OR_NULL : +case PTR_TO_TCP_SOCK : +case PTR_TO_TCP_SOCK_OR_NULL :return false;default :return true;
@@ -7166,6 +7190,9 @@ static int convert_ctx_accesses(struct bpf_verifier_env *env)case PTR_TO_SOCK_COMMON : convert_ctx_access = bpf_sock_convert_ctx_access;break ; +case PTR_TO_TCP_SOCK : + convert_ctx_access = bpf_tcp_sock_convert_ctx_access; +break ;default :continue ; }
net/core/filter.c +79 -0
97 lines not on this page · raw message
Signature · 1 line
2.17.1
PATCH v2 5/7 bpf: Sync bpf.h to tools/
In reply to Martin KaFai LauThis patch sync the uapi bpf.h to tools/.
--- tools/include/uapi/linux/bpf.h | 72 ++++++++++++++++++++++++++++++---- 1 file changed, 65 insertions(+), 7 deletions(-)
tools/include/uapi/linux/bpf.h +65 -7
@@ -2329,6 +2329,23 @@ union bpf_attr {* "**y**". * Return * 0 +* +* struct bpf_sock *bpf_sk_fullsock(struct bpf_sock *sk) +* Description +* This helper gets a **struct bpf_sock** pointer such +* that all the fields in bpf_sock can be accessed. +* Return +* A **struct bpf_sock** pointer on success, or NULL in +* case of failure. +* +* struct bpf_tcp_sock *bpf_tcp_sock(struct bpf_sock *sk) +* Description +* This helper gets a **struct bpf_tcp_sock** pointer from a +* **struct bpf_sock** pointer. +* +* Return +* A **struct bpf_tcp_sock** pointer on success, or NULL in +* case of failure. */ #define __BPF_FUNC_MAPPER (FN ) \ FN(unspec), \
@@ -2425,7 +2442,9 @@ union bpf_attr {FN (msg_pop_data), \FN (rc_pointer_rel), \FN (spin_lock), \ -FN (spin_unlock), +FN (spin_unlock), \ +FN (sk_fullsock), \ +FN (tcp_sock),/* integer value in 'imm' field of BPF_CALL instruction selects which helper * function eBPF program intends to call
@@ -2545,6 +2564,7 @@ struct __sk_buff {__u64 tstamp;__u32 wire_len;__u32 gso_segs; + __bpf_md_ptr(struct bpf_sock *, sk); };struct bpf_tunnel_key {
@@ -2596,14 +2616,52 @@ struct bpf_sock {__u32 protocol;__u32 mark;__u32 priority; -__u32 src_ip4;/* Allows 1,2,4-byte read. -* Stored in network byte order. +/* IP address also allows 1 and 2 bytes access */ +__u32 src_ip4; +__u32 src_ip6[4 ]; +__u32 src_port;/* host byte order */ +__u32 dst_port;/* network byte order */ +__u32 dst_ip4; +__u32 dst_ip6[4 ]; +__u32 state; +}; + +struct bpf_tcp_sock { +__u32 snd_cwnd;/* Sending congestion window */ +__u32 srtt_us;/* smoothed round trip time << 3 in usecs */ +__u32 rtt_min; +__u32 snd_ssthresh;/* Slow start size threshold */ +__u32 rcv_nxt;/* What we want to receive next */ +__u32 snd_nxt;/* Next sequence we send */ +__u32 snd_una;/* First byte we want an ack for */ +__u32 mss_cache;/* Cached effective mss, not including SACKS */ +__u32 ecn_flags;/* ECN status bits. */ +__u32 rate_delivered;/* saved rate sample: packets delivered */ +__u32 rate_interval_us;/* saved rate sample: time elapsed */ +__u32 packets_out;/* Packets which are "in flight" */ +__u32 retrans_out;/* Retransmitted packets out */ +__u32 total_retrans;/* Total retransmits for entire connection */ +__u32 segs_in;/* RFC4898 tcpEStatsPerfSegsIn +* total number of segments in. */ -__u32 src_ip6[4 ];/* Allows 1,2,4-byte read. -* Stored in network byte order. +__u32 data_segs_in;/* RFC4898 tcpEStatsPerfDataSegsIn +* total number of data segments in. +*/ +__u32 segs_out;/* RFC4898 tcpEStatsPerfSegsOut +* The total number of segments sent. +*/ +__u32 data_segs_out;/* RFC4898 tcpEStatsPerfDataSegsOut +* total number of data segments sent. +*/ +__u32 lost_out;/* Lost packets */ +__u32 sacked_out;/* SACK'd packets */ +__u64 bytes_received;/* RFC4898 tcpEStatsAppHCThruOctetsReceived +* sum(delta(rcv_nxt)), or how many bytes +* were acked. */ -__u32 src_port;/* Allows 4-byte read. -* Stored in host byte order +__u64 bytes_acked;/* RFC4898 tcpEStatsAppHCThruOctetsAcked +* sum(delta(snd_una)), or how many bytes +* were acked. */ };
Signature · 1 line
2.17.1
PATCH v2 6/7 bpf: Add skb->sk, bpf_sk_fullsock and bpf_tcp_sock tests to test_verifer
In reply to Martin KaFai LauThis patch tests accessing the skb->sk and the new helpers, bpf_sk_fullsock and bpf_tcp_sock.
The errstr of some existing "reference tracking" tests is changed with s/bpf_sock/sock/ and s/socket/sock/ where "sock" is from the verifier's reg_type_str[].
--- tools/testing/selftests/bpf/bpf_util.h | 9 + .../selftests/bpf/verifier/ref_tracking.c | 4 +- tools/testing/selftests/bpf/verifier/sock.c | 384 ++++++++++++++++++ tools/testing/selftests/bpf/verifier/unpriv.c | 2 +- 4 files changed, 396 insertions(+), 3 deletions(-) create mode 100644 tools/testing/selftests/bpf/verifier/sock.c
tools/testing/selftests/bpf/bpf_util.h +9 -0
@@ -48,4 +48,13 @@ static inline unsigned int bpf_num_possible_cpus(void)# define ARRAY_SIZE (x) (sizeof(x) / sizeof((x)[0]))#endif +#ifndef sizeof_field +#define sizeof_field (TYPE ,MEMBER ) sizeof((((TYPE *)0)->MEMBER)) +#endif + +#ifndef offsetofend +#define offsetofend (TYPE ,MEMBER ) \ + (offsetof(TYPE, MEMBER) + sizeof_field(TYPE, MEMBER)) +#endif +#endif /* __BPF_UTIL__ */
tools/testing/selftests/bpf/verifier/ref_tracking.c +2 -2
@@ -547,7 +547,7 @@ BPF_EXIT_INSN(), }, .prog_type = BPF_PROG_TYPE_SCHED_CLS, - .errstr = "cannot write into socket", + .errstr = "cannot write into sock", .result = REJECT, }, {
@@ -562,7 +562,7 @@ BPF_EXIT_INSN(), }, .prog_type = BPF_PROG_TYPE_SCHED_CLS, - .errstr = "invalid bpf_sock access off=0 size=8", + .errstr = "invalid sock access off=0 size=8", .result = REJECT, }, {
tools/testing/selftests/bpf/verifier/sock.c new file +384 -0
384 lines not on this page · raw message
tools/testing/selftests/bpf/verifier/unpriv.c +1 -1
@@ -365,7 +365,7 @@ }, .result = REJECT, //.errstr = "same insn cannot be used with different pointers", - .errstr = "cannot write into socket", + .errstr = "cannot write into sock", .prog_type = BPF_PROG_TYPE_SCHED_CLS, }, {
Signature · 1 line
2.17.1
PATCH v2 7/7 bpf: Add test_sock_fields for skb->sk and bpf_tcp_sock
In reply to Martin KaFai LauThis patch adds a C program to show the usage onskb->sk and bpf_tcp_sock.
--- tools/testing/selftests/bpf/Makefile | 6 +- tools/testing/selftests/bpf/bpf_helpers.h | 4 + .../testing/selftests/bpf/test_sock_fields.c | 327 ++++++++++++++++++ .../selftests/bpf/test_sock_fields_kern.c | 152 ++++++++ 4 files changed, 487 insertions(+), 2 deletions(-) create mode 100644 tools/testing/selftests/bpf/test_sock_fields.c create mode 100644 tools/testing/selftests/bpf/test_sock_fields_kern.c
tools/testing/selftests/bpf/Makefile +4 -2
@@ -23,7 +23,7 @@ TEST_GEN_PROGS = test_verifier test_tag test_maps test_lru_map test_lpm_map test test_align test_verifier_log test_dev_cgroup test_tcpbpf_user \ 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_netcnt test_tcpnotify_user test_sock_fields BPF_OBJ_FILES = \ test_xdp_redirect.o test_xdp_meta.o sockmap_parse_prog.o \
@@ -35,7 +35,8 @@ BPF_OBJ_FILES = \ sendmsg4_prog.o sendmsg6_prog.o test_lirc_mode2_kern.o \ get_cgroup_id_kern.o socket_cookie_prog.o test_select_reuseport_kern.o \ test_skb_cgroup_id_kern.o bpf_flow.o netcnt_prog.o test_xdp_vlan.o \ - xdp_dummy.o test_map_in_map.o test_spin_lock.o test_map_lock.o + xdp_dummy.o test_map_in_map.o test_spin_lock.o test_map_lock.o \ + test_sock_fields_kern.o # Objects are built with default compilation flags and with sub-register # code-gen enabled.
@@ -111,6 +112,7 @@ $(OUTPUT)/test_progs: trace_helpers.c $(OUTPUT)/get_cgroup_id_user: cgroup_helpers.c $(OUTPUT)/test_cgroup_storage: cgroup_helpers.c $(OUTPUT)/test_netcnt: cgroup_helpers.c +$(OUTPUT)/test_sock_fields: cgroup_helpers.c .PHONY: force
tools/testing/selftests/bpf/bpf_helpers.h +4 -0
@@ -176,6 +176,10 @@ static void (*bpf_spin_lock)(struct bpf_spin_lock *lock) = (void *) BPF_FUNC_spin_lock;static void (*bpf_spin_unlock)(struct bpf_spin_lock *lock) = (void *) BPF_FUNC_spin_unlock; +static struct bpf_sock *(*bpf_sk_fullsock)(struct bpf_sock *sk) = + (void *) BPF_FUNC_sk_fullsock; +static struct bpf_tcp_sock *(*bpf_tcp_sock)(struct bpf_sock *sk) = + (void *) BPF_FUNC_tcp_sock;/* llvm builtin functions that eBPF C program may use to * emit BPF_LD_ABS and BPF_LD_IND instructions
tools/testing/selftests/bpf/test_sock_fields.c new file +327 -0
327 lines not on this page · raw message
tools/testing/selftests/bpf/test_sock_fields_kern.c new file +152 -0
152 lines not on this page · raw message
Signature · 1 line
2.17.1
Quoted 27 lines · Martin KaFai Lau
This series adds
__sk_buff->sk, "structbpf_tcp_sock",BPF_FUNC_sk_fullsockandBPF_FUNC_tcp_sock. Together, they provide a common way to expose the members of "structtcp_sock" and "structbpf_sock" for thebpf_progto access.The patch series first adds a
bpf_sockpointer to__sk_buffand a new helperBPF_FUNC_sk_fullsock.It then adds
BPF_FUNC_tcp_sockto get abpf_tcp_sockpointer from abpf_sockpointer.The current use case is to allow a
cg_skb_bpf_progto provide per cgroup traffic policing/shaping.Please see individual patch for details.
v2:
- Patch 1 depends on
commitd623876646be("bpf: Fix narrow load on abpf_sockreturned fromsk_lookup()") in the bpf branch.
- Addsk_to_full_sk()tobpf_sk_fullsock()andbpf_tcp_sock()
such that there is a way to access the listener's sk andtcp_sk
when__sk_buff->skis arequest_sock.
The comments in the uapibpf.his updated accordingly.
-bpf_ctx_range_till()is used inbpf_sock_common_is_valid_access()
in patch 1. Saved a few lines.
- Patch 2 is new in v2 and it adds "state", "dst_ip4", "dst_ip6" and
Quoted 8 lines
"
dst_port" to thebpf_sock. Narrow load is allowed on them. The "state" (i.e.sk_state) has already been used inINET_DIAG(e.g. ss -t) andgetsockopt(TCP_INFO).
- While at it in the new patch 2, also allow narrow load on some existing fields of thebpf_sock, which are "family", "type", "protocol" and "src_port". Only allow loading from first byte for now. i.e. does not allow narrow load starting from the 2nd byte.
- Add some narrow load tests to the test_verifier'ssock.c
Daniel,
I believe this new revision addresses your concerns exactly as we discussed. So I pushed it to bpf-next.
please double check that it's what you expected.
We can always revert.
Thanks everyone!
Daniel Borkmann
maintainerQuoted 37 lines · Alexei Starovoitov
Quoted 27 lines · Martin KaFai Lau
This series adds
__sk_buff->sk, "structbpf_tcp_sock",BPF_FUNC_sk_fullsockandBPF_FUNC_tcp_sock. Together, they provide a common way to expose the members of "structtcp_sock" and "structbpf_sock" for thebpf_progto access.The patch series first adds a
bpf_sockpointer to__sk_buffand a new helperBPF_FUNC_sk_fullsock.It then adds
BPF_FUNC_tcp_sockto get abpf_tcp_sockpointer from abpf_sockpointer.The current use case is to allow a
cg_skb_bpf_progto provide per cgroup traffic policing/shaping.Please see individual patch for details.
v2:
- Patch 1 depends on
commitd623876646be("bpf: Fix narrow load on abpf_sockreturned fromsk_lookup()") in the bpf branch.
- Addsk_to_full_sk()tobpf_sk_fullsock()andbpf_tcp_sock()
such that there is a way to access the listener's sk andtcp_sk
when__sk_buff->skis arequest_sock.
The comments in the uapibpf.his updated accordingly.
-bpf_ctx_range_till()is used inbpf_sock_common_is_valid_access()
in patch 1. Saved a few lines.
- Patch 2 is new in v2 and it adds "state", "dst_ip4", "dst_ip6" andQuoted 8 lines
"
dst_port" to thebpf_sock. Narrow load is allowed on them. The "state" (i.e.sk_state) has already been used inINET_DIAG(e.g. ss -t) andgetsockopt(TCP_INFO).
- While at it in the new patch 2, also allow narrow load on some existing fields of thebpf_sock, which are "family", "type", "protocol" and "src_port". Only allow loading from first byte for now. i.e. does not allow narrow load starting from the 2nd byte.
- Add some narrow load tests to the test_verifier'ssock.c
Quoted 6 lines
Daniel,
I believe this new revision addresses your concerns exactly as we discussed. So I pushed it to bpf-next.
please double check that it's what you expected.
We can always revert.
Thanks everyone!
Yep, looks better, thanks!