name_table.c 25.1 KB
Newer Older
P
Per Liden 已提交
1 2
/*
 * net/tipc/name_table.c: TIPC name table code
3
 *
P
Per Liden 已提交
4
 * Copyright (c) 2000-2006, Ericsson AB
5
 * Copyright (c) 2004-2008, 2010-2011, Wind River Systems
P
Per Liden 已提交
6 7
 * All rights reserved.
 *
P
Per Liden 已提交
8
 * Redistribution and use in source and binary forms, with or without
P
Per Liden 已提交
9 10
 * modification, are permitted provided that the following conditions are met:
 *
P
Per Liden 已提交
11 12 13 14 15 16 17 18
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the names of the copyright holders nor the names of its
 *    contributors may be used to endorse or promote products derived from
 *    this software without specific prior written permission.
P
Per Liden 已提交
19
 *
P
Per Liden 已提交
20 21 22 23 24 25 26 27 28 29 30 31 32 33
 * Alternatively, this software may be distributed under the terms of the
 * GNU General Public License ("GPL") version 2 as published by the Free
 * Software Foundation.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
P
Per Liden 已提交
34 35 36 37 38 39 40 41 42 43
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include "core.h"
#include "config.h"
#include "name_table.h"
#include "name_distr.h"
#include "subscr.h"
#include "port.h"

A
Adrian Bunk 已提交
44
static int tipc_nametbl_size = 1024;		/* must be a power of 2 */
P
Per Liden 已提交
45 46

/**
47
 * struct name_info - name sequence publication info
48 49 50 51 52 53 54 55 56 57
 * @node_list: circular list of publications made by own node
 * @cluster_list: circular list of publications made by own cluster
 * @zone_list: circular list of publications made by own zone
 * @node_list_size: number of entries in "node_list"
 * @cluster_list_size: number of entries in "cluster_list"
 * @zone_list_size: number of entries in "zone_list"
 *
 * Note: The zone list always contains at least one entry, since all
 *       publications of the associated name sequence belong to it.
 *       (The cluster and node lists may be empty.)
P
Per Liden 已提交
58 59
 */

60
struct name_info {
61 62 63
	struct list_head node_list;
	struct list_head cluster_list;
	struct list_head zone_list;
64 65 66
	u32 node_list_size;
	u32 cluster_list_size;
	u32 zone_list_size;
P
Per Liden 已提交
67 68
};

69 70 71 72 73 74 75 76 77 78 79 80 81
/**
 * struct sub_seq - container for all published instances of a name sequence
 * @lower: name sequence lower bound
 * @upper: name sequence upper bound
 * @info: pointer to name sequence publication info
 */

struct sub_seq {
	u32 lower;
	u32 upper;
	struct name_info *info;
};

82
/**
P
Per Liden 已提交
83 84 85 86 87
 * struct name_seq - container for all published instances of a name type
 * @type: 32 bit 'type' value for name sequence
 * @sseq: pointer to dynamically-sized array of sub-sequences of this 'type';
 *        sub-sequences are sorted in ascending order
 * @alloc: number of sub-sequences currently in array
88
 * @first_free: array index of first unused sub-sequence entry
P
Per Liden 已提交
89 90
 * @ns_list: links to adjacent name sequences in hash chain
 * @subscriptions: list of subscriptions for this 'type'
91
 * @lock: spinlock controlling access to publication lists of all sub-sequences
P
Per Liden 已提交
92 93 94 95 96 97 98 99 100 101 102 103 104 105
 */

struct name_seq {
	u32 type;
	struct sub_seq *sseqs;
	u32 alloc;
	u32 first_free;
	struct hlist_node ns_list;
	struct list_head subscriptions;
	spinlock_t lock;
};

/**
 * struct name_table - table containing all existing port name publications
106
 * @types: pointer to fixed-sized array of name sequence lists,
P
Per Liden 已提交
107 108 109 110 111 112 113 114 115
 *         accessed via hashing on 'type'; name sequence lists are *not* sorted
 * @local_publ_count: number of publications issued by this node
 */

struct name_table {
	struct hlist_head *types;
	u32 local_publ_count;
};

116
static struct name_table table;
I
Ingo Molnar 已提交
117
DEFINE_RWLOCK(tipc_nametbl_lock);
P
Per Liden 已提交
118

S
Sam Ravnborg 已提交
119
static int hash(int x)
P
Per Liden 已提交
120
{
E
Eric Dumazet 已提交
121
	return x & (tipc_nametbl_size - 1);
P
Per Liden 已提交
122 123 124 125 126 127
}

/**
 * publ_create - create a publication structure
 */

