Release 4.11 net/tipc/link.c

/*
 * net/tipc/link.c: TIPC link code
 *
 * Copyright (c) 1996-2007, 2012-2016, 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 "subscr.h"
#include "link.h"
#include "bcast.h"
#include "socket.h"
#include "name_distr.h"
#include "discover.h"
#include "netlink.h"
#include "monitor.h"

#include <linux/pkt_sched.h>


struct tipc_stats {
	
u32 sent_pkts;
	
u32 recv_pkts;
	
u32 sent_states;
	
u32 recv_states;
	
u32 sent_probes;
	
u32 recv_probes;
	
u32 sent_nacks;
	
u32 recv_nacks;
	
u32 sent_acks;
	
u32 sent_bundled;
	
u32 sent_bundles;
	
u32 recv_bundled;
	
u32 recv_bundles;
	
u32 retransmitted;
	
u32 sent_fragmented;
	
u32 sent_fragments;
	
u32 recv_fragmented;
	
u32 recv_fragments;
	
u32 link_congs;		/* # port sends blocked by congestion */
	
u32 deferred_recv;
	
u32 duplicates;
	
u32 max_queue_sz;	/* send queue size high water mark */
	
u32 accu_queue_sz;	/* used for send queue size profiling */
	
u32 queue_sz_counts;	/* used for send queue size profiling */
	
u32 msg_length_counts;	/* used for message length profiling */
	
u32 msg_lengths_total;	/* used for message length profiling */
	
u32 msg_length_profile[7]; /* used for msg. length profiling */
};

/**
 * struct tipc_link - TIPC link data structure
 * @addr: network address of link's peer node
 * @name: link name character string
 * @media_addr: media address to use when sending messages over link
 * @timer: link timer
 * @net: pointer to namespace struct
 * @refcnt: reference counter for permanent references (owner node & timer)
 * @peer_session: link session # being used by peer end of link
 * @peer_bearer_id: bearer id used by link's peer endpoint
 * @bearer_id: local bearer id used by link
 * @tolerance: minimum link continuity loss needed to reset link [in ms]
 * @abort_limit: # of unacknowledged continuity probes needed to reset link
 * @state: current state of link FSM
 * @peer_caps: bitmap describing capabilities of peer node
 * @silent_intv_cnt: # of timer intervals without any reception from peer
 * @proto_msg: template for control messages generated by link
 * @pmsg: convenience pointer to "proto_msg" field
 * @priority: current link priority
 * @net_plane: current link network plane ('A' through 'H')
 * @mon_state: cookie with information needed by link monitor
 * @backlog_limit: backlog queue congestion thresholds (indexed by importance)
 * @exp_msg_count: # of tunnelled messages expected during link changeover
 * @reset_rcv_checkpt: seq # of last acknowledged message at time of link reset
 * @mtu: current maximum packet size for this link
 * @advertised_mtu: advertised own mtu when link is being established
 * @transmitq: queue for sent, non-acked messages
 * @backlogq: queue for messages waiting to be sent
 * @snt_nxt: next sequence number to use for outbound messages
 * @last_retransmitted: sequence number of most recently retransmitted message
 * @stale_count: # of identical retransmit requests made by peer
 * @ackers: # of peers that needs to ack each packet before it can be released
 * @acked: # last packet acked by a certain peer. Used for broadcast.
 * @rcv_nxt: next sequence number to expect for inbound messages
 * @deferred_queue: deferred queue saved OOS b'cast message received from node
 * @unacked_window: # of inbound messages rx'd without ack'ing back to peer
 * @inputq: buffer queue for messages to be delivered upwards
 * @namedq: buffer queue for name table messages to be delivered upwards
 * @next_out: ptr to first unsent outbound message in queue
 * @wakeupq: linked list of wakeup msgs waiting for link congestion to abate
 * @long_msg_seq_no: next identifier to use for outbound fragmented messages
 * @reasm_buf: head of partially reassembled inbound message fragments
 * @bc_rcvr: marks that this is a broadcast receiver link
 * @stats: collects statistics regarding link activity
 */

