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