Linux Audio

Check our new training course

Loading...
v3.15
  1/*
  2 * net/tipc/name_table.c: TIPC name table code
  3 *
  4 * Copyright (c) 2000-2006, Ericsson AB
  5 * Copyright (c) 2004-2008, 2010-2011, 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 "name_table.h"
 40#include "name_distr.h"
 41#include "subscr.h"
 42#include "port.h"
 43
 44#define TIPC_NAMETBL_SIZE 1024		/* must be a power of 2 */
 45
 46/**
 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"
 54 *
 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.)
 58 */
 59struct name_info {
 60	struct list_head node_list;
 61	struct list_head cluster_list;
 62	struct list_head zone_list;
 63	u32 node_list_size;
 64	u32 cluster_list_size;
 65	u32 zone_list_size;
 66};
 67
 68/**
 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
 73 */
 74struct sub_seq {
 75	u32 lower;
 76	u32 upper;
 77	struct name_info *info;
 
 
 78};
 79
 80/**
 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
 90 */
 91struct name_seq {
 92	u32 type;
 93	struct sub_seq *sseqs;
 94	u32 alloc;
 95	u32 first_free;
 96	struct hlist_node ns_list;
 97	struct list_head subscriptions;
 98	spinlock_t lock;
 
 99};
100
101/**
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
106 */
107struct name_table {
108	struct hlist_head *types;
109	u32 local_publ_count;
110};
111
112static struct name_table table;
113DEFINE_RWLOCK(tipc_nametbl_lock);
114
115static int hash(int x)
116{
117	return x & (TIPC_NAMETBL_SIZE - 1);
118}
119
120/**
121 * publ_create - create a publication structure
122 */
123static struct publication *publ_create(u32 type, u32 lower, u32 upper,
124				       u32 scope, u32 node, u32 port_ref,
125				       u32 key)
126{
127	struct publication *publ = kzalloc(sizeof(*publ), GFP_ATOMIC);
128	if (publ == NULL) {
129		pr_warn("Publication creation failure, no memory\n");
130		return NULL;
131	}
132
133	publ->type = type;
134	publ->lower = lower;
135	publ->upper = upper;
136	publ->scope = scope;
137	publ->node = node;
138	publ->ref = port_ref;
139	publ->key = key;
140	INIT_LIST_HEAD(&publ->local_list);
141	INIT_LIST_HEAD(&publ->pport_list);
142	INIT_LIST_HEAD(&publ->subscr.nodesub_list);
 
143	return publ;
144}
145
146/**
147 * tipc_subseq_alloc - allocate a specified number of sub-sequence structures
148 */
149static struct sub_seq *tipc_subseq_alloc(u32 cnt)
150{
151	return kcalloc(cnt, sizeof(struct sub_seq), GFP_ATOMIC);
152}
153
154/**
155 * tipc_nameseq_create - create a name sequence structure for the specified 'type'
156 *
157 * Allocates a single sub-sequence structure and sets it to all 0's.
158 */
159static struct name_seq *tipc_nameseq_create(u32 type, struct hlist_head *seq_head)
160{
161	struct name_seq *nseq = kzalloc(sizeof(*nseq), GFP_ATOMIC);
162	struct sub_seq *sseq = tipc_subseq_alloc(1);
163
164	if (!nseq || !sseq) {
165		pr_warn("Name sequence creation failed, no memory\n");
166		kfree(nseq);
167		kfree(sseq);
168		return NULL;
169	}
170
171	spin_lock_init(&nseq->lock);
172	nseq->type = type;
173	nseq->sseqs = sseq;
174	nseq->alloc = 1;
175	INIT_HLIST_NODE(&nseq->ns_list);
176	INIT_LIST_HEAD(&nseq->subscriptions);
177	hlist_add_head(&nseq->ns_list, seq_head);
178	return nseq;
179}
180
181/*
182 * nameseq_delete_empty - deletes a name sequence structure if now unused
183 */
184static void nameseq_delete_empty(struct name_seq *seq)
185{
186	if (!seq->first_free && list_empty(&seq->subscriptions)) {
187		hlist_del_init(&seq->ns_list);
188		kfree(seq->sseqs);
189		kfree(seq);
190	}
191}
192
193/**
194 * nameseq_find_subseq - find sub-sequence (if any) matching a name instance
195 *
196 * Very time-critical, so binary searches through sub-sequence array.
197 */
198static struct sub_seq *nameseq_find_subseq(struct name_seq *nseq,
199					   u32 instance)
200{
201	struct sub_seq *sseqs = nseq->sseqs;
202	int low = 0;
203	int high = nseq->first_free - 1;
204	int mid;
205
206	while (low <= high) {
207		mid = (low + high) / 2;
208		if (instance < sseqs[mid].lower)
209			high = mid - 1;
210		else if (instance > sseqs[mid].upper)
211			low = mid + 1;
212		else
213			return &sseqs[mid];
214	}
215	return NULL;
216}
217
218/**
219 * nameseq_locate_subseq - determine position of name instance in sub-sequence
220 *
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.
224 *
225 * Note: Similar to binary search code for locating a sub-sequence.
226 */
227static u32 nameseq_locate_subseq(struct name_seq *nseq, u32 instance)
228{
229	struct sub_seq *sseqs = nseq->sseqs;
230	int low = 0;
231	int high = nseq->first_free - 1;
232	int mid;
233
234	while (low <= high) {
235		mid = (low + high) / 2;
236		if (instance < sseqs[mid].lower)
237			high = mid - 1;
238		else if (instance > sseqs[mid].upper)
239			low = mid + 1;
240		else
241			return mid;
242	}
243	return low;
244}
245
246/**
247 * tipc_nameseq_insert_publ
248 */
249static 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)
252{
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;
259
260	sseq = nameseq_find_subseq(nseq, lower);
261	if (sseq) {
262
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",
266				type, lower, upper);
267			return NULL;
268		}
269
270		info = sseq->info;
271
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)))
276				return NULL;
277		}
278	} else {
279		u32 inspos;
280		struct sub_seq *freesseq;
281
282		/* Find where lower end should be inserted */
283		inspos = nameseq_locate_subseq(nseq, lower);
284
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",
289				type, lower, upper);
290			return NULL;
291		}
292
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);
296
297			if (!sseqs) {
298				pr_warn("Cannot publish {%u,%u,%u}, no memory\n",
299					type, lower, upper);
300				return NULL;
301			}
302			memcpy(sseqs, nseq->sseqs,
303			       nseq->alloc * sizeof(struct sub_seq));
304			kfree(nseq->sseqs);
305			nseq->sseqs = sseqs;
306			nseq->alloc *= 2;
307		}
308
309		info = kzalloc(sizeof(*info), GFP_ATOMIC);
310		if (!info) {
311			pr_warn("Cannot publish {%u,%u,%u}, no memory\n",
312				type, lower, upper);
313			return NULL;
314		}
315
316		INIT_LIST_HEAD(&info->node_list);
317		INIT_LIST_HEAD(&info->cluster_list);
318		INIT_LIST_HEAD(&info->zone_list);
319
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));
325		nseq->first_free++;
326		sseq->lower = lower;
327		sseq->upper = upper;
328		sseq->info = info;
329		created_subseq = 1;
330	}
331
332	/* Insert a publication */
333	publ = publ_create(type, lower, upper, scope, node, port, key);
334	if (!publ)
335		return NULL;
336
337	list_add(&publ->zone_list, &info->zone_list);
338	info->zone_list_size++;
339
340	if (in_own_cluster(node)) {
341		list_add(&publ->cluster_list, &info->cluster_list);
342		info->cluster_list_size++;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
343	}
344
345	if (in_own_node(node)) {
346		list_add(&publ->node_list, &info->node_list);
347		info->node_list_size++;
348	}
 
 
 
