sctp: introduce stream scheduler foundations

This patch introduces the hooks necessary to do stream scheduling, as
per RFC Draft ndata.  It also introduces the first scheduler, which is
what we do today but now factored out: first come first served (FCFS).

With stream scheduling now we have to track which chunk was enqueued on
which stream and be able to select another other than the in front of
the main outqueue. So we introduce a list on sctp_stream_out_ext
structure for this purpose.

We reuse sctp_chunk->transmitted_list space for the list above, as the
chunk cannot belong to the two lists at the same time. By using the
union in there, we can have distinct names for these moments.

sctp_sched_ops are the operations expected to be implemented by each
scheduler. The dequeueing is a bit particular to this implementation but
it is to match how we dequeue packets today. We first dequeue and then
check if it fits the packet and if not, we requeue it at head. Thus why
we don't have a peek operation but have dequeue_done instead, which is
called once the chunk can be safely considered as transmitted.

The check removed from sctp_outq_flush is now performed by
sctp_stream_outq_migrate, which is only called during assoc setup.
(sctp_sendmsg() also checks for it)

The only operation that is foreseen but not yet added here is a way to
signalize that a new packet is starting or that the packet is done, for
round robin scheduler per packet, but is intentionally left to the
patch that actually implements it.

Support for I-DATA chunks, also described in this RFC, with user message
interleaving is straightforward as it just requires the schedulers to
probe for the feature and ignore datamsg boundaries when dequeueing.

See-also: https://tools.ietf.org/html/draft-ietf-tsvwg-sctp-ndata-13
Tested-by: Xin Long <lucien.xin@gmail.com>
Signed-off-by: Marcelo Ricardo Leitner <marcelo.leitner@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

1 files changed, 32 insertions, 27 deletions

diff --git a/net/sctp/outqueue.c b/net/sctp/outqueue.c
index 746b07b7937d..4db012aa25f7 100644
--- a/net/sctp/outqueue.c
+++ b/net/sctp/outqueue.c
@@ -50,6 +50,7 @@
 
 #include <net/sctp/sctp.h>
 #include <net/sctp/sm.h>
+#include <net/sctp/stream_sched.h>
 
 /* Declare internal functions here.  */
 static int sctp_acked(struct sctp_sackhdr *sack, __u32 tsn);
@@ -72,32 +73,38 @@ static void sctp_outq_flush(struct sctp_outq *q, int rtx_timeout, gfp_t gfp);
 
 /* Add data to the front of the queue. */
 static inline void sctp_outq_head_data(struct sctp_outq *q,
-                                        struct sctp_chunk *ch)
+                                       struct sctp_chunk *ch)
 {
+        struct sctp_stream_out_ext *oute;
+        __u16 stream;
+
         list_add(&ch->list, &q->out_chunk_list);
         q->out_qlen += ch->skb->len;
+
+        stream = sctp_chunk_stream_no(ch);
+        oute = q->asoc->stream.out[stream].ext;
+        list_add(&ch->stream_list, &oute->outq);
 }
 
 /* Take data from the front of the queue. */
 static inline struct sctp_chunk *sctp_outq_dequeue_data(struct sctp_outq *q)
 {
-        struct sctp_chunk *ch = NULL;
-
-        if (!list_empty(&q->out_chunk_list)) {
-                struct list_head *entry = q->out_chunk_list.next;
-
-                ch = list_entry(entry, struct sctp_chunk, list);
-                list_del_init(entry);
-                q->out_qlen -= ch->skb->len;
-        }
-        return ch;
+        return q->sched->dequeue(q);
 }
