1// SPDX-License-Identifier: GPL-2.0
  2/* Multipath TCP
  3 *
  4 * Copyright (c) 2022, SUSE.
  5 */
  6
  7#define pr_fmt(fmt) "MPTCP: " fmt
  8
  9#include <linux/kernel.h>
 10#include <linux/module.h>
 11#include <linux/list.h>
 12#include <linux/rculist.h>
 13#include <linux/spinlock.h>
 14#include "protocol.h"
 15
 16static DEFINE_SPINLOCK(mptcp_sched_list_lock);
 17static LIST_HEAD(mptcp_sched_list);
 18
 19static int mptcp_sched_default_get_subflow(struct mptcp_sock *msk,
 20					   struct mptcp_sched_data *data)
 21{
 22	struct sock *ssk;
 23
 24	ssk = data->reinject ? mptcp_subflow_get_retrans(msk) :
 25			       mptcp_subflow_get_send(msk);
 26	if (!ssk)
 27		return -EINVAL;
 28
 29	mptcp_subflow_set_scheduled(mptcp_subflow_ctx(ssk), true);
 30	return 0;
 31}
 32
 33static struct mptcp_sched_ops mptcp_sched_default = {
 34	.get_subflow	= mptcp_sched_default_get_subflow,
 35	.name		= "default",
 36	.owner		= THIS_MODULE,
 37};
 38
 39/* Must be called with rcu read lock held */
 40struct mptcp_sched_ops *mptcp_sched_find(const char *name)
 41{
 42	struct mptcp_sched_ops *sched, *ret = NULL;
 43
 44	list_for_each_entry_rcu(sched, &mptcp_sched_list, list) {
 45		if (!strcmp(sched->name, name)) {
 46			ret = sched;
 47			break;
 48		}
 49	}
 50
 51	return ret;
 52}
 53
 54/* Build string with list of available scheduler values.
 55 * Similar to tcp_get_available_congestion_control()
 56 */
 57void mptcp_get_available_schedulers(char *buf, size_t maxlen)
 58{
 59	struct mptcp_sched_ops *sched;
 60	size_t offs = 0;
 61
 62	rcu_read_lock();
 63	list_for_each_entry_rcu(sched, &mptcp_sched_list, list) {
 64		offs += snprintf(buf + offs, maxlen - offs,
 65				 "%s%s",
 66				 offs == 0 ? "" : " ", sched->name);
 67
 68		if (WARN_ON_ONCE(offs >= maxlen))
 69			break;
 70	}
 71	rcu_read_unlock();
 72}
 73
 74int mptcp_register_scheduler(struct mptcp_sched_ops *sched)
 75{
 76	if (!sched->get_subflow)
 77		return -EINVAL;
 78
 79	spin_lock(&mptcp_sched_list_lock);
 80	if (mptcp_sched_find(sched->name)) {
 81		spin_unlock(&mptcp_sched_list_lock);
 82		return -EEXIST;
 83	}
 84	list_add_tail_rcu(&sched->list, &mptcp_sched_list);
 85	spin_unlock(&mptcp_sched_list_lock);
 86
 87	pr_debug("%s registered\n", sched->name);
 88	return 0;
 89}
 90
 91void mptcp_unregister_scheduler(struct mptcp_sched_ops *sched)
 92{
 93	if (sched == &mptcp_sched_default)
 94		return;
 95
 96	spin_lock(&mptcp_sched_list_lock);
 97	list_del_rcu(&sched->list);
 98	spin_unlock(&mptcp_sched_list_lock);
 99}
100
101void mptcp_sched_init(void)
102{
103	mptcp_register_scheduler(&mptcp_sched_default);
104}
105
106int mptcp_init_sched(struct mptcp_sock *msk,
107		     struct mptcp_sched_ops *sched)
108{
109	if (!sched)
110		sched = &mptcp_sched_default;
111
112	if (!bpf_try_module_get(sched, sched->owner))
113		return -EBUSY;
114
115	msk->sched = sched;
116	if (msk->sched->init)
117		msk->sched->init(msk);
118
119	pr_debug("sched=%s\n", msk->sched->name);
120
121	return 0;
122}
123
124void mptcp_release_sched(struct mptcp_sock *msk)
125{
126	struct mptcp_sched_ops *sched = msk->sched;
127
128	if (!sched)
129		return;
130
131	msk->sched = NULL;
132	if (sched->release)
133		sched->release(msk);
134
135	bpf_module_put(sched, sched->owner);
136}
137
138void mptcp_subflow_set_scheduled(struct mptcp_subflow_context *subflow,
139				 bool scheduled)
140{
141	WRITE_ONCE(subflow->scheduled, scheduled);
142}
143
144int mptcp_sched_get_send(struct mptcp_sock *msk)
145{
146	struct mptcp_subflow_context *subflow;
147	struct mptcp_sched_data data;
148
149	msk_owned_by_me(msk);
150
151	/* the following check is moved out of mptcp_subflow_get_send */
152	if (__mptcp_check_fallback(msk)) {
153		if (msk->first &&
154		    __tcp_can_send(msk->first) &&
155		    sk_stream_memory_free(msk->first)) {
156			mptcp_subflow_set_scheduled(mptcp_subflow_ctx(msk->first), true);
157			return 0;
158		}
159		return -EINVAL;
160	}
161
162	mptcp_for_each_subflow(msk, subflow) {
163		if (READ_ONCE(subflow->scheduled))
164			return 0;
165	}
166
167	data.reinject = false;
168	if (msk->sched == &mptcp_sched_default || !msk->sched)
169		return mptcp_sched_default_get_subflow(msk, &data);
170	return msk->sched->get_subflow(msk, &data);
171}
172
173int mptcp_sched_get_retrans(struct mptcp_sock *msk)
174{
175	struct mptcp_subflow_context *subflow;
176	struct mptcp_sched_data data;
177
178	msk_owned_by_me(msk);
179
180	/* the following check is moved out of mptcp_subflow_get_retrans */
181	if (__mptcp_check_fallback(msk))
182		return -EINVAL;
183
184	mptcp_for_each_subflow(msk, subflow) {
185		if (READ_ONCE(subflow->scheduled))
186			return 0;
187	}
188
189	data.reinject = true;
190	if (msk->sched == &mptcp_sched_default || !msk->sched)
191		return mptcp_sched_default_get_subflow(msk, &data);
192	return msk->sched->get_subflow(msk, &data);
193}