net/tipc/name_table.c

   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
  43 #define TIPC_NAMETBL_SIZE 1024          /* must be a power of 2 */
  44
  45 /**
  46  * struct name_info - name sequence publication info
  47  * @node_list: circular list of publications made by own node
  48  * @cluster_list: circular list of publications made by own cluster
  49  * @zone_list: circular list of publications made by own zone
  50  * @node_list_size: number of entries in "node_list"
  51  * @cluster_list_size: number of entries in "cluster_list"
  52  * @zone_list_size: number of entries in "zone_list"
  53  *
  54  * Note: The zone list always contains at least one entry, since all
  55  *       publications of the associated name sequence belong to it.
  56  *       (The cluster and node lists may be empty.)
  57  */
  58 struct name_info {
  59         struct list_head node_list;
  60         struct list_head cluster_list;
  61         struct list_head zone_list;
  62         u32 node_list_size;
  63         u32 cluster_list_size;
  64         u32 zone_list_size;
  65 };
  66
  67 /**
  68  * struct sub_seq - container for all published instances of a name sequence
  69  * @lower: name sequence lower bound
  70  * @upper: name sequence upper bound
  71  * @info: pointer to name sequence publication info
  72  */
  73 struct sub_seq {
  74         u32 lower;
  75         u32 upper;
  76         struct name_info *info;
  77 };
  78
  79 /**
  80  * struct name_seq - container for all published instances of a name type
  81  * @type: 32 bit 'type' value for name sequence
  82  * @sseq: pointer to dynamically-sized array of sub-sequences of this 'type';
  83  *        sub-sequences are sorted in ascending order
  84  * @alloc: number of sub-sequences currently in array
  85  * @first_free: array index of first unused sub-sequence entry
  86  * @ns_list: links to adjacent name sequences in hash chain
  87  * @subscriptions: list of subscriptions for this 'type'
  88  * @lock: spinlock controlling access to publication lists of all sub-sequences
  89  */
  90 struct name_seq {
  91         u32 type;
  92         struct sub_seq *sseqs;
  93         u32 alloc;
  94         u32 first_free;
  95         struct hlist_node ns_list;
  96         struct list_head subscriptions;
  97         spinlock_t lock;
  98 };
  99
 100 /**
 101  * struct name_table - table containing all existing port name publications
 102  * @types: pointer to fixed-sized array of name sequence lists,
 103  *         accessed via hashing on 'type'; name sequence lists are *not* sorted
 104  * @local_publ_count: number of publications issued by this node
 105  */
 106 struct name_table {
 107         struct hlist_head *types;
 108         u32 local_publ_count;
 109 };
 110
 111 static struct name_table table;
 112 DEFINE_RWLOCK(tipc_nametbl_lock);
 113
 114 static int hash(int x)
 115 {
 116         return x & (TIPC_NAMETBL_SIZE - 1);
 117 }
 118
 119 /**
 120  * publ_create - create a publication structure
 121  */
 122 static struct publication *publ_create(u32 type, u32 lower, u32 upper,
 123                                        u32 scope, u32 node, u32 port_ref,
 124                                        u32 key)
 125 {
 126         struct publication *publ = kzalloc(sizeof(*publ), GFP_ATOMIC);
 127         if (publ == NULL) {
 128                 pr_warn("Publication creation failure, no memory\n");
 129                 return NULL;
 130         }
 131
 132         publ->type = type;
 133         publ->lower = lower;
 134         publ->upper = upper;
 135         publ->scope = scope;
 136         publ->node = node;
 137         publ->ref = port_ref;
 138         publ->key = key;
 139         INIT_LIST_HEAD(&publ->local_list);
 140         INIT_LIST_HEAD(&publ->pport_list);
 141         INIT_LIST_HEAD(&publ->subscr.nodesub_list);
 142         return publ;
 143 }
 144
 145 /**
 146  * tipc_subseq_alloc - allocate a specified number of sub-sequence structures
 147  */
 148 static struct sub_seq *tipc_subseq_alloc(u32 cnt)
 149 {
 150         return kcalloc(cnt, sizeof(struct sub_seq), GFP_ATOMIC);
 151 }
 152
 153 /**
 154  * tipc_nameseq_create - create a name sequence structure for the specified 'type'
 155  *
 156  * Allocates a single sub-sequence structure and sets it to all 0's.
 157  */
 158 static struct name_seq *tipc_nameseq_create(u32 type, struct hlist_head *seq_head)
 159 {
 160         struct name_seq *nseq = kzalloc(sizeof(*nseq), GFP_ATOMIC);
 161         struct sub_seq *sseq = tipc_subseq_alloc(1);
 162
 163         if (!nseq || !sseq) {
 164                 pr_warn("Name sequence creation failed, no memory\n");
 165                 kfree(nseq);
 166                 kfree(sseq);
 167                 return NULL;
 168         }
 169
 170         spin_lock_init(&nseq->lock);
 171         nseq->type = type;
 172         nseq->sseqs = sseq;
 173         nseq->alloc = 1;
 174         INIT_HLIST_NODE(&nseq->ns_list);
 175         INIT_LIST_HEAD(&nseq->subscriptions);
 176         hlist_add_head(&nseq->ns_list, seq_head);
 177         return nseq;
 178 }
 179
 180 /*
 181  * nameseq_delete_empty - deletes a name sequence structure if now unused
 182  */
 183 static void nameseq_delete_empty(struct name_seq *seq)
 184 {
 185         if (!seq->first_free && list_empty(&seq->subscriptions)) {
 186                 hlist_del_init(&seq->ns_list);
 187                 kfree(seq->sseqs);
 188                 kfree(seq);
 189         }
 190 }
 191
 192 /**
 193  * nameseq_find_subseq - find sub-sequence (if any) matching a name instance
 194  *
 195  * Very time-critical, so binary searches through sub-sequence array.
 196  */
 197 static struct sub_seq *nameseq_find_subseq(struct name_seq *nseq,
 198                                            u32 instance)
 199 {
 200         struct sub_seq *sseqs = nseq->sseqs;
 201         int low = 0;
 202         int high = nseq->first_free - 1;
 203         int mid;
 204
 205         while (low <= high) {
 206                 mid = (low + high) / 2;
 207                 if (instance < sseqs[mid].lower)
 208                         high = mid - 1;
 209                 else if (instance > sseqs[mid].upper)
 210                         low = mid + 1;
 211                 else
 212                         return &sseqs[mid];
 213         }
 214         return NULL;
 215 }
 216
 217 /**
 218  * nameseq_locate_subseq - determine position of name instance in sub-sequence
 219  *
 220  * Returns index in sub-sequence array of the entry that contains the specified
 221  * instance value; if no entry contains that value, returns the position
 222  * where a new entry for it would be inserted in the array.
 223  *
 224  * Note: Similar to binary search code for locating a sub-sequence.
 225  */
 226 static u32 nameseq_locate_subseq(struct name_seq *nseq, u32 instance)
 227 {
 228         struct sub_seq *sseqs = nseq->sseqs;
 229         int low = 0;
 230         int high = nseq->first_free - 1;
 231         int mid;
 232
 233         while (low <= high) {
 234                 mid = (low + high) / 2;
 235                 if (instance < sseqs[mid].lower)
 236                         high = mid - 1;
 237                 else if (instance > sseqs[mid].upper)
 238                         low = mid + 1;
 239                 else
 240                         return mid;
 241         }
 242         return low;
 243 }
 244
 245 /**
 246  * tipc_nameseq_insert_publ
 247  */
 248 static struct publication *tipc_nameseq_insert_publ(struct name_seq *nseq,
 249                                                     u32 type, u32 lower, u32 upper,
 250                                                     u32 scope, u32 node, u32 port, u32 key)
 251 {
 252         struct tipc_subscription *s;
 253         struct tipc_subscription *st;
 254         struct publication *publ;
 255         struct sub_seq *sseq;
 256         struct name_info *info;
 257         int created_subseq = 0;
 258
 259         sseq = nameseq_find_subseq(nseq, lower);
 260         if (sseq) {
 261
 262                 /* Lower end overlaps existing entry => need an exact match */
 263                 if ((sseq->lower != lower) || (sseq->upper != upper)) {
 264                         return NULL;
 265                 }
 266
 267                 info = sseq->info;
 268
 269                 /* Check if an identical publication already exists */
 270                 list_for_each_entry(publ, &info->zone_list, zone_list) {
 271                         if ((publ->ref == port) && (publ->key == key) &&
 272                             (!publ->node || (publ->node == node)))
 273                                 return NULL;
 274                 }
 275         } else {
 276                 u32 inspos;
 277                 struct sub_seq *freesseq;
 278
 279                 /* Find where lower end should be inserted */
 280                 inspos = nameseq_locate_subseq(nseq, lower);
 281
 282                 /* Fail if upper end overlaps into an existing entry */
 283                 if ((inspos < nseq->first_free) &&
 284                     (upper >= nseq->sseqs[inspos].lower)) {
 285                         return NULL;
 286                 }
 287
 288                 /* Ensure there is space for new sub-sequence */
 289                 if (nseq->first_free == nseq->alloc) {
 290                         struct sub_seq *sseqs = tipc_subseq_alloc(nseq->alloc * 2);
 291
 292                         if (!sseqs) {
 293                                 pr_warn("Cannot publish {%u,%u,%u}, no memory\n",
 294                                         type, lower, upper);
 295                                 return NULL;
 296                         }
 297                         memcpy(sseqs, nseq->sseqs,
 298                                nseq->alloc * sizeof(struct sub_seq));
 299                         kfree(nseq->sseqs);
 300                         nseq->sseqs = sseqs;
 301                         nseq->alloc *= 2;
 302                 }
 303
 304                 info = kzalloc(sizeof(*info), GFP_ATOMIC);
 305                 if (!info) {
 306                         pr_warn("Cannot publish {%u,%u,%u}, no memory\n",
 307                                 type, lower, upper);
 308                         return NULL;
 309                 }
 310
 311                 INIT_LIST_HEAD(&info->node_list);
 312                 INIT_LIST_HEAD(&info->cluster_list);
 313                 INIT_LIST_HEAD(&info->zone_list);
 314
 315                 /* Insert new sub-sequence */
 316                 sseq = &nseq->sseqs[inspos];
 317                 freesseq = &nseq->sseqs[nseq->first_free];
 318                 memmove(sseq + 1, sseq, (freesseq - sseq) * sizeof(*sseq));
 319                 memset(sseq, 0, sizeof(*sseq));
 320                 nseq->first_free++;
 321                 sseq->lower = lower;
 322                 sseq->upper = upper;
 323                 sseq->info = info;
 324                 created_subseq = 1;
 325         }
 326
 327         /* Insert a publication */
 328         publ = publ_create(type, lower, upper, scope, node, port, key);
 329         if (!publ)
 330                 return NULL;
 331
 332         list_add(&publ->zone_list, &info->zone_list);
 333         info->zone_list_size++;
 334
 335         if (in_own_cluster(node)) {
 336                 list_add(&publ->cluster_list, &info->cluster_list);
 337                 info->cluster_list_size++;
 338         }
 339
 340         if (in_own_node(node)) {
 341                 list_add(&publ->node_list, &info->node_list);
 342                 info->node_list_size++;
 343         }
 344
 345         /* Any subscriptions waiting for notification?  */
 346         list_for_each_entry_safe(s, st, &nseq->subscriptions, nameseq_list) {
 347                 tipc_subscr_report_overlap(s,
 348                                            publ->lower,
 349                                            publ->upper,
 350                                            TIPC_PUBLISHED,
 351                                            publ->ref,
 352                                            publ->node,
 353                                            created_subseq);
 354         }
 355         return publ;
 356 }
 357
 358 /**
 359  * tipc_nameseq_remove_publ
 360  *
 361  * NOTE: There may be cases where TIPC is asked to remove a publication
 362  * that is not in the name table.  For example, if another node issues a
 363  * publication for a name sequence that overlaps an existing name sequence
 364  * the publication will not be recorded, which means the publication won't
 365  * be found when the name sequence is later withdrawn by that node.
 366  * A failed withdraw request simply returns a failure indication and lets the
 367  * caller issue any error or warning messages associated with such a problem.
 368  */
 369 static struct publication *tipc_nameseq_remove_publ(struct name_seq *nseq, u32 inst,
 370                                                     u32 node, u32 ref, u32 key)
 371 {
 372         struct publication *publ;
 373         struct sub_seq *sseq = nameseq_find_subseq(nseq, inst);
 374         struct name_info *info;
 375         struct sub_seq *free;
 376         struct tipc_subscription *s, *st;
 377         int removed_subseq = 0;
 378
 379         if (!sseq)
 380                 return NULL;
 381
 382         info = sseq->info;
 383
 384         /* Locate publication, if it exists */
 385         list_for_each_entry(publ, &info->zone_list, zone_list) {
 386                 if ((publ->key == key) && (publ->ref == ref) &&
 387                     (!publ->node || (publ->node == node)))
 388                         goto found;
 389         }
 390         return NULL;
 391
 392 found:
 393         /* Remove publication from zone scope list */
 394         list_del(&publ->zone_list);
 395         info->zone_list_size--;
 396
 397         /* Remove publication from cluster scope list, if present */
 398         if (in_own_cluster(node)) {
 399                 list_del(&publ->cluster_list);
 400                 info->cluster_list_size--;
 401         }
 402
 403         /* Remove publication from node scope list, if present */
 404         if (in_own_node(node)) {
 405                 list_del(&publ->node_list);
 406                 info->node_list_size--;
 407         }
 408
 409         /* Contract subseq list if no more publications for that subseq */
 410         if (list_empty(&info->zone_list)) {
 411                 kfree(info);
 412                 free = &nseq->sseqs[nseq->first_free--];
 413                 memmove(sseq, sseq + 1, (free - (sseq + 1)) * sizeof(*sseq));
 414                 removed_subseq = 1;
 415         }
 416
 417         /* Notify any waiting subscriptions */
 418         list_for_each_entry_safe(s, st, &nseq->subscriptions, nameseq_list) {
 419                 tipc_subscr_report_overlap(s,
 420                                            publ->lower,
 421                                            publ->upper,
 422                                            TIPC_WITHDRAWN,
 423                                            publ->ref,
 424                                            publ->node,
 425                                            removed_subseq);
 426         }
 427
 428         return publ;
 429 }
 430
 431 /**
 432  * tipc_nameseq_subscribe - attach a subscription, and issue
 433  * the prescribed number of events if there is any sub-
 434  * sequence overlapping with the requested sequence
 435  */
 436 static void tipc_nameseq_subscribe(struct name_seq *nseq,
 437                                    struct tipc_subscription *s)
 438 {
 439         struct sub_seq *sseq = nseq->sseqs;
 440
 441         list_add(&s->nameseq_list, &nseq->subscriptions);
 442
 443         if (!sseq)
 444                 return;
 445
 446         while (sseq != &nseq->sseqs[nseq->first_free]) {
 447                 if (tipc_subscr_overlap(s, sseq->lower, sseq->upper)) {
 448                         struct publication *crs;
 449                         struct name_info *info = sseq->info;
 450                         int must_report = 1;
 451
 452                         list_for_each_entry(crs, &info->zone_list, zone_list) {
 453                                 tipc_subscr_report_overlap(s,
 454                                                            sseq->lower,
 455                                                            sseq->upper,
 456                                                            TIPC_PUBLISHED,
 457                                                            crs->ref,
 458                                                            crs->node,
 459                                                            must_report);
 460                                 must_report = 0;
 461                         }
 462                 }
 463                 sseq++;
 464         }
 465 }
 466
 467 static struct name_seq *nametbl_find_seq(u32 type)
 468 {
 469         struct hlist_head *seq_head;
 470         struct name_seq *ns;
 471
 472         seq_head = &table.types[hash(type)];
 473         hlist_for_each_entry(ns, seq_head, ns_list) {
 474                 if (ns->type == type)
 475                         return ns;
 476         }
 477
 478         return NULL;
 479 };
 480
 481 struct publication *tipc_nametbl_insert_publ(u32 type, u32 lower, u32 upper,
 482                                              u32 scope, u32 node, u32 port, u32 key)
 483 {
 484         struct name_seq *seq = nametbl_find_seq(type);
 485
 486         if ((scope < TIPC_ZONE_SCOPE) || (scope > TIPC_NODE_SCOPE) ||
 487             (lower > upper)) {
 488                 pr_debug("Failed to publish illegal {%u,%u,%u} with scope %u\n",
 489                          type, lower, upper, scope);
 490                 return NULL;
 491         }
 492
 493         if (!seq)
 494                 seq = tipc_nameseq_create(type, &table.types[hash(type)]);
 495         if (!seq)
 496                 return NULL;
 497
 498         return tipc_nameseq_insert_publ(seq, type, lower, upper,
 499                                         scope, node, port, key);
 500 }
 501
 502 struct publication *tipc_nametbl_remove_publ(u32 type, u32 lower,
 503                                              u32 node, u32 ref, u32 key)
 504 {
 505         struct publication *publ;
 506         struct name_seq *seq = nametbl_find_seq(type);
 507
 508         if (!seq)
 509                 return NULL;
 510
 511         publ = tipc_nameseq_remove_publ(seq, lower, node, ref, key);
 512         nameseq_delete_empty(seq);
 513         return publ;
 514 }
 515
 516 /**
 517  * tipc_nametbl_translate - perform name translation
 518  *
 519  * On entry, 'destnode' is the search domain used during translation.
 520  *
 521  * On exit:
 522  * - if name translation is deferred to another node/cluster/zone,
 523  *   leaves 'destnode' unchanged (will be non-zero) and returns 0
 524  * - if name translation is attempted and succeeds, sets 'destnode'
 525  *   to publishing node and returns port reference (will be non-zero)
 526  * - if name translation is attempted and fails, sets 'destnode' to 0
 527  *   and returns 0
 528  */
 529 u32 tipc_nametbl_translate(u32 type, u32 instance, u32 *destnode)
 530 {
 531         struct sub_seq *sseq;
 532         struct name_info *info;
 533         struct publication *publ;
 534         struct name_seq *seq;
 535         u32 ref = 0;
 536         u32 node = 0;
 537
 538         if (!tipc_in_scope(*destnode, tipc_own_addr))
 539                 return 0;
 540
 541         read_lock_bh(&tipc_nametbl_lock);
 542         seq = nametbl_find_seq(type);
 543         if (unlikely(!seq))
 544                 goto not_found;
 545         sseq = nameseq_find_subseq(seq, instance);
 546         if (unlikely(!sseq))
 547                 goto not_found;
 548         spin_lock_bh(&seq->lock);
 549         info = sseq->info;
 550
 551         /* Closest-First Algorithm */
 552         if (likely(!*destnode)) {
 553                 if (!list_empty(&info->node_list)) {
 554                         publ = list_first_entry(&info->node_list,
 555                                                 struct publication,
 556                                                 node_list);
 557                         list_move_tail(&publ->node_list,
 558                                        &info->node_list);
 559                 } else if (!list_empty(&info->cluster_list)) {
 560                         publ = list_first_entry(&info->cluster_list,
 561                                                 struct publication,
 562                                                 cluster_list);
 563                         list_move_tail(&publ->cluster_list,
 564                                        &info->cluster_list);
 565                 } else {
 566                         publ = list_first_entry(&info->zone_list,
 567                                                 struct publication,
 568                                                 zone_list);
 569                         list_move_tail(&publ->zone_list,
 570                                        &info->zone_list);
 571                 }
 572         }
 573
 574         /* Round-Robin Algorithm */
 575         else if (*destnode == tipc_own_addr) {
 576                 if (list_empty(&info->node_list))
 577                         goto no_match;
 578                 publ = list_first_entry(&info->node_list, struct publication,
 579                                         node_list);
 580                 list_move_tail(&publ->node_list, &info->node_list);
 581         } else if (in_own_cluster_exact(*destnode)) {
 582                 if (list_empty(&info->cluster_list))
 583                         goto no_match;
 584                 publ = list_first_entry(&info->cluster_list, struct publication,
 585                                         cluster_list);
 586                 list_move_tail(&publ->cluster_list, &info->cluster_list);
 587         } else {
 588                 publ = list_first_entry(&info->zone_list, struct publication,
 589                                         zone_list);
 590                 list_move_tail(&publ->zone_list, &info->zone_list);
 591         }
 592
 593         ref = publ->ref;
 594         node = publ->node;
 595 no_match:
 596         spin_unlock_bh(&seq->lock);
 597 not_found:
 598         read_unlock_bh(&tipc_nametbl_lock);
 599         *destnode = node;
 600         return ref;
 601 }
 602
 603 /**
 604  * tipc_nametbl_mc_translate - find multicast destinations
 605  *
 606  * Creates list of all local ports that overlap the given multicast address;
 607  * also determines if any off-node ports overlap.
 608  *
 609  * Note: Publications with a scope narrower than 'limit' are ignored.
 610  * (i.e. local node-scope publications mustn't receive messages arriving
 611  * from another node, even if the multcast link brought it here)
 612  *
 613  * Returns non-zero if any off-node ports overlap
 614  */
 615 int tipc_nametbl_mc_translate(u32 type, u32 lower, u32 upper, u32 limit,
 616                               struct tipc_port_list *dports)
 617 {
 618         struct name_seq *seq;
 619         struct sub_seq *sseq;
 620         struct sub_seq *sseq_stop;
 621         struct name_info *info;
 622         int res = 0;
 623
 624         read_lock_bh(&tipc_nametbl_lock);
 625         seq = nametbl_find_seq(type);
 626         if (!seq)
 627                 goto exit;
 628
 629         spin_lock_bh(&seq->lock);
 630
 631         sseq = seq->sseqs + nameseq_locate_subseq(seq, lower);
 632         sseq_stop = seq->sseqs + seq->first_free;
 633         for (; sseq != sseq_stop; sseq++) {
 634                 struct publication *publ;
 635
 636                 if (sseq->lower > upper)
 637                         break;
 638
 639                 info = sseq->info;
 640                 list_for_each_entry(publ, &info->node_list, node_list) {
 641                         if (publ->scope <= limit)
 642                                 tipc_port_list_add(dports, publ->ref);
 643                 }
 644
 645                 if (info->cluster_list_size != info->node_list_size)
 646                         res = 1;
 647         }
 648
 649         spin_unlock_bh(&seq->lock);
 650 exit:
 651         read_unlock_bh(&tipc_nametbl_lock);
 652         return res;
 653 }
 654
 655 /*
 656  * tipc_nametbl_publish - add name publication to network name tables
 657  */
 658 struct publication *tipc_nametbl_publish(u32 type, u32 lower, u32 upper,
 659                                          u32 scope, u32 port_ref, u32 key)
 660 {
 661         struct publication *publ;
 662         struct sk_buff *buf = NULL;
 663
 664         if (table.local_publ_count >= TIPC_MAX_PUBLICATIONS) {
 665                 pr_warn("Publication failed, local publication limit reached (%u)\n",
 666                         TIPC_MAX_PUBLICATIONS);
 667                 return NULL;
 668         }
 669
 670         write_lock_bh(&tipc_nametbl_lock);
 671         publ = tipc_nametbl_insert_publ(type, lower, upper, scope,
 672                                    tipc_own_addr, port_ref, key);
 673         if (likely(publ)) {
 674                 table.local_publ_count++;
 675                 buf = tipc_named_publish(publ);
 676                 /* Any pending external events? */
 677                 tipc_named_process_backlog();
 678         }
 679         write_unlock_bh(&tipc_nametbl_lock);
 680
 681         if (buf)
 682                 named_cluster_distribute(buf);
 683         return publ;
 684 }
 685
 686 /**
 687  * tipc_nametbl_withdraw - withdraw name publication from network name tables
 688  */
 689 int tipc_nametbl_withdraw(u32 type, u32 lower, u32 ref, u32 key)
 690 {
 691         struct publication *publ;
 692         struct sk_buff *buf;
 693
 694         write_lock_bh(&tipc_nametbl_lock);
 695         publ = tipc_nametbl_remove_publ(type, lower, tipc_own_addr, ref, key);
 696         if (likely(publ)) {
 697                 table.local_publ_count--;
 698                 buf = tipc_named_withdraw(publ);
 699                 /* Any pending external events? */
 700                 tipc_named_process_backlog();
 701                 write_unlock_bh(&tipc_nametbl_lock);
 702                 list_del_init(&publ->pport_list);
 703                 kfree(publ);
 704
 705                 if (buf)
 706                         named_cluster_distribute(buf);
 707                 return 1;
 708         }
 709         write_unlock_bh(&tipc_nametbl_lock);
 710         pr_err("Unable to remove local publication\n"
 711                "(type=%u, lower=%u, ref=%u, key=%u)\n",
 712                type, lower, ref, key);
 713         return 0;
 714 }
 715
 716 /**
 717  * tipc_nametbl_subscribe - add a subscription object to the name table
 718  */
 719 void tipc_nametbl_subscribe(struct tipc_subscription *s)
 720 {
 721         u32 type = s->seq.type;
 722         struct name_seq *seq;
 723
 724         write_lock_bh(&tipc_nametbl_lock);
 725         seq = nametbl_find_seq(type);
 726         if (!seq)
 727                 seq = tipc_nameseq_create(type, &table.types[hash(type)]);
 728         if (seq) {
 729                 spin_lock_bh(&seq->lock);
 730                 tipc_nameseq_subscribe(seq, s);
 731                 spin_unlock_bh(&seq->lock);
 732         } else {
 733                 pr_warn("Failed to create subscription for {%u,%u,%u}\n",
 734                         s->seq.type, s->seq.lower, s->seq.upper);
 735         }
 736         write_unlock_bh(&tipc_nametbl_lock);
 737 }
 738
 739 /**
 740  * tipc_nametbl_unsubscribe - remove a subscription object from name table
 741  */
 742 void tipc_nametbl_unsubscribe(struct tipc_subscription *s)
 743 {
 744         struct name_seq *seq;
 745
 746         write_lock_bh(&tipc_nametbl_lock);
 747         seq = nametbl_find_seq(s->seq.type);
 748         if (seq != NULL) {
 749                 spin_lock_bh(&seq->lock);
 750                 list_del_init(&s->nameseq_list);
 751                 spin_unlock_bh(&seq->lock);
 752                 nameseq_delete_empty(seq);
 753         }
 754         write_unlock_bh(&tipc_nametbl_lock);
 755 }
 756
 757
 758 /**
 759  * subseq_list - print specified sub-sequence contents into the given buffer
 760  */
 761 static int subseq_list(struct sub_seq *sseq, char *buf, int len, u32 depth,
 762                        u32 index)
 763 {
 764         char portIdStr[27];
 765         const char *scope_str[] = {"", " zone", " cluster", " node"};
 766         struct publication *publ;
 767         struct name_info *info;
 768         int ret;
 769
 770         ret = tipc_snprintf(buf, len, "%-10u %-10u ", sseq->lower, sseq->upper);
 771
 772         if (depth == 2) {
 773                 ret += tipc_snprintf(buf - ret, len + ret, "\n");
 774                 return ret;
 775         }
 776
 777         info = sseq->info;
 778
 779         list_for_each_entry(publ, &info->zone_list, zone_list) {
 780                 sprintf(portIdStr, "<%u.%u.%u:%u>",
 781                          tipc_zone(publ->node), tipc_cluster(publ->node),
 782                          tipc_node(publ->node), publ->ref);
 783                 ret += tipc_snprintf(buf + ret, len - ret, "%-26s ", portIdStr);
 784                 if (depth > 3) {
 785                         ret += tipc_snprintf(buf + ret, len - ret, "%-10u %s",
 786                                              publ->key, scope_str[publ->scope]);
 787                 }
 788                 if (!list_is_last(&publ->zone_list, &info->zone_list))
 789                         ret += tipc_snprintf(buf + ret, len - ret,
 790                                              "\n%33s", " ");
 791         }
 792
 793         ret += tipc_snprintf(buf + ret, len - ret, "\n");
 794         return ret;
 795 }
 796
 797 /**
 798  * nameseq_list - print specified name sequence contents into the given buffer
 799  */
 800 static int nameseq_list(struct name_seq *seq, char *buf, int len, u32 depth,
 801                         u32 type, u32 lowbound, u32 upbound, u32 index)
 802 {
 803         struct sub_seq *sseq;
 804         char typearea[11];
 805         int ret = 0;
 806
 807         if (seq->first_free == 0)
 808                 return 0;
 809
 810         sprintf(typearea, "%-10u", seq->type);
 811
 812         if (depth == 1) {
 813                 ret += tipc_snprintf(buf, len, "%s\n", typearea);
 814                 return ret;
 815         }
 816
 817         for (sseq = seq->sseqs; sseq != &seq->sseqs[seq->first_free]; sseq++) {
 818                 if ((lowbound <= sseq->upper) && (upbound >= sseq->lower)) {
 819                         ret += tipc_snprintf(buf + ret, len - ret, "%s ",
 820                                             typearea);
 821                         spin_lock_bh(&seq->lock);
 822                         ret += subseq_list(sseq, buf + ret, len - ret,
 823                                           depth, index);
 824                         spin_unlock_bh(&seq->lock);
 825                         sprintf(typearea, "%10s", " ");
 826                 }
 827         }
 828         return ret;
 829 }
 830
 831 /**
 832  * nametbl_header - print name table header into the given buffer
 833  */
 834 static int nametbl_header(char *buf, int len, u32 depth)
 835 {
 836         const char *header[] = {
 837                 "Type       ",
 838                 "Lower      Upper      ",
 839                 "Port Identity              ",
 840                 "Publication Scope"
 841         };
 842
 843         int i;
 844         int ret = 0;
 845
 846         if (depth > 4)
 847                 depth = 4;
 848         for (i = 0; i < depth; i++)
 849                 ret += tipc_snprintf(buf + ret, len - ret, header[i]);
 850         ret += tipc_snprintf(buf + ret, len - ret, "\n");
 851         return ret;
 852 }
 853
 854 /**
 855  * nametbl_list - print specified name table contents into the given buffer
 856  */
 857 static int nametbl_list(char *buf, int len, u32 depth_info,
 858                         u32 type, u32 lowbound, u32 upbound)
 859 {
 860         struct hlist_head *seq_head;
 861         struct name_seq *seq;
 862         int all_types;
 863         int ret = 0;
 864         u32 depth;
 865         u32 i;
 866
 867         all_types = (depth_info & TIPC_NTQ_ALLTYPES);
 868         depth = (depth_info & ~TIPC_NTQ_ALLTYPES);
 869
 870         if (depth == 0)
 871                 return 0;
 872
 873         if (all_types) {
 874                 /* display all entries in name table to specified depth */
 875                 ret += nametbl_header(buf, len, depth);
 876                 lowbound = 0;
 877                 upbound = ~0;
 878                 for (i = 0; i < TIPC_NAMETBL_SIZE; i++) {
 879                         seq_head = &table.types[i];
 880                         hlist_for_each_entry(seq, seq_head, ns_list) {
 881                                 ret += nameseq_list(seq, buf + ret, len - ret,
 882                                                    depth, seq->type,
 883                                                    lowbound, upbound, i);
 884                         }
 885                 }
 886         } else {
 887                 /* display only the sequence that matches the specified type */
 888                 if (upbound < lowbound) {
 889                         ret += tipc_snprintf(buf + ret, len - ret,
 890                                         "invalid name sequence specified\n");
 891                         return ret;
 892                 }
 893                 ret += nametbl_header(buf + ret, len - ret, depth);
 894                 i = hash(type);
 895                 seq_head = &table.types[i];
 896                 hlist_for_each_entry(seq, seq_head, ns_list) {
 897                         if (seq->type == type) {
 898                                 ret += nameseq_list(seq, buf + ret, len - ret,
 899                                                    depth, type,
 900                                                    lowbound, upbound, i);
 901                                 break;
 902                         }
 903                 }
 904         }
 905         return ret;
 906 }
 907
 908 struct sk_buff *tipc_nametbl_get(const void *req_tlv_area, int req_tlv_space)
 909 {
 910         struct sk_buff *buf;
 911         struct tipc_name_table_query *argv;
 912         struct tlv_desc *rep_tlv;
 913         char *pb;
 914         int pb_len;
 915         int str_len;
 916
 917         if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_NAME_TBL_QUERY))
 918                 return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
 919
 920         buf = tipc_cfg_reply_alloc(TLV_SPACE(ULTRA_STRING_MAX_LEN));
 921         if (!buf)
 922                 return NULL;
 923
 924         rep_tlv = (struct tlv_desc *)buf->data;
 925         pb = TLV_DATA(rep_tlv);
 926         pb_len = ULTRA_STRING_MAX_LEN;
 927         argv = (struct tipc_name_table_query *)TLV_DATA(req_tlv_area);
 928         read_lock_bh(&tipc_nametbl_lock);
 929         str_len = nametbl_list(pb, pb_len, ntohl(argv->depth),
 930                                ntohl(argv->type),
 931                                ntohl(argv->lowbound), ntohl(argv->upbound));
 932         read_unlock_bh(&tipc_nametbl_lock);
 933         str_len += 1;   /* for "\0" */
 934         skb_put(buf, TLV_SPACE(str_len));
 935         TLV_SET(rep_tlv, TIPC_TLV_ULTRA_STRING, NULL, str_len);
 936
 937         return buf;
 938 }
 939
 940 int tipc_nametbl_init(void)
 941 {
 942         table.types = kcalloc(TIPC_NAMETBL_SIZE, sizeof(struct hlist_head),
 943                               GFP_ATOMIC);
 944         if (!table.types)
 945                 return -ENOMEM;
 946
 947         table.local_publ_count = 0;
 948         return 0;
 949 }
 950
 951 /**
 952  * tipc_purge_publications - remove all publications for a given type
 953  *
 954  * tipc_nametbl_lock must be held when calling this function
 955  */
 956 static void tipc_purge_publications(struct name_seq *seq)
 957 {
 958         struct publication *publ, *safe;
 959         struct sub_seq *sseq;
 960         struct name_info *info;
 961
 962         if (!seq->sseqs) {
 963                 nameseq_delete_empty(seq);
 964                 return;
 965         }
 966         sseq = seq->sseqs;
 967         info = sseq->info;
 968         list_for_each_entry_safe(publ, safe, &info->zone_list, zone_list) {
 969                 tipc_nametbl_remove_publ(publ->type, publ->lower, publ->node,
 970                                          publ->ref, publ->key);
 971                 kfree(publ);
 972         }
 973 }
 974
 975 void tipc_nametbl_stop(void)
 976 {
 977         u32 i;
 978         struct name_seq *seq;
 979         struct hlist_head *seq_head;
 980         struct hlist_node *safe;
 981
 982         /* Verify name table is empty and purge any lingering
 983          * publications, then release the name table
 984          */
 985         write_lock_bh(&tipc_nametbl_lock);
 986         for (i = 0; i < TIPC_NAMETBL_SIZE; i++) {
 987                 if (hlist_empty(&table.types[i]))
 988                         continue;
 989                 seq_head = &table.types[i];
 990                 hlist_for_each_entry_safe(seq, safe, seq_head, ns_list) {
 991                         tipc_purge_publications(seq);
 992                 }
 993         }
 994         kfree(table.types);
 995         table.types = NULL;
 996         write_unlock_bh(&tipc_nametbl_lock);
 997 }