2 * net/tipc/bearer.c: TIPC bearer code
4 * Copyright (c) 1996-2006, Ericsson AB
5 * Copyright (c) 2004-2006, 2010-2011, 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.
42 #define MAX_ADDR_STR 32
44 static struct tipc_media
*media_list
[MAX_MEDIA
];
45 static u32 media_count
;
47 struct tipc_bearer tipc_bearers
[MAX_BEARERS
];
49 static void bearer_disable(struct tipc_bearer
*b_ptr
);
52 * tipc_media_find - locates specified media object by name
54 struct tipc_media
*tipc_media_find(const char *name
)
58 for (i
= 0; i
< media_count
; i
++) {
59 if (!strcmp(media_list
[i
]->name
, name
))
66 * media_find_id - locates specified media object by type identifier
68 static struct tipc_media
*media_find_id(u8 type
)
72 for (i
= 0; i
< media_count
; i
++) {
73 if (media_list
[i
]->type_id
== type
)
80 * tipc_register_media - register a media type
82 * Bearers for this media type must be activated separately at a later stage.
84 int tipc_register_media(struct tipc_media
*m_ptr
)
88 write_lock_bh(&tipc_net_lock
);
90 if ((strlen(m_ptr
->name
) + 1) > TIPC_MAX_MEDIA_NAME
)
92 if ((m_ptr
->bcast_addr
.media_id
!= m_ptr
->type_id
) ||
93 !m_ptr
->bcast_addr
.broadcast
)
95 if (m_ptr
->priority
> TIPC_MAX_LINK_PRI
)
97 if ((m_ptr
->tolerance
< TIPC_MIN_LINK_TOL
) ||
98 (m_ptr
->tolerance
> TIPC_MAX_LINK_TOL
))
100 if (media_count
>= MAX_MEDIA
)
102 if (tipc_media_find(m_ptr
->name
) || media_find_id(m_ptr
->type_id
))
105 media_list
[media_count
] = m_ptr
;
109 write_unlock_bh(&tipc_net_lock
);
111 pr_warn("Media <%s> registration error\n", m_ptr
->name
);
116 * tipc_media_addr_printf - record media address in print buffer
118 void tipc_media_addr_printf(char *buf
, int len
, struct tipc_media_addr
*a
)
120 char addr_str
[MAX_ADDR_STR
];
121 struct tipc_media
*m_ptr
;
124 m_ptr
= media_find_id(a
->media_id
);
126 if (m_ptr
&& !m_ptr
->addr2str(a
, addr_str
, sizeof(addr_str
)))
127 ret
= tipc_snprintf(buf
, len
, "%s(%s)", m_ptr
->name
, addr_str
);
131 ret
= tipc_snprintf(buf
, len
, "UNKNOWN(%u)", a
->media_id
);
132 for (i
= 0; i
< sizeof(a
->value
); i
++)
133 ret
+= tipc_snprintf(buf
- ret
, len
+ ret
,
134 "-%02x", a
->value
[i
]);
139 * tipc_media_get_names - record names of registered media in buffer
141 struct sk_buff
*tipc_media_get_names(void)
146 buf
= tipc_cfg_reply_alloc(MAX_MEDIA
* TLV_SPACE(TIPC_MAX_MEDIA_NAME
));
150 read_lock_bh(&tipc_net_lock
);
151 for (i
= 0; i
< media_count
; i
++) {
152 tipc_cfg_append_tlv(buf
, TIPC_TLV_MEDIA_NAME
,
154 strlen(media_list
[i
]->name
) + 1);
156 read_unlock_bh(&tipc_net_lock
);
161 * bearer_name_validate - validate & (optionally) deconstruct bearer name
162 * @name: ptr to bearer name string
163 * @name_parts: ptr to area for bearer name components (or NULL if not needed)
165 * Returns 1 if bearer name is valid, otherwise 0.
167 static int bearer_name_validate(const char *name
,
168 struct tipc_bearer_names
*name_parts
)
170 char name_copy
[TIPC_MAX_BEARER_NAME
];
176 /* copy bearer name & ensure length is OK */
177 name_copy
[TIPC_MAX_BEARER_NAME
- 1] = 0;
178 /* need above in case non-Posix strncpy() doesn't pad with nulls */
179 strncpy(name_copy
, name
, TIPC_MAX_BEARER_NAME
);
180 if (name_copy
[TIPC_MAX_BEARER_NAME
- 1] != 0)
183 /* ensure all component parts of bearer name are present */
184 media_name
= name_copy
;
185 if_name
= strchr(media_name
, ':');
189 media_len
= if_name
- media_name
;
190 if_len
= strlen(if_name
) + 1;
192 /* validate component parts of bearer name */
193 if ((media_len
<= 1) || (media_len
> TIPC_MAX_MEDIA_NAME
) ||
194 (if_len
<= 1) || (if_len
> TIPC_MAX_IF_NAME
))
197 /* return bearer name components, if necessary */
199 strcpy(name_parts
->media_name
, media_name
);
200 strcpy(name_parts
->if_name
, if_name
);
206 * tipc_bearer_find - locates bearer object with matching bearer name
208 struct tipc_bearer
*tipc_bearer_find(const char *name
)
210 struct tipc_bearer
*b_ptr
;
213 for (i
= 0, b_ptr
= tipc_bearers
; i
< MAX_BEARERS
; i
++, b_ptr
++) {
214 if (b_ptr
->active
&& (!strcmp(b_ptr
->name
, name
)))
221 * tipc_bearer_find_interface - locates bearer object with matching interface name
223 struct tipc_bearer
*tipc_bearer_find_interface(const char *if_name
)
225 struct tipc_bearer
*b_ptr
;
229 for (i
= 0, b_ptr
= tipc_bearers
; i
< MAX_BEARERS
; i
++, b_ptr
++) {
232 b_if_name
= strchr(b_ptr
->name
, ':') + 1;
233 if (!strcmp(b_if_name
, if_name
))
240 * tipc_bearer_get_names - record names of bearers in buffer
242 struct sk_buff
*tipc_bearer_get_names(void)
245 struct tipc_bearer
*b_ptr
;
248 buf
= tipc_cfg_reply_alloc(MAX_BEARERS
* TLV_SPACE(TIPC_MAX_BEARER_NAME
));
252 read_lock_bh(&tipc_net_lock
);
253 for (i
= 0; i
< media_count
; i
++) {
254 for (j
= 0; j
< MAX_BEARERS
; j
++) {
255 b_ptr
= &tipc_bearers
[j
];
256 if (b_ptr
->active
&& (b_ptr
->media
== media_list
[i
])) {
257 tipc_cfg_append_tlv(buf
, TIPC_TLV_BEARER_NAME
,
259 strlen(b_ptr
->name
) + 1);
263 read_unlock_bh(&tipc_net_lock
);
267 void tipc_bearer_add_dest(struct tipc_bearer
*b_ptr
, u32 dest
)
269 tipc_nmap_add(&b_ptr
->nodes
, dest
);
270 tipc_bcbearer_sort();
271 tipc_disc_add_dest(b_ptr
->link_req
);
274 void tipc_bearer_remove_dest(struct tipc_bearer
*b_ptr
, u32 dest
)
276 tipc_nmap_remove(&b_ptr
->nodes
, dest
);
277 tipc_bcbearer_sort();
278 tipc_disc_remove_dest(b_ptr
->link_req
);
282 * Interrupt enabling new requests after bearer blocking:
285 void tipc_continue(struct tipc_bearer
*b
)
287 spin_lock_bh(&b
->lock
);
289 spin_unlock_bh(&b
->lock
);
293 * tipc_bearer_blocked - determines if bearer is currently blocked
295 int tipc_bearer_blocked(struct tipc_bearer
*b
)
299 spin_lock_bh(&b
->lock
);
301 spin_unlock_bh(&b
->lock
);
307 * tipc_enable_bearer - enable bearer with the given name
309 int tipc_enable_bearer(const char *name
, u32 disc_domain
, u32 priority
)
311 struct tipc_bearer
*b_ptr
;
312 struct tipc_media
*m_ptr
;
313 struct tipc_bearer_names b_names
;
314 char addr_string
[16];
320 if (!tipc_own_addr
) {
321 pr_warn("Bearer <%s> rejected, not supported in standalone mode\n",
325 if (!bearer_name_validate(name
, &b_names
)) {
326 pr_warn("Bearer <%s> rejected, illegal name\n", name
);
329 if (tipc_addr_domain_valid(disc_domain
) &&
330 (disc_domain
!= tipc_own_addr
)) {
331 if (tipc_in_scope(disc_domain
, tipc_own_addr
)) {
332 disc_domain
= tipc_own_addr
& TIPC_CLUSTER_MASK
;
333 res
= 0; /* accept any node in own cluster */
334 } else if (in_own_cluster_exact(disc_domain
))
335 res
= 0; /* accept specified node in own cluster */
338 pr_warn("Bearer <%s> rejected, illegal discovery domain\n",
342 if ((priority
> TIPC_MAX_LINK_PRI
) &&
343 (priority
!= TIPC_MEDIA_LINK_PRI
)) {
344 pr_warn("Bearer <%s> rejected, illegal priority\n", name
);
348 write_lock_bh(&tipc_net_lock
);
350 m_ptr
= tipc_media_find(b_names
.media_name
);
352 pr_warn("Bearer <%s> rejected, media <%s> not registered\n",
353 name
, b_names
.media_name
);
357 if (priority
== TIPC_MEDIA_LINK_PRI
)
358 priority
= m_ptr
->priority
;
361 bearer_id
= MAX_BEARERS
;
363 for (i
= MAX_BEARERS
; i
-- != 0; ) {
364 if (!tipc_bearers
[i
].active
) {
368 if (!strcmp(name
, tipc_bearers
[i
].name
)) {
369 pr_warn("Bearer <%s> rejected, already enabled\n",
373 if ((tipc_bearers
[i
].priority
== priority
) &&
374 (++with_this_prio
> 2)) {
375 if (priority
-- == 0) {
376 pr_warn("Bearer <%s> rejected, duplicate priority\n",
380 pr_warn("Bearer <%s> priority adjustment required %u->%u\n",
381 name
, priority
+ 1, priority
);
385 if (bearer_id
>= MAX_BEARERS
) {
386 pr_warn("Bearer <%s> rejected, bearer limit reached (%u)\n",
391 b_ptr
= &tipc_bearers
[bearer_id
];
392 strcpy(b_ptr
->name
, name
);
393 res
= m_ptr
->enable_bearer(b_ptr
);
395 pr_warn("Bearer <%s> rejected, enable failure (%d)\n",
400 b_ptr
->identity
= bearer_id
;
401 b_ptr
->media
= m_ptr
;
402 b_ptr
->tolerance
= m_ptr
->tolerance
;
403 b_ptr
->window
= m_ptr
->window
;
404 b_ptr
->net_plane
= bearer_id
+ 'A';
406 b_ptr
->priority
= priority
;
407 INIT_LIST_HEAD(&b_ptr
->links
);
408 spin_lock_init(&b_ptr
->lock
);
410 res
= tipc_disc_create(b_ptr
, &m_ptr
->bcast_addr
, disc_domain
);
412 bearer_disable(b_ptr
);
413 pr_warn("Bearer <%s> rejected, discovery object creation failed\n",
417 pr_info("Enabled bearer <%s>, discovery domain %s, priority %u\n",
419 tipc_addr_string_fill(addr_string
, disc_domain
), priority
);
421 write_unlock_bh(&tipc_net_lock
);
426 * tipc_block_bearer - Block the bearer with the given name, and reset all its links
428 int tipc_block_bearer(const char *name
)
430 struct tipc_bearer
*b_ptr
= NULL
;
431 struct tipc_link
*l_ptr
;
432 struct tipc_link
*temp_l_ptr
;
434 read_lock_bh(&tipc_net_lock
);
435 b_ptr
= tipc_bearer_find(name
);
437 pr_warn("Attempt to block unknown bearer <%s>\n", name
);
438 read_unlock_bh(&tipc_net_lock
);
442 pr_info("Blocking bearer <%s>\n", name
);
443 spin_lock_bh(&b_ptr
->lock
);
445 list_for_each_entry_safe(l_ptr
, temp_l_ptr
, &b_ptr
->links
, link_list
) {
446 struct tipc_node
*n_ptr
= l_ptr
->owner
;
448 spin_lock_bh(&n_ptr
->lock
);
449 tipc_link_reset(l_ptr
);
450 spin_unlock_bh(&n_ptr
->lock
);
452 spin_unlock_bh(&b_ptr
->lock
);
453 read_unlock_bh(&tipc_net_lock
);
460 * Note: This routine assumes caller holds tipc_net_lock.
462 static void bearer_disable(struct tipc_bearer
*b_ptr
)
464 struct tipc_link
*l_ptr
;
465 struct tipc_link
*temp_l_ptr
;
467 pr_info("Disabling bearer <%s>\n", b_ptr
->name
);
468 spin_lock_bh(&b_ptr
->lock
);
470 b_ptr
->media
->disable_bearer(b_ptr
);
471 list_for_each_entry_safe(l_ptr
, temp_l_ptr
, &b_ptr
->links
, link_list
) {
472 tipc_link_delete(l_ptr
);
475 tipc_disc_delete(b_ptr
->link_req
);
476 spin_unlock_bh(&b_ptr
->lock
);
477 memset(b_ptr
, 0, sizeof(struct tipc_bearer
));
480 int tipc_disable_bearer(const char *name
)
482 struct tipc_bearer
*b_ptr
;
485 write_lock_bh(&tipc_net_lock
);
486 b_ptr
= tipc_bearer_find(name
);
488 pr_warn("Attempt to disable unknown bearer <%s>\n", name
);
491 bearer_disable(b_ptr
);
494 write_unlock_bh(&tipc_net_lock
);
500 void tipc_bearer_stop(void)
504 for (i
= 0; i
< MAX_BEARERS
; i
++) {
505 if (tipc_bearers
[i
].active
)
506 bearer_disable(&tipc_bearers
[i
]);