name_table.c 25.0 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 189 190
	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;
}

/**
 * nameseq_find_subseq - find sub-sequence (if any) matching a name instance
191
 *
P
Per Liden 已提交
192 193 194
 * Very time-critical, so binary searches through sub-sequence array.
 */

S
Sam Ravnborg 已提交
195 196
static struct sub_seq *nameseq_find_subseq(struct name_seq *nseq,
					   u32 instance)
P
Per Liden 已提交
197 198 199 200 201 202 203 204 205 206 207 208 209 210 211
{
	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];
	}
212
	return NULL;
P
Per Liden 已提交
213 214 215 216
}

/**
 * nameseq_locate_subseq - determine position of name instance in sub-sequence
217
 *
P
Per Liden 已提交
218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244
 * 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;
}

/**
245
 * tipc_nameseq_insert_publ -
P
Per Liden 已提交
246 247
 */

A
Adrian Bunk 已提交
248 249 250
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 已提交
251
{
252 253
	struct tipc_subscription *s;
	struct tipc_subscription *st;
P
Per Liden 已提交
254 255
	struct publication *publ;
	struct sub_seq *sseq;
256
	struct name_info *info;
P
Per Liden 已提交
257 258 259 260 261 262 263 264
	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)) {
265 266
			warn("Cannot publish {%u,%u,%u}, overlap error\n",
			     type, lower, upper);
267
			return NULL;
P
Per Liden 已提交
268
		}
269 270

		info = sseq->info;
271 272 273 274 275 276 277

		/* 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 已提交
278 279 280 281 282 283 284 285 286 287 288 289
	} 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)) {
290 291
			warn("Cannot publish {%u,%u,%u}, overlap error\n",
			     type, lower, upper);
292
			return NULL;
P
Per Liden 已提交
293 294 295 296 297
		}

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

		if (nseq->first_free == nseq->alloc) {
298 299 300
			struct sub_seq *sseqs = tipc_subseq_alloc(nseq->alloc * 2);

			if (!sseqs) {
301 302
				warn("Cannot publish {%u,%u,%u}, no memory\n",
				     type, lower, upper);
303
				return NULL;
P
Per Liden 已提交
304
			}
305 306 307 308 309
			memcpy(sseqs, nseq->sseqs,
			       nseq->alloc * sizeof(struct sub_seq));
			kfree(nseq->sseqs);
			nseq->sseqs = sseqs;
			nseq->alloc *= 2;
P
Per Liden 已提交
310 311
		}

312 313 314 315 316 317 318
		info = kzalloc(sizeof(*info), GFP_ATOMIC);
		if (!info) {
			warn("Cannot publish {%u,%u,%u}, no memory\n",
			     type, lower, upper);
			return NULL;
		}

319 320 321 322
		INIT_LIST_HEAD(&info->node_list);
		INIT_LIST_HEAD(&info->cluster_list);
		INIT_LIST_HEAD(&info->zone_list);

P
Per Liden 已提交
323 324 325 326
		/* Insert new sub-sequence */

		sseq = &nseq->sseqs[inspos];
		freesseq = &nseq->sseqs[nseq->first_free];
327 328
		memmove(sseq + 1, sseq, (freesseq - sseq) * sizeof(*sseq));
		memset(sseq, 0, sizeof(*sseq));
P
Per Liden 已提交
329 330 331
		nseq->first_free++;
		sseq->lower = lower;
		sseq->upper = upper;
332
		sseq->info = info;
P
Per Liden 已提交
333 334 335 336 337 338 339
		created_subseq = 1;
	}

	/* Insert a publication: */

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

342
	list_add(&publ->zone_list, &info->zone_list);
343
	info->zone_list_size++;
P
Per Liden 已提交
344

345
	if (in_own_cluster_exact(node)) {
346
		list_add(&publ->cluster_list, &info->cluster_list);
347
		info->cluster_list_size++;
P
Per Liden 已提交
348 349 350
	}

	if (node == tipc_own_addr) {
351
		list_add(&publ->node_list, &info->node_list);
352
		info->node_list_size++;
P
Per Liden 已提交
353 354
	}

