tipc: refactor message delivery out of tipc_rcv

This is a cosmetic change, separating message delivery from the
link state processing.

Signed-off-by: Erik Hugne <erik.hugne@ericsson.com>
Reviewed-by: Ying Xue <ying.xue@windriver.com>
Reviewed-by: Jon Maloy <jon.maloy@ericsson.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/net/tipc/link.c b/net/tipc/link.c
index a081e7d..18b1524 100644 (file)
--- a/net/tipc/link.c
+++ b/net/tipc/link.c
@@ -88,6 +88,8 @@ static void link_print(struct tipc_link *l_ptr, const char *str);
 static int tipc_link_frag_xmit(struct tipc_link *l_ptr, struct sk_buff *buf);
 static void tipc_link_sync_xmit(struct tipc_link *l);
 static void tipc_link_sync_rcv(struct tipc_node *n, struct sk_buff *buf);
+static int tipc_link_input(struct tipc_link *l, struct sk_buff *buf);
+static int tipc_link_prepare_input(struct tipc_link *l, struct sk_buff **buf);
 
 /*
  *  Simple link routines
@@ -1458,54 +1460,14 @@ void tipc_rcv(struct sk_buff *head, struct tipc_bearer *b_ptr)
                if (unlikely(l_ptr->oldest_deferred_in))
                        head = link_insert_deferred_queue(l_ptr, head);
 
-               /* Deliver packet/message to correct user: */
-               if (unlikely(msg_user(msg) ==  CHANGEOVER_PROTOCOL)) {
-                       if (!tipc_link_tunnel_rcv(n_ptr, &buf)) {
-                               tipc_node_unlock(n_ptr);
-                               continue;
-                       }
-                       msg = buf_msg(buf);
-               } else if (msg_user(msg) == MSG_FRAGMENTER) {
-                       l_ptr->stats.recv_fragments++;
-                       if (tipc_buf_append(&l_ptr->reasm_buf, &buf)) {
-                               l_ptr->stats.recv_fragmented++;
-                               msg = buf_msg(buf);
-                       } else {
-                               if (!l_ptr->reasm_buf)
-                                       tipc_link_reset(l_ptr);
-                               tipc_node_unlock(n_ptr);
-                               continue;
-                       }
-               }
-
-               switch (msg_user(msg)) {
-               case TIPC_LOW_IMPORTANCE:
-               case TIPC_MEDIUM_IMPORTANCE:
-               case TIPC_HIGH_IMPORTANCE:
-               case TIPC_CRITICAL_IMPORTANCE:
-               case CONN_MANAGER:
-                       tipc_node_unlock(n_ptr);
-                       tipc_sk_rcv(buf);
-                       continue;
-               case MSG_BUNDLER:
-                       l_ptr->stats.recv_bundles++;
-                       l_ptr->stats.recv_bundled += msg_msgcnt(msg);
+               if (tipc_link_prepare_input(l_ptr, &buf)) {
                        tipc_node_unlock(n_ptr);
-                       tipc_link_bundle_rcv(buf);
                        continue;
-               case NAME_DISTRIBUTOR:
-                       n_ptr->bclink.recv_permitted = true;
-                       tipc_node_unlock(n_ptr);
-                       tipc_named_rcv(buf);
-                       continue;
-               case BCAST_PROTOCOL:
-                       tipc_link_sync_rcv(n_ptr, buf);
-                       break;
-               default:
-                       kfree_skb(buf);
-                       break;
                }
                tipc_node_unlock(n_ptr);
+               msg = buf_msg(buf);
+               if (tipc_link_input(l_ptr, buf) != 0)
+                       goto discard;
                continue;
 unlock_discard:
                tipc_node_unlock(n_ptr);
@@ -1515,6 +1477,80 @@ discard:
 }
 
 /**
+ * tipc_link_prepare_input - process TIPC link messages
+ *
+ * returns nonzero if the message was consumed
+ *
+ * Node lock must be held
+ */
+static int tipc_link_prepare_input(struct tipc_link *l, struct sk_buff **buf)
+{
+       struct tipc_node *n;
+       struct tipc_msg *msg;
+       int res = -EINVAL;
+
+       n = l->owner;
+       msg = buf_msg(*buf);
+       switch (msg_user(msg)) {
+       case CHANGEOVER_PROTOCOL:
+               if (tipc_link_tunnel_rcv(n, buf))
+                       res = 0;
+               break;
+       case MSG_FRAGMENTER:
+               l->stats.recv_fragments++;
+               if (tipc_buf_append(&l->reasm_buf, buf)) {
+                       l->stats.recv_fragmented++;
+                       res = 0;
+               } else if (!l->reasm_buf) {
+                       tipc_link_reset(l);
+               }
+               break;
+       case MSG_BUNDLER:
+               l->stats.recv_bundles++;
+               l->stats.recv_bundled += msg_msgcnt(msg);
+               res = 0;
+               break;
+       case NAME_DISTRIBUTOR:
+               n->bclink.recv_permitted = true;
+               res = 0;
+               break;
+       case BCAST_PROTOCOL:
+               tipc_link_sync_rcv(n, *buf);
+               break;
+       default:
+               res = 0;
+       }
+       return res;
+}
+/**
+ * tipc_link_input - Deliver message too higher layers
+ */
+static int tipc_link_input(struct tipc_link *l, struct sk_buff *buf)
+{
+       struct tipc_msg *msg = buf_msg(buf);
+       int res = 0;
+
+       switch (msg_user(msg)) {
+       case TIPC_LOW_IMPORTANCE:
+       case TIPC_MEDIUM_IMPORTANCE:
+       case TIPC_HIGH_IMPORTANCE:
+       case TIPC_CRITICAL_IMPORTANCE:
+       case CONN_MANAGER:
+               tipc_sk_rcv(buf);
+               break;
+       case NAME_DISTRIBUTOR:
+               tipc_named_rcv(buf);
+               break;
+       case MSG_BUNDLER:
+               tipc_link_bundle_rcv(buf);
+               break;
+       default:
+               res = -EINVAL;
+       }
+       return res;
+}
+
+/**
  * tipc_link_defer_pkt - Add out-of-sequence message to deferred reception queue
  *
  * Returns increase in queue length (i.e. 0 or 1)