1 /* 2 * net/tipc/bearer.c: TIPC bearer code 3 * 4 * Copyright (c) 2003-2005, Ericsson Research Canada 5 * Copyright (c) 2004-2005, Wind River Systems 6 * Copyright (c) 2005-2006, Ericsson AB 7 * All rights reserved. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions are met: 11 * 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 3. Neither the names of the copyright holders nor the names of its 18 * contributors may be used to endorse or promote products derived from 19 * this software without specific prior written permission. 20 * 21 * Alternatively, this software may be distributed under the terms of the 22 * GNU General Public License ("GPL") version 2 as published by the Free 23 * Software Foundation. 24 * 25 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 26 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 27 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 28 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 29 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 30 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 31 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 32 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 33 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 34 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 35 * POSSIBILITY OF SUCH DAMAGE. 36 */ 37 38 #include "core.h" 39 #include "config.h" 40 #include "dbg.h" 41 #include "bearer.h" 42 #include "link.h" 43 #include "port.h" 44 #include "discover.h" 45 #include "bcast.h" 46 47 #define MAX_ADDR_STR 32 48 49 static struct media *media_list = 0; 50 static u32 media_count = 0; 51 52 struct bearer *bearers = 0; 53 54 /** 55 * media_name_valid - validate media name 56 * 57 * Returns 1 if media name is valid, otherwise 0. 58 */ 59 60 static int media_name_valid(const char *name) 61 { 62 u32 len; 63 64 len = strlen(name); 65 if ((len + 1) > TIPC_MAX_MEDIA_NAME) 66 return 0; 67 return (strspn(name, tipc_alphabet) == len); 68 } 69 70 /** 71 * media_find - locates specified media object by name 72 */ 73 74 static struct media *media_find(const char *name) 75 { 76 struct media *m_ptr; 77 u32 i; 78 79 for (i = 0, m_ptr = media_list; i < media_count; i++, m_ptr++) { 80 if (!strcmp(m_ptr->name, name)) 81 return m_ptr; 82 } 83 return 0; 84 } 85 86 /** 87 * tipc_register_media - register a media type 88 * 89 * Bearers for this media type must be activated separately at a later stage. 90 */ 91 92 int tipc_register_media(u32 media_type, 93 char *name, 94 int (*enable)(struct tipc_bearer *), 95 void (*disable)(struct tipc_bearer *), 96 int (*send_msg)(struct sk_buff *, 97 struct tipc_bearer *, 98 struct tipc_media_addr *), 99 char *(*addr2str)(struct tipc_media_addr *a, 100 char *str_buf, int str_size), 101 struct tipc_media_addr *bcast_addr, 102 const u32 bearer_priority, 103 const u32 link_tolerance, /* [ms] */ 104 const u32 send_window_limit) 105 { 106 struct media *m_ptr; 107 u32 media_id; 108 u32 i; 109 int res = -EINVAL; 110 111 write_lock_bh(&net_lock); 112 if (!media_list) 113 goto exit; 114 115 if (!media_name_valid(name)) { 116 warn("Media registration error: illegal name <%s>\n", name); 117 goto exit; 118 } 119 if (!bcast_addr) { 120 warn("Media registration error: no broadcast address supplied\n"); 121 goto exit; 122 } 123 if (bearer_priority >= TIPC_NUM_LINK_PRI) { 124 warn("Media registration error: priority %u\n", bearer_priority); 125 goto exit; 126 } 127 if ((link_tolerance < TIPC_MIN_LINK_TOL) || 128 (link_tolerance > TIPC_MAX_LINK_TOL)) { 129 warn("Media registration error: tolerance %u\n", link_tolerance); 130 goto exit; 131 } 132 133 media_id = media_count++; 134 if (media_id >= MAX_MEDIA) { 135 warn("Attempt to register more than %u media\n", MAX_MEDIA); 136 media_count--; 137 goto exit; 138 } 139 for (i = 0; i < media_id; i++) { 140 if (media_list[i].type_id == media_type) { 141 warn("Attempt to register second media with type %u\n", 142 media_type); 143 media_count--; 144 goto exit; 145 } 146 if (!strcmp(name, media_list[i].name)) { 147 warn("Attempt to re-register media name <%s>\n", name); 148 media_count--; 149 goto exit; 150 } 151 } 152 153 m_ptr = &media_list[media_id]; 154 m_ptr->type_id = media_type; 155 m_ptr->send_msg = send_msg; 156 m_ptr->enable_bearer = enable; 157 m_ptr->disable_bearer = disable; 158 m_ptr->addr2str = addr2str; 159 memcpy(&m_ptr->bcast_addr, bcast_addr, sizeof(*bcast_addr)); 160 m_ptr->bcast = 1; 161 strcpy(m_ptr->name, name); 162 m_ptr->priority = bearer_priority; 163 m_ptr->tolerance = link_tolerance; 164 m_ptr->window = send_window_limit; 165 dbg("Media <%s> registered\n", name); 166 res = 0; 167 exit: 168 write_unlock_bh(&net_lock); 169 return res; 170 } 171 172 /** 173 * media_addr_printf - record media address in print buffer 174 */ 175 176 void 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 * media_get_names - record names of registered media in buffer 205 */ 206 207 struct sk_buff *media_get_names(void) 208 { 209 struct sk_buff *buf; 210 struct media *m_ptr; 211 int i; 212 213 buf = cfg_reply_alloc(MAX_MEDIA * TLV_SPACE(TIPC_MAX_MEDIA_NAME)); 214 if (!buf) 215 return NULL; 216 217 read_lock_bh(&net_lock); 218 for (i = 0, m_ptr = media_list; i < media_count; i++, m_ptr++) { 219 cfg_append_tlv(buf, TIPC_TLV_MEDIA_NAME, m_ptr->name, 220 strlen(m_ptr->name) + 1); 221 } 222 read_unlock_bh(&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 234 static 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 ((if_name = strchr(media_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 /* validate component parts of bearer name */ 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 /* return bearer name components, if necessary */ 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 * bearer_find - locates bearer object with matching bearer name 279 */ 280 281 static struct bearer *bearer_find(const char *name) 282 { 283 struct bearer *b_ptr; 284 u32 i; 285 286 for (i = 0, b_ptr = 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 0; 291 } 292 293 /** 294 * bearer_find - locates bearer object with matching interface name 295 */ 296 297 struct bearer *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 = 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 0; 311 } 312 313 /** 314 * bearer_get_names - record names of bearers in buffer 315 */ 316 317 struct sk_buff *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 = cfg_reply_alloc(MAX_BEARERS * TLV_SPACE(TIPC_MAX_BEARER_NAME)); 325 if (!buf) 326 return NULL; 327 328 read_lock_bh(&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 = &bearers[j]; 332 if (b_ptr->active && (b_ptr->media == m_ptr)) { 333 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(&net_lock); 340 return buf; 341 } 342 343 void bearer_add_dest(struct bearer *b_ptr, u32 dest) 344 { 345 nmap_add(&b_ptr->nodes, dest); 346 disc_update_link_req(b_ptr->link_req); 347 bcbearer_sort(); 348 } 349 350 void bearer_remove_dest(struct bearer *b_ptr, u32 dest) 351 { 352 nmap_remove(&b_ptr->nodes, dest); 353 disc_update_link_req(b_ptr->link_req); 354 bcbearer_sort(); 355 } 356 357 /* 358 * bearer_push(): Resolve bearer congestion. Force the waiting 359 * links to push out their unsent packets, one packet per link 360 * per iteration, until all packets are gone or congestion reoccurs. 361 * 'net_lock' is read_locked when this function is called 362 * bearer.lock must be taken before calling 363 * Returns binary true(1) ore false(0) 364 */ 365 static int bearer_push(struct bearer *b_ptr) 366 { 367 u32 res = TIPC_OK; 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 = 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 385 void 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 bcbearer_push(); 394 } 395 396 397 /* 398 * Interrupt enabling new requests after bearer congestion or blocking: 399 * See bearer_send(). 400 */ 401 void 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 k_signal((Handler)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 * Schedule link for sending of messages after the bearer 415 * has been deblocked by 'continue()'. This method is called 416 * when somebody tries to send a message via this link while 417 * the bearer is congested. 'net_lock' is in read_lock here 418 * bearer.lock is busy 419 */ 420 421 static void 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 * Schedule link for sending of messages after the bearer 428 * has been deblocked by 'continue()'. This method is called 429 * when somebody tries to send a message via this link while 430 * the bearer is congested. 'net_lock' is in read_lock here, 431 * bearer.lock is free 432 */ 433 434 void bearer_schedule(struct bearer *b_ptr, struct link *l_ptr) 435 { 436 spin_lock_bh(&b_ptr->publ.lock); 437 bearer_schedule_unlocked(b_ptr, l_ptr); 438 spin_unlock_bh(&b_ptr->publ.lock); 439 } 440 441 442 /* 443 * bearer_resolve_congestion(): Check if there is bearer congestion, 444 * and if there is, try to resolve it before returning. 445 * 'net_lock' is read_locked when this function is called 446 */ 447 int 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 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 * tipc_enable_bearer - enable bearer with the given name 465 */ 466 467 int tipc_enable_bearer(const char *name, u32 bcast_scope, u32 priority) 468 { 469 struct bearer *b_ptr; 470 struct media *m_ptr; 471 struct bearer_name b_name; 472 char addr_string[16]; 473 u32 bearer_id; 474 u32 with_this_prio; 475 u32 i; 476 int res = -EINVAL; 477 478 if (tipc_mode != TIPC_NET_MODE) 479 return -ENOPROTOOPT; 480 if (!bearer_name_validate(name, &b_name) || 481 !addr_domain_valid(bcast_scope) || 482 !in_scope(bcast_scope, tipc_own_addr) || 483 (priority > TIPC_NUM_LINK_PRI)) 484 return -EINVAL; 485 486 write_lock_bh(&net_lock); 487 if (!bearers) 488 goto failed; 489 490 m_ptr = media_find(b_name.media_name); 491 if (!m_ptr) { 492 warn("No media <%s>\n", b_name.media_name); 493 goto failed; 494 } 495 if (priority == TIPC_NUM_LINK_PRI) 496 priority = m_ptr->priority; 497 498 restart: 499 bearer_id = MAX_BEARERS; 500 with_this_prio = 1; 501 for (i = MAX_BEARERS; i-- != 0; ) { 502 if (!bearers[i].active) { 503 bearer_id = i; 504 continue; 505 } 506 if (!strcmp(name, bearers[i].publ.name)) { 507 warn("Bearer <%s> already enabled\n", name); 508 goto failed; 509 } 510 if ((bearers[i].priority == priority) && 511 (++with_this_prio > 2)) { 512 if (priority-- == 0) { 513 warn("Third bearer <%s> with priority %u, unable to lower to %u\n", 514 name, priority + 1, priority); 515 goto failed; 516 } 517 warn("Third bearer <%s> with priority %u, lowering to %u\n", 518 name, priority + 1, priority); 519 goto restart; 520 } 521 } 522 if (bearer_id >= MAX_BEARERS) { 523 warn("Attempt to enable more than %d bearers\n", MAX_BEARERS); 524 goto failed; 525 } 526 527 b_ptr = &bearers[bearer_id]; 528 memset(b_ptr, 0, sizeof(struct bearer)); 529 530 strcpy(b_ptr->publ.name, name); 531 res = m_ptr->enable_bearer(&b_ptr->publ); 532 if (res) { 533 warn("Failed to enable bearer <%s>\n", name); 534 goto failed; 535 } 536 537 b_ptr->identity = bearer_id; 538 b_ptr->media = m_ptr; 539 b_ptr->net_plane = bearer_id + 'A'; 540 b_ptr->active = 1; 541 b_ptr->detect_scope = bcast_scope; 542 b_ptr->priority = priority; 543 INIT_LIST_HEAD(&b_ptr->cong_links); 544 INIT_LIST_HEAD(&b_ptr->links); 545 if (m_ptr->bcast) { 546 b_ptr->link_req = disc_init_link_req(b_ptr, &m_ptr->bcast_addr, 547 bcast_scope, 2); 548 } 549 b_ptr->publ.lock = SPIN_LOCK_UNLOCKED; 550 write_unlock_bh(&net_lock); 551 info("Enabled bearer <%s>, discovery domain %s\n", 552 name, addr_string_fill(addr_string, bcast_scope)); 553 return 0; 554 failed: 555 write_unlock_bh(&net_lock); 556 return res; 557 } 558 559 /** 560 * tipc_block_bearer(): Block the bearer with the given name, 561 * and reset all its links 562 */ 563 564 int tipc_block_bearer(const char *name) 565 { 566 struct bearer *b_ptr = 0; 567 struct link *l_ptr; 568 struct link *temp_l_ptr; 569 570 if (tipc_mode != TIPC_NET_MODE) 571 return -ENOPROTOOPT; 572 573 read_lock_bh(&net_lock); 574 b_ptr = bearer_find(name); 575 if (!b_ptr) { 576 warn("Attempt to block unknown bearer <%s>\n", name); 577 read_unlock_bh(&net_lock); 578 return -EINVAL; 579 } 580 581 spin_lock_bh(&b_ptr->publ.lock); 582 b_ptr->publ.blocked = 1; 583 list_for_each_entry_safe(l_ptr, temp_l_ptr, &b_ptr->links, link_list) { 584 struct node *n_ptr = l_ptr->owner; 585 586 spin_lock_bh(&n_ptr->lock); 587 link_reset(l_ptr); 588 spin_unlock_bh(&n_ptr->lock); 589 } 590 spin_unlock_bh(&b_ptr->publ.lock); 591 read_unlock_bh(&net_lock); 592 info("Blocked bearer <%s>\n", name); 593 return TIPC_OK; 594 } 595 596 /** 597 * bearer_disable - 598 * 599 * Note: This routine assumes caller holds net_lock. 600 */ 601 602 static int bearer_disable(const char *name) 603 { 604 struct bearer *b_ptr; 605 struct link *l_ptr; 606 struct link *temp_l_ptr; 607 608 if (tipc_mode != TIPC_NET_MODE) 609 return -ENOPROTOOPT; 610 611 b_ptr = bearer_find(name); 612 if (!b_ptr) { 613 warn("Attempt to disable unknown bearer <%s>\n", name); 614 return -EINVAL; 615 } 616 617 disc_stop_link_req(b_ptr->link_req); 618 spin_lock_bh(&b_ptr->publ.lock); 619 b_ptr->link_req = NULL; 620 b_ptr->publ.blocked = 1; 621 if (b_ptr->media->disable_bearer) { 622 spin_unlock_bh(&b_ptr->publ.lock); 623 write_unlock_bh(&net_lock); 624 b_ptr->media->disable_bearer(&b_ptr->publ); 625 write_lock_bh(&net_lock); 626 spin_lock_bh(&b_ptr->publ.lock); 627 } 628 list_for_each_entry_safe(l_ptr, temp_l_ptr, &b_ptr->links, link_list) { 629 link_delete(l_ptr); 630 } 631 spin_unlock_bh(&b_ptr->publ.lock); 632 info("Disabled bearer <%s>\n", name); 633 memset(b_ptr, 0, sizeof(struct bearer)); 634 return TIPC_OK; 635 } 636 637 int tipc_disable_bearer(const char *name) 638 { 639 int res; 640 641 write_lock_bh(&net_lock); 642 res = bearer_disable(name); 643 write_unlock_bh(&net_lock); 644 return res; 645 } 646 647 648 649 int bearer_init(void) 650 { 651 int res; 652 653 write_lock_bh(&net_lock); 654 bearers = kmalloc(MAX_BEARERS * sizeof(struct bearer), GFP_ATOMIC); 655 media_list = kmalloc(MAX_MEDIA * sizeof(struct media), GFP_ATOMIC); 656 if (bearers && media_list) { 657 memset(bearers, 0, MAX_BEARERS * sizeof(struct bearer)); 658 memset(media_list, 0, MAX_MEDIA * sizeof(struct media)); 659 res = TIPC_OK; 660 } else { 661 kfree(bearers); 662 kfree(media_list); 663 bearers = 0; 664 media_list = 0; 665 res = -ENOMEM; 666 } 667 write_unlock_bh(&net_lock); 668 return res; 669 } 670 671 void bearer_stop(void) 672 { 673 u32 i; 674 675 if (!bearers) 676 return; 677 678 for (i = 0; i < MAX_BEARERS; i++) { 679 if (bearers[i].active) 680 bearers[i].publ.blocked = 1; 681 } 682 for (i = 0; i < MAX_BEARERS; i++) { 683 if (bearers[i].active) 684 bearer_disable(bearers[i].publ.name); 685 } 686 kfree(bearers); 687 kfree(media_list); 688 bearers = 0; 689 media_list = 0; 690 media_count = 0; 691 } 692 693 694