sctp: Add GSO support

SCTP has this pecualiarity that its packets cannot be just segmented to
(P)MTU. Its chunks must be contained in IP segments, padding respected.
So we can't just generate a big skb, set gso_size to the fragmentation
point and deliver it to IP layer.

This patch takes a different approach. SCTP will now build a skb as it
would be if it was received using GRO. That is, there will be a cover
skb with protocol headers and children ones containing the actual
segments, already segmented to a way that respects SCTP RFCs.

With that, we can tell skb_segment() to just split based on frag_list,
trusting its sizes are already in accordance.

This way SCTP can benefit from GSO and instead of passing several
packets through the stack, it can pass a single large packet.

v2:
- Added support for receiving GSO frames, as requested by Dave Miller.
- Clear skb->cb if packet is GSO (otherwise it's not used by SCTP)
- Added heuristics similar to what we have in TCP for not generating
  single GSO packets that fills cwnd.
v3:
- consider sctphdr size in skb_gso_transport_seglen()
- rebased due to 5c7cdf339af5 ("gso: Remove arbitrary checks for
  unsupported GSO")

Signed-off-by: Marcelo Ricardo Leitner <marcelo.leitner@gmail.com>
Tested-by: Xin Long <lucien.xin@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

1 files changed, 43 insertions, 8 deletions

diff --git a/net/sctp/inqueue.c b/net/sctp/inqueue.c
index 5ba08ceda3ab..edabbbdfca54 100644
--- a/net/sctp/inqueue.c
+++ b/net/sctp/inqueue.c
@@ -138,6 +138,17 @@ struct sctp_chunk *sctp_inq_pop(struct sctp_inq *queue)
                 if (chunk->singleton ||
                     chunk->end_of_packet ||
                     chunk->pdiscard) {
+                        if (chunk->head_skb == chunk->skb) {
+                                chunk->skb = skb_shinfo(chunk->skb)->frag_list;
+                                goto new_skb;
+                        }
+                        if (chunk->skb->next) {
+                                chunk->skb = chunk->skb->next;
+                                goto new_skb;
+                        }
+
+                        if (chunk->head_skb)
+                                chunk->skb = chunk->head_skb;
                         sctp_chunk_free(chunk);
                         chunk = queue->in_progress = NULL;
                 } else {
@@ -155,15 +166,15 @@ struct sctp_chunk *sctp_inq_pop(struct sctp_inq *queue)
 
 next_chunk:
                 /* Is the queue empty?  */
-                if (list_empty(&queue->in_chunk_list))
+                entry = sctp_list_dequeue(&queue->in_chunk_list);
+                if (!entry)
                         return NULL;
 
-                entry = queue->in_chunk_list.next;
                 chunk = list_entry(entry, struct sctp_chunk, list);
-                list_del_init(entry);
 
                 /* Linearize if it's not GSO */
-                if (skb_is_nonlinear(chunk->skb)) {
+                if ((skb_shinfo(chunk->skb)->gso_type & SKB_GSO_SCTP) != SKB_GSO_SCTP &&
+                    skb_is_nonlinear(chunk->skb)) {
                         if (skb_linearize(chunk->skb)) {
                                 __SCTP_INC_STATS(dev_net(chunk->skb->dev), SCTP_MIB_IN_PKT_DISCARDS);
                                 sctp_chunk_free(chunk);
@@ -174,15 +185,39 @@ next_chunk:
                         chunk->sctp_hdr = sctp_hdr(chunk->skb);
                 }
 
+                if ((skb_shinfo(chunk->skb)->gso_type & SKB_GSO_SCTP) == SKB_GSO_SCTP) {
+                        /* GSO-marked skbs but without frags, handle
+                         * them normally
+                         */
+                        if (skb_shinfo(chunk->skb)->frag_list)
+                                chunk->head_skb = chunk->skb;
+
+                        /* skbs with "cover letter" */
+                        if (chunk->head_skb && chunk->skb->data_len == chunk->skb->len)
+                                chunk->skb = skb_shinfo(chunk->skb)->frag_list;
+
+                        if (WARN_ON(!chunk->skb)) {
+                                __SCTP_INC_STATS(dev_net(chunk->skb->dev), SCTP_MIB_IN_PKT_DISCARDS);
+                                sctp_chunk_free(chunk);
+                                goto next_chunk;
+                        }
+                }
+
+                if (chunk->asoc)
+                        sock_rps_save_rxhash(chunk->asoc->base.sk, chunk->skb);
+
                 queue->in_progress = chunk;
 
+new_skb:
                 /* This is the first chunk in the packet.  */
-                chunk->singleton = 1;
                 ch = (sctp_chunkhdr_t *) chunk->skb->data;
+                chunk->singleton = 1;
                 chunk->data_accepted = 0;
-
-                if (chunk->asoc)
-                        sock_rps_save_rxhash(chunk->asoc->base.sk, chunk->skb);
+                chunk->pdiscard = 0;
+                chunk->auth = 0;
+                chunk->has_asconf = 0;
+                chunk->end_of_packet = 0;
+                chunk->ecn_ce_done = 0;
         }
 
         chunk->chunk_hdr = ch;