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"
43 #define TIPC_NAMETBL_SIZE 1024 /* must be a power of 2 */
46 * struct name_info - name sequence publication info
47 * @node_list: circular list of publications made by own node
48 * @cluster_list: circular list of publications made by own cluster
49 * @zone_list: circular list of publications made by own zone
50 * @node_list_size: number of entries in "node_list"
51 * @cluster_list_size: number of entries in "cluster_list"
52 * @zone_list_size: number of entries in "zone_list"
54 * Note: The zone list always contains at least one entry, since all
55 * publications of the associated name sequence belong to it.
56 * (The cluster and node lists may be empty.)
59 struct list_head node_list;
60 struct list_head cluster_list;
61 struct list_head zone_list;
63 u32 cluster_list_size;
68 * struct sub_seq - container for all published instances of a name sequence
69 * @lower: name sequence lower bound
70 * @upper: name sequence upper bound
71 * @info: pointer to name sequence publication info
76 struct name_info *info;
80 * struct name_seq - container for all published instances of a name type
81 * @type: 32 bit 'type' value for name sequence
82 * @sseq: pointer to dynamically-sized array of sub-sequences of this 'type';
83 * sub-sequences are sorted in ascending order
84 * @alloc: number of sub-sequences currently in array
85 * @first_free: array index of first unused sub-sequence entry
86 * @ns_list: links to adjacent name sequences in hash chain
87 * @subscriptions: list of subscriptions for this 'type'
88 * @lock: spinlock controlling access to publication lists of all sub-sequences
92 struct sub_seq *sseqs;
95 struct hlist_node ns_list;
96 struct list_head subscriptions;
101 * struct name_table - table containing all existing port name publications
102 * @types: pointer to fixed-sized array of name sequence lists,
103 * accessed via hashing on 'type'; name sequence lists are *not* sorted
104 * @local_publ_count: number of publications issued by this node
107 struct hlist_head *types;
108 u32 local_publ_count;
111 static struct name_table table;
112 DEFINE_RWLOCK(tipc_nametbl_lock);
114 static int hash(int x)
116 return x & (TIPC_NAMETBL_SIZE - 1);
120 * publ_create - create a publication structure
122 static struct publication *publ_create(u32 type, u32 lower, u32 upper,
123 u32 scope, u32 node, u32 port_ref,
126 struct publication *publ = kzalloc(sizeof(*publ), GFP_ATOMIC);
128 pr_warn("Publication creation failure, no memory\n");
137 publ->ref = port_ref;
139 INIT_LIST_HEAD(&publ->local_list);
140 INIT_LIST_HEAD(&publ->pport_list);
141 INIT_LIST_HEAD(&publ->subscr.nodesub_list);
146 * tipc_subseq_alloc - allocate a specified number of sub-sequence structures
148 static struct sub_seq *tipc_subseq_alloc(u32 cnt)
150 return kcalloc(cnt, sizeof(struct sub_seq), GFP_ATOMIC);
154 * tipc_nameseq_create - create a name sequence structure for the specified 'type'
156 * Allocates a single sub-sequence structure and sets it to all 0's.
158 static struct name_seq *tipc_nameseq_create(u32 type, struct hlist_head *seq_head)
160 struct name_seq *nseq = kzalloc(sizeof(*nseq), GFP_ATOMIC);
161 struct sub_seq *sseq = tipc_subseq_alloc(1);
163 if (!nseq || !sseq) {
164 pr_warn("Name sequence creation failed, no memory\n");
170 spin_lock_init(&nseq->lock);
174 INIT_HLIST_NODE(&nseq->ns_list);
175 INIT_LIST_HEAD(&nseq->subscriptions);
176 hlist_add_head(&nseq->ns_list, seq_head);
181 * nameseq_delete_empty - deletes a name sequence structure if now unused
183 static void nameseq_delete_empty(struct name_seq *seq)
185 if (!seq->first_free && list_empty(&seq->subscriptions)) {
186 hlist_del_init(&seq->ns_list);
193 * nameseq_find_subseq - find sub-sequence (if any) matching a name instance
195 * Very time-critical, so binary searches through sub-sequence array.
197 static struct sub_seq *nameseq_find_subseq(struct name_seq *nseq,
200 struct sub_seq *sseqs = nseq->sseqs;
202 int high = nseq->first_free - 1;
205 while (low <= high) {
206 mid = (low + high) / 2;
207 if (instance < sseqs[mid].lower)
209 else if (instance > sseqs[mid].upper)
218 * nameseq_locate_subseq - determine position of name instance in sub-sequence
220 * Returns index in sub-sequence array of the entry that contains the specified
221 * instance value; if no entry contains that value, returns the position
222 * where a new entry for it would be inserted in the array.
224 * Note: Similar to binary search code for locating a sub-sequence.
226 static u32 nameseq_locate_subseq(struct name_seq *nseq, u32 instance)
228 struct sub_seq *sseqs = nseq->sseqs;
230 int high = nseq->first_free - 1;
233 while (low <= high) {
234 mid = (low + high) / 2;
235 if (instance < sseqs[mid].lower)
237 else if (instance > sseqs[mid].upper)
246 * tipc_nameseq_insert_publ
248 static struct publication *tipc_nameseq_insert_publ(struct name_seq *nseq,
249 u32 type, u32 lower, u32 upper,
250 u32 scope, u32 node, u32 port, u32 key)
252 struct tipc_subscription *s;
253 struct tipc_subscription *st;
254 struct publication *publ;
255 struct sub_seq *sseq;
256 struct name_info *info;
257 int created_subseq = 0;
259 sseq = nameseq_find_subseq(nseq, lower);
262 /* Lower end overlaps existing entry => need an exact match */
263 if ((sseq->lower != lower) || (sseq->upper != upper)) {
269 /* Check if an identical publication already exists */
270 list_for_each_entry(publ, &info->zone_list, zone_list) {
271 if ((publ->ref == port) && (publ->key == key) &&
272 (!publ->node || (publ->node == node)))
277 struct sub_seq *freesseq;
279 /* Find where lower end should be inserted */
280 inspos = nameseq_locate_subseq(nseq, lower);
282 /* Fail if upper end overlaps into an existing entry */
283 if ((inspos < nseq->first_free) &&
284 (upper >= nseq->sseqs[inspos].lower)) {
288 /* Ensure there is space for new sub-sequence */
289 if (nseq->first_free == nseq->alloc) {
290 struct sub_seq *sseqs = tipc_subseq_alloc(nseq->alloc * 2);
293 pr_warn("Cannot publish {%u,%u,%u}, no memory\n",
297 memcpy(sseqs, nseq->sseqs,
298 nseq->alloc * sizeof(struct sub_seq));
304 info = kzalloc(sizeof(*info), GFP_ATOMIC);
306 pr_warn("Cannot publish {%u,%u,%u}, no memory\n",
311 INIT_LIST_HEAD(&info->node_list);
312 INIT_LIST_HEAD(&info->cluster_list);
313 INIT_LIST_HEAD(&info->zone_list);
315 /* Insert new sub-sequence */
316 sseq = &nseq->sseqs[inspos];
317 freesseq = &nseq->sseqs[nseq->first_free];
318 memmove(sseq + 1, sseq, (freesseq - sseq) * sizeof(*sseq));
319 memset(sseq, 0, sizeof(*sseq));
327 /* Insert a publication */
328 publ = publ_create(type, lower, upper, scope, node, port, key);
332 list_add(&publ->zone_list, &info->zone_list);
333 info->zone_list_size++;
335 if (in_own_cluster(node)) {
336 list_add(&publ->cluster_list, &info->cluster_list);
337 info->cluster_list_size++;
340 if (in_own_node(node)) {
341 list_add(&publ->node_list, &info->node_list);
342 info->node_list_size++;
345 /* Any subscriptions waiting for notification? */
346 list_for_each_entry_safe(s, st, &nseq->subscriptions, nameseq_list) {
347 tipc_subscr_report_overlap(s,
359 * tipc_nameseq_remove_publ
361 * NOTE: There may be cases where TIPC is asked to remove a publication
362 * that is not in the name table. For example, if another node issues a
363 * publication for a name sequence that overlaps an existing name sequence
364 * the publication will not be recorded, which means the publication won't
365 * be found when the name sequence is later withdrawn by that node.
366 * A failed withdraw request simply returns a failure indication and lets the
367 * caller issue any error or warning messages associated with such a problem.
369 static struct publication *tipc_nameseq_remove_publ(struct name_seq *nseq, u32 inst,
370 u32 node, u32 ref, u32 key)
372 struct publication *publ;
373 struct sub_seq *sseq = nameseq_find_subseq(nseq, inst);
374 struct name_info *info;
375 struct sub_seq *free;
376 struct tipc_subscription *s, *st;
377 int removed_subseq = 0;
384 /* Locate publication, if it exists */
385 list_for_each_entry(publ, &info->zone_list, zone_list) {
386 if ((publ->key == key) && (publ->ref == ref) &&
387 (!publ->node || (publ->node == node)))
393 /* Remove publication from zone scope list */
394 list_del(&publ->zone_list);
395 info->zone_list_size--;
397 /* Remove publication from cluster scope list, if present */
398 if (in_own_cluster(node)) {
399 list_del(&publ->cluster_list);
400 info->cluster_list_size--;
403 /* Remove publication from node scope list, if present */
404 if (in_own_node(node)) {
405 list_del(&publ->node_list);
406 info->node_list_size--;
409 /* Contract subseq list if no more publications for that subseq */
410 if (list_empty(&info->zone_list)) {
412 free = &nseq->sseqs[nseq->first_free--];
413 memmove(sseq, sseq + 1, (free - (sseq + 1)) * sizeof(*sseq));
417 /* Notify any waiting subscriptions */
418 list_for_each_entry_safe(s, st, &nseq->subscriptions, nameseq_list) {
419 tipc_subscr_report_overlap(s,
432 * tipc_nameseq_subscribe - attach a subscription, and issue
433 * the prescribed number of events if there is any sub-
434 * sequence overlapping with the requested sequence
436 static void tipc_nameseq_subscribe(struct name_seq *nseq,
437 struct tipc_subscription *s)
439 struct sub_seq *sseq = nseq->sseqs;
441 list_add(&s->nameseq_list, &nseq->subscriptions);
446 while (sseq != &nseq->sseqs[nseq->first_free]) {
447 if (tipc_subscr_overlap(s, sseq->lower, sseq->upper)) {
448 struct publication *crs;
449 struct name_info *info = sseq->info;
452 list_for_each_entry(crs, &info->zone_list, zone_list) {
453 tipc_subscr_report_overlap(s,
467 static struct name_seq *nametbl_find_seq(u32 type)
469 struct hlist_head *seq_head;
472 seq_head = &table.types[hash(type)];
473 hlist_for_each_entry(ns, seq_head, ns_list) {
474 if (ns->type == type)
481 struct publication *tipc_nametbl_insert_publ(u32 type, u32 lower, u32 upper,
482 u32 scope, u32 node, u32 port, u32 key)
484 struct name_seq *seq = nametbl_find_seq(type);
486 if ((scope < TIPC_ZONE_SCOPE) || (scope > TIPC_NODE_SCOPE) ||
488 pr_debug("Failed to publish illegal {%u,%u,%u} with scope %u\n",
489 type, lower, upper, scope);
494 seq = tipc_nameseq_create(type, &table.types[hash(type)]);
498 return tipc_nameseq_insert_publ(seq, type, lower, upper,
499 scope, node, port, key);
502 struct publication *tipc_nametbl_remove_publ(u32 type, u32 lower,
503 u32 node, u32 ref, u32 key)
505 struct publication *publ;
506 struct name_seq *seq = nametbl_find_seq(type);
511 publ = tipc_nameseq_remove_publ(seq, lower, node, ref, key);
512 nameseq_delete_empty(seq);
517 * tipc_nametbl_translate - perform name translation
519 * On entry, 'destnode' is the search domain used during translation.
522 * - if name translation is deferred to another node/cluster/zone,
523 * leaves 'destnode' unchanged (will be non-zero) and returns 0
524 * - if name translation is attempted and succeeds, sets 'destnode'
525 * to publishing node and returns port reference (will be non-zero)
526 * - if name translation is attempted and fails, sets 'destnode' to 0
529 u32 tipc_nametbl_translate(u32 type, u32 instance, u32 *destnode)
531 struct sub_seq *sseq;
532 struct name_info *info;
533 struct publication *publ;
534 struct name_seq *seq;
538 if (!tipc_in_scope(*destnode, tipc_own_addr))
541 read_lock_bh(&tipc_nametbl_lock);
542 seq = nametbl_find_seq(type);
545 sseq = nameseq_find_subseq(seq, instance);
548 spin_lock_bh(&seq->lock);
551 /* Closest-First Algorithm */
552 if (likely(!*destnode)) {
553 if (!list_empty(&info->node_list)) {
554 publ = list_first_entry(&info->node_list,
557 list_move_tail(&publ->node_list,
559 } else if (!list_empty(&info->cluster_list)) {
560 publ = list_first_entry(&info->cluster_list,
563 list_move_tail(&publ->cluster_list,
564 &info->cluster_list);
566 publ = list_first_entry(&info->zone_list,
569 list_move_tail(&publ->zone_list,
574 /* Round-Robin Algorithm */
575 else if (*destnode == tipc_own_addr) {
576 if (list_empty(&info->node_list))
578 publ = list_first_entry(&info->node_list, struct publication,
580 list_move_tail(&publ->node_list, &info->node_list);
581 } else if (in_own_cluster_exact(*destnode)) {
582 if (list_empty(&info->cluster_list))
584 publ = list_first_entry(&info->cluster_list, struct publication,
586 list_move_tail(&publ->cluster_list, &info->cluster_list);
588 publ = list_first_entry(&info->zone_list, struct publication,
590 list_move_tail(&publ->zone_list, &info->zone_list);
596 spin_unlock_bh(&seq->lock);
598 read_unlock_bh(&tipc_nametbl_lock);
604 * tipc_nametbl_mc_translate - find multicast destinations
606 * Creates list of all local ports that overlap the given multicast address;
607 * also determines if any off-node ports overlap.
609 * Note: Publications with a scope narrower than 'limit' are ignored.
610 * (i.e. local node-scope publications mustn't receive messages arriving
611 * from another node, even if the multcast link brought it here)
613 * Returns non-zero if any off-node ports overlap
615 int tipc_nametbl_mc_translate(u32 type, u32 lower, u32 upper, u32 limit,
616 struct tipc_port_list *dports)
618 struct name_seq *seq;
619 struct sub_seq *sseq;
620 struct sub_seq *sseq_stop;
621 struct name_info *info;
624 read_lock_bh(&tipc_nametbl_lock);
625 seq = nametbl_find_seq(type);
629 spin_lock_bh(&seq->lock);
631 sseq = seq->sseqs + nameseq_locate_subseq(seq, lower);
632 sseq_stop = seq->sseqs + seq->first_free;
633 for (; sseq != sseq_stop; sseq++) {
634 struct publication *publ;
636 if (sseq->lower > upper)
640 list_for_each_entry(publ, &info->node_list, node_list) {
641 if (publ->scope <= limit)
642 tipc_port_list_add(dports, publ->ref);
645 if (info->cluster_list_size != info->node_list_size)
649 spin_unlock_bh(&seq->lock);
651 read_unlock_bh(&tipc_nametbl_lock);
656 * tipc_nametbl_publish - add name publication to network name tables
658 struct publication *tipc_nametbl_publish(u32 type, u32 lower, u32 upper,
659 u32 scope, u32 port_ref, u32 key)
661 struct publication *publ;
662 struct sk_buff *buf = NULL;
664 if (table.local_publ_count >= TIPC_MAX_PUBLICATIONS) {
665 pr_warn("Publication failed, local publication limit reached (%u)\n",
666 TIPC_MAX_PUBLICATIONS);
670 write_lock_bh(&tipc_nametbl_lock);
671 publ = tipc_nametbl_insert_publ(type, lower, upper, scope,
672 tipc_own_addr, port_ref, key);
674 table.local_publ_count++;
675 buf = tipc_named_publish(publ);
676 /* Any pending external events? */
677 tipc_named_process_backlog();
679 write_unlock_bh(&tipc_nametbl_lock);
682 named_cluster_distribute(buf);
687 * tipc_nametbl_withdraw - withdraw name publication from network name tables
689 int tipc_nametbl_withdraw(u32 type, u32 lower, u32 ref, u32 key)
691 struct publication *publ;
694 write_lock_bh(&tipc_nametbl_lock);
695 publ = tipc_nametbl_remove_publ(type, lower, tipc_own_addr, ref, key);
697 table.local_publ_count--;
698 buf = tipc_named_withdraw(publ);
699 /* Any pending external events? */
700 tipc_named_process_backlog();
701 write_unlock_bh(&tipc_nametbl_lock);
702 list_del_init(&publ->pport_list);
706 named_cluster_distribute(buf);
709 write_unlock_bh(&tipc_nametbl_lock);
710 pr_err("Unable to remove local publication\n"
711 "(type=%u, lower=%u, ref=%u, key=%u)\n",
712 type, lower, ref, key);
717 * tipc_nametbl_subscribe - add a subscription object to the name table
719 void tipc_nametbl_subscribe(struct tipc_subscription *s)
721 u32 type = s->seq.type;
722 struct name_seq *seq;
724 write_lock_bh(&tipc_nametbl_lock);
725 seq = nametbl_find_seq(type);
727 seq = tipc_nameseq_create(type, &table.types[hash(type)]);
729 spin_lock_bh(&seq->lock);
730 tipc_nameseq_subscribe(seq, s);
731 spin_unlock_bh(&seq->lock);
733 pr_warn("Failed to create subscription for {%u,%u,%u}\n",
734 s->seq.type, s->seq.lower, s->seq.upper);
736 write_unlock_bh(&tipc_nametbl_lock);
740 * tipc_nametbl_unsubscribe - remove a subscription object from name table
742 void tipc_nametbl_unsubscribe(struct tipc_subscription *s)
744 struct name_seq *seq;
746 write_lock_bh(&tipc_nametbl_lock);
747 seq = nametbl_find_seq(s->seq.type);
749 spin_lock_bh(&seq->lock);
750 list_del_init(&s->nameseq_list);
751 spin_unlock_bh(&seq->lock);
752 nameseq_delete_empty(seq);
754 write_unlock_bh(&tipc_nametbl_lock);
759 * subseq_list - print specified sub-sequence contents into the given buffer
761 static int subseq_list(struct sub_seq *sseq, char *buf, int len, u32 depth,
765 const char *scope_str[] = {"", " zone", " cluster", " node"};
766 struct publication *publ;
767 struct name_info *info;
770 ret = tipc_snprintf(buf, len, "%-10u %-10u ", sseq->lower, sseq->upper);
773 ret += tipc_snprintf(buf - ret, len + ret, "\n");
779 list_for_each_entry(publ, &info->zone_list, zone_list) {
780 sprintf(portIdStr, "<%u.%u.%u:%u>",
781 tipc_zone(publ->node), tipc_cluster(publ->node),
782 tipc_node(publ->node), publ->ref);
783 ret += tipc_snprintf(buf + ret, len - ret, "%-26s ", portIdStr);
785 ret += tipc_snprintf(buf + ret, len - ret, "%-10u %s",
786 publ->key, scope_str[publ->scope]);
788 if (!list_is_last(&publ->zone_list, &info->zone_list))
789 ret += tipc_snprintf(buf + ret, len - ret,
793 ret += tipc_snprintf(buf + ret, len - ret, "\n");
798 * nameseq_list - print specified name sequence contents into the given buffer
800 static int nameseq_list(struct name_seq *seq, char *buf, int len, u32 depth,
801 u32 type, u32 lowbound, u32 upbound, u32 index)
803 struct sub_seq *sseq;
807 if (seq->first_free == 0)
810 sprintf(typearea, "%-10u", seq->type);
813 ret += tipc_snprintf(buf, len, "%s\n", typearea);
817 for (sseq = seq->sseqs; sseq != &seq->sseqs[seq->first_free]; sseq++) {
818 if ((lowbound <= sseq->upper) && (upbound >= sseq->lower)) {
819 ret += tipc_snprintf(buf + ret, len - ret, "%s ",
821 spin_lock_bh(&seq->lock);
822 ret += subseq_list(sseq, buf + ret, len - ret,
824 spin_unlock_bh(&seq->lock);
825 sprintf(typearea, "%10s", " ");
832 * nametbl_header - print name table header into the given buffer
834 static int nametbl_header(char *buf, int len, u32 depth)
836 const char *header[] = {
848 for (i = 0; i < depth; i++)
849 ret += tipc_snprintf(buf + ret, len - ret, header[i]);
850 ret += tipc_snprintf(buf + ret, len - ret, "\n");
855 * nametbl_list - print specified name table contents into the given buffer
857 static int nametbl_list(char *buf, int len, u32 depth_info,
858 u32 type, u32 lowbound, u32 upbound)
860 struct hlist_head *seq_head;
861 struct name_seq *seq;
867 all_types = (depth_info & TIPC_NTQ_ALLTYPES);
868 depth = (depth_info & ~TIPC_NTQ_ALLTYPES);
874 /* display all entries in name table to specified depth */
875 ret += nametbl_header(buf, len, depth);
878 for (i = 0; i < TIPC_NAMETBL_SIZE; i++) {
879 seq_head = &table.types[i];
880 hlist_for_each_entry(seq, seq_head, ns_list) {
881 ret += nameseq_list(seq, buf + ret, len - ret,
883 lowbound, upbound, i);
887 /* display only the sequence that matches the specified type */
888 if (upbound < lowbound) {
889 ret += tipc_snprintf(buf + ret, len - ret,
890 "invalid name sequence specified\n");
893 ret += nametbl_header(buf + ret, len - ret, depth);
895 seq_head = &table.types[i];
896 hlist_for_each_entry(seq, seq_head, ns_list) {
897 if (seq->type == type) {
898 ret += nameseq_list(seq, buf + ret, len - ret,
900 lowbound, upbound, i);
908 struct sk_buff *tipc_nametbl_get(const void *req_tlv_area, int req_tlv_space)
911 struct tipc_name_table_query *argv;
912 struct tlv_desc *rep_tlv;
917 if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_NAME_TBL_QUERY))
918 return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
920 buf = tipc_cfg_reply_alloc(TLV_SPACE(ULTRA_STRING_MAX_LEN));
924 rep_tlv = (struct tlv_desc *)buf->data;
925 pb = TLV_DATA(rep_tlv);
926 pb_len = ULTRA_STRING_MAX_LEN;
927 argv = (struct tipc_name_table_query *)TLV_DATA(req_tlv_area);
928 read_lock_bh(&tipc_nametbl_lock);
929 str_len = nametbl_list(pb, pb_len, ntohl(argv->depth),
931 ntohl(argv->lowbound), ntohl(argv->upbound));
932 read_unlock_bh(&tipc_nametbl_lock);
933 str_len += 1; /* for "\0" */
934 skb_put(buf, TLV_SPACE(str_len));
935 TLV_SET(rep_tlv, TIPC_TLV_ULTRA_STRING, NULL, str_len);
940 int tipc_nametbl_init(void)
942 table.types = kcalloc(TIPC_NAMETBL_SIZE, sizeof(struct hlist_head),
947 table.local_publ_count = 0;
952 * tipc_purge_publications - remove all publications for a given type
954 * tipc_nametbl_lock must be held when calling this function
956 static void tipc_purge_publications(struct name_seq *seq)
958 struct publication *publ, *safe;
959 struct sub_seq *sseq;
960 struct name_info *info;
963 nameseq_delete_empty(seq);
968 list_for_each_entry_safe(publ, safe, &info->zone_list, zone_list) {
969 tipc_nametbl_remove_publ(publ->type, publ->lower, publ->node,
970 publ->ref, publ->key);
975 void tipc_nametbl_stop(void)
978 struct name_seq *seq;
979 struct hlist_head *seq_head;
980 struct hlist_node *safe;
982 /* Verify name table is empty and purge any lingering
983 * publications, then release the name table
985 write_lock_bh(&tipc_nametbl_lock);
986 for (i = 0; i < TIPC_NAMETBL_SIZE; i++) {
987 if (hlist_empty(&table.types[i]))
989 seq_head = &table.types[i];
990 hlist_for_each_entry_safe(seq, safe, seq_head, ns_list) {
991 tipc_purge_publications(seq);
996 write_unlock_bh(&tipc_nametbl_lock);