]> Git Repo - linux.git/blob - net/mptcp/sched.c
init/modpost: conditionally check section mismatch to __meminit*
[linux.git] / net / mptcp / sched.c
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
16 static DEFINE_SPINLOCK(mptcp_sched_list_lock);
17 static LIST_HEAD(mptcp_sched_list);
18
19 static 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
33 static 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 */
40 struct 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  */
57 void 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         spin_lock(&mptcp_sched_list_lock);
64         list_for_each_entry_rcu(sched, &mptcp_sched_list, list) {
65                 offs += snprintf(buf + offs, maxlen - offs,
66                                  "%s%s",
67                                  offs == 0 ? "" : " ", sched->name);
68
69                 if (WARN_ON_ONCE(offs >= maxlen))
70                         break;
71         }
72         spin_unlock(&mptcp_sched_list_lock);
73         rcu_read_unlock();
74 }
75
76 int mptcp_register_scheduler(struct mptcp_sched_ops *sched)
77 {
78         if (!sched->get_subflow)
79                 return -EINVAL;
80
81         spin_lock(&mptcp_sched_list_lock);
82         if (mptcp_sched_find(sched->name)) {
83                 spin_unlock(&mptcp_sched_list_lock);
84                 return -EEXIST;
85         }
86         list_add_tail_rcu(&sched->list, &mptcp_sched_list);
87         spin_unlock(&mptcp_sched_list_lock);
88
89         pr_debug("%s registered", sched->name);
90         return 0;
91 }
92
93 void mptcp_unregister_scheduler(struct mptcp_sched_ops *sched)
94 {
95         if (sched == &mptcp_sched_default)
96                 return;
97
98         spin_lock(&mptcp_sched_list_lock);
99         list_del_rcu(&sched->list);
100         spin_unlock(&mptcp_sched_list_lock);
101 }
102
103 void mptcp_sched_init(void)
104 {
105         mptcp_register_scheduler(&mptcp_sched_default);
106 }
107
108 int mptcp_init_sched(struct mptcp_sock *msk,
109                      struct mptcp_sched_ops *sched)
110 {
111         if (!sched)
112                 sched = &mptcp_sched_default;
113
114         if (!bpf_try_module_get(sched, sched->owner))
115                 return -EBUSY;
116
117         msk->sched = sched;
118         if (msk->sched->init)
119                 msk->sched->init(msk);
120
121         pr_debug("sched=%s", msk->sched->name);
122
123         return 0;
124 }
125
126 void mptcp_release_sched(struct mptcp_sock *msk)
127 {
128         struct mptcp_sched_ops *sched = msk->sched;
129
130         if (!sched)
131                 return;
132
133         msk->sched = NULL;
134         if (sched->release)
135                 sched->release(msk);
136
137         bpf_module_put(sched, sched->owner);
138 }
139
140 void mptcp_subflow_set_scheduled(struct mptcp_subflow_context *subflow,
141                                  bool scheduled)
142 {
143         WRITE_ONCE(subflow->scheduled, scheduled);
144 }
145
146 int mptcp_sched_get_send(struct mptcp_sock *msk)
147 {
148         struct mptcp_subflow_context *subflow;
149         struct mptcp_sched_data data;
150
151         msk_owned_by_me(msk);
152
153         /* the following check is moved out of mptcp_subflow_get_send */
154         if (__mptcp_check_fallback(msk)) {
155                 if (msk->first &&
156                     __tcp_can_send(msk->first) &&
157                     sk_stream_memory_free(msk->first)) {
158                         mptcp_subflow_set_scheduled(mptcp_subflow_ctx(msk->first), true);
159                         return 0;
160                 }
161                 return -EINVAL;
162         }
163
164         mptcp_for_each_subflow(msk, subflow) {
165                 if (READ_ONCE(subflow->scheduled))
166                         return 0;
167         }
168
169         data.reinject = false;
170         if (msk->sched == &mptcp_sched_default || !msk->sched)
171                 return mptcp_sched_default_get_subflow(msk, &data);
172         return msk->sched->get_subflow(msk, &data);
173 }
174
175 int mptcp_sched_get_retrans(struct mptcp_sock *msk)
176 {
177         struct mptcp_subflow_context *subflow;
178         struct mptcp_sched_data data;
179
180         msk_owned_by_me(msk);
181
182         /* the following check is moved out of mptcp_subflow_get_retrans */
183         if (__mptcp_check_fallback(msk))
184                 return -EINVAL;
185
186         mptcp_for_each_subflow(msk, subflow) {
187                 if (READ_ONCE(subflow->scheduled))
188                         return 0;
189         }
190
191         data.reinject = true;
192         if (msk->sched == &mptcp_sched_default || !msk->sched)
193                 return mptcp_sched_default_get_subflow(msk, &data);
194         return msk->sched->get_subflow(msk, &data);
195 }
This page took 0.042338 seconds and 4 git commands to generate.