1 /* 2 * net/tipc/link.c: TIPC link code 3 * 4 * Copyright (c) 1996-2007, 2012, Ericsson AB 5 * Copyright (c) 2004-2007, 2010-2013, 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 "port.h" 40 #include "name_distr.h" 41 #include "discover.h" 42 #include "config.h" 43 44 #include <linux/pkt_sched.h> 45 46 /* 47 * Error message prefixes 48 */ 49 static const char *link_co_err = "Link changeover error, "; 50 static const char *link_rst_msg = "Resetting link "; 51 static const char *link_unk_evt = "Unknown link event "; 52 53 /* 54 * Out-of-range value for link session numbers 55 */ 56 #define INVALID_SESSION 0x10000 57 58 /* 59 * Link state events: 60 */ 61 #define STARTING_EVT 856384768 /* link processing trigger */ 62 #define TRAFFIC_MSG_EVT 560815u /* rx'd ??? */ 63 #define TIMEOUT_EVT 560817u /* link timer expired */ 64 65 /* 66 * The following two 'message types' is really just implementation 67 * data conveniently stored in the message header. 68 * They must not be considered part of the protocol 69 */ 70 #define OPEN_MSG 0 71 #define CLOSED_MSG 1 72 73 /* 74 * State value stored in 'exp_msg_count' 75 */ 76 #define START_CHANGEOVER 100000u 77 78 /** 79 * struct tipc_link_name - deconstructed link name 80 * @addr_local: network address of node at this end 81 * @if_local: name of interface at this end 82 * @addr_peer: network address of node at far end 83 * @if_peer: name of interface at far end 84 */ 85 struct tipc_link_name { 86 u32 addr_local; 87 char if_local[TIPC_MAX_IF_NAME]; 88 u32 addr_peer; 89 char if_peer[TIPC_MAX_IF_NAME]; 90 }; 91 92 static void link_handle_out_of_seq_msg(struct tipc_link *l_ptr, 93 struct sk_buff *buf); 94 static void link_recv_proto_msg(struct tipc_link *l_ptr, struct sk_buff *buf); 95 static int link_recv_changeover_msg(struct tipc_link **l_ptr, 96 struct sk_buff **buf); 97 static void link_set_supervision_props(struct tipc_link *l_ptr, u32 tolerance); 98 static int link_send_sections_long(struct tipc_port *sender, 99 struct iovec const *msg_sect, 100 u32 num_sect, unsigned int total_len, 101 u32 destnode); 102 static void link_state_event(struct tipc_link *l_ptr, u32 event); 103 static void link_reset_statistics(struct tipc_link *l_ptr); 104 static void link_print(struct tipc_link *l_ptr, const char *str); 105 static void link_start(struct tipc_link *l_ptr); 106 static int link_send_long_buf(struct tipc_link *l_ptr, struct sk_buff *buf); 107 static void tipc_link_send_sync(struct tipc_link *l); 108 static void tipc_link_recv_sync(struct tipc_node *n, struct sk_buff *buf); 109 110 /* 111 * Simple link routines 112 */ 113 static unsigned int align(unsigned int i) 114 { 115 return (i + 3) & ~3u; 116 } 117 118 static void link_init_max_pkt(struct tipc_link *l_ptr) 119 { 120 u32 max_pkt; 121 122 max_pkt = (l_ptr->b_ptr->mtu & ~3); 123 if (max_pkt > MAX_MSG_SIZE) 124 max_pkt = MAX_MSG_SIZE; 125 126 l_ptr->max_pkt_target = max_pkt; 127 if (l_ptr->max_pkt_target < MAX_PKT_DEFAULT) 128 l_ptr->max_pkt = l_ptr->max_pkt_target; 129 else 130 l_ptr->max_pkt = MAX_PKT_DEFAULT; 131 132 l_ptr->max_pkt_probes = 0; 133 } 134 135 static u32 link_next_sent(struct tipc_link *l_ptr) 136 { 137 if (l_ptr->next_out) 138 return buf_seqno(l_ptr->next_out); 139 return mod(l_ptr->next_out_no); 140 } 141 142 static u32 link_last_sent(struct tipc_link *l_ptr) 143 { 144 return mod(link_next_sent(l_ptr) - 1); 145 } 146 147 /* 148 * Simple non-static link routines (i.e. referenced outside this file) 149 */ 150 int tipc_link_is_up(struct tipc_link *l_ptr) 151 { 152 if (!l_ptr) 153 return 0; 154 return link_working_working(l_ptr) || link_working_unknown(l_ptr); 155 } 156 157 int tipc_link_is_active(struct tipc_link *l_ptr) 158 { 159 return (l_ptr->owner->active_links[0] == l_ptr) || 160 (l_ptr->owner->active_links[1] == l_ptr); 161 } 162 163 /** 164 * link_name_validate - validate & (optionally) deconstruct tipc_link name 165 * @name: ptr to link name string 166 * @name_parts: ptr to area for link name components (or NULL if not needed) 167 * 168 * Returns 1 if link name is valid, otherwise 0. 169 */ 170 static int link_name_validate(const char *name, 171 struct tipc_link_name *name_parts) 172 { 173 char name_copy[TIPC_MAX_LINK_NAME]; 174 char *addr_local; 175 char *if_local; 176 char *addr_peer; 177 char *if_peer; 178 char dummy; 179 u32 z_local, c_local, n_local; 180 u32 z_peer, c_peer, n_peer; 181 u32 if_local_len; 182 u32 if_peer_len; 183 184 /* copy link name & ensure length is OK */ 185 name_copy[TIPC_MAX_LINK_NAME - 1] = 0; 186 /* need above in case non-Posix strncpy() doesn't pad with nulls */ 187 strncpy(name_copy, name, TIPC_MAX_LINK_NAME); 188 if (name_copy[TIPC_MAX_LINK_NAME - 1] != 0) 189 return 0; 190 191 /* ensure all component parts of link name are present */ 192 addr_local = name_copy; 193 if_local = strchr(addr_local, ':'); 194 if (if_local == NULL) 195 return 0; 196 *(if_local++) = 0; 197 addr_peer = strchr(if_local, '-'); 198 if (addr_peer == NULL) 199 return 0; 200 *(addr_peer++) = 0; 201 if_local_len = addr_peer - if_local; 202 if_peer = strchr(addr_peer, ':'); 203 if (if_peer == NULL) 204 return 0; 205 *(if_peer++) = 0; 206 if_peer_len = strlen(if_peer) + 1; 207 208 /* validate component parts of link name */ 209 if ((sscanf(addr_local, "%u.%u.%u%c", 210 &z_local, &c_local, &n_local, &dummy) != 3) || 211 (sscanf(addr_peer, "%u.%u.%u%c", 212 &z_peer, &c_peer, &n_peer, &dummy) != 3) || 213 (z_local > 255) || (c_local > 4095) || (n_local > 4095) || 214 (z_peer > 255) || (c_peer > 4095) || (n_peer > 4095) || 215 (if_local_len <= 1) || (if_local_len > TIPC_MAX_IF_NAME) || 216 (if_peer_len <= 1) || (if_peer_len > TIPC_MAX_IF_NAME)) 217 return 0; 218 219 /* return link name components, if necessary */ 220 if (name_parts) { 221 name_parts->addr_local = tipc_addr(z_local, c_local, n_local); 222 strcpy(name_parts->if_local, if_local); 223 name_parts->addr_peer = tipc_addr(z_peer, c_peer, n_peer); 224 strcpy(name_parts->if_peer, if_peer); 225 } 226 return 1; 227 } 228 229 /** 230 * link_timeout - handle expiration of link timer 231 * @l_ptr: pointer to link 232 * 233 * This routine must not grab "tipc_net_lock" to avoid a potential deadlock conflict 234 * with tipc_link_delete(). (There is no risk that the node will be deleted by 235 * another thread because tipc_link_delete() always cancels the link timer before 236 * tipc_node_delete() is called.) 237 */ 238 static void link_timeout(struct tipc_link *l_ptr) 239 { 240 tipc_node_lock(l_ptr->owner); 241 242 /* update counters used in statistical profiling of send traffic */ 243 l_ptr->stats.accu_queue_sz += l_ptr->out_queue_size; 244 l_ptr->stats.queue_sz_counts++; 245 246 if (l_ptr->first_out) { 247 struct tipc_msg *msg = buf_msg(l_ptr->first_out); 248 u32 length = msg_size(msg); 249 250 if ((msg_user(msg) == MSG_FRAGMENTER) && 251 (msg_type(msg) == FIRST_FRAGMENT)) { 252 length = msg_size(msg_get_wrapped(msg)); 253 } 254 if (length) { 255 l_ptr->stats.msg_lengths_total += length; 256 l_ptr->stats.msg_length_counts++; 257 if (length <= 64) 258 l_ptr->stats.msg_length_profile[0]++; 259 else if (length <= 256) 260 l_ptr->stats.msg_length_profile[1]++; 261 else if (length <= 1024) 262 l_ptr->stats.msg_length_profile[2]++; 263 else if (length <= 4096) 264 l_ptr->stats.msg_length_profile[3]++; 265 else if (length <= 16384) 266 l_ptr->stats.msg_length_profile[4]++; 267 else if (length <= 32768) 268 l_ptr->stats.msg_length_profile[5]++; 269 else 270 l_ptr->stats.msg_length_profile[6]++; 271 } 272 } 273 274 /* do all other link processing performed on a periodic basis */ 275 276 link_state_event(l_ptr, TIMEOUT_EVT); 277 278 if (l_ptr->next_out) 279 tipc_link_push_queue(l_ptr); 280 281 tipc_node_unlock(l_ptr->owner); 282 } 283 284 static void link_set_timer(struct tipc_link *l_ptr, u32 time) 285 { 286 k_start_timer(&l_ptr->timer, time); 287 } 288 289 /** 290 * tipc_link_create - create a new link 291 * @n_ptr: pointer to associated node 292 * @b_ptr: pointer to associated bearer 293 * @media_addr: media address to use when sending messages over link 294 * 295 * Returns pointer to link. 296 */ 297 struct tipc_link *tipc_link_create(struct tipc_node *n_ptr, 298 struct tipc_bearer *b_ptr, 299 const struct tipc_media_addr *media_addr) 300 { 301 struct tipc_link *l_ptr; 302 struct tipc_msg *msg; 303 char *if_name; 304 char addr_string[16]; 305 u32 peer = n_ptr->addr; 306 307 if (n_ptr->link_cnt >= 2) { 308 tipc_addr_string_fill(addr_string, n_ptr->addr); 309 pr_err("Attempt to establish third link to %s\n", addr_string); 310 return NULL; 311 } 312 313 if (n_ptr->links[b_ptr->identity]) { 314 tipc_addr_string_fill(addr_string, n_ptr->addr); 315 pr_err("Attempt to establish second link on <%s> to %s\n", 316 b_ptr->name, addr_string); 317 return NULL; 318 } 319 320 l_ptr = kzalloc(sizeof(*l_ptr), GFP_ATOMIC); 321 if (!l_ptr) { 322 pr_warn("Link creation failed, no memory\n"); 323 return NULL; 324 } 325 326 l_ptr->addr = peer; 327 if_name = strchr(b_ptr->name, ':') + 1; 328 sprintf(l_ptr->name, "%u.%u.%u:%s-%u.%u.%u:unknown", 329 tipc_zone(tipc_own_addr), tipc_cluster(tipc_own_addr), 330 tipc_node(tipc_own_addr), 331 if_name, 332 tipc_zone(peer), tipc_cluster(peer), tipc_node(peer)); 333 /* note: peer i/f name is updated by reset/activate message */ 334 memcpy(&l_ptr->media_addr, media_addr, sizeof(*media_addr)); 335 l_ptr->owner = n_ptr; 336 l_ptr->checkpoint = 1; 337 l_ptr->peer_session = INVALID_SESSION; 338 l_ptr->b_ptr = b_ptr; 339 link_set_supervision_props(l_ptr, b_ptr->tolerance); 340 l_ptr->state = RESET_UNKNOWN; 341 342 l_ptr->pmsg = (struct tipc_msg *)&l_ptr->proto_msg; 343 msg = l_ptr->pmsg; 344 tipc_msg_init(msg, LINK_PROTOCOL, RESET_MSG, INT_H_SIZE, l_ptr->addr); 345 msg_set_size(msg, sizeof(l_ptr->proto_msg)); 346 msg_set_session(msg, (tipc_random & 0xffff)); 347 msg_set_bearer_id(msg, b_ptr->identity); 348 strcpy((char *)msg_data(msg), if_name); 349 350 l_ptr->priority = b_ptr->priority; 351 tipc_link_set_queue_limits(l_ptr, b_ptr->window); 352 353 link_init_max_pkt(l_ptr); 354 355 l_ptr->next_out_no = 1; 356 INIT_LIST_HEAD(&l_ptr->waiting_ports); 357 358 link_reset_statistics(l_ptr); 359 360 tipc_node_attach_link(n_ptr, l_ptr); 361 362 k_init_timer(&l_ptr->timer, (Handler)link_timeout, (unsigned long)l_ptr); 363 list_add_tail(&l_ptr->link_list, &b_ptr->links); 364 tipc_k_signal((Handler)link_start, (unsigned long)l_ptr); 365 366 return l_ptr; 367 } 368 369 /** 370 * tipc_link_delete - delete a link 371 * @l_ptr: pointer to link 372 * 373 * Note: 'tipc_net_lock' is write_locked, bearer is locked. 374 * This routine must not grab the node lock until after link timer cancellation 375 * to avoid a potential deadlock situation. 376 */ 377 void tipc_link_delete(struct tipc_link *l_ptr) 378 { 379 if (!l_ptr) { 380 pr_err("Attempt to delete non-existent link\n"); 381 return; 382 } 383 384 k_cancel_timer(&l_ptr->timer); 385 386 tipc_node_lock(l_ptr->owner); 387 tipc_link_reset(l_ptr); 388 tipc_node_detach_link(l_ptr->owner, l_ptr); 389 tipc_link_stop(l_ptr); 390 list_del_init(&l_ptr->link_list); 391 tipc_node_unlock(l_ptr->owner); 392 k_term_timer(&l_ptr->timer); 393 kfree(l_ptr); 394 } 395 396 static void link_start(struct tipc_link *l_ptr) 397 { 398 tipc_node_lock(l_ptr->owner); 399 link_state_event(l_ptr, STARTING_EVT); 400 tipc_node_unlock(l_ptr->owner); 401 } 402 403 /** 404 * link_schedule_port - schedule port for deferred sending 405 * @l_ptr: pointer to link 406 * @origport: reference to sending port 407 * @sz: amount of data to be sent 408 * 409 * Schedules port for renewed sending of messages after link congestion 410 * has abated. 411 */ 412 static int link_schedule_port(struct tipc_link *l_ptr, u32 origport, u32 sz) 413 { 414 struct tipc_port *p_ptr; 415 416 spin_lock_bh(&tipc_port_list_lock); 417 p_ptr = tipc_port_lock(origport); 418 if (p_ptr) { 419 if (!p_ptr->wakeup) 420 goto exit; 421 if (!list_empty(&p_ptr->wait_list)) 422 goto exit; 423 p_ptr->congested = 1; 424 p_ptr->waiting_pkts = 1 + ((sz - 1) / l_ptr->max_pkt); 425 list_add_tail(&p_ptr->wait_list, &l_ptr->waiting_ports); 426 l_ptr->stats.link_congs++; 427 exit: 428 tipc_port_unlock(p_ptr); 429 } 430 spin_unlock_bh(&tipc_port_list_lock); 431 return -ELINKCONG; 432 } 433 434 void tipc_link_wakeup_ports(struct tipc_link *l_ptr, int all) 435 { 436 struct tipc_port *p_ptr; 437 struct tipc_port *temp_p_ptr; 438 int win = l_ptr->queue_limit[0] - l_ptr->out_queue_size; 439 440 if (all) 441 win = 100000; 442 if (win <= 0) 443 return; 444 if (!spin_trylock_bh(&tipc_port_list_lock)) 445 return; 446 if (link_congested(l_ptr)) 447 goto exit; 448 list_for_each_entry_safe(p_ptr, temp_p_ptr, &l_ptr->waiting_ports, 449 wait_list) { 450 if (win <= 0) 451 break; 452 list_del_init(&p_ptr->wait_list); 453 spin_lock_bh(p_ptr->lock); 454 p_ptr->congested = 0; 455 p_ptr->wakeup(p_ptr); 456 win -= p_ptr->waiting_pkts; 457 spin_unlock_bh(p_ptr->lock); 458 } 459 460 exit: 461 spin_unlock_bh(&tipc_port_list_lock); 462 } 463 464 /** 465 * link_release_outqueue - purge link's outbound message queue 466 * @l_ptr: pointer to link 467 */ 468 static void link_release_outqueue(struct tipc_link *l_ptr) 469 { 470 struct sk_buff *buf = l_ptr->first_out; 471 struct sk_buff *next; 472 473 while (buf) { 474 next = buf->next; 475 kfree_skb(buf); 476 buf = next; 477 } 478 l_ptr->first_out = NULL; 479 l_ptr->out_queue_size = 0; 480 } 481 482 /** 483 * tipc_link_reset_fragments - purge link's inbound message fragments queue 484 * @l_ptr: pointer to link 485 */ 486 void tipc_link_reset_fragments(struct tipc_link *l_ptr) 487 { 488 struct sk_buff *buf = l_ptr->defragm_buf; 489 struct sk_buff *next; 490 491 while (buf) { 492 next = buf->next; 493 kfree_skb(buf); 494 buf = next; 495 } 496 l_ptr->defragm_buf = NULL; 497 } 498 499 /** 500 * tipc_link_stop - purge all inbound and outbound messages associated with link 501 * @l_ptr: pointer to link 502 */ 503 void tipc_link_stop(struct tipc_link *l_ptr) 504 { 505 struct sk_buff *buf; 506 struct sk_buff *next; 507 508 buf = l_ptr->oldest_deferred_in; 509 while (buf) { 510 next = buf->next; 511 kfree_skb(buf); 512 buf = next; 513 } 514 515 buf = l_ptr->first_out; 516 while (buf) { 517 next = buf->next; 518 kfree_skb(buf); 519 buf = next; 520 } 521 522 tipc_link_reset_fragments(l_ptr); 523 524 kfree_skb(l_ptr->proto_msg_queue); 525 l_ptr->proto_msg_queue = NULL; 526 } 527 528 void tipc_link_reset(struct tipc_link *l_ptr) 529 { 530 struct sk_buff *buf; 531 u32 prev_state = l_ptr->state; 532 u32 checkpoint = l_ptr->next_in_no; 533 int was_active_link = tipc_link_is_active(l_ptr); 534 535 msg_set_session(l_ptr->pmsg, ((msg_session(l_ptr->pmsg) + 1) & 0xffff)); 536 537 /* Link is down, accept any session */ 538 l_ptr->peer_session = INVALID_SESSION; 539 540 /* Prepare for max packet size negotiation */ 541 link_init_max_pkt(l_ptr); 542 543 l_ptr->state = RESET_UNKNOWN; 544 545 if ((prev_state == RESET_UNKNOWN) || (prev_state == RESET_RESET)) 546 return; 547 548 tipc_node_link_down(l_ptr->owner, l_ptr); 549 tipc_bearer_remove_dest(l_ptr->b_ptr, l_ptr->addr); 550 551 if (was_active_link && tipc_node_active_links(l_ptr->owner) && 552 l_ptr->owner->permit_changeover) { 553 l_ptr->reset_checkpoint = checkpoint; 554 l_ptr->exp_msg_count = START_CHANGEOVER; 555 } 556 557 /* Clean up all queues: */ 558 link_release_outqueue(l_ptr); 559 kfree_skb(l_ptr->proto_msg_queue); 560 l_ptr->proto_msg_queue = NULL; 561 buf = l_ptr->oldest_deferred_in; 562 while (buf) { 563 struct sk_buff *next = buf->next; 564 kfree_skb(buf); 565 buf = next; 566 } 567 if (!list_empty(&l_ptr->waiting_ports)) 568 tipc_link_wakeup_ports(l_ptr, 1); 569 570 l_ptr->retransm_queue_head = 0; 571 l_ptr->retransm_queue_size = 0; 572 l_ptr->last_out = NULL; 573 l_ptr->first_out = NULL; 574 l_ptr->next_out = NULL; 575 l_ptr->unacked_window = 0; 576 l_ptr->checkpoint = 1; 577 l_ptr->next_out_no = 1; 578 l_ptr->deferred_inqueue_sz = 0; 579 l_ptr->oldest_deferred_in = NULL; 580 l_ptr->newest_deferred_in = NULL; 581 l_ptr->fsm_msg_cnt = 0; 582 l_ptr->stale_count = 0; 583 link_reset_statistics(l_ptr); 584 } 585 586 587 static void link_activate(struct tipc_link *l_ptr) 588 { 589 l_ptr->next_in_no = l_ptr->stats.recv_info = 1; 590 tipc_node_link_up(l_ptr->owner, l_ptr); 591 tipc_bearer_add_dest(l_ptr->b_ptr, l_ptr->addr); 592 } 593 594 /** 595 * link_state_event - link finite state machine 596 * @l_ptr: pointer to link 597 * @event: state machine event to process 598 */ 599 static void link_state_event(struct tipc_link *l_ptr, unsigned int event) 600 { 601 struct tipc_link *other; 602 u32 cont_intv = l_ptr->continuity_interval; 603 604 if (!l_ptr->started && (event != STARTING_EVT)) 605 return; /* Not yet. */ 606 607 if (link_blocked(l_ptr)) { 608 if (event == TIMEOUT_EVT) 609 link_set_timer(l_ptr, cont_intv); 610 return; /* Changeover going on */ 611 } 612 613 switch (l_ptr->state) { 614 case WORKING_WORKING: 615 switch (event) { 616 case TRAFFIC_MSG_EVT: 617 case ACTIVATE_MSG: 618 break; 619 case TIMEOUT_EVT: 620 if (l_ptr->next_in_no != l_ptr->checkpoint) { 621 l_ptr->checkpoint = l_ptr->next_in_no; 622 if (tipc_bclink_acks_missing(l_ptr->owner)) { 623 tipc_link_send_proto_msg(l_ptr, STATE_MSG, 624 0, 0, 0, 0, 0); 625 l_ptr->fsm_msg_cnt++; 626 } else if (l_ptr->max_pkt < l_ptr->max_pkt_target) { 627 tipc_link_send_proto_msg(l_ptr, STATE_MSG, 628 1, 0, 0, 0, 0); 629 l_ptr->fsm_msg_cnt++; 630 } 631 link_set_timer(l_ptr, cont_intv); 632 break; 633 } 634 l_ptr->state = WORKING_UNKNOWN; 635 l_ptr->fsm_msg_cnt = 0; 636 tipc_link_send_proto_msg(l_ptr, STATE_MSG, 1, 0, 0, 0, 0); 637 l_ptr->fsm_msg_cnt++; 638 link_set_timer(l_ptr, cont_intv / 4); 639 break; 640 case RESET_MSG: 641 pr_info("%s<%s>, requested by peer\n", link_rst_msg, 642 l_ptr->name); 643 tipc_link_reset(l_ptr); 644 l_ptr->state = RESET_RESET; 645 l_ptr->fsm_msg_cnt = 0; 646 tipc_link_send_proto_msg(l_ptr, ACTIVATE_MSG, 0, 0, 0, 0, 0); 647 l_ptr->fsm_msg_cnt++; 648 link_set_timer(l_ptr, cont_intv); 649 break; 650 default: 651 pr_err("%s%u in WW state\n", link_unk_evt, event); 652 } 653 break; 654 case WORKING_UNKNOWN: 655 switch (event) { 656 case TRAFFIC_MSG_EVT: 657 case ACTIVATE_MSG: 658 l_ptr->state = WORKING_WORKING; 659 l_ptr->fsm_msg_cnt = 0; 660 link_set_timer(l_ptr, cont_intv); 661 break; 662 case RESET_MSG: 663 pr_info("%s<%s>, requested by peer while probing\n", 664 link_rst_msg, l_ptr->name); 665 tipc_link_reset(l_ptr); 666 l_ptr->state = RESET_RESET; 667 l_ptr->fsm_msg_cnt = 0; 668 tipc_link_send_proto_msg(l_ptr, ACTIVATE_MSG, 0, 0, 0, 0, 0); 669 l_ptr->fsm_msg_cnt++; 670 link_set_timer(l_ptr, cont_intv); 671 break; 672 case TIMEOUT_EVT: 673 if (l_ptr->next_in_no != l_ptr->checkpoint) { 674 l_ptr->state = WORKING_WORKING; 675 l_ptr->fsm_msg_cnt = 0; 676 l_ptr->checkpoint = l_ptr->next_in_no; 677 if (tipc_bclink_acks_missing(l_ptr->owner)) { 678 tipc_link_send_proto_msg(l_ptr, STATE_MSG, 679 0, 0, 0, 0, 0); 680 l_ptr->fsm_msg_cnt++; 681 } 682 link_set_timer(l_ptr, cont_intv); 683 } else if (l_ptr->fsm_msg_cnt < l_ptr->abort_limit) { 684 tipc_link_send_proto_msg(l_ptr, STATE_MSG, 685 1, 0, 0, 0, 0); 686 l_ptr->fsm_msg_cnt++; 687 link_set_timer(l_ptr, cont_intv / 4); 688 } else { /* Link has failed */ 689 pr_warn("%s<%s>, peer not responding\n", 690 link_rst_msg, l_ptr->name); 691 tipc_link_reset(l_ptr); 692 l_ptr->state = RESET_UNKNOWN; 693 l_ptr->fsm_msg_cnt = 0; 694 tipc_link_send_proto_msg(l_ptr, RESET_MSG, 695 0, 0, 0, 0, 0); 696 l_ptr->fsm_msg_cnt++; 697 link_set_timer(l_ptr, cont_intv); 698 } 699 break; 700 default: 701 pr_err("%s%u in WU state\n", link_unk_evt, event); 702 } 703 break; 704 case RESET_UNKNOWN: 705 switch (event) { 706 case TRAFFIC_MSG_EVT: 707 break; 708 case ACTIVATE_MSG: 709 other = l_ptr->owner->active_links[0]; 710 if (other && link_working_unknown(other)) 711 break; 712 l_ptr->state = WORKING_WORKING; 713 l_ptr->fsm_msg_cnt = 0; 714 link_activate(l_ptr); 715 tipc_link_send_proto_msg(l_ptr, STATE_MSG, 1, 0, 0, 0, 0); 716 l_ptr->fsm_msg_cnt++; 717 if (l_ptr->owner->working_links == 1) 718 tipc_link_send_sync(l_ptr); 719 link_set_timer(l_ptr, cont_intv); 720 break; 721 case RESET_MSG: 722 l_ptr->state = RESET_RESET; 723 l_ptr->fsm_msg_cnt = 0; 724 tipc_link_send_proto_msg(l_ptr, ACTIVATE_MSG, 1, 0, 0, 0, 0); 725 l_ptr->fsm_msg_cnt++; 726 link_set_timer(l_ptr, cont_intv); 727 break; 728 case STARTING_EVT: 729 l_ptr->started = 1; 730 /* fall through */ 731 case TIMEOUT_EVT: 732 tipc_link_send_proto_msg(l_ptr, RESET_MSG, 0, 0, 0, 0, 0); 733 l_ptr->fsm_msg_cnt++; 734 link_set_timer(l_ptr, cont_intv); 735 break; 736 default: 737 pr_err("%s%u in RU state\n", link_unk_evt, event); 738 } 739 break; 740 case RESET_RESET: 741 switch (event) { 742 case TRAFFIC_MSG_EVT: 743 case ACTIVATE_MSG: 744 other = l_ptr->owner->active_links[0]; 745 if (other && link_working_unknown(other)) 746 break; 747 l_ptr->state = WORKING_WORKING; 748 l_ptr->fsm_msg_cnt = 0; 749 link_activate(l_ptr); 750 tipc_link_send_proto_msg(l_ptr, STATE_MSG, 1, 0, 0, 0, 0); 751 l_ptr->fsm_msg_cnt++; 752 if (l_ptr->owner->working_links == 1) 753 tipc_link_send_sync(l_ptr); 754 link_set_timer(l_ptr, cont_intv); 755 break; 756 case RESET_MSG: 757 break; 758 case TIMEOUT_EVT: 759 tipc_link_send_proto_msg(l_ptr, ACTIVATE_MSG, 0, 0, 0, 0, 0); 760 l_ptr->fsm_msg_cnt++; 761 link_set_timer(l_ptr, cont_intv); 762 break; 763 default: 764 pr_err("%s%u in RR state\n", link_unk_evt, event); 765 } 766 break; 767 default: 768 pr_err("Unknown link state %u/%u\n", l_ptr->state, event); 769 } 770 } 771 772 /* 773 * link_bundle_buf(): Append contents of a buffer to 774 * the tail of an existing one. 775 */ 776 static int link_bundle_buf(struct tipc_link *l_ptr, struct sk_buff *bundler, 777 struct sk_buff *buf) 778 { 779 struct tipc_msg *bundler_msg = buf_msg(bundler); 780 struct tipc_msg *msg = buf_msg(buf); 781 u32 size = msg_size(msg); 782 u32 bundle_size = msg_size(bundler_msg); 783 u32 to_pos = align(bundle_size); 784 u32 pad = to_pos - bundle_size; 785 786 if (msg_user(bundler_msg) != MSG_BUNDLER) 787 return 0; 788 if (msg_type(bundler_msg) != OPEN_MSG) 789 return 0; 790 if (skb_tailroom(bundler) < (pad + size)) 791 return 0; 792 if (l_ptr->max_pkt < (to_pos + size)) 793 return 0; 794 795 skb_put(bundler, pad + size); 796 skb_copy_to_linear_data_offset(bundler, to_pos, buf->data, size); 797 msg_set_size(bundler_msg, to_pos + size); 798 msg_set_msgcnt(bundler_msg, msg_msgcnt(bundler_msg) + 1); 799 kfree_skb(buf); 800 l_ptr->stats.sent_bundled++; 801 return 1; 802 } 803 804 static void link_add_to_outqueue(struct tipc_link *l_ptr, 805 struct sk_buff *buf, 806 struct tipc_msg *msg) 807 { 808 u32 ack = mod(l_ptr->next_in_no - 1); 809 u32 seqno = mod(l_ptr->next_out_no++); 810 811 msg_set_word(msg, 2, ((ack << 16) | seqno)); 812 msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in); 813 buf->next = NULL; 814 if (l_ptr->first_out) { 815 l_ptr->last_out->next = buf; 816 l_ptr->last_out = buf; 817 } else 818 l_ptr->first_out = l_ptr->last_out = buf; 819 820 l_ptr->out_queue_size++; 821 if (l_ptr->out_queue_size > l_ptr->stats.max_queue_sz) 822 l_ptr->stats.max_queue_sz = l_ptr->out_queue_size; 823 } 824 825 static void link_add_chain_to_outqueue(struct tipc_link *l_ptr, 826 struct sk_buff *buf_chain, 827 u32 long_msgno) 828 { 829 struct sk_buff *buf; 830 struct tipc_msg *msg; 831 832 if (!l_ptr->next_out) 833 l_ptr->next_out = buf_chain; 834 while (buf_chain) { 835 buf = buf_chain; 836 buf_chain = buf_chain->next; 837 838 msg = buf_msg(buf); 839 msg_set_long_msgno(msg, long_msgno); 840 link_add_to_outqueue(l_ptr, buf, msg); 841 } 842 } 843 844 /* 845 * tipc_link_send_buf() is the 'full path' for messages, called from 846 * inside TIPC when the 'fast path' in tipc_send_buf 847 * has failed, and from link_send() 848 */ 849 int tipc_link_send_buf(struct tipc_link *l_ptr, struct sk_buff *buf) 850 { 851 struct tipc_msg *msg = buf_msg(buf); 852 u32 size = msg_size(msg); 853 u32 dsz = msg_data_sz(msg); 854 u32 queue_size = l_ptr->out_queue_size; 855 u32 imp = tipc_msg_tot_importance(msg); 856 u32 queue_limit = l_ptr->queue_limit[imp]; 857 u32 max_packet = l_ptr->max_pkt; 858 859 /* Match msg importance against queue limits: */ 860 if (unlikely(queue_size >= queue_limit)) { 861 if (imp <= TIPC_CRITICAL_IMPORTANCE) { 862 link_schedule_port(l_ptr, msg_origport(msg), size); 863 kfree_skb(buf); 864 return -ELINKCONG; 865 } 866 kfree_skb(buf); 867 if (imp > CONN_MANAGER) { 868 pr_warn("%s<%s>, send queue full", link_rst_msg, 869 l_ptr->name); 870 tipc_link_reset(l_ptr); 871 } 872 return dsz; 873 } 874 875 /* Fragmentation needed ? */ 876 if (size > max_packet) 877 return link_send_long_buf(l_ptr, buf); 878 879 /* Packet can be queued or sent. */ 880 if (likely(!tipc_bearer_blocked(l_ptr->b_ptr) && 881 !link_congested(l_ptr))) { 882 link_add_to_outqueue(l_ptr, buf, msg); 883 884 tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr); 885 l_ptr->unacked_window = 0; 886 return dsz; 887 } 888 /* Congestion: can message be bundled ? */ 889 if ((msg_user(msg) != CHANGEOVER_PROTOCOL) && 890 (msg_user(msg) != MSG_FRAGMENTER)) { 891 892 /* Try adding message to an existing bundle */ 893 if (l_ptr->next_out && 894 link_bundle_buf(l_ptr, l_ptr->last_out, buf)) 895 return dsz; 896 897 /* Try creating a new bundle */ 898 if (size <= max_packet * 2 / 3) { 899 struct sk_buff *bundler = tipc_buf_acquire(max_packet); 900 struct tipc_msg bundler_hdr; 901 902 if (bundler) { 903 tipc_msg_init(&bundler_hdr, MSG_BUNDLER, OPEN_MSG, 904 INT_H_SIZE, l_ptr->addr); 905 skb_copy_to_linear_data(bundler, &bundler_hdr, 906 INT_H_SIZE); 907 skb_trim(bundler, INT_H_SIZE); 908 link_bundle_buf(l_ptr, bundler, buf); 909 buf = bundler; 910 msg = buf_msg(buf); 911 l_ptr->stats.sent_bundles++; 912 } 913 } 914 } 915 if (!l_ptr->next_out) 916 l_ptr->next_out = buf; 917 link_add_to_outqueue(l_ptr, buf, msg); 918 return dsz; 919 } 920 921 /* 922 * tipc_link_send(): same as tipc_link_send_buf(), but the link to use has 923 * not been selected yet, and the the owner node is not locked 924 * Called by TIPC internal users, e.g. the name distributor 925 */ 926 int tipc_link_send(struct sk_buff *buf, u32 dest, u32 selector) 927 { 928 struct tipc_link *l_ptr; 929 struct tipc_node *n_ptr; 930 int res = -ELINKCONG; 931 932 read_lock_bh(&tipc_net_lock); 933 n_ptr = tipc_node_find(dest); 934 if (n_ptr) { 935 tipc_node_lock(n_ptr); 936 l_ptr = n_ptr->active_links[selector & 1]; 937 if (l_ptr) 938 res = tipc_link_send_buf(l_ptr, buf); 939 else 940 kfree_skb(buf); 941 tipc_node_unlock(n_ptr); 942 } else { 943 kfree_skb(buf); 944 } 945 read_unlock_bh(&tipc_net_lock); 946 return res; 947 } 948 949 /* 950 * tipc_link_send_sync - synchronize broadcast link endpoints. 951 * 952 * Give a newly added peer node the sequence number where it should 953 * start receiving and acking broadcast packets. 954 * 955 * Called with node locked 956 */ 957 static void tipc_link_send_sync(struct tipc_link *l) 958 { 959 struct sk_buff *buf; 960 struct tipc_msg *msg; 961 962 buf = tipc_buf_acquire(INT_H_SIZE); 963 if (!buf) 964 return; 965 966 msg = buf_msg(buf); 967 tipc_msg_init(msg, BCAST_PROTOCOL, STATE_MSG, INT_H_SIZE, l->addr); 968 msg_set_last_bcast(msg, l->owner->bclink.acked); 969 link_add_chain_to_outqueue(l, buf, 0); 970 tipc_link_push_queue(l); 971 } 972 973 /* 974 * tipc_link_recv_sync - synchronize broadcast link endpoints. 975 * Receive the sequence number where we should start receiving and 976 * acking broadcast packets from a newly added peer node, and open 977 * up for reception of such packets. 978 * 979 * Called with node locked 980 */ 981 static void tipc_link_recv_sync(struct tipc_node *n, struct sk_buff *buf) 982 { 983 struct tipc_msg *msg = buf_msg(buf); 984 985 n->bclink.last_sent = n->bclink.last_in = msg_last_bcast(msg); 986 n->bclink.recv_permitted = true; 987 kfree_skb(buf); 988 } 989 990 /* 991 * tipc_link_send_names - send name table entries to new neighbor 992 * 993 * Send routine for bulk delivery of name table messages when contact 994 * with a new neighbor occurs. No link congestion checking is performed 995 * because name table messages *must* be delivered. The messages must be 996 * small enough not to require fragmentation. 997 * Called without any locks held. 998 */ 999 void tipc_link_send_names(struct list_head *message_list, u32 dest) 1000 { 1001 struct tipc_node *n_ptr; 1002 struct tipc_link *l_ptr; 1003 struct sk_buff *buf; 1004 struct sk_buff *temp_buf; 1005 1006 if (list_empty(message_list)) 1007 return; 1008 1009 read_lock_bh(&tipc_net_lock); 1010 n_ptr = tipc_node_find(dest); 1011 if (n_ptr) { 1012 tipc_node_lock(n_ptr); 1013 l_ptr = n_ptr->active_links[0]; 1014 if (l_ptr) { 1015 /* convert circular list to linear list */ 1016 ((struct sk_buff *)message_list->prev)->next = NULL; 1017 link_add_chain_to_outqueue(l_ptr, 1018 (struct sk_buff *)message_list->next, 0); 1019 tipc_link_push_queue(l_ptr); 1020 INIT_LIST_HEAD(message_list); 1021 } 1022 tipc_node_unlock(n_ptr); 1023 } 1024 read_unlock_bh(&tipc_net_lock); 1025 1026 /* discard the messages if they couldn't be sent */ 1027 list_for_each_safe(buf, temp_buf, ((struct sk_buff *)message_list)) { 1028 list_del((struct list_head *)buf); 1029 kfree_skb(buf); 1030 } 1031 } 1032 1033 /* 1034 * link_send_buf_fast: Entry for data messages where the 1035 * destination link is known and the header is complete, 1036 * inclusive total message length. Very time critical. 1037 * Link is locked. Returns user data length. 1038 */ 1039 static int link_send_buf_fast(struct tipc_link *l_ptr, struct sk_buff *buf, 1040 u32 *used_max_pkt) 1041 { 1042 struct tipc_msg *msg = buf_msg(buf); 1043 int res = msg_data_sz(msg); 1044 1045 if (likely(!link_congested(l_ptr))) { 1046 if (likely(msg_size(msg) <= l_ptr->max_pkt)) { 1047 if (likely(!tipc_bearer_blocked(l_ptr->b_ptr))) { 1048 link_add_to_outqueue(l_ptr, buf, msg); 1049 tipc_bearer_send(l_ptr->b_ptr, buf, 1050 &l_ptr->media_addr); 1051 l_ptr->unacked_window = 0; 1052 return res; 1053 } 1054 } else 1055 *used_max_pkt = l_ptr->max_pkt; 1056 } 1057 return tipc_link_send_buf(l_ptr, buf); /* All other cases */ 1058 } 1059 1060 /* 1061 * tipc_link_send_sections_fast: Entry for messages where the 1062 * destination processor is known and the header is complete, 1063 * except for total message length. 1064 * Returns user data length or errno. 1065 */ 1066 int tipc_link_send_sections_fast(struct tipc_port *sender, 1067 struct iovec const *msg_sect, 1068 const u32 num_sect, unsigned int total_len, 1069 u32 destaddr) 1070 { 1071 struct tipc_msg *hdr = &sender->phdr; 1072 struct tipc_link *l_ptr; 1073 struct sk_buff *buf; 1074 struct tipc_node *node; 1075 int res; 1076 u32 selector = msg_origport(hdr) & 1; 1077 1078 again: 1079 /* 1080 * Try building message using port's max_pkt hint. 1081 * (Must not hold any locks while building message.) 1082 */ 1083 res = tipc_msg_build(hdr, msg_sect, num_sect, total_len, 1084 sender->max_pkt, &buf); 1085 /* Exit if build request was invalid */ 1086 if (unlikely(res < 0)) 1087 return res; 1088 1089 read_lock_bh(&tipc_net_lock); 1090 node = tipc_node_find(destaddr); 1091 if (likely(node)) { 1092 tipc_node_lock(node); 1093 l_ptr = node->active_links[selector]; 1094 if (likely(l_ptr)) { 1095 if (likely(buf)) { 1096 res = link_send_buf_fast(l_ptr, buf, 1097 &sender->max_pkt); 1098 exit: 1099 tipc_node_unlock(node); 1100 read_unlock_bh(&tipc_net_lock); 1101 return res; 1102 } 1103 1104 /* Exit if link (or bearer) is congested */ 1105 if (link_congested(l_ptr) || 1106 tipc_bearer_blocked(l_ptr->b_ptr)) { 1107 res = link_schedule_port(l_ptr, 1108 sender->ref, res); 1109 goto exit; 1110 } 1111 1112 /* 1113 * Message size exceeds max_pkt hint; update hint, 1114 * then re-try fast path or fragment the message 1115 */ 1116 sender->max_pkt = l_ptr->max_pkt; 1117 tipc_node_unlock(node); 1118 read_unlock_bh(&tipc_net_lock); 1119 1120 1121 if ((msg_hdr_sz(hdr) + res) <= sender->max_pkt) 1122 goto again; 1123 1124 return link_send_sections_long(sender, msg_sect, 1125 num_sect, total_len, 1126 destaddr); 1127 } 1128 tipc_node_unlock(node); 1129 } 1130 read_unlock_bh(&tipc_net_lock); 1131 1132 /* Couldn't find a link to the destination node */ 1133 if (buf) 1134 return tipc_reject_msg(buf, TIPC_ERR_NO_NODE); 1135 if (res >= 0) 1136 return tipc_port_reject_sections(sender, hdr, msg_sect, num_sect, 1137 total_len, TIPC_ERR_NO_NODE); 1138 return res; 1139 } 1140 1141 /* 1142 * link_send_sections_long(): Entry for long messages where the 1143 * destination node is known and the header is complete, 1144 * inclusive total message length. 1145 * Link and bearer congestion status have been checked to be ok, 1146 * and are ignored if they change. 1147 * 1148 * Note that fragments do not use the full link MTU so that they won't have 1149 * to undergo refragmentation if link changeover causes them to be sent 1150 * over another link with an additional tunnel header added as prefix. 1151 * (Refragmentation will still occur if the other link has a smaller MTU.) 1152 * 1153 * Returns user data length or errno. 1154 */ 1155 static int link_send_sections_long(struct tipc_port *sender, 1156 struct iovec const *msg_sect, 1157 u32 num_sect, unsigned int total_len, 1158 u32 destaddr) 1159 { 1160 struct tipc_link *l_ptr; 1161 struct tipc_node *node; 1162 struct tipc_msg *hdr = &sender->phdr; 1163 u32 dsz = total_len; 1164 u32 max_pkt, fragm_sz, rest; 1165 struct tipc_msg fragm_hdr; 1166 struct sk_buff *buf, *buf_chain, *prev; 1167 u32 fragm_crs, fragm_rest, hsz, sect_rest; 1168 const unchar *sect_crs; 1169 int curr_sect; 1170 u32 fragm_no; 1171 int res = 0; 1172 1173 again: 1174 fragm_no = 1; 1175 max_pkt = sender->max_pkt - INT_H_SIZE; 1176 /* leave room for tunnel header in case of link changeover */ 1177 fragm_sz = max_pkt - INT_H_SIZE; 1178 /* leave room for fragmentation header in each fragment */ 1179 rest = dsz; 1180 fragm_crs = 0; 1181 fragm_rest = 0; 1182 sect_rest = 0; 1183 sect_crs = NULL; 1184 curr_sect = -1; 1185 1186 /* Prepare reusable fragment header */ 1187 tipc_msg_init(&fragm_hdr, MSG_FRAGMENTER, FIRST_FRAGMENT, 1188 INT_H_SIZE, msg_destnode(hdr)); 1189 msg_set_size(&fragm_hdr, max_pkt); 1190 msg_set_fragm_no(&fragm_hdr, 1); 1191 1192 /* Prepare header of first fragment */ 1193 buf_chain = buf = tipc_buf_acquire(max_pkt); 1194 if (!buf) 1195 return -ENOMEM; 1196 buf->next = NULL; 1197 skb_copy_to_linear_data(buf, &fragm_hdr, INT_H_SIZE); 1198 hsz = msg_hdr_sz(hdr); 1199 skb_copy_to_linear_data_offset(buf, INT_H_SIZE, hdr, hsz); 1200 1201 /* Chop up message */ 1202 fragm_crs = INT_H_SIZE + hsz; 1203 fragm_rest = fragm_sz - hsz; 1204 1205 do { /* For all sections */ 1206 u32 sz; 1207 1208 if (!sect_rest) { 1209 sect_rest = msg_sect[++curr_sect].iov_len; 1210 sect_crs = (const unchar *)msg_sect[curr_sect].iov_base; 1211 } 1212 1213 if (sect_rest < fragm_rest) 1214 sz = sect_rest; 1215 else 1216 sz = fragm_rest; 1217 1218 if (copy_from_user(buf->data + fragm_crs, sect_crs, sz)) { 1219 res = -EFAULT; 1220 error: 1221 for (; buf_chain; buf_chain = buf) { 1222 buf = buf_chain->next; 1223 kfree_skb(buf_chain); 1224 } 1225 return res; 1226 } 1227 sect_crs += sz; 1228 sect_rest -= sz; 1229 fragm_crs += sz; 1230 fragm_rest -= sz; 1231 rest -= sz; 1232 1233 if (!fragm_rest && rest) { 1234 1235 /* Initiate new fragment: */ 1236 if (rest <= fragm_sz) { 1237 fragm_sz = rest; 1238 msg_set_type(&fragm_hdr, LAST_FRAGMENT); 1239 } else { 1240 msg_set_type(&fragm_hdr, FRAGMENT); 1241 } 1242 msg_set_size(&fragm_hdr, fragm_sz + INT_H_SIZE); 1243 msg_set_fragm_no(&fragm_hdr, ++fragm_no); 1244 prev = buf; 1245 buf = tipc_buf_acquire(fragm_sz + INT_H_SIZE); 1246 if (!buf) { 1247 res = -ENOMEM; 1248 goto error; 1249 } 1250 1251 buf->next = NULL; 1252 prev->next = buf; 1253 skb_copy_to_linear_data(buf, &fragm_hdr, INT_H_SIZE); 1254 fragm_crs = INT_H_SIZE; 1255 fragm_rest = fragm_sz; 1256 } 1257 } while (rest > 0); 1258 1259 /* 1260 * Now we have a buffer chain. Select a link and check 1261 * that packet size is still OK 1262 */ 1263 node = tipc_node_find(destaddr); 1264 if (likely(node)) { 1265 tipc_node_lock(node); 1266 l_ptr = node->active_links[sender->ref & 1]; 1267 if (!l_ptr) { 1268 tipc_node_unlock(node); 1269 goto reject; 1270 } 1271 if (l_ptr->max_pkt < max_pkt) { 1272 sender->max_pkt = l_ptr->max_pkt; 1273 tipc_node_unlock(node); 1274 for (; buf_chain; buf_chain = buf) { 1275 buf = buf_chain->next; 1276 kfree_skb(buf_chain); 1277 } 1278 goto again; 1279 } 1280 } else { 1281 reject: 1282 for (; buf_chain; buf_chain = buf) { 1283 buf = buf_chain->next; 1284 kfree_skb(buf_chain); 1285 } 1286 return tipc_port_reject_sections(sender, hdr, msg_sect, num_sect, 1287 total_len, TIPC_ERR_NO_NODE); 1288 } 1289 1290 /* Append chain of fragments to send queue & send them */ 1291 l_ptr->long_msg_seq_no++; 1292 link_add_chain_to_outqueue(l_ptr, buf_chain, l_ptr->long_msg_seq_no); 1293 l_ptr->stats.sent_fragments += fragm_no; 1294 l_ptr->stats.sent_fragmented++; 1295 tipc_link_push_queue(l_ptr); 1296 tipc_node_unlock(node); 1297 return dsz; 1298 } 1299 1300 /* 1301 * tipc_link_push_packet: Push one unsent packet to the media 1302 */ 1303 u32 tipc_link_push_packet(struct tipc_link *l_ptr) 1304 { 1305 struct sk_buff *buf = l_ptr->first_out; 1306 u32 r_q_size = l_ptr->retransm_queue_size; 1307 u32 r_q_head = l_ptr->retransm_queue_head; 1308 1309 /* Step to position where retransmission failed, if any, */ 1310 /* consider that buffers may have been released in meantime */ 1311 if (r_q_size && buf) { 1312 u32 last = lesser(mod(r_q_head + r_q_size), 1313 link_last_sent(l_ptr)); 1314 u32 first = buf_seqno(buf); 1315 1316 while (buf && less(first, r_q_head)) { 1317 first = mod(first + 1); 1318 buf = buf->next; 1319 } 1320 l_ptr->retransm_queue_head = r_q_head = first; 1321 l_ptr->retransm_queue_size = r_q_size = mod(last - first); 1322 } 1323 1324 /* Continue retransmission now, if there is anything: */ 1325 if (r_q_size && buf) { 1326 msg_set_ack(buf_msg(buf), mod(l_ptr->next_in_no - 1)); 1327 msg_set_bcast_ack(buf_msg(buf), l_ptr->owner->bclink.last_in); 1328 tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr); 1329 l_ptr->retransm_queue_head = mod(++r_q_head); 1330 l_ptr->retransm_queue_size = --r_q_size; 1331 l_ptr->stats.retransmitted++; 1332 return 0; 1333 } 1334 1335 /* Send deferred protocol message, if any: */ 1336 buf = l_ptr->proto_msg_queue; 1337 if (buf) { 1338 msg_set_ack(buf_msg(buf), mod(l_ptr->next_in_no - 1)); 1339 msg_set_bcast_ack(buf_msg(buf), l_ptr->owner->bclink.last_in); 1340 tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr); 1341 l_ptr->unacked_window = 0; 1342 kfree_skb(buf); 1343 l_ptr->proto_msg_queue = NULL; 1344 return 0; 1345 } 1346 1347 /* Send one deferred data message, if send window not full: */ 1348 buf = l_ptr->next_out; 1349 if (buf) { 1350 struct tipc_msg *msg = buf_msg(buf); 1351 u32 next = msg_seqno(msg); 1352 u32 first = buf_seqno(l_ptr->first_out); 1353 1354 if (mod(next - first) < l_ptr->queue_limit[0]) { 1355 msg_set_ack(msg, mod(l_ptr->next_in_no - 1)); 1356 msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in); 1357 tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr); 1358 if (msg_user(msg) == MSG_BUNDLER) 1359 msg_set_type(msg, CLOSED_MSG); 1360 l_ptr->next_out = buf->next; 1361 return 0; 1362 } 1363 } 1364 return 1; 1365 } 1366 1367 /* 1368 * push_queue(): push out the unsent messages of a link where 1369 * congestion has abated. Node is locked 1370 */ 1371 void tipc_link_push_queue(struct tipc_link *l_ptr) 1372 { 1373 u32 res; 1374 1375 if (tipc_bearer_blocked(l_ptr->b_ptr)) 1376 return; 1377 1378 do { 1379 res = tipc_link_push_packet(l_ptr); 1380 } while (!res); 1381 } 1382 1383 static void link_reset_all(unsigned long addr) 1384 { 1385 struct tipc_node *n_ptr; 1386 char addr_string[16]; 1387 u32 i; 1388 1389 read_lock_bh(&tipc_net_lock); 1390 n_ptr = tipc_node_find((u32)addr); 1391 if (!n_ptr) { 1392 read_unlock_bh(&tipc_net_lock); 1393 return; /* node no longer exists */ 1394 } 1395 1396 tipc_node_lock(n_ptr); 1397 1398 pr_warn("Resetting all links to %s\n", 1399 tipc_addr_string_fill(addr_string, n_ptr->addr)); 1400 1401 for (i = 0; i < MAX_BEARERS; i++) { 1402 if (n_ptr->links[i]) { 1403 link_print(n_ptr->links[i], "Resetting link\n"); 1404 tipc_link_reset(n_ptr->links[i]); 1405 } 1406 } 1407 1408 tipc_node_unlock(n_ptr); 1409 read_unlock_bh(&tipc_net_lock); 1410 } 1411 1412 static void link_retransmit_failure(struct tipc_link *l_ptr, 1413 struct sk_buff *buf) 1414 { 1415 struct tipc_msg *msg = buf_msg(buf); 1416 1417 pr_warn("Retransmission failure on link <%s>\n", l_ptr->name); 1418 1419 if (l_ptr->addr) { 1420 /* Handle failure on standard link */ 1421 link_print(l_ptr, "Resetting link\n"); 1422 tipc_link_reset(l_ptr); 1423 1424 } else { 1425 /* Handle failure on broadcast link */ 1426 struct tipc_node *n_ptr; 1427 char addr_string[16]; 1428 1429 pr_info("Msg seq number: %u, ", msg_seqno(msg)); 1430 pr_cont("Outstanding acks: %lu\n", 1431 (unsigned long) TIPC_SKB_CB(buf)->handle); 1432 1433 n_ptr = tipc_bclink_retransmit_to(); 1434 tipc_node_lock(n_ptr); 1435 1436 tipc_addr_string_fill(addr_string, n_ptr->addr); 1437 pr_info("Broadcast link info for %s\n", addr_string); 1438 pr_info("Reception permitted: %d, Acked: %u\n", 1439 n_ptr->bclink.recv_permitted, 1440 n_ptr->bclink.acked); 1441 pr_info("Last in: %u, Oos state: %u, Last sent: %u\n", 1442 n_ptr->bclink.last_in, 1443 n_ptr->bclink.oos_state, 1444 n_ptr->bclink.last_sent); 1445 1446 tipc_k_signal((Handler)link_reset_all, (unsigned long)n_ptr->addr); 1447 1448 tipc_node_unlock(n_ptr); 1449 1450 l_ptr->stale_count = 0; 1451 } 1452 } 1453 1454 void tipc_link_retransmit(struct tipc_link *l_ptr, struct sk_buff *buf, 1455 u32 retransmits) 1456 { 1457 struct tipc_msg *msg; 1458 1459 if (!buf) 1460 return; 1461 1462 msg = buf_msg(buf); 1463 1464 if (tipc_bearer_blocked(l_ptr->b_ptr)) { 1465 if (l_ptr->retransm_queue_size == 0) { 1466 l_ptr->retransm_queue_head = msg_seqno(msg); 1467 l_ptr->retransm_queue_size = retransmits; 1468 } else { 1469 pr_err("Unexpected retransmit on link %s (qsize=%d)\n", 1470 l_ptr->name, l_ptr->retransm_queue_size); 1471 } 1472 return; 1473 } else { 1474 /* Detect repeated retransmit failures on unblocked bearer */ 1475 if (l_ptr->last_retransmitted == msg_seqno(msg)) { 1476 if (++l_ptr->stale_count > 100) { 1477 link_retransmit_failure(l_ptr, buf); 1478 return; 1479 } 1480 } else { 1481 l_ptr->last_retransmitted = msg_seqno(msg); 1482 l_ptr->stale_count = 1; 1483 } 1484 } 1485 1486 while (retransmits && (buf != l_ptr->next_out) && buf) { 1487 msg = buf_msg(buf); 1488 msg_set_ack(msg, mod(l_ptr->next_in_no - 1)); 1489 msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in); 1490 tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr); 1491 buf = buf->next; 1492 retransmits--; 1493 l_ptr->stats.retransmitted++; 1494 } 1495 1496 l_ptr->retransm_queue_head = l_ptr->retransm_queue_size = 0; 1497 } 1498 1499 /** 1500 * link_insert_deferred_queue - insert deferred messages back into receive chain 1501 */ 1502 static struct sk_buff *link_insert_deferred_queue(struct tipc_link *l_ptr, 1503 struct sk_buff *buf) 1504 { 1505 u32 seq_no; 1506 1507 if (l_ptr->oldest_deferred_in == NULL) 1508 return buf; 1509 1510 seq_no = buf_seqno(l_ptr->oldest_deferred_in); 1511 if (seq_no == mod(l_ptr->next_in_no)) { 1512 l_ptr->newest_deferred_in->next = buf; 1513 buf = l_ptr->oldest_deferred_in; 1514 l_ptr->oldest_deferred_in = NULL; 1515 l_ptr->deferred_inqueue_sz = 0; 1516 } 1517 return buf; 1518 } 1519 1520 /** 1521 * link_recv_buf_validate - validate basic format of received message 1522 * 1523 * This routine ensures a TIPC message has an acceptable header, and at least 1524 * as much data as the header indicates it should. The routine also ensures 1525 * that the entire message header is stored in the main fragment of the message 1526 * buffer, to simplify future access to message header fields. 1527 * 1528 * Note: Having extra info present in the message header or data areas is OK. 1529 * TIPC will ignore the excess, under the assumption that it is optional info 1530 * introduced by a later release of the protocol. 1531 */ 1532 static int link_recv_buf_validate(struct sk_buff *buf) 1533 { 1534 static u32 min_data_hdr_size[8] = { 1535 SHORT_H_SIZE, MCAST_H_SIZE, NAMED_H_SIZE, BASIC_H_SIZE, 1536 MAX_H_SIZE, MAX_H_SIZE, MAX_H_SIZE, MAX_H_SIZE 1537 }; 1538 1539 struct tipc_msg *msg; 1540 u32 tipc_hdr[2]; 1541 u32 size; 1542 u32 hdr_size; 1543 u32 min_hdr_size; 1544 1545 if (unlikely(buf->len < MIN_H_SIZE)) 1546 return 0; 1547 1548 msg = skb_header_pointer(buf, 0, sizeof(tipc_hdr), tipc_hdr); 1549 if (msg == NULL) 1550 return 0; 1551 1552 if (unlikely(msg_version(msg) != TIPC_VERSION)) 1553 return 0; 1554 1555 size = msg_size(msg); 1556 hdr_size = msg_hdr_sz(msg); 1557 min_hdr_size = msg_isdata(msg) ? 1558 min_data_hdr_size[msg_type(msg)] : INT_H_SIZE; 1559 1560 if (unlikely((hdr_size < min_hdr_size) || 1561 (size < hdr_size) || 1562 (buf->len < size) || 1563 (size - hdr_size > TIPC_MAX_USER_MSG_SIZE))) 1564 return 0; 1565 1566 return pskb_may_pull(buf, hdr_size); 1567 } 1568 1569 /** 1570 * tipc_recv_msg - process TIPC messages arriving from off-node 1571 * @head: pointer to message buffer chain 1572 * @tb_ptr: pointer to bearer message arrived on 1573 * 1574 * Invoked with no locks held. Bearer pointer must point to a valid bearer 1575 * structure (i.e. cannot be NULL), but bearer can be inactive. 1576 */ 1577 void tipc_recv_msg(struct sk_buff *head, struct tipc_bearer *b_ptr) 1578 { 1579 read_lock_bh(&tipc_net_lock); 1580 while (head) { 1581 struct tipc_node *n_ptr; 1582 struct tipc_link *l_ptr; 1583 struct sk_buff *crs; 1584 struct sk_buff *buf = head; 1585 struct tipc_msg *msg; 1586 u32 seq_no; 1587 u32 ackd; 1588 u32 released = 0; 1589 int type; 1590 1591 head = head->next; 1592 1593 /* Ensure bearer is still enabled */ 1594 if (unlikely(!b_ptr->active)) 1595 goto cont; 1596 1597 /* Ensure message is well-formed */ 1598 if (unlikely(!link_recv_buf_validate(buf))) 1599 goto cont; 1600 1601 /* Ensure message data is a single contiguous unit */ 1602 if (unlikely(skb_linearize(buf))) 1603 goto cont; 1604 1605 /* Handle arrival of a non-unicast link message */ 1606 msg = buf_msg(buf); 1607 1608 if (unlikely(msg_non_seq(msg))) { 1609 if (msg_user(msg) == LINK_CONFIG) 1610 tipc_disc_recv_msg(buf, b_ptr); 1611 else 1612 tipc_bclink_recv_pkt(buf); 1613 continue; 1614 } 1615 1616 /* Discard unicast link messages destined for another node */ 1617 if (unlikely(!msg_short(msg) && 1618 (msg_destnode(msg) != tipc_own_addr))) 1619 goto cont; 1620 1621 /* Locate neighboring node that sent message */ 1622 n_ptr = tipc_node_find(msg_prevnode(msg)); 1623 if (unlikely(!n_ptr)) 1624 goto cont; 1625 tipc_node_lock(n_ptr); 1626 1627 /* Locate unicast link endpoint that should handle message */ 1628 l_ptr = n_ptr->links[b_ptr->identity]; 1629 if (unlikely(!l_ptr)) { 1630 tipc_node_unlock(n_ptr); 1631 goto cont; 1632 } 1633 1634 /* Verify that communication with node is currently allowed */ 1635 if ((n_ptr->block_setup & WAIT_PEER_DOWN) && 1636 msg_user(msg) == LINK_PROTOCOL && 1637 (msg_type(msg) == RESET_MSG || 1638 msg_type(msg) == ACTIVATE_MSG) && 1639 !msg_redundant_link(msg)) 1640 n_ptr->block_setup &= ~WAIT_PEER_DOWN; 1641 1642 if (n_ptr->block_setup) { 1643 tipc_node_unlock(n_ptr); 1644 goto cont; 1645 } 1646 1647 /* Validate message sequence number info */ 1648 seq_no = msg_seqno(msg); 1649 ackd = msg_ack(msg); 1650 1651 /* Release acked messages */ 1652 if (n_ptr->bclink.recv_permitted) 1653 tipc_bclink_acknowledge(n_ptr, msg_bcast_ack(msg)); 1654 1655 crs = l_ptr->first_out; 1656 while ((crs != l_ptr->next_out) && 1657 less_eq(buf_seqno(crs), ackd)) { 1658 struct sk_buff *next = crs->next; 1659 1660 kfree_skb(crs); 1661 crs = next; 1662 released++; 1663 } 1664 if (released) { 1665 l_ptr->first_out = crs; 1666 l_ptr->out_queue_size -= released; 1667 } 1668 1669 /* Try sending any messages link endpoint has pending */ 1670 if (unlikely(l_ptr->next_out)) 1671 tipc_link_push_queue(l_ptr); 1672 if (unlikely(!list_empty(&l_ptr->waiting_ports))) 1673 tipc_link_wakeup_ports(l_ptr, 0); 1674 if (unlikely(++l_ptr->unacked_window >= TIPC_MIN_LINK_WIN)) { 1675 l_ptr->stats.sent_acks++; 1676 tipc_link_send_proto_msg(l_ptr, STATE_MSG, 0, 0, 0, 0, 0); 1677 } 1678 1679 /* Now (finally!) process the incoming message */ 1680 protocol_check: 1681 if (likely(link_working_working(l_ptr))) { 1682 if (likely(seq_no == mod(l_ptr->next_in_no))) { 1683 l_ptr->next_in_no++; 1684 if (unlikely(l_ptr->oldest_deferred_in)) 1685 head = link_insert_deferred_queue(l_ptr, 1686 head); 1687 deliver: 1688 if (likely(msg_isdata(msg))) { 1689 tipc_node_unlock(n_ptr); 1690 tipc_port_recv_msg(buf); 1691 continue; 1692 } 1693 switch (msg_user(msg)) { 1694 int ret; 1695 case MSG_BUNDLER: 1696 l_ptr->stats.recv_bundles++; 1697 l_ptr->stats.recv_bundled += 1698 msg_msgcnt(msg); 1699 tipc_node_unlock(n_ptr); 1700 tipc_link_recv_bundle(buf); 1701 continue; 1702 case NAME_DISTRIBUTOR: 1703 n_ptr->bclink.recv_permitted = true; 1704 tipc_node_unlock(n_ptr); 1705 tipc_named_recv(buf); 1706 continue; 1707 case BCAST_PROTOCOL: 1708 tipc_link_recv_sync(n_ptr, buf); 1709 tipc_node_unlock(n_ptr); 1710 continue; 1711 case CONN_MANAGER: 1712 tipc_node_unlock(n_ptr); 1713 tipc_port_recv_proto_msg(buf); 1714 continue; 1715 case MSG_FRAGMENTER: 1716 l_ptr->stats.recv_fragments++; 1717 ret = tipc_link_recv_fragment( 1718 &l_ptr->defragm_buf, 1719 &buf, &msg); 1720 if (ret == 1) { 1721 l_ptr->stats.recv_fragmented++; 1722 goto deliver; 1723 } 1724 if (ret == -1) 1725 l_ptr->next_in_no--; 1726 break; 1727 case CHANGEOVER_PROTOCOL: 1728 type = msg_type(msg); 1729 if (link_recv_changeover_msg(&l_ptr, 1730 &buf)) { 1731 msg = buf_msg(buf); 1732 seq_no = msg_seqno(msg); 1733 if (type == ORIGINAL_MSG) 1734 goto deliver; 1735 goto protocol_check; 1736 } 1737 break; 1738 default: 1739 kfree_skb(buf); 1740 buf = NULL; 1741 break; 1742 } 1743 tipc_node_unlock(n_ptr); 1744 tipc_net_route_msg(buf); 1745 continue; 1746 } 1747 link_handle_out_of_seq_msg(l_ptr, buf); 1748 head = link_insert_deferred_queue(l_ptr, head); 1749 tipc_node_unlock(n_ptr); 1750 continue; 1751 } 1752 1753 /* Link is not in state WORKING_WORKING */ 1754 if (msg_user(msg) == LINK_PROTOCOL) { 1755 link_recv_proto_msg(l_ptr, buf); 1756 head = link_insert_deferred_queue(l_ptr, head); 1757 tipc_node_unlock(n_ptr); 1758 continue; 1759 } 1760 1761 /* Traffic message. Conditionally activate link */ 1762 link_state_event(l_ptr, TRAFFIC_MSG_EVT); 1763 1764 if (link_working_working(l_ptr)) { 1765 /* Re-insert buffer in front of queue */ 1766 buf->next = head; 1767 head = buf; 1768 tipc_node_unlock(n_ptr); 1769 continue; 1770 } 1771 tipc_node_unlock(n_ptr); 1772 cont: 1773 kfree_skb(buf); 1774 } 1775 read_unlock_bh(&tipc_net_lock); 1776 } 1777 1778 /** 1779 * tipc_link_defer_pkt - Add out-of-sequence message to deferred reception queue 1780 * 1781 * Returns increase in queue length (i.e. 0 or 1) 1782 */ 1783 u32 tipc_link_defer_pkt(struct sk_buff **head, struct sk_buff **tail, 1784 struct sk_buff *buf) 1785 { 1786 struct sk_buff *queue_buf; 1787 struct sk_buff **prev; 1788 u32 seq_no = buf_seqno(buf); 1789 1790 buf->next = NULL; 1791 1792 /* Empty queue ? */ 1793 if (*head == NULL) { 1794 *head = *tail = buf; 1795 return 1; 1796 } 1797 1798 /* Last ? */ 1799 if (less(buf_seqno(*tail), seq_no)) { 1800 (*tail)->next = buf; 1801 *tail = buf; 1802 return 1; 1803 } 1804 1805 /* Locate insertion point in queue, then insert; discard if duplicate */ 1806 prev = head; 1807 queue_buf = *head; 1808 for (;;) { 1809 u32 curr_seqno = buf_seqno(queue_buf); 1810 1811 if (seq_no == curr_seqno) { 1812 kfree_skb(buf); 1813 return 0; 1814 } 1815 1816 if (less(seq_no, curr_seqno)) 1817 break; 1818 1819 prev = &queue_buf->next; 1820 queue_buf = queue_buf->next; 1821 } 1822 1823 buf->next = queue_buf; 1824 *prev = buf; 1825 return 1; 1826 } 1827 1828 /* 1829 * link_handle_out_of_seq_msg - handle arrival of out-of-sequence packet 1830 */ 1831 static void link_handle_out_of_seq_msg(struct tipc_link *l_ptr, 1832 struct sk_buff *buf) 1833 { 1834 u32 seq_no = buf_seqno(buf); 1835 1836 if (likely(msg_user(buf_msg(buf)) == LINK_PROTOCOL)) { 1837 link_recv_proto_msg(l_ptr, buf); 1838 return; 1839 } 1840 1841 /* Record OOS packet arrival (force mismatch on next timeout) */ 1842 l_ptr->checkpoint--; 1843 1844 /* 1845 * Discard packet if a duplicate; otherwise add it to deferred queue 1846 * and notify peer of gap as per protocol specification 1847 */ 1848 if (less(seq_no, mod(l_ptr->next_in_no))) { 1849 l_ptr->stats.duplicates++; 1850 kfree_skb(buf); 1851 return; 1852 } 1853 1854 if (tipc_link_defer_pkt(&l_ptr->oldest_deferred_in, 1855 &l_ptr->newest_deferred_in, buf)) { 1856 l_ptr->deferred_inqueue_sz++; 1857 l_ptr->stats.deferred_recv++; 1858 if ((l_ptr->deferred_inqueue_sz % 16) == 1) 1859 tipc_link_send_proto_msg(l_ptr, STATE_MSG, 0, 0, 0, 0, 0); 1860 } else 1861 l_ptr->stats.duplicates++; 1862 } 1863 1864 /* 1865 * Send protocol message to the other endpoint. 1866 */ 1867 void tipc_link_send_proto_msg(struct tipc_link *l_ptr, u32 msg_typ, 1868 int probe_msg, u32 gap, u32 tolerance, 1869 u32 priority, u32 ack_mtu) 1870 { 1871 struct sk_buff *buf = NULL; 1872 struct tipc_msg *msg = l_ptr->pmsg; 1873 u32 msg_size = sizeof(l_ptr->proto_msg); 1874 int r_flag; 1875 1876 /* Discard any previous message that was deferred due to congestion */ 1877 if (l_ptr->proto_msg_queue) { 1878 kfree_skb(l_ptr->proto_msg_queue); 1879 l_ptr->proto_msg_queue = NULL; 1880 } 1881 1882 if (link_blocked(l_ptr)) 1883 return; 1884 1885 /* Abort non-RESET send if communication with node is prohibited */ 1886 if ((l_ptr->owner->block_setup) && (msg_typ != RESET_MSG)) 1887 return; 1888 1889 /* Create protocol message with "out-of-sequence" sequence number */ 1890 msg_set_type(msg, msg_typ); 1891 msg_set_net_plane(msg, l_ptr->b_ptr->net_plane); 1892 msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in); 1893 msg_set_last_bcast(msg, tipc_bclink_get_last_sent()); 1894 1895 if (msg_typ == STATE_MSG) { 1896 u32 next_sent = mod(l_ptr->next_out_no); 1897 1898 if (!tipc_link_is_up(l_ptr)) 1899 return; 1900 if (l_ptr->next_out) 1901 next_sent = buf_seqno(l_ptr->next_out); 1902 msg_set_next_sent(msg, next_sent); 1903 if (l_ptr->oldest_deferred_in) { 1904 u32 rec = buf_seqno(l_ptr->oldest_deferred_in); 1905 gap = mod(rec - mod(l_ptr->next_in_no)); 1906 } 1907 msg_set_seq_gap(msg, gap); 1908 if (gap) 1909 l_ptr->stats.sent_nacks++; 1910 msg_set_link_tolerance(msg, tolerance); 1911 msg_set_linkprio(msg, priority); 1912 msg_set_max_pkt(msg, ack_mtu); 1913 msg_set_ack(msg, mod(l_ptr->next_in_no - 1)); 1914 msg_set_probe(msg, probe_msg != 0); 1915 if (probe_msg) { 1916 u32 mtu = l_ptr->max_pkt; 1917 1918 if ((mtu < l_ptr->max_pkt_target) && 1919 link_working_working(l_ptr) && 1920 l_ptr->fsm_msg_cnt) { 1921 msg_size = (mtu + (l_ptr->max_pkt_target - mtu)/2 + 2) & ~3; 1922 if (l_ptr->max_pkt_probes == 10) { 1923 l_ptr->max_pkt_target = (msg_size - 4); 1924 l_ptr->max_pkt_probes = 0; 1925 msg_size = (mtu + (l_ptr->max_pkt_target - mtu)/2 + 2) & ~3; 1926 } 1927 l_ptr->max_pkt_probes++; 1928 } 1929 1930 l_ptr->stats.sent_probes++; 1931 } 1932 l_ptr->stats.sent_states++; 1933 } else { /* RESET_MSG or ACTIVATE_MSG */ 1934 msg_set_ack(msg, mod(l_ptr->reset_checkpoint - 1)); 1935 msg_set_seq_gap(msg, 0); 1936 msg_set_next_sent(msg, 1); 1937 msg_set_probe(msg, 0); 1938 msg_set_link_tolerance(msg, l_ptr->tolerance); 1939 msg_set_linkprio(msg, l_ptr->priority); 1940 msg_set_max_pkt(msg, l_ptr->max_pkt_target); 1941 } 1942 1943 r_flag = (l_ptr->owner->working_links > tipc_link_is_up(l_ptr)); 1944 msg_set_redundant_link(msg, r_flag); 1945 msg_set_linkprio(msg, l_ptr->priority); 1946 msg_set_size(msg, msg_size); 1947 1948 msg_set_seqno(msg, mod(l_ptr->next_out_no + (0xffff/2))); 1949 1950 buf = tipc_buf_acquire(msg_size); 1951 if (!buf) 1952 return; 1953 1954 skb_copy_to_linear_data(buf, msg, sizeof(l_ptr->proto_msg)); 1955 buf->priority = TC_PRIO_CONTROL; 1956 1957 /* Defer message if bearer is already blocked */ 1958 if (tipc_bearer_blocked(l_ptr->b_ptr)) { 1959 l_ptr->proto_msg_queue = buf; 1960 return; 1961 } 1962 1963 tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr); 1964 l_ptr->unacked_window = 0; 1965 kfree_skb(buf); 1966 } 1967 1968 /* 1969 * Receive protocol message : 1970 * Note that network plane id propagates through the network, and may 1971 * change at any time. The node with lowest address rules 1972 */ 1973 static void link_recv_proto_msg(struct tipc_link *l_ptr, struct sk_buff *buf) 1974 { 1975 u32 rec_gap = 0; 1976 u32 max_pkt_info; 1977 u32 max_pkt_ack; 1978 u32 msg_tol; 1979 struct tipc_msg *msg = buf_msg(buf); 1980 1981 if (link_blocked(l_ptr)) 1982 goto exit; 1983 1984 /* record unnumbered packet arrival (force mismatch on next timeout) */ 1985 l_ptr->checkpoint--; 1986 1987 if (l_ptr->b_ptr->net_plane != msg_net_plane(msg)) 1988 if (tipc_own_addr > msg_prevnode(msg)) 1989 l_ptr->b_ptr->net_plane = msg_net_plane(msg); 1990 1991 l_ptr->owner->permit_changeover = msg_redundant_link(msg); 1992 1993 switch (msg_type(msg)) { 1994 1995 case RESET_MSG: 1996 if (!link_working_unknown(l_ptr) && 1997 (l_ptr->peer_session != INVALID_SESSION)) { 1998 if (less_eq(msg_session(msg), l_ptr->peer_session)) 1999 break; /* duplicate or old reset: ignore */ 2000 } 2001 2002 if (!msg_redundant_link(msg) && (link_working_working(l_ptr) || 2003 link_working_unknown(l_ptr))) { 2004 /* 2005 * peer has lost contact -- don't allow peer's links 2006 * to reactivate before we recognize loss & clean up 2007 */ 2008 l_ptr->owner->block_setup = WAIT_NODE_DOWN; 2009 } 2010 2011 link_state_event(l_ptr, RESET_MSG); 2012 2013 /* fall thru' */ 2014 case ACTIVATE_MSG: 2015 /* Update link settings according other endpoint's values */ 2016 strcpy((strrchr(l_ptr->name, ':') + 1), (char *)msg_data(msg)); 2017 2018 msg_tol = msg_link_tolerance(msg); 2019 if (msg_tol > l_ptr->tolerance) 2020 link_set_supervision_props(l_ptr, msg_tol); 2021 2022 if (msg_linkprio(msg) > l_ptr->priority) 2023 l_ptr->priority = msg_linkprio(msg); 2024 2025 max_pkt_info = msg_max_pkt(msg); 2026 if (max_pkt_info) { 2027 if (max_pkt_info < l_ptr->max_pkt_target) 2028 l_ptr->max_pkt_target = max_pkt_info; 2029 if (l_ptr->max_pkt > l_ptr->max_pkt_target) 2030 l_ptr->max_pkt = l_ptr->max_pkt_target; 2031 } else { 2032 l_ptr->max_pkt = l_ptr->max_pkt_target; 2033 } 2034 2035 /* Synchronize broadcast link info, if not done previously */ 2036 if (!tipc_node_is_up(l_ptr->owner)) { 2037 l_ptr->owner->bclink.last_sent = 2038 l_ptr->owner->bclink.last_in = 2039 msg_last_bcast(msg); 2040 l_ptr->owner->bclink.oos_state = 0; 2041 } 2042 2043 l_ptr->peer_session = msg_session(msg); 2044 l_ptr->peer_bearer_id = msg_bearer_id(msg); 2045 2046 if (msg_type(msg) == ACTIVATE_MSG) 2047 link_state_event(l_ptr, ACTIVATE_MSG); 2048 break; 2049 case STATE_MSG: 2050 2051 msg_tol = msg_link_tolerance(msg); 2052 if (msg_tol) 2053 link_set_supervision_props(l_ptr, msg_tol); 2054 2055 if (msg_linkprio(msg) && 2056 (msg_linkprio(msg) != l_ptr->priority)) { 2057 pr_warn("%s<%s>, priority change %u->%u\n", 2058 link_rst_msg, l_ptr->name, l_ptr->priority, 2059 msg_linkprio(msg)); 2060 l_ptr->priority = msg_linkprio(msg); 2061 tipc_link_reset(l_ptr); /* Enforce change to take effect */ 2062 break; 2063 } 2064 link_state_event(l_ptr, TRAFFIC_MSG_EVT); 2065 l_ptr->stats.recv_states++; 2066 if (link_reset_unknown(l_ptr)) 2067 break; 2068 2069 if (less_eq(mod(l_ptr->next_in_no), msg_next_sent(msg))) { 2070 rec_gap = mod(msg_next_sent(msg) - 2071 mod(l_ptr->next_in_no)); 2072 } 2073 2074 max_pkt_ack = msg_max_pkt(msg); 2075 if (max_pkt_ack > l_ptr->max_pkt) { 2076 l_ptr->max_pkt = max_pkt_ack; 2077 l_ptr->max_pkt_probes = 0; 2078 } 2079 2080 max_pkt_ack = 0; 2081 if (msg_probe(msg)) { 2082 l_ptr->stats.recv_probes++; 2083 if (msg_size(msg) > sizeof(l_ptr->proto_msg)) 2084 max_pkt_ack = msg_size(msg); 2085 } 2086 2087 /* Protocol message before retransmits, reduce loss risk */ 2088 if (l_ptr->owner->bclink.recv_permitted) 2089 tipc_bclink_update_link_state(l_ptr->owner, 2090 msg_last_bcast(msg)); 2091 2092 if (rec_gap || (msg_probe(msg))) { 2093 tipc_link_send_proto_msg(l_ptr, STATE_MSG, 2094 0, rec_gap, 0, 0, max_pkt_ack); 2095 } 2096 if (msg_seq_gap(msg)) { 2097 l_ptr->stats.recv_nacks++; 2098 tipc_link_retransmit(l_ptr, l_ptr->first_out, 2099 msg_seq_gap(msg)); 2100 } 2101 break; 2102 } 2103 exit: 2104 kfree_skb(buf); 2105 } 2106 2107 2108 /* 2109 * tipc_link_tunnel(): Send one message via a link belonging to 2110 * another bearer. Owner node is locked. 2111 */ 2112 static void tipc_link_tunnel(struct tipc_link *l_ptr, 2113 struct tipc_msg *tunnel_hdr, struct tipc_msg *msg, 2114 u32 selector) 2115 { 2116 struct tipc_link *tunnel; 2117 struct sk_buff *buf; 2118 u32 length = msg_size(msg); 2119 2120 tunnel = l_ptr->owner->active_links[selector & 1]; 2121 if (!tipc_link_is_up(tunnel)) { 2122 pr_warn("%stunnel link no longer available\n", link_co_err); 2123 return; 2124 } 2125 msg_set_size(tunnel_hdr, length + INT_H_SIZE); 2126 buf = tipc_buf_acquire(length + INT_H_SIZE); 2127 if (!buf) { 2128 pr_warn("%sunable to send tunnel msg\n", link_co_err); 2129 return; 2130 } 2131 skb_copy_to_linear_data(buf, tunnel_hdr, INT_H_SIZE); 2132 skb_copy_to_linear_data_offset(buf, INT_H_SIZE, msg, length); 2133 tipc_link_send_buf(tunnel, buf); 2134 } 2135 2136 2137 2138 /* 2139 * changeover(): Send whole message queue via the remaining link 2140 * Owner node is locked. 2141 */ 2142 void tipc_link_changeover(struct tipc_link *l_ptr) 2143 { 2144 u32 msgcount = l_ptr->out_queue_size; 2145 struct sk_buff *crs = l_ptr->first_out; 2146 struct tipc_link *tunnel = l_ptr->owner->active_links[0]; 2147 struct tipc_msg tunnel_hdr; 2148 int split_bundles; 2149 2150 if (!tunnel) 2151 return; 2152 2153 if (!l_ptr->owner->permit_changeover) { 2154 pr_warn("%speer did not permit changeover\n", link_co_err); 2155 return; 2156 } 2157 2158 tipc_msg_init(&tunnel_hdr, CHANGEOVER_PROTOCOL, 2159 ORIGINAL_MSG, INT_H_SIZE, l_ptr->addr); 2160 msg_set_bearer_id(&tunnel_hdr, l_ptr->peer_bearer_id); 2161 msg_set_msgcnt(&tunnel_hdr, msgcount); 2162 2163 if (!l_ptr->first_out) { 2164 struct sk_buff *buf; 2165 2166 buf = tipc_buf_acquire(INT_H_SIZE); 2167 if (buf) { 2168 skb_copy_to_linear_data(buf, &tunnel_hdr, INT_H_SIZE); 2169 msg_set_size(&tunnel_hdr, INT_H_SIZE); 2170 tipc_link_send_buf(tunnel, buf); 2171 } else { 2172 pr_warn("%sunable to send changeover msg\n", 2173 link_co_err); 2174 } 2175 return; 2176 } 2177 2178 split_bundles = (l_ptr->owner->active_links[0] != 2179 l_ptr->owner->active_links[1]); 2180 2181 while (crs) { 2182 struct tipc_msg *msg = buf_msg(crs); 2183 2184 if ((msg_user(msg) == MSG_BUNDLER) && split_bundles) { 2185 struct tipc_msg *m = msg_get_wrapped(msg); 2186 unchar *pos = (unchar *)m; 2187 2188 msgcount = msg_msgcnt(msg); 2189 while (msgcount--) { 2190 msg_set_seqno(m, msg_seqno(msg)); 2191 tipc_link_tunnel(l_ptr, &tunnel_hdr, m, 2192 msg_link_selector(m)); 2193 pos += align(msg_size(m)); 2194 m = (struct tipc_msg *)pos; 2195 } 2196 } else { 2197 tipc_link_tunnel(l_ptr, &tunnel_hdr, msg, 2198 msg_link_selector(msg)); 2199 } 2200 crs = crs->next; 2201 } 2202 } 2203 2204 void tipc_link_send_duplicate(struct tipc_link *l_ptr, struct tipc_link *tunnel) 2205 { 2206 struct sk_buff *iter; 2207 struct tipc_msg tunnel_hdr; 2208 2209 tipc_msg_init(&tunnel_hdr, CHANGEOVER_PROTOCOL, 2210 DUPLICATE_MSG, INT_H_SIZE, l_ptr->addr); 2211 msg_set_msgcnt(&tunnel_hdr, l_ptr->out_queue_size); 2212 msg_set_bearer_id(&tunnel_hdr, l_ptr->peer_bearer_id); 2213 iter = l_ptr->first_out; 2214 while (iter) { 2215 struct sk_buff *outbuf; 2216 struct tipc_msg *msg = buf_msg(iter); 2217 u32 length = msg_size(msg); 2218 2219 if (msg_user(msg) == MSG_BUNDLER) 2220 msg_set_type(msg, CLOSED_MSG); 2221 msg_set_ack(msg, mod(l_ptr->next_in_no - 1)); /* Update */ 2222 msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in); 2223 msg_set_size(&tunnel_hdr, length + INT_H_SIZE); 2224 outbuf = tipc_buf_acquire(length + INT_H_SIZE); 2225 if (outbuf == NULL) { 2226 pr_warn("%sunable to send duplicate msg\n", 2227 link_co_err); 2228 return; 2229 } 2230 skb_copy_to_linear_data(outbuf, &tunnel_hdr, INT_H_SIZE); 2231 skb_copy_to_linear_data_offset(outbuf, INT_H_SIZE, iter->data, 2232 length); 2233 tipc_link_send_buf(tunnel, outbuf); 2234 if (!tipc_link_is_up(l_ptr)) 2235 return; 2236 iter = iter->next; 2237 } 2238 } 2239 2240 /** 2241 * buf_extract - extracts embedded TIPC message from another message 2242 * @skb: encapsulating message buffer 2243 * @from_pos: offset to extract from 2244 * 2245 * Returns a new message buffer containing an embedded message. The 2246 * encapsulating message itself is left unchanged. 2247 */ 2248 static struct sk_buff *buf_extract(struct sk_buff *skb, u32 from_pos) 2249 { 2250 struct tipc_msg *msg = (struct tipc_msg *)(skb->data + from_pos); 2251 u32 size = msg_size(msg); 2252 struct sk_buff *eb; 2253 2254 eb = tipc_buf_acquire(size); 2255 if (eb) 2256 skb_copy_to_linear_data(eb, msg, size); 2257 return eb; 2258 } 2259 2260 /* 2261 * link_recv_changeover_msg(): Receive tunneled packet sent 2262 * via other link. Node is locked. Return extracted buffer. 2263 */ 2264 static int link_recv_changeover_msg(struct tipc_link **l_ptr, 2265 struct sk_buff **buf) 2266 { 2267 struct sk_buff *tunnel_buf = *buf; 2268 struct tipc_link *dest_link; 2269 struct tipc_msg *msg; 2270 struct tipc_msg *tunnel_msg = buf_msg(tunnel_buf); 2271 u32 msg_typ = msg_type(tunnel_msg); 2272 u32 msg_count = msg_msgcnt(tunnel_msg); 2273 u32 bearer_id = msg_bearer_id(tunnel_msg); 2274 2275 if (bearer_id >= MAX_BEARERS) 2276 goto exit; 2277 dest_link = (*l_ptr)->owner->links[bearer_id]; 2278 if (!dest_link) 2279 goto exit; 2280 if (dest_link == *l_ptr) { 2281 pr_err("Unexpected changeover message on link <%s>\n", 2282 (*l_ptr)->name); 2283 goto exit; 2284 } 2285 *l_ptr = dest_link; 2286 msg = msg_get_wrapped(tunnel_msg); 2287 2288 if (msg_typ == DUPLICATE_MSG) { 2289 if (less(msg_seqno(msg), mod(dest_link->next_in_no))) 2290 goto exit; 2291 *buf = buf_extract(tunnel_buf, INT_H_SIZE); 2292 if (*buf == NULL) { 2293 pr_warn("%sduplicate msg dropped\n", link_co_err); 2294 goto exit; 2295 } 2296 kfree_skb(tunnel_buf); 2297 return 1; 2298 } 2299 2300 /* First original message ?: */ 2301 if (tipc_link_is_up(dest_link)) { 2302 pr_info("%s<%s>, changeover initiated by peer\n", link_rst_msg, 2303 dest_link->name); 2304 tipc_link_reset(dest_link); 2305 dest_link->exp_msg_count = msg_count; 2306 if (!msg_count) 2307 goto exit; 2308 } else if (dest_link->exp_msg_count == START_CHANGEOVER) { 2309 dest_link->exp_msg_count = msg_count; 2310 if (!msg_count) 2311 goto exit; 2312 } 2313 2314 /* Receive original message */ 2315 if (dest_link->exp_msg_count == 0) { 2316 pr_warn("%sgot too many tunnelled messages\n", link_co_err); 2317 goto exit; 2318 } 2319 dest_link->exp_msg_count--; 2320 if (less(msg_seqno(msg), dest_link->reset_checkpoint)) { 2321 goto exit; 2322 } else { 2323 *buf = buf_extract(tunnel_buf, INT_H_SIZE); 2324 if (*buf != NULL) { 2325 kfree_skb(tunnel_buf); 2326 return 1; 2327 } else { 2328 pr_warn("%soriginal msg dropped\n", link_co_err); 2329 } 2330 } 2331 exit: 2332 *buf = NULL; 2333 kfree_skb(tunnel_buf); 2334 return 0; 2335 } 2336 2337 /* 2338 * Bundler functionality: 2339 */ 2340 void tipc_link_recv_bundle(struct sk_buff *buf) 2341 { 2342 u32 msgcount = msg_msgcnt(buf_msg(buf)); 2343 u32 pos = INT_H_SIZE; 2344 struct sk_buff *obuf; 2345 2346 while (msgcount--) { 2347 obuf = buf_extract(buf, pos); 2348 if (obuf == NULL) { 2349 pr_warn("Link unable to unbundle message(s)\n"); 2350 break; 2351 } 2352 pos += align(msg_size(buf_msg(obuf))); 2353 tipc_net_route_msg(obuf); 2354 } 2355 kfree_skb(buf); 2356 } 2357 2358 /* 2359 * Fragmentation/defragmentation: 2360 */ 2361 2362 /* 2363 * link_send_long_buf: Entry for buffers needing fragmentation. 2364 * The buffer is complete, inclusive total message length. 2365 * Returns user data length. 2366 */ 2367 static int link_send_long_buf(struct tipc_link *l_ptr, struct sk_buff *buf) 2368 { 2369 struct sk_buff *buf_chain = NULL; 2370 struct sk_buff *buf_chain_tail = (struct sk_buff *)&buf_chain; 2371 struct tipc_msg *inmsg = buf_msg(buf); 2372 struct tipc_msg fragm_hdr; 2373 u32 insize = msg_size(inmsg); 2374 u32 dsz = msg_data_sz(inmsg); 2375 unchar *crs = buf->data; 2376 u32 rest = insize; 2377 u32 pack_sz = l_ptr->max_pkt; 2378 u32 fragm_sz = pack_sz - INT_H_SIZE; 2379 u32 fragm_no = 0; 2380 u32 destaddr; 2381 2382 if (msg_short(inmsg)) 2383 destaddr = l_ptr->addr; 2384 else 2385 destaddr = msg_destnode(inmsg); 2386 2387 /* Prepare reusable fragment header: */ 2388 tipc_msg_init(&fragm_hdr, MSG_FRAGMENTER, FIRST_FRAGMENT, 2389 INT_H_SIZE, destaddr); 2390 2391 /* Chop up message: */ 2392 while (rest > 0) { 2393 struct sk_buff *fragm; 2394 2395 if (rest <= fragm_sz) { 2396 fragm_sz = rest; 2397 msg_set_type(&fragm_hdr, LAST_FRAGMENT); 2398 } 2399 fragm = tipc_buf_acquire(fragm_sz + INT_H_SIZE); 2400 if (fragm == NULL) { 2401 kfree_skb(buf); 2402 while (buf_chain) { 2403 buf = buf_chain; 2404 buf_chain = buf_chain->next; 2405 kfree_skb(buf); 2406 } 2407 return -ENOMEM; 2408 } 2409 msg_set_size(&fragm_hdr, fragm_sz + INT_H_SIZE); 2410 fragm_no++; 2411 msg_set_fragm_no(&fragm_hdr, fragm_no); 2412 skb_copy_to_linear_data(fragm, &fragm_hdr, INT_H_SIZE); 2413 skb_copy_to_linear_data_offset(fragm, INT_H_SIZE, crs, 2414 fragm_sz); 2415 buf_chain_tail->next = fragm; 2416 buf_chain_tail = fragm; 2417 2418 rest -= fragm_sz; 2419 crs += fragm_sz; 2420 msg_set_type(&fragm_hdr, FRAGMENT); 2421 } 2422 kfree_skb(buf); 2423 2424 /* Append chain of fragments to send queue & send them */ 2425 l_ptr->long_msg_seq_no++; 2426 link_add_chain_to_outqueue(l_ptr, buf_chain, l_ptr->long_msg_seq_no); 2427 l_ptr->stats.sent_fragments += fragm_no; 2428 l_ptr->stats.sent_fragmented++; 2429 tipc_link_push_queue(l_ptr); 2430 2431 return dsz; 2432 } 2433 2434 /* 2435 * A pending message being re-assembled must store certain values 2436 * to handle subsequent fragments correctly. The following functions 2437 * help storing these values in unused, available fields in the 2438 * pending message. This makes dynamic memory allocation unnecessary. 2439 */ 2440 static void set_long_msg_seqno(struct sk_buff *buf, u32 seqno) 2441 { 2442 msg_set_seqno(buf_msg(buf), seqno); 2443 } 2444 2445 static u32 get_fragm_size(struct sk_buff *buf) 2446 { 2447 return msg_ack(buf_msg(buf)); 2448 } 2449 2450 static void set_fragm_size(struct sk_buff *buf, u32 sz) 2451 { 2452 msg_set_ack(buf_msg(buf), sz); 2453 } 2454 2455 static u32 get_expected_frags(struct sk_buff *buf) 2456 { 2457 return msg_bcast_ack(buf_msg(buf)); 2458 } 2459 2460 static void set_expected_frags(struct sk_buff *buf, u32 exp) 2461 { 2462 msg_set_bcast_ack(buf_msg(buf), exp); 2463 } 2464 2465 /* 2466 * tipc_link_recv_fragment(): Called with node lock on. Returns 2467 * the reassembled buffer if message is complete. 2468 */ 2469 int tipc_link_recv_fragment(struct sk_buff **pending, struct sk_buff **fb, 2470 struct tipc_msg **m) 2471 { 2472 struct sk_buff *prev = NULL; 2473 struct sk_buff *fbuf = *fb; 2474 struct tipc_msg *fragm = buf_msg(fbuf); 2475 struct sk_buff *pbuf = *pending; 2476 u32 long_msg_seq_no = msg_long_msgno(fragm); 2477 2478 *fb = NULL; 2479 2480 /* Is there an incomplete message waiting for this fragment? */ 2481 while (pbuf && ((buf_seqno(pbuf) != long_msg_seq_no) || 2482 (msg_orignode(fragm) != msg_orignode(buf_msg(pbuf))))) { 2483 prev = pbuf; 2484 pbuf = pbuf->next; 2485 } 2486 2487 if (!pbuf && (msg_type(fragm) == FIRST_FRAGMENT)) { 2488 struct tipc_msg *imsg = (struct tipc_msg *)msg_data(fragm); 2489 u32 msg_sz = msg_size(imsg); 2490 u32 fragm_sz = msg_data_sz(fragm); 2491 u32 exp_fragm_cnt; 2492 u32 max = TIPC_MAX_USER_MSG_SIZE + NAMED_H_SIZE; 2493 2494 if (msg_type(imsg) == TIPC_MCAST_MSG) 2495 max = TIPC_MAX_USER_MSG_SIZE + MCAST_H_SIZE; 2496 if (fragm_sz == 0 || msg_size(imsg) > max) { 2497 kfree_skb(fbuf); 2498 return 0; 2499 } 2500 exp_fragm_cnt = msg_sz / fragm_sz + !!(msg_sz % fragm_sz); 2501 pbuf = tipc_buf_acquire(msg_size(imsg)); 2502 if (pbuf != NULL) { 2503 pbuf->next = *pending; 2504 *pending = pbuf; 2505 skb_copy_to_linear_data(pbuf, imsg, 2506 msg_data_sz(fragm)); 2507 /* Prepare buffer for subsequent fragments. */ 2508 set_long_msg_seqno(pbuf, long_msg_seq_no); 2509 set_fragm_size(pbuf, fragm_sz); 2510 set_expected_frags(pbuf, exp_fragm_cnt - 1); 2511 } else { 2512 pr_debug("Link unable to reassemble fragmented message\n"); 2513 kfree_skb(fbuf); 2514 return -1; 2515 } 2516 kfree_skb(fbuf); 2517 return 0; 2518 } else if (pbuf && (msg_type(fragm) != FIRST_FRAGMENT)) { 2519 u32 dsz = msg_data_sz(fragm); 2520 u32 fsz = get_fragm_size(pbuf); 2521 u32 crs = ((msg_fragm_no(fragm) - 1) * fsz); 2522 u32 exp_frags = get_expected_frags(pbuf) - 1; 2523 skb_copy_to_linear_data_offset(pbuf, crs, 2524 msg_data(fragm), dsz); 2525 kfree_skb(fbuf); 2526 2527 /* Is message complete? */ 2528 if (exp_frags == 0) { 2529 if (prev) 2530 prev->next = pbuf->next; 2531 else 2532 *pending = pbuf->next; 2533 msg_reset_reroute_cnt(buf_msg(pbuf)); 2534 *fb = pbuf; 2535 *m = buf_msg(pbuf); 2536 return 1; 2537 } 2538 set_expected_frags(pbuf, exp_frags); 2539 return 0; 2540 } 2541 kfree_skb(fbuf); 2542 return 0; 2543 } 2544 2545 static void link_set_supervision_props(struct tipc_link *l_ptr, u32 tolerance) 2546 { 2547 if ((tolerance < TIPC_MIN_LINK_TOL) || (tolerance > TIPC_MAX_LINK_TOL)) 2548 return; 2549 2550 l_ptr->tolerance = tolerance; 2551 l_ptr->continuity_interval = 2552 ((tolerance / 4) > 500) ? 500 : tolerance / 4; 2553 l_ptr->abort_limit = tolerance / (l_ptr->continuity_interval / 4); 2554 } 2555 2556 void tipc_link_set_queue_limits(struct tipc_link *l_ptr, u32 window) 2557 { 2558 /* Data messages from this node, inclusive FIRST_FRAGM */ 2559 l_ptr->queue_limit[TIPC_LOW_IMPORTANCE] = window; 2560 l_ptr->queue_limit[TIPC_MEDIUM_IMPORTANCE] = (window / 3) * 4; 2561 l_ptr->queue_limit[TIPC_HIGH_IMPORTANCE] = (window / 3) * 5; 2562 l_ptr->queue_limit[TIPC_CRITICAL_IMPORTANCE] = (window / 3) * 6; 2563 /* Transiting data messages,inclusive FIRST_FRAGM */ 2564 l_ptr->queue_limit[TIPC_LOW_IMPORTANCE + 4] = 300; 2565 l_ptr->queue_limit[TIPC_MEDIUM_IMPORTANCE + 4] = 600; 2566 l_ptr->queue_limit[TIPC_HIGH_IMPORTANCE + 4] = 900; 2567 l_ptr->queue_limit[TIPC_CRITICAL_IMPORTANCE + 4] = 1200; 2568 l_ptr->queue_limit[CONN_MANAGER] = 1200; 2569 l_ptr->queue_limit[CHANGEOVER_PROTOCOL] = 2500; 2570 l_ptr->queue_limit[NAME_DISTRIBUTOR] = 3000; 2571 /* FRAGMENT and LAST_FRAGMENT packets */ 2572 l_ptr->queue_limit[MSG_FRAGMENTER] = 4000; 2573 } 2574 2575 /** 2576 * link_find_link - locate link by name 2577 * @name: ptr to link name string 2578 * @node: ptr to area to be filled with ptr to associated node 2579 * 2580 * Caller must hold 'tipc_net_lock' to ensure node and bearer are not deleted; 2581 * this also prevents link deletion. 2582 * 2583 * Returns pointer to link (or 0 if invalid link name). 2584 */ 2585 static struct tipc_link *link_find_link(const char *name, 2586 struct tipc_node **node) 2587 { 2588 struct tipc_link_name link_name_parts; 2589 struct tipc_bearer *b_ptr; 2590 struct tipc_link *l_ptr; 2591 2592 if (!link_name_validate(name, &link_name_parts)) 2593 return NULL; 2594 2595 b_ptr = tipc_bearer_find_interface(link_name_parts.if_local); 2596 if (!b_ptr) 2597 return NULL; 2598 2599 *node = tipc_node_find(link_name_parts.addr_peer); 2600 if (!*node) 2601 return NULL; 2602 2603 l_ptr = (*node)->links[b_ptr->identity]; 2604 if (!l_ptr || strcmp(l_ptr->name, name)) 2605 return NULL; 2606 2607 return l_ptr; 2608 } 2609 2610 /** 2611 * link_value_is_valid -- validate proposed link tolerance/priority/window 2612 * 2613 * @cmd: value type (TIPC_CMD_SET_LINK_*) 2614 * @new_value: the new value 2615 * 2616 * Returns 1 if value is within range, 0 if not. 2617 */ 2618 static int link_value_is_valid(u16 cmd, u32 new_value) 2619 { 2620 switch (cmd) { 2621 case TIPC_CMD_SET_LINK_TOL: 2622 return (new_value >= TIPC_MIN_LINK_TOL) && 2623 (new_value <= TIPC_MAX_LINK_TOL); 2624 case TIPC_CMD_SET_LINK_PRI: 2625 return (new_value <= TIPC_MAX_LINK_PRI); 2626 case TIPC_CMD_SET_LINK_WINDOW: 2627 return (new_value >= TIPC_MIN_LINK_WIN) && 2628 (new_value <= TIPC_MAX_LINK_WIN); 2629 } 2630 return 0; 2631 } 2632 2633 /** 2634 * link_cmd_set_value - change priority/tolerance/window for link/bearer/media 2635 * @name: ptr to link, bearer, or media name 2636 * @new_value: new value of link, bearer, or media setting 2637 * @cmd: which link, bearer, or media attribute to set (TIPC_CMD_SET_LINK_*) 2638 * 2639 * Caller must hold 'tipc_net_lock' to ensure link/bearer/media is not deleted. 2640 * 2641 * Returns 0 if value updated and negative value on error. 2642 */ 2643 static int link_cmd_set_value(const char *name, u32 new_value, u16 cmd) 2644 { 2645 struct tipc_node *node; 2646 struct tipc_link *l_ptr; 2647 struct tipc_bearer *b_ptr; 2648 struct tipc_media *m_ptr; 2649 2650 l_ptr = link_find_link(name, &node); 2651 if (l_ptr) { 2652 /* 2653 * acquire node lock for tipc_link_send_proto_msg(). 2654 * see "TIPC locking policy" in net.c. 2655 */ 2656 tipc_node_lock(node); 2657 switch (cmd) { 2658 case TIPC_CMD_SET_LINK_TOL: 2659 link_set_supervision_props(l_ptr, new_value); 2660 tipc_link_send_proto_msg(l_ptr, 2661 STATE_MSG, 0, 0, new_value, 0, 0); 2662 break; 2663 case TIPC_CMD_SET_LINK_PRI: 2664 l_ptr->priority = new_value; 2665 tipc_link_send_proto_msg(l_ptr, 2666 STATE_MSG, 0, 0, 0, new_value, 0); 2667 break; 2668 case TIPC_CMD_SET_LINK_WINDOW: 2669 tipc_link_set_queue_limits(l_ptr, new_value); 2670 break; 2671 } 2672 tipc_node_unlock(node); 2673 return 0; 2674 } 2675 2676 b_ptr = tipc_bearer_find(name); 2677 if (b_ptr) { 2678 switch (cmd) { 2679 case TIPC_CMD_SET_LINK_TOL: 2680 b_ptr->tolerance = new_value; 2681 return 0; 2682 case TIPC_CMD_SET_LINK_PRI: 2683 b_ptr->priority = new_value; 2684 return 0; 2685 case TIPC_CMD_SET_LINK_WINDOW: 2686 b_ptr->window = new_value; 2687 return 0; 2688 } 2689 return -EINVAL; 2690 } 2691 2692 m_ptr = tipc_media_find(name); 2693 if (!m_ptr) 2694 return -ENODEV; 2695 switch (cmd) { 2696 case TIPC_CMD_SET_LINK_TOL: 2697 m_ptr->tolerance = new_value; 2698 return 0; 2699 case TIPC_CMD_SET_LINK_PRI: 2700 m_ptr->priority = new_value; 2701 return 0; 2702 case TIPC_CMD_SET_LINK_WINDOW: 2703 m_ptr->window = new_value; 2704 return 0; 2705 } 2706 return -EINVAL; 2707 } 2708 2709 struct sk_buff *tipc_link_cmd_config(const void *req_tlv_area, int req_tlv_space, 2710 u16 cmd) 2711 { 2712 struct tipc_link_config *args; 2713 u32 new_value; 2714 int res; 2715 2716 if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_LINK_CONFIG)) 2717 return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR); 2718 2719 args = (struct tipc_link_config *)TLV_DATA(req_tlv_area); 2720 new_value = ntohl(args->value); 2721 2722 if (!link_value_is_valid(cmd, new_value)) 2723 return tipc_cfg_reply_error_string( 2724 "cannot change, value invalid"); 2725 2726 if (!strcmp(args->name, tipc_bclink_name)) { 2727 if ((cmd == TIPC_CMD_SET_LINK_WINDOW) && 2728 (tipc_bclink_set_queue_limits(new_value) == 0)) 2729 return tipc_cfg_reply_none(); 2730 return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED 2731 " (cannot change setting on broadcast link)"); 2732 } 2733 2734 read_lock_bh(&tipc_net_lock); 2735 res = link_cmd_set_value(args->name, new_value, cmd); 2736 read_unlock_bh(&tipc_net_lock); 2737 if (res) 2738 return tipc_cfg_reply_error_string("cannot change link setting"); 2739 2740 return tipc_cfg_reply_none(); 2741 } 2742 2743 /** 2744 * link_reset_statistics - reset link statistics 2745 * @l_ptr: pointer to link 2746 */ 2747 static void link_reset_statistics(struct tipc_link *l_ptr) 2748 { 2749 memset(&l_ptr->stats, 0, sizeof(l_ptr->stats)); 2750 l_ptr->stats.sent_info = l_ptr->next_out_no; 2751 l_ptr->stats.recv_info = l_ptr->next_in_no; 2752 } 2753 2754 struct sk_buff *tipc_link_cmd_reset_stats(const void *req_tlv_area, int req_tlv_space) 2755 { 2756 char *link_name; 2757 struct tipc_link *l_ptr; 2758 struct tipc_node *node; 2759 2760 if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_LINK_NAME)) 2761 return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR); 2762 2763 link_name = (char *)TLV_DATA(req_tlv_area); 2764 if (!strcmp(link_name, tipc_bclink_name)) { 2765 if (tipc_bclink_reset_stats()) 2766 return tipc_cfg_reply_error_string("link not found"); 2767 return tipc_cfg_reply_none(); 2768 } 2769 2770 read_lock_bh(&tipc_net_lock); 2771 l_ptr = link_find_link(link_name, &node); 2772 if (!l_ptr) { 2773 read_unlock_bh(&tipc_net_lock); 2774 return tipc_cfg_reply_error_string("link not found"); 2775 } 2776 2777 tipc_node_lock(node); 2778 link_reset_statistics(l_ptr); 2779 tipc_node_unlock(node); 2780 read_unlock_bh(&tipc_net_lock); 2781 return tipc_cfg_reply_none(); 2782 } 2783 2784 /** 2785 * percent - convert count to a percentage of total (rounding up or down) 2786 */ 2787 static u32 percent(u32 count, u32 total) 2788 { 2789 return (count * 100 + (total / 2)) / total; 2790 } 2791 2792 /** 2793 * tipc_link_stats - print link statistics 2794 * @name: link name 2795 * @buf: print buffer area 2796 * @buf_size: size of print buffer area 2797 * 2798 * Returns length of print buffer data string (or 0 if error) 2799 */ 2800 static int tipc_link_stats(const char *name, char *buf, const u32 buf_size) 2801 { 2802 struct tipc_link *l; 2803 struct tipc_stats *s; 2804 struct tipc_node *node; 2805 char *status; 2806 u32 profile_total = 0; 2807 int ret; 2808 2809 if (!strcmp(name, tipc_bclink_name)) 2810 return tipc_bclink_stats(buf, buf_size); 2811 2812 read_lock_bh(&tipc_net_lock); 2813 l = link_find_link(name, &node); 2814 if (!l) { 2815 read_unlock_bh(&tipc_net_lock); 2816 return 0; 2817 } 2818 tipc_node_lock(node); 2819 s = &l->stats; 2820 2821 if (tipc_link_is_active(l)) 2822 status = "ACTIVE"; 2823 else if (tipc_link_is_up(l)) 2824 status = "STANDBY"; 2825 else 2826 status = "DEFUNCT"; 2827 2828 ret = tipc_snprintf(buf, buf_size, "Link <%s>\n" 2829 " %s MTU:%u Priority:%u Tolerance:%u ms" 2830 " Window:%u packets\n", 2831 l->name, status, l->max_pkt, l->priority, 2832 l->tolerance, l->queue_limit[0]); 2833 2834 ret += tipc_snprintf(buf + ret, buf_size - ret, 2835 " RX packets:%u fragments:%u/%u bundles:%u/%u\n", 2836 l->next_in_no - s->recv_info, s->recv_fragments, 2837 s->recv_fragmented, s->recv_bundles, 2838 s->recv_bundled); 2839 2840 ret += tipc_snprintf(buf + ret, buf_size - ret, 2841 " TX packets:%u fragments:%u/%u bundles:%u/%u\n", 2842 l->next_out_no - s->sent_info, s->sent_fragments, 2843 s->sent_fragmented, s->sent_bundles, 2844 s->sent_bundled); 2845 2846 profile_total = s->msg_length_counts; 2847 if (!profile_total) 2848 profile_total = 1; 2849 2850 ret += tipc_snprintf(buf + ret, buf_size - ret, 2851 " TX profile sample:%u packets average:%u octets\n" 2852 " 0-64:%u%% -256:%u%% -1024:%u%% -4096:%u%% " 2853 "-16384:%u%% -32768:%u%% -66000:%u%%\n", 2854 s->msg_length_counts, 2855 s->msg_lengths_total / profile_total, 2856 percent(s->msg_length_profile[0], profile_total), 2857 percent(s->msg_length_profile[1], profile_total), 2858 percent(s->msg_length_profile[2], profile_total), 2859 percent(s->msg_length_profile[3], profile_total), 2860 percent(s->msg_length_profile[4], profile_total), 2861 percent(s->msg_length_profile[5], profile_total), 2862 percent(s->msg_length_profile[6], profile_total)); 2863 2864 ret += tipc_snprintf(buf + ret, buf_size - ret, 2865 " RX states:%u probes:%u naks:%u defs:%u" 2866 " dups:%u\n", s->recv_states, s->recv_probes, 2867 s->recv_nacks, s->deferred_recv, s->duplicates); 2868 2869 ret += tipc_snprintf(buf + ret, buf_size - ret, 2870 " TX states:%u probes:%u naks:%u acks:%u" 2871 " dups:%u\n", s->sent_states, s->sent_probes, 2872 s->sent_nacks, s->sent_acks, s->retransmitted); 2873 2874 ret += tipc_snprintf(buf + ret, buf_size - ret, 2875 " Congestion link:%u Send queue" 2876 " max:%u avg:%u\n", s->link_congs, 2877 s->max_queue_sz, s->queue_sz_counts ? 2878 (s->accu_queue_sz / s->queue_sz_counts) : 0); 2879 2880 tipc_node_unlock(node); 2881 read_unlock_bh(&tipc_net_lock); 2882 return ret; 2883 } 2884 2885 struct sk_buff *tipc_link_cmd_show_stats(const void *req_tlv_area, int req_tlv_space) 2886 { 2887 struct sk_buff *buf; 2888 struct tlv_desc *rep_tlv; 2889 int str_len; 2890 int pb_len; 2891 char *pb; 2892 2893 if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_LINK_NAME)) 2894 return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR); 2895 2896 buf = tipc_cfg_reply_alloc(TLV_SPACE(ULTRA_STRING_MAX_LEN)); 2897 if (!buf) 2898 return NULL; 2899 2900 rep_tlv = (struct tlv_desc *)buf->data; 2901 pb = TLV_DATA(rep_tlv); 2902 pb_len = ULTRA_STRING_MAX_LEN; 2903 str_len = tipc_link_stats((char *)TLV_DATA(req_tlv_area), 2904 pb, pb_len); 2905 if (!str_len) { 2906 kfree_skb(buf); 2907 return tipc_cfg_reply_error_string("link not found"); 2908 } 2909 str_len += 1; /* for "\0" */ 2910 skb_put(buf, TLV_SPACE(str_len)); 2911 TLV_SET(rep_tlv, TIPC_TLV_ULTRA_STRING, NULL, str_len); 2912 2913 return buf; 2914 } 2915 2916 /** 2917 * tipc_link_get_max_pkt - get maximum packet size to use when sending to destination 2918 * @dest: network address of destination node 2919 * @selector: used to select from set of active links 2920 * 2921 * If no active link can be found, uses default maximum packet size. 2922 */ 2923 u32 tipc_link_get_max_pkt(u32 dest, u32 selector) 2924 { 2925 struct tipc_node *n_ptr; 2926 struct tipc_link *l_ptr; 2927 u32 res = MAX_PKT_DEFAULT; 2928 2929 if (dest == tipc_own_addr) 2930 return MAX_MSG_SIZE; 2931 2932 read_lock_bh(&tipc_net_lock); 2933 n_ptr = tipc_node_find(dest); 2934 if (n_ptr) { 2935 tipc_node_lock(n_ptr); 2936 l_ptr = n_ptr->active_links[selector & 1]; 2937 if (l_ptr) 2938 res = l_ptr->max_pkt; 2939 tipc_node_unlock(n_ptr); 2940 } 2941 read_unlock_bh(&tipc_net_lock); 2942 return res; 2943 } 2944 2945 static void link_print(struct tipc_link *l_ptr, const char *str) 2946 { 2947 pr_info("%s Link %x<%s>:", str, l_ptr->addr, l_ptr->b_ptr->name); 2948 2949 if (link_working_unknown(l_ptr)) 2950 pr_cont(":WU\n"); 2951 else if (link_reset_reset(l_ptr)) 2952 pr_cont(":RR\n"); 2953 else if (link_reset_unknown(l_ptr)) 2954 pr_cont(":RU\n"); 2955 else if (link_working_working(l_ptr)) 2956 pr_cont(":WW\n"); 2957 else 2958 pr_cont("\n"); 2959 } 2960