[PATCH] knfsd: Create cache_lookup function instead of using a macro to declare one

The C++-like 'template' approach proves to be too ugly and hard to work with.

The old 'template' won't go away until all users are updated.

Signed-off-by: Neil Brown <neilb@suse.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

diff --git a/include/linux/sunrpc/cache.h b/include/linux/sunrpc/cache.h
index 405ac14e509aeaca80c05ebf8d6222651efb6bb1..3e17a5ff1dea312239b28672e1e6b5db0cd222db 100644 (file)
--- a/include/linux/sunrpc/cache.h
+++ b/include/linux/sunrpc/cache.h
@@ -81,6 +81,11 @@ struct cache_detail {
                                              struct cache_detail *cd,
                                              struct cache_head *h);
 
+       struct cache_head *     (*alloc)(void);
+       int                     (*match)(struct cache_head *orig, struct cache_head *new);
+       void                    (*init)(struct cache_head *orig, struct cache_head *new);
+       void                    (*update)(struct cache_head *orig, struct cache_head *new);
+
        /* fields below this comment are for internal use
         * and should not be touched by cache owners
         */
@@ -237,6 +242,13 @@ RTN *FNAME ARGS                                                                            \
        & FUNC##_cache, FUNC##_hash(item), FUNC##_match(item, tmp),     \
        STRUCT##_init(new, item), STRUCT##_update(tmp, item))
 
+extern struct cache_head *
+sunrpc_cache_lookup(struct cache_detail *detail,
+                   struct cache_head *key, int hash);
+extern struct cache_head *
+sunrpc_cache_update(struct cache_detail *detail,
+                   struct cache_head *new, struct cache_head *old, int hash);
+
 
 #define cache_for_each(pos, detail, index, member)                                             \
        for (({read_lock(&(detail)->hash_lock); index = (detail)->hash_size;}) ;                \

diff --git a/net/sunrpc/cache.c b/net/sunrpc/cache.c
index 0acccfeeb284ed7b12610bec06cd1bc4cd4ad62e..4449dc52edf5bcd4094c49dc2ece8fe5de2a87b7 100644 (file)
--- a/net/sunrpc/cache.c
+++ b/net/sunrpc/cache.c
@@ -47,6 +47,104 @@ void cache_init(struct cache_head *h)
        h->last_refresh = now;
 }
 
+struct cache_head *sunrpc_cache_lookup(struct cache_detail *detail,
+                                      struct cache_head *key, int hash)
+{
+       struct cache_head **head,  **hp;
+       struct cache_head *new = NULL;
+
+       head = &detail->hash_table[hash];
+
+       read_lock(&detail->hash_lock);
+
+       for (hp=head; *hp != NULL ; hp = &(*hp)->next) {
+               struct cache_head *tmp = *hp;
+               if (detail->match(tmp, key)) {
+                       cache_get(tmp);
+                       read_unlock(&detail->hash_lock);
+                       return tmp;
+               }
+       }
+       read_unlock(&detail->hash_lock);
+       /* Didn't find anything, insert an empty entry */
+
+       new = detail->alloc();
+       if (!new)
+               return NULL;
+       cache_init(new);
+
+       write_lock(&detail->hash_lock);
+
+       /* check if entry appeared while we slept */
+       for (hp=head; *hp != NULL ; hp = &(*hp)->next) {
+               struct cache_head *tmp = *hp;
+               if (detail->match(tmp, key)) {
+                       cache_get(tmp);
+                       write_unlock(&detail->hash_lock);
+                       detail->cache_put(new, detail);
+                       return tmp;
+               }
+       }
+       detail->init(new, key);
+       new->next = *head;
+       *head = new;
+       detail->entries++;
+       cache_get(new);
+       write_unlock(&detail->hash_lock);
+
+       return new;
+}
+EXPORT_SYMBOL(sunrpc_cache_lookup);
+
+struct cache_head *sunrpc_cache_update(struct cache_detail *detail,
+                                      struct cache_head *new, struct cache_head *old, int hash)
+{
+       /* The 'old' entry is to be replaced by 'new'.
+        * If 'old' is not VALID, we update it directly,
+        * otherwise we need to replace it
+        */
+       struct cache_head **head;
+       struct cache_head *tmp;
+
+       if (!test_bit(CACHE_VALID, &old->flags)) {
+               write_lock(&detail->hash_lock);
+               if (!test_bit(CACHE_VALID, &old->flags)) {
+                       if (test_bit(CACHE_NEGATIVE, &new->flags))
+                               set_bit(CACHE_NEGATIVE, &old->flags);
+                       else
+                               detail->update(old, new);
+                       /* FIXME cache_fresh should come first */
+                       write_unlock(&detail->hash_lock);
+                       cache_fresh(detail, old, new->expiry_time);
+                       return old;
+               }
+               write_unlock(&detail->hash_lock);
+       }
+       /* We need to insert a new entry */
+       tmp = detail->alloc();
+       if (!tmp) {
+               detail->cache_put(old, detail);
+               return NULL;
+       }
+       cache_init(tmp);
+       detail->init(tmp, old);
+       head = &detail->hash_table[hash];
+
+       write_lock(&detail->hash_lock);
+       if (test_bit(CACHE_NEGATIVE, &new->flags))
+               set_bit(CACHE_NEGATIVE, &tmp->flags);
+       else
+               detail->update(tmp, new);
+       tmp->next = *head;
+       *head = tmp;
+       cache_get(tmp);
+       write_unlock(&detail->hash_lock);
+       cache_fresh(detail, tmp, new->expiry_time);
+       cache_fresh(detail, old, 0);
+       detail->cache_put(old, detail);
+       return tmp;
+}
+EXPORT_SYMBOL(sunrpc_cache_update);
 
 static int cache_make_upcall(struct cache_detail *detail, struct cache_head *h);
 /*