Loading...
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
44static struct media media_list[MAX_MEDIA];
45static u32 media_count;
46
47struct tipc_bearer tipc_bearers[MAX_BEARERS];
48
49static void bearer_disable(struct tipc_bearer *b_ptr);
50
51/**
52 * media_name_valid - validate media name
53 *
54 * Returns 1 if media name is valid, otherwise 0.
55 */
56
57static int media_name_valid(const char *name)
58{
59 u32 len;
60
61 len = strlen(name);
62 if ((len + 1) > TIPC_MAX_MEDIA_NAME)
63 return 0;
64 return strspn(name, tipc_alphabet) == len;
65}
66
67/**
68 * media_find - locates specified media object by name
69 */
70
71static struct media *media_find(const char *name)
72{
73 struct media *m_ptr;
74 u32 i;
75
76 for (i = 0, m_ptr = media_list; i < media_count; i++, m_ptr++) {
77 if (!strcmp(m_ptr->name, name))
78 return m_ptr;
79 }
80 return NULL;
81}
82
83/**
84 * tipc_register_media - register a media type
85 *
86 * Bearers for this media type must be activated separately at a later stage.
87 */
88
89int tipc_register_media(u32 media_type,
90 char *name,
91 int (*enable)(struct tipc_bearer *),
92 void (*disable)(struct tipc_bearer *),
93 int (*send_msg)(struct sk_buff *,
94 struct tipc_bearer *,
95 struct tipc_media_addr *),
96 char *(*addr2str)(struct tipc_media_addr *a,
97 char *str_buf, int str_size),
98 struct tipc_media_addr *bcast_addr,
99 const u32 bearer_priority,
100 const u32 link_tolerance, /* [ms] */
101 const u32 send_window_limit)
102{
103 struct media *m_ptr;
104 u32 media_id;
105 u32 i;
106 int res = -EINVAL;
107
108 write_lock_bh(&tipc_net_lock);
109
110 if (tipc_mode != TIPC_NET_MODE) {
111 warn("Media <%s> rejected, not in networked mode yet\n", name);
112 goto exit;
113 }
114 if (!media_name_valid(name)) {
115 warn("Media <%s> rejected, illegal name\n", name);
116 goto exit;
117 }
118 if (!bcast_addr) {
119 warn("Media <%s> rejected, no broadcast address\n", name);
120 goto exit;
121 }
122 if ((bearer_priority < TIPC_MIN_LINK_PRI) ||
123 (bearer_priority > TIPC_MAX_LINK_PRI)) {
124 warn("Media <%s> rejected, illegal priority (%u)\n", name,
125 bearer_priority);
126 goto exit;
127 }
128 if ((link_tolerance < TIPC_MIN_LINK_TOL) ||
129 (link_tolerance > TIPC_MAX_LINK_TOL)) {
130 warn("Media <%s> rejected, illegal tolerance (%u)\n", name,
131 link_tolerance);
132 goto exit;
133 }
134
135 media_id = media_count++;
136 if (media_id >= MAX_MEDIA) {
137 warn("Media <%s> rejected, media limit reached (%u)\n", name,
138 MAX_MEDIA);
139 media_count--;
140 goto exit;
141 }
142 for (i = 0; i < media_id; i++) {
143 if (media_list[i].type_id == media_type) {
144 warn("Media <%s> rejected, duplicate type (%u)\n", name,
145 media_type);
146 media_count--;
147 goto exit;
148 }
149 if (!strcmp(name, media_list[i].name)) {
150 warn("Media <%s> rejected, duplicate name\n", name);
151 media_count--;
152 goto exit;
153 }
154 }
155
156 m_ptr = &media_list[media_id];
157 m_ptr->type_id = media_type;
158 m_ptr->send_msg = send_msg;
159 m_ptr->enable_bearer = enable;
160 m_ptr->disable_bearer = disable;
161 m_ptr->addr2str = addr2str;
162 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 res = 0;
168exit:
169 write_unlock_bh(&tipc_net_lock);
170 return res;
171}
172
173/**
174 * tipc_media_addr_printf - record media address in print buffer
175 */
176
177void tipc_media_addr_printf(struct print_buf *pb, struct tipc_media_addr *a)
178{
179 struct media *m_ptr;
180 u32 media_type;
181 u32 i;
182
183 media_type = ntohl(a->type);
184 for (i = 0, m_ptr = media_list; i < media_count; i++, m_ptr++) {
185 if (m_ptr->type_id == media_type)
186 break;
187 }
188
189 if ((i < media_count) && (m_ptr->addr2str != NULL)) {
190 char addr_str[MAX_ADDR_STR];
191
192 tipc_printf(pb, "%s(%s)", m_ptr->name,
193 m_ptr->addr2str(a, addr_str, sizeof(addr_str)));
194 } else {
195 unchar *addr = (unchar *)&a->dev_addr;
196
197 tipc_printf(pb, "UNKNOWN(%u)", media_type);
198 for (i = 0; i < (sizeof(*a) - sizeof(a->type)); i++)
199 tipc_printf(pb, "-%02x", addr[i]);
200 }
201}
202
203/**
204 * tipc_media_get_names - record names of registered media in buffer
205 */
206
207struct sk_buff *tipc_media_get_names(void)
208{
209 struct sk_buff *buf;
210 struct media *m_ptr;
211 int i;
212
213 buf = tipc_cfg_reply_alloc(MAX_MEDIA * TLV_SPACE(TIPC_MAX_MEDIA_NAME));
214 if (!buf)
215 return NULL;
216
217 read_lock_bh(&tipc_net_lock);
218 for (i = 0, m_ptr = media_list; i < media_count; i++, m_ptr++) {
219 tipc_cfg_append_tlv(buf, TIPC_TLV_MEDIA_NAME, m_ptr->name,
220 strlen(m_ptr->name) + 1);
221 }
222 read_unlock_bh(&tipc_net_lock);
223 return buf;
224}
225
226/**
227 * bearer_name_validate - validate & (optionally) deconstruct bearer name
228 * @name - ptr to bearer name string
229 * @name_parts - ptr to area for bearer name components (or NULL if not needed)
230 *
231 * Returns 1 if bearer name is valid, otherwise 0.
232 */
233
234static int bearer_name_validate(const char *name,
235 struct bearer_name *name_parts)
236{
237 char name_copy[TIPC_MAX_BEARER_NAME];
238 char *media_name;
239 char *if_name;
240 u32 media_len;
241 u32 if_len;
242
243 /* copy bearer name & ensure length is OK */
244
245 name_copy[TIPC_MAX_BEARER_NAME - 1] = 0;
246 /* need above in case non-Posix strncpy() doesn't pad with nulls */
247 strncpy(name_copy, name, TIPC_MAX_BEARER_NAME);
248 if (name_copy[TIPC_MAX_BEARER_NAME - 1] != 0)
249 return 0;
250
251 /* ensure all component parts of bearer name are present */
252
253 media_name = name_copy;
254 if_name = strchr(media_name, ':');
255 if (if_name == NULL)
256 return 0;
257 *(if_name++) = 0;
258 media_len = if_name - media_name;
259 if_len = strlen(if_name) + 1;
260
261 /* validate component parts of bearer name */
262
263 if ((media_len <= 1) || (media_len > TIPC_MAX_MEDIA_NAME) ||
264 (if_len <= 1) || (if_len > TIPC_MAX_IF_NAME) ||
265 (strspn(media_name, tipc_alphabet) != (media_len - 1)) ||
266 (strspn(if_name, tipc_alphabet) != (if_len - 1)))
267 return 0;
268
269 /* return bearer name components, if necessary */
270
271 if (name_parts) {
272 strcpy(name_parts->media_name, media_name);
273 strcpy(name_parts->if_name, if_name);
274 }
275 return 1;
276}
277
278/**
279 * bearer_find - locates bearer object with matching bearer name
280 */
281
282static struct tipc_bearer *bearer_find(const char *name)
283{
284 struct tipc_bearer *b_ptr;
285 u32 i;
286
287 for (i = 0, b_ptr = tipc_bearers; i < MAX_BEARERS; i++, b_ptr++) {
288 if (b_ptr->active && (!strcmp(b_ptr->name, name)))
289 return b_ptr;
290 }
291 return NULL;
292}
293
294/**
295 * tipc_bearer_find_interface - locates bearer object with matching interface name
296 */
297
298struct tipc_bearer *tipc_bearer_find_interface(const char *if_name)
299{
300 struct tipc_bearer *b_ptr;
301 char *b_if_name;
302 u32 i;
303
304 for (i = 0, b_ptr = tipc_bearers; i < MAX_BEARERS; i++, b_ptr++) {
305 if (!b_ptr->active)
306 continue;
307 b_if_name = strchr(b_ptr->name, ':') + 1;
308 if (!strcmp(b_if_name, if_name))
309 return b_ptr;
310 }
311 return NULL;
312}
313
314/**
315 * tipc_bearer_get_names - record names of bearers in buffer
316 */
317
318struct sk_buff *tipc_bearer_get_names(void)
319{
320 struct sk_buff *buf;
321 struct media *m_ptr;
322 struct tipc_bearer *b_ptr;
323 int i, j;
324
325 buf = tipc_cfg_reply_alloc(MAX_BEARERS * TLV_SPACE(TIPC_MAX_BEARER_NAME));
326 if (!buf)
327 return NULL;
328
329 read_lock_bh(&tipc_net_lock);
330 for (i = 0, m_ptr = media_list; i < media_count; i++, m_ptr++) {
331 for (j = 0; j < MAX_BEARERS; j++) {
332 b_ptr = &tipc_bearers[j];
333 if (b_ptr->active && (b_ptr->media == m_ptr)) {
334 tipc_cfg_append_tlv(buf, TIPC_TLV_BEARER_NAME,
335 b_ptr->name,
336 strlen(b_ptr->name) + 1);
337 }
338 }
339 }
340 read_unlock_bh(&tipc_net_lock);
341 return buf;
342}
343
344void tipc_bearer_add_dest(struct tipc_bearer *b_ptr, u32 dest)
345{
346 tipc_nmap_add(&b_ptr->nodes, dest);
347 tipc_bcbearer_sort();
348 tipc_disc_add_dest(b_ptr->link_req);
349}
350
351void tipc_bearer_remove_dest(struct tipc_bearer *b_ptr, u32 dest)
352{
353 tipc_nmap_remove(&b_ptr->nodes, dest);
354 tipc_bcbearer_sort();
355 tipc_disc_remove_dest(b_ptr->link_req);
356}
357
358/*
359 * bearer_push(): Resolve bearer congestion. Force the waiting
360 * links to push out their unsent packets, one packet per link
361 * per iteration, until all packets are gone or congestion reoccurs.
362 * 'tipc_net_lock' is read_locked when this function is called
363 * bearer.lock must be taken before calling
364 * Returns binary true(1) ore false(0)
365 */
366static int bearer_push(struct tipc_bearer *b_ptr)
367{
368 u32 res = 0;
369 struct link *ln, *tln;
370
371 if (b_ptr->blocked)
372 return 0;
373
374 while (!list_empty(&b_ptr->cong_links) && (res != PUSH_FAILED)) {
375 list_for_each_entry_safe(ln, tln, &b_ptr->cong_links, link_list) {
376 res = tipc_link_push_packet(ln);
377 if (res == PUSH_FAILED)
378 break;
379 if (res == PUSH_FINISHED)
380 list_move_tail(&ln->link_list, &b_ptr->links);
381 }
382 }
383 return list_empty(&b_ptr->cong_links);
384}
385
386void tipc_bearer_lock_push(struct tipc_bearer *b_ptr)
387{
388 int res;
389
390 spin_lock_bh(&b_ptr->lock);
391 res = bearer_push(b_ptr);
392 spin_unlock_bh(&b_ptr->lock);
393 if (res)
394 tipc_bcbearer_push();
395}
396
397
398/*
399 * Interrupt enabling new requests after bearer congestion or blocking:
400 * See bearer_send().
401 */
402void tipc_continue(struct tipc_bearer *b_ptr)
403{
404 spin_lock_bh(&b_ptr->lock);
405 if (!list_empty(&b_ptr->cong_links))
406 tipc_k_signal((Handler)tipc_bearer_lock_push, (unsigned long)b_ptr);
407 b_ptr->blocked = 0;
408 spin_unlock_bh(&b_ptr->lock);
409}
410
411/*
412 * Schedule link for sending of messages after the bearer
413 * has been deblocked by 'continue()'. This method is called
414 * when somebody tries to send a message via this link while
415 * the bearer is congested. 'tipc_net_lock' is in read_lock here
416 * bearer.lock is busy
417 */
418
419static void tipc_bearer_schedule_unlocked(struct tipc_bearer *b_ptr, struct link *l_ptr)
420{
421 list_move_tail(&l_ptr->link_list, &b_ptr->cong_links);
422}
423
424/*
425 * Schedule link for sending of messages after the bearer
426 * has been deblocked by 'continue()'. This method is called
427 * when somebody tries to send a message via this link while
428 * the bearer is congested. 'tipc_net_lock' is in read_lock here,
429 * bearer.lock is free
430 */
431
432void tipc_bearer_schedule(struct tipc_bearer *b_ptr, struct link *l_ptr)
433{
434 spin_lock_bh(&b_ptr->lock);
435 tipc_bearer_schedule_unlocked(b_ptr, l_ptr);
436 spin_unlock_bh(&b_ptr->lock);
437}
438
439
440/*
441 * tipc_bearer_resolve_congestion(): Check if there is bearer congestion,
442 * and if there is, try to resolve it before returning.
443 * 'tipc_net_lock' is read_locked when this function is called
444 */
445int tipc_bearer_resolve_congestion(struct tipc_bearer *b_ptr, struct link *l_ptr)
446{
447 int res = 1;
448
449 if (list_empty(&b_ptr->cong_links))
450 return 1;
451 spin_lock_bh(&b_ptr->lock);
452 if (!bearer_push(b_ptr)) {
453 tipc_bearer_schedule_unlocked(b_ptr, l_ptr);
454 res = 0;
455 }
456 spin_unlock_bh(&b_ptr->lock);
457 return res;
458}
459
460/**
461 * tipc_bearer_congested - determines if bearer is currently congested
462 */
463
464int tipc_bearer_congested(struct tipc_bearer *b_ptr, struct link *l_ptr)
465{
466 if (unlikely(b_ptr->blocked))
467 return 1;
468 if (likely(list_empty(&b_ptr->cong_links)))
469 return 0;
470 return !tipc_bearer_resolve_congestion(b_ptr, l_ptr);
471}
472
473/**
474 * tipc_enable_bearer - enable bearer with the given name
475 */
476
477int tipc_enable_bearer(const char *name, u32 disc_domain, u32 priority)
478{
479 struct tipc_bearer *b_ptr;
480 struct media *m_ptr;
481 struct bearer_name b_name;
482 char addr_string[16];
483 u32 bearer_id;
484 u32 with_this_prio;
485 u32 i;
486 int res = -EINVAL;
487
488 if (tipc_mode != TIPC_NET_MODE) {
489 warn("Bearer <%s> rejected, not supported in standalone mode\n",
490 name);
491 return -ENOPROTOOPT;
492 }
493 if (!bearer_name_validate(name, &b_name)) {
494 warn("Bearer <%s> rejected, illegal name\n", name);
495 return -EINVAL;
496 }
497 if (tipc_addr_domain_valid(disc_domain) &&
498 (disc_domain != tipc_own_addr)) {
499 if (tipc_in_scope(disc_domain, tipc_own_addr)) {
500 disc_domain = tipc_own_addr & TIPC_CLUSTER_MASK;
501 res = 0; /* accept any node in own cluster */
502 } else if (in_own_cluster(disc_domain))
503 res = 0; /* accept specified node in own cluster */
504 }
505 if (res) {
506 warn("Bearer <%s> rejected, illegal discovery domain\n", name);
507 return -EINVAL;
508 }
509 if ((priority < TIPC_MIN_LINK_PRI ||
510 priority > TIPC_MAX_LINK_PRI) &&
511 (priority != TIPC_MEDIA_LINK_PRI)) {
512 warn("Bearer <%s> rejected, illegal priority\n", name);
513 return -EINVAL;
514 }
515
516 write_lock_bh(&tipc_net_lock);
517
518 m_ptr = media_find(b_name.media_name);
519 if (!m_ptr) {
520 warn("Bearer <%s> rejected, media <%s> not registered\n", name,
521 b_name.media_name);
522 goto exit;
523 }
524
525 if (priority == TIPC_MEDIA_LINK_PRI)
526 priority = m_ptr->priority;
527
528restart:
529 bearer_id = MAX_BEARERS;
530 with_this_prio = 1;
531 for (i = MAX_BEARERS; i-- != 0; ) {
532 if (!tipc_bearers[i].active) {
533 bearer_id = i;
534 continue;
535 }
536 if (!strcmp(name, tipc_bearers[i].name)) {
537 warn("Bearer <%s> rejected, already enabled\n", name);
538 goto exit;
539 }
540 if ((tipc_bearers[i].priority == priority) &&
541 (++with_this_prio > 2)) {
542 if (priority-- == 0) {
543 warn("Bearer <%s> rejected, duplicate priority\n",
544 name);
545 goto exit;
546 }
547 warn("Bearer <%s> priority adjustment required %u->%u\n",
548 name, priority + 1, priority);
549 goto restart;
550 }
551 }
552 if (bearer_id >= MAX_BEARERS) {
553 warn("Bearer <%s> rejected, bearer limit reached (%u)\n",
554 name, MAX_BEARERS);
555 goto exit;
556 }
557
558 b_ptr = &tipc_bearers[bearer_id];
559 strcpy(b_ptr->name, name);
560 res = m_ptr->enable_bearer(b_ptr);
561 if (res) {
562 warn("Bearer <%s> rejected, enable failure (%d)\n", name, -res);
563 goto exit;
564 }
565
566 b_ptr->identity = bearer_id;
567 b_ptr->media = m_ptr;
568 b_ptr->net_plane = bearer_id + 'A';
569 b_ptr->active = 1;
570 b_ptr->priority = priority;
571 INIT_LIST_HEAD(&b_ptr->cong_links);
572 INIT_LIST_HEAD(&b_ptr->links);
573 spin_lock_init(&b_ptr->lock);
574
575 res = tipc_disc_create(b_ptr, &m_ptr->bcast_addr, disc_domain);
576 if (res) {
577 bearer_disable(b_ptr);
578 warn("Bearer <%s> rejected, discovery object creation failed\n",
579 name);
580 goto exit;
581 }
582 info("Enabled bearer <%s>, discovery domain %s, priority %u\n",
583 name, tipc_addr_string_fill(addr_string, disc_domain), priority);
584exit:
585 write_unlock_bh(&tipc_net_lock);
586 return res;
587}
588
589/**
590 * tipc_block_bearer(): Block the bearer with the given name,
591 * and reset all its links
592 */
593
594int tipc_block_bearer(const char *name)
595{
596 struct tipc_bearer *b_ptr = NULL;
597 struct link *l_ptr;
598 struct link *temp_l_ptr;
599
600 read_lock_bh(&tipc_net_lock);
601 b_ptr = bearer_find(name);
602 if (!b_ptr) {
603 warn("Attempt to block unknown bearer <%s>\n", name);
604 read_unlock_bh(&tipc_net_lock);
605 return -EINVAL;
606 }
607
608 info("Blocking bearer <%s>\n", name);
609 spin_lock_bh(&b_ptr->lock);
610 b_ptr->blocked = 1;
611 list_for_each_entry_safe(l_ptr, temp_l_ptr, &b_ptr->links, link_list) {
612 struct tipc_node *n_ptr = l_ptr->owner;
613
614 spin_lock_bh(&n_ptr->lock);
615 tipc_link_reset(l_ptr);
616 spin_unlock_bh(&n_ptr->lock);
617 }
618 spin_unlock_bh(&b_ptr->lock);
619 read_unlock_bh(&tipc_net_lock);
620 return 0;
621}
622
623/**
624 * bearer_disable -
625 *
626 * Note: This routine assumes caller holds tipc_net_lock.
627 */
628
629static void bearer_disable(struct tipc_bearer *b_ptr)
630{
631 struct link *l_ptr;
632 struct link *temp_l_ptr;
633
634 info("Disabling bearer <%s>\n", b_ptr->name);
635 spin_lock_bh(&b_ptr->lock);
636 b_ptr->blocked = 1;
637 b_ptr->media->disable_bearer(b_ptr);
638 list_for_each_entry_safe(l_ptr, temp_l_ptr, &b_ptr->links, link_list) {
639 tipc_link_delete(l_ptr);
640 }
641 if (b_ptr->link_req)
642 tipc_disc_delete(b_ptr->link_req);
643 spin_unlock_bh(&b_ptr->lock);
644 memset(b_ptr, 0, sizeof(struct tipc_bearer));
645}
646
647int tipc_disable_bearer(const char *name)
648{
649 struct tipc_bearer *b_ptr;
650 int res;
651
652 write_lock_bh(&tipc_net_lock);
653 b_ptr = bearer_find(name);
654 if (b_ptr == NULL) {
655 warn("Attempt to disable unknown bearer <%s>\n", name);
656 res = -EINVAL;
657 } else {
658 bearer_disable(b_ptr);
659 res = 0;
660 }
661 write_unlock_bh(&tipc_net_lock);
662 return res;
663}
664
665
666
667void tipc_bearer_stop(void)
668{
669 u32 i;
670
671 for (i = 0; i < MAX_BEARERS; i++) {
672 if (tipc_bearers[i].active)
673 bearer_disable(&tipc_bearers[i]);
674 }
675 media_count = 0;
676}
1/*
2 * net/tipc/bearer.c: TIPC bearer code
3 *
4 * Copyright (c) 1996-2006, 2013, Ericsson AB
5 * Copyright (c) 2004-2006, 2010-2013, 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 60
43
44static struct tipc_media * const media_info_array[] = {
45 ð_media_info,
46#ifdef CONFIG_TIPC_MEDIA_IB
47 &ib_media_info,
48#endif
49 NULL
50};
51
52struct tipc_bearer *bearer_list[MAX_BEARERS + 1];
53
54static void bearer_disable(struct tipc_bearer *b_ptr, bool shutting_down);
55
56/**
57 * tipc_media_find - locates specified media object by name
58 */
59struct tipc_media *tipc_media_find(const char *name)
60{
61 u32 i;
62
63 for (i = 0; media_info_array[i] != NULL; i++) {
64 if (!strcmp(media_info_array[i]->name, name))
65 break;
66 }
67 return media_info_array[i];
68}
69
70/**
71 * media_find_id - locates specified media object by type identifier
72 */
73static struct tipc_media *media_find_id(u8 type)
74{
75 u32 i;
76
77 for (i = 0; media_info_array[i] != NULL; i++) {
78 if (media_info_array[i]->type_id == type)
79 break;
80 }
81 return media_info_array[i];
82}
83
84/**
85 * tipc_media_addr_printf - record media address in print buffer
86 */
87void tipc_media_addr_printf(char *buf, int len, struct tipc_media_addr *a)
88{
89 char addr_str[MAX_ADDR_STR];
90 struct tipc_media *m_ptr;
91 int ret;
92
93 m_ptr = media_find_id(a->media_id);
94
95 if (m_ptr && !m_ptr->addr2str(a, addr_str, sizeof(addr_str)))
96 ret = tipc_snprintf(buf, len, "%s(%s)", m_ptr->name, addr_str);
97 else {
98 u32 i;
99
100 ret = tipc_snprintf(buf, len, "UNKNOWN(%u)", a->media_id);
101 for (i = 0; i < sizeof(a->value); i++)
102 ret += tipc_snprintf(buf - ret, len + ret,
103 "-%02x", a->value[i]);
104 }
105}
106
107/**
108 * tipc_media_get_names - record names of registered media in buffer
109 */
110struct sk_buff *tipc_media_get_names(void)
111{
112 struct sk_buff *buf;
113 int i;
114
115 buf = tipc_cfg_reply_alloc(MAX_MEDIA * TLV_SPACE(TIPC_MAX_MEDIA_NAME));
116 if (!buf)
117 return NULL;
118
119 for (i = 0; media_info_array[i] != NULL; i++) {
120 tipc_cfg_append_tlv(buf, TIPC_TLV_MEDIA_NAME,
121 media_info_array[i]->name,
122 strlen(media_info_array[i]->name) + 1);
123 }
124 return buf;
125}
126
127/**
128 * bearer_name_validate - validate & (optionally) deconstruct bearer name
129 * @name: ptr to bearer name string
130 * @name_parts: ptr to area for bearer name components (or NULL if not needed)
131 *
132 * Returns 1 if bearer name is valid, otherwise 0.
133 */
134static int bearer_name_validate(const char *name,
135 struct tipc_bearer_names *name_parts)
136{
137 char name_copy[TIPC_MAX_BEARER_NAME];
138 char *media_name;
139 char *if_name;
140 u32 media_len;
141 u32 if_len;
142
143 /* copy bearer name & ensure length is OK */
144 name_copy[TIPC_MAX_BEARER_NAME - 1] = 0;
145 /* need above in case non-Posix strncpy() doesn't pad with nulls */
146 strncpy(name_copy, name, TIPC_MAX_BEARER_NAME);
147 if (name_copy[TIPC_MAX_BEARER_NAME - 1] != 0)
148 return 0;
149
150 /* ensure all component parts of bearer name are present */
151 media_name = name_copy;
152 if_name = strchr(media_name, ':');
153 if (if_name == NULL)
154 return 0;
155 *(if_name++) = 0;
156 media_len = if_name - media_name;
157 if_len = strlen(if_name) + 1;
158
159 /* validate component parts of bearer name */
160 if ((media_len <= 1) || (media_len > TIPC_MAX_MEDIA_NAME) ||
161 (if_len <= 1) || (if_len > TIPC_MAX_IF_NAME))
162 return 0;
163
164 /* return bearer name components, if necessary */
165 if (name_parts) {
166 strcpy(name_parts->media_name, media_name);
167 strcpy(name_parts->if_name, if_name);
168 }
169 return 1;
170}
171
172/**
173 * tipc_bearer_find - locates bearer object with matching bearer name
174 */
175struct tipc_bearer *tipc_bearer_find(const char *name)
176{
177 struct tipc_bearer *b_ptr;
178 u32 i;
179
180 for (i = 0; i < MAX_BEARERS; i++) {
181 b_ptr = bearer_list[i];
182 if (b_ptr && (!strcmp(b_ptr->name, name)))
183 return b_ptr;
184 }
185 return NULL;
186}
187
188/**
189 * tipc_bearer_get_names - record names of bearers in buffer
190 */
191struct sk_buff *tipc_bearer_get_names(void)
192{
193 struct sk_buff *buf;
194 struct tipc_bearer *b;
195 int i, j;
196
197 buf = tipc_cfg_reply_alloc(MAX_BEARERS * TLV_SPACE(TIPC_MAX_BEARER_NAME));
198 if (!buf)
199 return NULL;
200
201 read_lock_bh(&tipc_net_lock);
202 for (i = 0; media_info_array[i] != NULL; i++) {
203 for (j = 0; j < MAX_BEARERS; j++) {
204 b = bearer_list[j];
205 if (!b)
206 continue;
207 if (b->media == media_info_array[i]) {
208 tipc_cfg_append_tlv(buf, TIPC_TLV_BEARER_NAME,
209 b->name,
210 strlen(b->name) + 1);
211 }
212 }
213 }
214 read_unlock_bh(&tipc_net_lock);
215 return buf;
216}
217
218void tipc_bearer_add_dest(struct tipc_bearer *b_ptr, u32 dest)
219{
220 tipc_nmap_add(&b_ptr->nodes, dest);
221 tipc_bcbearer_sort();
222 tipc_disc_add_dest(b_ptr->link_req);
223}
224
225void tipc_bearer_remove_dest(struct tipc_bearer *b_ptr, u32 dest)
226{
227 tipc_nmap_remove(&b_ptr->nodes, dest);
228 tipc_bcbearer_sort();
229 tipc_disc_remove_dest(b_ptr->link_req);
230}
231
232/**
233 * tipc_enable_bearer - enable bearer with the given name
234 */
235int tipc_enable_bearer(const char *name, u32 disc_domain, u32 priority)
236{
237 struct tipc_bearer *b_ptr;
238 struct tipc_media *m_ptr;
239 struct tipc_bearer_names b_names;
240 char addr_string[16];
241 u32 bearer_id;
242 u32 with_this_prio;
243 u32 i;
244 int res = -EINVAL;
245
246 if (!tipc_own_addr) {
247 pr_warn("Bearer <%s> rejected, not supported in standalone mode\n",
248 name);
249 return -ENOPROTOOPT;
250 }
251 if (!bearer_name_validate(name, &b_names)) {
252 pr_warn("Bearer <%s> rejected, illegal name\n", name);
253 return -EINVAL;
254 }
255 if (tipc_addr_domain_valid(disc_domain) &&
256 (disc_domain != tipc_own_addr)) {
257 if (tipc_in_scope(disc_domain, tipc_own_addr)) {
258 disc_domain = tipc_own_addr & TIPC_CLUSTER_MASK;
259 res = 0; /* accept any node in own cluster */
260 } else if (in_own_cluster_exact(disc_domain))
261 res = 0; /* accept specified node in own cluster */
262 }
263 if (res) {
264 pr_warn("Bearer <%s> rejected, illegal discovery domain\n",
265 name);
266 return -EINVAL;
267 }
268 if ((priority > TIPC_MAX_LINK_PRI) &&
269 (priority != TIPC_MEDIA_LINK_PRI)) {
270 pr_warn("Bearer <%s> rejected, illegal priority\n", name);
271 return -EINVAL;
272 }
273
274 write_lock_bh(&tipc_net_lock);
275
276 m_ptr = tipc_media_find(b_names.media_name);
277 if (!m_ptr) {
278 pr_warn("Bearer <%s> rejected, media <%s> not registered\n",
279 name, b_names.media_name);
280 goto exit;
281 }
282
283 if (priority == TIPC_MEDIA_LINK_PRI)
284 priority = m_ptr->priority;
285
286restart:
287 bearer_id = MAX_BEARERS;
288 with_this_prio = 1;
289 for (i = MAX_BEARERS; i-- != 0; ) {
290 b_ptr = bearer_list[i];
291 if (!b_ptr) {
292 bearer_id = i;
293 continue;
294 }
295 if (!strcmp(name, b_ptr->name)) {
296 pr_warn("Bearer <%s> rejected, already enabled\n",
297 name);
298 goto exit;
299 }
300 if ((b_ptr->priority == priority) &&
301 (++with_this_prio > 2)) {
302 if (priority-- == 0) {
303 pr_warn("Bearer <%s> rejected, duplicate priority\n",
304 name);
305 goto exit;
306 }
307 pr_warn("Bearer <%s> priority adjustment required %u->%u\n",
308 name, priority + 1, priority);
309 goto restart;
310 }
311 }
312 if (bearer_id >= MAX_BEARERS) {
313 pr_warn("Bearer <%s> rejected, bearer limit reached (%u)\n",
314 name, MAX_BEARERS);
315 goto exit;
316 }
317
318 b_ptr = kzalloc(sizeof(*b_ptr), GFP_ATOMIC);
319 if (!b_ptr) {
320 res = -ENOMEM;
321 goto exit;
322 }
323 strcpy(b_ptr->name, name);
324 b_ptr->media = m_ptr;
325 res = m_ptr->enable_media(b_ptr);
326 if (res) {
327 pr_warn("Bearer <%s> rejected, enable failure (%d)\n",
328 name, -res);
329 goto exit;
330 }
331
332 b_ptr->identity = bearer_id;
333 b_ptr->tolerance = m_ptr->tolerance;
334 b_ptr->window = m_ptr->window;
335 b_ptr->domain = disc_domain;
336 b_ptr->net_plane = bearer_id + 'A';
337 b_ptr->priority = priority;
338
339 res = tipc_disc_create(b_ptr, &b_ptr->bcast_addr);
340 if (res) {
341 bearer_disable(b_ptr, false);
342 pr_warn("Bearer <%s> rejected, discovery object creation failed\n",
343 name);
344 goto exit;
345 }
346
347 bearer_list[bearer_id] = b_ptr;
348
349 pr_info("Enabled bearer <%s>, discovery domain %s, priority %u\n",
350 name,
351 tipc_addr_string_fill(addr_string, disc_domain), priority);
352exit:
353 write_unlock_bh(&tipc_net_lock);
354 return res;
355}
356
357/**
358 * tipc_reset_bearer - Reset all links established over this bearer
359 */
360static int tipc_reset_bearer(struct tipc_bearer *b_ptr)
361{
362 read_lock_bh(&tipc_net_lock);
363 pr_info("Resetting bearer <%s>\n", b_ptr->name);
364 tipc_disc_delete(b_ptr->link_req);
365 tipc_link_reset_list(b_ptr->identity);
366 tipc_disc_create(b_ptr, &b_ptr->bcast_addr);
367 read_unlock_bh(&tipc_net_lock);
368 return 0;
369}
370
371/**
372 * bearer_disable
373 *
374 * Note: This routine assumes caller holds tipc_net_lock.
375 */
376static void bearer_disable(struct tipc_bearer *b_ptr, bool shutting_down)
377{
378 u32 i;
379
380 pr_info("Disabling bearer <%s>\n", b_ptr->name);
381 b_ptr->media->disable_media(b_ptr);
382
383 tipc_link_delete_list(b_ptr->identity, shutting_down);
384 if (b_ptr->link_req)
385 tipc_disc_delete(b_ptr->link_req);
386
387 for (i = 0; i < MAX_BEARERS; i++) {
388 if (b_ptr == bearer_list[i]) {
389 bearer_list[i] = NULL;
390 break;
391 }
392 }
393 kfree(b_ptr);
394}
395
396int tipc_disable_bearer(const char *name)
397{
398 struct tipc_bearer *b_ptr;
399 int res;
400
401 write_lock_bh(&tipc_net_lock);
402 b_ptr = tipc_bearer_find(name);
403 if (b_ptr == NULL) {
404 pr_warn("Attempt to disable unknown bearer <%s>\n", name);
405 res = -EINVAL;
406 } else {
407 bearer_disable(b_ptr, false);
408 res = 0;
409 }
410 write_unlock_bh(&tipc_net_lock);
411 return res;
412}
413
414
415/* tipc_l2_media_addr_set - initialize Ethernet media address structure
416 *
417 * Media-dependent "value" field stores MAC address in first 6 bytes
418 * and zeroes out the remaining bytes.
419 */
420void tipc_l2_media_addr_set(const struct tipc_bearer *b,
421 struct tipc_media_addr *a, char *mac)
422{
423 int len = b->media->hwaddr_len;
424
425 if (unlikely(sizeof(a->value) < len)) {
426 WARN_ONCE(1, "Media length invalid\n");
427 return;
428 }
429
430 memcpy(a->value, mac, len);
431 memset(a->value + len, 0, sizeof(a->value) - len);
432 a->media_id = b->media->type_id;
433 a->broadcast = !memcmp(mac, b->bcast_addr.value, len);
434}
435
436int tipc_enable_l2_media(struct tipc_bearer *b)
437{
438 struct net_device *dev;
439 char *driver_name = strchr((const char *)b->name, ':') + 1;
440
441 /* Find device with specified name */
442 dev = dev_get_by_name(&init_net, driver_name);
443 if (!dev)
444 return -ENODEV;
445
446 /* Associate TIPC bearer with Ethernet bearer */
447 b->media_ptr = dev;
448 memset(b->bcast_addr.value, 0, sizeof(b->bcast_addr.value));
449 memcpy(b->bcast_addr.value, dev->broadcast, b->media->hwaddr_len);
450 b->bcast_addr.media_id = b->media->type_id;
451 b->bcast_addr.broadcast = 1;
452 b->mtu = dev->mtu;
453 tipc_l2_media_addr_set(b, &b->addr, (char *)dev->dev_addr);
454 rcu_assign_pointer(dev->tipc_ptr, b);
455 return 0;
456}
457
458/* tipc_disable_l2_media - detach TIPC bearer from an Ethernet interface
459 *
460 * Mark Ethernet bearer as inactive so that incoming buffers are thrown away,
461 * then get worker thread to complete bearer cleanup. (Can't do cleanup
462 * here because cleanup code needs to sleep and caller holds spinlocks.)
463 */
464void tipc_disable_l2_media(struct tipc_bearer *b)
465{
466 struct net_device *dev = (struct net_device *)b->media_ptr;
467 RCU_INIT_POINTER(dev->tipc_ptr, NULL);
468 dev_put(dev);
469}
470
471/**
472 * tipc_l2_send_msg - send a TIPC packet out over an Ethernet interface
473 * @buf: the packet to be sent
474 * @b_ptr: the bearer through which the packet is to be sent
475 * @dest: peer destination address
476 */
477int tipc_l2_send_msg(struct sk_buff *buf, struct tipc_bearer *b,
478 struct tipc_media_addr *dest)
479{
480 struct sk_buff *clone;
481 int delta;
482 struct net_device *dev = (struct net_device *)b->media_ptr;
483
484 clone = skb_clone(buf, GFP_ATOMIC);
485 if (!clone)
486 return 0;
487
488 delta = dev->hard_header_len - skb_headroom(buf);
489 if ((delta > 0) &&
490 pskb_expand_head(clone, SKB_DATA_ALIGN(delta), 0, GFP_ATOMIC)) {
491 kfree_skb(clone);
492 return 0;
493 }
494
495 skb_reset_network_header(clone);
496 clone->dev = dev;
497 clone->protocol = htons(ETH_P_TIPC);
498 dev_hard_header(clone, dev, ETH_P_TIPC, dest->value,
499 dev->dev_addr, clone->len);
500 dev_queue_xmit(clone);
501 return 0;
502}
503
504/* tipc_bearer_send- sends buffer to destination over bearer
505 *
506 * IMPORTANT:
507 * The media send routine must not alter the buffer being passed in
508 * as it may be needed for later retransmission!
509 */
510void tipc_bearer_send(struct tipc_bearer *b, struct sk_buff *buf,
511 struct tipc_media_addr *dest)
512{
513 b->media->send_msg(buf, b, dest);
514}
515
516/**
517 * tipc_l2_rcv_msg - handle incoming TIPC message from an interface
518 * @buf: the received packet
519 * @dev: the net device that the packet was received on
520 * @pt: the packet_type structure which was used to register this handler
521 * @orig_dev: the original receive net device in case the device is a bond
522 *
523 * Accept only packets explicitly sent to this node, or broadcast packets;
524 * ignores packets sent using interface multicast, and traffic sent to other
525 * nodes (which can happen if interface is running in promiscuous mode).
526 */
527static int tipc_l2_rcv_msg(struct sk_buff *buf, struct net_device *dev,
528 struct packet_type *pt, struct net_device *orig_dev)
529{
530 struct tipc_bearer *b_ptr;
531
532 if (!net_eq(dev_net(dev), &init_net)) {
533 kfree_skb(buf);
534 return NET_RX_DROP;
535 }
536
537 rcu_read_lock();
538 b_ptr = rcu_dereference(dev->tipc_ptr);
539 if (likely(b_ptr)) {
540 if (likely(buf->pkt_type <= PACKET_BROADCAST)) {
541 buf->next = NULL;
542 tipc_rcv(buf, b_ptr);
543 rcu_read_unlock();
544 return NET_RX_SUCCESS;
545 }
546 }
547 rcu_read_unlock();
548
549 kfree_skb(buf);
550 return NET_RX_DROP;
551}
552
553/**
554 * tipc_l2_device_event - handle device events from network device
555 * @nb: the context of the notification
556 * @evt: the type of event
557 * @ptr: the net device that the event was on
558 *
559 * This function is called by the Ethernet driver in case of link
560 * change event.
561 */
562static int tipc_l2_device_event(struct notifier_block *nb, unsigned long evt,
563 void *ptr)
564{
565 struct tipc_bearer *b_ptr;
566 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
567
568 if (!net_eq(dev_net(dev), &init_net))
569 return NOTIFY_DONE;
570
571 rcu_read_lock();
572 b_ptr = rcu_dereference(dev->tipc_ptr);
573 if (!b_ptr) {
574 rcu_read_unlock();
575 return NOTIFY_DONE;
576 }
577
578 b_ptr->mtu = dev->mtu;
579
580 switch (evt) {
581 case NETDEV_CHANGE:
582 if (netif_carrier_ok(dev))
583 break;
584 case NETDEV_DOWN:
585 case NETDEV_CHANGEMTU:
586 tipc_reset_bearer(b_ptr);
587 break;
588 case NETDEV_CHANGEADDR:
589 tipc_l2_media_addr_set(b_ptr, &b_ptr->addr,
590 (char *)dev->dev_addr);
591 tipc_reset_bearer(b_ptr);
592 break;
593 case NETDEV_UNREGISTER:
594 case NETDEV_CHANGENAME:
595 tipc_disable_bearer(b_ptr->name);
596 break;
597 }
598 rcu_read_unlock();
599
600 return NOTIFY_OK;
601}
602
603static struct packet_type tipc_packet_type __read_mostly = {
604 .type = htons(ETH_P_TIPC),
605 .func = tipc_l2_rcv_msg,
606};
607
608static struct notifier_block notifier = {
609 .notifier_call = tipc_l2_device_event,
610 .priority = 0,
611};
612
613int tipc_bearer_setup(void)
614{
615 int err;
616
617 err = register_netdevice_notifier(¬ifier);
618 if (err)
619 return err;
620 dev_add_pack(&tipc_packet_type);
621 return 0;
622}
623
624void tipc_bearer_cleanup(void)
625{
626 unregister_netdevice_notifier(¬ifier);
627 dev_remove_pack(&tipc_packet_type);
628}
629
630void tipc_bearer_stop(void)
631{
632 struct tipc_bearer *b_ptr;
633 u32 i;
634
635 for (i = 0; i < MAX_BEARERS; i++) {
636 b_ptr = bearer_list[i];
637 if (b_ptr) {
638 bearer_disable(b_ptr, true);
639 bearer_list[i] = NULL;
640 }
641 }
642}