tipc: changes to general packet reception algorithm
authorJon Paul Maloy <jon.maloy@ericsson.com>
Thu, 13 Feb 2014 22:29:15 +0000 (17:29 -0500)
committerDavid S. Miller <davem@davemloft.net>
Thu, 13 Feb 2014 22:57:06 +0000 (17:57 -0500)
We change the order of checking for destination users when processing
incoming packets. By placing the checks for users that may potentially
replace the processed buffer, i.e., CHANGEOVER_PROTOCOL and
MSG_FRAGMENTER, in a separate step before we check for the true end
users, we get rid of a label and a 'goto', at the same time making the
code more comprehensible and easy to follow.

This commit does not change any functionality, it is just a cosmetic
code reshuffle.

Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Reviewed-by: Ying Xue <ying.xue@windriver.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
net/tipc/link.c

index b678c2e0080a26b63658fb0a06e6cc1a84cb1bb2..663623c5896df20098f9efe3f981a1d7338dc155 100644 (file)
@@ -1484,7 +1484,7 @@ void tipc_rcv(struct sk_buff *head, struct tipc_bearer *b_ptr)
                if ((n_ptr->block_setup & WAIT_PEER_DOWN) &&
                        msg_user(msg) == LINK_PROTOCOL &&
                        (msg_type(msg) == RESET_MSG ||
-                                       msg_type(msg) == ACTIVATE_MSG) &&
+                        msg_type(msg) == ACTIVATE_MSG) &&
                        !msg_redundant_link(msg))
                        n_ptr->block_setup &= ~WAIT_PEER_DOWN;
 
@@ -1503,7 +1503,6 @@ void tipc_rcv(struct sk_buff *head, struct tipc_bearer *b_ptr)
                while ((crs != l_ptr->next_out) &&
                       less_eq(buf_seqno(crs), ackd)) {
                        struct sk_buff *next = crs->next;
-
                        kfree_skb(crs);
                        crs = next;
                        released++;
@@ -1516,14 +1515,17 @@ void tipc_rcv(struct sk_buff *head, struct tipc_bearer *b_ptr)
                /* Try sending any messages link endpoint has pending */
                if (unlikely(l_ptr->next_out))
                        tipc_link_push_queue(l_ptr);
+
                if (unlikely(!list_empty(&l_ptr->waiting_ports)))
                        tipc_link_wakeup_ports(l_ptr, 0);
+
                if (unlikely(++l_ptr->unacked_window >= TIPC_MIN_LINK_WIN)) {
                        l_ptr->stats.sent_acks++;
-                       tipc_link_send_proto_msg(l_ptr, STATE_MSG, 0, 0, 0, 0, 0);
+                       tipc_link_send_proto_msg(l_ptr, STATE_MSG,
+                                                0, 0, 0, 0, 0);
                }
 
-               /* Now (finally!) process the incoming message */
+               /* Process the incoming packet */
                if (unlikely(!link_working_working(l_ptr))) {
                        if (msg_user(msg) == LINK_PROTOCOL) {
                                link_recv_proto_msg(l_ptr, buf);
@@ -1555,14 +1557,40 @@ void tipc_rcv(struct sk_buff *head, struct tipc_bearer *b_ptr)
                l_ptr->next_in_no++;
                if (unlikely(l_ptr->oldest_deferred_in))
                        head = link_insert_deferred_queue(l_ptr, head);
-deliver:
-               if (likely(msg_isdata(msg))) {
+
+               /* 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) {
+                       int rc;
+
+                       l_ptr->stats.recv_fragments++;
+                       rc = tipc_link_frag_rcv(&l_ptr->reasm_head,
+                                               &l_ptr->reasm_tail,
+                                               &buf);
+                       if (rc == LINK_REASM_COMPLETE) {
+                               l_ptr->stats.recv_fragmented++;
+                               msg = buf_msg(buf);
+                       } else {
+                               if (rc == LINK_REASM_ERROR)
+                                       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:
                        tipc_node_unlock(n_ptr);
                        tipc_port_recv_msg(buf);
                        continue;
-               }
-               switch (msg_user(msg)) {
-                       int ret;
                case MSG_BUNDLER:
                        l_ptr->stats.recv_bundles++;
                        l_ptr->stats.recv_bundled += msg_msgcnt(msg);
@@ -1574,44 +1602,20 @@ deliver:
                        tipc_node_unlock(n_ptr);
                        tipc_named_recv(buf);
                        continue;
-               case BCAST_PROTOCOL:
-                       tipc_link_recv_sync(n_ptr, buf);
-                       tipc_node_unlock(n_ptr);
-                       continue;
                case CONN_MANAGER:
                        tipc_node_unlock(n_ptr);
                        tipc_port_recv_proto_msg(buf);
                        continue;
-               case MSG_FRAGMENTER:
-                       l_ptr->stats.recv_fragments++;
-                       ret = tipc_link_frag_rcv(&l_ptr->reasm_head,
-                                                &l_ptr->reasm_tail,
-                                                &buf);
-                       if (ret == LINK_REASM_COMPLETE) {
-                               l_ptr->stats.recv_fragmented++;
-                               msg = buf_msg(buf);
-                               goto deliver;
-                       }
-                       if (ret == LINK_REASM_ERROR)
-                               tipc_link_reset(l_ptr);
-                       tipc_node_unlock(n_ptr);
-                       continue;
-               case CHANGEOVER_PROTOCOL:
-                       if (!tipc_link_tunnel_rcv(n_ptr, &buf))
-                               break;
-                       msg = buf_msg(buf);
-                       seq_no = msg_seqno(msg);
-                       goto deliver;
+               case BCAST_PROTOCOL:
+                       tipc_link_recv_sync(n_ptr, buf);
+                       break;
                default:
                        kfree_skb(buf);
-                       buf = NULL;
                        break;
                }
                tipc_node_unlock(n_ptr);
-               tipc_net_route_msg(buf);
                continue;
 unlock_discard:
-
                tipc_node_unlock(n_ptr);
 discard:
                kfree_skb(buf);