355 356
	/*
	 * Any subscriptions waiting for notification?
P
Per Liden 已提交
357 358
	 */
	list_for_each_entry_safe(s, st, &nseq->subscriptions, nameseq_list) {
359 360 361 362
		tipc_subscr_report_overlap(s,
					   publ->lower,
					   publ->upper,
					   TIPC_PUBLISHED,
363
					   publ->ref,
364 365
					   publ->node,
					   created_subseq);
P
Per Liden 已提交
366 367 368 369 370
	}
	return publ;
}

/**
371
 * tipc_nameseq_remove_publ -
372
 *
373 374 375 376 377 378 379
 * 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 已提交
380 381
 */

A
Adrian Bunk 已提交
382 383
static struct publication *tipc_nameseq_remove_publ(struct name_seq *nseq, u32 inst,
						    u32 node, u32 ref, u32 key)
P
Per Liden 已提交
384 385 386
{
	struct publication *publ;
	struct sub_seq *sseq = nameseq_find_subseq(nseq, inst);
387
	struct name_info *info;
P
Per Liden 已提交
388
	struct sub_seq *free;
389
	struct tipc_subscription *s, *st;
P
Per Liden 已提交
390 391
	int removed_subseq = 0;

392
	if (!sseq)
393
		return NULL;
394

395 396
	info = sseq->info;

397
	/* Locate publication, if it exists */
398

399 400 401 402 403 404
	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;
405

406 407
found:
	/* Remove publication from zone scope list */
408

409
	list_del(&publ->zone_list);
410
	info->zone_list_size--;
P
Per Liden 已提交
411

412 413
	/* Remove publication from cluster scope list, if present */

414
	if (in_own_cluster_exact(node)) {
415
		list_del(&publ->cluster_list);
416
		info->cluster_list_size--;
P
Per Liden 已提交
417
	}
418 419

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

	if (node == tipc_own_addr) {
422
		list_del(&publ->node_list);
423
		info->node_list_size--;
P
Per Liden 已提交
424 425
	}

426 427
	/* Contract subseq list if no more publications for that subseq */

428
	if (list_empty(&info->zone_list)) {
429
		kfree(info);
P
Per Liden 已提交
430
		free = &nseq->sseqs[nseq->first_free--];
431
		memmove(sseq, sseq + 1, (free - (sseq + 1)) * sizeof(*sseq));
P
Per Liden 已提交
432 433 434
		removed_subseq = 1;
	}

435 436
	/* Notify any waiting subscriptions */

P
Per Liden 已提交
437
	list_for_each_entry_safe(s, st, &nseq->subscriptions, nameseq_list) {
438 439 440
		tipc_subscr_report_overlap(s,
					   publ->lower,
					   publ->upper,
441 442
					   TIPC_WITHDRAWN,
					   publ->ref,
443 444
					   publ->node,
					   removed_subseq);
P
Per Liden 已提交
445
	}
446

P
Per Liden 已提交
447 448 449 450
	return publ;
}

/**
451
 * tipc_nameseq_subscribe: attach a subscription, and issue
P
Per Liden 已提交
452 453 454 455
 * the prescribed number of events if there is any sub-
 * sequence overlapping with the requested sequence
 */

456 457
static void tipc_nameseq_subscribe(struct name_seq *nseq,
					struct tipc_subscription *s)
P
Per Liden 已提交
458 459 460 461 462 463 464 465 466
{
	struct sub_seq *sseq = nseq->sseqs;

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

	if (!sseq)
		return;

	while (sseq != &nseq->sseqs[nseq->first_free]) {
467 468 469
		if (tipc_subscr_overlap(s, sseq->lower, sseq->upper)) {
			struct publication *crs;
			struct name_info *info = sseq->info;
P
Per Liden 已提交
470 471
			int must_report = 1;

472
			list_for_each_entry(crs, &info->zone_list, zone_list) {
473 474
				tipc_subscr_report_overlap(s,
							   sseq->lower,
475 476 477 478 479
							   sseq->upper,
							   TIPC_PUBLISHED,
							   crs->ref,
							   crs->node,
							   must_report);
P
Per Liden 已提交
480
				must_report = 0;
481
			}
P
Per Liden 已提交
482 483 484 485 486 487 488 489 490 491 492 493 494
		}
		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) {
495
		if (ns->type == type)
P
Per Liden 已提交
496 497 498
			return ns;
	}

499
	return NULL;
P
Per Liden 已提交
500 501
};

