/*

* net/tipc/node.c: TIPC node management routines

*

* Copyright (c) 2000-2006, 2012-2016, Ericsson AB

* Copyright (c) 2005-2006, 2010-2014, 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 "node.h"

#include "name_distr.h"

#include "socket.h"

#include "bcast.h"

#include "monitor.h"

#include "discover.h"

#include "netlink.h"

#include "trace.h"

#include "crypto.h"

#define INVALID_NODE_SIG 0x10000

#define NODE_CLEANUP_AFTER 300000

/* Flags used to take different actions according to flag type

* TIPC_NOTIFY_NODE_DOWN: notify node is down

* TIPC_NOTIFY_NODE_UP: notify node is up

* TIPC_DISTRIBUTE_NAME: publish or withdraw link state name type

*/

enum {

TIPC_NOTIFY_NODE_DOWN = (1 << 3),

TIPC_NOTIFY_NODE_UP = (1 << 4),

TIPC_NOTIFY_LINK_UP = (1 << 6),

TIPC_NOTIFY_LINK_DOWN = (1 << 7)

};

struct tipc_link_entry {

struct tipc_link *link;

spinlock_t lock; /* per link */

u32 mtu;

struct sk_buff_head inputq;

struct tipc_media_addr maddr;

};

struct tipc_bclink_entry {

struct tipc_link *link;

struct sk_buff_head inputq1;

struct sk_buff_head arrvq;

struct sk_buff_head inputq2;

struct sk_buff_head namedq;

u16 named_rcv_nxt;

bool named_open;

};

/**

* struct tipc_node - TIPC node structure

* @addr: network address of node

* @kref: reference counter to node object

* @lock: rwlock governing access to structure

* @net: the applicable net namespace

* @hash: links to adjacent nodes in unsorted hash chain

* @active_links: bearer ids of active links, used as index into links[] array

* @links: array containing references to all links to node

* @bc_entry: broadcast link entry

* @action_flags: bit mask of different types of node actions

* @state: connectivity state vs peer node

* @preliminary: a preliminary node or not

* @failover_sent: failover sent or not

* @sync_point: sequence number where synch/failover is finished

* @list: links to adjacent nodes in sorted list of cluster's nodes

* @working_links: number of working links to node (both active and standby)

* @link_cnt: number of links to node

* @capabilities: bitmap, indicating peer node's functional capabilities

* @signature: node instance identifier

* @link_id: local and remote bearer ids of changing link, if any

* @peer_id: 128-bit ID of peer

* @peer_id_string: ID string of peer

* @publ_list: list of publications

* @conn_sks: list of connections (FIXME)

* @timer: node's keepalive timer

* @keepalive_intv: keepalive interval in milliseconds

* @rcu: rcu struct for tipc_node

* @delete_at: indicates the time for deleting a down node

* @peer_net: peer's net namespace

* @peer_hash_mix: hash for this peer (FIXME)

* @crypto_rx: RX crypto handler

*/

struct tipc_node {

u32 addr;

struct kref kref;

rwlock_t lock;

struct net *net;

struct hlist_node hash;

int active_links[2];

struct tipc_link_entry links[MAX_BEARERS];

struct tipc_bclink_entry bc_entry;

int action_flags;

struct list_head list;

int state;

bool preliminary;

bool failover_sent;

u16 sync_point;

int link_cnt;

u16 working_links;

u16 capabilities;

u32 signature;

u32 link_id;

u8 peer_id[16];

char peer_id_string[NODE_ID_STR_LEN];

struct list_head publ_list;

struct list_head conn_sks;

unsigned long keepalive_intv;

struct timer_list timer;

struct rcu_head rcu;

unsigned long delete_at;

struct net *peer_net;

u32 peer_hash_mix;

#ifdef CONFIG_TIPC_CRYPTO

struct tipc_crypto *crypto_rx;

#endif

};

/* Node FSM states and events:

*/

