1 /* 2 * net/tipc/node.c: TIPC node management routines 3 * 4 * Copyright (c) 2000-2006, 2012-2015, 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 "discover.h" 44 45 /* Node FSM states and events: 46 */ 47 enum { 48 SELF_DOWN_PEER_DOWN = 0xdd, 49 SELF_UP_PEER_UP = 0xaa, 50 SELF_DOWN_PEER_LEAVING = 0xd1, 51 SELF_UP_PEER_COMING = 0xac, 52 SELF_COMING_PEER_UP = 0xca, 53 SELF_LEAVING_PEER_DOWN = 0x1d, 54 NODE_FAILINGOVER = 0xf0, 55 NODE_SYNCHING = 0xcc 56 }; 57 58 enum { 59 SELF_ESTABL_CONTACT_EVT = 0xece, 60 SELF_LOST_CONTACT_EVT = 0x1ce, 61 PEER_ESTABL_CONTACT_EVT = 0x9ece, 62 PEER_LOST_CONTACT_EVT = 0x91ce, 63 NODE_FAILOVER_BEGIN_EVT = 0xfbe, 64 NODE_FAILOVER_END_EVT = 0xfee, 65 NODE_SYNCH_BEGIN_EVT = 0xcbe, 66 NODE_SYNCH_END_EVT = 0xcee 67 }; 68 69 static void __tipc_node_link_down(struct tipc_node *n, int *bearer_id, 70 struct sk_buff_head *xmitq, 71 struct tipc_media_addr **maddr); 72 static void tipc_node_link_down(struct tipc_node *n, int bearer_id, 73 bool delete); 74 static void node_lost_contact(struct tipc_node *n, struct sk_buff_head *inputq); 75 static void tipc_node_delete(struct tipc_node *node); 76 static void tipc_node_timeout(unsigned long data); 77 static void tipc_node_fsm_evt(struct tipc_node *n, int evt); 78 79 struct tipc_sock_conn { 80 u32 port; 81 u32 peer_port; 82 u32 peer_node; 83 struct list_head list; 84 }; 85 86 static const struct nla_policy tipc_nl_node_policy[TIPC_NLA_NODE_MAX + 1] = { 87 [TIPC_NLA_NODE_UNSPEC] = { .type = NLA_UNSPEC }, 88 [TIPC_NLA_NODE_ADDR] = { .type = NLA_U32 }, 89 [TIPC_NLA_NODE_UP] = { .type = NLA_FLAG } 90 }; 91 92 /* 93 * A trivial power-of-two bitmask technique is used for speed, since this 94 * operation is done for every incoming TIPC packet. The number of hash table 95 * entries has been chosen so that no hash chain exceeds 8 nodes and will 96 * usually be much smaller (typically only a single node). 97 */ 98 static unsigned int tipc_hashfn(u32 addr) 99 { 100 return addr & (NODE_HTABLE_SIZE - 1); 101 } 102 103 static void tipc_node_kref_release(struct kref *kref) 104 { 105 struct tipc_node *node = container_of(kref, struct tipc_node, kref); 106 107 tipc_node_delete(node); 108 } 109 110 void tipc_node_put(struct tipc_node *node) 111 { 112 kref_put(&node->kref, tipc_node_kref_release); 113 } 114 115 static void tipc_node_get(struct tipc_node *node) 116 { 117 kref_get(&node->kref); 118 } 119 120 /* 121 * tipc_node_find - locate specified node object, if it exists 122 */ 123 struct tipc_node *tipc_node_find(struct net *net, u32 addr) 124 { 125 struct tipc_net *tn = net_generic(net, tipc_net_id); 126 struct tipc_node *node; 127 128 if (unlikely(!in_own_cluster_exact(net, addr))) 129 return NULL; 130 131 rcu_read_lock(); 132 hlist_for_each_entry_rcu(node, &tn->node_htable[tipc_hashfn(addr)], 133 hash) { 134 if (node->addr == addr) { 135 tipc_node_get(node); 136 rcu_read_unlock(); 137 return node; 138 } 139 } 140 rcu_read_unlock(); 141 return NULL; 142 } 143 144 struct tipc_node *tipc_node_create(struct net *net, u32 addr, u16 capabilities) 145 { 146 struct tipc_net *tn = net_generic(net, tipc_net_id); 147 struct tipc_node *n_ptr, *temp_node; 148 149 spin_lock_bh(&tn->node_list_lock); 150 n_ptr = tipc_node_find(net, addr); 151 if (n_ptr) 152 goto exit; 153 n_ptr = kzalloc(sizeof(*n_ptr), GFP_ATOMIC); 154 if (!n_ptr) { 155 pr_warn("Node creation failed, no memory\n"); 156 goto exit; 157 } 158 n_ptr->addr = addr; 159 n_ptr->net = net; 160 n_ptr->capabilities = capabilities; 161 kref_init(&n_ptr->kref); 162 spin_lock_init(&n_ptr->lock); 163 INIT_HLIST_NODE(&n_ptr->hash); 164 INIT_LIST_HEAD(&n_ptr->list); 165 INIT_LIST_HEAD(&n_ptr->publ_list); 166 INIT_LIST_HEAD(&n_ptr->conn_sks); 167 skb_queue_head_init(&n_ptr->bc_entry.namedq); 168 skb_queue_head_init(&n_ptr->bc_entry.inputq1); 169 __skb_queue_head_init(&n_ptr->bc_entry.arrvq); 170 skb_queue_head_init(&n_ptr->bc_entry.inputq2); 171 hlist_add_head_rcu(&n_ptr->hash, &tn->node_htable[tipc_hashfn(addr)]); 172 list_for_each_entry_rcu(temp_node, &tn->node_list, list) { 173 if (n_ptr->addr < temp_node->addr) 174 break; 175 } 176 list_add_tail_rcu(&n_ptr->list, &temp_node->list); 177 n_ptr->state = SELF_DOWN_PEER_LEAVING; 178 n_ptr->signature = INVALID_NODE_SIG; 179 n_ptr->active_links[0] = INVALID_BEARER_ID; 180 n_ptr->active_links[1] = INVALID_BEARER_ID; 181 if (!tipc_link_bc_create(net, tipc_own_addr(net), n_ptr->addr, 182 U16_MAX, tipc_bc_sndlink(net)->window, 183 n_ptr->capabilities, 184 &n_ptr->bc_entry.inputq1, 185 &n_ptr->bc_entry.namedq, 186 tipc_bc_sndlink(net), 187 &n_ptr->bc_entry.link)) { 188 pr_warn("Broadcast rcv link creation failed, no memory\n"); 189 kfree(n_ptr); 190 n_ptr = NULL; 191 goto exit; 192 } 193 tipc_node_get(n_ptr); 194 setup_timer(&n_ptr->timer, tipc_node_timeout, (unsigned long)n_ptr); 195 n_ptr->keepalive_intv = U32_MAX; 196 exit: 197 spin_unlock_bh(&tn->node_list_lock); 198 return n_ptr; 199 } 200 201 static void tipc_node_calculate_timer(struct tipc_node *n, struct tipc_link *l) 202 { 203 unsigned long tol = l->tolerance; 204 unsigned long intv = ((tol / 4) > 500) ? 500 : tol / 4; 205 unsigned long keepalive_intv = msecs_to_jiffies(intv); 206 207 /* Link with lowest tolerance determines timer interval */ 208 if (keepalive_intv < n->keepalive_intv) 209 n->keepalive_intv = keepalive_intv; 210 211 /* Ensure link's abort limit corresponds to current interval */ 212 l->abort_limit = l->tolerance / jiffies_to_msecs(n->keepalive_intv); 213 } 214 215 static void tipc_node_delete(struct tipc_node *node) 216 { 217 list_del_rcu(&node->list); 218 hlist_del_rcu(&node->hash); 219 kfree(node->bc_entry.link); 220 kfree_rcu(node, rcu); 221 } 222 223 void tipc_node_stop(struct net *net) 224 { 225 struct tipc_net *tn = net_generic(net, tipc_net_id); 226 struct tipc_node *node, *t_node; 227 228 spin_lock_bh(&tn->node_list_lock); 229 list_for_each_entry_safe(node, t_node, &tn->node_list, list) { 230 if (del_timer(&node->timer)) 231 tipc_node_put(node); 232 tipc_node_put(node); 233 } 234 spin_unlock_bh(&tn->node_list_lock); 235 } 236 237 int tipc_node_add_conn(struct net *net, u32 dnode, u32 port, u32 peer_port) 238 { 239 struct tipc_node *node; 240 struct tipc_sock_conn *conn; 241 int err = 0; 242 243 if (in_own_node(net, dnode)) 244 return 0; 245 246 node = tipc_node_find(net, dnode); 247 if (!node) { 248 pr_warn("Connecting sock to node 0x%x failed\n", dnode); 249 return -EHOSTUNREACH; 250 } 251 conn = kmalloc(sizeof(*conn), GFP_ATOMIC); 252 if (!conn) { 253 err = -EHOSTUNREACH; 254 goto exit; 255 } 256 conn->peer_node = dnode; 257 conn->port = port; 258 conn->peer_port = peer_port; 259 260 tipc_node_lock(node); 261 list_add_tail(&conn->list, &node->conn_sks); 262 tipc_node_unlock(node); 263 exit: 264 tipc_node_put(node); 265 return err; 266 } 267 268 void tipc_node_remove_conn(struct net *net, u32 dnode, u32 port) 269 { 270 struct tipc_node *node; 271 struct tipc_sock_conn *conn, *safe; 272 273 if (in_own_node(net, dnode)) 274 return; 275 276 node = tipc_node_find(net, dnode); 277 if (!node) 278 return; 279 280 tipc_node_lock(node); 281 list_for_each_entry_safe(conn, safe, &node->conn_sks, list) { 282 if (port != conn->port) 283 continue; 284 list_del(&conn->list); 285 kfree(conn); 286 } 287 tipc_node_unlock(node); 288 tipc_node_put(node); 289 } 290 291 /* tipc_node_timeout - handle expiration of node timer 292 */ 293 static void tipc_node_timeout(unsigned long data) 294 { 295 struct tipc_node *n = (struct tipc_node *)data; 296 struct tipc_link_entry *le; 297 struct sk_buff_head xmitq; 298 int bearer_id; 299 int rc = 0; 300 301 __skb_queue_head_init(&xmitq); 302 303 for (bearer_id = 0; bearer_id < MAX_BEARERS; bearer_id++) { 304 tipc_node_lock(n); 305 le = &n->links[bearer_id]; 306 if (le->link) { 307 /* Link tolerance may change asynchronously: */ 308 tipc_node_calculate_timer(n, le->link); 309 rc = tipc_link_timeout(le->link, &xmitq); 310 } 311 tipc_node_unlock(n); 312 tipc_bearer_xmit(n->net, bearer_id, &xmitq, &le->maddr); 313 if (rc & TIPC_LINK_DOWN_EVT) 314 tipc_node_link_down(n, bearer_id, false); 315 } 316 if (!mod_timer(&n->timer, jiffies + n->keepalive_intv)) 317 tipc_node_get(n); 318 tipc_node_put(n); 319 } 320 321 /** 322 * __tipc_node_link_up - handle addition of link 323 * Node lock must be held by caller 324 * Link becomes active (alone or shared) or standby, depending on its priority. 325 */ 326 static void __tipc_node_link_up(struct tipc_node *n, int bearer_id, 327 struct sk_buff_head *xmitq) 328 { 329 int *slot0 = &n->active_links[0]; 330 int *slot1 = &n->active_links[1]; 331 struct tipc_link *ol = node_active_link(n, 0); 332 struct tipc_link *nl = n->links[bearer_id].link; 333 334 if (!nl) 335 return; 336 337 tipc_link_fsm_evt(nl, LINK_ESTABLISH_EVT); 338 if (!tipc_link_is_up(nl)) 339 return; 340 341 n->working_links++; 342 n->action_flags |= TIPC_NOTIFY_LINK_UP; 343 n->link_id = nl->peer_bearer_id << 16 | bearer_id; 344 345 /* Leave room for tunnel header when returning 'mtu' to users: */ 346 n->links[bearer_id].mtu = nl->mtu - INT_H_SIZE; 347 348 tipc_bearer_add_dest(n->net, bearer_id, n->addr); 349 tipc_bcast_inc_bearer_dst_cnt(n->net, bearer_id); 350 351 pr_debug("Established link <%s> on network plane %c\n", 352 nl->name, nl->net_plane); 353 354 /* First link? => give it both slots */ 355 if (!ol) { 356 *slot0 = bearer_id; 357 *slot1 = bearer_id; 358 tipc_node_fsm_evt(n, SELF_ESTABL_CONTACT_EVT); 359 n->action_flags |= TIPC_NOTIFY_NODE_UP; 360 tipc_bcast_add_peer(n->net, nl, xmitq); 361 return; 362 } 363 364 /* Second link => redistribute slots */ 365 if (nl->priority > ol->priority) { 366 pr_debug("Old link <%s> becomes standby\n", ol->name); 367 *slot0 = bearer_id; 368 *slot1 = bearer_id; 369 tipc_link_set_active(nl, true); 370 tipc_link_set_active(ol, false); 371 } else if (nl->priority == ol->priority) { 372 tipc_link_set_active(nl, true); 373 *slot1 = bearer_id; 374 } else { 375 pr_debug("New link <%s> is standby\n", nl->name); 376 } 377 378 /* Prepare synchronization with first link */ 379 tipc_link_tnl_prepare(ol, nl, SYNCH_MSG, xmitq); 380 } 381 382 /** 383 * tipc_node_link_up - handle addition of link 384 * 385 * Link becomes active (alone or shared) or standby, depending on its priority. 386 */ 387 static void tipc_node_link_up(struct tipc_node *n, int bearer_id, 388 struct sk_buff_head *xmitq) 389 { 390 tipc_node_lock(n); 391 __tipc_node_link_up(n, bearer_id, xmitq); 392 tipc_node_unlock(n); 393 } 394 395 /** 396 * __tipc_node_link_down - handle loss of link 397 */ 398 static void __tipc_node_link_down(struct tipc_node *n, int *bearer_id, 399 struct sk_buff_head *xmitq, 400 struct tipc_media_addr **maddr) 401 { 402 struct tipc_link_entry *le = &n->links[*bearer_id]; 403 int *slot0 = &n->active_links[0]; 404 int *slot1 = &n->active_links[1]; 405 int i, highest = 0; 406 struct tipc_link *l, *_l, *tnl; 407 408 l = n->links[*bearer_id].link; 409 if (!l || tipc_link_is_reset(l)) 410 return; 411 412 n->working_links--; 413 n->action_flags |= TIPC_NOTIFY_LINK_DOWN; 414 n->link_id = l->peer_bearer_id << 16 | *bearer_id; 415 416 tipc_bearer_remove_dest(n->net, *bearer_id, n->addr); 417 418 pr_debug("Lost link <%s> on network plane %c\n", 419 l->name, l->net_plane); 420 421 /* Select new active link if any available */ 422 *slot0 = INVALID_BEARER_ID; 423 *slot1 = INVALID_BEARER_ID; 424 for (i = 0; i < MAX_BEARERS; i++) { 425 _l = n->links[i].link; 426 if (!_l || !tipc_link_is_up(_l)) 427 continue; 428 if (_l == l) 429 continue; 430 if (_l->priority < highest) 431 continue; 432 if (_l->priority > highest) { 433 highest = _l->priority; 434 *slot0 = i; 435 *slot1 = i; 436 continue; 437 } 438 *slot1 = i; 439 } 440 441 if (!tipc_node_is_up(n)) { 442 if (tipc_link_peer_is_down(l)) 443 tipc_node_fsm_evt(n, PEER_LOST_CONTACT_EVT); 444 tipc_node_fsm_evt(n, SELF_LOST_CONTACT_EVT); 445 tipc_link_fsm_evt(l, LINK_RESET_EVT); 446 tipc_link_reset(l); 447 tipc_link_build_reset_msg(l, xmitq); 448 *maddr = &n->links[*bearer_id].maddr; 449 node_lost_contact(n, &le->inputq); 450 tipc_bcast_dec_bearer_dst_cnt(n->net, *bearer_id); 451 return; 452 } 453 tipc_bcast_dec_bearer_dst_cnt(n->net, *bearer_id); 454 455 /* There is still a working link => initiate failover */ 456 tnl = node_active_link(n, 0); 457 tipc_link_fsm_evt(tnl, LINK_SYNCH_END_EVT); 458 tipc_node_fsm_evt(n, NODE_SYNCH_END_EVT); 459 n->sync_point = tnl->rcv_nxt + (U16_MAX / 2 - 1); 460 tipc_link_tnl_prepare(l, tnl, FAILOVER_MSG, xmitq); 461 tipc_link_reset(l); 462 tipc_link_fsm_evt(l, LINK_RESET_EVT); 463 tipc_link_fsm_evt(l, LINK_FAILOVER_BEGIN_EVT); 464 tipc_node_fsm_evt(n, NODE_FAILOVER_BEGIN_EVT); 465 *maddr = &n->links[tnl->bearer_id].maddr; 466 *bearer_id = tnl->bearer_id; 467 } 468 469 static void tipc_node_link_down(struct tipc_node *n, int bearer_id, bool delete) 470 { 471 struct tipc_link_entry *le = &n->links[bearer_id]; 472 struct tipc_link *l = le->link; 473 struct tipc_media_addr *maddr; 474 struct sk_buff_head xmitq; 475 476 if (!l) 477 return; 478 479 __skb_queue_head_init(&xmitq); 480 481 tipc_node_lock(n); 482 if (!tipc_link_is_establishing(l)) { 483 __tipc_node_link_down(n, &bearer_id, &xmitq, &maddr); 484 if (delete) { 485 kfree(l); 486 le->link = NULL; 487 n->link_cnt--; 488 } 489 } else { 490 /* Defuse pending tipc_node_link_up() */ 491 tipc_link_fsm_evt(l, LINK_RESET_EVT); 492 } 493 tipc_node_unlock(n); 494 tipc_bearer_xmit(n->net, bearer_id, &xmitq, maddr); 495 tipc_sk_rcv(n->net, &le->inputq); 496 } 497 498 bool tipc_node_is_up(struct tipc_node *n) 499 { 500 return n->active_links[0] != INVALID_BEARER_ID; 501 } 502 503 void tipc_node_check_dest(struct net *net, u32 onode, 504 struct tipc_bearer *b, 505 u16 capabilities, u32 signature, 506 struct tipc_media_addr *maddr, 507 bool *respond, bool *dupl_addr) 508 { 509 struct tipc_node *n; 510 struct tipc_link *l; 511 struct tipc_link_entry *le; 512 bool addr_match = false; 513 bool sign_match = false; 514 bool link_up = false; 515 bool accept_addr = false; 516 bool reset = true; 517 char *if_name; 518 519 *dupl_addr = false; 520 *respond = false; 521 522 n = tipc_node_create(net, onode, capabilities); 523 if (!n) 524 return; 525 526 tipc_node_lock(n); 527 528 le = &n->links[b->identity]; 529 530 /* Prepare to validate requesting node's signature and media address */ 531 l = le->link; 532 link_up = l && tipc_link_is_up(l); 533 addr_match = l && !memcmp(&le->maddr, maddr, sizeof(*maddr)); 534 sign_match = (signature == n->signature); 535 536 /* These three flags give us eight permutations: */ 537 538 if (sign_match && addr_match && link_up) { 539 /* All is fine. Do nothing. */ 540 reset = false; 541 } else if (sign_match && addr_match && !link_up) { 542 /* Respond. The link will come up in due time */ 543 *respond = true; 544 } else if (sign_match && !addr_match && link_up) { 545 /* Peer has changed i/f address without rebooting. 546 * If so, the link will reset soon, and the next 547 * discovery will be accepted. So we can ignore it. 548 * It may also be an cloned or malicious peer having 549 * chosen the same node address and signature as an 550 * existing one. 551 * Ignore requests until the link goes down, if ever. 552 */ 553 *dupl_addr = true; 554 } else if (sign_match && !addr_match && !link_up) { 555 /* Peer link has changed i/f address without rebooting. 556 * It may also be a cloned or malicious peer; we can't 557 * distinguish between the two. 558 * The signature is correct, so we must accept. 559 */ 560 accept_addr = true; 561 *respond = true; 562 } else if (!sign_match && addr_match && link_up) { 563 /* Peer node rebooted. Two possibilities: 564 * - Delayed re-discovery; this link endpoint has already 565 * reset and re-established contact with the peer, before 566 * receiving a discovery message from that node. 567 * (The peer happened to receive one from this node first). 568 * - The peer came back so fast that our side has not 569 * discovered it yet. Probing from this side will soon 570 * reset the link, since there can be no working link 571 * endpoint at the peer end, and the link will re-establish. 572 * Accept the signature, since it comes from a known peer. 573 */ 574 n->signature = signature; 575 } else if (!sign_match && addr_match && !link_up) { 576 /* The peer node has rebooted. 577 * Accept signature, since it is a known peer. 578 */ 579 n->signature = signature; 580 *respond = true; 581 } else if (!sign_match && !addr_match && link_up) { 582 /* Peer rebooted with new address, or a new/duplicate peer. 583 * Ignore until the link goes down, if ever. 584 */ 585 *dupl_addr = true; 586 } else if (!sign_match && !addr_match && !link_up) { 587 /* Peer rebooted with new address, or it is a new peer. 588 * Accept signature and address. 589 */ 590 n->signature = signature; 591 accept_addr = true; 592 *respond = true; 593 } 594 595 if (!accept_addr) 596 goto exit; 597 598 /* Now create new link if not already existing */ 599 if (!l) { 600 if (n->link_cnt == 2) { 601 pr_warn("Cannot establish 3rd link to %x\n", n->addr); 602 goto exit; 603 } 604 if_name = strchr(b->name, ':') + 1; 605 if (!tipc_link_create(net, if_name, b->identity, b->tolerance, 606 b->net_plane, b->mtu, b->priority, 607 b->window, mod(tipc_net(net)->random), 608 tipc_own_addr(net), onode, 609 n->capabilities, 610 tipc_bc_sndlink(n->net), n->bc_entry.link, 611 &le->inputq, 612 &n->bc_entry.namedq, &l)) { 613 *respond = false; 614 goto exit; 615 } 616 tipc_link_reset(l); 617 tipc_link_fsm_evt(l, LINK_RESET_EVT); 618 if (n->state == NODE_FAILINGOVER) 619 tipc_link_fsm_evt(l, LINK_FAILOVER_BEGIN_EVT); 620 le->link = l; 621 n->link_cnt++; 622 tipc_node_calculate_timer(n, l); 623 if (n->link_cnt == 1) 624 if (!mod_timer(&n->timer, jiffies + n->keepalive_intv)) 625 tipc_node_get(n); 626 } 627 memcpy(&le->maddr, maddr, sizeof(*maddr)); 628 exit: 629 tipc_node_unlock(n); 630 if (reset && !tipc_link_is_reset(l)) 631 tipc_node_link_down(n, b->identity, false); 632 tipc_node_put(n); 633 } 634 635 void tipc_node_delete_links(struct net *net, int bearer_id) 636 { 637 struct tipc_net *tn = net_generic(net, tipc_net_id); 638 struct tipc_node *n; 639 640 rcu_read_lock(); 641 list_for_each_entry_rcu(n, &tn->node_list, list) { 642 tipc_node_link_down(n, bearer_id, true); 643 } 644 rcu_read_unlock(); 645 } 646 647 static void tipc_node_reset_links(struct tipc_node *n) 648 { 649 char addr_string[16]; 650 int i; 651 652 pr_warn("Resetting all links to %s\n", 653 tipc_addr_string_fill(addr_string, n->addr)); 654 655 for (i = 0; i < MAX_BEARERS; i++) { 656 tipc_node_link_down(n, i, false); 657 } 658 } 659 660 /* tipc_node_fsm_evt - node finite state machine 661 * Determines when contact is allowed with peer node 662 */ 663 static void tipc_node_fsm_evt(struct tipc_node *n, int evt) 664 { 665 int state = n->state; 666 667 switch (state) { 668 case SELF_DOWN_PEER_DOWN: 669 switch (evt) { 670 case SELF_ESTABL_CONTACT_EVT: 671 state = SELF_UP_PEER_COMING; 672 break; 673 case PEER_ESTABL_CONTACT_EVT: 674 state = SELF_COMING_PEER_UP; 675 break; 676 case SELF_LOST_CONTACT_EVT: 677 case PEER_LOST_CONTACT_EVT: 678 break; 679 case NODE_SYNCH_END_EVT: 680 case NODE_SYNCH_BEGIN_EVT: 681 case NODE_FAILOVER_BEGIN_EVT: 682 case NODE_FAILOVER_END_EVT: 683 default: 684 goto illegal_evt; 685 } 686 break; 687 case SELF_UP_PEER_UP: 688 switch (evt) { 689 case SELF_LOST_CONTACT_EVT: 690 state = SELF_DOWN_PEER_LEAVING; 691 break; 692 case PEER_LOST_CONTACT_EVT: 693 state = SELF_LEAVING_PEER_DOWN; 694 break; 695 case NODE_SYNCH_BEGIN_EVT: 696 state = NODE_SYNCHING; 697 break; 698 case NODE_FAILOVER_BEGIN_EVT: 699 state = NODE_FAILINGOVER; 700 break; 701 case SELF_ESTABL_CONTACT_EVT: 702 case PEER_ESTABL_CONTACT_EVT: 703 case NODE_SYNCH_END_EVT: 704 case NODE_FAILOVER_END_EVT: 705 break; 706 default: 707 goto illegal_evt; 708 } 709 break; 710 case SELF_DOWN_PEER_LEAVING: 711 switch (evt) { 712 case PEER_LOST_CONTACT_EVT: 713 state = SELF_DOWN_PEER_DOWN; 714 break; 715 case SELF_ESTABL_CONTACT_EVT: 716 case PEER_ESTABL_CONTACT_EVT: 717 case SELF_LOST_CONTACT_EVT: 718 break; 719 case NODE_SYNCH_END_EVT: 720 case NODE_SYNCH_BEGIN_EVT: 721 case NODE_FAILOVER_BEGIN_EVT: 722 case NODE_FAILOVER_END_EVT: 723 default: 724 goto illegal_evt; 725 } 726 break; 727 case SELF_UP_PEER_COMING: 728 switch (evt) { 729 case PEER_ESTABL_CONTACT_EVT: 730 state = SELF_UP_PEER_UP; 731 break; 732 case SELF_LOST_CONTACT_EVT: 733 state = SELF_DOWN_PEER_LEAVING; 734 break; 735 case SELF_ESTABL_CONTACT_EVT: 736 case PEER_LOST_CONTACT_EVT: 737 case NODE_SYNCH_END_EVT: 738 case NODE_FAILOVER_BEGIN_EVT: 739 break; 740 case NODE_SYNCH_BEGIN_EVT: 741 case NODE_FAILOVER_END_EVT: 742 default: 743 goto illegal_evt; 744 } 745 break; 746 case SELF_COMING_PEER_UP: 747 switch (evt) { 748 case SELF_ESTABL_CONTACT_EVT: 749 state = SELF_UP_PEER_UP; 750 break; 751 case PEER_LOST_CONTACT_EVT: 752 state = SELF_LEAVING_PEER_DOWN; 753 break; 754 case SELF_LOST_CONTACT_EVT: 755 case PEER_ESTABL_CONTACT_EVT: 756 break; 757 case NODE_SYNCH_END_EVT: 758 case NODE_SYNCH_BEGIN_EVT: 759 case NODE_FAILOVER_BEGIN_EVT: 760 case NODE_FAILOVER_END_EVT: 761 default: 762 goto illegal_evt; 763 } 764 break; 765 case SELF_LEAVING_PEER_DOWN: 766 switch (evt) { 767 case SELF_LOST_CONTACT_EVT: 768 state = SELF_DOWN_PEER_DOWN; 769 break; 770 case SELF_ESTABL_CONTACT_EVT: 771 case PEER_ESTABL_CONTACT_EVT: 772 case PEER_LOST_CONTACT_EVT: 773 break; 774 case NODE_SYNCH_END_EVT: 775 case NODE_SYNCH_BEGIN_EVT: 776 case NODE_FAILOVER_BEGIN_EVT: 777 case NODE_FAILOVER_END_EVT: 778 default: 779 goto illegal_evt; 780 } 781 break; 782 case NODE_FAILINGOVER: 783 switch (evt) { 784 case SELF_LOST_CONTACT_EVT: 785 state = SELF_DOWN_PEER_LEAVING; 786 break; 787 case PEER_LOST_CONTACT_EVT: 788 state = SELF_LEAVING_PEER_DOWN; 789 break; 790 case NODE_FAILOVER_END_EVT: 791 state = SELF_UP_PEER_UP; 792 break; 793 case NODE_FAILOVER_BEGIN_EVT: 794 case SELF_ESTABL_CONTACT_EVT: 795 case PEER_ESTABL_CONTACT_EVT: 796 break; 797 case NODE_SYNCH_BEGIN_EVT: 798 case NODE_SYNCH_END_EVT: 799 default: 800 goto illegal_evt; 801 } 802 break; 803 case NODE_SYNCHING: 804 switch (evt) { 805 case SELF_LOST_CONTACT_EVT: 806 state = SELF_DOWN_PEER_LEAVING; 807 break; 808 case PEER_LOST_CONTACT_EVT: 809 state = SELF_LEAVING_PEER_DOWN; 810 break; 811 case NODE_SYNCH_END_EVT: 812 state = SELF_UP_PEER_UP; 813 break; 814 case NODE_FAILOVER_BEGIN_EVT: 815 state = NODE_FAILINGOVER; 816 break; 817 case NODE_SYNCH_BEGIN_EVT: 818 case SELF_ESTABL_CONTACT_EVT: 819 case PEER_ESTABL_CONTACT_EVT: 820 break; 821 case NODE_FAILOVER_END_EVT: 822 default: 823 goto illegal_evt; 824 } 825 break; 826 default: 827 pr_err("Unknown node fsm state %x\n", state); 828 break; 829 } 830 n->state = state; 831 return; 832 833 illegal_evt: 834 pr_err("Illegal node fsm evt %x in state %x\n", evt, state); 835 } 836 837 bool tipc_node_filter_pkt(struct tipc_node *n, struct tipc_msg *hdr) 838 { 839 int state = n->state; 840 841 if (likely(state == SELF_UP_PEER_UP)) 842 return true; 843 844 if (state == SELF_LEAVING_PEER_DOWN) 845 return false; 846 847 if (state == SELF_DOWN_PEER_LEAVING) { 848 if (msg_peer_node_is_up(hdr)) 849 return false; 850 } 851 852 return true; 853 } 854 855 static void node_lost_contact(struct tipc_node *n, 856 struct sk_buff_head *inputq) 857 { 858 char addr_string[16]; 859 struct tipc_sock_conn *conn, *safe; 860 struct tipc_link *l; 861 struct list_head *conns = &n->conn_sks; 862 struct sk_buff *skb; 863 uint i; 864 865 pr_debug("Lost contact with %s\n", 866 tipc_addr_string_fill(addr_string, n->addr)); 867 868 /* Clean up broadcast state */ 869 tipc_bcast_remove_peer(n->net, n->bc_entry.link); 870 871 /* Abort any ongoing link failover */ 872 for (i = 0; i < MAX_BEARERS; i++) { 873 l = n->links[i].link; 874 if (l) 875 tipc_link_fsm_evt(l, LINK_FAILOVER_END_EVT); 876 } 877 878 /* Notify publications from this node */ 879 n->action_flags |= TIPC_NOTIFY_NODE_DOWN; 880 881 /* Notify sockets connected to node */ 882 list_for_each_entry_safe(conn, safe, conns, list) { 883 skb = tipc_msg_create(TIPC_CRITICAL_IMPORTANCE, TIPC_CONN_MSG, 884 SHORT_H_SIZE, 0, tipc_own_addr(n->net), 885 conn->peer_node, conn->port, 886 conn->peer_port, TIPC_ERR_NO_NODE); 887 if (likely(skb)) 888 skb_queue_tail(inputq, skb); 889 list_del(&conn->list); 890 kfree(conn); 891 } 892 } 893 894 /** 895 * tipc_node_get_linkname - get the name of a link 896 * 897 * @bearer_id: id of the bearer 898 * @node: peer node address 899 * @linkname: link name output buffer 900 * 901 * Returns 0 on success 902 */ 903 int tipc_node_get_linkname(struct net *net, u32 bearer_id, u32 addr, 904 char *linkname, size_t len) 905 { 906 struct tipc_link *link; 907 int err = -EINVAL; 908 struct tipc_node *node = tipc_node_find(net, addr); 909 910 if (!node) 911 return err; 912 913 if (bearer_id >= MAX_BEARERS) 914 goto exit; 915 916 tipc_node_lock(node); 917 link = node->links[bearer_id].link; 918 if (link) { 919 strncpy(linkname, link->name, len); 920 err = 0; 921 } 922 exit: 923 tipc_node_unlock(node); 924 tipc_node_put(node); 925 return err; 926 } 927 928 void tipc_node_unlock(struct tipc_node *node) 929 { 930 struct net *net = node->net; 931 u32 addr = 0; 932 u32 flags = node->action_flags; 933 u32 link_id = 0; 934 struct list_head *publ_list; 935 936 if (likely(!flags)) { 937 spin_unlock_bh(&node->lock); 938 return; 939 } 940 941 addr = node->addr; 942 link_id = node->link_id; 943 publ_list = &node->publ_list; 944 945 node->action_flags &= ~(TIPC_NOTIFY_NODE_DOWN | TIPC_NOTIFY_NODE_UP | 946 TIPC_NOTIFY_LINK_DOWN | TIPC_NOTIFY_LINK_UP); 947 948 spin_unlock_bh(&node->lock); 949 950 if (flags & TIPC_NOTIFY_NODE_DOWN) 951 tipc_publ_notify(net, publ_list, addr); 952 953 if (flags & TIPC_NOTIFY_NODE_UP) 954 tipc_named_node_up(net, addr); 955 956 if (flags & TIPC_NOTIFY_LINK_UP) 957 tipc_nametbl_publish(net, TIPC_LINK_STATE, addr, addr, 958 TIPC_NODE_SCOPE, link_id, addr); 959 960 if (flags & TIPC_NOTIFY_LINK_DOWN) 961 tipc_nametbl_withdraw(net, TIPC_LINK_STATE, addr, 962 link_id, addr); 963 964 } 965 966 /* Caller should hold node lock for the passed node */ 967 static int __tipc_nl_add_node(struct tipc_nl_msg *msg, struct tipc_node *node) 968 { 969 void *hdr; 970 struct nlattr *attrs; 971 972 hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family, 973 NLM_F_MULTI, TIPC_NL_NODE_GET); 974 if (!hdr) 975 return -EMSGSIZE; 976 977 attrs = nla_nest_start(msg->skb, TIPC_NLA_NODE); 978 if (!attrs) 979 goto msg_full; 980 981 if (nla_put_u32(msg->skb, TIPC_NLA_NODE_ADDR, node->addr)) 982 goto attr_msg_full; 983 if (tipc_node_is_up(node)) 984 if (nla_put_flag(msg->skb, TIPC_NLA_NODE_UP)) 985 goto attr_msg_full; 986 987 nla_nest_end(msg->skb, attrs); 988 genlmsg_end(msg->skb, hdr); 989 990 return 0; 991 992 attr_msg_full: 993 nla_nest_cancel(msg->skb, attrs); 994 msg_full: 995 genlmsg_cancel(msg->skb, hdr); 996 997 return -EMSGSIZE; 998 } 999 1000 static struct tipc_link *tipc_node_select_link(struct tipc_node *n, int sel, 1001 int *bearer_id, 1002 struct tipc_media_addr **maddr) 1003 { 1004 int id = n->active_links[sel & 1]; 1005 1006 if (unlikely(id < 0)) 1007 return NULL; 1008 1009 *bearer_id = id; 1010 *maddr = &n->links[id].maddr; 1011 return n->links[id].link; 1012 } 1013 1014 /** 1015 * tipc_node_xmit() is the general link level function for message sending 1016 * @net: the applicable net namespace 1017 * @list: chain of buffers containing message 1018 * @dnode: address of destination node 1019 * @selector: a number used for deterministic link selection 1020 * Consumes the buffer chain, except when returning -ELINKCONG 1021 * Returns 0 if success, otherwise errno: -ELINKCONG,-EHOSTUNREACH,-EMSGSIZE 1022 */ 1023 int tipc_node_xmit(struct net *net, struct sk_buff_head *list, 1024 u32 dnode, int selector) 1025 { 1026 struct tipc_link *l = NULL; 1027 struct tipc_node *n; 1028 struct sk_buff_head xmitq; 1029 struct tipc_media_addr *maddr; 1030 int bearer_id; 1031 int rc = -EHOSTUNREACH; 1032 1033 __skb_queue_head_init(&xmitq); 1034 n = tipc_node_find(net, dnode); 1035 if (likely(n)) { 1036 tipc_node_lock(n); 1037 l = tipc_node_select_link(n, selector, &bearer_id, &maddr); 1038 if (likely(l)) 1039 rc = tipc_link_xmit(l, list, &xmitq); 1040 tipc_node_unlock(n); 1041 if (unlikely(rc == -ENOBUFS)) 1042 tipc_node_link_down(n, bearer_id, false); 1043 tipc_node_put(n); 1044 } 1045 if (likely(!rc)) { 1046 tipc_bearer_xmit(net, bearer_id, &xmitq, maddr); 1047 return 0; 1048 } 1049 if (likely(in_own_node(net, dnode))) { 1050 tipc_sk_rcv(net, list); 1051 return 0; 1052 } 1053 return rc; 1054 } 1055 1056 /* tipc_node_xmit_skb(): send single buffer to destination 1057 * Buffers sent via this functon are generally TIPC_SYSTEM_IMPORTANCE 1058 * messages, which will not be rejected 1059 * The only exception is datagram messages rerouted after secondary 1060 * lookup, which are rare and safe to dispose of anyway. 1061 * TODO: Return real return value, and let callers use 1062 * tipc_wait_for_sendpkt() where applicable 1063 */ 1064 int tipc_node_xmit_skb(struct net *net, struct sk_buff *skb, u32 dnode, 1065 u32 selector) 1066 { 1067 struct sk_buff_head head; 1068 int rc; 1069 1070 skb_queue_head_init(&head); 1071 __skb_queue_tail(&head, skb); 1072 rc = tipc_node_xmit(net, &head, dnode, selector); 1073 if (rc == -ELINKCONG) 1074 kfree_skb(skb); 1075 return 0; 1076 } 1077 1078 /** 1079 * tipc_node_bc_rcv - process TIPC broadcast packet arriving from off-node 1080 * @net: the applicable net namespace 1081 * @skb: TIPC packet 1082 * @bearer_id: id of bearer message arrived on 1083 * 1084 * Invoked with no locks held. 1085 */ 1086 static void tipc_node_bc_rcv(struct net *net, struct sk_buff *skb, int bearer_id) 1087 { 1088 int rc; 1089 struct sk_buff_head xmitq; 1090 struct tipc_bclink_entry *be; 1091 struct tipc_link_entry *le; 1092 struct tipc_msg *hdr = buf_msg(skb); 1093 int usr = msg_user(hdr); 1094 u32 dnode = msg_destnode(hdr); 1095 struct tipc_node *n; 1096 1097 __skb_queue_head_init(&xmitq); 1098 1099 /* If NACK for other node, let rcv link for that node peek into it */ 1100 if ((usr == BCAST_PROTOCOL) && (dnode != tipc_own_addr(net))) 1101 n = tipc_node_find(net, dnode); 1102 else 1103 n = tipc_node_find(net, msg_prevnode(hdr)); 1104 if (!n) { 1105 kfree_skb(skb); 1106 return; 1107 } 1108 be = &n->bc_entry; 1109 le = &n->links[bearer_id]; 1110 1111 rc = tipc_bcast_rcv(net, be->link, skb); 1112 1113 /* Broadcast link reset may happen at reassembly failure */ 1114 if (rc & TIPC_LINK_DOWN_EVT) 1115 tipc_node_reset_links(n); 1116 1117 /* Broadcast ACKs are sent on a unicast link */ 1118 if (rc & TIPC_LINK_SND_BC_ACK) { 1119 tipc_node_lock(n); 1120 tipc_link_build_ack_msg(le->link, &xmitq); 1121 tipc_node_unlock(n); 1122 } 1123 1124 if (!skb_queue_empty(&xmitq)) 1125 tipc_bearer_xmit(net, bearer_id, &xmitq, &le->maddr); 1126 1127 /* Deliver. 'arrvq' is under inputq2's lock protection */ 1128 if (!skb_queue_empty(&be->inputq1)) { 1129 spin_lock_bh(&be->inputq2.lock); 1130 spin_lock_bh(&be->inputq1.lock); 1131 skb_queue_splice_tail_init(&be->inputq1, &be->arrvq); 1132 spin_unlock_bh(&be->inputq1.lock); 1133 spin_unlock_bh(&be->inputq2.lock); 1134 tipc_sk_mcast_rcv(net, &be->arrvq, &be->inputq2); 1135 } 1136 tipc_node_put(n); 1137 } 1138 1139 /** 1140 * tipc_node_check_state - check and if necessary update node state 1141 * @skb: TIPC packet 1142 * @bearer_id: identity of bearer delivering the packet 1143 * Returns true if state is ok, otherwise consumes buffer and returns false 1144 */ 1145 static bool tipc_node_check_state(struct tipc_node *n, struct sk_buff *skb, 1146 int bearer_id, struct sk_buff_head *xmitq) 1147 { 1148 struct tipc_msg *hdr = buf_msg(skb); 1149 int usr = msg_user(hdr); 1150 int mtyp = msg_type(hdr); 1151 u16 oseqno = msg_seqno(hdr); 1152 u16 iseqno = msg_seqno(msg_get_wrapped(hdr)); 1153 u16 exp_pkts = msg_msgcnt(hdr); 1154 u16 rcv_nxt, syncpt, dlv_nxt; 1155 int state = n->state; 1156 struct tipc_link *l, *tnl, *pl = NULL; 1157 struct tipc_media_addr *maddr; 1158 int i, pb_id; 1159 1160 l = n->links[bearer_id].link; 1161 if (!l) 1162 return false; 1163 rcv_nxt = l->rcv_nxt; 1164 1165 1166 if (likely((state == SELF_UP_PEER_UP) && (usr != TUNNEL_PROTOCOL))) 1167 return true; 1168 1169 /* Find parallel link, if any */ 1170 for (i = 0; i < MAX_BEARERS; i++) { 1171 if ((i != bearer_id) && n->links[i].link) { 1172 pl = n->links[i].link; 1173 break; 1174 } 1175 } 1176 1177 /* Update node accesibility if applicable */ 1178 if (state == SELF_UP_PEER_COMING) { 1179 if (!tipc_link_is_up(l)) 1180 return true; 1181 if (!msg_peer_link_is_up(hdr)) 1182 return true; 1183 tipc_node_fsm_evt(n, PEER_ESTABL_CONTACT_EVT); 1184 } 1185 1186 if (state == SELF_DOWN_PEER_LEAVING) { 1187 if (msg_peer_node_is_up(hdr)) 1188 return false; 1189 tipc_node_fsm_evt(n, PEER_LOST_CONTACT_EVT); 1190 } 1191 1192 /* Ignore duplicate packets */ 1193 if ((usr != LINK_PROTOCOL) && less(oseqno, rcv_nxt)) 1194 return true; 1195 1196 /* Initiate or update failover mode if applicable */ 1197 if ((usr == TUNNEL_PROTOCOL) && (mtyp == FAILOVER_MSG)) { 1198 syncpt = oseqno + exp_pkts - 1; 1199 if (pl && tipc_link_is_up(pl)) { 1200 pb_id = pl->bearer_id; 1201 __tipc_node_link_down(n, &pb_id, xmitq, &maddr); 1202 tipc_skb_queue_splice_tail_init(pl->inputq, l->inputq); 1203 } 1204 /* If pkts arrive out of order, use lowest calculated syncpt */ 1205 if (less(syncpt, n->sync_point)) 1206 n->sync_point = syncpt; 1207 } 1208 1209 /* Open parallel link when tunnel link reaches synch point */ 1210 if ((n->state == NODE_FAILINGOVER) && tipc_link_is_up(l)) { 1211 if (!more(rcv_nxt, n->sync_point)) 1212 return true; 1213 tipc_node_fsm_evt(n, NODE_FAILOVER_END_EVT); 1214 if (pl) 1215 tipc_link_fsm_evt(pl, LINK_FAILOVER_END_EVT); 1216 return true; 1217 } 1218 1219 /* No synching needed if only one link */ 1220 if (!pl || !tipc_link_is_up(pl)) 1221 return true; 1222 1223 /* Initiate synch mode if applicable */ 1224 if ((usr == TUNNEL_PROTOCOL) && (mtyp == SYNCH_MSG) && (oseqno == 1)) { 1225 syncpt = iseqno + exp_pkts - 1; 1226 if (!tipc_link_is_up(l)) { 1227 tipc_link_fsm_evt(l, LINK_ESTABLISH_EVT); 1228 __tipc_node_link_up(n, bearer_id, xmitq); 1229 } 1230 if (n->state == SELF_UP_PEER_UP) { 1231 n->sync_point = syncpt; 1232 tipc_link_fsm_evt(l, LINK_SYNCH_BEGIN_EVT); 1233 tipc_node_fsm_evt(n, NODE_SYNCH_BEGIN_EVT); 1234 } 1235 if (less(syncpt, n->sync_point)) 1236 n->sync_point = syncpt; 1237 } 1238 1239 /* Open tunnel link when parallel link reaches synch point */ 1240 if ((n->state == NODE_SYNCHING) && tipc_link_is_synching(l)) { 1241 if (tipc_link_is_synching(l)) { 1242 tnl = l; 1243 } else { 1244 tnl = pl; 1245 pl = l; 1246 } 1247 dlv_nxt = pl->rcv_nxt - mod(skb_queue_len(pl->inputq)); 1248 if (more(dlv_nxt, n->sync_point)) { 1249 tipc_link_fsm_evt(tnl, LINK_SYNCH_END_EVT); 1250 tipc_node_fsm_evt(n, NODE_SYNCH_END_EVT); 1251 return true; 1252 } 1253 if (l == pl) 1254 return true; 1255 if ((usr == TUNNEL_PROTOCOL) && (mtyp == SYNCH_MSG)) 1256 return true; 1257 if (usr == LINK_PROTOCOL) 1258 return true; 1259 return false; 1260 } 1261 return true; 1262 } 1263 1264 /** 1265 * tipc_rcv - process TIPC packets/messages arriving from off-node 1266 * @net: the applicable net namespace 1267 * @skb: TIPC packet 1268 * @bearer: pointer to bearer message arrived on 1269 * 1270 * Invoked with no locks held. Bearer pointer must point to a valid bearer 1271 * structure (i.e. cannot be NULL), but bearer can be inactive. 1272 */ 1273 void tipc_rcv(struct net *net, struct sk_buff *skb, struct tipc_bearer *b) 1274 { 1275 struct sk_buff_head xmitq; 1276 struct tipc_node *n; 1277 struct tipc_msg *hdr = buf_msg(skb); 1278 int usr = msg_user(hdr); 1279 int bearer_id = b->identity; 1280 struct tipc_link_entry *le; 1281 u16 bc_ack = msg_bcast_ack(hdr); 1282 int rc = 0; 1283 1284 __skb_queue_head_init(&xmitq); 1285 1286 /* Ensure message is well-formed */ 1287 if (unlikely(!tipc_msg_validate(skb))) 1288 goto discard; 1289 1290 /* Handle arrival of discovery or broadcast packet */ 1291 if (unlikely(msg_non_seq(hdr))) { 1292 if (unlikely(usr == LINK_CONFIG)) 1293 return tipc_disc_rcv(net, skb, b); 1294 else 1295 return tipc_node_bc_rcv(net, skb, bearer_id); 1296 } 1297 1298 /* Locate neighboring node that sent packet */ 1299 n = tipc_node_find(net, msg_prevnode(hdr)); 1300 if (unlikely(!n)) 1301 goto discard; 1302 le = &n->links[bearer_id]; 1303 1304 /* Ensure broadcast reception is in synch with peer's send state */ 1305 if (unlikely(usr == LINK_PROTOCOL)) 1306 tipc_bcast_sync_rcv(net, n->bc_entry.link, hdr); 1307 else if (unlikely(n->bc_entry.link->acked != bc_ack)) 1308 tipc_bcast_ack_rcv(net, n->bc_entry.link, bc_ack); 1309 1310 tipc_node_lock(n); 1311 1312 /* Is reception permitted at the moment ? */ 1313 if (!tipc_node_filter_pkt(n, hdr)) 1314 goto unlock; 1315 1316 /* Check and if necessary update node state */ 1317 if (likely(tipc_node_check_state(n, skb, bearer_id, &xmitq))) { 1318 rc = tipc_link_rcv(le->link, skb, &xmitq); 1319 skb = NULL; 1320 } 1321 unlock: 1322 tipc_node_unlock(n); 1323 1324 if (unlikely(rc & TIPC_LINK_UP_EVT)) 1325 tipc_node_link_up(n, bearer_id, &xmitq); 1326 1327 if (unlikely(rc & TIPC_LINK_DOWN_EVT)) 1328 tipc_node_link_down(n, bearer_id, false); 1329 1330 if (unlikely(!skb_queue_empty(&n->bc_entry.namedq))) 1331 tipc_named_rcv(net, &n->bc_entry.namedq); 1332 1333 if (!skb_queue_empty(&le->inputq)) 1334 tipc_sk_rcv(net, &le->inputq); 1335 1336 if (!skb_queue_empty(&xmitq)) 1337 tipc_bearer_xmit(net, bearer_id, &xmitq, &le->maddr); 1338 1339 tipc_node_put(n); 1340 discard: 1341 kfree_skb(skb); 1342 } 1343 1344 int tipc_nl_node_dump(struct sk_buff *skb, struct netlink_callback *cb) 1345 { 1346 int err; 1347 struct net *net = sock_net(skb->sk); 1348 struct tipc_net *tn = net_generic(net, tipc_net_id); 1349 int done = cb->args[0]; 1350 int last_addr = cb->args[1]; 1351 struct tipc_node *node; 1352 struct tipc_nl_msg msg; 1353 1354 if (done) 1355 return 0; 1356 1357 msg.skb = skb; 1358 msg.portid = NETLINK_CB(cb->skb).portid; 1359 msg.seq = cb->nlh->nlmsg_seq; 1360 1361 rcu_read_lock(); 1362 if (last_addr) { 1363 node = tipc_node_find(net, last_addr); 1364 if (!node) { 1365 rcu_read_unlock(); 1366 /* We never set seq or call nl_dump_check_consistent() 1367 * this means that setting prev_seq here will cause the 1368 * consistence check to fail in the netlink callback 1369 * handler. Resulting in the NLMSG_DONE message having 1370 * the NLM_F_DUMP_INTR flag set if the node state 1371 * changed while we released the lock. 1372 */ 1373 cb->prev_seq = 1; 1374 return -EPIPE; 1375 } 1376 tipc_node_put(node); 1377 } 1378 1379 list_for_each_entry_rcu(node, &tn->node_list, list) { 1380 if (last_addr) { 1381 if (node->addr == last_addr) 1382 last_addr = 0; 1383 else 1384 continue; 1385 } 1386 1387 tipc_node_lock(node); 1388 err = __tipc_nl_add_node(&msg, node); 1389 if (err) { 1390 last_addr = node->addr; 1391 tipc_node_unlock(node); 1392 goto out; 1393 } 1394 1395 tipc_node_unlock(node); 1396 } 1397 done = 1; 1398 out: 1399 cb->args[0] = done; 1400 cb->args[1] = last_addr; 1401 rcu_read_unlock(); 1402 1403 return skb->len; 1404 } 1405