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