SUNRPC: parametrize rpc_uaddr2sockaddr() by network context
[linux-2.6.git] / fs / nfsd / nfs4idmap.c
index 5605a26..9409627 100644 (file)
@@ -1,6 +1,4 @@
 /*
- *  fs/nfsd/nfs4idmap.c
- *
  *  Mapping of UID/GIDs to name and vice versa.
  *
  *  Copyright (c) 2002, 2003 The Regents of the University of
  *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <linux/config.h>
 #include <linux/module.h>
-#include <linux/init.h>
-
-#include <linux/mm.h>
-#include <linux/utsname.h>
-#include <linux/errno.h>
-#include <linux/string.h>
-#include <linux/sunrpc/clnt.h>
-#include <linux/nfs.h>
-#include <linux/nfs4.h>
-#include <linux/nfs_fs.h>
-#include <linux/nfs_page.h>
-#include <linux/smp_lock.h>
-#include <linux/sunrpc/cache.h>
-#include <linux/nfsd_idmap.h>
-#include <linux/list.h>
-#include <linux/sched.h>
-#include <linux/time.h>
 #include <linux/seq_file.h>
-#include <linux/sunrpc/svcauth.h>
+#include <linux/sched.h>
+#include <linux/slab.h>
+#include <net/net_namespace.h>
+#include "idmap.h"
+#include "nfsd.h"
 
 /*
  * Cache entry
@@ -76,21 +60,17 @@ struct ent {
        char              authname[IDMAP_NAMESZ];
 };
 
-#define DefineSimpleCacheLookupMap(STRUCT, FUNC)                       \
-        DefineCacheLookup(struct STRUCT, h, FUNC##_lookup,             \
-        (struct STRUCT *item, int set), /*no setup */,                 \
-       & FUNC##_cache, FUNC##_hash(item), FUNC##_match(item, tmp),     \
-       STRUCT##_init(new, item), STRUCT##_update(tmp, item), 0)
-
 /* Common entry handling */
 
 #define ENT_HASHBITS          8
 #define ENT_HASHMAX           (1 << ENT_HASHBITS)
-#define ENT_HASHMASK          (ENT_HASHMAX - 1)
 
-static inline void
-ent_init(struct ent *new, struct ent *itm)
+static void
+ent_init(struct cache_head *cnew, struct cache_head *citm)
 {
+       struct ent *new = container_of(cnew, struct ent, h);
+       struct ent *itm = container_of(citm, struct ent, h);
+
        new->id = itm->id;
        new->type = itm->type;
 
@@ -98,19 +78,21 @@ ent_init(struct ent *new, struct ent *itm)
        strlcpy(new->authname, itm->authname, sizeof(new->name));
 }
 
-static inline void
-ent_update(struct ent *new, struct ent *itm)
+static void
+ent_put(struct kref *ref)
 {
-       ent_init(new, itm);
+       struct ent *map = container_of(ref, struct ent, h.ref);
+       kfree(map);
 }
 
