Staging: batman-adv: initialize static hash iterators

instead of dynamically registering hash iterators, calling functions are
changed to register the iterator objects statically. The two advantages are:

 * no memory leaks when aborting from hash_iterate()
 * no calls to kmalloc/kfree, therefore a little faster/safer

Tested with 9 QEMU instances, no obvious regression found.

Signed-off-by: Simon Wunderlich <siwu@hrz.tu-chemnitz.de>
Signed-off-by: Andrew Lunn <andrew@lunn.ch>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

diff --git a/drivers/staging/batman-adv/hard-interface.c b/drivers/staging/batman-adv/hard-interface.c
index 28d02f6..7c88592 100644 (file)
--- a/drivers/staging/batman-adv/hard-interface.c
+++ b/drivers/staging/batman-adv/hard-interface.c
@@ -318,7 +318,7 @@ int hardif_add_interface(char *dev, int if_num)
        struct batman_if *batman_if;
        struct batman_packet *batman_packet;
        struct orig_node *orig_node;
-       struct hash_it_t *hashit = NULL;
+       HASHIT(hashit);
 
        batman_if = kmalloc(sizeof(struct batman_if), GFP_KERNEL);
 
@@ -377,8 +377,8 @@ int hardif_add_interface(char *dev, int if_num)
         * if_num */
        spin_lock(&orig_hash_lock);
 
-       while (NULL != (hashit = hash_iterate(orig_hash, hashit))) {
-               orig_node = hashit->bucket->data;
+       while (hash_iterate(orig_hash, &hashit)) {
+               orig_node = hashit.bucket->data;
                if (resize_orig(orig_node, if_num) == -1) {
                        spin_unlock(&orig_hash_lock);
                        goto out;

diff --git a/drivers/staging/batman-adv/hash.c b/drivers/staging/batman-adv/hash.c
index 61cb4a2..5a2018d 100644 (file)
--- a/drivers/staging/batman-adv/hash.c
+++ b/drivers/staging/batman-adv/hash.c
@@ -64,24 +64,18 @@ void hash_destroy(struct hashtable_t *hash)
        kfree(hash);
 }
 
-/* iterate though the hash. first element is selected with iter_in NULL.  use
- * the returned iterator to access the elements until hash_it_t returns NULL. */
+/* iterate though the hash. First element is selected if an iterator
+ * initialized with HASHIT() is supplied as iter. Use the returned
+ * (or supplied) iterator to access the elements until hash_iterate returns
+ * NULL. */
+
 struct hash_it_t *hash_iterate(struct hashtable_t *hash,
-                              struct hash_it_t *iter_in)
+                              struct hash_it_t *iter)
 {
-       struct hash_it_t *iter;
-
        if (!hash)
                return NULL;
-
-       if (iter_in == NULL) {
-               iter = kmalloc(sizeof(struct hash_it_t), GFP_ATOMIC);
-               iter->index = -1;
-               iter->bucket = NULL;
-               iter->prev_bucket = NULL;
-       } else {
-               iter = iter_in;
-       }
+       if (!iter)
+               return NULL;
 
        /* sanity checks first (if our bucket got deleted in the last
         * iteration): */
@@ -139,7 +133,6 @@ struct hash_it_t *hash_iterate(struct hashtable_t *hash,
        }
 
        /* nothing to iterate over anymore */
-       kfree(iter);
        return NULL;
 }
 

diff --cc drivers/staging/batman-adv/hash.h
Simple merge

diff --cc drivers/staging/batman-adv/originator.c
Simple merge

diff --cc drivers/staging/batman-adv/proc.c
Simple merge

diff --cc drivers/staging/batman-adv/routing.c
Simple merge

diff --cc drivers/staging/batman-adv/translation-table.c
Simple merge

diff --cc drivers/staging/batman-adv/vis.c
Simple merge