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 & (1ULL << 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 (new_member_cnt > MAX_MON_DOMAIN) 469 return; 470 if (dlen < dom_rec_len(arrv_dom, 0)) 471 return; 472 if (dlen != dom_rec_len(arrv_dom, new_member_cnt)) 473 return; 474 if ((dlen < new_dlen) || ntohs(arrv_dom->len) != new_dlen) 475 return; 476 477 /* Synch generation numbers with peer if link just came up */ 478 if (!state->synched) { 479 state->peer_gen = new_gen - 1; 480 state->acked_gen = acked_gen; 481 state->synched = true; 482 } 483 484 if (more(acked_gen, state->acked_gen)) 485 state->acked_gen = acked_gen; 486 487 /* Drop duplicate unless we are waiting for a probe response */ 488 if (!more(new_gen, state->peer_gen) && !probing) 489 return; 490 491 write_lock_bh(&mon->lock); 492 peer = get_peer(mon, addr); 493 if (!peer || !peer->is_up) 494 goto exit; 495 496 /* Peer is confirmed, stop any ongoing probing */ 497 peer->down_cnt = 0; 498 499 /* Task is done for duplicate record */ 500 if (!more(new_gen, state->peer_gen)) 501 goto exit; 502 503 state->peer_gen = new_gen; 504 505 /* Cache current domain record for later use */ 506 dom_bef.member_cnt = 0; 507 dom = peer->domain; 508 if (dom) 509 memcpy(&dom_bef, dom, dom->len); 510 511 /* Transform and store received domain record */ 512 if (!dom || (dom->len < new_dlen)) { 513 kfree(dom); 514 dom = kmalloc(new_dlen, GFP_ATOMIC); 515 peer->domain = dom; 516 if (!dom) 517 goto exit; 518 } 519 dom->len = new_dlen; 520 dom->gen = new_gen; 521 dom->member_cnt = new_member_cnt; 522 dom->up_map = be64_to_cpu(arrv_dom->up_map); 523 for (i = 0; i < new_member_cnt; i++) 524 dom->members[i] = ntohl(arrv_dom->members[i]); 525 526 /* Update peers affected by this domain record */ 527 applied_bef = peer->applied; 528 mon_apply_domain(mon, peer); 529 mon_identify_lost_members(peer, &dom_bef, applied_bef); 530 mon_assign_roles(mon, peer_head(peer)); 531exit: 532 write_unlock_bh(&mon->lock); 533} 534 535void tipc_mon_prep(struct net *net, void *data, int *dlen, 536 struct tipc_mon_state *state, int bearer_id) 537{ 538 struct tipc_monitor *mon = tipc_monitor(net, bearer_id); 539 struct tipc_mon_domain *dom = data; 540 u16 gen = mon->dom_gen; 541 u16 len; 542 543 /* Send invalid record if not active */ 544 if (!tipc_mon_is_active(net, mon)) { 545 dom->len = 0; 546 return; 547 } 548 549 /* Send only a dummy record with ack if peer has acked our last sent */ 550 if (likely(state->acked_gen == gen)) { 551 len = dom_rec_len(dom, 0); 552 *dlen = len; 553 dom->len = htons(len); 554 dom->gen = htons(gen); 555 dom->ack_gen = htons(state->peer_gen); 556 dom->member_cnt = 0; 557 return; 558 } 559 /* Send the full record */ 560 read_lock_bh(&mon->lock); 561 len = ntohs(mon->cache.len); 562 *dlen = len; 563 memcpy(data, &mon->cache, len); 564 read_unlock_bh(&mon->lock); 565 dom->ack_gen = htons(state->peer_gen); 566} 567 568void tipc_mon_get_state(struct net *net, u32 addr, 569 struct tipc_mon_state *state, 570 int bearer_id) 571{ 572 struct tipc_monitor *mon = tipc_monitor(net, bearer_id); 573 struct tipc_peer *peer; 574 575 if (!tipc_mon_is_active(net, mon)) { 576 state->probing = false; 577 state->monitoring = true; 578 return; 579 } 580 581 /* Used cached state if table has not changed */ 582 if (!state->probing && 583 (state->list_gen == mon->list_gen) && 584 (state->acked_gen == mon->dom_gen)) 585 return; 586 587 read_lock_bh(&mon->lock); 588 peer = get_peer(mon, addr); 589 if (peer) { 590 state->probing = state->acked_gen != mon->dom_gen; 591 state->probing |= peer->down_cnt; 592 state->reset |= peer->down_cnt >= MAX_PEER_DOWN_EVENTS; 593 state->monitoring = peer->is_local; 594 state->monitoring |= peer->is_head; 595 state->list_gen = mon->list_gen; 596 } 597 read_unlock_bh(&mon->lock); 598} 599 600static void mon_timeout(struct timer_list *t) 601{ 602 struct tipc_monitor *mon = from_timer(mon, t, timer); 603 struct tipc_peer *self; 604 int best_member_cnt = dom_size(mon->peer_cnt) - 1; 605 606 write_lock_bh(&mon->lock); 607 self = mon->self; 608 if (self && (best_member_cnt != self->applied)) { 609 mon_update_local_domain(mon); 610 mon_assign_roles(mon, self); 611 } 612 write_unlock_bh(&mon->lock); 613 mod_timer(&mon->timer, jiffies + mon->timer_intv); 614} 615 616int tipc_mon_create(struct net *net, int bearer_id) 617{ 618 struct tipc_net *tn = tipc_net(net); 619 struct tipc_monitor *mon; 620 struct tipc_peer *self; 621 struct tipc_mon_domain *dom; 622 623 if (tn->monitors[bearer_id]) 624 return 0; 625 626 mon = kzalloc(sizeof(*mon), GFP_ATOMIC); 627 self = kzalloc(sizeof(*self), GFP_ATOMIC); 628 dom = kzalloc(sizeof(*dom), GFP_ATOMIC); 629 if (!mon || !self || !dom) { 630 kfree(mon); 631 kfree(self); 632 kfree(dom); 633 return -ENOMEM; 634 } 635 tn->monitors[bearer_id] = mon; 636 rwlock_init(&mon->lock); 637 mon->net = net; 638 mon->peer_cnt = 1; 639 mon->self = self; 640 self->domain = dom; 641 self->addr = tipc_own_addr(net); 642 self->is_up = true; 643 self->is_head = true; 644 INIT_LIST_HEAD(&self->list); 645 timer_setup(&mon->timer, mon_timeout, 0); 646 mon->timer_intv = msecs_to_jiffies(MON_TIMEOUT + (tn->random & 0xffff)); 647 mod_timer(&mon->timer, jiffies + mon->timer_intv); 648 return 0; 649} 650 651void tipc_mon_delete(struct net *net, int bearer_id) 652{ 653 struct tipc_net *tn = tipc_net(net); 654 struct tipc_monitor *mon = tipc_monitor(net, bearer_id); 655 struct tipc_peer *self; 656 struct tipc_peer *peer, *tmp; 657 658 if (!mon) 659 return; 660 661 self = get_self(net, bearer_id); 662 write_lock_bh(&mon->lock); 663 tn->monitors[bearer_id] = NULL; 664 list_for_each_entry_safe(peer, tmp, &self->list, list) { 665 list_del(&peer->list); 666 hlist_del(&peer->hash); 667 kfree(peer->domain); 668 kfree(peer); 669 } 670 mon->self = NULL; 671 write_unlock_bh(&mon->lock); 672 del_timer_sync(&mon->timer); 673 kfree(self->domain); 674 kfree(self); 675 kfree(mon); 676} 677 678void tipc_mon_reinit_self(struct net *net) 679{ 680 struct tipc_monitor *mon; 681 int bearer_id; 682 683 for (bearer_id = 0; bearer_id < MAX_BEARERS; bearer_id++) { 684 mon = tipc_monitor(net, bearer_id); 685 if (!mon) 686 continue; 687 write_lock_bh(&mon->lock); 688 mon->self->addr = tipc_own_addr(net); 689 write_unlock_bh(&mon->lock); 690 } 691} 692 693int tipc_nl_monitor_set_threshold(struct net *net, u32 cluster_size) 694{ 695 struct tipc_net *tn = tipc_net(net); 696 697 if (cluster_size > TIPC_CLUSTER_SIZE) 698 return -EINVAL; 699 700 tn->mon_threshold = cluster_size; 701 702 return 0; 703} 704 705int tipc_nl_monitor_get_threshold(struct net *net) 706{ 707 struct tipc_net *tn = tipc_net(net); 708 709 return tn->mon_threshold; 710} 711 712static int __tipc_nl_add_monitor_peer(struct tipc_peer *peer, 713 struct tipc_nl_msg *msg) 714{ 715 struct tipc_mon_domain *dom = peer->domain; 716 struct nlattr *attrs; 717 void *hdr; 718 719 hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family, 720 NLM_F_MULTI, TIPC_NL_MON_PEER_GET); 721 if (!hdr) 722 return -EMSGSIZE; 723 724 attrs = nla_nest_start_noflag(msg->skb, TIPC_NLA_MON_PEER); 725 if (!attrs) 726 goto msg_full; 727 728 if (nla_put_u32(msg->skb, TIPC_NLA_MON_PEER_ADDR, peer->addr)) 729 goto attr_msg_full; 730 if (nla_put_u32(msg->skb, TIPC_NLA_MON_PEER_APPLIED, peer->applied)) 731 goto attr_msg_full; 732 733 if (peer->is_up) 734 if (nla_put_flag(msg->skb, TIPC_NLA_MON_PEER_UP)) 735 goto attr_msg_full; 736 if (peer->is_local) 737 if (nla_put_flag(msg->skb, TIPC_NLA_MON_PEER_LOCAL)) 738 goto attr_msg_full; 739 if (peer->is_head) 740 if (nla_put_flag(msg->skb, TIPC_NLA_MON_PEER_HEAD)) 741 goto attr_msg_full; 742 743 if (dom) { 744 if (nla_put_u32(msg->skb, TIPC_NLA_MON_PEER_DOMGEN, dom->gen)) 745 goto attr_msg_full; 746 if (nla_put_u64_64bit(msg->skb, TIPC_NLA_MON_PEER_UPMAP, 747 dom->up_map, TIPC_NLA_MON_PEER_PAD)) 748 goto attr_msg_full; 749 if (nla_put(msg->skb, TIPC_NLA_MON_PEER_MEMBERS, 750 dom->member_cnt * sizeof(u32), &dom->members)) 751 goto attr_msg_full; 752 } 753 754 nla_nest_end(msg->skb, attrs); 755 genlmsg_end(msg->skb, hdr); 756 return 0; 757 758attr_msg_full: 759 nla_nest_cancel(msg->skb, attrs); 760msg_full: 761 genlmsg_cancel(msg->skb, hdr); 762 763 return -EMSGSIZE; 764} 765 766int tipc_nl_add_monitor_peer(struct net *net, struct tipc_nl_msg *msg, 767 u32 bearer_id, u32 *prev_node) 768{ 769 struct tipc_monitor *mon = tipc_monitor(net, bearer_id); 770 struct tipc_peer *peer; 771 772 if (!mon) 773 return -EINVAL; 774 775 read_lock_bh(&mon->lock); 776 peer = mon->self; 777 do { 778 if (*prev_node) { 779 if (peer->addr == *prev_node) 780 *prev_node = 0; 781 else 782 continue; 783 } 784 if (__tipc_nl_add_monitor_peer(peer, msg)) { 785 *prev_node = peer->addr; 786 read_unlock_bh(&mon->lock); 787 return -EMSGSIZE; 788 } 789 } while ((peer = peer_nxt(peer)) != mon->self); 790 read_unlock_bh(&mon->lock); 791 792 return 0; 793} 794 795int __tipc_nl_add_monitor(struct net *net, struct tipc_nl_msg *msg, 796 u32 bearer_id) 797{ 798 struct tipc_monitor *mon = tipc_monitor(net, bearer_id); 799 char bearer_name[TIPC_MAX_BEARER_NAME]; 800 struct nlattr *attrs; 801 void *hdr; 802 int ret; 803 804 ret = tipc_bearer_get_name(net, bearer_name, bearer_id); 805 if (ret || !mon) 806 return 0; 807 808 hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family, 809 NLM_F_MULTI, TIPC_NL_MON_GET); 810 if (!hdr) 811 return -EMSGSIZE; 812 813 attrs = nla_nest_start_noflag(msg->skb, TIPC_NLA_MON); 814 if (!attrs) 815 goto msg_full; 816 817 read_lock_bh(&mon->lock); 818 if (nla_put_u32(msg->skb, TIPC_NLA_MON_REF, bearer_id)) 819 goto attr_msg_full; 820 if (tipc_mon_is_active(net, mon)) 821 if (nla_put_flag(msg->skb, TIPC_NLA_MON_ACTIVE)) 822 goto attr_msg_full; 823 if (nla_put_string(msg->skb, TIPC_NLA_MON_BEARER_NAME, bearer_name)) 824 goto attr_msg_full; 825 if (nla_put_u32(msg->skb, TIPC_NLA_MON_PEERCNT, mon->peer_cnt)) 826 goto attr_msg_full; 827 if (nla_put_u32(msg->skb, TIPC_NLA_MON_LISTGEN, mon->list_gen)) 828 goto attr_msg_full; 829 830 read_unlock_bh(&mon->lock); 831 nla_nest_end(msg->skb, attrs); 832 genlmsg_end(msg->skb, hdr); 833 834 return 0; 835 836attr_msg_full: 837 read_unlock_bh(&mon->lock); 838 nla_nest_cancel(msg->skb, attrs); 839msg_full: 840 genlmsg_cancel(msg->skb, hdr); 841 842 return -EMSGSIZE; 843} 844