-static void
-ent_put(struct cache_head *ch, struct cache_detail *cd)
+static struct cache_head *
+ent_alloc(void)
 {
-       if (cache_put(ch, cd)) {
-               struct ent *map = container_of(ch, struct ent, h);
-               kfree(map);
-       }
+       struct ent *e = kmalloc(sizeof(*e), GFP_KERNEL);
+       if (e)
+               return &e->h;
+       else
+               return NULL;
 }
 
 /*
@@ -142,16 +124,25 @@ idtoname_request(struct cache_detail *cd, struct cache_head *ch, char **bpp,
        char idstr[11];
 
        qword_add(bpp, blen, ent->authname);
-       snprintf(idstr, sizeof(idstr), "%d", ent->id);
+       snprintf(idstr, sizeof(idstr), "%u", ent->id);
        qword_add(bpp, blen, ent->type == IDMAP_TYPE_GROUP ? "group" : "user");
        qword_add(bpp, blen, idstr);
 
        (*bpp)[-1] = '\n';
 }
 
-static inline int
-idtoname_match(struct ent *a, struct ent *b)
+static int
+idtoname_upcall(struct cache_detail *cd, struct cache_head *ch)
 {
+       return sunrpc_cache_pipe_upcall(cd, ch, idtoname_request);
+}
+
+static int
+idtoname_match(struct cache_head *ca, struct cache_head *cb)
+{
+       struct ent *a = container_of(ca, struct ent, h);
+       struct ent *b = container_of(cb, struct ent, h);
+
        return (a->id == b->id && a->type == b->type &&
            strcmp(a->authname, b->authname) == 0);
 }
@@ -166,7 +157,7 @@ idtoname_show(struct seq_file *m, struct cache_detail *cd, struct cache_head *h)
                return 0;
        }
        ent = container_of(h, struct ent, h);
-       seq_printf(m, "%s %s %d", ent->authname,
+       seq_printf(m, "%s %s %u", ent->authname,
                        ent->type == IDMAP_TYPE_GROUP ? "group" : "user",
                        ent->id);
        if (test_bit(CACHE_VALID, &h->flags))
@@ -176,32 +167,39 @@ idtoname_show(struct seq_file *m, struct cache_detail *cd, struct cache_head *h)
 }
 
 static void
-warn_no_idmapd(struct cache_detail *detail)
+warn_no_idmapd(struct cache_detail *detail, int has_died)
 {
        printk("nfsd: nfsv4 idmapping failing: has idmapd %s?\n",
-                       detail->last_close? "died" : "not been started");
+                       has_died ? "died" : "not been started");
 }
 
 
 static int         idtoname_parse(struct cache_detail *, char *, int);
-static struct ent *idtoname_lookup(struct ent *, int);
+static struct ent *idtoname_lookup(struct ent *);
+static struct ent *idtoname_update(struct ent *, struct ent *);
 
 static struct cache_detail idtoname_cache = {
+       .owner          = THIS_MODULE,
        .hash_size      = ENT_HASHMAX,
        .hash_table     = idtoname_table,
        .name           = "nfs4.idtoname",
        .cache_put      = ent_put,
-       .cache_request  = idtoname_request,
+       .cache_upcall   = idtoname_upcall,
        .cache_parse    = idtoname_parse,
        .cache_show     = idtoname_show,
        .warn_no_listener = warn_no_idmapd,
+       .match          = idtoname_match,
+       .init           = ent_init,
+       .update         = ent_init,
+       .alloc          = ent_alloc,
 };
 
-int
+static int
 idtoname_parse(struct cache_detail *cd, char *buf, int buflen)
 {
        struct ent ent, *res;
        char *buf1, *bp;
+       int len;
        int error = -EINVAL;
 
        if (buf[buflen - 1] != '\n')
@@ -237,24 +235,28 @@ idtoname_parse(struct cache_detail *cd, char *buf, int buflen)
        if (ent.h.expiry_time == 0)
                goto out;
 
+       error = -ENOMEM;
+       res = idtoname_lookup(&ent);
+       if (!res)
+               goto out;
+
        /* Name */
-       error = qword_get(&buf, buf1, PAGE_SIZE);
-       if (error == -EINVAL)
+       error = -EINVAL;
+       len = qword_get(&buf, buf1, PAGE_SIZE);
+       if (len < 0)
                goto out;
-       if (error == -ENOENT)
+       if (len == 0)
                set_bit(CACHE_NEGATIVE, &ent.h.flags);
-       else {
-               if (error >= IDMAP_NAMESZ) {
-                       error = -EINVAL;
-                       goto out;
-               }
+       else if (len >= IDMAP_NAMESZ)
+               goto out;
+       else
                memcpy(ent.name, buf1, sizeof(ent.name));
-       }
        error = -ENOMEM;
-       if ((res = idtoname_lookup(&ent, 1)) == NULL)
+       res = idtoname_update(&ent, res);
+       if (res == NULL)
                goto out;
 
-       ent_put(&res->h, &idtoname_cache);
+       cache_put(&res->h, &idtoname_cache);
 
        error = 0;
 out:
@@ -263,7 +265,31 @@ out:
        return error;
 }
 