128 129
static struct publication *publ_create(u32 type, u32 lower, u32 upper,
				       u32 scope, u32 node, u32 port_ref,
P
Per Liden 已提交
130 131
				       u32 key)
{
132
	struct publication *publ = kzalloc(sizeof(*publ), GFP_ATOMIC);
P
Per Liden 已提交
133
	if (publ == NULL) {
134
		warn("Publication creation failure, no memory\n");
135
		return NULL;
P
Per Liden 已提交
136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151
	}

	publ->type = type;
	publ->lower = lower;
	publ->upper = upper;
	publ->scope = scope;
	publ->node = node;
	publ->ref = port_ref;
	publ->key = key;
	INIT_LIST_HEAD(&publ->local_list);
	INIT_LIST_HEAD(&publ->pport_list);
	INIT_LIST_HEAD(&publ->subscr.nodesub_list);
	return publ;
}

/**
152
 * tipc_subseq_alloc - allocate a specified number of sub-sequence structures
P
Per Liden 已提交
153 154
 */

A
Adrian Bunk 已提交
155
static struct sub_seq *tipc_subseq_alloc(u32 cnt)
P
Per Liden 已提交
156
{
157
	struct sub_seq *sseq = kcalloc(cnt, sizeof(struct sub_seq), GFP_ATOMIC);
P
Per Liden 已提交
158 159 160 161
	return sseq;
}

/**
162
 * tipc_nameseq_create - create a name sequence structure for the specified 'type'
163
 *
P
Per Liden 已提交
164 165 166
 * Allocates a single sub-sequence structure and sets it to all 0's.
 */

A
Adrian Bunk 已提交
167
static struct name_seq *tipc_nameseq_create(u32 type, struct hlist_head *seq_head)
P
Per Liden 已提交
168
{
169
	struct name_seq *nseq = kzalloc(sizeof(*nseq), GFP_ATOMIC);
170
	struct sub_seq *sseq = tipc_subseq_alloc(1);
P
Per Liden 已提交
171 172

	if (!nseq || !sseq) {
173
		warn("Name sequence creation failed, no memory\n");
P
Per Liden 已提交
174 175
		kfree(nseq);
		kfree(sseq);
176
		return NULL;
P
Per Liden 已提交
177 178
	}

I
Ingo Molnar 已提交
179
	spin_lock_init(&nseq->lock);
P
Per Liden 已提交
180 181 182 183 184 185 186 187 188
	nseq->type = type;
	nseq->sseqs = sseq;
	nseq->alloc = 1;
	INIT_HLIST_NODE(&nseq->ns_list);
	INIT_LIST_HEAD(&nseq->subscriptions);
	hlist_add_head(&nseq->ns_list, seq_head);
	return nseq;
}

189 190 191 192 193 194 195 196 197 198 199 200 201
/*
 * nameseq_delete_empty - deletes a name sequence structure if now unused
 */
static void nameseq_delete_empty(struct name_seq *seq)
{
	if (!seq->first_free && list_empty(&seq->subscriptions)) {
		hlist_del_init(&seq->ns_list);
		kfree(seq->sseqs);
		kfree(seq);
	}
}

/*
P
Per Liden 已提交
202
 * nameseq_find_subseq - find sub-sequence (if any) matching a name instance
203
 *
P
Per Liden 已提交
204 205 206
 * Very time-critical, so binary searches through sub-sequence array.
 */

S
Sam Ravnborg 已提交
207 208
static struct sub_seq *nameseq_find_subseq(struct name_seq *nseq,
					   u32 instance)
P
Per Liden 已提交
209 210 211 212 213 214 215 216 217 218 219 220 221 222 223
{
	struct sub_seq *sseqs = nseq->sseqs;
	int low = 0;
	int high = nseq->first_free - 1;
	int mid;

	while (low <= high) {
		mid = (low + high) / 2;
		if (instance < sseqs[mid].lower)
			high = mid - 1;
		else if (instance > sseqs[mid].upper)
			low = mid + 1;
		else
			return &sseqs[mid];
	}
224
	return NULL;
P
Per Liden 已提交
225 226 227 228
}

/**
 * nameseq_locate_subseq - determine position of name instance in sub-sequence
229
 *
P
Per Liden 已提交
230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256
 * Returns index in sub-sequence array of the entry that contains the specified
 * instance value; if no entry contains that value, returns the position
 * where a new entry for it would be inserted in the array.
 *
 * Note: Similar to binary search code for locating a sub-sequence.
 */

static u32 nameseq_locate_subseq(struct name_seq *nseq, u32 instance)
{
	struct sub_seq *sseqs = nseq->sseqs;
	int low = 0;
	int high = nseq->first_free - 1;
	int mid;

	while (low <= high) {
		mid = (low + high) / 2;
		if (instance < sseqs[mid].lower)
			high = mid - 1;
		else if (instance > sseqs[mid].upper)
			low = mid + 1;
		else
			return mid;
	}
	return low;
}

/**
257
 * tipc_nameseq_insert_publ -
P
Per Liden 已提交
258 259
 */

