1 files changed, 135 insertions, 94 deletions

diff --git a/net/sunrpc/svcauth_unix.c b/net/sunrpc/svcauth_unix.c
index 3e6c694bbad1..7e5707e2d6b6 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) {
+                        if (new && rv != &new->h)
+                                auth_domain_put(&new->h);
+
+                        if (rv->flavour != &svcauth_unix) {
+                                auth_domain_put(rv);
+                                return NULL;
+                        }
+                        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)
@@ -90,15 +84,15 @@ struct ip_map {
 };
 static struct cache_head        *ip_table[IP_HASHMAX];
 
-static void ip_map_put(struct cache_head *item, struct cache_detail *cd)
+static void ip_map_put(struct kref *kref)
 {
+        struct cache_head *item = container_of(kref, struct cache_head, ref);
         struct ip_map *im = container_of(item, struct ip_map,h);
-        if (cache_put(item, cd)) {
-                if (test_bit(CACHE_VALID, &item->flags) &&
-                    !test_bit(CACHE_NEGATIVE, &item->flags))
-                        auth_domain_put(&im->m_client->h);
-                kfree(im);
-        }
+
+        if (test_bit(CACHE_VALID, &item->flags) &&
+            !test_bit(CACHE_NEGATIVE, &item->flags))
+                auth_domain_put(&im->m_client->h);
+        kfree(im);
 }
 
 #if IP_HASHBITS == 8
@@ -112,28 +106,38 @@ static inline int hash_ip(unsigned long ip)
         return (hash ^ (hash>>8)) & 0xff;
 }
 #endif
-
-static inline int ip_map_hash(struct ip_map *item)
-{
-        return hash_str(item->m_class, IP_HASHBITS) ^ 
-                hash_ip((unsigned long)item->m_addr.s_addr);
-}
-static inline int ip_map_match(struct ip_map *item, struct ip_map *tmp)
+static int ip_map_match(struct cache_head *corig, struct cache_head *cnew)
 {
-        return strcmp(tmp->m_class, item->m_class) == 0
-                && tmp->m_addr.s_addr == item->m_addr.s_addr;
+        struct ip_map *orig = container_of(corig, struct ip_map, h);
+        struct ip_map *new = container_of(cnew, struct ip_map, h);
+        return strcmp(orig->m_class, new->m_class) == 0
+                && orig->m_addr.s_addr == new->m_addr.s_addr;
 }
-static inline void ip_map_init(struct ip_map *new, struct ip_map *item)
+static void ip_map_init(struct cache_head *cnew, struct cache_head *citem)
 {
+        struct ip_map *new = container_of(cnew, struct ip_map, h);
+        struct ip_map *item = container_of(citem, struct ip_map, h);
+
         strcpy(new->m_class, item->m_class);
         new->m_addr.s_addr = item->m_addr.s_addr;
 }
-static inline void ip_map_update(struct ip_map *new, struct ip_map *item)
+static void update(struct cache_head *cnew, struct cache_head *citem)
 {
-        cache_get(&item->m_client->h.h);
+        struct ip_map *new = container_of(cnew, struct ip_map, h);
+        struct ip_map *item = container_of(citem, struct ip_map, h);
+
+        kref_get(&item->m_client->h.ref);
         new->m_client = item->m_client;
         new->m_add_change = item->m_add_change;
 }
