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