A
Adrian Bunk 已提交
260 261 262
static struct publication *tipc_nameseq_insert_publ(struct name_seq *nseq,
						    u32 type, u32 lower, u32 upper,
						    u32 scope, u32 node, u32 port, u32 key)
P
Per Liden 已提交
263
{
264 265
	struct tipc_subscription *s;
	struct tipc_subscription *st;
P
Per Liden 已提交
266 267
	struct publication *publ;
	struct sub_seq *sseq;
268
	struct name_info *info;
P
Per Liden 已提交
269 270 271 272 273 274 275 276
	int created_subseq = 0;

	sseq = nameseq_find_subseq(nseq, lower);
	if (sseq) {

		/* Lower end overlaps existing entry => need an exact match */

		if ((sseq->lower != lower) || (sseq->upper != upper)) {
277 278
			warn("Cannot publish {%u,%u,%u}, overlap error\n",
			     type, lower, upper);
279
			return NULL;
P
Per Liden 已提交
280
		}
281 282

		info = sseq->info;
283 284 285 286 287 288 289

		/* Check if an identical publication already exists */
		list_for_each_entry(publ, &info->zone_list, zone_list) {
			if ((publ->ref == port) && (publ->key == key) &&
			    (!publ->node || (publ->node == node)))
				return NULL;
		}
P
Per Liden 已提交
290 291 292 293 294 295 296 297 298 299 300 301
	} else {
		u32 inspos;
		struct sub_seq *freesseq;

		/* Find where lower end should be inserted */

		inspos = nameseq_locate_subseq(nseq, lower);

		/* Fail if upper end overlaps into an existing entry */

		if ((inspos < nseq->first_free) &&
		    (upper >= nseq->sseqs[inspos].lower)) {
302 303
			warn("Cannot publish {%u,%u,%u}, overlap error\n",
			     type, lower, upper);
304
			return NULL;
P
Per Liden 已提交
305 306 307 308 309
		}

		/* Ensure there is space for new sub-sequence */

		if (nseq->first_free == nseq->alloc) {
310 311 312
			struct sub_seq *sseqs = tipc_subseq_alloc(nseq->alloc * 2);

			if (!sseqs) {
313 314
				warn("Cannot publish {%u,%u,%u}, no memory\n",
				     type, lower, upper);
315
				return NULL;
P
Per Liden 已提交
316
			}
317 318 319 320 321
			memcpy(sseqs, nseq->sseqs,
			       nseq->alloc * sizeof(struct sub_seq));
			kfree(nseq->sseqs);
			nseq->sseqs = sseqs;
			nseq->alloc *= 2;
P
Per Liden 已提交
322 323
		}

324 325 326 327 328 329 330
		info = kzalloc(sizeof(*info), GFP_ATOMIC);
		if (!info) {
			warn("Cannot publish {%u,%u,%u}, no memory\n",
			     type, lower, upper);
			return NULL;
		}

331 332 333 334
		INIT_LIST_HEAD(&info->node_list);
		INIT_LIST_HEAD(&info->cluster_list);
		INIT_LIST_HEAD(&info->zone_list);

P
Per Liden 已提交
335 336 337 338
		/* Insert new sub-sequence */

		sseq = &nseq->sseqs[inspos];
		freesseq = &nseq->sseqs[nseq->first_free];
339 340
		memmove(sseq + 1, sseq, (freesseq - sseq) * sizeof(*sseq));
		memset(sseq, 0, sizeof(*sseq));
P
Per Liden 已提交
341 342 343
		nseq->first_free++;
		sseq->lower = lower;
		sseq->upper = upper;
344
		sseq->info = info;
P
Per Liden 已提交
345 346 347 348 349 350 351
		created_subseq = 1;
	}

	/* Insert a publication: */

	publ = publ_create(type, lower, upper, scope, node, port, key);
	if (!publ)
352
		return NULL;
P
Per Liden 已提交
353

354
	list_add(&publ->zone_list, &info->zone_list);
355
	info->zone_list_size++;
P
Per Liden 已提交
356

357
	if (in_own_cluster(node)) {
358
		list_add(&publ->cluster_list, &info->cluster_list);
359
		info->cluster_list_size++;
P
Per Liden 已提交
360 361
	}

362
	if (in_own_node(node)) {
363
		list_add(&publ->node_list, &info->node_list);
364
		info->node_list_size++;
P
Per Liden 已提交
365 366
	}

367 368
	/*
	 * Any subscriptions waiting for notification?
P
Per Liden 已提交
369 370
	 */
	list_for_each_entry_safe(s, st, &nseq->subscriptions, nameseq_list) {
371 372 373 374
		tipc_subscr_report_overlap(s,
					   publ->lower,
					   publ->upper,
					   TIPC_PUBLISHED,
375
					   publ->ref,
376 377
					   publ->node,
					   created_subseq);
P
Per Liden 已提交
378 379 380 381 382
	}
	return publ;
}