502 503
struct publication *tipc_nametbl_insert_publ(u32 type, u32 lower, u32 upper,
					     u32 scope, u32 node, u32 port, u32 key)
P
Per Liden 已提交
504 505 506 507
{
	struct name_seq *seq = nametbl_find_seq(type);

	if (lower > upper) {
508
		warn("Failed to publish illegal {%u,%u,%u}\n",
P
Per Liden 已提交
509
		     type, lower, upper);
510
		return NULL;
P
Per Liden 已提交
511 512
	}

513
	if (!seq)
514
		seq = tipc_nameseq_create(type, &table.types[hash(type)]);
P
Per Liden 已提交
515
	if (!seq)
516
		return NULL;
P
Per Liden 已提交
517

518 519
	return tipc_nameseq_insert_publ(seq, type, lower, upper,
					scope, node, port, key);
P
Per Liden 已提交
520 521
}

522
struct publication *tipc_nametbl_remove_publ(u32 type, u32 lower,
523
					     u32 node, u32 ref, u32 key)
P
Per Liden 已提交
524 525 526 527 528
{
	struct publication *publ;
	struct name_seq *seq = nametbl_find_seq(type);

	if (!seq)
529
		return NULL;
P
Per Liden 已提交
530

531
	publ = tipc_nameseq_remove_publ(seq, lower, node, ref, key);
P
Per Liden 已提交
532 533 534 535 536 537 538 539 540 541

	if (!seq->first_free && list_empty(&seq->subscriptions)) {
		hlist_del_init(&seq->ns_list);
		kfree(seq->sseqs);
		kfree(seq);
	}
	return publ;
}

/*
542
 * tipc_nametbl_translate - perform name translation
P
Per Liden 已提交
543
 *
544 545 546 547 548 549 550 551 552
 * 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 已提交
553 554
 */

555
u32 tipc_nametbl_translate(u32 type, u32 instance, u32 *destnode)
P
Per Liden 已提交
556 557
{
	struct sub_seq *sseq;
558
	struct name_info *info;
559
	struct publication *publ;
P
Per Liden 已提交
560
	struct name_seq *seq;
561
	u32 ref = 0;
562
	u32 node = 0;
P
Per Liden 已提交
563

564
	if (!tipc_in_scope(*destnode, tipc_own_addr))
P
Per Liden 已提交
565 566
		return 0;

567
	read_lock_bh(&tipc_nametbl_lock);
P
Per Liden 已提交
568 569 570 571 572 573 574
	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);
575
	info = sseq->info;
P
Per Liden 已提交
576 577 578

	/* Closest-First Algorithm: */
	if (likely(!*destnode)) {
579 580 581 582 583 584 585 586 587 588 589 590
		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);
591
		} else {
592 593 594 595 596
			publ = list_first_entry(&info->zone_list,
						struct publication,
						zone_list);
			list_move_tail(&publ->zone_list,
				       &info->zone_list);
597
		}
P
Per Liden 已提交
598 599 600 601
	}

	/* Round-Robin Algorithm: */
	else if (*destnode == tipc_own_addr) {
602 603 604 605 606
		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);
607
	} else if (in_own_cluster_exact(*destnode)) {
608 609 610 611 612
		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 已提交
613
	} else {
614 615 616
		publ = list_first_entry(&info->zone_list, struct publication,
					zone_list);
		list_move_tail(&publ->zone_list, &info->zone_list);
P
Per Liden 已提交
617
	}
618 619

	ref = publ->ref;
620
	node = publ->node;
621
no_match:
P
Per Liden 已提交
622 623
	spin_unlock_bh(&seq->lock);
not_found:
624
	read_unlock_bh(&tipc_nametbl_lock);
625
	*destnode = node;
626
	return ref;
