[PATCH] knfsd: Change the store of auth_domains to not be a 'cache'

The 'auth_domain's are simply handles on internal data structures.  They do
not cache information from user-space, and forcing them into the mold of a
'cache' misrepresents their true nature and causes confusion.

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

6 files changed, 81 insertions, 145 deletions

diff --git a/fs/nfsd/export.c b/fs/nfsd/export.c
index 417ec02df44f..ac0997731fce 100644
--- a/fs/nfsd/export.c
+++ b/fs/nfsd/export.c
@@ -242,7 +242,7 @@ static inline int svc_expkey_match (struct svc_expkey *a, struct svc_expkey *b)
 
 static inline void svc_expkey_init(struct svc_expkey *new, struct svc_expkey *item)
 {
-        cache_get(&item->ek_client->h);
+        kref_get(&item->ek_client->ref);
         new->ek_client = item->ek_client;
         new->ek_fsidtype = item->ek_fsidtype;
         new->ek_fsid[0] = item->ek_fsid[0];
@@ -474,7 +474,7 @@ static inline int svc_export_match(struct svc_export *a, struct svc_export *b)
 }
 static inline void svc_export_init(struct svc_export *new, struct svc_export *item)
 {
-        cache_get(&item->ex_client->h);
+        kref_get(&item->ex_client->ref);
         new->ex_client = item->ex_client;
         new->ex_dentry = dget(item->ex_dentry);
         new->ex_mnt = mntget(item->ex_mnt);
@@ -1129,7 +1129,6 @@ exp_delclient(struct nfsctl_client *ncp)
          */
         if (dom) {
                 err = auth_unix_forget_old(dom);
-                dom->h.expiry_time = get_seconds();
                 auth_domain_put(dom);
         }
 
diff --git a/include/linux/sunrpc/svcauth.h b/include/linux/sunrpc/svcauth.h
index c119ce7cbd22..2fe2087edd66 100644
--- a/include/linux/sunrpc/svcauth.h
+++ b/include/linux/sunrpc/svcauth.h
@@ -45,9 +45,10 @@ struct svc_rqst;		/* forward decl */
  * of ip addresses to the given client.
  */
 struct auth_domain {
-        struct  cache_head      h;
+        struct kref             ref;
+        struct hlist_node       hash;
         char                    *name;
-        int                     flavour;
+        struct auth_ops         *flavour;
 };
 
 /*
@@ -86,6 +87,9 @@ struct auth_domain {
  *
  * domain_release()
  *   This call releases a domain.
+ * set_client()
+ *   Givens a pending request (struct svc_rqst), finds and assigns
+ *   an appropriate 'auth_domain' as the client.
  */
 struct auth_ops {
         char *  name;
@@ -117,7 +121,7 @@ extern void	svc_auth_unregister(rpc_authflavor_t flavor);
 extern struct auth_domain *unix_domain_find(char *name);
 extern void auth_domain_put(struct auth_domain *item);
 extern int auth_unix_add_addr(struct in_addr addr, struct auth_domain *dom);
-extern struct auth_domain *auth_domain_lookup(struct auth_domain *item, int set);
+extern struct auth_domain *auth_domain_lookup(char *name, struct auth_domain *new);
 extern struct auth_domain *auth_domain_find(char *name);
 extern struct auth_domain *auth_unix_lookup(struct in_addr addr);
 extern int auth_unix_forget_old(struct auth_domain *dom);
@@ -160,8 +164,6 @@ static inline unsigned long hash_mem(char *buf, int length, int bits)
         return hash >> (BITS_PER_LONG - bits);
 }
 
-extern struct cache_detail auth_domain_cache, ip_map_cache;
-
 #endif /* __KERNEL__ */
 
 #endif /* _LINUX_SUNRPC_SVCAUTH_H_ */
diff --git a/net/sunrpc/auth_gss/svcauth_gss.c b/net/sunrpc/auth_gss/svcauth_gss.c
index 23632d84d8d7..6b073c2e6930 100644
--- a/net/sunrpc/auth_gss/svcauth_gss.c
+++ b/net/sunrpc/auth_gss/svcauth_gss.c
@@ -645,6 +645,8 @@ find_gss_auth_domain(struct gss_ctx *ctx, u32 svc)
         return auth_domain_find(name);
 }
 