/**
383
 * tipc_nameseq_remove_publ -
384
 *
385 386 387 388 389 390 391
 * NOTE: There may be cases where TIPC is asked to remove a publication
 * that is not in the name table.  For example, if another node issues a
 * publication for a name sequence that overlaps an existing name sequence
 * the publication will not be recorded, which means the publication won't
 * be found when the name sequence is later withdrawn by that node.
 * A failed withdraw request simply returns a failure indication and lets the
 * caller issue any error or warning messages associated with such a problem.
P
Per Liden 已提交
392 393
 */

A
Adrian Bunk 已提交
394 395
static struct publication *tipc_nameseq_remove_publ(struct name_seq *nseq, u32 inst,
						    u32 node, u32 ref, u32 key)
P
Per Liden 已提交
396 397 398
{
	struct publication *publ;
	struct sub_seq *sseq = nameseq_find_subseq(nseq, inst);
399
	struct name_info *info;
P
Per Liden 已提交
400
	struct sub_seq *free;
401
	struct tipc_subscription *s, *st;
P
Per Liden 已提交
402 403
	int removed_subseq = 0;

404
	if (!sseq)
405
		return NULL;
406

407 408
	info = sseq->info;

409
	/* Locate publication, if it exists */
410

411 412 413 414 415 416
	list_for_each_entry(publ, &info->zone_list, zone_list) {
		if ((publ->key == key) && (publ->ref == ref) &&
		    (!publ->node || (publ->node == node)))
			goto found;
	}
	return NULL;
417

418 419
found:
	/* Remove publication from zone scope list */
420

421
	list_del(&publ->zone_list);
422
	info->zone_list_size--;
P
Per Liden 已提交
423

424 425
	/* Remove publication from cluster scope list, if present */

426
	if (in_own_cluster(node)) {
427
		list_del(&publ->cluster_list);
428
		info->cluster_list_size--;
P
Per Liden 已提交
429
	}
430 431

	/* Remove publication from node scope list, if present */
P
Per Liden 已提交
432

433
	if (in_own_node(node)) {
434
		list_del(&publ->node_list);
435
		info->node_list_size--;
P
Per Liden 已提交
436 437
	}

438 439
	/* Contract subseq list if no more publications for that subseq */

440
	if (list_empty(&info->zone_list)) {
441
		kfree(info);
P
Per Liden 已提交
442
		free = &nseq->sseqs[nseq->first_free--];
443
		memmove(sseq, sseq + 1, (free - (sseq + 1)) * sizeof(*sseq));
P
Per Liden 已提交
444 445 446
		removed_subseq = 1;
	}

447 448
	/* Notify any waiting subscriptions */

P
Per Liden 已提交
449
	list_for_each_entry_safe(s, st, &nseq->subscriptions, nameseq_list) {
450 451 452
		tipc_subscr_report_overlap(s,
					   publ->lower,
					   publ->upper,
453 454
					   TIPC_WITHDRAWN,
					   publ->ref,
455 456
					   publ->node,
					   removed_subseq);
P
Per Liden 已提交
457
	}
458

P
Per Liden 已提交
459 460 461 462
	return publ;
}

/**
463
 * tipc_nameseq_subscribe: attach a subscription, and issue
P
Per Liden 已提交
464 465 466 467
 * the prescribed number of events if there is any sub-
 * sequence overlapping with the requested sequence
 */

468 469
static void tipc_nameseq_subscribe(struct name_seq *nseq,
					struct tipc_subscription *s)
P
Per Liden 已提交
470 471 472 473 474 475 476 477 478
{
	struct sub_seq *sseq = nseq->sseqs;

	list_add(&s->nameseq_list, &nseq->subscriptions);

	if (!sseq)
		return;

	while (sseq != &nseq->sseqs[nseq->first_free]) {
479 480 481
		if (tipc_subscr_overlap(s, sseq->lower, sseq->upper)) {
			struct publication *crs;
			struct name_info *info = sseq->info;
P
Per Liden 已提交
482 483
			int must_report = 1;

484
			list_for_each_entry(crs, &info->zone_list, zone_list) {
485 486
				tipc_subscr_report_overlap(s,
							   sseq->lower,
487 488 489 490 491
							   sseq->upper,
							   TIPC_PUBLISHED,
							   crs->ref,
							   crs->node,
							   must_report);
P
Per Liden 已提交
492
				must_report = 0;
493
			}
P
Per Liden 已提交
494 495 496 497 498 499 500 501 502 503 504 505 506
		}
		sseq++;
	}
}

static struct name_seq *nametbl_find_seq(u32 type)
{
	struct hlist_head *seq_head;
	struct hlist_node *seq_node;
	struct name_seq *ns;