+
 /* Add data chunk to the end of the queue. */
 static inline void sctp_outq_tail_data(struct sctp_outq *q,
                                        struct sctp_chunk *ch)
 {
+        struct sctp_stream_out_ext *oute;
+        __u16 stream;
+
         list_add_tail(&ch->list, &q->out_chunk_list);
         q->out_qlen += ch->skb->len;
+
+        stream = sctp_chunk_stream_no(ch);
+        oute = q->asoc->stream.out[stream].ext;
+        list_add_tail(&ch->stream_list, &oute->outq);
 }
 
 /*
@@ -207,6 +214,7 @@ void sctp_outq_init(struct sctp_association *asoc, struct sctp_outq *q)
         INIT_LIST_HEAD(&q->retransmit);
         INIT_LIST_HEAD(&q->sacked);
         INIT_LIST_HEAD(&q->abandoned);
+        sctp_sched_set_sched(asoc, SCTP_SS_FCFS);
 }
 
 /* Free the outqueue structure and any related pending chunks.
@@ -258,6 +266,7 @@ static void __sctp_outq_teardown(struct sctp_outq *q)
 
         /* Throw away any leftover data chunks. */
         while ((chunk = sctp_outq_dequeue_data(q)) != NULL) {
+                sctp_sched_dequeue_done(q, chunk);
 
                 /* Mark as send failure. */
                 sctp_chunk_fail(chunk, q->error);
@@ -391,13 +400,14 @@ static int sctp_prsctp_prune_unsent(struct sctp_association *asoc,
         struct sctp_outq *q = &asoc->outqueue;
         struct sctp_chunk *chk, *temp;
 
+        q->sched->unsched_all(&asoc->stream);
+
         list_for_each_entry_safe(chk, temp, &q->out_chunk_list, list) {
                 if (!SCTP_PR_PRIO_ENABLED(chk->sinfo.sinfo_flags) ||
                     chk->sinfo.sinfo_timetolive <= sinfo->sinfo_timetolive)
                         continue;
 
-                list_del_init(&chk->list);
-                q->out_qlen -= chk->skb->len;
+                sctp_sched_dequeue_common(q, chk);
                 asoc->sent_cnt_removable--;
                 asoc->abandoned_unsent[SCTP_PR_INDEX(PRIO)]++;
                 if (chk->sinfo.sinfo_stream < asoc->stream.outcnt) {
@@ -415,6 +425,8 @@ static int sctp_prsctp_prune_unsent(struct sctp_association *asoc,
                         break;
         }
 
+        q->sched->sched_all(&asoc->stream);
+
         return msg_len;
 }
 
@@ -1033,22 +1045,9 @@ static void sctp_outq_flush(struct sctp_outq *q, int rtx_timeout, gfp_t gfp)
                 while ((chunk = sctp_outq_dequeue_data(q)) != NULL) {
                         __u32 sid = ntohs(chunk->subh.data_hdr->stream);
 
-                        /* RFC 2960 6.5 Every DATA chunk MUST carry a valid
-                         * stream identifier.
-                         */
-                        if (chunk->sinfo.sinfo_stream >= asoc->stream.outcnt) {
-
-                                /* Mark as failed send. */
-                                sctp_chunk_fail(chunk, SCTP_ERROR_INV_STRM);
-                                if (asoc->peer.prsctp_capable &&
-                                    SCTP_PR_PRIO_ENABLED(chunk->sinfo.sinfo_flags))
-                                        asoc->sent_cnt_removable--;
-                                sctp_chunk_free(chunk);
-                                continue;
-                        }
-
                         /* Has this chunk expired? */
                         if (sctp_chunk_abandoned(chunk)) {
+                                sctp_sched_dequeue_done(q, chunk);
                                 sctp_chunk_fail(chunk, 0);
                                 sctp_chunk_free(chunk);
                                 continue;
@@ -1070,6 +1069,7 @@ static void sctp_outq_flush(struct sctp_outq *q, int rtx_timeout, gfp_t gfp)
                                 new_transport = asoc->peer.active_path;
                         if (new_transport->state == SCTP_UNCONFIRMED) {
                                 WARN_ONCE(1, "Attempt to send packet on unconfirmed path.");
+                                sctp_sched_dequeue_done(q, chunk);
                                 sctp_chunk_fail(chunk, 0);
                                 sctp_chunk_free(chunk);
                                 continue;
@@ -1133,6 +1133,11 @@ static void sctp_outq_flush(struct sctp_outq *q, int rtx_timeout, gfp_t gfp)
                                 else
                                         asoc->stats.oodchunks++;
 
+                                /* Only now it's safe to consider this
+                                 * chunk as sent, sched-wise.
+                                 */
+                                sctp_sched_dequeue_done(q, chunk);
+
                                 break;
 
                         default: