xref: /openbmc/linux/net/tipc/monitor.c (revision 292a089d)
1 /*
2  * net/tipc/monitor.c
3  *
4  * Copyright (c) 2016, Ericsson AB
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions are met:
9  *
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  * 3. Neither the names of the copyright holders nor the names of its
16  *    contributors may be used to endorse or promote products derived from
17  *    this software without specific prior written permission.
18  *
19  * Alternatively, this software may be distributed under the terms of the
20  * GNU General Public License ("GPL") version 2 as published by the Free
21  * Software Foundation.
22  *
23  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
24  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
27  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
28  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
29  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
30  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
31  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
32  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
33  * POSSIBILITY OF SUCH DAMAGE.
34  */
35 
36 #include <net/genetlink.h>
37 #include "core.h"
38 #include "addr.h"
39 #include "monitor.h"
40 #include "bearer.h"
41 
42 #define MAX_MON_DOMAIN       64
43 #define MON_TIMEOUT          120000
44 #define MAX_PEER_DOWN_EVENTS 4
45 
46 /* struct tipc_mon_domain: domain record to be transferred between peers
47  * @len: actual size of domain record
48  * @gen: current generation of sender's domain
49  * @ack_gen: most recent generation of self's domain acked by peer
50  * @member_cnt: number of domain member nodes described in this record
51  * @up_map: bit map indicating which of the members the sender considers up
52  * @members: identity of the domain members
53  */
54 struct tipc_mon_domain {
55 	u16 len;
56 	u16 gen;
57 	u16 ack_gen;
58 	u16 member_cnt;
59 	u64 up_map;
60 	u32 members[MAX_MON_DOMAIN];
61 };
62 
63 /* struct tipc_peer: state of a peer node and its domain
64  * @addr: tipc node identity of peer
65  * @head_map: shows which other nodes currently consider peer 'up'
66  * @domain: most recent domain record from peer
67  * @hash: position in hashed lookup list
68  * @list: position in linked list, in circular ascending order by 'addr'
69  * @applied: number of reported domain members applied on this monitor list
70  * @is_up: peer is up as seen from this node
71  * @is_head: peer is assigned domain head as seen from this node
72  * @is_local: peer is in local domain and should be continuously monitored
73  * @down_cnt: - numbers of other peers which have reported this on lost
74  */
75 struct tipc_peer {
76 	u32 addr;
77 	struct tipc_mon_domain *domain;
78 	struct hlist_node hash;
79 	struct list_head list;
80 	u8 applied;
81 	u8 down_cnt;
82 	bool is_up;
83 	bool is_head;
84 	bool is_local;
85 };
86 
87 struct tipc_monitor {
88 	struct hlist_head peers[NODE_HTABLE_SIZE];
89 	int peer_cnt;
90 	struct tipc_peer *self;
91 	rwlock_t lock;
92 	struct tipc_mon_domain cache;
93 	u16 list_gen;
94 	u16 dom_gen;
95 	struct net *net;
96 	struct timer_list timer;
97 	unsigned long timer_intv;
98 };
99 
tipc_monitor(struct net * net,int bearer_id)100 static struct tipc_monitor *tipc_monitor(struct net *net, int bearer_id)
101 {
102 	return tipc_net(net)->monitors[bearer_id];
103 }
104 
105 const int tipc_max_domain_size = sizeof(struct tipc_mon_domain);
106 
mon_cpu_to_le16(u16 val)107 static inline u16 mon_cpu_to_le16(u16 val)
108 {
109 	return (__force __u16)htons(val);
110 }
111 
mon_cpu_to_le32(u32 val)112 static inline u32 mon_cpu_to_le32(u32 val)
113 {
114 	return (__force __u32)htonl(val);
115 }
116 
mon_cpu_to_le64(u64 val)117 static inline u64 mon_cpu_to_le64(u64 val)
118 {
119 	return (__force __u64)cpu_to_be64(val);
120 }
121 
mon_le16_to_cpu(u16 val)122 static inline u16 mon_le16_to_cpu(u16 val)
123 {
124 	return ntohs((__force __be16)val);
125 }
126 
mon_le32_to_cpu(u32 val)127 static inline u32 mon_le32_to_cpu(u32 val)
128 {
129 	return ntohl((__force __be32)val);
130 }
131 
mon_le64_to_cpu(u64 val)132 static inline u64 mon_le64_to_cpu(u64 val)
133 {
134 	return be64_to_cpu((__force __be64)val);
135 }
136 
137 /* dom_rec_len(): actual length of domain record for transport
138  */
dom_rec_len(struct tipc_mon_domain * dom,u16 mcnt)139 static int dom_rec_len(struct tipc_mon_domain *dom, u16 mcnt)
140 {
141 	return (offsetof(struct tipc_mon_domain, members)) + (mcnt * sizeof(u32));
142 }
143 
144 /* dom_size() : calculate size of own domain based on number of peers
145  */
dom_size(int peers)146 static int dom_size(int peers)
147 {
148 	int i = 0;
149 
150 	while ((i * i) < peers)
151 		i++;
152 	return i < MAX_MON_DOMAIN ? i : MAX_MON_DOMAIN;
153 }
154 
map_set(u64 * up_map,int i,unsigned int v)155 static void map_set(u64 *up_map, int i, unsigned int v)
156 {
157 	*up_map &= ~(1ULL << i);
158 	*up_map |= ((u64)v << i);
159 }
160 
map_get(u64 up_map,int i)161 static int map_get(u64 up_map, int i)
162 {
163 	return (up_map & (1ULL << i)) >> i;
164 }
165 
peer_prev(struct tipc_peer * peer)166 static struct tipc_peer *peer_prev(struct tipc_peer *peer)
167 {
168 	return list_last_entry(&peer->list, struct tipc_peer, list);
169 }
170 
peer_nxt(struct tipc_peer * peer)171 static struct tipc_peer *peer_nxt(struct tipc_peer *peer)
172 {
173 	return list_first_entry(&peer->list, struct tipc_peer, list);
174 }
175 
peer_head(struct tipc_peer * peer)176 static struct tipc_peer *peer_head(struct tipc_peer *peer)
177 {
178 	while (!peer->is_head)
179 		peer = peer_prev(peer);
180 	return peer;
181 }
182 
get_peer(struct tipc_monitor * mon,u32 addr)183 static struct tipc_peer *get_peer(struct tipc_monitor *mon, u32 addr)
184 {
185 	struct tipc_peer *peer;
186 	unsigned int thash = tipc_hashfn(addr);
187 
188 	hlist_for_each_entry(peer, &mon->peers[thash], hash) {
189 		if (peer->addr == addr)
190 			return peer;
191 	}
192 	return NULL;
193 }
194 
get_self(struct net * net,int bearer_id)195 static struct tipc_peer *get_self(struct net *net, int bearer_id)
196 {
197 	struct tipc_monitor *mon = tipc_monitor(net, bearer_id);
198 
199 	return mon->self;
200 }
201 
tipc_mon_is_active(struct net * net,struct tipc_monitor * mon)202 static inline bool tipc_mon_is_active(struct net *net, struct tipc_monitor *mon)
203 {
204 	struct tipc_net *tn = tipc_net(net);
205 
206 	return mon->peer_cnt > tn->mon_threshold;
207 }
208 
209 /* mon_identify_lost_members() : - identify amd mark potentially lost members
210  */
mon_identify_lost_members(struct tipc_peer * peer,struct tipc_mon_domain * dom_bef,int applied_bef)211 static void mon_identify_lost_members(struct tipc_peer *peer,
212 				      struct tipc_mon_domain *dom_bef,
213 				      int applied_bef)
214 {
215 	struct tipc_peer *member = peer;
216 	struct tipc_mon_domain *dom_aft = peer->domain;
217 	int applied_aft = peer->applied;
218 	int i;
219 
220 	for (i = 0; i < applied_bef; i++) {
221 		member = peer_nxt(member);
222 
223 		/* Do nothing if self or peer already see member as down */
224 		if (!member->is_up || !map_get(dom_bef->up_map, i))
225 			continue;
226 
227 		/* Loss of local node must be detected by active probing */
228 		if (member->is_local)
229 			continue;
230 
231 		/* Start probing if member was removed from applied domain */
232 		if (!applied_aft || (applied_aft < i)) {
233 			member->down_cnt = 1;
234 			continue;
235 		}
236 
237 		/* Member loss is confirmed if it is still in applied domain */
238 		if (!map_get(dom_aft->up_map, i))
239 			member->down_cnt++;
240 	}
241 }
242 
243 /* mon_apply_domain() : match a peer's domain record against monitor list
244  */
mon_apply_domain(struct tipc_monitor * mon,struct tipc_peer * peer)245 static void mon_apply_domain(struct tipc_monitor *mon,
246 			     struct tipc_peer *peer)
247 {
248 	struct tipc_mon_domain *dom = peer->domain;
249 	struct tipc_peer *member;
250 	u32 addr;
251 	int i;
252 
253 	if (!dom || !peer->is_up)
254 		return;
255 
256 	/* Scan across domain members and match against monitor list */
257 	peer->applied = 0;
258 	member = peer_nxt(peer);
259 	for (i = 0; i < dom->member_cnt; i++) {
260 		addr = dom->members[i];
261 		if (addr != member->addr)
262 			return;
263 		peer->applied++;
264 		member = peer_nxt(member);
265 	}
266 }
267 
268 /* mon_update_local_domain() : update after peer addition/removal/up/down
269  */
mon_update_local_domain(struct tipc_monitor * mon)270 static void mon_update_local_domain(struct tipc_monitor *mon)
271 {
272 	struct tipc_peer *self = mon->self;
273 	struct tipc_mon_domain *cache = &mon->cache;
274 	struct tipc_mon_domain *dom = self->domain;
275 	struct tipc_peer *peer = self;
276 	u64 prev_up_map = dom->up_map;
277 	u16 member_cnt, i;
278 	bool diff;
279 
280 	/* Update local domain size based on current size of cluster */
281 	member_cnt = dom_size(mon->peer_cnt) - 1;
282 	self->applied = member_cnt;
283 
284 	/* Update native and cached outgoing local domain records */
285 	dom->len = dom_rec_len(dom, member_cnt);
286 	diff = dom->member_cnt != member_cnt;
287 	dom->member_cnt = member_cnt;
288 	for (i = 0; i < member_cnt; i++) {
289 		peer = peer_nxt(peer);
290 		diff |= dom->members[i] != peer->addr;
291 		dom->members[i] = peer->addr;
292 		map_set(&dom->up_map, i, peer->is_up);
293 		cache->members[i] = mon_cpu_to_le32(peer->addr);
294 	}
295 	diff |= dom->up_map != prev_up_map;
296 	if (!diff)
297 		return;
298 	dom->gen = ++mon->dom_gen;
299 	cache->len = mon_cpu_to_le16(dom->len);
300 	cache->gen = mon_cpu_to_le16(dom->gen);
301 	cache->member_cnt = mon_cpu_to_le16(member_cnt);
302 	cache->up_map = mon_cpu_to_le64(dom->up_map);
303 	mon_apply_domain(mon, self);
304 }
305 
306 /* mon_update_neighbors() : update preceding neighbors of added/removed peer
307  */
mon_update_neighbors(struct tipc_monitor * mon,struct tipc_peer * peer)308 static void mon_update_neighbors(struct tipc_monitor *mon,
309 				 struct tipc_peer *peer)
310 {
311 	int dz, i;
312 
313 	dz = dom_size(mon->peer_cnt);
314 	for (i = 0; i < dz; i++) {
315 		mon_apply_domain(mon, peer);
316 		peer = peer_prev(peer);
317 	}
318 }
319 
320 /* mon_assign_roles() : reassign peer roles after a network change
321  * The monitor list is consistent at this stage; i.e., each peer is monitoring
322  * a set of domain members as matched between domain record and the monitor list
323  */
mon_assign_roles(struct tipc_monitor * mon,struct tipc_peer * head)324 static void mon_assign_roles(struct tipc_monitor *mon, struct tipc_peer *head)
325 {
326 	struct tipc_peer *peer = peer_nxt(head);
327 	struct tipc_peer *self = mon->self;
328 	int i = 0;
329 
330 	for (; peer != self; peer = peer_nxt(peer)) {
331 		peer->is_local = false;
332 
333 		/* Update domain member */
334 		if (i++ < head->applied) {
335 			peer->is_head = false;
336 			if (head == self)
337 				peer->is_local = true;
338 			continue;
339 		}
340 		/* Assign next domain head */
341 		if (!peer->is_up)
342 			continue;
343 		if (peer->is_head)
344 			break;
345 		head = peer;
346 		head->is_head = true;
347 		i = 0;
348 	}
349 	mon->list_gen++;
350 }
351 
tipc_mon_remove_peer(struct net * net,u32 addr,int bearer_id)352 void tipc_mon_remove_peer(struct net *net, u32 addr, int bearer_id)
353 {
354 	struct tipc_monitor *mon = tipc_monitor(net, bearer_id);
355 	struct tipc_peer *self;
356 	struct tipc_peer *peer, *prev, *head;
357 
358 	if (!mon)
359 		return;
360 
361 	self = get_self(net, bearer_id);
362 	write_lock_bh(&mon->lock);
363 	peer = get_peer(mon, addr);
364 	if (!peer)
365 		goto exit;
366 	prev = peer_prev(peer);
367 	list_del(&peer->list);
368 	hlist_del(&peer->hash);
369 	kfree(peer->domain);
370 	kfree(peer);
371 	mon->peer_cnt--;
372 	head = peer_head(prev);
373 	if (head == self)
374 		mon_update_local_domain(mon);
375 	mon_update_neighbors(mon, prev);
376 
377 	/* Revert to full-mesh monitoring if we reach threshold */
378 	if (!tipc_mon_is_active(net, mon)) {
379 		list_for_each_entry(peer, &self->list, list) {
380 			kfree(peer->domain);
381 			peer->domain = NULL;
382 			peer->applied = 0;
383 		}
384 	}
385 	mon_assign_roles(mon, head);
386 exit:
387 	write_unlock_bh(&mon->lock);
388 }
389 
tipc_mon_add_peer(struct tipc_monitor * mon,u32 addr,struct tipc_peer ** peer)390 static bool tipc_mon_add_peer(struct tipc_monitor *mon, u32 addr,
391 			      struct tipc_peer **peer)
392 {
393 	struct tipc_peer *self = mon->self;
394 	struct tipc_peer *cur, *prev, *p;
395 
396 	p = kzalloc(sizeof(*p), GFP_ATOMIC);
397 	*peer = p;
398 	if (!p)
399 		return false;
400 	p->addr = addr;
401 
402 	/* Add new peer to lookup list */
403 	INIT_LIST_HEAD(&p->list);
404 	hlist_add_head(&p->hash, &mon->peers[tipc_hashfn(addr)]);
405 
406 	/* Sort new peer into iterator list, in ascending circular order */
407 	prev = self;
408 	list_for_each_entry(cur, &self->list, list) {
409 		if ((addr > prev->addr) && (addr < cur->addr))
410 			break;
411 		if (((addr < cur->addr) || (addr > prev->addr)) &&
412 		    (prev->addr > cur->addr))
413 			break;
414 		prev = cur;
415 	}
416 	list_add_tail(&p->list, &cur->list);
417 	mon->peer_cnt++;
418 	mon_update_neighbors(mon, p);
419 	return true;
420 }
421 
tipc_mon_peer_up(struct net * net,u32 addr,int bearer_id)422 void tipc_mon_peer_up(struct net *net, u32 addr, int bearer_id)
423 {
424 	struct tipc_monitor *mon = tipc_monitor(net, bearer_id);
425 	struct tipc_peer *self = get_self(net, bearer_id);
426 	struct tipc_peer *peer, *head;
427 
428 	write_lock_bh(&mon->lock);
429 	peer = get_peer(mon, addr);
430 	if (!peer && !tipc_mon_add_peer(mon, addr, &peer))
431 		goto exit;
432 	peer->is_up = true;
433 	head = peer_head(peer);
434 	if (head == self)
435 		mon_update_local_domain(mon);
436 	mon_assign_roles(mon, head);
437 exit:
438 	write_unlock_bh(&mon->lock);
439 }
440 
tipc_mon_peer_down(struct net * net,u32 addr,int bearer_id)441 void tipc_mon_peer_down(struct net *net, u32 addr, int bearer_id)
442 {
443 	struct tipc_monitor *mon = tipc_monitor(net, bearer_id);
444 	struct tipc_peer *self;
445 	struct tipc_peer *peer, *head;
446 	struct tipc_mon_domain *dom;
447 	int applied;
448 
449 	if (!mon)
450 		return;
451 
452 	self = get_self(net, bearer_id);
453 	write_lock_bh(&mon->lock);
454 	peer = get_peer(mon, addr);
455 	if (!peer) {
456 		pr_warn("Mon: unknown link %x/%u DOWN\n", addr, bearer_id);
457 		goto exit;
458 	}
459 	applied = peer->applied;
460 	peer->applied = 0;
461 	dom = peer->domain;
462 	peer->domain = NULL;
463 	if (peer->is_head)
464 		mon_identify_lost_members(peer, dom, applied);
465 	kfree(dom);
466 	peer->is_up = false;
467 	peer->is_head = false;
468 	peer->is_local = false;
469 	peer->down_cnt = 0;
470 	head = peer_head(peer);
471 	if (head == self)
472 		mon_update_local_domain(mon);
473 	mon_assign_roles(mon, head);
474 exit:
475 	write_unlock_bh(&mon->lock);
476 }
477 
478 /* tipc_mon_rcv - process monitor domain event message
479  */
tipc_mon_rcv(struct net * net,void * data,u16 dlen,u32 addr,struct tipc_mon_state * state,int bearer_id)480 void tipc_mon_rcv(struct net *net, void *data, u16 dlen, u32 addr,
481 		  struct tipc_mon_state *state, int bearer_id)
482 {
483 	struct tipc_monitor *mon = tipc_monitor(net, bearer_id);
484 	struct tipc_mon_domain *arrv_dom = data;
485 	struct tipc_mon_domain dom_bef;
486 	struct tipc_mon_domain *dom;
487 	struct tipc_peer *peer;
488 	u16 new_member_cnt = mon_le16_to_cpu(arrv_dom->member_cnt);
489 	int new_dlen = dom_rec_len(arrv_dom, new_member_cnt);
490 	u16 new_gen = mon_le16_to_cpu(arrv_dom->gen);
491 	u16 acked_gen = mon_le16_to_cpu(arrv_dom->ack_gen);
492 	u16 arrv_dlen = mon_le16_to_cpu(arrv_dom->len);
493 	bool probing = state->probing;
494 	int i, applied_bef;
495 
496 	state->probing = false;
497 
498 	/* Sanity check received domain record */
499 	if (new_member_cnt > MAX_MON_DOMAIN)
500 		return;
501 	if (dlen < dom_rec_len(arrv_dom, 0))
502 		return;
503 	if (dlen != dom_rec_len(arrv_dom, new_member_cnt))
504 		return;
505 	if (dlen < new_dlen || arrv_dlen != new_dlen)
506 		return;
507 
508 	/* Synch generation numbers with peer if link just came up */
509 	if (!state->synched) {
510 		state->peer_gen = new_gen - 1;
511 		state->acked_gen = acked_gen;
512 		state->synched = true;
513 	}
514 
515 	if (more(acked_gen, state->acked_gen))
516 		state->acked_gen = acked_gen;
517 
518 	/* Drop duplicate unless we are waiting for a probe response */
519 	if (!more(new_gen, state->peer_gen) && !probing)
520 		return;
521 
522 	write_lock_bh(&mon->lock);
523 	peer = get_peer(mon, addr);
524 	if (!peer || !peer->is_up)
525 		goto exit;
526 
527 	/* Peer is confirmed, stop any ongoing probing */
528 	peer->down_cnt = 0;
529 
530 	/* Task is done for duplicate record */
531 	if (!more(new_gen, state->peer_gen))
532 		goto exit;
533 
534 	state->peer_gen = new_gen;
535 
536 	/* Cache current domain record for later use */
537 	dom_bef.member_cnt = 0;
538 	dom = peer->domain;
539 	if (dom)
540 		memcpy(&dom_bef, dom, dom->len);
541 
542 	/* Transform and store received domain record */
543 	if (!dom || (dom->len < new_dlen)) {
544 		kfree(dom);
545 		dom = kmalloc(new_dlen, GFP_ATOMIC);
546 		peer->domain = dom;
547 		if (!dom)
548 			goto exit;
549 	}
550 	dom->len = new_dlen;
551 	dom->gen = new_gen;
552 	dom->member_cnt = new_member_cnt;
553 	dom->up_map = mon_le64_to_cpu(arrv_dom->up_map);
554 	for (i = 0; i < new_member_cnt; i++)
555 		dom->members[i] = mon_le32_to_cpu(arrv_dom->members[i]);
556 
557 	/* Update peers affected by this domain record */
558 	applied_bef = peer->applied;
559 	mon_apply_domain(mon, peer);
560 	mon_identify_lost_members(peer, &dom_bef, applied_bef);
561 	mon_assign_roles(mon, peer_head(peer));
562 exit:
563 	write_unlock_bh(&mon->lock);
564 }
565 
tipc_mon_prep(struct net * net,void * data,int * dlen,struct tipc_mon_state * state,int bearer_id)566 void tipc_mon_prep(struct net *net, void *data, int *dlen,
567 		   struct tipc_mon_state *state, int bearer_id)
568 {
569 	struct tipc_monitor *mon = tipc_monitor(net, bearer_id);
570 	struct tipc_mon_domain *dom = data;
571 	u16 gen = mon->dom_gen;
572 	u16 len;
573 
574 	/* Send invalid record if not active */
575 	if (!tipc_mon_is_active(net, mon)) {
576 		dom->len = 0;
577 		return;
578 	}
579 
580 	/* Send only a dummy record with ack if peer has acked our last sent */
581 	if (likely(state->acked_gen == gen)) {
582 		len = dom_rec_len(dom, 0);
583 		*dlen = len;
584 		dom->len = mon_cpu_to_le16(len);
585 		dom->gen = mon_cpu_to_le16(gen);
586 		dom->ack_gen = mon_cpu_to_le16(state->peer_gen);
587 		dom->member_cnt = 0;
588 		return;
589 	}
590 	/* Send the full record */
591 	read_lock_bh(&mon->lock);
592 	len = mon_le16_to_cpu(mon->cache.len);
593 	*dlen = len;
594 	memcpy(data, &mon->cache, len);
595 	read_unlock_bh(&mon->lock);
596 	dom->ack_gen = mon_cpu_to_le16(state->peer_gen);
597 }
598 
tipc_mon_get_state(struct net * net,u32 addr,struct tipc_mon_state * state,int bearer_id)599 void tipc_mon_get_state(struct net *net, u32 addr,
600 			struct tipc_mon_state *state,
601 			int bearer_id)
602 {
603 	struct tipc_monitor *mon = tipc_monitor(net, bearer_id);
604 	struct tipc_peer *peer;
605 
606 	if (!tipc_mon_is_active(net, mon)) {
607 		state->probing = false;
608 		state->monitoring = true;
609 		return;
610 	}
611 
612 	/* Used cached state if table has not changed */
613 	if (!state->probing &&
614 	    (state->list_gen == mon->list_gen) &&
615 	    (state->acked_gen == mon->dom_gen))
616 		return;
617 
618 	read_lock_bh(&mon->lock);
619 	peer = get_peer(mon, addr);
620 	if (peer) {
621 		state->probing = state->acked_gen != mon->dom_gen;
622 		state->probing |= peer->down_cnt;
623 		state->reset |= peer->down_cnt >= MAX_PEER_DOWN_EVENTS;
624 		state->monitoring = peer->is_local;
625 		state->monitoring |= peer->is_head;
626 		state->list_gen = mon->list_gen;
627 	}
628 	read_unlock_bh(&mon->lock);
629 }
630 
mon_timeout(struct timer_list * t)631 static void mon_timeout(struct timer_list *t)
632 {
633 	struct tipc_monitor *mon = from_timer(mon, t, timer);
634 	struct tipc_peer *self;
635 	int best_member_cnt = dom_size(mon->peer_cnt) - 1;
636 
637 	write_lock_bh(&mon->lock);
638 	self = mon->self;
639 	if (self && (best_member_cnt != self->applied)) {
640 		mon_update_local_domain(mon);
641 		mon_assign_roles(mon, self);
642 	}
643 	write_unlock_bh(&mon->lock);
644 	mod_timer(&mon->timer, jiffies + mon->timer_intv);
645 }
646 
tipc_mon_create(struct net * net,int bearer_id)647 int tipc_mon_create(struct net *net, int bearer_id)
648 {
649 	struct tipc_net *tn = tipc_net(net);
650 	struct tipc_monitor *mon;
651 	struct tipc_peer *self;
652 	struct tipc_mon_domain *dom;
653 
654 	if (tn->monitors[bearer_id])
655 		return 0;
656 
657 	mon = kzalloc(sizeof(*mon), GFP_ATOMIC);
658 	self = kzalloc(sizeof(*self), GFP_ATOMIC);
659 	dom = kzalloc(sizeof(*dom), GFP_ATOMIC);
660 	if (!mon || !self || !dom) {
661 		kfree(mon);
662 		kfree(self);
663 		kfree(dom);
664 		return -ENOMEM;
665 	}
666 	tn->monitors[bearer_id] = mon;
667 	rwlock_init(&mon->lock);
668 	mon->net = net;
669 	mon->peer_cnt = 1;
670 	mon->self = self;
671 	self->domain = dom;
672 	self->addr = tipc_own_addr(net);
673 	self->is_up = true;
674 	self->is_head = true;
675 	INIT_LIST_HEAD(&self->list);
676 	timer_setup(&mon->timer, mon_timeout, 0);
677 	mon->timer_intv = msecs_to_jiffies(MON_TIMEOUT + (tn->random & 0xffff));
678 	mod_timer(&mon->timer, jiffies + mon->timer_intv);
679 	return 0;
680 }
681 
tipc_mon_delete(struct net * net,int bearer_id)682 void tipc_mon_delete(struct net *net, int bearer_id)
683 {
684 	struct tipc_net *tn = tipc_net(net);
685 	struct tipc_monitor *mon = tipc_monitor(net, bearer_id);
686 	struct tipc_peer *self;
687 	struct tipc_peer *peer, *tmp;
688 
689 	if (!mon)
690 		return;
691 
692 	self = get_self(net, bearer_id);
693 	write_lock_bh(&mon->lock);
694 	tn->monitors[bearer_id] = NULL;
695 	list_for_each_entry_safe(peer, tmp, &self->list, list) {
696 		list_del(&peer->list);
697 		hlist_del(&peer->hash);
698 		kfree(peer->domain);
699 		kfree(peer);
700 	}
701 	mon->self = NULL;
702 	write_unlock_bh(&mon->lock);
703 	timer_shutdown_sync(&mon->timer);
704 	kfree(self->domain);
705 	kfree(self);
706 	kfree(mon);
707 }
708 
tipc_mon_reinit_self(struct net * net)709 void tipc_mon_reinit_self(struct net *net)
710 {
711 	struct tipc_monitor *mon;
712 	int bearer_id;
713 
714 	for (bearer_id = 0; bearer_id < MAX_BEARERS; bearer_id++) {
715 		mon = tipc_monitor(net, bearer_id);
716 		if (!mon)
717 			continue;
718 		write_lock_bh(&mon->lock);
719 		mon->self->addr = tipc_own_addr(net);
720 		write_unlock_bh(&mon->lock);
721 	}
722 }
723 
tipc_nl_monitor_set_threshold(struct net * net,u32 cluster_size)724 int tipc_nl_monitor_set_threshold(struct net *net, u32 cluster_size)
725 {
726 	struct tipc_net *tn = tipc_net(net);
727 
728 	if (cluster_size > TIPC_CLUSTER_SIZE)
729 		return -EINVAL;
730 
731 	tn->mon_threshold = cluster_size;
732 
733 	return 0;
734 }
735 
tipc_nl_monitor_get_threshold(struct net * net)736 int tipc_nl_monitor_get_threshold(struct net *net)
737 {
738 	struct tipc_net *tn = tipc_net(net);
739 
740 	return tn->mon_threshold;
741 }
742 
__tipc_nl_add_monitor_peer(struct tipc_peer * peer,struct tipc_nl_msg * msg)743 static int __tipc_nl_add_monitor_peer(struct tipc_peer *peer,
744 				      struct tipc_nl_msg *msg)
745 {
746 	struct tipc_mon_domain *dom = peer->domain;
747 	struct nlattr *attrs;
748 	void *hdr;
749 
750 	hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family,
751 			  NLM_F_MULTI, TIPC_NL_MON_PEER_GET);
752 	if (!hdr)
753 		return -EMSGSIZE;
754 
755 	attrs = nla_nest_start_noflag(msg->skb, TIPC_NLA_MON_PEER);
756 	if (!attrs)
757 		goto msg_full;
758 
759 	if (nla_put_u32(msg->skb, TIPC_NLA_MON_PEER_ADDR, peer->addr))
760 		goto attr_msg_full;
761 	if (nla_put_u32(msg->skb, TIPC_NLA_MON_PEER_APPLIED, peer->applied))
762 		goto attr_msg_full;
763 
764 	if (peer->is_up)
765 		if (nla_put_flag(msg->skb, TIPC_NLA_MON_PEER_UP))
766 			goto attr_msg_full;
767 	if (peer->is_local)
768 		if (nla_put_flag(msg->skb, TIPC_NLA_MON_PEER_LOCAL))
769 			goto attr_msg_full;
770 	if (peer->is_head)
771 		if (nla_put_flag(msg->skb, TIPC_NLA_MON_PEER_HEAD))
772 			goto attr_msg_full;
773 
774 	if (dom) {
775 		if (nla_put_u32(msg->skb, TIPC_NLA_MON_PEER_DOMGEN, dom->gen))
776 			goto attr_msg_full;
777 		if (nla_put_u64_64bit(msg->skb, TIPC_NLA_MON_PEER_UPMAP,
778 				      dom->up_map, TIPC_NLA_MON_PEER_PAD))
779 			goto attr_msg_full;
780 		if (nla_put(msg->skb, TIPC_NLA_MON_PEER_MEMBERS,
781 			    dom->member_cnt * sizeof(u32), &dom->members))
782 			goto attr_msg_full;
783 	}
784 
785 	nla_nest_end(msg->skb, attrs);
786 	genlmsg_end(msg->skb, hdr);
787 	return 0;
788 
789 attr_msg_full:
790 	nla_nest_cancel(msg->skb, attrs);
791 msg_full:
792 	genlmsg_cancel(msg->skb, hdr);
793 
794 	return -EMSGSIZE;
795 }
796 
tipc_nl_add_monitor_peer(struct net * net,struct tipc_nl_msg * msg,u32 bearer_id,u32 * prev_node)797 int tipc_nl_add_monitor_peer(struct net *net, struct tipc_nl_msg *msg,
798 			     u32 bearer_id, u32 *prev_node)
799 {
800 	struct tipc_monitor *mon = tipc_monitor(net, bearer_id);
801 	struct tipc_peer *peer;
802 
803 	if (!mon)
804 		return -EINVAL;
805 
806 	read_lock_bh(&mon->lock);
807 	peer = mon->self;
808 	do {
809 		if (*prev_node) {
810 			if (peer->addr == *prev_node)
811 				*prev_node = 0;
812 			else
813 				continue;
814 		}
815 		if (__tipc_nl_add_monitor_peer(peer, msg)) {
816 			*prev_node = peer->addr;
817 			read_unlock_bh(&mon->lock);
818 			return -EMSGSIZE;
819 		}
820 	} while ((peer = peer_nxt(peer)) != mon->self);
821 	read_unlock_bh(&mon->lock);
822 
823 	return 0;
824 }
825 
__tipc_nl_add_monitor(struct net * net,struct tipc_nl_msg * msg,u32 bearer_id)826 int __tipc_nl_add_monitor(struct net *net, struct tipc_nl_msg *msg,
827 			  u32 bearer_id)
828 {
829 	struct tipc_monitor *mon = tipc_monitor(net, bearer_id);
830 	char bearer_name[TIPC_MAX_BEARER_NAME];
831 	struct nlattr *attrs;
832 	void *hdr;
833 	int ret;
834 
835 	ret = tipc_bearer_get_name(net, bearer_name, bearer_id);
836 	if (ret || !mon)
837 		return 0;
838 
839 	hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family,
840 			  NLM_F_MULTI, TIPC_NL_MON_GET);
841 	if (!hdr)
842 		return -EMSGSIZE;
843 
844 	attrs = nla_nest_start_noflag(msg->skb, TIPC_NLA_MON);
845 	if (!attrs)
846 		goto msg_full;
847 
848 	read_lock_bh(&mon->lock);
849 	if (nla_put_u32(msg->skb, TIPC_NLA_MON_REF, bearer_id))
850 		goto attr_msg_full;
851 	if (tipc_mon_is_active(net, mon))
852 		if (nla_put_flag(msg->skb, TIPC_NLA_MON_ACTIVE))
853 			goto attr_msg_full;
854 	if (nla_put_string(msg->skb, TIPC_NLA_MON_BEARER_NAME, bearer_name))
855 		goto attr_msg_full;
856 	if (nla_put_u32(msg->skb, TIPC_NLA_MON_PEERCNT, mon->peer_cnt))
857 		goto attr_msg_full;
858 	if (nla_put_u32(msg->skb, TIPC_NLA_MON_LISTGEN, mon->list_gen))
859 		goto attr_msg_full;
860 
861 	read_unlock_bh(&mon->lock);
862 	nla_nest_end(msg->skb, attrs);
863 	genlmsg_end(msg->skb, hdr);
864 
865 	return 0;
866 
867 attr_msg_full:
868 	read_unlock_bh(&mon->lock);
869 	nla_nest_cancel(msg->skb, attrs);
870 msg_full:
871 	genlmsg_cancel(msg->skb, hdr);
872 
873 	return -EMSGSIZE;
874 }
875