	seq_head = &table.types[hash(type)];
	hlist_for_each_entry(ns, seq_node, seq_head, ns_list) {
507
		if (ns->type == type)
P
Per Liden 已提交
508 509 510
			return ns;
	}

511
	return NULL;
P
Per Liden 已提交
512 513
};

514 515
struct publication *tipc_nametbl_insert_publ(u32 type, u32 lower, u32 upper,
					     u32 scope, u32 node, u32 port, u32 key)
P
Per Liden 已提交
516 517 518
{
	struct name_seq *seq = nametbl_find_seq(type);

519 520 521 522
	if ((scope < TIPC_ZONE_SCOPE) || (scope > TIPC_NODE_SCOPE) ||
	    (lower > upper)) {
		dbg("Failed to publish illegal {%u,%u,%u} with scope %u\n",
		     type, lower, upper, scope);
523
		return NULL;
P
Per Liden 已提交
524 525
	}

526
	if (!seq)
527
		seq = tipc_nameseq_create(type, &table.types[hash(type)]);
P
Per Liden 已提交
528
	if (!seq)
529
		return NULL;
P
Per Liden 已提交
530

531 532
	return tipc_nameseq_insert_publ(seq, type, lower, upper,
					scope, node, port, key);
P
Per Liden 已提交
533 534
}

535
struct publication *tipc_nametbl_remove_publ(u32 type, u32 lower,
536
					     u32 node, u32 ref, u32 key)
P
Per Liden 已提交
537 538 539 540 541
{
	struct publication *publ;
	struct name_seq *seq = nametbl_find_seq(type);

	if (!seq)
542
		return NULL;
P
Per Liden 已提交
543

544
	publ = tipc_nameseq_remove_publ(seq, lower, node, ref, key);
545
	nameseq_delete_empty(seq);
P
Per Liden 已提交
546 547 548 549
	return publ;
}

/*
550
 * tipc_nametbl_translate - perform name translation
P
Per Liden 已提交
551
 *
552 553 554 555 556 557 558 559 560
 * On entry, 'destnode' is the search domain used during translation.
 *
 * On exit:
 * - if name translation is deferred to another node/cluster/zone,
 *   leaves 'destnode' unchanged (will be non-zero) and returns 0
 * - if name translation is attempted and succeeds, sets 'destnode'
 *   to publishing node and returns port reference (will be non-zero)
 * - if name translation is attempted and fails, sets 'destnode' to 0
 *   and returns 0
P
Per Liden 已提交
561 562
 */

563
u32 tipc_nametbl_translate(u32 type, u32 instance, u32 *destnode)
P
Per Liden 已提交
564 565
{
	struct sub_seq *sseq;
566
	struct name_info *info;
567
	struct publication *publ;
P
Per Liden 已提交
568
	struct name_seq *seq;
569
	u32 ref = 0;
570
	u32 node = 0;
P
Per Liden 已提交
571

572
	if (!tipc_in_scope(*destnode, tipc_own_addr))
P
Per Liden 已提交
573 574
		return 0;

575
	read_lock_bh(&tipc_nametbl_lock);
P
Per Liden 已提交
576 577 578 579 580 581 582
	seq = nametbl_find_seq(type);
	if (unlikely(!seq))
		goto not_found;
	sseq = nameseq_find_subseq(seq, instance);
	if (unlikely(!sseq))
		goto not_found;
	spin_lock_bh(&seq->lock);
583
	info = sseq->info;
P
Per Liden 已提交
584 585 586

	/* Closest-First Algorithm: */
	if (likely(!*destnode)) {
587 588 589 590 591 592 593 594 595 596 597 598
		if (!list_empty(&info->node_list)) {
			publ = list_first_entry(&info->node_list,
						struct publication,
						node_list);
			list_move_tail(&publ->node_list,
				       &info->node_list);
		} else if (!list_empty(&info->cluster_list)) {
			publ = list_first_entry(&info->cluster_list,
						struct publication,
						cluster_list);
			list_move_tail(&publ->cluster_list,
				       &info->cluster_list);
599
		} else {
600 601 602 603 604
			publ = list_first_entry(&info->zone_list,
						struct publication,
						zone_list);
			list_move_tail(&publ->zone_list,
				       &info->zone_list);
605
		}
P
Per Liden 已提交
606 607 608 609
	}

	/* Round-Robin Algorithm: */
	else if (*destnode == tipc_own_addr) {
610 611 612 613 614
		if (list_empty(&info->node_list))
			goto no_match;
		publ = list_first_entry(&info->node_list, struct publication,
					node_list);
		list_move_tail(&publ->node_list, &info->node_list);
615
	} else if (in_own_cluster_exact(*destnode)) {
616 617 618 619 620
		if (list_empty(&info->cluster_list))
			goto no_match;
		publ = list_first_entry(&info->cluster_list, struct publication,
					cluster_list);
		list_move_tail(&publ->cluster_list, &info->cluster_list);
P
Per Liden 已提交
621
	} else {
622 623 624
		publ = list_first_entry(&info->zone_list, struct publication,
					zone_list);
		list_move_tail(&publ->zone_list, &info->zone_list);
P
Per Liden 已提交
625
	}
626 627

	ref = publ->ref;
628
	node = publ->node;
629
no_match:
P
Per Liden 已提交
630 631
	spin_unlock_bh(&seq->lock);
not_found:
632
	read_unlock_bh(&tipc_nametbl_lock);
633
	*destnode = node;
634
	return ref;
P
Per Liden 已提交
635 636 637
}

