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