URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [fs/] [nfsd/] [nfs4idmap.c] - Blame information for rev 62

Details | Compare with Previous | View Log


/*
 *  fs/nfsd/nfs4idmap.c
 *
 *  Mapping of UID/GIDs to name and vice versa.
 *
 *  Copyright (c) 2002, 2003 The Regents of the University of
 *  Michigan.  All rights reserved.
 *
 *  Marius Aamodt Eriksen <marius@umich.edu>
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *  3. Neither the name of the University nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
 *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
#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/sunrpc/cache.h>
#include <linux/nfsd_idmap.h>
#include <linux/list.h>
#include <linux/time.h>
#include <linux/seq_file.h>
#include <linux/sunrpc/svcauth.h>
 
/*
 * Cache entry
 */
 
/*
 * XXX we know that IDMAP_NAMESZ < PAGE_SIZE, but it's ugly to rely on
 * that.
 */
 
#define IDMAP_TYPE_USER  0
#define IDMAP_TYPE_GROUP 1
 
struct ent {
        struct cache_head h;
        int               type;                /* User / Group */
        uid_t             id;
        char              name[IDMAP_NAMESZ];
        char              authname[IDMAP_NAMESZ];
};
 
/* Common entry handling */
 
#define ENT_HASHBITS          8
#define ENT_HASHMAX           (1 << ENT_HASHBITS)
#define ENT_HASHMASK          (ENT_HASHMAX - 1)
 
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;
 
        strlcpy(new->name, itm->name, sizeof(new->name));
        strlcpy(new->authname, itm->authname, sizeof(new->name));
}
 
static void
ent_put(struct kref *ref)
{
        struct ent *map = container_of(ref, struct ent, h.ref);
        kfree(map);
}
 
static struct cache_head *
ent_alloc(void)
{
        struct ent *e = kmalloc(sizeof(*e), GFP_KERNEL);
        if (e)
                return &e->h;
        else
                return NULL;
}
 
/*
 * ID -> Name cache
 */
 
static struct cache_head *idtoname_table[ENT_HASHMAX];
 
static uint32_t
idtoname_hash(struct ent *ent)
{
        uint32_t hash;
 
        hash = hash_str(ent->authname, ENT_HASHBITS);
        hash = hash_long(hash ^ ent->id, ENT_HASHBITS);
 
        /* Flip LSB for user/group */
        if (ent->type == IDMAP_TYPE_GROUP)
                hash ^= 1;
 
        return hash;
}
 
static void
idtoname_request(struct cache_detail *cd, struct cache_head *ch, char **bpp,
    int *blen)
{
        struct ent *ent = container_of(ch, struct ent, h);
        char idstr[11];
 
        qword_add(bpp, blen, ent->authname);
        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 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);
}
 
static int
idtoname_show(struct seq_file *m, struct cache_detail *cd, struct cache_head *h)
{
        struct ent *ent;
 
        if (h == NULL) {
                seq_puts(m, "#domain type id [name]\n");
                return 0;
        }
        ent = container_of(h, struct ent, h);
        seq_printf(m, "%s %s %u", ent->authname,
                        ent->type == IDMAP_TYPE_GROUP ? "group" : "user",
                        ent->id);
        if (test_bit(CACHE_VALID, &h->flags))
                seq_printf(m, " %s", ent->name);
        seq_printf(m, "\n");
        return 0;
}
 
static void
warn_no_idmapd(struct cache_detail *detail)
{
        printk("nfsd: nfsv4 idmapping failing: has idmapd %s?\n",
                        detail->last_close? "died" : "not been started");
}
 
 
static int         idtoname_parse(struct cache_detail *, char *, 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_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
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')
                return (-EINVAL);
        buf[buflen - 1]= '\0';
 
        buf1 = kmalloc(PAGE_SIZE, GFP_KERNEL);
        if (buf1 == NULL)
                return (-ENOMEM);
 
        memset(&ent, 0, sizeof(ent));
 
        /* Authentication name */
        if (qword_get(&buf, buf1, PAGE_SIZE) <= 0)
                goto out;
        memcpy(ent.authname, buf1, sizeof(ent.authname));
 
        /* Type */
        if (qword_get(&buf, buf1, PAGE_SIZE) <= 0)
                goto out;
        ent.type = strcmp(buf1, "user") == 0 ?
                IDMAP_TYPE_USER : IDMAP_TYPE_GROUP;
 
        /* ID */
        if (qword_get(&buf, buf1, PAGE_SIZE) <= 0)
                goto out;
        ent.id = simple_strtoul(buf1, &bp, 10);
        if (bp == buf1)
                goto out;
 
        /* expiry */
        ent.h.expiry_time = get_expiry(&buf);
        if (ent.h.expiry_time == 0)
                goto out;
 
        error = -ENOMEM;
        res = idtoname_lookup(&ent);
        if (!res)
                goto out;
 
        /* Name */
        error = -EINVAL;
        len = qword_get(&buf, buf1, PAGE_SIZE);
        if (len < 0)
                goto out;
        if (len == 0)
                set_bit(CACHE_NEGATIVE, &ent.h.flags);
        else {
                if (error >= IDMAP_NAMESZ) {
                        error = -EINVAL;
                        goto out;
                }
                memcpy(ent.name, buf1, sizeof(ent.name));
        }
        error = -ENOMEM;
        res = idtoname_update(&ent, res);
        if (res == NULL)
                goto out;
 
        cache_put(&res->h, &idtoname_cache);
 
        error = 0;
out:
        kfree(buf1);
 
        return error;
}
 
 
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
 */
 