/**
638
 * tipc_nametbl_mc_translate - find multicast destinations
639
 *
P
Per Liden 已提交
640 641 642 643 644 645
 * Creates list of all local ports that overlap the given multicast address;
 * also determines if any off-node ports overlap.
 *
 * Note: Publications with a scope narrower than 'limit' are ignored.
 * (i.e. local node-scope publications mustn't receive messages arriving
 * from another node, even if the multcast link brought it here)
646
 *
P
Per Liden 已提交
647 648 649
 * Returns non-zero if any off-node ports overlap
 */

650
int tipc_nametbl_mc_translate(u32 type, u32 lower, u32 upper, u32 limit,
651
			      struct tipc_port_list *dports)
P
Per Liden 已提交
652 653 654 655
{
	struct name_seq *seq;
	struct sub_seq *sseq;
	struct sub_seq *sseq_stop;
656
	struct name_info *info;
P
Per Liden 已提交
657 658
	int res = 0;

659
	read_lock_bh(&tipc_nametbl_lock);
P
Per Liden 已提交
660 661 662 663 664 665 666 667 668 669 670 671 672
	seq = nametbl_find_seq(type);
	if (!seq)
		goto exit;

	spin_lock_bh(&seq->lock);

	sseq = seq->sseqs + nameseq_locate_subseq(seq, lower);
	sseq_stop = seq->sseqs + seq->first_free;
	for (; sseq != sseq_stop; sseq++) {
		struct publication *publ;

		if (sseq->lower > upper)
			break;
673

674
		info = sseq->info;
675 676 677
		list_for_each_entry(publ, &info->node_list, node_list) {
			if (publ->scope <= limit)
				tipc_port_list_add(dports, publ->ref);
678 679
		}

680
		if (info->cluster_list_size != info->node_list_size)
681
			res = 1;
P
Per Liden 已提交
682 683 684 685
	}

	spin_unlock_bh(&seq->lock);
exit:
686
	read_unlock_bh(&tipc_nametbl_lock);
P
Per Liden 已提交
687 688 689
	return res;
}

690
/*
691
 * tipc_nametbl_publish - add name publication to network name tables
P
Per Liden 已提交
692 693
 */

694
struct publication *tipc_nametbl_publish(u32 type, u32 lower, u32 upper,
P
Per Liden 已提交
695 696 697 698 699
				    u32 scope, u32 port_ref, u32 key)
{
	struct publication *publ;

	if (table.local_publ_count >= tipc_max_publications) {
700
		warn("Publication failed, local publication limit reached (%u)\n",
P
Per Liden 已提交
701
		     tipc_max_publications);
702
		return NULL;
P
Per Liden 已提交
703 704
	}

705 706
	write_lock_bh(&tipc_nametbl_lock);
	publ = tipc_nametbl_insert_publ(type, lower, upper, scope,
P
Per Liden 已提交
707
				   tipc_own_addr, port_ref, key);
708 709
	if (likely(publ)) {
		table.local_publ_count++;
710
		tipc_named_publish(publ);
711
	}
712
	write_unlock_bh(&tipc_nametbl_lock);
P
Per Liden 已提交
713 714 715 716
	return publ;
}

/**
717
 * tipc_nametbl_withdraw - withdraw name publication from network name tables
P
Per Liden 已提交
718 719
 */

720
int tipc_nametbl_withdraw(u32 type, u32 lower, u32 ref, u32 key)
P
Per Liden 已提交
721 722 723
{
	struct publication *publ;

724 725
	write_lock_bh(&tipc_nametbl_lock);
	publ = tipc_nametbl_remove_publ(type, lower, tipc_own_addr, ref, key);
726
	if (likely(publ)) {
P
Per Liden 已提交
727
		table.local_publ_count--;
728
		tipc_named_withdraw(publ);
729
		write_unlock_bh(&tipc_nametbl_lock);
P
Per Liden 已提交
730 731 732 733
		list_del_init(&publ->pport_list);
		kfree(publ);
		return 1;
	}
734
	write_unlock_bh(&tipc_nametbl_lock);
735 736 737
	err("Unable to remove local publication\n"
	    "(type=%u, lower=%u, ref=%u, key=%u)\n",
	    type, lower, ref, key);
P
Per Liden 已提交
738 739 740 741
	return 0;
}