enum {

SELF_DOWN_PEER_DOWN = 0xdd,

SELF_UP_PEER_UP = 0xaa,

SELF_DOWN_PEER_LEAVING = 0xd1,

SELF_UP_PEER_COMING = 0xac,

SELF_COMING_PEER_UP = 0xca,

SELF_LEAVING_PEER_DOWN = 0x1d,

NODE_FAILINGOVER = 0xf0,

NODE_SYNCHING = 0xcc

};

enum {

SELF_ESTABL_CONTACT_EVT = 0xece,

SELF_LOST_CONTACT_EVT = 0x1ce,

PEER_ESTABL_CONTACT_EVT = 0x9ece,

PEER_LOST_CONTACT_EVT = 0x91ce,

NODE_FAILOVER_BEGIN_EVT = 0xfbe,

NODE_FAILOVER_END_EVT = 0xfee,

NODE_SYNCH_BEGIN_EVT = 0xcbe,

NODE_SYNCH_END_EVT = 0xcee

};

static void __tipc_node_link_down(struct tipc_node *n, int *bearer_id,

struct sk_buff_head *xmitq,

struct tipc_media_addr **maddr);

static void tipc_node_link_down(struct tipc_node *n, int bearer_id,

bool delete);

static void node_lost_contact(struct tipc_node *n, struct sk_buff_head *inputq);

static void tipc_node_delete(struct tipc_node *node);

static void tipc_node_timeout(struct timer_list *t);

static void tipc_node_fsm_evt(struct tipc_node *n, int evt);

static struct tipc_node *tipc_node_find(struct net *net, u32 addr);

static struct tipc_node *tipc_node_find_by_id(struct net *net, u8 *id);

static bool node_is_up(struct tipc_node *n);

static void tipc_node_delete_from_list(struct tipc_node *node);

struct tipc_sock_conn {

u32 port;

u32 peer_port;

u32 peer_node;

struct list_head list;

};

static struct tipc_link *node_active_link(struct tipc_node *n, int sel)

{

int bearer_id = n->active_links[sel & 1];

if (unlikely(bearer_id == INVALID_BEARER_ID))

return NULL;

return n->links[bearer_id].link;

}

int tipc_node_get_mtu(struct net *net, u32 addr, u32 sel, bool connected)

{

struct tipc_node *n;

int bearer_id;

unsigned int mtu = MAX_MSG_SIZE;

n = tipc_node_find(net, addr);

if (unlikely(!n))

return mtu;

/* Allow MAX_MSG_SIZE when building connection oriented message

* if they are in the same core network

*/

if (n->peer_net && connected) {

tipc_node_put(n);

return mtu;

}

bearer_id = n->active_links[sel & 1];

if (likely(bearer_id != INVALID_BEARER_ID))

mtu = n->links[bearer_id].mtu;

tipc_node_put(n);

return mtu;

}

bool tipc_node_get_id(struct net *net, u32 addr, u8 *id)

{

u8 *own_id = tipc_own_id(net);

struct tipc_node *n;

if (!own_id)

return true;

if (addr == tipc_own_addr(net)) {

memcpy(id, own_id, TIPC_NODEID_LEN);

return true;

}

n = tipc_node_find(net, addr);

if (!n)

return false;

memcpy(id, &n->peer_id, TIPC_NODEID_LEN);

tipc_node_put(n);

return true;

}

u16 tipc_node_get_capabilities(struct net *net, u32 addr)

{

struct tipc_node *n;

u16 caps;

n = tipc_node_find(net, addr);

if (unlikely(!n))

return TIPC_NODE_CAPABILITIES;

caps = n->capabilities;

tipc_node_put(n);

return caps;

}

u32 tipc_node_get_addr(struct tipc_node *node)

{

return (node) ? node->addr : 0;

}

char *tipc_node_get_id_str(struct tipc_node *node)

{

return node->peer_id_string;

}

#ifdef CONFIG_TIPC_CRYPTO

/**

* tipc_node_crypto_rx - Retrieve crypto RX handle from node

* @__n: target tipc_node

* Note: node ref counter must be held first!

*/

struct tipc_crypto *tipc_node_crypto_rx(struct tipc_node *__n)

