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