sctp: Send user messages to the lower layer as one

Currenlty, sctp breaks up user messages into fragments and
sends each fragment to the lower layer by itself.  This means
that for each fragment we go all the way down the stack
and back up.  This also discourages bundling of multiple
fragments when they can fit into a sigle packet (ex: due
to user setting a low fragmentation threashold).

We introduce a new command SCTP_CMD_SND_MSG and hand the
whole message down state machine.  The state machine and
the side-effect parser will cork the queue, add all chunks
from the message to the queue, and then un-cork the queue
thus causing the chunks to get transmitted.

Signed-off-by: Vlad Yasevich <vladislav.yasevich@hp.com>

diff --git a/include/net/sctp/command.h b/include/net/sctp/command.h
index 3b966802e05d2724ed6940e5e9a7326176192b8f..8be5135ff7aa4f9ba46bf2e491fc13350b676828 100644 (file)
--- a/include/net/sctp/command.h
+++ b/include/net/sctp/command.h
@@ -106,6 +106,7 @@ typedef enum {
        SCTP_CMD_ASSOC_SHKEY,    /* generate the association shared keys */
        SCTP_CMD_T1_RETRAN,      /* Mark for retransmission after T1 timeout  */
        SCTP_CMD_UPDATE_INITTAG, /* Update peer inittag */
+       SCTP_CMD_SEND_MSG,       /* Send the whole use message */
        SCTP_CMD_LAST
 } sctp_verb_t;
 