{

return (__n) ? __n->crypto_rx : NULL;

}

struct tipc_crypto *tipc_node_crypto_rx_by_list(struct list_head *pos)

{

return container_of(pos, struct tipc_node, list)->crypto_rx;

}

struct tipc_crypto *tipc_node_crypto_rx_by_addr(struct net *net, u32 addr)

{

struct tipc_node *n;

n = tipc_node_find(net, addr);

return (n) ? n->crypto_rx : NULL;

}

#endif

static void tipc_node_free(struct rcu_head *rp)

{

struct tipc_node *n = container_of(rp, struct tipc_node, rcu);

#ifdef CONFIG_TIPC_CRYPTO

tipc_crypto_stop(&n->crypto_rx);

#endif

kfree(n);

}

static void tipc_node_kref_release(struct kref *kref)

{

struct tipc_node *n = container_of(kref, struct tipc_node, kref);

kfree(n->bc_entry.link);

call_rcu(&n->rcu, tipc_node_free);

}

void tipc_node_put(struct tipc_node *node)

{

kref_put(&node->kref, tipc_node_kref_release);

}

void tipc_node_get(struct tipc_node *node)

{

kref_get(&node->kref);

}

/*

* tipc_node_find - locate specified node object, if it exists

*/

static struct tipc_node *tipc_node_find(struct net *net, u32 addr)

{

struct tipc_net *tn = tipc_net(net);

struct tipc_node *node;

unsigned int thash = tipc_hashfn(addr);

rcu_read_lock();

hlist_for_each_entry_rcu(node, &tn->node_htable[thash], hash) {

if (node->addr != addr || node->preliminary)

continue;

if (!kref_get_unless_zero(&node->kref))

node = NULL;

break;

}

rcu_read_unlock();

return node;

}

/* tipc_node_find_by_id - locate specified node object by its 128-bit id

* Note: this function is called only when a discovery request failed

* to find the node by its 32-bit id, and is not time critical

*/

static struct tipc_node *tipc_node_find_by_id(struct net *net, u8 *id)

{

struct tipc_net *tn = tipc_net(net);

struct tipc_node *n;

bool found = false;

rcu_read_lock();

list_for_each_entry_rcu(n, &tn->node_list, list) {

read_lock_bh(&n->lock);

if (!memcmp(id, n->peer_id, 16) &&

kref_get_unless_zero(&n->kref))

found = true;

read_unlock_bh(&n->lock);

if (found)

break;

}

rcu_read_unlock();

return found ? n : NULL;

}

static void tipc_node_read_lock(struct tipc_node *n)

__acquires(n->lock)

{

read_lock_bh(&n->lock);

}

static void tipc_node_read_unlock(struct tipc_node *n)

__releases(n->lock)

{

read_unlock_bh(&n->lock);

}

static void tipc_node_write_lock(struct tipc_node *n)

__acquires(n->lock)

{

write_lock_bh(&n->lock);

}

static void tipc_node_write_unlock_fast(struct tipc_node *n)

__releases(n->lock)

{

write_unlock_bh(&n->lock);

}

static void tipc_node_write_unlock(struct tipc_node *n)

__releases(n->lock)

{

struct tipc_socket_addr sk;

struct net *net = n->net;

u32 flags = n->action_flags;

struct list_head *publ_list;

struct tipc_uaddr ua;

u32 bearer_id, node;

if (likely(!flags)) {

write_unlock_bh(&n->lock);

return;

}

tipc_uaddr(&ua, TIPC_SERVICE_RANGE, TIPC_NODE_SCOPE,

TIPC_LINK_STATE, n->addr, n->addr);

sk.ref = n->link_id;

sk.node = tipc_own_addr(net);

node = n->addr;

bearer_id = n->link_id & 0xffff;

publ_list = &n->publ_list;

n->action_flags &= ~(TIPC_NOTIFY_NODE_DOWN | TIPC_NOTIFY_NODE_UP |

TIPC_NOTIFY_LINK_DOWN | TIPC_NOTIFY_LINK_UP);

write_unlock_bh(&n->lock);

if (flags & TIPC_NOTIFY_NODE_DOWN)

tipc_publ_notify(net, publ_list, node, n->capabilities);

if (flags & TIPC_NOTIFY_NODE_UP)

tipc_named_node_up(net, node, n->capabilities);

if (flags & TIPC_NOTIFY_LINK_UP) {

tipc_mon_peer_up(net, node, bearer_id);

tipc_nametbl_publish(net, &ua, &sk, sk.ref);

}

if (flags & TIPC_NOTIFY_LINK_DOWN) {

tipc_mon_peer_down(net, node, bearer_id);

tipc_nametbl_withdraw(net, &ua, &sk, sk.ref);

}

}

