]>
git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - net/tipc/name_table.c
2 * net/tipc/name_table.c: TIPC name table code
4 * Copyright (c) 2000-2006, Ericsson AB
5 * Copyright (c) 2004-2008, 2010-2011, Wind River Systems
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are met:
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.
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.
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.
39 #include "name_table.h"
40 #include "name_distr.h"
44 #define TIPC_NAMETBL_SIZE 1024 /* must be a power of 2 */
47 * struct name_info - name sequence publication info
48 * @node_list: circular list of publications made by own node
49 * @cluster_list: circular list of publications made by own cluster
50 * @zone_list: circular list of publications made by own zone
51 * @node_list_size: number of entries in "node_list"
52 * @cluster_list_size: number of entries in "cluster_list"
53 * @zone_list_size: number of entries in "zone_list"
55 * Note: The zone list always contains at least one entry, since all
56 * publications of the associated name sequence belong to it.
57 * (The cluster and node lists may be empty.)
60 struct list_head node_list
;
61 struct list_head cluster_list
;
62 struct list_head zone_list
;
64 u32 cluster_list_size
;
69 * struct sub_seq - container for all published instances of a name sequence
70 * @lower: name sequence lower bound
71 * @upper: name sequence upper bound
72 * @info: pointer to name sequence publication info
77 struct name_info
*info
;
81 * struct name_seq - container for all published instances of a name type
82 * @type: 32 bit 'type' value for name sequence
83 * @sseq: pointer to dynamically-sized array of sub-sequences of this 'type';
84 * sub-sequences are sorted in ascending order
85 * @alloc: number of sub-sequences currently in array
86 * @first_free: array index of first unused sub-sequence entry
87 * @ns_list: links to adjacent name sequences in hash chain
88 * @subscriptions: list of subscriptions for this 'type'
89 * @lock: spinlock controlling access to publication lists of all sub-sequences
93 struct sub_seq
*sseqs
;
96 struct hlist_node ns_list
;
97 struct list_head subscriptions
;
102 * struct name_table - table containing all existing port name publications
103 * @types: pointer to fixed-sized array of name sequence lists,
104 * accessed via hashing on 'type'; name sequence lists are *not* sorted
105 * @local_publ_count: number of publications issued by this node
108 struct hlist_head
*types
;
109 u32 local_publ_count
;
112 static struct name_table table
;
113 DEFINE_RWLOCK(tipc_nametbl_lock
);
115 static int hash(int x
)
117 return x
& (TIPC_NAMETBL_SIZE
- 1);
121 * publ_create - create a publication structure
123 static struct publication
*publ_create(u32 type
, u32 lower
, u32 upper
,
124 u32 scope
, u32 node
, u32 port_ref
,
127 struct publication
*publ
= kzalloc(sizeof(*publ
), GFP_ATOMIC
);
129 pr_warn("Publication creation failure, no memory\n");
138 publ
->ref
= port_ref
;
140 INIT_LIST_HEAD(&publ
->local_list
);
141 INIT_LIST_HEAD(&publ
->pport_list
);
142 INIT_LIST_HEAD(&publ
->subscr
.nodesub_list
);
147 * tipc_subseq_alloc - allocate a specified number of sub-sequence structures
149 static struct sub_seq
*tipc_subseq_alloc(u32 cnt
)
151 return kcalloc(cnt
, sizeof(struct sub_seq
), GFP_ATOMIC
);
155 * tipc_nameseq_create - create a name sequence structure for the specified 'type'
157 * Allocates a single sub-sequence structure and sets it to all 0's.
159 static struct name_seq
*tipc_nameseq_create(u32 type
, struct hlist_head
*seq_head
)
161 struct name_seq
*nseq
= kzalloc(sizeof(*nseq
), GFP_ATOMIC
);
162 struct sub_seq
*sseq
= tipc_subseq_alloc(1);
164 if (!nseq
|| !sseq
) {
165 pr_warn("Name sequence creation failed, no memory\n");
171 spin_lock_init(&nseq
->lock
);
175 INIT_HLIST_NODE(&nseq
->ns_list
);
176 INIT_LIST_HEAD(&nseq
->subscriptions
);
177 hlist_add_head(&nseq
->ns_list
, seq_head
);
182 * nameseq_delete_empty - deletes a name sequence structure if now unused
184 static void nameseq_delete_empty(struct name_seq
*seq
)
186 if (!seq
->first_free
&& list_empty(&seq
->subscriptions
)) {
187 hlist_del_init(&seq
->ns_list
);
194 * nameseq_find_subseq - find sub-sequence (if any) matching a name instance
196 * Very time-critical, so binary searches through sub-sequence array.
198 static struct sub_seq
*nameseq_find_subseq(struct name_seq
*nseq
,
201 struct sub_seq
*sseqs
= nseq
->sseqs
;
203 int high
= nseq
->first_free
- 1;
206 while (low
<= high
) {
207 mid
= (low
+ high
) / 2;
208 if (instance
< sseqs
[mid
].lower
)
210 else if (instance
> sseqs
[mid
].upper
)
219 * nameseq_locate_subseq - determine position of name instance in sub-sequence
221 * Returns index in sub-sequence array of the entry that contains the specified
222 * instance value; if no entry contains that value, returns the position
223 * where a new entry for it would be inserted in the array.
225 * Note: Similar to binary search code for locating a sub-sequence.
227 static u32
nameseq_locate_subseq(struct name_seq
*nseq
, u32 instance
)
229 struct sub_seq
*sseqs
= nseq
->sseqs
;
231 int high
= nseq
->first_free
- 1;
234 while (low
<= high
) {
235 mid
= (low
+ high
) / 2;
236 if (instance
< sseqs
[mid
].lower
)
238 else if (instance
> sseqs
[mid
].upper
)
247 * tipc_nameseq_insert_publ
249 static struct publication
*tipc_nameseq_insert_publ(struct name_seq
*nseq
,
250 u32 type
, u32 lower
, u32 upper
,
251 u32 scope
, u32 node
, u32 port
, u32 key
)
253 struct tipc_subscription
*s
;
254 struct tipc_subscription
*st
;
255 struct publication
*publ
;
256 struct sub_seq
*sseq
;
257 struct name_info
*info
;
258 int created_subseq
= 0;
260 sseq
= nameseq_find_subseq(nseq
, lower
);
263 /* Lower end overlaps existing entry => need an exact match */
264 if ((sseq
->lower
!= lower
) || (sseq
->upper
!= upper
)) {
265 pr_warn("Cannot publish {%u,%u,%u}, overlap error\n",
272 /* Check if an identical publication already exists */
273 list_for_each_entry(publ
, &info
->zone_list
, zone_list
) {
274 if ((publ
->ref
== port
) && (publ
->key
== key
) &&
275 (!publ
->node
|| (publ
->node
== node
)))
280 struct sub_seq
*freesseq
;
282 /* Find where lower end should be inserted */
283 inspos
= nameseq_locate_subseq(nseq
, lower
);
285 /* Fail if upper end overlaps into an existing entry */
286 if ((inspos
< nseq
->first_free
) &&
287 (upper
>= nseq
->sseqs
[inspos
].lower
)) {
288 pr_warn("Cannot publish {%u,%u,%u}, overlap error\n",
293 /* Ensure there is space for new sub-sequence */
294 if (nseq
->first_free
== nseq
->alloc
) {
295 struct sub_seq
*sseqs
= tipc_subseq_alloc(nseq
->alloc
* 2);
298 pr_warn("Cannot publish {%u,%u,%u}, no memory\n",
302 memcpy(sseqs
, nseq
->sseqs
,
303 nseq
->alloc
* sizeof(struct sub_seq
));
309 info
= kzalloc(sizeof(*info
), GFP_ATOMIC
);
311 pr_warn("Cannot publish {%u,%u,%u}, no memory\n",
316 INIT_LIST_HEAD(&info
->node_list
);
317 INIT_LIST_HEAD(&info
->cluster_list
);
318 INIT_LIST_HEAD(&info
->zone_list
);
320 /* Insert new sub-sequence */
321 sseq
= &nseq
->sseqs
[inspos
];
322 freesseq
= &nseq
->sseqs
[nseq
->first_free
];
323 memmove(sseq
+ 1, sseq
, (freesseq
- sseq
) * sizeof(*sseq
));
324 memset(sseq
, 0, sizeof(*sseq
));
332 /* Insert a publication */
333 publ
= publ_create(type
, lower
, upper
, scope
, node
, port
, key
);
337 list_add(&publ
->zone_list
, &info
->zone_list
);
338 info
->zone_list_size
++;
340 if (in_own_cluster(node
)) {
341 list_add(&publ
->cluster_list
, &info
->cluster_list
);
342 info
->cluster_list_size
++;
345 if (in_own_node(node
)) {
346 list_add(&publ
->node_list
, &info
->node_list
);
347 info
->node_list_size
++;
350 /* Any subscriptions waiting for notification? */
351 list_for_each_entry_safe(s
, st
, &nseq
->subscriptions
, nameseq_list
) {
352 tipc_subscr_report_overlap(s
,
364 * tipc_nameseq_remove_publ
366 * NOTE: There may be cases where TIPC is asked to remove a publication
367 * that is not in the name table. For example, if another node issues a
368 * publication for a name sequence that overlaps an existing name sequence
369 * the publication will not be recorded, which means the publication won't
370 * be found when the name sequence is later withdrawn by that node.
371 * A failed withdraw request simply returns a failure indication and lets the
372 * caller issue any error or warning messages associated with such a problem.
374 static struct publication
*tipc_nameseq_remove_publ(struct name_seq
*nseq
, u32 inst
,
375 u32 node
, u32 ref
, u32 key
)
377 struct publication
*publ
;
378 struct sub_seq
*sseq
= nameseq_find_subseq(nseq
, inst
);
379 struct name_info
*info
;
380 struct sub_seq
*free
;
381 struct tipc_subscription
*s
, *st
;
382 int removed_subseq
= 0;
389 /* Locate publication, if it exists */
390 list_for_each_entry(publ
, &info
->zone_list
, zone_list
) {
391 if ((publ
->key
== key
) && (publ
->ref
== ref
) &&
392 (!publ
->node
|| (publ
->node
== node
)))
398 /* Remove publication from zone scope list */
399 list_del(&publ
->zone_list
);
400 info
->zone_list_size
--;
402 /* Remove publication from cluster scope list, if present */
403 if (in_own_cluster(node
)) {
404 list_del(&publ
->cluster_list
);
405 info
->cluster_list_size
--;
408 /* Remove publication from node scope list, if present */
409 if (in_own_node(node
)) {
410 list_del(&publ
->node_list
);
411 info
->node_list_size
--;
414 /* Contract subseq list if no more publications for that subseq */
415 if (list_empty(&info
->zone_list
)) {
417 free
= &nseq
->sseqs
[nseq
->first_free
--];
418 memmove(sseq
, sseq
+ 1, (free
- (sseq
+ 1)) * sizeof(*sseq
));
422 /* Notify any waiting subscriptions */
423 list_for_each_entry_safe(s
, st
, &nseq
->subscriptions
, nameseq_list
) {
424 tipc_subscr_report_overlap(s
,
437 * tipc_nameseq_subscribe - attach a subscription, and issue
438 * the prescribed number of events if there is any sub-
439 * sequence overlapping with the requested sequence
441 static void tipc_nameseq_subscribe(struct name_seq
*nseq
,
442 struct tipc_subscription
*s
)
444 struct sub_seq
*sseq
= nseq
->sseqs
;
446 list_add(&s
->nameseq_list
, &nseq
->subscriptions
);
451 while (sseq
!= &nseq
->sseqs
[nseq
->first_free
]) {
452 if (tipc_subscr_overlap(s
, sseq
->lower
, sseq
->upper
)) {
453 struct publication
*crs
;
454 struct name_info
*info
= sseq
->info
;
457 list_for_each_entry(crs
, &info
->zone_list
, zone_list
) {
458 tipc_subscr_report_overlap(s
,
472 static struct name_seq
*nametbl_find_seq(u32 type
)
474 struct hlist_head
*seq_head
;
477 seq_head
= &table
.types
[hash(type
)];
478 hlist_for_each_entry(ns
, seq_head
, ns_list
) {
479 if (ns
->type
== type
)
486 struct publication
*tipc_nametbl_insert_publ(u32 type
, u32 lower
, u32 upper
,
487 u32 scope
, u32 node
, u32 port
, u32 key
)
489 struct name_seq
*seq
= nametbl_find_seq(type
);
491 if ((scope
< TIPC_ZONE_SCOPE
) || (scope
> TIPC_NODE_SCOPE
) ||
493 pr_debug("Failed to publish illegal {%u,%u,%u} with scope %u\n",
494 type
, lower
, upper
, scope
);
499 seq
= tipc_nameseq_create(type
, &table
.types
[hash(type
)]);
503 return tipc_nameseq_insert_publ(seq
, type
, lower
, upper
,
504 scope
, node
, port
, key
);
507 struct publication
*tipc_nametbl_remove_publ(u32 type
, u32 lower
,
508 u32 node
, u32 ref
, u32 key
)
510 struct publication
*publ
;
511 struct name_seq
*seq
= nametbl_find_seq(type
);
516 publ
= tipc_nameseq_remove_publ(seq
, lower
, node
, ref
, key
);
517 nameseq_delete_empty(seq
);
522 * tipc_nametbl_translate - perform name translation
524 * On entry, 'destnode' is the search domain used during translation.
527 * - if name translation is deferred to another node/cluster/zone,
528 * leaves 'destnode' unchanged (will be non-zero) and returns 0
529 * - if name translation is attempted and succeeds, sets 'destnode'
530 * to publishing node and returns port reference (will be non-zero)
531 * - if name translation is attempted and fails, sets 'destnode' to 0
534 u32
tipc_nametbl_translate(u32 type
, u32 instance
, u32
*destnode
)
536 struct sub_seq
*sseq
;
537 struct name_info
*info
;
538 struct publication
*publ
;
539 struct name_seq
*seq
;
543 if (!tipc_in_scope(*destnode
, tipc_own_addr
))
546 read_lock_bh(&tipc_nametbl_lock
);
547 seq
= nametbl_find_seq(type
);
550 sseq
= nameseq_find_subseq(seq
, instance
);
553 spin_lock_bh(&seq
->lock
);
556 /* Closest-First Algorithm */
557 if (likely(!*destnode
)) {
558 if (!list_empty(&info
->node_list
)) {
559 publ
= list_first_entry(&info
->node_list
,
562 list_move_tail(&publ
->node_list
,
564 } else if (!list_empty(&info
->cluster_list
)) {
565 publ
= list_first_entry(&info
->cluster_list
,
568 list_move_tail(&publ
->cluster_list
,
569 &info
->cluster_list
);
571 publ
= list_first_entry(&info
->zone_list
,
574 list_move_tail(&publ
->zone_list
,
579 /* Round-Robin Algorithm */
580 else if (*destnode
== tipc_own_addr
) {
581 if (list_empty(&info
->node_list
))
583 publ
= list_first_entry(&info
->node_list
, struct publication
,
585 list_move_tail(&publ
->node_list
, &info
->node_list
);
586 } else if (in_own_cluster_exact(*destnode
)) {
587 if (list_empty(&info
->cluster_list
))
589 publ
= list_first_entry(&info
->cluster_list
, struct publication
,
591 list_move_tail(&publ
->cluster_list
, &info
->cluster_list
);
593 publ
= list_first_entry(&info
->zone_list
, struct publication
,
595 list_move_tail(&publ
->zone_list
, &info
->zone_list
);
601 spin_unlock_bh(&seq
->lock
);
603 read_unlock_bh(&tipc_nametbl_lock
);
609 * tipc_nametbl_mc_translate - find multicast destinations
611 * Creates list of all local ports that overlap the given multicast address;
612 * also determines if any off-node ports overlap.
614 * Note: Publications with a scope narrower than 'limit' are ignored.
615 * (i.e. local node-scope publications mustn't receive messages arriving
616 * from another node, even if the multcast link brought it here)
618 * Returns non-zero if any off-node ports overlap
620 int tipc_nametbl_mc_translate(u32 type
, u32 lower
, u32 upper
, u32 limit
,
621 struct tipc_port_list
*dports
)
623 struct name_seq
*seq
;
624 struct sub_seq
*sseq
;
625 struct sub_seq
*sseq_stop
;
626 struct name_info
*info
;
629 read_lock_bh(&tipc_nametbl_lock
);
630 seq
= nametbl_find_seq(type
);
634 spin_lock_bh(&seq
->lock
);
636 sseq
= seq
->sseqs
+ nameseq_locate_subseq(seq
, lower
);
637 sseq_stop
= seq
->sseqs
+ seq
->first_free
;
638 for (; sseq
!= sseq_stop
; sseq
++) {
639 struct publication
*publ
;
641 if (sseq
->lower
> upper
)
645 list_for_each_entry(publ
, &info
->node_list
, node_list
) {
646 if (publ
->scope
<= limit
)
647 tipc_port_list_add(dports
, publ
->ref
);
650 if (info
->cluster_list_size
!= info
->node_list_size
)
654 spin_unlock_bh(&seq
->lock
);
656 read_unlock_bh(&tipc_nametbl_lock
);
661 * tipc_nametbl_publish - add name publication to network name tables
663 struct publication
*tipc_nametbl_publish(u32 type
, u32 lower
, u32 upper
,
664 u32 scope
, u32 port_ref
, u32 key
)
666 struct publication
*publ
;
668 if (table
.local_publ_count
>= TIPC_MAX_PUBLICATIONS
) {
669 pr_warn("Publication failed, local publication limit reached (%u)\n",
670 TIPC_MAX_PUBLICATIONS
);
674 write_lock_bh(&tipc_nametbl_lock
);
675 publ
= tipc_nametbl_insert_publ(type
, lower
, upper
, scope
,
676 tipc_own_addr
, port_ref
, key
);
678 table
.local_publ_count
++;
679 tipc_named_publish(publ
);
681 write_unlock_bh(&tipc_nametbl_lock
);
686 * tipc_nametbl_withdraw - withdraw name publication from network name tables
688 int tipc_nametbl_withdraw(u32 type
, u32 lower
, u32 ref
, u32 key
)
690 struct publication
*publ
;
692 write_lock_bh(&tipc_nametbl_lock
);
693 publ
= tipc_nametbl_remove_publ(type
, lower
, tipc_own_addr
, ref
, key
);
695 table
.local_publ_count
--;
696 tipc_named_withdraw(publ
);
697 write_unlock_bh(&tipc_nametbl_lock
);
698 list_del_init(&publ
->pport_list
);
702 write_unlock_bh(&tipc_nametbl_lock
);
703 pr_err("Unable to remove local publication\n"
704 "(type=%u, lower=%u, ref=%u, key=%u)\n",
705 type
, lower
, ref
, key
);
710 * tipc_nametbl_subscribe - add a subscription object to the name table
712 void tipc_nametbl_subscribe(struct tipc_subscription
*s
)
714 u32 type
= s
->seq
.type
;
715 struct name_seq
*seq
;
717 write_lock_bh(&tipc_nametbl_lock
);
718 seq
= nametbl_find_seq(type
);
720 seq
= tipc_nameseq_create(type
, &table
.types
[hash(type
)]);
722 spin_lock_bh(&seq
->lock
);
723 tipc_nameseq_subscribe(seq
, s
);
724 spin_unlock_bh(&seq
->lock
);
726 pr_warn("Failed to create subscription for {%u,%u,%u}\n",
727 s
->seq
.type
, s
->seq
.lower
, s
->seq
.upper
);
729 write_unlock_bh(&tipc_nametbl_lock
);
733 * tipc_nametbl_unsubscribe - remove a subscription object from name table
735 void tipc_nametbl_unsubscribe(struct tipc_subscription
*s
)
737 struct name_seq
*seq
;
739 write_lock_bh(&tipc_nametbl_lock
);
740 seq
= nametbl_find_seq(s
->seq
.type
);
742 spin_lock_bh(&seq
->lock
);
743 list_del_init(&s
->nameseq_list
);
744 spin_unlock_bh(&seq
->lock
);
745 nameseq_delete_empty(seq
);
747 write_unlock_bh(&tipc_nametbl_lock
);
752 * subseq_list - print specified sub-sequence contents into the given buffer
754 static int subseq_list(struct sub_seq
*sseq
, char *buf
, int len
, u32 depth
,
758 const char *scope_str
[] = {"", " zone", " cluster", " node"};
759 struct publication
*publ
;
760 struct name_info
*info
;
763 ret
= tipc_snprintf(buf
, len
, "%-10u %-10u ", sseq
->lower
, sseq
->upper
);
766 ret
+= tipc_snprintf(buf
- ret
, len
+ ret
, "\n");
772 list_for_each_entry(publ
, &info
->zone_list
, zone_list
) {
773 sprintf(portIdStr
, "<%u.%u.%u:%u>",
774 tipc_zone(publ
->node
), tipc_cluster(publ
->node
),
775 tipc_node(publ
->node
), publ
->ref
);
776 ret
+= tipc_snprintf(buf
+ ret
, len
- ret
, "%-26s ", portIdStr
);
778 ret
+= tipc_snprintf(buf
+ ret
, len
- ret
, "%-10u %s",
779 publ
->key
, scope_str
[publ
->scope
]);
781 if (!list_is_last(&publ
->zone_list
, &info
->zone_list
))
782 ret
+= tipc_snprintf(buf
+ ret
, len
- ret
,
786 ret
+= tipc_snprintf(buf
+ ret
, len
- ret
, "\n");
791 * nameseq_list - print specified name sequence contents into the given buffer
793 static int nameseq_list(struct name_seq
*seq
, char *buf
, int len
, u32 depth
,
794 u32 type
, u32 lowbound
, u32 upbound
, u32 index
)
796 struct sub_seq
*sseq
;
800 if (seq
->first_free
== 0)
803 sprintf(typearea
, "%-10u", seq
->type
);
806 ret
+= tipc_snprintf(buf
, len
, "%s\n", typearea
);
810 for (sseq
= seq
->sseqs
; sseq
!= &seq
->sseqs
[seq
->first_free
]; sseq
++) {
811 if ((lowbound
<= sseq
->upper
) && (upbound
>= sseq
->lower
)) {
812 ret
+= tipc_snprintf(buf
+ ret
, len
- ret
, "%s ",
814 spin_lock_bh(&seq
->lock
);
815 ret
+= subseq_list(sseq
, buf
+ ret
, len
- ret
,
817 spin_unlock_bh(&seq
->lock
);
818 sprintf(typearea
, "%10s", " ");
825 * nametbl_header - print name table header into the given buffer
827 static int nametbl_header(char *buf
, int len
, u32 depth
)
829 const char *header
[] = {
841 for (i
= 0; i
< depth
; i
++)
842 ret
+= tipc_snprintf(buf
+ ret
, len
- ret
, header
[i
]);
843 ret
+= tipc_snprintf(buf
+ ret
, len
- ret
, "\n");
848 * nametbl_list - print specified name table contents into the given buffer
850 static int nametbl_list(char *buf
, int len
, u32 depth_info
,
851 u32 type
, u32 lowbound
, u32 upbound
)
853 struct hlist_head
*seq_head
;
854 struct name_seq
*seq
;
860 all_types
= (depth_info
& TIPC_NTQ_ALLTYPES
);
861 depth
= (depth_info
& ~TIPC_NTQ_ALLTYPES
);
867 /* display all entries in name table to specified depth */
868 ret
+= nametbl_header(buf
, len
, depth
);
871 for (i
= 0; i
< TIPC_NAMETBL_SIZE
; i
++) {
872 seq_head
= &table
.types
[i
];
873 hlist_for_each_entry(seq
, seq_head
, ns_list
) {
874 ret
+= nameseq_list(seq
, buf
+ ret
, len
- ret
,
876 lowbound
, upbound
, i
);
880 /* display only the sequence that matches the specified type */
881 if (upbound
< lowbound
) {
882 ret
+= tipc_snprintf(buf
+ ret
, len
- ret
,
883 "invalid name sequence specified\n");
886 ret
+= nametbl_header(buf
+ ret
, len
- ret
, depth
);
888 seq_head
= &table
.types
[i
];
889 hlist_for_each_entry(seq
, seq_head
, ns_list
) {
890 if (seq
->type
== type
) {
891 ret
+= nameseq_list(seq
, buf
+ ret
, len
- ret
,
893 lowbound
, upbound
, i
);
901 struct sk_buff
*tipc_nametbl_get(const void *req_tlv_area
, int req_tlv_space
)
904 struct tipc_name_table_query
*argv
;
905 struct tlv_desc
*rep_tlv
;
910 if (!TLV_CHECK(req_tlv_area
, req_tlv_space
, TIPC_TLV_NAME_TBL_QUERY
))
911 return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR
);
913 buf
= tipc_cfg_reply_alloc(TLV_SPACE(ULTRA_STRING_MAX_LEN
));
917 rep_tlv
= (struct tlv_desc
*)buf
->data
;
918 pb
= TLV_DATA(rep_tlv
);
919 pb_len
= ULTRA_STRING_MAX_LEN
;
920 argv
= (struct tipc_name_table_query
*)TLV_DATA(req_tlv_area
);
921 read_lock_bh(&tipc_nametbl_lock
);
922 str_len
= nametbl_list(pb
, pb_len
, ntohl(argv
->depth
),
924 ntohl(argv
->lowbound
), ntohl(argv
->upbound
));
925 read_unlock_bh(&tipc_nametbl_lock
);
926 str_len
+= 1; /* for "\0" */
927 skb_put(buf
, TLV_SPACE(str_len
));
928 TLV_SET(rep_tlv
, TIPC_TLV_ULTRA_STRING
, NULL
, str_len
);
933 int tipc_nametbl_init(void)
935 table
.types
= kcalloc(TIPC_NAMETBL_SIZE
, sizeof(struct hlist_head
),
940 table
.local_publ_count
= 0;
945 * tipc_purge_publications - remove all publications for a given type
947 * tipc_nametbl_lock must be held when calling this function
949 static void tipc_purge_publications(struct name_seq
*seq
)
951 struct publication
*publ
, *safe
;
952 struct sub_seq
*sseq
;
953 struct name_info
*info
;
956 nameseq_delete_empty(seq
);
961 list_for_each_entry_safe(publ
, safe
, &info
->zone_list
, zone_list
) {
962 tipc_nametbl_remove_publ(publ
->type
, publ
->lower
, publ
->node
,
963 publ
->ref
, publ
->key
);
967 void tipc_nametbl_stop(void)
970 struct name_seq
*seq
;
971 struct hlist_head
*seq_head
;
972 struct hlist_node
*safe
;
974 /* Verify name table is empty and purge any lingering
975 * publications, then release the name table
977 write_lock_bh(&tipc_nametbl_lock
);
978 for (i
= 0; i
< TIPC_NAMETBL_SIZE
; i
++) {
979 if (hlist_empty(&table
.types
[i
]))
981 seq_head
= &table
.types
[i
];
982 hlist_for_each_entry_safe(seq
, safe
, seq_head
, ns_list
) {
983 tipc_purge_publications(seq
);
989 write_unlock_bh(&tipc_nametbl_lock
);