/* * net/tipc/link.c: TIPC link code * * Copyright (c) 1996-2007, Ericsson AB * Copyright (c) 2004-2007, 2010-2011, Wind River Systems * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * 1. Redistributions of source code must retain the above copyright *    notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright *    notice, this list of conditions and the following disclaimer in the *    documentation and/or other materials provided with the distribution. * 3. Neither the names of the copyright holders nor the names of its *    contributors may be used to endorse or promote products derived from *    this software without specific prior written permission. * * Alternatively, this software may be distributed under the terms of the * GNU General Public License ("GPL") version 2 as published by the Free * Software Foundation. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ #include "core.h"#include "link.h"#include "port.h"#include "name_distr.h"#include "discover.h"#include "config.h"  /* * Out-of-range value for link session numbers */#define INVALID_SESSION 0x10000 /* * Link state events: */#define  STARTING_EVT    856384768	/* link processing trigger */#define  TRAFFIC_MSG_EVT 560815u	/* rx'd ??? */#define  TIMEOUT_EVT     560817u	/* link timer expired */ /* * The following two 'message types' is really just implementation * data conveniently stored in the message header. * They must not be considered part of the protocol */#define OPEN_MSG   0#define CLOSED_MSG 1 /* * State value stored in 'exp_msg_count' */#define START_CHANGEOVER 100000u /** * struct tipc_link_name - deconstructed link name * @addr_local: network address of node at this end * @if_local: name of interface at this end * @addr_peer: network address of node at far end * @if_peer: name of interface at far end */struct tipc_link_name {	u32 addr_local;	char if_local[TIPC_MAX_IF_NAME];	u32 addr_peer;	char if_peer[TIPC_MAX_IF_NAME];}; 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 int  link_recv_changeover_msg(struct tipc_link **l_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,				    struct iovec const *msg_sect,				    u32 num_sect, unsigned int total_len,				    u32 destnode);static void link_check_defragm_bufs(struct tipc_link *l_ptr);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 void link_start(struct tipc_link *l_ptr);static int link_send_long_buf(struct tipc_link *l_ptr, struct sk_buff *buf); /* *  Simple link routines */static unsigned int align(unsigned int i){	return (i + 3) & ~3u;} static void link_init_max_pkt(struct tipc_link *l_ptr){	u32 max_pkt; 	max_pkt = (l_ptr->b_ptr->mtu & ~3);	if (max_pkt > MAX_MSG_SIZE)		max_pkt = MAX_MSG_SIZE; 	l_ptr->max_pkt_target = max_pkt;	if (l_ptr->max_pkt_target < MAX_PKT_DEFAULT)		l_ptr->max_pkt = l_ptr->max_pkt_target;	else		l_ptr->max_pkt = MAX_PKT_DEFAULT; 	l_ptr->max_pkt_probes = 0;} static u32 link_next_sent(struct tipc_link *l_ptr){	if (l_ptr->next_out)		return buf_seqno(l_ptr->next_out);	return mod(l_ptr->next_out_no);} static u32 link_last_sent(struct tipc_link *l_ptr){	return mod(link_next_sent(l_ptr) - 1);} /* *  Simple non-static link routines (i.e. referenced outside this file) */int tipc_link_is_up(struct tipc_link *l_ptr){	if (!l_ptr)		return 0;	return link_working_working(l_ptr) || link_working_unknown(l_ptr);} int tipc_link_is_active(struct tipc_link *l_ptr){	return	(l_ptr->owner->active_links[0] == l_ptr) ||		(l_ptr->owner->active_links[1] == l_ptr);} /** * link_name_validate - validate & (optionally) deconstruct tipc_link name * @name - ptr to link name string * @name_parts - ptr to area for link name components (or NULL if not needed) * * Returns 1 if link name is valid, otherwise 0. */static int link_name_validate(const char *name,				struct tipc_link_name *name_parts){	char name_copy[TIPC_MAX_LINK_NAME];	char *addr_local;	char *if_local;	char *addr_peer;	char *if_peer;	char dummy;	u32 z_local, c_local, n_local;	u32 z_peer, c_peer, n_peer;	u32 if_local_len;	u32 if_peer_len; 	/* copy link name & ensure length is OK */	name_copy[TIPC_MAX_LINK_NAME - 1] = 0;	/* need above in case non-Posix strncpy() doesn't pad with nulls */	strncpy(name_copy, name, TIPC_MAX_LINK_NAME);	if (name_copy[TIPC_MAX_LINK_NAME - 1] != 0)		return 0; 	/* ensure all component parts of link name are present */	addr_local = name_copy;	if_local = strchr(addr_local, ':');	if (if_local == NULL)		return 0;	*(if_local++) = 0;	addr_peer = strchr(if_local, '-');	if (addr_peer == NULL)		return 0;	*(addr_peer++) = 0;	if_local_len = addr_peer - if_local;	if_peer = strchr(addr_peer, ':');	if (if_peer == NULL)		return 0;	*(if_peer++) = 0;	if_peer_len = strlen(if_peer) + 1; 	/* validate component parts of link name */	if ((sscanf(addr_local, "%u.%u.%u%c",		    &z_local, &c_local, &n_local, &dummy) != 3) ||	    (sscanf(addr_peer, "%u.%u.%u%c",		    &z_peer, &c_peer, &n_peer, &dummy) != 3) ||	    (z_local > 255) || (c_local > 4095) || (n_local > 4095) ||	    (z_peer  > 255) || (c_peer  > 4095) || (n_peer  > 4095) ||	    (if_local_len <= 1) || (if_local_len > TIPC_MAX_IF_NAME) ||	    (if_peer_len  <= 1) || (if_peer_len  > TIPC_MAX_IF_NAME) ||	    (strspn(if_local, tipc_alphabet) != (if_local_len - 1)) ||	    (strspn(if_peer, tipc_alphabet) != (if_peer_len - 1)))		return 0; 	/* return link name components, if necessary */	if (name_parts) {		name_parts->addr_local = tipc_addr(z_local, c_local, n_local);		strcpy(name_parts->if_local, if_local);		name_parts->addr_peer = tipc_addr(z_peer, c_peer, n_peer);		strcpy(name_parts->if_peer, if_peer);	}	return 1;} /** * link_timeout - handle expiration of link timer * @l_ptr: pointer to link * * This routine must not grab "tipc_net_lock" to avoid a potential deadlock conflict * with tipc_link_delete().  (There is no risk that the node will be deleted by * another thread because tipc_link_delete() always cancels the link timer before * tipc_node_delete() is called.) */static void link_timeout(struct tipc_link *l_ptr){	tipc_node_lock(l_ptr->owner); 	/* update counters used in statistical profiling of send traffic */	l_ptr->stats.accu_queue_sz += l_ptr->out_queue_size;	l_ptr->stats.queue_sz_counts++; 	if (l_ptr->first_out) {		struct tipc_msg *msg = buf_msg(l_ptr->first_out);		u32 length = msg_size(msg); 		if ((msg_user(msg) == MSG_FRAGMENTER) &&		    (msg_type(msg) == FIRST_FRAGMENT)) {			length = msg_size(msg_get_wrapped(msg));		}		if (length) {			l_ptr->stats.msg_lengths_total += length;			l_ptr->stats.msg_length_counts++;			if (length <= 64)				l_ptr->stats.msg_length_profile[0]++;			else if (length <= 256)				l_ptr->stats.msg_length_profile[1]++;			else if (length <= 1024)				l_ptr->stats.msg_length_profile[2]++;			else if (length <= 4096)				l_ptr->stats.msg_length_profile[3]++;			else if (length <= 16384)				l_ptr->stats.msg_length_profile[4]++;			else if (length <= 32768)				l_ptr->stats.msg_length_profile[5]++;			else				l_ptr->stats.msg_length_profile[6]++;		}	} 	/* do all other link processing performed on a periodic basis */	link_check_defragm_bufs(l_ptr); 	link_state_event(l_ptr, TIMEOUT_EVT); 	if (l_ptr->next_out)		tipc_link_push_queue(l_ptr); 	tipc_node_unlock(l_ptr->owner);} static void link_set_timer(struct tipc_link *l_ptr, u32 time){	k_start_timer(&l_ptr->timer, time);} /** * tipc_link_create - create a new link * @n_ptr: pointer to associated node * @b_ptr: pointer to associated bearer * @media_addr: media address to use when sending messages over link * * Returns pointer to link. */struct tipc_link *tipc_link_create(struct tipc_node *n_ptr,			      struct tipc_bearer *b_ptr,			      const struct tipc_media_addr *media_addr){	struct tipc_link *l_ptr;	struct tipc_msg *msg;	char *if_name;	char addr_string[16];	u32 peer = n_ptr->addr; 	if (n_ptr->link_cnt >= 2) {		tipc_addr_string_fill(addr_string, n_ptr->addr);		err("Attempt to establish third link to %s\n", addr_string);		return NULL;	} 	if (n_ptr->links[b_ptr->identity]) {		tipc_addr_string_fill(addr_string, n_ptr->addr);		err("Attempt to establish second link on <%s> to %s\n",		    b_ptr->name, addr_string);		return NULL;	} 	l_ptr = kzalloc(sizeof(*l_ptr), GFP_ATOMIC);	if (!l_ptr) {		warn("Link creation failed, no memory\n");		return NULL;	} 	l_ptr->addr = peer;	if_name = strchr(b_ptr->name, ':') + 1;	sprintf(l_ptr->name, "%u.%u.%u:%s-%u.%u.%u:unknown",		tipc_zone(tipc_own_addr), tipc_cluster(tipc_own_addr),		tipc_node(tipc_own_addr),		if_name,		tipc_zone(peer), tipc_cluster(peer), tipc_node(peer));		/* note: peer i/f name is updated by reset/activate message */	memcpy(&l_ptr->media_addr, media_addr, sizeof(*media_addr));	l_ptr->owner = n_ptr;	l_ptr->checkpoint = 1;	l_ptr->peer_session = INVALID_SESSION;	l_ptr->b_ptr = b_ptr;	link_set_supervision_props(l_ptr, b_ptr->tolerance);	l_ptr->state = RESET_UNKNOWN; 	l_ptr->pmsg = (struct tipc_msg *)&l_ptr->proto_msg;	msg = l_ptr->pmsg;	tipc_msg_init(msg, LINK_PROTOCOL, RESET_MSG, INT_H_SIZE, l_ptr->addr);	msg_set_size(msg, sizeof(l_ptr->proto_msg));	msg_set_session(msg, (tipc_random & 0xffff));	msg_set_bearer_id(msg, b_ptr->identity);	strcpy((char *)msg_data(msg), if_name); 	l_ptr->priority = b_ptr->priority;	tipc_link_set_queue_limits(l_ptr, b_ptr->window); 	link_init_max_pkt(l_ptr); 	l_ptr->next_out_no = 1;	INIT_LIST_HEAD(&l_ptr->waiting_ports); 	link_reset_statistics(l_ptr); 	tipc_node_attach_link(n_ptr, l_ptr); 	k_init_timer(&l_ptr->timer, (Handler)link_timeout, (unsigned long)l_ptr);	list_add_tail(&l_ptr->link_list, &b_ptr->links);	tipc_k_signal((Handler)link_start, (unsigned long)l_ptr); 	return l_ptr;} /** * tipc_link_delete - delete a link * @l_ptr: pointer to link * * Note: 'tipc_net_lock' is write_locked, bearer is locked. * This routine must not grab the node lock until after link timer cancellation * to avoid a potential deadlock situation. */void tipc_link_delete(struct tipc_link *l_ptr){	if (!l_ptr) {		err("Attempt to delete non-existent link\n");		return;	} 	k_cancel_timer(&l_ptr->timer); 	tipc_node_lock(l_ptr->owner);	tipc_link_reset(l_ptr);	tipc_node_detach_link(l_ptr->owner, l_ptr);	tipc_link_stop(l_ptr);	list_del_init(&l_ptr->link_list);	tipc_node_unlock(l_ptr->owner);	k_term_timer(&l_ptr->timer);	kfree(l_ptr);} static void link_start(struct tipc_link *l_ptr){	tipc_node_lock(l_ptr->owner);	link_state_event(l_ptr, STARTING_EVT);	tipc_node_unlock(l_ptr->owner);} /** * link_schedule_port - schedule port for deferred sending * @l_ptr: pointer to link * @origport: reference to sending port * @sz: amount of data to be sent * * Schedules port for renewed sending of messages after link congestion * has abated. */static int link_schedule_port(struct tipc_link *l_ptr, u32 origport, u32 sz){	struct tipc_port *p_ptr; 	spin_lock_bh(&tipc_port_list_lock);	p_ptr = tipc_port_lock(origport);	if (p_ptr) {		if (!p_ptr->wakeup)			goto exit;		if (!list_empty(&p_ptr->wait_list))			goto exit;		p_ptr->congested = 1;		p_ptr->waiting_pkts = 1 + ((sz - 1) / l_ptr->max_pkt);		list_add_tail(&p_ptr->wait_list, &l_ptr->waiting_ports);		l_ptr->stats.link_congs++;exit:		tipc_port_unlock(p_ptr);	}	spin_unlock_bh(&tipc_port_list_lock);	return -ELINKCONG;} void tipc_link_wakeup_ports(struct tipc_link *l_ptr, int all){	struct tipc_port *p_ptr;	struct tipc_port *temp_p_ptr;	int win = l_ptr->queue_limit[0] - l_ptr->out_queue_size; 	if (all)		win = 100000;	if (win <= 0)		return;	if (!spin_trylock_bh(&tipc_port_list_lock))		return;	if (link_congested(l_ptr))		goto exit;	list_for_each_entry_safe(p_ptr, temp_p_ptr, &l_ptr->waiting_ports,				 wait_list) {		if (win <= 0)			break;		list_del_init(&p_ptr->wait_list);		spin_lock_bh(p_ptr->lock);		p_ptr->congested = 0;		p_ptr->wakeup(p_ptr);		win -= p_ptr->waiting_pkts;		spin_unlock_bh(p_ptr->lock);	} exit:	spin_unlock_bh(&tipc_port_list_lock);} /** * link_release_outqueue - purge link's outbound message queue * @l_ptr: pointer to link */static void link_release_outqueue(struct tipc_link *l_ptr){	struct sk_buff *buf = l_ptr->first_out;	struct sk_buff *next; 	while (buf) {		next = buf->next;		kfree_skb(buf);		buf = next;	}	l_ptr->first_out = NULL;	l_ptr->out_queue_size = 0;} /** * tipc_link_reset_fragments - purge link's inbound message fragments queue * @l_ptr: pointer to link */void tipc_link_reset_fragments(struct tipc_link *l_ptr){	struct sk_buff *buf = l_ptr->defragm_buf;	struct sk_buff *next; 	while (buf) {		next = buf->next;		kfree_skb(buf);		buf = next;	}	l_ptr->defragm_buf = NULL;} /** * tipc_link_stop - purge all inbound and outbound messages associated with link * @l_ptr: pointer to link */void tipc_link_stop(struct tipc_link *l_ptr){	struct sk_buff *buf;	struct sk_buff *next;

Lines 1–500 of 3064. Load more