static void tipc_node_assign_peer_net(struct tipc_node *n, u32 hash_mixes)

{

int net_id = tipc_netid(n->net);

struct tipc_net *tn_peer;

struct net *tmp;

u32 hash_chk;

if (n->peer_net)

return;

for_each_net_rcu(tmp) {

tn_peer = tipc_net(tmp);

if (!tn_peer)

continue;

/* Integrity checking whether node exists in namespace or not */

if (tn_peer->net_id != net_id)

continue;

if (memcmp(n->peer_id, tn_peer->node_id, NODE_ID_LEN))

continue;

hash_chk = tipc_net_hash_mixes(tmp, tn_peer->random);

if (hash_mixes ^ hash_chk)

continue;

n->peer_net = tmp;

n->peer_hash_mix = hash_mixes;

break;

}

}

struct tipc_node *tipc_node_create(struct net *net, u32 addr, u8 *peer_id,

u16 capabilities, u32 hash_mixes,

bool preliminary)

{

struct tipc_net *tn = net_generic(net, tipc_net_id);

struct tipc_link *l, *snd_l = tipc_bc_sndlink(net);

struct tipc_node *n, *temp_node;

unsigned long intv;

int bearer_id;

int i;

spin_lock_bh(&tn->node_list_lock);

n = tipc_node_find(net, addr) ?:

tipc_node_find_by_id(net, peer_id);

if (n) {

if (!n->preliminary)

goto update;

if (preliminary)

goto exit;

/* A preliminary node becomes "real" now, refresh its data */

tipc_node_write_lock(n);

if (!tipc_link_bc_create(net, tipc_own_addr(net), addr, peer_id, U16_MAX,

tipc_link_min_win(snd_l), tipc_link_max_win(snd_l),

n->capabilities, &n->bc_entry.inputq1,

&n->bc_entry.namedq, snd_l, &n->bc_entry.link)) {

pr_warn("Broadcast rcv link refresh failed, no memory\n");

tipc_node_write_unlock_fast(n);

tipc_node_put(n);

n = NULL;

goto exit;

}

n->preliminary = false;

n->addr = addr;

hlist_del_rcu(&n->hash);

hlist_add_head_rcu(&n->hash,

&tn->node_htable[tipc_hashfn(addr)]);

list_del_rcu(&n->list);

list_for_each_entry_rcu(temp_node, &tn->node_list, list) {

if (n->addr < temp_node->addr)

break;

}

list_add_tail_rcu(&n->list, &temp_node->list);

tipc_node_write_unlock_fast(n);

update:

if (n->peer_hash_mix ^ hash_mixes)

tipc_node_assign_peer_net(n, hash_mixes);

if (n->capabilities == capabilities)

goto exit;

/* Same node may come back with new capabilities */

tipc_node_write_lock(n);

n->capabilities = capabilities;

for (bearer_id = 0; bearer_id < MAX_BEARERS; bearer_id++) {

l = n->links[bearer_id].link;

if (l)

tipc_link_update_caps(l, capabilities);

}

tipc_node_write_unlock_fast(n);

/* Calculate cluster capabilities */

tn->capabilities = TIPC_NODE_CAPABILITIES;

list_for_each_entry_rcu(temp_node, &tn->node_list, list) {

tn->capabilities &= temp_node->capabilities;

}

tipc_bcast_toggle_rcast(net,

(tn->capabilities & TIPC_BCAST_RCAST));

goto exit;

}

n = kzalloc_obj(*n, GFP_ATOMIC);

if (!n) {

pr_warn("Node creation failed, no memory\n");

goto exit;

}

tipc_nodeid2string(n->peer_id_string, peer_id);

#ifdef CONFIG_TIPC_CRYPTO

if (unlikely(tipc_crypto_start(&n->crypto_rx, net, n))) {

pr_warn("Failed to start crypto RX(%s)!\n", n->peer_id_string);

kfree(n);

n = NULL;

goto exit;

}

#endif

n->addr = addr;

n->preliminary = preliminary;

memcpy(&n->peer_id, peer_id, 16);

n->net = net;

n->peer_net = NULL;

n->peer_hash_mix = 0;

/* Assign kernel local namespace if exists */

tipc_node_assign_peer_net(n, hash_mixes);

n->capabilities = capabilities;

kref_init(&n->kref);

rwlock_init(&n->lock);

INIT_HLIST_NODE(&n->hash);

INIT_LIST_HEAD(&n->list);

INIT_LIST_HEAD(&n->publ_list);

INIT_LIST_HEAD(&n->conn_sks);

skb_queue_head_init(&n->bc_entry.namedq);

skb_queue_head_init(&n->bc_entry.inputq1);

__skb_queue_head_init(&n->bc_entry.arrvq);

skb_queue_head_init(&n->bc_entry.inputq2);

for (i = 0; i < MAX_BEARERS; i++)

spin_lock_init(&n->links[i].lock);

n->state = SELF_DOWN_PEER_LEAVING;

n->delete_at = jiffies + msecs_to_jiffies(NODE_CLEANUP_AFTER);

n->signature = INVALID_NODE_SIG;

n->active_links[0] = INVALID_BEARER_ID;

n->active_links[1] = INVALID_BEARER_ID;

if (!preliminary &&

!tipc_link_bc_create(net, tipc_own_addr(net), addr, peer_id, U16_MAX,

tipc_link_min_win(snd_l), tipc_link_max_win(snd_l),

n->capabilities, &n->bc_entry.inputq1,

&n->bc_entry.namedq, snd_l, &n->bc_entry.link)) {

pr_warn("Broadcast rcv link creation failed, no memory\n");

tipc_node_put(n);

n = NULL;

goto exit;

}

tipc_node_get(n);

timer_setup(&n->timer, tipc_node_timeout, 0);

/* Start a slow timer anyway, crypto needs it */

n->keepalive_intv = 10000;

intv = jiffies + msecs_to_jiffies(n->keepalive_intv);

if (!mod_timer(&n->timer, intv))

tipc_node_get(n);

hlist_add_head_rcu(&n->hash, &tn->node_htable[tipc_hashfn(addr)]);

list_for_each_entry_rcu(temp_node, &tn->node_list, list) {

if (n->addr < temp_node->addr)

break;

}

list_add_tail_rcu(&n->list, &temp_node->list);

/* Calculate cluster capabilities */

tn->capabilities = TIPC_NODE_CAPABILITIES;

list_for_each_entry_rcu(temp_node, &tn->node_list, list) {

tn->capabilities &= temp_node->capabilities;

}

tipc_bcast_toggle_rcast(net, (tn->capabilities & TIPC_BCAST_RCAST));

trace_tipc_node_create(n, true, " ");

exit:

spin_unlock_bh(&tn->node_list_lock);

return n;

}

