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