P
Per Liden 已提交
627 628 629
}

/**
630
 * tipc_nametbl_mc_translate - find multicast destinations
631
 *
P
Per Liden 已提交
632 633 634 635 636 637
 * 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)
638
 *
P
Per Liden 已提交
639 640 641
 * Returns non-zero if any off-node ports overlap
 */

642
int tipc_nametbl_mc_translate(u32 type, u32 lower, u32 upper, u32 limit,
643
			      struct tipc_port_list *dports)
P
Per Liden 已提交
644 645 646 647
{
	struct name_seq *seq;
	struct sub_seq *sseq;
	struct sub_seq *sseq_stop;
648
	struct name_info *info;
P
Per Liden 已提交
649 650
	int res = 0;

651
	read_lock_bh(&tipc_nametbl_lock);
P
Per Liden 已提交
652 653 654 655 656 657 658 659 660 661 662 663 664
	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;
665

666
		info = sseq->info;
667 668 669
		list_for_each_entry(publ, &info->node_list, node_list) {
			if (publ->scope <= limit)
				tipc_port_list_add(dports, publ->ref);
670 671
		}

672
		if (info->cluster_list_size != info->node_list_size)
673
			res = 1;
P
Per Liden 已提交
674 675 676 677
	}

	spin_unlock_bh(&seq->lock);
exit:
678
	read_unlock_bh(&tipc_nametbl_lock);
P
Per Liden 已提交
679 680 681
	return res;
}

682
/*
683
 * tipc_nametbl_publish - add name publication to network name tables
P
Per Liden 已提交
684 685
 */

686
struct publication *tipc_nametbl_publish(u32 type, u32 lower, u32 upper,
P
Per Liden 已提交
687 688 689 690 691
				    u32 scope, u32 port_ref, u32 key)
{
	struct publication *publ;

	if (table.local_publ_count >= tipc_max_publications) {
692
		warn("Publication failed, local publication limit reached (%u)\n",
P
Per Liden 已提交
693
		     tipc_max_publications);
694
		return NULL;
P
Per Liden 已提交
695 696
	}

697 698
	write_lock_bh(&tipc_nametbl_lock);
	publ = tipc_nametbl_insert_publ(type, lower, upper, scope,
P
Per Liden 已提交
699
				   tipc_own_addr, port_ref, key);
700 701
	if (likely(publ)) {
		table.local_publ_count++;
702
		tipc_named_publish(publ);
703
	}
704
	write_unlock_bh(&tipc_nametbl_lock);
P
Per Liden 已提交
705 706 707 708
	return publ;
}

/**
709
 * tipc_nametbl_withdraw - withdraw name publication from network name tables
P
Per Liden 已提交
710 711
 */

712
int tipc_nametbl_withdraw(u32 type, u32 lower, u32 ref, u32 key)
P
Per Liden 已提交
713 714 715
{
	struct publication *publ;

716 717
	write_lock_bh(&tipc_nametbl_lock);
	publ = tipc_nametbl_remove_publ(type, lower, tipc_own_addr, ref, key);
718
	if (likely(publ)) {
P
Per Liden 已提交
719
		table.local_publ_count--;
720
		tipc_named_withdraw(publ);
721
		write_unlock_bh(&tipc_nametbl_lock);
P
Per Liden 已提交
722 723 724 725
		list_del_init(&publ->pport_list);
		kfree(publ);
		return 1;
	}
726
	write_unlock_bh(&tipc_nametbl_lock);
727 728 729
	err("Unable to remove local publication\n"
	    "(type=%u, lower=%u, ref=%u, key=%u)\n",
	    type, lower, ref, key);
P
Per Liden 已提交
730 731 732 733
	return 0;
}

/**
734
 * tipc_nametbl_subscribe - add a subscription object to the name table
P
Per Liden 已提交
735 736
 */

