net/tipc/bearer.c

   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
  48 static struct media *media_list = NULL;
  49 static u32 media_count = 0;
  50
  51 struct 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
  59 static 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
  73 static 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
  91 int  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;
 170 exit:
 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
 179 void 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
 210 struct 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
 237 static 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
 284 static 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
 303 struct 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
 323 struct 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
 349 void 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
 356 void 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  */
 371 static 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
 391 void 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  */
 407 void 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
 427 static 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
 440 void 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  */
 453 int 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
 473 int 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
 517 restart:
 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;
 574 failed:
 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
 584 int 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
 619 static 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
 651 int 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
 663 int 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
 683 void 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