Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 247f0f3c authored by Ying Xue's avatar Ying Xue Committed by David S. Miller
Browse files

tipc: align tipc function names with common naming practice in the network 



Rename the following functions, which are shorter and more in line
with common naming practice in the network subsystem.

tipc_bclink_send_msg->tipc_bclink_xmit
tipc_bclink_recv_pkt->tipc_bclink_rcv
tipc_disc_recv_msg->tipc_disc_rcv
tipc_link_send_proto_msg->tipc_link_proto_xmit
link_recv_proto_msg->tipc_link_proto_rcv
link_send_sections_long->tipc_link_iovec_long_xmit
tipc_link_send_sections_fast->tipc_link_iovec_xmit_fast
tipc_link_send_sync->tipc_link_sync_xmit
tipc_link_recv_sync->tipc_link_sync_rcv
tipc_link_send_buf->__tipc_link_xmit
tipc_link_send->tipc_link_xmit
tipc_link_send_names->tipc_link_names_xmit
tipc_named_recv->tipc_named_rcv
tipc_link_recv_bundle->tipc_link_bundle_rcv
tipc_link_dup_send_queue->tipc_link_dup_queue_xmit
link_send_long_buf->tipc_link_frag_xmit

tipc_multicast->tipc_port_mcast_xmit
tipc_port_recv_mcast->tipc_port_mcast_rcv
tipc_port_reject_sections->tipc_port_iovec_reject
tipc_port_recv_proto_msg->tipc_port_proto_rcv
tipc_connect->tipc_port_connect
__tipc_connect->__tipc_port_connect
__tipc_disconnect->__tipc_port_disconnect
tipc_disconnect->tipc_port_disconnect
tipc_shutdown->tipc_port_shutdown
tipc_port_recv_msg->tipc_port_rcv
tipc_port_recv_sections->tipc_port_iovec_rcv

release->tipc_release
accept->tipc_accept
bind->tipc_bind
get_name->tipc_getname
poll->tipc_poll
send_msg->tipc_sendmsg
send_packet->tipc_send_packet
send_stream->tipc_send_stream
recv_msg->tipc_recvmsg
recv_stream->tipc_recv_stream
connect->tipc_connect
listen->tipc_listen
shutdown->tipc_shutdown
setsockopt->tipc_setsockopt
getsockopt->tipc_getsockopt

Above changes have no impact on current users of the functions.

Signed-off-by: default avatarYing Xue <ying.xue@windriver.com>
Reviewed-by: default avatarJon Maloy <jon.maloy@ericsson.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent b356e978

net/tipc/bcast.c

+10 −11
Original line number Diff line number Diff line
@@ -356,9 +356,9 @@ static void bclink_peek_nack(struct tipc_msg *msg) 
}



/*

 * tipc_bclink_send_msg - broadcast a packet to all nodes in cluster

 * tipc_bclink_xmit - broadcast a packet to all nodes in cluster

 */

int tipc_bclink_send_msg(struct sk_buff *buf)

int tipc_bclink_xmit(struct sk_buff *buf)

