2 * net/tipc/bearer.c: TIPC bearer code
4 * Copyright (c) 2003-2006, Ericsson AB
5 * Copyright (c) 2004-2005, 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.
46 #define MAX_ADDR_STR 32
48 static struct media
*media_list
= 0;
49 static u32 media_count
= 0;
51 struct bearer
*bearers
= 0;
54 * media_name_valid - validate media name
56 * Returns 1 if media name is valid, otherwise 0.
59 static int media_name_valid(const char *name
)
64 if ((len
+ 1) > TIPC_MAX_MEDIA_NAME
)
66 return (strspn(name
, tipc_alphabet
) == len
);
70 * media_find - locates specified media object by name
73 static struct media
*media_find(const char *name
)
78 for (i
= 0, m_ptr
= media_list
; i
< media_count
; i
++, m_ptr
++) {
79 if (!strcmp(m_ptr
->name
, name
))
86 * tipc_register_media - register a media type
88 * Bearers for this media type must be activated separately at a later stage.
91 int tipc_register_media(u32 media_type
,
93 int (*enable
)(struct tipc_bearer
*),
94 void (*disable
)(struct tipc_bearer
*),
95 int (*send_msg
)(struct sk_buff
*,
97 struct tipc_media_addr
*),
98 char *(*addr2str
)(struct tipc_media_addr
*a
,
99 char *str_buf
, int str_size
),
100 struct tipc_media_addr
*bcast_addr
,
101 const u32 bearer_priority
,
102 const u32 link_tolerance
, /* [ms] */
103 const u32 send_window_limit
)
110 write_lock_bh(&net_lock
);
114 if (!media_name_valid(name
)) {
115 warn("Media registration error: illegal name <%s>\n", name
);
119 warn("Media registration error: no broadcast address supplied\n");
122 if (bearer_priority
>= TIPC_NUM_LINK_PRI
) {
123 warn("Media registration error: priority %u\n", bearer_priority
);
126 if ((link_tolerance
< TIPC_MIN_LINK_TOL
) ||
127 (link_tolerance
> TIPC_MAX_LINK_TOL
)) {
128 warn("Media registration error: tolerance %u\n", link_tolerance
);
132 media_id
= media_count
++;
133 if (media_id
>= MAX_MEDIA
) {
134 warn("Attempt to register more than %u media\n", MAX_MEDIA
);
138 for (i
= 0; i
< media_id
; i
++) {
139 if (media_list
[i
].type_id
== media_type
) {
140 warn("Attempt to register second media with type %u\n",
145 if (!strcmp(name
, media_list
[i
].name
)) {
146 warn("Attempt to re-register media name <%s>\n", name
);
152 m_ptr
= &media_list
[media_id
];
153 m_ptr
->type_id
= media_type
;
154 m_ptr
->send_msg
= send_msg
;
155 m_ptr
->enable_bearer
= enable
;
156 m_ptr
->disable_bearer
= disable
;
157 m_ptr
->addr2str
= addr2str
;
158 memcpy(&m_ptr
->bcast_addr
, bcast_addr
, sizeof(*bcast_addr
));
160 strcpy(m_ptr
->name
, name
);
161 m_ptr
->priority
= bearer_priority
;
162 m_ptr
->tolerance
= link_tolerance
;
163 m_ptr
->window
= send_window_limit
;
164 dbg("Media <%s> registered\n", name
);
167 write_unlock_bh(&net_lock
);
172 * media_addr_printf - record media address in print buffer
175 void media_addr_printf(struct print_buf
*pb
, struct tipc_media_addr
*a
)
181 media_type
= ntohl(a
->type
);
182 for (i
= 0, m_ptr
= media_list
; i
< media_count
; i
++, m_ptr
++) {
183 if (m_ptr
->type_id
== media_type
)
187 if ((i
< media_count
) && (m_ptr
->addr2str
!= NULL
)) {
188 char addr_str
[MAX_ADDR_STR
];
190 tipc_printf(pb
, "%s(%s) ", m_ptr
->name
,
191 m_ptr
->addr2str(a
, addr_str
, sizeof(addr_str
)));
193 unchar
*addr
= (unchar
*)&a
->dev_addr
;
195 tipc_printf(pb
, "UNKNOWN(%u):", media_type
);
196 for (i
= 0; i
< (sizeof(*a
) - sizeof(a
->type
)); i
++) {
197 tipc_printf(pb
, "%02x ", addr
[i
]);
203 * media_get_names - record names of registered media in buffer
206 struct sk_buff
*media_get_names(void)
212 buf
= cfg_reply_alloc(MAX_MEDIA
* TLV_SPACE(TIPC_MAX_MEDIA_NAME
));
216 read_lock_bh(&net_lock
);
217 for (i
= 0, m_ptr
= media_list
; i
< media_count
; i
++, m_ptr
++) {
218 cfg_append_tlv(buf
, TIPC_TLV_MEDIA_NAME
, m_ptr
->name
,
219 strlen(m_ptr
->name
) + 1);
221 read_unlock_bh(&net_lock
);
226 * bearer_name_validate - validate & (optionally) deconstruct bearer name
227 * @name - ptr to bearer name string
228 * @name_parts - ptr to area for bearer name components (or NULL if not needed)
230 * Returns 1 if bearer name is valid, otherwise 0.
233 static int bearer_name_validate(const char *name
,
234 struct bearer_name
*name_parts
)
236 char name_copy
[TIPC_MAX_BEARER_NAME
];
242 /* copy bearer name & ensure length is OK */
244 name_copy
[TIPC_MAX_BEARER_NAME
- 1] = 0;
245 /* need above in case non-Posix strncpy() doesn't pad with nulls */
246 strncpy(name_copy
, name
, TIPC_MAX_BEARER_NAME
);
247 if (name_copy
[TIPC_MAX_BEARER_NAME
- 1] != 0)
250 /* ensure all component parts of bearer name are present */
252 media_name
= name_copy
;
253 if ((if_name
= strchr(media_name
, ':')) == NULL
)
256 media_len
= if_name
- media_name
;
257 if_len
= strlen(if_name
) + 1;
259 /* validate component parts of bearer name */
261 if ((media_len
<= 1) || (media_len
> TIPC_MAX_MEDIA_NAME
) ||
262 (if_len
<= 1) || (if_len
> TIPC_MAX_IF_NAME
) ||
263 (strspn(media_name
, tipc_alphabet
) != (media_len
- 1)) ||
264 (strspn(if_name
, tipc_alphabet
) != (if_len
- 1)))
267 /* return bearer name components, if necessary */
270 strcpy(name_parts
->media_name
, media_name
);
271 strcpy(name_parts
->if_name
, if_name
);
277 * bearer_find - locates bearer object with matching bearer name
280 static struct bearer
*bearer_find(const char *name
)
282 struct bearer
*b_ptr
;
285 for (i
= 0, b_ptr
= bearers
; i
< MAX_BEARERS
; i
++, b_ptr
++) {
286 if (b_ptr
->active
&& (!strcmp(b_ptr
->publ
.name
, name
)))
293 * bearer_find - locates bearer object with matching interface name
296 struct bearer
*bearer_find_interface(const char *if_name
)
298 struct bearer
*b_ptr
;
302 for (i
= 0, b_ptr
= bearers
; i
< MAX_BEARERS
; i
++, b_ptr
++) {
305 b_if_name
= strchr(b_ptr
->publ
.name
, ':') + 1;
306 if (!strcmp(b_if_name
, if_name
))
313 * bearer_get_names - record names of bearers in buffer
316 struct sk_buff
*bearer_get_names(void)
320 struct bearer
*b_ptr
;
323 buf
= cfg_reply_alloc(MAX_BEARERS
* TLV_SPACE(TIPC_MAX_BEARER_NAME
));
327 read_lock_bh(&net_lock
);
328 for (i
= 0, m_ptr
= media_list
; i
< media_count
; i
++, m_ptr
++) {
329 for (j
= 0; j
< MAX_BEARERS
; j
++) {
331 if (b_ptr
->active
&& (b_ptr
->media
== m_ptr
)) {
332 cfg_append_tlv(buf
, TIPC_TLV_BEARER_NAME
,
334 strlen(b_ptr
->publ
.name
) + 1);
338 read_unlock_bh(&net_lock
);
342 void bearer_add_dest(struct bearer
*b_ptr
, u32 dest
)
344 nmap_add(&b_ptr
->nodes
, dest
);
345 disc_update_link_req(b_ptr
->link_req
);
349 void bearer_remove_dest(struct bearer
*b_ptr
, u32 dest
)
351 nmap_remove(&b_ptr
->nodes
, dest
);
352 disc_update_link_req(b_ptr
->link_req
);
357 * bearer_push(): Resolve bearer congestion. Force the waiting
358 * links to push out their unsent packets, one packet per link
359 * per iteration, until all packets are gone or congestion reoccurs.
360 * 'net_lock' is read_locked when this function is called
361 * bearer.lock must be taken before calling
362 * Returns binary true(1) ore false(0)
364 static int bearer_push(struct bearer
*b_ptr
)
367 struct link
*ln
, *tln
;
369 if (b_ptr
->publ
.blocked
)
372 while (!list_empty(&b_ptr
->cong_links
) && (res
!= PUSH_FAILED
)) {
373 list_for_each_entry_safe(ln
, tln
, &b_ptr
->cong_links
, link_list
) {
374 res
= link_push_packet(ln
);
375 if (res
== PUSH_FAILED
)
377 if (res
== PUSH_FINISHED
)
378 list_move_tail(&ln
->link_list
, &b_ptr
->links
);
381 return list_empty(&b_ptr
->cong_links
);
384 void bearer_lock_push(struct bearer
*b_ptr
)
388 spin_lock_bh(&b_ptr
->publ
.lock
);
389 res
= bearer_push(b_ptr
);
390 spin_unlock_bh(&b_ptr
->publ
.lock
);
397 * Interrupt enabling new requests after bearer congestion or blocking:
400 void tipc_continue(struct tipc_bearer
*tb_ptr
)
402 struct bearer
*b_ptr
= (struct bearer
*)tb_ptr
;
404 spin_lock_bh(&b_ptr
->publ
.lock
);
405 b_ptr
->continue_count
++;
406 if (!list_empty(&b_ptr
->cong_links
))
407 k_signal((Handler
)bearer_lock_push
, (unsigned long)b_ptr
);
408 b_ptr
->publ
.blocked
= 0;
409 spin_unlock_bh(&b_ptr
->publ
.lock
);
413 * Schedule link for sending of messages after the bearer
414 * has been deblocked by 'continue()'. This method is called
415 * when somebody tries to send a message via this link while
416 * the bearer is congested. 'net_lock' is in read_lock here
417 * bearer.lock is busy
420 static void bearer_schedule_unlocked(struct bearer
*b_ptr
, struct link
*l_ptr
)
422 list_move_tail(&l_ptr
->link_list
, &b_ptr
->cong_links
);
426 * Schedule link for sending of messages after the bearer
427 * has been deblocked by 'continue()'. This method is called
428 * when somebody tries to send a message via this link while
429 * the bearer is congested. 'net_lock' is in read_lock here,
430 * bearer.lock is free
433 void bearer_schedule(struct bearer
*b_ptr
, struct link
*l_ptr
)
435 spin_lock_bh(&b_ptr
->publ
.lock
);
436 bearer_schedule_unlocked(b_ptr
, l_ptr
);
437 spin_unlock_bh(&b_ptr
->publ
.lock
);
442 * bearer_resolve_congestion(): Check if there is bearer congestion,
443 * and if there is, try to resolve it before returning.
444 * 'net_lock' is read_locked when this function is called
446 int bearer_resolve_congestion(struct bearer
*b_ptr
, struct link
*l_ptr
)
450 if (list_empty(&b_ptr
->cong_links
))
452 spin_lock_bh(&b_ptr
->publ
.lock
);
453 if (!bearer_push(b_ptr
)) {
454 bearer_schedule_unlocked(b_ptr
, l_ptr
);
457 spin_unlock_bh(&b_ptr
->publ
.lock
);
463 * tipc_enable_bearer - enable bearer with the given name
466 int tipc_enable_bearer(const char *name
, u32 bcast_scope
, u32 priority
)
468 struct bearer
*b_ptr
;
470 struct bearer_name b_name
;
471 char addr_string
[16];
477 if (tipc_mode
!= TIPC_NET_MODE
)
479 if (!bearer_name_validate(name
, &b_name
) ||
480 !addr_domain_valid(bcast_scope
) ||
481 !in_scope(bcast_scope
, tipc_own_addr
) ||
482 (priority
> TIPC_NUM_LINK_PRI
))
485 write_lock_bh(&net_lock
);
489 m_ptr
= media_find(b_name
.media_name
);
491 warn("No media <%s>\n", b_name
.media_name
);
494 if (priority
== TIPC_NUM_LINK_PRI
)
495 priority
= m_ptr
->priority
;
498 bearer_id
= MAX_BEARERS
;
500 for (i
= MAX_BEARERS
; i
-- != 0; ) {
501 if (!bearers
[i
].active
) {
505 if (!strcmp(name
, bearers
[i
].publ
.name
)) {
506 warn("Bearer <%s> already enabled\n", name
);
509 if ((bearers
[i
].priority
== priority
) &&
510 (++with_this_prio
> 2)) {
511 if (priority
-- == 0) {
512 warn("Third bearer <%s> with priority %u, unable to lower to %u\n",
513 name
, priority
+ 1, priority
);
516 warn("Third bearer <%s> with priority %u, lowering to %u\n",
517 name
, priority
+ 1, priority
);
521 if (bearer_id
>= MAX_BEARERS
) {
522 warn("Attempt to enable more than %d bearers\n", MAX_BEARERS
);
526 b_ptr
= &bearers
[bearer_id
];
527 memset(b_ptr
, 0, sizeof(struct bearer
));
529 strcpy(b_ptr
->publ
.name
, name
);
530 res
= m_ptr
->enable_bearer(&b_ptr
->publ
);
532 warn("Failed to enable bearer <%s>\n", name
);
536 b_ptr
->identity
= bearer_id
;
537 b_ptr
->media
= m_ptr
;
538 b_ptr
->net_plane
= bearer_id
+ 'A';
540 b_ptr
->detect_scope
= bcast_scope
;
541 b_ptr
->priority
= priority
;
542 INIT_LIST_HEAD(&b_ptr
->cong_links
);
543 INIT_LIST_HEAD(&b_ptr
->links
);
545 b_ptr
->link_req
= disc_init_link_req(b_ptr
, &m_ptr
->bcast_addr
,
548 b_ptr
->publ
.lock
= SPIN_LOCK_UNLOCKED
;
549 write_unlock_bh(&net_lock
);
550 info("Enabled bearer <%s>, discovery domain %s\n",
551 name
, addr_string_fill(addr_string
, bcast_scope
));
554 write_unlock_bh(&net_lock
);
559 * tipc_block_bearer(): Block the bearer with the given name,
560 * and reset all its links
563 int tipc_block_bearer(const char *name
)
565 struct bearer
*b_ptr
= 0;
567 struct link
*temp_l_ptr
;
569 if (tipc_mode
!= TIPC_NET_MODE
)
572 read_lock_bh(&net_lock
);
573 b_ptr
= bearer_find(name
);
575 warn("Attempt to block unknown bearer <%s>\n", name
);
576 read_unlock_bh(&net_lock
);
580 spin_lock_bh(&b_ptr
->publ
.lock
);
581 b_ptr
->publ
.blocked
= 1;
582 list_for_each_entry_safe(l_ptr
, temp_l_ptr
, &b_ptr
->links
, link_list
) {
583 struct node
*n_ptr
= l_ptr
->owner
;
585 spin_lock_bh(&n_ptr
->lock
);
587 spin_unlock_bh(&n_ptr
->lock
);
589 spin_unlock_bh(&b_ptr
->publ
.lock
);
590 read_unlock_bh(&net_lock
);
591 info("Blocked bearer <%s>\n", name
);
598 * Note: This routine assumes caller holds net_lock.
601 static int bearer_disable(const char *name
)
603 struct bearer
*b_ptr
;
605 struct link
*temp_l_ptr
;
607 if (tipc_mode
!= TIPC_NET_MODE
)
610 b_ptr
= bearer_find(name
);
612 warn("Attempt to disable unknown bearer <%s>\n", name
);
616 disc_stop_link_req(b_ptr
->link_req
);
617 spin_lock_bh(&b_ptr
->publ
.lock
);
618 b_ptr
->link_req
= NULL
;
619 b_ptr
->publ
.blocked
= 1;
620 if (b_ptr
->media
->disable_bearer
) {
621 spin_unlock_bh(&b_ptr
->publ
.lock
);
622 write_unlock_bh(&net_lock
);
623 b_ptr
->media
->disable_bearer(&b_ptr
->publ
);
624 write_lock_bh(&net_lock
);
625 spin_lock_bh(&b_ptr
->publ
.lock
);
627 list_for_each_entry_safe(l_ptr
, temp_l_ptr
, &b_ptr
->links
, link_list
) {
630 spin_unlock_bh(&b_ptr
->publ
.lock
);
631 info("Disabled bearer <%s>\n", name
);
632 memset(b_ptr
, 0, sizeof(struct bearer
));
636 int tipc_disable_bearer(const char *name
)
640 write_lock_bh(&net_lock
);
641 res
= bearer_disable(name
);
642 write_unlock_bh(&net_lock
);
648 int bearer_init(void)
652 write_lock_bh(&net_lock
);
653 bearers
= kmalloc(MAX_BEARERS
* sizeof(struct bearer
), GFP_ATOMIC
);
654 media_list
= kmalloc(MAX_MEDIA
* sizeof(struct media
), GFP_ATOMIC
);
655 if (bearers
&& media_list
) {
656 memset(bearers
, 0, MAX_BEARERS
* sizeof(struct bearer
));
657 memset(media_list
, 0, MAX_MEDIA
* sizeof(struct media
));
666 write_unlock_bh(&net_lock
);
670 void bearer_stop(void)
677 for (i
= 0; i
< MAX_BEARERS
; i
++) {
678 if (bearers
[i
].active
)
679 bearers
[i
].publ
.blocked
= 1;
681 for (i
= 0; i
< MAX_BEARERS
; i
++) {
682 if (bearers
[i
].active
)
683 bearer_disable(bearers
[i
].publ
.name
);
This page took 0.045651 seconds and 6 git commands to generate.