-static DefineSimpleCacheLookupMap(ent, idtoname);
+
+static struct ent *
+idtoname_lookup(struct ent *item)
+{
+       struct cache_head *ch = sunrpc_cache_lookup(&idtoname_cache,
+                                                   &item->h,
+                                                   idtoname_hash(item));
+       if (ch)
+               return container_of(ch, struct ent, h);
+       else
+               return NULL;
+}
+
+static struct ent *
+idtoname_update(struct ent *new, struct ent *old)
+{
+       struct cache_head *ch = sunrpc_cache_update(&idtoname_cache,
+                                                   &new->h, &old->h,
+                                                   idtoname_hash(new));
+       if (ch)
+               return container_of(ch, struct ent, h);
+       else
+               return NULL;
+}
+
 
 /*
  * Name -> ID cache
@@ -290,9 +316,18 @@ nametoid_request(struct cache_detail *cd, struct cache_head *ch, char **bpp,
        (*bpp)[-1] = '\n';
 }
 
-static inline int
-nametoid_match(struct ent *a, struct ent *b)
+static int
+nametoid_upcall(struct cache_detail *cd, struct cache_head *ch)
+{
+       return sunrpc_cache_pipe_upcall(cd, ch, nametoid_request);
+}
+
+static int
+nametoid_match(struct cache_head *ca, struct cache_head *cb)
 {
+       struct ent *a = container_of(ca, struct ent, h);
+       struct ent *b = container_of(cb, struct ent, h);
+
        return (a->type == b->type && strcmp(a->name, b->name) == 0 &&
            strcmp(a->authname, b->authname) == 0);
 }
@@ -311,23 +346,29 @@ nametoid_show(struct seq_file *m, struct cache_detail *cd, struct cache_head *h)
                        ent->type == IDMAP_TYPE_GROUP ? "group" : "user",
                        ent->name);
        if (test_bit(CACHE_VALID, &h->flags))
-               seq_printf(m, " %d", ent->id);
+               seq_printf(m, " %u", ent->id);
        seq_printf(m, "\n");
        return 0;
 }
 
-static struct ent *nametoid_lookup(struct ent *, int);
+static struct ent *nametoid_lookup(struct ent *);
+static struct ent *nametoid_update(struct ent *, struct ent *);
 static int         nametoid_parse(struct cache_detail *, char *, int);
 
 static struct cache_detail nametoid_cache = {
+       .owner          = THIS_MODULE,
        .hash_size      = ENT_HASHMAX,
        .hash_table     = nametoid_table,
        .name           = "nfs4.nametoid",
        .cache_put      = ent_put,
-       .cache_request  = nametoid_request,
+       .cache_upcall   = nametoid_upcall,
        .cache_parse    = nametoid_parse,
        .cache_show     = nametoid_show,
        .warn_no_listener = warn_no_idmapd,
+       .match          = nametoid_match,
+       .init           = ent_init,
+       .update         = ent_init,
+       .alloc          = ent_alloc,
 };
 
 static int
@@ -377,10 +418,14 @@ nametoid_parse(struct cache_detail *cd, char *buf, int buflen)
                set_bit(CACHE_NEGATIVE, &ent.h.flags);
 
        error = -ENOMEM;
-       if ((res = nametoid_lookup(&ent, 1)) == NULL)
+       res = nametoid_lookup(&ent);
+       if (res == NULL)
+               goto out;
+       res = nametoid_update(&ent, res);
+       if (res == NULL)
                goto out;
 
-       ent_put(&res->h, &nametoid_cache);
+       cache_put(&res->h, &nametoid_cache);
        error = 0;
 out:
        kfree(buf1);
@@ -388,134 +433,89 @@ out:
        return (error);
 }
 
-static DefineSimpleCacheLookupMap(ent, nametoid);
-
-/*
- * Exported API
- */
 
