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