Loading...
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}
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 tipc_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 */
56static int media_name_valid(const char *name)
57{
58 u32 len;
59
60 len = strlen(name);
61 if ((len + 1) > TIPC_MAX_MEDIA_NAME)
62 return 0;
63 return strspn(name, tipc_alphabet) == len;
64}
65
66/**
67 * tipc_media_find - locates specified media object by name
68 */
69struct tipc_media *tipc_media_find(const char *name)
70{
71 u32 i;
72
73 for (i = 0; i < media_count; i++) {
74 if (!strcmp(media_list[i]->name, name))
75 return media_list[i];
76 }
77 return NULL;
78}
79
80/**
81 * media_find_id - locates specified media object by type identifier
82 */
83static struct tipc_media *media_find_id(u8 type)
84{
85 u32 i;
86
87 for (i = 0; i < media_count; i++) {
88 if (media_list[i]->type_id == type)
89 return media_list[i];
90 }
91 return NULL;
92}
93
94/**
95 * tipc_register_media - register a media type
96 *
97 * Bearers for this media type must be activated separately at a later stage.
98 */
99int tipc_register_media(struct tipc_media *m_ptr)
100{
101 int res = -EINVAL;
102
103 write_lock_bh(&tipc_net_lock);
104
105 if (!media_name_valid(m_ptr->name))
106 goto exit;
107 if ((m_ptr->bcast_addr.media_id != m_ptr->type_id) ||
108 !m_ptr->bcast_addr.broadcast)
109 goto exit;
110 if (m_ptr->priority > TIPC_MAX_LINK_PRI)
111 goto exit;
112 if ((m_ptr->tolerance < TIPC_MIN_LINK_TOL) ||
113 (m_ptr->tolerance > TIPC_MAX_LINK_TOL))
114 goto exit;
115 if (media_count >= MAX_MEDIA)
116 goto exit;
117 if (tipc_media_find(m_ptr->name) || media_find_id(m_ptr->type_id))
118 goto exit;
119
120 media_list[media_count] = m_ptr;
121 media_count++;
122 res = 0;
123exit:
124 write_unlock_bh(&tipc_net_lock);
125 if (res)
126 warn("Media <%s> registration error\n", m_ptr->name);
127 return res;
128}
129
130/**
131 * tipc_media_addr_printf - record media address in print buffer
132 */
133void tipc_media_addr_printf(struct print_buf *pb, struct tipc_media_addr *a)
134{
135 char addr_str[MAX_ADDR_STR];
136 struct tipc_media *m_ptr;
137
138 m_ptr = media_find_id(a->media_id);
139
140 if (m_ptr && !m_ptr->addr2str(a, addr_str, sizeof(addr_str)))
141 tipc_printf(pb, "%s(%s)", m_ptr->name, addr_str);
142 else {
143 u32 i;
144
145 tipc_printf(pb, "UNKNOWN(%u)", a->media_id);
146 for (i = 0; i < sizeof(a->value); i++)
147 tipc_printf(pb, "-%02x", a->value[i]);
148 }
149}
150
151/**
152 * tipc_media_get_names - record names of registered media in buffer
153 */
154struct sk_buff *tipc_media_get_names(void)
155{
156 struct sk_buff *buf;
157 int i;
158
159 buf = tipc_cfg_reply_alloc(MAX_MEDIA * TLV_SPACE(TIPC_MAX_MEDIA_NAME));
160 if (!buf)
161 return NULL;
162
163 read_lock_bh(&tipc_net_lock);
164 for (i = 0; i < media_count; i++) {
165 tipc_cfg_append_tlv(buf, TIPC_TLV_MEDIA_NAME,
166 media_list[i]->name,
167 strlen(media_list[i]->name) + 1);
168 }
169 read_unlock_bh(&tipc_net_lock);
170 return buf;
171}
172
173/**
174 * bearer_name_validate - validate & (optionally) deconstruct bearer name
175 * @name - ptr to bearer name string
176 * @name_parts - ptr to area for bearer name components (or NULL if not needed)
177 *
178 * Returns 1 if bearer name is valid, otherwise 0.
179 */
180static int bearer_name_validate(const char *name,
181 struct tipc_bearer_names *name_parts)
182{
183 char name_copy[TIPC_MAX_BEARER_NAME];
184 char *media_name;
185 char *if_name;
186 u32 media_len;
187 u32 if_len;
188
189 /* copy bearer name & ensure length is OK */
190 name_copy[TIPC_MAX_BEARER_NAME - 1] = 0;
191 /* need above in case non-Posix strncpy() doesn't pad with nulls */
192 strncpy(name_copy, name, TIPC_MAX_BEARER_NAME);
193 if (name_copy[TIPC_MAX_BEARER_NAME - 1] != 0)
194 return 0;
195
196 /* ensure all component parts of bearer name are present */
197 media_name = name_copy;
198 if_name = strchr(media_name, ':');
199 if (if_name == NULL)
200 return 0;
201 *(if_name++) = 0;
202 media_len = if_name - media_name;
203 if_len = strlen(if_name) + 1;
204
205 /* validate component parts of bearer name */
206 if ((media_len <= 1) || (media_len > TIPC_MAX_MEDIA_NAME) ||
207 (if_len <= 1) || (if_len > TIPC_MAX_IF_NAME) ||
208 (strspn(media_name, tipc_alphabet) != (media_len - 1)) ||
209 (strspn(if_name, tipc_alphabet) != (if_len - 1)))
210 return 0;
211
212 /* return bearer name components, if necessary */
213 if (name_parts) {
214 strcpy(name_parts->media_name, media_name);
215 strcpy(name_parts->if_name, if_name);
216 }
217 return 1;
218}
219
220/**
221 * tipc_bearer_find - locates bearer object with matching bearer name
222 */
223struct tipc_bearer *tipc_bearer_find(const char *name)
224{
225 struct tipc_bearer *b_ptr;
226 u32 i;
227
228 for (i = 0, b_ptr = tipc_bearers; i < MAX_BEARERS; i++, b_ptr++) {
229 if (b_ptr->active && (!strcmp(b_ptr->name, name)))
230 return b_ptr;
231 }
232 return NULL;
233}
234
235/**
236 * tipc_bearer_find_interface - locates bearer object with matching interface name
237 */
238struct tipc_bearer *tipc_bearer_find_interface(const char *if_name)
239{
240 struct tipc_bearer *b_ptr;
241 char *b_if_name;
242 u32 i;
243
244 for (i = 0, b_ptr = tipc_bearers; i < MAX_BEARERS; i++, b_ptr++) {
245 if (!b_ptr->active)
246 continue;
247 b_if_name = strchr(b_ptr->name, ':') + 1;
248 if (!strcmp(b_if_name, if_name))
249 return b_ptr;
250 }
251 return NULL;
252}
253
254/**
255 * tipc_bearer_get_names - record names of bearers in buffer
256 */
257struct sk_buff *tipc_bearer_get_names(void)
258{
259 struct sk_buff *buf;
260 struct tipc_bearer *b_ptr;
261 int i, j;
262
263 buf = tipc_cfg_reply_alloc(MAX_BEARERS * TLV_SPACE(TIPC_MAX_BEARER_NAME));
264 if (!buf)
265 return NULL;
266
267 read_lock_bh(&tipc_net_lock);
268 for (i = 0; i < media_count; i++) {
269 for (j = 0; j < MAX_BEARERS; j++) {
270 b_ptr = &tipc_bearers[j];
271 if (b_ptr->active && (b_ptr->media == media_list[i])) {
272 tipc_cfg_append_tlv(buf, TIPC_TLV_BEARER_NAME,
273 b_ptr->name,
274 strlen(b_ptr->name) + 1);
275 }
276 }
277 }
278 read_unlock_bh(&tipc_net_lock);
279 return buf;
280}
281
282void tipc_bearer_add_dest(struct tipc_bearer *b_ptr, u32 dest)
283{
284 tipc_nmap_add(&b_ptr->nodes, dest);
285 tipc_bcbearer_sort();
286 tipc_disc_add_dest(b_ptr->link_req);
287}
288
289void tipc_bearer_remove_dest(struct tipc_bearer *b_ptr, u32 dest)
290{
291 tipc_nmap_remove(&b_ptr->nodes, dest);
292 tipc_bcbearer_sort();
293 tipc_disc_remove_dest(b_ptr->link_req);
294}
295
296/*
297 * bearer_push(): Resolve bearer congestion. Force the waiting
298 * links to push out their unsent packets, one packet per link
299 * per iteration, until all packets are gone or congestion reoccurs.
300 * 'tipc_net_lock' is read_locked when this function is called
301 * bearer.lock must be taken before calling
302 * Returns binary true(1) ore false(0)
303 */
304static int bearer_push(struct tipc_bearer *b_ptr)
305{
306 u32 res = 0;
307 struct tipc_link *ln, *tln;
308
309 if (b_ptr->blocked)
310 return 0;
311
312 while (!list_empty(&b_ptr->cong_links) && (res != PUSH_FAILED)) {
313 list_for_each_entry_safe(ln, tln, &b_ptr->cong_links, link_list) {
314 res = tipc_link_push_packet(ln);
315 if (res == PUSH_FAILED)
316 break;
317 if (res == PUSH_FINISHED)
318 list_move_tail(&ln->link_list, &b_ptr->links);
319 }
320 }
321 return list_empty(&b_ptr->cong_links);
322}
323
324void tipc_bearer_lock_push(struct tipc_bearer *b_ptr)
325{
326 spin_lock_bh(&b_ptr->lock);
327 bearer_push(b_ptr);
328 spin_unlock_bh(&b_ptr->lock);
329}
330
331
332/*
333 * Interrupt enabling new requests after bearer congestion or blocking:
334 * See bearer_send().
335 */
336void tipc_continue(struct tipc_bearer *b_ptr)
337{
338 spin_lock_bh(&b_ptr->lock);
339 if (!list_empty(&b_ptr->cong_links))
340 tipc_k_signal((Handler)tipc_bearer_lock_push, (unsigned long)b_ptr);
341 b_ptr->blocked = 0;
342 spin_unlock_bh(&b_ptr->lock);
343}
344
345/*
346 * Schedule link for sending of messages after the bearer
347 * has been deblocked by 'continue()'. This method is called
348 * when somebody tries to send a message via this link while
349 * the bearer is congested. 'tipc_net_lock' is in read_lock here
350 * bearer.lock is busy
351 */
352static void tipc_bearer_schedule_unlocked(struct tipc_bearer *b_ptr,
353 struct tipc_link *l_ptr)
354{
355 list_move_tail(&l_ptr->link_list, &b_ptr->cong_links);
356}
357
358/*
359 * Schedule link for sending of messages after the bearer
360 * has been deblocked by 'continue()'. This method is called
361 * when somebody tries to send a message via this link while
362 * the bearer is congested. 'tipc_net_lock' is in read_lock here,
363 * bearer.lock is free
364 */
365void tipc_bearer_schedule(struct tipc_bearer *b_ptr, struct tipc_link *l_ptr)
366{
367 spin_lock_bh(&b_ptr->lock);
368 tipc_bearer_schedule_unlocked(b_ptr, l_ptr);
369 spin_unlock_bh(&b_ptr->lock);
370}
371
372
373/*
374 * tipc_bearer_resolve_congestion(): Check if there is bearer congestion,
375 * and if there is, try to resolve it before returning.
376 * 'tipc_net_lock' is read_locked when this function is called
377 */
378int tipc_bearer_resolve_congestion(struct tipc_bearer *b_ptr,
379 struct tipc_link *l_ptr)
380{
381 int res = 1;
382
383 if (list_empty(&b_ptr->cong_links))
384 return 1;
385 spin_lock_bh(&b_ptr->lock);
386 if (!bearer_push(b_ptr)) {
387 tipc_bearer_schedule_unlocked(b_ptr, l_ptr);
388 res = 0;
389 }
390 spin_unlock_bh(&b_ptr->lock);
391 return res;
392}
393
394/**
395 * tipc_bearer_congested - determines if bearer is currently congested
396 */
397int tipc_bearer_congested(struct tipc_bearer *b_ptr, struct tipc_link *l_ptr)
398{
399 if (unlikely(b_ptr->blocked))
400 return 1;
401 if (likely(list_empty(&b_ptr->cong_links)))
402 return 0;
403 return !tipc_bearer_resolve_congestion(b_ptr, l_ptr);
404}
405
406/**
407 * tipc_enable_bearer - enable bearer with the given name
408 */
409int tipc_enable_bearer(const char *name, u32 disc_domain, u32 priority)
410{
411 struct tipc_bearer *b_ptr;
412 struct tipc_media *m_ptr;
413 struct tipc_bearer_names b_names;
414 char addr_string[16];
415 u32 bearer_id;
416 u32 with_this_prio;
417 u32 i;
418 int res = -EINVAL;
419
420 if (!tipc_own_addr) {
421 warn("Bearer <%s> rejected, not supported in standalone mode\n",
422 name);
423 return -ENOPROTOOPT;
424 }
425 if (!bearer_name_validate(name, &b_names)) {
426 warn("Bearer <%s> rejected, illegal name\n", name);
427 return -EINVAL;
428 }
429 if (tipc_addr_domain_valid(disc_domain) &&
430 (disc_domain != tipc_own_addr)) {
431 if (tipc_in_scope(disc_domain, tipc_own_addr)) {
432 disc_domain = tipc_own_addr & TIPC_CLUSTER_MASK;
433 res = 0; /* accept any node in own cluster */
434 } else if (in_own_cluster_exact(disc_domain))
435 res = 0; /* accept specified node in own cluster */
436 }
437 if (res) {
438 warn("Bearer <%s> rejected, illegal discovery domain\n", name);
439 return -EINVAL;
440 }
441 if ((priority > TIPC_MAX_LINK_PRI) &&
442 (priority != TIPC_MEDIA_LINK_PRI)) {
443 warn("Bearer <%s> rejected, illegal priority\n", name);
444 return -EINVAL;
445 }
446
447 write_lock_bh(&tipc_net_lock);
448
449 m_ptr = tipc_media_find(b_names.media_name);
450 if (!m_ptr) {
451 warn("Bearer <%s> rejected, media <%s> not registered\n", name,
452 b_names.media_name);
453 goto exit;
454 }
455
456 if (priority == TIPC_MEDIA_LINK_PRI)
457 priority = m_ptr->priority;
458
459restart:
460 bearer_id = MAX_BEARERS;
461 with_this_prio = 1;
462 for (i = MAX_BEARERS; i-- != 0; ) {
463 if (!tipc_bearers[i].active) {
464 bearer_id = i;
465 continue;
466 }
467 if (!strcmp(name, tipc_bearers[i].name)) {
468 warn("Bearer <%s> rejected, already enabled\n", name);
469 goto exit;
470 }
471 if ((tipc_bearers[i].priority == priority) &&
472 (++with_this_prio > 2)) {
473 if (priority-- == 0) {
474 warn("Bearer <%s> rejected, duplicate priority\n",
475 name);
476 goto exit;
477 }
478 warn("Bearer <%s> priority adjustment required %u->%u\n",
479 name, priority + 1, priority);
480 goto restart;
481 }
482 }
483 if (bearer_id >= MAX_BEARERS) {
484 warn("Bearer <%s> rejected, bearer limit reached (%u)\n",
485 name, MAX_BEARERS);
486 goto exit;
487 }
488
489 b_ptr = &tipc_bearers[bearer_id];
490 strcpy(b_ptr->name, name);
491 res = m_ptr->enable_bearer(b_ptr);
492 if (res) {
493 warn("Bearer <%s> rejected, enable failure (%d)\n", name, -res);
494 goto exit;
495 }
496
497 b_ptr->identity = bearer_id;
498 b_ptr->media = m_ptr;
499 b_ptr->tolerance = m_ptr->tolerance;
500 b_ptr->window = m_ptr->window;
501 b_ptr->net_plane = bearer_id + 'A';
502 b_ptr->active = 1;
503 b_ptr->priority = priority;
504 INIT_LIST_HEAD(&b_ptr->cong_links);
505 INIT_LIST_HEAD(&b_ptr->links);
506 spin_lock_init(&b_ptr->lock);
507
508 res = tipc_disc_create(b_ptr, &m_ptr->bcast_addr, disc_domain);
509 if (res) {
510 bearer_disable(b_ptr);
511 warn("Bearer <%s> rejected, discovery object creation failed\n",
512 name);
513 goto exit;
514 }
515 info("Enabled bearer <%s>, discovery domain %s, priority %u\n",
516 name, tipc_addr_string_fill(addr_string, disc_domain), priority);
517exit:
518 write_unlock_bh(&tipc_net_lock);
519 return res;
520}
521
522/**
523 * tipc_block_bearer(): Block the bearer with the given name,
524 * and reset all its links
525 */
526int tipc_block_bearer(const char *name)
527{
528 struct tipc_bearer *b_ptr = NULL;
529 struct tipc_link *l_ptr;
530 struct tipc_link *temp_l_ptr;
531
532 read_lock_bh(&tipc_net_lock);
533 b_ptr = tipc_bearer_find(name);
534 if (!b_ptr) {
535 warn("Attempt to block unknown bearer <%s>\n", name);
536 read_unlock_bh(&tipc_net_lock);
537 return -EINVAL;
538 }
539
540 info("Blocking bearer <%s>\n", name);
541 spin_lock_bh(&b_ptr->lock);
542 b_ptr->blocked = 1;
543 list_splice_init(&b_ptr->cong_links, &b_ptr->links);
544 list_for_each_entry_safe(l_ptr, temp_l_ptr, &b_ptr->links, link_list) {
545 struct tipc_node *n_ptr = l_ptr->owner;
546
547 spin_lock_bh(&n_ptr->lock);
548 tipc_link_reset(l_ptr);
549 spin_unlock_bh(&n_ptr->lock);
550 }
551 spin_unlock_bh(&b_ptr->lock);
552 read_unlock_bh(&tipc_net_lock);
553 return 0;
554}
555
556/**
557 * bearer_disable
558 *
559 * Note: This routine assumes caller holds tipc_net_lock.
560 */
561static void bearer_disable(struct tipc_bearer *b_ptr)
562{
563 struct tipc_link *l_ptr;
564 struct tipc_link *temp_l_ptr;
565
566 info("Disabling bearer <%s>\n", b_ptr->name);
567 spin_lock_bh(&b_ptr->lock);
568 b_ptr->blocked = 1;
569 b_ptr->media->disable_bearer(b_ptr);
570 list_splice_init(&b_ptr->cong_links, &b_ptr->links);
571 list_for_each_entry_safe(l_ptr, temp_l_ptr, &b_ptr->links, link_list) {
572 tipc_link_delete(l_ptr);
573 }
574 if (b_ptr->link_req)
575 tipc_disc_delete(b_ptr->link_req);
576 spin_unlock_bh(&b_ptr->lock);
577 memset(b_ptr, 0, sizeof(struct tipc_bearer));
578}
579
580int tipc_disable_bearer(const char *name)
581{
582 struct tipc_bearer *b_ptr;
583 int res;
584
585 write_lock_bh(&tipc_net_lock);
586 b_ptr = tipc_bearer_find(name);
587 if (b_ptr == NULL) {
588 warn("Attempt to disable unknown bearer <%s>\n", name);
589 res = -EINVAL;
590 } else {
591 bearer_disable(b_ptr);
592 res = 0;
593 }
594 write_unlock_bh(&tipc_net_lock);
595 return res;
596}
597
598
599
600void tipc_bearer_stop(void)
601{
602 u32 i;
603
604 for (i = 0; i < MAX_BEARERS; i++) {
605 if (tipc_bearers[i].active)
606 bearer_disable(&tipc_bearers[i]);
607 }
608 media_count = 0;
609}