static void tipc_node_calculate_timer(struct tipc_node *n, struct tipc_link *l)

{

unsigned long tol = tipc_link_tolerance(l);

unsigned long intv = ((tol / 4) > 500) ? 500 : tol / 4;

/* Link with lowest tolerance determines timer interval */

if (intv < n->keepalive_intv)

n->keepalive_intv = intv;

/* Ensure link's abort limit corresponds to current tolerance */

tipc_link_set_abort_limit(l, tol / n->keepalive_intv);

}

static void tipc_node_delete_from_list(struct tipc_node *node)

{

#ifdef CONFIG_TIPC_CRYPTO

tipc_crypto_key_flush(node->crypto_rx);

#endif

list_del_rcu(&node->list);

hlist_del_rcu(&node->hash);

tipc_node_put(node);

}

static void tipc_node_delete(struct tipc_node *node)

{

trace_tipc_node_delete(node, true, " ");

tipc_node_delete_from_list(node);

timer_delete_sync(&node->timer);

tipc_node_put(node);

}

void tipc_node_stop(struct net *net)

{

struct tipc_net *tn = tipc_net(net);

struct tipc_node *node, *t_node;

spin_lock_bh(&tn->node_list_lock);

list_for_each_entry_safe(node, t_node, &tn->node_list, list)

tipc_node_delete(node);

spin_unlock_bh(&tn->node_list_lock);

}

