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