Root/
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 = 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 | |
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 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 | * 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 0; |
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 = 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 | |
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 | |
706 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9