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