bpf: tcp: Support arbitrary SYN Cookie at TC.
Subsystems (8)
v5 cover bpf: tcp: Support arbitrary SYN Cookie at TC.
Under SYN Flood, the TCP stack generates SYN Cookie to remain stateless for the connection request until a valid ACK is responded to the SYN+ACK.
The cookie contains two kinds of host-specific bits, a timestamp and secrets, so only can it be validated by the generator. It means SYN Cookie consumes network resources between the client and the server; intermediate nodes must remember which nodes to route ACK for the cookie.
SYN Proxy reduces such unwanted resource allocation by handling 3WHS at the edge network. After SYN Proxy completes 3WHS, it forwards SYN to the backend server and completes another 3WHS. However, since the server's ISN differs from the cookie, the proxy must manage the ISN mappings and fix up SEQ/ACK numbers in every packet for each connection. If a proxy node goes down, all the connections through it are terminated. Keeping a state at proxy is painful from that perspective.
At AWS, we use a dirty hack to build truly stateless SYN Proxy at scale. Our SYN Proxy consists of the front proxy layer and the backend kernel module. (See slides of LPC2023 [0], p37 - p48)
The cookie that SYN Proxy generates differs from the kernel's cookie in that it contains a secret (called rolling salt) (i) shared by all the proxy nodes so that any node can validate ACK and (ii) updated periodically so that old cookies cannot be validated and we need not encode a timestamp for the cookie. Also, ISN contains WScale, SACK, and ECN, not in TS val. This is not to sacrifice any connection quality, where some customers turn off TCP timestamps option due to retro CVE.
After 3WHS, the proxy restores SYN, encapsulates ACK into SYN, and forward the TCP-in-TCP packet to the backend server. Our kernel module works at Netfilter input/output hooks and first feeds SYN to the TCP stack to initiate 3WHS. When the module is triggered for SYN+ACK, it looks up the corresponding request socket and overwrites tcp_rsk(req)->snt_isn with the proxy's cookie. Then, the module can complete 3WHS with the original ACK as is.
This way, our SYN Proxy does not manage the ISN mappings nor wait for SYN+ACK from the backend thus can remain stateless. It's working very well for high-bandwidth services like multiple Tbps, but we are looking for a way to drop the dirty hack and further optimise the sequences.
If we could validate an arbitrary SYN Cookie on the backend server with BPF, the proxy would need not restore SYN nor pass it. After validating ACK, the proxy node just needs to forward it, and then the server can do the lightweight validation (e.g. check if ACK came from proxy nodes, etc) and create a connection from the ACK.
This series allows us to create a full sk from an arbitrary SYN Cookie, which is done in 3 steps.
1) At tc, BPF prog calls a new kfunc to create a reqsk and configure
it based on the argument populated from SYN Cookie. The reqsk has
its listener as req->rsk_listener and is passed to the TCP stack as
skb->sk. 2) During TCP socket lookup for the skb, skb_steal_sock() returns a
listener in the reuseport group that inet_reqsk(skb->sk)->rsk_listener
belongs to. 3) In cookie_v[46]_check(), the reqsk (skb->sk) is fully initialised and a full sk is created.
The kfunc usage is as follows:
struct tcp_cookie_attributes attr = {
.tcp_opt = {
.mss_clamp = mss,
.wscale_ok = wscale_ok,
.rcv_scale = recv_scale, /* Server's WScale < 15 */
.snd_scale = send_scale, /* Client's WScale < 15 */
.tstamp_ok = tstamp_ok,
.rcv_tsval = tsval,
.rcv_tsecr = tsecr,
.sack_ok = sack_ok,
},
.ecn_ok = ecn_ok,
.usec_ts_ok = usec_ts_ok,
};
skc = bpf_skc_lookup_tcp(...);
sk = (struct sock *)bpf_skc_to_tcp_sock(skc);
bpf_sk_assign_tcp_reqsk(skb, sk, attr, sizeof(attr));
bpf_sk_release(skc);[0]: https://lpc.events/event/17/contributions/1645/attachments/1350/2701/SYN_Proxy_at_Scale_with_BPF.pdf
Changes:
v5:
* Split patch 1-3
* Patch 3
* Clear req->rsk_listener in skb_steal_sock()
* Patch 4 & 5
* Move sysctl validation and tsoff init from cookie_bpf_check() to kfunc
* Patch 5
* Do not increment LINUX_MIB_SYNCOOKIES(RECV|FAILED)
* Patch 6
* Remove __always_inline
* Test if tcp_handle_{syn,ack}() is executed
* Move some definition to bpf_tracing_net.h
* s/BPF_F_CURRENT_NETNS/-1/
v4: https://lore.kernel.org/bpf/[email protected]/
* Patch 1 & 2
* s/CONFIG_SYN_COOKIE/CONFIG_SYN_COOKIES/
* Patch 1
* Don't set rcv_wscale for BPF SYN Cookie case.
* Patch 2
* Add test for tcp_opt.{unused,rcv_wscale} in kfunc
* Modify skb_steal_sock() to avoid resetting skb-sk
* Support SO_REUSEPORT lookup
* Patch 3
* Add CONFIG_SYN_COOKIES to Kconfig for CI
* Define BPF_F_CURRENT_NETNS
v3: https://lore.kernel.org/netdev/[email protected]/
* Guard kfunc and req->syncookie part in inet6?_steal_sock() with CONFIG_SYN_COOKIE
v2: https://lore.kernel.org/netdev/[email protected]/
* Drop SOCK_OPS and move SYN Cookie validation logic to TC with kfunc.
* Add cleanup patches to reduce discrepancy between cookie_v[46]_check()
v1: https://lore.kernel.org/bpf/[email protected]/
Kuniyuki Iwashima (6):
tcp: Move tcp_ns_to_ts() to tcp.h
tcp: Move skb_steal_sock() to request_sock.h
bpf: tcp: Handle BPF SYN Cookie in skb_steal_sock().
bpf: tcp: Handle BPF SYN Cookie in cookie_v[46]_check().
bpf: tcp: Support arbitrary SYN Cookie.
selftest: bpf: Test bpf_sk_assign_tcp_reqsk().
include/net/request_sock.h | 39 ++ include/net/sock.h | 25 - include/net/tcp.h | 35 ++ net/core/filter.c | 118 +++- net/core/sock.c | 14 +- net/ipv4/syncookies.c | 40 +- net/ipv6/syncookies.c | 13 +- tools/testing/selftests/bpf/bpf_kfuncs.h | 10 + tools/testing/selftests/bpf/config | 1 + .../bpf/prog_tests/tcp_custom_syncookie.c | 169 +++++ .../selftests/bpf/progs/bpf_tracing_net.h | 17 + .../selftests/bpf/progs/test_siphash.h | 64 ++ .../bpf/progs/test_tcp_custom_syncookie.c | 580 ++++++++++++++++++ .../bpf/progs/test_tcp_custom_syncookie.h | 140 +++++ 14 files changed, 1219 insertions(+), 46 deletions(-) create mode 100644 tools/testing/selftests/bpf/prog_tests/tcp_custom_syncookie.c create mode 100644 tools/testing/selftests/bpf/progs/test_siphash.h create mode 100644 tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.c create mode 100644 tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.h
Signature · 1 line
2.30.2
PATCH v5 1/6 tcp: Move tcp_ns_to_ts() to tcp.h
We will support arbitrary SYN Cookie with BPF.
When BPF prog validates ACK and kfunc allocates a reqsk, we need to call tcp_ns_to_ts() to calculate an offset of TSval for later use:
time
t0 : Send SYN+ACK
-> tsval = Initial TSval (Random Number)
t1 : Recv ACK of 3WHS
-> tsoff = TSecr - tcp_ns_to_ts(usec_ts_ok, tcp_clock_ns())
= Initial TSval - t1
t2 : Send ACK
-> tsval = t2 + tsoff
= Initial TSval + (t2 - t1)
= Initial TSval + Time Delta (x)(x) Note that the time delta does not include the initial RTT from t0 to t1.
Let's move tcp_ns_to_ts() to tcp.h.
--- include/net/tcp.h | 9 +++++++++ net/ipv4/syncookies.c | 9 --------- 2 files changed, 9 insertions(+), 9 deletions(-)
include/net/tcp.h +9 -0
@@ -577,6 +577,15 @@ static inline u32 tcp_cookie_time(void)return val; } +/* Convert one nsec 64bit timestamp to ts (ms or usec resolution) */ +static inline u64 tcp_ns_to_ts (bool usec_ts,u64 val) +{ +if (usec_ts) +return div_u64 (val,NSEC_PER_USEC ); + +return div_u64 (val,NSEC_PER_MSEC ); +} +u32 __cookie_v4_init_sequence (const struct iphdr *iph,const struct tcphdr *th,u16 *mssp);__u32 cookie_v4_init_sequence (const struct sk_buff *skb,__u16 *mss);
net/ipv4/syncookies.c +0 -9
@@ -51,15 +51,6 @@ static u32 cookie_hash(__be32 saddr, __be32 daddr, __be16 sport, __be16 dport, count, &syncookie_secret[c]); } -/* Convert one nsec 64bit timestamp to ts (ms or usec resolution) */ -static u64 tcp_ns_to_ts (bool usec_ts,u64 val) -{ -if (usec_ts) -return div_u64 (val,NSEC_PER_USEC ); - -return div_u64 (val,NSEC_PER_MSEC ); -} -/* * when syncookies are in effect and tcp timestamps are enabled we encode * tcp options in the lower bits of the timestamp value that will be
Signature · 1 line
2.30.2
PATCH v5 2/6 tcp: Move skb_steal_sock() to request_sock.h
In reply to Kuniyuki IwashimaWe will support arbitrary SYN Cookie with BPF.
If BPF prog validates ACK and kfunc allocates a reqsk, it will be carried to TCP stack as skb->sk with req->syncookie 1.
In skb_steal_sock(), we need to check inet_reqsk(sk)->syncookie to see if the reqsk is created by kfunc. However, inet_reqsk() is not available in sock.h.
Let's move skb_steal_sock() to request_sock.h.
While at it, we refactor skb_steal_sock() so it returns early if skb->sk is NULL to minimise the following patch.
--- include/net/request_sock.h | 28 ++++++++++++++++++++++++++++ include/net/sock.h | 25 ------------------------- 2 files changed, 28 insertions(+), 25 deletions(-)
include/net/request_sock.h +28 -0
@@ -83,6 +83,34 @@ static inline struct sock *req_to_sk(struct request_sock *req)return (struct sock *)req; } +/** +* skb_steal_sock - steal a socket from an sk_buff +* @skb: sk_buff to steal the socket from +* @refcounted: is set to true if the socket is reference-counted +* @prefetched: is set to true if the socket was assigned from bpf +*/ +static inline struct sock *skb_steal_sock (struct sk_buff *skb, +bool *refcounted,bool *prefetched) +{ +struct sock *sk = skb->sk; + +if (!sk) { + *prefetched = false; + *refcounted = false; +return NULL ; + } + + *prefetched =skb_sk_is_prefetched (skb); +if (*prefetched) + *refcounted =sk_is_refcounted (sk); +else + *refcounted = true; + + skb->destructor =NULL ; + skb->sk =NULL ; +return sk; +} +static inline struct request_sock *reqsk_alloc (const struct request_sock_ops *ops,struct sock *sk_listener,bool attach_listener)
include/net/sock.h +0 -25
@@ -2838,31 +2838,6 @@ sk_is_refcounted(struct sock *sk)return !sk_fullsock (sk) || !sock_flag (sk,SOCK_RCU_FREE ); } -/** -* skb_steal_sock - steal a socket from an sk_buff -* @skb: sk_buff to steal the socket from -* @refcounted: is set to true if the socket is reference-counted -* @prefetched: is set to true if the socket was assigned from bpf -*/ -static inline struct sock * -skb_steal_sock (struct sk_buff *skb,bool *refcounted,bool *prefetched) -{ -if (skb->sk) { -struct sock *sk = skb->sk; - - *refcounted = true; - *prefetched =skb_sk_is_prefetched (skb); -if (*prefetched) - *refcounted =sk_is_refcounted (sk); - skb->destructor =NULL ; - skb->sk =NULL ; -return sk; - } - *prefetched = false; - *refcounted = false; -return NULL ; -} -/* Checks if this SKB belongs to an HW offloaded socket * and whether any SW fallbacks are required based on dev. * Check decrypted mark in case skb_orphan() cleared socket.
Signature · 1 line
2.30.2
PATCH v5 3/6 bpf: tcp: Handle BPF SYN Cookie in skb_steal_sock().
In reply to Kuniyuki IwashimaWe will support arbitrary SYN Cookie with BPF.
If BPF prog validates ACK and kfunc allocates a reqsk, it will be carried to TCP stack as skb->sk with req->syncookie 1. Also, the reqsk has its listener as req->rsk_listener with no refcnt taken.
When the TCP stack looks up a socket from the skb, we steal inet_reqsk(skb->sk)->rsk_listener in skb_steal_sock() so that the skb will be processed in cookie_v[46]_check() with the listener or another one in the same reuseport group.
Note that we do not clear skb->sk and skb->destructor so that we can carry the reqsk to cookie_v[46]_check().
--- include/net/request_sock.h | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-)
include/net/request_sock.h +13 -2
@@ -101,10 +101,21 @@ static inline struct sock *skb_steal_sock(struct sk_buff *skb, } *prefetched =skb_sk_is_prefetched (skb); -if (*prefetched) +if (*prefetched) { +#if IS_ENABLED (CONFIG_SYN_COOKIES ) +if (sk->sk_state ==TCP_NEW_SYN_RECV &&inet_reqsk (sk)->syncookie) { +struct request_sock *req =inet_reqsk (sk); + + *refcounted = false; + sk = req->rsk_listener; + req->rsk_listener =NULL ; +return sk; + } +#endif *refcounted =sk_is_refcounted (sk); -else + }else { *refcounted = true; + } skb->destructor =NULL ; skb->sk =NULL ;
Signature · 1 line
2.30.2
PATCH v5 4/6 bpf: tcp: Handle BPF SYN Cookie in cookie_v[46]_check().
In reply to Kuniyuki IwashimaWe will support arbitrary SYN Cookie with BPF in the following patch.
If BPF prog validates ACK and kfunc allocates a reqsk, it will be carried to cookie_[46]_check() as skb->sk. If skb->sk is not NULL, we call cookie_bpf_check().
Then, we clear skb->sk and skb->destructor, which are needed not to hold refcnt for reqsk and the listener.
After that, we finish initialisation for the remaining fields with cookie_tcp_reqsk_init().
Note that the server side WScale is set only for non-BPF SYN Cookie.
--- include/net/tcp.h | 20 ++++++++++++++++++++ net/ipv4/syncookies.c | 31 +++++++++++++++++++++++++++---- net/ipv6/syncookies.c | 13 +++++++++---- 3 files changed, 56 insertions(+), 8 deletions(-)
include/net/tcp.h +20 -0
@@ -599,6 +599,26 @@ static inline bool cookie_ecn_ok(const struct net *net, const struct dst_entry *dst_feature (dst,RTAX_FEATURE_ECN ); } +#if IS_ENABLED (CONFIG_BPF ) +static inline bool cookie_bpf_ok (struct sk_buff *skb) +{ +return skb->sk; +} + +struct request_sock *cookie_bpf_check (struct sock *sk,struct sk_buff *skb); +#else +static inline bool cookie_bpf_ok (struct sk_buff *skb) +{ +return false; +} + +static inline struct request_sock *cookie_bpf_check (struct net *net,struct sock *sk, +struct sk_buff *skb) +{ +return NULL ; +} +#endif +/* From net/ipv6/syncookies.c */ int __cookie_v6_check (const struct ipv6hdr *iph,const struct tcphdr *th);struct sock *cookie_v6_check (struct sock *sk,struct sk_buff *skb);
net/ipv4/syncookies.c +27 -4
@@ -295,6 +295,24 @@ static int cookie_tcp_reqsk_init(struct sock *sk, struct sk_buff *skb,return 0 ; } +#if IS_ENABLED (CONFIG_BPF ) +struct request_sock *cookie_bpf_check (struct sock *sk,struct sk_buff *skb) +{ +struct request_sock *req =inet_reqsk (skb->sk); + + skb->sk =NULL ; + skb->destructor =NULL ; + +if (cookie_tcp_reqsk_init (sk, skb, req)) { +reqsk_free (req); + req =NULL ; + } + +return req; +} +EXPORT_SYMBOL_GPL (cookie_bpf_check); +#endif + struct request_sock *cookie_tcp_reqsk_alloc(const struct request_sock_ops *ops, struct sock *sk, struct sk_buff *skb, struct tcp_options_received *tcp_opt,
@@ -395,9 +413,13 @@ struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb) !th->ack || th->rst) goto out; - req =cookie_tcp_check (net, sk, skb); -if (IS_ERR (req)) - goto out; +if (cookie_bpf_ok (skb)) { + req =cookie_bpf_check (sk, skb); + }else { + req =cookie_tcp_check (net, sk, skb); +if (IS_ERR (req)) + goto out; + }if (!req) goto out_drop;
@@ -445,7 +467,8 @@ struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb) ireq->wscale_ok, &rcv_wscale, dst_metric(&rt->dst, RTAX_INITRWND)); - ireq->rcv_wscale = rcv_wscale; +if (!req->syncookie) + ireq->rcv_wscale = rcv_wscale; ireq->ecn_ok &=cookie_ecn_ok (net, &rt->dst); ret =tcp_get_cookie_sock (sk, skb, req, &rt->dst);
net/ipv6/syncookies.c +9 -4
@@ -182,9 +182,13 @@ struct sock *cookie_v6_check(struct sock *sk, struct sk_buff *skb) !th->ack || th->rst) goto out; - req =cookie_tcp_check (net, sk, skb); -if (IS_ERR (req)) - goto out; +if (cookie_bpf_ok (skb)) { + req =cookie_bpf_check (sk, skb); + }else { + req =cookie_tcp_check (net, sk, skb); +if (IS_ERR (req)) + goto out; + }if (!req) goto out_drop;
@@ -247,7 +251,8 @@ struct sock *cookie_v6_check(struct sock *sk, struct sk_buff *skb) ireq->wscale_ok, &rcv_wscale, dst_metric(dst, RTAX_INITRWND)); - ireq->rcv_wscale = rcv_wscale; +if (!req->syncookie) + ireq->rcv_wscale = rcv_wscale; ireq->ecn_ok &=cookie_ecn_ok (net, dst); ret =tcp_get_cookie_sock (sk, skb, req, dst);
Signature · 1 line
2.30.2
PATCH v5 5/6 bpf: tcp: Support arbitrary SYN Cookie.
In reply to Kuniyuki IwashimaThis patch adds a new kfunc available at TC hook to support arbitrary SYN Cookie.
The basic usage is as follows:
struct tcp_cookie_attributes attr = {
.tcp_opt = {
.mss_clamp = mss,
.wscale_ok = wscale_ok,
.rcv_scale = recv_scale, /* Server's WScale < 15 */
.snd_scale = send_scale, /* Client's WScale < 15 */
.tstamp_ok = tstamp_ok,
.rcv_tsval = tsval,
.rcv_tsecr = tsecr,
.sack_ok = sack_ok,
},
.ecn_ok = ecn_ok,
.usec_ts_ok = usec_ts_ok,
};
skc = bpf_skc_lookup_tcp(...);
sk = (struct sock *)bpf_skc_to_tcp_sock(skc);
bpf_sk_assign_tcp_reqsk(skb, sk, attr, sizeof(attr));
bpf_sk_release(skc);bpf_sk_assign_tcp_reqsk() takes skb, a listener sk, and struct tcp_cookie_attributes and allocates reqsk and configures it. Then, bpf_sk_assign_tcp_reqsk() links reqsk with skb and the listener.
The notable thing here is that we do not hold refcnt for both reqsk and listener. To differentiate that, we mark reqsk->syncookie, which is only used in TX for now. So, if reqsk->syncookie is 1 in RX, it means that the reqsk is allocated by kfunc.
When skb is freed, sock_pfree() checks if reqsk->syncookie is 1, and in that case, we set NULL to reqsk->rsk_listener before calling reqsk_free() as reqsk does not hold a refcnt of the listener.
When the TCP stack looks up a socket from the skb, we steal the listener from the reqsk in skb_steal_sock() and create a full sk in cookie_v[46]_check().
The refcnt of reqsk will finally be set to 1 in tcp_get_cookie_sock() after creating a full sk.
Note that we can use the unused bits in struct tcp_options_received and extend struct tcp_cookie_attributes in the future when we add a new attribute that is determined in 3WHS.
--- include/net/tcp.h | 6 +++ net/core/filter.c | 118 +++++++++++++++++++++++++++++++++++++++++++++- net/core/sock.c | 14 +++++- 3 files changed, 134 insertions(+), 4 deletions(-)
include/net/tcp.h +6 -0
@@ -600,6 +600,12 @@ static inline bool cookie_ecn_ok(const struct net *net, const struct dst_entry * }#if IS_ENABLED (CONFIG_BPF ) +struct tcp_cookie_attributes { +struct tcp_options_received tcp_opt; +bool ecn_ok; +bool usec_ts_ok; +} __packed; +static inline bool cookie_bpf_ok (struct sk_buff *skb) {return skb->sk;
net/core/filter.c +116 -2
142 lines not on this page · raw message
net/core/sock.c +12 -2
@@ -2579,8 +2579,18 @@ EXPORT_SYMBOL(sock_efree);#ifdef CONFIG_INET void sock_pfree (struct sk_buff *skb) { -if (sk_is_refcounted (skb->sk)) -sock_gen_put (skb->sk); +struct sock *sk = skb->sk; + +if (!sk_is_refcounted (sk)) +return ; + +if (sk->sk_state ==TCP_NEW_SYN_RECV &&inet_reqsk (sk)->syncookie) { +inet_reqsk (sk)->rsk_listener =NULL ; +reqsk_free (inet_reqsk (sk)); +return ; + } + +sock_gen_put (sk); }EXPORT_SYMBOL (sock_pfree);#endif /* CONFIG_INET */
Signature · 1 line
2.30.2
PATCH v5 6/6 selftest: bpf: Test bpf_sk_assign_tcp_reqsk().
In reply to Kuniyuki IwashimaThis commit adds a sample selftest to demonstrate how we can use bpf_sk_assign_tcp_reqsk() as the backend of SYN Proxy.
The test creates IPv4/IPv6 x TCP/MPTCP connections and transfer messages over them on lo with BPF tc prog attached.
The tc prog will process SYN and returns SYN+ACK with the following ISN and TS. In a real use case, this part will be done by other hosts.
MSB LSB
ISN: | 31 ... 8 | 7 6 | 5 | 4 | 3 2 1 0 |
| Hash_1 | MSS | ECN | SACK | WScale | TS: | 31 ... 8 | 7 ... 0 |
| Random | Hash_2 |WScale in SYN is reused in SYN+ACK.
The client returns ACK, and tc prog will recalculate ISN and TS from ACK and validate SYN Cookie.
If it's valid, the prog calls kfunc to allocate a reqsk for skb and configure the reqsk based on the argument created from SYN Cookie.
Later, the reqsk will be processed in cookie_v[46]_check() to create a connection.
--- tools/testing/selftests/bpf/bpf_kfuncs.h | 10 + tools/testing/selftests/bpf/config | 1 + .../bpf/prog_tests/tcp_custom_syncookie.c | 169 +++++ .../selftests/bpf/progs/bpf_tracing_net.h | 17 + .../selftests/bpf/progs/test_siphash.h | 64 ++ .../bpf/progs/test_tcp_custom_syncookie.c | 580 ++++++++++++++++++ .../bpf/progs/test_tcp_custom_syncookie.h | 140 +++++ 7 files changed, 981 insertions(+) create mode 100644 tools/testing/selftests/bpf/prog_tests/tcp_custom_syncookie.c create mode 100644 tools/testing/selftests/bpf/progs/test_siphash.h create mode 100644 tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.c create mode 100644 tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.h
tools/testing/selftests/bpf/bpf_kfuncs.h +10 -0
@@ -51,6 +51,16 @@ extern int bpf_dynptr_clone(const struct bpf_dynptr *ptr, struct bpf_dynptr *clo extern int bpf_sock_addr_set_sun_path(struct bpf_sock_addr_kern *sa_kern, const __u8 *sun_path, __u32 sun_path__sz) __ksym; +/* Description +* Allocate and configure a reqsk and link it with a listener and skb. +* Returns +* Error code +*/ +struct sock ; +struct tcp_cookie_attributes ; +extern int bpf_sk_assign_tcp_reqsk(struct __sk_buff *skb, struct sock *sk, + struct tcp_cookie_attributes *attr, int attr__sz) __ksym; +void *bpf_cast_to_kern_ctx (void *) __ksym;void *bpf_rdonly_cast (void *obj,__u32 btf_id) __ksym;
tools/testing/selftests/bpf/config +1 -0
@@ -81,6 +81,7 @@ CONFIG_NF_NAT=y CONFIG_RC_CORE=y CONFIG_SECURITY=y CONFIG_SECURITYFS=y +CONFIG_SYN_COOKIES=y CONFIG_TEST_BPF=m CONFIG_USERFAULTFD=y CONFIG_VSOCKETS=y
tools/testing/selftests/bpf/prog_tests/tcp_custom_syncookie.c new file +169 -0
169 lines not on this page · raw message
tools/testing/selftests/bpf/progs/bpf_tracing_net.h +17 -0
@@ -26,6 +26,7 @@#define IPV6_AUTOFLOWLABEL 70#define TC_ACT_UNSPEC (-1) +#define TC_ACT_OK 0#define TC_ACT_SHOT 2#define SOL_TCP 6
@@ -50,9 +51,25 @@#define ICSK_TIME_LOSS_PROBE 5#define ICSK_TIME_REO_TIMEOUT 6 +#define ETH_ALEN 6#define ETH_HLEN 14 +#define ETH_P_IP 0x0800#define ETH_P_IPV6 0x86DD +#define NEXTHDR_TCP 6 + +#define TCPOPT_NOP 1 +#define TCPOPT_EOL 0 +#define TCPOPT_MSS 2 +#define TCPOPT_WINDOW 3 +#define TCPOPT_TIMESTAMP 8 +#define TCPOPT_SACK_PERM 4 + +#define TCPOLEN_MSS 4 +#define TCPOLEN_WINDOW 3 +#define TCPOLEN_TIMESTAMP 10 +#define TCPOLEN_SACK_PERM 2 +#define CHECKSUM_NONE 0#define CHECKSUM_PARTIAL 3
tools/testing/selftests/bpf/progs/test_siphash.h new file +64 -0
64 lines not on this page · raw message
tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.c new file +580 -0
580 lines not on this page · raw message
tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.h new file +140 -0
140 lines not on this page · raw message
Signature · 1 line
2.30.2
Martin KaFai Lau
reviewerRe: [PATCH v5 bpf-next 6/6] selftest: bpf: Test bpf_sk_assign_tcp_reqsk().
Quoted 19 lines · Kuniyuki Iwashima
This commit adds a sample selftest to demonstrate how we can use
bpf_sk_assign_tcp_reqsk()as the backend of SYN Proxy.The test creates IPv4/IPv6 x TCP/MPTCP connections and transfer messages over them on lo with BPF tc prog attached.
The tc prog will process SYN and returns SYN+ACK with the following ISN and TS. In a real use case, this part will be done by other hosts.
MSB LSB
ISN: | 31 ... 8 | 7 6 | 5 | 4 | 3 2 1 0 | | Hash_1 | MSS | ECN | SACK | WScale |TS: | 31 ... 8 | 7 ... 0 | | Random | Hash_2 |WScale in SYN is reused in SYN+ACK.
Quoted 8 lines
The client returns ACK, and tc prog will recalculate ISN and TS from ACK and validate SYN Cookie.
If it's valid, the prog calls kfunc to allocate a reqsk for skb and configure the reqsk based on the argument created from SYN Cookie.
Later, the reqsk will be processed in cookie_v[46]_check() to create a connection.
The patch set looks good.
One thing I just noticed is about writing/reading bits into/from "struct tcp_options_received". More on this below.
[ ... ]
Quoted 10 lines
tools/testing/selftests/bpf/prog_tests/tcp_custom_syncookie.c new file +10
-0+void test_tcp_custom_syncookie (void ) +{ +struct test_tcp_custom_syncookie *skel; +int i; + +if (setup_netns ()) +return ; + + skel =test_tcp_custom_syncookie__open_and_load (); +if (!ASSERT_OK_PTR (skel,"open_and_load" ))
tools/testing/selftests/bpf/prog_tests/tcp_custom_syncookie.c line 158
Quoted 10 lines
tools/testing/selftests/bpf/prog_tests/tcp_custom_syncookie.c new file +10
-0+return ; + +if (setup_tc (skel)) + goto destroy_skel; + +for (i =0 ; i <ARRAY_SIZE (test_cases); i++) { + skel->bss->handled_syn = false; + skel->bss->handled_ack = false; + +test__start_subtest (test_cases[i].name);
This should be tested with:
if (!test__start_subtest(test_cases[i].name)) continue;
to skip the create_connection(). Probably do it at the beginning of the for loop.
Quoted 11 lines
tools/testing/selftests/bpf/prog_tests/tcp_custom_syncookie.c new file +11
-0+create_connection (&test_cases[i]); + +ASSERT_EQ (skel->bss->handled_syn, true,"SYN is not handled at tc." ); +ASSERT_EQ (skel->bss->handled_ack, true,"ACK is not handled at tc" ); + } + +destroy_skel: +system ("tc qdisc del dev lo clsact" ); + +test_tcp_custom_syncookie__destroy (skel); +}
[ ... ]
Quoted 25 lines
tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.c new file +25
-0+static int tcp_parse_option (__u32 index,struct tcp_syncookie *ctx) +{ +struct tcp_options_received *tcp_opt = &ctx->attr.tcp_opt; +char opcode, opsize; + +if (ctx->ptr +1 > ctx->data_end) + goto stop; + + opcode = *ctx->ptr++; + +if (opcode ==TCPOPT_EOL ) + goto stop; + +if (opcode ==TCPOPT_NOP ) + goto next; + +if (ctx->ptr +1 > ctx->data_end) + goto stop; + + opsize = *ctx->ptr++; + +if (opsize <2 ) + goto stop; + +switch (opcode) {
tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.c line 232
Quoted 10 lines
tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.c new file +10
-0+case TCPOPT_MSS : +if (opsize ==TCPOLEN_MSS && ctx->tcp->syn && + ctx->ptr + (TCPOLEN_MSS -2 ) < ctx->data_end) + tcp_opt->mss_clamp =get_unaligned_be16 (ctx->ptr); +break ; +case TCPOPT_WINDOW : +if (opsize ==TCPOLEN_WINDOW && ctx->tcp->syn && + ctx->ptr + (TCPOLEN_WINDOW -2 ) < ctx->data_end) { + tcp_opt->wscale_ok =1 ; + tcp_opt->snd_wscale = *ctx->ptr;
When writing to a bitfield of "struct tcp_options_received" which is a kernel struct, it needs to use the CO-RE api. The BPF_CORE_WRITE_BITFIELD has not been landed yet: https://lore.kernel.org/bpf/4d3dd215a4fd57d980733886f9c11a45e1a9adf3.1702325874.git.dxu@dxuuu.xyz/
The same for reading bitfield but BPF_CORE_READ_BITFIELD() has already been implemented in bpf_core_read.h
Once the BPF_CORE_WRITE_BITFIELD is landed, this test needs to be changed to use the BPF_CORE_{READ,WRITE}_BITFIELD.
Quoted 28 lines
tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.c new file +28
-0+ } +break ; +case TCPOPT_TIMESTAMP : +if (opsize ==TCPOLEN_TIMESTAMP && + ctx->ptr + (TCPOLEN_TIMESTAMP -2 ) < ctx->data_end) { + tcp_opt->saw_tstamp =1 ; + tcp_opt->rcv_tsval =get_unaligned_be32 (ctx->ptr); + tcp_opt->rcv_tsecr =get_unaligned_be32 (ctx->ptr +4 ); + +if (ctx->tcp->syn && tcp_opt->rcv_tsecr) + tcp_opt->tstamp_ok =0 ; +else + tcp_opt->tstamp_ok =1 ; + } +break ; +case TCPOPT_SACK_PERM : +if (opsize ==TCPOLEN_SACK_PERM && ctx->tcp->syn && + ctx->ptr + (TCPOLEN_SACK_PERM -2 ) < ctx->data_end) + tcp_opt->sack_ok =1 ; +break ; + } + + ctx->ptr += opsize -2 ; +next: +return 0 ; +stop: +return 1 ; +}
Re: [PATCH v5 bpf-next 6/6] selftest: bpf: Test bpf_sk_assign_tcp_reqsk().
From: Martin KaFai Lau <[email protected]>
Date: Wed, 13 Dec 2023 12:44:42 -0800
Quoted 60 lines · Kuniyuki Iwashima
Quoted 19 lines
This commit adds a sample selftest to demonstrate how we can use
bpf_sk_assign_tcp_reqsk()as the backend of SYN Proxy.The test creates IPv4/IPv6 x TCP/MPTCP connections and transfer messages over them on lo with BPF tc prog attached.
The tc prog will process SYN and returns SYN+ACK with the following ISN and TS. In a real use case, this part will be done by other hosts.
MSB LSB
ISN: | 31 ... 8 | 7 6 | 5 | 4 | 3 2 1 0 | | Hash_1 | MSS | ECN | SACK | WScale |TS: | 31 ... 8 | 7 ... 0 | | Random | Hash_2 |WScale in SYN is reused in SYN+ACK.
Quoted 8 lines
The client returns ACK, and tc prog will recalculate ISN and TS from ACK and validate SYN Cookie.
If it's valid, the prog calls kfunc to allocate a reqsk for skb and configure the reqsk based on the argument created from SYN Cookie.
Later, the reqsk will be processed in cookie_v[46]_check() to create a connection.
The patch set looks good.
One thing I just noticed is about writing/reading bits into/from "struct
tcp_options_received". More on this below.[ ... ]
Quoted 10 lines
tools/testing/selftests/bpf/prog_tests/tcp_custom_syncookie.c new file +10
-0+void test_tcp_custom_syncookie (void ) +{ +struct test_tcp_custom_syncookie *skel; +int i; + +if (setup_netns ()) +return ; + + skel =test_tcp_custom_syncookie__open_and_load (); +if (!ASSERT_OK_PTR (skel,"open_and_load" ))tools/testing/selftests/bpf/prog_tests/tcp_custom_syncookie.c line 158
Quoted 10 lines
tools/testing/selftests/bpf/prog_tests/tcp_custom_syncookie.c new file +10
-0+return ; + +if (setup_tc (skel)) + goto destroy_skel; + +for (i =0 ; i <ARRAY_SIZE (test_cases); i++) { + skel->bss->handled_syn = false; + skel->bss->handled_ack = false; + +test__start_subtest (test_cases[i].name);This should be tested with:
Quoted 4 lines
if (!test__start_subtest(test_cases[i].name)) continue;to skip the
create_connection(). Probably do it at the beginning of the for loop.
Thanks for catching this!
Will fix.
Quoted 56 lines
Quoted 12 lines
tools/testing/selftests/bpf/prog_tests/tcp_custom_syncookie.c new file +11
-0+create_connection (&test_cases[i]); + +ASSERT_EQ (skel->bss->handled_syn, true,"SYN is not handled at tc." ); +ASSERT_EQ (skel->bss->handled_ack, true,"ACK is not handled at tc" ); + } + +destroy_skel: +system ("tc qdisc del dev lo clsact" ); + +test_tcp_custom_syncookie__destroy (skel); +}[ ... ]
Quoted 25 lines
tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.c new file +25
-0+static int tcp_parse_option (__u32 index,struct tcp_syncookie *ctx) +{ +struct tcp_options_received *tcp_opt = &ctx->attr.tcp_opt; +char opcode, opsize; + +if (ctx->ptr +1 > ctx->data_end) + goto stop; + + opcode = *ctx->ptr++; + +if (opcode ==TCPOPT_EOL ) + goto stop; + +if (opcode ==TCPOPT_NOP ) + goto next; + +if (ctx->ptr +1 > ctx->data_end) + goto stop; + + opsize = *ctx->ptr++; + +if (opsize <2 ) + goto stop; + +switch (opcode) {tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.c line 232
Quoted 10 lines
tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.c new file +10
-0+case TCPOPT_MSS : +if (opsize ==TCPOLEN_MSS && ctx->tcp->syn && + ctx->ptr + (TCPOLEN_MSS -2 ) < ctx->data_end) + tcp_opt->mss_clamp =get_unaligned_be16 (ctx->ptr); +break ; +case TCPOPT_WINDOW : +if (opsize ==TCPOLEN_WINDOW && ctx->tcp->syn && + ctx->ptr + (TCPOLEN_WINDOW -2 ) < ctx->data_end) { + tcp_opt->wscale_ok =1 ; + tcp_opt->snd_wscale = *ctx->ptr;When writing to a bitfield of "struct
tcp_options_received" which is a kernel struct, it needs to use the CO-RE api. TheBPF_CORE_WRITE_BITFIELDhas not been landed yet:
https://lore.kernel.org/bpf/4d3dd215a4fd57d980733886f9c11a45e1a9adf3.1702325874.git.dxu@dxuuu.xyz/
Quoted 5 lines
The same for reading bitfield but
BPF_CORE_READ_BITFIELD()has already been implemented inbpf_core_read.hOnce the
BPF_CORE_WRITE_BITFIELDis landed, this test needs to be changed to use the BPF_CORE_{READ,WRITE}_BITFIELD.
IIUC, the CO-RE api assumes that the offset of bitfields could be changed.
If the size of struct tcp_cookie_attributes is changed, kfunc will not work in this test. So, BPF_CORE_WRITE_BITFIELD() works only when the size of tcp_cookie_attributes is unchanged but fields in tcp_options_received are rearranged or expanded to use the unused@ bits ?
Also, do we need to use BPF_CORE_READ() for other non-bitfields in strcut tcp_options_received (and ecn_ok in struct tcp_cookie_attributes just in case other fields are added to tcp_cookie_attributes and ecn_ok is rearranged) ?
Just trying to understand when to use CO-RE api.
Btw, thanks for merging BPF_CORE_WRITE_BITFIELD patches!
Quoted 29 lines
Quoted 29 lines
tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.c new file +28
-0+ } +break ; +case TCPOPT_TIMESTAMP : +if (opsize ==TCPOLEN_TIMESTAMP && + ctx->ptr + (TCPOLEN_TIMESTAMP -2 ) < ctx->data_end) { + tcp_opt->saw_tstamp =1 ; + tcp_opt->rcv_tsval =get_unaligned_be32 (ctx->ptr); + tcp_opt->rcv_tsecr =get_unaligned_be32 (ctx->ptr +4 ); + +if (ctx->tcp->syn && tcp_opt->rcv_tsecr) + tcp_opt->tstamp_ok =0 ; +else + tcp_opt->tstamp_ok =1 ; + } +break ; +case TCPOPT_SACK_PERM : +if (opsize ==TCPOLEN_SACK_PERM && ctx->tcp->syn && + ctx->ptr + (TCPOLEN_SACK_PERM -2 ) < ctx->data_end) + tcp_opt->sack_ok =1 ; +break ; + } + + ctx->ptr += opsize -2 ; +next: +return 0 ; +stop: +return 1 ; +}
Martin KaFai Lau
reviewerRe: [PATCH v5 bpf-next 6/6] selftest: bpf: Test bpf_sk_assign_tcp_reqsk().
Quoted 43 lines · Kuniyuki Iwashima
Quoted 43 lines
Quoted 25 lines
tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.c new file +25
-0+static int tcp_parse_option (__u32 index,struct tcp_syncookie *ctx) +{ +struct tcp_options_received *tcp_opt = &ctx->attr.tcp_opt; +char opcode, opsize; + +if (ctx->ptr +1 > ctx->data_end) + goto stop; + + opcode = *ctx->ptr++; + +if (opcode ==TCPOPT_EOL ) + goto stop; + +if (opcode ==TCPOPT_NOP ) + goto next; + +if (ctx->ptr +1 > ctx->data_end) + goto stop; + + opsize = *ctx->ptr++; + +if (opsize <2 ) + goto stop; + +switch (opcode) {tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.c line 232
Quoted 10 lines
tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.c new file +10
-0+case TCPOPT_MSS : +if (opsize ==TCPOLEN_MSS && ctx->tcp->syn && + ctx->ptr + (TCPOLEN_MSS -2 ) < ctx->data_end) + tcp_opt->mss_clamp =get_unaligned_be16 (ctx->ptr); +break ; +case TCPOPT_WINDOW : +if (opsize ==TCPOLEN_WINDOW && ctx->tcp->syn && + ctx->ptr + (TCPOLEN_WINDOW -2 ) < ctx->data_end) { + tcp_opt->wscale_ok =1 ; + tcp_opt->snd_wscale = *ctx->ptr;When writing to a bitfield of "struct
tcp_options_received" which is a kernel struct, it needs to use the CO-RE api. TheBPF_CORE_WRITE_BITFIELDhas not been landed yet:
https://lore.kernel.org/bpf/4d3dd215a4fd57d980733886f9c11a45e1a9adf3.1702325874.git.dxu@dxuuu.xyz/The same for reading bitfield but
BPF_CORE_READ_BITFIELD()has already been implemented inbpf_core_read.h
Quoted 8 lines
Quoted 2 lines
Once the
BPF_CORE_WRITE_BITFIELDis landed, this test needs to be changed to use the BPF_CORE_{READ,WRITE}_BITFIELD.IIUC, the CO-RE api assumes that the offset of bitfields could be changed.
If the size of struct
tcp_cookie_attributesis changed, kfunc will not work in this test. So,BPF_CORE_WRITE_BITFIELD()works only when the size oftcp_cookie_attributesis unchanged but fields intcp_options_receivedare rearranged or expanded to use the unused@ bits ?
Right, CO-RE helps to figure out the offset of a member in the running kernel.
Quoted 5 lines
Also, do we need to use
BPF_CORE_READ()for other non-bitfields in strcuttcp_options_received(andecn_okin structtcp_cookie_attributesjust in case other fields are added totcp_cookie_attributesandecn_okis rearranged) ?
BPF_CORE_READ is a CO-RE friendly macro for using bpf_probe_read_kernel(). bpf_probe_read_kernel() is mostly for the tracing use case where the ptr is not safe to read directly.
It is not the case for the tcp_options_received ptr in this tc-bpf use case or other stack allocated objects. In general, no need to use BPF_CORE_READ. The relocation will be done by the libbpf for tcp_opt->mss_clamp (e.g.).
Going back to bitfield, it needs BPF_CORE_*_BITFIELD because the offset may not be right after __attribute__((preserve_access_index)), cc: Yonghong and Andrii who know more details than I do.
A verifier error has been reported: https://lore.kernel.org/bpf/391d524c496acc97a8801d8bea80976f58485810.1700676682.git.dxu@dxuuu.xyz/.
I also hit an error earlier in https://lore.kernel.org/all/[email protected]/ when not using BPF_CORE_READ_BITFIELD. I don't exactly remember how the instruction looks like but it was reading a wrong value instead of verifier error.
================
Going back to this patch set here.
After sleeping on it longer, I am thinking it is better not to reuse 'struct tcp_options_received' (meaning no bitfield) in the bpf_sk_assign_tcp_reqsk() kfunc API.
There is not much benefit in reusing 'tcp_options_received'. When new tcp option was ever added to tcp_options_received, it is not like bpf_sk_assign_tcp_reqsk will support it automatically. It needs to relay this new option back to the allocated req. Unlike tcp_sock or req which may have a lot of them such that it is useful to have a compact tcp_options_received, the tc-bpf use case here is to allocate it once in the stack. Also, not all the members in tcp_options_received is useful, e.g. num_sacks, ts_recent_stamp, and user_mss are not used. Leaving it there being ignored by bpf_sk_assign_tcp_reqsk is confusing.
How about using a full u8 for each necessary member and directly add them to struct tcp_cookie_attributes instead of nesting them into another struct. After taking out the unnecessary members, the size may not end up to be much bigger.
The bpf prog can then directly access attr->tstamp_ok more naturally. The changes to patch 5 and 6 should be mostly mechanical changes.
I would also rename s/tcp_cookie_attributes/bpf_tcp_req_attrs/.
wdyt?
Re: [PATCH v5 bpf-next 6/6] selftest: bpf: Test bpf_sk_assign_tcp_reqsk().
From: Martin KaFai Lau <[email protected]>
Date: Wed, 13 Dec 2023 22:46:11 -0800
Quoted 73 lines · Kuniyuki Iwashima
Quoted 43 lines
Quoted 43 lines
Quoted 25 lines
tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.c new file +25
-0+static int tcp_parse_option (__u32 index,struct tcp_syncookie *ctx) +{ +struct tcp_options_received *tcp_opt = &ctx->attr.tcp_opt; +char opcode, opsize; + +if (ctx->ptr +1 > ctx->data_end) + goto stop; + + opcode = *ctx->ptr++; + +if (opcode ==TCPOPT_EOL ) + goto stop; + +if (opcode ==TCPOPT_NOP ) + goto next; + +if (ctx->ptr +1 > ctx->data_end) + goto stop; + + opsize = *ctx->ptr++; + +if (opsize <2 ) + goto stop; + +switch (opcode) {tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.c line 232
Quoted 10 lines
tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.c new file +10
-0+case TCPOPT_MSS : +if (opsize ==TCPOLEN_MSS && ctx->tcp->syn && + ctx->ptr + (TCPOLEN_MSS -2 ) < ctx->data_end) + tcp_opt->mss_clamp =get_unaligned_be16 (ctx->ptr); +break ; +case TCPOPT_WINDOW : +if (opsize ==TCPOLEN_WINDOW && ctx->tcp->syn && + ctx->ptr + (TCPOLEN_WINDOW -2 ) < ctx->data_end) { + tcp_opt->wscale_ok =1 ; + tcp_opt->snd_wscale = *ctx->ptr;When writing to a bitfield of "struct
tcp_options_received" which is a kernel struct, it needs to use the CO-RE api. TheBPF_CORE_WRITE_BITFIELDhas not been landed yet:
https://lore.kernel.org/bpf/4d3dd215a4fd57d980733886f9c11a45e1a9adf3.1702325874.git.dxu@dxuuu.xyz/The same for reading bitfield but
BPF_CORE_READ_BITFIELD()has already been implemented inbpf_core_read.hQuoted 8 lines
Quoted 2 lines
Once the
BPF_CORE_WRITE_BITFIELDis landed, this test needs to be changed to use the BPF_CORE_{READ,WRITE}_BITFIELD.IIUC, the CO-RE api assumes that the offset of bitfields could be changed.
If the size of struct
tcp_cookie_attributesis changed, kfunc will not work in this test. So,BPF_CORE_WRITE_BITFIELD()works only when the size oftcp_cookie_attributesis unchanged but fields intcp_options_receivedare rearranged or expanded to use the unused@ bits ?Right, CO-RE helps to figure out the offset of a member in the running kernel.
Quoted 5 lines
Also, do we need to use
BPF_CORE_READ()for other non-bitfields in strcuttcp_options_received(andecn_okin structtcp_cookie_attributesjust in case other fields are added totcp_cookie_attributesandecn_okis rearranged) ?
BPF_CORE_READis a CO-RE friendly macro for usingbpf_probe_read_kernel().bpf_probe_read_kernel()is mostly for the tracing use case where the ptr is not safe to read directly.It is not the case for the
tcp_options_receivedptr in this tc-bpf use case or other stack allocated objects. In general, no need to useBPF_CORE_READ. The relocation will be done by the libbpf fortcp_opt->mss_clamp(e.g.).Going back to bitfield, it needs BPF_CORE_*_BITFIELD because the offset may not be right after __attribute__((preserve_access_index)), cc: Yonghong and Andrii who know more details than I do.
Quoted 7 lines
A verifier error has been reported:
https://lore.kernel.org/bpf/391d524c496acc97a8801d8bea80976f58485810.1700676682.git.dxu@dxuuu.xyz/.I also hit an error earlier in
https://lore.kernel.org/all/[email protected]/ when not usingBPF_CORE_READ_BITFIELD. I don't exactly remember how the instruction looks like but it was reading a wrong value instead of verifier error.
Thank you so much for detailed explanation!
Quoted 22 lines
================
Going back to this patch set here.
After sleeping on it longer, I am thinking it is better not to reuse 'struct
tcp_options_received' (meaning no bitfield) in thebpf_sk_assign_tcp_reqsk()kfunc API.There is not much benefit in reusing '
tcp_options_received'. When new tcp option was ever added totcp_options_received, it is not likebpf_sk_assign_tcp_reqskwill support it automatically. It needs to relay this new option back to the allocated req. Unliketcp_sockor req which may have a lot of them such that it is useful to have a compacttcp_options_received, the tc-bpf use case here is to allocate it once in the stack. Also, not all the members intcp_options_receivedis useful, e.g.num_sacks,ts_recent_stamp, anduser_mssare not used. Leaving it there being ignored bybpf_sk_assign_tcp_reqskis confusing.How about using a full u8 for each necessary member and directly add them to struct
tcp_cookie_attributesinstead of nesting them into another struct. After taking out the unnecessary members, the size may not end up to be much bigger.
Quoted 6 lines
The bpf prog can then directly access
attr->tstamp_okmore naturally. The changes to patch 5 and 6 should be mostly mechanical changes.I would also rename s/tcp_cookie_attributes/bpf_tcp_req_attrs/.
wdyt?
Totally agree. I reused struct tcp_options_received but had a similar thought like unused fields, confusing fields (saw_tstamp vs tstamp_ok, user_mss vs clamp_mss), etc.
And I like bpf_tcp_req_attrs, tcp_cookie_attributes was bit wordy :)
So probably bpf_tcp_req_attrs would look like this ?
struct bpf_tcp_req_attrs {
u32 rcv_tsval;
u32 rcv_tsecr;
u16 mss;
u8 rcv_scale;
u8 snd_scale;
bool ecn_ok;
bool wscale_ok;
bool sack_ok;
bool tstamp_ok;
bool usec_ts;
} __packed;or you prefer u8 over bool and __packed ?
struct bpf_tcp_req_attrs {
u32 rcv_tsval;
u32 rcv_tsecr;
u16 mss;
u8 rcv_scale;
u8 snd_scale;
u8 ecn_ok;
u8 wscale_ok;
u8 sack_ok;
u8 tstamp_ok;
u8 usec_ts;
}Re: [PATCH v5 bpf-next 6/6] selftest: bpf: Test bpf_sk_assign_tcp_reqsk().
From: Kuniyuki Iwashima <[email protected]>
Date: Thu, 14 Dec 2023 16:49:55 +0900
Quoted 136 lines
From: Martin KaFai Lau <[email protected]>
Date: Wed, 13 Dec 2023 22:46:11 -0800Quoted 73 lines · Kuniyuki Iwashima
Quoted 43 lines
Quoted 43 lines
Quoted 25 lines
tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.c new file +25
-0+static int tcp_parse_option (__u32 index,struct tcp_syncookie *ctx) +{ +struct tcp_options_received *tcp_opt = &ctx->attr.tcp_opt; +char opcode, opsize; + +if (ctx->ptr +1 > ctx->data_end) + goto stop; + + opcode = *ctx->ptr++; + +if (opcode ==TCPOPT_EOL ) + goto stop; + +if (opcode ==TCPOPT_NOP ) + goto next; + +if (ctx->ptr +1 > ctx->data_end) + goto stop; + + opsize = *ctx->ptr++; + +if (opsize <2 ) + goto stop; + +switch (opcode) {tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.c line 232
Quoted 10 lines
tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.c new file +10
-0+case TCPOPT_MSS : +if (opsize ==TCPOLEN_MSS && ctx->tcp->syn && + ctx->ptr + (TCPOLEN_MSS -2 ) < ctx->data_end) + tcp_opt->mss_clamp =get_unaligned_be16 (ctx->ptr); +break ; +case TCPOPT_WINDOW : +if (opsize ==TCPOLEN_WINDOW && ctx->tcp->syn && + ctx->ptr + (TCPOLEN_WINDOW -2 ) < ctx->data_end) { + tcp_opt->wscale_ok =1 ; + tcp_opt->snd_wscale = *ctx->ptr;When writing to a bitfield of "struct
tcp_options_received" which is a kernel struct, it needs to use the CO-RE api. TheBPF_CORE_WRITE_BITFIELDhas not been landed yet:
https://lore.kernel.org/bpf/4d3dd215a4fd57d980733886f9c11a45e1a9adf3.1702325874.git.dxu@dxuuu.xyz/The same for reading bitfield but
BPF_CORE_READ_BITFIELD()has already been implemented inbpf_core_read.hQuoted 8 lines
Quoted 2 lines
Once the
BPF_CORE_WRITE_BITFIELDis landed, this test needs to be changed to use the BPF_CORE_{READ,WRITE}_BITFIELD.IIUC, the CO-RE api assumes that the offset of bitfields could be changed.
If the size of struct
tcp_cookie_attributesis changed, kfunc will not work in this test. So,BPF_CORE_WRITE_BITFIELD()works only when the size oftcp_cookie_attributesis unchanged but fields intcp_options_receivedare rearranged or expanded to use the unused@ bits ?Right, CO-RE helps to figure out the offset of a member in the running kernel.
Quoted 5 lines
Also, do we need to use
BPF_CORE_READ()for other non-bitfields in strcuttcp_options_received(andecn_okin structtcp_cookie_attributesjust in case other fields are added totcp_cookie_attributesandecn_okis rearranged) ?
BPF_CORE_READis a CO-RE friendly macro for usingbpf_probe_read_kernel().bpf_probe_read_kernel()is mostly for the tracing use case where the ptr is not safe to read directly.It is not the case for the
tcp_options_receivedptr in this tc-bpf use case or other stack allocated objects. In general, no need to useBPF_CORE_READ. The relocation will be done by the libbpf fortcp_opt->mss_clamp(e.g.).Going back to bitfield, it needs BPF_CORE_*_BITFIELD because the offset may not be right after __attribute__((preserve_access_index)), cc: Yonghong and Andrii who know more details than I do.
Quoted 7 lines
A verifier error has been reported:
https://lore.kernel.org/bpf/391d524c496acc97a8801d8bea80976f58485810.1700676682.git.dxu@dxuuu.xyz/.I also hit an error earlier in
https://lore.kernel.org/all/[email protected]/ when not usingBPF_CORE_READ_BITFIELD. I don't exactly remember how the instruction looks like but it was reading a wrong value instead of verifier error.Thank you so much for detailed explanation!
Quoted 22 lines
================
Going back to this patch set here.
After sleeping on it longer, I am thinking it is better not to reuse 'struct
tcp_options_received' (meaning no bitfield) in thebpf_sk_assign_tcp_reqsk()kfunc API.There is not much benefit in reusing '
tcp_options_received'. When new tcp option was ever added totcp_options_received, it is not likebpf_sk_assign_tcp_reqskwill support it automatically. It needs to relay this new option back to the allocated req. Unliketcp_sockor req which may have a lot of them such that it is useful to have a compacttcp_options_received, the tc-bpf use case here is to allocate it once in the stack. Also, not all the members intcp_options_receivedis useful, e.g.num_sacks,ts_recent_stamp, anduser_mssare not used. Leaving it there being ignored bybpf_sk_assign_tcp_reqskis confusing.How about using a full u8 for each necessary member and directly add them to struct
tcp_cookie_attributesinstead of nesting them into another struct. After taking out the unnecessary members, the size may not end up to be much bigger.Quoted 6 lines
The bpf prog can then directly access
attr->tstamp_okmore naturally. The changes to patch 5 and 6 should be mostly mechanical changes.I would also rename s/tcp_cookie_attributes/bpf_tcp_req_attrs/.
wdyt?
Totally agree. I reused struct
tcp_options_receivedbut had a similar thought like unused fields, confusing fields (saw_tstampvststamp_ok,user_mssvsclamp_mss), etc.And I like
bpf_tcp_req_attrs,tcp_cookie_attributeswas bit wordy :)So probably
bpf_tcp_req_attrswould look like this ?struct bpf_tcp_req_attrs { u32 rcv_tsval; u32 rcv_tsecr; u16 mss; u8 rcv_scale; u8 snd_scale; bool ecn_ok; bool wscale_ok; bool sack_ok; bool tstamp_ok; bool usec_ts; } __packed;
Quoted 1 line
or you prefer u8 over bool and
__packed?
Ah, bool and __packed will require BPF_CORE_(READ|WRITE)_BITFIELD(). I'll use the following struct.
Thank you!
Quoted 13 lines
struct bpf_tcp_req_attrs {
u32 rcv_tsval;
u32 rcv_tsecr;
u16 mss;
u8 rcv_scale;
u8 snd_scale;
u8 ecn_ok;
u8 wscale_ok;
u8 sack_ok;
u8 tstamp_ok;
u8 usec_ts;
}