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_sk_rcv(net, list); 1447 return 0; 1448 } 1449 1450 n = tipc_node_find(net, dnode); 1451 if (unlikely(!n)) { 1452 skb_queue_purge(list); 1453 return -EHOSTUNREACH; 1454 } 1455 1456 tipc_node_read_lock(n); 1457 bearer_id = n->active_links[selector & 1]; 1458 if (unlikely(bearer_id == INVALID_BEARER_ID)) { 1459 tipc_node_read_unlock(n); 1460 tipc_node_put(n); 1461 skb_queue_purge(list); 1462 return -EHOSTUNREACH; 1463 } 1464 1465 __skb_queue_head_init(&xmitq); 1466 le = &n->links[bearer_id]; 1467 spin_lock_bh(&le->lock); 1468 rc = tipc_link_xmit(le->link, list, &xmitq); 1469 spin_unlock_bh(&le->lock); 1470 tipc_node_read_unlock(n); 1471 1472 if (unlikely(rc == -ENOBUFS)) 1473 tipc_node_link_down(n, bearer_id, false); 1474 else 1475 tipc_bearer_xmit(net, bearer_id, &xmitq, &le->maddr); 1476 1477 tipc_node_put(n); 1478 1479 return rc; 1480 } 1481 1482 /* tipc_node_xmit_skb(): send single buffer to destination 1483 * Buffers sent via this functon are generally TIPC_SYSTEM_IMPORTANCE 1484 * messages, which will not be rejected 1485 * The only exception is datagram messages rerouted after secondary 1486 * lookup, which are rare and safe to dispose of anyway. 1487 */ 1488 int tipc_node_xmit_skb(struct net *net, struct sk_buff *skb, u32 dnode, 1489 u32 selector) 1490 { 1491 struct sk_buff_head head; 1492 1493 skb_queue_head_init(&head); 1494 __skb_queue_tail(&head, skb); 1495 tipc_node_xmit(net, &head, dnode, selector); 1496 return 0; 1497 } 1498 1499 /* tipc_node_distr_xmit(): send single buffer msgs to individual destinations 1500 * Note: this is only for SYSTEM_IMPORTANCE messages, which cannot be rejected 1501 */ 1502 int tipc_node_distr_xmit(struct net *net, struct sk_buff_head *xmitq) 1503 { 1504 struct sk_buff *skb; 1505 u32 selector, dnode; 1506 1507 while ((skb = __skb_dequeue(xmitq))) { 1508 selector = msg_origport(buf_msg(skb)); 1509 dnode = msg_destnode(buf_msg(skb)); 1510 tipc_node_xmit_skb(net, skb, dnode, selector); 1511 } 1512 return 0; 1513 } 1514 1515 void tipc_node_broadcast(struct net *net, struct sk_buff *skb) 1516 { 1517 struct sk_buff *txskb; 1518 struct tipc_node *n; 1519 u32 dst; 1520 1521 rcu_read_lock(); 1522 list_for_each_entry_rcu(n, tipc_nodes(net), list) { 1523 dst = n->addr; 1524 if (in_own_node(net, dst)) 1525 continue; 1526 if (!node_is_up(n)) 1527 continue; 1528 txskb = pskb_copy(skb, GFP_ATOMIC); 1529 if (!txskb) 1530 break; 1531 msg_set_destnode(buf_msg(txskb), dst); 1532 tipc_node_xmit_skb(net, txskb, dst, 0); 1533 } 1534 rcu_read_unlock(); 1535 1536 kfree_skb(skb); 1537 } 1538 1539 static void tipc_node_mcast_rcv(struct tipc_node *n) 1540 { 1541 struct tipc_bclink_entry *be = &n->bc_entry; 1542 1543 /* 'arrvq' is under inputq2's lock protection */ 1544 spin_lock_bh(&be->inputq2.lock); 1545 spin_lock_bh(&be->inputq1.lock); 1546 skb_queue_splice_tail_init(&be->inputq1, &be->arrvq); 1547 spin_unlock_bh(&be->inputq1.lock); 1548 spin_unlock_bh(&be->inputq2.lock); 1549 tipc_sk_mcast_rcv(n->net, &be->arrvq, &be->inputq2); 1550 } 1551 1552 static void tipc_node_bc_sync_rcv(struct tipc_node *n, struct tipc_msg *hdr, 1553 int bearer_id, struct sk_buff_head *xmitq) 1554 { 1555 struct tipc_link *ucl; 1556 int rc; 1557 1558 rc = tipc_bcast_sync_rcv(n->net, n->bc_entry.link, hdr); 1559 1560 if (rc & TIPC_LINK_DOWN_EVT) { 1561 tipc_node_reset_links(n); 1562 return; 1563 } 1564 1565 if (!(rc & TIPC_LINK_SND_STATE)) 1566 return; 1567 1568 /* If probe message, a STATE response will be sent anyway */ 1569 if (msg_probe(hdr)) 1570 return; 1571 1572 /* Produce a STATE message carrying broadcast NACK */ 1573 tipc_node_read_lock(n); 1574 ucl = n->links[bearer_id].link; 1575 if (ucl) 1576 tipc_link_build_state_msg(ucl, xmitq); 1577 tipc_node_read_unlock(n); 1578 } 1579 1580 /** 1581 * tipc_node_bc_rcv - process TIPC broadcast packet arriving from off-node 1582 * @net: the applicable net namespace 1583 * @skb: TIPC packet 1584 * @bearer_id: id of bearer message arrived on 1585 * 1586 * Invoked with no locks held. 1587 */ 1588 static void tipc_node_bc_rcv(struct net *net, struct sk_buff *skb, int bearer_id) 1589 { 1590 int rc; 1591 struct sk_buff_head xmitq; 1592 struct tipc_bclink_entry *be; 1593 struct tipc_link_entry *le; 1594 struct tipc_msg *hdr = buf_msg(skb); 1595 int usr = msg_user(hdr); 1596 u32 dnode = msg_destnode(hdr); 1597 struct tipc_node *n; 1598 1599 __skb_queue_head_init(&xmitq); 1600 1601 /* If NACK for other node, let rcv link for that node peek into it */ 1602 if ((usr == BCAST_PROTOCOL) && (dnode != tipc_own_addr(net))) 1603 n = tipc_node_find(net, dnode); 1604 else 1605 n = tipc_node_find(net, msg_prevnode(hdr)); 1606 if (!n) { 1607 kfree_skb(skb); 1608 return; 1609 } 1610 be = &n->bc_entry; 1611 le = &n->links[bearer_id]; 1612 1613 rc = tipc_bcast_rcv(net, be->link, skb); 1614 1615 /* Broadcast ACKs are sent on a unicast link */ 1616 if (rc & TIPC_LINK_SND_STATE) { 1617 tipc_node_read_lock(n); 1618 tipc_link_build_state_msg(le->link, &xmitq); 1619 tipc_node_read_unlock(n); 1620 } 1621 1622 if (!skb_queue_empty(&xmitq)) 1623 tipc_bearer_xmit(net, bearer_id, &xmitq, &le->maddr); 1624 1625 if (!skb_queue_empty(&be->inputq1)) 1626 tipc_node_mcast_rcv(n); 1627 1628 /* Handle NAME_DISTRIBUTOR messages sent from 1.7 nodes */ 1629 if (!skb_queue_empty(&n->bc_entry.namedq)) 1630 tipc_named_rcv(net, &n->bc_entry.namedq); 1631 1632 /* If reassembly or retransmission failure => reset all links to peer */ 1633 if (rc & TIPC_LINK_DOWN_EVT) 1634 tipc_node_reset_links(n); 1635 1636 tipc_node_put(n); 1637 } 1638 1639 /** 1640 * tipc_node_check_state - check and if necessary update node state 1641 * @skb: TIPC packet 1642 * @bearer_id: identity of bearer delivering the packet 1643 * Returns true if state and msg are ok, otherwise false 1644 */ 1645 static bool tipc_node_check_state(struct tipc_node *n, struct sk_buff *skb, 1646 int bearer_id, struct sk_buff_head *xmitq) 1647 { 1648 struct tipc_msg *hdr = buf_msg(skb); 1649 int usr = msg_user(hdr); 1650 int mtyp = msg_type(hdr); 1651 u16 oseqno = msg_seqno(hdr); 1652 u16 iseqno = msg_seqno(msg_get_wrapped(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 syncpt = iseqno + exp_pkts - 1; 1752 if (!tipc_link_is_up(l)) 1753 __tipc_node_link_up(n, bearer_id, xmitq); 1754 if (n->state == SELF_UP_PEER_UP) { 1755 n->sync_point = syncpt; 1756 tipc_link_fsm_evt(l, LINK_SYNCH_BEGIN_EVT); 1757 tipc_node_fsm_evt(n, NODE_SYNCH_BEGIN_EVT); 1758 } 1759 } 1760 1761 /* Open tunnel link when parallel link reaches synch point */ 1762 if (n->state == NODE_SYNCHING) { 1763 if (tipc_link_is_synching(l)) { 1764 tnl = l; 1765 } else { 1766 tnl = pl; 1767 pl = l; 1768 } 1769 inputq_len = skb_queue_len(tipc_link_inputq(pl)); 1770 dlv_nxt = tipc_link_rcv_nxt(pl) - inputq_len; 1771 if (more(dlv_nxt, n->sync_point)) { 1772 tipc_link_fsm_evt(tnl, LINK_SYNCH_END_EVT); 1773 tipc_node_fsm_evt(n, NODE_SYNCH_END_EVT); 1774 return true; 1775 } 1776 if (l == pl) 1777 return true; 1778 if ((usr == TUNNEL_PROTOCOL) && (mtyp == SYNCH_MSG)) 1779 return true; 1780 if (usr == LINK_PROTOCOL) 1781 return true; 1782 return false; 1783 } 1784 return true; 1785 } 1786 1787 /** 1788 * tipc_rcv - process TIPC packets/messages arriving from off-node 1789 * @net: the applicable net namespace 1790 * @skb: TIPC packet 1791 * @bearer: pointer to bearer message arrived on 1792 * 1793 * Invoked with no locks held. Bearer pointer must point to a valid bearer 1794 * structure (i.e. cannot be NULL), but bearer can be inactive. 1795 */ 1796 void tipc_rcv(struct net *net, struct sk_buff *skb, struct tipc_bearer *b) 1797 { 1798 struct sk_buff_head xmitq; 1799 struct tipc_node *n; 1800 struct tipc_msg *hdr; 1801 int bearer_id = b->identity; 1802 struct tipc_link_entry *le; 1803 u32 self = tipc_own_addr(net); 1804 int usr, rc = 0; 1805 u16 bc_ack; 1806 1807 __skb_queue_head_init(&xmitq); 1808 1809 /* Ensure message is well-formed before touching the header */ 1810 if (unlikely(!tipc_msg_validate(&skb))) 1811 goto discard; 1812 hdr = buf_msg(skb); 1813 usr = msg_user(hdr); 1814 bc_ack = msg_bcast_ack(hdr); 1815 1816 /* Handle arrival of discovery or broadcast packet */ 1817 if (unlikely(msg_non_seq(hdr))) { 1818 if (unlikely(usr == LINK_CONFIG)) 1819 return tipc_disc_rcv(net, skb, b); 1820 else 1821 return tipc_node_bc_rcv(net, skb, bearer_id); 1822 } 1823 1824 /* Discard unicast link messages destined for another node */ 1825 if (unlikely(!msg_short(hdr) && (msg_destnode(hdr) != self))) 1826 goto discard; 1827 1828 /* Locate neighboring node that sent packet */ 1829 n = tipc_node_find(net, msg_prevnode(hdr)); 1830 if (unlikely(!n)) 1831 goto discard; 1832 le = &n->links[bearer_id]; 1833 1834 /* Ensure broadcast reception is in synch with peer's send state */ 1835 if (unlikely(usr == LINK_PROTOCOL)) 1836 tipc_node_bc_sync_rcv(n, hdr, bearer_id, &xmitq); 1837 else if (unlikely(tipc_link_acked(n->bc_entry.link) != bc_ack)) 1838 tipc_bcast_ack_rcv(net, n->bc_entry.link, hdr); 1839 1840 /* Receive packet directly if conditions permit */ 1841 tipc_node_read_lock(n); 1842 if (likely((n->state == SELF_UP_PEER_UP) && (usr != TUNNEL_PROTOCOL))) { 1843 spin_lock_bh(&le->lock); 1844 if (le->link) { 1845 rc = tipc_link_rcv(le->link, skb, &xmitq); 1846 skb = NULL; 1847 } 1848 spin_unlock_bh(&le->lock); 1849 } 1850 tipc_node_read_unlock(n); 1851 1852 /* Check/update node state before receiving */ 1853 if (unlikely(skb)) { 1854 if (unlikely(skb_linearize(skb))) 1855 goto discard; 1856 tipc_node_write_lock(n); 1857 if (tipc_node_check_state(n, skb, bearer_id, &xmitq)) { 1858 if (le->link) { 1859 rc = tipc_link_rcv(le->link, skb, &xmitq); 1860 skb = NULL; 1861 } 1862 } 1863 tipc_node_write_unlock(n); 1864 } 1865 1866 if (unlikely(rc & TIPC_LINK_UP_EVT)) 1867 tipc_node_link_up(n, bearer_id, &xmitq); 1868 1869 if (unlikely(rc & TIPC_LINK_DOWN_EVT)) 1870 tipc_node_link_down(n, bearer_id, false); 1871 1872 if (unlikely(!skb_queue_empty(&n->bc_entry.namedq))) 1873 tipc_named_rcv(net, &n->bc_entry.namedq); 1874 1875 if (unlikely(!skb_queue_empty(&n->bc_entry.inputq1))) 1876 tipc_node_mcast_rcv(n); 1877 1878 if (!skb_queue_empty(&le->inputq)) 1879 tipc_sk_rcv(net, &le->inputq); 1880 1881 if (!skb_queue_empty(&xmitq)) 1882 tipc_bearer_xmit(net, bearer_id, &xmitq, &le->maddr); 1883 1884 tipc_node_put(n); 1885 discard: 1886 kfree_skb(skb); 1887 } 1888 1889 void tipc_node_apply_property(struct net *net, struct tipc_bearer *b, 1890 int prop) 1891 { 1892 struct tipc_net *tn = tipc_net(net); 1893 int bearer_id = b->identity; 1894 struct sk_buff_head xmitq; 1895 struct tipc_link_entry *e; 1896 struct tipc_node *n; 1897 1898 __skb_queue_head_init(&xmitq); 1899 1900 rcu_read_lock(); 1901 1902 list_for_each_entry_rcu(n, &tn->node_list, list) { 1903 tipc_node_write_lock(n); 1904 e = &n->links[bearer_id]; 1905 if (e->link) { 1906 if (prop == TIPC_NLA_PROP_TOL) 1907 tipc_link_set_tolerance(e->link, b->tolerance, 1908 &xmitq); 1909 else if (prop == TIPC_NLA_PROP_MTU) 1910 tipc_link_set_mtu(e->link, b->mtu); 1911 } 1912 tipc_node_write_unlock(n); 1913 tipc_bearer_xmit(net, bearer_id, &xmitq, &e->maddr); 1914 } 1915 1916 rcu_read_unlock(); 1917 } 1918 1919 int tipc_nl_peer_rm(struct sk_buff *skb, struct genl_info *info) 1920 { 1921 struct net *net = sock_net(skb->sk); 1922 struct tipc_net *tn = net_generic(net, tipc_net_id); 1923 struct nlattr *attrs[TIPC_NLA_NET_MAX + 1]; 1924 struct tipc_node *peer; 1925 u32 addr; 1926 int err; 1927 1928 /* We identify the peer by its net */ 1929 if (!info->attrs[TIPC_NLA_NET]) 1930 return -EINVAL; 1931 1932 err = nla_parse_nested_deprecated(attrs, TIPC_NLA_NET_MAX, 1933 info->attrs[TIPC_NLA_NET], 1934 tipc_nl_net_policy, info->extack); 1935 if (err) 1936 return err; 1937 1938 if (!attrs[TIPC_NLA_NET_ADDR]) 1939 return -EINVAL; 1940 1941 addr = nla_get_u32(attrs[TIPC_NLA_NET_ADDR]); 1942 1943 if (in_own_node(net, addr)) 1944 return -ENOTSUPP; 1945 1946 spin_lock_bh(&tn->node_list_lock); 1947 peer = tipc_node_find(net, addr); 1948 if (!peer) { 1949 spin_unlock_bh(&tn->node_list_lock); 1950 return -ENXIO; 1951 } 1952 1953 tipc_node_write_lock(peer); 1954 if (peer->state != SELF_DOWN_PEER_DOWN && 1955 peer->state != SELF_DOWN_PEER_LEAVING) { 1956 tipc_node_write_unlock(peer); 1957 err = -EBUSY; 1958 goto err_out; 1959 } 1960 1961 tipc_node_clear_links(peer); 1962 tipc_node_write_unlock(peer); 1963 tipc_node_delete(peer); 1964 1965 err = 0; 1966 err_out: 1967 tipc_node_put(peer); 1968 spin_unlock_bh(&tn->node_list_lock); 1969 1970 return err; 1971 } 1972 1973 int tipc_nl_node_dump(struct sk_buff *skb, struct netlink_callback *cb) 1974 { 1975 int err; 1976 struct net *net = sock_net(skb->sk); 1977 struct tipc_net *tn = net_generic(net, tipc_net_id); 1978 int done = cb->args[0]; 1979 int last_addr = cb->args[1]; 1980 struct tipc_node *node; 1981 struct tipc_nl_msg msg; 1982 1983 if (done) 1984 return 0; 1985 1986 msg.skb = skb; 1987 msg.portid = NETLINK_CB(cb->skb).portid; 1988 msg.seq = cb->nlh->nlmsg_seq; 1989 1990 rcu_read_lock(); 1991 if (last_addr) { 1992 node = tipc_node_find(net, last_addr); 1993 if (!node) { 1994 rcu_read_unlock(); 1995 /* We never set seq or call nl_dump_check_consistent() 1996 * this means that setting prev_seq here will cause the 1997 * consistence check to fail in the netlink callback 1998 * handler. Resulting in the NLMSG_DONE message having 1999 * the NLM_F_DUMP_INTR flag set if the node state 2000 * changed while we released the lock. 2001 */ 2002 cb->prev_seq = 1; 2003 return -EPIPE; 2004 } 2005 tipc_node_put(node); 2006 } 2007 2008 list_for_each_entry_rcu(node, &tn->node_list, list) { 2009 if (last_addr) { 2010 if (node->addr == last_addr) 2011 last_addr = 0; 2012 else 2013 continue; 2014 } 2015 2016 tipc_node_read_lock(node); 2017 err = __tipc_nl_add_node(&msg, node); 2018 if (err) { 2019 last_addr = node->addr; 2020 tipc_node_read_unlock(node); 2021 goto out; 2022 } 2023 2024 tipc_node_read_unlock(node); 2025 } 2026 done = 1; 2027 out: 2028 cb->args[0] = done; 2029 cb->args[1] = last_addr; 2030 rcu_read_unlock(); 2031 2032 return skb->len; 2033 } 2034 2035 /* tipc_node_find_by_name - locate owner node of link by link's name 2036 * @net: the applicable net namespace 2037 * @name: pointer to link name string 2038 * @bearer_id: pointer to index in 'node->links' array where the link was found. 2039 * 2040 * Returns pointer to node owning the link, or 0 if no matching link is found. 2041 */ 2042 static struct tipc_node *tipc_node_find_by_name(struct net *net, 2043 const char *link_name, 2044 unsigned int *bearer_id) 2045 { 2046 struct tipc_net *tn = net_generic(net, tipc_net_id); 2047 struct tipc_link *l; 2048 struct tipc_node *n; 2049 struct tipc_node *found_node = NULL; 2050 int i; 2051 2052 *bearer_id = 0; 2053 rcu_read_lock(); 2054 list_for_each_entry_rcu(n, &tn->node_list, list) { 2055 tipc_node_read_lock(n); 2056 for (i = 0; i < MAX_BEARERS; i++) { 2057 l = n->links[i].link; 2058 if (l && !strcmp(tipc_link_name(l), link_name)) { 2059 *bearer_id = i; 2060 found_node = n; 2061 break; 2062 } 2063 } 2064 tipc_node_read_unlock(n); 2065 if (found_node) 2066 break; 2067 } 2068 rcu_read_unlock(); 2069 2070 return found_node; 2071 } 2072 2073 int tipc_nl_node_set_link(struct sk_buff *skb, struct genl_info *info) 2074 { 2075 int err; 2076 int res = 0; 2077 int bearer_id; 2078 char *name; 2079 struct tipc_link *link; 2080 struct tipc_node *node; 2081 struct sk_buff_head xmitq; 2082 struct nlattr *attrs[TIPC_NLA_LINK_MAX + 1]; 2083 struct net *net = sock_net(skb->sk); 2084 2085 __skb_queue_head_init(&xmitq); 2086 2087 if (!info->attrs[TIPC_NLA_LINK]) 2088 return -EINVAL; 2089 2090 err = nla_parse_nested_deprecated(attrs, TIPC_NLA_LINK_MAX, 2091 info->attrs[TIPC_NLA_LINK], 2092 tipc_nl_link_policy, info->extack); 2093 if (err) 2094 return err; 2095 2096 if (!attrs[TIPC_NLA_LINK_NAME]) 2097 return -EINVAL; 2098 2099 name = nla_data(attrs[TIPC_NLA_LINK_NAME]); 2100 2101 if (strcmp(name, tipc_bclink_name) == 0) 2102 return tipc_nl_bc_link_set(net, attrs); 2103 2104 node = tipc_node_find_by_name(net, name, &bearer_id); 2105 if (!node) 2106 return -EINVAL; 2107 2108 tipc_node_read_lock(node); 2109 2110 link = node->links[bearer_id].link; 2111 if (!link) { 2112 res = -EINVAL; 2113 goto out; 2114 } 2115 2116 if (attrs[TIPC_NLA_LINK_PROP]) { 2117 struct nlattr *props[TIPC_NLA_PROP_MAX + 1]; 2118 2119 err = tipc_nl_parse_link_prop(attrs[TIPC_NLA_LINK_PROP], 2120 props); 2121 if (err) { 2122 res = err; 2123 goto out; 2124 } 2125 2126 if (props[TIPC_NLA_PROP_TOL]) { 2127 u32 tol; 2128 2129 tol = nla_get_u32(props[TIPC_NLA_PROP_TOL]); 2130 tipc_link_set_tolerance(link, tol, &xmitq); 2131 } 2132 if (props[TIPC_NLA_PROP_PRIO]) { 2133 u32 prio; 2134 2135 prio = nla_get_u32(props[TIPC_NLA_PROP_PRIO]); 2136 tipc_link_set_prio(link, prio, &xmitq); 2137 } 2138 if (props[TIPC_NLA_PROP_WIN]) { 2139 u32 win; 2140 2141 win = nla_get_u32(props[TIPC_NLA_PROP_WIN]); 2142 tipc_link_set_queue_limits(link, win); 2143 } 2144 } 2145 2146 out: 2147 tipc_node_read_unlock(node); 2148 tipc_bearer_xmit(net, bearer_id, &xmitq, &node->links[bearer_id].maddr); 2149 return res; 2150 } 2151 2152 int tipc_nl_node_get_link(struct sk_buff *skb, struct genl_info *info) 2153 { 2154 struct net *net = genl_info_net(info); 2155 struct nlattr *attrs[TIPC_NLA_LINK_MAX + 1]; 2156 struct tipc_nl_msg msg; 2157 char *name; 2158 int err; 2159 2160 msg.portid = info->snd_portid; 2161 msg.seq = info->snd_seq; 2162 2163 if (!info->attrs[TIPC_NLA_LINK]) 2164 return -EINVAL; 2165 2166 err = nla_parse_nested_deprecated(attrs, TIPC_NLA_LINK_MAX, 2167 info->attrs[TIPC_NLA_LINK], 2168 tipc_nl_link_policy, info->extack); 2169 if (err) 2170 return err; 2171 2172 if (!attrs[TIPC_NLA_LINK_NAME]) 2173 return -EINVAL; 2174 2175 name = nla_data(attrs[TIPC_NLA_LINK_NAME]); 2176 2177 msg.skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL); 2178 if (!msg.skb) 2179 return -ENOMEM; 2180 2181 if (strcmp(name, tipc_bclink_name) == 0) { 2182 err = tipc_nl_add_bc_link(net, &msg); 2183 if (err) 2184 goto err_free; 2185 } else { 2186 int bearer_id; 2187 struct tipc_node *node; 2188 struct tipc_link *link; 2189 2190 node = tipc_node_find_by_name(net, name, &bearer_id); 2191 if (!node) { 2192 err = -EINVAL; 2193 goto err_free; 2194 } 2195 2196 tipc_node_read_lock(node); 2197 link = node->links[bearer_id].link; 2198 if (!link) { 2199 tipc_node_read_unlock(node); 2200 err = -EINVAL; 2201 goto err_free; 2202 } 2203 2204 err = __tipc_nl_add_link(net, &msg, link, 0); 2205 tipc_node_read_unlock(node); 2206 if (err) 2207 goto err_free; 2208 } 2209 2210 return genlmsg_reply(msg.skb, info); 2211 2212 err_free: 2213 nlmsg_free(msg.skb); 2214 return err; 2215 } 2216 2217 int tipc_nl_node_reset_link_stats(struct sk_buff *skb, struct genl_info *info) 2218 { 2219 int err; 2220 char *link_name; 2221 unsigned int bearer_id; 2222 struct tipc_link *link; 2223 struct tipc_node *node; 2224 struct nlattr *attrs[TIPC_NLA_LINK_MAX + 1]; 2225 struct net *net = sock_net(skb->sk); 2226 struct tipc_link_entry *le; 2227 2228 if (!info->attrs[TIPC_NLA_LINK]) 2229 return -EINVAL; 2230 2231 err = nla_parse_nested_deprecated(attrs, TIPC_NLA_LINK_MAX, 2232 info->attrs[TIPC_NLA_LINK], 2233 tipc_nl_link_policy, info->extack); 2234 if (err) 2235 return err; 2236 2237 if (!attrs[TIPC_NLA_LINK_NAME]) 2238 return -EINVAL; 2239 2240 link_name = nla_data(attrs[TIPC_NLA_LINK_NAME]); 2241 2242 if (strcmp(link_name, tipc_bclink_name) == 0) { 2243 err = tipc_bclink_reset_stats(net); 2244 if (err) 2245 return err; 2246 return 0; 2247 } 2248 2249 node = tipc_node_find_by_name(net, link_name, &bearer_id); 2250 if (!node) 2251 return -EINVAL; 2252 2253 le = &node->links[bearer_id]; 2254 tipc_node_read_lock(node); 2255 spin_lock_bh(&le->lock); 2256 link = node->links[bearer_id].link; 2257 if (!link) { 2258 spin_unlock_bh(&le->lock); 2259 tipc_node_read_unlock(node); 2260 return -EINVAL; 2261 } 2262 tipc_link_reset_stats(link); 2263 spin_unlock_bh(&le->lock); 2264 tipc_node_read_unlock(node); 2265 return 0; 2266 } 2267 2268 /* Caller should hold node lock */ 2269 static int __tipc_nl_add_node_links(struct net *net, struct tipc_nl_msg *msg, 2270 struct tipc_node *node, u32 *prev_link) 2271 { 2272 u32 i; 2273 int err; 2274 2275 for (i = *prev_link; i < MAX_BEARERS; i++) { 2276 *prev_link = i; 2277 2278 if (!node->links[i].link) 2279 continue; 2280 2281 err = __tipc_nl_add_link(net, msg, 2282 node->links[i].link, NLM_F_MULTI); 2283 if (err) 2284 return err; 2285 } 2286 *prev_link = 0; 2287 2288 return 0; 2289 } 2290 2291 int tipc_nl_node_dump_link(struct sk_buff *skb, struct netlink_callback *cb) 2292 { 2293 struct net *net = sock_net(skb->sk); 2294 struct tipc_net *tn = net_generic(net, tipc_net_id); 2295 struct tipc_node *node; 2296 struct tipc_nl_msg msg; 2297 u32 prev_node = cb->args[0]; 2298 u32 prev_link = cb->args[1]; 2299 int done = cb->args[2]; 2300 int err; 2301 2302 if (done) 2303 return 0; 2304 2305 msg.skb = skb; 2306 msg.portid = NETLINK_CB(cb->skb).portid; 2307 msg.seq = cb->nlh->nlmsg_seq; 2308 2309 rcu_read_lock(); 2310 if (prev_node) { 2311 node = tipc_node_find(net, prev_node); 2312 if (!node) { 2313 /* We never set seq or call nl_dump_check_consistent() 2314 * this means that setting prev_seq here will cause the 2315 * consistence check to fail in the netlink callback 2316 * handler. Resulting in the last NLMSG_DONE message 2317 * having the NLM_F_DUMP_INTR flag set. 2318 */ 2319 cb->prev_seq = 1; 2320 goto out; 2321 } 2322 tipc_node_put(node); 2323 2324 list_for_each_entry_continue_rcu(node, &tn->node_list, 2325 list) { 2326 tipc_node_read_lock(node); 2327 err = __tipc_nl_add_node_links(net, &msg, node, 2328 &prev_link); 2329 tipc_node_read_unlock(node); 2330 if (err) 2331 goto out; 2332 2333 prev_node = node->addr; 2334 } 2335 } else { 2336 err = tipc_nl_add_bc_link(net, &msg); 2337 if (err) 2338 goto out; 2339 2340 list_for_each_entry_rcu(node, &tn->node_list, list) { 2341 tipc_node_read_lock(node); 2342 err = __tipc_nl_add_node_links(net, &msg, node, 2343 &prev_link); 2344 tipc_node_read_unlock(node); 2345 if (err) 2346 goto out; 2347 2348 prev_node = node->addr; 2349 } 2350 } 2351 done = 1; 2352 out: 2353 rcu_read_unlock(); 2354 2355 cb->args[0] = prev_node; 2356 cb->args[1] = prev_link; 2357 cb->args[2] = done; 2358 2359 return skb->len; 2360 } 2361 2362 int tipc_nl_node_set_monitor(struct sk_buff *skb, struct genl_info *info) 2363 { 2364 struct nlattr *attrs[TIPC_NLA_MON_MAX + 1]; 2365 struct net *net = sock_net(skb->sk); 2366 int err; 2367 2368 if (!info->attrs[TIPC_NLA_MON]) 2369 return -EINVAL; 2370 2371 err = nla_parse_nested_deprecated(attrs, TIPC_NLA_MON_MAX, 2372 info->attrs[TIPC_NLA_MON], 2373 tipc_nl_monitor_policy, 2374 info->extack); 2375 if (err) 2376 return err; 2377 2378 if (attrs[TIPC_NLA_MON_ACTIVATION_THRESHOLD]) { 2379 u32 val; 2380 2381 val = nla_get_u32(attrs[TIPC_NLA_MON_ACTIVATION_THRESHOLD]); 2382 err = tipc_nl_monitor_set_threshold(net, val); 2383 if (err) 2384 return err; 2385 } 2386 2387 return 0; 2388 } 2389 2390 static int __tipc_nl_add_monitor_prop(struct net *net, struct tipc_nl_msg *msg) 2391 { 2392 struct nlattr *attrs; 2393 void *hdr; 2394 u32 val; 2395 2396 hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family, 2397 0, TIPC_NL_MON_GET); 2398 if (!hdr) 2399 return -EMSGSIZE; 2400 2401 attrs = nla_nest_start_noflag(msg->skb, TIPC_NLA_MON); 2402 if (!attrs) 2403 goto msg_full; 2404 2405 val = tipc_nl_monitor_get_threshold(net); 2406 2407 if (nla_put_u32(msg->skb, TIPC_NLA_MON_ACTIVATION_THRESHOLD, val)) 2408 goto attr_msg_full; 2409 2410 nla_nest_end(msg->skb, attrs); 2411 genlmsg_end(msg->skb, hdr); 2412 2413 return 0; 2414 2415 attr_msg_full: 2416 nla_nest_cancel(msg->skb, attrs); 2417 msg_full: 2418 genlmsg_cancel(msg->skb, hdr); 2419 2420 return -EMSGSIZE; 2421 } 2422 2423 int tipc_nl_node_get_monitor(struct sk_buff *skb, struct genl_info *info) 2424 { 2425 struct net *net = sock_net(skb->sk); 2426 struct tipc_nl_msg msg; 2427 int err; 2428 2429 msg.skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL); 2430 if (!msg.skb) 2431 return -ENOMEM; 2432 msg.portid = info->snd_portid; 2433 msg.seq = info->snd_seq; 2434 2435 err = __tipc_nl_add_monitor_prop(net, &msg); 2436 if (err) { 2437 nlmsg_free(msg.skb); 2438 return err; 2439 } 2440 2441 return genlmsg_reply(msg.skb, info); 2442 } 2443 2444 int tipc_nl_node_dump_monitor(struct sk_buff *skb, struct netlink_callback *cb) 2445 { 2446 struct net *net = sock_net(skb->sk); 2447 u32 prev_bearer = cb->args[0]; 2448 struct tipc_nl_msg msg; 2449 int bearer_id; 2450 int err; 2451 2452 if (prev_bearer == MAX_BEARERS) 2453 return 0; 2454 2455 msg.skb = skb; 2456 msg.portid = NETLINK_CB(cb->skb).portid; 2457 msg.seq = cb->nlh->nlmsg_seq; 2458 2459 rtnl_lock(); 2460 for (bearer_id = prev_bearer; bearer_id < MAX_BEARERS; bearer_id++) { 2461 err = __tipc_nl_add_monitor(net, &msg, bearer_id); 2462 if (err) 2463 break; 2464 } 2465 rtnl_unlock(); 2466 cb->args[0] = bearer_id; 2467 2468 return skb->len; 2469 } 2470 2471 int tipc_nl_node_dump_monitor_peer(struct sk_buff *skb, 2472 struct netlink_callback *cb) 2473 { 2474 struct net *net = sock_net(skb->sk); 2475 u32 prev_node = cb->args[1]; 2476 u32 bearer_id = cb->args[2]; 2477 int done = cb->args[0]; 2478 struct tipc_nl_msg msg; 2479 int err; 2480 2481 if (!prev_node) { 2482 struct nlattr **attrs; 2483 struct nlattr *mon[TIPC_NLA_MON_MAX + 1]; 2484 2485 err = tipc_nlmsg_parse(cb->nlh, &attrs); 2486 if (err) 2487 return err; 2488 2489 if (!attrs[TIPC_NLA_MON]) 2490 return -EINVAL; 2491 2492 err = nla_parse_nested_deprecated(mon, TIPC_NLA_MON_MAX, 2493 attrs[TIPC_NLA_MON], 2494 tipc_nl_monitor_policy, 2495 NULL); 2496 if (err) 2497 return err; 2498 2499 if (!mon[TIPC_NLA_MON_REF]) 2500 return -EINVAL; 2501 2502 bearer_id = nla_get_u32(mon[TIPC_NLA_MON_REF]); 2503 2504 if (bearer_id >= MAX_BEARERS) 2505 return -EINVAL; 2506 } 2507 2508 if (done) 2509 return 0; 2510 2511 msg.skb = skb; 2512 msg.portid = NETLINK_CB(cb->skb).portid; 2513 msg.seq = cb->nlh->nlmsg_seq; 2514 2515 rtnl_lock(); 2516 err = tipc_nl_add_monitor_peer(net, &msg, bearer_id, &prev_node); 2517 if (!err) 2518 done = 1; 2519 2520 rtnl_unlock(); 2521 cb->args[0] = done; 2522 cb->args[1] = prev_node; 2523 cb->args[2] = bearer_id; 2524 2525 return skb->len; 2526 } 2527 2528 u32 tipc_node_get_addr(struct tipc_node *node) 2529 { 2530 return (node) ? node->addr : 0; 2531 } 2532 2533 /** 2534 * tipc_node_dump - dump TIPC node data 2535 * @n: tipc node to be dumped 2536 * @more: dump more? 2537 * - false: dump only tipc node data 2538 * - true: dump node link data as well 2539 * @buf: returned buffer of dump data in format 2540 */ 2541 int tipc_node_dump(struct tipc_node *n, bool more, char *buf) 2542 { 2543 int i = 0; 2544 size_t sz = (more) ? NODE_LMAX : NODE_LMIN; 2545 2546 if (!n) { 2547 i += scnprintf(buf, sz, "node data: (null)\n"); 2548 return i; 2549 } 2550 2551 i += scnprintf(buf, sz, "node data: %x", n->addr); 2552 i += scnprintf(buf + i, sz - i, " %x", n->state); 2553 i += scnprintf(buf + i, sz - i, " %d", n->active_links[0]); 2554 i += scnprintf(buf + i, sz - i, " %d", n->active_links[1]); 2555 i += scnprintf(buf + i, sz - i, " %x", n->action_flags); 2556 i += scnprintf(buf + i, sz - i, " %u", n->failover_sent); 2557 i += scnprintf(buf + i, sz - i, " %u", n->sync_point); 2558 i += scnprintf(buf + i, sz - i, " %d", n->link_cnt); 2559 i += scnprintf(buf + i, sz - i, " %u", n->working_links); 2560 i += scnprintf(buf + i, sz - i, " %x", n->capabilities); 2561 i += scnprintf(buf + i, sz - i, " %lu\n", n->keepalive_intv); 2562 2563 if (!more) 2564 return i; 2565 2566 i += scnprintf(buf + i, sz - i, "link_entry[0]:\n"); 2567 i += scnprintf(buf + i, sz - i, " mtu: %u\n", n->links[0].mtu); 2568 i += scnprintf(buf + i, sz - i, " media: "); 2569 i += tipc_media_addr_printf(buf + i, sz - i, &n->links[0].maddr); 2570 i += scnprintf(buf + i, sz - i, "\n"); 2571 i += tipc_link_dump(n->links[0].link, TIPC_DUMP_NONE, buf + i); 2572 i += scnprintf(buf + i, sz - i, " inputq: "); 2573 i += tipc_list_dump(&n->links[0].inputq, false, buf + i); 2574 2575 i += scnprintf(buf + i, sz - i, "link_entry[1]:\n"); 2576 i += scnprintf(buf + i, sz - i, " mtu: %u\n", n->links[1].mtu); 2577 i += scnprintf(buf + i, sz - i, " media: "); 2578 i += tipc_media_addr_printf(buf + i, sz - i, &n->links[1].maddr); 2579 i += scnprintf(buf + i, sz - i, "\n"); 2580 i += tipc_link_dump(n->links[1].link, TIPC_DUMP_NONE, buf + i); 2581 i += scnprintf(buf + i, sz - i, " inputq: "); 2582 i += tipc_list_dump(&n->links[1].inputq, false, buf + i); 2583 2584 i += scnprintf(buf + i, sz - i, "bclink:\n "); 2585 i += tipc_link_dump(n->bc_entry.link, TIPC_DUMP_NONE, buf + i); 2586 2587 return i; 2588 } 2589