struct tipc_link {
	
u32 addr;
	
char name[TIPC_MAX_LINK_NAME];
	
struct net *net;

	/* Management and link supervision data */
	
u32 peer_session;
	
u32 session;
	
u32 peer_bearer_id;
	
u32 bearer_id;
	
u32 tolerance;
	
u32 abort_limit;
	
u32 state;
	
u16 peer_caps;
	
bool active;
	
u32 silent_intv_cnt;
	
char if_name[TIPC_MAX_IF_NAME];
	
u32 priority;
	
char net_plane;
	
struct tipc_mon_state mon_state;
	
u16 rst_cnt;

	/* Failover/synch */
	
u16 drop_point;
	
struct sk_buff *failover_reasm_skb;

	/* Max packet negotiation */
	
u16 mtu;
	
u16 advertised_mtu;

	/* Sending */
	
struct sk_buff_head transmq;
	
struct sk_buff_head backlogq;
	struct {
		
u16 len;
		
u16 limit;
	} 
backlog[5];
	
u16 snd_nxt;
	
u16 last_retransm;
	
u16 window;
	
u32 stale_count;

	/* Reception */
	
u16 rcv_nxt;
	
u32 rcv_unacked;
	
struct sk_buff_head deferdq;
	
struct sk_buff_head *inputq;
	
struct sk_buff_head *namedq;

	/* Congestion handling */
	
struct sk_buff_head wakeupq;

	/* Fragmentation/reassembly */
	
struct sk_buff *reasm_buf;

	/* Broadcast */
	
u16 ackers;
	
u16 acked;
	
struct tipc_link *bc_rcvlink;
	
struct tipc_link *bc_sndlink;
	
unsigned long prev_retr;
	
u16 prev_from;
	
u16 prev_to;
	
u8 nack_state;
	
bool bc_peer_is_up;

	/* Statistics */
	
struct tipc_stats stats;
};

/*
 * Error message prefixes
 */

static const char *link_co_err = "Link tunneling error, ";

static const char *link_rst_msg = "Resetting link ";

/* Send states for broadcast NACKs
 */
enum {
	
BC_NACK_SND_CONDITIONAL,
	
BC_NACK_SND_UNCONDITIONAL,
	
BC_NACK_SND_SUPPRESS,
};


#define TIPC_BC_RETR_LIMIT 10   
/* [ms] */

/*
 * Interval between NACKs when packets arrive out of order
 */

#define TIPC_NACK_INTV (TIPC_MIN_LINK_WIN * 2)

/* Wildcard value for link session numbers. When it is known that
 * peer endpoint is down, any session number must be accepted.
 */

#define ANY_SESSION 0x10000

/* Link FSM states:
 */
enum {
	
LINK_ESTABLISHED     = 0xe,
	
LINK_ESTABLISHING    = 0xe  << 4,
	
LINK_RESET           = 0x1  << 8,
	
LINK_RESETTING       = 0x2  << 12,
	
LINK_PEER_RESET      = 0xd  << 16,
	
LINK_FAILINGOVER     = 0xf  << 20,
	
LINK_SYNCHING        = 0xc  << 24
};

/* Link FSM state checking routines
 */