{

	int res;
@@ -370,7 +370,7 @@ int tipc_bclink_send_msg(struct sk_buff *buf) 
		goto exit;

	}



	res = tipc_link_send_buf(bcl, buf);

	res = __tipc_link_xmit(bcl, buf);

	if (likely(res >= 0)) {

		bclink_set_last_sent();

		bcl->stats.queue_sz_counts++;
@@ -399,19 +399,18 @@ static void bclink_accept_pkt(struct tipc_node *node, u32 seqno) 
	 */



	if (((seqno - tipc_own_addr) % TIPC_MIN_LINK_WIN) == 0) {

		tipc_link_send_proto_msg(

			node->active_links[node->addr & 1],

		tipc_link_proto_xmit(node->active_links[node->addr & 1],

				     STATE_MSG, 0, 0, 0, 0, 0);

		bcl->stats.sent_acks++;

	}

}



/**

 * tipc_bclink_recv_pkt - receive a broadcast packet, and deliver upwards

 * tipc_bclink_rcv - receive a broadcast packet, and deliver upwards

 *

 * tipc_net_lock is read_locked, no other locks set

 */

void tipc_bclink_recv_pkt(struct sk_buff *buf)

void tipc_bclink_rcv(struct sk_buff *buf)

{

	struct tipc_msg *msg = buf_msg(buf);

	struct tipc_node *node;
@@ -468,7 +467,7 @@ void tipc_bclink_recv_pkt(struct sk_buff *buf) 
			spin_unlock_bh(&bc_lock);

			tipc_node_unlock(node);

			if (likely(msg_mcast(msg)))

				tipc_port_recv_mcast(buf, NULL);

				tipc_port_mcast_rcv(buf, NULL);

			else

				kfree_skb(buf);

		} else if (msg_user(msg) == MSG_BUNDLER) {
@@ -478,7 +477,7 @@ void tipc_bclink_recv_pkt(struct sk_buff *buf) 
			bcl->stats.recv_bundled += msg_msgcnt(msg);

			spin_unlock_bh(&bc_lock);

			tipc_node_unlock(node);

			tipc_link_recv_bundle(buf);

			tipc_link_bundle_rcv(buf);

		} else if (msg_user(msg) == MSG_FRAGMENTER) {

			int ret;

			ret = tipc_link_frag_rcv(&node->bclink.reasm_head,
@@ -503,7 +502,7 @@ void tipc_bclink_recv_pkt(struct sk_buff *buf) 
			bclink_accept_pkt(node, seqno);

			spin_unlock_bh(&bc_lock);

			tipc_node_unlock(node);

			tipc_named_recv(buf);

			tipc_named_rcv(buf);

		} else {

			spin_lock_bh(&bc_lock);

			bclink_accept_pkt(node, seqno);

net/tipc/bcast.h

+2 −2
Original line number Diff line number Diff line
@@ -90,8 +90,8 @@ void tipc_bclink_add_node(u32 addr); 
void tipc_bclink_remove_node(u32 addr);

struct tipc_node *tipc_bclink_retransmit_to(void);

void tipc_bclink_acknowledge(struct tipc_node *n_ptr, u32 acked);

int  tipc_bclink_send_msg(struct sk_buff *buf);

void tipc_bclink_recv_pkt(struct sk_buff *buf);

int  tipc_bclink_xmit(struct sk_buff *buf);

void tipc_bclink_rcv(struct sk_buff *buf);

u32  tipc_bclink_get_last_sent(void);

u32  tipc_bclink_acks_missing(struct tipc_node *n_ptr);

void tipc_bclink_update_link_state(struct tipc_node *n_ptr, u32 last_sent);

net/tipc/discover.c

+2 −2
Original line number Diff line number Diff line
@@ -110,11 +110,11 @@ static void disc_dupl_alert(struct tipc_bearer *b_ptr, u32 node_addr, 
}



/**

 * tipc_disc_recv_msg - handle incoming link setup message (request or response)

 * tipc_disc_rcv - handle incoming link setup message (request or response)

 * @buf: buffer containing message

 * @b_ptr: bearer that message arrived on

 */

void tipc_disc_recv_msg(struct sk_buff *buf, struct tipc_bearer *b_ptr)

void tipc_disc_rcv(struct sk_buff *buf, struct tipc_bearer *b_ptr)

{

	struct tipc_node *n_ptr;

	struct tipc_link *link;

net/tipc/discover.h

+1 −1
Original line number Diff line number Diff line
@@ -44,6 +44,6 @@ int tipc_disc_create(struct tipc_bearer *b_ptr, struct tipc_media_addr *dest, 
void tipc_disc_delete(struct tipc_link_req *req);

void tipc_disc_add_dest(struct tipc_link_req *req);

void tipc_disc_remove_dest(struct tipc_link_req *req);

void tipc_disc_recv_msg(struct sk_buff *buf, struct tipc_bearer *b_ptr);

void tipc_disc_rcv(struct sk_buff *buf, struct tipc_bearer *b_ptr);



#endif

net/tipc/link.c

+93 −91
Original line number Diff line number Diff line
@@ -77,19 +77,19 @@ static const char *link_unk_evt = "Unknown link event "; 


static void link_handle_out_of_seq_msg(struct tipc_link *l_ptr,

				       struct sk_buff *buf);

static void link_recv_proto_msg(struct tipc_link *l_ptr, struct sk_buff *buf);

static void tipc_link_proto_rcv(struct tipc_link *l_ptr, struct sk_buff *buf);

static int  tipc_link_tunnel_rcv(struct tipc_node *n_ptr,

				 struct sk_buff **buf);

static void link_set_supervision_props(struct tipc_link *l_ptr, u32 tolerance);

static int  link_send_sections_long(struct tipc_port *sender,

static int  tipc_link_iovec_long_xmit(struct tipc_port *sender,

				      struct iovec const *msg_sect,

				      unsigned int len, u32 destnode);

static void link_state_event(struct tipc_link *l_ptr, u32 event);

static void link_reset_statistics(struct tipc_link *l_ptr);

static void link_print(struct tipc_link *l_ptr, const char *str);

static int link_send_long_buf(struct tipc_link *l_ptr, struct sk_buff *buf);

static void tipc_link_send_sync(struct tipc_link *l);

static void tipc_link_recv_sync(struct tipc_node *n, struct sk_buff *buf);

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);



/*

 *  Simple link routines
@@ -512,11 +512,11 @@ static void link_state_event(struct tipc_link *l_ptr, unsigned int event) 
			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)) {

					tipc_link_send_proto_msg(l_ptr, STATE_MSG,

					tipc_link_proto_xmit(l_ptr, STATE_MSG,

							     0, 0, 0, 0, 0);

					l_ptr->fsm_msg_cnt++;

				} else if (l_ptr->max_pkt < l_ptr->max_pkt_target) {

					tipc_link_send_proto_msg(l_ptr, STATE_MSG,

					tipc_link_proto_xmit(l_ptr, STATE_MSG,

							     1, 0, 0, 0, 0);

					l_ptr->fsm_msg_cnt++;

				}
@@ -525,7 +525,7 @@ static void link_state_event(struct tipc_link *l_ptr, unsigned int event) 
			}

			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);

			tipc_link_proto_xmit(l_ptr, STATE_MSG, 1, 0, 0, 0, 0);

			l_ptr->fsm_msg_cnt++;

			link_set_timer(l_ptr, cont_intv / 4);

			break;
@@ -535,7 +535,8 @@ static void link_state_event(struct tipc_link *l_ptr, unsigned int event) 
			tipc_link_reset(l_ptr);

			l_ptr->state = RESET_RESET;

			l_ptr->fsm_msg_cnt = 0;

			tipc_link_send_proto_msg(l_ptr, ACTIVATE_MSG, 0, 0, 0, 0, 0);

			tipc_link_proto_xmit(l_ptr, ACTIVATE_MSG,

					     0, 0, 0, 0, 0);

			l_ptr->fsm_msg_cnt++;

			link_set_timer(l_ptr, cont_intv);

			break;
@@ -557,7 +558,8 @@ static void link_state_event(struct tipc_link *l_ptr, unsigned int event) 
			tipc_link_reset(l_ptr);

			l_ptr->state = RESET_RESET;

			l_ptr->fsm_msg_cnt = 0;

			tipc_link_send_proto_msg(l_ptr, ACTIVATE_MSG, 0, 0, 0, 0, 0);

			tipc_link_proto_xmit(l_ptr, ACTIVATE_MSG,

					     0, 0, 0, 0, 0);

			l_ptr->fsm_msg_cnt++;

			link_set_timer(l_ptr, cont_intv);

			break;
@@ -567,13 +569,13 @@ static void link_state_event(struct tipc_link *l_ptr, unsigned int event) 
				l_ptr->fsm_msg_cnt = 0;

				l_ptr->checkpoint = l_ptr->next_in_no;

				if (tipc_bclink_acks_missing(l_ptr->owner)) {

					tipc_link_send_proto_msg(l_ptr, STATE_MSG,

					tipc_link_proto_xmit(l_ptr, STATE_MSG,

							     0, 0, 0, 0, 0);

					l_ptr->fsm_msg_cnt++;

				}

				link_set_timer(l_ptr, cont_intv);

			} else if (l_ptr->fsm_msg_cnt < l_ptr->abort_limit) {

				tipc_link_send_proto_msg(l_ptr, STATE_MSG,

				tipc_link_proto_xmit(l_ptr, STATE_MSG,

						     1, 0, 0, 0, 0);

				l_ptr->fsm_msg_cnt++;

				link_set_timer(l_ptr, cont_intv / 4);
@@ -583,7 +585,7 @@ static void link_state_event(struct tipc_link *l_ptr, unsigned int event) 
				tipc_link_reset(l_ptr);

				l_ptr->state = RESET_UNKNOWN;

				l_ptr->fsm_msg_cnt = 0;

				tipc_link_send_proto_msg(l_ptr, RESET_MSG,

				tipc_link_proto_xmit(l_ptr, RESET_MSG,

						     0, 0, 0, 0, 0);

				l_ptr->fsm_msg_cnt++;

				link_set_timer(l_ptr, cont_intv);
@@ -604,16 +606,17 @@ static void link_state_event(struct tipc_link *l_ptr, unsigned int event) 
			l_ptr->state = WORKING_WORKING;

			l_ptr->fsm_msg_cnt = 0;

			link_activate(l_ptr);

			tipc_link_send_proto_msg(l_ptr, STATE_MSG, 1, 0, 0, 0, 0);

			tipc_link_proto_xmit(l_ptr, STATE_MSG, 1, 0, 0, 0, 0);

			l_ptr->fsm_msg_cnt++;

			if (l_ptr->owner->working_links == 1)

				tipc_link_send_sync(l_ptr);

				tipc_link_sync_xmit(l_ptr);

			link_set_timer(l_ptr, cont_intv);

			break;

		case RESET_MSG:

			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);

			tipc_link_proto_xmit(l_ptr, ACTIVATE_MSG,

					     1, 0, 0, 0, 0);

			l_ptr->fsm_msg_cnt++;

			link_set_timer(l_ptr, cont_intv);

			break;
@@ -621,7 +624,7 @@ static void link_state_event(struct tipc_link *l_ptr, unsigned int event) 
			l_ptr->flags |= LINK_STARTED;

			/* fall through */

		case TIMEOUT_EVT:

			tipc_link_send_proto_msg(l_ptr, RESET_MSG, 0, 0, 0, 0, 0);

			tipc_link_proto_xmit(l_ptr, RESET_MSG, 0, 0, 0, 0, 0);

			l_ptr->fsm_msg_cnt++;

			link_set_timer(l_ptr, cont_intv);

			break;
@@ -639,16 +642,17 @@ static void link_state_event(struct tipc_link *l_ptr, unsigned int event) 
			l_ptr->state = WORKING_WORKING;

			l_ptr->fsm_msg_cnt = 0;

			link_activate(l_ptr);

			tipc_link_send_proto_msg(l_ptr, STATE_MSG, 1, 0, 0, 0, 0);

			tipc_link_proto_xmit(l_ptr, STATE_MSG, 1, 0, 0, 0, 0);

			l_ptr->fsm_msg_cnt++;

			if (l_ptr->owner->working_links == 1)

				tipc_link_send_sync(l_ptr);

				tipc_link_sync_xmit(l_ptr);

			link_set_timer(l_ptr, cont_intv);

			break;

		case RESET_MSG:

			break;

		case TIMEOUT_EVT:

			tipc_link_send_proto_msg(l_ptr, ACTIVATE_MSG, 0, 0, 0, 0, 0);

			tipc_link_proto_xmit(l_ptr, ACTIVATE_MSG,

					     0, 0, 0, 0, 0);

			l_ptr->fsm_msg_cnt++;

			link_set_timer(l_ptr, cont_intv);

			break;
@@ -734,11 +738,11 @@ static void link_add_chain_to_outqueue(struct tipc_link *l_ptr, 
}



/*

 * tipc_link_send_buf() is the 'full path' for messages, called from

 * inside TIPC when the 'fast path' in tipc_send_buf

 * tipc_link_xmit() is the 'full path' for messages, called from

 * inside TIPC when the 'fast path' in tipc_send_xmit

 * has failed, and from link_send()

 */

int tipc_link_send_buf(struct tipc_link *l_ptr, struct sk_buff *buf)

int __tipc_link_xmit(struct tipc_link *l_ptr, struct sk_buff *buf)

{

	struct tipc_msg *msg = buf_msg(buf);

	u32 size = msg_size(msg);
@@ -766,7 +770,7 @@ int tipc_link_send_buf(struct tipc_link *l_ptr, struct sk_buff *buf) 


	/* Fragmentation needed ? */

	if (size > max_packet)

		return link_send_long_buf(l_ptr, buf);

		return tipc_link_frag_xmit(l_ptr, buf);



	/* Packet can be queued or sent. */

	if (likely(!link_congested(l_ptr))) {
@@ -810,11 +814,11 @@ int tipc_link_send_buf(struct tipc_link *l_ptr, struct sk_buff *buf) 
}



/*

 * tipc_link_send(): same as tipc_link_send_buf(), but the link to use has

 * not been selected yet, and the the owner node is not locked

 * tipc_link_xmit(): same as __tipc_link_xmit(), but the link to use

 * has not been selected yet, and the the owner node is not locked

 * Called by TIPC internal users, e.g. the name distributor

 */

int tipc_link_send(struct sk_buff *buf, u32 dest, u32 selector)

int tipc_link_xmit(struct sk_buff *buf, u32 dest, u32 selector)

{

	struct tipc_link *l_ptr;

	struct tipc_node *n_ptr;
@@ -826,7 +830,7 @@ int tipc_link_send(struct sk_buff *buf, u32 dest, u32 selector) 
		tipc_node_lock(n_ptr);

		l_ptr = n_ptr->active_links[selector & 1];

		if (l_ptr)

			res = tipc_link_send_buf(l_ptr, buf);

			res = __tipc_link_xmit(l_ptr, buf);

		else

			kfree_skb(buf);

		tipc_node_unlock(n_ptr);
@@ -838,14 +842,14 @@ int tipc_link_send(struct sk_buff *buf, u32 dest, u32 selector) 
}



/*

 * tipc_link_send_sync - synchronize broadcast link endpoints.

 * tipc_link_sync_xmit - synchronize broadcast link endpoints.

 *

 * Give a newly added peer node the sequence number where it should

 * start receiving and acking broadcast packets.

 *

 * Called with node locked

 */

static void tipc_link_send_sync(struct tipc_link *l)

static void tipc_link_sync_xmit(struct tipc_link *l)

{

	struct sk_buff *buf;

	struct tipc_msg *msg;
@@ -862,14 +866,14 @@ static void tipc_link_send_sync(struct tipc_link *l) 
}



/*

 * tipc_link_recv_sync - synchronize broadcast link endpoints.

 * tipc_link_sync_rcv - synchronize broadcast link endpoints.

 * Receive the sequence number where we should start receiving and

 * acking broadcast packets from a newly added peer node, and open

 * up for reception of such packets.

 *

 * Called with node locked

 */

static void tipc_link_recv_sync(struct tipc_node *n, struct sk_buff *buf)

static void tipc_link_sync_rcv(struct tipc_node *n, struct sk_buff *buf)

{

	struct tipc_msg *msg = buf_msg(buf);
@@ -879,7 +883,7 @@ static void tipc_link_recv_sync(struct tipc_node *n, struct sk_buff *buf) 
}



/*

 * tipc_link_send_names - send name table entries to new neighbor

 * tipc_link_names_xmit - send name table entries to new neighbor

 *

 * Send routine for bulk delivery of name table messages when contact

 * with a new neighbor occurs. No link congestion checking is performed
@@ -887,7 +891,7 @@ static void tipc_link_recv_sync(struct tipc_node *n, struct sk_buff *buf) 
 * small enough not to require fragmentation.

 * Called without any locks held.

 */

void tipc_link_send_names(struct list_head *message_list, u32 dest)

void tipc_link_names_xmit(struct list_head *message_list, u32 dest)

{

	struct tipc_node *n_ptr;

	struct tipc_link *l_ptr;
@@ -922,12 +926,12 @@ void tipc_link_send_names(struct list_head *message_list, u32 dest) 
}



/*

 * link_send_buf_fast: Entry for data messages where the

 * tipc_link_xmit_fast: Entry for data messages where the

 * destination link is known and the header is complete,

 * inclusive total message length. Very time critical.

 * Link is locked. Returns user data length.

 */

static int link_send_buf_fast(struct tipc_link *l_ptr, struct sk_buff *buf,

static int tipc_link_xmit_fast(struct tipc_link *l_ptr, struct sk_buff *buf,

			       u32 *used_max_pkt)

{

	struct tipc_msg *msg = buf_msg(buf);
@@ -944,16 +948,16 @@ static int link_send_buf_fast(struct tipc_link *l_ptr, struct sk_buff *buf, 
		else

			*used_max_pkt = l_ptr->max_pkt;

	}

	return tipc_link_send_buf(l_ptr, buf);  /* All other cases */

	return __tipc_link_xmit(l_ptr, buf);  /* All other cases */

}



/*

 * tipc_link_send_sections_fast: Entry for messages where the

 * tipc_link_iovec_xmit_fast: Entry for messages where the

 * destination processor is known and the header is complete,

 * except for total message length.

 * Returns user data length or errno.

 */

int tipc_link_send_sections_fast(struct tipc_port *sender,

int tipc_link_iovec_xmit_fast(struct tipc_port *sender,

			      struct iovec const *msg_sect,

			      unsigned int len, u32 destaddr)

{
@@ -981,7 +985,7 @@ int tipc_link_send_sections_fast(struct tipc_port *sender, 
		l_ptr = node->active_links[selector];

		if (likely(l_ptr)) {

			if (likely(buf)) {

				res = link_send_buf_fast(l_ptr, buf,

				res = tipc_link_xmit_fast(l_ptr, buf,

							  &sender->max_pkt);

exit:

				tipc_node_unlock(node);
@@ -1008,8 +1012,8 @@ int tipc_link_send_sections_fast(struct tipc_port *sender, 
			if ((msg_hdr_sz(hdr) + res) <= sender->max_pkt)

				goto again;



			return link_send_sections_long(sender, msg_sect, len,

						       destaddr);

			return tipc_link_iovec_long_xmit(sender, msg_sect,

							 len, destaddr);

		}

		tipc_node_unlock(node);

	}
@@ -1019,13 +1023,13 @@ int tipc_link_send_sections_fast(struct tipc_port *sender, 
	if (buf)

		return tipc_reject_msg(buf, TIPC_ERR_NO_NODE);

	if (res >= 0)

		return tipc_port_reject_sections(sender, hdr, msg_sect,

						 len, TIPC_ERR_NO_NODE);

		return tipc_port_iovec_reject(sender, hdr, msg_sect, len,

					      TIPC_ERR_NO_NODE);

	return res;

}



/*

 * link_send_sections_long(): Entry for long messages where the

 * tipc_link_iovec_long_xmit(): Entry for long messages where the

 * destination node is known and the header is complete,

 * inclusive total message length.

 * Link and bearer congestion status have been checked to be ok,
@@ -1038,7 +1042,7 @@ int tipc_link_send_sections_fast(struct tipc_port *sender, 
 *

 * Returns user data length or errno.

 */

static int link_send_sections_long(struct tipc_port *sender,

static int tipc_link_iovec_long_xmit(struct tipc_port *sender,

				     struct iovec const *msg_sect,

				     unsigned int len, u32 destaddr)

{
@@ -1159,7 +1163,7 @@ static int link_send_sections_long(struct tipc_port *sender, 
	} else {

reject:

		kfree_skb_list(buf_chain);

		return tipc_port_reject_sections(sender, hdr, msg_sect,

		return tipc_port_iovec_reject(sender, hdr, msg_sect,

					      len, TIPC_ERR_NO_NODE);

	}
@@ -1469,9 +1473,9 @@ void tipc_rcv(struct sk_buff *head, struct tipc_bearer *b_ptr) 


		if (unlikely(msg_non_seq(msg))) {

			if (msg_user(msg) ==  LINK_CONFIG)

				tipc_disc_recv_msg(buf, b_ptr);

				tipc_disc_rcv(buf, b_ptr);

			else

				tipc_bclink_recv_pkt(buf);

				tipc_bclink_rcv(buf);

			continue;

		}
@@ -1532,14 +1536,13 @@ void tipc_rcv(struct sk_buff *head, struct tipc_bearer *b_ptr) 


		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_proto_xmit(l_ptr, STATE_MSG, 0, 0, 0, 0, 0);

		}



		/* Process the incoming packet */

		if (unlikely(!link_working_working(l_ptr))) {

			if (msg_user(msg) == LINK_PROTOCOL) {

				link_recv_proto_msg(l_ptr, buf);

				tipc_link_proto_rcv(l_ptr, buf);

				head = link_insert_deferred_queue(l_ptr, head);

				tipc_node_unlock(n_ptr);

				continue;
@@ -1600,25 +1603,25 @@ void tipc_rcv(struct sk_buff *head, struct tipc_bearer *b_ptr) 
		case TIPC_HIGH_IMPORTANCE:

		case TIPC_CRITICAL_IMPORTANCE:

			tipc_node_unlock(n_ptr);

			tipc_port_recv_msg(buf);

			tipc_port_rcv(buf);

			continue;

		case MSG_BUNDLER:

			l_ptr->stats.recv_bundles++;

			l_ptr->stats.recv_bundled += msg_msgcnt(msg);

			tipc_node_unlock(n_ptr);

			tipc_link_recv_bundle(buf);

			tipc_link_bundle_rcv(buf);

			continue;

		case NAME_DISTRIBUTOR:

			n_ptr->bclink.recv_permitted = true;

			tipc_node_unlock(n_ptr);

			tipc_named_recv(buf);

			tipc_named_rcv(buf);

			continue;

		case CONN_MANAGER:

			tipc_node_unlock(n_ptr);

			tipc_port_recv_proto_msg(buf);

			tipc_port_proto_rcv(buf);

			continue;

		case BCAST_PROTOCOL:

			tipc_link_recv_sync(n_ptr, buf);

			tipc_link_sync_rcv(n_ptr, buf);

			break;

		default:

			kfree_skb(buf);
@@ -1693,7 +1696,7 @@ static void link_handle_out_of_seq_msg(struct tipc_link *l_ptr, 
	u32 seq_no = buf_seqno(buf);



	if (likely(msg_user(buf_msg(buf)) == LINK_PROTOCOL)) {

		link_recv_proto_msg(l_ptr, buf);

		tipc_link_proto_rcv(l_ptr, buf);

		return;

	}
@@ -1715,7 +1718,7 @@ static void link_handle_out_of_seq_msg(struct tipc_link *l_ptr, 
		l_ptr->deferred_inqueue_sz++;

		l_ptr->stats.deferred_recv++;

		if ((l_ptr->deferred_inqueue_sz % 16) == 1)

			tipc_link_send_proto_msg(l_ptr, STATE_MSG, 0, 0, 0, 0, 0);

			tipc_link_proto_xmit(l_ptr, STATE_MSG, 0, 0, 0, 0, 0);

	} else

		l_ptr->stats.duplicates++;

}
@@ -1723,9 +1726,8 @@ static void link_handle_out_of_seq_msg(struct tipc_link *l_ptr, 
/*

 * Send protocol message to the other endpoint.

 */

void tipc_link_send_proto_msg(struct tipc_link *l_ptr, u32 msg_typ,

			      int probe_msg, u32 gap, u32 tolerance,

			      u32 priority, u32 ack_mtu)

void tipc_link_proto_xmit(struct tipc_link *l_ptr, u32 msg_typ, int probe_msg,

			  u32 gap, u32 tolerance, u32 priority, u32 ack_mtu)

{

	struct sk_buff *buf = NULL;

	struct tipc_msg *msg = l_ptr->pmsg;
@@ -1824,7 +1826,7 @@ void tipc_link_send_proto_msg(struct tipc_link *l_ptr, u32 msg_typ, 
 * Note that network plane id propagates through the network, and may

 * change at any time. The node with lowest address rules

 */

static void link_recv_proto_msg(struct tipc_link *l_ptr, struct sk_buff *buf)

static void tipc_link_proto_rcv(struct tipc_link *l_ptr, struct sk_buff *buf)

{

	u32 rec_gap = 0;

	u32 max_pkt_info;
@@ -1943,8 +1945,8 @@ static void link_recv_proto_msg(struct tipc_link *l_ptr, struct sk_buff *buf) 
						      msg_last_bcast(msg));



		if (rec_gap || (msg_probe(msg))) {

			tipc_link_send_proto_msg(l_ptr, STATE_MSG,

						 0, rec_gap, 0, 0, max_pkt_ack);

			tipc_link_proto_xmit(l_ptr, STATE_MSG, 0, rec_gap, 0,

					     0, max_pkt_ack);

		}

		if (msg_seq_gap(msg)) {

			l_ptr->stats.recv_nacks++;
@@ -1983,7 +1985,7 @@ static void tipc_link_tunnel_xmit(struct tipc_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);

	tipc_link_send_buf(tunnel, buf);

	__tipc_link_xmit(tunnel, buf);

}
@@ -2016,7 +2018,7 @@ void tipc_link_failover_send_queue(struct tipc_link *l_ptr) 
		if (buf) {

			skb_copy_to_linear_data(buf, &tunnel_hdr, INT_H_SIZE);

			msg_set_size(&tunnel_hdr, INT_H_SIZE);

			tipc_link_send_buf(tunnel, buf);

			__tipc_link_xmit(tunnel, buf);

		} else {

			pr_warn("%sunable to send changeover msg\n",

				link_co_err);
@@ -2050,7 +2052,7 @@ void tipc_link_failover_send_queue(struct tipc_link *l_ptr) 
	}

}



/* tipc_link_dup_send_queue(): A second link has become active. Tunnel a

/* tipc_link_dup_queue_xmit(): A second link has become active. Tunnel a

 * duplicate of the first link's send queue via the new link. This way, we

 * are guaranteed that currently queued packets from a socket are delivered

 * before future traffic from the same socket, even if this is using the
@@ -2059,7 +2061,7 @@ void tipc_link_failover_send_queue(struct tipc_link *l_ptr) 
 * and sequence order is preserved per sender/receiver socket pair.

 * Owner node is locked.

 */

void tipc_link_dup_send_queue(struct tipc_link *l_ptr,

void tipc_link_dup_queue_xmit(struct tipc_link *l_ptr,

			      struct tipc_link *tunnel)

{

	struct sk_buff *iter;
@@ -2089,7 +2091,7 @@ void tipc_link_dup_send_queue(struct tipc_link *l_ptr, 
		skb_copy_to_linear_data(outbuf, &tunnel_hdr, INT_H_SIZE);

		skb_copy_to_linear_data_offset(outbuf, INT_H_SIZE, iter->data,

					       length);

		tipc_link_send_buf(tunnel, outbuf);

		__tipc_link_xmit(tunnel, outbuf);

		if (!tipc_link_is_up(l_ptr))

			return;

		iter = iter->next;
@@ -2223,7 +2225,7 @@ static int tipc_link_tunnel_rcv(struct tipc_node *n_ptr, 
/*

 *  Bundler functionality:

 */

void tipc_link_recv_bundle(struct sk_buff *buf)

void tipc_link_bundle_rcv(struct sk_buff *buf)

{

	u32 msgcount = msg_msgcnt(buf_msg(buf));

	u32 pos = INT_H_SIZE;
@@ -2246,11 +2248,11 @@ void tipc_link_recv_bundle(struct sk_buff *buf) 
 */



/*

 * link_send_long_buf: Entry for buffers needing fragmentation.

 * tipc_link_frag_xmit: Entry for buffers needing fragmentation.

 * The buffer is complete, inclusive total message length.

 * Returns user data length.

 */

static int link_send_long_buf(struct tipc_link *l_ptr, struct sk_buff *buf)

static int tipc_link_frag_xmit(struct tipc_link *l_ptr, struct sk_buff *buf)

{

	struct sk_buff *buf_chain = NULL;

	struct sk_buff *buf_chain_tail = (struct sk_buff *)&buf_chain;
@@ -2477,13 +2479,13 @@ static int link_cmd_set_value(const char *name, u32 new_value, u16 cmd) 
			switch (cmd) {

			case TIPC_CMD_SET_LINK_TOL:

				link_set_supervision_props(l_ptr, new_value);

				tipc_link_send_proto_msg(l_ptr, STATE_MSG, 0,

							 0, new_value, 0, 0);

				tipc_link_proto_xmit(l_ptr, STATE_MSG, 0, 0,

						     new_value, 0, 0);

				break;

			case TIPC_CMD_SET_LINK_PRI:

				l_ptr->priority = new_value;

				tipc_link_send_proto_msg(l_ptr, STATE_MSG, 0,

							 0, 0, new_value, 0);

				tipc_link_proto_xmit(l_ptr, STATE_MSG, 0, 0,

						     0, new_value, 0);

				break;

			case TIPC_CMD_SET_LINK_WINDOW:

				tipc_link_set_queue_limits(l_ptr, new_value);