1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* SCTP kernel implementation
3 * (C) Copyright Red Hat Inc. 2017
4 *
5 * This file is part of the SCTP kernel implementation
6 *
7 * These functions manipulate sctp stream queue/scheduling.
8 *
9 * Please send any bug reports or fixes you make to the
10 * email addresched(es):
11 * lksctp developers <linux-sctp@vger.kernel.org>
12 *
13 * Written or modified by:
14 * Marcelo Ricardo Leitner <marcelo.leitner@gmail.com>
15 */
16
17 #include <linux/list.h>
18 #include <net/sctp/sctp.h>
19 #include <net/sctp/sm.h>
20 #include <net/sctp/stream_sched.h>
21
22 /* Priority handling
23 * RFC DRAFT ndata section 3.4
24 */
25
26 static void sctp_sched_prio_unsched_all(struct sctp_stream *stream);
27
28 static struct sctp_stream_priorities *sctp_sched_prio_head_get(struct sctp_stream_priorities *p)
29 {
30 p->users++;
31 return p;
32 }
33
34 static void sctp_sched_prio_head_put(struct sctp_stream_priorities *p)
35 {
36 if (p && --p->users == 0)
37 kfree(p);
38 }
39
40 static struct sctp_stream_priorities *sctp_sched_prio_new_head(
41 struct sctp_stream *stream, int prio, gfp_t gfp)
42 {
43 struct sctp_stream_priorities *p;
44
45 p = kmalloc(sizeof(*p), gfp);
46 if (!p)
47 return NULL;
48
49 INIT_LIST_HEAD(&p->prio_sched);
50 INIT_LIST_HEAD(&p->active);
51 p->next = NULL;
52 p->prio = prio;
53 p->users = 1;
54
55 return p;
56 }
57
58 static struct sctp_stream_priorities *sctp_sched_prio_get_head(
59 struct sctp_stream *stream, int prio, gfp_t gfp)
60 {
61 struct sctp_stream_priorities *p;
62 int i;
63
64 /* Look into scheduled priorities first, as they are sorted and
65 * we can find it fast IF it's scheduled.
66 */
67 list_for_each_entry(p, &stream->prio_list, prio_sched) {
68 if (p->prio == prio)
69 return sctp_sched_prio_head_get(p);
70 if (p->prio > prio)
71 break;
72 }
73
74 /* No luck. So we search on all streams now. */
75 for (i = 0; i < stream->outcnt; i++) {
76 if (!SCTP_SO(stream, i)->ext)
77 continue;
78
79 p = SCTP_SO(stream, i)->ext->prio_head;
80 if (!p)
81 /* Means all other streams won't be initialized
82 * as well.
83 */
84 break;
85 if (p->prio == prio)
86 return sctp_sched_prio_head_get(p);
87 }
88
89 /* If not even there, allocate a new one. */
90 return sctp_sched_prio_new_head(stream, prio, gfp);
91 }
92
93 static void sctp_sched_prio_next_stream(struct sctp_stream_priorities *p)
94 {
95 struct list_head *pos;
96
97 pos = p->next->prio_list.next;
98 if (pos == &p->active)
99 pos = pos->next;
100 p->next = list_entry(pos, struct sctp_stream_out_ext, prio_list);
101 }
102
103 static bool sctp_sched_prio_unsched(struct sctp_stream_out_ext *soute)
104 {
105 bool scheduled = false;
106
107 if (!list_empty(&soute->prio_list)) {
108 struct sctp_stream_priorities *prio_head = soute->prio_head;
109
110 /* Scheduled */
111 scheduled = true;
112
113 if (prio_head->next == soute)
114 /* Try to move to the next stream */
115 sctp_sched_prio_next_stream(prio_head);
116
117 list_del_init(&soute->prio_list);
118
119 /* Also unsched the priority if this was the last stream */
120 if (list_empty(&prio_head->active)) {
121 list_del_init(&prio_head->prio_sched);
122 /* If there is no stream left, clear next */
123 prio_head->next = NULL;
124 }
125 }
126
127 return scheduled;
128 }
129
130 static void sctp_sched_prio_sched(struct sctp_stream *stream,
131 struct sctp_stream_out_ext *soute)
132 {
133 struct sctp_stream_priorities *prio, *prio_head;
134
135 prio_head = soute->prio_head;
136
137 /* Nothing to do if already scheduled */
138 if (!list_empty(&soute->prio_list))
139 return;
140
141 /* Schedule the stream. If there is a next, we schedule the new
142 * one before it, so it's the last in round robin order.
143 * If there isn't, we also have to schedule the priority.
144 */
145 if (prio_head->next) {
146 list_add(&soute->prio_list, prio_head->next->prio_list.prev);
147 return;
148 }
149
150 list_add(&soute->prio_list, &prio_head->active);
151 prio_head->next = soute;
152
153 list_for_each_entry(prio, &stream->prio_list, prio_sched) {
154 if (prio->prio > prio_head->prio) {
155 list_add(&prio_head->prio_sched, prio->prio_sched.prev);
156 return;
157 }
158 }
159
160 list_add_tail(&prio_head->prio_sched, &stream->prio_list);
161 }
162
163 static int sctp_sched_prio_set(struct sctp_stream *stream, __u16 sid,
164 __u16 prio, gfp_t gfp)
165 {
166 struct sctp_stream_out *sout = SCTP_SO(stream, sid);
167 struct sctp_stream_out_ext *soute = sout->ext;
168 struct sctp_stream_priorities *prio_head, *old;
169 bool reschedule = false;
170
171 old = soute->prio_head;
172 if (old && old->prio == prio)
173 return 0;
174
175 prio_head = sctp_sched_prio_get_head(stream, prio, gfp);
176 if (!prio_head)
177 return -ENOMEM;
178
179 reschedule = sctp_sched_prio_unsched(soute);
180 soute->prio_head = prio_head;
181 if (reschedule)
182 sctp_sched_prio_sched(stream, soute);
183
184 sctp_sched_prio_head_put(old);
185 return 0;
186 }
187
188 static int sctp_sched_prio_get(struct sctp_stream *stream, __u16 sid,
189 __u16 *value)
190 {
191 *value = SCTP_SO(stream, sid)->ext->prio_head->prio;
192 return 0;
193 }
194
195 static int sctp_sched_prio_init(struct sctp_stream *stream)
196 {
197 INIT_LIST_HEAD(&stream->prio_list);
198
199 return 0;
200 }
201
202 static int sctp_sched_prio_init_sid(struct sctp_stream *stream, __u16 sid,
203 gfp_t gfp)
204 {
205 INIT_LIST_HEAD(&SCTP_SO(stream, sid)->ext->prio_list);
206 return sctp_sched_prio_set(stream, sid, 0, gfp);
207 }
208
209 static void sctp_sched_prio_free_sid(struct sctp_stream *stream, __u16 sid)
210 {
211 sctp_sched_prio_head_put(SCTP_SO(stream, sid)->ext->prio_head);
212 SCTP_SO(stream, sid)->ext->prio_head = NULL;
213 }
214
215 static void sctp_sched_prio_enqueue(struct sctp_outq *q,
216 struct sctp_datamsg *msg)
217 {
218 struct sctp_stream *stream;
219 struct sctp_chunk *ch;
220 __u16 sid;
221
222 ch = list_first_entry(&msg->chunks, struct sctp_chunk, frag_list);
223 sid = sctp_chunk_stream_no(ch);
224 stream = &q->asoc->stream;
225 sctp_sched_prio_sched(stream, SCTP_SO(stream, sid)->ext);
226 }
227
228 static struct sctp_chunk *sctp_sched_prio_dequeue(struct sctp_outq *q)
229 {
230 struct sctp_stream *stream = &q->asoc->stream;
231 struct sctp_stream_priorities *prio;
232 struct sctp_stream_out_ext *soute;
233 struct sctp_chunk *ch = NULL;
234
235 /* Bail out quickly if queue is empty */
236 if (list_empty(&q->out_chunk_list))
237 goto out;
238
239 /* Find which chunk is next. It's easy, it's either the current
240 * one or the first chunk on the next active stream.
241 */
242 if (stream->out_curr) {
243 soute = stream->out_curr->ext;
244 } else {
245 prio = list_entry(stream->prio_list.next,
246 struct sctp_stream_priorities, prio_sched);
247 soute = prio->next;
248 }
249 ch = list_entry(soute->outq.next, struct sctp_chunk, stream_list);
250 sctp_sched_dequeue_common(q, ch);
251
252 out:
253 return ch;
254 }
255
256 static void sctp_sched_prio_dequeue_done(struct sctp_outq *q,
257 struct sctp_chunk *ch)
258 {
259 struct sctp_stream_priorities *prio;
260 struct sctp_stream_out_ext *soute;
261 __u16 sid;
262
263 /* Last chunk on that msg, move to the next stream on
264 * this priority.
265 */
266 sid = sctp_chunk_stream_no(ch);
267 soute = SCTP_SO(&q->asoc->stream, sid)->ext;
268 prio = soute->prio_head;
269
270 sctp_sched_prio_next_stream(prio);
271
272 if (list_empty(&soute->outq))
273 sctp_sched_prio_unsched(soute);
274 }
275
276 static void sctp_sched_prio_sched_all(struct sctp_stream *stream)
277 {
278 struct sctp_association *asoc;
279 struct sctp_stream_out *sout;
280 struct sctp_chunk *ch;
281
282 asoc = container_of(stream, struct sctp_association, stream);
283 list_for_each_entry(ch, &asoc->outqueue.out_chunk_list, list) {
284 __u16 sid;
285
286 sid = sctp_chunk_stream_no(ch);
287 sout = SCTP_SO(stream, sid);
288 if (sout->ext)
289 sctp_sched_prio_sched(stream, sout->ext);
290 }
291 }
292
293 static void sctp_sched_prio_unsched_all(struct sctp_stream *stream)
294 {
295 struct sctp_stream_priorities *p, *tmp;
296 struct sctp_stream_out_ext *soute, *souttmp;
297
298 list_for_each_entry_safe(p, tmp, &stream->prio_list, prio_sched)
299 list_for_each_entry_safe(soute, souttmp, &p->active, prio_list)
300 sctp_sched_prio_unsched(soute);
301 }
302
303 static struct sctp_sched_ops sctp_sched_prio = {
304 .set = sctp_sched_prio_set,
305 .get = sctp_sched_prio_get,
306 .init = sctp_sched_prio_init,
307 .init_sid = sctp_sched_prio_init_sid,
308 .free_sid = sctp_sched_prio_free_sid,
309 .enqueue = sctp_sched_prio_enqueue,
310 .dequeue = sctp_sched_prio_dequeue,
311 .dequeue_done = sctp_sched_prio_dequeue_done,
312 .sched_all = sctp_sched_prio_sched_all,
313 .unsched_all = sctp_sched_prio_unsched_all,
314 };
315
316 void sctp_sched_ops_prio_init(void)
317 {
318 sctp_sched_ops_register(SCTP_SS_PRIO, &sctp_sched_prio);
319 }
320
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.