/* * net/tipc/monitor.c * * Copyright (c) 2016, Ericsson AB * 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 <net/genetlink.h>#include "core.h"#include "addr.h"#include "monitor.h"#include "bearer.h" #define MAX_MON_DOMAIN       64#define MON_TIMEOUT          120000#define MAX_PEER_DOWN_EVENTS 4 /* struct tipc_mon_domain: domain record to be transferred between peers * @len: actual size of domain record * @gen: current generation of sender's domain * @ack_gen: most recent generation of self's domain acked by peer * @member_cnt: number of domain member nodes described in this record * @up_map: bit map indicating which of the members the sender considers up * @members: identity of the domain members */struct tipc_mon_domain {	u16 len;	u16 gen;	u16 ack_gen;	u16 member_cnt;	u64 up_map;	u32 members[MAX_MON_DOMAIN];}; /* struct tipc_peer: state of a peer node and its domain * @addr: tipc node identity of peer * @head_map: shows which other nodes currently consider peer 'up' * @domain: most recent domain record from peer * @hash: position in hashed lookup list * @list: position in linked list, in circular ascending order by 'addr' * @applied: number of reported domain members applied on this monitor list * @is_up: peer is up as seen from this node * @is_head: peer is assigned domain head as seen from this node * @is_local: peer is in local domain and should be continuously monitored * @down_cnt: - numbers of other peers which have reported this on lost */struct tipc_peer {	u32 addr;	struct tipc_mon_domain *domain;	struct hlist_node hash;	struct list_head list;	u8 applied;	u8 down_cnt;	bool is_up;	bool is_head;	bool is_local;}; struct tipc_monitor {	struct hlist_head peers[NODE_HTABLE_SIZE];	int peer_cnt;	struct tipc_peer *self;	rwlock_t lock;	struct tipc_mon_domain cache;	u16 list_gen;	u16 dom_gen;	struct net *net;	struct timer_list timer;	unsigned long timer_intv;}; static struct tipc_monitor *tipc_monitor(struct net *net, int bearer_id){	return tipc_net(net)->monitors[bearer_id];} const int tipc_max_domain_size = sizeof(struct tipc_mon_domain); static inline u16 mon_cpu_to_le16(u16 val){	return (__force __u16)htons(val);} static inline u32 mon_cpu_to_le32(u32 val){	return (__force __u32)htonl(val);} static inline u64 mon_cpu_to_le64(u64 val){	return (__force __u64)cpu_to_be64(val);} static inline u16 mon_le16_to_cpu(u16 val){	return ntohs((__force __be16)val);} static inline u32 mon_le32_to_cpu(u32 val){	return ntohl((__force __be32)val);} static inline u64 mon_le64_to_cpu(u64 val){	return be64_to_cpu((__force __be64)val);} /* dom_rec_len(): actual length of domain record for transport */static int dom_rec_len(struct tipc_mon_domain *dom, u16 mcnt){	return (offsetof(struct tipc_mon_domain, members)) + (mcnt * sizeof(u32));} /* dom_size() : calculate size of own domain based on number of peers */static int dom_size(int peers){	int i = 0; 	while ((i * i) < peers)		i++;	return min(i, MAX_MON_DOMAIN);} static void map_set(u64 *up_map, int i, unsigned int v){	*up_map &= ~(1ULL << i);	*up_map |= ((u64)v << i);} static int map_get(u64 up_map, int i){	return (up_map & (1ULL << i)) >> i;} static struct tipc_peer *peer_prev(struct tipc_peer *peer){	return list_last_entry(&peer->list, struct tipc_peer, list);} static struct tipc_peer *peer_nxt(struct tipc_peer *peer){	return list_first_entry(&peer->list, struct tipc_peer, list);} static struct tipc_peer *peer_head(struct tipc_peer *peer){	while (!peer->is_head)		peer = peer_prev(peer);	return peer;} static struct tipc_peer *get_peer(struct tipc_monitor *mon, u32 addr){	struct tipc_peer *peer;	unsigned int thash = tipc_hashfn(addr); 	hlist_for_each_entry(peer, &mon->peers[thash], hash) {		if (peer->addr == addr)			return peer;	}	return NULL;} static struct tipc_peer *get_self(struct net *net, int bearer_id){	struct tipc_monitor *mon = tipc_monitor(net, bearer_id); 	return mon->self;} static inline bool tipc_mon_is_active(struct net *net, struct tipc_monitor *mon){	struct tipc_net *tn = tipc_net(net); 	return mon->peer_cnt > tn->mon_threshold;} /* mon_identify_lost_members() : - identify amd mark potentially lost members */static void mon_identify_lost_members(struct tipc_peer *peer,				      struct tipc_mon_domain *dom_bef,				      int applied_bef){	struct tipc_peer *member = peer;	struct tipc_mon_domain *dom_aft = peer->domain;	int applied_aft = peer->applied;	int i; 	for (i = 0; i < applied_bef; i++) {		member = peer_nxt(member); 		/* Do nothing if self or peer already see member as down */		if (!member->is_up || !map_get(dom_bef->up_map, i))			continue; 		/* Loss of local node must be detected by active probing */		if (member->is_local)			continue; 		/* Start probing if member was removed from applied domain */		if (!applied_aft || (applied_aft < i)) {			member->down_cnt = 1;			continue;		} 		/* Member loss is confirmed if it is still in applied domain */		if (!map_get(dom_aft->up_map, i))			member->down_cnt++;	}} /* mon_apply_domain() : match a peer's domain record against monitor list */static void mon_apply_domain(struct tipc_monitor *mon,			     struct tipc_peer *peer){	struct tipc_mon_domain *dom = peer->domain;	struct tipc_peer *member;	u32 addr;	int i; 	if (!dom || !peer->is_up)		return; 	/* Scan across domain members and match against monitor list */	peer->applied = 0;	member = peer_nxt(peer);	for (i = 0; i < dom->member_cnt; i++) {		addr = dom->members[i];		if (addr != member->addr)			return;		peer->applied++;		member = peer_nxt(member);	}} /* mon_update_local_domain() : update after peer addition/removal/up/down */static void mon_update_local_domain(struct tipc_monitor *mon){	struct tipc_peer *self = mon->self;	struct tipc_mon_domain *cache = &mon->cache;	struct tipc_mon_domain *dom = self->domain;	struct tipc_peer *peer = self;	u64 prev_up_map = dom->up_map;	u16 member_cnt, i;	bool diff; 	/* Update local domain size based on current size of cluster */	member_cnt = dom_size(mon->peer_cnt) - 1;	self->applied = member_cnt; 	/* Update native and cached outgoing local domain records */	dom->len = dom_rec_len(dom, member_cnt);	diff = dom->member_cnt != member_cnt;	dom->member_cnt = member_cnt;	for (i = 0; i < member_cnt; i++) {		peer = peer_nxt(peer);		diff |= dom->members[i] != peer->addr;		dom->members[i] = peer->addr;		map_set(&dom->up_map, i, peer->is_up);		cache->members[i] = mon_cpu_to_le32(peer->addr);	}	diff |= dom->up_map != prev_up_map;	if (!diff)		return;	dom->gen = ++mon->dom_gen;	cache->len = mon_cpu_to_le16(dom->len);	cache->gen = mon_cpu_to_le16(dom->gen);	cache->member_cnt = mon_cpu_to_le16(member_cnt);	cache->up_map = mon_cpu_to_le64(dom->up_map);	mon_apply_domain(mon, self);} /* mon_update_neighbors() : update preceding neighbors of added/removed peer */static void mon_update_neighbors(struct tipc_monitor *mon,				 struct tipc_peer *peer){	int dz, i; 	dz = dom_size(mon->peer_cnt);	for (i = 0; i < dz; i++) {		mon_apply_domain(mon, peer);		peer = peer_prev(peer);	}} /* mon_assign_roles() : reassign peer roles after a network change * The monitor list is consistent at this stage; i.e., each peer is monitoring * a set of domain members as matched between domain record and the monitor list */static void mon_assign_roles(struct tipc_monitor *mon, struct tipc_peer *head){	struct tipc_peer *peer = peer_nxt(head);	struct tipc_peer *self = mon->self;	int i = 0; 	for (; peer != self; peer = peer_nxt(peer)) {		peer->is_local = false; 		/* Update domain member */		if (i++ < head->applied) {			peer->is_head = false;			if (head == self)				peer->is_local = true;			continue;		}		/* Assign next domain head */		if (!peer->is_up)			continue;		if (peer->is_head)			break;		head = peer;		head->is_head = true;		i = 0;	}	mon->list_gen++;} void tipc_mon_remove_peer(struct net *net, u32 addr, int bearer_id){	struct tipc_monitor *mon = tipc_monitor(net, bearer_id);	struct tipc_peer *self;	struct tipc_peer *peer, *prev, *head; 	if (!mon)		return; 	self = get_self(net, bearer_id);	write_lock_bh(&mon->lock);	peer = get_peer(mon, addr);	if (!peer)		goto exit;	prev = peer_prev(peer);	list_del(&peer->list);	hlist_del(&peer->hash);	kfree(peer->domain);	kfree(peer);	mon->peer_cnt--;	head = peer_head(prev);	if (head == self)		mon_update_local_domain(mon);	mon_update_neighbors(mon, prev); 	/* Revert to full-mesh monitoring if we reach threshold */	if (!tipc_mon_is_active(net, mon)) {		list_for_each_entry(peer, &self->list, list) {			kfree(peer->domain);			peer->domain = NULL;			peer->applied = 0;		}	}	mon_assign_roles(mon, head);exit:	write_unlock_bh(&mon->lock);} static bool tipc_mon_add_peer(struct tipc_monitor *mon, u32 addr,			      struct tipc_peer **peer){	struct tipc_peer *self = mon->self;	struct tipc_peer *cur, *prev, *p; 	p = kzalloc_obj(*p, GFP_ATOMIC);	*peer = p;	if (!p)		return false;	p->addr = addr; 	/* Add new peer to lookup list */	INIT_LIST_HEAD(&p->list);	hlist_add_head(&p->hash, &mon->peers[tipc_hashfn(addr)]); 	/* Sort new peer into iterator list, in ascending circular order */	prev = self;	list_for_each_entry(cur, &self->list, list) {		if ((addr > prev->addr) && (addr < cur->addr))			break;		if (((addr < cur->addr) || (addr > prev->addr)) &&		    (prev->addr > cur->addr))			break;		prev = cur;	}	list_add_tail(&p->list, &cur->list);	mon->peer_cnt++;	mon_update_neighbors(mon, p);	return true;} void tipc_mon_peer_up(struct net *net, u32 addr, int bearer_id){	struct tipc_monitor *mon = tipc_monitor(net, bearer_id);	struct tipc_peer *self = get_self(net, bearer_id);	struct tipc_peer *peer, *head; 	write_lock_bh(&mon->lock);	peer = get_peer(mon, addr);	if (!peer && !tipc_mon_add_peer(mon, addr, &peer))		goto exit;	peer->is_up = true;	head = peer_head(peer);	if (head == self)		mon_update_local_domain(mon);	mon_assign_roles(mon, head);exit:	write_unlock_bh(&mon->lock);} void tipc_mon_peer_down(struct net *net, u32 addr, int bearer_id){	struct tipc_monitor *mon = tipc_monitor(net, bearer_id);	struct tipc_peer *self;	struct tipc_peer *peer, *head;	struct tipc_mon_domain *dom;	int applied; 	if (!mon)		return; 	self = get_self(net, bearer_id);	write_lock_bh(&mon->lock);	peer = get_peer(mon, addr);	if (!peer) {		pr_warn("Mon: unknown link %x/%u DOWN\n", addr, bearer_id);		goto exit;	}	applied = peer->applied;	peer->applied = 0;	dom = peer->domain;	peer->domain = NULL;	if (peer->is_head)		mon_identify_lost_members(peer, dom, applied);	kfree(dom);	peer->is_up = false;	peer->is_head = false;	peer->is_local = false;	peer->down_cnt = 0;	head = peer_head(peer);	if (head == self)		mon_update_local_domain(mon);	mon_assign_roles(mon, head);exit:	write_unlock_bh(&mon->lock);} /* tipc_mon_rcv - process monitor domain event message */void tipc_mon_rcv(struct net *net, void *data, u16 dlen, u32 addr,		  struct tipc_mon_state *state, int bearer_id){	struct tipc_monitor *mon = tipc_monitor(net, bearer_id);	struct tipc_mon_domain *arrv_dom = data;	struct tipc_mon_domain dom_bef;	struct tipc_mon_domain *dom;	struct tipc_peer *peer;	u16 new_member_cnt = mon_le16_to_cpu(arrv_dom->member_cnt);	int new_dlen = dom_rec_len(arrv_dom, new_member_cnt);	u16 new_gen = mon_le16_to_cpu(arrv_dom->gen);	u16 acked_gen = mon_le16_to_cpu(arrv_dom->ack_gen);	u16 arrv_dlen = mon_le16_to_cpu(arrv_dom->len);	bool probing = state->probing;	int i, applied_bef; 	state->probing = false; 	/* Sanity check received domain record */	if (new_member_cnt > MAX_MON_DOMAIN)		return;

Lines 1–500 of 875. Load more