1/* 2 * net/tipc/bearer.c: TIPC bearer code 3 * 4 * Copyright (c) 1996-2006, Ericsson AB 5 * Copyright (c) 2004-2006, 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 "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 * media_name_valid - validate media name 55 * 56 * Returns 1 if media name is valid, otherwise 0. 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 * media_find - locates specified media object by name 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 * tipc_register_media - register a media type 87 * 88 * Bearers for this media type must be activated separately at a later stage. 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, /* [ms] */ 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 * tipc_media_addr_printf - record media address in print buffer 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 * tipc_media_get_names - record names of registered media in buffer 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 * bearer_name_validate - validate & (optionally) deconstruct bearer name 231 * @name - ptr to bearer name string 232 * @name_parts - ptr to area for bearer name components (or NULL if not needed) 233 * 234 * Returns 1 if bearer name is valid, otherwise 0. 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 /* copy bearer name & ensure length is OK */ 247 248 name_copy[TIPC_MAX_BEARER_NAME - 1] = 0; 249 /* need above in case non-Posix strncpy() doesn't pad with nulls */ 250 strncpy(name_copy, name, TIPC_MAX_BEARER_NAME); 251 if (name_copy[TIPC_MAX_BEARER_NAME - 1] != 0) 252 return 0; 253 254 /* ensure all component parts of bearer name are present */ 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 /* validate component parts of bearer name */ 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 /* return bearer name components, if necessary */ 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 * bearer_find - locates bearer object with matching bearer name 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 * tipc_bearer_find_interface - locates bearer object with matching interface name 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 * tipc_bearer_get_names - record names of bearers in buffer 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 * bearer_push(): Resolve bearer congestion. Force the waiting 365 * links to push out their unsent packets, one packet per link 366 * per iteration, until all packets are gone or congestion reoccurs. 367 * 'tipc_net_lock' is read_locked when this function is called 368 * bearer.lock must be taken before calling 369 * Returns binary true(1) ore false(0) 370 */ 371static int bearer_push(struct bearer *b_ptr) 372{ 373 u32 res = TIPC_OK; 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 * Interrupt enabling new requests after bearer congestion or blocking: 405 * See bearer_send(). 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 * Schedule link for sending of messages after the bearer 421 * has been deblocked by 'continue()'. This method is called 422 * when somebody tries to send a message via this link while 423 * the bearer is congested. 'tipc_net_lock' is in read_lock here 424 * bearer.lock is busy 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 * Schedule link for sending of messages after the bearer 434 * has been deblocked by 'continue()'. This method is called 435 * when somebody tries to send a message via this link while 436 * the bearer is congested. 'tipc_net_lock' is in read_lock here, 437 * bearer.lock is free 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 * tipc_bearer_resolve_congestion(): Check if there is bearer congestion, 450 * and if there is, try to resolve it before returning. 451 * 'tipc_net_lock' is read_locked when this function is called 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 * tipc_enable_bearer - enable bearer with the given name 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 * tipc_block_bearer(): Block the bearer with the given name, 581 * and reset all its links 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 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 TIPC_OK; 611} 612 613/** 614 * bearer_disable - 615 * 616 * Note: This routine assumes caller holds tipc_net_lock. 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 TIPC_OK; 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 = TIPC_OK; 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