-void
-nfsd_idmap_init(void)
+static struct ent *
+nametoid_lookup(struct ent *item)
 {
-       cache_register(&idtoname_cache);
-       cache_register(&nametoid_cache);
+       struct cache_head *ch = sunrpc_cache_lookup(&nametoid_cache,
+                                                   &item->h,
+                                                   nametoid_hash(item));
+       if (ch)
+               return container_of(ch, struct ent, h);
+       else
+               return NULL;
 }
 
-void
-nfsd_idmap_shutdown(void)
+static struct ent *
+nametoid_update(struct ent *new, struct ent *old)
 {
-       cache_unregister(&idtoname_cache);
-       cache_unregister(&nametoid_cache);
+       struct cache_head *ch = sunrpc_cache_update(&nametoid_cache,
+                                                   &new->h, &old->h,
+                                                   nametoid_hash(new));
+       if (ch)
+               return container_of(ch, struct ent, h);
+       else
+               return NULL;
 }
 
 /*
- * Deferred request handling
+ * Exported API
  */
 
-struct idmap_defer_req {
-       struct cache_req                req;
-       struct cache_deferred_req deferred_req;
-       wait_queue_head_t       waitq;
-       atomic_t                        count;
-};
-
-static inline void
-put_mdr(struct idmap_defer_req *mdr)
-{
-       if (atomic_dec_and_test(&mdr->count))
-               kfree(mdr);
-}
-
-static inline void
-get_mdr(struct idmap_defer_req *mdr)
-{
-       atomic_inc(&mdr->count);
-}
-
-static void
-idmap_revisit(struct cache_deferred_req *dreq, int toomany)
-{
-       struct idmap_defer_req *mdr =
-               container_of(dreq, struct idmap_defer_req, deferred_req);
-
-       wake_up(&mdr->waitq);
-       put_mdr(mdr);
-}
-
-static struct cache_deferred_req *
-idmap_defer(struct cache_req *req)
-{
-       struct idmap_defer_req *mdr =
-               container_of(req, struct idmap_defer_req, req);
-
-       mdr->deferred_req.revisit = idmap_revisit;
-       get_mdr(mdr);
-       return (&mdr->deferred_req);
-}
-
-static inline int
-do_idmap_lookup(struct ent *(*lookup_fn)(struct ent *, int), struct ent *key,
-               struct cache_detail *detail, struct ent **item,
-               struct idmap_defer_req *mdr)
+int
+nfsd_idmap_init(void)
 {
-       *item = lookup_fn(key, 0);
-       if (!*item)
-               return -ENOMEM;
-       return cache_check(detail, &(*item)->h, &mdr->req);
+       int rv;
+
+       rv = cache_register_net(&idtoname_cache, &init_net);
+       if (rv)
+               return rv;
+       rv = cache_register_net(&nametoid_cache, &init_net);
+       if (rv)
+               cache_unregister_net(&idtoname_cache, &init_net);
+       return rv;
 }
 
