1 files changed, 120 insertions, 169 deletions

diff --git a/net/tipc/name_table.c b/net/tipc/name_table.c
index 205ed4a4e18..46e6b6c2ecc 100644
--- a/net/tipc/name_table.c
+++ b/net/tipc/name_table.c
@@ -2,7 +2,7 @@
  * net/tipc/name_table.c: TIPC name table code
  *
  * Copyright (c) 2000-2006, Ericsson AB
- * Copyright (c) 2004-2008, Wind River Systems
+ * Copyright (c) 2004-2008, 2010-2011, Wind River Systems
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -44,9 +44,7 @@
 static int tipc_nametbl_size = 1024;            /* must be a power of 2 */
 
 /**
- * struct sub_seq - container for all published instances of a name sequence
- * @lower: name sequence lower bound
- * @upper: name sequence upper bound
+ * struct name_info - name sequence publication info
  * @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
@@ -59,18 +57,29 @@ static int tipc_nametbl_size = 1024;		/* must be a power of 2 */
  *       (The cluster and node lists may be empty.)
  */
 
-struct sub_seq {
-        u32 lower;
-        u32 upper;
-        struct publication *node_list;
-        struct publication *cluster_list;
-        struct publication *zone_list;
+struct name_info {
+        struct list_head node_list;
+        struct list_head cluster_list;
+        struct list_head zone_list;
         u32 node_list_size;
         u32 cluster_list_size;
         u32 zone_list_size;
 };
 
 /**
+ * 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;
+};
+
+/**
  * 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';
@@ -246,6 +255,7 @@ static struct publication *tipc_nameseq_insert_publ(struct name_seq *nseq,
         struct subscription *st;
         struct publication *publ;
         struct sub_seq *sseq;
+        struct name_info *info;
         int created_subseq = 0;
 
         sseq = nameseq_find_subseq(nseq, lower);
@@ -258,6 +268,8 @@ static struct publication *tipc_nameseq_insert_publ(struct name_seq *nseq,
                              type, lower, upper);
                         return NULL;
                 }
+
+                info = sseq->info;
         } else {
                 u32 inspos;
                 struct sub_seq *freesseq;
@@ -292,6 +304,17 @@ static struct publication *tipc_nameseq_insert_publ(struct name_seq *nseq,
                         nseq->alloc *= 2;
                 }
 
+                info = kzalloc(sizeof(*info), GFP_ATOMIC);
+                if (!info) {
+                        warn("Cannot publish {%u,%u,%u}, no memory\n",
+                             type, lower, upper);
+                        return NULL;
+                }
+
+                INIT_LIST_HEAD(&info->node_list);
+                INIT_LIST_HEAD(&info->cluster_list);
+                INIT_LIST_HEAD(&info->zone_list);
+
                 /* Insert new sub-sequence */
 
                 sseq = &nseq->sseqs[inspos];
@@ -301,6 +324,7 @@ static struct publication *tipc_nameseq_insert_publ(struct name_seq *nseq,
                 nseq->first_free++;
                 sseq->lower = lower;
                 sseq->upper = upper;
+                sseq->info = info;
                 created_subseq = 1;
         }
 
@@ -310,33 +334,17 @@ static struct publication *tipc_nameseq_insert_publ(struct name_seq *nseq,
         if (!publ)
                 return NULL;
 
-        sseq->zone_list_size++;
-        if (!sseq->zone_list)
-                sseq->zone_list = publ->zone_list_next = publ;
-        else {
-                publ->zone_list_next = sseq->zone_list->zone_list_next;
-                sseq->zone_list->zone_list_next = publ;
-        }
+        list_add(&publ->zone_list, &info->zone_list);
+        info->zone_list_size++;
 
         if (in_own_cluster(node)) {
-                sseq->cluster_list_size++;
-                if (!sseq->cluster_list)
-                        sseq->cluster_list = publ->cluster_list_next = publ;
-                else {
-                        publ->cluster_list_next =
-                        sseq->cluster_list->cluster_list_next;
-                        sseq->cluster_list->cluster_list_next = publ;
-                }
+                list_add(&publ->cluster_list, &info->cluster_list);
+                info->cluster_list_size++;
         }
 
         if (node == tipc_own_addr) {
-                sseq->node_list_size++;
-                if (!sseq->node_list)
-                        sseq->node_list = publ->node_list_next = publ;
-                else {
-                        publ->node_list_next = sseq->node_list->node_list_next;
-                        sseq->node_list->node_list_next = publ;
-                }
+                list_add(&publ->node_list, &info->node_list);
+                info->node_list_size++;
         }
 
         /*
@@ -370,9 +378,8 @@ static struct publication *tipc_nameseq_remove_publ(struct name_seq *nseq, u32 i
                                                     u32 node, u32 ref, u32 key)
 {
         struct publication *publ;
-        struct publication *curr;
-        struct publication *prev;
         struct sub_seq *sseq = nameseq_find_subseq(nseq, inst);
+        struct name_info *info;
         struct sub_seq *free;
         struct subscription *s, *st;
         int removed_subseq = 0;
@@ -380,96 +387,41 @@ static struct publication *tipc_nameseq_remove_publ(struct name_seq *nseq, u32 i
         if (!sseq)
                 return NULL;
 
-        /* Remove publication from zone scope list */
+        info = sseq->info;
 
-        prev = sseq->zone_list;
-        publ = sseq->zone_list->zone_list_next;
-        while ((publ->key != key) || (publ->ref != ref) ||
-               (publ->node && (publ->node != node))) {
-                prev = publ;
-                publ = publ->zone_list_next;
-                if (prev == sseq->zone_list) {
+        /* Locate publication, if it exists */
 
-                        /* Prevent endless loop if publication not found */
-
-                        return NULL;
-                }
-        }
-        if (publ != sseq->zone_list)
-                prev->zone_list_next = publ->zone_list_next;
-        else if (publ->zone_list_next != publ) {
-                prev->zone_list_next = publ->zone_list_next;
-                sseq->zone_list = publ->zone_list_next;
-        } else {
-                sseq->zone_list = NULL;
+        list_for_each_entry(publ, &info->zone_list, zone_list) {
+                if ((publ->key == key) && (publ->ref == ref) &&
+                    (!publ->node || (publ->node == node)))
+                        goto found;
         }
-        sseq->zone_list_size--;
+        return NULL;
+
+found:
+        /* Remove publication from zone scope list */
+
+        list_del(&publ->zone_list);
+        info->zone_list_size--;
 
         /* Remove publication from cluster scope list, if present */
 
         if (in_own_cluster(node)) {
-                prev = sseq->cluster_list;
-                curr = sseq->cluster_list->cluster_list_next;
-                while (curr != publ) {
-                        prev = curr;
-                        curr = curr->cluster_list_next;
-                        if (prev == sseq->cluster_list) {
-
-                                /* Prevent endless loop for malformed list */
-
-                                err("Unable to de-list cluster publication\n"
-                                    "{%u%u}, node=0x%x, ref=%u, key=%u)\n",
-                                    publ->type, publ->lower, publ->node,
-                                    publ->ref, publ->key);
-                                goto end_cluster;
-                        }
-                }
-                if (publ != sseq->cluster_list)
-                        prev->cluster_list_next = publ->cluster_list_next;
-                else if (publ->cluster_list_next != publ) {
-                        prev->cluster_list_next = publ->cluster_list_next;
-                        sseq->cluster_list = publ->cluster_list_next;
-                } else {
-                        sseq->cluster_list = NULL;
-                }
-                sseq->cluster_list_size--;
+                list_del(&publ->cluster_list);
+                info->cluster_list_size--;
         }
-end_cluster:
 
         /* Remove publication from node scope list, if present */
 
         if (node == tipc_own_addr) {
-                prev = sseq->node_list;
-                curr = sseq->node_list->node_list_next;
-                while (curr != publ) {
-                        prev = curr;
-                        curr = curr->node_list_next;
-                        if (prev == sseq->node_list) {
-
-                                /* Prevent endless loop for malformed list */
-
-                                err("Unable to de-list node publication\n"
-                                    "{%u%u}, node=0x%x, ref=%u, key=%u)\n",
-                                    publ->type, publ->lower, publ->node,
-                                    publ->ref, publ->key);
-                                goto end_node;
-                        }
-                }
-                if (publ != sseq->node_list)
-                        prev->node_list_next = publ->node_list_next;
-                else if (publ->node_list_next != publ) {
-                        prev->node_list_next = publ->node_list_next;
-                        sseq->node_list = publ->node_list_next;
-                } else {
-                        sseq->node_list = NULL;
-                }
-                sseq->node_list_size--;
+                list_del(&publ->node_list);
+                info->node_list_size--;
         }
-end_node:
 
         /* Contract subseq list if no more publications for that subseq */
 
-        if (!sseq->zone_list) {
+        if (list_empty(&info->zone_list)) {
+                kfree(info);
                 free = &nseq->sseqs[nseq->first_free--];
                 memmove(sseq, sseq + 1, (free - (sseq + 1)) * sizeof(*sseq));
                 removed_subseq = 1;
@@ -506,12 +458,12 @@ static void tipc_nameseq_subscribe(struct name_seq *nseq, struct subscription *s
                 return;
 
         while (sseq != &nseq->sseqs[nseq->first_free]) {
-                struct publication *zl = sseq->zone_list;
-                if (zl && tipc_subscr_overlap(s, sseq->lower, sseq->upper)) {
-                        struct publication *crs = zl;
+                if (tipc_subscr_overlap(s, sseq->lower, sseq->upper)) {
+                        struct publication *crs;
+                        struct name_info *info = sseq->info;
                         int must_report = 1;
 
-                        do {
+                        list_for_each_entry(crs, &info->zone_list, zone_list) {
                                 tipc_subscr_report_overlap(s,
                                                            sseq->lower,
                                                            sseq->upper,
@@ -520,8 +472,7 @@ static void tipc_nameseq_subscribe(struct name_seq *nseq, struct subscription *s
                                                            crs->node,
                                                            must_report);
                                 must_report = 0;
-                                crs = crs->zone_list_next;
-                        } while (crs != zl);
+                        }
                 }
                 sseq++;
         }
@@ -591,9 +542,10 @@ struct publication *tipc_nametbl_remove_publ(u32 type, u32 lower,
 u32 tipc_nametbl_translate(u32 type, u32 instance, u32 *destnode)
 {
         struct sub_seq *sseq;
-        struct publication *publ = NULL;
+        struct name_info *info;
+        struct publication *publ;
         struct name_seq *seq;
-        u32 ref;
+        u32 ref = 0;
 
         if (!tipc_in_scope(*destnode, tipc_own_addr))
                 return 0;
@@ -606,55 +558,57 @@ u32 tipc_nametbl_translate(u32 type, u32 instance, u32 *destnode)
         if (unlikely(!sseq))
                 goto not_found;
         spin_lock_bh(&seq->lock);
+        info = sseq->info;
 
         /* Closest-First Algorithm: */
         if (likely(!*destnode)) {
-                publ = sseq->node_list;
-                if (publ) {
-                        sseq->node_list = publ->node_list_next;
-found:
-                        ref = publ->ref;
-                        *destnode = publ->node;
-                        spin_unlock_bh(&seq->lock);
-                        read_unlock_bh(&tipc_nametbl_lock);
-                        return ref;
-                }
-                publ = sseq->cluster_list;
-                if (publ) {
-                        sseq->cluster_list = publ->cluster_list_next;
-                        goto found;
-                }
-                publ = sseq->zone_list;
-                if (publ) {
-                        sseq->zone_list = publ->zone_list_next;
-                        goto found;
+                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);
+                } else {
+                        publ = list_first_entry(&info->zone_list,
+                                                struct publication,
+                                                zone_list);
+                        list_move_tail(&publ->zone_list,
+                                       &info->zone_list);
                 }
         }
 
         /* Round-Robin Algorithm: */
         else if (*destnode == tipc_own_addr) {
-                publ = sseq->node_list;
-                if (publ) {
-                        sseq->node_list = publ->node_list_next;
-                        goto found;
-                }
+                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);
         } else if (in_own_cluster(*destnode)) {
-                publ = sseq->cluster_list;
-                if (publ) {
-                        sseq->cluster_list = publ->cluster_list_next;
-                        goto found;
-                }
+                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);
         } else {
-                publ = sseq->zone_list;
-                if (publ) {
-                        sseq->zone_list = publ->zone_list_next;
-                        goto found;
-                }
+                publ = list_first_entry(&info->zone_list, struct publication,
+                                        zone_list);
+                list_move_tail(&publ->zone_list, &info->zone_list);
         }
+
+        ref = publ->ref;
+        *destnode = publ->node;
+no_match:
         spin_unlock_bh(&seq->lock);
 not_found:
         read_unlock_bh(&tipc_nametbl_lock);
-        return 0;
+        return ref;
 }
 
 /**
@@ -676,6 +630,7 @@ int tipc_nametbl_mc_translate(u32 type, u32 lower, u32 upper, u32 limit,
         struct name_seq *seq;
         struct sub_seq *sseq;
         struct sub_seq *sseq_stop;
+        struct name_info *info;
         int res = 0;
 
         read_lock_bh(&tipc_nametbl_lock);
@@ -693,16 +648,13 @@ int tipc_nametbl_mc_translate(u32 type, u32 lower, u32 upper, u32 limit,
                 if (sseq->lower > upper)
                         break;
 
-                publ = sseq->node_list;
-                if (publ) {
-                        do {
-                                if (publ->scope <= limit)
-                                        tipc_port_list_add(dports, publ->ref);
-                                publ = publ->node_list_next;
-                        } while (publ != sseq->node_list);
+                info = sseq->info;
+                list_for_each_entry(publ, &info->node_list, node_list) {
+                        if (publ->scope <= limit)
+                                tipc_port_list_add(dports, publ->ref);
                 }
 
-                if (sseq->cluster_list_size != sseq->node_list_size)
+                if (info->cluster_list_size != info->node_list_size)
                         res = 1;
         }
 
@@ -840,16 +792,19 @@ static void subseq_list(struct sub_seq *sseq, struct print_buf *buf, u32 depth,
 {
         char portIdStr[27];
         const char *scope_str[] = {"", " zone", " cluster", " node"};
-        struct publication *publ = sseq->zone_list;
+        struct publication *publ;
+        struct name_info *info;
 
         tipc_printf(buf, "%-10u %-10u ", sseq->lower, sseq->upper);
 
-        if (depth == 2 || !publ) {
+        if (depth == 2) {
                 tipc_printf(buf, "\n");
                 return;
         }
 
-        do {
+        info = sseq->info;
+
+        list_for_each_entry(publ, &info->zone_list, zone_list) {
                 sprintf(portIdStr, "<%u.%u.%u:%u>",
                          tipc_zone(publ->node), tipc_cluster(publ->node),
                          tipc_node(publ->node), publ->ref);
@@ -858,13 +813,9 @@ static void subseq_list(struct sub_seq *sseq, struct print_buf *buf, u32 depth,
                         tipc_printf(buf, "%-10u %s", publ->key,
                                     scope_str[publ->scope]);
                 }
-
-                publ = publ->zone_list_next;
-                if (publ == sseq->zone_list)
-                        break;
-
-                tipc_printf(buf, "\n%33s", " ");
-        } while (1);
+                if (!list_is_last(&publ->zone_list, &info->zone_list))
+                        tipc_printf(buf, "\n%33s", " ");
+        };
 
         tipc_printf(buf, "\n");
 }