1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
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 bearer tipc_bearers[MAX_BEARERS];
48
49
50
51
52
53
54
55static int media_name_valid(const char *name)
56{
57 u32 len;
58
59 len = strlen(name);
60 if ((len + 1) > TIPC_MAX_MEDIA_NAME)
61 return 0;
62 return strspn(name, tipc_alphabet) == len;
63}
64
65
66
67
68
69static struct media *media_find(const char *name)
70{
71 struct media *m_ptr;
72 u32 i;
73
74 for (i = 0, m_ptr = media_list; i < media_count; i++, m_ptr++) {
75 if (!strcmp(m_ptr->name, name))
76 return m_ptr;
77 }
78 return NULL;
79}
80
81
82
83
84
85
86
87int tipc_register_media(u32 media_type,
88 char *name,
89 int (*enable)(struct tipc_bearer *),
90 void (*disable)(struct tipc_bearer *),
91 int (*send_msg)(struct sk_buff *,
92 struct tipc_bearer *,
93 struct tipc_media_addr *),
94 char *(*addr2str)(struct tipc_media_addr *a,
95 char *str_buf, int str_size),
96 struct tipc_media_addr *bcast_addr,
97 const u32 bearer_priority,
98 const u32 link_tolerance,
99 const u32 send_window_limit)
100{
101 struct media *m_ptr;
102 u32 media_id;
103 u32 i;
104 int res = -EINVAL;
105
106 write_lock_bh(&tipc_net_lock);
107
108 if (tipc_mode != TIPC_NET_MODE) {
109 warn("Media <%s> rejected, not in networked mode yet\n", name);
110 goto exit;
111 }
112 if (!media_name_valid(name)) {
113 warn("Media <%s> rejected, illegal name\n", name);
114 goto exit;
115 }
116 if (!bcast_addr) {
117 warn("Media <%s> rejected, no broadcast address\n", name);
118 goto exit;
119 }
120 if ((bearer_priority < TIPC_MIN_LINK_PRI) ||
121 (bearer_priority > TIPC_MAX_LINK_PRI)) {
122 warn("Media <%s> rejected, illegal priority (%u)\n", name,
123 bearer_priority);
124 goto exit;
125 }
126 if ((link_tolerance < TIPC_MIN_LINK_TOL) ||
127 (link_tolerance > TIPC_MAX_LINK_TOL)) {
128 warn("Media <%s> rejected, illegal tolerance (%u)\n", name,
129 link_tolerance);
130 goto exit;
131 }
132
133 media_id = media_count++;
134 if (media_id >= MAX_MEDIA) {
135 warn("Media <%s> rejected, media limit reached (%u)\n", name,
136 MAX_MEDIA);
137 media_count--;
138 goto exit;
139 }
140 for (i = 0; i < media_id; i++) {
141 if (media_list[i].type_id == media_type) {
142 warn("Media <%s> rejected, duplicate type (%u)\n", name,
143 media_type);
144 media_count--;
145 goto exit;
146 }
147 if (!strcmp(name, media_list[i].name)) {
148 warn("Media <%s> rejected, duplicate name\n", name);
149 media_count--;
150 goto exit;
151 }
152 }
153
154 m_ptr = &media_list[media_id];
155 m_ptr->type_id = media_type;
156 m_ptr->send_msg = send_msg;
157 m_ptr->enable_bearer = enable;
158 m_ptr->disable_bearer = disable;
159 m_ptr->addr2str = addr2str;
160 memcpy(&m_ptr->bcast_addr, bcast_addr, sizeof(*bcast_addr));
161 m_ptr->bcast = 1;
162 strcpy(m_ptr->name, name);
163 m_ptr->priority = bearer_priority;
164 m_ptr->tolerance = link_tolerance;
165 m_ptr->window = send_window_limit;
166 res = 0;
167exit:
168 write_unlock_bh(&tipc_net_lock);
169 return res;
170}
171
172
173
174
175
176void tipc_media_addr_printf(struct print_buf *pb, struct tipc_media_addr *a)
177{
178 struct media *m_ptr;
179 u32 media_type;
180 u32 i;
181
182 media_type = ntohl(a->type);
183 for (i = 0, m_ptr = media_list; i < media_count; i++, m_ptr++) {
184 if (m_ptr->type_id == media_type)
185 break;
186 }
187
188 if ((i < media_count) && (m_ptr->addr2str != NULL)) {
189 char addr_str[MAX_ADDR_STR];
190
191 tipc_printf(pb, "%s(%s)", m_ptr->name,
192 m_ptr->addr2str(a, addr_str, sizeof(addr_str)));
193 } else {
194 unchar *addr = (unchar *)&a->dev_addr;
195
196 tipc_printf(pb, "UNKNOWN(%u)", media_type);
197 for (i = 0; i < (sizeof(*a) - sizeof(a->type)); i++)
198 tipc_printf(pb, "-%02x", addr[i]);
199 }
200}
201
202
203
204
205
206struct sk_buff *tipc_media_get_names(void)
207{
208 struct sk_buff *buf;
209 struct media *m_ptr;
210 int i;
211
212 buf = tipc_cfg_reply_alloc(MAX_MEDIA * TLV_SPACE(TIPC_MAX_MEDIA_NAME));
213 if (!buf)
214 return NULL;
215
216 read_lock_bh(&tipc_net_lock);
217 for (i = 0, m_ptr = media_list; i < media_count; i++, m_ptr++) {
218 tipc_cfg_append_tlv(buf, TIPC_TLV_MEDIA_NAME, m_ptr->name,
219 strlen(m_ptr->name) + 1);
220 }
221 read_unlock_bh(&tipc_net_lock);
222 return buf;
223}
224
225
226
227
228
229
230
231
232
233static int bearer_name_validate(const char *name,
234 struct bearer_name *name_parts)
235{
236 char name_copy[TIPC_MAX_BEARER_NAME];
237 char *media_name;
238 char *if_name;
239 u32 media_len;
240 u32 if_len;
241
242
243
244 name_copy[TIPC_MAX_BEARER_NAME - 1] = 0;
245
246 strncpy(name_copy, name, TIPC_MAX_BEARER_NAME);
247 if (name_copy[TIPC_MAX_BEARER_NAME - 1] != 0)
248 return 0;
249
250
251
252 media_name = name_copy;
253 if_name = strchr(media_name, ':');
254 if (if_name == NULL)
255 return 0;
256 *(if_name++) = 0;
257 media_len = if_name - media_name;
258 if_len = strlen(if_name) + 1;
259
260
261
262 if ((media_len <= 1) || (media_len > TIPC_MAX_MEDIA_NAME) ||
263 (if_len <= 1) || (if_len > TIPC_MAX_IF_NAME) ||
264 (strspn(media_name, tipc_alphabet) != (media_len - 1)) ||
265 (strspn(if_name, tipc_alphabet) != (if_len - 1)))
266 return 0;
267
268
269
270 if (name_parts) {
271 strcpy(name_parts->media_name, media_name);
272 strcpy(name_parts->if_name, if_name);
273 }
274 return 1;
275}
276
277
278
279
280
281static struct bearer *bearer_find(const char *name)
282{
283 struct bearer *b_ptr;
284 u32 i;
285
286 for (i = 0, b_ptr = tipc_bearers; i < MAX_BEARERS; i++, b_ptr++) {
287 if (b_ptr->active && (!strcmp(b_ptr->publ.name, name)))
288 return b_ptr;
289 }
290 return NULL;
291}
292
293
294
295
296
297struct bearer *tipc_bearer_find_interface(const char *if_name)
298{
299 struct bearer *b_ptr;
300 char *b_if_name;
301 u32 i;
302
303 for (i = 0, b_ptr = tipc_bearers; i < MAX_BEARERS; i++, b_ptr++) {
304 if (!b_ptr->active)
305 continue;
306 b_if_name = strchr(b_ptr->publ.name, ':') + 1;
307 if (!strcmp(b_if_name, if_name))
308 return b_ptr;
309 }
310 return NULL;
311}
312
313
314
315
316
317struct sk_buff *tipc_bearer_get_names(void)
318{
319 struct sk_buff *buf;
320 struct media *m_ptr;
321 struct bearer *b_ptr;
322 int i, j;
323
324 buf = tipc_cfg_reply_alloc(MAX_BEARERS * TLV_SPACE(TIPC_MAX_BEARER_NAME));
325 if (!buf)
326 return NULL;
327
328 read_lock_bh(&tipc_net_lock);
329 for (i = 0, m_ptr = media_list; i < media_count; i++, m_ptr++) {
330 for (j = 0; j < MAX_BEARERS; j++) {
331 b_ptr = &tipc_bearers[j];
332 if (b_ptr->active && (b_ptr->media == m_ptr)) {
333 tipc_cfg_append_tlv(buf, TIPC_TLV_BEARER_NAME,
334 b_ptr->publ.name,
335 strlen(b_ptr->publ.name) + 1);
336 }
337 }
338 }
339 read_unlock_bh(&tipc_net_lock);
340 return buf;
341}
342
343void tipc_bearer_add_dest(struct bearer *b_ptr, u32 dest)
344{
345 tipc_nmap_add(&b_ptr->nodes, dest);
346 tipc_disc_update_link_req(b_ptr->link_req);
347 tipc_bcbearer_sort();
348}
349
350void tipc_bearer_remove_dest(struct bearer *b_ptr, u32 dest)
351{
352 tipc_nmap_remove(&b_ptr->nodes, dest);
353 tipc_disc_update_link_req(b_ptr->link_req);
354 tipc_bcbearer_sort();
355}
356
357
358
359
360
361
362
363
364
365static int bearer_push(struct bearer *b_ptr)
366{
367 u32 res = 0;
368 struct link *ln, *tln;
369
370 if (b_ptr->publ.blocked)
371 return 0;
372
373 while (!list_empty(&b_ptr->cong_links) && (res != PUSH_FAILED)) {
374 list_for_each_entry_safe(ln, tln, &b_ptr->cong_links, link_list) {
375 res = tipc_link_push_packet(ln);
376 if (res == PUSH_FAILED)
377 break;
378 if (res == PUSH_FINISHED)
379 list_move_tail(&ln->link_list, &b_ptr->links);
380 }
381 }
382 return list_empty(&b_ptr->cong_links);
383}
384
385void tipc_bearer_lock_push(struct bearer *b_ptr)
386{
387 int res;
388
389 spin_lock_bh(&b_ptr->publ.lock);
390 res = bearer_push(b_ptr);
391 spin_unlock_bh(&b_ptr->publ.lock);
392 if (res)
393 tipc_bcbearer_push();
394}
395
396
397
398
399
400
401void tipc_continue(struct tipc_bearer *tb_ptr)
402{
403 struct bearer *b_ptr = (struct bearer *)tb_ptr;
404
405 spin_lock_bh(&b_ptr->publ.lock);
406 b_ptr->continue_count++;
407 if (!list_empty(&b_ptr->cong_links))
408 tipc_k_signal((Handler)tipc_bearer_lock_push, (unsigned long)b_ptr);
409 b_ptr->publ.blocked = 0;
410 spin_unlock_bh(&b_ptr->publ.lock);
411}
412
413
414
415
416
417
418
419
420
421static void tipc_bearer_schedule_unlocked(struct bearer *b_ptr, struct link *l_ptr)
422{
423 list_move_tail(&l_ptr->link_list, &b_ptr->cong_links);
424}
425
426
427
428
429
430
431
432
433
434void tipc_bearer_schedule(struct bearer *b_ptr, struct link *l_ptr)
435{
436 spin_lock_bh(&b_ptr->publ.lock);
437 tipc_bearer_schedule_unlocked(b_ptr, l_ptr);
438 spin_unlock_bh(&b_ptr->publ.lock);
439}
440
441
442
443
444
445
446
447int tipc_bearer_resolve_congestion(struct bearer *b_ptr, struct link *l_ptr)
448{
449 int res = 1;
450
451 if (list_empty(&b_ptr->cong_links))
452 return 1;
453 spin_lock_bh(&b_ptr->publ.lock);
454 if (!bearer_push(b_ptr)) {
455 tipc_bearer_schedule_unlocked(b_ptr, l_ptr);
456 res = 0;
457 }
458 spin_unlock_bh(&b_ptr->publ.lock);
459 return res;
460}
461
462
463
464
465
466int tipc_bearer_congested(struct bearer *b_ptr, struct link *l_ptr)
467{
468 if (unlikely(b_ptr->publ.blocked))
469 return 1;
470 if (likely(list_empty(&b_ptr->cong_links)))
471 return 0;
472 return !tipc_bearer_resolve_congestion(b_ptr, l_ptr);
473}
474
475
476
477
478
479int tipc_enable_bearer(const char *name, u32 bcast_scope, u32 priority)
480{
481 struct bearer *b_ptr;
482 struct media *m_ptr;
483 struct bearer_name b_name;
484 char addr_string[16];
485 u32 bearer_id;
486 u32 with_this_prio;
487 u32 i;
488 int res = -EINVAL;
489
490 if (tipc_mode != TIPC_NET_MODE) {
491 warn("Bearer <%s> rejected, not supported in standalone mode\n",
492 name);
493 return -ENOPROTOOPT;
494 }
495 if (!bearer_name_validate(name, &b_name)) {
496 warn("Bearer <%s> rejected, illegal name\n", name);
497 return -EINVAL;
498 }
499 if (!tipc_addr_domain_valid(bcast_scope) ||
500 !tipc_in_scope(bcast_scope, tipc_own_addr)) {
501 warn("Bearer <%s> rejected, illegal broadcast scope\n", name);
502 return -EINVAL;
503 }
504 if ((priority < TIPC_MIN_LINK_PRI ||
505 priority > TIPC_MAX_LINK_PRI) &&
506 (priority != TIPC_MEDIA_LINK_PRI)) {
507 warn("Bearer <%s> rejected, illegal priority\n", name);
508 return -EINVAL;
509 }
510
511 write_lock_bh(&tipc_net_lock);
512
513 m_ptr = media_find(b_name.media_name);
514 if (!m_ptr) {
515 warn("Bearer <%s> rejected, media <%s> not registered\n", name,
516 b_name.media_name);
517 goto failed;
518 }
519
520 if (priority == TIPC_MEDIA_LINK_PRI)
521 priority = m_ptr->priority;
522
523restart:
524 bearer_id = MAX_BEARERS;
525 with_this_prio = 1;
526 for (i = MAX_BEARERS; i-- != 0; ) {
527 if (!tipc_bearers[i].active) {
528 bearer_id = i;
529 continue;
530 }
531 if (!strcmp(name, tipc_bearers[i].publ.name)) {
532 warn("Bearer <%s> rejected, already enabled\n", name);
533 goto failed;
534 }
535 if ((tipc_bearers[i].priority == priority) &&
536 (++with_this_prio > 2)) {
537 if (priority-- == 0) {
538 warn("Bearer <%s> rejected, duplicate priority\n",
539 name);
540 goto failed;
541 }
542 warn("Bearer <%s> priority adjustment required %u->%u\n",
543 name, priority + 1, priority);
544 goto restart;
545 }
546 }
547 if (bearer_id >= MAX_BEARERS) {
548 warn("Bearer <%s> rejected, bearer limit reached (%u)\n",
549 name, MAX_BEARERS);
550 goto failed;
551 }
552
553 b_ptr = &tipc_bearers[bearer_id];
554 strcpy(b_ptr->publ.name, name);
555 res = m_ptr->enable_bearer(&b_ptr->publ);
556 if (res) {
557 warn("Bearer <%s> rejected, enable failure (%d)\n", name, -res);
558 goto failed;
559 }
560
561 b_ptr->identity = bearer_id;
562 b_ptr->media = m_ptr;
563 b_ptr->net_plane = bearer_id + 'A';
564 b_ptr->active = 1;
565 b_ptr->detect_scope = bcast_scope;
566 b_ptr->priority = priority;
567 INIT_LIST_HEAD(&b_ptr->cong_links);
568 INIT_LIST_HEAD(&b_ptr->links);
569 if (m_ptr->bcast) {
570 b_ptr->link_req = tipc_disc_init_link_req(b_ptr, &m_ptr->bcast_addr,
571 bcast_scope, 2);
572 }
573 spin_lock_init(&b_ptr->publ.lock);
574 write_unlock_bh(&tipc_net_lock);
575 info("Enabled bearer <%s>, discovery domain %s, priority %u\n",
576 name, tipc_addr_string_fill(addr_string, bcast_scope), priority);
577 return 0;
578failed:
579 write_unlock_bh(&tipc_net_lock);
580 return res;
581}
582
583
584
585
586
587
588int tipc_block_bearer(const char *name)
589{
590 struct bearer *b_ptr = NULL;
591 struct link *l_ptr;
592 struct link *temp_l_ptr;
593
594 read_lock_bh(&tipc_net_lock);
595 b_ptr = bearer_find(name);
596 if (!b_ptr) {
597 warn("Attempt to block unknown bearer <%s>\n", name);
598 read_unlock_bh(&tipc_net_lock);
599 return -EINVAL;
600 }
601
602 info("Blocking bearer <%s>\n", name);
603 spin_lock_bh(&b_ptr->publ.lock);
604 b_ptr->publ.blocked = 1;
605 list_for_each_entry_safe(l_ptr, temp_l_ptr, &b_ptr->links, link_list) {
606 struct tipc_node *n_ptr = l_ptr->owner;
607
608 spin_lock_bh(&n_ptr->lock);
609 tipc_link_reset(l_ptr);
610 spin_unlock_bh(&n_ptr->lock);
611 }
612 spin_unlock_bh(&b_ptr->publ.lock);
613 read_unlock_bh(&tipc_net_lock);
614 return 0;
615}
616
617
618
619
620
621
622
623static void bearer_disable(struct bearer *b_ptr)
624{
625 struct link *l_ptr;
626 struct link *temp_l_ptr;
627
628 info("Disabling bearer <%s>\n", b_ptr->publ.name);
629 tipc_disc_stop_link_req(b_ptr->link_req);
630 spin_lock_bh(&b_ptr->publ.lock);
631 b_ptr->link_req = NULL;
632 b_ptr->publ.blocked = 1;
633 b_ptr->media->disable_bearer(&b_ptr->publ);
634 list_for_each_entry_safe(l_ptr, temp_l_ptr, &b_ptr->links, link_list) {
635 tipc_link_delete(l_ptr);
636 }
637 spin_unlock_bh(&b_ptr->publ.lock);
638 memset(b_ptr, 0, sizeof(struct bearer));
639}
640
641int tipc_disable_bearer(const char *name)
642{
643 struct bearer *b_ptr;
644 int res;
645
646 write_lock_bh(&tipc_net_lock);
647 b_ptr = bearer_find(name);
648 if (b_ptr == NULL) {
649 warn("Attempt to disable unknown bearer <%s>\n", name);
650 res = -EINVAL;
651 } else {
652 bearer_disable(b_ptr);
653 res = 0;
654 }
655 write_unlock_bh(&tipc_net_lock);
656 return res;
657}
658
659
660
661void tipc_bearer_stop(void)
662{
663 u32 i;
664
665 for (i = 0; i < MAX_BEARERS; i++) {
666 if (tipc_bearers[i].active)
667 bearer_disable(&tipc_bearers[i]);
668 }
669 media_count = 0;
670}
671