2 * net/tipc/link.c: TIPC link code
4 * Copyright (c) 1996-2007, 2012-2014, Ericsson AB
5 * Copyright (c) 2004-2007, 2010-2013, Wind River Systems
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are met:
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.
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.
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.
40 #include "name_distr.h"
44 #include <linux/pkt_sched.h>
47 * Error message prefixes
49 static const char *link_co_err
= "Link changeover error, ";
50 static const char *link_rst_msg
= "Resetting link ";
51 static const char *link_unk_evt
= "Unknown link event ";
54 * Out-of-range value for link session numbers
56 #define INVALID_SESSION 0x10000
61 #define STARTING_EVT 856384768 /* link processing trigger */
62 #define TRAFFIC_MSG_EVT 560815u /* rx'd ??? */
63 #define TIMEOUT_EVT 560817u /* link timer expired */
66 * The following two 'message types' is really just implementation
67 * data conveniently stored in the message header.
68 * They must not be considered part of the protocol
74 * State value stored in 'exp_msg_count'
76 #define START_CHANGEOVER 100000u
78 static void link_handle_out_of_seq_msg(struct tipc_link
*l_ptr
,
80 static void tipc_link_proto_rcv(struct tipc_link
*l_ptr
, struct sk_buff
*buf
);
81 static int tipc_link_tunnel_rcv(struct tipc_node
*n_ptr
,
82 struct sk_buff
**buf
);
83 static void link_set_supervision_props(struct tipc_link
*l_ptr
, u32 tolerance
);
84 static int tipc_link_iovec_long_xmit(struct tipc_port
*sender
,
85 struct iovec
const *msg_sect
,
86 unsigned int len
, u32 destnode
);
87 static void link_state_event(struct tipc_link
*l_ptr
, u32 event
);
88 static void link_reset_statistics(struct tipc_link
*l_ptr
);
89 static void link_print(struct tipc_link
*l_ptr
, const char *str
);
90 static int tipc_link_frag_xmit(struct tipc_link
*l_ptr
, struct sk_buff
*buf
);
91 static void tipc_link_sync_xmit(struct tipc_link
*l
);
92 static void tipc_link_sync_rcv(struct tipc_node
*n
, struct sk_buff
*buf
);
95 * Simple link routines
97 static unsigned int align(unsigned int i
)
102 static void link_init_max_pkt(struct tipc_link
*l_ptr
)
104 struct tipc_bearer
*b_ptr
;
108 b_ptr
= rcu_dereference_rtnl(bearer_list
[l_ptr
->bearer_id
]);
113 max_pkt
= (b_ptr
->mtu
& ~3);
116 if (max_pkt
> MAX_MSG_SIZE
)
117 max_pkt
= MAX_MSG_SIZE
;
119 l_ptr
->max_pkt_target
= max_pkt
;
120 if (l_ptr
->max_pkt_target
< MAX_PKT_DEFAULT
)
121 l_ptr
->max_pkt
= l_ptr
->max_pkt_target
;
123 l_ptr
->max_pkt
= MAX_PKT_DEFAULT
;
125 l_ptr
->max_pkt_probes
= 0;
128 static u32
link_next_sent(struct tipc_link
*l_ptr
)
131 return buf_seqno(l_ptr
->next_out
);
132 return mod(l_ptr
->next_out_no
);
135 static u32
link_last_sent(struct tipc_link
*l_ptr
)
137 return mod(link_next_sent(l_ptr
) - 1);
141 * Simple non-static link routines (i.e. referenced outside this file)
143 int tipc_link_is_up(struct tipc_link
*l_ptr
)
147 return link_working_working(l_ptr
) || link_working_unknown(l_ptr
);
150 int tipc_link_is_active(struct tipc_link
*l_ptr
)
152 return (l_ptr
->owner
->active_links
[0] == l_ptr
) ||
153 (l_ptr
->owner
->active_links
[1] == l_ptr
);
157 * link_timeout - handle expiration of link timer
158 * @l_ptr: pointer to link
160 static void link_timeout(struct tipc_link
*l_ptr
)
162 tipc_node_lock(l_ptr
->owner
);
164 /* update counters used in statistical profiling of send traffic */
165 l_ptr
->stats
.accu_queue_sz
+= l_ptr
->out_queue_size
;
166 l_ptr
->stats
.queue_sz_counts
++;
168 if (l_ptr
->first_out
) {
169 struct tipc_msg
*msg
= buf_msg(l_ptr
->first_out
);
170 u32 length
= msg_size(msg
);
172 if ((msg_user(msg
) == MSG_FRAGMENTER
) &&
173 (msg_type(msg
) == FIRST_FRAGMENT
)) {
174 length
= msg_size(msg_get_wrapped(msg
));
177 l_ptr
->stats
.msg_lengths_total
+= length
;
178 l_ptr
->stats
.msg_length_counts
++;
180 l_ptr
->stats
.msg_length_profile
[0]++;
181 else if (length
<= 256)
182 l_ptr
->stats
.msg_length_profile
[1]++;
183 else if (length
<= 1024)
184 l_ptr
->stats
.msg_length_profile
[2]++;
185 else if (length
<= 4096)
186 l_ptr
->stats
.msg_length_profile
[3]++;
187 else if (length
<= 16384)
188 l_ptr
->stats
.msg_length_profile
[4]++;
189 else if (length
<= 32768)
190 l_ptr
->stats
.msg_length_profile
[5]++;
192 l_ptr
->stats
.msg_length_profile
[6]++;
196 /* do all other link processing performed on a periodic basis */
198 link_state_event(l_ptr
, TIMEOUT_EVT
);
201 tipc_link_push_queue(l_ptr
);
203 tipc_node_unlock(l_ptr
->owner
);
206 static void link_set_timer(struct tipc_link
*l_ptr
, u32 time
)
208 k_start_timer(&l_ptr
->timer
, time
);
212 * tipc_link_create - create a new link
213 * @n_ptr: pointer to associated node
214 * @b_ptr: pointer to associated bearer
215 * @media_addr: media address to use when sending messages over link
217 * Returns pointer to link.
219 struct tipc_link
*tipc_link_create(struct tipc_node
*n_ptr
,
220 struct tipc_bearer
*b_ptr
,
221 const struct tipc_media_addr
*media_addr
)
223 struct tipc_link
*l_ptr
;
224 struct tipc_msg
*msg
;
226 char addr_string
[16];
227 u32 peer
= n_ptr
->addr
;
229 if (n_ptr
->link_cnt
>= 2) {
230 tipc_addr_string_fill(addr_string
, n_ptr
->addr
);
231 pr_err("Attempt to establish third link to %s\n", addr_string
);
235 if (n_ptr
->links
[b_ptr
->identity
]) {
236 tipc_addr_string_fill(addr_string
, n_ptr
->addr
);
237 pr_err("Attempt to establish second link on <%s> to %s\n",
238 b_ptr
->name
, addr_string
);
242 l_ptr
= kzalloc(sizeof(*l_ptr
), GFP_ATOMIC
);
244 pr_warn("Link creation failed, no memory\n");
249 if_name
= strchr(b_ptr
->name
, ':') + 1;
250 sprintf(l_ptr
->name
, "%u.%u.%u:%s-%u.%u.%u:unknown",
251 tipc_zone(tipc_own_addr
), tipc_cluster(tipc_own_addr
),
252 tipc_node(tipc_own_addr
),
254 tipc_zone(peer
), tipc_cluster(peer
), tipc_node(peer
));
255 /* note: peer i/f name is updated by reset/activate message */
256 memcpy(&l_ptr
->media_addr
, media_addr
, sizeof(*media_addr
));
257 l_ptr
->owner
= n_ptr
;
258 l_ptr
->checkpoint
= 1;
259 l_ptr
->peer_session
= INVALID_SESSION
;
260 l_ptr
->bearer_id
= b_ptr
->identity
;
261 link_set_supervision_props(l_ptr
, b_ptr
->tolerance
);
262 l_ptr
->state
= RESET_UNKNOWN
;
264 l_ptr
->pmsg
= (struct tipc_msg
*)&l_ptr
->proto_msg
;
266 tipc_msg_init(msg
, LINK_PROTOCOL
, RESET_MSG
, INT_H_SIZE
, l_ptr
->addr
);
267 msg_set_size(msg
, sizeof(l_ptr
->proto_msg
));
268 msg_set_session(msg
, (tipc_random
& 0xffff));
269 msg_set_bearer_id(msg
, b_ptr
->identity
);
270 strcpy((char *)msg_data(msg
), if_name
);
272 l_ptr
->priority
= b_ptr
->priority
;
273 tipc_link_set_queue_limits(l_ptr
, b_ptr
->window
);
275 l_ptr
->net_plane
= b_ptr
->net_plane
;
276 link_init_max_pkt(l_ptr
);
278 l_ptr
->next_out_no
= 1;
279 INIT_LIST_HEAD(&l_ptr
->waiting_ports
);
281 link_reset_statistics(l_ptr
);
283 tipc_node_attach_link(n_ptr
, l_ptr
);
285 k_init_timer(&l_ptr
->timer
, (Handler
)link_timeout
,
286 (unsigned long)l_ptr
);
288 link_state_event(l_ptr
, STARTING_EVT
);
293 void tipc_link_delete_list(unsigned int bearer_id
, bool shutting_down
)
295 struct tipc_link
*l_ptr
;
296 struct tipc_node
*n_ptr
;
299 list_for_each_entry_rcu(n_ptr
, &tipc_node_list
, list
) {
300 spin_lock_bh(&n_ptr
->lock
);
301 l_ptr
= n_ptr
->links
[bearer_id
];
303 tipc_link_reset(l_ptr
);
304 if (shutting_down
|| !tipc_node_is_up(n_ptr
)) {
305 tipc_node_detach_link(l_ptr
->owner
, l_ptr
);
306 tipc_link_reset_fragments(l_ptr
);
307 spin_unlock_bh(&n_ptr
->lock
);
309 /* Nobody else can access this link now: */
310 del_timer_sync(&l_ptr
->timer
);
313 /* Detach/delete when failover is finished: */
314 l_ptr
->flags
|= LINK_STOPPED
;
315 spin_unlock_bh(&n_ptr
->lock
);
316 del_timer_sync(&l_ptr
->timer
);
320 spin_unlock_bh(&n_ptr
->lock
);
326 * link_schedule_port - schedule port for deferred sending
327 * @l_ptr: pointer to link
328 * @origport: reference to sending port
329 * @sz: amount of data to be sent
331 * Schedules port for renewed sending of messages after link congestion
334 static int link_schedule_port(struct tipc_link
*l_ptr
, u32 origport
, u32 sz
)
336 struct tipc_port
*p_ptr
;
338 spin_lock_bh(&tipc_port_list_lock
);
339 p_ptr
= tipc_port_lock(origport
);
341 if (!list_empty(&p_ptr
->wait_list
))
343 p_ptr
->congested
= 1;
344 p_ptr
->waiting_pkts
= 1 + ((sz
- 1) / l_ptr
->max_pkt
);
345 list_add_tail(&p_ptr
->wait_list
, &l_ptr
->waiting_ports
);
346 l_ptr
->stats
.link_congs
++;
348 tipc_port_unlock(p_ptr
);
350 spin_unlock_bh(&tipc_port_list_lock
);
354 void tipc_link_wakeup_ports(struct tipc_link
*l_ptr
, int all
)
356 struct tipc_port
*p_ptr
;
357 struct tipc_port
*temp_p_ptr
;
358 int win
= l_ptr
->queue_limit
[0] - l_ptr
->out_queue_size
;
364 if (!spin_trylock_bh(&tipc_port_list_lock
))
366 if (link_congested(l_ptr
))
368 list_for_each_entry_safe(p_ptr
, temp_p_ptr
, &l_ptr
->waiting_ports
,
372 list_del_init(&p_ptr
->wait_list
);
373 spin_lock_bh(p_ptr
->lock
);
374 p_ptr
->congested
= 0;
375 tipc_port_wakeup(p_ptr
);
376 win
-= p_ptr
->waiting_pkts
;
377 spin_unlock_bh(p_ptr
->lock
);
381 spin_unlock_bh(&tipc_port_list_lock
);
385 * link_release_outqueue - purge link's outbound message queue
386 * @l_ptr: pointer to link
388 static void link_release_outqueue(struct tipc_link
*l_ptr
)
390 kfree_skb_list(l_ptr
->first_out
);
391 l_ptr
->first_out
= NULL
;
392 l_ptr
->out_queue_size
= 0;
396 * tipc_link_reset_fragments - purge link's inbound message fragments queue
397 * @l_ptr: pointer to link
399 void tipc_link_reset_fragments(struct tipc_link
*l_ptr
)
401 kfree_skb(l_ptr
->reasm_head
);
402 l_ptr
->reasm_head
= NULL
;
403 l_ptr
->reasm_tail
= NULL
;
407 * tipc_link_purge_queues - purge all pkt queues associated with link
408 * @l_ptr: pointer to link
410 void tipc_link_purge_queues(struct tipc_link
*l_ptr
)
412 kfree_skb_list(l_ptr
->oldest_deferred_in
);
413 kfree_skb_list(l_ptr
->first_out
);
414 tipc_link_reset_fragments(l_ptr
);
415 kfree_skb(l_ptr
->proto_msg_queue
);
416 l_ptr
->proto_msg_queue
= NULL
;
419 void tipc_link_reset(struct tipc_link
*l_ptr
)
421 u32 prev_state
= l_ptr
->state
;
422 u32 checkpoint
= l_ptr
->next_in_no
;
423 int was_active_link
= tipc_link_is_active(l_ptr
);
425 msg_set_session(l_ptr
->pmsg
, ((msg_session(l_ptr
->pmsg
) + 1) & 0xffff));
427 /* Link is down, accept any session */
428 l_ptr
->peer_session
= INVALID_SESSION
;
430 /* Prepare for max packet size negotiation */
431 link_init_max_pkt(l_ptr
);
433 l_ptr
->state
= RESET_UNKNOWN
;
435 if ((prev_state
== RESET_UNKNOWN
) || (prev_state
== RESET_RESET
))
438 tipc_node_link_down(l_ptr
->owner
, l_ptr
);
439 tipc_bearer_remove_dest(l_ptr
->bearer_id
, l_ptr
->addr
);
441 if (was_active_link
&& tipc_node_active_links(l_ptr
->owner
)) {
442 l_ptr
->reset_checkpoint
= checkpoint
;
443 l_ptr
->exp_msg_count
= START_CHANGEOVER
;
446 /* Clean up all queues: */
447 link_release_outqueue(l_ptr
);
448 kfree_skb(l_ptr
->proto_msg_queue
);
449 l_ptr
->proto_msg_queue
= NULL
;
450 kfree_skb_list(l_ptr
->oldest_deferred_in
);
451 if (!list_empty(&l_ptr
->waiting_ports
))
452 tipc_link_wakeup_ports(l_ptr
, 1);
454 l_ptr
->retransm_queue_head
= 0;
455 l_ptr
->retransm_queue_size
= 0;
456 l_ptr
->last_out
= NULL
;
457 l_ptr
->first_out
= NULL
;
458 l_ptr
->next_out
= NULL
;
459 l_ptr
->unacked_window
= 0;
460 l_ptr
->checkpoint
= 1;
461 l_ptr
->next_out_no
= 1;
462 l_ptr
->deferred_inqueue_sz
= 0;
463 l_ptr
->oldest_deferred_in
= NULL
;
464 l_ptr
->newest_deferred_in
= NULL
;
465 l_ptr
->fsm_msg_cnt
= 0;
466 l_ptr
->stale_count
= 0;
467 link_reset_statistics(l_ptr
);
470 void tipc_link_reset_list(unsigned int bearer_id
)
472 struct tipc_link
*l_ptr
;
473 struct tipc_node
*n_ptr
;
476 list_for_each_entry_rcu(n_ptr
, &tipc_node_list
, list
) {
477 spin_lock_bh(&n_ptr
->lock
);
478 l_ptr
= n_ptr
->links
[bearer_id
];
480 tipc_link_reset(l_ptr
);
481 spin_unlock_bh(&n_ptr
->lock
);
486 static void link_activate(struct tipc_link
*l_ptr
)
488 l_ptr
->next_in_no
= l_ptr
->stats
.recv_info
= 1;
489 tipc_node_link_up(l_ptr
->owner
, l_ptr
);
490 tipc_bearer_add_dest(l_ptr
->bearer_id
, l_ptr
->addr
);
494 * link_state_event - link finite state machine
495 * @l_ptr: pointer to link
496 * @event: state machine event to process
498 static void link_state_event(struct tipc_link
*l_ptr
, unsigned int event
)
500 struct tipc_link
*other
;
501 u32 cont_intv
= l_ptr
->continuity_interval
;
503 if (l_ptr
->flags
& LINK_STOPPED
)
506 if (!(l_ptr
->flags
& LINK_STARTED
) && (event
!= STARTING_EVT
))
507 return; /* Not yet. */
509 /* Check whether changeover is going on */
510 if (l_ptr
->exp_msg_count
) {
511 if (event
== TIMEOUT_EVT
)
512 link_set_timer(l_ptr
, cont_intv
);
516 switch (l_ptr
->state
) {
517 case WORKING_WORKING
:
519 case TRAFFIC_MSG_EVT
:
523 if (l_ptr
->next_in_no
!= l_ptr
->checkpoint
) {
524 l_ptr
->checkpoint
= l_ptr
->next_in_no
;
525 if (tipc_bclink_acks_missing(l_ptr
->owner
)) {
526 tipc_link_proto_xmit(l_ptr
, STATE_MSG
,
528 l_ptr
->fsm_msg_cnt
++;
529 } else if (l_ptr
->max_pkt
< l_ptr
->max_pkt_target
) {
530 tipc_link_proto_xmit(l_ptr
, STATE_MSG
,
532 l_ptr
->fsm_msg_cnt
++;
534 link_set_timer(l_ptr
, cont_intv
);
537 l_ptr
->state
= WORKING_UNKNOWN
;
538 l_ptr
->fsm_msg_cnt
= 0;
539 tipc_link_proto_xmit(l_ptr
, STATE_MSG
, 1, 0, 0, 0, 0);
540 l_ptr
->fsm_msg_cnt
++;
541 link_set_timer(l_ptr
, cont_intv
/ 4);
544 pr_info("%s<%s>, requested by peer\n", link_rst_msg
,
546 tipc_link_reset(l_ptr
);
547 l_ptr
->state
= RESET_RESET
;
548 l_ptr
->fsm_msg_cnt
= 0;
549 tipc_link_proto_xmit(l_ptr
, ACTIVATE_MSG
,
551 l_ptr
->fsm_msg_cnt
++;
552 link_set_timer(l_ptr
, cont_intv
);
555 pr_err("%s%u in WW state\n", link_unk_evt
, event
);
558 case WORKING_UNKNOWN
:
560 case TRAFFIC_MSG_EVT
:
562 l_ptr
->state
= WORKING_WORKING
;
563 l_ptr
->fsm_msg_cnt
= 0;
564 link_set_timer(l_ptr
, cont_intv
);
567 pr_info("%s<%s>, requested by peer while probing\n",
568 link_rst_msg
, l_ptr
->name
);
569 tipc_link_reset(l_ptr
);
570 l_ptr
->state
= RESET_RESET
;
571 l_ptr
->fsm_msg_cnt
= 0;
572 tipc_link_proto_xmit(l_ptr
, ACTIVATE_MSG
,
574 l_ptr
->fsm_msg_cnt
++;
575 link_set_timer(l_ptr
, cont_intv
);
578 if (l_ptr
->next_in_no
!= l_ptr
->checkpoint
) {
579 l_ptr
->state
= WORKING_WORKING
;
580 l_ptr
->fsm_msg_cnt
= 0;
581 l_ptr
->checkpoint
= l_ptr
->next_in_no
;
582 if (tipc_bclink_acks_missing(l_ptr
->owner
)) {
583 tipc_link_proto_xmit(l_ptr
, STATE_MSG
,
585 l_ptr
->fsm_msg_cnt
++;
587 link_set_timer(l_ptr
, cont_intv
);
588 } else if (l_ptr
->fsm_msg_cnt
< l_ptr
->abort_limit
) {
589 tipc_link_proto_xmit(l_ptr
, STATE_MSG
,
591 l_ptr
->fsm_msg_cnt
++;
592 link_set_timer(l_ptr
, cont_intv
/ 4);
593 } else { /* Link has failed */
594 pr_warn("%s<%s>, peer not responding\n",
595 link_rst_msg
, l_ptr
->name
);
596 tipc_link_reset(l_ptr
);
597 l_ptr
->state
= RESET_UNKNOWN
;
598 l_ptr
->fsm_msg_cnt
= 0;
599 tipc_link_proto_xmit(l_ptr
, RESET_MSG
,
601 l_ptr
->fsm_msg_cnt
++;
602 link_set_timer(l_ptr
, cont_intv
);
606 pr_err("%s%u in WU state\n", link_unk_evt
, event
);
611 case TRAFFIC_MSG_EVT
:
614 other
= l_ptr
->owner
->active_links
[0];
615 if (other
&& link_working_unknown(other
))
617 l_ptr
->state
= WORKING_WORKING
;
618 l_ptr
->fsm_msg_cnt
= 0;
619 link_activate(l_ptr
);
620 tipc_link_proto_xmit(l_ptr
, STATE_MSG
, 1, 0, 0, 0, 0);
621 l_ptr
->fsm_msg_cnt
++;
622 if (l_ptr
->owner
->working_links
== 1)
623 tipc_link_sync_xmit(l_ptr
);
624 link_set_timer(l_ptr
, cont_intv
);
627 l_ptr
->state
= RESET_RESET
;
628 l_ptr
->fsm_msg_cnt
= 0;
629 tipc_link_proto_xmit(l_ptr
, ACTIVATE_MSG
,
631 l_ptr
->fsm_msg_cnt
++;
632 link_set_timer(l_ptr
, cont_intv
);
635 l_ptr
->flags
|= LINK_STARTED
;
638 tipc_link_proto_xmit(l_ptr
, RESET_MSG
, 0, 0, 0, 0, 0);
639 l_ptr
->fsm_msg_cnt
++;
640 link_set_timer(l_ptr
, cont_intv
);
643 pr_err("%s%u in RU state\n", link_unk_evt
, event
);
648 case TRAFFIC_MSG_EVT
:
650 other
= l_ptr
->owner
->active_links
[0];
651 if (other
&& link_working_unknown(other
))
653 l_ptr
->state
= WORKING_WORKING
;
654 l_ptr
->fsm_msg_cnt
= 0;
655 link_activate(l_ptr
);
656 tipc_link_proto_xmit(l_ptr
, STATE_MSG
, 1, 0, 0, 0, 0);
657 l_ptr
->fsm_msg_cnt
++;
658 if (l_ptr
->owner
->working_links
== 1)
659 tipc_link_sync_xmit(l_ptr
);
660 link_set_timer(l_ptr
, cont_intv
);
665 tipc_link_proto_xmit(l_ptr
, ACTIVATE_MSG
,
667 l_ptr
->fsm_msg_cnt
++;
668 link_set_timer(l_ptr
, cont_intv
);
671 pr_err("%s%u in RR state\n", link_unk_evt
, event
);
675 pr_err("Unknown link state %u/%u\n", l_ptr
->state
, event
);
680 * link_bundle_buf(): Append contents of a buffer to
681 * the tail of an existing one.
683 static int link_bundle_buf(struct tipc_link
*l_ptr
, struct sk_buff
*bundler
,
686 struct tipc_msg
*bundler_msg
= buf_msg(bundler
);
687 struct tipc_msg
*msg
= buf_msg(buf
);
688 u32 size
= msg_size(msg
);
689 u32 bundle_size
= msg_size(bundler_msg
);
690 u32 to_pos
= align(bundle_size
);
691 u32 pad
= to_pos
- bundle_size
;
693 if (msg_user(bundler_msg
) != MSG_BUNDLER
)
695 if (msg_type(bundler_msg
) != OPEN_MSG
)
697 if (skb_tailroom(bundler
) < (pad
+ size
))
699 if (l_ptr
->max_pkt
< (to_pos
+ size
))
702 skb_put(bundler
, pad
+ size
);
703 skb_copy_to_linear_data_offset(bundler
, to_pos
, buf
->data
, size
);
704 msg_set_size(bundler_msg
, to_pos
+ size
);
705 msg_set_msgcnt(bundler_msg
, msg_msgcnt(bundler_msg
) + 1);
707 l_ptr
->stats
.sent_bundled
++;
711 static void link_add_to_outqueue(struct tipc_link
*l_ptr
,
713 struct tipc_msg
*msg
)
715 u32 ack
= mod(l_ptr
->next_in_no
- 1);
716 u32 seqno
= mod(l_ptr
->next_out_no
++);
718 msg_set_word(msg
, 2, ((ack
<< 16) | seqno
));
719 msg_set_bcast_ack(msg
, l_ptr
->owner
->bclink
.last_in
);
721 if (l_ptr
->first_out
) {
722 l_ptr
->last_out
->next
= buf
;
723 l_ptr
->last_out
= buf
;
725 l_ptr
->first_out
= l_ptr
->last_out
= buf
;
727 l_ptr
->out_queue_size
++;
728 if (l_ptr
->out_queue_size
> l_ptr
->stats
.max_queue_sz
)
729 l_ptr
->stats
.max_queue_sz
= l_ptr
->out_queue_size
;
732 static void link_add_chain_to_outqueue(struct tipc_link
*l_ptr
,
733 struct sk_buff
*buf_chain
,
737 struct tipc_msg
*msg
;
739 if (!l_ptr
->next_out
)
740 l_ptr
->next_out
= buf_chain
;
743 buf_chain
= buf_chain
->next
;
746 msg_set_long_msgno(msg
, long_msgno
);
747 link_add_to_outqueue(l_ptr
, buf
, msg
);
752 * tipc_link_xmit() is the 'full path' for messages, called from
753 * inside TIPC when the 'fast path' in tipc_send_xmit
754 * has failed, and from link_send()
756 int __tipc_link_xmit(struct tipc_link
*l_ptr
, struct sk_buff
*buf
)
758 struct tipc_msg
*msg
= buf_msg(buf
);
759 u32 size
= msg_size(msg
);
760 u32 dsz
= msg_data_sz(msg
);
761 u32 queue_size
= l_ptr
->out_queue_size
;
762 u32 imp
= tipc_msg_tot_importance(msg
);
763 u32 queue_limit
= l_ptr
->queue_limit
[imp
];
764 u32 max_packet
= l_ptr
->max_pkt
;
766 /* Match msg importance against queue limits: */
767 if (unlikely(queue_size
>= queue_limit
)) {
768 if (imp
<= TIPC_CRITICAL_IMPORTANCE
) {
769 link_schedule_port(l_ptr
, msg_origport(msg
), size
);
774 if (imp
> CONN_MANAGER
) {
775 pr_warn("%s<%s>, send queue full", link_rst_msg
,
777 tipc_link_reset(l_ptr
);
782 /* Fragmentation needed ? */
783 if (size
> max_packet
)
784 return tipc_link_frag_xmit(l_ptr
, buf
);
786 /* Packet can be queued or sent. */
787 if (likely(!link_congested(l_ptr
))) {
788 link_add_to_outqueue(l_ptr
, buf
, msg
);
790 tipc_bearer_send(l_ptr
->bearer_id
, buf
, &l_ptr
->media_addr
);
791 l_ptr
->unacked_window
= 0;
794 /* Congestion: can message be bundled ? */
795 if ((msg_user(msg
) != CHANGEOVER_PROTOCOL
) &&
796 (msg_user(msg
) != MSG_FRAGMENTER
)) {
798 /* Try adding message to an existing bundle */
799 if (l_ptr
->next_out
&&
800 link_bundle_buf(l_ptr
, l_ptr
->last_out
, buf
))
803 /* Try creating a new bundle */
804 if (size
<= max_packet
* 2 / 3) {
805 struct sk_buff
*bundler
= tipc_buf_acquire(max_packet
);
806 struct tipc_msg bundler_hdr
;
809 tipc_msg_init(&bundler_hdr
, MSG_BUNDLER
, OPEN_MSG
,
810 INT_H_SIZE
, l_ptr
->addr
);
811 skb_copy_to_linear_data(bundler
, &bundler_hdr
,
813 skb_trim(bundler
, INT_H_SIZE
);
814 link_bundle_buf(l_ptr
, bundler
, buf
);
817 l_ptr
->stats
.sent_bundles
++;
821 if (!l_ptr
->next_out
)
822 l_ptr
->next_out
= buf
;
823 link_add_to_outqueue(l_ptr
, buf
, msg
);
828 * tipc_link_xmit(): same as __tipc_link_xmit(), but the link to use
829 * has not been selected yet, and the the owner node is not locked
830 * Called by TIPC internal users, e.g. the name distributor
832 int tipc_link_xmit(struct sk_buff
*buf
, u32 dest
, u32 selector
)
834 struct tipc_link
*l_ptr
;
835 struct tipc_node
*n_ptr
;
836 int res
= -ELINKCONG
;
838 read_lock_bh(&tipc_net_lock
);
839 n_ptr
= tipc_node_find(dest
);
841 tipc_node_lock(n_ptr
);
842 l_ptr
= n_ptr
->active_links
[selector
& 1];
844 res
= __tipc_link_xmit(l_ptr
, buf
);
847 tipc_node_unlock(n_ptr
);
851 read_unlock_bh(&tipc_net_lock
);
856 * tipc_link_sync_xmit - synchronize broadcast link endpoints.
858 * Give a newly added peer node the sequence number where it should
859 * start receiving and acking broadcast packets.
861 * Called with node locked
863 static void tipc_link_sync_xmit(struct tipc_link
*l
)
866 struct tipc_msg
*msg
;
868 buf
= tipc_buf_acquire(INT_H_SIZE
);
873 tipc_msg_init(msg
, BCAST_PROTOCOL
, STATE_MSG
, INT_H_SIZE
, l
->addr
);
874 msg_set_last_bcast(msg
, l
->owner
->bclink
.acked
);
875 link_add_chain_to_outqueue(l
, buf
, 0);
876 tipc_link_push_queue(l
);
880 * tipc_link_sync_rcv - synchronize broadcast link endpoints.
881 * Receive the sequence number where we should start receiving and
882 * acking broadcast packets from a newly added peer node, and open
883 * up for reception of such packets.
885 * Called with node locked
887 static void tipc_link_sync_rcv(struct tipc_node
*n
, struct sk_buff
*buf
)
889 struct tipc_msg
*msg
= buf_msg(buf
);
891 n
->bclink
.last_sent
= n
->bclink
.last_in
= msg_last_bcast(msg
);
892 n
->bclink
.recv_permitted
= true;
897 * tipc_link_names_xmit - send name table entries to new neighbor
899 * Send routine for bulk delivery of name table messages when contact
900 * with a new neighbor occurs. No link congestion checking is performed
901 * because name table messages *must* be delivered. The messages must be
902 * small enough not to require fragmentation.
903 * Called without any locks held.
905 void tipc_link_names_xmit(struct list_head
*message_list
, u32 dest
)
907 struct tipc_node
*n_ptr
;
908 struct tipc_link
*l_ptr
;
910 struct sk_buff
*temp_buf
;
912 if (list_empty(message_list
))
915 read_lock_bh(&tipc_net_lock
);
916 n_ptr
= tipc_node_find(dest
);
918 tipc_node_lock(n_ptr
);
919 l_ptr
= n_ptr
->active_links
[0];
921 /* convert circular list to linear list */
922 ((struct sk_buff
*)message_list
->prev
)->next
= NULL
;
923 link_add_chain_to_outqueue(l_ptr
,
924 (struct sk_buff
*)message_list
->next
, 0);
925 tipc_link_push_queue(l_ptr
);
926 INIT_LIST_HEAD(message_list
);
928 tipc_node_unlock(n_ptr
);
930 read_unlock_bh(&tipc_net_lock
);
932 /* discard the messages if they couldn't be sent */
933 list_for_each_safe(buf
, temp_buf
, ((struct sk_buff
*)message_list
)) {
934 list_del((struct list_head
*)buf
);
940 * tipc_link_xmit_fast: Entry for data messages where the
941 * destination link is known and the header is complete,
942 * inclusive total message length. Very time critical.
943 * Link is locked. Returns user data length.
945 static int tipc_link_xmit_fast(struct tipc_link
*l_ptr
, struct sk_buff
*buf
,
948 struct tipc_msg
*msg
= buf_msg(buf
);
949 int res
= msg_data_sz(msg
);
951 if (likely(!link_congested(l_ptr
))) {
952 if (likely(msg_size(msg
) <= l_ptr
->max_pkt
)) {
953 link_add_to_outqueue(l_ptr
, buf
, msg
);
954 tipc_bearer_send(l_ptr
->bearer_id
, buf
,
956 l_ptr
->unacked_window
= 0;
960 *used_max_pkt
= l_ptr
->max_pkt
;
962 return __tipc_link_xmit(l_ptr
, buf
); /* All other cases */
966 * tipc_link_iovec_xmit_fast: Entry for messages where the
967 * destination processor is known and the header is complete,
968 * except for total message length.
969 * Returns user data length or errno.
971 int tipc_link_iovec_xmit_fast(struct tipc_port
*sender
,
972 struct iovec
const *msg_sect
,
973 unsigned int len
, u32 destaddr
)
975 struct tipc_msg
*hdr
= &sender
->phdr
;
976 struct tipc_link
*l_ptr
;
978 struct tipc_node
*node
;
980 u32 selector
= msg_origport(hdr
) & 1;
984 * Try building message using port's max_pkt hint.
985 * (Must not hold any locks while building message.)
987 res
= tipc_msg_build(hdr
, msg_sect
, len
, sender
->max_pkt
, &buf
);
988 /* Exit if build request was invalid */
989 if (unlikely(res
< 0))
992 read_lock_bh(&tipc_net_lock
);
993 node
= tipc_node_find(destaddr
);
995 tipc_node_lock(node
);
996 l_ptr
= node
->active_links
[selector
];
999 res
= tipc_link_xmit_fast(l_ptr
, buf
,
1002 tipc_node_unlock(node
);
1003 read_unlock_bh(&tipc_net_lock
);
1007 /* Exit if link (or bearer) is congested */
1008 if (link_congested(l_ptr
)) {
1009 res
= link_schedule_port(l_ptr
,
1015 * Message size exceeds max_pkt hint; update hint,
1016 * then re-try fast path or fragment the message
1018 sender
->max_pkt
= l_ptr
->max_pkt
;
1019 tipc_node_unlock(node
);
1020 read_unlock_bh(&tipc_net_lock
);
1023 if ((msg_hdr_sz(hdr
) + res
) <= sender
->max_pkt
)
1026 return tipc_link_iovec_long_xmit(sender
, msg_sect
,
1029 tipc_node_unlock(node
);
1031 read_unlock_bh(&tipc_net_lock
);
1033 /* Couldn't find a link to the destination node */
1035 tipc_port_iovec_reject(sender
, hdr
, msg_sect
, len
, TIPC_ERR_NO_NODE
);
1036 return -ENETUNREACH
;
1040 * tipc_link_iovec_long_xmit(): Entry for long messages where the
1041 * destination node is known and the header is complete,
1042 * inclusive total message length.
1043 * Link and bearer congestion status have been checked to be ok,
1044 * and are ignored if they change.
1046 * Note that fragments do not use the full link MTU so that they won't have
1047 * to undergo refragmentation if link changeover causes them to be sent
1048 * over another link with an additional tunnel header added as prefix.
1049 * (Refragmentation will still occur if the other link has a smaller MTU.)
1051 * Returns user data length or errno.
1053 static int tipc_link_iovec_long_xmit(struct tipc_port
*sender
,
1054 struct iovec
const *msg_sect
,
1055 unsigned int len
, u32 destaddr
)
1057 struct tipc_link
*l_ptr
;
1058 struct tipc_node
*node
;
1059 struct tipc_msg
*hdr
= &sender
->phdr
;
1061 u32 max_pkt
, fragm_sz
, rest
;
1062 struct tipc_msg fragm_hdr
;
1063 struct sk_buff
*buf
, *buf_chain
, *prev
;
1064 u32 fragm_crs
, fragm_rest
, hsz
, sect_rest
;
1065 const unchar __user
*sect_crs
;
1072 max_pkt
= sender
->max_pkt
- INT_H_SIZE
;
1073 /* leave room for tunnel header in case of link changeover */
1074 fragm_sz
= max_pkt
- INT_H_SIZE
;
1075 /* leave room for fragmentation header in each fragment */
1083 /* Prepare reusable fragment header */
1084 tipc_msg_init(&fragm_hdr
, MSG_FRAGMENTER
, FIRST_FRAGMENT
,
1085 INT_H_SIZE
, msg_destnode(hdr
));
1086 msg_set_size(&fragm_hdr
, max_pkt
);
1087 msg_set_fragm_no(&fragm_hdr
, 1);
1089 /* Prepare header of first fragment */
1090 buf_chain
= buf
= tipc_buf_acquire(max_pkt
);
1094 skb_copy_to_linear_data(buf
, &fragm_hdr
, INT_H_SIZE
);
1095 hsz
= msg_hdr_sz(hdr
);
1096 skb_copy_to_linear_data_offset(buf
, INT_H_SIZE
, hdr
, hsz
);
1098 /* Chop up message */
1099 fragm_crs
= INT_H_SIZE
+ hsz
;
1100 fragm_rest
= fragm_sz
- hsz
;
1102 do { /* For all sections */
1106 sect_rest
= msg_sect
[++curr_sect
].iov_len
;
1107 sect_crs
= msg_sect
[curr_sect
].iov_base
;
1110 if (sect_rest
< fragm_rest
)
1115 if (copy_from_user(buf
->data
+ fragm_crs
, sect_crs
, sz
)) {
1118 kfree_skb_list(buf_chain
);
1127 if (!fragm_rest
&& rest
) {
1129 /* Initiate new fragment: */
1130 if (rest
<= fragm_sz
) {
1132 msg_set_type(&fragm_hdr
, LAST_FRAGMENT
);
1134 msg_set_type(&fragm_hdr
, FRAGMENT
);
1136 msg_set_size(&fragm_hdr
, fragm_sz
+ INT_H_SIZE
);
1137 msg_set_fragm_no(&fragm_hdr
, ++fragm_no
);
1139 buf
= tipc_buf_acquire(fragm_sz
+ INT_H_SIZE
);
1147 skb_copy_to_linear_data(buf
, &fragm_hdr
, INT_H_SIZE
);
1148 fragm_crs
= INT_H_SIZE
;
1149 fragm_rest
= fragm_sz
;
1154 * Now we have a buffer chain. Select a link and check
1155 * that packet size is still OK
1157 node
= tipc_node_find(destaddr
);
1159 tipc_node_lock(node
);
1160 l_ptr
= node
->active_links
[sender
->ref
& 1];
1162 tipc_node_unlock(node
);
1165 if (l_ptr
->max_pkt
< max_pkt
) {
1166 sender
->max_pkt
= l_ptr
->max_pkt
;
1167 tipc_node_unlock(node
);
1168 kfree_skb_list(buf_chain
);
1173 kfree_skb_list(buf_chain
);
1174 tipc_port_iovec_reject(sender
, hdr
, msg_sect
, len
,
1176 return -ENETUNREACH
;
1179 /* Append chain of fragments to send queue & send them */
1180 l_ptr
->long_msg_seq_no
++;
1181 link_add_chain_to_outqueue(l_ptr
, buf_chain
, l_ptr
->long_msg_seq_no
);
1182 l_ptr
->stats
.sent_fragments
+= fragm_no
;
1183 l_ptr
->stats
.sent_fragmented
++;
1184 tipc_link_push_queue(l_ptr
);
1185 tipc_node_unlock(node
);
1190 * tipc_link_push_packet: Push one unsent packet to the media
1192 static u32
tipc_link_push_packet(struct tipc_link
*l_ptr
)
1194 struct sk_buff
*buf
= l_ptr
->first_out
;
1195 u32 r_q_size
= l_ptr
->retransm_queue_size
;
1196 u32 r_q_head
= l_ptr
->retransm_queue_head
;
1198 /* Step to position where retransmission failed, if any, */
1199 /* consider that buffers may have been released in meantime */
1200 if (r_q_size
&& buf
) {
1201 u32 last
= lesser(mod(r_q_head
+ r_q_size
),
1202 link_last_sent(l_ptr
));
1203 u32 first
= buf_seqno(buf
);
1205 while (buf
&& less(first
, r_q_head
)) {
1206 first
= mod(first
+ 1);
1209 l_ptr
->retransm_queue_head
= r_q_head
= first
;
1210 l_ptr
->retransm_queue_size
= r_q_size
= mod(last
- first
);
1213 /* Continue retransmission now, if there is anything: */
1214 if (r_q_size
&& buf
) {
1215 msg_set_ack(buf_msg(buf
), mod(l_ptr
->next_in_no
- 1));
1216 msg_set_bcast_ack(buf_msg(buf
), l_ptr
->owner
->bclink
.last_in
);
1217 tipc_bearer_send(l_ptr
->bearer_id
, buf
, &l_ptr
->media_addr
);
1218 l_ptr
->retransm_queue_head
= mod(++r_q_head
);
1219 l_ptr
->retransm_queue_size
= --r_q_size
;
1220 l_ptr
->stats
.retransmitted
++;
1224 /* Send deferred protocol message, if any: */
1225 buf
= l_ptr
->proto_msg_queue
;
1227 msg_set_ack(buf_msg(buf
), mod(l_ptr
->next_in_no
- 1));
1228 msg_set_bcast_ack(buf_msg(buf
), l_ptr
->owner
->bclink
.last_in
);
1229 tipc_bearer_send(l_ptr
->bearer_id
, buf
, &l_ptr
->media_addr
);
1230 l_ptr
->unacked_window
= 0;
1232 l_ptr
->proto_msg_queue
= NULL
;
1236 /* Send one deferred data message, if send window not full: */
1237 buf
= l_ptr
->next_out
;
1239 struct tipc_msg
*msg
= buf_msg(buf
);
1240 u32 next
= msg_seqno(msg
);
1241 u32 first
= buf_seqno(l_ptr
->first_out
);
1243 if (mod(next
- first
) < l_ptr
->queue_limit
[0]) {
1244 msg_set_ack(msg
, mod(l_ptr
->next_in_no
- 1));
1245 msg_set_bcast_ack(msg
, l_ptr
->owner
->bclink
.last_in
);
1246 tipc_bearer_send(l_ptr
->bearer_id
, buf
,
1247 &l_ptr
->media_addr
);
1248 if (msg_user(msg
) == MSG_BUNDLER
)
1249 msg_set_type(msg
, CLOSED_MSG
);
1250 l_ptr
->next_out
= buf
->next
;
1258 * push_queue(): push out the unsent messages of a link where
1259 * congestion has abated. Node is locked
1261 void tipc_link_push_queue(struct tipc_link
*l_ptr
)
1266 res
= tipc_link_push_packet(l_ptr
);
1270 static void link_reset_all(unsigned long addr
)
1272 struct tipc_node
*n_ptr
;
1273 char addr_string
[16];
1276 read_lock_bh(&tipc_net_lock
);
1277 n_ptr
= tipc_node_find((u32
)addr
);
1279 read_unlock_bh(&tipc_net_lock
);
1280 return; /* node no longer exists */
1283 tipc_node_lock(n_ptr
);
1285 pr_warn("Resetting all links to %s\n",
1286 tipc_addr_string_fill(addr_string
, n_ptr
->addr
));
1288 for (i
= 0; i
< MAX_BEARERS
; i
++) {
1289 if (n_ptr
->links
[i
]) {
1290 link_print(n_ptr
->links
[i
], "Resetting link\n");
1291 tipc_link_reset(n_ptr
->links
[i
]);
1295 tipc_node_unlock(n_ptr
);
1296 read_unlock_bh(&tipc_net_lock
);
1299 static void link_retransmit_failure(struct tipc_link
*l_ptr
,
1300 struct sk_buff
*buf
)
1302 struct tipc_msg
*msg
= buf_msg(buf
);
1304 pr_warn("Retransmission failure on link <%s>\n", l_ptr
->name
);
1307 /* Handle failure on standard link */
1308 link_print(l_ptr
, "Resetting link\n");
1309 tipc_link_reset(l_ptr
);
1312 /* Handle failure on broadcast link */
1313 struct tipc_node
*n_ptr
;
1314 char addr_string
[16];
1316 pr_info("Msg seq number: %u, ", msg_seqno(msg
));
1317 pr_cont("Outstanding acks: %lu\n",
1318 (unsigned long) TIPC_SKB_CB(buf
)->handle
);
1320 n_ptr
= tipc_bclink_retransmit_to();
1321 tipc_node_lock(n_ptr
);
1323 tipc_addr_string_fill(addr_string
, n_ptr
->addr
);
1324 pr_info("Broadcast link info for %s\n", addr_string
);
1325 pr_info("Reception permitted: %d, Acked: %u\n",
1326 n_ptr
->bclink
.recv_permitted
,
1327 n_ptr
->bclink
.acked
);
1328 pr_info("Last in: %u, Oos state: %u, Last sent: %u\n",
1329 n_ptr
->bclink
.last_in
,
1330 n_ptr
->bclink
.oos_state
,
1331 n_ptr
->bclink
.last_sent
);
1333 tipc_k_signal((Handler
)link_reset_all
, (unsigned long)n_ptr
->addr
);
1335 tipc_node_unlock(n_ptr
);
1337 l_ptr
->stale_count
= 0;
1341 void tipc_link_retransmit(struct tipc_link
*l_ptr
, struct sk_buff
*buf
,
1344 struct tipc_msg
*msg
;
1351 /* Detect repeated retransmit failures */
1352 if (l_ptr
->last_retransmitted
== msg_seqno(msg
)) {
1353 if (++l_ptr
->stale_count
> 100) {
1354 link_retransmit_failure(l_ptr
, buf
);
1358 l_ptr
->last_retransmitted
= msg_seqno(msg
);
1359 l_ptr
->stale_count
= 1;
1362 while (retransmits
&& (buf
!= l_ptr
->next_out
) && buf
) {
1364 msg_set_ack(msg
, mod(l_ptr
->next_in_no
- 1));
1365 msg_set_bcast_ack(msg
, l_ptr
->owner
->bclink
.last_in
);
1366 tipc_bearer_send(l_ptr
->bearer_id
, buf
, &l_ptr
->media_addr
);
1369 l_ptr
->stats
.retransmitted
++;
1372 l_ptr
->retransm_queue_head
= l_ptr
->retransm_queue_size
= 0;
1376 * link_insert_deferred_queue - insert deferred messages back into receive chain
1378 static struct sk_buff
*link_insert_deferred_queue(struct tipc_link
*l_ptr
,
1379 struct sk_buff
*buf
)
1383 if (l_ptr
->oldest_deferred_in
== NULL
)
1386 seq_no
= buf_seqno(l_ptr
->oldest_deferred_in
);
1387 if (seq_no
== mod(l_ptr
->next_in_no
)) {
1388 l_ptr
->newest_deferred_in
->next
= buf
;
1389 buf
= l_ptr
->oldest_deferred_in
;
1390 l_ptr
->oldest_deferred_in
= NULL
;
1391 l_ptr
->deferred_inqueue_sz
= 0;
1397 * link_recv_buf_validate - validate basic format of received message
1399 * This routine ensures a TIPC message has an acceptable header, and at least
1400 * as much data as the header indicates it should. The routine also ensures
1401 * that the entire message header is stored in the main fragment of the message
1402 * buffer, to simplify future access to message header fields.
1404 * Note: Having extra info present in the message header or data areas is OK.
1405 * TIPC will ignore the excess, under the assumption that it is optional info
1406 * introduced by a later release of the protocol.
1408 static int link_recv_buf_validate(struct sk_buff
*buf
)
1410 static u32 min_data_hdr_size
[8] = {
1411 SHORT_H_SIZE
, MCAST_H_SIZE
, NAMED_H_SIZE
, BASIC_H_SIZE
,
1412 MAX_H_SIZE
, MAX_H_SIZE
, MAX_H_SIZE
, MAX_H_SIZE
1415 struct tipc_msg
*msg
;
1421 /* If this packet comes from the defer queue, the skb has already
1424 if (unlikely(TIPC_SKB_CB(buf
)->deferred
))
1427 if (unlikely(buf
->len
< MIN_H_SIZE
))
1430 msg
= skb_header_pointer(buf
, 0, sizeof(tipc_hdr
), tipc_hdr
);
1434 if (unlikely(msg_version(msg
) != TIPC_VERSION
))
1437 size
= msg_size(msg
);
1438 hdr_size
= msg_hdr_sz(msg
);
1439 min_hdr_size
= msg_isdata(msg
) ?
1440 min_data_hdr_size
[msg_type(msg
)] : INT_H_SIZE
;
1442 if (unlikely((hdr_size
< min_hdr_size
) ||
1443 (size
< hdr_size
) ||
1444 (buf
->len
< size
) ||
1445 (size
- hdr_size
> TIPC_MAX_USER_MSG_SIZE
)))
1448 return pskb_may_pull(buf
, hdr_size
);
1452 * tipc_rcv - process TIPC packets/messages arriving from off-node
1453 * @head: pointer to message buffer chain
1454 * @b_ptr: pointer to bearer message arrived on
1456 * Invoked with no locks held. Bearer pointer must point to a valid bearer
1457 * structure (i.e. cannot be NULL), but bearer can be inactive.
1459 void tipc_rcv(struct sk_buff
*head
, struct tipc_bearer
*b_ptr
)
1461 read_lock_bh(&tipc_net_lock
);
1463 struct tipc_node
*n_ptr
;
1464 struct tipc_link
*l_ptr
;
1465 struct sk_buff
*crs
;
1466 struct sk_buff
*buf
= head
;
1467 struct tipc_msg
*msg
;
1475 /* Ensure message is well-formed */
1476 if (unlikely(!link_recv_buf_validate(buf
)))
1479 /* Ensure message data is a single contiguous unit */
1480 if (unlikely(skb_linearize(buf
)))
1483 /* Handle arrival of a non-unicast link message */
1486 if (unlikely(msg_non_seq(msg
))) {
1487 if (msg_user(msg
) == LINK_CONFIG
)
1488 tipc_disc_rcv(buf
, b_ptr
);
1490 tipc_bclink_rcv(buf
);
1494 /* Discard unicast link messages destined for another node */
1495 if (unlikely(!msg_short(msg
) &&
1496 (msg_destnode(msg
) != tipc_own_addr
)))
1499 /* Locate neighboring node that sent message */
1500 n_ptr
= tipc_node_find(msg_prevnode(msg
));
1501 if (unlikely(!n_ptr
))
1503 tipc_node_lock(n_ptr
);
1505 /* Locate unicast link endpoint that should handle message */
1506 l_ptr
= n_ptr
->links
[b_ptr
->identity
];
1507 if (unlikely(!l_ptr
))
1508 goto unlock_discard
;
1510 /* Verify that communication with node is currently allowed */
1511 if ((n_ptr
->block_setup
& WAIT_PEER_DOWN
) &&
1512 msg_user(msg
) == LINK_PROTOCOL
&&
1513 (msg_type(msg
) == RESET_MSG
||
1514 msg_type(msg
) == ACTIVATE_MSG
) &&
1515 !msg_redundant_link(msg
))
1516 n_ptr
->block_setup
&= ~WAIT_PEER_DOWN
;
1518 if (n_ptr
->block_setup
)
1519 goto unlock_discard
;
1521 /* Validate message sequence number info */
1522 seq_no
= msg_seqno(msg
);
1523 ackd
= msg_ack(msg
);
1525 /* Release acked messages */
1526 if (n_ptr
->bclink
.recv_permitted
)
1527 tipc_bclink_acknowledge(n_ptr
, msg_bcast_ack(msg
));
1529 crs
= l_ptr
->first_out
;
1530 while ((crs
!= l_ptr
->next_out
) &&
1531 less_eq(buf_seqno(crs
), ackd
)) {
1532 struct sk_buff
*next
= crs
->next
;
1538 l_ptr
->first_out
= crs
;
1539 l_ptr
->out_queue_size
-= released
;
1542 /* Try sending any messages link endpoint has pending */
1543 if (unlikely(l_ptr
->next_out
))
1544 tipc_link_push_queue(l_ptr
);
1546 if (unlikely(!list_empty(&l_ptr
->waiting_ports
)))
1547 tipc_link_wakeup_ports(l_ptr
, 0);
1549 if (unlikely(++l_ptr
->unacked_window
>= TIPC_MIN_LINK_WIN
)) {
1550 l_ptr
->stats
.sent_acks
++;
1551 tipc_link_proto_xmit(l_ptr
, STATE_MSG
, 0, 0, 0, 0, 0);
1554 /* Process the incoming packet */
1555 if (unlikely(!link_working_working(l_ptr
))) {
1556 if (msg_user(msg
) == LINK_PROTOCOL
) {
1557 tipc_link_proto_rcv(l_ptr
, buf
);
1558 head
= link_insert_deferred_queue(l_ptr
, head
);
1559 tipc_node_unlock(n_ptr
);
1563 /* Traffic message. Conditionally activate link */
1564 link_state_event(l_ptr
, TRAFFIC_MSG_EVT
);
1566 if (link_working_working(l_ptr
)) {
1567 /* Re-insert buffer in front of queue */
1570 tipc_node_unlock(n_ptr
);
1573 goto unlock_discard
;
1576 /* Link is now in state WORKING_WORKING */
1577 if (unlikely(seq_no
!= mod(l_ptr
->next_in_no
))) {
1578 link_handle_out_of_seq_msg(l_ptr
, buf
);
1579 head
= link_insert_deferred_queue(l_ptr
, head
);
1580 tipc_node_unlock(n_ptr
);
1583 l_ptr
->next_in_no
++;
1584 if (unlikely(l_ptr
->oldest_deferred_in
))
1585 head
= link_insert_deferred_queue(l_ptr
, head
);
1587 /* Deliver packet/message to correct user: */
1588 if (unlikely(msg_user(msg
) == CHANGEOVER_PROTOCOL
)) {
1589 if (!tipc_link_tunnel_rcv(n_ptr
, &buf
)) {
1590 tipc_node_unlock(n_ptr
);
1594 } else if (msg_user(msg
) == MSG_FRAGMENTER
) {
1597 l_ptr
->stats
.recv_fragments
++;
1598 rc
= tipc_link_frag_rcv(&l_ptr
->reasm_head
,
1601 if (rc
== LINK_REASM_COMPLETE
) {
1602 l_ptr
->stats
.recv_fragmented
++;
1605 if (rc
== LINK_REASM_ERROR
)
1606 tipc_link_reset(l_ptr
);
1607 tipc_node_unlock(n_ptr
);
1612 switch (msg_user(msg
)) {
1613 case TIPC_LOW_IMPORTANCE
:
1614 case TIPC_MEDIUM_IMPORTANCE
:
1615 case TIPC_HIGH_IMPORTANCE
:
1616 case TIPC_CRITICAL_IMPORTANCE
:
1617 tipc_node_unlock(n_ptr
);
1621 l_ptr
->stats
.recv_bundles
++;
1622 l_ptr
->stats
.recv_bundled
+= msg_msgcnt(msg
);
1623 tipc_node_unlock(n_ptr
);
1624 tipc_link_bundle_rcv(buf
);
1626 case NAME_DISTRIBUTOR
:
1627 n_ptr
->bclink
.recv_permitted
= true;
1628 tipc_node_unlock(n_ptr
);
1629 tipc_named_rcv(buf
);
1632 tipc_node_unlock(n_ptr
);
1633 tipc_port_proto_rcv(buf
);
1635 case BCAST_PROTOCOL
:
1636 tipc_link_sync_rcv(n_ptr
, buf
);
1642 tipc_node_unlock(n_ptr
);
1645 tipc_node_unlock(n_ptr
);
1649 read_unlock_bh(&tipc_net_lock
);
1653 * tipc_link_defer_pkt - Add out-of-sequence message to deferred reception queue
1655 * Returns increase in queue length (i.e. 0 or 1)
1657 u32
tipc_link_defer_pkt(struct sk_buff
**head
, struct sk_buff
**tail
,
1658 struct sk_buff
*buf
)
1660 struct sk_buff
*queue_buf
;
1661 struct sk_buff
**prev
;
1662 u32 seq_no
= buf_seqno(buf
);
1667 if (*head
== NULL
) {
1668 *head
= *tail
= buf
;
1673 if (less(buf_seqno(*tail
), seq_no
)) {
1674 (*tail
)->next
= buf
;
1679 /* Locate insertion point in queue, then insert; discard if duplicate */
1683 u32 curr_seqno
= buf_seqno(queue_buf
);
1685 if (seq_no
== curr_seqno
) {
1690 if (less(seq_no
, curr_seqno
))
1693 prev
= &queue_buf
->next
;
1694 queue_buf
= queue_buf
->next
;
1697 buf
->next
= queue_buf
;
1703 * link_handle_out_of_seq_msg - handle arrival of out-of-sequence packet
1705 static void link_handle_out_of_seq_msg(struct tipc_link
*l_ptr
,
1706 struct sk_buff
*buf
)
1708 u32 seq_no
= buf_seqno(buf
);
1710 if (likely(msg_user(buf_msg(buf
)) == LINK_PROTOCOL
)) {
1711 tipc_link_proto_rcv(l_ptr
, buf
);
1715 /* Record OOS packet arrival (force mismatch on next timeout) */
1716 l_ptr
->checkpoint
--;
1719 * Discard packet if a duplicate; otherwise add it to deferred queue
1720 * and notify peer of gap as per protocol specification
1722 if (less(seq_no
, mod(l_ptr
->next_in_no
))) {
1723 l_ptr
->stats
.duplicates
++;
1728 if (tipc_link_defer_pkt(&l_ptr
->oldest_deferred_in
,
1729 &l_ptr
->newest_deferred_in
, buf
)) {
1730 l_ptr
->deferred_inqueue_sz
++;
1731 l_ptr
->stats
.deferred_recv
++;
1732 TIPC_SKB_CB(buf
)->deferred
= true;
1733 if ((l_ptr
->deferred_inqueue_sz
% 16) == 1)
1734 tipc_link_proto_xmit(l_ptr
, STATE_MSG
, 0, 0, 0, 0, 0);
1736 l_ptr
->stats
.duplicates
++;
1740 * Send protocol message to the other endpoint.
1742 void tipc_link_proto_xmit(struct tipc_link
*l_ptr
, u32 msg_typ
, int probe_msg
,
1743 u32 gap
, u32 tolerance
, u32 priority
, u32 ack_mtu
)
1745 struct sk_buff
*buf
= NULL
;
1746 struct tipc_msg
*msg
= l_ptr
->pmsg
;
1747 u32 msg_size
= sizeof(l_ptr
->proto_msg
);
1750 /* Discard any previous message that was deferred due to congestion */
1751 if (l_ptr
->proto_msg_queue
) {
1752 kfree_skb(l_ptr
->proto_msg_queue
);
1753 l_ptr
->proto_msg_queue
= NULL
;
1756 /* Don't send protocol message during link changeover */
1757 if (l_ptr
->exp_msg_count
)
1760 /* Abort non-RESET send if communication with node is prohibited */
1761 if ((l_ptr
->owner
->block_setup
) && (msg_typ
!= RESET_MSG
))
1764 /* Create protocol message with "out-of-sequence" sequence number */
1765 msg_set_type(msg
, msg_typ
);
1766 msg_set_net_plane(msg
, l_ptr
->net_plane
);
1767 msg_set_bcast_ack(msg
, l_ptr
->owner
->bclink
.last_in
);
1768 msg_set_last_bcast(msg
, tipc_bclink_get_last_sent());
1770 if (msg_typ
== STATE_MSG
) {
1771 u32 next_sent
= mod(l_ptr
->next_out_no
);
1773 if (!tipc_link_is_up(l_ptr
))
1775 if (l_ptr
->next_out
)
1776 next_sent
= buf_seqno(l_ptr
->next_out
);
1777 msg_set_next_sent(msg
, next_sent
);
1778 if (l_ptr
->oldest_deferred_in
) {
1779 u32 rec
= buf_seqno(l_ptr
->oldest_deferred_in
);
1780 gap
= mod(rec
- mod(l_ptr
->next_in_no
));
1782 msg_set_seq_gap(msg
, gap
);
1784 l_ptr
->stats
.sent_nacks
++;
1785 msg_set_link_tolerance(msg
, tolerance
);
1786 msg_set_linkprio(msg
, priority
);
1787 msg_set_max_pkt(msg
, ack_mtu
);
1788 msg_set_ack(msg
, mod(l_ptr
->next_in_no
- 1));
1789 msg_set_probe(msg
, probe_msg
!= 0);
1791 u32 mtu
= l_ptr
->max_pkt
;
1793 if ((mtu
< l_ptr
->max_pkt_target
) &&
1794 link_working_working(l_ptr
) &&
1795 l_ptr
->fsm_msg_cnt
) {
1796 msg_size
= (mtu
+ (l_ptr
->max_pkt_target
- mtu
)/2 + 2) & ~3;
1797 if (l_ptr
->max_pkt_probes
== 10) {
1798 l_ptr
->max_pkt_target
= (msg_size
- 4);
1799 l_ptr
->max_pkt_probes
= 0;
1800 msg_size
= (mtu
+ (l_ptr
->max_pkt_target
- mtu
)/2 + 2) & ~3;
1802 l_ptr
->max_pkt_probes
++;
1805 l_ptr
->stats
.sent_probes
++;
1807 l_ptr
->stats
.sent_states
++;
1808 } else { /* RESET_MSG or ACTIVATE_MSG */
1809 msg_set_ack(msg
, mod(l_ptr
->reset_checkpoint
- 1));
1810 msg_set_seq_gap(msg
, 0);
1811 msg_set_next_sent(msg
, 1);
1812 msg_set_probe(msg
, 0);
1813 msg_set_link_tolerance(msg
, l_ptr
->tolerance
);
1814 msg_set_linkprio(msg
, l_ptr
->priority
);
1815 msg_set_max_pkt(msg
, l_ptr
->max_pkt_target
);
1818 r_flag
= (l_ptr
->owner
->working_links
> tipc_link_is_up(l_ptr
));
1819 msg_set_redundant_link(msg
, r_flag
);
1820 msg_set_linkprio(msg
, l_ptr
->priority
);
1821 msg_set_size(msg
, msg_size
);
1823 msg_set_seqno(msg
, mod(l_ptr
->next_out_no
+ (0xffff/2)));
1825 buf
= tipc_buf_acquire(msg_size
);
1829 skb_copy_to_linear_data(buf
, msg
, sizeof(l_ptr
->proto_msg
));
1830 buf
->priority
= TC_PRIO_CONTROL
;
1832 tipc_bearer_send(l_ptr
->bearer_id
, buf
, &l_ptr
->media_addr
);
1833 l_ptr
->unacked_window
= 0;
1838 * Receive protocol message :
1839 * Note that network plane id propagates through the network, and may
1840 * change at any time. The node with lowest address rules
1842 static void tipc_link_proto_rcv(struct tipc_link
*l_ptr
, struct sk_buff
*buf
)
1848 struct tipc_msg
*msg
= buf_msg(buf
);
1850 /* Discard protocol message during link changeover */
1851 if (l_ptr
->exp_msg_count
)
1854 /* record unnumbered packet arrival (force mismatch on next timeout) */
1855 l_ptr
->checkpoint
--;
1857 if (l_ptr
->net_plane
!= msg_net_plane(msg
))
1858 if (tipc_own_addr
> msg_prevnode(msg
))
1859 l_ptr
->net_plane
= msg_net_plane(msg
);
1861 switch (msg_type(msg
)) {
1864 if (!link_working_unknown(l_ptr
) &&
1865 (l_ptr
->peer_session
!= INVALID_SESSION
)) {
1866 if (less_eq(msg_session(msg
), l_ptr
->peer_session
))
1867 break; /* duplicate or old reset: ignore */
1870 if (!msg_redundant_link(msg
) && (link_working_working(l_ptr
) ||
1871 link_working_unknown(l_ptr
))) {
1873 * peer has lost contact -- don't allow peer's links
1874 * to reactivate before we recognize loss & clean up
1876 l_ptr
->owner
->block_setup
= WAIT_NODE_DOWN
;
1879 link_state_event(l_ptr
, RESET_MSG
);
1883 /* Update link settings according other endpoint's values */
1884 strcpy((strrchr(l_ptr
->name
, ':') + 1), (char *)msg_data(msg
));
1886 msg_tol
= msg_link_tolerance(msg
);
1887 if (msg_tol
> l_ptr
->tolerance
)
1888 link_set_supervision_props(l_ptr
, msg_tol
);
1890 if (msg_linkprio(msg
) > l_ptr
->priority
)
1891 l_ptr
->priority
= msg_linkprio(msg
);
1893 max_pkt_info
= msg_max_pkt(msg
);
1895 if (max_pkt_info
< l_ptr
->max_pkt_target
)
1896 l_ptr
->max_pkt_target
= max_pkt_info
;
1897 if (l_ptr
->max_pkt
> l_ptr
->max_pkt_target
)
1898 l_ptr
->max_pkt
= l_ptr
->max_pkt_target
;
1900 l_ptr
->max_pkt
= l_ptr
->max_pkt_target
;
1903 /* Synchronize broadcast link info, if not done previously */
1904 if (!tipc_node_is_up(l_ptr
->owner
)) {
1905 l_ptr
->owner
->bclink
.last_sent
=
1906 l_ptr
->owner
->bclink
.last_in
=
1907 msg_last_bcast(msg
);
1908 l_ptr
->owner
->bclink
.oos_state
= 0;
1911 l_ptr
->peer_session
= msg_session(msg
);
1912 l_ptr
->peer_bearer_id
= msg_bearer_id(msg
);
1914 if (msg_type(msg
) == ACTIVATE_MSG
)
1915 link_state_event(l_ptr
, ACTIVATE_MSG
);
1919 msg_tol
= msg_link_tolerance(msg
);
1921 link_set_supervision_props(l_ptr
, msg_tol
);
1923 if (msg_linkprio(msg
) &&
1924 (msg_linkprio(msg
) != l_ptr
->priority
)) {
1925 pr_warn("%s<%s>, priority change %u->%u\n",
1926 link_rst_msg
, l_ptr
->name
, l_ptr
->priority
,
1928 l_ptr
->priority
= msg_linkprio(msg
);
1929 tipc_link_reset(l_ptr
); /* Enforce change to take effect */
1932 link_state_event(l_ptr
, TRAFFIC_MSG_EVT
);
1933 l_ptr
->stats
.recv_states
++;
1934 if (link_reset_unknown(l_ptr
))
1937 if (less_eq(mod(l_ptr
->next_in_no
), msg_next_sent(msg
))) {
1938 rec_gap
= mod(msg_next_sent(msg
) -
1939 mod(l_ptr
->next_in_no
));
1942 max_pkt_ack
= msg_max_pkt(msg
);
1943 if (max_pkt_ack
> l_ptr
->max_pkt
) {
1944 l_ptr
->max_pkt
= max_pkt_ack
;
1945 l_ptr
->max_pkt_probes
= 0;
1949 if (msg_probe(msg
)) {
1950 l_ptr
->stats
.recv_probes
++;
1951 if (msg_size(msg
) > sizeof(l_ptr
->proto_msg
))
1952 max_pkt_ack
= msg_size(msg
);
1955 /* Protocol message before retransmits, reduce loss risk */
1956 if (l_ptr
->owner
->bclink
.recv_permitted
)
1957 tipc_bclink_update_link_state(l_ptr
->owner
,
1958 msg_last_bcast(msg
));
1960 if (rec_gap
|| (msg_probe(msg
))) {
1961 tipc_link_proto_xmit(l_ptr
, STATE_MSG
, 0, rec_gap
, 0,
1964 if (msg_seq_gap(msg
)) {
1965 l_ptr
->stats
.recv_nacks
++;
1966 tipc_link_retransmit(l_ptr
, l_ptr
->first_out
,
1976 /* tipc_link_tunnel_xmit(): Tunnel one packet via a link belonging to
1977 * a different bearer. Owner node is locked.
1979 static void tipc_link_tunnel_xmit(struct tipc_link
*l_ptr
,
1980 struct tipc_msg
*tunnel_hdr
,
1981 struct tipc_msg
*msg
,
1984 struct tipc_link
*tunnel
;
1985 struct sk_buff
*buf
;
1986 u32 length
= msg_size(msg
);
1988 tunnel
= l_ptr
->owner
->active_links
[selector
& 1];
1989 if (!tipc_link_is_up(tunnel
)) {
1990 pr_warn("%stunnel link no longer available\n", link_co_err
);
1993 msg_set_size(tunnel_hdr
, length
+ INT_H_SIZE
);
1994 buf
= tipc_buf_acquire(length
+ INT_H_SIZE
);
1996 pr_warn("%sunable to send tunnel msg\n", link_co_err
);
1999 skb_copy_to_linear_data(buf
, tunnel_hdr
, INT_H_SIZE
);
2000 skb_copy_to_linear_data_offset(buf
, INT_H_SIZE
, msg
, length
);
2001 __tipc_link_xmit(tunnel
, buf
);
2005 /* tipc_link_failover_send_queue(): A link has gone down, but a second
2006 * link is still active. We can do failover. Tunnel the failing link's
2007 * whole send queue via the remaining link. This way, we don't lose
2008 * any packets, and sequence order is preserved for subsequent traffic
2009 * sent over the remaining link. Owner node is locked.
2011 void tipc_link_failover_send_queue(struct tipc_link
*l_ptr
)
2013 u32 msgcount
= l_ptr
->out_queue_size
;
2014 struct sk_buff
*crs
= l_ptr
->first_out
;
2015 struct tipc_link
*tunnel
= l_ptr
->owner
->active_links
[0];
2016 struct tipc_msg tunnel_hdr
;
2022 tipc_msg_init(&tunnel_hdr
, CHANGEOVER_PROTOCOL
,
2023 ORIGINAL_MSG
, INT_H_SIZE
, l_ptr
->addr
);
2024 msg_set_bearer_id(&tunnel_hdr
, l_ptr
->peer_bearer_id
);
2025 msg_set_msgcnt(&tunnel_hdr
, msgcount
);
2027 if (!l_ptr
->first_out
) {
2028 struct sk_buff
*buf
;
2030 buf
= tipc_buf_acquire(INT_H_SIZE
);
2032 skb_copy_to_linear_data(buf
, &tunnel_hdr
, INT_H_SIZE
);
2033 msg_set_size(&tunnel_hdr
, INT_H_SIZE
);
2034 __tipc_link_xmit(tunnel
, buf
);
2036 pr_warn("%sunable to send changeover msg\n",
2042 split_bundles
= (l_ptr
->owner
->active_links
[0] !=
2043 l_ptr
->owner
->active_links
[1]);
2046 struct tipc_msg
*msg
= buf_msg(crs
);
2048 if ((msg_user(msg
) == MSG_BUNDLER
) && split_bundles
) {
2049 struct tipc_msg
*m
= msg_get_wrapped(msg
);
2050 unchar
*pos
= (unchar
*)m
;
2052 msgcount
= msg_msgcnt(msg
);
2053 while (msgcount
--) {
2054 msg_set_seqno(m
, msg_seqno(msg
));
2055 tipc_link_tunnel_xmit(l_ptr
, &tunnel_hdr
, m
,
2056 msg_link_selector(m
));
2057 pos
+= align(msg_size(m
));
2058 m
= (struct tipc_msg
*)pos
;
2061 tipc_link_tunnel_xmit(l_ptr
, &tunnel_hdr
, msg
,
2062 msg_link_selector(msg
));
2068 /* tipc_link_dup_queue_xmit(): A second link has become active. Tunnel a
2069 * duplicate of the first link's send queue via the new link. This way, we
2070 * are guaranteed that currently queued packets from a socket are delivered
2071 * before future traffic from the same socket, even if this is using the
2072 * new link. The last arriving copy of each duplicate packet is dropped at
2073 * the receiving end by the regular protocol check, so packet cardinality
2074 * and sequence order is preserved per sender/receiver socket pair.
2075 * Owner node is locked.
2077 void tipc_link_dup_queue_xmit(struct tipc_link
*l_ptr
,
2078 struct tipc_link
*tunnel
)
2080 struct sk_buff
*iter
;
2081 struct tipc_msg tunnel_hdr
;
2083 tipc_msg_init(&tunnel_hdr
, CHANGEOVER_PROTOCOL
,
2084 DUPLICATE_MSG
, INT_H_SIZE
, l_ptr
->addr
);
2085 msg_set_msgcnt(&tunnel_hdr
, l_ptr
->out_queue_size
);
2086 msg_set_bearer_id(&tunnel_hdr
, l_ptr
->peer_bearer_id
);
2087 iter
= l_ptr
->first_out
;
2089 struct sk_buff
*outbuf
;
2090 struct tipc_msg
*msg
= buf_msg(iter
);
2091 u32 length
= msg_size(msg
);
2093 if (msg_user(msg
) == MSG_BUNDLER
)
2094 msg_set_type(msg
, CLOSED_MSG
);
2095 msg_set_ack(msg
, mod(l_ptr
->next_in_no
- 1)); /* Update */
2096 msg_set_bcast_ack(msg
, l_ptr
->owner
->bclink
.last_in
);
2097 msg_set_size(&tunnel_hdr
, length
+ INT_H_SIZE
);
2098 outbuf
= tipc_buf_acquire(length
+ INT_H_SIZE
);
2099 if (outbuf
== NULL
) {
2100 pr_warn("%sunable to send duplicate msg\n",
2104 skb_copy_to_linear_data(outbuf
, &tunnel_hdr
, INT_H_SIZE
);
2105 skb_copy_to_linear_data_offset(outbuf
, INT_H_SIZE
, iter
->data
,
2107 __tipc_link_xmit(tunnel
, outbuf
);
2108 if (!tipc_link_is_up(l_ptr
))
2115 * buf_extract - extracts embedded TIPC message from another message
2116 * @skb: encapsulating message buffer
2117 * @from_pos: offset to extract from
2119 * Returns a new message buffer containing an embedded message. The
2120 * encapsulating message itself is left unchanged.
2122 static struct sk_buff
*buf_extract(struct sk_buff
*skb
, u32 from_pos
)
2124 struct tipc_msg
*msg
= (struct tipc_msg
*)(skb
->data
+ from_pos
);
2125 u32 size
= msg_size(msg
);
2128 eb
= tipc_buf_acquire(size
);
2130 skb_copy_to_linear_data(eb
, msg
, size
);
2136 /* tipc_link_dup_rcv(): Receive a tunnelled DUPLICATE_MSG packet.
2137 * Owner node is locked.
2139 static void tipc_link_dup_rcv(struct tipc_link
*l_ptr
,
2140 struct sk_buff
*t_buf
)
2142 struct sk_buff
*buf
;
2144 if (!tipc_link_is_up(l_ptr
))
2147 buf
= buf_extract(t_buf
, INT_H_SIZE
);
2149 pr_warn("%sfailed to extract inner dup pkt\n", link_co_err
);
2153 /* Add buffer to deferred queue, if applicable: */
2154 link_handle_out_of_seq_msg(l_ptr
, buf
);
2157 /* tipc_link_failover_rcv(): Receive a tunnelled ORIGINAL_MSG packet
2158 * Owner node is locked.
2160 static struct sk_buff
*tipc_link_failover_rcv(struct tipc_link
*l_ptr
,
2161 struct sk_buff
*t_buf
)
2163 struct tipc_msg
*t_msg
= buf_msg(t_buf
);
2164 struct sk_buff
*buf
= NULL
;
2165 struct tipc_msg
*msg
;
2167 if (tipc_link_is_up(l_ptr
))
2168 tipc_link_reset(l_ptr
);
2170 /* First failover packet? */
2171 if (l_ptr
->exp_msg_count
== START_CHANGEOVER
)
2172 l_ptr
->exp_msg_count
= msg_msgcnt(t_msg
);
2174 /* Should there be an inner packet? */
2175 if (l_ptr
->exp_msg_count
) {
2176 l_ptr
->exp_msg_count
--;
2177 buf
= buf_extract(t_buf
, INT_H_SIZE
);
2179 pr_warn("%sno inner failover pkt\n", link_co_err
);
2184 if (less(msg_seqno(msg
), l_ptr
->reset_checkpoint
)) {
2189 if (msg_user(msg
) == MSG_FRAGMENTER
) {
2190 l_ptr
->stats
.recv_fragments
++;
2191 tipc_link_frag_rcv(&l_ptr
->reasm_head
,
2197 if ((l_ptr
->exp_msg_count
== 0) && (l_ptr
->flags
& LINK_STOPPED
)) {
2198 tipc_node_detach_link(l_ptr
->owner
, l_ptr
);
2204 /* tipc_link_tunnel_rcv(): Receive a tunnelled packet, sent
2205 * via other link as result of a failover (ORIGINAL_MSG) or
2206 * a new active link (DUPLICATE_MSG). Failover packets are
2207 * returned to the active link for delivery upwards.
2208 * Owner node is locked.
2210 static int tipc_link_tunnel_rcv(struct tipc_node
*n_ptr
,
2211 struct sk_buff
**buf
)
2213 struct sk_buff
*t_buf
= *buf
;
2214 struct tipc_link
*l_ptr
;
2215 struct tipc_msg
*t_msg
= buf_msg(t_buf
);
2216 u32 bearer_id
= msg_bearer_id(t_msg
);
2220 if (bearer_id
>= MAX_BEARERS
)
2223 l_ptr
= n_ptr
->links
[bearer_id
];
2227 if (msg_type(t_msg
) == DUPLICATE_MSG
)
2228 tipc_link_dup_rcv(l_ptr
, t_buf
);
2229 else if (msg_type(t_msg
) == ORIGINAL_MSG
)
2230 *buf
= tipc_link_failover_rcv(l_ptr
, t_buf
);
2232 pr_warn("%sunknown tunnel pkt received\n", link_co_err
);
2235 return *buf
!= NULL
;
2239 * Bundler functionality:
2241 void tipc_link_bundle_rcv(struct sk_buff
*buf
)
2243 u32 msgcount
= msg_msgcnt(buf_msg(buf
));
2244 u32 pos
= INT_H_SIZE
;
2245 struct sk_buff
*obuf
;
2247 while (msgcount
--) {
2248 obuf
= buf_extract(buf
, pos
);
2250 pr_warn("Link unable to unbundle message(s)\n");
2253 pos
+= align(msg_size(buf_msg(obuf
)));
2254 tipc_net_route_msg(obuf
);
2260 * Fragmentation/defragmentation:
2264 * tipc_link_frag_xmit: Entry for buffers needing fragmentation.
2265 * The buffer is complete, inclusive total message length.
2266 * Returns user data length.
2268 static int tipc_link_frag_xmit(struct tipc_link
*l_ptr
, struct sk_buff
*buf
)
2270 struct sk_buff
*buf_chain
= NULL
;
2271 struct sk_buff
*buf_chain_tail
= (struct sk_buff
*)&buf_chain
;
2272 struct tipc_msg
*inmsg
= buf_msg(buf
);
2273 struct tipc_msg fragm_hdr
;
2274 u32 insize
= msg_size(inmsg
);
2275 u32 dsz
= msg_data_sz(inmsg
);
2276 unchar
*crs
= buf
->data
;
2278 u32 pack_sz
= l_ptr
->max_pkt
;
2279 u32 fragm_sz
= pack_sz
- INT_H_SIZE
;
2283 if (msg_short(inmsg
))
2284 destaddr
= l_ptr
->addr
;
2286 destaddr
= msg_destnode(inmsg
);
2288 /* Prepare reusable fragment header: */
2289 tipc_msg_init(&fragm_hdr
, MSG_FRAGMENTER
, FIRST_FRAGMENT
,
2290 INT_H_SIZE
, destaddr
);
2292 /* Chop up message: */
2294 struct sk_buff
*fragm
;
2296 if (rest
<= fragm_sz
) {
2298 msg_set_type(&fragm_hdr
, LAST_FRAGMENT
);
2300 fragm
= tipc_buf_acquire(fragm_sz
+ INT_H_SIZE
);
2301 if (fragm
== NULL
) {
2303 kfree_skb_list(buf_chain
);
2306 msg_set_size(&fragm_hdr
, fragm_sz
+ INT_H_SIZE
);
2308 msg_set_fragm_no(&fragm_hdr
, fragm_no
);
2309 skb_copy_to_linear_data(fragm
, &fragm_hdr
, INT_H_SIZE
);
2310 skb_copy_to_linear_data_offset(fragm
, INT_H_SIZE
, crs
,
2312 buf_chain_tail
->next
= fragm
;
2313 buf_chain_tail
= fragm
;
2317 msg_set_type(&fragm_hdr
, FRAGMENT
);
2321 /* Append chain of fragments to send queue & send them */
2322 l_ptr
->long_msg_seq_no
++;
2323 link_add_chain_to_outqueue(l_ptr
, buf_chain
, l_ptr
->long_msg_seq_no
);
2324 l_ptr
->stats
.sent_fragments
+= fragm_no
;
2325 l_ptr
->stats
.sent_fragmented
++;
2326 tipc_link_push_queue(l_ptr
);
2331 /* tipc_link_frag_rcv(): Called with node lock on. Returns
2332 * the reassembled buffer if message is complete.
2334 int tipc_link_frag_rcv(struct sk_buff
**head
, struct sk_buff
**tail
,
2335 struct sk_buff
**fbuf
)
2337 struct sk_buff
*frag
= *fbuf
;
2338 struct tipc_msg
*msg
= buf_msg(frag
);
2339 u32 fragid
= msg_type(msg
);
2343 skb_pull(frag
, msg_hdr_sz(msg
));
2344 if (fragid
== FIRST_FRAGMENT
) {
2345 if (*head
|| skb_unclone(frag
, GFP_ATOMIC
))
2348 skb_frag_list_init(*head
);
2352 skb_try_coalesce(*head
, frag
, &headstolen
, &delta
)) {
2353 kfree_skb_partial(frag
, headstolen
);
2357 if (!skb_has_frag_list(*head
))
2358 skb_shinfo(*head
)->frag_list
= frag
;
2360 (*tail
)->next
= frag
;
2362 (*head
)->truesize
+= frag
->truesize
;
2364 if (fragid
== LAST_FRAGMENT
) {
2366 *tail
= *head
= NULL
;
2367 return LINK_REASM_COMPLETE
;
2372 pr_warn_ratelimited("Link unable to reassemble fragmented message\n");
2375 return LINK_REASM_ERROR
;
2378 static void link_set_supervision_props(struct tipc_link
*l_ptr
, u32 tolerance
)
2380 if ((tolerance
< TIPC_MIN_LINK_TOL
) || (tolerance
> TIPC_MAX_LINK_TOL
))
2383 l_ptr
->tolerance
= tolerance
;
2384 l_ptr
->continuity_interval
=
2385 ((tolerance
/ 4) > 500) ? 500 : tolerance
/ 4;
2386 l_ptr
->abort_limit
= tolerance
/ (l_ptr
->continuity_interval
/ 4);
2389 void tipc_link_set_queue_limits(struct tipc_link
*l_ptr
, u32 window
)
2391 /* Data messages from this node, inclusive FIRST_FRAGM */
2392 l_ptr
->queue_limit
[TIPC_LOW_IMPORTANCE
] = window
;
2393 l_ptr
->queue_limit
[TIPC_MEDIUM_IMPORTANCE
] = (window
/ 3) * 4;
2394 l_ptr
->queue_limit
[TIPC_HIGH_IMPORTANCE
] = (window
/ 3) * 5;
2395 l_ptr
->queue_limit
[TIPC_CRITICAL_IMPORTANCE
] = (window
/ 3) * 6;
2396 /* Transiting data messages,inclusive FIRST_FRAGM */
2397 l_ptr
->queue_limit
[TIPC_LOW_IMPORTANCE
+ 4] = 300;
2398 l_ptr
->queue_limit
[TIPC_MEDIUM_IMPORTANCE
+ 4] = 600;
2399 l_ptr
->queue_limit
[TIPC_HIGH_IMPORTANCE
+ 4] = 900;
2400 l_ptr
->queue_limit
[TIPC_CRITICAL_IMPORTANCE
+ 4] = 1200;
2401 l_ptr
->queue_limit
[CONN_MANAGER
] = 1200;
2402 l_ptr
->queue_limit
[CHANGEOVER_PROTOCOL
] = 2500;
2403 l_ptr
->queue_limit
[NAME_DISTRIBUTOR
] = 3000;
2404 /* FRAGMENT and LAST_FRAGMENT packets */
2405 l_ptr
->queue_limit
[MSG_FRAGMENTER
] = 4000;
2408 /* tipc_link_find_owner - locate owner node of link by link's name
2409 * @name: pointer to link name string
2410 * @bearer_id: pointer to index in 'node->links' array where the link was found.
2411 * Caller must hold 'tipc_net_lock' to ensure node and bearer are not deleted;
2412 * this also prevents link deletion.
2414 * Returns pointer to node owning the link, or 0 if no matching link is found.
2416 static struct tipc_node
*tipc_link_find_owner(const char *link_name
,
2417 unsigned int *bearer_id
)
2419 struct tipc_link
*l_ptr
;
2420 struct tipc_node
*n_ptr
;
2421 struct tipc_node
*found_node
= 0;
2426 list_for_each_entry_rcu(n_ptr
, &tipc_node_list
, list
) {
2427 tipc_node_lock(n_ptr
);
2428 for (i
= 0; i
< MAX_BEARERS
; i
++) {
2429 l_ptr
= n_ptr
->links
[i
];
2430 if (l_ptr
&& !strcmp(l_ptr
->name
, link_name
)) {
2436 tipc_node_unlock(n_ptr
);
2446 * link_value_is_valid -- validate proposed link tolerance/priority/window
2448 * @cmd: value type (TIPC_CMD_SET_LINK_*)
2449 * @new_value: the new value
2451 * Returns 1 if value is within range, 0 if not.
2453 static int link_value_is_valid(u16 cmd
, u32 new_value
)
2456 case TIPC_CMD_SET_LINK_TOL
:
2457 return (new_value
>= TIPC_MIN_LINK_TOL
) &&
2458 (new_value
<= TIPC_MAX_LINK_TOL
);
2459 case TIPC_CMD_SET_LINK_PRI
:
2460 return (new_value
<= TIPC_MAX_LINK_PRI
);
2461 case TIPC_CMD_SET_LINK_WINDOW
:
2462 return (new_value
>= TIPC_MIN_LINK_WIN
) &&
2463 (new_value
<= TIPC_MAX_LINK_WIN
);
2469 * link_cmd_set_value - change priority/tolerance/window for link/bearer/media
2470 * @name: ptr to link, bearer, or media name
2471 * @new_value: new value of link, bearer, or media setting
2472 * @cmd: which link, bearer, or media attribute to set (TIPC_CMD_SET_LINK_*)
2474 * Caller must hold 'tipc_net_lock' to ensure link/bearer/media is not deleted.
2476 * Returns 0 if value updated and negative value on error.
2478 static int link_cmd_set_value(const char *name
, u32 new_value
, u16 cmd
)
2480 struct tipc_node
*node
;
2481 struct tipc_link
*l_ptr
;
2482 struct tipc_bearer
*b_ptr
;
2483 struct tipc_media
*m_ptr
;
2487 node
= tipc_link_find_owner(name
, &bearer_id
);
2489 tipc_node_lock(node
);
2490 l_ptr
= node
->links
[bearer_id
];
2494 case TIPC_CMD_SET_LINK_TOL
:
2495 link_set_supervision_props(l_ptr
, new_value
);
2496 tipc_link_proto_xmit(l_ptr
, STATE_MSG
, 0, 0,
2499 case TIPC_CMD_SET_LINK_PRI
:
2500 l_ptr
->priority
= new_value
;
2501 tipc_link_proto_xmit(l_ptr
, STATE_MSG
, 0, 0,
2504 case TIPC_CMD_SET_LINK_WINDOW
:
2505 tipc_link_set_queue_limits(l_ptr
, new_value
);
2512 tipc_node_unlock(node
);
2516 b_ptr
= tipc_bearer_find(name
);
2519 case TIPC_CMD_SET_LINK_TOL
:
2520 b_ptr
->tolerance
= new_value
;
2522 case TIPC_CMD_SET_LINK_PRI
:
2523 b_ptr
->priority
= new_value
;
2525 case TIPC_CMD_SET_LINK_WINDOW
:
2526 b_ptr
->window
= new_value
;
2535 m_ptr
= tipc_media_find(name
);
2539 case TIPC_CMD_SET_LINK_TOL
:
2540 m_ptr
->tolerance
= new_value
;
2542 case TIPC_CMD_SET_LINK_PRI
:
2543 m_ptr
->priority
= new_value
;
2545 case TIPC_CMD_SET_LINK_WINDOW
:
2546 m_ptr
->window
= new_value
;
2555 struct sk_buff
*tipc_link_cmd_config(const void *req_tlv_area
, int req_tlv_space
,
2558 struct tipc_link_config
*args
;
2562 if (!TLV_CHECK(req_tlv_area
, req_tlv_space
, TIPC_TLV_LINK_CONFIG
))
2563 return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR
);
2565 args
= (struct tipc_link_config
*)TLV_DATA(req_tlv_area
);
2566 new_value
= ntohl(args
->value
);
2568 if (!link_value_is_valid(cmd
, new_value
))
2569 return tipc_cfg_reply_error_string(
2570 "cannot change, value invalid");
2572 if (!strcmp(args
->name
, tipc_bclink_name
)) {
2573 if ((cmd
== TIPC_CMD_SET_LINK_WINDOW
) &&
2574 (tipc_bclink_set_queue_limits(new_value
) == 0))
2575 return tipc_cfg_reply_none();
2576 return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
2577 " (cannot change setting on broadcast link)");
2580 read_lock_bh(&tipc_net_lock
);
2581 res
= link_cmd_set_value(args
->name
, new_value
, cmd
);
2582 read_unlock_bh(&tipc_net_lock
);
2584 return tipc_cfg_reply_error_string("cannot change link setting");
2586 return tipc_cfg_reply_none();
2590 * link_reset_statistics - reset link statistics
2591 * @l_ptr: pointer to link
2593 static void link_reset_statistics(struct tipc_link
*l_ptr
)
2595 memset(&l_ptr
->stats
, 0, sizeof(l_ptr
->stats
));
2596 l_ptr
->stats
.sent_info
= l_ptr
->next_out_no
;
2597 l_ptr
->stats
.recv_info
= l_ptr
->next_in_no
;
2600 struct sk_buff
*tipc_link_cmd_reset_stats(const void *req_tlv_area
, int req_tlv_space
)
2603 struct tipc_link
*l_ptr
;
2604 struct tipc_node
*node
;
2605 unsigned int bearer_id
;
2607 if (!TLV_CHECK(req_tlv_area
, req_tlv_space
, TIPC_TLV_LINK_NAME
))
2608 return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR
);
2610 link_name
= (char *)TLV_DATA(req_tlv_area
);
2611 if (!strcmp(link_name
, tipc_bclink_name
)) {
2612 if (tipc_bclink_reset_stats())
2613 return tipc_cfg_reply_error_string("link not found");
2614 return tipc_cfg_reply_none();
2616 read_lock_bh(&tipc_net_lock
);
2617 node
= tipc_link_find_owner(link_name
, &bearer_id
);
2619 read_unlock_bh(&tipc_net_lock
);
2620 return tipc_cfg_reply_error_string("link not found");
2622 tipc_node_lock(node
);
2623 l_ptr
= node
->links
[bearer_id
];
2625 tipc_node_unlock(node
);
2626 read_unlock_bh(&tipc_net_lock
);
2627 return tipc_cfg_reply_error_string("link not found");
2629 link_reset_statistics(l_ptr
);
2630 tipc_node_unlock(node
);
2631 read_unlock_bh(&tipc_net_lock
);
2632 return tipc_cfg_reply_none();
2636 * percent - convert count to a percentage of total (rounding up or down)
2638 static u32
percent(u32 count
, u32 total
)
2640 return (count
* 100 + (total
/ 2)) / total
;
2644 * tipc_link_stats - print link statistics
2646 * @buf: print buffer area
2647 * @buf_size: size of print buffer area
2649 * Returns length of print buffer data string (or 0 if error)
2651 static int tipc_link_stats(const char *name
, char *buf
, const u32 buf_size
)
2653 struct tipc_link
*l
;
2654 struct tipc_stats
*s
;
2655 struct tipc_node
*node
;
2657 u32 profile_total
= 0;
2658 unsigned int bearer_id
;
2661 if (!strcmp(name
, tipc_bclink_name
))
2662 return tipc_bclink_stats(buf
, buf_size
);
2664 read_lock_bh(&tipc_net_lock
);
2665 node
= tipc_link_find_owner(name
, &bearer_id
);
2667 read_unlock_bh(&tipc_net_lock
);
2670 tipc_node_lock(node
);
2672 l
= node
->links
[bearer_id
];
2674 tipc_node_unlock(node
);
2675 read_unlock_bh(&tipc_net_lock
);
2681 if (tipc_link_is_active(l
))
2683 else if (tipc_link_is_up(l
))
2688 ret
= tipc_snprintf(buf
, buf_size
, "Link <%s>\n"
2689 " %s MTU:%u Priority:%u Tolerance:%u ms"
2690 " Window:%u packets\n",
2691 l
->name
, status
, l
->max_pkt
, l
->priority
,
2692 l
->tolerance
, l
->queue_limit
[0]);
2694 ret
+= tipc_snprintf(buf
+ ret
, buf_size
- ret
,
2695 " RX packets:%u fragments:%u/%u bundles:%u/%u\n",
2696 l
->next_in_no
- s
->recv_info
, s
->recv_fragments
,
2697 s
->recv_fragmented
, s
->recv_bundles
,
2700 ret
+= tipc_snprintf(buf
+ ret
, buf_size
- ret
,
2701 " TX packets:%u fragments:%u/%u bundles:%u/%u\n",
2702 l
->next_out_no
- s
->sent_info
, s
->sent_fragments
,
2703 s
->sent_fragmented
, s
->sent_bundles
,
2706 profile_total
= s
->msg_length_counts
;
2710 ret
+= tipc_snprintf(buf
+ ret
, buf_size
- ret
,
2711 " TX profile sample:%u packets average:%u octets\n"
2712 " 0-64:%u%% -256:%u%% -1024:%u%% -4096:%u%% "
2713 "-16384:%u%% -32768:%u%% -66000:%u%%\n",
2714 s
->msg_length_counts
,
2715 s
->msg_lengths_total
/ profile_total
,
2716 percent(s
->msg_length_profile
[0], profile_total
),
2717 percent(s
->msg_length_profile
[1], profile_total
),
2718 percent(s
->msg_length_profile
[2], profile_total
),
2719 percent(s
->msg_length_profile
[3], profile_total
),
2720 percent(s
->msg_length_profile
[4], profile_total
),
2721 percent(s
->msg_length_profile
[5], profile_total
),
2722 percent(s
->msg_length_profile
[6], profile_total
));
2724 ret
+= tipc_snprintf(buf
+ ret
, buf_size
- ret
,
2725 " RX states:%u probes:%u naks:%u defs:%u"
2726 " dups:%u\n", s
->recv_states
, s
->recv_probes
,
2727 s
->recv_nacks
, s
->deferred_recv
, s
->duplicates
);
2729 ret
+= tipc_snprintf(buf
+ ret
, buf_size
- ret
,
2730 " TX states:%u probes:%u naks:%u acks:%u"
2731 " dups:%u\n", s
->sent_states
, s
->sent_probes
,
2732 s
->sent_nacks
, s
->sent_acks
, s
->retransmitted
);
2734 ret
+= tipc_snprintf(buf
+ ret
, buf_size
- ret
,
2735 " Congestion link:%u Send queue"
2736 " max:%u avg:%u\n", s
->link_congs
,
2737 s
->max_queue_sz
, s
->queue_sz_counts
?
2738 (s
->accu_queue_sz
/ s
->queue_sz_counts
) : 0);
2740 tipc_node_unlock(node
);
2741 read_unlock_bh(&tipc_net_lock
);
2745 struct sk_buff
*tipc_link_cmd_show_stats(const void *req_tlv_area
, int req_tlv_space
)
2747 struct sk_buff
*buf
;
2748 struct tlv_desc
*rep_tlv
;
2753 if (!TLV_CHECK(req_tlv_area
, req_tlv_space
, TIPC_TLV_LINK_NAME
))
2754 return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR
);
2756 buf
= tipc_cfg_reply_alloc(TLV_SPACE(ULTRA_STRING_MAX_LEN
));
2760 rep_tlv
= (struct tlv_desc
*)buf
->data
;
2761 pb
= TLV_DATA(rep_tlv
);
2762 pb_len
= ULTRA_STRING_MAX_LEN
;
2763 str_len
= tipc_link_stats((char *)TLV_DATA(req_tlv_area
),
2767 return tipc_cfg_reply_error_string("link not found");
2769 str_len
+= 1; /* for "\0" */
2770 skb_put(buf
, TLV_SPACE(str_len
));
2771 TLV_SET(rep_tlv
, TIPC_TLV_ULTRA_STRING
, NULL
, str_len
);
2777 * tipc_link_get_max_pkt - get maximum packet size to use when sending to destination
2778 * @dest: network address of destination node
2779 * @selector: used to select from set of active links
2781 * If no active link can be found, uses default maximum packet size.
2783 u32
tipc_link_get_max_pkt(u32 dest
, u32 selector
)
2785 struct tipc_node
*n_ptr
;
2786 struct tipc_link
*l_ptr
;
2787 u32 res
= MAX_PKT_DEFAULT
;
2789 if (dest
== tipc_own_addr
)
2790 return MAX_MSG_SIZE
;
2792 read_lock_bh(&tipc_net_lock
);
2793 n_ptr
= tipc_node_find(dest
);
2795 tipc_node_lock(n_ptr
);
2796 l_ptr
= n_ptr
->active_links
[selector
& 1];
2798 res
= l_ptr
->max_pkt
;
2799 tipc_node_unlock(n_ptr
);
2801 read_unlock_bh(&tipc_net_lock
);
2805 static void link_print(struct tipc_link
*l_ptr
, const char *str
)
2807 struct tipc_bearer
*b_ptr
;
2810 b_ptr
= rcu_dereference_rtnl(bearer_list
[l_ptr
->bearer_id
]);
2812 pr_info("%s Link %x<%s>:", str
, l_ptr
->addr
, b_ptr
->name
);
2815 if (link_working_unknown(l_ptr
))
2817 else if (link_reset_reset(l_ptr
))
2819 else if (link_reset_unknown(l_ptr
))
2821 else if (link_working_working(l_ptr
))
This page took 0.08569 seconds and 6 git commands to generate.