xref: /linux/net/tipc/bearer.c (revision b889fcf63cb62e7fdb7816565e28f44dbe4a76a5)
1 /*
2  * net/tipc/bearer.c: TIPC bearer code
3  *
4  * Copyright (c) 1996-2006, Ericsson AB
5  * Copyright (c) 2004-2006, 2010-2011, Wind River Systems
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions are met:
10  *
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.
19  *
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.
23  *
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.
35  */
36 
37 #include "core.h"
38 #include "config.h"
39 #include "bearer.h"
40 #include "discover.h"
41 
42 #define MAX_ADDR_STR 32
43 
44 static struct tipc_media *media_list[MAX_MEDIA];
45 static u32 media_count;
46 
47 struct tipc_bearer tipc_bearers[MAX_BEARERS];
48 
49 static void bearer_disable(struct tipc_bearer *b_ptr);
50 
51 /**
52  * tipc_media_find - locates specified media object by name
53  */
54 struct tipc_media *tipc_media_find(const char *name)
55 {
56 	u32 i;
57 
58 	for (i = 0; i < media_count; i++) {
59 		if (!strcmp(media_list[i]->name, name))
60 			return media_list[i];
61 	}
62 	return NULL;
63 }
64 
65 /**
66  * media_find_id - locates specified media object by type identifier
67  */
68 static struct tipc_media *media_find_id(u8 type)
69 {
70 	u32 i;
71 
72 	for (i = 0; i < media_count; i++) {
73 		if (media_list[i]->type_id == type)
74 			return media_list[i];
75 	}
76 	return NULL;
77 }
78 
79 /**
80  * tipc_register_media - register a media type
81  *
82  * Bearers for this media type must be activated separately at a later stage.
83  */
84 int tipc_register_media(struct tipc_media *m_ptr)
85 {
86 	int res = -EINVAL;
87 
88 	write_lock_bh(&tipc_net_lock);
89 
90 	if ((strlen(m_ptr->name) + 1) > TIPC_MAX_MEDIA_NAME)
91 		goto exit;
92 	if ((m_ptr->bcast_addr.media_id != m_ptr->type_id) ||
93 	    !m_ptr->bcast_addr.broadcast)
94 		goto exit;
95 	if (m_ptr->priority > TIPC_MAX_LINK_PRI)
96 		goto exit;
97 	if ((m_ptr->tolerance < TIPC_MIN_LINK_TOL) ||
98 	    (m_ptr->tolerance > TIPC_MAX_LINK_TOL))
99 		goto exit;
100 	if (media_count >= MAX_MEDIA)
101 		goto exit;
102 	if (tipc_media_find(m_ptr->name) || media_find_id(m_ptr->type_id))
103 		goto exit;
104 
105 	media_list[media_count] = m_ptr;
106 	media_count++;
107 	res = 0;
108 exit:
109 	write_unlock_bh(&tipc_net_lock);
110 	if (res)
111 		pr_warn("Media <%s> registration error\n", m_ptr->name);
112 	return res;
113 }
114 
115 /**
116  * tipc_media_addr_printf - record media address in print buffer
117  */
118 void tipc_media_addr_printf(char *buf, int len, struct tipc_media_addr *a)
119 {
120 	char addr_str[MAX_ADDR_STR];
121 	struct tipc_media *m_ptr;
122 	int ret;
123 
124 	m_ptr = media_find_id(a->media_id);
125 
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);
128 	else {
129 		u32 i;
130 
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]);
135 	}
136 }
137 
138 /**
139  * tipc_media_get_names - record names of registered media in buffer
140  */
141 struct sk_buff *tipc_media_get_names(void)
142 {
143 	struct sk_buff *buf;
144 	int i;
145 
146 	buf = tipc_cfg_reply_alloc(MAX_MEDIA * TLV_SPACE(TIPC_MAX_MEDIA_NAME));
147 	if (!buf)
148 		return NULL;
149 
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,
153 				    media_list[i]->name,
154 				    strlen(media_list[i]->name) + 1);
155 	}
156 	read_unlock_bh(&tipc_net_lock);
157 	return buf;
158 }
159 
160 /**
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)
164  *
165  * Returns 1 if bearer name is valid, otherwise 0.
166  */
167 static int bearer_name_validate(const char *name,
168 				struct tipc_bearer_names *name_parts)
169 {
170 	char name_copy[TIPC_MAX_BEARER_NAME];
171 	char *media_name;
172 	char *if_name;
173 	u32 media_len;
174 	u32 if_len;
175 
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)
181 		return 0;
182 
183 	/* ensure all component parts of bearer name are present */
184 	media_name = name_copy;
185 	if_name = strchr(media_name, ':');
186 	if (if_name == NULL)
187 		return 0;
188 	*(if_name++) = 0;
189 	media_len = if_name - media_name;
190 	if_len = strlen(if_name) + 1;
191 
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))
195 		return 0;
196 
197 	/* return bearer name components, if necessary */
198 	if (name_parts) {
199 		strcpy(name_parts->media_name, media_name);
200 		strcpy(name_parts->if_name, if_name);
201 	}
202 	return 1;
203 }
204 
205 /**
206  * tipc_bearer_find - locates bearer object with matching bearer name
207  */
208 struct tipc_bearer *tipc_bearer_find(const char *name)
209 {
210 	struct tipc_bearer *b_ptr;
211 	u32 i;
212 
213 	for (i = 0, b_ptr = tipc_bearers; i < MAX_BEARERS; i++, b_ptr++) {
214 		if (b_ptr->active && (!strcmp(b_ptr->name, name)))
215 			return b_ptr;
216 	}
217 	return NULL;
218 }
219 
220 /**
221  * tipc_bearer_find_interface - locates bearer object with matching interface name
222  */
223 struct tipc_bearer *tipc_bearer_find_interface(const char *if_name)
224 {
225 	struct tipc_bearer *b_ptr;
226 	char *b_if_name;
227 	u32 i;
228 
229 	for (i = 0, b_ptr = tipc_bearers; i < MAX_BEARERS; i++, b_ptr++) {
230 		if (!b_ptr->active)
231 			continue;
232 		b_if_name = strchr(b_ptr->name, ':') + 1;
233 		if (!strcmp(b_if_name, if_name))
234 			return b_ptr;
235 	}
236 	return NULL;
237 }
238 
239 /**
240  * tipc_bearer_get_names - record names of bearers in buffer
241  */
242 struct sk_buff *tipc_bearer_get_names(void)
243 {
244 	struct sk_buff *buf;
245 	struct tipc_bearer *b_ptr;
246 	int i, j;
247 
248 	buf = tipc_cfg_reply_alloc(MAX_BEARERS * TLV_SPACE(TIPC_MAX_BEARER_NAME));
249 	if (!buf)
250 		return NULL;
251 
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,
258 						    b_ptr->name,
259 						    strlen(b_ptr->name) + 1);
260 			}
261 		}
262 	}
263 	read_unlock_bh(&tipc_net_lock);
264 	return buf;
265 }
266 
267 void tipc_bearer_add_dest(struct tipc_bearer *b_ptr, u32 dest)
268 {
269 	tipc_nmap_add(&b_ptr->nodes, dest);
270 	tipc_bcbearer_sort();
271 	tipc_disc_add_dest(b_ptr->link_req);
272 }
273 
274 void tipc_bearer_remove_dest(struct tipc_bearer *b_ptr, u32 dest)
275 {
276 	tipc_nmap_remove(&b_ptr->nodes, dest);
277 	tipc_bcbearer_sort();
278 	tipc_disc_remove_dest(b_ptr->link_req);
279 }
280 
281 /*
282  * Interrupt enabling new requests after bearer blocking:
283  * See bearer_send().
284  */
285 void tipc_continue(struct tipc_bearer *b)
286 {
287 	spin_lock_bh(&b->lock);
288 	b->blocked = 0;
289 	spin_unlock_bh(&b->lock);
290 }
291 
292 /*
293  * tipc_bearer_blocked - determines if bearer is currently blocked
294  */
295 int tipc_bearer_blocked(struct tipc_bearer *b)
296 {
297 	int res;
298 
299 	spin_lock_bh(&b->lock);
300 	res = b->blocked;
301 	spin_unlock_bh(&b->lock);
302 
303 	return res;
304 }
305 
306 /**
307  * tipc_enable_bearer - enable bearer with the given name
308  */
309 int tipc_enable_bearer(const char *name, u32 disc_domain, u32 priority)
310 {
311 	struct tipc_bearer *b_ptr;
312 	struct tipc_media *m_ptr;
313 	struct tipc_bearer_names b_names;
314 	char addr_string[16];
315 	u32 bearer_id;
316 	u32 with_this_prio;
317 	u32 i;
318 	int res = -EINVAL;
319 
320 	if (!tipc_own_addr) {
321 		pr_warn("Bearer <%s> rejected, not supported in standalone mode\n",
322 			name);
323 		return -ENOPROTOOPT;
324 	}
325 	if (!bearer_name_validate(name, &b_names)) {
326 		pr_warn("Bearer <%s> rejected, illegal name\n", name);
327 		return -EINVAL;
328 	}
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 */
336 	}
337 	if (res) {
338 		pr_warn("Bearer <%s> rejected, illegal discovery domain\n",
339 			name);
340 		return -EINVAL;
341 	}
342 	if ((priority > TIPC_MAX_LINK_PRI) &&
343 	    (priority != TIPC_MEDIA_LINK_PRI)) {
344 		pr_warn("Bearer <%s> rejected, illegal priority\n", name);
345 		return -EINVAL;
346 	}
347 
348 	write_lock_bh(&tipc_net_lock);
349 
350 	m_ptr = tipc_media_find(b_names.media_name);
351 	if (!m_ptr) {
352 		pr_warn("Bearer <%s> rejected, media <%s> not registered\n",
353 			name, b_names.media_name);
354 		goto exit;
355 	}
356 
357 	if (priority == TIPC_MEDIA_LINK_PRI)
358 		priority = m_ptr->priority;
359 
360 restart:
361 	bearer_id = MAX_BEARERS;
362 	with_this_prio = 1;
363 	for (i = MAX_BEARERS; i-- != 0; ) {
364 		if (!tipc_bearers[i].active) {
365 			bearer_id = i;
366 			continue;
367 		}
368 		if (!strcmp(name, tipc_bearers[i].name)) {
369 			pr_warn("Bearer <%s> rejected, already enabled\n",
370 				name);
371 			goto exit;
372 		}
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",
377 					name);
378 				goto exit;
379 			}
380 			pr_warn("Bearer <%s> priority adjustment required %u->%u\n",
381 				name, priority + 1, priority);
382 			goto restart;
383 		}
384 	}
385 	if (bearer_id >= MAX_BEARERS) {
386 		pr_warn("Bearer <%s> rejected, bearer limit reached (%u)\n",
387 			name, MAX_BEARERS);
388 		goto exit;
389 	}
390 
391 	b_ptr = &tipc_bearers[bearer_id];
392 	strcpy(b_ptr->name, name);
393 	res = m_ptr->enable_bearer(b_ptr);
394 	if (res) {
395 		pr_warn("Bearer <%s> rejected, enable failure (%d)\n",
396 			name, -res);
397 		goto exit;
398 	}
399 
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';
405 	b_ptr->active = 1;
406 	b_ptr->priority = priority;
407 	INIT_LIST_HEAD(&b_ptr->links);
408 	spin_lock_init(&b_ptr->lock);
409 
410 	res = tipc_disc_create(b_ptr, &m_ptr->bcast_addr, disc_domain);
411 	if (res) {
412 		bearer_disable(b_ptr);
413 		pr_warn("Bearer <%s> rejected, discovery object creation failed\n",
414 			name);
415 		goto exit;
416 	}
417 	pr_info("Enabled bearer <%s>, discovery domain %s, priority %u\n",
418 		name,
419 		tipc_addr_string_fill(addr_string, disc_domain), priority);
420 exit:
421 	write_unlock_bh(&tipc_net_lock);
422 	return res;
423 }
424 
425 /**
426  * tipc_block_bearer - Block the bearer with the given name, and reset all its links
427  */
428 int tipc_block_bearer(const char *name)
429 {
430 	struct tipc_bearer *b_ptr = NULL;
431 	struct tipc_link *l_ptr;
432 	struct tipc_link *temp_l_ptr;
433 
434 	read_lock_bh(&tipc_net_lock);
435 	b_ptr = tipc_bearer_find(name);
436 	if (!b_ptr) {
437 		pr_warn("Attempt to block unknown bearer <%s>\n", name);
438 		read_unlock_bh(&tipc_net_lock);
439 		return -EINVAL;
440 	}
441 
442 	pr_info("Blocking bearer <%s>\n", name);
443 	spin_lock_bh(&b_ptr->lock);
444 	b_ptr->blocked = 1;
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;
447 
448 		spin_lock_bh(&n_ptr->lock);
449 		tipc_link_reset(l_ptr);
450 		spin_unlock_bh(&n_ptr->lock);
451 	}
452 	spin_unlock_bh(&b_ptr->lock);
453 	read_unlock_bh(&tipc_net_lock);
454 	return 0;
455 }
456 
457 /**
458  * bearer_disable
459  *
460  * Note: This routine assumes caller holds tipc_net_lock.
461  */
462 static void bearer_disable(struct tipc_bearer *b_ptr)
463 {
464 	struct tipc_link *l_ptr;
465 	struct tipc_link *temp_l_ptr;
466 
467 	pr_info("Disabling bearer <%s>\n", b_ptr->name);
468 	spin_lock_bh(&b_ptr->lock);
469 	b_ptr->blocked = 1;
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);
473 	}
474 	if (b_ptr->link_req)
475 		tipc_disc_delete(b_ptr->link_req);
476 	spin_unlock_bh(&b_ptr->lock);
477 	memset(b_ptr, 0, sizeof(struct tipc_bearer));
478 }
479 
480 int tipc_disable_bearer(const char *name)
481 {
482 	struct tipc_bearer *b_ptr;
483 	int res;
484 
485 	write_lock_bh(&tipc_net_lock);
486 	b_ptr = tipc_bearer_find(name);
487 	if (b_ptr == NULL) {
488 		pr_warn("Attempt to disable unknown bearer <%s>\n", name);
489 		res = -EINVAL;
490 	} else {
491 		bearer_disable(b_ptr);
492 		res = 0;
493 	}
494 	write_unlock_bh(&tipc_net_lock);
495 	return res;
496 }
497 
498 
499 
500 void tipc_bearer_stop(void)
501 {
502 	u32 i;
503 
504 	for (i = 0; i < MAX_BEARERS; i++) {
505 		if (tipc_bearers[i].active)
506 			bearer_disable(&tipc_bearers[i]);
507 	}
508 	media_count = 0;
509 }
510