/* * net/tipc/link.c: TIPC link code * * Copyright (c) 1996-2007, 2012, Ericsson AB * Copyright (c) 2004-2007, 2010-2013, 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" #include <linux/pkt_sched.h> /* * Error message prefixes */static const char *link_co_err = "Link changeover error, ";static const char *link_rst_msg = "Resetting link ";static const char *link_unk_evt = "Unknown link event "; /* * 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 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,				    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 void link_start(struct tipc_link *l_ptr);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); /* *  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_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_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);		pr_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);		pr_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) {		pr_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) {		pr_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){	kfree_skb(l_ptr->reasm_head);	l_ptr->reasm_head = NULL;	l_ptr->reasm_tail = 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; 	buf = l_ptr->oldest_deferred_in;	while (buf) {		next = buf->next;		kfree_skb(buf);		buf = next;	} 	buf = l_ptr->first_out;	while (buf) {		next = buf->next;		kfree_skb(buf);		buf = next;	} 	tipc_link_reset_fragments(l_ptr); 	kfree_skb(l_ptr->proto_msg_queue);	l_ptr->proto_msg_queue = NULL;} void tipc_link_reset(struct tipc_link *l_ptr){	struct sk_buff *buf;	u32 prev_state = l_ptr->state;	u32 checkpoint = l_ptr->next_in_no;	int was_active_link = tipc_link_is_active(l_ptr); 	msg_set_session(l_ptr->pmsg, ((msg_session(l_ptr->pmsg) + 1) & 0xffff)); 	/* Link is down, accept any session */	l_ptr->peer_session = INVALID_SESSION; 	/* Prepare for max packet size negotiation */	link_init_max_pkt(l_ptr); 	l_ptr->state = RESET_UNKNOWN; 	if ((prev_state == RESET_UNKNOWN) || (prev_state == RESET_RESET))		return; 	tipc_node_link_down(l_ptr->owner, l_ptr);	tipc_bearer_remove_dest(l_ptr->b_ptr, l_ptr->addr); 	if (was_active_link && tipc_node_active_links(l_ptr->owner) &&	    l_ptr->owner->permit_changeover) {		l_ptr->reset_checkpoint = checkpoint;		l_ptr->exp_msg_count = START_CHANGEOVER;	} 	/* Clean up all queues: */	link_release_outqueue(l_ptr);	kfree_skb(l_ptr->proto_msg_queue);	l_ptr->proto_msg_queue = NULL;	buf = l_ptr->oldest_deferred_in;	while (buf) {		struct sk_buff *next = buf->next;		kfree_skb(buf);		buf = next;	}	if (!list_empty(&l_ptr->waiting_ports))		tipc_link_wakeup_ports(l_ptr, 1); 	l_ptr->retransm_queue_head = 0;	l_ptr->retransm_queue_size = 0;	l_ptr->last_out = NULL;	l_ptr->first_out = NULL;	l_ptr->next_out = NULL;	l_ptr->unacked_window = 0;	l_ptr->checkpoint = 1;	l_ptr->next_out_no = 1;	l_ptr->deferred_inqueue_sz = 0;	l_ptr->oldest_deferred_in = NULL;	l_ptr->newest_deferred_in = NULL;	l_ptr->fsm_msg_cnt = 0;	l_ptr->stale_count = 0;	link_reset_statistics(l_ptr);}  static void link_activate(struct tipc_link *l_ptr)

Lines 1–500 of 2807. Load more