d_path: Make d_path() use a struct path
[linux-2.6.git] / fs / nfsd / export.c
index 49c310b..8a6f7c9 100644 (file)
@@ -16,7 +16,6 @@
 
 #include <linux/unistd.h>
 #include <linux/slab.h>
-#include <linux/sched.h>
 #include <linux/stat.h>
 #include <linux/in.h>
 #include <linux/seq_file.h>
 #include <linux/mount.h>
 #include <linux/hash.h>
 #include <linux/module.h>
+#include <linux/exportfs.h>
 
 #include <linux/sunrpc/svc.h>
 #include <linux/nfsd/nfsd.h>
 #include <linux/nfsd/nfsfh.h>
 #include <linux/nfsd/syscall.h>
 #include <linux/lockd/bind.h>
+#include <linux/sunrpc/msg_prot.h>
+#include <linux/sunrpc/gss_api.h>
 
 #define NFSDDBG_FACILITY       NFSDDBG_EXPORT
 
@@ -61,10 +63,8 @@ static void expkey_put(struct kref *ref)
        struct svc_expkey *key = container_of(ref, struct svc_expkey, h.ref);
 
        if (test_bit(CACHE_VALID, &key->h.flags) &&
-           !test_bit(CACHE_NEGATIVE, &key->h.flags)) {
-               dput(key->ek_dentry);
-               mntput(key->ek_mnt);
-       }
+           !test_bit(CACHE_NEGATIVE, &key->h.flags))
+               path_put(&key->ek_path);
        auth_domain_put(key->ek_client);
        kfree(key);
 }
@@ -167,15 +167,14 @@ static int expkey_parse(struct cache_detail *cd, char *mesg, int mlen)
                        goto out;
 
                dprintk("Found the path %s\n", buf);
-               key.ek_mnt = nd.mnt;
-               key.ek_dentry = nd.dentry;
-               
+               key.ek_path = nd.path;
+
                ek = svc_expkey_update(&key, ek);
                if (ek)
                        cache_put(&ek->h, &svc_expkey_cache);
                else
                        err = -ENOMEM;
-               path_release(&nd);
+               path_put(&nd.path);
        }
        cache_flush();
  out:
@@ -190,22 +189,21 @@ static int expkey_show(struct seq_file *m,
                       struct cache_head *h)
 {
        struct svc_expkey *ek ;
+       int i;
 
        if (h ==NULL) {
                seq_puts(m, "#domain fsidtype fsid [path]\n");
                return 0;
        }
        ek = container_of(h, struct svc_expkey, h);
-       seq_printf(m, "%s %d 0x%08x", ek->ek_client->name,
-                  ek->ek_fsidtype, ek->ek_fsid[0]);
-       if (ek->ek_fsidtype != 1)
-               seq_printf(m, "%08x", ek->ek_fsid[1]);
-       if (ek->ek_fsidtype == 2)
-               seq_printf(m, "%08x", ek->ek_fsid[2]);
+       seq_printf(m, "%s %d 0x", ek->ek_client->name,
+                  ek->ek_fsidtype);
+       for (i=0; i < key_len(ek->ek_fsidtype)/4; i++)
+               seq_printf(m, "%08x", ek->ek_fsid[i]);
        if (test_bit(CACHE_VALID, &h->flags) && 
            !test_bit(CACHE_NEGATIVE, &h->flags)) {
                seq_printf(m, " ");
-               seq_path(m, ek->ek_mnt, ek->ek_dentry, "\\ \t\n");
+               seq_path(m, &ek->ek_path, "\\ \t\n");
        }
        seq_printf(m, "\n");
        return 0;
@@ -232,9 +230,8 @@ static inline void expkey_init(struct cache_head *cnew,
        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];
-       new->ek_fsid[1] = item->ek_fsid[1];
-       new->ek_fsid[2] = item->ek_fsid[2];
+
+       memcpy(new->ek_fsid, item->ek_fsid, sizeof(new->ek_fsid));
 }
 
 static inline void expkey_update(struct cache_head *cnew,
@@ -243,8 +240,8 @@ static inline void expkey_update(struct cache_head *cnew,
        struct svc_expkey *new = container_of(cnew, struct svc_expkey, h);
        struct svc_expkey *item = container_of(citem, struct svc_expkey, h);
 
-       new->ek_mnt = mntget(item->ek_mnt);
-       new->ek_dentry = dget(item->ek_dentry);
+       new->ek_path = item->ek_path;
+       path_get(&item->ek_path);
 }
 
 static struct cache_head *expkey_alloc(void)
@@ -332,10 +329,9 @@ static void nfsd4_fslocs_free(struct nfsd4_fs_locations *fsloc)
 static void svc_export_put(struct kref *ref)
 {
        struct svc_export *exp = container_of(ref, struct svc_export, h.ref);
-       dput(exp->ex_dentry);
-       mntput(exp->ex_mnt);
+       path_put(&exp->ex_path);
        auth_domain_put(exp->ex_client);
-       kfree(exp->ex_path);
+       kfree(exp->ex_pathname);
        nfsd4_fslocs_free(&exp->ex_fslocs);
        kfree(exp);
 }
@@ -349,7 +345,7 @@ static void svc_export_request(struct cache_detail *cd,
        char *pth;
 
        qword_add(bpp, blen, exp->ex_client->name);
-       pth = d_path(exp->ex_dentry, exp->ex_mnt, *bpp, *blen);
+       pth = d_path(&exp->ex_path, *bpp, *blen);
        if (IS_ERR(pth)) {
                /* is this correct? */
                (*bpp)[0] = '\n';
@@ -363,7 +359,7 @@ static struct svc_export *svc_export_update(struct svc_export *new,
                                            struct svc_export *old);
 static struct svc_export *svc_export_lookup(struct svc_export *);
 
-static int check_export(struct inode *inode, int flags)
+static int check_export(struct inode *inode, int flags, unsigned char *uuid)
 {
 
        /* We currently export only dirs and regular files.
@@ -376,24 +372,23 @@ static int check_export(struct inode *inode, int flags)
        /* There are two requirements on a filesystem to be exportable.
         * 1:  We must be able to identify the filesystem from a number.
         *       either a device number (so FS_REQUIRES_DEV needed)
-        *       or an FSID number (so NFSEXP_FSID needed).
+        *       or an FSID number (so NFSEXP_FSID or ->uuid is needed).
         * 2:  We must be able to find an inode from a filehandle.
         *       This means that s_export_op must be set.
         */
        if (!(inode->i_sb->s_type->fs_flags & FS_REQUIRES_DEV) &&
-           !(flags & NFSEXP_FSID)) {
+           !(flags & NFSEXP_FSID) &&
+           uuid == NULL) {
                dprintk("exp_export: export of non-dev fs without fsid\n");
                return -EINVAL;
        }
-       if (!inode->i_sb->s_export_op) {
+
+       if (!inode->i_sb->s_export_op ||
+           !inode->i_sb->s_export_op->fh_to_dentry) {
                dprintk("exp_export: export of invalid fs type.\n");
                return -EINVAL;
        }
 
-       /* Ok, we can export it */;
-       if (!inode->i_sb->s_export_op->find_exported_dentry)
-               inode->i_sb->s_export_op->find_exported_dentry =
-                       find_exported_dentry;
        return 0;
 
 }
@@ -406,10 +401,6 @@ fsloc_parse(char **mesg, char *buf, struct nfsd4_fs_locations *fsloc)
        int len;
        int migrated, i, err;
 
-       len = qword_get(mesg, buf, PAGE_SIZE);
-       if (len != 5 || memcmp(buf, "fsloc", 5))
-               return 0;
-
        /* listsize */
        err = get_int(mesg, &fsloc->locations_count);
        if (err)
@@ -457,8 +448,48 @@ out_free_all:
        return err;
 }
 
+static int secinfo_parse(char **mesg, char *buf, struct svc_export *exp)
+{
+       int listsize, err;
+       struct exp_flavor_info *f;
+
+       err = get_int(mesg, &listsize);
+       if (err)
+               return err;
+       if (listsize < 0 || listsize > MAX_SECINFO_LIST)
+               return -EINVAL;
+
+       for (f = exp->ex_flavors; f < exp->ex_flavors + listsize; f++) {
+               err = get_int(mesg, &f->pseudoflavor);
+               if (err)
+                       return err;
+               /*
+                * Just a quick sanity check; we could also try to check
+                * whether this pseudoflavor is supported, but at worst
+                * an unsupported pseudoflavor on the export would just
+                * be a pseudoflavor that won't match the flavor of any
+                * authenticated request.  The administrator will
+                * probably discover the problem when someone fails to
+                * authenticate.
+                */
+               if (f->pseudoflavor < 0)
+                       return -EINVAL;
+               err = get_int(mesg, &f->flags);
+               if (err)
+                       return err;
+               /* Only some flags are allowed to differ between flavors: */
+               if (~NFSEXP_SECINFO_FLAGS & (f->flags ^ exp->ex_flags))
+                       return -EINVAL;
+       }
+       exp->ex_nflavors = listsize;
+       return 0;
+}
+
 #else /* CONFIG_NFSD_V4 */
-static inline int fsloc_parse(char **mesg, char *buf, struct nfsd4_fs_locations *fsloc) { return 0; }
+static inline int
+fsloc_parse(char **mesg, char *buf, struct nfsd4_fs_locations *fsloc){return 0;}
+static inline int
+secinfo_parse(char **mesg, char *buf, struct svc_export *exp) { return 0; }
 #endif
 
 static int svc_export_parse(struct cache_detail *cd, char *mesg, int mlen)
@@ -472,8 +503,18 @@ static int svc_export_parse(struct cache_detail *cd, char *mesg, int mlen)
        struct svc_export exp, *expp;
        int an_int;
 
-       nd.dentry = NULL;
-       exp.ex_path = NULL;
+       nd.path.dentry = NULL;
+       exp.ex_pathname = NULL;
+
+       /* fs locations */
+       exp.ex_fslocs.locations = NULL;
+       exp.ex_fslocs.locations_count = 0;
+       exp.ex_fslocs.migrated = 0;
+
+       exp.ex_uuid = NULL;
+
+       /* secinfo */
+       exp.ex_nflavors = 0;
 
        if (mesg[mlen-1] != '\n')
                return -EINVAL;
@@ -502,11 +543,11 @@ static int svc_export_parse(struct cache_detail *cd, char *mesg, int mlen)
 
        exp.h.flags = 0;
        exp.ex_client = dom;
-       exp.ex_mnt = nd.mnt;
-       exp.ex_dentry = nd.dentry;
-       exp.ex_path = kstrdup(buf, GFP_KERNEL);
+       exp.ex_path.mnt = nd.path.mnt;
+       exp.ex_path.dentry = nd.path.dentry;
+       exp.ex_pathname = kstrdup(buf, GFP_KERNEL);
        err = -ENOMEM;
-       if (!exp.ex_path)
+       if (!exp.ex_pathname)
                goto out;
 
        /* expiry */
@@ -515,16 +556,12 @@ static int svc_export_parse(struct cache_detail *cd, char *mesg, int mlen)
        if (exp.h.expiry_time == 0)
                goto out;
 
-       /* fs locations */
-       exp.ex_fslocs.locations = NULL;
-       exp.ex_fslocs.locations_count = 0;
-       exp.ex_fslocs.migrated = 0;
-
        /* flags */
        err = get_int(&mesg, &an_int);
-       if (err == -ENOENT)
+       if (err == -ENOENT) {
+               err = 0;
                set_bit(CACHE_NEGATIVE, &exp.h.flags);
-       else {
+       } else {
                if (err || an_int < 0) goto out;        
                exp.ex_flags= an_int;
        
@@ -543,12 +580,35 @@ static int svc_export_parse(struct cache_detail *cd, char *mesg, int mlen)
                if (err) goto out;
                exp.ex_fsid = an_int;
 
-               err = check_export(nd.dentry->d_inode, exp.ex_flags);
-               if (err) goto out;
+               while ((len = qword_get(&mesg, buf, PAGE_SIZE)) > 0) {
+                       if (strcmp(buf, "fsloc") == 0)
+                               err = fsloc_parse(&mesg, buf, &exp.ex_fslocs);
+                       else if (strcmp(buf, "uuid") == 0) {
+                               /* expect a 16 byte uuid encoded as \xXXXX... */
+                               len = qword_get(&mesg, buf, PAGE_SIZE);
+                               if (len != 16)
+                                       err  = -EINVAL;
+                               else {
+                                       exp.ex_uuid =
+                                               kmemdup(buf, 16, GFP_KERNEL);
+                                       if (exp.ex_uuid == NULL)
+                                               err = -ENOMEM;
+                               }
+                       } else if (strcmp(buf, "secinfo") == 0)
+                               err = secinfo_parse(&mesg, buf, &exp);
+                       else
+                               /* quietly ignore unknown words and anything
+                                * following. Newer user-space can try to set
+                                * new values, then see what the result was.
+                                */
+                               break;
+                       if (err)
+                               goto out;
+               }
 
-               err = fsloc_parse(&mesg, buf, &exp.ex_fslocs);
-               if (err)
-                       goto out;
+               err = check_export(nd.path.dentry->d_inode, exp.ex_flags,
+                                  exp.ex_uuid);
+               if (err) goto out;
        }
 
        expp = svc_export_lookup(&exp);
@@ -562,9 +622,11 @@ static int svc_export_parse(struct cache_detail *cd, char *mesg, int mlen)
        else
                exp_put(expp);
  out:
-       kfree(exp.ex_path);
-       if (nd.dentry)
-               path_release(&nd);
+       nfsd4_fslocs_free(&exp.ex_fslocs);
+       kfree(exp.ex_uuid);
+       kfree(exp.ex_pathname);
+       if (nd.path.dentry)
+               path_put(&nd.path);
  out_no_path:
        if (dom)
                auth_domain_put(dom);
@@ -574,6 +636,7 @@ static int svc_export_parse(struct cache_detail *cd, char *mesg, int mlen)
 
 static void exp_flags(struct seq_file *m, int flag, int fsid,
                uid_t anonu, uid_t anong, struct nfsd4_fs_locations *fslocs);
+static void show_secinfo(struct seq_file *m, struct svc_export *exp);
 
 static int svc_export_show(struct seq_file *m,
                           struct cache_detail *cd,
@@ -586,14 +649,25 @@ static int svc_export_show(struct seq_file *m,
                return 0;
        }
        exp = container_of(h, struct svc_export, h);
-       seq_path(m, exp->ex_mnt, exp->ex_dentry, " \t\n\\");
+       seq_path(m, &exp->ex_path, " \t\n\\");
        seq_putc(m, '\t');
        seq_escape(m, exp->ex_client->name, " \t\n\\");
        seq_putc(m, '(');
        if (test_bit(CACHE_VALID, &h->flags) && 
-           !test_bit(CACHE_NEGATIVE, &h->flags))
+           !test_bit(CACHE_NEGATIVE, &h->flags)) {
                exp_flags(m, exp->ex_flags, exp->ex_fsid,
                          exp->ex_anon_uid, exp->ex_anon_gid, &exp->ex_fslocs);
+               if (exp->ex_uuid) {
+                       int i;
+                       seq_puts(m, ",uuid=");
+                       for (i=0; i<16; i++) {
+                               if ((i&3) == 0 && i)
+                                       seq_putc(m, ':');
+                               seq_printf(m, "%02x", exp->ex_uuid[i]);
+                       }
+               }
+               show_secinfo(m, exp);
+       }
        seq_puts(m, ")\n");
        return 0;
 }
@@ -602,8 +676,8 @@ static int svc_export_match(struct cache_head *a, struct cache_head *b)
        struct svc_export *orig = container_of(a, struct svc_export, h);
        struct svc_export *new = container_of(b, struct svc_export, h);
        return orig->ex_client == new->ex_client &&
-               orig->ex_dentry == new->ex_dentry &&
-               orig->ex_mnt == new->ex_mnt;
+               orig->ex_path.dentry == new->ex_path.dentry &&
+               orig->ex_path.mnt == new->ex_path.mnt;
 }
 
 static void svc_export_init(struct cache_head *cnew, struct cache_head *citem)
@@ -613,9 +687,9 @@ static void svc_export_init(struct cache_head *cnew, struct cache_head *citem)
 
        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);
-       new->ex_path = NULL;
+       new->ex_path.dentry = dget(item->ex_path.dentry);
+       new->ex_path.mnt = mntget(item->ex_path.mnt);
+       new->ex_pathname = NULL;
        new->ex_fslocs.locations = NULL;
        new->ex_fslocs.locations_count = 0;
        new->ex_fslocs.migrated = 0;
@@ -625,19 +699,26 @@ static void export_update(struct cache_head *cnew, struct cache_head *citem)
 {
        struct svc_export *new = container_of(cnew, struct svc_export, h);
        struct svc_export *item = container_of(citem, struct svc_export, h);
+       int i;
 
        new->ex_flags = item->ex_flags;
        new->ex_anon_uid = item->ex_anon_uid;
        new->ex_anon_gid = item->ex_anon_gid;
        new->ex_fsid = item->ex_fsid;
-       new->ex_path = item->ex_path;
-       item->ex_path = NULL;
+       new->ex_uuid = item->ex_uuid;
+       item->ex_uuid = NULL;
+       new->ex_pathname = item->ex_pathname;
+       item->ex_pathname = NULL;
        new->ex_fslocs.locations = item->ex_fslocs.locations;
        item->ex_fslocs.locations = NULL;
        new->ex_fslocs.locations_count = item->ex_fslocs.locations_count;
        item->ex_fslocs.locations_count = 0;
        new->ex_fslocs.migrated = item->ex_fslocs.migrated;
        item->ex_fslocs.migrated = 0;
+       new->ex_nflavors = item->ex_nflavors;
+       for (i = 0; i < MAX_SECINFO_LIST; i++) {
+               new->ex_flavors[i] = item->ex_flavors[i];
+       }
 }
 
 static struct cache_head *svc_export_alloc(void)
@@ -670,8 +751,8 @@ svc_export_lookup(struct svc_export *exp)
        struct cache_head *ch;
        int hash;
        hash = hash_ptr(exp->ex_client, EXPORT_HASHBITS);
-       hash ^= hash_ptr(exp->ex_dentry, EXPORT_HASHBITS);
-       hash ^= hash_ptr(exp->ex_mnt, EXPORT_HASHBITS);
+       hash ^= hash_ptr(exp->ex_path.dentry, EXPORT_HASHBITS);
+       hash ^= hash_ptr(exp->ex_path.mnt, EXPORT_HASHBITS);
 
        ch = sunrpc_cache_lookup(&svc_export_cache, &exp->h,
                                 hash);
@@ -687,8 +768,8 @@ svc_export_update(struct svc_export *new, struct svc_export *old)
        struct cache_head *ch;
        int hash;
        hash = hash_ptr(old->ex_client, EXPORT_HASHBITS);
-       hash ^= hash_ptr(old->ex_dentry, EXPORT_HASHBITS);
-       hash ^= hash_ptr(old->ex_mnt, EXPORT_HASHBITS);
+       hash ^= hash_ptr(old->ex_path.dentry, EXPORT_HASHBITS);
+       hash ^= hash_ptr(old->ex_path.mnt, EXPORT_HASHBITS);
 
        ch = sunrpc_cache_update(&svc_export_cache, &new->h,
                                 &old->h,
@@ -707,16 +788,18 @@ exp_find_key(svc_client *clp, int fsid_type, u32 *fsidv, struct cache_req *reqp)
        int err;
        
        if (!clp)
-               return NULL;
+               return ERR_PTR(-ENOENT);
 
        key.ek_client = clp;
        key.ek_fsidtype = fsid_type;
        memcpy(key.ek_fsid, fsidv, key_len(fsid_type));
 
        ek = svc_expkey_lookup(&key);
-       if (ek != NULL)
-               if ((err = cache_check(&svc_expkey_cache, &ek->h, reqp)))
-                       ek = ERR_PTR(err);
+       if (ek == NULL)
+               return ERR_PTR(-ENOMEM);
+       err = cache_check(&svc_expkey_cache, &ek->h, reqp);
+       if (err)
+               return ERR_PTR(err);
        return ek;
 }
 
@@ -728,8 +811,7 @@ static int exp_set_key(svc_client *clp, int fsid_type, u32 *fsidv,
        key.ek_client = clp;
        key.ek_fsidtype = fsid_type;
        memcpy(key.ek_fsid, fsidv, key_len(fsid_type));
-       key.ek_mnt = exp->ex_mnt;
-       key.ek_dentry = exp->ex_dentry;
+       key.ek_path = exp->ex_path;
        key.h.expiry_time = NEVER;
        key.h.flags = 0;
 
@@ -752,11 +834,11 @@ exp_get_key(svc_client *clp, dev_t dev, ino_t ino)
        u32 fsidv[3];
        
        if (old_valid_dev(dev)) {
-               mk_fsid_v0(fsidv, dev, ino);
-               return exp_find_key(clp, 0, fsidv, NULL);
+               mk_fsid(FSID_DEV, fsidv, dev, ino, 0, NULL);
+               return exp_find_key(clp, FSID_DEV, fsidv, NULL);
        }
-       mk_fsid_v3(fsidv, dev, ino);
-       return exp_find_key(clp, 3, fsidv, NULL);
+       mk_fsid(FSID_ENCODE_DEV, fsidv, dev, ino, 0, NULL);
+       return exp_find_key(clp, FSID_ENCODE_DEV, fsidv, NULL);
 }
 
 /*
@@ -767,56 +849,47 @@ exp_get_fsid_key(svc_client *clp, int fsid)
 {
        u32 fsidv[2];
 
-       mk_fsid_v1(fsidv, fsid);
+       mk_fsid(FSID_NUM, fsidv, 0, 0, fsid, NULL);
 
-       return exp_find_key(clp, 1, fsidv, NULL);
+       return exp_find_key(clp, FSID_NUM, fsidv, NULL);
 }
 
-svc_export *
-exp_get_by_name(svc_client *clp, struct vfsmount *mnt, struct dentry *dentry,
-               struct cache_req *reqp)
+static svc_export *exp_get_by_name(svc_client *clp, struct vfsmount *mnt,
+                                  struct dentry *dentry,
+                                  struct cache_req *reqp)
 {
        struct svc_export *exp, key;
-       
+       int err;
+
        if (!clp)
-               return NULL;
+               return ERR_PTR(-ENOENT);
 
        key.ex_client = clp;
-       key.ex_mnt = mnt;
-       key.ex_dentry = dentry;
+       key.ex_path.mnt = mnt;
+       key.ex_path.dentry = dentry;
 
        exp = svc_export_lookup(&key);
-       if (exp != NULL)  {
-               int err;
-
-               err = cache_check(&svc_export_cache, &exp->h, reqp);
-               switch (err) {
-               case 0: break;
-               case -EAGAIN:
-               case -ETIMEDOUT:
-                       exp = ERR_PTR(err);
-                       break;
-               default:
-                       exp = NULL;
-               }
-       }
-
+       if (exp == NULL)
+               return ERR_PTR(-ENOMEM);
+       err = cache_check(&svc_export_cache, &exp->h, reqp);
+       if (err)
+               return ERR_PTR(err);
        return exp;
 }
 
 /*
  * Find the export entry for a given dentry.
  */
-struct svc_export *
-exp_parent(svc_client *clp, struct vfsmount *mnt, struct dentry *dentry,
-          struct cache_req *reqp)
+static struct svc_export *exp_parent(svc_client *clp, struct vfsmount *mnt,
+                                    struct dentry *dentry,
+                                    struct cache_req *reqp)
 {
        svc_export *exp;
 
        dget(dentry);
        exp = exp_get_by_name(clp, mnt, dentry, reqp);
 
-       while (exp == NULL && !IS_ROOT(dentry)) {
+       while (PTR_ERR(exp) == -ENOENT && !IS_ROOT(dentry)) {
                struct dentry *parent;
 
                parent = dget_parent(dentry);
@@ -869,7 +942,7 @@ static void exp_fsid_unhash(struct svc_export *exp)
                return;
 
        ek = exp_get_fsid_key(exp->ex_client, exp->ex_fsid);
-       if (ek && !IS_ERR(ek)) {
+       if (!IS_ERR(ek)) {
                ek->h.expiry_time = get_seconds()-1;
                cache_put(&ek->h, &svc_expkey_cache);
        }
@@ -883,31 +956,31 @@ static int exp_fsid_hash(svc_client *clp, struct svc_export *exp)
        if ((exp->ex_flags & NFSEXP_FSID) == 0)
                return 0;
 
-       mk_fsid_v1(fsid, exp->ex_fsid);
-       return exp_set_key(clp, 1, fsid, exp);
+       mk_fsid(FSID_NUM, fsid, 0, 0, exp->ex_fsid, NULL);
+       return exp_set_key(clp, FSID_NUM, fsid, exp);
 }
 
 static int exp_hash(struct auth_domain *clp, struct svc_export *exp)
 {
        u32 fsid[2];
-       struct inode *inode = exp->ex_dentry->d_inode;
+       struct inode *inode = exp->ex_path.dentry->d_inode;
        dev_t dev = inode->i_sb->s_dev;
 
        if (old_valid_dev(dev)) {
-               mk_fsid_v0(fsid, dev, inode->i_ino);
-               return exp_set_key(clp, 0, fsid, exp);
+               mk_fsid(FSID_DEV, fsid, dev, inode->i_ino, 0, NULL);
+               return exp_set_key(clp, FSID_DEV, fsid, exp);
        }
-       mk_fsid_v3(fsid, dev, inode->i_ino);
-       return exp_set_key(clp, 3, fsid, exp);
+       mk_fsid(FSID_ENCODE_DEV, fsid, dev, inode->i_ino, 0, NULL);
+       return exp_set_key(clp, FSID_ENCODE_DEV, fsid, exp);
 }
 
 static void exp_unhash(struct svc_export *exp)
 {
        struct svc_expkey *ek;
-       struct inode *inode = exp->ex_dentry->d_inode;
+       struct inode *inode = exp->ex_path.dentry->d_inode;
 
        ek = exp_get_key(exp->ex_client, inode->i_sb->s_dev, inode->i_ino);
-       if (ek && !IS_ERR(ek)) {
+       if (!IS_ERR(ek)) {
                ek->h.expiry_time = get_seconds()-1;
                cache_put(&ek->h, &svc_expkey_cache);
        }
@@ -952,19 +1025,19 @@ exp_export(struct nfsctl_export *nxp)
                goto out_unlock;
        err = -EINVAL;
 
-       exp = exp_get_by_name(clp, nd.mnt, nd.dentry, NULL);
+       exp = exp_get_by_name(clp, nd.path.mnt, nd.path.dentry, NULL);
 
        memset(&new, 0, sizeof(new));
 
        /* must make sure there won't be an ex_fsid clash */
        if ((nxp->ex_flags & NFSEXP_FSID) &&
-           (fsid_key = exp_get_fsid_key(clp, nxp->ex_dev)) &&
-           !IS_ERR(fsid_key) &&
-           fsid_key->ek_mnt &&
-           (fsid_key->ek_mnt != nd.mnt || fsid_key->ek_dentry != nd.dentry) )
+           (!IS_ERR(fsid_key = exp_get_fsid_key(clp, nxp->ex_dev))) &&
+           fsid_key->ek_path.mnt &&
+           (fsid_key->ek_path.mnt != nd.path.mnt ||
+            fsid_key->ek_path.dentry != nd.path.dentry))
                goto finish;
 
-       if (exp) {
+       if (!IS_ERR(exp)) {
                /* just a flags/id/fsid update */
 
                exp_fsid_unhash(exp);
@@ -977,7 +1050,7 @@ exp_export(struct nfsctl_export *nxp)
                goto finish;
        }
 
-       err = check_export(nd.dentry->d_inode, nxp->ex_flags);
+       err = check_export(nd.path.dentry->d_inode, nxp->ex_flags, NULL);
        if (err) goto finish;
 
        err = -ENOMEM;
@@ -986,12 +1059,11 @@ exp_export(struct nfsctl_export *nxp)
 
        new.h.expiry_time = NEVER;
        new.h.flags = 0;
-       new.ex_path = kstrdup(nxp->ex_path, GFP_KERNEL);
-       if (!new.ex_path)
+       new.ex_pathname = kstrdup(nxp->ex_path, GFP_KERNEL);
+       if (!new.ex_pathname)
                goto finish;
        new.ex_client = clp;
-       new.ex_mnt = nd.mnt;
-       new.ex_dentry = nd.dentry;
+       new.ex_path = nd.path;
        new.ex_flags = nxp->ex_flags;
        new.ex_anon_uid = nxp->ex_anon_uid;
        new.ex_anon_gid = nxp->ex_anon_gid;
@@ -1012,15 +1084,14 @@ exp_export(struct nfsctl_export *nxp)
        } else
                err = 0;
 finish:
-       if (new.ex_path)
-               kfree(new.ex_path);
+       kfree(new.ex_pathname);
        if (exp)
                exp_put(exp);
        if (fsid_key && !IS_ERR(fsid_key))
                cache_put(&fsid_key->h, &svc_expkey_cache);
        if (clp)
                auth_domain_put(clp);
-       path_release(&nd);
+       path_put(&nd.path);
 out_unlock:
        exp_writeunlock();
 out:
@@ -1071,9 +1142,9 @@ exp_unexport(struct nfsctl_export *nxp)
                goto out_domain;
 
        err = -EINVAL;
-       exp = exp_get_by_name(dom, nd.mnt, nd.dentry, NULL);
-       path_release(&nd);
-       if (!exp)
+       exp = exp_get_by_name(dom, nd.path.mnt, nd.path.dentry, NULL);
+       path_put(&nd.path);
+       if (IS_ERR(exp))
                goto out_domain;
 
        exp_do_unexport(exp);
@@ -1108,26 +1179,22 @@ exp_rootfh(svc_client *clp, char *path, struct knfsd_fh *f, int maxsize)
                printk("nfsd: exp_rootfh path not found %s", path);
                return err;
        }
-       inode = nd.dentry->d_inode;
+       inode = nd.path.dentry->d_inode;
 
        dprintk("nfsd: exp_rootfh(%s [%p] %s:%s/%ld)\n",
-                path, nd.dentry, clp->name,
+                path, nd.path.dentry, clp->name,
                 inode->i_sb->s_id, inode->i_ino);
-       exp = exp_parent(clp, nd.mnt, nd.dentry, NULL);
+       exp = exp_parent(clp, nd.path.mnt, nd.path.dentry, NULL);
        if (IS_ERR(exp)) {
                err = PTR_ERR(exp);
                goto out;
        }
-       if (!exp) {
-               dprintk("nfsd: exp_rootfh export not found.\n");
-               goto out;
-       }
 
        /*
         * fh must be initialized before calling fh_compose
         */
        fh_init(&fh, maxsize);
-       if (fh_compose(&fh, exp, nd.dentry, NULL))
+       if (fh_compose(&fh, exp, nd.path.dentry, NULL))
                err = -EINVAL;
        else
                err = 0;
@@ -1135,27 +1202,139 @@ exp_rootfh(svc_client *clp, char *path, struct knfsd_fh *f, int maxsize)
        fh_put(&fh);
        exp_put(exp);
 out:
-       path_release(&nd);
+       path_put(&nd.path);
        return err;
 }
 
-struct svc_export *
-exp_find(struct auth_domain *clp, int fsid_type, u32 *fsidv,
-        struct cache_req *reqp)
+static struct svc_export *exp_find(struct auth_domain *clp, int fsid_type,
+                                  u32 *fsidv, struct cache_req *reqp)
 {
        struct svc_export *exp;
        struct svc_expkey *ek = exp_find_key(clp, fsid_type, fsidv, reqp);
-       if (!ek || IS_ERR(ek))
-               return ERR_PTR(PTR_ERR(ek));
+       if (IS_ERR(ek))
+               return ERR_CAST(ek);
 
-       exp = exp_get_by_name(clp, ek->ek_mnt, ek->ek_dentry, reqp);
+       exp = exp_get_by_name(clp, ek->ek_path.mnt, ek->ek_path.dentry, reqp);
        cache_put(&ek->h, &svc_expkey_cache);
 
-       if (!exp || IS_ERR(exp))
-               return ERR_PTR(PTR_ERR(exp));
+       if (IS_ERR(exp))
+               return ERR_CAST(exp);
        return exp;
 }
 
+__be32 check_nfsd_access(struct svc_export *exp, struct svc_rqst *rqstp)
+{
+       struct exp_flavor_info *f;
+       struct exp_flavor_info *end = exp->ex_flavors + exp->ex_nflavors;
+
+       /* legacy gss-only clients are always OK: */
+       if (exp->ex_client == rqstp->rq_gssclient)
+               return 0;
+       /* ip-address based client; check sec= export option: */
+       for (f = exp->ex_flavors; f < end; f++) {
+               if (f->pseudoflavor == rqstp->rq_flavor)
+                       return 0;
+       }
+       /* defaults in absence of sec= options: */
+       if (exp->ex_nflavors == 0) {
+               if (rqstp->rq_flavor == RPC_AUTH_NULL ||
+                   rqstp->rq_flavor == RPC_AUTH_UNIX)
+                       return 0;
+       }
+       return nfserr_wrongsec;
+}
+
+/*
+ * Uses rq_client and rq_gssclient to find an export; uses rq_client (an
+ * auth_unix client) if it's available and has secinfo information;
+ * otherwise, will try to use rq_gssclient.
+ *
+ * Called from functions that handle requests; functions that do work on
+ * behalf of mountd are passed a single client name to use, and should
+ * use exp_get_by_name() or exp_find().
+ */
+struct svc_export *
+rqst_exp_get_by_name(struct svc_rqst *rqstp, struct vfsmount *mnt,
+               struct dentry *dentry)
+{
+       struct svc_export *gssexp, *exp = ERR_PTR(-ENOENT);
+
+       if (rqstp->rq_client == NULL)
+               goto gss;
+
+       /* First try the auth_unix client: */
+       exp = exp_get_by_name(rqstp->rq_client, mnt, dentry,
+                                               &rqstp->rq_chandle);
+       if (PTR_ERR(exp) == -ENOENT)
+               goto gss;
+       if (IS_ERR(exp))
+               return exp;
+       /* If it has secinfo, assume there are no gss/... clients */
+       if (exp->ex_nflavors > 0)
+               return exp;
+gss:
+       /* Otherwise, try falling back on gss client */
+       if (rqstp->rq_gssclient == NULL)
+               return exp;
+       gssexp = exp_get_by_name(rqstp->rq_gssclient, mnt, dentry,
+                                               &rqstp->rq_chandle);
+       if (PTR_ERR(gssexp) == -ENOENT)
+               return exp;
+       if (!IS_ERR(exp))
+               exp_put(exp);
+       return gssexp;
+}
+
+struct svc_export *
+rqst_exp_find(struct svc_rqst *rqstp, int fsid_type, u32 *fsidv)
+{
+       struct svc_export *gssexp, *exp = ERR_PTR(-ENOENT);
+
+       if (rqstp->rq_client == NULL)
+               goto gss;
+
+       /* First try the auth_unix client: */
+       exp = exp_find(rqstp->rq_client, fsid_type, fsidv, &rqstp->rq_chandle);
+       if (PTR_ERR(exp) == -ENOENT)
+               goto gss;
+       if (IS_ERR(exp))
+               return exp;
+       /* If it has secinfo, assume there are no gss/... clients */
+       if (exp->ex_nflavors > 0)
+               return exp;
+gss:
+       /* Otherwise, try falling back on gss client */
+       if (rqstp->rq_gssclient == NULL)
+               return exp;
+       gssexp = exp_find(rqstp->rq_gssclient, fsid_type, fsidv,
+                                               &rqstp->rq_chandle);
+       if (PTR_ERR(gssexp) == -ENOENT)
+               return exp;
+       if (!IS_ERR(exp))
+               exp_put(exp);
+       return gssexp;
+}
+
+struct svc_export *
+rqst_exp_parent(struct svc_rqst *rqstp, struct vfsmount *mnt,
+               struct dentry *dentry)
+{
+       struct svc_export *exp;
+
+       dget(dentry);
+       exp = rqst_exp_get_by_name(rqstp, mnt, dentry);
+
+       while (PTR_ERR(exp) == -ENOENT && !IS_ROOT(dentry)) {
+               struct dentry *parent;
+
+               parent = dget_parent(dentry);
+               dput(dentry);
+               dentry = parent;
+               exp = rqst_exp_get_by_name(rqstp, mnt, dentry);
+       }
+       dput(dentry);
+       return exp;
+}
 
 /*
  * Called when we need the filehandle for the root of the pseudofs,
@@ -1163,21 +1342,22 @@ exp_find(struct auth_domain *clp, int fsid_type, u32 *fsidv,
  * export point with fsid==0
  */
 __be32
-exp_pseudoroot(struct auth_domain *clp, struct svc_fh *fhp,
-              struct cache_req *creq)
+exp_pseudoroot(struct svc_rqst *rqstp, struct svc_fh *fhp)
 {
        struct svc_export *exp;
        __be32 rv;
        u32 fsidv[2];
 
-       mk_fsid_v1(fsidv, 0);
+       mk_fsid(FSID_NUM, fsidv, 0, 0, 0, NULL);
 
-       exp = exp_find(clp, 1, fsidv, creq);
+       exp = rqst_exp_find(rqstp, FSID_NUM, fsidv);
        if (IS_ERR(exp))
                return nfserrno(PTR_ERR(exp));
-       if (exp == NULL)
-               return nfserr_perm;
-       rv = fh_compose(fhp, exp, exp->ex_dentry, NULL);
+       rv = fh_compose(fhp, exp, exp->ex_path.dentry, NULL);
+       if (rv)
+               goto out;
+       rv = check_nfsd_access(exp, rqstp);
+out:
        exp_put(exp);
        return rv;
 }
@@ -1265,28 +1445,62 @@ static struct flags {
        { 0, {"", ""}}
 };
 
-static void exp_flags(struct seq_file *m, int flag, int fsid,
-               uid_t anonu, uid_t anong, struct nfsd4_fs_locations *fsloc)
+static void show_expflags(struct seq_file *m, int flags, int mask)
 {
-       int first = 0;
        struct flags *flg;
+       int state, first = 0;
 
        for (flg = expflags; flg->flag; flg++) {
-               int state = (flg->flag & flag)?0:1;
+               if (flg->flag & ~mask)
+                       continue;
+               state = (flg->flag & flags) ? 0 : 1;
                if (*flg->name[state])
                        seq_printf(m, "%s%s", first++?",":"", flg->name[state]);
        }
+}
+
+static void show_secinfo_flags(struct seq_file *m, int flags)
+{
+       seq_printf(m, ",");
+       show_expflags(m, flags, NFSEXP_SECINFO_FLAGS);
+}
+
+static void show_secinfo(struct seq_file *m, struct svc_export *exp)
+{
+       struct exp_flavor_info *f;
+       struct exp_flavor_info *end = exp->ex_flavors + exp->ex_nflavors;
+       int lastflags = 0, first = 0;
+
+       if (exp->ex_nflavors == 0)
+               return;
+       for (f = exp->ex_flavors; f < end; f++) {
+               if (first || f->flags != lastflags) {
+                       if (!first)
+                               show_secinfo_flags(m, lastflags);
+                       seq_printf(m, ",sec=%d", f->pseudoflavor);
+                       lastflags = f->flags;
+               } else {
+                       seq_printf(m, ":%d", f->pseudoflavor);
+               }
+       }
+       show_secinfo_flags(m, lastflags);
+}
+
+static void exp_flags(struct seq_file *m, int flag, int fsid,
+               uid_t anonu, uid_t anong, struct nfsd4_fs_locations *fsloc)
+{
+       show_expflags(m, flag, NFSEXP_ALLFLAGS);
        if (flag & NFSEXP_FSID)
-               seq_printf(m, "%sfsid=%d", first++?",":"", fsid);
+               seq_printf(m, ",fsid=%d", fsid);
        if (anonu != (uid_t)-2 && anonu != (0x10000-2))
-               seq_printf(m, "%sanonuid=%d", first++?",":"", anonu);
+               seq_printf(m, ",anonuid=%u", anonu);
        if (anong != (gid_t)-2 && anong != (0x10000-2))
-               seq_printf(m, "%sanongid=%d", first++?",":"", anong);
+               seq_printf(m, ",anongid=%u", anong);
        if (fsloc && fsloc->locations_count > 0) {
                char *loctype = (fsloc->migrated) ? "refer" : "replicas";
                int i;
 
-               seq_printf(m, "%s%s=", first++?",":"", loctype);
+               seq_printf(m, ",%s=", loctype);
                seq_escape(m, fsloc->locations[0].path, ",;@ \t\n\\");
                seq_putc(m, '@');
                seq_escape(m, fsloc->locations[0].hosts, ",;@ \t\n\\");
@@ -1415,13 +1629,19 @@ exp_verify_string(char *cp, int max)
 /*
  * Initialize the exports module.
  */
-void
+int
 nfsd_export_init(void)
 {
+       int rv;
        dprintk("nfsd: initializing export module.\n");
 
-       cache_register(&svc_export_cache);
-       cache_register(&svc_expkey_cache);
+       rv = cache_register(&svc_export_cache);
+       if (rv)
+               return rv;
+       rv = cache_register(&svc_expkey_cache);
+       if (rv)
+               cache_unregister(&svc_export_cache);
+       return rv;
 
 }
 
@@ -1448,10 +1668,8 @@ nfsd_export_shutdown(void)
 
        exp_writelock();
 
-       if (cache_unregister(&svc_expkey_cache))
-               printk(KERN_ERR "nfsd: failed to unregister expkey cache\n");
-       if (cache_unregister(&svc_export_cache))
-               printk(KERN_ERR "nfsd: failed to unregister export cache\n");
+       cache_unregister(&svc_expkey_cache);
+       cache_unregister(&svc_export_cache);
        svcauth_unix_purge();
 
        exp_writeunlock();