net/sctp/stream_sched_fc.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /* SCTP kernel implementation
   3  * (C) Copyright Red Hat Inc. 2022
   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 <[email protected]>
  12  *
  13  * Written or modified by:
  14  *    Xin Long <[email protected]>
  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 /* Fair Capacity and Weighted Fair Queueing handling
  23  * RFC 8260 section 3.5 and 3.6
  24  */
  25 static void sctp_sched_fc_unsched_all(struct sctp_stream *stream);
  26
  27 static int sctp_sched_wfq_set(struct sctp_stream *stream, __u16 sid,
  28                               __u16 weight, gfp_t gfp)
  29 {
  30         struct sctp_stream_out_ext *soute = SCTP_SO(stream, sid)->ext;
  31
  32         if (!weight)
  33                 return -EINVAL;
  34
  35         soute->fc_weight = weight;
  36         return 0;
  37 }
  38
  39 static int sctp_sched_wfq_get(struct sctp_stream *stream, __u16 sid,
  40                               __u16 *value)
  41 {
  42         struct sctp_stream_out_ext *soute = SCTP_SO(stream, sid)->ext;
  43
  44         *value = soute->fc_weight;
  45         return 0;
  46 }
  47
  48 static int sctp_sched_fc_set(struct sctp_stream *stream, __u16 sid,
  49                              __u16 weight, gfp_t gfp)
  50 {
  51         return 0;
  52 }
  53
  54 static int sctp_sched_fc_get(struct sctp_stream *stream, __u16 sid,
  55                              __u16 *value)
  56 {
  57         return 0;
  58 }
  59
  60 static int sctp_sched_fc_init(struct sctp_stream *stream)
  61 {
  62         INIT_LIST_HEAD(&stream->fc_list);
  63
  64         return 0;
  65 }
  66
  67 static int sctp_sched_fc_init_sid(struct sctp_stream *stream, __u16 sid,
  68                                   gfp_t gfp)
  69 {
  70         struct sctp_stream_out_ext *soute = SCTP_SO(stream, sid)->ext;
  71
  72         INIT_LIST_HEAD(&soute->fc_list);
  73         soute->fc_length = 0;
  74         soute->fc_weight = 1;
  75
  76         return 0;
  77 }
  78
  79 static void sctp_sched_fc_free_sid(struct sctp_stream *stream, __u16 sid)
  80 {
  81 }
  82
  83 static void sctp_sched_fc_sched(struct sctp_stream *stream,
  84                                 struct sctp_stream_out_ext *soute)
  85 {
  86         struct sctp_stream_out_ext *pos;
  87
  88         if (!list_empty(&soute->fc_list))
  89                 return;
  90
  91         list_for_each_entry(pos, &stream->fc_list, fc_list)
  92                 if ((__u64)pos->fc_length * soute->fc_weight >=
  93                     (__u64)soute->fc_length * pos->fc_weight)
  94                         break;
  95         list_add_tail(&soute->fc_list, &pos->fc_list);
  96 }
  97
  98 static void sctp_sched_fc_enqueue(struct sctp_outq *q,
  99                                   struct sctp_datamsg *msg)
 100 {
 101         struct sctp_stream *stream;
 102         struct sctp_chunk *ch;
 103         __u16 sid;
 104
 105         ch = list_first_entry(&msg->chunks, struct sctp_chunk, frag_list);
 106         sid = sctp_chunk_stream_no(ch);
 107         stream = &q->asoc->stream;
 108         sctp_sched_fc_sched(stream, SCTP_SO(stream, sid)->ext);
 109 }
 110
 111 static struct sctp_chunk *sctp_sched_fc_dequeue(struct sctp_outq *q)
 112 {
 113         struct sctp_stream *stream = &q->asoc->stream;
 114         struct sctp_stream_out_ext *soute;
 115         struct sctp_chunk *ch;
 116
 117         /* Bail out quickly if queue is empty */
 118         if (list_empty(&q->out_chunk_list))
 119                 return NULL;
 120
 121         /* Find which chunk is next */
 122         if (stream->out_curr)
 123                 soute = stream->out_curr->ext;
 124         else
 125                 soute = list_entry(stream->fc_list.next, struct sctp_stream_out_ext, fc_list);
 126         ch = list_entry(soute->outq.next, struct sctp_chunk, stream_list);
 127
 128         sctp_sched_dequeue_common(q, ch);
 129         return ch;
 130 }
 131
 132 static void sctp_sched_fc_dequeue_done(struct sctp_outq *q,
 133                                        struct sctp_chunk *ch)
 134 {
 135         struct sctp_stream *stream = &q->asoc->stream;
 136         struct sctp_stream_out_ext *soute, *pos;
 137         __u16 sid, i;
 138
 139         sid = sctp_chunk_stream_no(ch);
 140         soute = SCTP_SO(stream, sid)->ext;
 141         /* reduce all fc_lengths by U32_MAX / 4 if the current fc_length overflows. */
 142         if (soute->fc_length > U32_MAX - ch->skb->len) {
 143                 for (i = 0; i < stream->outcnt; i++) {
 144                         pos = SCTP_SO(stream, i)->ext;
 145                         if (!pos)
 146                                 continue;
 147                         if (pos->fc_length <= (U32_MAX >> 2)) {
 148                                 pos->fc_length = 0;
 149                                 continue;
 150                         }
 151                         pos->fc_length -= (U32_MAX >> 2);
 152                 }
 153         }
 154         soute->fc_length += ch->skb->len;
 155
 156         if (list_empty(&soute->outq)) {
 157                 list_del_init(&soute->fc_list);
 158                 return;
 159         }
 160
 161         pos = soute;
 162         list_for_each_entry_continue(pos, &stream->fc_list, fc_list)
 163                 if ((__u64)pos->fc_length * soute->fc_weight >=
 164                     (__u64)soute->fc_length * pos->fc_weight)
 165                         break;
 166         list_move_tail(&soute->fc_list, &pos->fc_list);
 167 }
 168
 169 static void sctp_sched_fc_sched_all(struct sctp_stream *stream)
 170 {
 171         struct sctp_association *asoc;
 172         struct sctp_chunk *ch;
 173
 174         asoc = container_of(stream, struct sctp_association, stream);
 175         list_for_each_entry(ch, &asoc->outqueue.out_chunk_list, list) {
 176                 __u16 sid = sctp_chunk_stream_no(ch);
 177
 178                 if (SCTP_SO(stream, sid)->ext)
 179                         sctp_sched_fc_sched(stream, SCTP_SO(stream, sid)->ext);
 180         }
 181 }
 182
 183 static void sctp_sched_fc_unsched_all(struct sctp_stream *stream)
 184 {
 185         struct sctp_stream_out_ext *soute, *tmp;
 186
 187         list_for_each_entry_safe(soute, tmp, &stream->fc_list, fc_list)
 188                 list_del_init(&soute->fc_list);
 189 }
 190
 191 static struct sctp_sched_ops sctp_sched_fc = {
 192         .set = sctp_sched_fc_set,
 193         .get = sctp_sched_fc_get,
 194         .init = sctp_sched_fc_init,
 195         .init_sid = sctp_sched_fc_init_sid,
 196         .free_sid = sctp_sched_fc_free_sid,
 197         .enqueue = sctp_sched_fc_enqueue,
 198         .dequeue = sctp_sched_fc_dequeue,
 199         .dequeue_done = sctp_sched_fc_dequeue_done,
 200         .sched_all = sctp_sched_fc_sched_all,
 201         .unsched_all = sctp_sched_fc_unsched_all,
 202 };
 203
 204 void sctp_sched_ops_fc_init(void)
 205 {
 206         sctp_sched_ops_register(SCTP_SS_FC, &sctp_sched_fc);
 207 }
 208
 209 static struct sctp_sched_ops sctp_sched_wfq = {
 210         .set = sctp_sched_wfq_set,
 211         .get = sctp_sched_wfq_get,
 212         .init = sctp_sched_fc_init,
 213         .init_sid = sctp_sched_fc_init_sid,
 214         .free_sid = sctp_sched_fc_free_sid,
 215         .enqueue = sctp_sched_fc_enqueue,
 216         .dequeue = sctp_sched_fc_dequeue,
 217         .dequeue_done = sctp_sched_fc_dequeue_done,
 218         .sched_all = sctp_sched_fc_sched_all,
 219         .unsched_all = sctp_sched_fc_unsched_all,
 220 };
 221
 222 void sctp_sched_ops_wfq_init(void)
 223 {
 224         sctp_sched_ops_register(SCTP_SS_WFQ, &sctp_sched_wfq);
 225 }