349
350	/* Any subscriptions waiting for notification?  */
351	list_for_each_entry_safe(s, st, &nseq->subscriptions, nameseq_list) {
352		tipc_subscr_report_overlap(s,
353					   publ->lower,
354					   publ->upper,
355					   TIPC_PUBLISHED,
356					   publ->ref,
357					   publ->node,
358					   created_subseq);
359	}
360	return publ;
361}
362
363/**
364 * tipc_nameseq_remove_publ
365 *
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.
373 */
374static struct publication *tipc_nameseq_remove_publ(struct name_seq *nseq, u32 inst,
375						    u32 node, u32 ref, u32 key)
376{
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;
383
384	if (!sseq)
 
385		return NULL;
386
387	info = sseq->info;
388
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)))
393			goto found;
394	}
395	return NULL;
 
396
397found:
398	/* Remove publication from zone scope list */
399	list_del(&publ->zone_list);
400	info->zone_list_size--;
401
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--;
406	}
407
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--;
412	}
413
414	/* Contract subseq list if no more publications for that subseq */
415	if (list_empty(&info->zone_list)) {
416		kfree(info);
417		free = &nseq->sseqs[nseq->first_free--];
418		memmove(sseq, sseq + 1, (free - (sseq + 1)) * sizeof(*sseq));
419		removed_subseq = 1;
420	}
 
 
 
 
 
 
 
421
422	/* Notify any waiting subscriptions */
423	list_for_each_entry_safe(s, st, &nseq->subscriptions, nameseq_list) {
424		tipc_subscr_report_overlap(s,
425					   publ->lower,
426					   publ->upper,
427					   TIPC_WITHDRAWN,
428					   publ->ref,
429					   publ->node,
430					   removed_subseq);
431	}
432
433	return publ;
434}
435
436/**
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
440 */
441static void tipc_nameseq_subscribe(struct name_seq *nseq,
442				   struct tipc_subscription *s)
443{
444	struct sub_seq *sseq = nseq->sseqs;
 
 
 
 
 
445
446	list_add(&s->nameseq_list, &nseq->subscriptions);
 
 
447
448	if (!sseq)
 
 
 
449		return;
450
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;
455			int must_report = 1;
456
457			list_for_each_entry(crs, &info->zone_list, zone_list) {
458				tipc_subscr_report_overlap(s,
459							   sseq->lower,
460							   sseq->upper,
461							   TIPC_PUBLISHED,
462							   crs->ref,
463							   crs->node,
464							   must_report);
465				must_report = 0;
466			}
467		}
468		sseq++;
469	}
470}
471
472static struct name_seq *nametbl_find_seq(u32 type)
473{
474	struct hlist_head *seq_head;
475	struct name_seq *ns;
476
477	seq_head = &table.types[hash(type)];
478	hlist_for_each_entry(ns, seq_head, ns_list) {
479		if (ns->type == type)
480			return ns;
 
481	}
482
483	return NULL;
484};
485
486struct publication *tipc_nametbl_insert_publ(u32 type, u32 lower, u32 upper,
487					     u32 scope, u32 node, u32 port, u32 key)
488{
489	struct name_seq *seq = nametbl_find_seq(type);
 
 
 
 
490
491	if ((scope < TIPC_ZONE_SCOPE) || (scope > TIPC_NODE_SCOPE) ||
492	    (lower > upper)) {
493		pr_debug("Failed to publish illegal {%u,%u,%u} with scope %u\n",
494			 type, lower, upper, scope);
495		return NULL;
496	}
497
498	if (!seq)
499		seq = tipc_nameseq_create(type, &table.types[hash(type)]);
500	if (!seq)
501		return NULL;
502
503	return tipc_nameseq_insert_publ(seq, type, lower, upper,
504					scope, node, port, key);
505}
506
507struct publication *tipc_nametbl_remove_publ(u32 type, u32 lower,
508					     u32 node, u32 ref, u32 key)
509{
510	struct publication *publ;
511	struct name_seq *seq = nametbl_find_seq(type);
 
 
 
 
 
512
513	if (!seq)
514		return NULL;
515
516	publ = tipc_nameseq_remove_publ(seq, lower, node, ref, key);
517	nameseq_delete_empty(seq);
518	return publ;
 
 
 
 
 
 
 
 
 
 
 
 
 
519}
520
521/**
522 * tipc_nametbl_translate - perform name translation
523 *
524 * On entry, 'destnode' is the search domain used during translation.
525 *
526 * On exit:
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
532 *   and returns 0
533 */
534u32 tipc_nametbl_translate(u32 type, u32 instance, u32 *destnode)
535{
536	struct sub_seq *sseq;
537	struct name_info *info;
538	struct publication *publ;
539	struct name_seq *seq;
540	u32 ref = 0;
 
 
 
 
 
 
541	u32 node = 0;
542
543	if (!tipc_in_scope(*destnode, tipc_own_addr))
544		return 0;
545
546	read_lock_bh(&tipc_nametbl_lock);
547	seq = nametbl_find_seq(type);
548	if (unlikely(!seq))
549		goto not_found;
550	sseq = nameseq_find_subseq(seq, instance);
551	if (unlikely(!sseq))
552		goto not_found;
553	spin_lock_bh(&seq->lock);
554	info = sseq->info;
555
556	/* Closest-First Algorithm */
557	if (likely(!*destnode)) {
558		if (!list_empty(&info->node_list)) {
559			publ = list_first_entry(&info->node_list,
560						struct publication,
561						node_list);
562			list_move_tail(&publ->node_list,
563				       &info->node_list);
564		} else if (!list_empty(&info->cluster_list)) {
565			publ = list_first_entry(&info->cluster_list,
566						struct publication,
567						cluster_list);
568			list_move_tail(&publ->cluster_list,
569				       &info->cluster_list);
570		} else {
571			publ = list_first_entry(&info->zone_list,
572						struct publication,
573						zone_list);
574			list_move_tail(&publ->zone_list,
575				       &info->zone_list);
576		}
577	}
578
579	/* Round-Robin Algorithm */
580	else if (*destnode == tipc_own_addr) {
581		if (list_empty(&info->node_list))
582			goto no_match;
583		publ = list_first_entry(&info->node_list, struct publication,
584					node_list);
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))
588			goto no_match;
589		publ = list_first_entry(&info->cluster_list, struct publication,
590					cluster_list);
591		list_move_tail(&publ->cluster_list, &info->cluster_list);
 
 
 
592	} else {
593		publ = list_first_entry(&info->zone_list, struct publication,
594					zone_list);
595		list_move_tail(&publ->zone_list, &info->zone_list);
596	}
597
598	ref = publ->ref;
599	node = publ->node;
600no_match:
601	spin_unlock_bh(&seq->lock);
602not_found:
603	read_unlock_bh(&tipc_nametbl_lock);
604	*destnode = node;
605	return ref;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
606}
607
608/**
609 * tipc_nametbl_mc_translate - find multicast destinations
610 *
611 * Creates list of all local ports that overlap the given multicast address;
612 * also determines if any off-node ports overlap.
613 *
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)
617 *
618 * Returns non-zero if any off-node ports overlap
619 */
620int tipc_nametbl_mc_translate(u32 type, u32 lower, u32 upper, u32 limit,
621			      struct tipc_port_list *dports)
622{
623	struct name_seq *seq;
624	struct sub_seq *sseq;
625	struct sub_seq *sseq_stop;
626	struct name_info *info;
627	int res = 0;
628
629	read_lock_bh(&tipc_nametbl_lock);
630	seq = nametbl_find_seq(type);
631	if (!seq)
632		goto exit;
633
634	spin_lock_bh(&seq->lock);
 
 
 
635
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;
640
641		if (sseq->lower > upper)
 
 
 
 
642			break;
643
644		info = sseq->info;
645		list_for_each_entry(publ, &info->node_list, node_list) {
646			if (publ->scope <= limit)
647				tipc_port_list_add(dports, publ->ref);
648		}
 
 
 
 
 
649
650		if (info->cluster_list_size != info->node_list_size)
651			res = 1;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
652	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
653
654	spin_unlock_bh(&seq->lock);
 
 
 
 
 
 
 
 
 
655exit:
656	read_unlock_bh(&tipc_nametbl_lock);
657	return res;
658}
659
660/*
661 * tipc_nametbl_publish - add name publication to network name tables
662 */
663struct publication *tipc_nametbl_publish(u32 type, u32 lower, u32 upper,
664					 u32 scope, u32 port_ref, u32 key)
 
