1 files changed, 77 insertions, 306 deletions

diff --git a/net/tipc/link.c b/net/tipc/link.c
index b31992ccd5d3..18702f58d111 100644
--- a/net/tipc/link.c
+++ b/net/tipc/link.c
@@ -35,19 +35,11 @@
  */
 
 #include "core.h"
-#include "dbg.h"
 #include "link.h"
-#include "net.h"
-#include "node.h"
 #include "port.h"
-#include "addr.h"
-#include "node_subscr.h"
 #include "name_distr.h"
-#include "bearer.h"
-#include "name_table.h"
 #include "discover.h"
 #include "config.h"
-#include "bcast.h"
 
 
 /*
@@ -57,12 +49,6 @@
 #define INVALID_SESSION 0x10000
 
 /*
- * Limit for deferred reception queue:
- */
-
-#define DEF_QUEUE_LIMIT 256u
-
-/*
  * Link state events:
  */
 
@@ -110,75 +96,10 @@ static int  link_send_sections_long(struct port *sender,
 static void link_check_defragm_bufs(struct link *l_ptr);
 static void link_state_event(struct link *l_ptr, u32 event);
 static void link_reset_statistics(struct link *l_ptr);
-static void link_print(struct link *l_ptr, struct print_buf *buf,
-                       const char *str);
+static void link_print(struct link *l_ptr, const char *str);
 static void link_start(struct link *l_ptr);
 static int link_send_long_buf(struct link *l_ptr, struct sk_buff *buf);
 
-
-/*
- * Debugging code used by link routines only
- *
- * When debugging link problems on a system that has multiple links,
- * the standard TIPC debugging routines may not be useful since they
- * allow the output from multiple links to be intermixed.  For this reason
- * routines of the form "dbg_link_XXX()" have been created that will capture
- * debug info into a link's personal print buffer, which can then be dumped
- * into the TIPC system log (TIPC_LOG) upon request.
- *
- * To enable per-link debugging, use LINK_LOG_BUF_SIZE to specify the size
- * of the print buffer used by each link.  If LINK_LOG_BUF_SIZE is set to 0,
- * the dbg_link_XXX() routines simply send their output to the standard
- * debug print buffer (DBG_OUTPUT), if it has been defined; this can be useful
- * when there is only a single link in the system being debugged.
- *
- * Notes:
- * - When enabled, LINK_LOG_BUF_SIZE should be set to at least TIPC_PB_MIN_SIZE
- * - "l_ptr" must be valid when using dbg_link_XXX() macros
- */
-
-#define LINK_LOG_BUF_SIZE 0
-
-#define dbg_link(fmt, arg...) \
-        do { \
-                if (LINK_LOG_BUF_SIZE) \
-                        tipc_printf(&l_ptr->print_buf, fmt, ## arg); \
-        } while (0)
-#define dbg_link_msg(msg, txt) \
-        do { \
-                if (LINK_LOG_BUF_SIZE) \
-                        tipc_msg_dbg(&l_ptr->print_buf, msg, txt); \
-        } while (0)
-#define dbg_link_state(txt) \
-        do { \
-                if (LINK_LOG_BUF_SIZE) \
-                        link_print(l_ptr, &l_ptr->print_buf, txt); \
-        } while (0)
-#define dbg_link_dump() do { \
-        if (LINK_LOG_BUF_SIZE) { \
-                tipc_printf(LOG, "\n\nDumping link <%s>:\n", l_ptr->name); \
-                tipc_printbuf_move(LOG, &l_ptr->print_buf); \
-        } \
-} while (0)
-
-static void dbg_print_link(struct link *l_ptr, const char *str)
-{
-        if (DBG_OUTPUT != TIPC_NULL)
-                link_print(l_ptr, DBG_OUTPUT, str);
-}
-
-static void dbg_print_buf_chain(struct sk_buff *root_buf)
-{
-        if (DBG_OUTPUT != TIPC_NULL) {
-                struct sk_buff *buf = root_buf;
-
-                while (buf) {
-                        msg_dbg(buf_msg(buf), "In chain: ");
-                        buf = buf->next;
-                }
-        }
-}
-
 /*
  *  Simple link routines
  */
@@ -266,14 +187,17 @@ static int link_name_validate(const char *name, struct link_name *name_parts)
         /* ensure all component parts of link name are present */
 
         addr_local = name_copy;
-        if ((if_local = strchr(addr_local, ':')) == NULL)
+        if_local = strchr(addr_local, ':');
+        if (if_local == NULL)
                 return 0;
         *(if_local++) = 0;
-        if ((addr_peer = strchr(if_local, '-')) == NULL)
+        addr_peer = strchr(if_local, '-');
+        if (addr_peer == NULL)
                 return 0;
         *(addr_peer++) = 0;
         if_local_len = addr_peer - if_local;
-        if ((if_peer = strchr(addr_peer, ':')) == NULL)
+        if_peer = strchr(addr_peer, ':');
+        if (if_peer == NULL)
                 return 0;
         *(if_peer++) = 0;
         if_peer_len = strlen(if_peer) + 1;
@@ -392,17 +316,6 @@ struct link *tipc_link_create(struct bearer *b_ptr, const u32 peer,
                 return NULL;
         }
 
-        if (LINK_LOG_BUF_SIZE) {
-                char *pb = kmalloc(LINK_LOG_BUF_SIZE, GFP_ATOMIC);
-
-                if (!pb) {
-                        kfree(l_ptr);
-                        warn("Link creation failed, no memory for print buffer\n");
-                        return NULL;
-                }
-                tipc_printbuf_init(&l_ptr->print_buf, pb, LINK_LOG_BUF_SIZE);
-        }
-
         l_ptr->addr = peer;
         if_name = strchr(b_ptr->publ.name, ':') + 1;
         sprintf(l_ptr->name, "%u.%u.%u:%s-%u.%u.%u:",
@@ -437,8 +350,6 @@ struct link *tipc_link_create(struct bearer *b_ptr, const u32 peer,
 
         l_ptr->owner = tipc_node_attach_link(l_ptr);
         if (!l_ptr->owner) {
-                if (LINK_LOG_BUF_SIZE)
-                        kfree(l_ptr->print_buf.buf);
                 kfree(l_ptr);
                 return NULL;
         }
@@ -447,9 +358,6 @@ struct link *tipc_link_create(struct bearer *b_ptr, const u32 peer,
         list_add_tail(&l_ptr->link_list, &b_ptr->links);
         tipc_k_signal((Handler)link_start, (unsigned long)l_ptr);
 
-        dbg("tipc_link_create(): tolerance = %u,cont intv = %u, abort_limit = %u\n",
-            l_ptr->tolerance, l_ptr->continuity_interval, l_ptr->abort_limit);
-
         return l_ptr;
 }
 
@@ -469,8 +377,6 @@ void tipc_link_delete(struct link *l_ptr)
                 return;
         }
 
-        dbg("tipc_link_delete()\n");
-
         k_cancel_timer(&l_ptr->timer);
 
         tipc_node_lock(l_ptr->owner);
@@ -478,8 +384,6 @@ void tipc_link_delete(struct link *l_ptr)
         tipc_node_detach_link(l_ptr->owner, l_ptr);
         tipc_link_stop(l_ptr);
         list_del_init(&l_ptr->link_list);
-        if (LINK_LOG_BUF_SIZE)
-                kfree(l_ptr->print_buf.buf);
         tipc_node_unlock(l_ptr->owner);
         k_term_timer(&l_ptr->timer);
         kfree(l_ptr);
@@ -487,7 +391,6 @@ void tipc_link_delete(struct link *l_ptr)
 
 static void link_start(struct link *l_ptr)
 {
-        dbg("link_start %x\n", l_ptr);
         link_state_event(l_ptr, STARTING_EVT);
 }
 
@@ -639,7 +542,6 @@ void tipc_link_reset(struct link *l_ptr)
         link_init_max_pkt(l_ptr);
 
         l_ptr->state = RESET_UNKNOWN;
-        dbg_link_state("Resetting Link\n");
 
         if ((prev_state == RESET_UNKNOWN) || (prev_state == RESET_RESET))
                 return;
@@ -713,25 +615,18 @@ static void link_state_event(struct link *l_ptr, unsigned event)
                 return;         /* Not yet. */
 
         if (link_blocked(l_ptr)) {
-                if (event == TIMEOUT_EVT) {
+                if (event == TIMEOUT_EVT)
                         link_set_timer(l_ptr, cont_intv);
-                }
                 return;   /* Changeover going on */
         }
-        dbg_link("STATE_EV: <%s> ", l_ptr->name);
 
         switch (l_ptr->state) {
         case WORKING_WORKING:
-                dbg_link("WW/");
                 switch (event) {
                 case TRAFFIC_MSG_EVT:
-                        dbg_link("TRF-");
-                        /* fall through */
                 case ACTIVATE_MSG:
-                        dbg_link("ACT\n");
                         break;
                 case TIMEOUT_EVT:
-                        dbg_link("TIM ");
                         if (l_ptr->next_in_no != l_ptr->checkpoint) {
                                 l_ptr->checkpoint = l_ptr->next_in_no;
                                 if (tipc_bclink_acks_missing(l_ptr->owner)) {
@@ -746,7 +641,6 @@ static void link_state_event(struct link *l_ptr, unsigned event)
                                 link_set_timer(l_ptr, cont_intv);
                                 break;
                         }
-                        dbg_link(" -> WU\n");
                         l_ptr->state = WORKING_UNKNOWN;
                         l_ptr->fsm_msg_cnt = 0;
                         tipc_link_send_proto_msg(l_ptr, STATE_MSG, 1, 0, 0, 0, 0);
@@ -754,7 +648,6 @@ static void link_state_event(struct link *l_ptr, unsigned event)
                         link_set_timer(l_ptr, cont_intv / 4);
                         break;
                 case RESET_MSG:
-                        dbg_link("RES -> RR\n");
                         info("Resetting link <%s>, requested by peer\n",
                              l_ptr->name);
                         tipc_link_reset(l_ptr);
@@ -769,18 +662,14 @@ static void link_state_event(struct link *l_ptr, unsigned event)
                 }
                 break;
         case WORKING_UNKNOWN:
-                dbg_link("WU/");
                 switch (event) {
                 case TRAFFIC_MSG_EVT:
-                        dbg_link("TRF-");
                 case ACTIVATE_MSG:
-                        dbg_link("ACT -> WW\n");
                         l_ptr->state = WORKING_WORKING;
                         l_ptr->fsm_msg_cnt = 0;
                         link_set_timer(l_ptr, cont_intv);
                         break;
                 case RESET_MSG:
-                        dbg_link("RES -> RR\n");
                         info("Resetting link <%s>, requested by peer "
                              "while probing\n", l_ptr->name);
                         tipc_link_reset(l_ptr);
@@ -791,9 +680,7 @@ static void link_state_event(struct link *l_ptr, unsigned event)
                         link_set_timer(l_ptr, cont_intv);
                         break;
                 case TIMEOUT_EVT:
-                        dbg_link("TIM ");
                         if (l_ptr->next_in_no != l_ptr->checkpoint) {
-                                dbg_link("-> WW\n");
                                 l_ptr->state = WORKING_WORKING;
                                 l_ptr->fsm_msg_cnt = 0;
                                 l_ptr->checkpoint = l_ptr->next_in_no;
@@ -804,16 +691,11 @@ static void link_state_event(struct link *l_ptr, unsigned event)
                                 }
                                 link_set_timer(l_ptr, cont_intv);
                         } else if (l_ptr->fsm_msg_cnt < l_ptr->abort_limit) {
-                                dbg_link("Probing %u/%u,timer = %u ms)\n",
-                                         l_ptr->fsm_msg_cnt, l_ptr->abort_limit,
-                                         cont_intv / 4);
                                 tipc_link_send_proto_msg(l_ptr, STATE_MSG,
                                                          1, 0, 0, 0, 0);
                                 l_ptr->fsm_msg_cnt++;
                                 link_set_timer(l_ptr, cont_intv / 4);
                         } else {        /* Link has failed */
-                                dbg_link("-> RU (%u probes unanswered)\n",
-                                         l_ptr->fsm_msg_cnt);
                                 warn("Resetting link <%s>, peer not responding\n",
                                      l_ptr->name);
                                 tipc_link_reset(l_ptr);
@@ -830,18 +712,13 @@ static void link_state_event(struct link *l_ptr, unsigned event)
                 }
                 break;
         case RESET_UNKNOWN:
-                dbg_link("RU/");
                 switch (event) {
                 case TRAFFIC_MSG_EVT:
-                        dbg_link("TRF-\n");
                         break;
                 case ACTIVATE_MSG:
                         other = l_ptr->owner->active_links[0];
-                        if (other && link_working_unknown(other)) {
-                                dbg_link("ACT\n");
+                        if (other && link_working_unknown(other))
                                 break;
-                        }
-                        dbg_link("ACT -> WW\n");
                         l_ptr->state = WORKING_WORKING;
                         l_ptr->fsm_msg_cnt = 0;
                         link_activate(l_ptr);
@@ -850,8 +727,6 @@ static void link_state_event(struct link *l_ptr, unsigned event)
                         link_set_timer(l_ptr, cont_intv);
                         break;
                 case RESET_MSG:
-                        dbg_link("RES\n");
-                        dbg_link(" -> RR\n");
                         l_ptr->state = RESET_RESET;
                         l_ptr->fsm_msg_cnt = 0;
                         tipc_link_send_proto_msg(l_ptr, ACTIVATE_MSG, 1, 0, 0, 0, 0);
@@ -859,11 +734,9 @@ static void link_state_event(struct link *l_ptr, unsigned event)
                         link_set_timer(l_ptr, cont_intv);
                         break;
                 case STARTING_EVT:
-                        dbg_link("START-");
                         l_ptr->started = 1;
                         /* fall through */
                 case TIMEOUT_EVT:
-                        dbg_link("TIM\n");
                         tipc_link_send_proto_msg(l_ptr, RESET_MSG, 0, 0, 0, 0, 0);
                         l_ptr->fsm_msg_cnt++;
                         link_set_timer(l_ptr, cont_intv);
@@ -873,18 +746,12 @@ static void link_state_event(struct link *l_ptr, unsigned event)
                 }
                 break;
         case RESET_RESET:
-                dbg_link("RR/ ");
                 switch (event) {
                 case TRAFFIC_MSG_EVT:
-                        dbg_link("TRF-");
-                        /* fall through */
                 case ACTIVATE_MSG:
                         other = l_ptr->owner->active_links[0];
-                        if (other && link_working_unknown(other)) {
-                                dbg_link("ACT\n");
+                        if (other && link_working_unknown(other))
                                 break;
-                        }
-                        dbg_link("ACT -> WW\n");
                         l_ptr->state = WORKING_WORKING;
                         l_ptr->fsm_msg_cnt = 0;
                         link_activate(l_ptr);
@@ -893,14 +760,11 @@ static void link_state_event(struct link *l_ptr, unsigned event)
                         link_set_timer(l_ptr, cont_intv);
                         break;
                 case RESET_MSG:
-                        dbg_link("RES\n");
                         break;
                 case TIMEOUT_EVT:
-                        dbg_link("TIM\n");
                         tipc_link_send_proto_msg(l_ptr, ACTIVATE_MSG, 0, 0, 0, 0, 0);
                         l_ptr->fsm_msg_cnt++;
                         link_set_timer(l_ptr, cont_intv);
-                        dbg_link("fsm_msg_cnt %u\n", l_ptr->fsm_msg_cnt);
                         break;
                 default:
                         err("Unknown link event %u in RR state\n", event);
@@ -940,9 +804,6 @@ static int link_bundle_buf(struct link *l_ptr,
         skb_copy_to_linear_data_offset(bundler, to_pos, buf->data, size);
         msg_set_size(bundler_msg, to_pos + size);
         msg_set_msgcnt(bundler_msg, msg_msgcnt(bundler_msg) + 1);
-        dbg("Packed msg # %u(%u octets) into pos %u in buf(#%u)\n",
-            msg_msgcnt(bundler_msg), size, to_pos, msg_seqno(bundler_msg));
-        msg_dbg(msg, "PACKD:");
         buf_discard(buf);
         l_ptr->stats.sent_bundled++;
         return 1;
@@ -991,7 +852,6 @@ int tipc_link_send_buf(struct link *l_ptr, struct sk_buff *buf)
                         return link_schedule_port(l_ptr, msg_origport(msg),
                                                   size);
                 }
-                msg_dbg(msg, "TIPC: Congestion, throwing away\n");
                 buf_discard(buf);
                 if (imp > CONN_MANAGER) {
                         warn("Resetting link <%s>, send queue full", l_ptr->name);
@@ -1075,22 +935,16 @@ int tipc_link_send(struct sk_buff *buf, u32 dest, u32 selector)
         int res = -ELINKCONG;
 
         read_lock_bh(&tipc_net_lock);
-        n_ptr = tipc_node_select(dest, selector);
+        n_ptr = tipc_node_find(dest);
         if (n_ptr) {
                 tipc_node_lock(n_ptr);
                 l_ptr = n_ptr->active_links[selector & 1];
-                if (l_ptr) {
-                        dbg("tipc_link_send: found link %x for dest %x\n", l_ptr, dest);
+                if (l_ptr)
                         res = tipc_link_send_buf(l_ptr, buf);
-                } else {
-                        dbg("Attempt to send msg to unreachable node:\n");
-                        msg_dbg(buf_msg(buf),">>>");
+                else
                         buf_discard(buf);
-                }
                 tipc_node_unlock(n_ptr);
         } else {
-                dbg("Attempt to send msg to unknown node:\n");
-                msg_dbg(buf_msg(buf),">>>");
                 buf_discard(buf);
         }
         read_unlock_bh(&tipc_net_lock);
@@ -1117,17 +971,14 @@ static int link_send_buf_fast(struct link *l_ptr, struct sk_buff *buf,
                                 if (likely(tipc_bearer_send(l_ptr->b_ptr, buf,
                                                             &l_ptr->media_addr))) {
                                         l_ptr->unacked_window = 0;
-                                        msg_dbg(msg,"SENT_FAST:");
                                         return res;
                                 }
-                                dbg("failed sent fast...\n");
                                 tipc_bearer_schedule(l_ptr->b_ptr, l_ptr);
                                 l_ptr->stats.bearer_congs++;
                                 l_ptr->next_out = buf;
                                 return res;
                         }
-                }
-                else
+                } else
                         *used_max_pkt = l_ptr->max_pkt;
         }
         return tipc_link_send_buf(l_ptr, buf);  /* All other cases */
@@ -1151,12 +1002,10 @@ int tipc_send_buf_fast(struct sk_buff *buf, u32 destnode)
                 return tipc_port_recv_msg(buf);
 
         read_lock_bh(&tipc_net_lock);
-        n_ptr = tipc_node_select(destnode, selector);
+        n_ptr = tipc_node_find(destnode);
         if (likely(n_ptr)) {
                 tipc_node_lock(n_ptr);
                 l_ptr = n_ptr->active_links[selector];
-                dbg("send_fast: buf %x selected %x, destnode = %x\n",
-                    buf, l_ptr, destnode);
                 if (likely(l_ptr)) {
                         res = link_send_buf_fast(l_ptr, buf, &dummy);
                         tipc_node_unlock(n_ptr);
@@ -1200,7 +1049,7 @@ again:
                         !sender->user_port, &buf);
 
         read_lock_bh(&tipc_net_lock);
-        node = tipc_node_select(destaddr, selector);
+        node = tipc_node_find(destaddr);
         if (likely(node)) {
                 tipc_node_lock(node);
                 l_ptr = node->active_links[selector];
@@ -1283,10 +1132,10 @@ static int link_send_sections_long(struct port *sender,
         struct tipc_node *node;
         struct tipc_msg *hdr = &sender->publ.phdr;
         u32 dsz = msg_data_sz(hdr);
-        u32 max_pkt,fragm_sz,rest;
+        u32 max_pkt, fragm_sz, rest;
         struct tipc_msg fragm_hdr;
-        struct sk_buff *buf,*buf_chain,*prev;
-        u32 fragm_crs,fragm_rest,hsz,sect_rest;
+        struct sk_buff *buf, *buf_chain, *prev;
+        u32 fragm_crs, fragm_rest, hsz, sect_rest;
         const unchar *sect_crs;
         int curr_sect;
         u32 fragm_no;
@@ -1306,7 +1155,6 @@ again:
 
         /* Prepare reusable fragment header: */
 
-        msg_dbg(hdr, ">FRAGMENTING>");
         tipc_msg_init(&fragm_hdr, MSG_FRAGMENTER, FIRST_FRAGMENT,
                  INT_H_SIZE, msg_destnode(hdr));
         msg_set_link_selector(&fragm_hdr, sender->publ.ref);
@@ -1322,7 +1170,6 @@ again:
         skb_copy_to_linear_data(buf, &fragm_hdr, INT_H_SIZE);
         hsz = msg_hdr_sz(hdr);
         skb_copy_to_linear_data_offset(buf, INT_H_SIZE, hdr, hsz);
-        msg_dbg(buf_msg(buf), ">BUILD>");
 
         /* Chop up message: */
 
@@ -1365,7 +1212,7 @@ error:
                         /* Initiate new fragment: */
                         if (rest <= fragm_sz) {
                                 fragm_sz = rest;
-                                msg_set_type(&fragm_hdr,LAST_FRAGMENT);
+                                msg_set_type(&fragm_hdr, LAST_FRAGMENT);
                         } else {
                                 msg_set_type(&fragm_hdr, FRAGMENT);
                         }
@@ -1381,16 +1228,14 @@ error:
                         skb_copy_to_linear_data(buf, &fragm_hdr, INT_H_SIZE);
                         fragm_crs = INT_H_SIZE;
                         fragm_rest = fragm_sz;
-                        msg_dbg(buf_msg(buf),"  >BUILD>");
                 }
-        }
-        while (rest > 0);
+        } while (rest > 0);
 
         /*
          * Now we have a buffer chain. Select a link and check
          * that packet size is still OK
          */
-        node = tipc_node_select(destaddr, sender->publ.ref & 1);
+        node = tipc_node_find(destaddr);
         if (likely(node)) {
                 tipc_node_lock(node);
                 l_ptr = node->active_links[sender->publ.ref & 1];
@@ -1431,7 +1276,6 @@ reject:
                 l_ptr->stats.sent_fragments++;
                 msg_set_long_msgno(msg, l_ptr->long_msg_seq_no);
                 link_add_to_outqueue(l_ptr, buf, msg);
-                msg_dbg(msg, ">ADD>");
                 buf = next;
         }
 
@@ -1473,14 +1317,12 @@ u32 tipc_link_push_packet(struct link *l_ptr)
                 msg_set_ack(buf_msg(buf), mod(l_ptr->next_in_no - 1));
                 msg_set_bcast_ack(buf_msg(buf), l_ptr->owner->bclink.last_in);
                 if (tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr)) {
-                        msg_dbg(buf_msg(buf), ">DEF-RETR>");
                         l_ptr->retransm_queue_head = mod(++r_q_head);
                         l_ptr->retransm_queue_size = --r_q_size;
                         l_ptr->stats.retransmitted++;
                         return 0;
                 } else {
                         l_ptr->stats.bearer_congs++;
-                        msg_dbg(buf_msg(buf), "|>DEF-RETR>");
                         return PUSH_FAILED;
                 }
         }
@@ -1490,15 +1332,13 @@ u32 tipc_link_push_packet(struct link *l_ptr)
         buf = l_ptr->proto_msg_queue;
         if (buf) {
                 msg_set_ack(buf_msg(buf), mod(l_ptr->next_in_no - 1));
-                msg_set_bcast_ack(buf_msg(buf),l_ptr->owner->bclink.last_in);
+                msg_set_bcast_ack(buf_msg(buf), l_ptr->owner->bclink.last_in);
                 if (tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr)) {
-                        msg_dbg(buf_msg(buf), ">DEF-PROT>");
                         l_ptr->unacked_window = 0;
                         buf_discard(buf);
                         l_ptr->proto_msg_queue = NULL;
                         return 0;
                 } else {
-                        msg_dbg(buf_msg(buf), "|>DEF-PROT>");
                         l_ptr->stats.bearer_congs++;
                         return PUSH_FAILED;
                 }
@@ -1518,11 +1358,9 @@ u32 tipc_link_push_packet(struct link *l_ptr)
                         if (tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr)) {
                                 if (msg_user(msg) == MSG_BUNDLER)
                                         msg_set_type(msg, CLOSED_MSG);
-                                msg_dbg(msg, ">PUSH-DATA>");
                                 l_ptr->next_out = buf->next;
                                 return 0;
                         } else {
-                                msg_dbg(msg, "|PUSH-DATA|");
                                 l_ptr->stats.bearer_congs++;
                                 return PUSH_FAILED;
                         }