-static inline int
-do_idmap_lookup_nowait(struct ent *(*lookup_fn)(struct ent *, int),
-                       struct ent *key, struct cache_detail *detail,
-                       struct ent **item)
+void
+nfsd_idmap_shutdown(void)
 {
-       int ret = -ENOMEM;
-
-       *item = lookup_fn(key, 0);
-       if (!*item)
-               goto out_err;
-       ret = -ETIMEDOUT;
-       if (!test_bit(CACHE_VALID, &(*item)->h.flags)
-                       || (*item)->h.expiry_time < get_seconds()
-                       || detail->flush_time > (*item)->h.last_refresh)
-               goto out_put;
-       ret = -ENOENT;
-       if (test_bit(CACHE_NEGATIVE, &(*item)->h.flags))
-               goto out_put;
-       return 0;
-out_put:
-       ent_put(&(*item)->h, detail);
-out_err:
-       *item = NULL;
-       return ret;
+       cache_unregister_net(&idtoname_cache, &init_net);
+       cache_unregister_net(&nametoid_cache, &init_net);
 }
 
 static int
 idmap_lookup(struct svc_rqst *rqstp,
-               struct ent *(*lookup_fn)(struct ent *, int), struct ent *key,
+               struct ent *(*lookup_fn)(struct ent *), struct ent *key,
                struct cache_detail *detail, struct ent **item)
 {
-       struct idmap_defer_req *mdr;
        int ret;
 
-       mdr = kmalloc(sizeof(*mdr), GFP_KERNEL);
-       if (!mdr)
+       *item = lookup_fn(key);
+       if (!*item)
                return -ENOMEM;
-       memset(mdr, 0, sizeof(*mdr));
-       atomic_set(&mdr->count, 1);
-       init_waitqueue_head(&mdr->waitq);
-       mdr->req.defer = idmap_defer;
-       ret = do_idmap_lookup(lookup_fn, key, detail, item, mdr);
-       if (ret == -EAGAIN) {
-               wait_event_interruptible_timeout(mdr->waitq,
-                       test_bit(CACHE_VALID, &(*item)->h.flags), 1 * HZ);
-               ret = do_idmap_lookup_nowait(lookup_fn, key, detail, item);
+ retry:
+       ret = cache_check(detail, &(*item)->h, &rqstp->rq_chandle);
+
+       if (ret == -ETIMEDOUT) {
+               struct ent *prev_item = *item;
+               *item = lookup_fn(key);
+               if (*item != prev_item)
+                       goto retry;
+               cache_put(&(*item)->h, detail);
        }
-       put_mdr(mdr);
        return ret;
 }
 
-static int
+static char *
+rqst_authname(struct svc_rqst *rqstp)
+{
+       struct auth_domain *clp;
+
+       clp = rqstp->rq_gssclient ? rqstp->rq_gssclient : rqstp->rq_client;
+       return clp->name;
+}
+
+static __be32
 idmap_name_to_id(struct svc_rqst *rqstp, int type, const char *name, u32 namelen,
                uid_t *id)
 {
@@ -525,17 +525,17 @@ idmap_name_to_id(struct svc_rqst *rqstp, int type, const char *name, u32 namelen
        int ret;
 
        if (namelen + 1 > sizeof(key.name))
-               return -EINVAL;
+               return nfserr_badowner;
        memcpy(key.name, name, namelen);
        key.name[namelen] = '\0';
-       strlcpy(key.authname, rqstp->rq_client->name, sizeof(key.authname));
+       strlcpy(key.authname, rqst_authname(rqstp), sizeof(key.authname));
        ret = idmap_lookup(rqstp, nametoid_lookup, &key, &nametoid_cache, &item);
        if (ret == -ENOENT)
-               ret = -ESRCH; /* nfserr_badname */
+               return nfserr_badowner;
        if (ret)
-               return ret;
+               return nfserrno(ret);
        *id = item->id;
-       ent_put(&item->h, &nametoid_cache);
+       cache_put(&item->h, &nametoid_cache);
        return 0;
 }
 
@@ -548,7 +548,7 @@ idmap_id_to_name(struct svc_rqst *rqstp, int type, uid_t id, char *name)
        };
        int ret;
 
-       strlcpy(key.authname, rqstp->rq_client->name, sizeof(key.authname));
+       strlcpy(key.authname, rqst_authname(rqstp), sizeof(key.authname));
        ret = idmap_lookup(rqstp, idtoname_lookup, &key, &idtoname_cache, &item);
        if (ret == -ENOENT)
                return sprintf(name, "%u", id);
@@ -557,18 +557,18 @@ idmap_id_to_name(struct svc_rqst *rqstp, int type, uid_t id, char *name)
        ret = strlen(item->name);
        BUG_ON(ret > IDMAP_NAMESZ);
        memcpy(name, item->name, ret);
-       ent_put(&item->h, &idtoname_cache);
+       cache_put(&item->h, &idtoname_cache);
        return ret;
 }
 
-int
+__be32
 nfsd_map_name_to_uid(struct svc_rqst *rqstp, const char *name, size_t namelen,
                __u32 *id)
 {
        return idmap_name_to_id(rqstp, IDMAP_TYPE_USER, name, namelen, id);
 }
 
-int
+__be32
 nfsd_map_name_to_gid(struct svc_rqst *rqstp, const char *name, size_t namelen,
                __u32 *id)
 {