/**
742
 * tipc_nametbl_subscribe - add a subscription object to the name table
P
Per Liden 已提交
743 744
 */

745
void tipc_nametbl_subscribe(struct tipc_subscription *s)
P
Per Liden 已提交
746 747 748 749
{
	u32 type = s->seq.type;
	struct name_seq *seq;

750
	write_lock_bh(&tipc_nametbl_lock);
P
Per Liden 已提交
751
	seq = nametbl_find_seq(type);
752
	if (!seq)
753
		seq = tipc_nameseq_create(type, &table.types[hash(type)]);
754
	if (seq) {
755 756 757 758
		spin_lock_bh(&seq->lock);
		tipc_nameseq_subscribe(seq, s);
		spin_unlock_bh(&seq->lock);
	} else {
759 760
		warn("Failed to create subscription for {%u,%u,%u}\n",
		     s->seq.type, s->seq.lower, s->seq.upper);
761 762
	}
	write_unlock_bh(&tipc_nametbl_lock);
P
Per Liden 已提交
763 764 765
}

/**
766
 * tipc_nametbl_unsubscribe - remove a subscription object from name table
P
Per Liden 已提交
767 768
 */

769
void tipc_nametbl_unsubscribe(struct tipc_subscription *s)
P
Per Liden 已提交
770 771 772
{
	struct name_seq *seq;

773 774
	write_lock_bh(&tipc_nametbl_lock);
	seq = nametbl_find_seq(s->seq.type);
775
	if (seq != NULL) {
776 777 778
		spin_lock_bh(&seq->lock);
		list_del_init(&s->nameseq_list);
		spin_unlock_bh(&seq->lock);
779
		nameseq_delete_empty(seq);
780 781
	}
	write_unlock_bh(&tipc_nametbl_lock);
P
Per Liden 已提交
782 783 784 785 786 787 788 789 790 791 792
}


/**
 * subseq_list: print specified sub-sequence contents into the given buffer
 */

static void subseq_list(struct sub_seq *sseq, struct print_buf *buf, u32 depth,
			u32 index)
{
	char portIdStr[27];
793
	const char *scope_str[] = {"", " zone", " cluster", " node"};
794 795
	struct publication *publ;
	struct name_info *info;
P
Per Liden 已提交
796 797 798

	tipc_printf(buf, "%-10u %-10u ", sseq->lower, sseq->upper);

799
	if (depth == 2) {
P
Per Liden 已提交
800 801 802 803
		tipc_printf(buf, "\n");
		return;
	}

804 805 806
	info = sseq->info;

	list_for_each_entry(publ, &info->zone_list, zone_list) {
807
		sprintf(portIdStr, "<%u.%u.%u:%u>",
P
Per Liden 已提交
808 809 810 811
			 tipc_zone(publ->node), tipc_cluster(publ->node),
			 tipc_node(publ->node), publ->ref);
		tipc_printf(buf, "%-26s ", portIdStr);
		if (depth > 3) {
812 813
			tipc_printf(buf, "%-10u %s", publ->key,
				    scope_str[publ->scope]);
P
Per Liden 已提交
814
		}
815 816 817
		if (!list_is_last(&publ->zone_list, &info->zone_list))
			tipc_printf(buf, "\n%33s", " ");
	};
P
Per Liden 已提交
818 819 820 821 822 823 824 825 826 827 828 829 830 831

	tipc_printf(buf, "\n");
}

/**
 * nameseq_list: print specified name sequence contents into the given buffer
 */

static void nameseq_list(struct name_seq *seq, struct print_buf *buf, u32 depth,
			 u32 type, u32 lowbound, u32 upbound, u32 index)
{
	struct sub_seq *sseq;
	char typearea[11];

832 833 834
	if (seq->first_free == 0)
		return;

P
Per Liden 已提交
835 836 837 838 839 840 841 842 843 844
	sprintf(typearea, "%-10u", seq->type);

	if (depth == 1) {
		tipc_printf(buf, "%s\n", typearea);
		return;
	}

	for (sseq = seq->sseqs; sseq != &seq->sseqs[seq->first_free]; sseq++) {
		if ((lowbound <= sseq->upper) && (upbound >= sseq->lower)) {
			tipc_printf(buf, "%s ", typearea);
845
			spin_lock_bh(&seq->lock);
P
Per Liden 已提交
846
			subseq_list(sseq, buf, depth, index);
847
			spin_unlock_bh(&seq->lock);
P
Per Liden 已提交
848 849 850 851 852 853 854 855 856 857 858
			sprintf(typearea, "%10s", " ");
		}
	}
}

/**
 * nametbl_header - print name table header into the given buffer
 */