@@ -1570,8 +1408,7 @@ static void link_reset_all(unsigned long addr)
 
         for (i = 0; i < MAX_BEARERS; i++) {
                 if (n_ptr->links[i]) {
-                        link_print(n_ptr->links[i], TIPC_OUTPUT,
-                                   "Resetting link\n");
+                        link_print(n_ptr->links[i], "Resetting link\n");
                         tipc_link_reset(n_ptr->links[i]);
                 }
         }
@@ -1585,13 +1422,12 @@ static void link_retransmit_failure(struct link *l_ptr, struct sk_buff *buf)
         struct tipc_msg *msg = buf_msg(buf);
 
         warn("Retransmission failure on link <%s>\n", l_ptr->name);
-        tipc_msg_dbg(TIPC_OUTPUT, msg, ">RETR-FAIL>");
 
         if (l_ptr->addr) {
 
                 /* Handle failure on standard link */
 
-                link_print(l_ptr, TIPC_OUTPUT, "Resetting link\n");
+                link_print(l_ptr, "Resetting link\n");
                 tipc_link_reset(l_ptr);
 
         } else {
@@ -1601,21 +1437,21 @@ static void link_retransmit_failure(struct link *l_ptr, struct sk_buff *buf)
                 struct tipc_node *n_ptr;
                 char addr_string[16];
 
-                tipc_printf(TIPC_OUTPUT, "Msg seq number: %u,  ", msg_seqno(msg));
-                tipc_printf(TIPC_OUTPUT, "Outstanding acks: %lu\n",
-                                     (unsigned long) TIPC_SKB_CB(buf)->handle);
+                info("Msg seq number: %u,  ", msg_seqno(msg));
+                info("Outstanding acks: %lu\n",
+                     (unsigned long) TIPC_SKB_CB(buf)->handle);
 
                 n_ptr = l_ptr->owner->next;
                 tipc_node_lock(n_ptr);
 
                 tipc_addr_string_fill(addr_string, n_ptr->addr);
-                tipc_printf(TIPC_OUTPUT, "Multicast link info for %s\n", addr_string);
-                tipc_printf(TIPC_OUTPUT, "Supported: %d,  ", n_ptr->bclink.supported);
-                tipc_printf(TIPC_OUTPUT, "Acked: %u\n", n_ptr->bclink.acked);
-                tipc_printf(TIPC_OUTPUT, "Last in: %u,  ", n_ptr->bclink.last_in);
-                tipc_printf(TIPC_OUTPUT, "Gap after: %u,  ", n_ptr->bclink.gap_after);
-                tipc_printf(TIPC_OUTPUT, "Gap to: %u\n", n_ptr->bclink.gap_to);
-                tipc_printf(TIPC_OUTPUT, "Nack sync: %u\n\n", n_ptr->bclink.nack_sync);
+                info("Multicast link info for %s\n", addr_string);
+                info("Supported: %d,  ", n_ptr->bclink.supported);
+                info("Acked: %u\n", n_ptr->bclink.acked);
+                info("Last in: %u,  ", n_ptr->bclink.last_in);
+                info("Gap after: %u,  ", n_ptr->bclink.gap_after);
+                info("Gap to: %u\n", n_ptr->bclink.gap_to);
+                info("Nack sync: %u\n\n", n_ptr->bclink.nack_sync);
 
                 tipc_k_signal((Handler)link_reset_all, (unsigned long)n_ptr->addr);
 
@@ -1635,12 +1471,8 @@ void tipc_link_retransmit(struct link *l_ptr, struct sk_buff *buf,
 
         msg = buf_msg(buf);
 
-        dbg("Retransmitting %u in link %x\n", retransmits, l_ptr);
-
         if (tipc_bearer_congested(l_ptr->b_ptr, l_ptr)) {
                 if (l_ptr->retransm_queue_size == 0) {
-                        msg_dbg(msg, ">NO_RETR->BCONG>");
-                        dbg_print_link(l_ptr, "   ");
                         l_ptr->retransm_queue_head = msg_seqno(msg);
                         l_ptr->retransm_queue_size = retransmits;
                 } else {
@@ -1667,7 +1499,6 @@ void tipc_link_retransmit(struct link *l_ptr, struct sk_buff *buf,
                 msg_set_ack(msg, mod(l_ptr->next_in_no - 1));
                 msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in);
                 if (tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr)) {
-                        msg_dbg(buf_msg(buf), ">RETR>");
                         buf = buf->next;
                         retransmits--;
                         l_ptr->stats.retransmitted++;
@@ -1793,9 +1624,8 @@ void tipc_recv_msg(struct sk_buff *head, struct tipc_bearer *tb_ptr)
 
                 /* Ensure message data is a single contiguous unit */
 
-                if (unlikely(buf_linearize(buf))) {
+                if (unlikely(buf_linearize(buf)))
                         goto cont;
-                }
 
                 /* Handle arrival of a non-unicast link message */
 
@@ -1907,7 +1737,7 @@ deliver:
                                                 continue;
                                         case ROUTE_DISTRIBUTOR:
                                                 tipc_node_unlock(n_ptr);
-                                                tipc_cltr_recv_routing_table(buf);
+                                                buf_discard(buf);
                                                 continue;
                                         case NAME_DISTRIBUTOR:
                                                 tipc_node_unlock(n_ptr);
@@ -1953,12 +1783,10 @@ deliver:
                         tipc_node_unlock(n_ptr);
                         continue;
                 }
-                msg_dbg(msg,"NSEQ<REC<");
                 link_state_event(l_ptr, TRAFFIC_MSG_EVT);
 
                 if (link_working_working(l_ptr)) {
                         /* Re-insert in front of queue */
-                        msg_dbg(msg,"RECV-REINS:");
                         buf->next = head;
                         head = buf;
                         tipc_node_unlock(n_ptr);
@@ -2012,13 +1840,11 @@ u32 tipc_link_defer_pkt(struct sk_buff **head,
                                 *head = buf;
                         return 1;
                 }
-                if (seq_no == msg_seqno(msg)) {
+                if (seq_no == msg_seqno(msg))
                         break;
-                }
                 prev = crs;
                 crs = crs->next;
-        }
-        while (crs);
+        } while (crs);
 
         /* Message is a duplicate of an existing message */
 
@@ -2040,9 +1866,6 @@ static void link_handle_out_of_seq_msg(struct link *l_ptr,
                 return;
         }
 
-        dbg("rx OOS msg: seq_no %u, expecting %u (%u)\n",
-            seq_no, mod(l_ptr->next_in_no), l_ptr->next_in_no);
-
         /* Record OOS packet arrival (force mismatch on next timeout) */
 
         l_ptr->checkpoint--;
@@ -2132,11 +1955,10 @@ void tipc_link_send_proto_msg(struct link *l_ptr, u32 msg_typ, int probe_msg,
                 msg_set_max_pkt(msg, l_ptr->max_pkt_target);
         }
 
-        if (tipc_node_has_redundant_links(l_ptr->owner)) {
+        if (tipc_node_has_redundant_links(l_ptr->owner))
                 msg_set_redundant_link(msg);
-        } else {
+        else
                 msg_clear_redundant_link(msg);
-        }
         msg_set_linkprio(msg, l_ptr->priority);
 
         /* Ensure sequence number will not fit : */
@@ -2160,8 +1982,6 @@ void tipc_link_send_proto_msg(struct link *l_ptr, u32 msg_typ, int probe_msg,
 
         /* Message can be sent */
 
-        msg_dbg(msg, ">>");
-
         buf = tipc_buf_acquire(msg_size);
         if (!buf)
                 return;
@@ -2195,8 +2015,6 @@ static void link_recv_proto_msg(struct link *l_ptr, struct sk_buff *buf)
         u32 msg_tol;
         struct tipc_msg *msg = buf_msg(buf);
 
-        dbg("AT(%u):", jiffies_to_msecs(jiffies));
-        msg_dbg(msg, "<<");
         if (link_blocked(l_ptr))
                 goto exit;
 
@@ -2215,11 +2033,8 @@ static void link_recv_proto_msg(struct link *l_ptr, struct sk_buff *buf)
         case RESET_MSG:
                 if (!link_working_unknown(l_ptr) &&
                     (l_ptr->peer_session != INVALID_SESSION)) {
-                        if (msg_session(msg) == l_ptr->peer_session) {
-                                dbg("Duplicate RESET: %u<->%u\n",
-                                    msg_session(msg), l_ptr->peer_session);
+                        if (msg_session(msg) == l_ptr->peer_session)
                                 break; /* duplicate: ignore */
-                        }
                 }
                 /* fall thru' */
         case ACTIVATE_MSG:
@@ -2227,8 +2042,8 @@ static void link_recv_proto_msg(struct link *l_ptr, struct sk_buff *buf)
 
                 strcpy((strrchr(l_ptr->name, ':') + 1), (char *)msg_data(msg));
 
-                if ((msg_tol = msg_link_tolerance(msg)) &&
-                    (msg_tol > l_ptr->tolerance))
+                msg_tol = msg_link_tolerance(msg);
+                if (msg_tol > l_ptr->tolerance)
                         link_set_supervision_props(l_ptr, msg_tol);
 
                 if (msg_linkprio(msg) > l_ptr->priority)
@@ -2251,13 +2066,13 @@ static void link_recv_proto_msg(struct link *l_ptr, struct sk_buff *buf)
                 l_ptr->peer_bearer_id = msg_bearer_id(msg);
 
                 /* Synchronize broadcast sequence numbers */
-                if (!tipc_node_has_redundant_links(l_ptr->owner)) {
+                if (!tipc_node_has_redundant_links(l_ptr->owner))
                         l_ptr->owner->bclink.last_in = mod(msg_last_bcast(msg));
-                }
                 break;
         case STATE_MSG:
 
-                if ((msg_tol = msg_link_tolerance(msg)))
+                msg_tol = msg_link_tolerance(msg);
+                if (msg_tol)
                         link_set_supervision_props(l_ptr, msg_tol);
 
                 if (msg_linkprio(msg) &&
@@ -2280,8 +2095,6 @@ static void link_recv_proto_msg(struct link *l_ptr, struct sk_buff *buf)
 
                 max_pkt_ack = msg_max_pkt(msg);
                 if (max_pkt_ack > l_ptr->max_pkt) {
-                        dbg("Link <%s> updated MTU %u -> %u\n",
-                            l_ptr->name, l_ptr->max_pkt, max_pkt_ack);
                         l_ptr->max_pkt = max_pkt_ack;
                         l_ptr->max_pkt_probes = 0;
                 }
@@ -2289,9 +2102,8 @@ static void link_recv_proto_msg(struct link *l_ptr, struct sk_buff *buf)
                 max_pkt_ack = 0;
                 if (msg_probe(msg)) {
                         l_ptr->stats.recv_probes++;
-                        if (msg_size(msg) > sizeof(l_ptr->proto_msg)) {
+                        if (msg_size(msg) > sizeof(l_ptr->proto_msg))
                                 max_pkt_ack = msg_size(msg);
-                        }
                 }
 
                 /* Protocol message before retransmits, reduce loss risk */
@@ -2303,14 +2115,11 @@ static void link_recv_proto_msg(struct link *l_ptr, struct sk_buff *buf)
                                                  0, rec_gap, 0, 0, max_pkt_ack);
                 }
                 if (msg_seq_gap(msg)) {
-                        msg_dbg(msg, "With Gap:");
                         l_ptr->stats.recv_nacks++;
                         tipc_link_retransmit(l_ptr, l_ptr->first_out,
                                              msg_seq_gap(msg));
                 }
                 break;
-        default:
-                msg_dbg(buf_msg(buf), "<DISCARDING UNKNOWN<");
         }
 exit:
         buf_discard(buf);
@@ -2345,8 +2154,6 @@ static void tipc_link_tunnel(struct link *l_ptr,
         }
         skb_copy_to_linear_data(buf, tunnel_hdr, INT_H_SIZE);
         skb_copy_to_linear_data_offset(buf, INT_H_SIZE, msg, length);
-        dbg("%c->%c:", l_ptr->b_ptr->net_plane, tunnel->b_ptr->net_plane);
-        msg_dbg(buf_msg(buf), ">SEND>");
         tipc_link_send_buf(tunnel, buf);
 }
 