void tipc_node_subscribe(struct net *net, struct list_head *subscr, u32 addr)

{

struct tipc_node *n;

if (in_own_node(net, addr))

return;

n = tipc_node_find(net, addr);

if (!n) {

pr_warn("Node subscribe rejected, unknown node 0x%x\n", addr);

return;

}

tipc_node_write_lock(n);

list_add_tail(subscr, &n->publ_list);

tipc_node_write_unlock_fast(n);

tipc_node_put(n);

}

void tipc_node_unsubscribe(struct net *net, struct list_head *subscr, u32 addr)

{

struct tipc_node *n;

if (in_own_node(net, addr))

return;

n = tipc_node_find(net, addr);

if (!n) {

pr_warn("Node unsubscribe rejected, unknown node 0x%x\n", addr);

return;

}

tipc_node_write_lock(n);

list_del_init(subscr);

tipc_node_write_unlock_fast(n);

tipc_node_put(n);

}

int tipc_node_add_conn(struct net *net, u32 dnode, u32 port, u32 peer_port)

{

struct tipc_node *node;

struct tipc_sock_conn *conn;

int err = 0;

if (in_own_node(net, dnode))

return 0;

node = tipc_node_find(net, dnode);

if (!node) {

pr_warn("Connecting sock to node 0x%x failed\n", dnode);

return -EHOSTUNREACH;

}

conn = kmalloc_obj(*conn, GFP_ATOMIC);

if (!conn) {

err = -EHOSTUNREACH;

goto exit;

}

conn->peer_node = dnode;

conn->port = port;

conn->peer_port = peer_port;

tipc_node_write_lock(node);

list_add_tail(&conn->list, &node->conn_sks);

tipc_node_write_unlock(node);

exit:

tipc_node_put(node);

return err;

}

void tipc_node_remove_conn(struct net *net, u32 dnode, u32 port)

{

struct tipc_node *node;

struct tipc_sock_conn *conn, *safe;

if (in_own_node(net, dnode))

return;

node = tipc_node_find(net, dnode);

if (!node)

return;

tipc_node_write_lock(node);

list_for_each_entry_safe(conn, safe, &node->conn_sks, list) {

if (port != conn->port)

continue;

list_del(&conn->list);

kfree(conn);

}

tipc_node_write_unlock(node);

tipc_node_put(node);

}

static void tipc_node_clear_links(struct tipc_node *node)

{

int i;

for (i = 0; i < MAX_BEARERS; i++) {

struct tipc_link_entry *le = &node->links[i];

if (le->link) {

kfree(le->link);

le->link = NULL;

node->link_cnt--;

}

}

}

/* tipc_node_cleanup - delete nodes that does not

* have active links for NODE_CLEANUP_AFTER time

*/

static bool tipc_node_cleanup(struct tipc_node *peer)