static int link_is_up(struct tipc_link *l)
{
	return l->state & (LINK_ESTABLISHED | LINK_SYNCHING);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jon Paul Maloy
22
100.00%
2
100.00%
Total
22
100.00%
2
100.00%

static int tipc_link_proto_rcv(struct tipc_link *l, struct sk_buff *skb,
			       struct sk_buff_head *xmitq);
static void tipc_link_build_proto_msg(struct tipc_link *l, int mtyp, bool probe,
				      u16 rcvgap, int tolerance, int priority,
				      struct sk_buff_head *xmitq);
static void link_print(struct tipc_link *l, const char *str);
static int tipc_link_build_nack_msg(struct tipc_link *l,
				    struct sk_buff_head *xmitq);
static void tipc_link_build_bc_init_msg(struct tipc_link *l,
					struct sk_buff_head *xmitq);
static bool tipc_link_release_pkts(struct tipc_link *l, u16 to);

/*
 *  Simple non-static link routines (i.e. referenced outside this file)
 */


bool tipc_link_is_up(struct tipc_link *l)
{
	return link_is_up(l);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Per Liden
11
68.75%
2
50.00%
Jon Paul Maloy
4
25.00%
1
25.00%
Paul Gortmaker
1
6.25%
1
25.00%
Total
16
100.00%
4
100.00%



bool tipc_link_peer_is_down(struct tipc_link *l)
{
	return l->state == LINK_PEER_RESET;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jon Paul Maloy
17
100.00%
1
100.00%
Total
17
100.00%
1
100.00%



bool tipc_link_is_reset(struct tipc_link *l)
{
	return l->state & (LINK_RESET | LINK_FAILINGOVER | LINK_ESTABLISHING);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jon Paul Maloy
23
100.00%
1
100.00%
Total
23
100.00%
1
100.00%



bool tipc_link_is_establishing(struct tipc_link *l)
{
	return l->state == LINK_ESTABLISHING;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jon Paul Maloy
17
100.00%
1
100.00%
Total
17
100.00%
1
100.00%



bool tipc_link_is_synching(struct tipc_link *l)
{
	return l->state == LINK_SYNCHING;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jon Paul Maloy
17
100.00%
1
100.00%
Total
17
100.00%
1
100.00%



bool tipc_link_is_failingover(struct tipc_link *l)
{
	return l->state == LINK_FAILINGOVER;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jon Paul Maloy
17
100.00%
1
100.00%
Total
17
100.00%
1
100.00%



bool tipc_link_is_blocked(struct tipc_link *l)
{
	return l->state & (LINK_RESETTING | LINK_PEER_RESET | LINK_FAILINGOVER);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jon Paul Maloy
23
100.00%
1
100.00%
Total
23
100.00%
1
100.00%



static bool link_is_bc_sndlink(struct tipc_link *l)
{
	return !l->bc_sndlink;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jon Paul Maloy
16
94.12%
1
50.00%
Fengguang Wu
1
5.88%
1
50.00%
Total
17
100.00%
2
100.00%



static bool link_is_bc_rcvlink(struct tipc_link *l)
{
	return ((l->bc_rcvlink == l) && !link_is_bc_sndlink(l));
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jon Paul Maloy
27
96.43%
1
50.00%
Fengguang Wu
1
3.57%
1
50.00%
Total
28
100.00%
2
100.00%



int tipc_link_is_active(struct tipc_link *l)
{
	return l->active;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Per Liden
8
53.33%
2
40.00%
Jon Paul Maloy
6
40.00%
2
40.00%
Paul Gortmaker
1
6.67%
1
20.00%
Total
15
100.00%
5
100.00%



void tipc_link_set_active(struct tipc_link *l, bool active)
{
	l->active = active;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jon Paul Maloy
18
94.74%
2
66.67%
Per Liden
1
5.26%
1
33.33%
Total
19
100.00%
3
100.00%



u32 tipc_link_id(struct tipc_link *l)
{
	return l->peer_bearer_id << 16 | l->bearer_id;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jon Paul Maloy
21
100.00%
2
100.00%
Total
21
100.00%
2
100.00%



int tipc_link_window(struct tipc_link *l)
{
	return l->window;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jon Paul Maloy
15
100.00%
3
100.00%
Total
15
100.00%
3
100.00%



int tipc_link_prio(struct tipc_link *l)
{
	return l->priority;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jon Paul Maloy
15
100.00%
3
100.00%
Total
15
100.00%
3
100.00%



unsigned long tipc_link_tolerance(struct tipc_link *l)
{
	return l->tolerance;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jon Paul Maloy
16
100.00%
2
100.00%
Total
16
100.00%
2
100.00%



struct sk_buff_head *tipc_link_inputq(struct tipc_link *l)
{
	return l->inputq;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jon Paul Maloy
17
100.00%
2
100.00%
Total
17
100.00%
2
100.00%



char tipc_link_plane(struct tipc_link *l)
{
	return l->net_plane;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jon Paul Maloy
15
100.00%
1
100.00%
Total
15
100.00%
1
100.00%



void tipc_link_add_bc_peer(struct tipc_link *snd_l,
			   struct tipc_link *uc_l,
			   struct sk_buff_head *xmitq)
{
	struct tipc_link *rcv_l = uc_l->bc_rcvlink;

	snd_l->ackers++;
	rcv_l->acked = snd_l->snd_nxt - 1;
	snd_l->state = LINK_ESTABLISHED;
	tipc_link_build_bc_init_msg(uc_l, xmitq);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jon Paul Maloy
57
100.00%
2
100.00%
Total
57
100.00%
2
100.00%



void tipc_link_remove_bc_peer(struct tipc_link *snd_l,
			      struct tipc_link *rcv_l,
			      struct sk_buff_head *xmitq)
{
	u16 ack = snd_l->snd_nxt - 1;

	snd_l->ackers--;
	rcv_l->bc_peer_is_up = true;
	rcv_l->state = LINK_ESTABLISHED;
	tipc_link_bc_ack_rcv(rcv_l, ack, xmitq);
	tipc_link_reset(rcv_l);
	rcv_l->state = LINK_RESET;
	if (!snd_l->ackers) {
		tipc_link_reset(snd_l);
		snd_l->state = LINK_RESET;
		__skb_queue_purge(xmitq);
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jon Paul Maloy
91
100.00%
5
100.00%
Total
91
100.00%
5
100.00%



int tipc_link_bc_peers(struct tipc_link *l)
{
	return l->ackers;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jon Paul Maloy
15
100.00%
1
100.00%
Total
15
100.00%
1
100.00%



u16 link_bc_rcv_gap(struct tipc_link *l)
{
	struct sk_buff *skb = skb_peek(&l->deferdq);
	u16 gap = 0;

	if (more(l->snd_nxt, l->rcv_nxt))
		gap = l->snd_nxt - l->rcv_nxt;
	if (skb)
		gap = buf_seqno(skb) - l->rcv_nxt;
	return gap;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jon Paul Maloy
69
100.00%
1
100.00%
Total
69
100.00%
1
100.00%



void tipc_link_set_mtu(struct tipc_link *l, int mtu)
{
	l->mtu = mtu;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jon Paul Maloy
19
100.00%
1
100.00%
Total
19
100.00%
1
100.00%



int tipc_link_mtu(struct tipc_link *l)
{
	return l->mtu;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jon Paul Maloy
15
100.00%
1
100.00%
Total
15
100.00%
1
100.00%



u16 tipc_link_rcv_nxt(struct tipc_link *l)
{
	return l->rcv_nxt;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jon Paul Maloy
15
100.00%
1
100.00%
Total
15
100.00%
1
100.00%



u16 tipc_link_acked(struct tipc_link *l)
{
	return l->acked;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jon Paul Maloy
15
100.00%
1
100.00%
Total
15
100.00%
1
100.00%



char *tipc_link_name(struct tipc_link *l)
{
	return l->name;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jon Paul Maloy
16
100.00%
1
100.00%
Total
16
100.00%
1
100.00%

/**
 * tipc_link_create - create a new link
 * @n: pointer to associated node
 * @if_name: associated interface name
 * @bearer_id: id (index) of associated bearer
 * @tolerance: link tolerance to be used by link
 * @net_plane: network plane (A,B,c..) this link belongs to
 * @mtu: mtu to be advertised by link
 * @priority: priority to be used by link
 * @window: send window to be used by link
 * @session: session to be used by link
 * @ownnode: identity of own node
 * @peer: node id of peer node
 * @peer_caps: bitmap describing peer node capabilities
 * @bc_sndlink: the namespace global link used for broadcast sending
 * @bc_rcvlink: the peer specific link used for broadcast reception
 * @inputq: queue to put messages ready for delivery
 * @namedq: queue to put binding table update messages ready for delivery
 * @link: return value, pointer to put the created link
 *
 * Returns true if link was created, otherwise false
 */


bool tipc_link_create(struct net *net, char *if_name, int bearer_id,
		      int tolerance, char net_plane, u32 mtu, int priority,
		      int window, u32 session, u32 ownnode, u32 peer,
		      u16 peer_caps,
		      struct tipc_link *bc_sndlink,
		      struct tipc_link *bc_rcvlink,
		      struct sk_buff_head *inputq,
		      struct sk_buff_head *namedq,
		      struct tipc_link **link)
{
	struct tipc_link *l;

	l = kzalloc(sizeof(*l), GFP_ATOMIC);
	if (!l)
		return false;
	*link = l;
	l->session = session;

	/* Note: peer i/f name is completed by reset/activate message */
	sprintf(l->name, "%u.%u.%u:%s-%u.%u.%u:unknown",
		tipc_zone(ownnode), tipc_cluster(ownnode), tipc_node(ownnode),
		if_name, tipc_zone(peer), tipc_cluster(peer), tipc_node(peer));
	strcpy(l->if_name, if_name);
	l->addr = peer;
	l->peer_caps = peer_caps;
	l->net = net;
	l->peer_session = ANY_SESSION;
	l->bearer_id = bearer_id;
	l->tolerance = tolerance;
	l->net_plane = net_plane;
	l->advertised_mtu = mtu;
	l->mtu = mtu;
	l->priority = priority;
	tipc_link_set_queue_limits(l, window);
	l->ackers = 1;
	l->bc_sndlink = bc_sndlink;
	l->bc_rcvlink = bc_rcvlink;
	l->inputq = inputq;
	l->namedq = namedq;
	l->state = LINK_RESETTING;
	__skb_queue_head_init(&l->transmq);
	__skb_queue_head_init(&l->backlogq);
	__skb_queue_head_init(&l->deferdq);
	skb_queue_head_init(&l->wakeupq);
	skb_queue_head_init(l->inputq);
	return true;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jon Paul Maloy
210
69.31%
14
60.87%
Per Liden
71
23.43%
1
4.35%
Ying Xue
12
3.96%
3
13.04%
Allan Stephens
8
2.64%
3
13.04%
Panagiotis Issaris
1
0.33%
1
4.35%
Richard Alpe
1
0.33%
1
4.35%
Total
303
100.00%
23
100.00%

/**
 * tipc_link_bc_create - create new link to be used for broadcast
 * @n: pointer to associated node
 * @mtu: mtu to be used
 * @window: send window to be used
 * @inputq: queue to put messages ready for delivery
 * @namedq: queue to put binding table update messages ready for delivery
 * @link: return value, pointer to put the created link
 *
 * Returns true if link was created, otherwise false
 */


bool tipc_link_bc_create(struct net *net, u32 ownnode, u32 peer,
			 int mtu, int window, u16 peer_caps,
			 struct sk_buff_head *inputq,
			 struct sk_buff_head *namedq,
			 struct tipc_link *bc_sndlink,
			 struct tipc_link **link)
{
	struct tipc_link *l;

	if (!tipc_link_create(net, "", MAX_BEARERS, 0, 'Z', mtu, 0, window,
			      0, ownnode, peer, peer_caps, bc_sndlink,
			      NULL, inputq, namedq, link))
		return false;

	l = *link;
	strcpy(l->name, tipc_bclink_name);
	tipc_link_reset(l);
	l->state = LINK_RESET;
	l->ackers = 0;
	l->bc_rcvlink = l;

	/* Broadcast send link is always up */
	if (link_is_bc_sndlink(l))
		l->state = LINK_ESTABLISHED;

	/* Disable replicast if even a single peer doesn't support it */
	if (link_is_bc_rcvlink(l) && !(peer_caps & TIPC_BCAST_RCAST))
		tipc_bcast_disable_rcast(net);

	return true;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jon Paul Maloy
168
100.00%
6
100.00%
Total
168
100.00%
6
100.00%

/**
 * tipc_link_fsm_evt - link finite state machine
 * @l: pointer to link
 * @evt: state machine event to be processed
 */


int tipc_link_fsm_evt(struct tipc_link *l, int evt)
{
	int rc = 0;

	switch (l->state) {
	case LINK_RESETTING:
		switch (evt) {
		case LINK_PEER_RESET_EVT:
			l->state = LINK_PEER_RESET;
			break;
		case LINK_RESET_EVT:
			l->state = LINK_RESET;
			break;
		case LINK_FAILURE_EVT:
		case LINK_FAILOVER_BEGIN_EVT:
		case LINK_ESTABLISH_EVT:
		case LINK_FAILOVER_END_EVT:
		case LINK_SYNCH_BEGIN_EVT:
		case LINK_SYNCH_END_EVT:
		default:
			goto illegal_evt;
		}
		break;
	case LINK_RESET:
		switch (evt) {
		case LINK_PEER_RESET_EVT:
			l->state = LINK_ESTABLISHING;
			break;
		case LINK_FAILOVER_BEGIN_EVT:
			l->state = LINK_FAILINGOVER;
		case LINK_FAILURE_EVT:
		case LINK_RESET_EVT:
		case LINK_ESTABLISH_EVT:
		case LINK_FAILOVER_END_EVT:
			break;
		case LINK_SYNCH_BEGIN_EVT:
		case LINK_SYNCH_END_EVT:
		default:
			goto illegal_evt;
		}
		break;
	case LINK_PEER_RESET:
		switch (evt) {
		case LINK_RESET_EVT:
			l->state = LINK_ESTABLISHING;
			break;
		case LINK_PEER_RESET_EVT:
		case LINK_ESTABLISH_EVT:
		case LINK_FAILURE_EVT:
			break;
		case LINK_SYNCH_BEGIN_EVT:
		case LINK_SYNCH_END_EVT:
		case LINK_FAILOVER_BEGIN_EVT:
		case LINK_FAILOVER_END_EVT:
		default:
			goto illegal_evt;
		}
		break;
	case LINK_FAILINGOVER:
		switch (evt) {
		case LINK_FAILOVER_END_EVT:
			l->state = LINK_RESET;
			break;
		case LINK_PEER_RESET_EVT:
		case LINK_RESET_EVT:
		case LINK_ESTABLISH_EVT:
		case LINK_FAILURE_EVT:
			break;
		case LINK_FAILOVER_BEGIN_EVT:
		case LINK_SYNCH_BEGIN_EVT:
		case LINK_SYNCH_END_EVT:
		default:
			goto illegal_evt;
		}
		break;
	case LINK_ESTABLISHING:
		switch (evt) {
		case LINK_ESTABLISH_EVT:
			l->state = LINK_ESTABLISHED;
			break;
		case LINK_FAILOVER_BEGIN_EVT:
			l->state = LINK_FAILINGOVER;
			break;
		case LINK_RESET_EVT:
			l->state = LINK_RESET;
			break;
		case LINK_FAILURE_EVT:
		case LINK_PEER_RESET_EVT:
		case LINK_SYNCH_BEGIN_EVT:
		case LINK_FAILOVER_END_EVT:
			break;
		case LINK_SYNCH_END_EVT:
		default:
			goto illegal_evt;
		}
		break;
	case LINK_ESTABLISHED:
		switch (evt) {
		case LINK_PEER_RESET_EVT:
			l->state = LINK_PEER_RESET;
			rc |= TIPC_LINK_DOWN_EVT;
			break;
		case LINK_FAILURE_EVT:
			l->state = LINK_RESETTING;
			rc |= TIPC_LINK_DOWN_EVT;
			break;
		case LINK_RESET_EVT:
			l->state = LINK_RESET;
			break;
		case LINK_ESTABLISH_EVT:
		case LINK_SYNCH_END_EVT:
			break;
		case LINK_SYNCH_BEGIN_EVT:
			l->state = LINK_SYNCHING;
			break;
		case LINK_FAILOVER_BEGIN_EVT:
		case LINK_FAILOVER_END_EVT:
		default:
			goto illegal_evt;
		}
		break;
	case LINK_SYNCHING:
		switch (evt) {
		case LINK_PEER_RESET_EVT:
			l->state = LINK_PEER_RESET;
			rc |= TIPC_LINK_DOWN_EVT;
			break;
		case LINK_FAILURE_EVT:
			l->state = LINK_RESETTING;
			rc |= TIPC_LINK_DOWN_EVT;
			break;
		case LINK_RESET_EVT:
			l->state = LINK_RESET;
			break;
		case LINK_ESTABLISH_EVT:
		case LINK_SYNCH_BEGIN_EVT:
			break;
		case LINK_SYNCH_END_EVT:
			l->state = LINK_ESTABLISHED;
			break;
		case LINK_FAILOVER_BEGIN_EVT:
		case LINK_FAILOVER_END_EVT:
		default:
			goto illegal_evt;
		}
		break;
	default:
		pr_err("Unknown FSM state %x in %s\n", l->state, l->name);
	}
	return rc;
illegal_evt:
	pr_err("Illegal FSM event %x in state %x on link %s\n",
	       evt, l->state, l->name);
	return rc;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jon Paul Maloy
457
97.44%
11
84.62%
Per Liden
11
2.35%
1
7.69%
Ying Xue
1
0.21%
1
7.69%
Total
469
100.00%
13
100.00%

/* link_profile_stats - update statistical profiling of traffic
 */


static void link_profile_stats(struct tipc_link *l)
{
	struct sk_buff *skb;
	struct tipc_msg *msg;
	int length;

	/* Update counters used in statistical profiling of send traffic */
	l->stats.accu_queue_sz += skb_queue_len(&l->transmq);
	l->stats.queue_sz_counts++;

	skb = skb_peek(&l->transmq);
	if (!skb)
		return;
	msg = buf_msg(skb);
	length = msg_size(msg);

	if (msg_user(msg) == MSG_FRAGMENTER) {
		if (msg_type(msg) != FIRST_FRAGMENT)
			return;
		length = msg_size(msg_get_wrapped(msg));
	}
	l->stats.msg_lengths_total += length;
	l->stats.msg_length_counts++;
	if (length <= 64)
		l->stats.msg_length_profile[0]++;
	else if (length <= 256)
		l->stats.msg_length_profile[1]++;
	else if (length <= 1024)
		l->stats.msg_length_profile[2]++;
	else if (length <= 4096)
		l->stats.msg_length_profile[3]++;
	else if (length <= 16384)
		l->stats.msg_length_profile[4]++;
	else if (length <= 32768)
		l->stats.msg_length_profile[5]++;
	else
		l->stats.msg_length_profile[6]++;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jon Paul Maloy
230
98.29%
3
75.00%
Per Liden
4
1.71%
1
25.00%
Total
234
100.00%
4
100.00%

/* tipc_link_timeout - perform periodic task as instructed from node timeout
 */


int tipc_link_timeout(struct tipc_link *l, struct sk_buff_head *xmitq)
{
	int mtyp = 0;
	int rc = 0;
	bool state = false;
	bool probe = false;
	bool setup = false;
	u16 bc_snt = l->bc_sndlink->snd_nxt - 1;
	u16 bc_acked = l->bc_rcvlink->acked;
	struct tipc_mon_state *mstate = &l->mon_state;

	switch (l->state) {
	case LINK_ESTABLISHED:
	case LINK_SYNCHING:
		mtyp = STATE_MSG;
		link_profile_stats(l);
		tipc_mon_get_state(l->net, l->addr, mstate, l->bearer_id);
		if (mstate->reset || (l->silent_intv_cnt > l->abort_limit))
			return tipc_link_fsm_evt(l, LINK_FAILURE_EVT);
		state = bc_acked != bc_snt;
		state |= l->bc_rcvlink->rcv_unacked;
		state |= l->rcv_unacked;
		state |= !skb_queue_empty(&l->transmq);
		state |= !skb_queue_empty(&l->deferdq);
		probe = mstate->probing;
		probe |= l->silent_intv_cnt;
		if (probe || mstate->monitoring)
			l->silent_intv_cnt++;
		break;
	case LINK_RESET:
		setup = l->rst_cnt++ <= 4;
		setup |= !(l->rst_cnt % 16);
		mtyp = RESET_MSG;
		break;
	case LINK_ESTABLISHING:
		setup = true;
		mtyp = ACTIVATE_MSG;
		break;
	case LINK_PEER_RESET:
	case LINK_RESETTING:
	case LINK_FAILINGOVER:
		break;
	default:
		break;
	}

	if (state || probe || setup)
		tipc_link_build_proto_msg(l, mtyp, probe, 0, 0, 0, xmitq);

	return rc;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jon Paul Maloy
278
98.58%
10
90.91%
Ying Xue
4
1.42%
1
9.09%
Total
282
100.00%
11
100.00%

/**
 * link_schedule_user - schedule a message sender for wakeup after congestion
 * @l: congested link
 * @hdr: header of message that is being sent
 * Create pseudo msg to send back to user when congestion abates
 */


static int link_schedule_user(struct tipc_link *l, struct tipc_msg *hdr)
{
	u32 dnode = tipc_own_addr(l->net);
	u32 dport = msg_origport(hdr);
	struct sk_buff *skb;

	/* Create and schedule wakeup pseudo message */
	skb = tipc_msg_create(SOCK_WAKEUP, 0, INT_H_SIZE, 0,
			      dnode, l->addr, dport, 0, 0);
	if (!skb)
		return -ENOBUFS;
	msg_set_dest_droppable(buf_msg(skb), true);
	TIPC_SKB_CB(skb)->chain_imp = msg_importance(hdr);
	skb_queue_tail(&l->wakeupq, skb);
	l->stats.link_congs++;
	return -ELINKCONG;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jon Paul Maloy
93
79.49%
4
50.00%
Per Liden
18
15.38%
1
12.50%
Allan Stephens
4
3.42%
1
12.50%
Paul Gortmaker
1
0.85%
1
12.50%
Ying Xue
1
0.85%
1
12.50%
Total
117
100.00%
8
100.00%

/**
 * link_prepare_wakeup - prepare users for wakeup after congestion
 * @l: congested link
 * Wake up a number of waiting users, as permitted by available space
 * in the send queue
 */


void link_prepare_wakeup(struct tipc_link *l)
{
	struct sk_buff *skb, *tmp;
	int imp, i = 0;

	skb_queue_walk_safe(&l->wakeupq, skb, tmp) {
		imp = TIPC_SKB_CB(skb)->chain_imp;
		if (l->backlog[imp].len < l->backlog[imp].limit) {
			skb_unlink(skb, &l->wakeupq);
			skb_queue_tail(l->inputq, skb);
		} else if (i++ > 10) {
			break;
		}
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jon Paul Maloy
90
93.75%
4
66.67%
Per Liden
4
4.17%
1
16.67%
Ying Xue
2
2.08%
1
16.67%
Total
96
100.00%
6
100.00%



void tipc_link_reset(struct tipc_link *l)
{
	l->peer_session = ANY_SESSION;
	l->session++;
	l->mtu = l->advertised_mtu;
	__skb_queue_purge(&l->transmq);
	__skb_queue_purge(&l->deferdq);
	skb_queue_splice_init(&l->wakeupq, l