665{
666	struct publication *publ;
 
 
 
667
668	if (table.local_publ_count >= TIPC_MAX_PUBLICATIONS) {
669		pr_warn("Publication failed, local publication limit reached (%u)\n",
670			TIPC_MAX_PUBLICATIONS);
671		return NULL;
 
672	}
673
674	write_lock_bh(&tipc_nametbl_lock);
675	publ = tipc_nametbl_insert_publ(type, lower, upper, scope,
676				   tipc_own_addr, port_ref, key);
677	if (likely(publ)) {
678		table.local_publ_count++;
679		tipc_named_publish(publ);
680	}
681	write_unlock_bh(&tipc_nametbl_lock);
682	return publ;
 
 
 
 
683}
684
685/**
686 * tipc_nametbl_withdraw - withdraw name publication from network name tables
687 */
688int tipc_nametbl_withdraw(u32 type, u32 lower, u32 ref, u32 key)
 
689{
690	struct publication *publ;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
691
692	write_lock_bh(&tipc_nametbl_lock);
693	publ = tipc_nametbl_remove_publ(type, lower, tipc_own_addr, ref, key);
694	if (likely(publ)) {
695		table.local_publ_count--;
696		tipc_named_withdraw(publ);
697		write_unlock_bh(&tipc_nametbl_lock);
698		list_del_init(&publ->pport_list);
699		kfree(publ);
700		return 1;
701	}
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);
706	return 0;
707}
708
709/**
710 * tipc_nametbl_subscribe - add a subscription object to the name table
711 */
712void tipc_nametbl_subscribe(struct tipc_subscription *s)
713{
714	u32 type = s->seq.type;
715	struct name_seq *seq;
716
717	write_lock_bh(&tipc_nametbl_lock);
718	seq = nametbl_find_seq(type);
719	if (!seq)
720		seq = tipc_nameseq_create(type, &table.types[hash(type)]);
721	if (seq) {
722		spin_lock_bh(&seq->lock);
723		tipc_nameseq_subscribe(seq, s);
724		spin_unlock_bh(&seq->lock);
 
 
 
 
725	} else {
726		pr_warn("Failed to create subscription for {%u,%u,%u}\n",
727			s->seq.type, s->seq.lower, s->seq.upper);
 
 
728	}
729	write_unlock_bh(&tipc_nametbl_lock);
 
730}
731
732/**
733 * tipc_nametbl_unsubscribe - remove a subscription object from name table
734 */
735void tipc_nametbl_unsubscribe(struct tipc_subscription *s)
736{
737	struct name_seq *seq;
 
 
 
 
 
 
 
 
738
739	write_lock_bh(&tipc_nametbl_lock);
740	seq = nametbl_find_seq(s->seq.type);
741	if (seq != NULL) {
742		spin_lock_bh(&seq->lock);
743		list_del_init(&s->nameseq_list);
744		spin_unlock_bh(&seq->lock);
745		nameseq_delete_empty(seq);
 
746	}
747	write_unlock_bh(&tipc_nametbl_lock);
 
 
748}
749
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
750
751/**
752 * subseq_list - print specified sub-sequence contents into the given buffer
753 */
754static int subseq_list(struct sub_seq *sseq, char *buf, int len, u32 depth,
755		       u32 index)
756{
757	char portIdStr[27];
758	const char *scope_str[] = {"", " zone", " cluster", " node"};
759	struct publication *publ;
760	struct name_info *info;
761	int ret;
762
763	ret = tipc_snprintf(buf, len, "%-10u %-10u ", sseq->lower, sseq->upper);
764
765	if (depth == 2) {
766		ret += tipc_snprintf(buf - ret, len + ret, "\n");
767		return ret;
 
 
 
 
 
 
768	}
 
 
 
 
769
770	info = sseq->info;
 
 
 
 
 
 
771
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);
777		if (depth > 3) {
778			ret += tipc_snprintf(buf + ret, len - ret, "%-10u %s",
779					     publ->key, scope_str[publ->scope]);
 
 
780		}
781		if (!list_is_last(&publ->zone_list, &info->zone_list))
782			ret += tipc_snprintf(buf + ret, len - ret,
783					     "\n%33s", " ");
784	}
 
785
786	ret += tipc_snprintf(buf + ret, len - ret, "\n");
787	return ret;
788}
789
790/**
791 * nameseq_list - print specified name sequence contents into the given buffer
792 */
793static int nameseq_list(struct name_seq *seq, char *buf, int len, u32 depth,
794			u32 type, u32 lowbound, u32 upbound, u32 index)
795{
796	struct sub_seq *sseq;
797	char typearea[11];
798	int ret = 0;
 
799
800	if (seq->first_free == 0)
801		return 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
802
803	sprintf(typearea, "%-10u", seq->type);
804
805	if (depth == 1) {
806		ret += tipc_snprintf(buf, len, "%s\n", typearea);
807		return ret;
808	}
809
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 ",
813					    typearea);
814			spin_lock_bh(&seq->lock);
815			ret += subseq_list(sseq, buf + ret, len - ret,
816					  depth, index);
817			spin_unlock_bh(&seq->lock);
818			sprintf(typearea, "%10s", " ");
 
 
 
 
 
 
 
 
 
 
 
 
819		}
820	}
821	return ret;
 