static void nametbl_header(struct print_buf *buf, u32 depth)
{
859 860 861 862 863 864 865 866 867 868 869 870 871
	const char *header[] = {
		"Type       ",
		"Lower      Upper      ",
		"Port Identity              ",
		"Publication Scope"
	};

	int i;

	if (depth > 4)
		depth = 4;
	for (i = 0; i < depth; i++)
		tipc_printf(buf, header[i]);
P
Per Liden 已提交
872 873 874 875 876 877 878
	tipc_printf(buf, "\n");
}

/**
 * nametbl_list - print specified name table contents into the given buffer
 */

879
static void nametbl_list(struct print_buf *buf, u32 depth_info,
P
Per Liden 已提交
880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902
			 u32 type, u32 lowbound, u32 upbound)
{
	struct hlist_head *seq_head;
	struct hlist_node *seq_node;
	struct name_seq *seq;
	int all_types;
	u32 depth;
	u32 i;

	all_types = (depth_info & TIPC_NTQ_ALLTYPES);
	depth = (depth_info & ~TIPC_NTQ_ALLTYPES);

	if (depth == 0)
		return;

	if (all_types) {
		/* display all entries in name table to specified depth */
		nametbl_header(buf, depth);
		lowbound = 0;
		upbound = ~0;
		for (i = 0; i < tipc_nametbl_size; i++) {
			seq_head = &table.types[i];
			hlist_for_each_entry(seq, seq_node, seq_head, ns_list) {
903
				nameseq_list(seq, buf, depth, seq->type,
P
Per Liden 已提交
904 905 906 907 908 909 910 911 912 913 914 915 916 917
					     lowbound, upbound, i);
			}
		}
	} else {
		/* display only the sequence that matches the specified type */
		if (upbound < lowbound) {
			tipc_printf(buf, "invalid name sequence specified\n");
			return;
		}
		nametbl_header(buf, depth);
		i = hash(type);
		seq_head = &table.types[i];
		hlist_for_each_entry(seq, seq_node, seq_head, ns_list) {
			if (seq->type == type) {
918
				nameseq_list(seq, buf, depth, type,
P
Per Liden 已提交
919 920 921 922 923 924 925 926 927
					     lowbound, upbound, i);
				break;
			}
		}
	}
}

#define MAX_NAME_TBL_QUERY 32768

928
struct sk_buff *tipc_nametbl_get(const void *req_tlv_area, int req_tlv_space)
P
Per Liden 已提交
929 930 931 932 933 934 935 936
{
	struct sk_buff *buf;
	struct tipc_name_table_query *argv;
	struct tlv_desc *rep_tlv;
	struct print_buf b;
	int str_len;

	if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_NAME_TBL_QUERY))
937
		return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
P
Per Liden 已提交
938

939
	buf = tipc_cfg_reply_alloc(TLV_SPACE(MAX_NAME_TBL_QUERY));
P
Per Liden 已提交
940 941 942 943
	if (!buf)
		return NULL;

	rep_tlv = (struct tlv_desc *)buf->data;
944
	tipc_printbuf_init(&b, TLV_DATA(rep_tlv), MAX_NAME_TBL_QUERY);
P
Per Liden 已提交
945
	argv = (struct tipc_name_table_query *)TLV_DATA(req_tlv_area);
946
	read_lock_bh(&tipc_nametbl_lock);
947
	nametbl_list(&b, ntohl(argv->depth), ntohl(argv->type),
P
Per Liden 已提交
948
		     ntohl(argv->lowbound), ntohl(argv->upbound));
949 950
	read_unlock_bh(&tipc_nametbl_lock);
	str_len = tipc_printbuf_validate(&b);
P
Per Liden 已提交
951 952 953 954 955 956 957

	skb_put(buf, TLV_SPACE(str_len));
	TLV_SET(rep_tlv, TIPC_TLV_ULTRA_STRING, NULL, str_len);

	return buf;
}

958
int tipc_nametbl_init(void)
P
Per Liden 已提交
959
{
960 961
	table.types = kcalloc(tipc_nametbl_size, sizeof(struct hlist_head),
			      GFP_ATOMIC);
P
Per Liden 已提交
962 963 964 965 966 967 968
	if (!table.types)
		return -ENOMEM;

	table.local_publ_count = 0;
	return 0;
}

969
void tipc_nametbl_stop(void)
P
Per Liden 已提交
970 971 972 973 974 975
{
	u32 i;

	if (!table.types)
		return;

976 977
	/* Verify name table is empty, then release it */

978
	write_lock_bh(&tipc_nametbl_lock);
P
Per Liden 已提交
979
	for (i = 0; i < tipc_nametbl_size; i++) {
980 981
		if (!hlist_empty(&table.types[i]))
			err("tipc_nametbl_stop(): hash chain %u is non-null\n", i);
P
Per Liden 已提交
982 983 984
	}
	kfree(table.types);
	table.types = NULL;
985
	write_unlock_bh(&tipc_nametbl_lock);
P
Per Liden 已提交
986
}
987