BPF redundant scheduler
Subsystems (5)
v2 cover BPF redundant scheduler
v2:
- add MPTCP_SUBFLOWS_MAX limit to avoid infinite loops when the scheduler always sets call_again to true.
- track the largest copied amount.
- deal with __mptcp_subflow_push_pending() and the retransmit loop.
- depends on "BPF round-robin scheduler" v14.
v1:
Implements the redundant BPF MPTCP scheduler, which sends all packets redundantly on all available subflows.
depends on:
- BPF round-robin scheduler, v13
Geliang Tang (5):
Squash to "mptcp: add get_subflow wrappers"
mptcp: add redundant subflows support
mptcp: add call_again flag in mptcp_sched_ops
selftests/bpf: add bpf_red scheduler
selftests/bpf: add bpf_red test
include/net/mptcp.h | 1 + net/mptcp/protocol.c | 64 ++++++++++++++----- net/mptcp/protocol.h | 4 +- net/mptcp/sched.c | 11 +++- .../testing/selftests/bpf/prog_tests/mptcp.c | 38 +++++++++++ .../selftests/bpf/progs/mptcp_bpf_red.c | 54 ++++++++++++++++ 6 files changed, 151 insertions(+), 21 deletions(-) create mode 100644 tools/testing/selftests/bpf/progs/mptcp_bpf_red.c
Signature · 1 line
2.34.1
PATCH v2 1/5 Squash to "mptcp: add get_subflow wrappers"
Add call_again parameter for mptcp_sched_get_send() and mptcp_sched_get_retrans().
--- net/mptcp/protocol.c | 13 +++++++++---- net/mptcp/protocol.h | 4 ++-- net/mptcp/sched.c | 10 ++++++++-- 3 files changed, 19 insertions(+), 8 deletions(-)
net/mptcp/protocol.c +9 -4
@@ -1558,6 +1558,7 @@ void __mptcp_push_pending(struct sock *sk, unsigned int flags) };struct mptcp_data_frag *dfrag;int len, copied =0 ; +bool call_again;while ((dfrag =mptcp_send_head (sk))) { info.sent = dfrag->already_sent;
@@ -1567,7 +1568,7 @@ void __mptcp_push_pending(struct sock *sk, unsigned int flags)int ret =0 ; prev_ssk = ssk; - ssk =mptcp_sched_get_send (msk); + ssk =mptcp_sched_get_send (msk, &call_again);/* First check. If the ssk has changed since * the last round, release prev_ssk
@@ -1618,6 +1619,7 @@ static void __mptcp_subflow_push_pending(struct sock *sk, struct sock *ssk) .data_lock_held = true, };struct mptcp_data_frag *dfrag; +bool call_again = false;struct sock *xmit_ssk;int len, copied =0 ;bool first = true;
@@ -1634,7 +1636,7 @@ static void __mptcp_subflow_push_pending(struct sock *sk, struct sock *ssk)* check for a different subflow usage only after * spooling the first chunk of data */ - xmit_ssk = first ? ssk :mptcp_sched_get_send (mptcp_sk (sk)); + xmit_ssk = first ? ssk :mptcp_sched_get_send (mptcp_sk (sk), &call_again);if (!xmit_ssk) goto out;if (xmit_ssk != ssk) {
@@ -2461,12 +2463,13 @@ static void __mptcp_retrans(struct sock *sk)struct mptcp_data_frag *dfrag;size_t copied =0 ;struct sock *ssk; +bool call_again;int ret;mptcp_clean_una_wakeup (sk);/* first check ssk: need to kick "stale" logic */ - ssk =mptcp_sched_get_retrans (msk); + ssk =mptcp_sched_get_retrans (msk, &call_again); dfrag =mptcp_rtx_head (sk);if (!dfrag) {if (mptcp_data_fin_enabled (msk)) {
@@ -3111,11 +3114,13 @@ void __mptcp_data_acked(struct sock *sk)void __mptcp_check_push (struct sock *sk,struct sock *ssk) { +bool call_again; +if (!mptcp_send_head (sk))return ;if (!sock_owned_by_user (sk)) { -struct sock *xmit_ssk =mptcp_sched_get_send (mptcp_sk (sk)); +struct sock *xmit_ssk =mptcp_sched_get_send (mptcp_sk (sk), &call_again);if (xmit_ssk == ssk)__mptcp_subflow_push_pending (sk, ssk);
net/mptcp/protocol.h +2 -2
@@ -631,8 +631,8 @@ int mptcp_init_sched(struct mptcp_sock *msk,void mptcp_release_sched (struct mptcp_sock *msk);struct sock *mptcp_subflow_get_send (struct mptcp_sock *msk);struct sock *mptcp_subflow_get_retrans (struct mptcp_sock *msk); -struct sock *mptcp_sched_get_send (struct mptcp_sock *msk); -struct sock *mptcp_sched_get_retrans (struct mptcp_sock *msk); +struct sock *mptcp_sched_get_send (struct mptcp_sock *msk,bool *call_again); +struct sock *mptcp_sched_get_retrans (struct mptcp_sock *msk,bool *call_again);static inline bool __mptcp_subflow_active (struct mptcp_subflow_context *subflow) {
net/mptcp/sched.c +8 -2
@@ -112,12 +112,14 @@ static int mptcp_sched_data_init(struct mptcp_sock *msk,return 0 ; } -struct sock *mptcp_sched_get_send (struct mptcp_sock *msk) +struct sock *mptcp_sched_get_send (struct mptcp_sock *msk,bool *call_again) {struct mptcp_sched_data data;sock_owned_by_me ((struct sock *)msk); + *call_again =0 ; +/* the following check is moved out of mptcp_subflow_get_send */ if (__mptcp_check_fallback (msk)) {if (!msk->first)
@@ -132,15 +134,18 @@ struct sock *mptcp_sched_get_send(struct mptcp_sock *msk) msk->sched->get_subflow (msk, false, &data); msk->last_snd = data.sock; + *call_again = data.call_again;return data.sock; } -struct sock *mptcp_sched_get_retrans (struct mptcp_sock *msk) +struct sock *mptcp_sched_get_retrans (struct mptcp_sock *msk,bool *call_again) {struct mptcp_sched_data data;sock_owned_by_me ((const struct sock *)msk); + *call_again =0 ; +/* the following check is moved out of mptcp_subflow_get_retrans */ if (__mptcp_check_fallback (msk))return NULL ;
@@ -152,5 +157,6 @@ struct sock *mptcp_sched_get_retrans(struct mptcp_sock *msk) msk->sched->get_subflow (msk, true, &data); msk->last_snd = data.sock; + *call_again = data.call_again;return data.sock; }
Signature · 1 line
2.34.1
PATCH v2 2/5 mptcp: add redundant subflows support
In reply to Geliang TangThis patch adds the redundant subflows support, sending all packets redundantly on all available subflows.
--- net/mptcp/protocol.c | 40 ++++++++++++++++++++++++++++------------ 1 file changed, 28 insertions(+), 12 deletions(-)
net/mptcp/protocol.c +28 -12
@@ -1559,6 +1559,7 @@ void __mptcp_push_pending(struct sock *sk, unsigned int flags)struct mptcp_data_frag *dfrag;int len, copied =0 ;bool call_again; +int max =0 ;while ((dfrag =mptcp_send_head (sk))) { info.sent = dfrag->already_sent;
@@ -1586,18 +1587,25 @@ void __mptcp_push_pending(struct sock *sk, unsigned int flags)lock_sock (ssk); ret =mptcp_sendmsg_frag (sk, ssk, dfrag, &info); -if (ret <=0 ) { +if (ret <=0 && !call_again) {mptcp_push_release (ssk, &info); goto out; } - info.sent += ret; - copied += ret; - len -= ret; +if (ret > max) + max = ret; -mptcp_update_post_push (msk, dfrag, ret); +if (!call_again) { + info.sent += max; + copied += max; + len -= max; + +mptcp_update_post_push (msk, dfrag, max); + max =0 ; + } } -WRITE_ONCE (msk->first_pending,mptcp_send_next (sk)); +if (!call_again) +WRITE_ONCE (msk->first_pending,mptcp_send_next (sk)); }/* at this point we held the socket lock for the last subflow we used */
@@ -1623,6 +1631,7 @@ static void __mptcp_subflow_push_pending(struct sock *sk, struct sock *ssk)struct sock *xmit_ssk;int len, copied =0 ;bool first = true; +int max =0 ; info.flags =0 ;while ((dfrag =mptcp_send_head (sk))) {
@@ -1646,17 +1655,24 @@ static void __mptcp_subflow_push_pending(struct sock *sk, struct sock *ssk) } ret =mptcp_sendmsg_frag (sk, ssk, dfrag, &info); -if (ret <=0 ) +if (ret <=0 && !call_again) goto out; - info.sent += ret; - copied += ret; - len -= ret; +if (ret > max) + max = ret; + first = false; +if (!call_again) { + info.sent += max; + copied += max; + len -= max; -mptcp_update_post_push (msk, dfrag, ret); +mptcp_update_post_push (msk, dfrag, max); + max =0 ; + } } -WRITE_ONCE (msk->first_pending,mptcp_send_next (sk)); +if (!call_again) +WRITE_ONCE (msk->first_pending,mptcp_send_next (sk)); } out:
Signature · 1 line
2.34.1
PATCH v2 3/5 mptcp: add call_again flag in mptcp_sched_ops
In reply to Geliang TangThis patch adds call_again flag in struct mptcp_sched_ops, init it as true. Set it to false when the scheduler set call_again = true over MPTCP_SUBFLOWS_MAX times to avoid infinite loops.
--- include/net/mptcp.h | 1 + net/mptcp/protocol.c | 21 +++++++++++++++------ net/mptcp/sched.c | 1 + 3 files changed, 17 insertions(+), 6 deletions(-)
include/net/mptcp.h +1 -0
@@ -112,6 +112,7 @@ struct mptcp_sched_ops {char name[MPTCP_SCHED_NAME_MAX ];struct module *owner;struct list_head list; +bool call_again;void (*init)(const struct mptcp_sock *msk);void (*release)(const struct mptcp_sock *msk);
net/mptcp/protocol.c +15 -6
@@ -1560,6 +1560,7 @@ void __mptcp_push_pending(struct sock *sk, unsigned int flags)int len, copied =0 ;bool call_again;int max =0 ; +int nr =0 ;while ((dfrag =mptcp_send_head (sk))) { info.sent = dfrag->already_sent;
@@ -1587,7 +1588,7 @@ void __mptcp_push_pending(struct sock *sk, unsigned int flags)lock_sock (ssk); ret =mptcp_sendmsg_frag (sk, ssk, dfrag, &info); -if (ret <=0 && !call_again) { +if (ret <=0 && (!call_again || !msk->sched->call_again)) {mptcp_push_release (ssk, &info); goto out; }
@@ -1595,16 +1596,20 @@ void __mptcp_push_pending(struct sock *sk, unsigned int flags)if (ret > max) max = ret; -if (!call_again) { +if (!call_again || !msk->sched->call_again) { info.sent += max; copied += max; len -= max;mptcp_update_post_push (msk, dfrag, max); max =0 ; + }else if (nr++ >=MPTCP_SUBFLOWS_MAX ) { +mptcp_push_release (ssk, &info); +WRITE_ONCE (msk->sched->call_again, false); + goto out; } } -if (!call_again) +if (!call_again || !msk->sched->call_again)WRITE_ONCE (msk->first_pending,mptcp_send_next (sk)); }
@@ -1632,6 +1637,7 @@ static void __mptcp_subflow_push_pending(struct sock *sk, struct sock *ssk)int len, copied =0 ;bool first = true;int max =0 ; +int nr =0 ; info.flags =0 ;while ((dfrag =mptcp_send_head (sk))) {
@@ -1655,23 +1661,26 @@ static void __mptcp_subflow_push_pending(struct sock *sk, struct sock *ssk) } ret =mptcp_sendmsg_frag (sk, ssk, dfrag, &info); -if (ret <=0 && !call_again) +if (ret <=0 && (!call_again || !msk->sched->call_again)) goto out;if (ret > max) max = ret; first = false; -if (!call_again) { +if (!call_again || !msk->sched->call_again) { info.sent += max; copied += max; len -= max;mptcp_update_post_push (msk, dfrag, max); max =0 ; + }else if (nr++ >=MPTCP_SUBFLOWS_MAX ) { +WRITE_ONCE (msk->sched->call_again, false); + goto out; } } -if (!call_again) +if (!call_again || !msk->sched->call_again)WRITE_ONCE (msk->first_pending,mptcp_send_next (sk)); }
net/mptcp/sched.c +1 -0
@@ -67,6 +67,7 @@ int mptcp_init_sched(struct mptcp_sock *msk, msk->sched = sched;if (msk->sched->init) msk->sched->init (msk); +WRITE_ONCE (msk->sched->call_again, true);pr_debug ("sched=%s" , msk->sched->name);
Signature · 1 line
2.34.1
PATCH v2 4/5 selftests/bpf: add bpf_red scheduler
In reply to Geliang TangThis patch implements the redundant BPF MPTCP scheduler, named bpf_red, which sends all packets redundantly on all available subflows.
--- .../selftests/bpf/progs/mptcp_bpf_red.c | 54 +++++++++++++++++++ 1 file changed, 54 insertions(+) create mode 100644 tools/testing/selftests/bpf/progs/mptcp_bpf_red.c
tools/testing/selftests/bpf/progs/mptcp_bpf_red.c new file +54 -0
@@ -0,0 +1,54 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright (c) 2022, SUSE. */ + +#include <linux/bpf.h> +#include "bpf_tcp_helpers.h" + +char _license[] SEC("license") = "GPL"; + +SEC("struct_ops/mptcp_sched_red_init") +void BPF_PROG (mptcp_sched_red_init ,const struct mptcp_sock *msk) +{ +} + +SEC("struct_ops/mptcp_sched_red_release") +void BPF_PROG (mptcp_sched_red_release ,const struct mptcp_sock *msk) +{ +} + +void BPF_STRUCT_OPS (bpf_red_get_subflow ,const struct mptcp_sock *msk, +bool reinject,struct mptcp_sched_data *data) +{ +struct sock *ssk = data->contexts[0 ]->tcp_sock; +int i; + +if (reinject) { + data->sock = ssk; + data->call_again =0 ; +return ; + } + +for (i =0 ; i <MPTCP_SUBFLOWS_MAX && i < data->subflows; i++) { +if (!msk->last_snd) +break ; + +if (data->contexts[i]->tcp_sock == msk->last_snd) { +if (i +1 ==MPTCP_SUBFLOWS_MAX || !data->contexts[i +1 ]) +break ; + + ssk = data->contexts[i +1 ]->tcp_sock; +break ; + } + } + + data->sock = ssk; + data->call_again = i +1 == data->subflows ?0 :1 ; +} + +SEC(".struct_ops") +struct mptcp_sched_ops red = { + .init = (void *)mptcp_sched_red_init, + .release = (void *)mptcp_sched_red_release, + .get_subflow = (void *)bpf_red_get_subflow, + .name ="bpf_red" , +};
Signature · 1 line
2.34.1
PATCH v2 5/5 selftests/bpf: add bpf_red test
In reply to Geliang TangThis patch adds the redundant BPF MPTCP scheduler test. Use sysctl to set net.mptcp.scheduler to use this sched.
--- .../testing/selftests/bpf/prog_tests/mptcp.c | 38 +++++++++++++++++++ 1 file changed, 38 insertions(+)
tools/testing/selftests/bpf/prog_tests/mptcp.c +38 -0
@@ -7,6 +7,7 @@#include "network_helpers.h" #include "mptcp_bpf_first.skel.h" #include "mptcp_bpf_rr.skel.h" +#include "mptcp_bpf_red.skel.h" #ifndef TCP_CA_NAME_MAX #define TCP_CA_NAME_MAX 16
@@ -405,6 +406,41 @@ static void test_rr(void)mptcp_bpf_rr__destroy (rr_skel); } +static void test_red (void ) +{ +struct mptcp_bpf_red *red_skel; +int server_fd, client_fd; +struct bpf_link *link; + + red_skel =mptcp_bpf_red__open_and_load (); +if (!ASSERT_OK_PTR (red_skel,"bpf_red__open_and_load" )) +return ; + + link =bpf_map__attach_struct_ops (red_skel->maps.red); +if (!ASSERT_OK_PTR (link,"bpf_map__attach_struct_ops" )) { +mptcp_bpf_red__destroy (red_skel); +return ; + } + +system ("ip link add veth1 type veth" ); +system ("ip addr add 10.0.1.1/24 dev veth1" ); +system ("ip link set veth1 up" ); +system ("ip mptcp endpoint add 10.0.1.1 subflow" ); +system ("sysctl -qw net.mptcp.scheduler=bpf_red" ); + server_fd =start_mptcp_server (AF_INET ,NULL ,0 ,0 ); + client_fd =connect_to_mptcp_fd (server_fd,0 ); + +send_data (server_fd, client_fd); + +close (client_fd); +close (server_fd); +system ("sysctl -qw net.mptcp.scheduler=default" ); +system ("ip mptcp endpoint flush" ); +system ("ip link del veth1" ); +bpf_link__destroy (link); +mptcp_bpf_red__destroy (red_skel); +} +void test_mptcp (void ) {if (test__start_subtest ("base" ))
@@ -413,4 +449,6 @@ void test_mptcp(void)test_first ();if (test__start_subtest ("rr" ))test_rr (); +if (test__start_subtest ("red" )) +test_red (); }
Signature · 1 line
2.34.1
Quoted 6 lines · Geliang Tang
v2:
- addMPTCP_SUBFLOWS_MAXlimit to avoid infinite loops when the scheduler always setscall_againto true.
- track the largest copied amount.
- deal with__mptcp_subflow_push_pending()and the retransmit loop.
- depends on "BPF round-robin scheduler" v14.
Thanks for those updates.
As we talked about in the meeting this week, I think it's still good to revise this to be able to return multiple subflows (whether in a bitmap or array) from the BPF scheduler function. That is more likely to be workable with __mptcp_subflow_push_pending() and the way it chains to send on different subflows with mptcp_subflow_delegate().
- Mat
Quoted 16 lines
v1:
Implements the redundant BPF MPTCP scheduler, which sends all packets redundantly on all available subflows.
depends on:
- BPF round-robin scheduler, v13Geliang Tang (5):
Squash to "mptcp: addget_subflowwrappers"
mptcp: add redundant subflows support
mptcp: addcall_againflag inmptcp_sched_ops
selftests/bpf: addbpf_redscheduler
selftests/bpf: addbpf_redtest
Quoted 14 lines
include/net/mptcp.h | 1 + net/mptcp/protocol.c | 64 ++++++++++++++----- net/mptcp/protocol.h | 4 +- net/mptcp/sched.c | 11 +++- .../testing/selftests/bpf/prog_tests/mptcp.c | 38 +++++++++++ .../selftests/bpf/progs/mptcp_bpf_red.c | 54 ++++++++++++++++ 6 files changed, 151 insertions(+), 21 deletions(-)create mode 100644
tools/testing/selftests/bpf/progs/mptcp_bpf_red.cSignature · 1 line
2.34.1
--
Mat Martineau
Intel