2 * net/tipc/name_table.c: TIPC name table code
4 * Copyright (c) 2000-2006, Ericsson AB
5 * Copyright (c) 2004-2008, 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 static int tipc_nametbl_size
= 1024; /* must be a power of 2 */
47 * struct sub_seq - container for all published instances of a name sequence
48 * @lower: name sequence lower bound
49 * @upper: name sequence upper bound
50 * @node_list: circular list of publications made by own node
51 * @cluster_list: circular list of publications made by own cluster
52 * @zone_list: circular list of publications made by own zone
53 * @node_list_size: number of entries in "node_list"
54 * @cluster_list_size: number of entries in "cluster_list"
55 * @zone_list_size: number of entries in "zone_list"
57 * Note: The zone list always contains at least one entry, since all
58 * publications of the associated name sequence belong to it.
59 * (The cluster and node lists may be empty.)
65 struct publication
*node_list
;
66 struct publication
*cluster_list
;
67 struct publication
*zone_list
;
69 u32 cluster_list_size
;
74 * struct name_seq - container for all published instances of a name type
75 * @type: 32 bit 'type' value for name sequence
76 * @sseq: pointer to dynamically-sized array of sub-sequences of this 'type';
77 * sub-sequences are sorted in ascending order
78 * @alloc: number of sub-sequences currently in array
79 * @first_free: array index of first unused sub-sequence entry
80 * @ns_list: links to adjacent name sequences in hash chain
81 * @subscriptions: list of subscriptions for this 'type'
82 * @lock: spinlock controlling access to publication lists of all sub-sequences
87 struct sub_seq
*sseqs
;
90 struct hlist_node ns_list
;
91 struct list_head subscriptions
;
96 * struct name_table - table containing all existing port name publications
97 * @types: pointer to fixed-sized array of name sequence lists,
98 * accessed via hashing on 'type'; name sequence lists are *not* sorted
99 * @local_publ_count: number of publications issued by this node
103 struct hlist_head
*types
;
104 u32 local_publ_count
;
107 static struct name_table table
= { NULL
} ;
108 static atomic_t rsv_publ_ok
= ATOMIC_INIT(0);
109 DEFINE_RWLOCK(tipc_nametbl_lock
);
112 static int hash(int x
)
114 return x
& (tipc_nametbl_size
- 1);
118 * publ_create - create a publication structure
121 static struct publication
*publ_create(u32 type
, u32 lower
, u32 upper
,
122 u32 scope
, u32 node
, u32 port_ref
,
125 struct publication
*publ
= kzalloc(sizeof(*publ
), GFP_ATOMIC
);
127 warn("Publication creation failure, no memory\n");
136 publ
->ref
= port_ref
;
138 INIT_LIST_HEAD(&publ
->local_list
);
139 INIT_LIST_HEAD(&publ
->pport_list
);
140 INIT_LIST_HEAD(&publ
->subscr
.nodesub_list
);
145 * tipc_subseq_alloc - allocate a specified number of sub-sequence structures
148 static struct sub_seq
*tipc_subseq_alloc(u32 cnt
)
150 struct sub_seq
*sseq
= 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.
160 static struct name_seq
*tipc_nameseq_create(u32 type
, struct hlist_head
*seq_head
)
162 struct name_seq
*nseq
= kzalloc(sizeof(*nseq
), GFP_ATOMIC
);
163 struct sub_seq
*sseq
= tipc_subseq_alloc(1);
165 if (!nseq
|| !sseq
) {
166 warn("Name sequence creation failed, no memory\n");
172 spin_lock_init(&nseq
->lock
);
175 dbg("tipc_nameseq_create(): nseq = %p, type %u, ssseqs %p, ff: %u\n",
176 nseq
, type
, nseq
->sseqs
, nseq
->first_free
);
178 INIT_HLIST_NODE(&nseq
->ns_list
);
179 INIT_LIST_HEAD(&nseq
->subscriptions
);
180 hlist_add_head(&nseq
->ns_list
, seq_head
);
185 * nameseq_find_subseq - find sub-sequence (if any) matching a name instance
187 * Very time-critical, so binary searches through sub-sequence array.
190 static struct sub_seq
*nameseq_find_subseq(struct name_seq
*nseq
,
193 struct sub_seq
*sseqs
= nseq
->sseqs
;
195 int high
= nseq
->first_free
- 1;
198 while (low
<= high
) {
199 mid
= (low
+ high
) / 2;
200 if (instance
< sseqs
[mid
].lower
)
202 else if (instance
> sseqs
[mid
].upper
)
211 * nameseq_locate_subseq - determine position of name instance in sub-sequence
213 * Returns index in sub-sequence array of the entry that contains the specified
214 * instance value; if no entry contains that value, returns the position
215 * where a new entry for it would be inserted in the array.
217 * Note: Similar to binary search code for locating a sub-sequence.
220 static u32
nameseq_locate_subseq(struct name_seq
*nseq
, u32 instance
)
222 struct sub_seq
*sseqs
= nseq
->sseqs
;
224 int high
= nseq
->first_free
- 1;
227 while (low
<= high
) {
228 mid
= (low
+ high
) / 2;
229 if (instance
< sseqs
[mid
].lower
)
231 else if (instance
> sseqs
[mid
].upper
)
240 * tipc_nameseq_insert_publ -
243 static struct publication
*tipc_nameseq_insert_publ(struct name_seq
*nseq
,
244 u32 type
, u32 lower
, u32 upper
,
245 u32 scope
, u32 node
, u32 port
, u32 key
)
247 struct subscription
*s
;
248 struct subscription
*st
;
249 struct publication
*publ
;
250 struct sub_seq
*sseq
;
251 int created_subseq
= 0;
253 sseq
= nameseq_find_subseq(nseq
, lower
);
254 dbg("nameseq_ins: for seq %p, {%u,%u}, found sseq %p\n",
255 nseq
, type
, lower
, sseq
);
258 /* Lower end overlaps existing entry => need an exact match */
260 if ((sseq
->lower
!= lower
) || (sseq
->upper
!= upper
)) {
261 warn("Cannot publish {%u,%u,%u}, overlap error\n",
267 struct sub_seq
*freesseq
;
269 /* Find where lower end should be inserted */
271 inspos
= nameseq_locate_subseq(nseq
, lower
);
273 /* Fail if upper end overlaps into an existing entry */
275 if ((inspos
< nseq
->first_free
) &&
276 (upper
>= nseq
->sseqs
[inspos
].lower
)) {
277 warn("Cannot publish {%u,%u,%u}, overlap error\n",
282 /* Ensure there is space for new sub-sequence */
284 if (nseq
->first_free
== nseq
->alloc
) {
285 struct sub_seq
*sseqs
= tipc_subseq_alloc(nseq
->alloc
* 2);
288 warn("Cannot publish {%u,%u,%u}, no memory\n",
292 dbg("Allocated %u more sseqs\n", nseq
->alloc
);
293 memcpy(sseqs
, nseq
->sseqs
,
294 nseq
->alloc
* sizeof(struct sub_seq
));
299 dbg("Have %u sseqs for type %u\n", nseq
->alloc
, type
);
301 /* Insert new sub-sequence */
303 dbg("ins in pos %u, ff = %u\n", inspos
, nseq
->first_free
);
304 sseq
= &nseq
->sseqs
[inspos
];
305 freesseq
= &nseq
->sseqs
[nseq
->first_free
];
306 memmove(sseq
+ 1, sseq
, (freesseq
- sseq
) * sizeof (*sseq
));
307 memset(sseq
, 0, sizeof (*sseq
));
313 dbg("inserting {%u,%u,%u} from <0x%x:%u> into sseq %p(%u,%u) of seq %p\n",
314 type
, lower
, upper
, node
, port
, sseq
,
315 sseq
->lower
, sseq
->upper
, nseq
);
317 /* Insert a publication: */
319 publ
= publ_create(type
, lower
, upper
, scope
, node
, port
, key
);
322 dbg("inserting publ %p, node=0x%x publ->node=0x%x, subscr->node=%p\n",
323 publ
, node
, publ
->node
, publ
->subscr
.node
);
325 sseq
->zone_list_size
++;
326 if (!sseq
->zone_list
)
327 sseq
->zone_list
= publ
->zone_list_next
= publ
;
329 publ
->zone_list_next
= sseq
->zone_list
->zone_list_next
;
330 sseq
->zone_list
->zone_list_next
= publ
;
333 if (in_own_cluster(node
)) {
334 sseq
->cluster_list_size
++;
335 if (!sseq
->cluster_list
)
336 sseq
->cluster_list
= publ
->cluster_list_next
= publ
;
338 publ
->cluster_list_next
=
339 sseq
->cluster_list
->cluster_list_next
;
340 sseq
->cluster_list
->cluster_list_next
= publ
;
344 if (node
== tipc_own_addr
) {
345 sseq
->node_list_size
++;
346 if (!sseq
->node_list
)
347 sseq
->node_list
= publ
->node_list_next
= publ
;
349 publ
->node_list_next
= sseq
->node_list
->node_list_next
;
350 sseq
->node_list
->node_list_next
= publ
;
355 * Any subscriptions waiting for notification?
357 list_for_each_entry_safe(s
, st
, &nseq
->subscriptions
, nameseq_list
) {
358 dbg("calling report_overlap()\n");
359 tipc_subscr_report_overlap(s
,
371 * tipc_nameseq_remove_publ -
373 * NOTE: There may be cases where TIPC is asked to remove a publication
374 * that is not in the name table. For example, if another node issues a
375 * publication for a name sequence that overlaps an existing name sequence
376 * the publication will not be recorded, which means the publication won't
377 * be found when the name sequence is later withdrawn by that node.
378 * A failed withdraw request simply returns a failure indication and lets the
379 * caller issue any error or warning messages associated with such a problem.
382 static struct publication
*tipc_nameseq_remove_publ(struct name_seq
*nseq
, u32 inst
,
383 u32 node
, u32 ref
, u32 key
)
385 struct publication
*publ
;
386 struct publication
*curr
;
387 struct publication
*prev
;
388 struct sub_seq
*sseq
= nameseq_find_subseq(nseq
, inst
);
389 struct sub_seq
*free
;
390 struct subscription
*s
, *st
;
391 int removed_subseq
= 0;
396 dbg("tipc_nameseq_remove_publ: seq: %p, sseq %p, {%u,%u}, key %u\n",
397 nseq
, sseq
, nseq
->type
, inst
, key
);
399 /* Remove publication from zone scope list */
401 prev
= sseq
->zone_list
;
402 publ
= sseq
->zone_list
->zone_list_next
;
403 while ((publ
->key
!= key
) || (publ
->ref
!= ref
) ||
404 (publ
->node
&& (publ
->node
!= node
))) {
406 publ
= publ
->zone_list_next
;
407 if (prev
== sseq
->zone_list
) {
409 /* Prevent endless loop if publication not found */
414 if (publ
!= sseq
->zone_list
)
415 prev
->zone_list_next
= publ
->zone_list_next
;
416 else if (publ
->zone_list_next
!= publ
) {
417 prev
->zone_list_next
= publ
->zone_list_next
;
418 sseq
->zone_list
= publ
->zone_list_next
;
420 sseq
->zone_list
= NULL
;
422 sseq
->zone_list_size
--;
424 /* Remove publication from cluster scope list, if present */
426 if (in_own_cluster(node
)) {
427 prev
= sseq
->cluster_list
;
428 curr
= sseq
->cluster_list
->cluster_list_next
;
429 while (curr
!= publ
) {
431 curr
= curr
->cluster_list_next
;
432 if (prev
== sseq
->cluster_list
) {
434 /* Prevent endless loop for malformed list */
436 err("Unable to de-list cluster publication\n"
437 "{%u%u}, node=0x%x, ref=%u, key=%u)\n",
438 publ
->type
, publ
->lower
, publ
->node
,
439 publ
->ref
, publ
->key
);
443 if (publ
!= sseq
->cluster_list
)
444 prev
->cluster_list_next
= publ
->cluster_list_next
;
445 else if (publ
->cluster_list_next
!= publ
) {
446 prev
->cluster_list_next
= publ
->cluster_list_next
;
447 sseq
->cluster_list
= publ
->cluster_list_next
;
449 sseq
->cluster_list
= NULL
;
451 sseq
->cluster_list_size
--;
455 /* Remove publication from node scope list, if present */
457 if (node
== tipc_own_addr
) {
458 prev
= sseq
->node_list
;
459 curr
= sseq
->node_list
->node_list_next
;
460 while (curr
!= publ
) {
462 curr
= curr
->node_list_next
;
463 if (prev
== sseq
->node_list
) {
465 /* Prevent endless loop for malformed list */
467 err("Unable to de-list node publication\n"
468 "{%u%u}, node=0x%x, ref=%u, key=%u)\n",
469 publ
->type
, publ
->lower
, publ
->node
,
470 publ
->ref
, publ
->key
);
474 if (publ
!= sseq
->node_list
)
475 prev
->node_list_next
= publ
->node_list_next
;
476 else if (publ
->node_list_next
!= publ
) {
477 prev
->node_list_next
= publ
->node_list_next
;
478 sseq
->node_list
= publ
->node_list_next
;
480 sseq
->node_list
= NULL
;
482 sseq
->node_list_size
--;
486 /* Contract subseq list if no more publications for that subseq */
488 if (!sseq
->zone_list
) {
489 free
= &nseq
->sseqs
[nseq
->first_free
--];
490 memmove(sseq
, sseq
+ 1, (free
- (sseq
+ 1)) * sizeof (*sseq
));
494 /* Notify any waiting subscriptions */
496 list_for_each_entry_safe(s
, st
, &nseq
->subscriptions
, nameseq_list
) {
497 tipc_subscr_report_overlap(s
,
510 * tipc_nameseq_subscribe: attach a subscription, and issue
511 * the prescribed number of events if there is any sub-
512 * sequence overlapping with the requested sequence
515 static void tipc_nameseq_subscribe(struct name_seq
*nseq
, struct subscription
*s
)
517 struct sub_seq
*sseq
= nseq
->sseqs
;
519 list_add(&s
->nameseq_list
, &nseq
->subscriptions
);
524 while (sseq
!= &nseq
->sseqs
[nseq
->first_free
]) {
525 struct publication
*zl
= sseq
->zone_list
;
526 if (zl
&& tipc_subscr_overlap(s
,sseq
->lower
,sseq
->upper
)) {
527 struct publication
*crs
= zl
;
531 tipc_subscr_report_overlap(s
,
539 crs
= crs
->zone_list_next
;
546 static struct name_seq
*nametbl_find_seq(u32 type
)
548 struct hlist_head
*seq_head
;
549 struct hlist_node
*seq_node
;
552 dbg("find_seq %u,(%u,0x%x) table = %p, hash[type] = %u\n",
553 type
, htonl(type
), type
, table
.types
, hash(type
));
555 seq_head
= &table
.types
[hash(type
)];
556 hlist_for_each_entry(ns
, seq_node
, seq_head
, ns_list
) {
557 if (ns
->type
== type
) {
558 dbg("found %p\n", ns
);
566 struct publication
*tipc_nametbl_insert_publ(u32 type
, u32 lower
, u32 upper
,
567 u32 scope
, u32 node
, u32 port
, u32 key
)
569 struct name_seq
*seq
= nametbl_find_seq(type
);
571 dbg("tipc_nametbl_insert_publ: {%u,%u,%u} found %p\n", type
, lower
, upper
, seq
);
573 warn("Failed to publish illegal {%u,%u,%u}\n",
578 dbg("Publishing {%u,%u,%u} from 0x%x\n", type
, lower
, upper
, node
);
580 seq
= tipc_nameseq_create(type
, &table
.types
[hash(type
)]);
581 dbg("tipc_nametbl_insert_publ: created %p\n", seq
);
586 return tipc_nameseq_insert_publ(seq
, type
, lower
, upper
,
587 scope
, node
, port
, key
);
590 struct publication
*tipc_nametbl_remove_publ(u32 type
, u32 lower
,
591 u32 node
, u32 ref
, u32 key
)
593 struct publication
*publ
;
594 struct name_seq
*seq
= nametbl_find_seq(type
);
599 dbg("Withdrawing {%u,%u} from 0x%x\n", type
, lower
, node
);
600 publ
= tipc_nameseq_remove_publ(seq
, lower
, node
, ref
, key
);
602 if (!seq
->first_free
&& list_empty(&seq
->subscriptions
)) {
603 hlist_del_init(&seq
->ns_list
);
611 * tipc_nametbl_translate - translate name to port id
613 * Note: on entry 'destnode' is the search domain used during translation;
614 * on exit it passes back the node address of the matching port (if any)
617 u32
tipc_nametbl_translate(u32 type
, u32 instance
, u32
*destnode
)
619 struct sub_seq
*sseq
;
620 struct publication
*publ
= NULL
;
621 struct name_seq
*seq
;
624 if (!tipc_in_scope(*destnode
, tipc_own_addr
))
627 read_lock_bh(&tipc_nametbl_lock
);
628 seq
= nametbl_find_seq(type
);
631 sseq
= nameseq_find_subseq(seq
, instance
);
634 spin_lock_bh(&seq
->lock
);
636 /* Closest-First Algorithm: */
637 if (likely(!*destnode
)) {
638 publ
= sseq
->node_list
;
640 sseq
->node_list
= publ
->node_list_next
;
643 *destnode
= publ
->node
;
644 spin_unlock_bh(&seq
->lock
);
645 read_unlock_bh(&tipc_nametbl_lock
);
648 publ
= sseq
->cluster_list
;
650 sseq
->cluster_list
= publ
->cluster_list_next
;
653 publ
= sseq
->zone_list
;
655 sseq
->zone_list
= publ
->zone_list_next
;
660 /* Round-Robin Algorithm: */
661 else if (*destnode
== tipc_own_addr
) {
662 publ
= sseq
->node_list
;
664 sseq
->node_list
= publ
->node_list_next
;
667 } else if (in_own_cluster(*destnode
)) {
668 publ
= sseq
->cluster_list
;
670 sseq
->cluster_list
= publ
->cluster_list_next
;
674 publ
= sseq
->zone_list
;
676 sseq
->zone_list
= publ
->zone_list_next
;
680 spin_unlock_bh(&seq
->lock
);
682 read_unlock_bh(&tipc_nametbl_lock
);
687 * tipc_nametbl_mc_translate - find multicast destinations
689 * Creates list of all local ports that overlap the given multicast address;
690 * also determines if any off-node ports overlap.
692 * Note: Publications with a scope narrower than 'limit' are ignored.
693 * (i.e. local node-scope publications mustn't receive messages arriving
694 * from another node, even if the multcast link brought it here)
696 * Returns non-zero if any off-node ports overlap
699 int tipc_nametbl_mc_translate(u32 type
, u32 lower
, u32 upper
, u32 limit
,
700 struct port_list
*dports
)
702 struct name_seq
*seq
;
703 struct sub_seq
*sseq
;
704 struct sub_seq
*sseq_stop
;
707 read_lock_bh(&tipc_nametbl_lock
);
708 seq
= nametbl_find_seq(type
);
712 spin_lock_bh(&seq
->lock
);
714 sseq
= seq
->sseqs
+ nameseq_locate_subseq(seq
, lower
);
715 sseq_stop
= seq
->sseqs
+ seq
->first_free
;
716 for (; sseq
!= sseq_stop
; sseq
++) {
717 struct publication
*publ
;
719 if (sseq
->lower
> upper
)
722 publ
= sseq
->node_list
;
725 if (publ
->scope
<= limit
)
726 tipc_port_list_add(dports
, publ
->ref
);
727 publ
= publ
->node_list_next
;
728 } while (publ
!= sseq
->node_list
);
731 if (sseq
->cluster_list_size
!= sseq
->node_list_size
)
735 spin_unlock_bh(&seq
->lock
);
737 read_unlock_bh(&tipc_nametbl_lock
);
742 * tipc_nametbl_publish_rsv - publish port name using a reserved name type
745 int tipc_nametbl_publish_rsv(u32 ref
, unsigned int scope
,
746 struct tipc_name_seq
const *seq
)
750 atomic_inc(&rsv_publ_ok
);
751 res
= tipc_publish(ref
, scope
, seq
);
752 atomic_dec(&rsv_publ_ok
);
757 * tipc_nametbl_publish - add name publication to network name tables
760 struct publication
*tipc_nametbl_publish(u32 type
, u32 lower
, u32 upper
,
761 u32 scope
, u32 port_ref
, u32 key
)
763 struct publication
*publ
;
765 if (table
.local_publ_count
>= tipc_max_publications
) {
766 warn("Publication failed, local publication limit reached (%u)\n",
767 tipc_max_publications
);
770 if ((type
< TIPC_RESERVED_TYPES
) && !atomic_read(&rsv_publ_ok
)) {
771 warn("Publication failed, reserved name {%u,%u,%u}\n",
776 write_lock_bh(&tipc_nametbl_lock
);
777 table
.local_publ_count
++;
778 publ
= tipc_nametbl_insert_publ(type
, lower
, upper
, scope
,
779 tipc_own_addr
, port_ref
, key
);
780 if (publ
&& (scope
!= TIPC_NODE_SCOPE
)) {
781 tipc_named_publish(publ
);
783 write_unlock_bh(&tipc_nametbl_lock
);
788 * tipc_nametbl_withdraw - withdraw name publication from network name tables
791 int tipc_nametbl_withdraw(u32 type
, u32 lower
, u32 ref
, u32 key
)
793 struct publication
*publ
;
795 dbg("tipc_nametbl_withdraw: {%u,%u}, key=%u\n", type
, lower
, key
);
796 write_lock_bh(&tipc_nametbl_lock
);
797 publ
= tipc_nametbl_remove_publ(type
, lower
, tipc_own_addr
, ref
, key
);
799 table
.local_publ_count
--;
800 if (publ
->scope
!= TIPC_NODE_SCOPE
)
801 tipc_named_withdraw(publ
);
802 write_unlock_bh(&tipc_nametbl_lock
);
803 list_del_init(&publ
->pport_list
);
807 write_unlock_bh(&tipc_nametbl_lock
);
808 err("Unable to remove local publication\n"
809 "(type=%u, lower=%u, ref=%u, key=%u)\n",
810 type
, lower
, ref
, key
);
815 * tipc_nametbl_subscribe - add a subscription object to the name table
818 void tipc_nametbl_subscribe(struct subscription
*s
)
820 u32 type
= s
->seq
.type
;
821 struct name_seq
*seq
;
823 write_lock_bh(&tipc_nametbl_lock
);
824 seq
= nametbl_find_seq(type
);
826 seq
= tipc_nameseq_create(type
, &table
.types
[hash(type
)]);
829 spin_lock_bh(&seq
->lock
);
830 dbg("tipc_nametbl_subscribe:found %p for {%u,%u,%u}\n",
831 seq
, type
, s
->seq
.lower
, s
->seq
.upper
);
832 tipc_nameseq_subscribe(seq
, s
);
833 spin_unlock_bh(&seq
->lock
);
835 warn("Failed to create subscription for {%u,%u,%u}\n",
836 s
->seq
.type
, s
->seq
.lower
, s
->seq
.upper
);
838 write_unlock_bh(&tipc_nametbl_lock
);
842 * tipc_nametbl_unsubscribe - remove a subscription object from name table
845 void tipc_nametbl_unsubscribe(struct subscription
*s
)
847 struct name_seq
*seq
;
849 write_lock_bh(&tipc_nametbl_lock
);
850 seq
= nametbl_find_seq(s
->seq
.type
);
852 spin_lock_bh(&seq
->lock
);
853 list_del_init(&s
->nameseq_list
);
854 spin_unlock_bh(&seq
->lock
);
855 if ((seq
->first_free
== 0) && list_empty(&seq
->subscriptions
)) {
856 hlist_del_init(&seq
->ns_list
);
861 write_unlock_bh(&tipc_nametbl_lock
);
866 * subseq_list: print specified sub-sequence contents into the given buffer
869 static void subseq_list(struct sub_seq
*sseq
, struct print_buf
*buf
, u32 depth
,
873 const char *scope_str
[] = {"", " zone", " cluster", " node"};
874 struct publication
*publ
= sseq
->zone_list
;
876 tipc_printf(buf
, "%-10u %-10u ", sseq
->lower
, sseq
->upper
);
878 if (depth
== 2 || !publ
) {
879 tipc_printf(buf
, "\n");
884 sprintf (portIdStr
, "<%u.%u.%u:%u>",
885 tipc_zone(publ
->node
), tipc_cluster(publ
->node
),
886 tipc_node(publ
->node
), publ
->ref
);
887 tipc_printf(buf
, "%-26s ", portIdStr
);
889 tipc_printf(buf
, "%-10u %s", publ
->key
,
890 scope_str
[publ
->scope
]);
893 publ
= publ
->zone_list_next
;
894 if (publ
== sseq
->zone_list
)
897 tipc_printf(buf
, "\n%33s", " ");
900 tipc_printf(buf
, "\n");
904 * nameseq_list: print specified name sequence contents into the given buffer
907 static void nameseq_list(struct name_seq
*seq
, struct print_buf
*buf
, u32 depth
,
908 u32 type
, u32 lowbound
, u32 upbound
, u32 index
)
910 struct sub_seq
*sseq
;
913 if (seq
->first_free
== 0)
916 sprintf(typearea
, "%-10u", seq
->type
);
919 tipc_printf(buf
, "%s\n", typearea
);
923 for (sseq
= seq
->sseqs
; sseq
!= &seq
->sseqs
[seq
->first_free
]; sseq
++) {
924 if ((lowbound
<= sseq
->upper
) && (upbound
>= sseq
->lower
)) {
925 tipc_printf(buf
, "%s ", typearea
);
926 spin_lock_bh(&seq
->lock
);
927 subseq_list(sseq
, buf
, depth
, index
);
928 spin_unlock_bh(&seq
->lock
);
929 sprintf(typearea
, "%10s", " ");
935 * nametbl_header - print name table header into the given buffer
938 static void nametbl_header(struct print_buf
*buf
, u32 depth
)
940 const char *header
[] = {
951 for (i
= 0; i
< depth
; i
++)
952 tipc_printf(buf
, header
[i
]);
953 tipc_printf(buf
, "\n");
957 * nametbl_list - print specified name table contents into the given buffer
960 static void nametbl_list(struct print_buf
*buf
, u32 depth_info
,
961 u32 type
, u32 lowbound
, u32 upbound
)
963 struct hlist_head
*seq_head
;
964 struct hlist_node
*seq_node
;
965 struct name_seq
*seq
;
970 all_types
= (depth_info
& TIPC_NTQ_ALLTYPES
);
971 depth
= (depth_info
& ~TIPC_NTQ_ALLTYPES
);
977 /* display all entries in name table to specified depth */
978 nametbl_header(buf
, depth
);
981 for (i
= 0; i
< tipc_nametbl_size
; i
++) {
982 seq_head
= &table
.types
[i
];
983 hlist_for_each_entry(seq
, seq_node
, seq_head
, ns_list
) {
984 nameseq_list(seq
, buf
, depth
, seq
->type
,
985 lowbound
, upbound
, i
);
989 /* display only the sequence that matches the specified type */
990 if (upbound
< lowbound
) {
991 tipc_printf(buf
, "invalid name sequence specified\n");
994 nametbl_header(buf
, depth
);
996 seq_head
= &table
.types
[i
];
997 hlist_for_each_entry(seq
, seq_node
, seq_head
, ns_list
) {
998 if (seq
->type
== type
) {
999 nameseq_list(seq
, buf
, depth
, type
,
1000 lowbound
, upbound
, i
);
1007 #define MAX_NAME_TBL_QUERY 32768
1009 struct sk_buff
*tipc_nametbl_get(const void *req_tlv_area
, int req_tlv_space
)
1011 struct sk_buff
*buf
;
1012 struct tipc_name_table_query
*argv
;
1013 struct tlv_desc
*rep_tlv
;
1017 if (!TLV_CHECK(req_tlv_area
, req_tlv_space
, TIPC_TLV_NAME_TBL_QUERY
))
1018 return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR
);
1020 buf
= tipc_cfg_reply_alloc(TLV_SPACE(MAX_NAME_TBL_QUERY
));
1024 rep_tlv
= (struct tlv_desc
*)buf
->data
;
1025 tipc_printbuf_init(&b
, TLV_DATA(rep_tlv
), MAX_NAME_TBL_QUERY
);
1026 argv
= (struct tipc_name_table_query
*)TLV_DATA(req_tlv_area
);
1027 read_lock_bh(&tipc_nametbl_lock
);
1028 nametbl_list(&b
, ntohl(argv
->depth
), ntohl(argv
->type
),
1029 ntohl(argv
->lowbound
), ntohl(argv
->upbound
));
1030 read_unlock_bh(&tipc_nametbl_lock
);
1031 str_len
= tipc_printbuf_validate(&b
);
1033 skb_put(buf
, TLV_SPACE(str_len
));
1034 TLV_SET(rep_tlv
, TIPC_TLV_ULTRA_STRING
, NULL
, str_len
);
1039 int tipc_nametbl_init(void)
1041 table
.types
= kcalloc(tipc_nametbl_size
, sizeof(struct hlist_head
),
1046 table
.local_publ_count
= 0;
1050 void tipc_nametbl_stop(void)
1057 /* Verify name table is empty, then release it */
1059 write_lock_bh(&tipc_nametbl_lock
);
1060 for (i
= 0; i
< tipc_nametbl_size
; i
++) {
1061 if (!hlist_empty(&table
.types
[i
]))
1062 err("tipc_nametbl_stop(): hash chain %u is non-null\n", i
);
1066 write_unlock_bh(&tipc_nametbl_lock
);