bearer.c 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705
  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. #include "core.h"
  37. #include "config.h"
  38. #include "dbg.h"
  39. #include "bearer.h"
  40. #include "link.h"
  41. #include "port.h"
  42. #include "discover.h"
  43. #include "bcast.h"
  44. #define MAX_ADDR_STR 32
  45. static struct media *media_list = NULL;
  46. static u32 media_count = 0;
  47. struct bearer *tipc_bearers = NULL;
  48. /**
  49. * media_name_valid - validate media name
  50. *
  51. * Returns 1 if media name is valid, otherwise 0.
  52. */
  53. static int media_name_valid(const char *name)
  54. {
  55. u32 len;
  56. len = strlen(name);
  57. if ((len + 1) > TIPC_MAX_MEDIA_NAME)
  58. return 0;
  59. return (strspn(name, tipc_alphabet) == len);
  60. }
  61. /**
  62. * media_find - locates specified media object by name
  63. */
  64. static struct media *media_find(const char *name)
  65. {
  66. struct media *m_ptr;
  67. u32 i;
  68. for (i = 0, m_ptr = media_list; i < media_count; i++, m_ptr++) {
  69. if (!strcmp(m_ptr->name, name))
  70. return m_ptr;
  71. }
  72. return NULL;
  73. }
  74. /**
  75. * tipc_register_media - register a media type
  76. *
  77. * Bearers for this media type must be activated separately at a later stage.
  78. */
  79. int tipc_register_media(u32 media_type,
  80. char *name,
  81. int (*enable)(struct tipc_bearer *),
  82. void (*disable)(struct tipc_bearer *),
  83. int (*send_msg)(struct sk_buff *,
  84. struct tipc_bearer *,
  85. struct tipc_media_addr *),
  86. char *(*addr2str)(struct tipc_media_addr *a,
  87. char *str_buf, int str_size),
  88. struct tipc_media_addr *bcast_addr,
  89. const u32 bearer_priority,
  90. const u32 link_tolerance, /* [ms] */
  91. const u32 send_window_limit)
  92. {
  93. struct media *m_ptr;
  94. u32 media_id;
  95. u32 i;
  96. int res = -EINVAL;
  97. write_lock_bh(&tipc_net_lock);
  98. if (!media_list)
  99. goto exit;
  100. if (!media_name_valid(name)) {
  101. warn("Media <%s> rejected, illegal name\n", name);
  102. goto exit;
  103. }
  104. if (!bcast_addr) {
  105. warn("Media <%s> rejected, no broadcast address\n", name);
  106. goto exit;
  107. }
  108. if ((bearer_priority < TIPC_MIN_LINK_PRI) &&
  109. (bearer_priority > TIPC_MAX_LINK_PRI)) {
  110. warn("Media <%s> rejected, illegal priority (%u)\n", name,
  111. bearer_priority);
  112. goto exit;
  113. }
  114. if ((link_tolerance < TIPC_MIN_LINK_TOL) ||
  115. (link_tolerance > TIPC_MAX_LINK_TOL)) {
  116. warn("Media <%s> rejected, illegal tolerance (%u)\n", name,
  117. link_tolerance);
  118. goto exit;
  119. }
  120. media_id = media_count++;
  121. if (media_id >= MAX_MEDIA) {
  122. warn("Media <%s> rejected, media limit reached (%u)\n", name,
  123. MAX_MEDIA);
  124. media_count--;
  125. goto exit;
  126. }
  127. for (i = 0; i < media_id; i++) {
  128. if (media_list[i].type_id == media_type) {
  129. warn("Media <%s> rejected, duplicate type (%u)\n", name,
  130. media_type);
  131. media_count--;
  132. goto exit;
  133. }
  134. if (!strcmp(name, media_list[i].name)) {
  135. warn("Media <%s> rejected, duplicate name\n", name);
  136. media_count--;
  137. goto exit;
  138. }
  139. }
  140. m_ptr = &media_list[media_id];
  141. m_ptr->type_id = media_type;
  142. m_ptr->send_msg = send_msg;
  143. m_ptr->enable_bearer = enable;
  144. m_ptr->disable_bearer = disable;
  145. m_ptr->addr2str = addr2str;
  146. memcpy(&m_ptr->bcast_addr, bcast_addr, sizeof(*bcast_addr));
  147. m_ptr->bcast = 1;
  148. strcpy(m_ptr->name, name);
  149. m_ptr->priority = bearer_priority;
  150. m_ptr->tolerance = link_tolerance;
  151. m_ptr->window = send_window_limit;
  152. dbg("Media <%s> registered\n", name);
  153. res = 0;
  154. exit:
  155. write_unlock_bh(&tipc_net_lock);
  156. return res;
  157. }
  158. /**
  159. * tipc_media_addr_printf - record media address in print buffer
  160. */
  161. void tipc_media_addr_printf(struct print_buf *pb, struct tipc_media_addr *a)
  162. {
  163. struct media *m_ptr;
  164. u32 media_type;
  165. u32 i;
  166. media_type = ntohl(a->type);
  167. for (i = 0, m_ptr = media_list; i < media_count; i++, m_ptr++) {
  168. if (m_ptr->type_id == media_type)
  169. break;
  170. }
  171. if ((i < media_count) && (m_ptr->addr2str != NULL)) {
  172. char addr_str[MAX_ADDR_STR];
  173. tipc_printf(pb, "%s(%s)", m_ptr->name,
  174. m_ptr->addr2str(a, addr_str, sizeof(addr_str)));
  175. } else {
  176. unchar *addr = (unchar *)&a->dev_addr;
  177. tipc_printf(pb, "UNKNOWN(%u)", media_type);
  178. for (i = 0; i < (sizeof(*a) - sizeof(a->type)); i++) {
  179. tipc_printf(pb, "-%02x", addr[i]);
  180. }
  181. }
  182. }
  183. /**
  184. * tipc_media_get_names - record names of registered media in buffer
  185. */
  186. struct sk_buff *tipc_media_get_names(void)
  187. {
  188. struct sk_buff *buf;
  189. struct media *m_ptr;
  190. int i;
  191. buf = tipc_cfg_reply_alloc(MAX_MEDIA * TLV_SPACE(TIPC_MAX_MEDIA_NAME));
  192. if (!buf)
  193. return NULL;
  194. read_lock_bh(&tipc_net_lock);
  195. for (i = 0, m_ptr = media_list; i < media_count; i++, m_ptr++) {
  196. tipc_cfg_append_tlv(buf, TIPC_TLV_MEDIA_NAME, m_ptr->name,
  197. strlen(m_ptr->name) + 1);
  198. }
  199. read_unlock_bh(&tipc_net_lock);
  200. return buf;
  201. }
  202. /**
  203. * bearer_name_validate - validate & (optionally) deconstruct bearer name
  204. * @name - ptr to bearer name string
  205. * @name_parts - ptr to area for bearer name components (or NULL if not needed)
  206. *
  207. * Returns 1 if bearer name is valid, otherwise 0.
  208. */
  209. static int bearer_name_validate(const char *name,
  210. struct bearer_name *name_parts)
  211. {
  212. char name_copy[TIPC_MAX_BEARER_NAME];
  213. char *media_name;
  214. char *if_name;
  215. u32 media_len;
  216. u32 if_len;
  217. /* copy bearer name & ensure length is OK */
  218. name_copy[TIPC_MAX_BEARER_NAME - 1] = 0;
  219. /* need above in case non-Posix strncpy() doesn't pad with nulls */
  220. strncpy(name_copy, name, TIPC_MAX_BEARER_NAME);
  221. if (name_copy[TIPC_MAX_BEARER_NAME - 1] != 0)
  222. return 0;
  223. /* ensure all component parts of bearer name are present */
  224. media_name = name_copy;
  225. if ((if_name = strchr(media_name, ':')) == NULL)
  226. return 0;
  227. *(if_name++) = 0;
  228. media_len = if_name - media_name;
  229. if_len = strlen(if_name) + 1;
  230. /* validate component parts of bearer name */
  231. if ((media_len <= 1) || (media_len > TIPC_MAX_MEDIA_NAME) ||
  232. (if_len <= 1) || (if_len > TIPC_MAX_IF_NAME) ||
  233. (strspn(media_name, tipc_alphabet) != (media_len - 1)) ||
  234. (strspn(if_name, tipc_alphabet) != (if_len - 1)))
  235. return 0;
  236. /* return bearer name components, if necessary */
  237. if (name_parts) {
  238. strcpy(name_parts->media_name, media_name);
  239. strcpy(name_parts->if_name, if_name);
  240. }
  241. return 1;
  242. }
  243. /**
  244. * bearer_find - locates bearer object with matching bearer name
  245. */
  246. static struct bearer *bearer_find(const char *name)
  247. {
  248. struct bearer *b_ptr;
  249. u32 i;
  250. if (tipc_mode != TIPC_NET_MODE)
  251. return NULL;
  252. for (i = 0, b_ptr = tipc_bearers; i < MAX_BEARERS; i++, b_ptr++) {
  253. if (b_ptr->active && (!strcmp(b_ptr->publ.name, name)))
  254. return b_ptr;
  255. }
  256. return NULL;
  257. }
  258. /**
  259. * tipc_bearer_find_interface - locates bearer object with matching interface name
  260. */
  261. struct bearer *tipc_bearer_find_interface(const char *if_name)
  262. {
  263. struct bearer *b_ptr;
  264. char *b_if_name;
  265. u32 i;
  266. for (i = 0, b_ptr = tipc_bearers; i < MAX_BEARERS; i++, b_ptr++) {
  267. if (!b_ptr->active)
  268. continue;
  269. b_if_name = strchr(b_ptr->publ.name, ':') + 1;
  270. if (!strcmp(b_if_name, if_name))
  271. return b_ptr;
  272. }
  273. return NULL;
  274. }
  275. /**
  276. * tipc_bearer_get_names - record names of bearers in buffer
  277. */
  278. struct sk_buff *tipc_bearer_get_names(void)
  279. {
  280. struct sk_buff *buf;
  281. struct media *m_ptr;
  282. struct bearer *b_ptr;
  283. int i, j;
  284. buf = tipc_cfg_reply_alloc(MAX_BEARERS * TLV_SPACE(TIPC_MAX_BEARER_NAME));
  285. if (!buf)
  286. return NULL;
  287. read_lock_bh(&tipc_net_lock);
  288. for (i = 0, m_ptr = media_list; i < media_count; i++, m_ptr++) {
  289. for (j = 0; j < MAX_BEARERS; j++) {
  290. b_ptr = &tipc_bearers[j];
  291. if (b_ptr->active && (b_ptr->media == m_ptr)) {
  292. tipc_cfg_append_tlv(buf, TIPC_TLV_BEARER_NAME,
  293. b_ptr->publ.name,
  294. strlen(b_ptr->publ.name) + 1);
  295. }
  296. }
  297. }
  298. read_unlock_bh(&tipc_net_lock);
  299. return buf;
  300. }
  301. void tipc_bearer_add_dest(struct bearer *b_ptr, u32 dest)
  302. {
  303. tipc_nmap_add(&b_ptr->nodes, dest);
  304. tipc_disc_update_link_req(b_ptr->link_req);
  305. tipc_bcbearer_sort();
  306. }
  307. void tipc_bearer_remove_dest(struct bearer *b_ptr, u32 dest)
  308. {
  309. tipc_nmap_remove(&b_ptr->nodes, dest);
  310. tipc_disc_update_link_req(b_ptr->link_req);
  311. tipc_bcbearer_sort();
  312. }
  313. /*
  314. * bearer_push(): Resolve bearer congestion. Force the waiting
  315. * links to push out their unsent packets, one packet per link
  316. * per iteration, until all packets are gone or congestion reoccurs.
  317. * 'tipc_net_lock' is read_locked when this function is called
  318. * bearer.lock must be taken before calling
  319. * Returns binary true(1) ore false(0)
  320. */
  321. static int bearer_push(struct bearer *b_ptr)
  322. {
  323. u32 res = TIPC_OK;
  324. struct link *ln, *tln;
  325. if (b_ptr->publ.blocked)
  326. return 0;
  327. while (!list_empty(&b_ptr->cong_links) && (res != PUSH_FAILED)) {
  328. list_for_each_entry_safe(ln, tln, &b_ptr->cong_links, link_list) {
  329. res = tipc_link_push_packet(ln);
  330. if (res == PUSH_FAILED)
  331. break;
  332. if (res == PUSH_FINISHED)
  333. list_move_tail(&ln->link_list, &b_ptr->links);
  334. }
  335. }
  336. return list_empty(&b_ptr->cong_links);
  337. }
  338. void tipc_bearer_lock_push(struct bearer *b_ptr)
  339. {
  340. int res;
  341. spin_lock_bh(&b_ptr->publ.lock);
  342. res = bearer_push(b_ptr);
  343. spin_unlock_bh(&b_ptr->publ.lock);
  344. if (res)
  345. tipc_bcbearer_push();
  346. }
  347. /*
  348. * Interrupt enabling new requests after bearer congestion or blocking:
  349. * See bearer_send().
  350. */
  351. void tipc_continue(struct tipc_bearer *tb_ptr)
  352. {
  353. struct bearer *b_ptr = (struct bearer *)tb_ptr;
  354. spin_lock_bh(&b_ptr->publ.lock);
  355. b_ptr->continue_count++;
  356. if (!list_empty(&b_ptr->cong_links))
  357. tipc_k_signal((Handler)tipc_bearer_lock_push, (unsigned long)b_ptr);
  358. b_ptr->publ.blocked = 0;
  359. spin_unlock_bh(&b_ptr->publ.lock);
  360. }
  361. /*
  362. * Schedule link for sending of messages after the bearer
  363. * has been deblocked by 'continue()'. This method is called
  364. * when somebody tries to send a message via this link while
  365. * the bearer is congested. 'tipc_net_lock' is in read_lock here
  366. * bearer.lock is busy
  367. */
  368. static void tipc_bearer_schedule_unlocked(struct bearer *b_ptr, struct link *l_ptr)
  369. {
  370. list_move_tail(&l_ptr->link_list, &b_ptr->cong_links);
  371. }
  372. /*
  373. * Schedule link for sending of messages after the bearer
  374. * has been deblocked by 'continue()'. This method is called
  375. * when somebody tries to send a message via this link while
  376. * the bearer is congested. 'tipc_net_lock' is in read_lock here,
  377. * bearer.lock is free
  378. */
  379. void tipc_bearer_schedule(struct bearer *b_ptr, struct link *l_ptr)
  380. {
  381. spin_lock_bh(&b_ptr->publ.lock);
  382. tipc_bearer_schedule_unlocked(b_ptr, l_ptr);
  383. spin_unlock_bh(&b_ptr->publ.lock);
  384. }
  385. /*
  386. * tipc_bearer_resolve_congestion(): Check if there is bearer congestion,
  387. * and if there is, try to resolve it before returning.
  388. * 'tipc_net_lock' is read_locked when this function is called
  389. */
  390. int tipc_bearer_resolve_congestion(struct bearer *b_ptr, struct link *l_ptr)
  391. {
  392. int res = 1;
  393. if (list_empty(&b_ptr->cong_links))
  394. return 1;
  395. spin_lock_bh(&b_ptr->publ.lock);
  396. if (!bearer_push(b_ptr)) {
  397. tipc_bearer_schedule_unlocked(b_ptr, l_ptr);
  398. res = 0;
  399. }
  400. spin_unlock_bh(&b_ptr->publ.lock);
  401. return res;
  402. }
  403. /**
  404. * tipc_enable_bearer - enable bearer with the given name
  405. */
  406. int tipc_enable_bearer(const char *name, u32 bcast_scope, u32 priority)
  407. {
  408. struct bearer *b_ptr;
  409. struct media *m_ptr;
  410. struct bearer_name b_name;
  411. char addr_string[16];
  412. u32 bearer_id;
  413. u32 with_this_prio;
  414. u32 i;
  415. int res = -EINVAL;
  416. if (tipc_mode != TIPC_NET_MODE) {
  417. warn("Bearer <%s> rejected, not supported in standalone mode\n",
  418. name);
  419. return -ENOPROTOOPT;
  420. }
  421. if (!bearer_name_validate(name, &b_name)) {
  422. warn("Bearer <%s> rejected, illegal name\n", name);
  423. return -EINVAL;
  424. }
  425. if (!tipc_addr_domain_valid(bcast_scope) ||
  426. !in_scope(bcast_scope, tipc_own_addr)) {
  427. warn("Bearer <%s> rejected, illegal broadcast scope\n", name);
  428. return -EINVAL;
  429. }
  430. if ((priority < TIPC_MIN_LINK_PRI ||
  431. priority > TIPC_MAX_LINK_PRI) &&
  432. (priority != TIPC_MEDIA_LINK_PRI)) {
  433. warn("Bearer <%s> rejected, illegal priority\n", name);
  434. return -EINVAL;
  435. }
  436. write_lock_bh(&tipc_net_lock);
  437. m_ptr = media_find(b_name.media_name);
  438. if (!m_ptr) {
  439. warn("Bearer <%s> rejected, media <%s> not registered\n", name,
  440. b_name.media_name);
  441. goto failed;
  442. }
  443. if (priority == TIPC_MEDIA_LINK_PRI)
  444. priority = m_ptr->priority;
  445. restart:
  446. bearer_id = MAX_BEARERS;
  447. with_this_prio = 1;
  448. for (i = MAX_BEARERS; i-- != 0; ) {
  449. if (!tipc_bearers[i].active) {
  450. bearer_id = i;
  451. continue;
  452. }
  453. if (!strcmp(name, tipc_bearers[i].publ.name)) {
  454. warn("Bearer <%s> rejected, already enabled\n", name);
  455. goto failed;
  456. }
  457. if ((tipc_bearers[i].priority == priority) &&
  458. (++with_this_prio > 2)) {
  459. if (priority-- == 0) {
  460. warn("Bearer <%s> rejected, duplicate priority\n",
  461. name);
  462. goto failed;
  463. }
  464. warn("Bearer <%s> priority adjustment required %u->%u\n",
  465. name, priority + 1, priority);
  466. goto restart;
  467. }
  468. }
  469. if (bearer_id >= MAX_BEARERS) {
  470. warn("Bearer <%s> rejected, bearer limit reached (%u)\n",
  471. name, MAX_BEARERS);
  472. goto failed;
  473. }
  474. b_ptr = &tipc_bearers[bearer_id];
  475. memset(b_ptr, 0, sizeof(struct bearer));
  476. strcpy(b_ptr->publ.name, name);
  477. res = m_ptr->enable_bearer(&b_ptr->publ);
  478. if (res) {
  479. warn("Bearer <%s> rejected, enable failure (%d)\n", name, -res);
  480. goto failed;
  481. }
  482. b_ptr->identity = bearer_id;
  483. b_ptr->media = m_ptr;
  484. b_ptr->net_plane = bearer_id + 'A';
  485. b_ptr->active = 1;
  486. b_ptr->detect_scope = bcast_scope;
  487. b_ptr->priority = priority;
  488. INIT_LIST_HEAD(&b_ptr->cong_links);
  489. INIT_LIST_HEAD(&b_ptr->links);
  490. if (m_ptr->bcast) {
  491. b_ptr->link_req = tipc_disc_init_link_req(b_ptr, &m_ptr->bcast_addr,
  492. bcast_scope, 2);
  493. }
  494. spin_lock_init(&b_ptr->publ.lock);
  495. write_unlock_bh(&tipc_net_lock);
  496. info("Enabled bearer <%s>, discovery domain %s, priority %u\n",
  497. name, addr_string_fill(addr_string, bcast_scope), priority);
  498. return 0;
  499. failed:
  500. write_unlock_bh(&tipc_net_lock);
  501. return res;
  502. }
  503. /**
  504. * tipc_block_bearer(): Block the bearer with the given name,
  505. * and reset all its links
  506. */
  507. int tipc_block_bearer(const char *name)
  508. {
  509. struct bearer *b_ptr = NULL;
  510. struct link *l_ptr;
  511. struct link *temp_l_ptr;
  512. read_lock_bh(&tipc_net_lock);
  513. b_ptr = bearer_find(name);
  514. if (!b_ptr) {
  515. warn("Attempt to block unknown bearer <%s>\n", name);
  516. read_unlock_bh(&tipc_net_lock);
  517. return -EINVAL;
  518. }
  519. info("Blocking bearer <%s>\n", name);
  520. spin_lock_bh(&b_ptr->publ.lock);
  521. b_ptr->publ.blocked = 1;
  522. list_for_each_entry_safe(l_ptr, temp_l_ptr, &b_ptr->links, link_list) {
  523. struct node *n_ptr = l_ptr->owner;
  524. spin_lock_bh(&n_ptr->lock);
  525. tipc_link_reset(l_ptr);
  526. spin_unlock_bh(&n_ptr->lock);
  527. }
  528. spin_unlock_bh(&b_ptr->publ.lock);
  529. read_unlock_bh(&tipc_net_lock);
  530. return TIPC_OK;
  531. }
  532. /**
  533. * bearer_disable -
  534. *
  535. * Note: This routine assumes caller holds tipc_net_lock.
  536. */
  537. static int bearer_disable(const char *name)
  538. {
  539. struct bearer *b_ptr;
  540. struct link *l_ptr;
  541. struct link *temp_l_ptr;
  542. b_ptr = bearer_find(name);
  543. if (!b_ptr) {
  544. warn("Attempt to disable unknown bearer <%s>\n", name);
  545. return -EINVAL;
  546. }
  547. info("Disabling bearer <%s>\n", name);
  548. tipc_disc_stop_link_req(b_ptr->link_req);
  549. spin_lock_bh(&b_ptr->publ.lock);
  550. b_ptr->link_req = NULL;
  551. b_ptr->publ.blocked = 1;
  552. if (b_ptr->media->disable_bearer) {
  553. spin_unlock_bh(&b_ptr->publ.lock);
  554. write_unlock_bh(&tipc_net_lock);
  555. b_ptr->media->disable_bearer(&b_ptr->publ);
  556. write_lock_bh(&tipc_net_lock);
  557. spin_lock_bh(&b_ptr->publ.lock);
  558. }
  559. list_for_each_entry_safe(l_ptr, temp_l_ptr, &b_ptr->links, link_list) {
  560. tipc_link_delete(l_ptr);
  561. }
  562. spin_unlock_bh(&b_ptr->publ.lock);
  563. memset(b_ptr, 0, sizeof(struct bearer));
  564. return TIPC_OK;
  565. }
  566. int tipc_disable_bearer(const char *name)
  567. {
  568. int res;
  569. write_lock_bh(&tipc_net_lock);
  570. res = bearer_disable(name);
  571. write_unlock_bh(&tipc_net_lock);
  572. return res;
  573. }
  574. int tipc_bearer_init(void)
  575. {
  576. int res;
  577. write_lock_bh(&tipc_net_lock);
  578. tipc_bearers = kcalloc(MAX_BEARERS, sizeof(struct bearer), GFP_ATOMIC);
  579. media_list = kcalloc(MAX_MEDIA, sizeof(struct media), GFP_ATOMIC);
  580. if (tipc_bearers && media_list) {
  581. res = TIPC_OK;
  582. } else {
  583. kfree(tipc_bearers);
  584. kfree(media_list);
  585. tipc_bearers = NULL;
  586. media_list = NULL;
  587. res = -ENOMEM;
  588. }
  589. write_unlock_bh(&tipc_net_lock);
  590. return res;
  591. }
  592. void tipc_bearer_stop(void)
  593. {
  594. u32 i;
  595. if (!tipc_bearers)
  596. return;
  597. for (i = 0; i < MAX_BEARERS; i++) {
  598. if (tipc_bearers[i].active)
  599. tipc_bearers[i].publ.blocked = 1;
  600. }
  601. for (i = 0; i < MAX_BEARERS; i++) {
  602. if (tipc_bearers[i].active)
  603. bearer_disable(tipc_bearers[i].publ.name);
  604. }
  605. kfree(tipc_bearers);
  606. kfree(media_list);
  607. tipc_bearers = NULL;
  608. media_list = NULL;
  609. media_count = 0;
  610. }