1 /* 2 * net/tipc/node.c: TIPC node management routines 3 * 4 * Copyright (c) 2000-2006, 2012-2016, Ericsson AB 5 * Copyright (c) 2005-2006, 2010-2014, Wind River Systems 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions are met: 10 * 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. Neither the names of the copyright holders nor the names of its 17 * contributors may be used to endorse or promote products derived from 18 * this software without specific prior written permission. 19 * 20 * Alternatively, this software may be distributed under the terms of the 21 * GNU General Public License ("GPL") version 2 as published by the Free 22 * Software Foundation. 23 * 24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 25 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 27 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 28 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 29 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 30 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 31 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 32 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 33 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 34 * POSSIBILITY OF SUCH DAMAGE. 35 */ 36 37 #include "core.h" 38 #include "link.h" 39 #include "node.h" 40 #include "name_distr.h" 41 #include "socket.h" 42 #include "bcast.h" 43 #include "monitor.h" 44 #include "discover.h" 45 #include "netlink.h" 46 47 #define INVALID_NODE_SIG 0x10000 48 49 /* Flags used to take different actions according to flag type 50 * TIPC_NOTIFY_NODE_DOWN: notify node is down 51 * TIPC_NOTIFY_NODE_UP: notify node is up 52 * TIPC_DISTRIBUTE_NAME: publish or withdraw link state name type 53 */ 54 enum { 55 TIPC_NOTIFY_NODE_DOWN = (1 << 3), 56 TIPC_NOTIFY_NODE_UP = (1 << 4), 57 TIPC_NOTIFY_LINK_UP = (1 << 6), 58 TIPC_NOTIFY_LINK_DOWN = (1 << 7) 59 }; 60 61 struct tipc_link_entry { 62 struct tipc_link *link; 63 spinlock_t lock; /* per link */ 64 u32 mtu; 65 struct sk_buff_head inputq; 66 struct tipc_media_addr maddr; 67 }; 68 69 struct tipc_bclink_entry { 70 struct tipc_link *link; 71 struct sk_buff_head inputq1; 72 struct sk_buff_head arrvq; 73 struct sk_buff_head inputq2; 74 struct sk_buff_head namedq; 75 }; 76 77 /** 78 * struct tipc_node - TIPC node structure 79 * @addr: network address of node 80 * @ref: reference counter to node object 81 * @lock: rwlock governing access to structure 82 * @net: the applicable net namespace 83 * @hash: links to adjacent nodes in unsorted hash chain 84 * @inputq: pointer to input queue containing messages for msg event 85 * @namedq: pointer to name table input queue with name table messages 86 * @active_links: bearer ids of active links, used as index into links[] array 87 * @links: array containing references to all links to node 88 * @action_flags: bit mask of different types of node actions 89 * @state: connectivity state vs peer node 90 * @sync_point: sequence number where synch/failover is finished 91 * @list: links to adjacent nodes in sorted list of cluster's nodes 92 * @working_links: number of working links to node (both active and standby) 93 * @link_cnt: number of links to node 94 * @capabilities: bitmap, indicating peer node's functional capabilities 95 * @signature: node instance identifier 96 * @link_id: local and remote bearer ids of changing link, if any 97 * @publ_list: list of publications 98 * @rcu: rcu struct for tipc_node 99 */ 100 struct tipc_node { 101 u32 addr; 102 struct kref kref; 103 rwlock_t lock; 104 struct net *net; 105 struct hlist_node hash; 106 int active_links[2]; 107 struct tipc_link_entry links[MAX_BEARERS]; 108 struct tipc_bclink_entry bc_entry; 109 int action_flags; 110 struct list_head list; 111 int state; 112 u16 sync_point; 113 int link_cnt; 114 u16 working_links; 115 u16 capabilities; 116 u32 signature; 117 u32 link_id; 118 struct list_head publ_list; 119 struct list_head conn_sks; 120 unsigned long keepalive_intv; 121 struct timer_list timer; 122 struct rcu_head rcu; 123 }; 124 125 /* Node FSM states and events: 126 */ 127 enum { 128 SELF_DOWN_PEER_DOWN = 0xdd, 129 SELF_UP_PEER_UP = 0xaa, 130 SELF_DOWN_PEER_LEAVING = 0xd1, 131 SELF_UP_PEER_COMING = 0xac, 132 SELF_COMING_PEER_UP = 0xca, 133 SELF_LEAVING_PEER_DOWN = 0x1d, 134 NODE_FAILINGOVER = 0xf0, 135 NODE_SYNCHING = 0xcc 136 }; 137 138 enum { 139 SELF_ESTABL_CONTACT_EVT = 0xece, 140 SELF_LOST_CONTACT_EVT = 0x1ce, 141 PEER_ESTABL_CONTACT_EVT = 0x9ece, 142 PEER_LOST_CONTACT_EVT = 0x91ce, 143 NODE_FAILOVER_BEGIN_EVT = 0xfbe, 144 NODE_FAILOVER_END_EVT = 0xfee, 145 NODE_SYNCH_BEGIN_EVT = 0xcbe, 146 NODE_SYNCH_END_EVT = 0xcee 147 }; 148 149 static void __tipc_node_link_down(struct tipc_node *n, int *bearer_id, 150 struct sk_buff_head *xmitq, 151 struct tipc_media_addr **maddr); 152 static void tipc_node_link_down(struct tipc_node *n, int bearer_id, 153 bool delete); 154 static void node_lost_contact(struct tipc_node *n, struct sk_buff_head *inputq); 155 static void tipc_node_delete(struct tipc_node *node); 156 static void tipc_node_timeout(unsigned long data); 157 static void tipc_node_fsm_evt(struct tipc_node *n, int evt); 158 static struct tipc_node *tipc_node_find(struct net *net, u32 addr); 159 static void tipc_node_put(struct tipc_node *node); 160 static bool tipc_node_is_up(struct tipc_node *n); 161 162 struct tipc_sock_conn { 163 u32 port; 164 u32 peer_port; 165 u32 peer_node; 166 struct list_head list; 167 }; 168 169 static struct tipc_link *node_active_link(struct tipc_node *n, int sel) 170 { 171 int bearer_id = n->active_links[sel & 1]; 172 173 if (unlikely(bearer_id == INVALID_BEARER_ID)) 174 return NULL; 175 176 return n->links[bearer_id].link; 177 } 178 179 int tipc_node_get_mtu(struct net *net, u32 addr, u32 sel) 180 { 181 struct tipc_node *n; 182 int bearer_id; 183 unsigned int mtu = MAX_MSG_SIZE; 184 185 n = tipc_node_find(net, addr); 186 if (unlikely(!n)) 187 return mtu; 188 189 bearer_id = n->active_links[sel & 1]; 190 if (likely(bearer_id != INVALID_BEARER_ID)) 191 mtu = n->links[bearer_id].mtu; 192 tipc_node_put(n); 193 return mtu; 194 } 195 196 u16 tipc_node_get_capabilities(struct net *net, u32 addr) 197 { 198 struct tipc_node *n; 199 u16 caps; 200 201 n = tipc_node_find(net, addr); 202 if (unlikely(!n)) 203 return TIPC_NODE_CAPABILITIES; 204 caps = n->capabilities; 205 tipc_node_put(n); 206 return caps; 207 } 208 209 static void tipc_node_kref_release(struct kref *kref) 210 { 211 struct tipc_node *n = container_of(kref, struct tipc_node, kref); 212 213 kfree(n->bc_entry.link); 214 kfree_rcu(n, rcu); 215 } 216 217 static void tipc_node_put(struct tipc_node *node) 218 { 219 kref_put(&node->kref, tipc_node_kref_release); 220 } 221 222 static void tipc_node_get(struct tipc_node *node) 223 { 224 kref_get(&node->kref); 225 } 226 227 /* 228 * tipc_node_find - locate specified node object, if it exists 229 */ 230 static struct tipc_node *tipc_node_find(struct net *net, u32 addr) 231 { 232 struct tipc_net *tn = tipc_net(net); 233 struct tipc_node *node; 234 unsigned int thash = tipc_hashfn(addr); 235 236 if (unlikely(!in_own_cluster_exact(net, addr))) 237 return NULL; 238 239 rcu_read_lock(); 240 hlist_for_each_entry_rcu(node, &tn->node_htable[thash], hash) { 241 if (node->addr != addr) 242 continue; 243 if (!kref_get_unless_zero(&node->kref)) 244 node = NULL; 245 break; 246 } 247 rcu_read_unlock(); 248 return node; 249 } 250 251 static void tipc_node_read_lock(struct tipc_node *n) 252 { 253 read_lock_bh(&n->lock); 254 } 255 256 static void tipc_node_read_unlock(struct tipc_node *n) 257 { 258 read_unlock_bh(&n->lock); 259 } 260 261 static void tipc_node_write_lock(struct tipc_node *n) 262 { 263 write_lock_bh(&n->lock); 264 } 265 266 static void tipc_node_write_unlock(struct tipc_node *n) 267 { 268 struct net *net = n->net; 269 u32 addr = 0; 270 u32 flags = n->action_flags; 271 u32 link_id = 0; 272 u32 bearer_id; 273 struct list_head *publ_list; 274 275 if (likely(!flags)) { 276 write_unlock_bh(&n->lock); 277 return; 278 } 279 280 addr = n->addr; 281 link_id = n->link_id; 282 bearer_id = link_id & 0xffff; 283 publ_list = &n->publ_list; 284 285 n->action_flags &= ~(TIPC_NOTIFY_NODE_DOWN | TIPC_NOTIFY_NODE_UP | 286 TIPC_NOTIFY_LINK_DOWN | TIPC_NOTIFY_LINK_UP); 287 288 write_unlock_bh(&n->lock); 289 290 if (flags & TIPC_NOTIFY_NODE_DOWN) 291 tipc_publ_notify(net, publ_list, addr); 292 293 if (flags & TIPC_NOTIFY_NODE_UP) 294 tipc_named_node_up(net, addr); 295 296 if (flags & TIPC_NOTIFY_LINK_UP) { 297 tipc_mon_peer_up(net, addr, bearer_id); 298 tipc_nametbl_publish(net, TIPC_LINK_STATE, addr, addr, 299 TIPC_NODE_SCOPE, link_id, addr); 300 } 301 if (flags & TIPC_NOTIFY_LINK_DOWN) { 302 tipc_mon_peer_down(net, addr, bearer_id); 303 tipc_nametbl_withdraw(net, TIPC_LINK_STATE, addr, 304 link_id, addr); 305 } 306 } 307 308 struct tipc_node *tipc_node_create(struct net *net, u32 addr, u16 capabilities) 309 { 310 struct tipc_net *tn = net_generic(net, tipc_net_id); 311 struct tipc_node *n, *temp_node; 312 int i; 313 314 spin_lock_bh(&tn->node_list_lock); 315 n = tipc_node_find(net, addr); 316 if (n) { 317 /* Same node may come back with new capabilities */ 318 n->capabilities = capabilities; 319 goto exit; 320 } 321 n = kzalloc(sizeof(*n), GFP_ATOMIC); 322 if (!n) { 323 pr_warn("Node creation failed, no memory\n"); 324 goto exit; 325 } 326 n->addr = addr; 327 n->net = net; 328 n->capabilities = capabilities; 329 kref_init(&n->kref); 330 rwlock_init(&n->lock); 331 INIT_HLIST_NODE(&n->hash); 332 INIT_LIST_HEAD(&n->list); 333 INIT_LIST_HEAD(&n->publ_list); 334 INIT_LIST_HEAD(&n->conn_sks); 335 skb_queue_head_init(&n->bc_entry.namedq); 336 skb_queue_head_init(&n->bc_entry.inputq1); 337 __skb_queue_head_init(&n->bc_entry.arrvq); 338 skb_queue_head_init(&n->bc_entry.inputq2); 339 for (i = 0; i < MAX_BEARERS; i++) 340 spin_lock_init(&n->links[i].lock); 341 n->state = SELF_DOWN_PEER_LEAVING; 342 n->signature = INVALID_NODE_SIG; 343 n->active_links[0] = INVALID_BEARER_ID; 344 n->active_links[1] = INVALID_BEARER_ID; 345 if (!tipc_link_bc_create(net, tipc_own_addr(net), n->addr, 346 U16_MAX, 347 tipc_link_window(tipc_bc_sndlink(net)), 348 n->capabilities, 349 &n->bc_entry.inputq1, 350 &n->bc_entry.namedq, 351 tipc_bc_sndlink(net), 352 &n->bc_entry.link)) { 353 pr_warn("Broadcast rcv link creation failed, no memory\n"); 354 kfree(n); 355 n = NULL; 356 goto exit; 357 } 358 tipc_node_get(n); 359 setup_timer(&n->timer, tipc_node_timeout, (unsigned long)n); 360 n->keepalive_intv = U32_MAX; 361 hlist_add_head_rcu(&n->hash, &tn->node_htable[tipc_hashfn(addr)]); 362 list_for_each_entry_rcu(temp_node, &tn->node_list, list) { 363 if (n->addr < temp_node->addr) 364 break; 365 } 366 list_add_tail_rcu(&n->list, &temp_node->list); 367 exit: 368 spin_unlock_bh(&tn->node_list_lock); 369 return n; 370 } 371 372 static void tipc_node_calculate_timer(struct tipc_node *n, struct tipc_link *l) 373 { 374 unsigned long tol = tipc_link_tolerance(l); 375 unsigned long intv = ((tol / 4) > 500) ? 500 : tol / 4; 376 377 /* Link with lowest tolerance determines timer interval */ 378 if (intv < n->keepalive_intv) 379 n->keepalive_intv = intv; 380 381 /* Ensure link's abort limit corresponds to current tolerance */ 382 tipc_link_set_abort_limit(l, tol / n->keepalive_intv); 383 } 384 385 static void tipc_node_delete(struct tipc_node *node) 386 { 387 list_del_rcu(&node->list); 388 hlist_del_rcu(&node->hash); 389 tipc_node_put(node); 390 391 del_timer_sync(&node->timer); 392 tipc_node_put(node); 393 } 394 395 void tipc_node_stop(struct net *net) 396 { 397 struct tipc_net *tn = tipc_net(net); 398 struct tipc_node *node, *t_node; 399 400 spin_lock_bh(&tn->node_list_lock); 401 list_for_each_entry_safe(node, t_node, &tn->node_list, list) 402 tipc_node_delete(node); 403 spin_unlock_bh(&tn->node_list_lock); 404 } 405 406 void tipc_node_subscribe(struct net *net, struct list_head *subscr, u32 addr) 407 { 408 struct tipc_node *n; 409 410 if (in_own_node(net, addr)) 411 return; 412 413 n = tipc_node_find(net, addr); 414 if (!n) { 415 pr_warn("Node subscribe rejected, unknown node 0x%x\n", addr); 416 return; 417 } 418 tipc_node_write_lock(n); 419 list_add_tail(subscr, &n->publ_list); 420 tipc_node_write_unlock(n); 421 tipc_node_put(n); 422 } 423 424 void tipc_node_unsubscribe(struct net *net, struct list_head *subscr, u32 addr) 425 { 426 struct tipc_node *n; 427 428 if (in_own_node(net, addr)) 429 return; 430 431 n = tipc_node_find(net, addr); 432 if (!n) { 433 pr_warn("Node unsubscribe rejected, unknown node 0x%x\n", addr); 434 return; 435 } 436 tipc_node_write_lock(n); 437 list_del_init(subscr); 438 tipc_node_write_unlock(n); 439 tipc_node_put(n); 440 } 441 442 int tipc_node_add_conn(struct net *net, u32 dnode, u32 port, u32 peer_port) 443 { 444 struct tipc_node *node; 445 struct tipc_sock_conn *conn; 446 int err = 0; 447 448 if (in_own_node(net, dnode)) 449 return 0; 450 451 node = tipc_node_find(net, dnode); 452 if (!node) { 453 pr_warn("Connecting sock to node 0x%x failed\n", dnode); 454 return -EHOSTUNREACH; 455 } 456 conn = kmalloc(sizeof(*conn), GFP_ATOMIC); 457 if (!conn) { 458 err = -EHOSTUNREACH; 459 goto exit; 460 } 461 conn->peer_node = dnode; 462 conn->port = port; 463 conn->peer_port = peer_port; 464 465 tipc_node_write_lock(node); 466 list_add_tail(&conn->list, &node->conn_sks); 467 tipc_node_write_unlock(node); 468 exit: 469 tipc_node_put(node); 470 return err; 471 } 472 473 void tipc_node_remove_conn(struct net *net, u32 dnode, u32 port) 474 { 475 struct tipc_node *node; 476 struct tipc_sock_conn *conn, *safe; 477 478 if (in_own_node(net, dnode)) 479 return; 480 481 node = tipc_node_find(net, dnode); 482 if (!node) 483 return; 484 485 tipc_node_write_lock(node); 486 list_for_each_entry_safe(conn, safe, &node->conn_sks, list) { 487 if (port != conn->port) 488 continue; 489 list_del(&conn->list); 490 kfree(conn); 491 } 492 tipc_node_write_unlock(node); 493 tipc_node_put(node); 494 } 495 496 /* tipc_node_timeout - handle expiration of node timer 497 */ 498 static void tipc_node_timeout(unsigned long data) 499 { 500 struct tipc_node *n = (struct tipc_node *)data; 501 struct tipc_link_entry *le; 502 struct sk_buff_head xmitq; 503 int bearer_id; 504 int rc = 0; 505 506 __skb_queue_head_init(&xmitq); 507 508 for (bearer_id = 0; bearer_id < MAX_BEARERS; bearer_id++) { 509 tipc_node_read_lock(n); 510 le = &n->links[bearer_id]; 511 spin_lock_bh(&le->lock); 512 if (le->link) { 513 /* Link tolerance may change asynchronously: */ 514 tipc_node_calculate_timer(n, le->link); 515 rc = tipc_link_timeout(le->link, &xmitq); 516 } 517 spin_unlock_bh(&le->lock); 518 tipc_node_read_unlock(n); 519 tipc_bearer_xmit(n->net, bearer_id, &xmitq, &le->maddr); 520 if (rc & TIPC_LINK_DOWN_EVT) 521 tipc_node_link_down(n, bearer_id, false); 522 } 523 mod_timer(&n->timer, jiffies + msecs_to_jiffies(n->keepalive_intv)); 524 } 525 526 /** 527 * __tipc_node_link_up - handle addition of link 528 * Node lock must be held by caller 529 * Link becomes active (alone or shared) or standby, depending on its priority. 530 */ 531 static void __tipc_node_link_up(struct tipc_node *n, int bearer_id, 532 struct sk_buff_head *xmitq) 533 { 534 int *slot0 = &n->active_links[0]; 535 int *slot1 = &n->active_links[1]; 536 struct tipc_link *ol = node_active_link(n, 0); 537 struct tipc_link *nl = n->links[bearer_id].link; 538 539 if (!nl || tipc_link_is_up(nl)) 540 return; 541 542 tipc_link_fsm_evt(nl, LINK_ESTABLISH_EVT); 543 if (!tipc_link_is_up(nl)) 544 return; 545 546 n->working_links++; 547 n->action_flags |= TIPC_NOTIFY_LINK_UP; 548 n->link_id = tipc_link_id(nl); 549 550 /* Leave room for tunnel header when returning 'mtu' to users: */ 551 n->links[bearer_id].mtu = tipc_link_mtu(nl) - INT_H_SIZE; 552 553 tipc_bearer_add_dest(n->net, bearer_id, n->addr); 554 tipc_bcast_inc_bearer_dst_cnt(n->net, bearer_id); 555 556 pr_debug("Established link <%s> on network plane %c\n", 557 tipc_link_name(nl), tipc_link_plane(nl)); 558 559 /* Ensure that a STATE message goes first */ 560 tipc_link_build_state_msg(nl, xmitq); 561 562 /* First link? => give it both slots */ 563 if (!ol) { 564 *slot0 = bearer_id; 565 *slot1 = bearer_id; 566 tipc_node_fsm_evt(n, SELF_ESTABL_CONTACT_EVT); 567 n->action_flags |= TIPC_NOTIFY_NODE_UP; 568 tipc_link_set_active(nl, true); 569 tipc_bcast_add_peer(n->net, nl, xmitq); 570 return; 571 } 572 573 /* Second link => redistribute slots */ 574 if (tipc_link_prio(nl) > tipc_link_prio(ol)) { 575 pr_debug("Old link <%s> becomes standby\n", tipc_link_name(ol)); 576 *slot0 = bearer_id; 577 *slot1 = bearer_id; 578 tipc_link_set_active(nl, true); 579 tipc_link_set_active(ol, false); 580 } else if (tipc_link_prio(nl) == tipc_link_prio(ol)) { 581 tipc_link_set_active(nl, true); 582 *slot1 = bearer_id; 583 } else { 584 pr_debug("New link <%s> is standby\n", tipc_link_name(nl)); 585 } 586 587 /* Prepare synchronization with first link */ 588 tipc_link_tnl_prepare(ol, nl, SYNCH_MSG, xmitq); 589 } 590 591 /** 592 * tipc_node_link_up - handle addition of link 593 * 594 * Link becomes active (alone or shared) or standby, depending on its priority. 595 */ 596 static void tipc_node_link_up(struct tipc_node *n, int bearer_id, 597 struct sk_buff_head *xmitq) 598 { 599 struct tipc_media_addr *maddr; 600 601 tipc_node_write_lock(n); 602 __tipc_node_link_up(n, bearer_id, xmitq); 603 maddr = &n->links[bearer_id].maddr; 604 tipc_bearer_xmit(n->net, bearer_id, xmitq, maddr); 605 tipc_node_write_unlock(n); 606 } 607 608 /** 609 * __tipc_node_link_down - handle loss of link 610 */ 611 static void __tipc_node_link_down(struct tipc_node *n, int *bearer_id, 612 struct sk_buff_head *xmitq, 613 struct tipc_media_addr **maddr) 614 { 615 struct tipc_link_entry *le = &n->links[*bearer_id]; 616 int *slot0 = &n->active_links[0]; 617 int *slot1 = &n->active_links[1]; 618 int i, highest = 0, prio; 619 struct tipc_link *l, *_l, *tnl; 620 621 l = n->links[*bearer_id].link; 622 if (!l || tipc_link_is_reset(l)) 623 return; 624 625 n->working_links--; 626 n->action_flags |= TIPC_NOTIFY_LINK_DOWN; 627 n->link_id = tipc_link_id(l); 628 629 tipc_bearer_remove_dest(n->net, *bearer_id, n->addr); 630 631 pr_debug("Lost link <%s> on network plane %c\n", 632 tipc_link_name(l), tipc_link_plane(l)); 633 634 /* Select new active link if any available */ 635 *slot0 = INVALID_BEARER_ID; 636 *slot1 = INVALID_BEARER_ID; 637 for (i = 0; i < MAX_BEARERS; i++) { 638 _l = n->links[i].link; 639 if (!_l || !tipc_link_is_up(_l)) 640 continue; 641 if (_l == l) 642 continue; 643 prio = tipc_link_prio(_l); 644 if (prio < highest) 645 continue; 646 if (prio > highest) { 647 highest = prio; 648 *slot0 = i; 649 *slot1 = i; 650 continue; 651 } 652 *slot1 = i; 653 } 654 655 if (!tipc_node_is_up(n)) { 656 if (tipc_link_peer_is_down(l)) 657 tipc_node_fsm_evt(n, PEER_LOST_CONTACT_EVT); 658 tipc_node_fsm_evt(n, SELF_LOST_CONTACT_EVT); 659 tipc_link_fsm_evt(l, LINK_RESET_EVT); 660 tipc_link_reset(l); 661 tipc_link_build_reset_msg(l, xmitq); 662 *maddr = &n->links[*bearer_id].maddr; 663 node_lost_contact(n, &le->inputq); 664 tipc_bcast_dec_bearer_dst_cnt(n->net, *bearer_id); 665 return; 666 } 667 tipc_bcast_dec_bearer_dst_cnt(n->net, *bearer_id); 668 669 /* There is still a working link => initiate failover */ 670 *bearer_id = n->active_links[0]; 671 tnl = n->links[*bearer_id].link; 672 tipc_link_fsm_evt(tnl, LINK_SYNCH_END_EVT); 673 tipc_node_fsm_evt(n, NODE_SYNCH_END_EVT); 674 n->sync_point = tipc_link_rcv_nxt(tnl) + (U16_MAX / 2 - 1); 675 tipc_link_tnl_prepare(l, tnl, FAILOVER_MSG, xmitq); 676 tipc_link_reset(l); 677 tipc_link_fsm_evt(l, LINK_RESET_EVT); 678 tipc_link_fsm_evt(l, LINK_FAILOVER_BEGIN_EVT); 679 tipc_node_fsm_evt(n, NODE_FAILOVER_BEGIN_EVT); 680 *maddr = &n->links[*bearer_id].maddr; 681 } 682 683 static void tipc_node_link_down(struct tipc_node *n, int bearer_id, bool delete) 684 { 685 struct tipc_link_entry *le = &n->links[bearer_id]; 686 struct tipc_link *l = le->link; 687 struct tipc_media_addr *maddr; 688 struct sk_buff_head xmitq; 689 int old_bearer_id = bearer_id; 690 691 if (!l) 692 return; 693 694 __skb_queue_head_init(&xmitq); 695 696 tipc_node_write_lock(n); 697 if (!tipc_link_is_establishing(l)) { 698 __tipc_node_link_down(n, &bearer_id, &xmitq, &maddr); 699 if (delete) { 700 kfree(l); 701 le->link = NULL; 702 n->link_cnt--; 703 } 704 } else { 705 /* Defuse pending tipc_node_link_up() */ 706 tipc_link_fsm_evt(l, LINK_RESET_EVT); 707 } 708 tipc_node_write_unlock(n); 709 if (delete) 710 tipc_mon_remove_peer(n->net, n->addr, old_bearer_id); 711 tipc_bearer_xmit(n->net, bearer_id, &xmitq, maddr); 712 tipc_sk_rcv(n->net, &le->inputq); 713 } 714 715 static bool tipc_node_is_up(struct tipc_node *n) 716 { 717 return n->active_links[0] != INVALID_BEARER_ID; 718 } 719 720 void tipc_node_check_dest(struct net *net, u32 onode, 721 struct tipc_bearer *b, 722 u16 capabilities, u32 signature, 723 struct tipc_media_addr *maddr, 724 bool *respond, bool *dupl_addr) 725 { 726 struct tipc_node *n; 727 struct tipc_link *l; 728 struct tipc_link_entry *le; 729 bool addr_match = false; 730 bool sign_match = false; 731 bool link_up = false; 732 bool accept_addr = false; 733 bool reset = true; 734 char *if_name; 735 unsigned long intv; 736 737 *dupl_addr = false; 738 *respond = false; 739 740 n = tipc_node_create(net, onode, capabilities); 741 if (!n) 742 return; 743 744 tipc_node_write_lock(n); 745 746 le = &n->links[b->identity]; 747 748 /* Prepare to validate requesting node's signature and media address */ 749 l = le->link; 750 link_up = l && tipc_link_is_up(l); 751 addr_match = l && !memcmp(&le->maddr, maddr, sizeof(*maddr)); 752 sign_match = (signature == n->signature); 753 754 /* These three flags give us eight permutations: */ 755 756 if (sign_match && addr_match && link_up) { 757 /* All is fine. Do nothing. */ 758 reset = false; 759 } else if (sign_match && addr_match && !link_up) { 760 /* Respond. The link will come up in due time */ 761 *respond = true; 762 } else if (sign_match && !addr_match && link_up) { 763 /* Peer has changed i/f address without rebooting. 764 * If so, the link will reset soon, and the next 765 * discovery will be accepted. So we can ignore it. 766 * It may also be an cloned or malicious peer having 767 * chosen the same node address and signature as an 768 * existing one. 769 * Ignore requests until the link goes down, if ever. 770 */ 771 *dupl_addr = true; 772 } else if (sign_match && !addr_match && !link_up) { 773 /* Peer link has changed i/f address without rebooting. 774 * It may also be a cloned or malicious peer; we can't 775 * distinguish between the two. 776 * The signature is correct, so we must accept. 777 */ 778 accept_addr = true; 779 *respond = true; 780 } else if (!sign_match && addr_match && link_up) { 781 /* Peer node rebooted. Two possibilities: 782 * - Delayed re-discovery; this link endpoint has already 783 * reset and re-established contact with the peer, before 784 * receiving a discovery message from that node. 785 * (The peer happened to receive one from this node first). 786 * - The peer came back so fast that our side has not 787 * discovered it yet. Probing from this side will soon 788 * reset the link, since there can be no working link 789 * endpoint at the peer end, and the link will re-establish. 790 * Accept the signature, since it comes from a known peer. 791 */ 792 n->signature = signature; 793 } else if (!sign_match && addr_match && !link_up) { 794 /* The peer node has rebooted. 795 * Accept signature, since it is a known peer. 796 */ 797 n->signature = signature; 798 *respond = true; 799 } else if (!sign_match && !addr_match && link_up) { 800 /* Peer rebooted with new address, or a new/duplicate peer. 801 * Ignore until the link goes down, if ever. 802 */ 803 *dupl_addr = true; 804 } else if (!sign_match && !addr_match && !link_up) { 805 /* Peer rebooted with new address, or it is a new peer. 806 * Accept signature and address. 807 */ 808 n->signature = signature; 809 accept_addr = true; 810 *respond = true; 811 } 812 813 if (!accept_addr) 814 goto exit; 815 816 /* Now create new link if not already existing */ 817 if (!l) { 818 if (n->link_cnt == 2) { 819 pr_warn("Cannot establish 3rd link to %x\n", n->addr); 820 goto exit; 821 } 822 if_name = strchr(b->name, ':') + 1; 823 if (!tipc_link_create(net, if_name, b->identity, b->tolerance, 824 b->net_plane, b->mtu, b->priority, 825 b->window, mod(tipc_net(net)->random), 826 tipc_own_addr(net), onode, 827 n->capabilities, 828 tipc_bc_sndlink(n->net), n->bc_entry.link, 829 &le->inputq, 830 &n->bc_entry.namedq, &l)) { 831 *respond = false; 832 goto exit; 833 } 834 tipc_link_reset(l); 835 tipc_link_fsm_evt(l, LINK_RESET_EVT); 836 if (n->state == NODE_FAILINGOVER) 837 tipc_link_fsm_evt(l, LINK_FAILOVER_BEGIN_EVT); 838 le->link = l; 839 n->link_cnt++; 840 tipc_node_calculate_timer(n, l); 841 if (n->link_cnt == 1) { 842 intv = jiffies + msecs_to_jiffies(n->keepalive_intv); 843 if (!mod_timer(&n->timer, intv)) 844 tipc_node_get(n); 845 } 846 } 847 memcpy(&le->maddr, maddr, sizeof(*maddr)); 848 exit: 849 tipc_node_write_unlock(n); 850 if (reset && l && !tipc_link_is_reset(l)) 851 tipc_node_link_down(n, b->identity, false); 852 tipc_node_put(n); 853 } 854 855 void tipc_node_delete_links(struct net *net, int bearer_id) 856 { 857 struct tipc_net *tn = net_generic(net, tipc_net_id); 858 struct tipc_node *n; 859 860 rcu_read_lock(); 861 list_for_each_entry_rcu(n, &tn->node_list, list) { 862 tipc_node_link_down(n, bearer_id, true); 863 } 864 rcu_read_unlock(); 865 } 866 867 static void tipc_node_reset_links(struct tipc_node *n) 868 { 869 char addr_string[16]; 870 int i; 871 872 pr_warn("Resetting all links to %s\n", 873 tipc_addr_string_fill(addr_string, n->addr)); 874 875 for (i = 0; i < MAX_BEARERS; i++) { 876 tipc_node_link_down(n, i, false); 877 } 878 } 879 880 /* tipc_node_fsm_evt - node finite state machine 881 * Determines when contact is allowed with peer node 882 */ 883 static void tipc_node_fsm_evt(struct tipc_node *n, int evt) 884 { 885 int state = n->state; 886 887 switch (state) { 888 case SELF_DOWN_PEER_DOWN: 889 switch (evt) { 890 case SELF_ESTABL_CONTACT_EVT: 891 state = SELF_UP_PEER_COMING; 892 break; 893 case PEER_ESTABL_CONTACT_EVT: 894 state = SELF_COMING_PEER_UP; 895 break; 896 case SELF_LOST_CONTACT_EVT: 897 case PEER_LOST_CONTACT_EVT: 898 break; 899 case NODE_SYNCH_END_EVT: 900 case NODE_SYNCH_BEGIN_EVT: 901 case NODE_FAILOVER_BEGIN_EVT: 902 case NODE_FAILOVER_END_EVT: 903 default: 904 goto illegal_evt; 905 } 906 break; 907 case SELF_UP_PEER_UP: 908 switch (evt) { 909 case SELF_LOST_CONTACT_EVT: 910 state = SELF_DOWN_PEER_LEAVING; 911 break; 912 case PEER_LOST_CONTACT_EVT: 913 state = SELF_LEAVING_PEER_DOWN; 914 break; 915 case NODE_SYNCH_BEGIN_EVT: 916 state = NODE_SYNCHING; 917 break; 918 case NODE_FAILOVER_BEGIN_EVT: 919 state = NODE_FAILINGOVER; 920 break; 921 case SELF_ESTABL_CONTACT_EVT: 922 case PEER_ESTABL_CONTACT_EVT: 923 case NODE_SYNCH_END_EVT: 924 case NODE_FAILOVER_END_EVT: 925 break; 926 default: 927 goto illegal_evt; 928 } 929 break; 930 case SELF_DOWN_PEER_LEAVING: 931 switch (evt) { 932 case PEER_LOST_CONTACT_EVT: 933 state = SELF_DOWN_PEER_DOWN; 934 break; 935 case SELF_ESTABL_CONTACT_EVT: 936 case PEER_ESTABL_CONTACT_EVT: 937 case SELF_LOST_CONTACT_EVT: 938 break; 939 case NODE_SYNCH_END_EVT: 940 case NODE_SYNCH_BEGIN_EVT: 941 case NODE_FAILOVER_BEGIN_EVT: 942 case NODE_FAILOVER_END_EVT: 943 default: 944 goto illegal_evt; 945 } 946 break; 947 case SELF_UP_PEER_COMING: 948 switch (evt) { 949 case PEER_ESTABL_CONTACT_EVT: 950 state = SELF_UP_PEER_UP; 951 break; 952 case SELF_LOST_CONTACT_EVT: 953 state = SELF_DOWN_PEER_DOWN; 954 break; 955 case SELF_ESTABL_CONTACT_EVT: 956 case PEER_LOST_CONTACT_EVT: 957 case NODE_SYNCH_END_EVT: 958 case NODE_FAILOVER_BEGIN_EVT: 959 break; 960 case NODE_SYNCH_BEGIN_EVT: 961 case NODE_FAILOVER_END_EVT: 962 default: 963 goto illegal_evt; 964 } 965 break; 966 case SELF_COMING_PEER_UP: 967 switch (evt) { 968 case SELF_ESTABL_CONTACT_EVT: 969 state = SELF_UP_PEER_UP; 970 break; 971 case PEER_LOST_CONTACT_EVT: 972 state = SELF_DOWN_PEER_DOWN; 973 break; 974 case SELF_LOST_CONTACT_EVT: 975 case PEER_ESTABL_CONTACT_EVT: 976 break; 977 case NODE_SYNCH_END_EVT: 978 case NODE_SYNCH_BEGIN_EVT: 979 case NODE_FAILOVER_BEGIN_EVT: 980 case NODE_FAILOVER_END_EVT: 981 default: 982 goto illegal_evt; 983 } 984 break; 985 case SELF_LEAVING_PEER_DOWN: 986 switch (evt) { 987 case SELF_LOST_CONTACT_EVT: 988 state = SELF_DOWN_PEER_DOWN; 989 break; 990 case SELF_ESTABL_CONTACT_EVT: 991 case PEER_ESTABL_CONTACT_EVT: 992 case PEER_LOST_CONTACT_EVT: 993 break; 994 case NODE_SYNCH_END_EVT: 995 case NODE_SYNCH_BEGIN_EVT: 996 case NODE_FAILOVER_BEGIN_EVT: 997 case NODE_FAILOVER_END_EVT: 998 default: 999 goto illegal_evt; 1000 } 1001 break; 1002 case NODE_FAILINGOVER: 1003 switch (evt) { 1004 case SELF_LOST_CONTACT_EVT: 1005 state = SELF_DOWN_PEER_LEAVING; 1006 break; 1007 case PEER_LOST_CONTACT_EVT: 1008 state = SELF_LEAVING_PEER_DOWN; 1009 break; 1010 case NODE_FAILOVER_END_EVT: 1011 state = SELF_UP_PEER_UP; 1012 break; 1013 case NODE_FAILOVER_BEGIN_EVT: 1014 case SELF_ESTABL_CONTACT_EVT: 1015 case PEER_ESTABL_CONTACT_EVT: 1016 break; 1017 case NODE_SYNCH_BEGIN_EVT: 1018 case NODE_SYNCH_END_EVT: 1019 default: 1020 goto illegal_evt; 1021 } 1022 break; 1023 case NODE_SYNCHING: 1024 switch (evt) { 1025 case SELF_LOST_CONTACT_EVT: 1026 state = SELF_DOWN_PEER_LEAVING; 1027 break; 1028 case PEER_LOST_CONTACT_EVT: 1029 state = SELF_LEAVING_PEER_DOWN; 1030 break; 1031 case NODE_SYNCH_END_EVT: 1032 state = SELF_UP_PEER_UP; 1033 break; 1034 case NODE_FAILOVER_BEGIN_EVT: 1035 state = NODE_FAILINGOVER; 1036 break; 1037 case NODE_SYNCH_BEGIN_EVT: 1038 case SELF_ESTABL_CONTACT_EVT: 1039 case PEER_ESTABL_CONTACT_EVT: 1040 break; 1041 case NODE_FAILOVER_END_EVT: 1042 default: 1043 goto illegal_evt; 1044 } 1045 break; 1046 default: 1047 pr_err("Unknown node fsm state %x\n", state); 1048 break; 1049 } 1050 n->state = state; 1051 return; 1052 1053 illegal_evt: 1054 pr_err("Illegal node fsm evt %x in state %x\n", evt, state); 1055 } 1056 1057 static void node_lost_contact(struct tipc_node *n, 1058 struct sk_buff_head *inputq) 1059 { 1060 char addr_string[16]; 1061 struct tipc_sock_conn *conn, *safe; 1062 struct tipc_link *l; 1063 struct list_head *conns = &n->conn_sks; 1064 struct sk_buff *skb; 1065 uint i; 1066 1067 pr_debug("Lost contact with %s\n", 1068 tipc_addr_string_fill(addr_string, n->addr)); 1069 1070 /* Clean up broadcast state */ 1071 tipc_bcast_remove_peer(n->net, n->bc_entry.link); 1072 1073 /* Abort any ongoing link failover */ 1074 for (i = 0; i < MAX_BEARERS; i++) { 1075 l = n->links[i].link; 1076 if (l) 1077 tipc_link_fsm_evt(l, LINK_FAILOVER_END_EVT); 1078 } 1079 1080 /* Notify publications from this node */ 1081 n->action_flags |= TIPC_NOTIFY_NODE_DOWN; 1082 1083 /* Notify sockets connected to node */ 1084 list_for_each_entry_safe(conn, safe, conns, list) { 1085 skb = tipc_msg_create(TIPC_CRITICAL_IMPORTANCE, TIPC_CONN_MSG, 1086 SHORT_H_SIZE, 0, tipc_own_addr(n->net), 1087 conn->peer_node, conn->port, 1088 conn->peer_port, TIPC_ERR_NO_NODE); 1089 if (likely(skb)) 1090 skb_queue_tail(inputq, skb); 1091 list_del(&conn->list); 1092 kfree(conn); 1093 } 1094 } 1095 1096 /** 1097 * tipc_node_get_linkname - get the name of a link 1098 * 1099 * @bearer_id: id of the bearer 1100 * @node: peer node address 1101 * @linkname: link name output buffer 1102 * 1103 * Returns 0 on success 1104 */ 1105 int tipc_node_get_linkname(struct net *net, u32 bearer_id, u32 addr, 1106 char *linkname, size_t len) 1107 { 1108 struct tipc_link *link; 1109 int err = -EINVAL; 1110 struct tipc_node *node = tipc_node_find(net, addr); 1111 1112 if (!node) 1113 return err; 1114 1115 if (bearer_id >= MAX_BEARERS) 1116 goto exit; 1117 1118 tipc_node_read_lock(node); 1119 link = node->links[bearer_id].link; 1120 if (link) { 1121 strncpy(linkname, tipc_link_name(link), len); 1122 err = 0; 1123 } 1124 exit: 1125 tipc_node_read_unlock(node); 1126 tipc_node_put(node); 1127 return err; 1128 } 1129 1130 /* Caller should hold node lock for the passed node */ 1131 static int __tipc_nl_add_node(struct tipc_nl_msg *msg, struct tipc_node *node) 1132 { 1133 void *hdr; 1134 struct nlattr *attrs; 1135 1136 hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family, 1137 NLM_F_MULTI, TIPC_NL_NODE_GET); 1138 if (!hdr) 1139 return -EMSGSIZE; 1140 1141 attrs = nla_nest_start(msg->skb, TIPC_NLA_NODE); 1142 if (!attrs) 1143 goto msg_full; 1144 1145 if (nla_put_u32(msg->skb, TIPC_NLA_NODE_ADDR, node->addr)) 1146 goto attr_msg_full; 1147 if (tipc_node_is_up(node)) 1148 if (nla_put_flag(msg->skb, TIPC_NLA_NODE_UP)) 1149 goto attr_msg_full; 1150 1151 nla_nest_end(msg->skb, attrs); 1152 genlmsg_end(msg->skb, hdr); 1153 1154 return 0; 1155 1156 attr_msg_full: 1157 nla_nest_cancel(msg->skb, attrs); 1158 msg_full: 1159 genlmsg_cancel(msg->skb, hdr); 1160 1161 return -EMSGSIZE; 1162 } 1163 1164 /** 1165 * tipc_node_xmit() is the general link level function for message sending 1166 * @net: the applicable net namespace 1167 * @list: chain of buffers containing message 1168 * @dnode: address of destination node 1169 * @selector: a number used for deterministic link selection 1170 * Consumes the buffer chain. 1171 * Returns 0 if success, otherwise: -ELINKCONG,-EHOSTUNREACH,-EMSGSIZE,-ENOBUF 1172 */ 1173 int tipc_node_xmit(struct net *net, struct sk_buff_head *list, 1174 u32 dnode, int selector) 1175 { 1176 struct tipc_link_entry *le = NULL; 1177 struct tipc_node *n; 1178 struct sk_buff_head xmitq; 1179 int bearer_id; 1180 int rc; 1181 1182 if (in_own_node(net, dnode)) { 1183 tipc_sk_rcv(net, list); 1184 return 0; 1185 } 1186 1187 n = tipc_node_find(net, dnode); 1188 if (unlikely(!n)) { 1189 skb_queue_purge(list); 1190 return -EHOSTUNREACH; 1191 } 1192 1193 tipc_node_read_lock(n); 1194 bearer_id = n->active_links[selector & 1]; 1195 if (unlikely(bearer_id == INVALID_BEARER_ID)) { 1196 tipc_node_read_unlock(n); 1197 tipc_node_put(n); 1198 skb_queue_purge(list); 1199 return -EHOSTUNREACH; 1200 } 1201 1202 __skb_queue_head_init(&xmitq); 1203 le = &n->links[bearer_id]; 1204 spin_lock_bh(&le->lock); 1205 rc = tipc_link_xmit(le->link, list, &xmitq); 1206 spin_unlock_bh(&le->lock); 1207 tipc_node_read_unlock(n); 1208 1209 if (unlikely(rc == -ENOBUFS)) 1210 tipc_node_link_down(n, bearer_id, false); 1211 else 1212 tipc_bearer_xmit(net, bearer_id, &xmitq, &le->maddr); 1213 1214 tipc_node_put(n); 1215 1216 return rc; 1217 } 1218 1219 /* tipc_node_xmit_skb(): send single buffer to destination 1220 * Buffers sent via this functon are generally TIPC_SYSTEM_IMPORTANCE 1221 * messages, which will not be rejected 1222 * The only exception is datagram messages rerouted after secondary 1223 * lookup, which are rare and safe to dispose of anyway. 1224 */ 1225 int tipc_node_xmit_skb(struct net *net, struct sk_buff *skb, u32 dnode, 1226 u32 selector) 1227 { 1228 struct sk_buff_head head; 1229 1230 skb_queue_head_init(&head); 1231 __skb_queue_tail(&head, skb); 1232 tipc_node_xmit(net, &head, dnode, selector); 1233 return 0; 1234 } 1235 1236 void tipc_node_broadcast(struct net *net, struct sk_buff *skb) 1237 { 1238 struct sk_buff *txskb; 1239 struct tipc_node *n; 1240 u32 dst; 1241 1242 rcu_read_lock(); 1243 list_for_each_entry_rcu(n, tipc_nodes(net), list) { 1244 dst = n->addr; 1245 if (in_own_node(net, dst)) 1246 continue; 1247 if (!tipc_node_is_up(n)) 1248 continue; 1249 txskb = pskb_copy(skb, GFP_ATOMIC); 1250 if (!txskb) 1251 break; 1252 msg_set_destnode(buf_msg(txskb), dst); 1253 tipc_node_xmit_skb(net, txskb, dst, 0); 1254 } 1255 rcu_read_unlock(); 1256 1257 kfree_skb(skb); 1258 } 1259 1260 static void tipc_node_bc_sync_rcv(struct tipc_node *n, struct tipc_msg *hdr, 1261 int bearer_id, struct sk_buff_head *xmitq) 1262 { 1263 struct tipc_link *ucl; 1264 int rc; 1265 1266 rc = tipc_bcast_sync_rcv(n->net, n->bc_entry.link, hdr); 1267 1268 if (rc & TIPC_LINK_DOWN_EVT) { 1269 tipc_bearer_reset_all(n->net); 1270 return; 1271 } 1272 1273 if (!(rc & TIPC_LINK_SND_STATE)) 1274 return; 1275 1276 /* If probe message, a STATE response will be sent anyway */ 1277 if (msg_probe(hdr)) 1278 return; 1279 1280 /* Produce a STATE message carrying broadcast NACK */ 1281 tipc_node_read_lock(n); 1282 ucl = n->links[bearer_id].link; 1283 if (ucl) 1284 tipc_link_build_state_msg(ucl, xmitq); 1285 tipc_node_read_unlock(n); 1286 } 1287 1288 /** 1289 * tipc_node_bc_rcv - process TIPC broadcast packet arriving from off-node 1290 * @net: the applicable net namespace 1291 * @skb: TIPC packet 1292 * @bearer_id: id of bearer message arrived on 1293 * 1294 * Invoked with no locks held. 1295 */ 1296 static void tipc_node_bc_rcv(struct net *net, struct sk_buff *skb, int bearer_id) 1297 { 1298 int rc; 1299 struct sk_buff_head xmitq; 1300 struct tipc_bclink_entry *be; 1301 struct tipc_link_entry *le; 1302 struct tipc_msg *hdr = buf_msg(skb); 1303 int usr = msg_user(hdr); 1304 u32 dnode = msg_destnode(hdr); 1305 struct tipc_node *n; 1306 1307 __skb_queue_head_init(&xmitq); 1308 1309 /* If NACK for other node, let rcv link for that node peek into it */ 1310 if ((usr == BCAST_PROTOCOL) && (dnode != tipc_own_addr(net))) 1311 n = tipc_node_find(net, dnode); 1312 else 1313 n = tipc_node_find(net, msg_prevnode(hdr)); 1314 if (!n) { 1315 kfree_skb(skb); 1316 return; 1317 } 1318 be = &n->bc_entry; 1319 le = &n->links[bearer_id]; 1320 1321 rc = tipc_bcast_rcv(net, be->link, skb); 1322 1323 /* Broadcast ACKs are sent on a unicast link */ 1324 if (rc & TIPC_LINK_SND_STATE) { 1325 tipc_node_read_lock(n); 1326 tipc_link_build_state_msg(le->link, &xmitq); 1327 tipc_node_read_unlock(n); 1328 } 1329 1330 if (!skb_queue_empty(&xmitq)) 1331 tipc_bearer_xmit(net, bearer_id, &xmitq, &le->maddr); 1332 1333 /* Deliver. 'arrvq' is under inputq2's lock protection */ 1334 if (!skb_queue_empty(&be->inputq1)) { 1335 spin_lock_bh(&be->inputq2.lock); 1336 spin_lock_bh(&be->inputq1.lock); 1337 skb_queue_splice_tail_init(&be->inputq1, &be->arrvq); 1338 spin_unlock_bh(&be->inputq1.lock); 1339 spin_unlock_bh(&be->inputq2.lock); 1340 tipc_sk_mcast_rcv(net, &be->arrvq, &be->inputq2); 1341 } 1342 1343 if (rc & TIPC_LINK_DOWN_EVT) { 1344 /* Reception reassembly failure => reset all links to peer */ 1345 if (!tipc_link_is_up(be->link)) 1346 tipc_node_reset_links(n); 1347 1348 /* Retransmission failure => reset all links to all peers */ 1349 if (!tipc_link_is_up(tipc_bc_sndlink(net))) 1350 tipc_bearer_reset_all(net); 1351 } 1352 1353 tipc_node_put(n); 1354 } 1355 1356 /** 1357 * tipc_node_check_state - check and if necessary update node state 1358 * @skb: TIPC packet 1359 * @bearer_id: identity of bearer delivering the packet 1360 * Returns true if state is ok, otherwise consumes buffer and returns false 1361 */ 1362 static bool tipc_node_check_state(struct tipc_node *n, struct sk_buff *skb, 1363 int bearer_id, struct sk_buff_head *xmitq) 1364 { 1365 struct tipc_msg *hdr = buf_msg(skb); 1366 int usr = msg_user(hdr); 1367 int mtyp = msg_type(hdr); 1368 u16 oseqno = msg_seqno(hdr); 1369 u16 iseqno = msg_seqno(msg_get_wrapped(hdr)); 1370 u16 exp_pkts = msg_msgcnt(hdr); 1371 u16 rcv_nxt, syncpt, dlv_nxt, inputq_len; 1372 int state = n->state; 1373 struct tipc_link *l, *tnl, *pl = NULL; 1374 struct tipc_media_addr *maddr; 1375 int pb_id; 1376 1377 l = n->links[bearer_id].link; 1378 if (!l) 1379 return false; 1380 rcv_nxt = tipc_link_rcv_nxt(l); 1381 1382 1383 if (likely((state == SELF_UP_PEER_UP) && (usr != TUNNEL_PROTOCOL))) 1384 return true; 1385 1386 /* Find parallel link, if any */ 1387 for (pb_id = 0; pb_id < MAX_BEARERS; pb_id++) { 1388 if ((pb_id != bearer_id) && n->links[pb_id].link) { 1389 pl = n->links[pb_id].link; 1390 break; 1391 } 1392 } 1393 1394 /* Check and update node accesibility if applicable */ 1395 if (state == SELF_UP_PEER_COMING) { 1396 if (!tipc_link_is_up(l)) 1397 return true; 1398 if (!msg_peer_link_is_up(hdr)) 1399 return true; 1400 tipc_node_fsm_evt(n, PEER_ESTABL_CONTACT_EVT); 1401 } 1402 1403 if (state == SELF_DOWN_PEER_LEAVING) { 1404 if (msg_peer_node_is_up(hdr)) 1405 return false; 1406 tipc_node_fsm_evt(n, PEER_LOST_CONTACT_EVT); 1407 return true; 1408 } 1409 1410 if (state == SELF_LEAVING_PEER_DOWN) 1411 return false; 1412 1413 /* Ignore duplicate packets */ 1414 if ((usr != LINK_PROTOCOL) && less(oseqno, rcv_nxt)) 1415 return true; 1416 1417 /* Initiate or update failover mode if applicable */ 1418 if ((usr == TUNNEL_PROTOCOL) && (mtyp == FAILOVER_MSG)) { 1419 syncpt = oseqno + exp_pkts - 1; 1420 if (pl && tipc_link_is_up(pl)) { 1421 __tipc_node_link_down(n, &pb_id, xmitq, &maddr); 1422 tipc_skb_queue_splice_tail_init(tipc_link_inputq(pl), 1423 tipc_link_inputq(l)); 1424 } 1425 /* If pkts arrive out of order, use lowest calculated syncpt */ 1426 if (less(syncpt, n->sync_point)) 1427 n->sync_point = syncpt; 1428 } 1429 1430 /* Open parallel link when tunnel link reaches synch point */ 1431 if ((n->state == NODE_FAILINGOVER) && tipc_link_is_up(l)) { 1432 if (!more(rcv_nxt, n->sync_point)) 1433 return true; 1434 tipc_node_fsm_evt(n, NODE_FAILOVER_END_EVT); 1435 if (pl) 1436 tipc_link_fsm_evt(pl, LINK_FAILOVER_END_EVT); 1437 return true; 1438 } 1439 1440 /* No synching needed if only one link */ 1441 if (!pl || !tipc_link_is_up(pl)) 1442 return true; 1443 1444 /* Initiate synch mode if applicable */ 1445 if ((usr == TUNNEL_PROTOCOL) && (mtyp == SYNCH_MSG) && (oseqno == 1)) { 1446 syncpt = iseqno + exp_pkts - 1; 1447 if (!tipc_link_is_up(l)) { 1448 tipc_link_fsm_evt(l, LINK_ESTABLISH_EVT); 1449 __tipc_node_link_up(n, bearer_id, xmitq); 1450 } 1451 if (n->state == SELF_UP_PEER_UP) { 1452 n->sync_point = syncpt; 1453 tipc_link_fsm_evt(l, LINK_SYNCH_BEGIN_EVT); 1454 tipc_node_fsm_evt(n, NODE_SYNCH_BEGIN_EVT); 1455 } 1456 } 1457 1458 /* Open tunnel link when parallel link reaches synch point */ 1459 if (n->state == NODE_SYNCHING) { 1460 if (tipc_link_is_synching(l)) { 1461 tnl = l; 1462 } else { 1463 tnl = pl; 1464 pl = l; 1465 } 1466 inputq_len = skb_queue_len(tipc_link_inputq(pl)); 1467 dlv_nxt = tipc_link_rcv_nxt(pl) - inputq_len; 1468 if (more(dlv_nxt, n->sync_point)) { 1469 tipc_link_fsm_evt(tnl, LINK_SYNCH_END_EVT); 1470 tipc_node_fsm_evt(n, NODE_SYNCH_END_EVT); 1471 return true; 1472 } 1473 if (l == pl) 1474 return true; 1475 if ((usr == TUNNEL_PROTOCOL) && (mtyp == SYNCH_MSG)) 1476 return true; 1477 if (usr == LINK_PROTOCOL) 1478 return true; 1479 return false; 1480 } 1481 return true; 1482 } 1483 1484 /** 1485 * tipc_rcv - process TIPC packets/messages arriving from off-node 1486 * @net: the applicable net namespace 1487 * @skb: TIPC packet 1488 * @bearer: pointer to bearer message arrived on 1489 * 1490 * Invoked with no locks held. Bearer pointer must point to a valid bearer 1491 * structure (i.e. cannot be NULL), but bearer can be inactive. 1492 */ 1493 void tipc_rcv(struct net *net, struct sk_buff *skb, struct tipc_bearer *b) 1494 { 1495 struct sk_buff_head xmitq; 1496 struct tipc_node *n; 1497 struct tipc_msg *hdr = buf_msg(skb); 1498 int usr = msg_user(hdr); 1499 int bearer_id = b->identity; 1500 struct tipc_link_entry *le; 1501 u16 bc_ack = msg_bcast_ack(hdr); 1502 u32 self = tipc_own_addr(net); 1503 int rc = 0; 1504 1505 __skb_queue_head_init(&xmitq); 1506 1507 /* Ensure message is well-formed */ 1508 if (unlikely(!tipc_msg_validate(skb))) 1509 goto discard; 1510 1511 /* Handle arrival of discovery or broadcast packet */ 1512 if (unlikely(msg_non_seq(hdr))) { 1513 if (unlikely(usr == LINK_CONFIG)) 1514 return tipc_disc_rcv(net, skb, b); 1515 else 1516 return tipc_node_bc_rcv(net, skb, bearer_id); 1517 } 1518 1519 /* Discard unicast link messages destined for another node */ 1520 if (unlikely(!msg_short(hdr) && (msg_destnode(hdr) != self))) 1521 goto discard; 1522 1523 /* Locate neighboring node that sent packet */ 1524 n = tipc_node_find(net, msg_prevnode(hdr)); 1525 if (unlikely(!n)) 1526 goto discard; 1527 le = &n->links[bearer_id]; 1528 1529 /* Ensure broadcast reception is in synch with peer's send state */ 1530 if (unlikely(usr == LINK_PROTOCOL)) 1531 tipc_node_bc_sync_rcv(n, hdr, bearer_id, &xmitq); 1532 else if (unlikely(tipc_link_acked(n->bc_entry.link) != bc_ack)) 1533 tipc_bcast_ack_rcv(net, n->bc_entry.link, hdr); 1534 1535 /* Receive packet directly if conditions permit */ 1536 tipc_node_read_lock(n); 1537 if (likely((n->state == SELF_UP_PEER_UP) && (usr != TUNNEL_PROTOCOL))) { 1538 spin_lock_bh(&le->lock); 1539 if (le->link) { 1540 rc = tipc_link_rcv(le->link, skb, &xmitq); 1541 skb = NULL; 1542 } 1543 spin_unlock_bh(&le->lock); 1544 } 1545 tipc_node_read_unlock(n); 1546 1547 /* Check/update node state before receiving */ 1548 if (unlikely(skb)) { 1549 tipc_node_write_lock(n); 1550 if (tipc_node_check_state(n, skb, bearer_id, &xmitq)) { 1551 if (le->link) { 1552 rc = tipc_link_rcv(le->link, skb, &xmitq); 1553 skb = NULL; 1554 } 1555 } 1556 tipc_node_write_unlock(n); 1557 } 1558 1559 if (unlikely(rc & TIPC_LINK_UP_EVT)) 1560 tipc_node_link_up(n, bearer_id, &xmitq); 1561 1562 if (unlikely(rc & TIPC_LINK_DOWN_EVT)) 1563 tipc_node_link_down(n, bearer_id, false); 1564 1565 if (unlikely(!skb_queue_empty(&n->bc_entry.namedq))) 1566 tipc_named_rcv(net, &n->bc_entry.namedq); 1567 1568 if (!skb_queue_empty(&le->inputq)) 1569 tipc_sk_rcv(net, &le->inputq); 1570 1571 if (!skb_queue_empty(&xmitq)) 1572 tipc_bearer_xmit(net, bearer_id, &xmitq, &le->maddr); 1573 1574 tipc_node_put(n); 1575 discard: 1576 kfree_skb(skb); 1577 } 1578 1579 int tipc_nl_peer_rm(struct sk_buff *skb, struct genl_info *info) 1580 { 1581 struct net *net = sock_net(skb->sk); 1582 struct tipc_net *tn = net_generic(net, tipc_net_id); 1583 struct nlattr *attrs[TIPC_NLA_NET_MAX + 1]; 1584 struct tipc_node *peer; 1585 u32 addr; 1586 int err; 1587 int i; 1588 1589 /* We identify the peer by its net */ 1590 if (!info->attrs[TIPC_NLA_NET]) 1591 return -EINVAL; 1592 1593 err = nla_parse_nested(attrs, TIPC_NLA_NET_MAX, 1594 info->attrs[TIPC_NLA_NET], 1595 tipc_nl_net_policy); 1596 if (err) 1597 return err; 1598 1599 if (!attrs[TIPC_NLA_NET_ADDR]) 1600 return -EINVAL; 1601 1602 addr = nla_get_u32(attrs[TIPC_NLA_NET_ADDR]); 1603 1604 if (in_own_node(net, addr)) 1605 return -ENOTSUPP; 1606 1607 spin_lock_bh(&tn->node_list_lock); 1608 peer = tipc_node_find(net, addr); 1609 if (!peer) { 1610 spin_unlock_bh(&tn->node_list_lock); 1611 return -ENXIO; 1612 } 1613 1614 tipc_node_write_lock(peer); 1615 if (peer->state != SELF_DOWN_PEER_DOWN && 1616 peer->state != SELF_DOWN_PEER_LEAVING) { 1617 tipc_node_write_unlock(peer); 1618 err = -EBUSY; 1619 goto err_out; 1620 } 1621 1622 for (i = 0; i < MAX_BEARERS; i++) { 1623 struct tipc_link_entry *le = &peer->links[i]; 1624 1625 if (le->link) { 1626 kfree(le->link); 1627 le->link = NULL; 1628 peer->link_cnt--; 1629 } 1630 } 1631 tipc_node_write_unlock(peer); 1632 tipc_node_delete(peer); 1633 1634 err = 0; 1635 err_out: 1636 tipc_node_put(peer); 1637 spin_unlock_bh(&tn->node_list_lock); 1638 1639 return err; 1640 } 1641 1642 int tipc_nl_node_dump(struct sk_buff *skb, struct netlink_callback *cb) 1643 { 1644 int err; 1645 struct net *net = sock_net(skb->sk); 1646 struct tipc_net *tn = net_generic(net, tipc_net_id); 1647 int done = cb->args[0]; 1648 int last_addr = cb->args[1]; 1649 struct tipc_node *node; 1650 struct tipc_nl_msg msg; 1651 1652 if (done) 1653 return 0; 1654 1655 msg.skb = skb; 1656 msg.portid = NETLINK_CB(cb->skb).portid; 1657 msg.seq = cb->nlh->nlmsg_seq; 1658 1659 rcu_read_lock(); 1660 if (last_addr) { 1661 node = tipc_node_find(net, last_addr); 1662 if (!node) { 1663 rcu_read_unlock(); 1664 /* We never set seq or call nl_dump_check_consistent() 1665 * this means that setting prev_seq here will cause the 1666 * consistence check to fail in the netlink callback 1667 * handler. Resulting in the NLMSG_DONE message having 1668 * the NLM_F_DUMP_INTR flag set if the node state 1669 * changed while we released the lock. 1670 */ 1671 cb->prev_seq = 1; 1672 return -EPIPE; 1673 } 1674 tipc_node_put(node); 1675 } 1676 1677 list_for_each_entry_rcu(node, &tn->node_list, list) { 1678 if (last_addr) { 1679 if (node->addr == last_addr) 1680 last_addr = 0; 1681 else 1682 continue; 1683 } 1684 1685 tipc_node_read_lock(node); 1686 err = __tipc_nl_add_node(&msg, node); 1687 if (err) { 1688 last_addr = node->addr; 1689 tipc_node_read_unlock(node); 1690 goto out; 1691 } 1692 1693 tipc_node_read_unlock(node); 1694 } 1695 done = 1; 1696 out: 1697 cb->args[0] = done; 1698 cb->args[1] = last_addr; 1699 rcu_read_unlock(); 1700 1701 return skb->len; 1702 } 1703 1704 /* tipc_node_find_by_name - locate owner node of link by link's name 1705 * @net: the applicable net namespace 1706 * @name: pointer to link name string 1707 * @bearer_id: pointer to index in 'node->links' array where the link was found. 1708 * 1709 * Returns pointer to node owning the link, or 0 if no matching link is found. 1710 */ 1711 static struct tipc_node *tipc_node_find_by_name(struct net *net, 1712 const char *link_name, 1713 unsigned int *bearer_id) 1714 { 1715 struct tipc_net *tn = net_generic(net, tipc_net_id); 1716 struct tipc_link *l; 1717 struct tipc_node *n; 1718 struct tipc_node *found_node = NULL; 1719 int i; 1720 1721 *bearer_id = 0; 1722 rcu_read_lock(); 1723 list_for_each_entry_rcu(n, &tn->node_list, list) { 1724 tipc_node_read_lock(n); 1725 for (i = 0; i < MAX_BEARERS; i++) { 1726 l = n->links[i].link; 1727 if (l && !strcmp(tipc_link_name(l), link_name)) { 1728 *bearer_id = i; 1729 found_node = n; 1730 break; 1731 } 1732 } 1733 tipc_node_read_unlock(n); 1734 if (found_node) 1735 break; 1736 } 1737 rcu_read_unlock(); 1738 1739 return found_node; 1740 } 1741 1742 int tipc_nl_node_set_link(struct sk_buff *skb, struct genl_info *info) 1743 { 1744 int err; 1745 int res = 0; 1746 int bearer_id; 1747 char *name; 1748 struct tipc_link *link; 1749 struct tipc_node *node; 1750 struct sk_buff_head xmitq; 1751 struct nlattr *attrs[TIPC_NLA_LINK_MAX + 1]; 1752 struct net *net = sock_net(skb->sk); 1753 1754 __skb_queue_head_init(&xmitq); 1755 1756 if (!info->attrs[TIPC_NLA_LINK]) 1757 return -EINVAL; 1758 1759 err = nla_parse_nested(attrs, TIPC_NLA_LINK_MAX, 1760 info->attrs[TIPC_NLA_LINK], 1761 tipc_nl_link_policy); 1762 if (err) 1763 return err; 1764 1765 if (!attrs[TIPC_NLA_LINK_NAME]) 1766 return -EINVAL; 1767 1768 name = nla_data(attrs[TIPC_NLA_LINK_NAME]); 1769 1770 if (strcmp(name, tipc_bclink_name) == 0) 1771 return tipc_nl_bc_link_set(net, attrs); 1772 1773 node = tipc_node_find_by_name(net, name, &bearer_id); 1774 if (!node) 1775 return -EINVAL; 1776 1777 tipc_node_read_lock(node); 1778 1779 link = node->links[bearer_id].link; 1780 if (!link) { 1781 res = -EINVAL; 1782 goto out; 1783 } 1784 1785 if (attrs[TIPC_NLA_LINK_PROP]) { 1786 struct nlattr *props[TIPC_NLA_PROP_MAX + 1]; 1787 1788 err = tipc_nl_parse_link_prop(attrs[TIPC_NLA_LINK_PROP], 1789 props); 1790 if (err) { 1791 res = err; 1792 goto out; 1793 } 1794 1795 if (props[TIPC_NLA_PROP_TOL]) { 1796 u32 tol; 1797 1798 tol = nla_get_u32(props[TIPC_NLA_PROP_TOL]); 1799 tipc_link_set_tolerance(link, tol, &xmitq); 1800 } 1801 if (props[TIPC_NLA_PROP_PRIO]) { 1802 u32 prio; 1803 1804 prio = nla_get_u32(props[TIPC_NLA_PROP_PRIO]); 1805 tipc_link_set_prio(link, prio, &xmitq); 1806 } 1807 if (props[TIPC_NLA_PROP_WIN]) { 1808 u32 win; 1809 1810 win = nla_get_u32(props[TIPC_NLA_PROP_WIN]); 1811 tipc_link_set_queue_limits(link, win); 1812 } 1813 } 1814 1815 out: 1816 tipc_node_read_unlock(node); 1817 tipc_bearer_xmit(net, bearer_id, &xmitq, &node->links[bearer_id].maddr); 1818 return res; 1819 } 1820 1821 int tipc_nl_node_get_link(struct sk_buff *skb, struct genl_info *info) 1822 { 1823 struct net *net = genl_info_net(info); 1824 struct tipc_nl_msg msg; 1825 char *name; 1826 int err; 1827 1828 msg.portid = info->snd_portid; 1829 msg.seq = info->snd_seq; 1830 1831 if (!info->attrs[TIPC_NLA_LINK_NAME]) 1832 return -EINVAL; 1833 name = nla_data(info->attrs[TIPC_NLA_LINK_NAME]); 1834 1835 msg.skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL); 1836 if (!msg.skb) 1837 return -ENOMEM; 1838 1839 if (strcmp(name, tipc_bclink_name) == 0) { 1840 err = tipc_nl_add_bc_link(net, &msg); 1841 if (err) { 1842 nlmsg_free(msg.skb); 1843 return err; 1844 } 1845 } else { 1846 int bearer_id; 1847 struct tipc_node *node; 1848 struct tipc_link *link; 1849 1850 node = tipc_node_find_by_name(net, name, &bearer_id); 1851 if (!node) 1852 return -EINVAL; 1853 1854 tipc_node_read_lock(node); 1855 link = node->links[bearer_id].link; 1856 if (!link) { 1857 tipc_node_read_unlock(node); 1858 nlmsg_free(msg.skb); 1859 return -EINVAL; 1860 } 1861 1862 err = __tipc_nl_add_link(net, &msg, link, 0); 1863 tipc_node_read_unlock(node); 1864 if (err) { 1865 nlmsg_free(msg.skb); 1866 return err; 1867 } 1868 } 1869 1870 return genlmsg_reply(msg.skb, info); 1871 } 1872 1873 int tipc_nl_node_reset_link_stats(struct sk_buff *skb, struct genl_info *info) 1874 { 1875 int err; 1876 char *link_name; 1877 unsigned int bearer_id; 1878 struct tipc_link *link; 1879 struct tipc_node *node; 1880 struct nlattr *attrs[TIPC_NLA_LINK_MAX + 1]; 1881 struct net *net = sock_net(skb->sk); 1882 struct tipc_link_entry *le; 1883 1884 if (!info->attrs[TIPC_NLA_LINK]) 1885 return -EINVAL; 1886 1887 err = nla_parse_nested(attrs, TIPC_NLA_LINK_MAX, 1888 info->attrs[TIPC_NLA_LINK], 1889 tipc_nl_link_policy); 1890 if (err) 1891 return err; 1892 1893 if (!attrs[TIPC_NLA_LINK_NAME]) 1894 return -EINVAL; 1895 1896 link_name = nla_data(attrs[TIPC_NLA_LINK_NAME]); 1897 1898 if (strcmp(link_name, tipc_bclink_name) == 0) { 1899 err = tipc_bclink_reset_stats(net); 1900 if (err) 1901 return err; 1902 return 0; 1903 } 1904 1905 node = tipc_node_find_by_name(net, link_name, &bearer_id); 1906 if (!node) 1907 return -EINVAL; 1908 1909 le = &node->links[bearer_id]; 1910 tipc_node_read_lock(node); 1911 spin_lock_bh(&le->lock); 1912 link = node->links[bearer_id].link; 1913 if (!link) { 1914 spin_unlock_bh(&le->lock); 1915 tipc_node_read_unlock(node); 1916 return -EINVAL; 1917 } 1918 tipc_link_reset_stats(link); 1919 spin_unlock_bh(&le->lock); 1920 tipc_node_read_unlock(node); 1921 return 0; 1922 } 1923 1924 /* Caller should hold node lock */ 1925 static int __tipc_nl_add_node_links(struct net *net, struct tipc_nl_msg *msg, 1926 struct tipc_node *node, u32 *prev_link) 1927 { 1928 u32 i; 1929 int err; 1930 1931 for (i = *prev_link; i < MAX_BEARERS; i++) { 1932 *prev_link = i; 1933 1934 if (!node->links[i].link) 1935 continue; 1936 1937 err = __tipc_nl_add_link(net, msg, 1938 node->links[i].link, NLM_F_MULTI); 1939 if (err) 1940 return err; 1941 } 1942 *prev_link = 0; 1943 1944 return 0; 1945 } 1946 1947 int tipc_nl_node_dump_link(struct sk_buff *skb, struct netlink_callback *cb) 1948 { 1949 struct net *net = sock_net(skb->sk); 1950 struct tipc_net *tn = net_generic(net, tipc_net_id); 1951 struct tipc_node *node; 1952 struct tipc_nl_msg msg; 1953 u32 prev_node = cb->args[0]; 1954 u32 prev_link = cb->args[1]; 1955 int done = cb->args[2]; 1956 int err; 1957 1958 if (done) 1959 return 0; 1960 1961 msg.skb = skb; 1962 msg.portid = NETLINK_CB(cb->skb).portid; 1963 msg.seq = cb->nlh->nlmsg_seq; 1964 1965 rcu_read_lock(); 1966 if (prev_node) { 1967 node = tipc_node_find(net, prev_node); 1968 if (!node) { 1969 /* We never set seq or call nl_dump_check_consistent() 1970 * this means that setting prev_seq here will cause the 1971 * consistence check to fail in the netlink callback 1972 * handler. Resulting in the last NLMSG_DONE message 1973 * having the NLM_F_DUMP_INTR flag set. 1974 */ 1975 cb->prev_seq = 1; 1976 goto out; 1977 } 1978 tipc_node_put(node); 1979 1980 list_for_each_entry_continue_rcu(node, &tn->node_list, 1981 list) { 1982 tipc_node_read_lock(node); 1983 err = __tipc_nl_add_node_links(net, &msg, node, 1984 &prev_link); 1985 tipc_node_read_unlock(node); 1986 if (err) 1987 goto out; 1988 1989 prev_node = node->addr; 1990 } 1991 } else { 1992 err = tipc_nl_add_bc_link(net, &msg); 1993 if (err) 1994 goto out; 1995 1996 list_for_each_entry_rcu(node, &tn->node_list, list) { 1997 tipc_node_read_lock(node); 1998 err = __tipc_nl_add_node_links(net, &msg, node, 1999 &prev_link); 2000 tipc_node_read_unlock(node); 2001 if (err) 2002 goto out; 2003 2004 prev_node = node->addr; 2005 } 2006 } 2007 done = 1; 2008 out: 2009 rcu_read_unlock(); 2010 2011 cb->args[0] = prev_node; 2012 cb->args[1] = prev_link; 2013 cb->args[2] = done; 2014 2015 return skb->len; 2016 } 2017 2018 int tipc_nl_node_set_monitor(struct sk_buff *skb, struct genl_info *info) 2019 { 2020 struct nlattr *attrs[TIPC_NLA_MON_MAX + 1]; 2021 struct net *net = sock_net(skb->sk); 2022 int err; 2023 2024 if (!info->attrs[TIPC_NLA_MON]) 2025 return -EINVAL; 2026 2027 err = nla_parse_nested(attrs, TIPC_NLA_MON_MAX, 2028 info->attrs[TIPC_NLA_MON], 2029 tipc_nl_monitor_policy); 2030 if (err) 2031 return err; 2032 2033 if (attrs[TIPC_NLA_MON_ACTIVATION_THRESHOLD]) { 2034 u32 val; 2035 2036 val = nla_get_u32(attrs[TIPC_NLA_MON_ACTIVATION_THRESHOLD]); 2037 err = tipc_nl_monitor_set_threshold(net, val); 2038 if (err) 2039 return err; 2040 } 2041 2042 return 0; 2043 } 2044 2045 static int __tipc_nl_add_monitor_prop(struct net *net, struct tipc_nl_msg *msg) 2046 { 2047 struct nlattr *attrs; 2048 void *hdr; 2049 u32 val; 2050 2051 hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family, 2052 0, TIPC_NL_MON_GET); 2053 if (!hdr) 2054 return -EMSGSIZE; 2055 2056 attrs = nla_nest_start(msg->skb, TIPC_NLA_MON); 2057 if (!attrs) 2058 goto msg_full; 2059 2060 val = tipc_nl_monitor_get_threshold(net); 2061 2062 if (nla_put_u32(msg->skb, TIPC_NLA_MON_ACTIVATION_THRESHOLD, val)) 2063 goto attr_msg_full; 2064 2065 nla_nest_end(msg->skb, attrs); 2066 genlmsg_end(msg->skb, hdr); 2067 2068 return 0; 2069 2070 attr_msg_full: 2071 nla_nest_cancel(msg->skb, attrs); 2072 msg_full: 2073 genlmsg_cancel(msg->skb, hdr); 2074 2075 return -EMSGSIZE; 2076 } 2077 2078 int tipc_nl_node_get_monitor(struct sk_buff *skb, struct genl_info *info) 2079 { 2080 struct net *net = sock_net(skb->sk); 2081 struct tipc_nl_msg msg; 2082 int err; 2083 2084 msg.skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL); 2085 msg.portid = info->snd_portid; 2086 msg.seq = info->snd_seq; 2087 2088 err = __tipc_nl_add_monitor_prop(net, &msg); 2089 if (err) { 2090 nlmsg_free(msg.skb); 2091 return err; 2092 } 2093 2094 return genlmsg_reply(msg.skb, info); 2095 } 2096 2097 int tipc_nl_node_dump_monitor(struct sk_buff *skb, struct netlink_callback *cb) 2098 { 2099 struct net *net = sock_net(skb->sk); 2100 u32 prev_bearer = cb->args[0]; 2101 struct tipc_nl_msg msg; 2102 int err; 2103 int i; 2104 2105 if (prev_bearer == MAX_BEARERS) 2106 return 0; 2107 2108 msg.skb = skb; 2109 msg.portid = NETLINK_CB(cb->skb).portid; 2110 msg.seq = cb->nlh->nlmsg_seq; 2111 2112 rtnl_lock(); 2113 for (i = prev_bearer; i < MAX_BEARERS; i++) { 2114 prev_bearer = i; 2115 err = __tipc_nl_add_monitor(net, &msg, prev_bearer); 2116 if (err) 2117 goto out; 2118 } 2119 2120 out: 2121 rtnl_unlock(); 2122 cb->args[0] = prev_bearer; 2123 2124 return skb->len; 2125 } 2126 2127 int tipc_nl_node_dump_monitor_peer(struct sk_buff *skb, 2128 struct netlink_callback *cb) 2129 { 2130 struct net *net = sock_net(skb->sk); 2131 u32 prev_node = cb->args[1]; 2132 u32 bearer_id = cb->args[2]; 2133 int done = cb->args[0]; 2134 struct tipc_nl_msg msg; 2135 int err; 2136 2137 if (!prev_node) { 2138 struct nlattr **attrs; 2139 struct nlattr *mon[TIPC_NLA_MON_MAX + 1]; 2140 2141 err = tipc_nlmsg_parse(cb->nlh, &attrs); 2142 if (err) 2143 return err; 2144 2145 if (!attrs[TIPC_NLA_MON]) 2146 return -EINVAL; 2147 2148 err = nla_parse_nested(mon, TIPC_NLA_MON_MAX, 2149 attrs[TIPC_NLA_MON], 2150 tipc_nl_monitor_policy); 2151 if (err) 2152 return err; 2153 2154 if (!mon[TIPC_NLA_MON_REF]) 2155 return -EINVAL; 2156 2157 bearer_id = nla_get_u32(mon[TIPC_NLA_MON_REF]); 2158 2159 if (bearer_id >= MAX_BEARERS) 2160 return -EINVAL; 2161 } 2162 2163 if (done) 2164 return 0; 2165 2166 msg.skb = skb; 2167 msg.portid = NETLINK_CB(cb->skb).portid; 2168 msg.seq = cb->nlh->nlmsg_seq; 2169 2170 rtnl_lock(); 2171 err = tipc_nl_add_monitor_peer(net, &msg, bearer_id, &prev_node); 2172 if (!err) 2173 done = 1; 2174 2175 rtnl_unlock(); 2176 cb->args[0] = done; 2177 cb->args[1] = prev_node; 2178 cb->args[2] = bearer_id; 2179 2180 return skb->len; 2181 } 2182