Pileus Git - ~andy/linux/blob - net/tipc/link.c

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