@@ -139,6 +140,7 @@ typedef union {
        struct sctp_ulpevent *ulpevent;
        struct sctp_packet *packet;
        sctp_sackhdr_t *sackh;
+       struct sctp_datamsg *msg;
 } sctp_arg_t;
 
 /* We are simulating ML type constructors here.
@@ -188,6 +190,7 @@ SCTP_ARG_CONSTRUCTOR(PEER_INIT,     sctp_init_chunk_t *, init)
 SCTP_ARG_CONSTRUCTOR(ULPEVENT,  struct sctp_ulpevent *, ulpevent)
 SCTP_ARG_CONSTRUCTOR(PACKET,   struct sctp_packet *, packet)
 SCTP_ARG_CONSTRUCTOR(SACKH,    sctp_sackhdr_t *, sackh)
+SCTP_ARG_CONSTRUCTOR(DATAMSG,  struct sctp_datamsg *, msg)
 
 typedef struct {
        sctp_arg_t obj;

diff --git a/include/net/sctp/structs.h b/include/net/sctp/structs.h
index edfcacf3250e5695c07f5cbeba9d7de10037d57d..97024faaa08f20332778b80f4568751c970f9abb 100644 (file)
--- a/include/net/sctp/structs.h
+++ b/include/net/sctp/structs.h
@@ -643,6 +643,7 @@ struct sctp_datamsg {
 struct sctp_datamsg *sctp_datamsg_from_user(struct sctp_association *,
                                            struct sctp_sndrcvinfo *,
                                            struct msghdr *, int len);
+void sctp_datamsg_free(struct sctp_datamsg *);
 void sctp_datamsg_put(struct sctp_datamsg *);
 void sctp_chunk_fail(struct sctp_chunk *, int error);
 int sctp_chunk_abandoned(struct sctp_chunk *);

diff --git a/net/sctp/chunk.c b/net/sctp/chunk.c
index 7acaf15679b658dfbf80aad1ea9e7b21a6425fbc..645577ddc33e378ed1e33ffbe9cd043c6aeab9a9 100644 (file)
--- a/net/sctp/chunk.c
+++ b/net/sctp/chunk.c
@@ -73,6 +73,19 @@ SCTP_STATIC struct sctp_datamsg *sctp_datamsg_new(gfp_t gfp)
        return msg;
 }
 
+void sctp_datamsg_free(struct sctp_datamsg *msg)
+{
+       struct sctp_chunk *chunk;
+
+       /* This doesn't have to be a _safe vairant because
+        * sctp_chunk_free() only drops the refs.
+        */
+       list_for_each_entry(chunk, &msg->chunks, frag_list)
+               sctp_chunk_free(chunk);
+
+       sctp_datamsg_put(msg);
+}
+
 /* Final destructruction of datamsg memory. */
 static void sctp_datamsg_destroy(struct sctp_datamsg *msg)
 {

diff --git a/net/sctp/sm_sideeffect.c b/net/sctp/sm_sideeffect.c
index 86426aac16009ec3e886efc2dd8fdd3f82f6a612..238adf7978e96124f8adef2918b2eab36ba3959c 100644 (file)
--- a/net/sctp/sm_sideeffect.c
+++ b/net/sctp/sm_sideeffect.c
@@ -931,6 +931,27 @@ static void sctp_cmd_t1_timer_update(struct sctp_association *asoc,
 
 }
 
+/* Send the whole message, chunk by chunk, to the outqueue.
+ * This way the whole message is queued up and bundling if
+ * encouraged for small fragments.
+ */
+static int sctp_cmd_send_msg(struct sctp_association *asoc,
+                               struct sctp_datamsg *msg)
+{
+       struct sctp_chunk *chunk;
+       int error = 0;
+
+       list_for_each_entry(chunk, &msg->chunks, frag_list) {
+               error = sctp_outq_tail(&asoc->outqueue, chunk);
+               if (error)
+                       break;
+       }
+
+       return error;
+}
+
+
+
 /* These three macros allow us to pull the debugging code out of the
  * main flow of sctp_do_sm() to keep attention focused on the real
  * functionality there.
@@ -1575,7 +1596,13 @@ static int sctp_cmd_interpreter(sctp_event_t event_type,
                case SCTP_CMD_UPDATE_INITTAG:
                        asoc->peer.i.init_tag = cmd->obj.u32;
                        break;
-
+               case SCTP_CMD_SEND_MSG:
+                       if (!asoc->outqueue.cork) {
+                               sctp_outq_cork(&asoc->outqueue);
+                               local_cork = 1;
+                       }
+                       error = sctp_cmd_send_msg(asoc, cmd->obj.msg);
+                       break;
                default:
                        printk(KERN_WARNING "Impossible command: %u, %p\n",
                               cmd->verb, cmd->obj.ptr);

diff --git a/net/sctp/sm_statefuns.c b/net/sctp/sm_statefuns.c
index 50225dd2e6dc92cba165b9d7edeee454bc650cf8..910926906a3ac19f2f00ab97abb1da737490f047 100644 (file)
--- a/net/sctp/sm_statefuns.c
+++ b/net/sctp/sm_statefuns.c
@@ -4555,9 +4555,9 @@ sctp_disposition_t sctp_sf_do_prm_send(const struct sctp_endpoint *ep,
                                       void *arg,
                                       sctp_cmd_seq_t *commands)
 {
-       struct sctp_chunk *chunk = arg;
+       struct sctp_datamsg *msg = arg;
 
-       sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(chunk));
+       sctp_add_cmd_sf(commands, SCTP_CMD_SEND_MSG, SCTP_DATAMSG(msg));
        return SCTP_DISPOSITION_CONSUME;
 }
 

diff --git a/net/sctp/socket.c b/net/sctp/socket.c
index a7e544e3f28aa73294ec0e228b07fc17b05c052d..95a5623d79a0dc01642f29662a99ba5d4afd0885 100644 (file)
--- a/net/sctp/socket.c
+++ b/net/sctp/socket.c
@@ -1814,20 +1814,22 @@ SCTP_STATIC int sctp_sendmsg(struct kiocb *iocb, struct sock *sk,
                sctp_set_owner_w(chunk);
 
                chunk->transport = chunk_tp;
-
-               /* Send it to the lower layers.  Note:  all chunks
-                * must either fail or succeed.   The lower layer
-                * works that way today.  Keep it that way or this
-                * breaks.
-                */
-               err = sctp_primitive_SEND(asoc, chunk);
-               /* Did the lower layer accept the chunk? */
-               if (err)
-                       sctp_chunk_free(chunk);
-               SCTP_DEBUG_PRINTK("We sent primitively.\n");
        }
 
-       sctp_datamsg_put(datamsg);
+       /* Send it to the lower layers.  Note:  all chunks
+        * must either fail or succeed.   The lower layer
+        * works that way today.  Keep it that way or this
+        * breaks.
+        */
+       err = sctp_primitive_SEND(asoc, datamsg);
+       /* Did the lower layer accept the chunk? */
+       if (err)
+               sctp_datamsg_free(datamsg);
+       else
+               sctp_datamsg_put(datamsg);
+
+       SCTP_DEBUG_PRINTK("We sent primitively.\n");
+
        if (err)
                goto out_free;
        else