static struct cache_head *nametoid_table[ENT_HASHMAX];
 
static inline int
nametoid_hash(struct ent *ent)
{
        return hash_str(ent->name, ENT_HASHBITS);
}
 
static void
nametoid_request(struct cache_detail *cd, struct cache_head *ch, char **bpp,
    int *blen)
{
        struct ent *ent = container_of(ch, struct ent, h);
 
        qword_add(bpp, blen, ent->authname);
        qword_add(bpp, blen, ent->type == IDMAP_TYPE_GROUP ? "group" : "user");
        qword_add(bpp, blen, ent->name);
 
        (*bpp)[-1] = '\n';
}
 
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);
}
 
static int
nametoid_show(struct seq_file *m, struct cache_detail *cd, struct cache_head *h)
{
        struct ent *ent;
 
        if (h == NULL) {
                seq_puts(m, "#domain type name [id]\n");
                return 0;
        }
        ent = container_of(h, struct ent, h);
        seq_printf(m, "%s %s %s", ent->authname,
                        ent->type == IDMAP_TYPE_GROUP ? "group" : "user",
                        ent->name);
        if (test_bit(CACHE_VALID, &h->flags))
                seq_printf(m, " %u", ent->id);
        seq_printf(m, "\n");
        return 0;
}
 
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_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
nametoid_parse(struct cache_detail *cd, char *buf, int buflen)
{
        struct ent ent, *res;
        char *buf1;
        int error = -EINVAL;
 
        if (buf[buflen - 1] != '\n')
                return (-EINVAL);
        buf[buflen - 1]= '\0';
 
        buf1 = kmalloc(PAGE_SIZE, GFP_KERNEL);
        if (buf1 == NULL)
                return (-ENOMEM);
 
        memset(&ent, 0, sizeof(ent));
 
        /* Authentication name */
        if (qword_get(&buf, buf1, PAGE_SIZE) <= 0)
                goto out;
        memcpy(ent.authname, buf1, sizeof(ent.authname));
 
        /* Type */
        if (qword_get(&buf, buf1, PAGE_SIZE) <= 0)
                goto out;
        ent.type = strcmp(buf1, "user") == 0 ?
                IDMAP_TYPE_USER : IDMAP_TYPE_GROUP;
 
        /* Name */
        error = qword_get(&buf, buf1, PAGE_SIZE);
        if (error <= 0 || error >= IDMAP_NAMESZ)
                goto out;
        memcpy(ent.name, buf1, sizeof(ent.name));
 
        /* expiry */
        ent.h.expiry_time = get_expiry(&buf);
        if (ent.h.expiry_time == 0)
                goto out;
 
        /* ID */
        error = get_int(&buf, &ent.id);
        if (error == -EINVAL)
                goto out;
        if (error == -ENOENT)
                set_bit(CACHE_NEGATIVE, &ent.h.flags);
 
        error = -ENOMEM;
        res = nametoid_lookup(&ent);
        if (res == NULL)
                goto out;
        res = nametoid_update(&ent, res);
        if (res == NULL)
                goto out;
 
        cache_put(&res->h, &nametoid_cache);
        error = 0;
out:
        kfree(buf1);
 
        return (error);
}
 
 
static struct ent *
nametoid_lookup(struct ent *item)
{
        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;
}
 
static struct ent *
nametoid_update(struct ent *new, struct ent *old)
{
        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;
}
 
/*
 * Exported API
 */
 
void
nfsd_idmap_init(void)
{
        cache_register(&idtoname_cache);
        cache_register(&nametoid_cache);
}
 