{

struct tipc_node *temp_node;

struct tipc_net *tn = tipc_net(peer->net);

bool deleted = false;

/* If lock held by tipc_node_stop() the node will be deleted anyway */

if (!spin_trylock_bh(&tn->node_list_lock))

return false;

tipc_node_write_lock(peer);

if (!node_is_up(peer) && time_after(jiffies, peer->delete_at)) {

tipc_node_clear_links(peer);

tipc_node_delete_from_list(peer);

deleted = true;

}

tipc_node_write_unlock(peer);

if (!deleted) {

spin_unlock_bh(&tn->node_list_lock);

return deleted;

}

/* Calculate cluster capabilities */

tn->capabilities = TIPC_NODE_CAPABILITIES;

list_for_each_entry_rcu(temp_node, &tn->node_list, list) {

tn->capabilities &= temp_node->capabilities;

}

tipc_bcast_toggle_rcast(peer->net,

(tn->capabilities & TIPC_BCAST_RCAST));

spin_unlock_bh(&tn->node_list_lock);

return deleted;

}

/* tipc_node_timeout - handle expiration of node timer

*/

static void tipc_node_timeout(struct timer_list *t)

{

struct tipc_node *n = timer_container_of(n, t, timer);

struct tipc_link_entry *le;

struct sk_buff_head xmitq;

int remains = n->link_cnt;

int bearer_id;

int rc = 0;

trace_tipc_node_timeout(n, false, " ");

if (!node_is_up(n) && tipc_node_cleanup(n)) {

/*Removing the reference of Timer*/

tipc_node_put(n);

return;

}

#ifdef CONFIG_TIPC_CRYPTO

/* Take any crypto key related actions first */

tipc_crypto_timeout(n->crypto_rx);

#endif

__skb_queue_head_init(&xmitq);

/* Initial node interval to value larger (10 seconds), then it will be

* recalculated with link lowest tolerance

*/

tipc_node_read_lock(n);

n->keepalive_intv = 10000;

tipc_node_read_unlock(n);

for (bearer_id = 0; remains && (bearer_id < MAX_BEARERS); bearer_id++) {

tipc_node_read_lock(n);

le = &n->links[bearer_id];

if (le->link) {

spin_lock_bh(&le->lock);

/* Link tolerance may change asynchronously: */

tipc_node_calculate_timer(n, le->link);

rc = tipc_link_timeout(le->link, &xmitq);

spin_unlock_bh(&le->lock);

remains--;

}

tipc_node_read_unlock(n);

tipc_bearer_xmit(n->net, bearer_id, &xmitq, &le->maddr, n);

if (rc & TIPC_LINK_DOWN_EVT)

tipc_node_link_down(n, bearer_id, false);

}

mod_timer(&n->timer, jiffies + msecs_to_jiffies(n->keepalive_intv));

}

/**

* __tipc_node_link_up - handle addition of link

* @n: target tipc_node

* @bearer_id: id of the bearer

* @xmitq: queue for messages to be xmited on

* Node lock must be held by caller

* Link becomes active (alone or shared) or standby, depending on its priority.

*/

static void __tipc_node_link_up(struct tipc_node *n, int bearer_id,

struct sk_buff_head *xmitq)

{

int *slot0 = &n->active_links[0];

int *slot1 = &n->active_links[1];

struct tipc_link *ol = node_active_link(n, 0);

struct tipc_link *nl = n->links[bearer_id].link;

if (!nl || tipc_link_is_up(nl))

return;

tipc_link_fsm_evt(nl, LINK_ESTABLISH_EVT);

if (!tipc_link_is_up(nl))

return;

n->working_links++;

n->action_flags |= TIPC_NOTIFY_LINK_UP;

n->link_id = tipc_link_id(nl);

/* Leave room for tunnel header when returning 'mtu' to users: */

n->links[bearer_id].mtu = tipc_link_mss(nl);

tipc_bearer_add_dest(n->net, bearer_id, n->addr);

tipc_bcast_inc_bearer_dst_cnt(n->net, bearer_id);

pr_debug("Established link <%s> on network plane %c\n",

tipc_link_name(nl), tipc_link_plane(nl));

trace_tipc_node_link_up(n, true, " ");

/* Ensure that a STATE message goes first */

tipc_link_build_state_msg(nl, xmitq);

/* First link? => give it both slots */

if (!ol) {

*slot0 = bearer_id;

*slot1 = bearer_id;

tipc_node_fsm_evt(n, SELF_ESTABL_CONTACT_EVT);

n->action_flags |= TIPC_NOTIFY_NODE_UP;

tipc_link_set_active(nl, true);

tipc_bcast_add_peer(n->net, nl, xmitq);

return;

}

/* Second link => redistribute slots */

if (tipc_link_prio(nl) > tipc_link_prio(ol)) {

pr_debug("Old link <%s> becomes standby\n", tipc_link_name(ol));

*slot0 = bearer_id;

*slot1 = bearer_id;

tipc_link_set_active(nl, true);

tipc_link_set_active(ol, false);

} else if (tipc_link_prio(nl) == tipc_link_prio(ol)) {

tipc_link_set_active(nl, true);

*slot1 = bearer_id;

} else {

pr_debug("New link <%s> is standby\n", tipc_link_name(nl));

}

/* Prepare synchronization with first link */

tipc_link_tnl_prepare(ol, nl, SYNCH_MSG, xmitq);

}

