tipc: fall back to smaller MTU if allocation of local send skb fails

When sending node local messages the code is using an 'mtu' of 66060
bytes to avoid unnecessary fragmentation. During situations of low
memory tipc_msg_build() may sometimes fail to allocate such large
buffers, resulting in unnecessary send failures. This can easily be
remedied by falling back to a smaller MTU, and then reassemble the
buffer chain as if the message were arriving from a remote node.

At the same time, we change the initial MTU setting of the broadcast
link to a lower value, so that large messages always are fragmented
into smaller buffers even when we run in single node mode. Apart from
obtaining the same advantage as for the 'fallback' solution above, this
turns out to give a significant performance improvement. This can
probably be explained with the __pskb_copy() operation performed on the
buffer for each recipient during reception. We found the optimal value
for this, considering the most relevant skb pool, to be 3744 bytes.

Acked-by: Ying Xue <ying.xue@ericsson.com>
Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

1 files changed, 44 insertions, 7 deletions

diff --git a/net/tipc/msg.c b/net/tipc/msg.c
index b0d07b35909d..55d8ba92291d 100644
--- a/net/tipc/msg.c
+++ b/net/tipc/msg.c
@@ -251,20 +251,23 @@ bool tipc_msg_validate(struct sk_buff **_skb)
  * @pktmax: Max packet size that can be used
  * @list: Buffer or chain of buffers to be returned to caller
  *
+ * Note that the recursive call we are making here is safe, since it can
+ * logically go only one further level down.
+ *
  * Returns message data size or errno: -ENOMEM, -EFAULT
  */
-int tipc_msg_build(struct tipc_msg *mhdr, struct msghdr *m,
-                   int offset, int dsz, int pktmax, struct sk_buff_head *list)
+int tipc_msg_build(struct tipc_msg *mhdr, struct msghdr *m, int offset,
+                   int dsz, int pktmax, struct sk_buff_head *list)
 {
         int mhsz = msg_hdr_sz(mhdr);
+        struct tipc_msg pkthdr;
         int msz = mhsz + dsz;
-        int pktno = 1;
-        int pktsz;
         int pktrem = pktmax;
-        int drem = dsz;
-        struct tipc_msg pkthdr;
         struct sk_buff *skb;
+        int drem = dsz;
+        int pktno = 1;
         char *pktpos;
+        int pktsz;
         int rc;
 
         msg_set_size(mhdr, msz);
@@ -272,8 +275,18 @@ int tipc_msg_build(struct tipc_msg *mhdr, struct msghdr *m,
         /* No fragmentation needed? */
         if (likely(msz <= pktmax)) {
                 skb = tipc_buf_acquire(msz, GFP_KERNEL);
-                if (unlikely(!skb))
+
+                /* Fall back to smaller MTU if node local message */
+                if (unlikely(!skb)) {
+                        if (pktmax != MAX_MSG_SIZE)
+                                return -ENOMEM;
+                        rc = tipc_msg_build(mhdr, m, offset, dsz, FB_MTU, list);
+                        if (rc != dsz)
+                                return rc;
+                        if (tipc_msg_assemble(list))
+                                return dsz;
                         return -ENOMEM;
+                }
                 skb_orphan(skb);
                 __skb_queue_tail(list, skb);
                 skb_copy_to_linear_data(skb, mhdr, mhsz);
@@ -589,6 +602,30 @@ bool tipc_msg_lookup_dest(struct net *net, struct sk_buff *skb, int *err)
         return true;
 }
 
+/* tipc_msg_assemble() - assemble chain of fragments into one message
+ */
+bool tipc_msg_assemble(struct sk_buff_head *list)
+{
+        struct sk_buff *skb, *tmp = NULL;
+
+        if (skb_queue_len(list) == 1)
+                return true;
+
+        while ((skb = __skb_dequeue(list))) {
+                skb->next = NULL;
+                if (tipc_buf_append(&tmp, &skb)) {
+                        __skb_queue_tail(list, skb);
+                        return true;
+                }
+                if (!tmp)
+                        break;
+        }
+        __skb_queue_purge(list);
+        __skb_queue_head_init(list);
+        pr_warn("Failed do assemble buffer\n");
+        return false;
+}
+
 /* tipc_msg_reassemble() - clone a buffer chain of fragments and
  *                         reassemble the clones into one message
  */