void
nfsd_idmap_shutdown(void)
{
        if (cache_unregister(&idtoname_cache))
                printk(KERN_ERR "nfsd: failed to unregister idtoname cache\n");
        if (cache_unregister(&nametoid_cache))
                printk(KERN_ERR "nfsd: failed to unregister nametoid cache\n");
}
 
/*
 * Deferred request handling
 */
 
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 *), struct ent *key,
                struct cache_detail *detail, struct ent **item,
                struct idmap_defer_req *mdr)
{
        *item = lookup_fn(key);
        if (!*item)
                return -ENOMEM;
        return cache_check(detail, &(*item)->h, &mdr->req);
}
 
static inline int
do_idmap_lookup_nowait(struct ent *(*lookup_fn)(struct ent *),
                        struct ent *key, struct cache_detail *detail,
                        struct ent **item)
{
        int ret = -ENOMEM;
 
        *item = lookup_fn(key);
        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:
        cache_put(&(*item)->h, detail);
out_err:
        *item = NULL;
        return ret;
}
 
static int
idmap_lookup(struct svc_rqst *rqstp,
                struct ent *(*lookup_fn)(struct ent *), struct ent *key,
                struct cache_detail *detail, struct ent **item)
{
        struct idmap_defer_req *mdr;
        int ret;
 
        mdr = kzalloc(sizeof(*mdr), GFP_KERNEL);
        if (!mdr)
                return -ENOMEM;
        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);
        }
        put_mdr(mdr);
        return ret;
}
 
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 int
idmap_name_to_id(struct svc_rqst *rqstp, int type, const char *name, u32 namelen,
                uid_t *id)
{
        struct ent *item, key = {
                .type = type,
        };
        int ret;
 
        if (namelen + 1 > sizeof(key.name))
                return -EINVAL;
        memcpy(key.name, name, namelen);
        key.name[namelen] = '\0';
        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 */
        if (ret)
                return ret;
        *id = item->id;
        cache_put(&item->h, &nametoid_cache);
        return 0;
}
 
static int
idmap_id_to_name(struct svc_rqst *rqstp, int type, uid_t id, char *name)
{
        struct ent *item, key = {
                .id = id,
                .type = type,
        };
        int ret;
 
        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);
        if (ret)
                return ret;
        ret = strlen(item->name);
        BUG_ON(ret > IDMAP_NAMESZ);
        memcpy(name, item->name, ret);
        cache_put(&item->h, &idtoname_cache);
        return ret;
}
 
int
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
nfsd_map_name_to_gid(struct svc_rqst *rqstp, const char *name, size_t namelen,
                __u32 *id)
{
        return idmap_name_to_id(rqstp, IDMAP_TYPE_GROUP, name, namelen, id);
}
 
int
nfsd_map_uid_to_name(struct svc_rqst *rqstp, __u32 id, char *name)
{
        return idmap_id_to_name(rqstp, IDMAP_TYPE_USER, id, name);
}
 
int
nfsd_map_gid_to_name(struct svc_rqst *rqstp, __u32 id, char *name)
{
        return idmap_id_to_name(rqstp, IDMAP_TYPE_GROUP, id, name);
}

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [fs/] [nfsd/] [nfs4idmap.c] - Blame information for rev 62

