Commit | Line | Data |
---|---|---|
47505b8b | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
5bbbbe32 MRL |
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 | * | |
5bbbbe32 MRL |
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 | /* First Come First Serve (a.k.a. FIFO) | |
23 | * RFC DRAFT ndata Section 3.1 | |
24 | */ | |
25 | static int sctp_sched_fcfs_set(struct sctp_stream *stream, __u16 sid, | |
26 | __u16 value, gfp_t gfp) | |
27 | { | |
28 | return 0; | |
29 | } | |
30 | ||
31 | static int sctp_sched_fcfs_get(struct sctp_stream *stream, __u16 sid, | |
32 | __u16 *value) | |
33 | { | |
34 | *value = 0; | |
35 | return 0; | |
36 | } | |
37 | ||
38 | static int sctp_sched_fcfs_init(struct sctp_stream *stream) | |
39 | { | |
40 | return 0; | |
41 | } | |
42 | ||
43 | static int sctp_sched_fcfs_init_sid(struct sctp_stream *stream, __u16 sid, | |
44 | gfp_t gfp) | |
45 | { | |
46 | return 0; | |
47 | } | |
48 | ||
9ed7bfc7 ZS |
49 | static void sctp_sched_fcfs_free_sid(struct sctp_stream *stream, __u16 sid) |
50 | { | |
51 | } | |
52 | ||
5bbbbe32 MRL |
53 | static void sctp_sched_fcfs_free(struct sctp_stream *stream) |
54 | { | |
55 | } | |
56 | ||
57 | static void sctp_sched_fcfs_enqueue(struct sctp_outq *q, | |
58 | struct sctp_datamsg *msg) | |
59 | { | |
60 | } | |
61 | ||
62 | static struct sctp_chunk *sctp_sched_fcfs_dequeue(struct sctp_outq *q) | |
63 | { | |
64 | struct sctp_stream *stream = &q->asoc->stream; | |
65 | struct sctp_chunk *ch = NULL; | |
66 | struct list_head *entry; | |
67 | ||
68 | if (list_empty(&q->out_chunk_list)) | |
69 | goto out; | |
70 | ||
71 | if (stream->out_curr) { | |
72 | ch = list_entry(stream->out_curr->ext->outq.next, | |
73 | struct sctp_chunk, stream_list); | |
74 | } else { | |
75 | entry = q->out_chunk_list.next; | |
76 | ch = list_entry(entry, struct sctp_chunk, list); | |
77 | } | |
78 | ||
79 | sctp_sched_dequeue_common(q, ch); | |
80 | ||
81 | out: | |
82 | return ch; | |
83 | } | |
84 | ||
85 | static void sctp_sched_fcfs_dequeue_done(struct sctp_outq *q, | |
86 | struct sctp_chunk *chunk) | |
87 | { | |
88 | } | |
89 | ||
90 | static void sctp_sched_fcfs_sched_all(struct sctp_stream *stream) | |
91 | { | |
92 | } | |
93 | ||
94 | static void sctp_sched_fcfs_unsched_all(struct sctp_stream *stream) | |
95 | { | |
96 | } | |
97 | ||
98 | static struct sctp_sched_ops sctp_sched_fcfs = { | |
99 | .set = sctp_sched_fcfs_set, | |
100 | .get = sctp_sched_fcfs_get, | |
101 | .init = sctp_sched_fcfs_init, | |
102 | .init_sid = sctp_sched_fcfs_init_sid, | |
9ed7bfc7 | 103 | .free_sid = sctp_sched_fcfs_free_sid, |
5bbbbe32 MRL |
104 | .free = sctp_sched_fcfs_free, |
105 | .enqueue = sctp_sched_fcfs_enqueue, | |
106 | .dequeue = sctp_sched_fcfs_dequeue, | |
107 | .dequeue_done = sctp_sched_fcfs_dequeue_done, | |
108 | .sched_all = sctp_sched_fcfs_sched_all, | |
109 | .unsched_all = sctp_sched_fcfs_unsched_all, | |
110 | }; | |
111 | ||
1ba896f6 XL |
112 | static void sctp_sched_ops_fcfs_init(void) |
113 | { | |
114 | sctp_sched_ops_register(SCTP_SS_FCFS, &sctp_sched_fcfs); | |
115 | } | |
116 | ||
5bbbbe32 MRL |
117 | /* API to other parts of the stack */ |
118 | ||
1ba896f6 | 119 | static struct sctp_sched_ops *sctp_sched_ops[SCTP_SS_MAX + 1]; |
637784ad | 120 | |
1ba896f6 XL |
121 | void sctp_sched_ops_register(enum sctp_sched_type sched, |
122 | struct sctp_sched_ops *sched_ops) | |
123 | { | |
124 | sctp_sched_ops[sched] = sched_ops; | |
125 | } | |
126 | ||
127 | void sctp_sched_ops_init(void) | |
128 | { | |
129 | sctp_sched_ops_fcfs_init(); | |
130 | sctp_sched_ops_prio_init(); | |
131 | sctp_sched_ops_rr_init(); | |
132 | } | |
5bbbbe32 MRL |
133 | |
134 | int sctp_sched_set_sched(struct sctp_association *asoc, | |
135 | enum sctp_sched_type sched) | |
136 | { | |
137 | struct sctp_sched_ops *n = sctp_sched_ops[sched]; | |
138 | struct sctp_sched_ops *old = asoc->outqueue.sched; | |
139 | struct sctp_datamsg *msg = NULL; | |
140 | struct sctp_chunk *ch; | |
141 | int i, ret = 0; | |
142 | ||
143 | if (old == n) | |
144 | return ret; | |
145 | ||
146 | if (sched > SCTP_SS_MAX) | |
147 | return -EINVAL; | |
148 | ||
149 | if (old) { | |
150 | old->free(&asoc->stream); | |
151 | ||
152 | /* Give the next scheduler a clean slate. */ | |
153 | for (i = 0; i < asoc->stream.outcnt; i++) { | |
29849a48 | 154 | struct sctp_stream_out_ext *ext = SCTP_SO(&asoc->stream, i)->ext; |
5bbbbe32 | 155 | |
29849a48 | 156 | if (!ext) |
5bbbbe32 | 157 | continue; |
29849a48 | 158 | memset_after(ext, 0, outq); |
5bbbbe32 MRL |
159 | } |
160 | } | |
161 | ||
162 | asoc->outqueue.sched = n; | |
163 | n->init(&asoc->stream); | |
164 | for (i = 0; i < asoc->stream.outcnt; i++) { | |
05364ca0 | 165 | if (!SCTP_SO(&asoc->stream, i)->ext) |
5bbbbe32 MRL |
166 | continue; |
167 | ||
b89fc26f | 168 | ret = n->init_sid(&asoc->stream, i, GFP_ATOMIC); |
5bbbbe32 MRL |
169 | if (ret) |
170 | goto err; | |
171 | } | |
172 | ||
173 | /* We have to requeue all chunks already queued. */ | |
174 | list_for_each_entry(ch, &asoc->outqueue.out_chunk_list, list) { | |
175 | if (ch->msg == msg) | |
176 | continue; | |
177 | msg = ch->msg; | |
178 | n->enqueue(&asoc->outqueue, msg); | |
179 | } | |
180 | ||
181 | return ret; | |
182 | ||
183 | err: | |
184 | n->free(&asoc->stream); | |
185 | asoc->outqueue.sched = &sctp_sched_fcfs; /* Always safe */ | |
186 | ||
187 | return ret; | |
188 | } | |
189 | ||
190 | int sctp_sched_get_sched(struct sctp_association *asoc) | |
191 | { | |
192 | int i; | |
193 | ||
194 | for (i = 0; i <= SCTP_SS_MAX; i++) | |
195 | if (asoc->outqueue.sched == sctp_sched_ops[i]) | |
196 | return i; | |
197 | ||
198 | return 0; | |
199 | } | |
200 | ||
201 | int sctp_sched_set_value(struct sctp_association *asoc, __u16 sid, | |
202 | __u16 value, gfp_t gfp) | |
203 | { | |
204 | if (sid >= asoc->stream.outcnt) | |
205 | return -EINVAL; | |
206 | ||
05364ca0 | 207 | if (!SCTP_SO(&asoc->stream, sid)->ext) { |
5bbbbe32 MRL |
208 | int ret; |
209 | ||
210 | ret = sctp_stream_init_ext(&asoc->stream, sid); | |
211 | if (ret) | |
212 | return ret; | |
213 | } | |
214 | ||
215 | return asoc->outqueue.sched->set(&asoc->stream, sid, value, gfp); | |
216 | } | |
217 | ||
218 | int sctp_sched_get_value(struct sctp_association *asoc, __u16 sid, | |
219 | __u16 *value) | |
220 | { | |
221 | if (sid >= asoc->stream.outcnt) | |
222 | return -EINVAL; | |
223 | ||
05364ca0 | 224 | if (!SCTP_SO(&asoc->stream, sid)->ext) |
5bbbbe32 MRL |
225 | return 0; |
226 | ||
227 | return asoc->outqueue.sched->get(&asoc->stream, sid, value); | |
228 | } | |
229 | ||
230 | void sctp_sched_dequeue_done(struct sctp_outq *q, struct sctp_chunk *ch) | |
231 | { | |
ef4775e3 | 232 | if (!list_is_last(&ch->frag_list, &ch->msg->chunks) && |
da1f6d4d | 233 | !q->asoc->peer.intl_capable) { |
5bbbbe32 MRL |
234 | struct sctp_stream_out *sout; |
235 | __u16 sid; | |
236 | ||
237 | /* datamsg is not finish, so save it as current one, | |
238 | * in case application switch scheduler or a higher | |
239 | * priority stream comes in. | |
240 | */ | |
241 | sid = sctp_chunk_stream_no(ch); | |
05364ca0 | 242 | sout = SCTP_SO(&q->asoc->stream, sid); |
5bbbbe32 MRL |
243 | q->asoc->stream.out_curr = sout; |
244 | return; | |
245 | } | |
246 | ||
247 | q->asoc->stream.out_curr = NULL; | |
248 | q->sched->dequeue_done(q, ch); | |
249 | } | |
250 | ||
251 | /* Auxiliary functions for the schedulers */ | |
252 | void sctp_sched_dequeue_common(struct sctp_outq *q, struct sctp_chunk *ch) | |
253 | { | |
254 | list_del_init(&ch->list); | |
255 | list_del_init(&ch->stream_list); | |
256 | q->out_qlen -= ch->skb->len; | |
257 | } | |
258 | ||
259 | int sctp_sched_init_sid(struct sctp_stream *stream, __u16 sid, gfp_t gfp) | |
260 | { | |
261 | struct sctp_sched_ops *sched = sctp_sched_ops_from_stream(stream); | |
05364ca0 | 262 | struct sctp_stream_out_ext *ext = SCTP_SO(stream, sid)->ext; |
5bbbbe32 | 263 | |
05364ca0 | 264 | INIT_LIST_HEAD(&ext->outq); |
5bbbbe32 MRL |
265 | return sched->init_sid(stream, sid, gfp); |
266 | } | |
267 | ||
268 | struct sctp_sched_ops *sctp_sched_ops_from_stream(struct sctp_stream *stream) | |
269 | { | |
270 | struct sctp_association *asoc; | |
271 | ||
272 | asoc = container_of(stream, struct sctp_association, stream); | |
273 | ||
274 | return asoc->outqueue.sched; | |
275 | } |