2 * net/tipc/bearer.c: TIPC bearer code
4 * Copyright (c) 1996-2006, Ericsson AB
5 * Copyright (c) 2004-2006, 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.
43 #define MAX_ADDR_STR 32
45 static struct media media_list
[MAX_MEDIA
];
46 static u32 media_count
= 0;
48 struct bearer tipc_bearers
[MAX_BEARERS
];
51 * media_name_valid - validate media name
53 * Returns 1 if media name is valid, otherwise 0.
56 static int media_name_valid(const char *name
)
61 if ((len
+ 1) > TIPC_MAX_MEDIA_NAME
)
63 return strspn(name
, tipc_alphabet
) == len
;
67 * media_find - locates specified media object by name
70 static struct media
*media_find(const char *name
)
75 for (i
= 0, m_ptr
= media_list
; i
< media_count
; i
++, m_ptr
++) {
76 if (!strcmp(m_ptr
->name
, name
))
83 * tipc_register_media - register a media type
85 * Bearers for this media type must be activated separately at a later stage.
88 int tipc_register_media(u32 media_type
,
90 int (*enable
)(struct tipc_bearer
*),
91 void (*disable
)(struct tipc_bearer
*),
92 int (*send_msg
)(struct sk_buff
*,
94 struct tipc_media_addr
*),
95 char *(*addr2str
)(struct tipc_media_addr
*a
,
96 char *str_buf
, int str_size
),
97 struct tipc_media_addr
*bcast_addr
,
98 const u32 bearer_priority
,
99 const u32 link_tolerance
, /* [ms] */
100 const u32 send_window_limit
)
107 write_lock_bh(&tipc_net_lock
);
109 if (tipc_mode
!= TIPC_NET_MODE
) {
110 warn("Media <%s> rejected, not in networked mode yet\n", name
);
113 if (!media_name_valid(name
)) {
114 warn("Media <%s> rejected, illegal name\n", name
);
118 warn("Media <%s> rejected, no broadcast address\n", name
);
121 if ((bearer_priority
< TIPC_MIN_LINK_PRI
) ||
122 (bearer_priority
> TIPC_MAX_LINK_PRI
)) {
123 warn("Media <%s> rejected, illegal priority (%u)\n", name
,
127 if ((link_tolerance
< TIPC_MIN_LINK_TOL
) ||
128 (link_tolerance
> TIPC_MAX_LINK_TOL
)) {
129 warn("Media <%s> rejected, illegal tolerance (%u)\n", name
,
134 media_id
= media_count
++;
135 if (media_id
>= MAX_MEDIA
) {
136 warn("Media <%s> rejected, media limit reached (%u)\n", name
,
141 for (i
= 0; i
< media_id
; i
++) {
142 if (media_list
[i
].type_id
== media_type
) {
143 warn("Media <%s> rejected, duplicate type (%u)\n", name
,
148 if (!strcmp(name
, media_list
[i
].name
)) {
149 warn("Media <%s> rejected, duplicate name\n", name
);
155 m_ptr
= &media_list
[media_id
];
156 m_ptr
->type_id
= media_type
;
157 m_ptr
->send_msg
= send_msg
;
158 m_ptr
->enable_bearer
= enable
;
159 m_ptr
->disable_bearer
= disable
;
160 m_ptr
->addr2str
= addr2str
;
161 memcpy(&m_ptr
->bcast_addr
, bcast_addr
, sizeof(*bcast_addr
));
163 strcpy(m_ptr
->name
, name
);
164 m_ptr
->priority
= bearer_priority
;
165 m_ptr
->tolerance
= link_tolerance
;
166 m_ptr
->window
= send_window_limit
;
167 dbg("Media <%s> registered\n", name
);
170 write_unlock_bh(&tipc_net_lock
);
175 * tipc_media_addr_printf - record media address in print buffer
178 void tipc_media_addr_printf(struct print_buf
*pb
, struct tipc_media_addr
*a
)
184 media_type
= ntohl(a
->type
);
185 for (i
= 0, m_ptr
= media_list
; i
< media_count
; i
++, m_ptr
++) {
186 if (m_ptr
->type_id
== media_type
)
190 if ((i
< media_count
) && (m_ptr
->addr2str
!= NULL
)) {
191 char addr_str
[MAX_ADDR_STR
];
193 tipc_printf(pb
, "%s(%s)", m_ptr
->name
,
194 m_ptr
->addr2str(a
, addr_str
, sizeof(addr_str
)));
196 unchar
*addr
= (unchar
*)&a
->dev_addr
;
198 tipc_printf(pb
, "UNKNOWN(%u)", media_type
);
199 for (i
= 0; i
< (sizeof(*a
) - sizeof(a
->type
)); i
++) {
200 tipc_printf(pb
, "-%02x", addr
[i
]);
206 * tipc_media_get_names - record names of registered media in buffer
209 struct sk_buff
*tipc_media_get_names(void)
215 buf
= tipc_cfg_reply_alloc(MAX_MEDIA
* TLV_SPACE(TIPC_MAX_MEDIA_NAME
));
219 read_lock_bh(&tipc_net_lock
);
220 for (i
= 0, m_ptr
= media_list
; i
< media_count
; i
++, m_ptr
++) {
221 tipc_cfg_append_tlv(buf
, TIPC_TLV_MEDIA_NAME
, m_ptr
->name
,
222 strlen(m_ptr
->name
) + 1);
224 read_unlock_bh(&tipc_net_lock
);
229 * bearer_name_validate - validate & (optionally) deconstruct bearer name
230 * @name - ptr to bearer name string
231 * @name_parts - ptr to area for bearer name components (or NULL if not needed)
233 * Returns 1 if bearer name is valid, otherwise 0.
236 static int bearer_name_validate(const char *name
,
237 struct bearer_name
*name_parts
)
239 char name_copy
[TIPC_MAX_BEARER_NAME
];
245 /* copy bearer name & ensure length is OK */
247 name_copy
[TIPC_MAX_BEARER_NAME
- 1] = 0;
248 /* need above in case non-Posix strncpy() doesn't pad with nulls */
249 strncpy(name_copy
, name
, TIPC_MAX_BEARER_NAME
);
250 if (name_copy
[TIPC_MAX_BEARER_NAME
- 1] != 0)
253 /* ensure all component parts of bearer name are present */
255 media_name
= name_copy
;
256 if ((if_name
= strchr(media_name
, ':')) == NULL
)
259 media_len
= if_name
- media_name
;
260 if_len
= strlen(if_name
) + 1;
262 /* validate component parts of bearer name */
264 if ((media_len
<= 1) || (media_len
> TIPC_MAX_MEDIA_NAME
) ||
265 (if_len
<= 1) || (if_len
> TIPC_MAX_IF_NAME
) ||
266 (strspn(media_name
, tipc_alphabet
) != (media_len
- 1)) ||
267 (strspn(if_name
, tipc_alphabet
) != (if_len
- 1)))
270 /* return bearer name components, if necessary */
273 strcpy(name_parts
->media_name
, media_name
);
274 strcpy(name_parts
->if_name
, if_name
);
280 * bearer_find - locates bearer object with matching bearer name
283 static struct bearer
*bearer_find(const char *name
)
285 struct bearer
*b_ptr
;
288 for (i
= 0, b_ptr
= tipc_bearers
; i
< MAX_BEARERS
; i
++, b_ptr
++) {
289 if (b_ptr
->active
&& (!strcmp(b_ptr
->publ
.name
, name
)))
296 * tipc_bearer_find_interface - locates bearer object with matching interface name
299 struct bearer
*tipc_bearer_find_interface(const char *if_name
)
301 struct bearer
*b_ptr
;
305 for (i
= 0, b_ptr
= tipc_bearers
; i
< MAX_BEARERS
; i
++, b_ptr
++) {
308 b_if_name
= strchr(b_ptr
->publ
.name
, ':') + 1;
309 if (!strcmp(b_if_name
, if_name
))
316 * tipc_bearer_get_names - record names of bearers in buffer
319 struct sk_buff
*tipc_bearer_get_names(void)
323 struct bearer
*b_ptr
;
326 buf
= tipc_cfg_reply_alloc(MAX_BEARERS
* TLV_SPACE(TIPC_MAX_BEARER_NAME
));
330 read_lock_bh(&tipc_net_lock
);
331 for (i
= 0, m_ptr
= media_list
; i
< media_count
; i
++, m_ptr
++) {
332 for (j
= 0; j
< MAX_BEARERS
; j
++) {
333 b_ptr
= &tipc_bearers
[j
];
334 if (b_ptr
->active
&& (b_ptr
->media
== m_ptr
)) {
335 tipc_cfg_append_tlv(buf
, TIPC_TLV_BEARER_NAME
,
337 strlen(b_ptr
->publ
.name
) + 1);
341 read_unlock_bh(&tipc_net_lock
);
345 void tipc_bearer_add_dest(struct bearer
*b_ptr
, u32 dest
)
347 tipc_nmap_add(&b_ptr
->nodes
, dest
);
348 tipc_disc_update_link_req(b_ptr
->link_req
);
349 tipc_bcbearer_sort();
352 void tipc_bearer_remove_dest(struct bearer
*b_ptr
, u32 dest
)
354 tipc_nmap_remove(&b_ptr
->nodes
, dest
);
355 tipc_disc_update_link_req(b_ptr
->link_req
);
356 tipc_bcbearer_sort();
360 * bearer_push(): Resolve bearer congestion. Force the waiting
361 * links to push out their unsent packets, one packet per link
362 * per iteration, until all packets are gone or congestion reoccurs.
363 * 'tipc_net_lock' is read_locked when this function is called
364 * bearer.lock must be taken before calling
365 * Returns binary true(1) ore false(0)
367 static int bearer_push(struct bearer
*b_ptr
)
370 struct link
*ln
, *tln
;
372 if (b_ptr
->publ
.blocked
)
375 while (!list_empty(&b_ptr
->cong_links
) && (res
!= PUSH_FAILED
)) {
376 list_for_each_entry_safe(ln
, tln
, &b_ptr
->cong_links
, link_list
) {
377 res
= tipc_link_push_packet(ln
);
378 if (res
== PUSH_FAILED
)
380 if (res
== PUSH_FINISHED
)
381 list_move_tail(&ln
->link_list
, &b_ptr
->links
);
384 return list_empty(&b_ptr
->cong_links
);
387 void tipc_bearer_lock_push(struct bearer
*b_ptr
)
391 spin_lock_bh(&b_ptr
->publ
.lock
);
392 res
= bearer_push(b_ptr
);
393 spin_unlock_bh(&b_ptr
->publ
.lock
);
395 tipc_bcbearer_push();
400 * Interrupt enabling new requests after bearer congestion or blocking:
403 void tipc_continue(struct tipc_bearer
*tb_ptr
)
405 struct bearer
*b_ptr
= (struct bearer
*)tb_ptr
;
407 spin_lock_bh(&b_ptr
->publ
.lock
);
408 b_ptr
->continue_count
++;
409 if (!list_empty(&b_ptr
->cong_links
))
410 tipc_k_signal((Handler
)tipc_bearer_lock_push
, (unsigned long)b_ptr
);
411 b_ptr
->publ
.blocked
= 0;
412 spin_unlock_bh(&b_ptr
->publ
.lock
);
416 * Schedule link for sending of messages after the bearer
417 * has been deblocked by 'continue()'. This method is called
418 * when somebody tries to send a message via this link while
419 * the bearer is congested. 'tipc_net_lock' is in read_lock here
420 * bearer.lock is busy
423 static void tipc_bearer_schedule_unlocked(struct bearer
*b_ptr
, struct link
*l_ptr
)
425 list_move_tail(&l_ptr
->link_list
, &b_ptr
->cong_links
);
429 * Schedule link for sending of messages after the bearer
430 * has been deblocked by 'continue()'. This method is called
431 * when somebody tries to send a message via this link while
432 * the bearer is congested. 'tipc_net_lock' is in read_lock here,
433 * bearer.lock is free
436 void tipc_bearer_schedule(struct bearer
*b_ptr
, struct link
*l_ptr
)
438 spin_lock_bh(&b_ptr
->publ
.lock
);
439 tipc_bearer_schedule_unlocked(b_ptr
, l_ptr
);
440 spin_unlock_bh(&b_ptr
->publ
.lock
);
445 * tipc_bearer_resolve_congestion(): Check if there is bearer congestion,
446 * and if there is, try to resolve it before returning.
447 * 'tipc_net_lock' is read_locked when this function is called
449 int tipc_bearer_resolve_congestion(struct bearer
*b_ptr
, struct link
*l_ptr
)
453 if (list_empty(&b_ptr
->cong_links
))
455 spin_lock_bh(&b_ptr
->publ
.lock
);
456 if (!bearer_push(b_ptr
)) {
457 tipc_bearer_schedule_unlocked(b_ptr
, l_ptr
);
460 spin_unlock_bh(&b_ptr
->publ
.lock
);
465 * tipc_bearer_congested - determines if bearer is currently congested
468 int tipc_bearer_congested(struct bearer
*b_ptr
, struct link
*l_ptr
)
470 if (unlikely(b_ptr
->publ
.blocked
))
472 if (likely(list_empty(&b_ptr
->cong_links
)))
474 return !tipc_bearer_resolve_congestion(b_ptr
, l_ptr
);
478 * tipc_enable_bearer - enable bearer with the given name
481 int tipc_enable_bearer(const char *name
, u32 bcast_scope
, u32 priority
)
483 struct bearer
*b_ptr
;
485 struct bearer_name b_name
;
486 char addr_string
[16];
492 if (tipc_mode
!= TIPC_NET_MODE
) {
493 warn("Bearer <%s> rejected, not supported in standalone mode\n",
497 if (!bearer_name_validate(name
, &b_name
)) {
498 warn("Bearer <%s> rejected, illegal name\n", name
);
501 if (!tipc_addr_domain_valid(bcast_scope
) ||
502 !tipc_in_scope(bcast_scope
, tipc_own_addr
)) {
503 warn("Bearer <%s> rejected, illegal broadcast scope\n", name
);
506 if ((priority
< TIPC_MIN_LINK_PRI
||
507 priority
> TIPC_MAX_LINK_PRI
) &&
508 (priority
!= TIPC_MEDIA_LINK_PRI
)) {
509 warn("Bearer <%s> rejected, illegal priority\n", name
);
513 write_lock_bh(&tipc_net_lock
);
515 m_ptr
= media_find(b_name
.media_name
);
517 warn("Bearer <%s> rejected, media <%s> not registered\n", name
,
522 if (priority
== TIPC_MEDIA_LINK_PRI
)
523 priority
= m_ptr
->priority
;
526 bearer_id
= MAX_BEARERS
;
528 for (i
= MAX_BEARERS
; i
-- != 0; ) {
529 if (!tipc_bearers
[i
].active
) {
533 if (!strcmp(name
, tipc_bearers
[i
].publ
.name
)) {
534 warn("Bearer <%s> rejected, already enabled\n", name
);
537 if ((tipc_bearers
[i
].priority
== priority
) &&
538 (++with_this_prio
> 2)) {
539 if (priority
-- == 0) {
540 warn("Bearer <%s> rejected, duplicate priority\n",
544 warn("Bearer <%s> priority adjustment required %u->%u\n",
545 name
, priority
+ 1, priority
);
549 if (bearer_id
>= MAX_BEARERS
) {
550 warn("Bearer <%s> rejected, bearer limit reached (%u)\n",
555 b_ptr
= &tipc_bearers
[bearer_id
];
556 strcpy(b_ptr
->publ
.name
, name
);
557 res
= m_ptr
->enable_bearer(&b_ptr
->publ
);
559 warn("Bearer <%s> rejected, enable failure (%d)\n", name
, -res
);
563 b_ptr
->identity
= bearer_id
;
564 b_ptr
->media
= m_ptr
;
565 b_ptr
->net_plane
= bearer_id
+ 'A';
567 b_ptr
->detect_scope
= bcast_scope
;
568 b_ptr
->priority
= priority
;
569 INIT_LIST_HEAD(&b_ptr
->cong_links
);
570 INIT_LIST_HEAD(&b_ptr
->links
);
572 b_ptr
->link_req
= tipc_disc_init_link_req(b_ptr
, &m_ptr
->bcast_addr
,
575 spin_lock_init(&b_ptr
->publ
.lock
);
576 write_unlock_bh(&tipc_net_lock
);
577 info("Enabled bearer <%s>, discovery domain %s, priority %u\n",
578 name
, tipc_addr_string_fill(addr_string
, bcast_scope
), priority
);
581 write_unlock_bh(&tipc_net_lock
);
586 * tipc_block_bearer(): Block the bearer with the given name,
587 * and reset all its links
590 int tipc_block_bearer(const char *name
)
592 struct bearer
*b_ptr
= NULL
;
594 struct link
*temp_l_ptr
;
596 read_lock_bh(&tipc_net_lock
);
597 b_ptr
= bearer_find(name
);
599 warn("Attempt to block unknown bearer <%s>\n", name
);
600 read_unlock_bh(&tipc_net_lock
);
604 info("Blocking bearer <%s>\n", name
);
605 spin_lock_bh(&b_ptr
->publ
.lock
);
606 b_ptr
->publ
.blocked
= 1;
607 list_for_each_entry_safe(l_ptr
, temp_l_ptr
, &b_ptr
->links
, link_list
) {
608 struct tipc_node
*n_ptr
= l_ptr
->owner
;
610 spin_lock_bh(&n_ptr
->lock
);
611 tipc_link_reset(l_ptr
);
612 spin_unlock_bh(&n_ptr
->lock
);
614 spin_unlock_bh(&b_ptr
->publ
.lock
);
615 read_unlock_bh(&tipc_net_lock
);
622 * Note: This routine assumes caller holds tipc_net_lock.
625 static int bearer_disable(struct bearer
*b_ptr
)
628 struct link
*temp_l_ptr
;
630 info("Disabling bearer <%s>\n", b_ptr
->publ
.name
);
631 tipc_disc_stop_link_req(b_ptr
->link_req
);
632 spin_lock_bh(&b_ptr
->publ
.lock
);
633 b_ptr
->link_req
= NULL
;
634 b_ptr
->publ
.blocked
= 1;
635 b_ptr
->media
->disable_bearer(&b_ptr
->publ
);
636 list_for_each_entry_safe(l_ptr
, temp_l_ptr
, &b_ptr
->links
, link_list
) {
637 tipc_link_delete(l_ptr
);
639 spin_unlock_bh(&b_ptr
->publ
.lock
);
640 memset(b_ptr
, 0, sizeof(struct bearer
));
644 int tipc_disable_bearer(const char *name
)
646 struct bearer
*b_ptr
;
649 write_lock_bh(&tipc_net_lock
);
650 b_ptr
= bearer_find(name
);
652 warn("Attempt to disable unknown bearer <%s>\n", name
);
655 res
= bearer_disable(b_ptr
);
656 write_unlock_bh(&tipc_net_lock
);
662 void tipc_bearer_stop(void)
666 for (i
= 0; i
< MAX_BEARERS
; i
++) {
667 if (tipc_bearers
[i
].active
)
668 bearer_disable(&tipc_bearers
[i
]);