Line No.	Rev	Author	Line
1	62	marcus.erl	`/*`
2			`* fs/nfsd/nfs4idmap.c`
3			`*`
4			`* Mapping of UID/GIDs to name and vice versa.`
5			`*`
6			`* Copyright (c) 2002, 2003 The Regents of the University of`
7			`* Michigan. All rights reserved.`
8			`*`
9			`* Marius Aamodt Eriksen <marius@umich.edu>`
10			`*`
11			`* Redistribution and use in source and binary forms, with or without`
12			`* modification, are permitted provided that the following conditions`
13			`* are met:`
14			`*`
15			`* 1. Redistributions of source code must retain the above copyright`
16			`* notice, this list of conditions and the following disclaimer.`
17			`* 2. Redistributions in binary form must reproduce the above copyright`
18			`* notice, this list of conditions and the following disclaimer in the`
19			`* documentation and/or other materials provided with the distribution.`
20			`* 3. Neither the name of the University nor the names of its`
21			`* contributors may be used to endorse or promote products derived`
22			`* from this software without specific prior written permission.`
23			`*`
24			* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
25			`* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF`
26			`* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE`
27			`* DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE`
28			`* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR`
29			`* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF`
30			`* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR`
31			`* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF`
32			`* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING`
33			`* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS`
34			`* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.`
35			`*/`
36
37			`#include <linux/module.h>`
38			`#include <linux/init.h>`
39
40			`#include <linux/mm.h>`
41			`#include <linux/utsname.h>`
42			`#include <linux/errno.h>`
43			`#include <linux/string.h>`
44			`#include <linux/sunrpc/clnt.h>`
45			`#include <linux/nfs.h>`
46			`#include <linux/nfs4.h>`
47			`#include <linux/nfs_fs.h>`
48			`#include <linux/nfs_page.h>`
49			`#include <linux/sunrpc/cache.h>`
50			`#include <linux/nfsd_idmap.h>`
51			`#include <linux/list.h>`
52			`#include <linux/time.h>`
53			`#include <linux/seq_file.h>`
54			`#include <linux/sunrpc/svcauth.h>`
55
56			`/*`
57			`* Cache entry`
58			`*/`
59
60			`/*`
61			`* XXX we know that IDMAP_NAMESZ < PAGE_SIZE, but it's ugly to rely on`
62			`* that.`
63			`*/`
64
65			`#define IDMAP_TYPE_USER 0`
66			`#define IDMAP_TYPE_GROUP 1`
67
68			`struct ent {`
69			`struct cache_head h;`
70			`int type; /* User / Group */`
71			`uid_t id;`
72			`char name[IDMAP_NAMESZ];`
73			`char authname[IDMAP_NAMESZ];`
74			`};`
75
76			`/* Common entry handling */`
77
78			`#define ENT_HASHBITS 8`
79			`#define ENT_HASHMAX (1 << ENT_HASHBITS)`
80			`#define ENT_HASHMASK (ENT_HASHMAX - 1)`
81
82			`static void`
83			`ent_init(struct cache_head cnew, struct cache_head citm)`
84			`{`
85			`struct ent *new = container_of(cnew, struct ent, h);`
86			`struct ent *itm = container_of(citm, struct ent, h);`
87
88			`new->id = itm->id;`
89			`new->type = itm->type;`
90
91			`strlcpy(new->name, itm->name, sizeof(new->name));`
92			`strlcpy(new->authname, itm->authname, sizeof(new->name));`
93			`}`
94
95			`static void`
96			`ent_put(struct kref *ref)`
97			`{`
98			`struct ent *map = container_of(ref, struct ent, h.ref);`
99			`kfree(map);`
100			`}`
101
102			`static struct cache_head *`
103			`ent_alloc(void)`
104			`{`
105			`struct ent e = kmalloc(sizeof(e), GFP_KERNEL);`
106			`if (e)`
107			`return &e->h;`
108			`else`
109			`return NULL;`
110			`}`
111
112			`/*`
113			`* ID -> Name cache`
114			`*/`
115
116			`static struct cache_head *idtoname_table[ENT_HASHMAX];`
117
118			`static uint32_t`
119			`idtoname_hash(struct ent *ent)`
120			`{`
121			`uint32_t hash;`
122
123			`hash = hash_str(ent->authname, ENT_HASHBITS);`
124			`hash = hash_long(hash ^ ent->id, ENT_HASHBITS);`
125
126			`/* Flip LSB for user/group */`
127			`if (ent->type == IDMAP_TYPE_GROUP)`
128			`hash ^= 1;`
129
130			`return hash;`
131			`}`
132
133			`static void`
134			`idtoname_request(struct cache_detail cd, struct cache_head ch, char **bpp,`
135			`int *blen)`
136			`{`
137			`struct ent *ent = container_of(ch, struct ent, h);`
138			`char idstr[11];`
139
140			`qword_add(bpp, blen, ent->authname);`
141			`snprintf(idstr, sizeof(idstr), "%u", ent->id);`
142			`qword_add(bpp, blen, ent->type == IDMAP_TYPE_GROUP ? "group" : "user");`
143			`qword_add(bpp, blen, idstr);`
144
145			`(*bpp)[-1] = '\n';`
146			`}`
147
148			`static int`
149			`idtoname_match(struct cache_head ca, struct cache_head cb)`
150			`{`
151			`struct ent *a = container_of(ca, struct ent, h);`
152			`struct ent *b = container_of(cb, struct ent, h);`
153
154			`return (a->id == b->id && a->type == b->type &&`
155			`strcmp(a->authname, b->authname) == 0);`
156			`}`
157
158			`static int`
159			`idtoname_show(struct seq_file m, struct cache_detail cd, struct cache_head *h)`
160			`{`
161			`struct ent *ent;`
162
163			`if (h == NULL) {`
164			`seq_puts(m, "#domain type id [name]\n");`
165			`return 0;`
166			`}`
167			`ent = container_of(h, struct ent, h);`
168			`seq_printf(m, "%s %s %u", ent->authname,`
169			`ent->type == IDMAP_TYPE_GROUP ? "group" : "user",`
170			`ent->id);`
171			`if (test_bit(CACHE_VALID, &h->flags))`
172			`seq_printf(m, " %s", ent->name);`
173			`seq_printf(m, "\n");`
174			`return 0;`
175			`}`
176
177			`static void`
178			`warn_no_idmapd(struct cache_detail *detail)`
179			`{`
180			`printk("nfsd: nfsv4 idmapping failing: has idmapd %s?\n",`
181			`detail->last_close? "died" : "not been started");`
182			`}`
183
184
185			`static int idtoname_parse(struct cache_detail , char , int);`
186			`static struct ent idtoname_lookup(struct ent );`
187			`static struct ent idtoname_update(struct ent , struct ent *);`
188
189			`static struct cache_detail idtoname_cache = {`
190			`.owner = THIS_MODULE,`
191			`.hash_size = ENT_HASHMAX,`
192			`.hash_table = idtoname_table,`
193			`.name = "nfs4.idtoname",`
194			`.cache_put = ent_put,`
195			`.cache_request = idtoname_request,`
196			`.cache_parse = idtoname_parse,`
197			`.cache_show = idtoname_show,`
198			`.warn_no_listener = warn_no_idmapd,`
199			`.match = idtoname_match,`
200			`.init = ent_init,`
201			`.update = ent_init,`
202			`.alloc = ent_alloc,`
203			`};`
204
205			`int`
206			`idtoname_parse(struct cache_detail cd, char buf, int buflen)`
207			`{`
208			`struct ent ent, *res;`
209			`char buf1, bp;`
210			`int len;`
211			`int error = -EINVAL;`
212
213			`if (buf[buflen - 1] != '\n')`
214			`return (-EINVAL);`
215			`buf[buflen - 1]= '\0';`
216
217			`buf1 = kmalloc(PAGE_SIZE, GFP_KERNEL);`
218			`if (buf1 == NULL)`
219			`return (-ENOMEM);`
220
221			`memset(&ent, 0, sizeof(ent));`
222
223			`/* Authentication name */`
224			`if (qword_get(&buf, buf1, PAGE_SIZE) <= 0)`
225			`goto out;`
226			`memcpy(ent.authname, buf1, sizeof(ent.authname));`
227
228			`/* Type */`
229			`if (qword_get(&buf, buf1, PAGE_SIZE) <= 0)`
230			`goto out;`
231			`ent.type = strcmp(buf1, "user") == 0 ?`
232			`IDMAP_TYPE_USER : IDMAP_TYPE_GROUP;`
233
234			`/* ID */`
235			`if (qword_get(&buf, buf1, PAGE_SIZE) <= 0)`
236			`goto out;`
237			`ent.id = simple_strtoul(buf1, &bp, 10);`
238			`if (bp == buf1)`
239			`goto out;`
240
241			`/* expiry */`
242			`ent.h.expiry_time = get_expiry(&buf);`
243			`if (ent.h.expiry_time == 0)`
244			`goto out;`
245
246			`error = -ENOMEM;`
247			`res = idtoname_lookup(&ent);`
248			`if (!res)`
249			`goto out;`
250
251			`/* Name */`
252			`error = -EINVAL;`
253			`len = qword_get(&buf, buf1, PAGE_SIZE);`
254			`if (len < 0)`
255			`goto out;`
256			`if (len == 0)`
257			`set_bit(CACHE_NEGATIVE, &ent.h.flags);`
258			`else {`
259			`if (error >= IDMAP_NAMESZ) {`
260			`error = -EINVAL;`
261			`goto out;`
262			`}`
263			`memcpy(ent.name, buf1, sizeof(ent.name));`
264			`}`
265			`error = -ENOMEM;`
266			`res = idtoname_update(&ent, res);`
267			`if (res == NULL)`
268			`goto out;`
269
270			`cache_put(&res->h, &idtoname_cache);`
271
272			`error = 0;`
273			`out:`
274			`kfree(buf1);`
275
276			`return error;`
277			`}`
278
279
280			`static struct ent *`
281			`idtoname_lookup(struct ent *item)`
282			`{`
283			`struct cache_head *ch = sunrpc_cache_lookup(&idtoname_cache,`
284			`&item->h,`
285			`idtoname_hash(item));`
286			`if (ch)`
287			`return container_of(ch, struct ent, h);`
288			`else`
289			`return NULL;`
290			`}`
291
292			`static struct ent *`
293			`idtoname_update(struct ent new, struct ent old)`
294			`{`
295			`struct cache_head *ch = sunrpc_cache_update(&idtoname_cache,`
296			`&new->h, &old->h,`
297			`idtoname_hash(new));`
298			`if (ch)`
299			`return container_of(ch, struct ent, h);`
300			`else`
301			`return NULL;`
302			`}`
303
304
305			`/*`
306			`* Name -> ID cache`
307			`*/`
308
309			`static struct cache_head *nametoid_table[ENT_HASHMAX];`
310
311			`static inline int`
312			`nametoid_hash(struct ent *ent)`
313			`{`
314			`return hash_str(ent->name, ENT_HASHBITS);`
315			`}`
316
317			`static void`
318			`nametoid_request(struct cache_detail cd, struct cache_head ch, char **bpp,`
319			`int *blen)`
320			`{`
321			`struct ent *ent = container_of(ch, struct ent, h);`
322
323			`qword_add(bpp, blen, ent->authname);`
324			`qword_add(bpp, blen, ent->type == IDMAP_TYPE_GROUP ? "group" : "user");`
325			`qword_add(bpp, blen, ent->name);`
326
327			`(*bpp)[-1] = '\n';`
328			`}`
329
330			`static int`
331			`nametoid_match(struct cache_head ca, struct cache_head cb)`
332			`{`
333			`struct ent *a = container_of(ca, struct ent, h);`
334			`struct ent *b = container_of(cb, struct ent, h);`
335
336			`return (a->type == b->type && strcmp(a->name, b->name) == 0 &&`
337			`strcmp(a->authname, b->authname) == 0);`
338			`}`
339
340			`static int`
341			`nametoid_show(struct seq_file m, struct cache_detail cd, struct cache_head *h)`
342			`{`
343			`struct ent *ent;`
344
345			`if (h == NULL) {`
346			`seq_puts(m, "#domain type name [id]\n");`
347			`return 0;`
348			`}`
349			`ent = container_of(h, struct ent, h);`
350			`seq_printf(m, "%s %s %s", ent->authname,`
351			`ent->type == IDMAP_TYPE_GROUP ? "group" : "user",`
352			`ent->name);`
353			`if (test_bit(CACHE_VALID, &h->flags))`
354			`seq_printf(m, " %u", ent->id);`
355			`seq_printf(m, "\n");`
356			`return 0;`
357			`}`
358
359			`static struct ent nametoid_lookup(struct ent );`
360			`static struct ent nametoid_update(struct ent , struct ent *);`
361			`static int nametoid_parse(struct cache_detail , char , int);`
362
363			`static struct cache_detail nametoid_cache = {`
364			`.owner = THIS_MODULE,`
365			`.hash_size = ENT_HASHMAX,`
366			`.hash_table = nametoid_table,`
367			`.name = "nfs4.nametoid",`
368			`.cache_put = ent_put,`
369			`.cache_request = nametoid_request,`
370			`.cache_parse = nametoid_parse,`
371			`.cache_show = nametoid_show,`
372			`.warn_no_listener = warn_no_idmapd,`
373			`.match = nametoid_match,`
374			`.init = ent_init,`
375			`.update = ent_init,`
376			`.alloc = ent_alloc,`
377			`};`
378
379			`static int`
380			`nametoid_parse(struct cache_detail cd, char buf, int buflen)`
381			`{`
382			`struct ent ent, *res;`
383			`char *buf1;`
384			`int error = -EINVAL;`
385
386			`if (buf[buflen - 1] != '\n')`
387			`return (-EINVAL);`
388			`buf[buflen - 1]= '\0';`
389
390			`buf1 = kmalloc(PAGE_SIZE, GFP_KERNEL);`
391			`if (buf1 == NULL)`
392			`return (-ENOMEM);`
393
394			`memset(&ent, 0, sizeof(ent));`
395
396			`/* Authentication name */`
397			`if (qword_get(&buf, buf1, PAGE_SIZE) <= 0)`
398			`goto out;`
399			`memcpy(ent.authname, buf1, sizeof(ent.authname));`
400
401			`/* Type */`
402			`if (qword_get(&buf, buf1, PAGE_SIZE) <= 0)`
403			`goto out;`
404			`ent.type = strcmp(buf1, "user") == 0 ?`
405			`IDMAP_TYPE_USER : IDMAP_TYPE_GROUP;`
406
407			`/* Name */`
408			`error = qword_get(&buf, buf1, PAGE_SIZE);`
409			`if (error <= 0 \|\| error >= IDMAP_NAMESZ)`
410			`goto out;`
411			`memcpy(ent.name, buf1, sizeof(ent.name));`
412
413			`/* expiry */`
414			`ent.h.expiry_time = get_expiry(&buf);`
415			`if (ent.h.expiry_time == 0)`
416			`goto out;`
417
418			`/* ID */`
419			`error = get_int(&buf, &ent.id);`
420			`if (error == -EINVAL)`
421			`goto out;`
422			`if (error == -ENOENT)`
423			`set_bit(CACHE_NEGATIVE, &ent.h.flags);`
424
425			`error = -ENOMEM;`
426			`res = nametoid_lookup(&ent);`
427			`if (res == NULL)`
428			`goto out;`
429			`res = nametoid_update(&ent, res);`
430			`if (res == NULL)`
431			`goto out;`
432
433			`cache_put(&res->h, &nametoid_cache);`
434			`error = 0;`
435			`out:`
436			`kfree(buf1);`
437
438			`return (error);`
439			`}`
440
441
442			`static struct ent *`
443			`nametoid_lookup(struct ent *item)`
444			`{`
445			`struct cache_head *ch = sunrpc_cache_lookup(&nametoid_cache,`
446			`&item->h,`
447			`nametoid_hash(item));`
448			`if (ch)`
449			`return container_of(ch, struct ent, h);`
450			`else`
451			`return NULL;`
452			`}`
453
454			`static struct ent *`
455			`nametoid_update(struct ent new, struct ent old)`
456			`{`
457			`struct cache_head *ch = sunrpc_cache_update(&nametoid_cache,`
458			`&new->h, &old->h,`
459			`nametoid_hash(new));`
460			`if (ch)`
461			`return container_of(ch, struct ent, h);`
462			`else`
463			`return NULL;`
464			`}`
465
466			`/*`
467			`* Exported API`
468			`*/`
469
470			`void`
471			`nfsd_idmap_init(void)`
472			`{`
473			`cache_register(&idtoname_cache);`
474			`cache_register(&nametoid_cache);`
475			`}`
476
477			`void`
478			`nfsd_idmap_shutdown(void)`
479			`{`
480			`if (cache_unregister(&idtoname_cache))`
481			`printk(KERN_ERR "nfsd: failed to unregister idtoname cache\n");`
482			`if (cache_unregister(&nametoid_cache))`
483			`printk(KERN_ERR "nfsd: failed to unregister nametoid cache\n");`
484			`}`
485
486			`/*`
487			`* Deferred request handling`
488			`*/`
489
490			`struct idmap_defer_req {`
491			`struct cache_req req;`
492			`struct cache_deferred_req deferred_req;`
493			`wait_queue_head_t waitq;`
494			`atomic_t count;`
495			`};`
496
497			`static inline void`
498			`put_mdr(struct idmap_defer_req *mdr)`
499			`{`
500			`if (atomic_dec_and_test(&mdr->count))`
501			`kfree(mdr);`
502			`}`
503
504			`static inline void`
505			`get_mdr(struct idmap_defer_req *mdr)`
506			`{`
507			`atomic_inc(&mdr->count);`
508			`}`
509
510			`static void`
511			`idmap_revisit(struct cache_deferred_req *dreq, int toomany)`
512			`{`
513			`struct idmap_defer_req *mdr =`
514			`container_of(dreq, struct idmap_defer_req, deferred_req);`
515
516			`wake_up(&mdr->waitq);`
517			`put_mdr(mdr);`
518			`}`
519
520			`static struct cache_deferred_req *`
521			`idmap_defer(struct cache_req *req)`
522			`{`
523			`struct idmap_defer_req *mdr =`
524			`container_of(req, struct idmap_defer_req, req);`
525
526			`mdr->deferred_req.revisit = idmap_revisit;`
527			`get_mdr(mdr);`
528			`return (&mdr->deferred_req);`
529			`}`
530
531			`static inline int`
532			`do_idmap_lookup(struct ent (lookup_fn)(struct ent ), struct ent key,`
533			`struct cache_detail detail, struct ent *item,`
534			`struct idmap_defer_req *mdr)`
535			`{`
536			`*item = lookup_fn(key);`
537			`if (!*item)`
538			`return -ENOMEM;`
539			`return cache_check(detail, &(*item)->h, &mdr->req);`
540			`}`
541
542			`static inline int`
543			`do_idmap_lookup_nowait(struct ent (lookup_fn)(struct ent *),`
544			`struct ent key, struct cache_detail detail,`
545			`struct ent **item)`
546			`{`
547			`int ret = -ENOMEM;`
548
549			`*item = lookup_fn(key);`
550			`if (!*item)`
551			`goto out_err;`
552			`ret = -ETIMEDOUT;`
553			`if (!test_bit(CACHE_VALID, &(*item)->h.flags)`
554			`\|\| (*item)->h.expiry_time < get_seconds()`
555			`\|\| detail->flush_time > (*item)->h.last_refresh)`
556			`goto out_put;`
557			`ret = -ENOENT;`
558			`if (test_bit(CACHE_NEGATIVE, &(*item)->h.flags))`
559			`goto out_put;`
560			`return 0;`
561			`out_put:`
562			`cache_put(&(*item)->h, detail);`
563			`out_err:`
564			`*item = NULL;`
565			`return ret;`
566			`}`
567
568			`static int`
569			`idmap_lookup(struct svc_rqst *rqstp,`
570			`struct ent (lookup_fn)(struct ent ), struct ent key,`
571			`struct cache_detail detail, struct ent *item)`
572			`{`
573			`struct idmap_defer_req *mdr;`
574			`int ret;`
575
576			`mdr = kzalloc(sizeof(*mdr), GFP_KERNEL);`
577			`if (!mdr)`
578			`return -ENOMEM;`
579			`atomic_set(&mdr->count, 1);`
580			`init_waitqueue_head(&mdr->waitq);`
581			`mdr->req.defer = idmap_defer;`
582			`ret = do_idmap_lookup(lookup_fn, key, detail, item, mdr);`
583			`if (ret == -EAGAIN) {`
584			`wait_event_interruptible_timeout(mdr->waitq,`
585			`test_bit(CACHE_VALID, &(item)->h.flags), 1 HZ);`
586			`ret = do_idmap_lookup_nowait(lookup_fn, key, detail, item);`
587			`}`
588			`put_mdr(mdr);`
589			`return ret;`
590			`}`
591
592			`static char *`
593			`rqst_authname(struct svc_rqst *rqstp)`
594			`{`
595			`struct auth_domain *clp;`
596
597			`clp = rqstp->rq_gssclient ? rqstp->rq_gssclient : rqstp->rq_client;`
598			`return clp->name;`
599			`}`
600
601			`static int`
602			`idmap_name_to_id(struct svc_rqst rqstp, int type, const char name, u32 namelen,`
603			`uid_t *id)`
604			`{`
605			`struct ent *item, key = {`
606			`.type = type,`
607			`};`
608			`int ret;`
609
610			`if (namelen + 1 > sizeof(key.name))`
611			`return -EINVAL;`
612			`memcpy(key.name, name, namelen);`
613			`key.name[namelen] = '\0';`
614			`strlcpy(key.authname, rqst_authname(rqstp), sizeof(key.authname));`
615			`ret = idmap_lookup(rqstp, nametoid_lookup, &key, &nametoid_cache, &item);`
616			`if (ret == -ENOENT)`
617			`ret = -ESRCH; /* nfserr_badname */`
618			`if (ret)`
619			`return ret;`
620			`*id = item->id;`
621			`cache_put(&item->h, &nametoid_cache);`
622			`return 0;`
623			`}`
624
625			`static int`
626			`idmap_id_to_name(struct svc_rqst rqstp, int type, uid_t id, char name)`
627			`{`
628			`struct ent *item, key = {`
629			`.id = id,`
630			`.type = type,`
631			`};`
632			`int ret;`
633
634			`strlcpy(key.authname, rqst_authname(rqstp), sizeof(key.authname));`
635			`ret = idmap_lookup(rqstp, idtoname_lookup, &key, &idtoname_cache, &item);`
636			`if (ret == -ENOENT)`
637			`return sprintf(name, "%u", id);`
638			`if (ret)`
639			`return ret;`
640			`ret = strlen(item->name);`
641			`BUG_ON(ret > IDMAP_NAMESZ);`
642			`memcpy(name, item->name, ret);`
643			`cache_put(&item->h, &idtoname_cache);`
644			`return ret;`
645			`}`
646
647			`int`
648			`nfsd_map_name_to_uid(struct svc_rqst rqstp, const char name, size_t namelen,`
649			`__u32 *id)`
650			`{`
651			`return idmap_name_to_id(rqstp, IDMAP_TYPE_USER, name, namelen, id);`
652			`}`
653
654			`int`
655			`nfsd_map_name_to_gid(struct svc_rqst rqstp, const char name, size_t namelen,`
656			`__u32 *id)`
657			`{`
658			`return idmap_name_to_id(rqstp, IDMAP_TYPE_GROUP, name, namelen, id);`
659			`}`
660
661			`int`
662			`nfsd_map_uid_to_name(struct svc_rqst rqstp, __u32 id, char name)`
663			`{`
664			`return idmap_id_to_name(rqstp, IDMAP_TYPE_USER, id, name);`
665			`}`
666
667			`int`
668			`nfsd_map_gid_to_name(struct svc_rqst rqstp, __u32 id, char name)`
669			`{`
670			`return idmap_id_to_name(rqstp, IDMAP_TYPE_GROUP, id, name);`
671			`}`