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
107 /* dom_rec_len(): actual length of domain record for transport
108 */
dom_rec_len(struct tipc_mon_domain * dom,u16 mcnt)109 static 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 */
dom_size(int peers)116 static 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
map_set(u64 * up_map,int i,unsigned int v)125 static 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
map_get(u64 up_map,int i)131 static int map_get(u64 up_map, int i)
132 {
133 return (up_map & (1ULL << i)) >> i;
134 }
135
peer_prev(struct tipc_peer * peer)136 static struct tipc_peer *peer_prev(struct tipc_peer *peer)
137 {
138 return list_last_entry(&peer->list, struct tipc_peer, list);
139 }
140
peer_nxt(struct tipc_peer * peer)141 static struct tipc_peer *peer_nxt(struct tipc_peer *peer)
142 {
143 return list_first_entry(&peer->list, struct tipc_peer, list);
144 }
145
peer_head(struct tipc_peer * peer)146 static 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
get_peer(struct tipc_monitor * mon,u32 addr)153 static 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
get_self(struct net * net,int bearer_id)165 static 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
tipc_mon_is_active(struct net * net,struct tipc_monitor * mon)172 static 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 */
mon_identify_lost_members(struct tipc_peer * peer,struct tipc_mon_domain * dom_bef,int applied_bef)181 static 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 */
mon_apply_domain(struct tipc_monitor * mon,struct tipc_peer * peer)215 static 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 */
mon_update_local_domain(struct tipc_monitor * mon)240 static 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 */
mon_update_neighbors(struct tipc_monitor * mon,struct tipc_peer * peer)278 static 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 */
mon_assign_roles(struct tipc_monitor * mon,struct tipc_peer * head)294 static 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
tipc_mon_remove_peer(struct net * net,u32 addr,int bearer_id)322 void 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 = get_self(net, bearer_id);
326 struct tipc_peer *peer, *prev, *head;
327
328 write_lock_bh(&mon->lock);
329 peer = get_peer(mon, addr);
330 if (!peer)
331 goto exit;
332 prev = peer_prev(peer);
333 list_del(&peer->list);
334 hlist_del(&peer->hash);
335 kfree(peer->domain);
336 kfree(peer);
337 mon->peer_cnt--;
338 head = peer_head(prev);
339 if (head == self)
340 mon_update_local_domain(mon);
341 mon_update_neighbors(mon, prev);
342
343 /* Revert to full-mesh monitoring if we reach threshold */
344 if (!tipc_mon_is_active(net, mon)) {
345 list_for_each_entry(peer, &self->list, list) {
346 kfree(peer->domain);
347 peer->domain = NULL;
348 peer->applied = 0;
349 }
350 }
351 mon_assign_roles(mon, head);
352 exit:
353 write_unlock_bh(&mon->lock);
354 }
355
tipc_mon_add_peer(struct tipc_monitor * mon,u32 addr,struct tipc_peer ** peer)356 static bool tipc_mon_add_peer(struct tipc_monitor *mon, u32 addr,
357 struct tipc_peer **peer)
358 {
359 struct tipc_peer *self = mon->self;
360 struct tipc_peer *cur, *prev, *p;
361
362 p = kzalloc(sizeof(*p), GFP_ATOMIC);
363 *peer = p;
364 if (!p)
365 return false;
366 p->addr = addr;
367
368 /* Add new peer to lookup list */
369 INIT_LIST_HEAD(&p->list);
370 hlist_add_head(&p->hash, &mon->peers[tipc_hashfn(addr)]);
371
372 /* Sort new peer into iterator list, in ascending circular order */
373 prev = self;
374 list_for_each_entry(cur, &self->list, list) {
375 if ((addr > prev->addr) && (addr < cur->addr))
376 break;
377 if (((addr < cur->addr) || (addr > prev->addr)) &&
378 (prev->addr > cur->addr))
379 break;
380 prev = cur;
381 }
382 list_add_tail(&p->list, &cur->list);
383 mon->peer_cnt++;
384 mon_update_neighbors(mon, p);
385 return true;
386 }
387
tipc_mon_peer_up(struct net * net,u32 addr,int bearer_id)388 void tipc_mon_peer_up(struct net *net, u32 addr, int bearer_id)
389 {
390 struct tipc_monitor *mon = tipc_monitor(net, bearer_id);
391 struct tipc_peer *self = get_self(net, bearer_id);
392 struct tipc_peer *peer, *head;
393
394 write_lock_bh(&mon->lock);
395 peer = get_peer(mon, addr);
396 if (!peer && !tipc_mon_add_peer(mon, addr, &peer))
397 goto exit;
398 peer->is_up = true;
399 head = peer_head(peer);
400 if (head == self)
401 mon_update_local_domain(mon);
402 mon_assign_roles(mon, head);
403 exit:
404 write_unlock_bh(&mon->lock);
405 }
406
tipc_mon_peer_down(struct net * net,u32 addr,int bearer_id)407 void tipc_mon_peer_down(struct net *net, u32 addr, int bearer_id)
408 {
409 struct tipc_monitor *mon = tipc_monitor(net, bearer_id);
410 struct tipc_peer *self = get_self(net, bearer_id);
411 struct tipc_peer *peer, *head;
412 struct tipc_mon_domain *dom;
413 int applied;
414
415 write_lock_bh(&mon->lock);
416 peer = get_peer(mon, addr);
417 if (!peer) {
418 pr_warn("Mon: unknown link %x/%u DOWN\n", addr, bearer_id);
419 goto exit;
420 }
421 applied = peer->applied;
422 peer->applied = 0;
423 dom = peer->domain;
424 peer->domain = NULL;
425 if (peer->is_head)
426 mon_identify_lost_members(peer, dom, applied);
427 kfree(dom);
428 peer->is_up = false;
429 peer->is_head = false;
430 peer->is_local = false;
431 peer->down_cnt = 0;
432 head = peer_head(peer);
433 if (head == self)
434 mon_update_local_domain(mon);
435 mon_assign_roles(mon, head);
436 exit:
437 write_unlock_bh(&mon->lock);
438 }
439
440 /* tipc_mon_rcv - process monitor domain event message
441 */
tipc_mon_rcv(struct net * net,void * data,u16 dlen,u32 addr,struct tipc_mon_state * state,int bearer_id)442 void tipc_mon_rcv(struct net *net, void *data, u16 dlen, u32 addr,
443 struct tipc_mon_state *state, int bearer_id)
444 {
445 struct tipc_monitor *mon = tipc_monitor(net, bearer_id);
446 struct tipc_mon_domain *arrv_dom = data;
447 struct tipc_mon_domain dom_bef;
448 struct tipc_mon_domain *dom;
449 struct tipc_peer *peer;
450 u16 new_member_cnt = ntohs(arrv_dom->member_cnt);
451 int new_dlen = dom_rec_len(arrv_dom, new_member_cnt);
452 u16 new_gen = ntohs(arrv_dom->gen);
453 u16 acked_gen = ntohs(arrv_dom->ack_gen);
454 bool probing = state->probing;
455 int i, applied_bef;
456
457 state->probing = false;
458
459 /* Sanity check received domain record */
460 if (new_member_cnt > MAX_MON_DOMAIN)
461 return;
462 if (dlen < dom_rec_len(arrv_dom, 0))
463 return;
464 if (dlen != dom_rec_len(arrv_dom, new_member_cnt))
465 return;
466 if ((dlen < new_dlen) || ntohs(arrv_dom->len) != new_dlen)
467 return;
468
469 /* Synch generation numbers with peer if link just came up */
470 if (!state->synched) {
471 state->peer_gen = new_gen - 1;
472 state->acked_gen = acked_gen;
473 state->synched = true;
474 }
475
476 if (more(acked_gen, state->acked_gen))
477 state->acked_gen = acked_gen;
478
479 /* Drop duplicate unless we are waiting for a probe response */
480 if (!more(new_gen, state->peer_gen) && !probing)
481 return;
482
483 write_lock_bh(&mon->lock);
484 peer = get_peer(mon, addr);
485 if (!peer || !peer->is_up)
486 goto exit;
487
488 /* Peer is confirmed, stop any ongoing probing */
489 peer->down_cnt = 0;
490
491 /* Task is done for duplicate record */
492 if (!more(new_gen, state->peer_gen))
493 goto exit;
494
495 state->peer_gen = new_gen;
496
497 /* Cache current domain record for later use */
498 dom_bef.member_cnt = 0;
499 dom = peer->domain;
500 if (dom)
501 memcpy(&dom_bef, dom, dom->len);
502
503 /* Transform and store received domain record */
504 if (!dom || (dom->len < new_dlen)) {
505 kfree(dom);
506 dom = kmalloc(new_dlen, GFP_ATOMIC);
507 peer->domain = dom;
508 if (!dom)
509 goto exit;
510 }
511 dom->len = new_dlen;
512 dom->gen = new_gen;
513 dom->member_cnt = new_member_cnt;
514 dom->up_map = be64_to_cpu(arrv_dom->up_map);
515 for (i = 0; i < new_member_cnt; i++)
516 dom->members[i] = ntohl(arrv_dom->members[i]);
517
518 /* Update peers affected by this domain record */
519 applied_bef = peer->applied;
520 mon_apply_domain(mon, peer);
521 mon_identify_lost_members(peer, &dom_bef, applied_bef);
522 mon_assign_roles(mon, peer_head(peer));
523 exit:
524 write_unlock_bh(&mon->lock);
525 }
526
tipc_mon_prep(struct net * net,void * data,int * dlen,struct tipc_mon_state * state,int bearer_id)527 void tipc_mon_prep(struct net *net, void *data, int *dlen,
528 struct tipc_mon_state *state, int bearer_id)
529 {
530 struct tipc_monitor *mon = tipc_monitor(net, bearer_id);
531 struct tipc_mon_domain *dom = data;
532 u16 gen = mon->dom_gen;
533 u16 len;
534
535 /* Send invalid record if not active */
536 if (!tipc_mon_is_active(net, mon)) {
537 dom->len = 0;
538 return;
539 }
540
541 /* Send only a dummy record with ack if peer has acked our last sent */
542 if (likely(state->acked_gen == gen)) {
543 len = dom_rec_len(dom, 0);
544 *dlen = len;
545 dom->len = htons(len);
546 dom->gen = htons(gen);
547 dom->ack_gen = htons(state->peer_gen);
548 dom->member_cnt = 0;
549 return;
550 }
551 /* Send the full record */
552 read_lock_bh(&mon->lock);
553 len = ntohs(mon->cache.len);
554 *dlen = len;
555 memcpy(data, &mon->cache, len);
556 read_unlock_bh(&mon->lock);
557 dom->ack_gen = htons(state->peer_gen);
558 }
559
tipc_mon_get_state(struct net * net,u32 addr,struct tipc_mon_state * state,int bearer_id)560 void tipc_mon_get_state(struct net *net, u32 addr,
561 struct tipc_mon_state *state,
562 int bearer_id)
563 {
564 struct tipc_monitor *mon = tipc_monitor(net, bearer_id);
565 struct tipc_peer *peer;
566
567 if (!tipc_mon_is_active(net, mon)) {
568 state->probing = false;
569 state->monitoring = true;
570 return;
571 }
572
573 /* Used cached state if table has not changed */
574 if (!state->probing &&
575 (state->list_gen == mon->list_gen) &&
576 (state->acked_gen == mon->dom_gen))
577 return;
578
579 read_lock_bh(&mon->lock);
580 peer = get_peer(mon, addr);
581 if (peer) {
582 state->probing = state->acked_gen != mon->dom_gen;
583 state->probing |= peer->down_cnt;
584 state->reset |= peer->down_cnt >= MAX_PEER_DOWN_EVENTS;
585 state->monitoring = peer->is_local;
586 state->monitoring |= peer->is_head;
587 state->list_gen = mon->list_gen;
588 }
589 read_unlock_bh(&mon->lock);
590 }
591
mon_timeout(struct timer_list * t)592 static void mon_timeout(struct timer_list *t)
593 {
594 struct tipc_monitor *mon = from_timer(mon, t, timer);
595 struct tipc_peer *self;
596 int best_member_cnt = dom_size(mon->peer_cnt) - 1;
597
598 write_lock_bh(&mon->lock);
599 self = mon->self;
600 if (self && (best_member_cnt != self->applied)) {
601 mon_update_local_domain(mon);
602 mon_assign_roles(mon, self);
603 }
604 write_unlock_bh(&mon->lock);
605 mod_timer(&mon->timer, jiffies + mon->timer_intv);
606 }
607
tipc_mon_create(struct net * net,int bearer_id)608 int tipc_mon_create(struct net *net, int bearer_id)
609 {
610 struct tipc_net *tn = tipc_net(net);
611 struct tipc_monitor *mon;
612 struct tipc_peer *self;
613 struct tipc_mon_domain *dom;
614
615 if (tn->monitors[bearer_id])
616 return 0;
617
618 mon = kzalloc(sizeof(*mon), GFP_ATOMIC);
619 self = kzalloc(sizeof(*self), GFP_ATOMIC);
620 dom = kzalloc(sizeof(*dom), GFP_ATOMIC);
621 if (!mon || !self || !dom) {
622 kfree(mon);
623 kfree(self);
624 kfree(dom);
625 return -ENOMEM;
626 }
627 tn->monitors[bearer_id] = mon;
628 rwlock_init(&mon->lock);
629 mon->net = net;
630 mon->peer_cnt = 1;
631 mon->self = self;
632 self->domain = dom;
633 self->addr = tipc_own_addr(net);
634 self->is_up = true;
635 self->is_head = true;
636 INIT_LIST_HEAD(&self->list);
637 timer_setup(&mon->timer, mon_timeout, 0);
638 mon->timer_intv = msecs_to_jiffies(MON_TIMEOUT + (tn->random & 0xffff));
639 mod_timer(&mon->timer, jiffies + mon->timer_intv);
640 return 0;
641 }
642
tipc_mon_delete(struct net * net,int bearer_id)643 void tipc_mon_delete(struct net *net, int bearer_id)
644 {
645 struct tipc_net *tn = tipc_net(net);
646 struct tipc_monitor *mon = tipc_monitor(net, bearer_id);
647 struct tipc_peer *self;
648 struct tipc_peer *peer, *tmp;
649
650 if (!mon)
651 return;
652
653 self = get_self(net, bearer_id);
654 write_lock_bh(&mon->lock);
655 tn->monitors[bearer_id] = NULL;
656 list_for_each_entry_safe(peer, tmp, &self->list, list) {
657 list_del(&peer->list);
658 hlist_del(&peer->hash);
659 kfree(peer->domain);
660 kfree(peer);
661 }
662 mon->self = NULL;
663 write_unlock_bh(&mon->lock);
664 del_timer_sync(&mon->timer);
665 kfree(self->domain);
666 kfree(self);
667 kfree(mon);
668 }
669
tipc_mon_reinit_self(struct net * net)670 void tipc_mon_reinit_self(struct net *net)
671 {
672 struct tipc_monitor *mon;
673 int bearer_id;
674
675 for (bearer_id = 0; bearer_id < MAX_BEARERS; bearer_id++) {
676 mon = tipc_monitor(net, bearer_id);
677 if (!mon)
678 continue;
679 write_lock_bh(&mon->lock);
680 mon->self->addr = tipc_own_addr(net);
681 write_unlock_bh(&mon->lock);
682 }
683 }
684
tipc_nl_monitor_set_threshold(struct net * net,u32 cluster_size)685 int tipc_nl_monitor_set_threshold(struct net *net, u32 cluster_size)
686 {
687 struct tipc_net *tn = tipc_net(net);
688
689 if (cluster_size > TIPC_CLUSTER_SIZE)
690 return -EINVAL;
691
692 tn->mon_threshold = cluster_size;
693
694 return 0;
695 }
696
tipc_nl_monitor_get_threshold(struct net * net)697 int tipc_nl_monitor_get_threshold(struct net *net)
698 {
699 struct tipc_net *tn = tipc_net(net);
700
701 return tn->mon_threshold;
702 }
703
__tipc_nl_add_monitor_peer(struct tipc_peer * peer,struct tipc_nl_msg * msg)704 static int __tipc_nl_add_monitor_peer(struct tipc_peer *peer,
705 struct tipc_nl_msg *msg)
706 {
707 struct tipc_mon_domain *dom = peer->domain;
708 struct nlattr *attrs;
709 void *hdr;
710
711 hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family,
712 NLM_F_MULTI, TIPC_NL_MON_PEER_GET);
713 if (!hdr)
714 return -EMSGSIZE;
715
716 attrs = nla_nest_start_noflag(msg->skb, TIPC_NLA_MON_PEER);
717 if (!attrs)
718 goto msg_full;
719
720 if (nla_put_u32(msg->skb, TIPC_NLA_MON_PEER_ADDR, peer->addr))
721 goto attr_msg_full;
722 if (nla_put_u32(msg->skb, TIPC_NLA_MON_PEER_APPLIED, peer->applied))
723 goto attr_msg_full;
724
725 if (peer->is_up)
726 if (nla_put_flag(msg->skb, TIPC_NLA_MON_PEER_UP))
727 goto attr_msg_full;
728 if (peer->is_local)
729 if (nla_put_flag(msg->skb, TIPC_NLA_MON_PEER_LOCAL))
730 goto attr_msg_full;
731 if (peer->is_head)
732 if (nla_put_flag(msg->skb, TIPC_NLA_MON_PEER_HEAD))
733 goto attr_msg_full;
734
735 if (dom) {
736 if (nla_put_u32(msg->skb, TIPC_NLA_MON_PEER_DOMGEN, dom->gen))
737 goto attr_msg_full;
738 if (nla_put_u64_64bit(msg->skb, TIPC_NLA_MON_PEER_UPMAP,
739 dom->up_map, TIPC_NLA_MON_PEER_PAD))
740 goto attr_msg_full;
741 if (nla_put(msg->skb, TIPC_NLA_MON_PEER_MEMBERS,
742 dom->member_cnt * sizeof(u32), &dom->members))
743 goto attr_msg_full;
744 }
745
746 nla_nest_end(msg->skb, attrs);
747 genlmsg_end(msg->skb, hdr);
748 return 0;
749
750 attr_msg_full:
751 nla_nest_cancel(msg->skb, attrs);
752 msg_full:
753 genlmsg_cancel(msg->skb, hdr);
754
755 return -EMSGSIZE;
756 }
757
tipc_nl_add_monitor_peer(struct net * net,struct tipc_nl_msg * msg,u32 bearer_id,u32 * prev_node)758 int tipc_nl_add_monitor_peer(struct net *net, struct tipc_nl_msg *msg,
759 u32 bearer_id, u32 *prev_node)
760 {
761 struct tipc_monitor *mon = tipc_monitor(net, bearer_id);
762 struct tipc_peer *peer;
763
764 if (!mon)
765 return -EINVAL;
766
767 read_lock_bh(&mon->lock);
768 peer = mon->self;
769 do {
770 if (*prev_node) {
771 if (peer->addr == *prev_node)
772 *prev_node = 0;
773 else
774 continue;
775 }
776 if (__tipc_nl_add_monitor_peer(peer, msg)) {
777 *prev_node = peer->addr;
778 read_unlock_bh(&mon->lock);
779 return -EMSGSIZE;
780 }
781 } while ((peer = peer_nxt(peer)) != mon->self);
782 read_unlock_bh(&mon->lock);
783
784 return 0;
785 }
786
__tipc_nl_add_monitor(struct net * net,struct tipc_nl_msg * msg,u32 bearer_id)787 int __tipc_nl_add_monitor(struct net *net, struct tipc_nl_msg *msg,
788 u32 bearer_id)
789 {
790 struct tipc_monitor *mon = tipc_monitor(net, bearer_id);
791 char bearer_name[TIPC_MAX_BEARER_NAME];
792 struct nlattr *attrs;
793 void *hdr;
794 int ret;
795
796 ret = tipc_bearer_get_name(net, bearer_name, bearer_id);
797 if (ret || !mon)
798 return 0;
799
800 hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family,
801 NLM_F_MULTI, TIPC_NL_MON_GET);
802 if (!hdr)
803 return -EMSGSIZE;
804
805 attrs = nla_nest_start_noflag(msg->skb, TIPC_NLA_MON);
806 if (!attrs)
807 goto msg_full;
808
809 read_lock_bh(&mon->lock);
810 if (nla_put_u32(msg->skb, TIPC_NLA_MON_REF, bearer_id))
811 goto attr_msg_full;
812 if (tipc_mon_is_active(net, mon))
813 if (nla_put_flag(msg->skb, TIPC_NLA_MON_ACTIVE))
814 goto attr_msg_full;
815 if (nla_put_string(msg->skb, TIPC_NLA_MON_BEARER_NAME, bearer_name))
816 goto attr_msg_full;
817 if (nla_put_u32(msg->skb, TIPC_NLA_MON_PEERCNT, mon->peer_cnt))
818 goto attr_msg_full;
819 if (nla_put_u32(msg->skb, TIPC_NLA_MON_LISTGEN, mon->list_gen))
820 goto attr_msg_full;
821
822 read_unlock_bh(&mon->lock);
823 nla_nest_end(msg->skb, attrs);
824 genlmsg_end(msg->skb, hdr);
825
826 return 0;
827
828 attr_msg_full:
829 read_unlock_bh(&mon->lock);
830 nla_nest_cancel(msg->skb, attrs);
831 msg_full:
832 genlmsg_cancel(msg->skb, hdr);
833
834 return -EMSGSIZE;
835 }
836