/**

* tipc_node_link_up - handle addition of link

* @n: target tipc_node

* @bearer_id: id of the bearer

* @xmitq: queue for messages to be xmited on

*

* Link becomes active (alone or shared) or standby, depending on its priority.

*/

static void tipc_node_link_up(struct tipc_node *n, int bearer_id,

struct sk_buff_head *xmitq)

{

struct tipc_media_addr *maddr;

tipc_node_write_lock(n);

__tipc_node_link_up(n, bearer_id, xmitq);

maddr = &n->links[bearer_id].maddr;

tipc_bearer_xmit(n->net, bearer_id, xmitq, maddr, n);

tipc_node_write_unlock(n);

}

/**

* tipc_node_link_failover() - start failover in case "half-failover"

*

* This function is only called in a very special situation where link

* failover can be already started on peer node but not on this node.

* This can happen when e.g.::

*

* 1. Both links <1A-2A>, <1B-2B> down

* 2. Link endpoint 2A up, but 1A still down (e.g. due to network

* disturbance, wrong session, etc.)

* 3. Link <1B-2B> up

* 4. Link endpoint 2A down (e.g. due to link tolerance timeout)

* 5. Node 2 starts failover onto link <1B-2B>

*

* ==> Node 1 does never start link/node failover!

*

* @n: tipc node structure

* @l: link peer endpoint failingover (- can be NULL)

* @tnl: tunnel link

* @xmitq: queue for messages to be xmited on tnl link later

*/

static void tipc_node_link_failover(struct tipc_node *n, struct tipc_link *l,

struct tipc_link *tnl,

struct sk_buff_head *xmitq)

{

/* Avoid to be "self-failover" that can never end */

if (!tipc_link_is_up(tnl))

return;

/* Don't rush, failure link may be in the process of resetting */

if (l && !tipc_link_is_reset(l))

return;

tipc_link_fsm_evt(tnl, LINK_SYNCH_END_EVT);

tipc_node_fsm_evt(n, NODE_SYNCH_END_EVT);

n->sync_point = tipc_link_rcv_nxt(tnl) + (U16_MAX / 2 - 1);

tipc_link_failover_prepare(l, tnl, xmitq);

if (l)

tipc_link_fsm_evt(l, LINK_FAILOVER_BEGIN_EVT);

tipc_node_fsm_evt(n, NODE_FAILOVER_BEGIN_EVT);

}

/**

* __tipc_node_link_down - handle loss of link

* @n: target tipc_node

* @bearer_id: id of the bearer

* @xmitq: queue for messages to be xmited on

* @maddr: output media address of the bearer

*/

static void __tipc_node_link_down(struct tipc_node *n, int *bearer_id,

struct sk_buff_head *xmitq,

struct tipc_media_addr **maddr)

{

struct tipc_link_entry *le = &n->links[*bearer_id];

int *slot0 = &n->active_links[0];

int *slot1 = &n->active_links[1];

int i, highest = 0, prio;

struct tipc_link *l, *_l, *tnl;

l = n->links[*bearer_id].link;

if (!l || tipc_link_is_reset(l))

return;