rhashtable: Add rhastable_walk_peek

This function is like rhashtable_walk_next except that it only returns
the current element in the inter and does not advance the iter.

This patch also creates __rhashtable_walk_find_next. It finds the next
element in the table when the entry cached in iter is NULL or at the end
of a slot. __rhashtable_walk_find_next is called from
rhashtable_walk_next and rhastable_walk_peek.

end_of_table is an added field to the iter structure. This indicates
that the end of table was reached (walker.tbl being NULL is not a
sufficient condition for end of table).

Signed-off-by: Tom Herbert <tom@quantonium.net>
Acked-by: Herbert Xu <herbert@gondor.apana.org.au>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/include/linux/rhashtable.h b/include/linux/rhashtable.h
index 13ccc483738d0316ceec8ec8cf9d12d3f9de3e1a..542b1b265ac4f9de7be11f84deaeacc971fcc7d9 100644 (file)
--- a/include/linux/rhashtable.h
+++ b/include/linux/rhashtable.h
@@ -207,6 +207,7 @@ struct rhashtable_iter {
        struct rhashtable_walker walker;
        unsigned int slot;
        unsigned int skip;
+       bool end_of_table;
 };
 
 static inline unsigned long rht_marker(const struct rhashtable *ht, u32 hash)
@@ -386,6 +387,7 @@ static inline void rhashtable_walk_start(struct rhashtable_iter *iter)
 }
 
 void *rhashtable_walk_next(struct rhashtable_iter *iter);
+void *rhashtable_walk_peek(struct rhashtable_iter *iter);
 void rhashtable_walk_stop(struct rhashtable_iter *iter) __releases(RCU);
 
 void rhashtable_free_and_destroy(struct rhashtable *ht,

diff --git a/lib/rhashtable.c b/lib/rhashtable.c
index 1935e86ed4770adb524a097c6cd91a13759a5de2..6fc52d82efe6498b3937e259eb708a3e2034beab 100644 (file)
--- a/lib/rhashtable.c
+++ b/lib/rhashtable.c
@@ -707,6 +707,7 @@ void rhashtable_walk_enter(struct rhashtable *ht, struct rhashtable_iter *iter)
        iter->p = NULL;
        iter->slot = 0;
        iter->skip = 0;
+       iter->end_of_table = 0;
 
        spin_lock(&ht->lock);
        iter->walker.tbl =
@@ -761,7 +762,7 @@ int rhashtable_walk_start_check(struct rhashtable_iter *iter)
                list_del(&iter->walker.list);
        spin_unlock(&ht->lock);
 
-       if (!iter->walker.tbl) {
+       if (!iter->walker.tbl && !iter->end_of_table) {
                iter->walker.tbl = rht_dereference_rcu(ht->tbl, ht);
                return -EAGAIN;
        }
@@ -771,18 +772,16 @@ int rhashtable_walk_start_check(struct rhashtable_iter *iter)
 EXPORT_SYMBOL_GPL(rhashtable_walk_start_check);
 
 /**
- * rhashtable_walk_next - Return the next object and advance the iterator
+ * __rhashtable_walk_find_next - Find the next element in a table (or the first
+ * one in case of a new walk).
+ *
  * @iter:      Hash table iterator
  *
- * Note that you must call rhashtable_walk_stop when you are finished
- * with the walk.
+ * Returns the found object or NULL when the end of the table is reached.
  *
- * Returns the next object or NULL when the end of the table is reached.
- *
- * Returns -EAGAIN if resize event occured.  Note that the iterator
- * will rewind back to the beginning and you may continue to use it.
+ * Returns -EAGAIN if resize event occurred.
  */
-void *rhashtable_walk_next(struct rhashtable_iter *iter)
+static void *__rhashtable_walk_find_next(struct rhashtable_iter *iter)
 {
        struct bucket_table *tbl = iter->walker.tbl;
        struct rhlist_head *list = iter->list;
@@ -790,13 +789,8 @@ void *rhashtable_walk_next(struct rhashtable_iter *iter)
        struct rhash_head *p = iter->p;
        bool rhlist = ht->rhlist;
 
-       if (p) {
-               if (!rhlist || !(list = rcu_dereference(list->next))) {
-                       p = rcu_dereference(p->next);
-                       list = container_of(p, struct rhlist_head, rhead);
-               }
-               goto next;
-       }
+       if (!tbl)
+               return NULL;
 
        for (; iter->slot < tbl->size; iter->slot++) {
                int skip = iter->skip;
@@ -840,12 +834,89 @@ next:
                iter->slot = 0;
                iter->skip = 0;
                return ERR_PTR(-EAGAIN);
+       } else {
+               iter->end_of_table = true;
        }
 
        return NULL;
 }
+
+/**
+ * rhashtable_walk_next - Return the next object and advance the iterator
+ * @iter:      Hash table iterator
+ *
+ * Note that you must call rhashtable_walk_stop when you are finished
+ * with the walk.
+ *
+ * Returns the next object or NULL when the end of the table is reached.
+ *
+ * Returns -EAGAIN if resize event occurred.  Note that the iterator
+ * will rewind back to the beginning and you may continue to use it.
+ */
+void *rhashtable_walk_next(struct rhashtable_iter *iter)
+{
+       struct rhlist_head *list = iter->list;
+       struct rhashtable *ht = iter->ht;
+       struct rhash_head *p = iter->p;
+       bool rhlist = ht->rhlist;
+
+       if (p) {
+               if (!rhlist || !(list = rcu_dereference(list->next))) {
+                       p = rcu_dereference(p->next);
+                       list = container_of(p, struct rhlist_head, rhead);
+               }
+               if (!rht_is_a_nulls(p)) {
+                       iter->skip++;
+                       iter->p = p;
+                       iter->list = list;
+                       return rht_obj(ht, rhlist ? &list->rhead : p);
+               }
+
+               /* At the end of this slot, switch to next one and then find
+                * next entry from that point.
+                */
+               iter->skip = 0;
+               iter->slot++;
+       }
+
+       return __rhashtable_walk_find_next(iter);
+}
 EXPORT_SYMBOL_GPL(rhashtable_walk_next);
 
+/**
+ * rhashtable_walk_peek - Return the next object but don't advance the iterator
+ * @iter:      Hash table iterator
+ *
+ * Returns the next object or NULL when the end of the table is reached.
+ *
+ * Returns -EAGAIN if resize event occurred.  Note that the iterator
+ * will rewind back to the beginning and you may continue to use it.
+ */
+void *rhashtable_walk_peek(struct rhashtable_iter *iter)
+{
+       struct rhlist_head *list = iter->list;
+       struct rhashtable *ht = iter->ht;
+       struct rhash_head *p = iter->p;
+
+       if (p)
+               return rht_obj(ht, ht->rhlist ? &list->rhead : p);
+
+       /* No object found in current iter, find next one in the table. */
+
+       if (iter->skip) {
+               /* A nonzero skip value points to the next entry in the table
+                * beyond that last one that was found. Decrement skip so
+                * we find the current value. __rhashtable_walk_find_next
+                * will restore the original value of skip assuming that
+                * the table hasn't changed.
+                */
+               iter->skip--;
+       }
+
+       return __rhashtable_walk_find_next(iter);
+}
+EXPORT_SYMBOL_GPL(rhashtable_walk_peek);
+
 /**
  * rhashtable_walk_stop - Finish a hash table walk
  * @iter:      Hash table iterator