[PATCH mptcp-next v2 0/5] BPF redundant scheduler

[PATCH mptcp-next v2 0/5] BPF redundant scheduler

[Geliang Tang]

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

-- 
2.34.1

[PATCH mptcp-next v2 1/5] Squash to "mptcp: add get_subflow wrappers"

[Geliang Tang]

Add call_again parameter for mptcp_sched_get_send() and
mptcp_sched_get_retrans().

Signed-off-by: Geliang Tang <geliang.tang@suse.com>
---
 net/mptcp/protocol.c | 13 +++++++++----
 net/mptcp/protocol.h |  4 ++--
 net/mptcp/sched.c    | 10 ++++++++--
 3 files changed, 19 insertions(+), 8 deletions(-)

diff --git a/net/mptcp/protocol.c b/net/mptcp/protocol.c
index ea3c93322592..74dc832a9d9d 100644
--- a/net/mptcp/protocol.c
+++ b/net/mptcp/protocol.c
@@ -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);
diff --git a/net/mptcp/protocol.h b/net/mptcp/protocol.h
index 59a23838782f..2fe0021a678e 100644
--- a/net/mptcp/protocol.h
+++ b/net/mptcp/protocol.h
@@ -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)
 {
diff --git a/net/mptcp/sched.c b/net/mptcp/sched.c
index f86b97292044..0d5fc96a2ce0 100644
--- a/net/mptcp/sched.c
+++ b/net/mptcp/sched.c
@@ -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;
 }
-- 
2.34.1

[PATCH mptcp-next v2 2/5] mptcp: add redundant subflows support

[Geliang Tang]

This patch adds the redundant subflows support, sending all packets
redundantly on all available subflows.

Signed-off-by: Geliang Tang <geliang.tang@suse.com>
---
 net/mptcp/protocol.c | 40 ++++++++++++++++++++++++++++------------
 1 file changed, 28 insertions(+), 12 deletions(-)

diff --git a/net/mptcp/protocol.c b/net/mptcp/protocol.c
index 74dc832a9d9d..1105c8ad670f 100644
--- a/net/mptcp/protocol.c
+++ b/net/mptcp/protocol.c
@@ -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:
-- 
2.34.1

[PATCH mptcp-next v2 3/5] mptcp: add call_again flag in mptcp_sched_ops

[Geliang Tang]

This 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.

Signed-off-by: Geliang Tang <geliang.tang@suse.com>
---
 include/net/mptcp.h  |  1 +
 net/mptcp/protocol.c | 21 +++++++++++++++------
 net/mptcp/sched.c    |  1 +
 3 files changed, 17 insertions(+), 6 deletions(-)

diff --git a/include/net/mptcp.h b/include/net/mptcp.h
index d48c66de8466..8c9991ef591a 100644
--- a/include/net/mptcp.h
+++ b/include/net/mptcp.h
@@ -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);
diff --git a/net/mptcp/protocol.c b/net/mptcp/protocol.c
index 1105c8ad670f..9c1ebd7a507e 100644
--- a/net/mptcp/protocol.c
+++ b/net/mptcp/protocol.c
@@ -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));
 	}
 
diff --git a/net/mptcp/sched.c b/net/mptcp/sched.c
index 0d5fc96a2ce0..10736c334ab0 100644
--- a/net/mptcp/sched.c
+++ b/net/mptcp/sched.c
@@ -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);
 
-- 
2.34.1

[PATCH mptcp-next v2 4/5] selftests/bpf: add bpf_red scheduler

[Geliang Tang]

This patch implements the redundant BPF MPTCP scheduler, named bpf_red,
which sends all packets redundantly on all available subflows.

Signed-off-by: Geliang Tang <geliang.tang@suse.com>
---
 .../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

diff --git a/tools/testing/selftests/bpf/progs/mptcp_bpf_red.c b/tools/testing/selftests/bpf/progs/mptcp_bpf_red.c
new file mode 100644
index 000000000000..ea006a895cf1
--- /dev/null
+++ b/tools/testing/selftests/bpf/progs/mptcp_bpf_red.c
@@ -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",
+};
-- 
2.34.1

[PATCH mptcp-next v2 5/5] selftests/bpf: add bpf_red test

[Geliang Tang]

This patch adds the redundant BPF MPTCP scheduler test. Use sysctl to
set net.mptcp.scheduler to use this sched.

Signed-off-by: Geliang Tang <geliang.tang@suse.com>
---
 .../testing/selftests/bpf/prog_tests/mptcp.c  | 38 +++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/tools/testing/selftests/bpf/prog_tests/mptcp.c b/tools/testing/selftests/bpf/prog_tests/mptcp.c
index 6303eba67fab..58300a30f218 100644
--- a/tools/testing/selftests/bpf/prog_tests/mptcp.c
+++ b/tools/testing/selftests/bpf/prog_tests/mptcp.c
@@ -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();
 }
-- 
2.34.1

Re: [PATCH mptcp-next v2 0/5] BPF redundant scheduler

[Mat Martineau]

On Wed, 11 May 2022, Geliang Tang wrote:

> 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.

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

>
> 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
>
> -- 
> 2.34.1
>
>
>

--
Mat Martineau
Intel