@@ -2378,7 +2185,6 @@ void tipc_link_changeover(struct link *l_ptr)
                  ORIGINAL_MSG, INT_H_SIZE, l_ptr->addr);
         msg_set_bearer_id(&tunnel_hdr, l_ptr->peer_bearer_id);
         msg_set_msgcnt(&tunnel_hdr, msgcount);
-        dbg("Link changeover requires %u tunnel messages\n", msgcount);
 
         if (!l_ptr->first_out) {
                 struct sk_buff *buf;
@@ -2387,9 +2193,6 @@ void tipc_link_changeover(struct link *l_ptr)
                 if (buf) {
                         skb_copy_to_linear_data(buf, &tunnel_hdr, INT_H_SIZE);
                         msg_set_size(&tunnel_hdr, INT_H_SIZE);
-                        dbg("%c->%c:", l_ptr->b_ptr->net_plane,
-                            tunnel->b_ptr->net_plane);
-                        msg_dbg(&tunnel_hdr, "EMPTY>SEND>");
                         tipc_link_send_buf(tunnel, buf);
                 } else {
                         warn("Link changeover error, "
@@ -2406,11 +2209,11 @@ void tipc_link_changeover(struct link *l_ptr)
 
                 if ((msg_user(msg) == MSG_BUNDLER) && split_bundles) {
                         struct tipc_msg *m = msg_get_wrapped(msg);
-                        unchar* pos = (unchar*)m;
+                        unchar *pos = (unchar *)m;
 
                         msgcount = msg_msgcnt(msg);
                         while (msgcount--) {
-                                msg_set_seqno(m,msg_seqno(msg));
+                                msg_set_seqno(m, msg_seqno(msg));
                                 tipc_link_tunnel(l_ptr, &tunnel_hdr, m,
                                                  msg_link_selector(m));
                                 pos += align(msg_size(m));
@@ -2453,9 +2256,6 @@ void tipc_link_send_duplicate(struct link *l_ptr, struct link *tunnel)
                 skb_copy_to_linear_data(outbuf, &tunnel_hdr, INT_H_SIZE);
                 skb_copy_to_linear_data_offset(outbuf, INT_H_SIZE, iter->data,
                                                length);
-                dbg("%c->%c:", l_ptr->b_ptr->net_plane,
-                    tunnel->b_ptr->net_plane);
-                msg_dbg(buf_msg(outbuf), ">SEND>");
                 tipc_link_send_buf(tunnel, outbuf);
                 if (!tipc_link_is_up(l_ptr))
                         return;
@@ -2502,31 +2302,24 @@ static int link_recv_changeover_msg(struct link **l_ptr,
         u32 msg_count = msg_msgcnt(tunnel_msg);
 
         dest_link = (*l_ptr)->owner->links[msg_bearer_id(tunnel_msg)];
-        if (!dest_link) {
-                msg_dbg(tunnel_msg, "NOLINK/<REC<");
+        if (!dest_link)
                 goto exit;
-        }
         if (dest_link == *l_ptr) {
                 err("Unexpected changeover message on link <%s>\n",
                     (*l_ptr)->name);
                 goto exit;
         }
-        dbg("%c<-%c:", dest_link->b_ptr->net_plane,
-            (*l_ptr)->b_ptr->net_plane);
         *l_ptr = dest_link;
         msg = msg_get_wrapped(tunnel_msg);
 
         if (msg_typ == DUPLICATE_MSG) {
-                if (less(msg_seqno(msg), mod(dest_link->next_in_no))) {
-                        msg_dbg(tunnel_msg, "DROP/<REC<");
+                if (less(msg_seqno(msg), mod(dest_link->next_in_no)))
                         goto exit;
-                }
-                *buf = buf_extract(tunnel_buf,INT_H_SIZE);
+                *buf = buf_extract(tunnel_buf, INT_H_SIZE);
                 if (*buf == NULL) {
                         warn("Link changeover error, duplicate msg dropped\n");
                         goto exit;
                 }
-                msg_dbg(tunnel_msg, "TNL<REC<");
                 buf_discard(tunnel_buf);
                 return 1;
         }
@@ -2534,18 +2327,14 @@ static int link_recv_changeover_msg(struct link **l_ptr,
         /* First original message ?: */
 
         if (tipc_link_is_up(dest_link)) {
-                msg_dbg(tunnel_msg, "UP/FIRST/<REC<");
                 info("Resetting link <%s>, changeover initiated by peer\n",
                      dest_link->name);
                 tipc_link_reset(dest_link);
                 dest_link->exp_msg_count = msg_count;
-                dbg("Expecting %u tunnelled messages\n", msg_count);
                 if (!msg_count)
                         goto exit;
         } else if (dest_link->exp_msg_count == START_CHANGEOVER) {
-                msg_dbg(tunnel_msg, "BLK/FIRST/<REC<");
                 dest_link->exp_msg_count = msg_count;
-                dbg("Expecting %u tunnelled messages\n", msg_count);
                 if (!msg_count)
                         goto exit;
         }
@@ -2555,18 +2344,14 @@ static int link_recv_changeover_msg(struct link **l_ptr,
         if (dest_link->exp_msg_count == 0) {
                 warn("Link switchover error, "
                      "got too many tunnelled messages\n");
-                msg_dbg(tunnel_msg, "OVERDUE/DROP/<REC<");
-                dbg_print_link(dest_link, "LINK:");
                 goto exit;
         }
         dest_link->exp_msg_count--;
         if (less(msg_seqno(msg), dest_link->reset_checkpoint)) {
-                msg_dbg(tunnel_msg, "DROP/DUPL/<REC<");
                 goto exit;
         } else {
                 *buf = buf_extract(tunnel_buf, INT_H_SIZE);
                 if (*buf != NULL) {
-                        msg_dbg(tunnel_msg, "TNL<REC<");
                         buf_discard(tunnel_buf);
                         return 1;
                 } else {
@@ -2588,7 +2373,6 @@ void tipc_link_recv_bundle(struct sk_buff *buf)
         u32 pos = INT_H_SIZE;
         struct sk_buff *obuf;
 
-        msg_dbg(buf_msg(buf), "<BNDL<: ");
         while (msgcount--) {
                 obuf = buf_extract(buf, pos);
                 if (obuf == NULL) {
@@ -2596,7 +2380,6 @@ void tipc_link_recv_bundle(struct sk_buff *buf)
                         break;
                 }
                 pos += align(msg_size(buf_msg(obuf)));
-                msg_dbg(buf_msg(obuf), "     /");
                 tipc_net_route_msg(obuf);
         }
         buf_discard(buf);
@@ -2733,7 +2516,6 @@ int tipc_link_recv_fragment(struct sk_buff **pending, struct sk_buff **fb,
         u32 long_msg_seq_no = msg_long_msgno(fragm);
 
         *fb = NULL;
-        msg_dbg(fragm,"FRG<REC<");
 
         /* Is there an incomplete message waiting for this fragment? */
 
@@ -2752,7 +2534,6 @@ int tipc_link_recv_fragment(struct sk_buff **pending, struct sk_buff **fb,
                 if (msg_type(imsg) == TIPC_MCAST_MSG)
                         max = TIPC_MAX_USER_MSG_SIZE + MCAST_H_SIZE;
                 if (msg_size(imsg) > max) {
-                        msg_dbg(fragm,"<REC<Oversized: ");
                         buf_discard(fbuf);
                         return 0;
                 }
@@ -2765,8 +2546,8 @@ int tipc_link_recv_fragment(struct sk_buff **pending, struct sk_buff **fb,
                         /*  Prepare buffer for subsequent fragments. */
 
                         set_long_msg_seqno(pbuf, long_msg_seq_no);
-                        set_fragm_size(pbuf,fragm_sz);
-                        set_expected_frags(pbuf,exp_fragm_cnt - 1);
+                        set_fragm_size(pbuf, fragm_sz);
+                        set_expected_frags(pbuf, exp_fragm_cnt - 1);
                 } else {
                         warn("Link unable to reassemble fragmented message\n");
                 }
@@ -2793,13 +2574,9 @@ int tipc_link_recv_fragment(struct sk_buff **pending, struct sk_buff **fb,
                         *m = buf_msg(pbuf);
                         return 1;
                 }
-                set_expected_frags(pbuf,exp_frags);
+                set_expected_frags(pbuf, exp_frags);
                 return 0;
         }
-        dbg(" Discarding orphan fragment %x\n",fbuf);
-        msg_dbg(fragm,"ORPHAN:");
-        dbg("Pending long buffers:\n");
-        dbg_print_buf_chain(*pending);
         buf_discard(fbuf);
         return 0;
 }
@@ -2827,11 +2604,6 @@ static void link_check_defragm_bufs(struct link *l_ptr)
                         incr_timer_cnt(buf);
                         prev = buf;
                 } else {
-                        dbg(" Discarding incomplete long buffer\n");
-                        msg_dbg(buf_msg(buf), "LONG:");
-                        dbg_print_link(l_ptr, "curr:");
-                        dbg("Pending long buffers:\n");
-                        dbg_print_buf_chain(l_ptr->defragm_buf);
                         if (prev)
                                 prev->next = buf->next;
                         else
@@ -2866,7 +2638,6 @@ void tipc_link_set_queue_limits(struct link *l_ptr, u32 window)
         l_ptr->queue_limit[TIPC_HIGH_IMPORTANCE + 4] = 900;
         l_ptr->queue_limit[TIPC_CRITICAL_IMPORTANCE + 4] = 1200;
         l_ptr->queue_limit[CONN_MANAGER] = 1200;
-        l_ptr->queue_limit[ROUTE_DISTRIBUTOR] = 1200;
         l_ptr->queue_limit[CHANGEOVER_PROTOCOL] = 2500;
         l_ptr->queue_limit[NAME_DISTRIBUTOR] = 3000;
         /* FRAGMENT and LAST_FRAGMENT packets */
@@ -3168,7 +2939,7 @@ u32 tipc_link_get_max_pkt(u32 dest, u32 selector)
                 return MAX_MSG_SIZE;
 
         read_lock_bh(&tipc_net_lock);
-        n_ptr = tipc_node_select(dest, selector);
+        n_ptr = tipc_node_find(dest);
         if (n_ptr) {
                 tipc_node_lock(n_ptr);
                 l_ptr = n_ptr->active_links[selector & 1];
@@ -3180,27 +2951,22 @@ u32 tipc_link_get_max_pkt(u32 dest, u32 selector)
         return res;
 }
 
-static void link_dump_send_queue(struct link *l_ptr)
+static void link_print(struct link *l_ptr, const char *str)
 {
-        if (l_ptr->next_out) {
-                info("\nContents of unsent queue:\n");
-                dbg_print_buf_chain(l_ptr->next_out);
-        }
-        info("\nContents of send queue:\n");
-        if (l_ptr->first_out) {
-                dbg_print_buf_chain(l_ptr->first_out);
-        }
-        info("Empty send queue\n");
-}
+        char print_area[256];
+        struct print_buf pb;
+        struct print_buf *buf = &pb;
+
+        tipc_printbuf_init(buf, print_area, sizeof(print_area));
 
-static void link_print(struct link *l_ptr, struct print_buf *buf,
-                       const char *str)
-{
         tipc_printf(buf, str);
-        if (link_reset_reset(l_ptr) || link_reset_unknown(l_ptr))
-                return;
         tipc_printf(buf, "Link %x<%s>:",
                     l_ptr->addr, l_ptr->b_ptr->publ.name);
+
+#ifdef CONFIG_TIPC_DEBUG
+        if (link_reset_reset(l_ptr) || link_reset_unknown(l_ptr))
+                goto print_state;
+
         tipc_printf(buf, ": NXO(%u):", mod(l_ptr->next_out_no));
         tipc_printf(buf, "NXI(%u):", mod(l_ptr->next_in_no));
         tipc_printf(buf, "SQUE");
@@ -3218,7 +2984,6 @@ static void link_print(struct link *l_ptr, struct print_buf *buf,
                         tipc_printf(buf, "first_out= %x ", l_ptr->first_out);
                         tipc_printf(buf, "next_out= %x ", l_ptr->next_out);
                         tipc_printf(buf, "last_out= %x ", l_ptr->last_out);
-                        link_dump_send_queue(l_ptr);
                 }
         } else
                 tipc_printf(buf, "[]");
@@ -3232,14 +2997,20 @@ static void link_print(struct link *l_ptr, struct print_buf *buf,
                                     l_ptr->deferred_inqueue_sz);
                 }
         }
+print_state:
+#endif
+
         if (link_working_unknown(l_ptr))
                 tipc_printf(buf, ":WU");
-        if (link_reset_reset(l_ptr))
+        else if (link_reset_reset(l_ptr))
                 tipc_printf(buf, ":RR");
-        if (link_reset_unknown(l_ptr))
+        else if (link_reset_unknown(l_ptr))
                 tipc_printf(buf, ":RU");
-        if (link_working_working(l_ptr))
+        else if (link_working_working(l_ptr))
                 tipc_printf(buf, ":WW");
         tipc_printf(buf, "\n");
+
+        tipc_printbuf_validate(buf);
+        info("%s", print_area);
 }