+static struct auth_ops svcauthops_gss;
+
 int
 svcauth_gss_register_pseudoflavor(u32 pseudoflavor, char * name)
 {
@@ -655,20 +657,18 @@ svcauth_gss_register_pseudoflavor(u32 pseudoflavor, char * name)
         new = kmalloc(sizeof(*new), GFP_KERNEL);
         if (!new)
                 goto out;
-        cache_init(&new->h.h);
+        kref_init(&new->h.ref);
         new->h.name = kmalloc(strlen(name) + 1, GFP_KERNEL);
         if (!new->h.name)
                 goto out_free_dom;
         strcpy(new->h.name, name);
-        new->h.flavour = RPC_AUTH_GSS;
+        new->h.flavour = &svcauthops_gss;
         new->pseudoflavor = pseudoflavor;
-        new->h.h.expiry_time = NEVER;
 
-        test = auth_domain_lookup(&new->h, 1);
-        if (test == &new->h) {
-                BUG_ON(atomic_dec_and_test(&new->h.h.refcnt));
-        } else { /* XXX Duplicate registration? */
+        test = auth_domain_lookup(name, &new->h);
+        if (test != &new->h) { /* XXX Duplicate registration? */
                 auth_domain_put(&new->h);
+                /* dangling ref-count... */
                 goto out;
         }
         return 0;
diff --git a/net/sunrpc/sunrpc_syms.c b/net/sunrpc/sunrpc_syms.c
index 9f7373203592..40401196e7de 100644
--- a/net/sunrpc/sunrpc_syms.c
+++ b/net/sunrpc/sunrpc_syms.c
@@ -142,6 +142,7 @@ EXPORT_SYMBOL(nlm_debug);
 
 extern int register_rpc_pipefs(void);
 extern void unregister_rpc_pipefs(void);
+extern struct cache_detail ip_map_cache;
 
 static int __init
 init_sunrpc(void)
@@ -158,7 +159,6 @@ init_sunrpc(void)
 #ifdef CONFIG_PROC_FS
         rpc_proc_init();
 #endif
-        cache_register(&auth_domain_cache);
         cache_register(&ip_map_cache);
 out:
         return err;
@@ -169,8 +169,6 @@ cleanup_sunrpc(void)
 {
         unregister_rpc_pipefs();
         rpc_destroy_mempool();
-        if (cache_unregister(&auth_domain_cache))
-                printk(KERN_ERR "sunrpc: failed to unregister auth_domain cache\n");
         if (cache_unregister(&ip_map_cache))
                 printk(KERN_ERR "sunrpc: failed to unregister ip_map cache\n");
 #ifdef RPC_DEBUG
diff --git a/net/sunrpc/svcauth.c b/net/sunrpc/svcauth.c
index dda4f0c63511..5b28c6176806 100644
--- a/net/sunrpc/svcauth.c
+++ b/net/sunrpc/svcauth.c
@@ -106,112 +106,56 @@ svc_auth_unregister(rpc_authflavor_t flavor)
 EXPORT_SYMBOL(svc_auth_unregister);
 
 /**************************************************
- * cache for domain name to auth_domain
- * Entries are only added by flavours which will normally
- * have a structure that 'inherits' from auth_domain.
- * e.g. when an IP -> domainname is given to  auth_unix,
- * and the domain name doesn't exist, it will create a
- * auth_unix_domain and add it to this hash table.
- * If it finds the name does exist, but isn't AUTH_UNIX,
- * it will complain.
+ * 'auth_domains' are stored in a hash table indexed by name.
+ * When the last reference to an 'auth_domain' is dropped,
+ * the object is unhashed and freed.
+ * If auth_domain_lookup fails to find an entry, it will return
+ * it's second argument 'new'.  If this is non-null, it will
+ * have been atomically linked into the table.
  */
 
-/*
- * Auth auth_domain cache is somewhat different to other caches,
- * largely because the entries are possibly of different types:
- * each auth flavour has it's own type.
- * One consequence of this that DefineCacheLookup cannot
- * allocate a new structure as it cannot know the size.
- * Notice that the "INIT" code fragment is quite different
- * from other caches.  When auth_domain_lookup might be
- * creating a new domain, the new domain is passed in
- * complete and it is used as-is rather than being copied into
- * another structure.
- */
 #define DN_HASHBITS     6
 #define DN_HASHMAX      (1<<DN_HASHBITS)
 #define DN_HASHMASK     (DN_HASHMAX-1)
 
-static struct cache_head        *auth_domain_table[DN_HASHMAX];
-
-static void auth_domain_drop(struct cache_head *item, struct cache_detail *cd)
-{
-        struct auth_domain *dom = container_of(item, struct auth_domain, h);
-        if (cache_put(item,cd))
-                authtab[dom->flavour]->domain_release(dom);
-}
-
-
-struct cache_detail auth_domain_cache = {
-        .owner          = THIS_MODULE,
-        .hash_size      = DN_HASHMAX,
-        .hash_table     = auth_domain_table,
-        .name           = "auth.domain",
-        .cache_put      = auth_domain_drop,
-};
+static struct hlist_head        auth_domain_table[DN_HASHMAX];
+static spinlock_t       auth_domain_lock = SPIN_LOCK_UNLOCKED;
 
 void auth_domain_put(struct auth_domain *dom)
 {
-        auth_domain_drop(&dom->h, &auth_domain_cache);
-}
-
-static inline int auth_domain_hash(struct auth_domain *item)
-{
-        return hash_str(item->name, DN_HASHBITS);
-}
-static inline int auth_domain_match(struct auth_domain *tmp, struct auth_domain *item)
-{
-        return strcmp(tmp->name, item->name) == 0;
+        if (atomic_dec_and_lock(&dom->ref.refcount, &auth_domain_lock)) {
+                hlist_del(&dom->hash);
+                dom->flavour->domain_release(dom);
+        }
 }
 
 struct auth_domain *
-auth_domain_lookup(struct auth_domain *item, int set)
+auth_domain_lookup(char *name, struct auth_domain *new)
 {
-        struct auth_domain *tmp = NULL;
-        struct cache_head **hp, **head;
-        head = &auth_domain_cache.hash_table[auth_domain_hash(item)];
-
-        if (set)
-                write_lock(&auth_domain_cache.hash_lock);
-        else
-                read_lock(&auth_domain_cache.hash_lock);
-        for (hp=head; *hp != NULL; hp = &tmp->h.next) {
-                tmp = container_of(*hp, struct auth_domain, h);
-                if (!auth_domain_match(tmp, item))
-                        continue;
-                if (!set) {
-                        cache_get(&tmp->h);
-                        goto out_noset;
+        struct auth_domain *hp;
+        struct hlist_head *head;
+        struct hlist_node *np;
+
+        head = &auth_domain_table[hash_str(name, DN_HASHBITS)];
+
+        spin_lock(&auth_domain_lock);
+
+        hlist_for_each_entry(hp, np, head, hash) {
+                if (strcmp(hp->name, name)==0) {
+                        kref_get(&hp->ref);
+                        spin_unlock(&auth_domain_lock);
+                        return hp;
                 }
-                *hp = tmp->h.next;
-                tmp->h.next = NULL;
-                auth_domain_drop(&tmp->h, &auth_domain_cache);
-                goto out_set;
         }
-        /* Didn't find anything */
-        if (!set)
-                goto out_nada;
-        auth_domain_cache.entries++;
-out_set:
-        item->h.next = *head;
-        *head = &item->h;
-        cache_get(&item->h);
-        write_unlock(&auth_domain_cache.hash_lock);
-        cache_fresh(&auth_domain_cache, &item->h, item->h.expiry_time);
-        cache_get(&item->h);
-        return item;
-out_nada:
-        tmp = NULL;
-out_noset:
-        read_unlock(&auth_domain_cache.hash_lock);
-        return tmp;
+        if (new) {
+                hlist_add_head(&new->hash, head);
+                kref_get(&new->ref);
+        }
+        spin_unlock(&auth_domain_lock);
+        return new;
 }
 
 struct auth_domain *auth_domain_find(char *name)
 {
-        struct auth_domain *rv, ad;
-
-        ad.name = name;
-        rv = auth_domain_lookup(&ad, 0);
-        return rv;
+        return auth_domain_lookup(name, NULL);
 }
diff --git a/net/sunrpc/svcauth_unix.c b/net/sunrpc/svcauth_unix.c
index 3e6c694bbad1..17e8b2a3130c 100644
--- a/net/sunrpc/svcauth_unix.c
+++ b/net/sunrpc/svcauth_unix.c
@@ -27,41 +27,35 @@ struct unix_domain {
         /* other stuff later */
 };
 
+extern struct auth_ops svcauth_unix;
+
 struct auth_domain *unix_domain_find(char *name)
 {
-        struct auth_domain *rv, ud;
-        struct unix_domain *new;
-
-        ud.name = name;
-        
-        rv = auth_domain_lookup(&ud, 0);
-
- foundit:
-        if (rv && rv->flavour != RPC_AUTH_UNIX) {
-                auth_domain_put(rv);
-                return NULL;
-        }
-        if (rv)
-                return rv;
-
-        new = kmalloc(sizeof(*new), GFP_KERNEL);
-        if (new == NULL)
-                return NULL;
-        cache_init(&new->h.h);
-        new->h.name = kstrdup(name, GFP_KERNEL);
-        new->h.flavour = RPC_AUTH_UNIX;
-        new->addr_changes = 0;
-        new->h.h.expiry_time = NEVER;
-
-        rv = auth_domain_lookup(&new->h, 2);
-        if (rv == &new->h) {
-                if (atomic_dec_and_test(&new->h.h.refcnt)) BUG();
-        } else {
-                auth_domain_put(&new->h);
-                goto foundit;
+        struct auth_domain *rv;
+        struct unix_domain *new = NULL;
+
+        rv = auth_domain_lookup(name, NULL);
+        while(1) {
+                if (rv != &new->h) {
+                        if (new) auth_domain_put(&new->h);
+                        return rv;
+                }
+                if (rv && rv->flavour != &svcauth_unix) {
+                        auth_domain_put(rv);
+                        return NULL;
+                }
+                if (rv)
+                        return rv;
+
+                new = kmalloc(sizeof(*new), GFP_KERNEL);
+                if (new == NULL)
+                        return NULL;
+                kref_init(&new->h.ref);
+                new->h.name = kstrdup(name, GFP_KERNEL);
+                new->h.flavour = &svcauth_unix;
+                new->addr_changes = 0;
+                rv = auth_domain_lookup(name, &new->h);
         }
-
-        return rv;
 }
 
 static void svcauth_unix_domain_release(struct auth_domain *dom)
@@ -130,7 +124,7 @@ static inline void ip_map_init(struct ip_map *new, struct ip_map *item)
 }
 static inline void ip_map_update(struct ip_map *new, struct ip_map *item)
 {
-        cache_get(&item->m_client->h.h);
+        kref_get(&item->m_client->h.ref);
         new->m_client = item->m_client;
         new->m_add_change = item->m_add_change;
 }
@@ -272,7 +266,7 @@ int auth_unix_add_addr(struct in_addr addr, struct auth_domain *dom)
         struct unix_domain *udom;
         struct ip_map ip, *ipmp;
 
-        if (dom->flavour != RPC_AUTH_UNIX)
+        if (dom->flavour != &svcauth_unix)
                 return -EINVAL;
         udom = container_of(dom, struct unix_domain, h);
         strcpy(ip.m_class, "nfsd");
@@ -295,7 +289,7 @@ int auth_unix_forget_old(struct auth_domain *dom)
 {
         struct unix_domain *udom;
         
-        if (dom->flavour != RPC_AUTH_UNIX)
+        if (dom->flavour != &svcauth_unix)
                 return -EINVAL;
         udom = container_of(dom, struct unix_domain, h);
         udom->addr_changes++;
@@ -323,7 +317,7 @@ struct auth_domain *auth_unix_lookup(struct in_addr addr)
                 rv = NULL;
         } else {
                 rv = &ipm->m_client->h;
-                cache_get(&rv->h);
+                kref_get(&rv->ref);
         }
         ip_map_put(&ipm->h, &ip_map_cache);
         return rv;
@@ -332,7 +326,6 @@ struct auth_domain *auth_unix_lookup(struct in_addr addr)
 void svcauth_unix_purge(void)
 {
         cache_purge(&ip_map_cache);
-        cache_purge(&auth_domain_cache);
 }
 
 static int
@@ -361,7 +354,7 @@ svcauth_unix_set_client(struct svc_rqst *rqstp)
                         return SVC_DENIED;
                 case 0:
                         rqstp->rq_client = &ipm->m_client->h;
-                        cache_get(&rqstp->rq_client->h);
+                        kref_get(&rqstp->rq_client->ref);
                         ip_map_put(&ipm->h, &ip_map_cache);
                         break;
         }