net/sctp/stream_sched_prio.c

   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_new_head(
  29                         struct sctp_stream *stream, int prio, gfp_t gfp)
  30 {
  31         struct sctp_stream_priorities *p;
  32
  33         p = kmalloc(sizeof(*p), gfp);
  34         if (!p)
  35                 return NULL;
  36
  37         INIT_LIST_HEAD(&p->prio_sched);
  38         INIT_LIST_HEAD(&p->active);
  39         p->next = NULL;
  40         p->prio = prio;
  41
  42         return p;
  43 }
  44
  45 static struct sctp_stream_priorities *sctp_sched_prio_get_head(
  46                         struct sctp_stream *stream, int prio, gfp_t gfp)
  47 {
  48         struct sctp_stream_priorities *p;
  49         int i;
  50
  51         /* Look into scheduled priorities first, as they are sorted and
  52          * we can find it fast IF it's scheduled.
  53          */
  54         list_for_each_entry(p, &stream->prio_list, prio_sched) {
  55                 if (p->prio == prio)
  56                         return p;
  57                 if (p->prio > prio)
  58                         break;
  59         }
  60
  61         /* No luck. So we search on all streams now. */
  62         for (i = 0; i < stream->outcnt; i++) {
  63                 if (!SCTP_SO(stream, i)->ext)
  64                         continue;
  65
  66                 p = SCTP_SO(stream, i)->ext->prio_head;
  67                 if (!p)
  68                         /* Means all other streams won't be initialized
  69                          * as well.
  70                          */
  71                         break;
  72                 if (p->prio == prio)
  73                         return p;
  74         }
  75
  76         /* If not even there, allocate a new one. */
  77         return sctp_sched_prio_new_head(stream, prio, gfp);
  78 }
  79
  80 static void sctp_sched_prio_next_stream(struct sctp_stream_priorities *p)
  81 {
  82         struct list_head *pos;
  83
  84         pos = p->next->prio_list.next;
  85         if (pos == &p->active)
  86                 pos = pos->next;
  87         p->next = list_entry(pos, struct sctp_stream_out_ext, prio_list);
  88 }
  89
  90 static bool sctp_sched_prio_unsched(struct sctp_stream_out_ext *soute)
  91 {
  92         bool scheduled = false;
  93
  94         if (!list_empty(&soute->prio_list)) {
  95                 struct sctp_stream_priorities *prio_head = soute->prio_head;
  96
  97                 /* Scheduled */
  98                 scheduled = true;
  99
 100                 if (prio_head->next == soute)
 101                         /* Try to move to the next stream */
 102                         sctp_sched_prio_next_stream(prio_head);
 103
 104                 list_del_init(&soute->prio_list);
 105
 106                 /* Also unsched the priority if this was the last stream */
 107                 if (list_empty(&prio_head->active)) {
 108                         list_del_init(&prio_head->prio_sched);
 109                         /* If there is no stream left, clear next */
 110                         prio_head->next = NULL;
 111                 }
 112         }
 113
 114         return scheduled;
 115 }
 116
 117 static void sctp_sched_prio_sched(struct sctp_stream *stream,
 118                                   struct sctp_stream_out_ext *soute)
 119 {
 120         struct sctp_stream_priorities *prio, *prio_head;
 121
 122         prio_head = soute->prio_head;
 123
 124         /* Nothing to do if already scheduled */
 125         if (!list_empty(&soute->prio_list))
 126                 return;
 127
 128         /* Schedule the stream. If there is a next, we schedule the new
 129          * one before it, so it's the last in round robin order.
 130          * If there isn't, we also have to schedule the priority.
 131          */
 132         if (prio_head->next) {
 133                 list_add(&soute->prio_list, prio_head->next->prio_list.prev);
 134                 return;
 135         }
 136
 137         list_add(&soute->prio_list, &prio_head->active);
 138         prio_head->next = soute;
 139
 140         list_for_each_entry(prio, &stream->prio_list, prio_sched) {
 141                 if (prio->prio > prio_head->prio) {
 142                         list_add(&prio_head->prio_sched, prio->prio_sched.prev);
 143                         return;
 144                 }
 145         }
 146
 147         list_add_tail(&prio_head->prio_sched, &stream->prio_list);
 148 }
 149
 150 static int sctp_sched_prio_set(struct sctp_stream *stream, __u16 sid,
 151                                __u16 prio, gfp_t gfp)
 152 {
 153         struct sctp_stream_out *sout = SCTP_SO(stream, sid);
 154         struct sctp_stream_out_ext *soute = sout->ext;
 155         struct sctp_stream_priorities *prio_head, *old;
 156         bool reschedule = false;
 157         int i;
 158
 159         prio_head = sctp_sched_prio_get_head(stream, prio, gfp);
 160         if (!prio_head)
 161                 return -ENOMEM;
 162
 163         reschedule = sctp_sched_prio_unsched(soute);
 164         old = soute->prio_head;
 165         soute->prio_head = prio_head;
 166         if (reschedule)
 167                 sctp_sched_prio_sched(stream, soute);
 168
 169         if (!old)
 170                 /* Happens when we set the priority for the first time */
 171                 return 0;
 172
 173         for (i = 0; i < stream->outcnt; i++) {
 174                 soute = SCTP_SO(stream, i)->ext;
 175                 if (soute && soute->prio_head == old)
 176                         /* It's still in use, nothing else to do here. */
 177                         return 0;
 178         }
 179
 180         /* No hits, we are good to free it. */
 181         kfree(old);
 182
 183         return 0;
 184 }
 185
 186 static int sctp_sched_prio_get(struct sctp_stream *stream, __u16 sid,
 187                                __u16 *value)
 188 {
 189         *value = SCTP_SO(stream, sid)->ext->prio_head->prio;
 190         return 0;
 191 }
 192
 193 static int sctp_sched_prio_init(struct sctp_stream *stream)
 194 {
 195         INIT_LIST_HEAD(&stream->prio_list);
 196
 197         return 0;
 198 }
 199
 200 static int sctp_sched_prio_init_sid(struct sctp_stream *stream, __u16 sid,
 201                                     gfp_t gfp)
 202 {
 203         INIT_LIST_HEAD(&SCTP_SO(stream, sid)->ext->prio_list);
 204         return sctp_sched_prio_set(stream, sid, 0, gfp);
 205 }
 206
 207 static void sctp_sched_prio_free(struct sctp_stream *stream)
 208 {
 209         struct sctp_stream_priorities *prio, *n;
 210         LIST_HEAD(list);
 211         int i;
 212
 213         /* As we don't keep a list of priorities, to avoid multiple
 214          * frees we have to do it in 3 steps:
 215          *   1. unsched everyone, so the lists are free to use in 2.
 216          *   2. build the list of the priorities
 217          *   3. free the list
 218          */
 219         sctp_sched_prio_unsched_all(stream);
 220         for (i = 0; i < stream->outcnt; i++) {
 221                 if (!SCTP_SO(stream, i)->ext)
 222                         continue;
 223                 prio = SCTP_SO(stream, i)->ext->prio_head;
 224                 if (prio && list_empty(&prio->prio_sched))
 225                         list_add(&prio->prio_sched, &list);
 226         }
 227         list_for_each_entry_safe(prio, n, &list, prio_sched) {
 228                 list_del_init(&prio->prio_sched);
 229                 kfree(prio);
 230         }
 231 }
 232
 233 static void sctp_sched_prio_enqueue(struct sctp_outq *q,
 234                                     struct sctp_datamsg *msg)
 235 {
 236         struct sctp_stream *stream;
 237         struct sctp_chunk *ch;
 238         __u16 sid;
 239
 240         ch = list_first_entry(&msg->chunks, struct sctp_chunk, frag_list);
 241         sid = sctp_chunk_stream_no(ch);
 242         stream = &q->asoc->stream;
 243         sctp_sched_prio_sched(stream, SCTP_SO(stream, sid)->ext);
 244 }
 245
 246 static struct sctp_chunk *sctp_sched_prio_dequeue(struct sctp_outq *q)
 247 {
 248         struct sctp_stream *stream = &q->asoc->stream;
 249         struct sctp_stream_priorities *prio;
 250         struct sctp_stream_out_ext *soute;
 251         struct sctp_chunk *ch = NULL;
 252
 253         /* Bail out quickly if queue is empty */
 254         if (list_empty(&q->out_chunk_list))
 255                 goto out;
 256
 257         /* Find which chunk is next. It's easy, it's either the current
 258          * one or the first chunk on the next active stream.
 259          */
 260         if (stream->out_curr) {
 261                 soute = stream->out_curr->ext;
 262         } else {
 263                 prio = list_entry(stream->prio_list.next,
 264                                   struct sctp_stream_priorities, prio_sched);
 265                 soute = prio->next;
 266         }
 267         ch = list_entry(soute->outq.next, struct sctp_chunk, stream_list);
 268         sctp_sched_dequeue_common(q, ch);
 269
 270 out:
 271         return ch;
 272 }
 273
 274 static void sctp_sched_prio_dequeue_done(struct sctp_outq *q,
 275                                          struct sctp_chunk *ch)
 276 {
 277         struct sctp_stream_priorities *prio;
 278         struct sctp_stream_out_ext *soute;
 279         __u16 sid;
 280
 281         /* Last chunk on that msg, move to the next stream on
 282          * this priority.
 283          */
 284         sid = sctp_chunk_stream_no(ch);
 285         soute = SCTP_SO(&q->asoc->stream, sid)->ext;
 286         prio = soute->prio_head;
 287
 288         sctp_sched_prio_next_stream(prio);
 289
 290         if (list_empty(&soute->outq))
 291                 sctp_sched_prio_unsched(soute);
 292 }
 293
 294 static void sctp_sched_prio_sched_all(struct sctp_stream *stream)
 295 {
 296         struct sctp_association *asoc;
 297         struct sctp_stream_out *sout;
 298         struct sctp_chunk *ch;
 299
 300         asoc = container_of(stream, struct sctp_association, stream);
 301         list_for_each_entry(ch, &asoc->outqueue.out_chunk_list, list) {
 302                 __u16 sid;
 303
 304                 sid = sctp_chunk_stream_no(ch);
 305                 sout = SCTP_SO(stream, sid);
 306                 if (sout->ext)
 307                         sctp_sched_prio_sched(stream, sout->ext);
 308         }
 309 }
 310
 311 static void sctp_sched_prio_unsched_all(struct sctp_stream *stream)
 312 {
 313         struct sctp_stream_priorities *p, *tmp;
 314         struct sctp_stream_out_ext *soute, *souttmp;
 315
 316         list_for_each_entry_safe(p, tmp, &stream->prio_list, prio_sched)
 317                 list_for_each_entry_safe(soute, souttmp, &p->active, prio_list)
 318                         sctp_sched_prio_unsched(soute);
 319 }
 320
 321 static struct sctp_sched_ops sctp_sched_prio = {
 322         .set = sctp_sched_prio_set,
 323         .get = sctp_sched_prio_get,
 324         .init = sctp_sched_prio_init,
 325         .init_sid = sctp_sched_prio_init_sid,
 326         .free = sctp_sched_prio_free,
 327         .enqueue = sctp_sched_prio_enqueue,
 328         .dequeue = sctp_sched_prio_dequeue,
 329         .dequeue_done = sctp_sched_prio_dequeue_done,
 330         .sched_all = sctp_sched_prio_sched_all,
 331         .unsched_all = sctp_sched_prio_unsched_all,
 332 };
 333
 334 void sctp_sched_ops_prio_init(void)
 335 {
 336         sctp_sched_ops_register(SCTP_SS_PRIO, &sctp_sched_prio);
 337 }