+static struct cache_head *ip_map_alloc(void)
+{
+        struct ip_map *i = kmalloc(sizeof(*i), GFP_KERNEL);
+        if (i)
+                return &i->h;
+        else
+                return NULL;
+}
 
 static void ip_map_request(struct cache_detail *cd,
                                   struct cache_head *h,
@@ -154,7 +158,8 @@ static void ip_map_request(struct cache_detail *cd,
         (*bpp)[-1] = '\n';
 }
 
-static struct ip_map *ip_map_lookup(struct ip_map *, int);
+static struct ip_map *ip_map_lookup(char *class, struct in_addr addr);
+static int ip_map_update(struct ip_map *ipm, struct unix_domain *udom, time_t expiry);
 
 static int ip_map_parse(struct cache_detail *cd,
                           char *mesg, int mlen)
@@ -166,7 +171,11 @@ static int ip_map_parse(struct cache_detail *cd,
         int len;
         int b1,b2,b3,b4;
         char c;
-        struct ip_map ipm, *ipmp;
+        char class[8];
+        struct in_addr addr;
+        int err;
+
+        struct ip_map *ipmp;
         struct auth_domain *dom;
         time_t expiry;
 
@@ -175,7 +184,7 @@ static int ip_map_parse(struct cache_detail *cd,
         mesg[mlen-1] = 0;
 
         /* class */
-        len = qword_get(&mesg, ipm.m_class, sizeof(ipm.m_class));
+        len = qword_get(&mesg, class, sizeof(class));
         if (len <= 0) return -EINVAL;
 
         /* ip address */
@@ -200,25 +209,22 @@ static int ip_map_parse(struct cache_detail *cd,
         } else
                 dom = NULL;
 
-        ipm.m_addr.s_addr =
+        addr.s_addr =
                 htonl((((((b1<<8)|b2)<<8)|b3)<<8)|b4);
-        ipm.h.flags = 0;
-        if (dom) {
-                ipm.m_client = container_of(dom, struct unix_domain, h);
-                ipm.m_add_change = ipm.m_client->addr_changes;
+
+        ipmp = ip_map_lookup(class,addr);
+        if (ipmp) {
+                err = ip_map_update(ipmp,
+                             container_of(dom, struct unix_domain, h),
+                             expiry);
         } else
-                set_bit(CACHE_NEGATIVE, &ipm.h.flags);
-        ipm.h.expiry_time = expiry;
+                err = -ENOMEM;
 
-        ipmp = ip_map_lookup(&ipm, 1);
-        if (ipmp)
-                ip_map_put(&ipmp->h, &ip_map_cache);
         if (dom)
                 auth_domain_put(dom);
-        if (!ipmp)
-                return -ENOMEM;
+
         cache_flush();
-        return 0;
+        return err;
 }
 
 static int ip_map_show(struct seq_file *m,
@@ -262,32 +268,70 @@ struct cache_detail ip_map_cache = {
         .cache_request  = ip_map_request,
         .cache_parse    = ip_map_parse,
         .cache_show     = ip_map_show,
+        .match          = ip_map_match,
+        .init           = ip_map_init,
+        .update         = update,
+        .alloc          = ip_map_alloc,
 };
 
-static DefineSimpleCacheLookup(ip_map, 0)
+static struct ip_map *ip_map_lookup(char *class, struct in_addr addr)
+{
+        struct ip_map ip;
+        struct cache_head *ch;
+
+        strcpy(ip.m_class, class);
+        ip.m_addr = addr;
+        ch = sunrpc_cache_lookup(&ip_map_cache, &ip.h,
+                                 hash_str(class, IP_HASHBITS) ^
+                                 hash_ip((unsigned long)addr.s_addr));
+
+        if (ch)
+                return container_of(ch, struct ip_map, h);
+        else
+                return NULL;
+}
 
+static int ip_map_update(struct ip_map *ipm, struct unix_domain *udom, time_t expiry)
+{
+        struct ip_map ip;
+        struct cache_head *ch;
+
+        ip.m_client = udom;
+        ip.h.flags = 0;
+        if (!udom)
+                set_bit(CACHE_NEGATIVE, &ip.h.flags);
+        else {
+                ip.m_add_change = udom->addr_changes;
+                /* if this is from the legacy set_client system call,
+                 * we need m_add_change to be one higher
+                 */
+                if (expiry == NEVER)
+                        ip.m_add_change++;
+        }
+        ip.h.expiry_time = expiry;
+        ch = sunrpc_cache_update(&ip_map_cache,
+                                 &ip.h, &ipm->h,
+                                 hash_str(ipm->m_class, IP_HASHBITS) ^
+                                 hash_ip((unsigned long)ipm->m_addr.s_addr));
+        if (!ch)
+                return -ENOMEM;
+        cache_put(ch, &ip_map_cache);
+        return 0;
+}
 
 int auth_unix_add_addr(struct in_addr addr, struct auth_domain *dom)
 {
         struct unix_domain *udom;
-        struct ip_map ip, *ipmp;
+        struct ip_map *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");
-        ip.m_addr = addr;
-        ip.m_client = udom;
-        ip.m_add_change = udom->addr_changes+1;
-        ip.h.flags = 0;
-        ip.h.expiry_time = NEVER;
-        
-        ipmp = ip_map_lookup(&ip, 1);
+        ipmp = ip_map_lookup("nfsd", addr);
 
-        if (ipmp) {
-                ip_map_put(&ipmp->h, &ip_map_cache);
-                return 0;
-        } else
+        if (ipmp)
+                return ip_map_update(ipmp, udom, NEVER);
+        else
                 return -ENOMEM;
 }
 
@@ -295,7 +339,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++;
@@ -310,7 +354,7 @@ struct auth_domain *auth_unix_lookup(struct in_addr addr)
         strcpy(key.m_class, "nfsd");
         key.m_addr = addr;
 
-        ipm = ip_map_lookup(&key, 0);
+        ipm = ip_map_lookup("nfsd", addr);
 
         if (!ipm)
                 return NULL;
@@ -323,31 +367,28 @@ 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);
+        cache_put(&ipm->h, &ip_map_cache);
         return rv;
 }
 
 void svcauth_unix_purge(void)
 {
         cache_purge(&ip_map_cache);
-        cache_purge(&auth_domain_cache);
 }
 
 static int
 svcauth_unix_set_client(struct svc_rqst *rqstp)
 {
-        struct ip_map key, *ipm;
+        struct ip_map *ipm;
 
         rqstp->rq_client = NULL;
         if (rqstp->rq_proc == 0)
                 return SVC_OK;
 
-        strcpy(key.m_class, rqstp->rq_server->sv_program->pg_class);
-        key.m_addr = rqstp->rq_addr.sin_addr;
-
-        ipm = ip_map_lookup(&key, 0);
+        ipm = ip_map_lookup(rqstp->rq_server->sv_program->pg_class,
+                            rqstp->rq_addr.sin_addr);
 
         if (ipm == NULL)
                 return SVC_DENIED;
@@ -361,8 +402,8 @@ 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);
-                        ip_map_put(&ipm->h, &ip_map_cache);
+                        kref_get(&rqstp->rq_client->ref);
+                        cache_put(&ipm->h, &ip_map_cache);
                         break;
         }
         return SVC_OK;