822}
823
824/**
825 * nametbl_header - print name table header into the given buffer
826 */
827static int nametbl_header(char *buf, int len, u32 depth)
828{
829	const char *header[] = {
830		"Type       ",
831		"Lower      Upper      ",
832		"Port Identity              ",
833		"Publication Scope"
834	};
835
836	int i;
837	int ret = 0;
838
839	if (depth > 4)
840		depth = 4;
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");
844	return ret;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
845}
846
847/**
848 * nametbl_list - print specified name table contents into the given buffer
849 */
850static int nametbl_list(char *buf, int len, u32 depth_info,
851			u32 type, u32 lowbound, u32 upbound)
852{
853	struct hlist_head *seq_head;
854	struct name_seq *seq;
855	int all_types;
856	int ret = 0;
857	u32 depth;
858	u32 i;
 
859
860	all_types = (depth_info & TIPC_NTQ_ALLTYPES);
861	depth = (depth_info & ~TIPC_NTQ_ALLTYPES);
862
863	if (depth == 0)
864		return 0;
865
866	if (all_types) {
867		/* display all entries in name table to specified depth */
868		ret += nametbl_header(buf, len, depth);
869		lowbound = 0;
870		upbound = ~0;
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,
875						   depth, seq->type,
876						   lowbound, upbound, i);
877			}
878		}
879	} else {
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");
884			return ret;
885		}
886		ret += nametbl_header(buf + ret, len - ret, depth);
887		i = hash(type);
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,
892						   depth, type,
893						   lowbound, upbound, i);
894				break;
895			}
896		}
 
 
 
 
 
 
897	}
898	return ret;
899}
900
901struct sk_buff *tipc_nametbl_get(const void *req_tlv_area, int req_tlv_space)
902{
903	struct sk_buff *buf;
904	struct tipc_name_table_query *argv;
905	struct tlv_desc *rep_tlv;
906	char *pb;
907	int pb_len;
908	int str_len;
909
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);
912
913	buf = tipc_cfg_reply_alloc(TLV_SPACE(ULTRA_STRING_MAX_LEN));
914	if (!buf)
915		return NULL;
 
 
 
 
916
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),
923			       ntohl(argv->type),
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);
929
930	return buf;
931}
932
933int tipc_nametbl_init(void)
934{
935	table.types = kcalloc(TIPC_NAMETBL_SIZE, sizeof(struct hlist_head),
936			      GFP_ATOMIC);
937	if (!table.types)
938		return -ENOMEM;
939
940	table.local_publ_count = 0;
941	return 0;
 
 
 
 
 
 
 
 
942}
943
944/**
945 * tipc_purge_publications - remove all publications for a given type
946 *
947 * tipc_nametbl_lock must be held when calling this function
948 */
949static void tipc_purge_publications(struct name_seq *seq)
950{
951	struct publication *publ, *safe;
952	struct sub_seq *sseq;
953	struct name_info *info;
954
955	if (!seq->sseqs) {
956		nameseq_delete_empty(seq);
957		return;
958	}
959	sseq = seq->sseqs;
960	info = sseq->info;
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);
 
 
 
 
 
 
964	}
965}
966
967void tipc_nametbl_stop(void)
968{
969	u32 i;
970	struct name_seq *seq;
971	struct hlist_head *seq_head;
972	struct hlist_node *safe;
973
974	/* Verify name table is empty and purge any lingering
975	 * publications, then release the name table
976	 */
977	write_lock_bh(&tipc_nametbl_lock);
978	for (i = 0; i < TIPC_NAMETBL_SIZE; i++) {
979		if (hlist_empty(&table.types[i]))
980			continue;
981		seq_head = &table.types[i];
982		hlist_for_each_entry_safe(seq, safe, seq_head, ns_list) {
983			tipc_purge_publications(seq);
984		}
985		continue;
986	}
987	kfree(table.types);
988	table.types = NULL;
989	write_unlock_bh(&tipc_nametbl_lock);
990}
v4.17
   1/*
   2 * net/tipc/name_table.c: TIPC name table code
   3 *
   4 * Copyright (c) 2000-2006, 2014-2018, Ericsson AB
   5 * Copyright (c) 2004-2008, 2010-2014, 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 <net/sock.h>
  38#include "core.h"
  39#include "netlink.h"
  40#include "name_table.h"
  41#include "name_distr.h"
  42#include "subscr.h"
  43#include "bcast.h"
  44#include "addr.h"
  45#include "node.h"
  46#include "group.h"
  47
  48/**
  49 * struct service_range - container for all bindings of a service range
  50 * @lower: service range lower bound
  51 * @upper: service range upper bound
  52 * @tree_node: member of service range RB tree
  53 * @local_publ: list of identical publications made from this node
  54 *   Used by closest_first lookup and multicast lookup algorithm
  55 * @all_publ: all publications identical to this one, whatever node and scope
  56 *   Used by round-robin lookup algorithm
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  57 */
  58struct service_range {
  59	u32 lower;
  60	u32 upper;
  61	struct rb_node tree_node;
  62	struct list_head local_publ;
  63	struct list_head all_publ;
  64};
  65
  66/**
  67 * struct tipc_service - container for all published instances of a service type
  68 * @type: 32 bit 'type' value for service
  69 * @ranges: rb tree containing all service ranges for this service
  70 * @service_list: links to adjacent name ranges in hash chain
  71 * @subscriptions: list of subscriptions for this service type
  72 * @lock: spinlock controlling access to pertaining service ranges/publications
  73 * @rcu: RCU callback head used for deferred freeing
 
 
  74 */
  75struct tipc_service {
  76	u32 type;
  77	struct rb_root ranges;
  78	struct hlist_node service_list;
 
 
  79	struct list_head subscriptions;
  80	spinlock_t lock; /* Covers service range list */
  81	struct rcu_head rcu;
  82};
  83
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  84static int hash(int x)
  85{
  86	return x & (TIPC_NAMETBL_SIZE - 1);
  87}
  88
  89/**
  90 * tipc_publ_create - create a publication structure
  91 */
  92static struct publication *tipc_publ_create(u32 type, u32 lower, u32 upper,
  93					    u32 scope, u32 node, u32 port,
  94					    u32 key)
  95{
  96	struct publication *publ = kzalloc(sizeof(*publ), GFP_ATOMIC);
  97
  98	if (!publ)
  99		return NULL;
 
 100
 101	publ->type = type;
 102	publ->lower = lower;
 103	publ->upper = upper;
 104	publ->scope = scope;
 105	publ->node = node;
 106	publ->port = port;
 107	publ->key = key;
 108	INIT_LIST_HEAD(&publ->binding_sock);
 109	INIT_LIST_HEAD(&publ->binding_node);
 110	INIT_LIST_HEAD(&publ->local_publ);
 111	INIT_LIST_HEAD(&publ->all_publ);
 112	return publ;
 113}
 114
 115/**
 116 * tipc_service_create - create a service structure for the specified 'type'
 
 
 
 
 
 
 
 
 117 *
 118 * Allocates a single range structure and sets it to all 0's.
 119 */
 120static struct tipc_service *tipc_service_create(u32 type, struct hlist_head *hd)
 121{
 122	struct tipc_service *service = kzalloc(sizeof(*service), GFP_ATOMIC);
 
 123
 124	if (!service) {
 125		pr_warn("Service creation failed, no memory\n");
 
 
 126		return NULL;
 127	}
 128
 129	spin_lock_init(&service->lock);
 130	service->type = type;
 131	service->ranges = RB_ROOT;
 132	INIT_HLIST_NODE(&service->service_list);
 133	INIT_LIST_HEAD(&service->subscriptions);
 134	hlist_add_head_rcu(&service->service_list, hd);
 135	return service;
 
 
 
 
 
 
 
 
 
 
 
 
 
 136}
 137
 138/**
 139 * tipc_service_find_range - find service range matching a service instance
 140 *
 141 * Very time-critical, so binary search through range rb tree
 142 */
 143static struct service_range *tipc_service_find_range(struct tipc_service *sc,
 144						     u32 instance)
 145{
 146	struct rb_node *n = sc->ranges.rb_node;
 147	struct service_range *sr;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 148
 149	while (n) {
 150		sr = container_of(n, struct service_range, tree_node);
 151		if (sr->lower > instance)
 152			n = n->rb_left;
 153		else if (sr->upper < instance)
 154			n = n->rb_right;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 155		else
 156			return sr;
 157	}
 158	return NULL;
 159}
 160
 161static struct service_range *tipc_service_create_range(struct tipc_service *sc,
 162						       u32 lower, u32 upper)
 
 
 
 
 163{
 164	struct rb_node **n, *parent = NULL;
 165	struct service_range *sr, *tmp;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 166
 167	n = &sc->ranges.rb_node;
 168	while (*n) {
 169		tmp = container_of(*n, struct service_range, tree_node);
 170		parent = *n;
 171		tmp = container_of(parent, struct service_range, tree_node);
 172		if (lower < tmp->lower)
 173			n = &(*n)->rb_left;
 174		else if (lower > tmp->lower)
 175			n = &(*n)->rb_right;
 176		else if (upper < tmp->upper)
 177			n = &(*n)->rb_left;
 178		else if (upper > tmp->upper)
 179			n = &(*n)->rb_right;
 180		else
 181			return tmp;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 182	}
 183	sr = kzalloc(sizeof(*sr), GFP_ATOMIC);
 184	if (!sr)
 
 
 185		return NULL;
 186	sr->lower = lower;
 187	sr->upper = upper;
 188	INIT_LIST_HEAD(&sr->local_publ);
 189	INIT_LIST_HEAD(&sr->all_publ);
 190	rb_link_node(&sr->tree_node, parent, n);
 191	rb_insert_color(&sr->tree_node, &sc->ranges);
 192	return sr;
 193}
 194
 195static struct publication *tipc_service_insert_publ(struct net *net,
 196						    struct tipc_service *sc,
 197						    u32 type, u32 lower,
 198						    u32 upper, u32 scope,
 199						    u32 node, u32 port,
 200						    u32 key)
 201{
 202	struct tipc_subscription *sub, *tmp;
 203	struct service_range *sr;
 204	struct publication *p;
 205	bool first = false;
 206
 207	sr = tipc_service_create_range(sc, lower, upper);
 208	if (!sr)
 209		goto  err;
 210
 211	first = list_empty(&sr->all_publ);
 212
 213	/* Return if the publication already exists */
 214	list_for_each_entry(p, &sr->all_publ, all_publ) {
 215		if (p->key == key && (!p->node || p->node == node))
 216			return NULL;
 217	}
 218
 219	/* Create and insert publication */
 220	p = tipc_publ_create(type, lower, upper, scope, node, port, key);
 221	if (!p)
 222		goto err;
 223	if (in_own_node(net, node))
 224		list_add(&p->local_publ, &sr->local_publ);
 225	list_add(&p->all_publ, &sr->all_publ);
 226
 227	/* Any subscriptions waiting for notification?  */
 228	list_for_each_entry_safe(sub, tmp, &sc->subscriptions, service_list) {
 229		tipc_sub_report_overlap(sub, p->lower, p->upper, TIPC_PUBLISHED,
 230					p->port, p->node, p->scope, first);
 231	}
 232	return p;
 233err:
 234	pr_warn("Failed to bind to %u,%u,%u, no memory\n", type, lower, upper);
 235	return NULL;
 
 
 236}
 237
 238/**
 239 * tipc_service_remove_publ - remove a publication from a service
 240 */
 241static struct publication *tipc_service_remove_publ(struct net *net,
 242						    struct tipc_service *sc,
 243						    u32 lower, u32 upper,
 244						    u32 node, u32 key,
 245						    struct service_range **rng)
 246{
 247	struct tipc_subscription *sub, *tmp;
 248	struct service_range *sr;
 249	struct publication *p;
 250	bool found = false;
 251	bool last = false;
 252	struct rb_node *n;
 
 
 
 
 
 253
 254	sr = tipc_service_find_range(sc, lower);
 255	if (!sr)
 256		return NULL;
 257
 258	/* Find exact matching service range */
 259	for (n = &sr->tree_node; n; n = rb_next(n)) {
 260		sr = container_of(n, struct service_range, tree_node);
 261		if (sr->upper == upper)
 262			break;
 
 
 263	}
 264	if (!n || sr->lower != lower || sr->upper != upper)
 265		return NULL;
 266
 267	/* Find publication, if it exists */
 268	list_for_each_entry(p, &sr->all_publ, all_publ) {
 269		if (p->key != key || (node && node != p->node))
 270			continue;
 271		found = true;
 272		break;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 273	}
 274	if (!found)
 275		return NULL;
 276
 277	list_del(&p->all_publ);
 278	list_del(&p->local_publ);
 279	if (list_empty(&sr->all_publ))
 280		last = true;
 281
 282	/* Notify any waiting subscriptions */
 283	list_for_each_entry_safe(sub, tmp, &sc->subscriptions, service_list) {
 284		tipc_sub_report_overlap(sub, p->lower, p->upper, TIPC_WITHDRAWN,
 285					p->port, p->node, p->scope, last);
 
 
 
 
 
 286	}
 287	*rng = sr;
 288	return p;
 289}
 290
 291/**
 292 * tipc_service_subscribe - attach a subscription, and optionally
 293 * issue the prescribed number of events if there is any service
 294 * range overlapping with the requested range
 295 */
 296static void tipc_service_subscribe(struct tipc_service *service,
 297				   struct tipc_subscription *sub)
 298{
 299	struct tipc_subscr *sb = &sub->evt.s;
 300	struct service_range *sr;
 301	struct tipc_name_seq ns;
 302	struct publication *p;
 303	struct rb_node *n;
 304	bool first;
 305
 306	ns.type = tipc_sub_read(sb, seq.type);
 307	ns.lower = tipc_sub_read(sb, seq.lower);
 308	ns.upper = tipc_sub_read(sb, seq.upper);
 309
 310	tipc_sub_get(sub);
 311	list_add(&sub->service_list, &service->subscriptions);
 312
 313	if (tipc_sub_read(sb, filter) & TIPC_SUB_NO_STATUS)
 314		return;
 315
 316	for (n = rb_first(&service->ranges); n; n = rb_next(n)) {
 317		sr = container_of(n, struct service_range, tree_node);
 318		if (sr->lower > ns.upper)
 319			break;
 320		if (!tipc_sub_check_overlap(&ns, sr->lower, sr->upper))
 321			continue;
 322		first = true;
 323
 324		list_for_each_entry(p, &sr->all_publ, all_publ) {
 325			tipc_sub_report_overlap(sub, sr->lower, sr->upper,
 326						TIPC_PUBLISHED,	p->port,
 327						p->node, p->scope, first);
 328			first = false;
 
 
 
 329		}
 
 330	}
 331}
 332
 333static struct tipc_service *tipc_service_find(struct net *net, u32 type)
 334{
 335	struct name_table *nt = tipc_name_table(net);
 336	struct hlist_head *service_head;
 337	struct tipc_service *service;
 338
 339	service_head = &nt->services[hash(type)];
 340	hlist_for_each_entry_rcu(service, service_head, service_list) {
 341		if (service->type == type)
 342			return service;
 343	}
 
 344	return NULL;
 345};
 346
 347struct publication *tipc_nametbl_insert_publ(struct net *net, u32 type,
 348					     u32 lower, u32 upper,
 349					     u32 scope, u32 node,
 350					     u32 port, u32 key)
 351{
 352	struct name_table *nt = tipc_name_table(net);
 353	struct tipc_service *sc;
 354	struct publication *p;
 355
 356	if (scope > TIPC_NODE_SCOPE || lower > upper) {
 357		pr_debug("Failed to bind illegal {%u,%u,%u} with scope %u\n",
 
 358			 type, lower, upper, scope);
 359		return NULL;
 360	}
 361	sc = tipc_service_find(net, type);
 362	if (!sc)
 363		sc = tipc_service_create(type, &nt->services[hash(type)]);
 364	if (!sc)
 365		return NULL;
 366
 367	spin_lock_bh(&sc->lock);
 368	p = tipc_service_insert_publ(net, sc, type, lower, upper,
 369				     scope, node, port, key);
 370	spin_unlock_bh(&sc->lock);
 371	return p;
 372}
 373
 374struct publication *tipc_nametbl_remove_publ(struct net *net, u32 type,
 375					     u32 lower, u32 upper,
 376					     u32 node, u32 key)
 377{
 378	struct tipc_service *sc = tipc_service_find(net, type);
 379	struct service_range *sr = NULL;
 380	struct publication *p = NULL;
 381
 382	if (!sc)
 383		return NULL;
 384
 385	spin_lock_bh(&sc->lock);
 386	p = tipc_service_remove_publ(net, sc, lower, upper, node, key, &sr);
 387
 388	/* Remove service range item if this was its last publication */
 389	if (sr && list_empty(&sr->all_publ)) {
 390		rb_erase(&sr->tree_node, &sc->ranges);
 391		kfree(sr);
 392	}
 393
 394	/* Delete service item if this no more publications and subscriptions */
 395	if (RB_EMPTY_ROOT(&sc->ranges) && list_empty(&sc->subscriptions)) {
 396		hlist_del_init_rcu(&sc->service_list);
 397		kfree_rcu(sc, rcu);
 398	}
 399	spin_unlock_bh(&sc->lock);
 400	return p;
 401}
 402
 403/**
 404 * tipc_nametbl_translate - perform service instance to socket translation
 405 *
 406 * On entry, 'dnode' is the search domain used during translation.
 407 *
 408 * On exit:
 409 * - if translation is deferred to another node, leave 'dnode' unchanged and
 410 *   return 0
 411 * - if translation is attempted and succeeds, set 'dnode' to the publishing
 412 *   node and return the published (non-zero) port number
 413 * - if translation is attempted and fails, set 'dnode' to 0 and return 0
 414 *
 415 * Note that for legacy users (node configured with Z.C.N address format) the
 416 * 'closest-first' lookup algorithm must be maintained, i.e., if dnode is 0
 417 * we must look in the local binding list first
 418 */
 419u32 tipc_nametbl_translate(struct net *net, u32 type, u32 instance, u32 *dnode)
 420{
 421	struct tipc_net *tn = tipc_net(net);
 422	bool legacy = tn->legacy_addr_format;
 423	u32 self = tipc_own_addr(net);
 424	struct service_range *sr;
 425	struct tipc_service *sc;
 426	struct list_head *list;
 427	struct publication *p;
 428	u32 port = 0;
 429	u32 node = 0;
 430
 431	if (!tipc_in_scope(legacy, *dnode, self))
 432		return 0;
 433
 434	rcu_read_lock();
 435	sc = tipc_service_find(net, type);
 436	if (unlikely(!sc))
 437		goto not_found;
 
 
 
 
 
 438
 439	spin_lock_bh(&sc->lock);
 440	sr = tipc_service_find_range(sc, instance);
 441	if (unlikely(!sr))
 442		goto no_match;
 443
 444	/* Select lookup algorithm: local, closest-first or round-robin */
 445	if (*dnode == self) {
 446		list = &sr->local_publ;
 447		if (list_empty(list))
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 448			goto no_match;
 449		p = list_first_entry(list, struct publication, local_publ);
 450		list_move_tail(&p->local_publ, &sr->local_publ);
 451	} else if (legacy && !*dnode && !list_empty(&sr->local_publ)) {
 452		list = &sr->local_publ;
 453		p = list_first_entry(list, struct publication, local_publ);
 454		list_move_tail(&p->local_publ, &sr->local_publ);
 455	} else {
 456		list = &sr->all_publ;
 457		p = list_first_entry(list, struct publication, all_publ);
 458		list_move_tail(&p->all_publ, &sr->all_publ);
 459	}
 460	port = p->port;
 461	node = p->node;
 
 462no_match:
 463	spin_unlock_bh(&sc->lock);
 464not_found:
 465	rcu_read_unlock();
 466	*dnode = node;
 467	return port;
 468}
 469
 470bool tipc_nametbl_lookup(struct net *net, u32 type, u32 instance, u32 scope,
 471			 struct list_head *dsts, int *dstcnt, u32 exclude,
 472			 bool all)
 473{
 474	u32 self = tipc_own_addr(net);
 475	struct service_range *sr;
 476	struct tipc_service *sc;
 477	struct publication *p;
 478
 479	*dstcnt = 0;
 480	rcu_read_lock();
 481	sc = tipc_service_find(net, type);
 482	if (unlikely(!sc))
 483		goto exit;
 484
 485	spin_lock_bh(&sc->lock);
 486
 487	sr = tipc_service_find_range(sc, instance);
 488	if (!sr)
 489		goto no_match;
 490
 491	list_for_each_entry(p, &sr->all_publ, all_publ) {
 492		if (p->scope != scope)
 493			continue;
 494		if (p->port == exclude && p->node == self)
 495			continue;
 496		tipc_dest_push(dsts, p->node, p->port);
 497		(*dstcnt)++;
 498		if (all)
 499			continue;
 500		list_move_tail(&p->all_publ, &sr->all_publ);
 501		break;
 502	}
 503no_match:
 504	spin_unlock_bh(&sc->lock);
 505exit:
 506	rcu_read_unlock();
 507	return !list_empty(dsts);
 508}
 509
 510void tipc_nametbl_mc_lookup(struct net *net, u32 type, u32 lower, u32 upper,
 511			    u32 scope, bool exact, struct list_head *dports)
 
 
 
 
 
 
 
 
 
 
 
 
 512{
 513	struct service_range *sr;
 514	struct tipc_service *sc;
 515	struct publication *p;
 516	struct rb_node *n;
 
 
 
 
 
 
 517
 518	rcu_read_lock();
 519	sc = tipc_service_find(net, type);
 520	if (!sc)
 521		goto exit;
 522
 523	spin_lock_bh(&sc->lock);
 
 
 
 524
 525	for (n = rb_first(&sc->ranges); n; n = rb_next(n)) {
 526		sr = container_of(n, struct service_range, tree_node);
 527		if (sr->upper < lower)
 528			continue;
 529		if (sr->lower > upper)
 530			break;
 531		list_for_each_entry(p, &sr->local_publ, local_publ) {
 532			if (p->scope == scope || (!exact && p->scope < scope))
 533				tipc_dest_push(dports, 0, p->port);
 
 
 534		}
 535	}
 536	spin_unlock_bh(&sc->lock);
 537exit:
 538	rcu_read_unlock();
 539}
 540
 541/* tipc_nametbl_lookup_dst_nodes - find broadcast destination nodes
 542 * - Creates list of nodes that overlap the given multicast address
 543 * - Determines if any node local destinations overlap
 544 */
 545void tipc_nametbl_lookup_dst_nodes(struct net *net, u32 type, u32 lower,
 546				   u32 upper, struct tipc_nlist *nodes)
 547{
 548	struct service_range *sr;
 549	struct tipc_service *sc;
 550	struct publication *p;
 551	struct rb_node *n;
 552
 553	rcu_read_lock();
 554	sc = tipc_service_find(net, type);
 555	if (!sc)
 556		goto exit;
 557
 558	spin_lock_bh(&sc->lock);
 559
 560	for (n = rb_first(&sc->ranges); n; n = rb_next(n)) {
 561		sr = container_of(n, struct service_range, tree_node);
 562		if (sr->upper < lower)
 563			continue;
 564		if (sr->lower > upper)
 565			break;
 566		list_for_each_entry(p, &sr->all_publ, all_publ) {
 567			tipc_nlist_add(nodes, p->node);
 568		}
 569	}
 570	spin_unlock_bh(&sc->lock);
 571exit:
 572	rcu_read_unlock();
 573}
 574
 575/* tipc_nametbl_build_group - build list of communication group members
 576 */
 577void tipc_nametbl_build_group(struct net *net, struct tipc_group *grp,
 578			      u32 type, u32 scope)
 579{
 580	struct service_range *sr;
 581	struct tipc_service *sc;
 582	struct publication *p;
 583	struct rb_node *n;
 584
 585	rcu_read_lock();
 586	sc = tipc_service_find(net, type);
 587	if (!sc)
 588		goto exit;
 589
 590	spin_lock_bh(&sc->lock);
 591	for (n = rb_first(&sc->ranges); n; n = rb_next(n)) {
 592		sr = container_of(n, struct service_range, tree_node);
 593		list_for_each_entry(p, &sr->all_publ, all_publ) {
 594			if (p->scope != scope)
 595				continue;
 596			tipc_group_add_member(grp, p->node, p->port, p->lower);
 597		}
 598	}
 599	spin_unlock_bh(&sc->lock);
 600exit:
 601	rcu_read_unlock();
 
 602}
 603
 604/* tipc_nametbl_publish - add service binding to name table
 
 605 */
 606struct publication *tipc_nametbl_publish(struct net *net, u32 type, u32 lower,
 607					 u32 upper, u32 scope, u32 port,
 608					 u32 key)
 609{
 610	struct name_table *nt = tipc_name_table(net);
 611	struct tipc_net *tn = tipc_net(net);
 612	struct publication *p = NULL;
 613	struct sk_buff *skb = NULL;
 614
 615	spin_lock_bh(&tn->nametbl_lock);
 616
 617	if (nt->local_publ_count >= TIPC_MAX_PUBL) {
 618		pr_warn("Bind failed, max limit %u reached\n", TIPC_MAX_PUBL);
 619		goto exit;
 620	}
 621
 622	p = tipc_nametbl_insert_publ(net, type, lower, upper, scope,
 623				     tipc_own_addr(net), port, key);
 624	if (p) {
 625		nt->local_publ_count++;
 626		skb = tipc_named_publish(net, p);
 
 627	}
 628exit:
 629	spin_unlock_bh(&tn->nametbl_lock);
 630
 631	if (skb)
 632		tipc_node_broadcast(net, skb);
 633	return p;
 634}
 635
 636/**
 637 * tipc_nametbl_withdraw - withdraw a service binding
 638 */
 639int tipc_nametbl_withdraw(struct net *net, u32 type, u32 lower,
 640			  u32 upper, u32 key)
 641{
 642	struct name_table *nt = tipc_name_table(net);
 643	struct tipc_net *tn = tipc_net(net);
 644	u32 self = tipc_own_addr(net);
 645	struct sk_buff *skb = NULL;
 646	struct publication *p;
 647
 648	spin_lock_bh(&tn->nametbl_lock);
 649
 650	p = tipc_nametbl_remove_publ(net, type, lower, upper, self, key);
 651	if (p) {
 652		nt->local_publ_count--;
 653		skb = tipc_named_withdraw(net, p);
 654		list_del_init(&p->binding_sock);
 655		kfree_rcu(p, rcu);
 656	} else {
 657		pr_err("Failed to remove local publication {%u,%u,%u}/%u\n",
 658		       type, lower, upper, key);
 659	}
 660	spin_unlock_bh(&tn->nametbl_lock);
 661
 662	if (skb) {
 663		tipc_node_broadcast(net, skb);
 
 
 
 
 
 
 664		return 1;
 665	}
 
 
 
 
 666	return 0;
 667}
 668
 669/**
 670 * tipc_nametbl_subscribe - add a subscription object to the name table
 671 */
 672bool tipc_nametbl_subscribe(struct tipc_subscription *sub)
 673{
 674	struct name_table *nt = tipc_name_table(sub->net);
 675	struct tipc_net *tn = tipc_net(sub->net);
 676	struct tipc_subscr *s = &sub->evt.s;
 677	u32 type = tipc_sub_read(s, seq.type);
 678	struct tipc_service *sc;
 679	bool res = true;
 680
 681	spin_lock_bh(&tn->nametbl_lock);
 682	sc = tipc_service_find(sub->net, type);
 683	if (!sc)
 684		sc = tipc_service_create(type, &nt->services[hash(type)]);
 685	if (sc) {
 686		spin_lock_bh(&sc->lock);
 687		tipc_service_subscribe(sc, sub);
 688		spin_unlock_bh(&sc->lock);
 689	} else {
 690		pr_warn("Failed to subscribe for {%u,%u,%u}\n", type,
 691			tipc_sub_read(s, seq.lower),
 692			tipc_sub_read(s, seq.upper));
 693		res = false;
 694	}
 695	spin_unlock_bh(&tn->nametbl_lock);
 696	return res;
 697}
 698
 699/**
 700 * tipc_nametbl_unsubscribe - remove a subscription object from name table
 701 */
 702void tipc_nametbl_unsubscribe(struct tipc_subscription *sub)
 703{
 704	struct tipc_net *tn = tipc_net(sub->net);
 705	struct tipc_subscr *s = &sub->evt.s;
 706	u32 type = tipc_sub_read(s, seq.type);
 707	struct tipc_service *sc;
 708
 709	spin_lock_bh(&tn->nametbl_lock);
 710	sc = tipc_service_find(sub->net, type);
 711	if (!sc)
 712		goto exit;
 713
 714	spin_lock_bh(&sc->lock);
 715	list_del_init(&sub->service_list);
 716	tipc_sub_put(sub);
 717
 718	/* Delete service item if no more publications and subscriptions */
 719	if (RB_EMPTY_ROOT(&sc->ranges) && list_empty(&sc->subscriptions)) {
 720		hlist_del_init_rcu(&sc->service_list);
 721		kfree_rcu(sc, rcu);
 722	}
 723	spin_unlock_bh(&sc->lock);
 724exit:
 725	spin_unlock_bh(&tn->nametbl_lock);
 726}
 727
 728int tipc_nametbl_init(struct net *net)
 729{
 730	struct tipc_net *tn = tipc_net(net);
 731	struct name_table *nt;
 732	int i;
 733
 734	nt = kzalloc(sizeof(*nt), GFP_ATOMIC);
 735	if (!nt)
 736		return -ENOMEM;
 737
 738	for (i = 0; i < TIPC_NAMETBL_SIZE; i++)
 739		INIT_HLIST_HEAD(&nt->services[i]);
 740
 741	INIT_LIST_HEAD(&nt->node_scope);
 742	INIT_LIST_HEAD(&nt->cluster_scope);
 743	tn->nametbl = nt;
 744	spin_lock_init(&tn->nametbl_lock);
 745	return 0;
 746}
 747
 748/**
 749 *  tipc_service_delete - purge all publications for a service and delete it
 750 */
 751static void tipc_service_delete(struct net *net, struct tipc_service *sc)
 
 752{
 753	struct service_range *sr, *tmpr;
 754	struct publication *p, *tmp;
 
 
 
 
 
 755
 756	spin_lock_bh(&sc->lock);
 757	rbtree_postorder_for_each_entry_safe(sr, tmpr, &sc->ranges, tree_node) {
 758		list_for_each_entry_safe(p, tmp, &sr->all_publ, all_publ) {
 759			tipc_service_remove_publ(net, sc, p->lower, p->upper,
 760						 p->node, p->key, &sr);
 761			kfree_rcu(p, rcu);
 762		}
 763		rb_erase(&sr->tree_node, &sc->ranges);
 764		kfree(sr);
 765	}
 766	hlist_del_init_rcu(&sc->service_list);
 767	spin_unlock_bh(&sc->lock);
 768	kfree_rcu(sc, rcu);
 769}
 770
 771void tipc_nametbl_stop(struct net *net)
 772{
 773	struct name_table *nt = tipc_name_table(net);
 774	struct tipc_net *tn = tipc_net(net);
 775	struct hlist_head *service_head;
 776	struct tipc_service *service;
 777	u32 i;
 778
 779	/* Verify name table is empty and purge any lingering
 780	 * publications, then release the name table
 781	 */
 782	spin_lock_bh(&tn->nametbl_lock);
 783	for (i = 0; i < TIPC_NAMETBL_SIZE; i++) {
 784		if (hlist_empty(&nt->services[i]))
 785			continue;
 786		service_head = &nt->services[i];
 787		hlist_for_each_entry_rcu(service, service_head, service_list) {
 788			tipc_service_delete(net, service);
 789		}
 
 
 
 790	}
 791	spin_unlock_bh(&tn->nametbl_lock);
 792
 793	synchronize_net();
 794	kfree(nt);
 795}
 796
 797static int __tipc_nl_add_nametable_publ(struct tipc_nl_msg *msg,
 798					struct tipc_service *service,
 799					struct service_range *sr,
 800					u32 *last_key)
 
 801{
 802	struct publication *p;
 803	struct nlattr *attrs;
 804	struct nlattr *b;
 805	void *hdr;
 806
 807	if (*last_key) {
 808		list_for_each_entry(p, &sr->all_publ, all_publ)
 809			if (p->key == *last_key)
 810				break;
 811		if (p->key != *last_key)
 812			return -EPIPE;
 813	} else {
 814		p = list_first_entry(&sr->all_publ,
 815				     struct publication,
 816				     all_publ);
 817	}
 818
 819	list_for_each_entry_from(p, &sr->all_publ, all_publ) {
 820		*last_key = p->key;
 821
 822		hdr = genlmsg_put(msg->skb, msg->portid, msg->seq,
 823				  &tipc_genl_family, NLM_F_MULTI,
 824				  TIPC_NL_NAME_TABLE_GET);
 825		if (!hdr)
 826			return -EMSGSIZE;
 827
 828		attrs = nla_nest_start(msg->skb, TIPC_NLA_NAME_TABLE);
 829		if (!attrs)
 830			goto msg_full;
 831
 832		b = nla_nest_start(msg->skb, TIPC_NLA_NAME_TABLE_PUBL);
 833		if (!b)
 834			goto attr_msg_full;
 835
 836		if (nla_put_u32(msg->skb, TIPC_NLA_PUBL_TYPE, service->type))
 837			goto publ_msg_full;
 838		if (nla_put_u32(msg->skb, TIPC_NLA_PUBL_LOWER, sr->lower))
 839			goto publ_msg_full;
 840		if (nla_put_u32(msg->skb, TIPC_NLA_PUBL_UPPER, sr->upper))
 841			goto publ_msg_full;
 842		if (nla_put_u32(msg->skb, TIPC_NLA_PUBL_SCOPE, p->scope))
 843			goto publ_msg_full;
 844		if (nla_put_u32(msg->skb, TIPC_NLA_PUBL_NODE, p->node))
 845			goto publ_msg_full;
 846		if (nla_put_u32(msg->skb, TIPC_NLA_PUBL_REF, p->port))
 847			goto publ_msg_full;
 848		if (nla_put_u32(msg->skb, TIPC_NLA_PUBL_KEY, p->key))
 849			goto publ_msg_full;
 850
 851		nla_nest_end(msg->skb, b);
 852		nla_nest_end(msg->skb, attrs);
 853		genlmsg_end(msg->skb, hdr);
 854	}
 855	*last_key = 0;
 856
 857	return 0;
 858
 859publ_msg_full:
 860	nla_nest_cancel(msg->skb, b);
 861attr_msg_full:
 862	nla_nest_cancel(msg->skb, attrs);
 863msg_full:
 864	genlmsg_cancel(msg->skb, hdr);
 865
 866	return -EMSGSIZE;
 867}
 868
 869static int __tipc_nl_service_range_list(struct tipc_nl_msg *msg,
 870					struct tipc_service *sc,
 871					u32 *last_lower, u32 *last_key)
 872{
 873	struct service_range *sr;
 874	struct rb_node *n;
 875	int err;
 876
 877	for (n = rb_first(&sc->ranges); n; n = rb_next(n)) {
 878		sr = container_of(n, struct service_range, tree_node);
 879		if (sr->lower < *last_lower)
 880			continue;
 881		err = __tipc_nl_add_nametable_publ(msg, sc, sr, last_key);
 882		if (err) {
 883			*last_lower = sr->lower;
 884			return err;
 885		}
 886	}
 887	*last_lower = 0;
 888	return 0;
 889}
 890
 891static int tipc_nl_service_list(struct net *net, struct tipc_nl_msg *msg,
 892				u32 *last_type, u32 *last_lower, u32 *last_key)
 
 
 893{
 894	struct tipc_net *tn = tipc_net(net);
 895	struct tipc_service *service = NULL;
 896	struct hlist_head *head;
 897	int err;
 
 
 
 898	int i;
 
 899
 900	if (*last_type)
 901		i = hash(*last_type);
 902	else
 903		i = 0;
 904
 905	for (; i < TIPC_NAMETBL_SIZE; i++) {
 906		head = &tn->nametbl->services[i];
 907
 908		if (*last_type) {
 909			service = tipc_service_find(net, *last_type);
 910			if (!service)
 911				return -EPIPE;
 912		} else {
 913			hlist_for_each_entry_rcu(service, head, service_list)
 914				break;
 915			if (!service)
 916				continue;
 917		}
 918
 919		hlist_for_each_entry_from_rcu(service, service_list) {
 920			spin_lock_bh(&service->lock);
 921			err = __tipc_nl_service_range_list(msg, service,
 922							   last_lower,
 923							   last_key);
 924
 925			if (err) {
 926				*last_type = service->type;
 927				spin_unlock_bh(&service->lock);
 928				return err;
 929			}
 930			spin_unlock_bh(&service->lock);
 931		}
 932		*last_type = 0;
 933	}
 934	return 0;
 935}
 936
 937int tipc_nl_name_table_dump(struct sk_buff *skb, struct netlink_callback *cb)
 
 
 
 
 938{
 939	struct net *net = sock_net(skb->sk);
 940	u32 last_type = cb->args[0];
 941	u32 last_lower = cb->args[1];
 942	u32 last_key = cb->args[2];
 943	int done = cb->args[3];
 944	struct tipc_nl_msg msg;
 945	int err;
 946
 947	if (done)
 
 
 
 948		return 0;
 949
 950	msg.skb = skb;
 951	msg.portid = NETLINK_CB(cb->skb).portid;
 952	msg.seq = cb->nlh->nlmsg_seq;
 953
 954	rcu_read_lock();
 955	err = tipc_nl_service_list(net, &msg, &last_type,
 956				   &last_lower, &last_key);
 957	if (!err) {
 958		done = 1;
 959	} else if (err != -EMSGSIZE) {
 960		/* We never set seq or call nl_dump_check_consistent() this
 961		 * means that setting prev_seq here will cause the consistence
 962		 * check to fail in the netlink callback handler. Resulting in
 963		 * the NLMSG_DONE message having the NLM_F_DUMP_INTR flag set if
 964		 * we got an error.
 965		 */
 966		cb->prev_seq = 1;
 967	}
 968	rcu_read_unlock();
 969
 970	cb->args[0] = last_type;
 971	cb->args[1] = last_lower;
 972	cb->args[2] = last_key;
 973	cb->args[3] = done;
 974
 975	return skb->len;
 976}
 977
 978struct tipc_dest *tipc_dest_find(struct list_head *l, u32 node, u32 port)
 979{
 980	u64 value = (u64)node << 32 | port;
 981	struct tipc_dest *dst;
 982
 983	list_for_each_entry(dst, l, list) {
 984		if (dst->value != value)
 985			continue;
 986		return dst;
 987	}
 988	return NULL;
 989}
 990
 991bool tipc_dest_push(struct list_head *l, u32 node, u32 port)
 992{
 993	u64 value = (u64)node << 32 | port;
 994	struct tipc_dest *dst;
 
 
 
 
 995
 996	if (tipc_dest_find(l, node, port))
 997		return false;
 998
 999	dst = kmalloc(sizeof(*dst), GFP_ATOMIC);
1000	if (unlikely(!dst))
1001		return false;
1002	dst->value = value;
1003	list_add(&dst->list, l);
1004	return true;
1005}
1006
1007bool tipc_dest_pop(struct list_head *l, u32 *node, u32 *port)
1008{
1009	struct tipc_dest *dst;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1010
1011	if (list_empty(l))
1012		return false;
1013	dst = list_first_entry(l, typeof(*dst), list);
1014	if (port)
1015		*port = dst->port;
1016	if (node)
1017		*node = dst->node;
1018	list_del(&dst->list);
1019	kfree(dst);
1020	return true;
1021}
1022
1023bool tipc_dest_del(struct list_head *l, u32 node, u32 port)
 
 
 
 
 
1024{
1025	struct tipc_dest *dst;
 
 
1026
1027	dst = tipc_dest_find(l, node, port);
1028	if (!dst)
1029		return false;
1030	list_del(&dst->list);
1031	kfree(dst);
1032	return true;
1033}
1034
1035void tipc_dest_list_purge(struct list_head *l)
1036{
1037	struct tipc_dest *dst, *tmp;
1038
1039	list_for_each_entry_safe(dst, tmp, l, list) {
1040		list_del(&dst->list);
1041		kfree(dst);
1042	}
1043}
1044
1045int tipc_dest_list_len(struct list_head *l)
1046{
1047	struct tipc_dest *dst;
1048	int i = 0;
 
 
1049
1050	list_for_each_entry(dst, l, list) {
1051		i++;
 
 
 
 
 
 
 
 
 
 
1052	}
1053	return i;
 
 
1054}