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