737
void tipc_nametbl_subscribe(struct tipc_subscription *s)
P
Per Liden 已提交
738 739 740 741
{
	u32 type = s->seq.type;
	struct name_seq *seq;

742
	write_lock_bh(&tipc_nametbl_lock);
P
Per Liden 已提交
743
	seq = nametbl_find_seq(type);
744
	if (!seq)
745
		seq = tipc_nameseq_create(type, &table.types[hash(type)]);
746
	if (seq) {
747 748 749 750
		spin_lock_bh(&seq->lock);
		tipc_nameseq_subscribe(seq, s);
		spin_unlock_bh(&seq->lock);
	} else {
751 752
		warn("Failed to create subscription for {%u,%u,%u}\n",
		     s->seq.type, s->seq.lower, s->seq.upper);
753 754
	}
	write_unlock_bh(&tipc_nametbl_lock);
P
Per Liden 已提交
755 756 757
}

/**
758
 * tipc_nametbl_unsubscribe - remove a subscription object from name table
P
Per Liden 已提交
759 760
 */

761
void tipc_nametbl_unsubscribe(struct tipc_subscription *s)
P
Per Liden 已提交
762 763 764
{
	struct name_seq *seq;

765 766
	write_lock_bh(&tipc_nametbl_lock);
	seq = nametbl_find_seq(s->seq.type);
767
	if (seq != NULL) {
768 769 770 771 772 773 774 775 776 777
		spin_lock_bh(&seq->lock);
		list_del_init(&s->nameseq_list);
		spin_unlock_bh(&seq->lock);
		if ((seq->first_free == 0) && list_empty(&seq->subscriptions)) {
			hlist_del_init(&seq->ns_list);
			kfree(seq->sseqs);
			kfree(seq);
		}
	}
	write_unlock_bh(&tipc_nametbl_lock);
P
Per Liden 已提交
778 779 780 781 782 783 784 785 786 787 788
}


/**
 * 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];
789
	const char *scope_str[] = {"", " zone", " cluster", " node"};
790 791
	struct publication *publ;
	struct name_info *info;
P
Per Liden 已提交
792 793 794

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

795
	if (depth == 2) {
P
Per Liden 已提交
796 797 798 799
		tipc_printf(buf, "\n");
		return;
	}

800 801 802
	info = sseq->info;

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

	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];

828 829 830
	if (seq->first_free == 0)
		return;

P
Per Liden 已提交
831 832 833 834 835 836 837 838 839 840
	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);
841
			spin_lock_bh(&seq->lock);
P
Per Liden 已提交
842
			subseq_list(sseq, buf, depth, index);
843
			spin_unlock_bh(&seq->lock);
P
Per Liden 已提交
844 845 846 847 848 849 850 851 852 853 854
			sprintf(typearea, "%10s", " ");
		}
	}
}

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

static void nametbl_header(struct print_buf *buf, u32 depth)
{
855 856 857 858 859 860 861 862 863 864 865 866 867
	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 已提交
868 869 870 871 872 873 874
	tipc_printf(buf, "\n");
}

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

875
static void nametbl_list(struct print_buf *buf, u32 depth_info,
P
Per Liden 已提交
876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898
			 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) {
899
				nameseq_list(seq, buf, depth, seq->type,
P
Per Liden 已提交
900 901 902 903 904 905 906 907 908 909 910 911 912 913
					     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) {
914
				nameseq_list(seq, buf, depth, type,
P
Per Liden 已提交
915 916 917 918 919 920 921 922 923
					     lowbound, upbound, i);
				break;
			}
		}
	}
}

#define MAX_NAME_TBL_QUERY 32768

924
struct sk_buff *tipc_nametbl_get(const void *req_tlv_area, int req_tlv_space)
P
Per Liden 已提交
925 926 927 928 929 930 931 932
{
	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))
933
		return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
P
Per Liden 已提交
934

935
	buf = tipc_cfg_reply_alloc(TLV_SPACE(MAX_NAME_TBL_QUERY));
P
Per Liden 已提交
936 937 938 939
	if (!buf)
		return NULL;

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

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

	return buf;
}

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

	table.local_publ_count = 0;
	return 0;
}

965
void tipc_nametbl_stop(void)
P
Per Liden 已提交
966 967 968 969 970 971
{
	u32 i;

	if (!table.types)
		return;

972 973
	/* Verify name table is empty, then release it */

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