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 tipc_node_lock(n_ptr
);
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 tipc_node_unlock(n_ptr
);
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 tipc_node_unlock(n_ptr
);
316 del_timer_sync(&l_ptr
->timer
);
320 tipc_node_unlock(n_ptr
);
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 tipc_node_lock(n_ptr
);
478 l_ptr
= n_ptr
->links
[bearer_id
];
480 tipc_link_reset(l_ptr
);
481 tipc_node_unlock(n_ptr
);
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 n_ptr
= tipc_node_find(dest
);
840 tipc_node_lock(n_ptr
);
841 l_ptr
= n_ptr
->active_links
[selector
& 1];
843 res
= __tipc_link_xmit(l_ptr
, buf
);
846 tipc_node_unlock(n_ptr
);
854 * tipc_link_sync_xmit - synchronize broadcast link endpoints.
856 * Give a newly added peer node the sequence number where it should
857 * start receiving and acking broadcast packets.
859 * Called with node locked
861 static void tipc_link_sync_xmit(struct tipc_link
*l
)
864 struct tipc_msg
*msg
;
866 buf
= tipc_buf_acquire(INT_H_SIZE
);
871 tipc_msg_init(msg
, BCAST_PROTOCOL
, STATE_MSG
, INT_H_SIZE
, l
->addr
);
872 msg_set_last_bcast(msg
, l
->owner
->bclink
.acked
);
873 link_add_chain_to_outqueue(l
, buf
, 0);
874 tipc_link_push_queue(l
);
878 * tipc_link_sync_rcv - synchronize broadcast link endpoints.
879 * Receive the sequence number where we should start receiving and
880 * acking broadcast packets from a newly added peer node, and open
881 * up for reception of such packets.
883 * Called with node locked
885 static void tipc_link_sync_rcv(struct tipc_node
*n
, struct sk_buff
*buf
)
887 struct tipc_msg
*msg
= buf_msg(buf
);
889 n
->bclink
.last_sent
= n
->bclink
.last_in
= msg_last_bcast(msg
);
890 n
->bclink
.recv_permitted
= true;
895 * tipc_link_names_xmit - send name table entries to new neighbor
897 * Send routine for bulk delivery of name table messages when contact
898 * with a new neighbor occurs. No link congestion checking is performed
899 * because name table messages *must* be delivered. The messages must be
900 * small enough not to require fragmentation.
901 * Called without any locks held.
903 void tipc_link_names_xmit(struct list_head
*message_list
, u32 dest
)
905 struct tipc_node
*n_ptr
;
906 struct tipc_link
*l_ptr
;
908 struct sk_buff
*temp_buf
;
910 if (list_empty(message_list
))
913 n_ptr
= tipc_node_find(dest
);
915 tipc_node_lock(n_ptr
);
916 l_ptr
= n_ptr
->active_links
[0];
918 /* convert circular list to linear list */
919 ((struct sk_buff
*)message_list
->prev
)->next
= NULL
;
920 link_add_chain_to_outqueue(l_ptr
,
921 (struct sk_buff
*)message_list
->next
, 0);
922 tipc_link_push_queue(l_ptr
);
923 INIT_LIST_HEAD(message_list
);
925 tipc_node_unlock(n_ptr
);
928 /* discard the messages if they couldn't be sent */
929 list_for_each_safe(buf
, temp_buf
, ((struct sk_buff
*)message_list
)) {
930 list_del((struct list_head
*)buf
);
936 * tipc_link_xmit_fast: Entry for data messages where the
937 * destination link is known and the header is complete,
938 * inclusive total message length. Very time critical.
939 * Link is locked. Returns user data length.
941 static int tipc_link_xmit_fast(struct tipc_link
*l_ptr
, struct sk_buff
*buf
,
944 struct tipc_msg
*msg
= buf_msg(buf
);
945 int res
= msg_data_sz(msg
);
947 if (likely(!link_congested(l_ptr
))) {
948 if (likely(msg_size(msg
) <= l_ptr
->max_pkt
)) {
949 link_add_to_outqueue(l_ptr
, buf
, msg
);
950 tipc_bearer_send(l_ptr
->bearer_id
, buf
,
952 l_ptr
->unacked_window
= 0;
956 *used_max_pkt
= l_ptr
->max_pkt
;
958 return __tipc_link_xmit(l_ptr
, buf
); /* All other cases */
962 * tipc_link_iovec_xmit_fast: Entry for messages where the
963 * destination processor is known and the header is complete,
964 * except for total message length.
965 * Returns user data length or errno.
967 int tipc_link_iovec_xmit_fast(struct tipc_port
*sender
,
968 struct iovec
const *msg_sect
,
969 unsigned int len
, u32 destaddr
)
971 struct tipc_msg
*hdr
= &sender
->phdr
;
972 struct tipc_link
*l_ptr
;
974 struct tipc_node
*node
;
976 u32 selector
= msg_origport(hdr
) & 1;
980 * Try building message using port's max_pkt hint.
981 * (Must not hold any locks while building message.)
983 res
= tipc_msg_build(hdr
, msg_sect
, len
, sender
->max_pkt
, &buf
);
984 /* Exit if build request was invalid */
985 if (unlikely(res
< 0))
988 node
= tipc_node_find(destaddr
);
990 tipc_node_lock(node
);
991 l_ptr
= node
->active_links
[selector
];
994 res
= tipc_link_xmit_fast(l_ptr
, buf
,
997 tipc_node_unlock(node
);
1001 /* Exit if link (or bearer) is congested */
1002 if (link_congested(l_ptr
)) {
1003 res
= link_schedule_port(l_ptr
,
1009 * Message size exceeds max_pkt hint; update hint,
1010 * then re-try fast path or fragment the message
1012 sender
->max_pkt
= l_ptr
->max_pkt
;
1013 tipc_node_unlock(node
);
1016 if ((msg_hdr_sz(hdr
) + res
) <= sender
->max_pkt
)
1019 return tipc_link_iovec_long_xmit(sender
, msg_sect
,
1022 tipc_node_unlock(node
);
1025 /* Couldn't find a link to the destination node */
1027 tipc_port_iovec_reject(sender
, hdr
, msg_sect
, len
, TIPC_ERR_NO_NODE
);
1028 return -ENETUNREACH
;
1032 * tipc_link_iovec_long_xmit(): Entry for long messages where the
1033 * destination node is known and the header is complete,
1034 * inclusive total message length.
1035 * Link and bearer congestion status have been checked to be ok,
1036 * and are ignored if they change.
1038 * Note that fragments do not use the full link MTU so that they won't have
1039 * to undergo refragmentation if link changeover causes them to be sent
1040 * over another link with an additional tunnel header added as prefix.
1041 * (Refragmentation will still occur if the other link has a smaller MTU.)
1043 * Returns user data length or errno.
1045 static int tipc_link_iovec_long_xmit(struct tipc_port
*sender
,
1046 struct iovec
const *msg_sect
,
1047 unsigned int len
, u32 destaddr
)
1049 struct tipc_link
*l_ptr
;
1050 struct tipc_node
*node
;
1051 struct tipc_msg
*hdr
= &sender
->phdr
;
1053 u32 max_pkt
, fragm_sz
, rest
;
1054 struct tipc_msg fragm_hdr
;
1055 struct sk_buff
*buf
, *buf_chain
, *prev
;
1056 u32 fragm_crs
, fragm_rest
, hsz
, sect_rest
;
1057 const unchar __user
*sect_crs
;
1064 max_pkt
= sender
->max_pkt
- INT_H_SIZE
;
1065 /* leave room for tunnel header in case of link changeover */
1066 fragm_sz
= max_pkt
- INT_H_SIZE
;
1067 /* leave room for fragmentation header in each fragment */
1075 /* Prepare reusable fragment header */
1076 tipc_msg_init(&fragm_hdr
, MSG_FRAGMENTER
, FIRST_FRAGMENT
,
1077 INT_H_SIZE
, msg_destnode(hdr
));
1078 msg_set_size(&fragm_hdr
, max_pkt
);
1079 msg_set_fragm_no(&fragm_hdr
, 1);
1081 /* Prepare header of first fragment */
1082 buf_chain
= buf
= tipc_buf_acquire(max_pkt
);
1086 skb_copy_to_linear_data(buf
, &fragm_hdr
, INT_H_SIZE
);
1087 hsz
= msg_hdr_sz(hdr
);
1088 skb_copy_to_linear_data_offset(buf
, INT_H_SIZE
, hdr
, hsz
);
1090 /* Chop up message */
1091 fragm_crs
= INT_H_SIZE
+ hsz
;
1092 fragm_rest
= fragm_sz
- hsz
;
1094 do { /* For all sections */
1098 sect_rest
= msg_sect
[++curr_sect
].iov_len
;
1099 sect_crs
= msg_sect
[curr_sect
].iov_base
;
1102 if (sect_rest
< fragm_rest
)
1107 if (copy_from_user(buf
->data
+ fragm_crs
, sect_crs
, sz
)) {
1110 kfree_skb_list(buf_chain
);
1119 if (!fragm_rest
&& rest
) {
1121 /* Initiate new fragment: */
1122 if (rest
<= fragm_sz
) {
1124 msg_set_type(&fragm_hdr
, LAST_FRAGMENT
);
1126 msg_set_type(&fragm_hdr
, FRAGMENT
);
1128 msg_set_size(&fragm_hdr
, fragm_sz
+ INT_H_SIZE
);
1129 msg_set_fragm_no(&fragm_hdr
, ++fragm_no
);
1131 buf
= tipc_buf_acquire(fragm_sz
+ INT_H_SIZE
);
1139 skb_copy_to_linear_data(buf
, &fragm_hdr
, INT_H_SIZE
);
1140 fragm_crs
= INT_H_SIZE
;
1141 fragm_rest
= fragm_sz
;
1146 * Now we have a buffer chain. Select a link and check
1147 * that packet size is still OK
1149 node
= tipc_node_find(destaddr
);
1151 tipc_node_lock(node
);
1152 l_ptr
= node
->active_links
[sender
->ref
& 1];
1154 tipc_node_unlock(node
);
1157 if (l_ptr
->max_pkt
< max_pkt
) {
1158 sender
->max_pkt
= l_ptr
->max_pkt
;
1159 tipc_node_unlock(node
);
1160 kfree_skb_list(buf_chain
);
1165 kfree_skb_list(buf_chain
);
1166 tipc_port_iovec_reject(sender
, hdr
, msg_sect
, len
,
1168 return -ENETUNREACH
;
1171 /* Append chain of fragments to send queue & send them */
1172 l_ptr
->long_msg_seq_no
++;
1173 link_add_chain_to_outqueue(l_ptr
, buf_chain
, l_ptr
->long_msg_seq_no
);
1174 l_ptr
->stats
.sent_fragments
+= fragm_no
;
1175 l_ptr
->stats
.sent_fragmented
++;
1176 tipc_link_push_queue(l_ptr
);
1177 tipc_node_unlock(node
);
1182 * tipc_link_push_packet: Push one unsent packet to the media
1184 static u32
tipc_link_push_packet(struct tipc_link
*l_ptr
)
1186 struct sk_buff
*buf
= l_ptr
->first_out
;
1187 u32 r_q_size
= l_ptr
->retransm_queue_size
;
1188 u32 r_q_head
= l_ptr
->retransm_queue_head
;
1190 /* Step to position where retransmission failed, if any, */
1191 /* consider that buffers may have been released in meantime */
1192 if (r_q_size
&& buf
) {
1193 u32 last
= lesser(mod(r_q_head
+ r_q_size
),
1194 link_last_sent(l_ptr
));
1195 u32 first
= buf_seqno(buf
);
1197 while (buf
&& less(first
, r_q_head
)) {
1198 first
= mod(first
+ 1);
1201 l_ptr
->retransm_queue_head
= r_q_head
= first
;
1202 l_ptr
->retransm_queue_size
= r_q_size
= mod(last
- first
);
1205 /* Continue retransmission now, if there is anything: */
1206 if (r_q_size
&& buf
) {
1207 msg_set_ack(buf_msg(buf
), mod(l_ptr
->next_in_no
- 1));
1208 msg_set_bcast_ack(buf_msg(buf
), l_ptr
->owner
->bclink
.last_in
);
1209 tipc_bearer_send(l_ptr
->bearer_id
, buf
, &l_ptr
->media_addr
);
1210 l_ptr
->retransm_queue_head
= mod(++r_q_head
);
1211 l_ptr
->retransm_queue_size
= --r_q_size
;
1212 l_ptr
->stats
.retransmitted
++;
1216 /* Send deferred protocol message, if any: */
1217 buf
= l_ptr
->proto_msg_queue
;
1219 msg_set_ack(buf_msg(buf
), mod(l_ptr
->next_in_no
- 1));
1220 msg_set_bcast_ack(buf_msg(buf
), l_ptr
->owner
->bclink
.last_in
);
1221 tipc_bearer_send(l_ptr
->bearer_id
, buf
, &l_ptr
->media_addr
);
1222 l_ptr
->unacked_window
= 0;
1224 l_ptr
->proto_msg_queue
= NULL
;
1228 /* Send one deferred data message, if send window not full: */
1229 buf
= l_ptr
->next_out
;
1231 struct tipc_msg
*msg
= buf_msg(buf
);
1232 u32 next
= msg_seqno(msg
);
1233 u32 first
= buf_seqno(l_ptr
->first_out
);
1235 if (mod(next
- first
) < l_ptr
->queue_limit
[0]) {
1236 msg_set_ack(msg
, mod(l_ptr
->next_in_no
- 1));
1237 msg_set_bcast_ack(msg
, l_ptr
->owner
->bclink
.last_in
);
1238 tipc_bearer_send(l_ptr
->bearer_id
, buf
,
1239 &l_ptr
->media_addr
);
1240 if (msg_user(msg
) == MSG_BUNDLER
)
1241 msg_set_type(msg
, CLOSED_MSG
);
1242 l_ptr
->next_out
= buf
->next
;
1250 * push_queue(): push out the unsent messages of a link where
1251 * congestion has abated. Node is locked
1253 void tipc_link_push_queue(struct tipc_link
*l_ptr
)
1258 res
= tipc_link_push_packet(l_ptr
);
1262 static void link_reset_all(unsigned long addr
)
1264 struct tipc_node
*n_ptr
;
1265 char addr_string
[16];
1268 n_ptr
= tipc_node_find((u32
)addr
);
1270 return; /* node no longer exists */
1272 tipc_node_lock(n_ptr
);
1274 pr_warn("Resetting all links to %s\n",
1275 tipc_addr_string_fill(addr_string
, n_ptr
->addr
));
1277 for (i
= 0; i
< MAX_BEARERS
; i
++) {
1278 if (n_ptr
->links
[i
]) {
1279 link_print(n_ptr
->links
[i
], "Resetting link\n");
1280 tipc_link_reset(n_ptr
->links
[i
]);
1284 tipc_node_unlock(n_ptr
);
1287 static void link_retransmit_failure(struct tipc_link
*l_ptr
,
1288 struct sk_buff
*buf
)
1290 struct tipc_msg
*msg
= buf_msg(buf
);
1292 pr_warn("Retransmission failure on link <%s>\n", l_ptr
->name
);
1295 /* Handle failure on standard link */
1296 link_print(l_ptr
, "Resetting link\n");
1297 tipc_link_reset(l_ptr
);
1300 /* Handle failure on broadcast link */
1301 struct tipc_node
*n_ptr
;
1302 char addr_string
[16];
1304 pr_info("Msg seq number: %u, ", msg_seqno(msg
));
1305 pr_cont("Outstanding acks: %lu\n",
1306 (unsigned long) TIPC_SKB_CB(buf
)->handle
);
1308 n_ptr
= tipc_bclink_retransmit_to();
1309 tipc_node_lock(n_ptr
);
1311 tipc_addr_string_fill(addr_string
, n_ptr
->addr
);
1312 pr_info("Broadcast link info for %s\n", addr_string
);
1313 pr_info("Reception permitted: %d, Acked: %u\n",
1314 n_ptr
->bclink
.recv_permitted
,
1315 n_ptr
->bclink
.acked
);
1316 pr_info("Last in: %u, Oos state: %u, Last sent: %u\n",
1317 n_ptr
->bclink
.last_in
,
1318 n_ptr
->bclink
.oos_state
,
1319 n_ptr
->bclink
.last_sent
);
1321 tipc_k_signal((Handler
)link_reset_all
, (unsigned long)n_ptr
->addr
);
1323 tipc_node_unlock(n_ptr
);
1325 l_ptr
->stale_count
= 0;
1329 void tipc_link_retransmit(struct tipc_link
*l_ptr
, struct sk_buff
*buf
,
1332 struct tipc_msg
*msg
;
1339 /* Detect repeated retransmit failures */
1340 if (l_ptr
->last_retransmitted
== msg_seqno(msg
)) {
1341 if (++l_ptr
->stale_count
> 100) {
1342 link_retransmit_failure(l_ptr
, buf
);
1346 l_ptr
->last_retransmitted
= msg_seqno(msg
);
1347 l_ptr
->stale_count
= 1;
1350 while (retransmits
&& (buf
!= l_ptr
->next_out
) && buf
) {
1352 msg_set_ack(msg
, mod(l_ptr
->next_in_no
- 1));
1353 msg_set_bcast_ack(msg
, l_ptr
->owner
->bclink
.last_in
);
1354 tipc_bearer_send(l_ptr
->bearer_id
, buf
, &l_ptr
->media_addr
);
1357 l_ptr
->stats
.retransmitted
++;
1360 l_ptr
->retransm_queue_head
= l_ptr
->retransm_queue_size
= 0;
1364 * link_insert_deferred_queue - insert deferred messages back into receive chain
1366 static struct sk_buff
*link_insert_deferred_queue(struct tipc_link
*l_ptr
,
1367 struct sk_buff
*buf
)
1371 if (l_ptr
->oldest_deferred_in
== NULL
)
1374 seq_no
= buf_seqno(l_ptr
->oldest_deferred_in
);
1375 if (seq_no
== mod(l_ptr
->next_in_no
)) {
1376 l_ptr
->newest_deferred_in
->next
= buf
;
1377 buf
= l_ptr
->oldest_deferred_in
;
1378 l_ptr
->oldest_deferred_in
= NULL
;
1379 l_ptr
->deferred_inqueue_sz
= 0;
1385 * link_recv_buf_validate - validate basic format of received message
1387 * This routine ensures a TIPC message has an acceptable header, and at least
1388 * as much data as the header indicates it should. The routine also ensures
1389 * that the entire message header is stored in the main fragment of the message
1390 * buffer, to simplify future access to message header fields.
1392 * Note: Having extra info present in the message header or data areas is OK.
1393 * TIPC will ignore the excess, under the assumption that it is optional info
1394 * introduced by a later release of the protocol.
1396 static int link_recv_buf_validate(struct sk_buff
*buf
)
1398 static u32 min_data_hdr_size
[8] = {
1399 SHORT_H_SIZE
, MCAST_H_SIZE
, NAMED_H_SIZE
, BASIC_H_SIZE
,
1400 MAX_H_SIZE
, MAX_H_SIZE
, MAX_H_SIZE
, MAX_H_SIZE
1403 struct tipc_msg
*msg
;
1409 /* If this packet comes from the defer queue, the skb has already
1412 if (unlikely(TIPC_SKB_CB(buf
)->deferred
))
1415 if (unlikely(buf
->len
< MIN_H_SIZE
))
1418 msg
= skb_header_pointer(buf
, 0, sizeof(tipc_hdr
), tipc_hdr
);
1422 if (unlikely(msg_version(msg
) != TIPC_VERSION
))
1425 size
= msg_size(msg
);
1426 hdr_size
= msg_hdr_sz(msg
);
1427 min_hdr_size
= msg_isdata(msg
) ?
1428 min_data_hdr_size
[msg_type(msg
)] : INT_H_SIZE
;
1430 if (unlikely((hdr_size
< min_hdr_size
) ||
1431 (size
< hdr_size
) ||
1432 (buf
->len
< size
) ||
1433 (size
- hdr_size
> TIPC_MAX_USER_MSG_SIZE
)))
1436 return pskb_may_pull(buf
, hdr_size
);
1440 * tipc_rcv - process TIPC packets/messages arriving from off-node
1441 * @head: pointer to message buffer chain
1442 * @b_ptr: pointer to bearer message arrived on
1444 * Invoked with no locks held. Bearer pointer must point to a valid bearer
1445 * structure (i.e. cannot be NULL), but bearer can be inactive.
1447 void tipc_rcv(struct sk_buff
*head
, struct tipc_bearer
*b_ptr
)
1450 struct tipc_node
*n_ptr
;
1451 struct tipc_link
*l_ptr
;
1452 struct sk_buff
*crs
;
1453 struct sk_buff
*buf
= head
;
1454 struct tipc_msg
*msg
;
1462 /* Ensure message is well-formed */
1463 if (unlikely(!link_recv_buf_validate(buf
)))
1466 /* Ensure message data is a single contiguous unit */
1467 if (unlikely(skb_linearize(buf
)))
1470 /* Handle arrival of a non-unicast link message */
1473 if (unlikely(msg_non_seq(msg
))) {
1474 if (msg_user(msg
) == LINK_CONFIG
)
1475 tipc_disc_rcv(buf
, b_ptr
);
1477 tipc_bclink_rcv(buf
);
1481 /* Discard unicast link messages destined for another node */
1482 if (unlikely(!msg_short(msg
) &&
1483 (msg_destnode(msg
) != tipc_own_addr
)))
1486 /* Locate neighboring node that sent message */
1487 n_ptr
= tipc_node_find(msg_prevnode(msg
));
1488 if (unlikely(!n_ptr
))
1490 tipc_node_lock(n_ptr
);
1492 /* Locate unicast link endpoint that should handle message */
1493 l_ptr
= n_ptr
->links
[b_ptr
->identity
];
1494 if (unlikely(!l_ptr
))
1495 goto unlock_discard
;
1497 /* Verify that communication with node is currently allowed */
1498 if ((n_ptr
->flags
& TIPC_NODE_DOWN
) &&
1499 msg_user(msg
) == LINK_PROTOCOL
&&
1500 (msg_type(msg
) == RESET_MSG
||
1501 msg_type(msg
) == ACTIVATE_MSG
) &&
1502 !msg_redundant_link(msg
))
1503 n_ptr
->flags
&= ~TIPC_NODE_DOWN
;
1505 if (tipc_node_blocked(n_ptr
))
1506 goto unlock_discard
;
1508 /* Validate message sequence number info */
1509 seq_no
= msg_seqno(msg
);
1510 ackd
= msg_ack(msg
);
1512 /* Release acked messages */
1513 if (n_ptr
->bclink
.recv_permitted
)
1514 tipc_bclink_acknowledge(n_ptr
, msg_bcast_ack(msg
));
1516 crs
= l_ptr
->first_out
;
1517 while ((crs
!= l_ptr
->next_out
) &&
1518 less_eq(buf_seqno(crs
), ackd
)) {
1519 struct sk_buff
*next
= crs
->next
;
1525 l_ptr
->first_out
= crs
;
1526 l_ptr
->out_queue_size
-= released
;
1529 /* Try sending any messages link endpoint has pending */
1530 if (unlikely(l_ptr
->next_out
))
1531 tipc_link_push_queue(l_ptr
);
1533 if (unlikely(!list_empty(&l_ptr
->waiting_ports
)))
1534 tipc_link_wakeup_ports(l_ptr
, 0);
1536 if (unlikely(++l_ptr
->unacked_window
>= TIPC_MIN_LINK_WIN
)) {
1537 l_ptr
->stats
.sent_acks
++;
1538 tipc_link_proto_xmit(l_ptr
, STATE_MSG
, 0, 0, 0, 0, 0);
1541 /* Process the incoming packet */
1542 if (unlikely(!link_working_working(l_ptr
))) {
1543 if (msg_user(msg
) == LINK_PROTOCOL
) {
1544 tipc_link_proto_rcv(l_ptr
, buf
);
1545 head
= link_insert_deferred_queue(l_ptr
, head
);
1546 tipc_node_unlock(n_ptr
);
1550 /* Traffic message. Conditionally activate link */
1551 link_state_event(l_ptr
, TRAFFIC_MSG_EVT
);
1553 if (link_working_working(l_ptr
)) {
1554 /* Re-insert buffer in front of queue */
1557 tipc_node_unlock(n_ptr
);
1560 goto unlock_discard
;
1563 /* Link is now in state WORKING_WORKING */
1564 if (unlikely(seq_no
!= mod(l_ptr
->next_in_no
))) {
1565 link_handle_out_of_seq_msg(l_ptr
, buf
);
1566 head
= link_insert_deferred_queue(l_ptr
, head
);
1567 tipc_node_unlock(n_ptr
);
1570 l_ptr
->next_in_no
++;
1571 if (unlikely(l_ptr
->oldest_deferred_in
))
1572 head
= link_insert_deferred_queue(l_ptr
, head
);
1574 /* Deliver packet/message to correct user: */
1575 if (unlikely(msg_user(msg
) == CHANGEOVER_PROTOCOL
)) {
1576 if (!tipc_link_tunnel_rcv(n_ptr
, &buf
)) {
1577 tipc_node_unlock(n_ptr
);
1581 } else if (msg_user(msg
) == MSG_FRAGMENTER
) {
1584 l_ptr
->stats
.recv_fragments
++;
1585 rc
= tipc_link_frag_rcv(&l_ptr
->reasm_head
,
1588 if (rc
== LINK_REASM_COMPLETE
) {
1589 l_ptr
->stats
.recv_fragmented
++;
1592 if (rc
== LINK_REASM_ERROR
)
1593 tipc_link_reset(l_ptr
);
1594 tipc_node_unlock(n_ptr
);
1599 switch (msg_user(msg
)) {
1600 case TIPC_LOW_IMPORTANCE
:
1601 case TIPC_MEDIUM_IMPORTANCE
:
1602 case TIPC_HIGH_IMPORTANCE
:
1603 case TIPC_CRITICAL_IMPORTANCE
:
1604 tipc_node_unlock(n_ptr
);
1608 l_ptr
->stats
.recv_bundles
++;
1609 l_ptr
->stats
.recv_bundled
+= msg_msgcnt(msg
);
1610 tipc_node_unlock(n_ptr
);
1611 tipc_link_bundle_rcv(buf
);
1613 case NAME_DISTRIBUTOR
:
1614 n_ptr
->bclink
.recv_permitted
= true;
1615 tipc_node_unlock(n_ptr
);
1616 tipc_named_rcv(buf
);
1619 tipc_node_unlock(n_ptr
);
1620 tipc_port_proto_rcv(buf
);
1622 case BCAST_PROTOCOL
:
1623 tipc_link_sync_rcv(n_ptr
, buf
);
1629 tipc_node_unlock(n_ptr
);
1632 tipc_node_unlock(n_ptr
);
1639 * tipc_link_defer_pkt - Add out-of-sequence message to deferred reception queue
1641 * Returns increase in queue length (i.e. 0 or 1)
1643 u32
tipc_link_defer_pkt(struct sk_buff
**head
, struct sk_buff
**tail
,
1644 struct sk_buff
*buf
)
1646 struct sk_buff
*queue_buf
;
1647 struct sk_buff
**prev
;
1648 u32 seq_no
= buf_seqno(buf
);
1653 if (*head
== NULL
) {
1654 *head
= *tail
= buf
;
1659 if (less(buf_seqno(*tail
), seq_no
)) {
1660 (*tail
)->next
= buf
;
1665 /* Locate insertion point in queue, then insert; discard if duplicate */
1669 u32 curr_seqno
= buf_seqno(queue_buf
);
1671 if (seq_no
== curr_seqno
) {
1676 if (less(seq_no
, curr_seqno
))
1679 prev
= &queue_buf
->next
;
1680 queue_buf
= queue_buf
->next
;
1683 buf
->next
= queue_buf
;
1689 * link_handle_out_of_seq_msg - handle arrival of out-of-sequence packet
1691 static void link_handle_out_of_seq_msg(struct tipc_link
*l_ptr
,
1692 struct sk_buff
*buf
)
1694 u32 seq_no
= buf_seqno(buf
);
1696 if (likely(msg_user(buf_msg(buf
)) == LINK_PROTOCOL
)) {
1697 tipc_link_proto_rcv(l_ptr
, buf
);
1701 /* Record OOS packet arrival (force mismatch on next timeout) */
1702 l_ptr
->checkpoint
--;
1705 * Discard packet if a duplicate; otherwise add it to deferred queue
1706 * and notify peer of gap as per protocol specification
1708 if (less(seq_no
, mod(l_ptr
->next_in_no
))) {
1709 l_ptr
->stats
.duplicates
++;
1714 if (tipc_link_defer_pkt(&l_ptr
->oldest_deferred_in
,
1715 &l_ptr
->newest_deferred_in
, buf
)) {
1716 l_ptr
->deferred_inqueue_sz
++;
1717 l_ptr
->stats
.deferred_recv
++;
1718 TIPC_SKB_CB(buf
)->deferred
= true;
1719 if ((l_ptr
->deferred_inqueue_sz
% 16) == 1)
1720 tipc_link_proto_xmit(l_ptr
, STATE_MSG
, 0, 0, 0, 0, 0);
1722 l_ptr
->stats
.duplicates
++;
1726 * Send protocol message to the other endpoint.
1728 void tipc_link_proto_xmit(struct tipc_link
*l_ptr
, u32 msg_typ
, int probe_msg
,
1729 u32 gap
, u32 tolerance
, u32 priority
, u32 ack_mtu
)
1731 struct sk_buff
*buf
= NULL
;
1732 struct tipc_msg
*msg
= l_ptr
->pmsg
;
1733 u32 msg_size
= sizeof(l_ptr
->proto_msg
);
1736 /* Discard any previous message that was deferred due to congestion */
1737 if (l_ptr
->proto_msg_queue
) {
1738 kfree_skb(l_ptr
->proto_msg_queue
);
1739 l_ptr
->proto_msg_queue
= NULL
;
1742 /* Don't send protocol message during link changeover */
1743 if (l_ptr
->exp_msg_count
)
1746 /* Abort non-RESET send if communication with node is prohibited */
1747 if ((tipc_node_blocked(l_ptr
->owner
)) && (msg_typ
!= RESET_MSG
))
1750 /* Create protocol message with "out-of-sequence" sequence number */
1751 msg_set_type(msg
, msg_typ
);
1752 msg_set_net_plane(msg
, l_ptr
->net_plane
);
1753 msg_set_bcast_ack(msg
, l_ptr
->owner
->bclink
.last_in
);
1754 msg_set_last_bcast(msg
, tipc_bclink_get_last_sent());
1756 if (msg_typ
== STATE_MSG
) {
1757 u32 next_sent
= mod(l_ptr
->next_out_no
);
1759 if (!tipc_link_is_up(l_ptr
))
1761 if (l_ptr
->next_out
)
1762 next_sent
= buf_seqno(l_ptr
->next_out
);
1763 msg_set_next_sent(msg
, next_sent
);
1764 if (l_ptr
->oldest_deferred_in
) {
1765 u32 rec
= buf_seqno(l_ptr
->oldest_deferred_in
);
1766 gap
= mod(rec
- mod(l_ptr
->next_in_no
));
1768 msg_set_seq_gap(msg
, gap
);
1770 l_ptr
->stats
.sent_nacks
++;
1771 msg_set_link_tolerance(msg
, tolerance
);
1772 msg_set_linkprio(msg
, priority
);
1773 msg_set_max_pkt(msg
, ack_mtu
);
1774 msg_set_ack(msg
, mod(l_ptr
->next_in_no
- 1));
1775 msg_set_probe(msg
, probe_msg
!= 0);
1777 u32 mtu
= l_ptr
->max_pkt
;
1779 if ((mtu
< l_ptr
->max_pkt_target
) &&
1780 link_working_working(l_ptr
) &&
1781 l_ptr
->fsm_msg_cnt
) {
1782 msg_size
= (mtu
+ (l_ptr
->max_pkt_target
- mtu
)/2 + 2) & ~3;
1783 if (l_ptr
->max_pkt_probes
== 10) {
1784 l_ptr
->max_pkt_target
= (msg_size
- 4);
1785 l_ptr
->max_pkt_probes
= 0;
1786 msg_size
= (mtu
+ (l_ptr
->max_pkt_target
- mtu
)/2 + 2) & ~3;
1788 l_ptr
->max_pkt_probes
++;
1791 l_ptr
->stats
.sent_probes
++;
1793 l_ptr
->stats
.sent_states
++;
1794 } else { /* RESET_MSG or ACTIVATE_MSG */
1795 msg_set_ack(msg
, mod(l_ptr
->reset_checkpoint
- 1));
1796 msg_set_seq_gap(msg
, 0);
1797 msg_set_next_sent(msg
, 1);
1798 msg_set_probe(msg
, 0);
1799 msg_set_link_tolerance(msg
, l_ptr
->tolerance
);
1800 msg_set_linkprio(msg
, l_ptr
->priority
);
1801 msg_set_max_pkt(msg
, l_ptr
->max_pkt_target
);
1804 r_flag
= (l_ptr
->owner
->working_links
> tipc_link_is_up(l_ptr
));
1805 msg_set_redundant_link(msg
, r_flag
);
1806 msg_set_linkprio(msg
, l_ptr
->priority
);
1807 msg_set_size(msg
, msg_size
);
1809 msg_set_seqno(msg
, mod(l_ptr
->next_out_no
+ (0xffff/2)));
1811 buf
= tipc_buf_acquire(msg_size
);
1815 skb_copy_to_linear_data(buf
, msg
, sizeof(l_ptr
->proto_msg
));
1816 buf
->priority
= TC_PRIO_CONTROL
;
1818 tipc_bearer_send(l_ptr
->bearer_id
, buf
, &l_ptr
->media_addr
);
1819 l_ptr
->unacked_window
= 0;
1824 * Receive protocol message :
1825 * Note that network plane id propagates through the network, and may
1826 * change at any time. The node with lowest address rules
1828 static void tipc_link_proto_rcv(struct tipc_link
*l_ptr
, struct sk_buff
*buf
)
1834 struct tipc_msg
*msg
= buf_msg(buf
);
1836 /* Discard protocol message during link changeover */
1837 if (l_ptr
->exp_msg_count
)
1840 /* record unnumbered packet arrival (force mismatch on next timeout) */
1841 l_ptr
->checkpoint
--;
1843 if (l_ptr
->net_plane
!= msg_net_plane(msg
))
1844 if (tipc_own_addr
> msg_prevnode(msg
))
1845 l_ptr
->net_plane
= msg_net_plane(msg
);
1847 switch (msg_type(msg
)) {
1850 if (!link_working_unknown(l_ptr
) &&
1851 (l_ptr
->peer_session
!= INVALID_SESSION
)) {
1852 if (less_eq(msg_session(msg
), l_ptr
->peer_session
))
1853 break; /* duplicate or old reset: ignore */
1856 if (!msg_redundant_link(msg
) && (link_working_working(l_ptr
) ||
1857 link_working_unknown(l_ptr
))) {
1859 * peer has lost contact -- don't allow peer's links
1860 * to reactivate before we recognize loss & clean up
1862 l_ptr
->owner
->flags
= TIPC_NODE_RESET
;
1865 link_state_event(l_ptr
, RESET_MSG
);
1869 /* Update link settings according other endpoint's values */
1870 strcpy((strrchr(l_ptr
->name
, ':') + 1), (char *)msg_data(msg
));
1872 msg_tol
= msg_link_tolerance(msg
);
1873 if (msg_tol
> l_ptr
->tolerance
)
1874 link_set_supervision_props(l_ptr
, msg_tol
);
1876 if (msg_linkprio(msg
) > l_ptr
->priority
)
1877 l_ptr
->priority
= msg_linkprio(msg
);
1879 max_pkt_info
= msg_max_pkt(msg
);
1881 if (max_pkt_info
< l_ptr
->max_pkt_target
)
1882 l_ptr
->max_pkt_target
= max_pkt_info
;
1883 if (l_ptr
->max_pkt
> l_ptr
->max_pkt_target
)
1884 l_ptr
->max_pkt
= l_ptr
->max_pkt_target
;
1886 l_ptr
->max_pkt
= l_ptr
->max_pkt_target
;
1889 /* Synchronize broadcast link info, if not done previously */
1890 if (!tipc_node_is_up(l_ptr
->owner
)) {
1891 l_ptr
->owner
->bclink
.last_sent
=
1892 l_ptr
->owner
->bclink
.last_in
=
1893 msg_last_bcast(msg
);
1894 l_ptr
->owner
->bclink
.oos_state
= 0;
1897 l_ptr
->peer_session
= msg_session(msg
);
1898 l_ptr
->peer_bearer_id
= msg_bearer_id(msg
);
1900 if (msg_type(msg
) == ACTIVATE_MSG
)
1901 link_state_event(l_ptr
, ACTIVATE_MSG
);
1905 msg_tol
= msg_link_tolerance(msg
);
1907 link_set_supervision_props(l_ptr
, msg_tol
);
1909 if (msg_linkprio(msg
) &&
1910 (msg_linkprio(msg
) != l_ptr
->priority
)) {
1911 pr_warn("%s<%s>, priority change %u->%u\n",
1912 link_rst_msg
, l_ptr
->name
, l_ptr
->priority
,
1914 l_ptr
->priority
= msg_linkprio(msg
);
1915 tipc_link_reset(l_ptr
); /* Enforce change to take effect */
1918 link_state_event(l_ptr
, TRAFFIC_MSG_EVT
);
1919 l_ptr
->stats
.recv_states
++;
1920 if (link_reset_unknown(l_ptr
))
1923 if (less_eq(mod(l_ptr
->next_in_no
), msg_next_sent(msg
))) {
1924 rec_gap
= mod(msg_next_sent(msg
) -
1925 mod(l_ptr
->next_in_no
));
1928 max_pkt_ack
= msg_max_pkt(msg
);
1929 if (max_pkt_ack
> l_ptr
->max_pkt
) {
1930 l_ptr
->max_pkt
= max_pkt_ack
;
1931 l_ptr
->max_pkt_probes
= 0;
1935 if (msg_probe(msg
)) {
1936 l_ptr
->stats
.recv_probes
++;
1937 if (msg_size(msg
) > sizeof(l_ptr
->proto_msg
))
1938 max_pkt_ack
= msg_size(msg
);
1941 /* Protocol message before retransmits, reduce loss risk */
1942 if (l_ptr
->owner
->bclink
.recv_permitted
)
1943 tipc_bclink_update_link_state(l_ptr
->owner
,
1944 msg_last_bcast(msg
));
1946 if (rec_gap
|| (msg_probe(msg
))) {
1947 tipc_link_proto_xmit(l_ptr
, STATE_MSG
, 0, rec_gap
, 0,
1950 if (msg_seq_gap(msg
)) {
1951 l_ptr
->stats
.recv_nacks
++;
1952 tipc_link_retransmit(l_ptr
, l_ptr
->first_out
,
1962 /* tipc_link_tunnel_xmit(): Tunnel one packet via a link belonging to
1963 * a different bearer. Owner node is locked.
1965 static void tipc_link_tunnel_xmit(struct tipc_link
*l_ptr
,
1966 struct tipc_msg
*tunnel_hdr
,
1967 struct tipc_msg
*msg
,
1970 struct tipc_link
*tunnel
;
1971 struct sk_buff
*buf
;
1972 u32 length
= msg_size(msg
);
1974 tunnel
= l_ptr
->owner
->active_links
[selector
& 1];
1975 if (!tipc_link_is_up(tunnel
)) {
1976 pr_warn("%stunnel link no longer available\n", link_co_err
);
1979 msg_set_size(tunnel_hdr
, length
+ INT_H_SIZE
);
1980 buf
= tipc_buf_acquire(length
+ INT_H_SIZE
);
1982 pr_warn("%sunable to send tunnel msg\n", link_co_err
);
1985 skb_copy_to_linear_data(buf
, tunnel_hdr
, INT_H_SIZE
);
1986 skb_copy_to_linear_data_offset(buf
, INT_H_SIZE
, msg
, length
);
1987 __tipc_link_xmit(tunnel
, buf
);
1991 /* tipc_link_failover_send_queue(): A link has gone down, but a second
1992 * link is still active. We can do failover. Tunnel the failing link's
1993 * whole send queue via the remaining link. This way, we don't lose
1994 * any packets, and sequence order is preserved for subsequent traffic
1995 * sent over the remaining link. Owner node is locked.
1997 void tipc_link_failover_send_queue(struct tipc_link
*l_ptr
)
1999 u32 msgcount
= l_ptr
->out_queue_size
;
2000 struct sk_buff
*crs
= l_ptr
->first_out
;
2001 struct tipc_link
*tunnel
= l_ptr
->owner
->active_links
[0];
2002 struct tipc_msg tunnel_hdr
;
2008 tipc_msg_init(&tunnel_hdr
, CHANGEOVER_PROTOCOL
,
2009 ORIGINAL_MSG
, INT_H_SIZE
, l_ptr
->addr
);
2010 msg_set_bearer_id(&tunnel_hdr
, l_ptr
->peer_bearer_id
);
2011 msg_set_msgcnt(&tunnel_hdr
, msgcount
);
2013 if (!l_ptr
->first_out
) {
2014 struct sk_buff
*buf
;
2016 buf
= tipc_buf_acquire(INT_H_SIZE
);
2018 skb_copy_to_linear_data(buf
, &tunnel_hdr
, INT_H_SIZE
);
2019 msg_set_size(&tunnel_hdr
, INT_H_SIZE
);
2020 __tipc_link_xmit(tunnel
, buf
);
2022 pr_warn("%sunable to send changeover msg\n",
2028 split_bundles
= (l_ptr
->owner
->active_links
[0] !=
2029 l_ptr
->owner
->active_links
[1]);
2032 struct tipc_msg
*msg
= buf_msg(crs
);
2034 if ((msg_user(msg
) == MSG_BUNDLER
) && split_bundles
) {
2035 struct tipc_msg
*m
= msg_get_wrapped(msg
);
2036 unchar
*pos
= (unchar
*)m
;
2038 msgcount
= msg_msgcnt(msg
);
2039 while (msgcount
--) {
2040 msg_set_seqno(m
, msg_seqno(msg
));
2041 tipc_link_tunnel_xmit(l_ptr
, &tunnel_hdr
, m
,
2042 msg_link_selector(m
));
2043 pos
+= align(msg_size(m
));
2044 m
= (struct tipc_msg
*)pos
;
2047 tipc_link_tunnel_xmit(l_ptr
, &tunnel_hdr
, msg
,
2048 msg_link_selector(msg
));
2054 /* tipc_link_dup_queue_xmit(): A second link has become active. Tunnel a
2055 * duplicate of the first link's send queue via the new link. This way, we
2056 * are guaranteed that currently queued packets from a socket are delivered
2057 * before future traffic from the same socket, even if this is using the
2058 * new link. The last arriving copy of each duplicate packet is dropped at
2059 * the receiving end by the regular protocol check, so packet cardinality
2060 * and sequence order is preserved per sender/receiver socket pair.
2061 * Owner node is locked.
2063 void tipc_link_dup_queue_xmit(struct tipc_link
*l_ptr
,
2064 struct tipc_link
*tunnel
)
2066 struct sk_buff
*iter
;
2067 struct tipc_msg tunnel_hdr
;
2069 tipc_msg_init(&tunnel_hdr
, CHANGEOVER_PROTOCOL
,
2070 DUPLICATE_MSG
, INT_H_SIZE
, l_ptr
->addr
);
2071 msg_set_msgcnt(&tunnel_hdr
, l_ptr
->out_queue_size
);
2072 msg_set_bearer_id(&tunnel_hdr
, l_ptr
->peer_bearer_id
);
2073 iter
= l_ptr
->first_out
;
2075 struct sk_buff
*outbuf
;
2076 struct tipc_msg
*msg
= buf_msg(iter
);
2077 u32 length
= msg_size(msg
);
2079 if (msg_user(msg
) == MSG_BUNDLER
)
2080 msg_set_type(msg
, CLOSED_MSG
);
2081 msg_set_ack(msg
, mod(l_ptr
->next_in_no
- 1)); /* Update */
2082 msg_set_bcast_ack(msg
, l_ptr
->owner
->bclink
.last_in
);
2083 msg_set_size(&tunnel_hdr
, length
+ INT_H_SIZE
);
2084 outbuf
= tipc_buf_acquire(length
+ INT_H_SIZE
);
2085 if (outbuf
== NULL
) {
2086 pr_warn("%sunable to send duplicate msg\n",
2090 skb_copy_to_linear_data(outbuf
, &tunnel_hdr
, INT_H_SIZE
);
2091 skb_copy_to_linear_data_offset(outbuf
, INT_H_SIZE
, iter
->data
,
2093 __tipc_link_xmit(tunnel
, outbuf
);
2094 if (!tipc_link_is_up(l_ptr
))
2101 * buf_extract - extracts embedded TIPC message from another message
2102 * @skb: encapsulating message buffer
2103 * @from_pos: offset to extract from
2105 * Returns a new message buffer containing an embedded message. The
2106 * encapsulating message itself is left unchanged.
2108 static struct sk_buff
*buf_extract(struct sk_buff
*skb
, u32 from_pos
)
2110 struct tipc_msg
*msg
= (struct tipc_msg
*)(skb
->data
+ from_pos
);
2111 u32 size
= msg_size(msg
);
2114 eb
= tipc_buf_acquire(size
);
2116 skb_copy_to_linear_data(eb
, msg
, size
);
2122 /* tipc_link_dup_rcv(): Receive a tunnelled DUPLICATE_MSG packet.
2123 * Owner node is locked.
2125 static void tipc_link_dup_rcv(struct tipc_link
*l_ptr
,
2126 struct sk_buff
*t_buf
)
2128 struct sk_buff
*buf
;
2130 if (!tipc_link_is_up(l_ptr
))
2133 buf
= buf_extract(t_buf
, INT_H_SIZE
);
2135 pr_warn("%sfailed to extract inner dup pkt\n", link_co_err
);
2139 /* Add buffer to deferred queue, if applicable: */
2140 link_handle_out_of_seq_msg(l_ptr
, buf
);
2143 /* tipc_link_failover_rcv(): Receive a tunnelled ORIGINAL_MSG packet
2144 * Owner node is locked.
2146 static struct sk_buff
*tipc_link_failover_rcv(struct tipc_link
*l_ptr
,
2147 struct sk_buff
*t_buf
)
2149 struct tipc_msg
*t_msg
= buf_msg(t_buf
);
2150 struct sk_buff
*buf
= NULL
;
2151 struct tipc_msg
*msg
;
2153 if (tipc_link_is_up(l_ptr
))
2154 tipc_link_reset(l_ptr
);
2156 /* First failover packet? */
2157 if (l_ptr
->exp_msg_count
== START_CHANGEOVER
)
2158 l_ptr
->exp_msg_count
= msg_msgcnt(t_msg
);
2160 /* Should there be an inner packet? */
2161 if (l_ptr
->exp_msg_count
) {
2162 l_ptr
->exp_msg_count
--;
2163 buf
= buf_extract(t_buf
, INT_H_SIZE
);
2165 pr_warn("%sno inner failover pkt\n", link_co_err
);
2170 if (less(msg_seqno(msg
), l_ptr
->reset_checkpoint
)) {
2175 if (msg_user(msg
) == MSG_FRAGMENTER
) {
2176 l_ptr
->stats
.recv_fragments
++;
2177 tipc_link_frag_rcv(&l_ptr
->reasm_head
,
2183 if ((l_ptr
->exp_msg_count
== 0) && (l_ptr
->flags
& LINK_STOPPED
)) {
2184 tipc_node_detach_link(l_ptr
->owner
, l_ptr
);
2190 /* tipc_link_tunnel_rcv(): Receive a tunnelled packet, sent
2191 * via other link as result of a failover (ORIGINAL_MSG) or
2192 * a new active link (DUPLICATE_MSG). Failover packets are
2193 * returned to the active link for delivery upwards.
2194 * Owner node is locked.
2196 static int tipc_link_tunnel_rcv(struct tipc_node
*n_ptr
,
2197 struct sk_buff
**buf
)
2199 struct sk_buff
*t_buf
= *buf
;
2200 struct tipc_link
*l_ptr
;
2201 struct tipc_msg
*t_msg
= buf_msg(t_buf
);
2202 u32 bearer_id
= msg_bearer_id(t_msg
);
2206 if (bearer_id
>= MAX_BEARERS
)
2209 l_ptr
= n_ptr
->links
[bearer_id
];
2213 if (msg_type(t_msg
) == DUPLICATE_MSG
)
2214 tipc_link_dup_rcv(l_ptr
, t_buf
);
2215 else if (msg_type(t_msg
) == ORIGINAL_MSG
)
2216 *buf
= tipc_link_failover_rcv(l_ptr
, t_buf
);
2218 pr_warn("%sunknown tunnel pkt received\n", link_co_err
);
2221 return *buf
!= NULL
;
2225 * Bundler functionality:
2227 void tipc_link_bundle_rcv(struct sk_buff
*buf
)
2229 u32 msgcount
= msg_msgcnt(buf_msg(buf
));
2230 u32 pos
= INT_H_SIZE
;
2231 struct sk_buff
*obuf
;
2233 while (msgcount
--) {
2234 obuf
= buf_extract(buf
, pos
);
2236 pr_warn("Link unable to unbundle message(s)\n");
2239 pos
+= align(msg_size(buf_msg(obuf
)));
2240 tipc_net_route_msg(obuf
);
2246 * Fragmentation/defragmentation:
2250 * tipc_link_frag_xmit: Entry for buffers needing fragmentation.
2251 * The buffer is complete, inclusive total message length.
2252 * Returns user data length.
2254 static int tipc_link_frag_xmit(struct tipc_link
*l_ptr
, struct sk_buff
*buf
)
2256 struct sk_buff
*buf_chain
= NULL
;
2257 struct sk_buff
*buf_chain_tail
= (struct sk_buff
*)&buf_chain
;
2258 struct tipc_msg
*inmsg
= buf_msg(buf
);
2259 struct tipc_msg fragm_hdr
;
2260 u32 insize
= msg_size(inmsg
);
2261 u32 dsz
= msg_data_sz(inmsg
);
2262 unchar
*crs
= buf
->data
;
2264 u32 pack_sz
= l_ptr
->max_pkt
;
2265 u32 fragm_sz
= pack_sz
- INT_H_SIZE
;
2269 if (msg_short(inmsg
))
2270 destaddr
= l_ptr
->addr
;
2272 destaddr
= msg_destnode(inmsg
);
2274 /* Prepare reusable fragment header: */
2275 tipc_msg_init(&fragm_hdr
, MSG_FRAGMENTER
, FIRST_FRAGMENT
,
2276 INT_H_SIZE
, destaddr
);
2278 /* Chop up message: */
2280 struct sk_buff
*fragm
;
2282 if (rest
<= fragm_sz
) {
2284 msg_set_type(&fragm_hdr
, LAST_FRAGMENT
);
2286 fragm
= tipc_buf_acquire(fragm_sz
+ INT_H_SIZE
);
2287 if (fragm
== NULL
) {
2289 kfree_skb_list(buf_chain
);
2292 msg_set_size(&fragm_hdr
, fragm_sz
+ INT_H_SIZE
);
2294 msg_set_fragm_no(&fragm_hdr
, fragm_no
);
2295 skb_copy_to_linear_data(fragm
, &fragm_hdr
, INT_H_SIZE
);
2296 skb_copy_to_linear_data_offset(fragm
, INT_H_SIZE
, crs
,
2298 buf_chain_tail
->next
= fragm
;
2299 buf_chain_tail
= fragm
;
2303 msg_set_type(&fragm_hdr
, FRAGMENT
);
2307 /* Append chain of fragments to send queue & send them */
2308 l_ptr
->long_msg_seq_no
++;
2309 link_add_chain_to_outqueue(l_ptr
, buf_chain
, l_ptr
->long_msg_seq_no
);
2310 l_ptr
->stats
.sent_fragments
+= fragm_no
;
2311 l_ptr
->stats
.sent_fragmented
++;
2312 tipc_link_push_queue(l_ptr
);
2317 /* tipc_link_frag_rcv(): Called with node lock on. Returns
2318 * the reassembled buffer if message is complete.
2320 int tipc_link_frag_rcv(struct sk_buff
**head
, struct sk_buff
**tail
,
2321 struct sk_buff
**fbuf
)
2323 struct sk_buff
*frag
= *fbuf
;
2324 struct tipc_msg
*msg
= buf_msg(frag
);
2325 u32 fragid
= msg_type(msg
);
2329 skb_pull(frag
, msg_hdr_sz(msg
));
2330 if (fragid
== FIRST_FRAGMENT
) {
2331 if (*head
|| skb_unclone(frag
, GFP_ATOMIC
))
2334 skb_frag_list_init(*head
);
2338 skb_try_coalesce(*head
, frag
, &headstolen
, &delta
)) {
2339 kfree_skb_partial(frag
, headstolen
);
2343 if (!skb_has_frag_list(*head
))
2344 skb_shinfo(*head
)->frag_list
= frag
;
2346 (*tail
)->next
= frag
;
2348 (*head
)->truesize
+= frag
->truesize
;
2350 if (fragid
== LAST_FRAGMENT
) {
2352 *tail
= *head
= NULL
;
2353 return LINK_REASM_COMPLETE
;
2358 pr_warn_ratelimited("Link unable to reassemble fragmented message\n");
2361 return LINK_REASM_ERROR
;
2364 static void link_set_supervision_props(struct tipc_link
*l_ptr
, u32 tolerance
)
2366 if ((tolerance
< TIPC_MIN_LINK_TOL
) || (tolerance
> TIPC_MAX_LINK_TOL
))
2369 l_ptr
->tolerance
= tolerance
;
2370 l_ptr
->continuity_interval
=
2371 ((tolerance
/ 4) > 500) ? 500 : tolerance
/ 4;
2372 l_ptr
->abort_limit
= tolerance
/ (l_ptr
->continuity_interval
/ 4);
2375 void tipc_link_set_queue_limits(struct tipc_link
*l_ptr
, u32 window
)
2377 /* Data messages from this node, inclusive FIRST_FRAGM */
2378 l_ptr
->queue_limit
[TIPC_LOW_IMPORTANCE
] = window
;
2379 l_ptr
->queue_limit
[TIPC_MEDIUM_IMPORTANCE
] = (window
/ 3) * 4;
2380 l_ptr
->queue_limit
[TIPC_HIGH_IMPORTANCE
] = (window
/ 3) * 5;
2381 l_ptr
->queue_limit
[TIPC_CRITICAL_IMPORTANCE
] = (window
/ 3) * 6;
2382 /* Transiting data messages,inclusive FIRST_FRAGM */
2383 l_ptr
->queue_limit
[TIPC_LOW_IMPORTANCE
+ 4] = 300;
2384 l_ptr
->queue_limit
[TIPC_MEDIUM_IMPORTANCE
+ 4] = 600;
2385 l_ptr
->queue_limit
[TIPC_HIGH_IMPORTANCE
+ 4] = 900;
2386 l_ptr
->queue_limit
[TIPC_CRITICAL_IMPORTANCE
+ 4] = 1200;
2387 l_ptr
->queue_limit
[CONN_MANAGER
] = 1200;
2388 l_ptr
->queue_limit
[CHANGEOVER_PROTOCOL
] = 2500;
2389 l_ptr
->queue_limit
[NAME_DISTRIBUTOR
] = 3000;
2390 /* FRAGMENT and LAST_FRAGMENT packets */
2391 l_ptr
->queue_limit
[MSG_FRAGMENTER
] = 4000;
2394 /* tipc_link_find_owner - locate owner node of link by link's name
2395 * @name: pointer to link name string
2396 * @bearer_id: pointer to index in 'node->links' array where the link was found.
2398 * Returns pointer to node owning the link, or 0 if no matching link is found.
2400 static struct tipc_node
*tipc_link_find_owner(const char *link_name
,
2401 unsigned int *bearer_id
)
2403 struct tipc_link
*l_ptr
;
2404 struct tipc_node
*n_ptr
;
2405 struct tipc_node
*found_node
= 0;
2410 list_for_each_entry_rcu(n_ptr
, &tipc_node_list
, list
) {
2411 tipc_node_lock(n_ptr
);
2412 for (i
= 0; i
< MAX_BEARERS
; i
++) {
2413 l_ptr
= n_ptr
->links
[i
];
2414 if (l_ptr
&& !strcmp(l_ptr
->name
, link_name
)) {
2420 tipc_node_unlock(n_ptr
);
2430 * link_value_is_valid -- validate proposed link tolerance/priority/window
2432 * @cmd: value type (TIPC_CMD_SET_LINK_*)
2433 * @new_value: the new value
2435 * Returns 1 if value is within range, 0 if not.
2437 static int link_value_is_valid(u16 cmd
, u32 new_value
)
2440 case TIPC_CMD_SET_LINK_TOL
:
2441 return (new_value
>= TIPC_MIN_LINK_TOL
) &&
2442 (new_value
<= TIPC_MAX_LINK_TOL
);
2443 case TIPC_CMD_SET_LINK_PRI
:
2444 return (new_value
<= TIPC_MAX_LINK_PRI
);
2445 case TIPC_CMD_SET_LINK_WINDOW
:
2446 return (new_value
>= TIPC_MIN_LINK_WIN
) &&
2447 (new_value
<= TIPC_MAX_LINK_WIN
);
2453 * link_cmd_set_value - change priority/tolerance/window for link/bearer/media
2454 * @name: ptr to link, bearer, or media name
2455 * @new_value: new value of link, bearer, or media setting
2456 * @cmd: which link, bearer, or media attribute to set (TIPC_CMD_SET_LINK_*)
2458 * Caller must hold RTNL lock to ensure link/bearer/media is not deleted.
2460 * Returns 0 if value updated and negative value on error.
2462 static int link_cmd_set_value(const char *name
, u32 new_value
, u16 cmd
)
2464 struct tipc_node
*node
;
2465 struct tipc_link
*l_ptr
;
2466 struct tipc_bearer
*b_ptr
;
2467 struct tipc_media
*m_ptr
;
2471 node
= tipc_link_find_owner(name
, &bearer_id
);
2473 tipc_node_lock(node
);
2474 l_ptr
= node
->links
[bearer_id
];
2478 case TIPC_CMD_SET_LINK_TOL
:
2479 link_set_supervision_props(l_ptr
, new_value
);
2480 tipc_link_proto_xmit(l_ptr
, STATE_MSG
, 0, 0,
2483 case TIPC_CMD_SET_LINK_PRI
:
2484 l_ptr
->priority
= new_value
;
2485 tipc_link_proto_xmit(l_ptr
, STATE_MSG
, 0, 0,
2488 case TIPC_CMD_SET_LINK_WINDOW
:
2489 tipc_link_set_queue_limits(l_ptr
, new_value
);
2496 tipc_node_unlock(node
);
2500 b_ptr
= tipc_bearer_find(name
);
2503 case TIPC_CMD_SET_LINK_TOL
:
2504 b_ptr
->tolerance
= new_value
;
2506 case TIPC_CMD_SET_LINK_PRI
:
2507 b_ptr
->priority
= new_value
;
2509 case TIPC_CMD_SET_LINK_WINDOW
:
2510 b_ptr
->window
= new_value
;
2519 m_ptr
= tipc_media_find(name
);
2523 case TIPC_CMD_SET_LINK_TOL
:
2524 m_ptr
->tolerance
= new_value
;
2526 case TIPC_CMD_SET_LINK_PRI
:
2527 m_ptr
->priority
= new_value
;
2529 case TIPC_CMD_SET_LINK_WINDOW
:
2530 m_ptr
->window
= new_value
;
2539 struct sk_buff
*tipc_link_cmd_config(const void *req_tlv_area
, int req_tlv_space
,
2542 struct tipc_link_config
*args
;
2546 if (!TLV_CHECK(req_tlv_area
, req_tlv_space
, TIPC_TLV_LINK_CONFIG
))
2547 return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR
);
2549 args
= (struct tipc_link_config
*)TLV_DATA(req_tlv_area
);
2550 new_value
= ntohl(args
->value
);
2552 if (!link_value_is_valid(cmd
, new_value
))
2553 return tipc_cfg_reply_error_string(
2554 "cannot change, value invalid");
2556 if (!strcmp(args
->name
, tipc_bclink_name
)) {
2557 if ((cmd
== TIPC_CMD_SET_LINK_WINDOW
) &&
2558 (tipc_bclink_set_queue_limits(new_value
) == 0))
2559 return tipc_cfg_reply_none();
2560 return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
2561 " (cannot change setting on broadcast link)");
2564 res
= link_cmd_set_value(args
->name
, new_value
, cmd
);
2566 return tipc_cfg_reply_error_string("cannot change link setting");
2568 return tipc_cfg_reply_none();
2572 * link_reset_statistics - reset link statistics
2573 * @l_ptr: pointer to link
2575 static void link_reset_statistics(struct tipc_link
*l_ptr
)
2577 memset(&l_ptr
->stats
, 0, sizeof(l_ptr
->stats
));
2578 l_ptr
->stats
.sent_info
= l_ptr
->next_out_no
;
2579 l_ptr
->stats
.recv_info
= l_ptr
->next_in_no
;
2582 struct sk_buff
*tipc_link_cmd_reset_stats(const void *req_tlv_area
, int req_tlv_space
)
2585 struct tipc_link
*l_ptr
;
2586 struct tipc_node
*node
;
2587 unsigned int bearer_id
;
2589 if (!TLV_CHECK(req_tlv_area
, req_tlv_space
, TIPC_TLV_LINK_NAME
))
2590 return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR
);
2592 link_name
= (char *)TLV_DATA(req_tlv_area
);
2593 if (!strcmp(link_name
, tipc_bclink_name
)) {
2594 if (tipc_bclink_reset_stats())
2595 return tipc_cfg_reply_error_string("link not found");
2596 return tipc_cfg_reply_none();
2598 node
= tipc_link_find_owner(link_name
, &bearer_id
);
2600 return tipc_cfg_reply_error_string("link not found");
2602 tipc_node_lock(node
);
2603 l_ptr
= node
->links
[bearer_id
];
2605 tipc_node_unlock(node
);
2606 return tipc_cfg_reply_error_string("link not found");
2608 link_reset_statistics(l_ptr
);
2609 tipc_node_unlock(node
);
2610 return tipc_cfg_reply_none();
2614 * percent - convert count to a percentage of total (rounding up or down)
2616 static u32
percent(u32 count
, u32 total
)
2618 return (count
* 100 + (total
/ 2)) / total
;
2622 * tipc_link_stats - print link statistics
2624 * @buf: print buffer area
2625 * @buf_size: size of print buffer area
2627 * Returns length of print buffer data string (or 0 if error)
2629 static int tipc_link_stats(const char *name
, char *buf
, const u32 buf_size
)
2631 struct tipc_link
*l
;
2632 struct tipc_stats
*s
;
2633 struct tipc_node
*node
;
2635 u32 profile_total
= 0;
2636 unsigned int bearer_id
;
2639 if (!strcmp(name
, tipc_bclink_name
))
2640 return tipc_bclink_stats(buf
, buf_size
);
2642 node
= tipc_link_find_owner(name
, &bearer_id
);
2646 tipc_node_lock(node
);
2648 l
= node
->links
[bearer_id
];
2650 tipc_node_unlock(node
);
2656 if (tipc_link_is_active(l
))
2658 else if (tipc_link_is_up(l
))
2663 ret
= tipc_snprintf(buf
, buf_size
, "Link <%s>\n"
2664 " %s MTU:%u Priority:%u Tolerance:%u ms"
2665 " Window:%u packets\n",
2666 l
->name
, status
, l
->max_pkt
, l
->priority
,
2667 l
->tolerance
, l
->queue_limit
[0]);
2669 ret
+= tipc_snprintf(buf
+ ret
, buf_size
- ret
,
2670 " RX packets:%u fragments:%u/%u bundles:%u/%u\n",
2671 l
->next_in_no
- s
->recv_info
, s
->recv_fragments
,
2672 s
->recv_fragmented
, s
->recv_bundles
,
2675 ret
+= tipc_snprintf(buf
+ ret
, buf_size
- ret
,
2676 " TX packets:%u fragments:%u/%u bundles:%u/%u\n",
2677 l
->next_out_no
- s
->sent_info
, s
->sent_fragments
,
2678 s
->sent_fragmented
, s
->sent_bundles
,
2681 profile_total
= s
->msg_length_counts
;
2685 ret
+= tipc_snprintf(buf
+ ret
, buf_size
- ret
,
2686 " TX profile sample:%u packets average:%u octets\n"
2687 " 0-64:%u%% -256:%u%% -1024:%u%% -4096:%u%% "
2688 "-16384:%u%% -32768:%u%% -66000:%u%%\n",
2689 s
->msg_length_counts
,
2690 s
->msg_lengths_total
/ profile_total
,
2691 percent(s
->msg_length_profile
[0], profile_total
),
2692 percent(s
->msg_length_profile
[1], profile_total
),
2693 percent(s
->msg_length_profile
[2], profile_total
),
2694 percent(s
->msg_length_profile
[3], profile_total
),
2695 percent(s
->msg_length_profile
[4], profile_total
),
2696 percent(s
->msg_length_profile
[5], profile_total
),
2697 percent(s
->msg_length_profile
[6], profile_total
));
2699 ret
+= tipc_snprintf(buf
+ ret
, buf_size
- ret
,
2700 " RX states:%u probes:%u naks:%u defs:%u"
2701 " dups:%u\n", s
->recv_states
, s
->recv_probes
,
2702 s
->recv_nacks
, s
->deferred_recv
, s
->duplicates
);
2704 ret
+= tipc_snprintf(buf
+ ret
, buf_size
- ret
,
2705 " TX states:%u probes:%u naks:%u acks:%u"
2706 " dups:%u\n", s
->sent_states
, s
->sent_probes
,
2707 s
->sent_nacks
, s
->sent_acks
, s
->retransmitted
);
2709 ret
+= tipc_snprintf(buf
+ ret
, buf_size
- ret
,
2710 " Congestion link:%u Send queue"
2711 " max:%u avg:%u\n", s
->link_congs
,
2712 s
->max_queue_sz
, s
->queue_sz_counts
?
2713 (s
->accu_queue_sz
/ s
->queue_sz_counts
) : 0);
2715 tipc_node_unlock(node
);
2719 struct sk_buff
*tipc_link_cmd_show_stats(const void *req_tlv_area
, int req_tlv_space
)
2721 struct sk_buff
*buf
;
2722 struct tlv_desc
*rep_tlv
;
2727 if (!TLV_CHECK(req_tlv_area
, req_tlv_space
, TIPC_TLV_LINK_NAME
))
2728 return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR
);
2730 buf
= tipc_cfg_reply_alloc(TLV_SPACE(ULTRA_STRING_MAX_LEN
));
2734 rep_tlv
= (struct tlv_desc
*)buf
->data
;
2735 pb
= TLV_DATA(rep_tlv
);
2736 pb_len
= ULTRA_STRING_MAX_LEN
;
2737 str_len
= tipc_link_stats((char *)TLV_DATA(req_tlv_area
),
2741 return tipc_cfg_reply_error_string("link not found");
2743 str_len
+= 1; /* for "\0" */
2744 skb_put(buf
, TLV_SPACE(str_len
));
2745 TLV_SET(rep_tlv
, TIPC_TLV_ULTRA_STRING
, NULL
, str_len
);
2751 * tipc_link_get_max_pkt - get maximum packet size to use when sending to destination
2752 * @dest: network address of destination node
2753 * @selector: used to select from set of active links
2755 * If no active link can be found, uses default maximum packet size.
2757 u32
tipc_link_get_max_pkt(u32 dest
, u32 selector
)
2759 struct tipc_node
*n_ptr
;
2760 struct tipc_link
*l_ptr
;
2761 u32 res
= MAX_PKT_DEFAULT
;
2763 if (dest
== tipc_own_addr
)
2764 return MAX_MSG_SIZE
;
2766 n_ptr
= tipc_node_find(dest
);
2768 tipc_node_lock(n_ptr
);
2769 l_ptr
= n_ptr
->active_links
[selector
& 1];
2771 res
= l_ptr
->max_pkt
;
2772 tipc_node_unlock(n_ptr
);
2777 static void link_print(struct tipc_link
*l_ptr
, const char *str
)
2779 struct tipc_bearer
*b_ptr
;
2782 b_ptr
= rcu_dereference_rtnl(bearer_list
[l_ptr
->bearer_id
]);
2784 pr_info("%s Link %x<%s>:", str
, l_ptr
->addr
, b_ptr
->name
);
2787 if (link_working_unknown(l_ptr
))
2789 else if (link_reset_reset(l_ptr
))
2791 else if (link_reset_unknown(l_ptr
))
2793 else if (link_working_working(l_ptr
))
This page took 0.086525 seconds and 5 git commands to generate.