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 #include "crypto.h" 48 49 #define INVALID_NODE_SIG 0x10000 50 #define NODE_CLEANUP_AFTER 300000 51 52 /* Flags used to take different actions according to flag type 53 * TIPC_NOTIFY_NODE_DOWN: notify node is down 54 * TIPC_NOTIFY_NODE_UP: notify node is up 55 * TIPC_DISTRIBUTE_NAME: publish or withdraw link state name type 56 */ 57 enum { 58 TIPC_NOTIFY_NODE_DOWN = (1 << 3), 59 TIPC_NOTIFY_NODE_UP = (1 << 4), 60 TIPC_NOTIFY_LINK_UP = (1 << 6), 61 TIPC_NOTIFY_LINK_DOWN = (1 << 7) 62 }; 63 64 struct tipc_link_entry { 65 struct tipc_link *link; 66 spinlock_t lock; /* per link */ 67 u32 mtu; 68 struct sk_buff_head inputq; 69 struct tipc_media_addr maddr; 70 }; 71 72 struct tipc_bclink_entry { 73 struct tipc_link *link; 74 struct sk_buff_head inputq1; 75 struct sk_buff_head arrvq; 76 struct sk_buff_head inputq2; 77 struct sk_buff_head namedq; 78 u16 named_rcv_nxt; 79 bool named_open; 80 }; 81 82 /** 83 * struct tipc_node - TIPC node structure 84 * @addr: network address of node 85 * @kref: reference counter to node object 86 * @lock: rwlock governing access to structure 87 * @net: the applicable net namespace 88 * @hash: links to adjacent nodes in unsorted hash chain 89 * @active_links: bearer ids of active links, used as index into links[] array 90 * @links: array containing references to all links to node 91 * @bc_entry: broadcast link entry 92 * @action_flags: bit mask of different types of node actions 93 * @state: connectivity state vs peer node 94 * @preliminary: a preliminary node or not 95 * @failover_sent: failover sent or not 96 * @sync_point: sequence number where synch/failover is finished 97 * @list: links to adjacent nodes in sorted list of cluster's nodes 98 * @working_links: number of working links to node (both active and standby) 99 * @link_cnt: number of links to node 100 * @capabilities: bitmap, indicating peer node's functional capabilities 101 * @signature: node instance identifier 102 * @link_id: local and remote bearer ids of changing link, if any 103 * @peer_id: 128-bit ID of peer 104 * @peer_id_string: ID string of peer 105 * @publ_list: list of publications 106 * @conn_sks: list of connections (FIXME) 107 * @timer: node's keepalive timer 108 * @keepalive_intv: keepalive interval in milliseconds 109 * @rcu: rcu struct for tipc_node 110 * @delete_at: indicates the time for deleting a down node 111 * @peer_net: peer's net namespace 112 * @peer_hash_mix: hash for this peer (FIXME) 113 * @crypto_rx: RX crypto handler 114 */ 115 struct tipc_node { 116 u32 addr; 117 struct kref kref; 118 rwlock_t lock; 119 struct net *net; 120 struct hlist_node hash; 121 int active_links[2]; 122 struct tipc_link_entry links[MAX_BEARERS]; 123 struct tipc_bclink_entry bc_entry; 124 int action_flags; 125 struct list_head list; 126 int state; 127 bool preliminary; 128 bool failover_sent; 129 u16 sync_point; 130 int link_cnt; 131 u16 working_links; 132 u16 capabilities; 133 u32 signature; 134 u32 link_id; 135 u8 peer_id[16]; 136 char peer_id_string[NODE_ID_STR_LEN]; 137 struct list_head publ_list; 138 struct list_head conn_sks; 139 unsigned long keepalive_intv; 140 struct timer_list timer; 141 struct rcu_head rcu; 142 unsigned long delete_at; 143 struct net *peer_net; 144 u32 peer_hash_mix; 145 #ifdef CONFIG_TIPC_CRYPTO 146 struct tipc_crypto *crypto_rx; 147 #endif 148 }; 149 150 /* Node FSM states and events: 151 */ 152 enum { 153 SELF_DOWN_PEER_DOWN = 0xdd, 154 SELF_UP_PEER_UP = 0xaa, 155 SELF_DOWN_PEER_LEAVING = 0xd1, 156 SELF_UP_PEER_COMING = 0xac, 157 SELF_COMING_PEER_UP = 0xca, 158 SELF_LEAVING_PEER_DOWN = 0x1d, 159 NODE_FAILINGOVER = 0xf0, 160 NODE_SYNCHING = 0xcc 161 }; 162 163 enum { 164 SELF_ESTABL_CONTACT_EVT = 0xece, 165 SELF_LOST_CONTACT_EVT = 0x1ce, 166 PEER_ESTABL_CONTACT_EVT = 0x9ece, 167 PEER_LOST_CONTACT_EVT = 0x91ce, 168 NODE_FAILOVER_BEGIN_EVT = 0xfbe, 169 NODE_FAILOVER_END_EVT = 0xfee, 170 NODE_SYNCH_BEGIN_EVT = 0xcbe, 171 NODE_SYNCH_END_EVT = 0xcee 172 }; 173 174 static void __tipc_node_link_down(struct tipc_node *n, int *bearer_id, 175 struct sk_buff_head *xmitq, 176 struct tipc_media_addr **maddr); 177 static void tipc_node_link_down(struct tipc_node *n, int bearer_id, 178 bool delete); 179 static void node_lost_contact(struct tipc_node *n, struct sk_buff_head *inputq); 180 static void tipc_node_delete(struct tipc_node *node); 181 static void tipc_node_timeout(struct timer_list *t); 182 static void tipc_node_fsm_evt(struct tipc_node *n, int evt); 183 static struct tipc_node *tipc_node_find(struct net *net, u32 addr); 184 static struct tipc_node *tipc_node_find_by_id(struct net *net, u8 *id); 185 static bool node_is_up(struct tipc_node *n); 186 static void tipc_node_delete_from_list(struct tipc_node *node); 187 188 struct tipc_sock_conn { 189 u32 port; 190 u32 peer_port; 191 u32 peer_node; 192 struct list_head list; 193 }; 194 195 static struct tipc_link *node_active_link(struct tipc_node *n, int sel) 196 { 197 int bearer_id = n->active_links[sel & 1]; 198 199 if (unlikely(bearer_id == INVALID_BEARER_ID)) 200 return NULL; 201 202 return n->links[bearer_id].link; 203 } 204 205 int tipc_node_get_mtu(struct net *net, u32 addr, u32 sel, bool connected) 206 { 207 struct tipc_node *n; 208 int bearer_id; 209 unsigned int mtu = MAX_MSG_SIZE; 210 211 n = tipc_node_find(net, addr); 212 if (unlikely(!n)) 213 return mtu; 214 215 /* Allow MAX_MSG_SIZE when building connection oriented message 216 * if they are in the same core network 217 */ 218 if (n->peer_net && connected) { 219 tipc_node_put(n); 220 return mtu; 221 } 222 223 bearer_id = n->active_links[sel & 1]; 224 if (likely(bearer_id != INVALID_BEARER_ID)) 225 mtu = n->links[bearer_id].mtu; 226 tipc_node_put(n); 227 return mtu; 228 } 229 230 bool tipc_node_get_id(struct net *net, u32 addr, u8 *id) 231 { 232 u8 *own_id = tipc_own_id(net); 233 struct tipc_node *n; 234 235 if (!own_id) 236 return true; 237 238 if (addr == tipc_own_addr(net)) { 239 memcpy(id, own_id, TIPC_NODEID_LEN); 240 return true; 241 } 242 n = tipc_node_find(net, addr); 243 if (!n) 244 return false; 245 246 memcpy(id, &n->peer_id, TIPC_NODEID_LEN); 247 tipc_node_put(n); 248 return true; 249 } 250 251 u16 tipc_node_get_capabilities(struct net *net, u32 addr) 252 { 253 struct tipc_node *n; 254 u16 caps; 255 256 n = tipc_node_find(net, addr); 257 if (unlikely(!n)) 258 return TIPC_NODE_CAPABILITIES; 259 caps = n->capabilities; 260 tipc_node_put(n); 261 return caps; 262 } 263 264 u32 tipc_node_get_addr(struct tipc_node *node) 265 { 266 return (node) ? node->addr : 0; 267 } 268 269 char *tipc_node_get_id_str(struct tipc_node *node) 270 { 271 return node->peer_id_string; 272 } 273 274 #ifdef CONFIG_TIPC_CRYPTO 275 /** 276 * tipc_node_crypto_rx - Retrieve crypto RX handle from node 277 * @__n: target tipc_node 278 * Note: node ref counter must be held first! 279 */ 280 struct tipc_crypto *tipc_node_crypto_rx(struct tipc_node *__n) 281 { 282 return (__n) ? __n->crypto_rx : NULL; 283 } 284 285 struct tipc_crypto *tipc_node_crypto_rx_by_list(struct list_head *pos) 286 { 287 return container_of(pos, struct tipc_node, list)->crypto_rx; 288 } 289 290 struct tipc_crypto *tipc_node_crypto_rx_by_addr(struct net *net, u32 addr) 291 { 292 struct tipc_node *n; 293 294 n = tipc_node_find(net, addr); 295 return (n) ? n->crypto_rx : NULL; 296 } 297 #endif 298 299 static void tipc_node_free(struct rcu_head *rp) 300 { 301 struct tipc_node *n = container_of(rp, struct tipc_node, rcu); 302 303 #ifdef CONFIG_TIPC_CRYPTO 304 tipc_crypto_stop(&n->crypto_rx); 305 #endif 306 kfree(n); 307 } 308 309 static void tipc_node_kref_release(struct kref *kref) 310 { 311 struct tipc_node *n = container_of(kref, struct tipc_node, kref); 312 313 kfree(n->bc_entry.link); 314 call_rcu(&n->rcu, tipc_node_free); 315 } 316 317 void tipc_node_put(struct tipc_node *node) 318 { 319 kref_put(&node->kref, tipc_node_kref_release); 320 } 321 322 void tipc_node_get(struct tipc_node *node) 323 { 324 kref_get(&node->kref); 325 } 326 327 /* 328 * tipc_node_find - locate specified node object, if it exists 329 */ 330 static struct tipc_node *tipc_node_find(struct net *net, u32 addr) 331 { 332 struct tipc_net *tn = tipc_net(net); 333 struct tipc_node *node; 334 unsigned int thash = tipc_hashfn(addr); 335 336 rcu_read_lock(); 337 hlist_for_each_entry_rcu(node, &tn->node_htable[thash], hash) { 338 if (node->addr != addr || node->preliminary) 339 continue; 340 if (!kref_get_unless_zero(&node->kref)) 341 node = NULL; 342 break; 343 } 344 rcu_read_unlock(); 345 return node; 346 } 347 348 /* tipc_node_find_by_id - locate specified node object by its 128-bit id 349 * Note: this function is called only when a discovery request failed 350 * to find the node by its 32-bit id, and is not time critical 351 */ 352 static struct tipc_node *tipc_node_find_by_id(struct net *net, u8 *id) 353 { 354 struct tipc_net *tn = tipc_net(net); 355 struct tipc_node *n; 356 bool found = false; 357 358 rcu_read_lock(); 359 list_for_each_entry_rcu(n, &tn->node_list, list) { 360 read_lock_bh(&n->lock); 361 if (!memcmp(id, n->peer_id, 16) && 362 kref_get_unless_zero(&n->kref)) 363 found = true; 364 read_unlock_bh(&n->lock); 365 if (found) 366 break; 367 } 368 rcu_read_unlock(); 369 return found ? n : NULL; 370 } 371 372 static void tipc_node_read_lock(struct tipc_node *n) 373 __acquires(n->lock) 374 { 375 read_lock_bh(&n->lock); 376 } 377 378 static void tipc_node_read_unlock(struct tipc_node *n) 379 __releases(n->lock) 380 { 381 read_unlock_bh(&n->lock); 382 } 383 384 static void tipc_node_write_lock(struct tipc_node *n) 385 __acquires(n->lock) 386 { 387 write_lock_bh(&n->lock); 388 } 389 390 static void tipc_node_write_unlock_fast(struct tipc_node *n) 391 __releases(n->lock) 392 { 393 write_unlock_bh(&n->lock); 394 } 395 396 static void tipc_node_write_unlock(struct tipc_node *n) 397 __releases(n->lock) 398 { 399 struct tipc_socket_addr sk; 400 struct net *net = n->net; 401 u32 flags = n->action_flags; 402 struct list_head *publ_list; 403 struct tipc_uaddr ua; 404 u32 bearer_id, node; 405 406 if (likely(!flags)) { 407 write_unlock_bh(&n->lock); 408 return; 409 } 410 411 tipc_uaddr(&ua, TIPC_SERVICE_RANGE, TIPC_NODE_SCOPE, 412 TIPC_LINK_STATE, n->addr, n->addr); 413 sk.ref = n->link_id; 414 sk.node = tipc_own_addr(net); 415 node = n->addr; 416 bearer_id = n->link_id & 0xffff; 417 publ_list = &n->publ_list; 418 419 n->action_flags &= ~(TIPC_NOTIFY_NODE_DOWN | TIPC_NOTIFY_NODE_UP | 420 TIPC_NOTIFY_LINK_DOWN | TIPC_NOTIFY_LINK_UP); 421 422 write_unlock_bh(&n->lock); 423 424 if (flags & TIPC_NOTIFY_NODE_DOWN) 425 tipc_publ_notify(net, publ_list, node, n->capabilities); 426 427 if (flags & TIPC_NOTIFY_NODE_UP) 428 tipc_named_node_up(net, node, n->capabilities); 429 430 if (flags & TIPC_NOTIFY_LINK_UP) { 431 tipc_mon_peer_up(net, node, bearer_id); 432 tipc_nametbl_publish(net, &ua, &sk, sk.ref); 433 } 434 if (flags & TIPC_NOTIFY_LINK_DOWN) { 435 tipc_mon_peer_down(net, node, bearer_id); 436 tipc_nametbl_withdraw(net, &ua, &sk, sk.ref); 437 } 438 } 439 440 static void tipc_node_assign_peer_net(struct tipc_node *n, u32 hash_mixes) 441 { 442 int net_id = tipc_netid(n->net); 443 struct tipc_net *tn_peer; 444 struct net *tmp; 445 u32 hash_chk; 446 447 if (n->peer_net) 448 return; 449 450 for_each_net_rcu(tmp) { 451 tn_peer = tipc_net(tmp); 452 if (!tn_peer) 453 continue; 454 /* Integrity checking whether node exists in namespace or not */ 455 if (tn_peer->net_id != net_id) 456 continue; 457 if (memcmp(n->peer_id, tn_peer->node_id, NODE_ID_LEN)) 458 continue; 459 hash_chk = tipc_net_hash_mixes(tmp, tn_peer->random); 460 if (hash_mixes ^ hash_chk) 461 continue; 462 n->peer_net = tmp; 463 n->peer_hash_mix = hash_mixes; 464 break; 465 } 466 } 467 468 struct tipc_node *tipc_node_create(struct net *net, u32 addr, u8 *peer_id, 469 u16 capabilities, u32 hash_mixes, 470 bool preliminary) 471 { 472 struct tipc_net *tn = net_generic(net, tipc_net_id); 473 struct tipc_link *l, *snd_l = tipc_bc_sndlink(net); 474 struct tipc_node *n, *temp_node; 475 unsigned long intv; 476 int bearer_id; 477 int i; 478 479 spin_lock_bh(&tn->node_list_lock); 480 n = tipc_node_find(net, addr) ?: 481 tipc_node_find_by_id(net, peer_id); 482 if (n) { 483 if (!n->preliminary) 484 goto update; 485 if (preliminary) 486 goto exit; 487 /* A preliminary node becomes "real" now, refresh its data */ 488 tipc_node_write_lock(n); 489 if (!tipc_link_bc_create(net, tipc_own_addr(net), addr, peer_id, U16_MAX, 490 tipc_link_min_win(snd_l), tipc_link_max_win(snd_l), 491 n->capabilities, &n->bc_entry.inputq1, 492 &n->bc_entry.namedq, snd_l, &n->bc_entry.link)) { 493 pr_warn("Broadcast rcv link refresh failed, no memory\n"); 494 tipc_node_write_unlock_fast(n); 495 tipc_node_put(n); 496 n = NULL; 497 goto exit; 498 } 499 n->preliminary = false; 500 n->addr = addr; 501 hlist_del_rcu(&n->hash); 502 hlist_add_head_rcu(&n->hash, 503 &tn->node_htable[tipc_hashfn(addr)]); 504 list_del_rcu(&n->list); 505 list_for_each_entry_rcu(temp_node, &tn->node_list, list) { 506 if (n->addr < temp_node->addr) 507 break; 508 } 509 list_add_tail_rcu(&n->list, &temp_node->list); 510 tipc_node_write_unlock_fast(n); 511 512 update: 513 if (n->peer_hash_mix ^ hash_mixes) 514 tipc_node_assign_peer_net(n, hash_mixes); 515 if (n->capabilities == capabilities) 516 goto exit; 517 /* Same node may come back with new capabilities */ 518 tipc_node_write_lock(n); 519 n->capabilities = capabilities; 520 for (bearer_id = 0; bearer_id < MAX_BEARERS; bearer_id++) { 521 l = n->links[bearer_id].link; 522 if (l) 523 tipc_link_update_caps(l, capabilities); 524 } 525 tipc_node_write_unlock_fast(n); 526 527 /* Calculate cluster capabilities */ 528 tn->capabilities = TIPC_NODE_CAPABILITIES; 529 list_for_each_entry_rcu(temp_node, &tn->node_list, list) { 530 tn->capabilities &= temp_node->capabilities; 531 } 532 533 tipc_bcast_toggle_rcast(net, 534 (tn->capabilities & TIPC_BCAST_RCAST)); 535 536 goto exit; 537 } 538 n = kzalloc_obj(*n, GFP_ATOMIC); 539 if (!n) { 540 pr_warn("Node creation failed, no memory\n"); 541 goto exit; 542 } 543 tipc_nodeid2string(n->peer_id_string, peer_id); 544 #ifdef CONFIG_TIPC_CRYPTO 545 if (unlikely(tipc_crypto_start(&n->crypto_rx, net, n))) { 546 pr_warn("Failed to start crypto RX(%s)!\n", n->peer_id_string); 547 kfree(n); 548 n = NULL; 549 goto exit; 550 } 551 #endif 552 n->addr = addr; 553 n->preliminary = preliminary; 554 memcpy(&n->peer_id, peer_id, 16); 555 n->net = net; 556 n->peer_net = NULL; 557 n->peer_hash_mix = 0; 558 /* Assign kernel local namespace if exists */ 559 tipc_node_assign_peer_net(n, hash_mixes); 560 n->capabilities = capabilities; 561 kref_init(&n->kref); 562 rwlock_init(&n->lock); 563 INIT_HLIST_NODE(&n->hash); 564 INIT_LIST_HEAD(&n->list); 565 INIT_LIST_HEAD(&n->publ_list); 566 INIT_LIST_HEAD(&n->conn_sks); 567 skb_queue_head_init(&n->bc_entry.namedq); 568 skb_queue_head_init(&n->bc_entry.inputq1); 569 __skb_queue_head_init(&n->bc_entry.arrvq); 570 skb_queue_head_init(&n->bc_entry.inputq2); 571 for (i = 0; i < MAX_BEARERS; i++) 572 spin_lock_init(&n->links[i].lock); 573 n->state = SELF_DOWN_PEER_LEAVING; 574 n->delete_at = jiffies + msecs_to_jiffies(NODE_CLEANUP_AFTER); 575 n->signature = INVALID_NODE_SIG; 576 n->active_links[0] = INVALID_BEARER_ID; 577 n->active_links[1] = INVALID_BEARER_ID; 578 if (!preliminary && 579 !tipc_link_bc_create(net, tipc_own_addr(net), addr, peer_id, U16_MAX, 580 tipc_link_min_win(snd_l), tipc_link_max_win(snd_l), 581 n->capabilities, &n->bc_entry.inputq1, 582 &n->bc_entry.namedq, snd_l, &n->bc_entry.link)) { 583 pr_warn("Broadcast rcv link creation failed, no memory\n"); 584 tipc_node_put(n); 585 n = NULL; 586 goto exit; 587 } 588 tipc_node_get(n); 589 timer_setup(&n->timer, tipc_node_timeout, 0); 590 /* Start a slow timer anyway, crypto needs it */ 591 n->keepalive_intv = 10000; 592 intv = jiffies + msecs_to_jiffies(n->keepalive_intv); 593 if (!mod_timer(&n->timer, intv)) 594 tipc_node_get(n); 595 hlist_add_head_rcu(&n->hash, &tn->node_htable[tipc_hashfn(addr)]); 596 list_for_each_entry_rcu(temp_node, &tn->node_list, list) { 597 if (n->addr < temp_node->addr) 598 break; 599 } 600 list_add_tail_rcu(&n->list, &temp_node->list); 601 /* Calculate cluster capabilities */ 602 tn->capabilities = TIPC_NODE_CAPABILITIES; 603 list_for_each_entry_rcu(temp_node, &tn->node_list, list) { 604 tn->capabilities &= temp_node->capabilities; 605 } 606 tipc_bcast_toggle_rcast(net, (tn->capabilities & TIPC_BCAST_RCAST)); 607 trace_tipc_node_create(n, true, " "); 608 exit: 609 spin_unlock_bh(&tn->node_list_lock); 610 return n; 611 } 612 613 static void tipc_node_calculate_timer(struct tipc_node *n, struct tipc_link *l) 614 { 615 unsigned long tol = tipc_link_tolerance(l); 616 unsigned long intv = ((tol / 4) > 500) ? 500 : tol / 4; 617 618 /* Link with lowest tolerance determines timer interval */ 619 if (intv < n->keepalive_intv) 620 n->keepalive_intv = intv; 621 622 /* Ensure link's abort limit corresponds to current tolerance */ 623 tipc_link_set_abort_limit(l, tol / n->keepalive_intv); 624 } 625 626 static void tipc_node_delete_from_list(struct tipc_node *node) 627 { 628 #ifdef CONFIG_TIPC_CRYPTO 629 tipc_crypto_key_flush(node->crypto_rx); 630 #endif 631 list_del_rcu(&node->list); 632 hlist_del_rcu(&node->hash); 633 tipc_node_put(node); 634 } 635 636 static void tipc_node_delete(struct tipc_node *node) 637 { 638 trace_tipc_node_delete(node, true, " "); 639 tipc_node_delete_from_list(node); 640 641 timer_delete_sync(&node->timer); 642 tipc_node_put(node); 643 } 644 645 void tipc_node_stop(struct net *net) 646 { 647 struct tipc_net *tn = tipc_net(net); 648 struct tipc_node *node, *t_node; 649 650 spin_lock_bh(&tn->node_list_lock); 651 list_for_each_entry_safe(node, t_node, &tn->node_list, list) 652 tipc_node_delete(node); 653 spin_unlock_bh(&tn->node_list_lock); 654 } 655 656 void tipc_node_subscribe(struct net *net, struct list_head *subscr, u32 addr) 657 { 658 struct tipc_node *n; 659 660 if (in_own_node(net, addr)) 661 return; 662 663 n = tipc_node_find(net, addr); 664 if (!n) { 665 pr_warn("Node subscribe rejected, unknown node 0x%x\n", addr); 666 return; 667 } 668 tipc_node_write_lock(n); 669 list_add_tail(subscr, &n->publ_list); 670 tipc_node_write_unlock_fast(n); 671 tipc_node_put(n); 672 } 673 674 void tipc_node_unsubscribe(struct net *net, struct list_head *subscr, u32 addr) 675 { 676 struct tipc_node *n; 677 678 if (in_own_node(net, addr)) 679 return; 680 681 n = tipc_node_find(net, addr); 682 if (!n) { 683 pr_warn("Node unsubscribe rejected, unknown node 0x%x\n", addr); 684 return; 685 } 686 tipc_node_write_lock(n); 687 list_del_init(subscr); 688 tipc_node_write_unlock_fast(n); 689 tipc_node_put(n); 690 } 691 692 int tipc_node_add_conn(struct net *net, u32 dnode, u32 port, u32 peer_port) 693 { 694 struct tipc_node *node; 695 struct tipc_sock_conn *conn; 696 int err = 0; 697 698 if (in_own_node(net, dnode)) 699 return 0; 700 701 node = tipc_node_find(net, dnode); 702 if (!node) { 703 pr_warn("Connecting sock to node 0x%x failed\n", dnode); 704 return -EHOSTUNREACH; 705 } 706 conn = kmalloc_obj(*conn, GFP_ATOMIC); 707 if (!conn) { 708 err = -EHOSTUNREACH; 709 goto exit; 710 } 711 conn->peer_node = dnode; 712 conn->port = port; 713 conn->peer_port = peer_port; 714 715 tipc_node_write_lock(node); 716 list_add_tail(&conn->list, &node->conn_sks); 717 tipc_node_write_unlock(node); 718 exit: 719 tipc_node_put(node); 720 return err; 721 } 722 723 void tipc_node_remove_conn(struct net *net, u32 dnode, u32 port) 724 { 725 struct tipc_node *node; 726 struct tipc_sock_conn *conn, *safe; 727 728 if (in_own_node(net, dnode)) 729 return; 730 731 node = tipc_node_find(net, dnode); 732 if (!node) 733 return; 734 735 tipc_node_write_lock(node); 736 list_for_each_entry_safe(conn, safe, &node->conn_sks, list) { 737 if (port != conn->port) 738 continue; 739 list_del(&conn->list); 740 kfree(conn); 741 } 742 tipc_node_write_unlock(node); 743 tipc_node_put(node); 744 } 745 746 static void tipc_node_clear_links(struct tipc_node *node) 747 { 748 int i; 749 750 for (i = 0; i < MAX_BEARERS; i++) { 751 struct tipc_link_entry *le = &node->links[i]; 752 753 if (le->link) { 754 kfree(le->link); 755 le->link = NULL; 756 node->link_cnt--; 757 } 758 } 759 } 760 761 /* tipc_node_cleanup - delete nodes that does not 762 * have active links for NODE_CLEANUP_AFTER time 763 */ 764 static bool tipc_node_cleanup(struct tipc_node *peer) 765 { 766 struct tipc_node *temp_node; 767 struct tipc_net *tn = tipc_net(peer->net); 768 bool deleted = false; 769 770 /* If lock held by tipc_node_stop() the node will be deleted anyway */ 771 if (!spin_trylock_bh(&tn->node_list_lock)) 772 return false; 773 774 tipc_node_write_lock(peer); 775 776 if (!node_is_up(peer) && time_after(jiffies, peer->delete_at)) { 777 tipc_node_clear_links(peer); 778 tipc_node_delete_from_list(peer); 779 deleted = true; 780 } 781 tipc_node_write_unlock(peer); 782 783 if (!deleted) { 784 spin_unlock_bh(&tn->node_list_lock); 785 return deleted; 786 } 787 788 /* Calculate cluster capabilities */ 789 tn->capabilities = TIPC_NODE_CAPABILITIES; 790 list_for_each_entry_rcu(temp_node, &tn->node_list, list) { 791 tn->capabilities &= temp_node->capabilities; 792 } 793 tipc_bcast_toggle_rcast(peer->net, 794 (tn->capabilities & TIPC_BCAST_RCAST)); 795 spin_unlock_bh(&tn->node_list_lock); 796 return deleted; 797 } 798 799 /* tipc_node_timeout - handle expiration of node timer 800 */ 801 static void tipc_node_timeout(struct timer_list *t) 802 { 803 struct tipc_node *n = timer_container_of(n, t, timer); 804 struct tipc_link_entry *le; 805 struct sk_buff_head xmitq; 806 int remains = n->link_cnt; 807 int bearer_id; 808 int rc = 0; 809 810 trace_tipc_node_timeout(n, false, " "); 811 if (!node_is_up(n) && tipc_node_cleanup(n)) { 812 /*Removing the reference of Timer*/ 813 tipc_node_put(n); 814 return; 815 } 816 817 #ifdef CONFIG_TIPC_CRYPTO 818 /* Take any crypto key related actions first */ 819 tipc_crypto_timeout(n->crypto_rx); 820 #endif 821 __skb_queue_head_init(&xmitq); 822 823 /* Initial node interval to value larger (10 seconds), then it will be 824 * recalculated with link lowest tolerance 825 */ 826 tipc_node_read_lock(n); 827 n->keepalive_intv = 10000; 828 tipc_node_read_unlock(n); 829 for (bearer_id = 0; remains && (bearer_id < MAX_BEARERS); bearer_id++) { 830 tipc_node_read_lock(n); 831 le = &n->links[bearer_id]; 832 if (le->link) { 833 spin_lock_bh(&le->lock); 834 /* Link tolerance may change asynchronously: */ 835 tipc_node_calculate_timer(n, le->link); 836 rc = tipc_link_timeout(le->link, &xmitq); 837 spin_unlock_bh(&le->lock); 838 remains--; 839 } 840 tipc_node_read_unlock(n); 841 tipc_bearer_xmit(n->net, bearer_id, &xmitq, &le->maddr, n); 842 if (rc & TIPC_LINK_DOWN_EVT) 843 tipc_node_link_down(n, bearer_id, false); 844 } 845 mod_timer(&n->timer, jiffies + msecs_to_jiffies(n->keepalive_intv)); 846 } 847 848 /** 849 * __tipc_node_link_up - handle addition of link 850 * @n: target tipc_node 851 * @bearer_id: id of the bearer 852 * @xmitq: queue for messages to be xmited on 853 * Node lock must be held by caller 854 * Link becomes active (alone or shared) or standby, depending on its priority. 855 */ 856 static void __tipc_node_link_up(struct tipc_node *n, int bearer_id, 857 struct sk_buff_head *xmitq) 858 { 859 int *slot0 = &n->active_links[0]; 860 int *slot1 = &n->active_links[1]; 861 struct tipc_link *ol = node_active_link(n, 0); 862 struct tipc_link *nl = n->links[bearer_id].link; 863 864 if (!nl || tipc_link_is_up(nl)) 865 return; 866 867 tipc_link_fsm_evt(nl, LINK_ESTABLISH_EVT); 868 if (!tipc_link_is_up(nl)) 869 return; 870 871 n->working_links++; 872 n->action_flags |= TIPC_NOTIFY_LINK_UP; 873 n->link_id = tipc_link_id(nl); 874 875 /* Leave room for tunnel header when returning 'mtu' to users: */ 876 n->links[bearer_id].mtu = tipc_link_mss(nl); 877 878 tipc_bearer_add_dest(n->net, bearer_id, n->addr); 879 tipc_bcast_inc_bearer_dst_cnt(n->net, bearer_id); 880 881 pr_debug("Established link <%s> on network plane %c\n", 882 tipc_link_name(nl), tipc_link_plane(nl)); 883 trace_tipc_node_link_up(n, true, " "); 884 885 /* Ensure that a STATE message goes first */ 886 tipc_link_build_state_msg(nl, xmitq); 887 888 /* First link? => give it both slots */ 889 if (!ol) { 890 *slot0 = bearer_id; 891 *slot1 = bearer_id; 892 tipc_node_fsm_evt(n, SELF_ESTABL_CONTACT_EVT); 893 n->action_flags |= TIPC_NOTIFY_NODE_UP; 894 tipc_link_set_active(nl, true); 895 tipc_bcast_add_peer(n->net, nl, xmitq); 896 return; 897 } 898 899 /* Second link => redistribute slots */ 900 if (tipc_link_prio(nl) > tipc_link_prio(ol)) { 901 pr_debug("Old link <%s> becomes standby\n", tipc_link_name(ol)); 902 *slot0 = bearer_id; 903 *slot1 = bearer_id; 904 tipc_link_set_active(nl, true); 905 tipc_link_set_active(ol, false); 906 } else if (tipc_link_prio(nl) == tipc_link_prio(ol)) { 907 tipc_link_set_active(nl, true); 908 *slot1 = bearer_id; 909 } else { 910 pr_debug("New link <%s> is standby\n", tipc_link_name(nl)); 911 } 912 913 /* Prepare synchronization with first link */ 914 tipc_link_tnl_prepare(ol, nl, SYNCH_MSG, xmitq); 915 } 916 917 /** 918 * tipc_node_link_up - handle addition of link 919 * @n: target tipc_node 920 * @bearer_id: id of the bearer 921 * @xmitq: queue for messages to be xmited on 922 * 923 * Link becomes active (alone or shared) or standby, depending on its priority. 924 */ 925 static void tipc_node_link_up(struct tipc_node *n, int bearer_id, 926 struct sk_buff_head *xmitq) 927 { 928 struct tipc_media_addr *maddr; 929 930 tipc_node_write_lock(n); 931 __tipc_node_link_up(n, bearer_id, xmitq); 932 maddr = &n->links[bearer_id].maddr; 933 tipc_bearer_xmit(n->net, bearer_id, xmitq, maddr, n); 934 tipc_node_write_unlock(n); 935 } 936 937 /** 938 * tipc_node_link_failover() - start failover in case "half-failover" 939 * 940 * This function is only called in a very special situation where link 941 * failover can be already started on peer node but not on this node. 942 * This can happen when e.g.:: 943 * 944 * 1. Both links <1A-2A>, <1B-2B> down 945 * 2. Link endpoint 2A up, but 1A still down (e.g. due to network 946 * disturbance, wrong session, etc.) 947 * 3. Link <1B-2B> up 948 * 4. Link endpoint 2A down (e.g. due to link tolerance timeout) 949 * 5. Node 2 starts failover onto link <1B-2B> 950 * 951 * ==> Node 1 does never start link/node failover! 952 * 953 * @n: tipc node structure 954 * @l: link peer endpoint failingover (- can be NULL) 955 * @tnl: tunnel link 956 * @xmitq: queue for messages to be xmited on tnl link later 957 */ 958 static void tipc_node_link_failover(struct tipc_node *n, struct tipc_link *l, 959 struct tipc_link *tnl, 960 struct sk_buff_head *xmitq) 961 { 962 /* Avoid to be "self-failover" that can never end */ 963 if (!tipc_link_is_up(tnl)) 964 return; 965 966 /* Don't rush, failure link may be in the process of resetting */ 967 if (l && !tipc_link_is_reset(l)) 968 return; 969 970 tipc_link_fsm_evt(tnl, LINK_SYNCH_END_EVT); 971 tipc_node_fsm_evt(n, NODE_SYNCH_END_EVT); 972 973 n->sync_point = tipc_link_rcv_nxt(tnl) + (U16_MAX / 2 - 1); 974 tipc_link_failover_prepare(l, tnl, xmitq); 975 976 if (l) 977 tipc_link_fsm_evt(l, LINK_FAILOVER_BEGIN_EVT); 978 tipc_node_fsm_evt(n, NODE_FAILOVER_BEGIN_EVT); 979 } 980 981 /** 982 * __tipc_node_link_down - handle loss of link 983 * @n: target tipc_node 984 * @bearer_id: id of the bearer 985 * @xmitq: queue for messages to be xmited on 986 * @maddr: output media address of the bearer 987 */ 988 static void __tipc_node_link_down(struct tipc_node *n, int *bearer_id, 989 struct sk_buff_head *xmitq, 990 struct tipc_media_addr **maddr) 991 { 992 struct tipc_link_entry *le = &n->links[*bearer_id]; 993 int *slot0 = &n->active_links[0]; 994 int *slot1 = &n->active_links[1]; 995 int i, highest = 0, prio; 996 struct tipc_link *l, *_l, *tnl; 997 998 l = n->links[*bearer_id].link; 999 if (!l || tipc_link_is_reset(l)) 1000 return; 1001 1002 n->working_links--; 1003 n->action_flags |= TIPC_NOTIFY_LINK_DOWN; 1004 n->link_id = tipc_link_id(l); 1005 1006 tipc_bearer_remove_dest(n->net, *bearer_id, n->addr); 1007 1008 pr_debug("Lost link <%s> on network plane %c\n", 1009 tipc_link_name(l), tipc_link_plane(l)); 1010 1011 /* Select new active link if any available */ 1012 *slot0 = INVALID_BEARER_ID; 1013 *slot1 = INVALID_BEARER_ID; 1014 for (i = 0; i < MAX_BEARERS; i++) { 1015 _l = n->links[i].link; 1016 if (!_l || !tipc_link_is_up(_l)) 1017 continue; 1018 if (_l == l) 1019 continue; 1020 prio = tipc_link_prio(_l); 1021 if (prio < highest) 1022 continue; 1023 if (prio > highest) { 1024 highest = prio; 1025 *slot0 = i; 1026 *slot1 = i; 1027 continue; 1028 } 1029 *slot1 = i; 1030 } 1031 1032 if (!node_is_up(n)) { 1033 if (tipc_link_peer_is_down(l)) 1034 tipc_node_fsm_evt(n, PEER_LOST_CONTACT_EVT); 1035 tipc_node_fsm_evt(n, SELF_LOST_CONTACT_EVT); 1036 trace_tipc_link_reset(l, TIPC_DUMP_ALL, "link down!"); 1037 tipc_link_fsm_evt(l, LINK_RESET_EVT); 1038 tipc_link_reset(l); 1039 tipc_link_build_reset_msg(l, xmitq); 1040 *maddr = &n->links[*bearer_id].maddr; 1041 node_lost_contact(n, &le->inputq); 1042 tipc_bcast_dec_bearer_dst_cnt(n->net, *bearer_id); 1043 return; 1044 } 1045 tipc_bcast_dec_bearer_dst_cnt(n->net, *bearer_id); 1046 1047 /* There is still a working link => initiate failover */ 1048 *bearer_id = n->active_links[0]; 1049 tnl = n->links[*bearer_id].link; 1050 tipc_link_fsm_evt(tnl, LINK_SYNCH_END_EVT); 1051 tipc_node_fsm_evt(n, NODE_SYNCH_END_EVT); 1052 n->sync_point = tipc_link_rcv_nxt(tnl) + (U16_MAX / 2 - 1); 1053 tipc_link_tnl_prepare(l, tnl, FAILOVER_MSG, xmitq); 1054 trace_tipc_link_reset(l, TIPC_DUMP_ALL, "link down -> failover!"); 1055 tipc_link_reset(l); 1056 tipc_link_fsm_evt(l, LINK_RESET_EVT); 1057 tipc_link_fsm_evt(l, LINK_FAILOVER_BEGIN_EVT); 1058 tipc_node_fsm_evt(n, NODE_FAILOVER_BEGIN_EVT); 1059 *maddr = &n->links[*bearer_id].maddr; 1060 } 1061 1062 static void tipc_node_link_down(struct tipc_node *n, int bearer_id, bool delete) 1063 { 1064 struct tipc_media_addr *maddr = NULL; 1065 int old_bearer_id = bearer_id; 1066 struct tipc_link_entry *le; 1067 struct sk_buff_head xmitq; 1068 struct tipc_link *l; 1069 1070 __skb_queue_head_init(&xmitq); 1071 1072 /* Synchronize the link lookup with bearer teardown. */ 1073 tipc_node_write_lock(n); 1074 le = &n->links[bearer_id]; 1075 l = le->link; 1076 if (!l) { 1077 tipc_node_write_unlock_fast(n); 1078 return; 1079 } 1080 1081 if (!tipc_link_is_establishing(l)) { 1082 __tipc_node_link_down(n, &bearer_id, &xmitq, &maddr); 1083 } else { 1084 /* Defuse pending tipc_node_link_up() */ 1085 tipc_link_reset(l); 1086 tipc_link_fsm_evt(l, LINK_RESET_EVT); 1087 } 1088 if (delete) { 1089 kfree(l); 1090 le->link = NULL; 1091 n->link_cnt--; 1092 } 1093 trace_tipc_node_link_down(n, true, "node link down or deleted!"); 1094 tipc_node_write_unlock(n); 1095 if (delete) 1096 tipc_mon_remove_peer(n->net, n->addr, old_bearer_id); 1097 if (!skb_queue_empty(&xmitq)) 1098 tipc_bearer_xmit(n->net, bearer_id, &xmitq, maddr, n); 1099 tipc_sk_rcv(n->net, &le->inputq); 1100 } 1101 1102 static bool node_is_up(struct tipc_node *n) 1103 { 1104 return n->active_links[0] != INVALID_BEARER_ID; 1105 } 1106 1107 bool tipc_node_is_up(struct net *net, u32 addr) 1108 { 1109 struct tipc_node *n; 1110 bool retval = false; 1111 1112 if (in_own_node(net, addr)) 1113 return true; 1114 1115 n = tipc_node_find(net, addr); 1116 if (!n) 1117 return false; 1118 retval = node_is_up(n); 1119 tipc_node_put(n); 1120 return retval; 1121 } 1122 1123 static u32 tipc_node_suggest_addr(struct net *net, u32 addr) 1124 { 1125 struct tipc_node *n; 1126 1127 addr ^= tipc_net(net)->random; 1128 while ((n = tipc_node_find(net, addr))) { 1129 tipc_node_put(n); 1130 addr++; 1131 } 1132 return addr; 1133 } 1134 1135 /* tipc_node_try_addr(): Check if addr can be used by peer, suggest other if not 1136 * Returns suggested address if any, otherwise 0 1137 */ 1138 u32 tipc_node_try_addr(struct net *net, u8 *id, u32 addr) 1139 { 1140 struct tipc_net *tn = tipc_net(net); 1141 struct tipc_node *n; 1142 bool preliminary; 1143 u32 sugg_addr; 1144 1145 /* Suggest new address if some other peer is using this one */ 1146 n = tipc_node_find(net, addr); 1147 if (n) { 1148 if (!memcmp(n->peer_id, id, NODE_ID_LEN)) 1149 addr = 0; 1150 tipc_node_put(n); 1151 if (!addr) 1152 return 0; 1153 return tipc_node_suggest_addr(net, addr); 1154 } 1155 1156 /* Suggest previously used address if peer is known */ 1157 n = tipc_node_find_by_id(net, id); 1158 if (n) { 1159 sugg_addr = n->addr; 1160 preliminary = n->preliminary; 1161 tipc_node_put(n); 1162 if (!preliminary) 1163 return sugg_addr; 1164 } 1165 1166 /* Even this node may be in conflict */ 1167 if (tn->trial_addr == addr) 1168 return tipc_node_suggest_addr(net, addr); 1169 1170 return 0; 1171 } 1172 1173 void tipc_node_check_dest(struct net *net, u32 addr, 1174 u8 *peer_id, struct tipc_bearer *b, 1175 u16 capabilities, u32 signature, u32 hash_mixes, 1176 struct tipc_media_addr *maddr, 1177 bool *respond, bool *dupl_addr) 1178 { 1179 struct tipc_node *n; 1180 struct tipc_link *l; 1181 struct tipc_link_entry *le; 1182 bool addr_match = false; 1183 bool sign_match = false; 1184 bool link_up = false; 1185 bool link_is_reset = false; 1186 bool accept_addr = false; 1187 bool reset = false; 1188 char *if_name; 1189 unsigned long intv; 1190 u16 session; 1191 1192 *dupl_addr = false; 1193 *respond = false; 1194 1195 n = tipc_node_create(net, addr, peer_id, capabilities, hash_mixes, 1196 false); 1197 if (!n) 1198 return; 1199 1200 tipc_node_write_lock(n); 1201 1202 le = &n->links[b->identity]; 1203 1204 /* Prepare to validate requesting node's signature and media address */ 1205 l = le->link; 1206 link_up = l && tipc_link_is_up(l); 1207 link_is_reset = l && tipc_link_is_reset(l); 1208 addr_match = l && !memcmp(&le->maddr, maddr, sizeof(*maddr)); 1209 sign_match = (signature == n->signature); 1210 1211 /* These three flags give us eight permutations: */ 1212 1213 if (sign_match && addr_match && link_up) { 1214 /* All is fine. Ignore requests. */ 1215 /* Peer node is not a container/local namespace */ 1216 if (!n->peer_hash_mix) 1217 n->peer_hash_mix = hash_mixes; 1218 } else if (sign_match && addr_match && !link_up) { 1219 /* Respond. The link will come up in due time */ 1220 *respond = true; 1221 } else if (sign_match && !addr_match && link_up) { 1222 /* Peer has changed i/f address without rebooting. 1223 * If so, the link will reset soon, and the next 1224 * discovery will be accepted. So we can ignore it. 1225 * It may also be a cloned or malicious peer having 1226 * chosen the same node address and signature as an 1227 * existing one. 1228 * Ignore requests until the link goes down, if ever. 1229 */ 1230 *dupl_addr = true; 1231 } else if (sign_match && !addr_match && !link_up) { 1232 /* Peer link has changed i/f address without rebooting. 1233 * It may also be a cloned or malicious peer; we can't 1234 * distinguish between the two. 1235 * The signature is correct, so we must accept. 1236 */ 1237 accept_addr = true; 1238 *respond = true; 1239 reset = true; 1240 } else if (!sign_match && addr_match && link_up) { 1241 /* Peer node rebooted. Two possibilities: 1242 * - Delayed re-discovery; this link endpoint has already 1243 * reset and re-established contact with the peer, before 1244 * receiving a discovery message from that node. 1245 * (The peer happened to receive one from this node first). 1246 * - The peer came back so fast that our side has not 1247 * discovered it yet. Probing from this side will soon 1248 * reset the link, since there can be no working link 1249 * endpoint at the peer end, and the link will re-establish. 1250 * Accept the signature, since it comes from a known peer. 1251 */ 1252 n->signature = signature; 1253 } else if (!sign_match && addr_match && !link_up) { 1254 /* The peer node has rebooted. 1255 * Accept signature, since it is a known peer. 1256 */ 1257 n->signature = signature; 1258 *respond = true; 1259 } else if (!sign_match && !addr_match && link_up) { 1260 /* Peer rebooted with new address, or a new/duplicate peer. 1261 * Ignore until the link goes down, if ever. 1262 */ 1263 *dupl_addr = true; 1264 } else if (!sign_match && !addr_match && !link_up) { 1265 /* Peer rebooted with new address, or it is a new peer. 1266 * Accept signature and address. 1267 */ 1268 n->signature = signature; 1269 accept_addr = true; 1270 *respond = true; 1271 reset = true; 1272 } 1273 1274 if (!accept_addr) 1275 goto exit; 1276 1277 /* Now create new link if not already existing */ 1278 if (!l) { 1279 if (n->link_cnt == 2) 1280 goto exit; 1281 1282 if_name = strchr(b->name, ':') + 1; 1283 session = get_random_u16(); 1284 if (!tipc_link_create(net, if_name, b->identity, b->tolerance, 1285 b->net_plane, b->mtu, b->priority, 1286 b->min_win, b->max_win, session, 1287 tipc_own_addr(net), addr, peer_id, 1288 n->capabilities, 1289 tipc_bc_sndlink(n->net), n->bc_entry.link, 1290 &le->inputq, 1291 &n->bc_entry.namedq, &l)) { 1292 *respond = false; 1293 goto exit; 1294 } 1295 trace_tipc_link_reset(l, TIPC_DUMP_ALL, "link created!"); 1296 tipc_link_reset(l); 1297 tipc_link_fsm_evt(l, LINK_RESET_EVT); 1298 if (n->state == NODE_FAILINGOVER) 1299 tipc_link_fsm_evt(l, LINK_FAILOVER_BEGIN_EVT); 1300 link_is_reset = tipc_link_is_reset(l); 1301 le->link = l; 1302 n->link_cnt++; 1303 tipc_node_calculate_timer(n, l); 1304 if (n->link_cnt == 1) { 1305 intv = jiffies + msecs_to_jiffies(n->keepalive_intv); 1306 if (!mod_timer(&n->timer, intv)) 1307 tipc_node_get(n); 1308 } 1309 } 1310 memcpy(&le->maddr, maddr, sizeof(*maddr)); 1311 exit: 1312 tipc_node_write_unlock(n); 1313 if (reset && !link_is_reset) 1314 tipc_node_link_down(n, b->identity, false); 1315 tipc_node_put(n); 1316 } 1317 1318 void tipc_node_delete_links(struct net *net, int bearer_id) 1319 { 1320 struct tipc_net *tn = net_generic(net, tipc_net_id); 1321 struct tipc_node *n; 1322 1323 rcu_read_lock(); 1324 list_for_each_entry_rcu(n, &tn->node_list, list) { 1325 tipc_node_link_down(n, bearer_id, true); 1326 } 1327 rcu_read_unlock(); 1328 } 1329 1330 static void tipc_node_reset_links(struct tipc_node *n) 1331 { 1332 int i; 1333 1334 pr_warn("Resetting all links to %x\n", n->addr); 1335 1336 tipc_node_write_lock(n); 1337 trace_tipc_node_reset_links(n, true, " "); 1338 tipc_node_write_unlock_fast(n); 1339 for (i = 0; i < MAX_BEARERS; i++) { 1340 tipc_node_link_down(n, i, false); 1341 } 1342 } 1343 1344 /* tipc_node_fsm_evt - node finite state machine 1345 * Determines when contact is allowed with peer node 1346 */ 1347 static void tipc_node_fsm_evt(struct tipc_node *n, int evt) 1348 { 1349 int state = n->state; 1350 1351 switch (state) { 1352 case SELF_DOWN_PEER_DOWN: 1353 switch (evt) { 1354 case SELF_ESTABL_CONTACT_EVT: 1355 state = SELF_UP_PEER_COMING; 1356 break; 1357 case PEER_ESTABL_CONTACT_EVT: 1358 state = SELF_COMING_PEER_UP; 1359 break; 1360 case SELF_LOST_CONTACT_EVT: 1361 case PEER_LOST_CONTACT_EVT: 1362 break; 1363 case NODE_SYNCH_END_EVT: 1364 case NODE_SYNCH_BEGIN_EVT: 1365 case NODE_FAILOVER_BEGIN_EVT: 1366 case NODE_FAILOVER_END_EVT: 1367 default: 1368 goto illegal_evt; 1369 } 1370 break; 1371 case SELF_UP_PEER_UP: 1372 switch (evt) { 1373 case SELF_LOST_CONTACT_EVT: 1374 state = SELF_DOWN_PEER_LEAVING; 1375 break; 1376 case PEER_LOST_CONTACT_EVT: 1377 state = SELF_LEAVING_PEER_DOWN; 1378 break; 1379 case NODE_SYNCH_BEGIN_EVT: 1380 state = NODE_SYNCHING; 1381 break; 1382 case NODE_FAILOVER_BEGIN_EVT: 1383 state = NODE_FAILINGOVER; 1384 break; 1385 case SELF_ESTABL_CONTACT_EVT: 1386 case PEER_ESTABL_CONTACT_EVT: 1387 case NODE_SYNCH_END_EVT: 1388 case NODE_FAILOVER_END_EVT: 1389 break; 1390 default: 1391 goto illegal_evt; 1392 } 1393 break; 1394 case SELF_DOWN_PEER_LEAVING: 1395 switch (evt) { 1396 case PEER_LOST_CONTACT_EVT: 1397 state = SELF_DOWN_PEER_DOWN; 1398 break; 1399 case SELF_ESTABL_CONTACT_EVT: 1400 case PEER_ESTABL_CONTACT_EVT: 1401 case SELF_LOST_CONTACT_EVT: 1402 break; 1403 case NODE_SYNCH_END_EVT: 1404 case NODE_SYNCH_BEGIN_EVT: 1405 case NODE_FAILOVER_BEGIN_EVT: 1406 case NODE_FAILOVER_END_EVT: 1407 default: 1408 goto illegal_evt; 1409 } 1410 break; 1411 case SELF_UP_PEER_COMING: 1412 switch (evt) { 1413 case PEER_ESTABL_CONTACT_EVT: 1414 state = SELF_UP_PEER_UP; 1415 break; 1416 case SELF_LOST_CONTACT_EVT: 1417 state = SELF_DOWN_PEER_DOWN; 1418 break; 1419 case SELF_ESTABL_CONTACT_EVT: 1420 case PEER_LOST_CONTACT_EVT: 1421 case NODE_SYNCH_END_EVT: 1422 case NODE_FAILOVER_BEGIN_EVT: 1423 break; 1424 case NODE_SYNCH_BEGIN_EVT: 1425 case NODE_FAILOVER_END_EVT: 1426 default: 1427 goto illegal_evt; 1428 } 1429 break; 1430 case SELF_COMING_PEER_UP: 1431 switch (evt) { 1432 case SELF_ESTABL_CONTACT_EVT: 1433 state = SELF_UP_PEER_UP; 1434 break; 1435 case PEER_LOST_CONTACT_EVT: 1436 state = SELF_DOWN_PEER_DOWN; 1437 break; 1438 case SELF_LOST_CONTACT_EVT: 1439 case PEER_ESTABL_CONTACT_EVT: 1440 break; 1441 case NODE_SYNCH_END_EVT: 1442 case NODE_SYNCH_BEGIN_EVT: 1443 case NODE_FAILOVER_BEGIN_EVT: 1444 case NODE_FAILOVER_END_EVT: 1445 default: 1446 goto illegal_evt; 1447 } 1448 break; 1449 case SELF_LEAVING_PEER_DOWN: 1450 switch (evt) { 1451 case SELF_LOST_CONTACT_EVT: 1452 state = SELF_DOWN_PEER_DOWN; 1453 break; 1454 case SELF_ESTABL_CONTACT_EVT: 1455 case PEER_ESTABL_CONTACT_EVT: 1456 case PEER_LOST_CONTACT_EVT: 1457 break; 1458 case NODE_SYNCH_END_EVT: 1459 case NODE_SYNCH_BEGIN_EVT: 1460 case NODE_FAILOVER_BEGIN_EVT: 1461 case NODE_FAILOVER_END_EVT: 1462 default: 1463 goto illegal_evt; 1464 } 1465 break; 1466 case NODE_FAILINGOVER: 1467 switch (evt) { 1468 case SELF_LOST_CONTACT_EVT: 1469 state = SELF_DOWN_PEER_LEAVING; 1470 break; 1471 case PEER_LOST_CONTACT_EVT: 1472 state = SELF_LEAVING_PEER_DOWN; 1473 break; 1474 case NODE_FAILOVER_END_EVT: 1475 state = SELF_UP_PEER_UP; 1476 break; 1477 case NODE_FAILOVER_BEGIN_EVT: 1478 case SELF_ESTABL_CONTACT_EVT: 1479 case PEER_ESTABL_CONTACT_EVT: 1480 break; 1481 case NODE_SYNCH_BEGIN_EVT: 1482 case NODE_SYNCH_END_EVT: 1483 default: 1484 goto illegal_evt; 1485 } 1486 break; 1487 case NODE_SYNCHING: 1488 switch (evt) { 1489 case SELF_LOST_CONTACT_EVT: 1490 state = SELF_DOWN_PEER_LEAVING; 1491 break; 1492 case PEER_LOST_CONTACT_EVT: 1493 state = SELF_LEAVING_PEER_DOWN; 1494 break; 1495 case NODE_SYNCH_END_EVT: 1496 state = SELF_UP_PEER_UP; 1497 break; 1498 case NODE_FAILOVER_BEGIN_EVT: 1499 state = NODE_FAILINGOVER; 1500 break; 1501 case NODE_SYNCH_BEGIN_EVT: 1502 case SELF_ESTABL_CONTACT_EVT: 1503 case PEER_ESTABL_CONTACT_EVT: 1504 break; 1505 case NODE_FAILOVER_END_EVT: 1506 default: 1507 goto illegal_evt; 1508 } 1509 break; 1510 default: 1511 pr_err("Unknown node fsm state %x\n", state); 1512 break; 1513 } 1514 trace_tipc_node_fsm(n->peer_id, n->state, state, evt); 1515 n->state = state; 1516 return; 1517 1518 illegal_evt: 1519 pr_err("Illegal node fsm evt %x in state %x\n", evt, state); 1520 trace_tipc_node_fsm(n->peer_id, n->state, state, evt); 1521 } 1522 1523 static void node_lost_contact(struct tipc_node *n, 1524 struct sk_buff_head *inputq) 1525 { 1526 struct tipc_sock_conn *conn, *safe; 1527 struct tipc_link *l; 1528 struct list_head *conns = &n->conn_sks; 1529 struct sk_buff *skb; 1530 uint i; 1531 1532 pr_debug("Lost contact with %x\n", n->addr); 1533 n->delete_at = jiffies + msecs_to_jiffies(NODE_CLEANUP_AFTER); 1534 trace_tipc_node_lost_contact(n, true, " "); 1535 1536 /* Clean up broadcast state */ 1537 tipc_bcast_remove_peer(n->net, n->bc_entry.link); 1538 skb_queue_purge(&n->bc_entry.namedq); 1539 1540 /* Abort any ongoing link failover */ 1541 for (i = 0; i < MAX_BEARERS; i++) { 1542 l = n->links[i].link; 1543 if (l) 1544 tipc_link_fsm_evt(l, LINK_FAILOVER_END_EVT); 1545 } 1546 1547 /* Notify publications from this node */ 1548 n->action_flags |= TIPC_NOTIFY_NODE_DOWN; 1549 n->peer_net = NULL; 1550 n->peer_hash_mix = 0; 1551 /* Notify sockets connected to node */ 1552 list_for_each_entry_safe(conn, safe, conns, list) { 1553 skb = tipc_msg_create(TIPC_CRITICAL_IMPORTANCE, TIPC_CONN_MSG, 1554 SHORT_H_SIZE, 0, tipc_own_addr(n->net), 1555 conn->peer_node, conn->port, 1556 conn->peer_port, TIPC_ERR_NO_NODE); 1557 if (likely(skb)) 1558 skb_queue_tail(inputq, skb); 1559 list_del(&conn->list); 1560 kfree(conn); 1561 } 1562 } 1563 1564 /** 1565 * tipc_node_get_linkname - get the name of a link 1566 * 1567 * @net: the applicable net namespace 1568 * @bearer_id: id of the bearer 1569 * @addr: peer node address 1570 * @linkname: link name output buffer 1571 * @len: size of @linkname output buffer 1572 * 1573 * Return: 0 on success 1574 */ 1575 int tipc_node_get_linkname(struct net *net, u32 bearer_id, u32 addr, 1576 char *linkname, size_t len) 1577 { 1578 struct tipc_link *link; 1579 int err = -EINVAL; 1580 struct tipc_node *node = tipc_node_find(net, addr); 1581 1582 if (!node) 1583 return err; 1584 1585 if (bearer_id >= MAX_BEARERS) 1586 goto exit; 1587 1588 tipc_node_read_lock(node); 1589 link = node->links[bearer_id].link; 1590 if (link) { 1591 strscpy(linkname, tipc_link_name(link), len); 1592 err = 0; 1593 } 1594 tipc_node_read_unlock(node); 1595 exit: 1596 tipc_node_put(node); 1597 return err; 1598 } 1599 1600 /* Caller should hold node lock for the passed node */ 1601 static int __tipc_nl_add_node(struct tipc_nl_msg *msg, struct tipc_node *node) 1602 { 1603 void *hdr; 1604 struct nlattr *attrs; 1605 1606 hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family, 1607 NLM_F_MULTI, TIPC_NL_NODE_GET); 1608 if (!hdr) 1609 return -EMSGSIZE; 1610 1611 attrs = nla_nest_start_noflag(msg->skb, TIPC_NLA_NODE); 1612 if (!attrs) 1613 goto msg_full; 1614 1615 if (nla_put_u32(msg->skb, TIPC_NLA_NODE_ADDR, node->addr)) 1616 goto attr_msg_full; 1617 if (node_is_up(node)) 1618 if (nla_put_flag(msg->skb, TIPC_NLA_NODE_UP)) 1619 goto attr_msg_full; 1620 1621 nla_nest_end(msg->skb, attrs); 1622 genlmsg_end(msg->skb, hdr); 1623 1624 return 0; 1625 1626 attr_msg_full: 1627 nla_nest_cancel(msg->skb, attrs); 1628 msg_full: 1629 genlmsg_cancel(msg->skb, hdr); 1630 1631 return -EMSGSIZE; 1632 } 1633 1634 static void tipc_lxc_xmit(struct net *peer_net, struct sk_buff_head *list) 1635 { 1636 struct tipc_msg *hdr = buf_msg(skb_peek(list)); 1637 struct sk_buff_head inputq; 1638 1639 switch (msg_user(hdr)) { 1640 case TIPC_LOW_IMPORTANCE: 1641 case TIPC_MEDIUM_IMPORTANCE: 1642 case TIPC_HIGH_IMPORTANCE: 1643 case TIPC_CRITICAL_IMPORTANCE: 1644 if (msg_connected(hdr) || msg_named(hdr) || 1645 msg_direct(hdr)) { 1646 tipc_loopback_trace(peer_net, list); 1647 spin_lock_init(&list->lock); 1648 tipc_sk_rcv(peer_net, list); 1649 return; 1650 } 1651 if (msg_mcast(hdr)) { 1652 tipc_loopback_trace(peer_net, list); 1653 skb_queue_head_init(&inputq); 1654 tipc_sk_mcast_rcv(peer_net, list, &inputq); 1655 __skb_queue_purge(list); 1656 skb_queue_purge(&inputq); 1657 return; 1658 } 1659 return; 1660 case MSG_FRAGMENTER: 1661 if (tipc_msg_assemble(list)) { 1662 tipc_loopback_trace(peer_net, list); 1663 skb_queue_head_init(&inputq); 1664 tipc_sk_mcast_rcv(peer_net, list, &inputq); 1665 __skb_queue_purge(list); 1666 skb_queue_purge(&inputq); 1667 } 1668 return; 1669 case GROUP_PROTOCOL: 1670 case CONN_MANAGER: 1671 tipc_loopback_trace(peer_net, list); 1672 spin_lock_init(&list->lock); 1673 tipc_sk_rcv(peer_net, list); 1674 return; 1675 case LINK_PROTOCOL: 1676 case NAME_DISTRIBUTOR: 1677 case TUNNEL_PROTOCOL: 1678 case BCAST_PROTOCOL: 1679 return; 1680 default: 1681 return; 1682 } 1683 } 1684 1685 /** 1686 * tipc_node_xmit() - general link level function for message sending 1687 * @net: the applicable net namespace 1688 * @list: chain of buffers containing message 1689 * @dnode: address of destination node 1690 * @selector: a number used for deterministic link selection 1691 * Consumes the buffer chain. 1692 * Return: 0 if success, otherwise: -ELINKCONG,-EHOSTUNREACH,-EMSGSIZE,-ENOBUF 1693 */ 1694 int tipc_node_xmit(struct net *net, struct sk_buff_head *list, 1695 u32 dnode, int selector) 1696 { 1697 struct tipc_link_entry *le = NULL; 1698 struct tipc_node *n; 1699 struct sk_buff_head xmitq; 1700 bool node_up = false; 1701 struct net *peer_net; 1702 int bearer_id; 1703 int rc; 1704 1705 if (in_own_node(net, dnode)) { 1706 tipc_loopback_trace(net, list); 1707 spin_lock_init(&list->lock); 1708 tipc_sk_rcv(net, list); 1709 return 0; 1710 } 1711 1712 n = tipc_node_find(net, dnode); 1713 if (unlikely(!n)) { 1714 __skb_queue_purge(list); 1715 return -EHOSTUNREACH; 1716 } 1717 1718 rcu_read_lock(); 1719 tipc_node_read_lock(n); 1720 node_up = node_is_up(n); 1721 peer_net = n->peer_net; 1722 tipc_node_read_unlock(n); 1723 if (node_up && peer_net && check_net(peer_net)) { 1724 /* xmit inner linux container */ 1725 tipc_lxc_xmit(peer_net, list); 1726 if (likely(skb_queue_empty(list))) { 1727 rcu_read_unlock(); 1728 tipc_node_put(n); 1729 return 0; 1730 } 1731 } 1732 rcu_read_unlock(); 1733 1734 tipc_node_read_lock(n); 1735 bearer_id = n->active_links[selector & 1]; 1736 if (unlikely(bearer_id == INVALID_BEARER_ID)) { 1737 tipc_node_read_unlock(n); 1738 tipc_node_put(n); 1739 __skb_queue_purge(list); 1740 return -EHOSTUNREACH; 1741 } 1742 1743 __skb_queue_head_init(&xmitq); 1744 le = &n->links[bearer_id]; 1745 spin_lock_bh(&le->lock); 1746 rc = tipc_link_xmit(le->link, list, &xmitq); 1747 spin_unlock_bh(&le->lock); 1748 tipc_node_read_unlock(n); 1749 1750 if (unlikely(rc == -ENOBUFS)) 1751 tipc_node_link_down(n, bearer_id, false); 1752 else 1753 tipc_bearer_xmit(net, bearer_id, &xmitq, &le->maddr, n); 1754 1755 tipc_node_put(n); 1756 1757 return rc; 1758 } 1759 1760 /* tipc_node_xmit_skb(): send single buffer to destination 1761 * Buffers sent via this function are generally TIPC_SYSTEM_IMPORTANCE 1762 * messages, which will not be rejected 1763 * The only exception is datagram messages rerouted after secondary 1764 * lookup, which are rare and safe to dispose of anyway. 1765 */ 1766 int tipc_node_xmit_skb(struct net *net, struct sk_buff *skb, u32 dnode, 1767 u32 selector) 1768 { 1769 struct sk_buff_head head; 1770 1771 __skb_queue_head_init(&head); 1772 __skb_queue_tail(&head, skb); 1773 tipc_node_xmit(net, &head, dnode, selector); 1774 return 0; 1775 } 1776 1777 /* tipc_node_distr_xmit(): send single buffer msgs to individual destinations 1778 * Note: this is only for SYSTEM_IMPORTANCE messages, which cannot be rejected 1779 */ 1780 int tipc_node_distr_xmit(struct net *net, struct sk_buff_head *xmitq) 1781 { 1782 struct sk_buff *skb; 1783 u32 selector, dnode; 1784 1785 while ((skb = __skb_dequeue(xmitq))) { 1786 selector = msg_origport(buf_msg(skb)); 1787 dnode = msg_destnode(buf_msg(skb)); 1788 tipc_node_xmit_skb(net, skb, dnode, selector); 1789 } 1790 return 0; 1791 } 1792 1793 void tipc_node_broadcast(struct net *net, struct sk_buff *skb, int rc_dests) 1794 { 1795 struct sk_buff_head xmitq; 1796 struct sk_buff *txskb; 1797 struct tipc_node *n; 1798 u16 dummy; 1799 u32 dst; 1800 1801 /* Use broadcast if all nodes support it */ 1802 if (!rc_dests && tipc_bcast_get_mode(net) != BCLINK_MODE_RCAST) { 1803 __skb_queue_head_init(&xmitq); 1804 __skb_queue_tail(&xmitq, skb); 1805 tipc_bcast_xmit(net, &xmitq, &dummy); 1806 return; 1807 } 1808 1809 /* Otherwise use legacy replicast method */ 1810 rcu_read_lock(); 1811 list_for_each_entry_rcu(n, tipc_nodes(net), list) { 1812 dst = n->addr; 1813 if (in_own_node(net, dst)) 1814 continue; 1815 if (!node_is_up(n)) 1816 continue; 1817 txskb = pskb_copy(skb, GFP_ATOMIC); 1818 if (!txskb) 1819 break; 1820 msg_set_destnode(buf_msg(txskb), dst); 1821 tipc_node_xmit_skb(net, txskb, dst, 0); 1822 } 1823 rcu_read_unlock(); 1824 kfree_skb(skb); 1825 } 1826 1827 static void tipc_node_mcast_rcv(struct tipc_node *n) 1828 { 1829 struct tipc_bclink_entry *be = &n->bc_entry; 1830 1831 /* 'arrvq' is under inputq2's lock protection */ 1832 spin_lock_bh(&be->inputq2.lock); 1833 spin_lock_bh(&be->inputq1.lock); 1834 skb_queue_splice_tail_init(&be->inputq1, &be->arrvq); 1835 spin_unlock_bh(&be->inputq1.lock); 1836 spin_unlock_bh(&be->inputq2.lock); 1837 tipc_sk_mcast_rcv(n->net, &be->arrvq, &be->inputq2); 1838 } 1839 1840 static void tipc_node_bc_sync_rcv(struct tipc_node *n, struct tipc_msg *hdr, 1841 int bearer_id, struct sk_buff_head *xmitq, 1842 bool *valid) 1843 { 1844 struct tipc_link *ucl; 1845 int rc; 1846 1847 rc = tipc_bcast_sync_rcv(n->net, n->bc_entry.link, hdr, xmitq, valid); 1848 if (!*valid) 1849 return; 1850 1851 if (rc & TIPC_LINK_DOWN_EVT) { 1852 tipc_node_reset_links(n); 1853 return; 1854 } 1855 1856 if (!(rc & TIPC_LINK_SND_STATE)) 1857 return; 1858 1859 /* If probe message, a STATE response will be sent anyway */ 1860 if (msg_probe(hdr)) 1861 return; 1862 1863 /* Produce a STATE message carrying broadcast NACK */ 1864 tipc_node_read_lock(n); 1865 ucl = n->links[bearer_id].link; 1866 if (ucl) 1867 tipc_link_build_state_msg(ucl, xmitq); 1868 tipc_node_read_unlock(n); 1869 } 1870 1871 /** 1872 * tipc_node_bc_rcv - process TIPC broadcast packet arriving from off-node 1873 * @net: the applicable net namespace 1874 * @skb: TIPC packet 1875 * @bearer_id: id of bearer message arrived on 1876 * 1877 * Invoked with no locks held. 1878 */ 1879 static void tipc_node_bc_rcv(struct net *net, struct sk_buff *skb, int bearer_id) 1880 { 1881 int rc; 1882 struct sk_buff_head xmitq; 1883 struct tipc_bclink_entry *be; 1884 struct tipc_link_entry *le; 1885 struct tipc_msg *hdr = buf_msg(skb); 1886 int usr = msg_user(hdr); 1887 u32 dnode = msg_destnode(hdr); 1888 struct tipc_node *n; 1889 1890 __skb_queue_head_init(&xmitq); 1891 1892 /* If NACK for other node, let rcv link for that node peek into it */ 1893 if ((usr == BCAST_PROTOCOL) && (dnode != tipc_own_addr(net))) 1894 n = tipc_node_find(net, dnode); 1895 else 1896 n = tipc_node_find(net, msg_prevnode(hdr)); 1897 if (!n) { 1898 kfree_skb(skb); 1899 return; 1900 } 1901 be = &n->bc_entry; 1902 le = &n->links[bearer_id]; 1903 1904 rc = tipc_bcast_rcv(net, be->link, skb); 1905 1906 /* Broadcast ACKs are sent on a unicast link */ 1907 if (rc & TIPC_LINK_SND_STATE) { 1908 tipc_node_read_lock(n); 1909 tipc_link_build_state_msg(le->link, &xmitq); 1910 tipc_node_read_unlock(n); 1911 } 1912 1913 if (!skb_queue_empty(&xmitq)) 1914 tipc_bearer_xmit(net, bearer_id, &xmitq, &le->maddr, n); 1915 1916 if (!skb_queue_empty(&be->inputq1)) 1917 tipc_node_mcast_rcv(n); 1918 1919 /* Handle NAME_DISTRIBUTOR messages sent from 1.7 nodes */ 1920 if (!skb_queue_empty(&n->bc_entry.namedq)) 1921 tipc_named_rcv(net, &n->bc_entry.namedq, 1922 &n->bc_entry.named_rcv_nxt, 1923 &n->bc_entry.named_open); 1924 1925 /* If reassembly or retransmission failure => reset all links to peer */ 1926 if (rc & TIPC_LINK_DOWN_EVT) 1927 tipc_node_reset_links(n); 1928 1929 tipc_node_put(n); 1930 } 1931 1932 /** 1933 * tipc_node_check_state - check and if necessary update node state 1934 * @n: target tipc_node 1935 * @skb: TIPC packet 1936 * @bearer_id: identity of bearer delivering the packet 1937 * @xmitq: queue for messages to be xmited on 1938 * Return: true if state and msg are ok, otherwise false 1939 */ 1940 static bool tipc_node_check_state(struct tipc_node *n, struct sk_buff *skb, 1941 int bearer_id, struct sk_buff_head *xmitq) 1942 { 1943 struct tipc_msg *hdr = buf_msg(skb); 1944 int usr = msg_user(hdr); 1945 int mtyp = msg_type(hdr); 1946 u16 oseqno = msg_seqno(hdr); 1947 u16 exp_pkts = msg_msgcnt(hdr); 1948 u16 rcv_nxt, syncpt, dlv_nxt, inputq_len; 1949 int state = n->state; 1950 struct tipc_link *l, *tnl, *pl = NULL; 1951 struct tipc_media_addr *maddr; 1952 int pb_id; 1953 1954 if (trace_tipc_node_check_state_enabled()) { 1955 trace_tipc_skb_dump(skb, false, "skb for node state check"); 1956 trace_tipc_node_check_state(n, true, " "); 1957 } 1958 l = n->links[bearer_id].link; 1959 if (!l) 1960 return false; 1961 rcv_nxt = tipc_link_rcv_nxt(l); 1962 1963 1964 if (likely((state == SELF_UP_PEER_UP) && (usr != TUNNEL_PROTOCOL))) 1965 return true; 1966 1967 /* Find parallel link, if any */ 1968 for (pb_id = 0; pb_id < MAX_BEARERS; pb_id++) { 1969 if ((pb_id != bearer_id) && n->links[pb_id].link) { 1970 pl = n->links[pb_id].link; 1971 break; 1972 } 1973 } 1974 1975 if (!tipc_link_validate_msg(l, hdr)) { 1976 trace_tipc_skb_dump(skb, false, "PROTO invalid (2)!"); 1977 trace_tipc_link_dump(l, TIPC_DUMP_NONE, "PROTO invalid (2)!"); 1978 return false; 1979 } 1980 1981 /* Check and update node accesibility if applicable */ 1982 if (state == SELF_UP_PEER_COMING) { 1983 if (!tipc_link_is_up(l)) 1984 return true; 1985 if (!msg_peer_link_is_up(hdr)) 1986 return true; 1987 tipc_node_fsm_evt(n, PEER_ESTABL_CONTACT_EVT); 1988 } 1989 1990 if (state == SELF_DOWN_PEER_LEAVING) { 1991 if (msg_peer_node_is_up(hdr)) 1992 return false; 1993 tipc_node_fsm_evt(n, PEER_LOST_CONTACT_EVT); 1994 return true; 1995 } 1996 1997 if (state == SELF_LEAVING_PEER_DOWN) 1998 return false; 1999 2000 /* Ignore duplicate packets */ 2001 if ((usr != LINK_PROTOCOL) && less(oseqno, rcv_nxt)) 2002 return true; 2003 2004 /* Initiate or update failover mode if applicable */ 2005 if ((usr == TUNNEL_PROTOCOL) && (mtyp == FAILOVER_MSG)) { 2006 syncpt = oseqno + exp_pkts - 1; 2007 if (pl && !tipc_link_is_reset(pl)) { 2008 __tipc_node_link_down(n, &pb_id, xmitq, &maddr); 2009 trace_tipc_node_link_down(n, true, 2010 "node link down <- failover!"); 2011 tipc_skb_queue_splice_tail_init(tipc_link_inputq(pl), 2012 tipc_link_inputq(l)); 2013 } 2014 2015 /* If parallel link was already down, and this happened before 2016 * the tunnel link came up, node failover was never started. 2017 * Ensure that a FAILOVER_MSG is sent to get peer out of 2018 * NODE_FAILINGOVER state, also this node must accept 2019 * TUNNEL_MSGs from peer. 2020 */ 2021 if (n->state != NODE_FAILINGOVER) 2022 tipc_node_link_failover(n, pl, l, xmitq); 2023 2024 /* If pkts arrive out of order, use lowest calculated syncpt */ 2025 if (less(syncpt, n->sync_point)) 2026 n->sync_point = syncpt; 2027 } 2028 2029 /* Open parallel link when tunnel link reaches synch point */ 2030 if ((n->state == NODE_FAILINGOVER) && tipc_link_is_up(l)) { 2031 if (!more(rcv_nxt, n->sync_point)) 2032 return true; 2033 tipc_node_fsm_evt(n, NODE_FAILOVER_END_EVT); 2034 if (pl) 2035 tipc_link_fsm_evt(pl, LINK_FAILOVER_END_EVT); 2036 return true; 2037 } 2038 2039 /* No syncing needed if only one link */ 2040 if (!pl || !tipc_link_is_up(pl)) 2041 return true; 2042 2043 /* Initiate synch mode if applicable */ 2044 if ((usr == TUNNEL_PROTOCOL) && (mtyp == SYNCH_MSG) && (oseqno == 1)) { 2045 if (n->capabilities & TIPC_TUNNEL_ENHANCED) 2046 syncpt = msg_syncpt(hdr); 2047 else 2048 syncpt = msg_seqno(msg_inner_hdr(hdr)) + exp_pkts - 1; 2049 if (!tipc_link_is_up(l)) 2050 __tipc_node_link_up(n, bearer_id, xmitq); 2051 if (n->state == SELF_UP_PEER_UP) { 2052 n->sync_point = syncpt; 2053 tipc_link_fsm_evt(l, LINK_SYNCH_BEGIN_EVT); 2054 tipc_node_fsm_evt(n, NODE_SYNCH_BEGIN_EVT); 2055 } 2056 } 2057 2058 /* Open tunnel link when parallel link reaches synch point */ 2059 if (n->state == NODE_SYNCHING) { 2060 if (tipc_link_is_synching(l)) { 2061 tnl = l; 2062 } else { 2063 tnl = pl; 2064 pl = l; 2065 } 2066 inputq_len = skb_queue_len(tipc_link_inputq(pl)); 2067 dlv_nxt = tipc_link_rcv_nxt(pl) - inputq_len; 2068 if (more(dlv_nxt, n->sync_point)) { 2069 tipc_link_fsm_evt(tnl, LINK_SYNCH_END_EVT); 2070 tipc_node_fsm_evt(n, NODE_SYNCH_END_EVT); 2071 return true; 2072 } 2073 if (l == pl) 2074 return true; 2075 if ((usr == TUNNEL_PROTOCOL) && (mtyp == SYNCH_MSG)) 2076 return true; 2077 if (usr == LINK_PROTOCOL) 2078 return true; 2079 return false; 2080 } 2081 return true; 2082 } 2083 2084 /** 2085 * tipc_rcv - process TIPC packets/messages arriving from off-node 2086 * @net: the applicable net namespace 2087 * @skb: TIPC packet 2088 * @b: pointer to bearer message arrived on 2089 * 2090 * Invoked with no locks held. Bearer pointer must point to a valid bearer 2091 * structure (i.e. cannot be NULL), but bearer can be inactive. 2092 */ 2093 void tipc_rcv(struct net *net, struct sk_buff *skb, struct tipc_bearer *b) 2094 { 2095 struct sk_buff_head xmitq; 2096 struct tipc_link_entry *le; 2097 struct tipc_msg *hdr; 2098 struct tipc_node *n; 2099 int bearer_id = b->identity; 2100 u32 self = tipc_own_addr(net); 2101 int usr, rc = 0; 2102 u16 bc_ack; 2103 #ifdef CONFIG_TIPC_CRYPTO 2104 struct tipc_ehdr *ehdr; 2105 2106 /* Check if message must be decrypted first */ 2107 if (TIPC_SKB_CB(skb)->decrypted || !tipc_ehdr_validate(skb)) 2108 goto rcv; 2109 2110 ehdr = (struct tipc_ehdr *)skb->data; 2111 if (likely(ehdr->user != LINK_CONFIG)) { 2112 n = tipc_node_find(net, ntohl(ehdr->addr)); 2113 if (unlikely(!n)) 2114 goto discard; 2115 } else { 2116 n = tipc_node_find_by_id(net, ehdr->id); 2117 } 2118 skb_dst_force(skb); 2119 tipc_crypto_rcv(net, (n) ? n->crypto_rx : NULL, &skb, b); 2120 if (!skb) 2121 return; 2122 2123 rcv: 2124 #endif 2125 /* Ensure message is well-formed before touching the header */ 2126 if (unlikely(!tipc_msg_validate(&skb))) 2127 goto discard; 2128 __skb_queue_head_init(&xmitq); 2129 hdr = buf_msg(skb); 2130 usr = msg_user(hdr); 2131 bc_ack = msg_bcast_ack(hdr); 2132 2133 /* Handle arrival of discovery or broadcast packet */ 2134 if (unlikely(msg_non_seq(hdr))) { 2135 if (unlikely(usr == LINK_CONFIG)) 2136 return tipc_disc_rcv(net, skb, b); 2137 else 2138 return tipc_node_bc_rcv(net, skb, bearer_id); 2139 } 2140 2141 /* Discard unicast link messages destined for another node */ 2142 if (unlikely(!msg_short(hdr) && (msg_destnode(hdr) != self))) 2143 goto discard; 2144 2145 /* Locate neighboring node that sent packet */ 2146 n = tipc_node_find(net, msg_prevnode(hdr)); 2147 if (unlikely(!n)) 2148 goto discard; 2149 le = &n->links[bearer_id]; 2150 2151 /* Ensure broadcast reception is in synch with peer's send state */ 2152 if (unlikely(usr == LINK_PROTOCOL)) { 2153 bool valid = true; 2154 2155 if (unlikely(skb_linearize(skb))) { 2156 tipc_node_put(n); 2157 goto discard; 2158 } 2159 hdr = buf_msg(skb); 2160 tipc_node_bc_sync_rcv(n, hdr, bearer_id, &xmitq, &valid); 2161 if (!valid) { 2162 tipc_node_put(n); 2163 goto discard; 2164 } 2165 } else if (unlikely(tipc_link_acked(n->bc_entry.link) != bc_ack)) { 2166 tipc_bcast_ack_rcv(net, n->bc_entry.link, hdr); 2167 } 2168 2169 /* Receive packet directly if conditions permit */ 2170 tipc_node_read_lock(n); 2171 if (likely((n->state == SELF_UP_PEER_UP) && (usr != TUNNEL_PROTOCOL))) { 2172 spin_lock_bh(&le->lock); 2173 if (le->link) { 2174 rc = tipc_link_rcv(le->link, skb, &xmitq); 2175 skb = NULL; 2176 } 2177 spin_unlock_bh(&le->lock); 2178 } 2179 tipc_node_read_unlock(n); 2180 2181 /* Check/update node state before receiving */ 2182 if (unlikely(skb)) { 2183 if (unlikely(skb_linearize(skb))) 2184 goto out_node_put; 2185 tipc_node_write_lock(n); 2186 if (tipc_node_check_state(n, skb, bearer_id, &xmitq)) { 2187 if (le->link) { 2188 rc = tipc_link_rcv(le->link, skb, &xmitq); 2189 skb = NULL; 2190 } 2191 } 2192 tipc_node_write_unlock(n); 2193 } 2194 2195 if (unlikely(rc & TIPC_LINK_UP_EVT)) 2196 tipc_node_link_up(n, bearer_id, &xmitq); 2197 2198 if (unlikely(rc & TIPC_LINK_DOWN_EVT)) 2199 tipc_node_link_down(n, bearer_id, false); 2200 2201 if (unlikely(!skb_queue_empty(&n->bc_entry.namedq))) 2202 tipc_named_rcv(net, &n->bc_entry.namedq, 2203 &n->bc_entry.named_rcv_nxt, 2204 &n->bc_entry.named_open); 2205 2206 if (unlikely(!skb_queue_empty(&n->bc_entry.inputq1))) 2207 tipc_node_mcast_rcv(n); 2208 2209 if (!skb_queue_empty(&le->inputq)) 2210 tipc_sk_rcv(net, &le->inputq); 2211 2212 if (!skb_queue_empty(&xmitq)) 2213 tipc_bearer_xmit(net, bearer_id, &xmitq, &le->maddr, n); 2214 2215 out_node_put: 2216 tipc_node_put(n); 2217 discard: 2218 kfree_skb(skb); 2219 } 2220 2221 void tipc_node_apply_property(struct net *net, struct tipc_bearer *b, 2222 int prop) 2223 { 2224 struct tipc_net *tn = tipc_net(net); 2225 int bearer_id = b->identity; 2226 struct sk_buff_head xmitq; 2227 struct tipc_link_entry *e; 2228 struct tipc_node *n; 2229 2230 __skb_queue_head_init(&xmitq); 2231 2232 rcu_read_lock(); 2233 2234 list_for_each_entry_rcu(n, &tn->node_list, list) { 2235 tipc_node_write_lock(n); 2236 e = &n->links[bearer_id]; 2237 if (e->link) { 2238 if (prop == TIPC_NLA_PROP_TOL) 2239 tipc_link_set_tolerance(e->link, b->tolerance, 2240 &xmitq); 2241 else if (prop == TIPC_NLA_PROP_MTU) 2242 tipc_link_set_mtu(e->link, b->mtu); 2243 2244 /* Update MTU for node link entry */ 2245 e->mtu = tipc_link_mss(e->link); 2246 } 2247 2248 tipc_node_write_unlock(n); 2249 tipc_bearer_xmit(net, bearer_id, &xmitq, &e->maddr, NULL); 2250 } 2251 2252 rcu_read_unlock(); 2253 } 2254 2255 int tipc_nl_peer_rm(struct sk_buff *skb, struct genl_info *info) 2256 { 2257 struct net *net = sock_net(skb->sk); 2258 struct tipc_net *tn = net_generic(net, tipc_net_id); 2259 struct nlattr *attrs[TIPC_NLA_NET_MAX + 1]; 2260 struct tipc_node *peer, *temp_node; 2261 u8 node_id[NODE_ID_LEN]; 2262 u64 *w0 = (u64 *)&node_id[0]; 2263 u64 *w1 = (u64 *)&node_id[8]; 2264 u32 addr; 2265 int err; 2266 2267 /* We identify the peer by its net */ 2268 if (!info->attrs[TIPC_NLA_NET]) 2269 return -EINVAL; 2270 2271 err = nla_parse_nested_deprecated(attrs, TIPC_NLA_NET_MAX, 2272 info->attrs[TIPC_NLA_NET], 2273 tipc_nl_net_policy, info->extack); 2274 if (err) 2275 return err; 2276 2277 /* attrs[TIPC_NLA_NET_NODEID] and attrs[TIPC_NLA_NET_ADDR] are 2278 * mutually exclusive cases 2279 */ 2280 if (attrs[TIPC_NLA_NET_ADDR]) { 2281 addr = nla_get_u32(attrs[TIPC_NLA_NET_ADDR]); 2282 if (!addr) 2283 return -EINVAL; 2284 } 2285 2286 if (attrs[TIPC_NLA_NET_NODEID]) { 2287 if (!attrs[TIPC_NLA_NET_NODEID_W1]) 2288 return -EINVAL; 2289 *w0 = nla_get_u64(attrs[TIPC_NLA_NET_NODEID]); 2290 *w1 = nla_get_u64(attrs[TIPC_NLA_NET_NODEID_W1]); 2291 addr = hash128to32(node_id); 2292 } 2293 2294 if (in_own_node(net, addr)) 2295 return -ENOTSUPP; 2296 2297 spin_lock_bh(&tn->node_list_lock); 2298 peer = tipc_node_find(net, addr); 2299 if (!peer) { 2300 spin_unlock_bh(&tn->node_list_lock); 2301 return -ENXIO; 2302 } 2303 2304 tipc_node_write_lock(peer); 2305 if (peer->state != SELF_DOWN_PEER_DOWN && 2306 peer->state != SELF_DOWN_PEER_LEAVING) { 2307 tipc_node_write_unlock(peer); 2308 err = -EBUSY; 2309 goto err_out; 2310 } 2311 2312 tipc_node_clear_links(peer); 2313 tipc_node_write_unlock(peer); 2314 tipc_node_delete(peer); 2315 2316 /* Calculate cluster capabilities */ 2317 tn->capabilities = TIPC_NODE_CAPABILITIES; 2318 list_for_each_entry_rcu(temp_node, &tn->node_list, list) { 2319 tn->capabilities &= temp_node->capabilities; 2320 } 2321 tipc_bcast_toggle_rcast(net, (tn->capabilities & TIPC_BCAST_RCAST)); 2322 err = 0; 2323 err_out: 2324 tipc_node_put(peer); 2325 spin_unlock_bh(&tn->node_list_lock); 2326 2327 return err; 2328 } 2329 2330 int tipc_nl_node_dump(struct sk_buff *skb, struct netlink_callback *cb) 2331 { 2332 int err; 2333 struct net *net = sock_net(skb->sk); 2334 struct tipc_net *tn = net_generic(net, tipc_net_id); 2335 int done = cb->args[0]; 2336 int last_addr = cb->args[1]; 2337 struct tipc_node *node; 2338 struct tipc_nl_msg msg; 2339 2340 if (done) 2341 return 0; 2342 2343 msg.skb = skb; 2344 msg.portid = NETLINK_CB(cb->skb).portid; 2345 msg.seq = cb->nlh->nlmsg_seq; 2346 2347 rcu_read_lock(); 2348 if (last_addr) { 2349 node = tipc_node_find(net, last_addr); 2350 if (!node) { 2351 rcu_read_unlock(); 2352 /* We never set seq or call nl_dump_check_consistent() 2353 * this means that setting prev_seq here will cause the 2354 * consistence check to fail in the netlink callback 2355 * handler. Resulting in the NLMSG_DONE message having 2356 * the NLM_F_DUMP_INTR flag set if the node state 2357 * changed while we released the lock. 2358 */ 2359 cb->prev_seq = 1; 2360 return -EPIPE; 2361 } 2362 tipc_node_put(node); 2363 } 2364 2365 list_for_each_entry_rcu(node, &tn->node_list, list) { 2366 if (node->preliminary) 2367 continue; 2368 if (last_addr) { 2369 if (node->addr == last_addr) 2370 last_addr = 0; 2371 else 2372 continue; 2373 } 2374 2375 tipc_node_read_lock(node); 2376 err = __tipc_nl_add_node(&msg, node); 2377 if (err) { 2378 last_addr = node->addr; 2379 tipc_node_read_unlock(node); 2380 goto out; 2381 } 2382 2383 tipc_node_read_unlock(node); 2384 } 2385 done = 1; 2386 out: 2387 cb->args[0] = done; 2388 cb->args[1] = last_addr; 2389 rcu_read_unlock(); 2390 2391 return skb->len; 2392 } 2393 2394 /* tipc_node_find_by_name - locate owner node of link by link's name 2395 * @net: the applicable net namespace 2396 * @name: pointer to link name string 2397 * @bearer_id: pointer to index in 'node->links' array where the link was found. 2398 * 2399 * Returns pointer to node owning the link, or 0 if no matching link is found. 2400 */ 2401 static struct tipc_node *tipc_node_find_by_name(struct net *net, 2402 const char *link_name, 2403 unsigned int *bearer_id) 2404 { 2405 struct tipc_net *tn = net_generic(net, tipc_net_id); 2406 struct tipc_link *l; 2407 struct tipc_node *n; 2408 struct tipc_node *found_node = NULL; 2409 int i; 2410 2411 *bearer_id = 0; 2412 rcu_read_lock(); 2413 list_for_each_entry_rcu(n, &tn->node_list, list) { 2414 tipc_node_read_lock(n); 2415 for (i = 0; i < MAX_BEARERS; i++) { 2416 l = n->links[i].link; 2417 if (l && !strcmp(tipc_link_name(l), link_name)) { 2418 *bearer_id = i; 2419 found_node = n; 2420 break; 2421 } 2422 } 2423 tipc_node_read_unlock(n); 2424 if (found_node) { 2425 if (!kref_get_unless_zero(&found_node->kref)) 2426 found_node = NULL; 2427 break; 2428 } 2429 } 2430 rcu_read_unlock(); 2431 2432 return found_node; 2433 } 2434 2435 int tipc_nl_node_set_link(struct sk_buff *skb, struct genl_info *info) 2436 { 2437 int err; 2438 int res = 0; 2439 int bearer_id; 2440 char *name; 2441 struct tipc_link *link; 2442 struct tipc_node *node; 2443 struct sk_buff_head xmitq; 2444 struct nlattr *attrs[TIPC_NLA_LINK_MAX + 1]; 2445 struct net *net = sock_net(skb->sk); 2446 2447 __skb_queue_head_init(&xmitq); 2448 2449 if (!info->attrs[TIPC_NLA_LINK]) 2450 return -EINVAL; 2451 2452 err = nla_parse_nested_deprecated(attrs, TIPC_NLA_LINK_MAX, 2453 info->attrs[TIPC_NLA_LINK], 2454 tipc_nl_link_policy, info->extack); 2455 if (err) 2456 return err; 2457 2458 if (!attrs[TIPC_NLA_LINK_NAME]) 2459 return -EINVAL; 2460 2461 name = nla_data(attrs[TIPC_NLA_LINK_NAME]); 2462 2463 if (strcmp(name, tipc_bclink_name) == 0) 2464 return tipc_nl_bc_link_set(net, attrs); 2465 2466 node = tipc_node_find_by_name(net, name, &bearer_id); 2467 if (!node) 2468 return -EINVAL; 2469 2470 tipc_node_read_lock(node); 2471 2472 link = node->links[bearer_id].link; 2473 if (!link) { 2474 res = -EINVAL; 2475 goto out; 2476 } 2477 2478 if (attrs[TIPC_NLA_LINK_PROP]) { 2479 struct nlattr *props[TIPC_NLA_PROP_MAX + 1]; 2480 2481 err = tipc_nl_parse_link_prop(attrs[TIPC_NLA_LINK_PROP], props); 2482 if (err) { 2483 res = err; 2484 goto out; 2485 } 2486 2487 if (props[TIPC_NLA_PROP_TOL]) { 2488 u32 tol; 2489 2490 tol = nla_get_u32(props[TIPC_NLA_PROP_TOL]); 2491 tipc_link_set_tolerance(link, tol, &xmitq); 2492 } 2493 if (props[TIPC_NLA_PROP_PRIO]) { 2494 u32 prio; 2495 2496 prio = nla_get_u32(props[TIPC_NLA_PROP_PRIO]); 2497 tipc_link_set_prio(link, prio, &xmitq); 2498 } 2499 if (props[TIPC_NLA_PROP_WIN]) { 2500 u32 max_win; 2501 2502 max_win = nla_get_u32(props[TIPC_NLA_PROP_WIN]); 2503 tipc_link_set_queue_limits(link, 2504 tipc_link_min_win(link), 2505 max_win); 2506 } 2507 } 2508 2509 out: 2510 tipc_node_read_unlock(node); 2511 tipc_bearer_xmit(net, bearer_id, &xmitq, &node->links[bearer_id].maddr, 2512 NULL); 2513 tipc_node_put(node); 2514 return res; 2515 } 2516 2517 int tipc_nl_node_get_link(struct sk_buff *skb, struct genl_info *info) 2518 { 2519 struct net *net = genl_info_net(info); 2520 struct nlattr *attrs[TIPC_NLA_LINK_MAX + 1]; 2521 struct tipc_nl_msg msg; 2522 char *name; 2523 int err; 2524 2525 msg.portid = info->snd_portid; 2526 msg.seq = info->snd_seq; 2527 2528 if (!info->attrs[TIPC_NLA_LINK]) 2529 return -EINVAL; 2530 2531 err = nla_parse_nested_deprecated(attrs, TIPC_NLA_LINK_MAX, 2532 info->attrs[TIPC_NLA_LINK], 2533 tipc_nl_link_policy, info->extack); 2534 if (err) 2535 return err; 2536 2537 if (!attrs[TIPC_NLA_LINK_NAME]) 2538 return -EINVAL; 2539 2540 name = nla_data(attrs[TIPC_NLA_LINK_NAME]); 2541 2542 msg.skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL); 2543 if (!msg.skb) 2544 return -ENOMEM; 2545 2546 if (strcmp(name, tipc_bclink_name) == 0) { 2547 err = tipc_nl_add_bc_link(net, &msg, tipc_net(net)->bcl); 2548 if (err) 2549 goto err_free; 2550 } else { 2551 int bearer_id; 2552 struct tipc_node *node; 2553 struct tipc_link *link; 2554 2555 node = tipc_node_find_by_name(net, name, &bearer_id); 2556 if (!node) { 2557 err = -EINVAL; 2558 goto err_free; 2559 } 2560 2561 tipc_node_read_lock(node); 2562 link = node->links[bearer_id].link; 2563 if (!link) { 2564 tipc_node_read_unlock(node); 2565 tipc_node_put(node); 2566 err = -EINVAL; 2567 goto err_free; 2568 } 2569 2570 err = __tipc_nl_add_link(net, &msg, link, 0); 2571 tipc_node_read_unlock(node); 2572 tipc_node_put(node); 2573 if (err) 2574 goto err_free; 2575 } 2576 2577 return genlmsg_reply(msg.skb, info); 2578 2579 err_free: 2580 nlmsg_free(msg.skb); 2581 return err; 2582 } 2583 2584 int tipc_nl_node_reset_link_stats(struct sk_buff *skb, struct genl_info *info) 2585 { 2586 int err; 2587 char *link_name; 2588 unsigned int bearer_id; 2589 struct tipc_link *link; 2590 struct tipc_node *node; 2591 struct nlattr *attrs[TIPC_NLA_LINK_MAX + 1]; 2592 struct net *net = sock_net(skb->sk); 2593 struct tipc_net *tn = tipc_net(net); 2594 struct tipc_link_entry *le; 2595 2596 if (!info->attrs[TIPC_NLA_LINK]) 2597 return -EINVAL; 2598 2599 err = nla_parse_nested_deprecated(attrs, TIPC_NLA_LINK_MAX, 2600 info->attrs[TIPC_NLA_LINK], 2601 tipc_nl_link_policy, info->extack); 2602 if (err) 2603 return err; 2604 2605 if (!attrs[TIPC_NLA_LINK_NAME]) 2606 return -EINVAL; 2607 2608 link_name = nla_data(attrs[TIPC_NLA_LINK_NAME]); 2609 2610 err = -EINVAL; 2611 if (!strcmp(link_name, tipc_bclink_name)) { 2612 err = tipc_bclink_reset_stats(net, tipc_bc_sndlink(net)); 2613 if (err) 2614 return err; 2615 return 0; 2616 } else if (strstr(link_name, tipc_bclink_name)) { 2617 rcu_read_lock(); 2618 list_for_each_entry_rcu(node, &tn->node_list, list) { 2619 tipc_node_read_lock(node); 2620 link = node->bc_entry.link; 2621 if (link && !strcmp(link_name, tipc_link_name(link))) { 2622 err = tipc_bclink_reset_stats(net, link); 2623 tipc_node_read_unlock(node); 2624 break; 2625 } 2626 tipc_node_read_unlock(node); 2627 } 2628 rcu_read_unlock(); 2629 return err; 2630 } 2631 2632 node = tipc_node_find_by_name(net, link_name, &bearer_id); 2633 if (!node) 2634 return -EINVAL; 2635 2636 le = &node->links[bearer_id]; 2637 tipc_node_read_lock(node); 2638 spin_lock_bh(&le->lock); 2639 link = node->links[bearer_id].link; 2640 if (!link) { 2641 spin_unlock_bh(&le->lock); 2642 tipc_node_read_unlock(node); 2643 tipc_node_put(node); 2644 return -EINVAL; 2645 } 2646 tipc_link_reset_stats(link); 2647 spin_unlock_bh(&le->lock); 2648 tipc_node_read_unlock(node); 2649 tipc_node_put(node); 2650 return 0; 2651 } 2652 2653 /* Caller should hold node lock */ 2654 static int __tipc_nl_add_node_links(struct net *net, struct tipc_nl_msg *msg, 2655 struct tipc_node *node, u32 *prev_link, 2656 bool bc_link) 2657 { 2658 u32 i; 2659 int err; 2660 2661 for (i = *prev_link; i < MAX_BEARERS; i++) { 2662 *prev_link = i; 2663 2664 if (!node->links[i].link) 2665 continue; 2666 2667 err = __tipc_nl_add_link(net, msg, 2668 node->links[i].link, NLM_F_MULTI); 2669 if (err) 2670 return err; 2671 } 2672 2673 if (bc_link) { 2674 *prev_link = i; 2675 err = tipc_nl_add_bc_link(net, msg, node->bc_entry.link); 2676 if (err) 2677 return err; 2678 } 2679 2680 *prev_link = 0; 2681 2682 return 0; 2683 } 2684 2685 int tipc_nl_node_dump_link(struct sk_buff *skb, struct netlink_callback *cb) 2686 { 2687 struct net *net = sock_net(skb->sk); 2688 struct nlattr **attrs = genl_dumpit_info(cb)->info.attrs; 2689 struct nlattr *link[TIPC_NLA_LINK_MAX + 1]; 2690 struct tipc_net *tn = net_generic(net, tipc_net_id); 2691 struct tipc_node *node; 2692 struct tipc_nl_msg msg; 2693 u32 prev_node = cb->args[0]; 2694 u32 prev_link = cb->args[1]; 2695 int done = cb->args[2]; 2696 bool bc_link = cb->args[3]; 2697 int err; 2698 2699 if (done) 2700 return 0; 2701 2702 if (!prev_node) { 2703 /* Check if broadcast-receiver links dumping is needed */ 2704 if (attrs && attrs[TIPC_NLA_LINK]) { 2705 err = nla_parse_nested_deprecated(link, 2706 TIPC_NLA_LINK_MAX, 2707 attrs[TIPC_NLA_LINK], 2708 tipc_nl_link_policy, 2709 NULL); 2710 if (unlikely(err)) 2711 return err; 2712 if (unlikely(!link[TIPC_NLA_LINK_BROADCAST])) 2713 return -EINVAL; 2714 bc_link = true; 2715 } 2716 } 2717 2718 msg.skb = skb; 2719 msg.portid = NETLINK_CB(cb->skb).portid; 2720 msg.seq = cb->nlh->nlmsg_seq; 2721 2722 rcu_read_lock(); 2723 if (prev_node) { 2724 node = tipc_node_find(net, prev_node); 2725 if (!node) { 2726 /* We never set seq or call nl_dump_check_consistent() 2727 * this means that setting prev_seq here will cause the 2728 * consistence check to fail in the netlink callback 2729 * handler. Resulting in the last NLMSG_DONE message 2730 * having the NLM_F_DUMP_INTR flag set. 2731 */ 2732 cb->prev_seq = 1; 2733 goto out; 2734 } 2735 tipc_node_put(node); 2736 2737 list_for_each_entry_continue_rcu(node, &tn->node_list, 2738 list) { 2739 tipc_node_read_lock(node); 2740 err = __tipc_nl_add_node_links(net, &msg, node, 2741 &prev_link, bc_link); 2742 tipc_node_read_unlock(node); 2743 if (err) 2744 goto out; 2745 2746 prev_node = node->addr; 2747 } 2748 } else { 2749 err = tipc_nl_add_bc_link(net, &msg, tn->bcl); 2750 if (err) 2751 goto out; 2752 2753 list_for_each_entry_rcu(node, &tn->node_list, list) { 2754 tipc_node_read_lock(node); 2755 err = __tipc_nl_add_node_links(net, &msg, node, 2756 &prev_link, bc_link); 2757 tipc_node_read_unlock(node); 2758 if (err) 2759 goto out; 2760 2761 prev_node = node->addr; 2762 } 2763 } 2764 done = 1; 2765 out: 2766 rcu_read_unlock(); 2767 2768 cb->args[0] = prev_node; 2769 cb->args[1] = prev_link; 2770 cb->args[2] = done; 2771 cb->args[3] = bc_link; 2772 2773 return skb->len; 2774 } 2775 2776 int tipc_nl_node_set_monitor(struct sk_buff *skb, struct genl_info *info) 2777 { 2778 struct nlattr *attrs[TIPC_NLA_MON_MAX + 1]; 2779 struct net *net = sock_net(skb->sk); 2780 int err; 2781 2782 if (!info->attrs[TIPC_NLA_MON]) 2783 return -EINVAL; 2784 2785 err = nla_parse_nested_deprecated(attrs, TIPC_NLA_MON_MAX, 2786 info->attrs[TIPC_NLA_MON], 2787 tipc_nl_monitor_policy, 2788 info->extack); 2789 if (err) 2790 return err; 2791 2792 if (attrs[TIPC_NLA_MON_ACTIVATION_THRESHOLD]) { 2793 u32 val; 2794 2795 val = nla_get_u32(attrs[TIPC_NLA_MON_ACTIVATION_THRESHOLD]); 2796 err = tipc_nl_monitor_set_threshold(net, val); 2797 if (err) 2798 return err; 2799 } 2800 2801 return 0; 2802 } 2803 2804 static int __tipc_nl_add_monitor_prop(struct net *net, struct tipc_nl_msg *msg) 2805 { 2806 struct nlattr *attrs; 2807 void *hdr; 2808 u32 val; 2809 2810 hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family, 2811 0, TIPC_NL_MON_GET); 2812 if (!hdr) 2813 return -EMSGSIZE; 2814 2815 attrs = nla_nest_start_noflag(msg->skb, TIPC_NLA_MON); 2816 if (!attrs) 2817 goto msg_full; 2818 2819 val = tipc_nl_monitor_get_threshold(net); 2820 2821 if (nla_put_u32(msg->skb, TIPC_NLA_MON_ACTIVATION_THRESHOLD, val)) 2822 goto attr_msg_full; 2823 2824 nla_nest_end(msg->skb, attrs); 2825 genlmsg_end(msg->skb, hdr); 2826 2827 return 0; 2828 2829 attr_msg_full: 2830 nla_nest_cancel(msg->skb, attrs); 2831 msg_full: 2832 genlmsg_cancel(msg->skb, hdr); 2833 2834 return -EMSGSIZE; 2835 } 2836 2837 int tipc_nl_node_get_monitor(struct sk_buff *skb, struct genl_info *info) 2838 { 2839 struct net *net = sock_net(skb->sk); 2840 struct tipc_nl_msg msg; 2841 int err; 2842 2843 msg.skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL); 2844 if (!msg.skb) 2845 return -ENOMEM; 2846 msg.portid = info->snd_portid; 2847 msg.seq = info->snd_seq; 2848 2849 err = __tipc_nl_add_monitor_prop(net, &msg); 2850 if (err) { 2851 nlmsg_free(msg.skb); 2852 return err; 2853 } 2854 2855 return genlmsg_reply(msg.skb, info); 2856 } 2857 2858 int tipc_nl_node_dump_monitor(struct sk_buff *skb, struct netlink_callback *cb) 2859 { 2860 struct net *net = sock_net(skb->sk); 2861 u32 prev_bearer = cb->args[0]; 2862 struct tipc_nl_msg msg; 2863 int bearer_id; 2864 int err; 2865 2866 if (prev_bearer == MAX_BEARERS) 2867 return 0; 2868 2869 msg.skb = skb; 2870 msg.portid = NETLINK_CB(cb->skb).portid; 2871 msg.seq = cb->nlh->nlmsg_seq; 2872 2873 rtnl_lock(); 2874 for (bearer_id = prev_bearer; bearer_id < MAX_BEARERS; bearer_id++) { 2875 err = __tipc_nl_add_monitor(net, &msg, bearer_id); 2876 if (err) 2877 break; 2878 } 2879 rtnl_unlock(); 2880 cb->args[0] = bearer_id; 2881 2882 return skb->len; 2883 } 2884 2885 int tipc_nl_node_dump_monitor_peer(struct sk_buff *skb, 2886 struct netlink_callback *cb) 2887 { 2888 struct net *net = sock_net(skb->sk); 2889 u32 prev_node = cb->args[1]; 2890 u32 bearer_id = cb->args[2]; 2891 int done = cb->args[0]; 2892 struct tipc_nl_msg msg; 2893 int err; 2894 2895 if (!prev_node) { 2896 struct nlattr **attrs = genl_dumpit_info(cb)->info.attrs; 2897 struct nlattr *mon[TIPC_NLA_MON_MAX + 1]; 2898 2899 if (!attrs[TIPC_NLA_MON]) 2900 return -EINVAL; 2901 2902 err = nla_parse_nested_deprecated(mon, TIPC_NLA_MON_MAX, 2903 attrs[TIPC_NLA_MON], 2904 tipc_nl_monitor_policy, 2905 NULL); 2906 if (err) 2907 return err; 2908 2909 if (!mon[TIPC_NLA_MON_REF]) 2910 return -EINVAL; 2911 2912 bearer_id = nla_get_u32(mon[TIPC_NLA_MON_REF]); 2913 2914 if (bearer_id >= MAX_BEARERS) 2915 return -EINVAL; 2916 } 2917 2918 if (done) 2919 return 0; 2920 2921 msg.skb = skb; 2922 msg.portid = NETLINK_CB(cb->skb).portid; 2923 msg.seq = cb->nlh->nlmsg_seq; 2924 2925 rtnl_lock(); 2926 err = tipc_nl_add_monitor_peer(net, &msg, bearer_id, &prev_node); 2927 if (!err) 2928 done = 1; 2929 2930 rtnl_unlock(); 2931 cb->args[0] = done; 2932 cb->args[1] = prev_node; 2933 cb->args[2] = bearer_id; 2934 2935 return skb->len; 2936 } 2937 2938 #ifdef CONFIG_TIPC_CRYPTO 2939 static int tipc_nl_retrieve_key(struct nlattr **attrs, 2940 struct tipc_aead_key **pkey) 2941 { 2942 struct nlattr *attr = attrs[TIPC_NLA_NODE_KEY]; 2943 struct tipc_aead_key *key; 2944 2945 if (!attr) 2946 return -ENODATA; 2947 2948 if (nla_len(attr) < sizeof(*key)) 2949 return -EINVAL; 2950 key = (struct tipc_aead_key *)nla_data(attr); 2951 if (key->keylen > TIPC_AEAD_KEYLEN_MAX || 2952 nla_len(attr) < tipc_aead_key_size(key)) 2953 return -EINVAL; 2954 2955 *pkey = key; 2956 return 0; 2957 } 2958 2959 static int tipc_nl_retrieve_nodeid(struct nlattr **attrs, u8 **node_id) 2960 { 2961 struct nlattr *attr = attrs[TIPC_NLA_NODE_ID]; 2962 2963 if (!attr) 2964 return -ENODATA; 2965 2966 if (nla_len(attr) < TIPC_NODEID_LEN) 2967 return -EINVAL; 2968 2969 *node_id = (u8 *)nla_data(attr); 2970 return 0; 2971 } 2972 2973 static int tipc_nl_retrieve_rekeying(struct nlattr **attrs, u32 *intv) 2974 { 2975 struct nlattr *attr = attrs[TIPC_NLA_NODE_REKEYING]; 2976 2977 if (!attr) 2978 return -ENODATA; 2979 2980 *intv = nla_get_u32(attr); 2981 return 0; 2982 } 2983 2984 static int __tipc_nl_node_set_key(struct sk_buff *skb, struct genl_info *info) 2985 { 2986 struct nlattr *attrs[TIPC_NLA_NODE_MAX + 1]; 2987 struct net *net = sock_net(skb->sk); 2988 struct tipc_crypto *tx = tipc_net(net)->crypto_tx, *c = tx; 2989 struct tipc_node *n = NULL; 2990 struct tipc_aead_key *ukey; 2991 bool rekeying = true, master_key = false; 2992 u8 *id, *own_id, mode; 2993 u32 intv = 0; 2994 int rc = 0; 2995 2996 if (!info->attrs[TIPC_NLA_NODE]) 2997 return -EINVAL; 2998 2999 rc = nla_parse_nested(attrs, TIPC_NLA_NODE_MAX, 3000 info->attrs[TIPC_NLA_NODE], 3001 tipc_nl_node_policy, info->extack); 3002 if (rc) 3003 return rc; 3004 3005 own_id = tipc_own_id(net); 3006 if (!own_id) { 3007 GENL_SET_ERR_MSG(info, "not found own node identity (set id?)"); 3008 return -EPERM; 3009 } 3010 3011 rc = tipc_nl_retrieve_rekeying(attrs, &intv); 3012 if (rc == -ENODATA) 3013 rekeying = false; 3014 3015 rc = tipc_nl_retrieve_key(attrs, &ukey); 3016 if (rc == -ENODATA && rekeying) 3017 goto rekeying; 3018 else if (rc) 3019 return rc; 3020 3021 rc = tipc_aead_key_validate(ukey, info); 3022 if (rc) 3023 return rc; 3024 3025 rc = tipc_nl_retrieve_nodeid(attrs, &id); 3026 switch (rc) { 3027 case -ENODATA: 3028 mode = CLUSTER_KEY; 3029 master_key = !!(attrs[TIPC_NLA_NODE_KEY_MASTER]); 3030 break; 3031 case 0: 3032 mode = PER_NODE_KEY; 3033 if (memcmp(id, own_id, NODE_ID_LEN)) { 3034 n = tipc_node_find_by_id(net, id) ?: 3035 tipc_node_create(net, 0, id, 0xffffu, 0, true); 3036 if (unlikely(!n)) 3037 return -ENOMEM; 3038 c = n->crypto_rx; 3039 } 3040 break; 3041 default: 3042 return rc; 3043 } 3044 3045 /* Initiate the TX/RX key */ 3046 rc = tipc_crypto_key_init(c, ukey, mode, master_key); 3047 if (n) 3048 tipc_node_put(n); 3049 3050 if (unlikely(rc < 0)) { 3051 GENL_SET_ERR_MSG(info, "unable to initiate or attach new key"); 3052 return rc; 3053 } else if (c == tx) { 3054 /* Distribute TX key but not master one */ 3055 if (!master_key && tipc_crypto_key_distr(tx, rc, NULL)) 3056 GENL_SET_ERR_MSG(info, "failed to replicate new key"); 3057 rekeying: 3058 /* Schedule TX rekeying if needed */ 3059 tipc_crypto_rekeying_sched(tx, rekeying, intv); 3060 } 3061 3062 return 0; 3063 } 3064 3065 int tipc_nl_node_set_key(struct sk_buff *skb, struct genl_info *info) 3066 { 3067 int err; 3068 3069 rtnl_lock(); 3070 err = __tipc_nl_node_set_key(skb, info); 3071 rtnl_unlock(); 3072 3073 return err; 3074 } 3075 3076 static int __tipc_nl_node_flush_key(struct sk_buff *skb, 3077 struct genl_info *info) 3078 { 3079 struct net *net = sock_net(skb->sk); 3080 struct tipc_net *tn = tipc_net(net); 3081 struct tipc_node *n; 3082 3083 tipc_crypto_key_flush(tn->crypto_tx); 3084 rcu_read_lock(); 3085 list_for_each_entry_rcu(n, &tn->node_list, list) 3086 tipc_crypto_key_flush(n->crypto_rx); 3087 rcu_read_unlock(); 3088 3089 return 0; 3090 } 3091 3092 int tipc_nl_node_flush_key(struct sk_buff *skb, struct genl_info *info) 3093 { 3094 int err; 3095 3096 rtnl_lock(); 3097 err = __tipc_nl_node_flush_key(skb, info); 3098 rtnl_unlock(); 3099 3100 return err; 3101 } 3102 #endif 3103 3104 /** 3105 * tipc_node_dump - dump TIPC node data 3106 * @n: tipc node to be dumped 3107 * @more: dump more? 3108 * - false: dump only tipc node data 3109 * - true: dump node link data as well 3110 * @buf: returned buffer of dump data in format 3111 */ 3112 int tipc_node_dump(struct tipc_node *n, bool more, char *buf) 3113 { 3114 int i = 0; 3115 size_t sz = (more) ? NODE_LMAX : NODE_LMIN; 3116 3117 if (!n) { 3118 i += scnprintf(buf, sz, "node data: (null)\n"); 3119 return i; 3120 } 3121 3122 i += scnprintf(buf, sz, "node data: %x", n->addr); 3123 i += scnprintf(buf + i, sz - i, " %x", n->state); 3124 i += scnprintf(buf + i, sz - i, " %d", n->active_links[0]); 3125 i += scnprintf(buf + i, sz - i, " %d", n->active_links[1]); 3126 i += scnprintf(buf + i, sz - i, " %x", n->action_flags); 3127 i += scnprintf(buf + i, sz - i, " %u", n->failover_sent); 3128 i += scnprintf(buf + i, sz - i, " %u", n->sync_point); 3129 i += scnprintf(buf + i, sz - i, " %d", n->link_cnt); 3130 i += scnprintf(buf + i, sz - i, " %u", n->working_links); 3131 i += scnprintf(buf + i, sz - i, " %x", n->capabilities); 3132 i += scnprintf(buf + i, sz - i, " %lu\n", n->keepalive_intv); 3133 3134 if (!more) 3135 return i; 3136 3137 i += scnprintf(buf + i, sz - i, "link_entry[0]:\n"); 3138 i += scnprintf(buf + i, sz - i, " mtu: %u\n", n->links[0].mtu); 3139 i += scnprintf(buf + i, sz - i, " media: "); 3140 i += tipc_media_addr_printf(buf + i, sz - i, &n->links[0].maddr); 3141 i += scnprintf(buf + i, sz - i, "\n"); 3142 i += tipc_link_dump(n->links[0].link, TIPC_DUMP_NONE, buf + i); 3143 i += scnprintf(buf + i, sz - i, " inputq: "); 3144 i += tipc_list_dump(&n->links[0].inputq, false, buf + i); 3145 3146 i += scnprintf(buf + i, sz - i, "link_entry[1]:\n"); 3147 i += scnprintf(buf + i, sz - i, " mtu: %u\n", n->links[1].mtu); 3148 i += scnprintf(buf + i, sz - i, " media: "); 3149 i += tipc_media_addr_printf(buf + i, sz - i, &n->links[1].maddr); 3150 i += scnprintf(buf + i, sz - i, "\n"); 3151 i += tipc_link_dump(n->links[1].link, TIPC_DUMP_NONE, buf + i); 3152 i += scnprintf(buf + i, sz - i, " inputq: "); 3153 i += tipc_list_dump(&n->links[1].inputq, false, buf + i); 3154 3155 i += scnprintf(buf + i, sz - i, "bclink:\n "); 3156 i += tipc_link_dump(n->bc_entry.link, TIPC_DUMP_NONE, buf + i); 3157 3158 return i; 3159 } 3160 3161 void tipc_node_pre_cleanup_net(struct net *exit_net) 3162 { 3163 struct tipc_node *n; 3164 struct tipc_net *tn; 3165 struct net *tmp; 3166 3167 rcu_read_lock(); 3168 for_each_net_rcu(tmp) { 3169 if (tmp == exit_net) 3170 continue; 3171 tn = tipc_net(tmp); 3172 if (!tn) 3173 continue; 3174 spin_lock_bh(&tn->node_list_lock); 3175 list_for_each_entry_rcu(n, &tn->node_list, list) { 3176 if (!n->peer_net) 3177 continue; 3178 if (n->peer_net != exit_net) 3179 continue; 3180 tipc_node_write_lock(n); 3181 n->peer_net = NULL; 3182 n->peer_hash_mix = 0; 3183 tipc_node_write_unlock_fast(n); 3184 break; 3185 } 3186 spin_unlock_bh(&tn->node_list_lock); 3187 } 3188 rcu_read_unlock(); 3189 } 3190