Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/ericvh/v9fs

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/ericvh/v9fs:
  9p: remove sysctl
  9p: fix bad kconfig cross-dependency
  9p: soften invalidation in loose_mode
  9p: attach-per-user
  9p: rename uid and gid parameters
  9p: define session flags
  9p: Make transports dynamic

6 files changed, 266 insertions, 193 deletions

diff --git a/fs/9p/fid.c b/fs/9p/fid.c
index 15e05a15b575..b364da70ff28 100644
--- a/fs/9p/fid.c
+++ b/fs/9p/fid.c
@@ -1,6 +1,7 @@
 /*
  * V9FS FID Management
  *
+ *  Copyright (C) 2007 by Latchesar Ionkov <lucho@ionkov.net>
  *  Copyright (C) 2005, 2006 by Eric Van Hensbergen <ericvh@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
@@ -34,9 +35,9 @@
 #include "fid.h"
 
 /**
- * v9fs_fid_insert - add a fid to a dentry
+ * v9fs_fid_add - add a fid to a dentry
+ * @dentry: dentry that the fid is being added to
  * @fid: fid to add
- * @dentry: dentry that it is being added to
  *
  */
 
@@ -66,52 +67,144 @@ int v9fs_fid_add(struct dentry *dentry, struct p9_fid *fid)
 }
 
 /**
- * v9fs_fid_lookup - return a locked fid from a dentry
+ * v9fs_fid_find - retrieve a fid that belongs to the specified uid
  * @dentry: dentry to look for fid in
- *
- * find a fid in the dentry, obtain its semaphore and return a reference to it.
- * code calling lookup is responsible for releasing lock
- *
- * TODO: only match fids that have the same uid as current user
+ * @uid: return fid that belongs to the specified user
+ * @any: if non-zero, return any fid associated with the dentry
  *
  */
 
-struct p9_fid *v9fs_fid_lookup(struct dentry *dentry)
+static struct p9_fid *v9fs_fid_find(struct dentry *dentry, u32 uid, int any)
 {
         struct v9fs_dentry *dent;
-        struct p9_fid *fid;
-
-        P9_DPRINTK(P9_DEBUG_VFS, " dentry: %s (%p)\n", dentry->d_iname, dentry);
-        dent = dentry->d_fsdata;
-        if (dent)
-                fid = list_entry(dent->fidlist.next, struct p9_fid, dlist);
-        else
-                fid = ERR_PTR(-EBADF);
+        struct p9_fid *fid, *ret;
+
+        P9_DPRINTK(P9_DEBUG_VFS, " dentry: %s (%p) uid %d any %d\n",
+                dentry->d_iname, dentry, uid, any);
+        dent = (struct v9fs_dentry *) dentry->d_fsdata;
+        ret = NULL;
+        if (dent) {
+                spin_lock(&dent->lock);
+                list_for_each_entry(fid, &dent->fidlist, dlist) {
+                        if (any || fid->uid == uid) {
+                                ret = fid;
+                                break;
+                        }
+                }
+                spin_unlock(&dent->lock);
+        }
 
-        P9_DPRINTK(P9_DEBUG_VFS, " fid: %p\n", fid);
-        return fid;
+        return ret;
 }
 
 /**
- * v9fs_fid_clone - lookup the fid for a dentry, clone a private copy and
- *      release it
+ * v9fs_fid_lookup - lookup for a fid, try to walk if not found
  * @dentry: dentry to look for fid in
  *
- * find a fid in the dentry and then clone to a new private fid
- *
- * TODO: only match fids that have the same uid as current user
- *
+ * Look for a fid in the specified dentry for the current user.
+ * If no fid is found, try to create one walking from a fid from the parent
+ * dentry (if it has one), or the root dentry. If the user haven't accessed
+ * the fs yet, attach now and walk from the root.
  */
 
-struct p9_fid *v9fs_fid_clone(struct dentry *dentry)
+struct p9_fid *v9fs_fid_lookup(struct dentry *dentry)
 {
-        struct p9_fid *ofid, *fid;
+        int i, n, l, clone, any, access;
+        u32 uid;
+        struct p9_fid *fid;
+        struct dentry *d, *ds;
+        struct v9fs_session_info *v9ses;
+        char **wnames, *uname;
+
+        v9ses = v9fs_inode2v9ses(dentry->d_inode);
+        access = v9ses->flags & V9FS_ACCESS_MASK;
+        switch (access) {
+        case V9FS_ACCESS_SINGLE:
+        case V9FS_ACCESS_USER:
+                uid = current->fsuid;
+                any = 0;
+                break;
+
+        case V9FS_ACCESS_ANY:
+                uid = v9ses->uid;
+                any = 1;
+                break;
+
+        default:
+                uid = ~0;
+                any = 0;
+                break;
+        }
 
-        P9_DPRINTK(P9_DEBUG_VFS, " dentry: %s (%p)\n", dentry->d_iname, dentry);
-        ofid = v9fs_fid_lookup(dentry);
-        if (IS_ERR(ofid))
-                return ofid;
+        fid = v9fs_fid_find(dentry, uid, any);
+        if (fid)
+                return fid;
+
+        ds = dentry->d_parent;
+        fid = v9fs_fid_find(ds, uid, any);
+        if (!fid) { /* walk from the root */
+                n = 0;
+                for (ds = dentry; !IS_ROOT(ds); ds = ds->d_parent)
+                        n++;
+
+                fid = v9fs_fid_find(ds, uid, any);
+                if (!fid) { /* the user is not attached to the fs yet */
+                        if (access == V9FS_ACCESS_SINGLE)
+                                return ERR_PTR(-EPERM);
+
+                        if (v9fs_extended(v9ses))
+                                uname = NULL;
+                        else
+                                uname = v9ses->uname;
+
+                        fid = p9_client_attach(v9ses->clnt, NULL, uname, uid,
+                                v9ses->aname);
+
+                        if (IS_ERR(fid))
+                                return fid;
+
+                        v9fs_fid_add(ds, fid);
+                }
+        } else /* walk from the parent */
+                n = 1;
+
+        if (ds == dentry)
+                return fid;
+
+        wnames = kmalloc(sizeof(char *) * n, GFP_KERNEL);
+        if (!wnames)
+                return ERR_PTR(-ENOMEM);
+
+        for (d = dentry, i = n; i >= 0; i--, d = d->d_parent)
+                wnames[i] = (char *) d->d_name.name;
+
+        clone = 1;
+        i = 0;
+        while (i < n) {
+                l = min(n - i, P9_MAXWELEM);
+                fid = p9_client_walk(fid, l, &wnames[i], clone);
+                if (!fid) {
+                        kfree(wnames);
+                        return fid;
+                }
+
+                i += l;
+                clone = 0;
+        }
 
-        fid = p9_client_walk(ofid, 0, NULL, 1);
+        kfree(wnames);
+        v9fs_fid_add(dentry, fid);
         return fid;
 }
+
+struct p9_fid *v9fs_fid_clone(struct dentry *dentry)
+{
+        struct p9_fid *fid, *ret;
+
+        fid = v9fs_fid_lookup(dentry);
+        if (IS_ERR(fid))
+                return fid;
+
+        ret = p9_client_walk(fid, 0, NULL, 1);
+        return ret;
+}
diff --git a/fs/9p/v9fs.c b/fs/9p/v9fs.c
index 0a7068e30ecb..873802de21cd 100644
--- a/fs/9p/v9fs.c
+++ b/fs/9p/v9fs.c
@@ -38,56 +38,41 @@
 
 /*
   * Option Parsing (code inspired by NFS code)
-  *
+  *  NOTE: each transport will parse its own options
   */
 
 enum {
         /* Options that take integer arguments */
-        Opt_debug, Opt_port, Opt_msize, Opt_uid, Opt_gid, Opt_afid,
-        Opt_rfdno, Opt_wfdno,
+        Opt_debug, Opt_msize, Opt_dfltuid, Opt_dfltgid, Opt_afid,
         /* String options */
-        Opt_uname, Opt_remotename,
+        Opt_uname, Opt_remotename, Opt_trans,
         /* Options that take no arguments */
-        Opt_legacy, Opt_nodevmap, Opt_unix, Opt_tcp, Opt_fd, Opt_pci,
+        Opt_legacy, Opt_nodevmap,
         /* Cache options */
         Opt_cache_loose,
+        /* Access options */
+        Opt_access,
         /* Error token */
         Opt_err
 };
 
 static match_table_t tokens = {
         {Opt_debug, "debug=%x"},
-        {Opt_port, "port=%u"},
         {Opt_msize, "msize=%u"},
-        {Opt_uid, "uid=%u"},
-        {Opt_gid, "gid=%u"},
+        {Opt_dfltuid, "dfltuid=%u"},
+        {Opt_dfltgid, "dfltgid=%u"},
         {Opt_afid, "afid=%u"},
-        {Opt_rfdno, "rfdno=%u"},
-        {Opt_wfdno, "wfdno=%u"},
         {Opt_uname, "uname=%s"},
         {Opt_remotename, "aname=%s"},
-        {Opt_unix, "proto=unix"},
-        {Opt_tcp, "proto=tcp"},
-        {Opt_fd, "proto=fd"},
-#ifdef CONFIG_PCI_9P
-        {Opt_pci, "proto=pci"},
-#endif
-        {Opt_tcp, "tcp"},
-        {Opt_unix, "unix"},
-        {Opt_fd, "fd"},
+        {Opt_trans, "trans=%s"},
         {Opt_legacy, "noextend"},
         {Opt_nodevmap, "nodevmap"},
         {Opt_cache_loose, "cache=loose"},
         {Opt_cache_loose, "loose"},
+        {Opt_access, "access=%s"},
         {Opt_err, NULL}
 };
 
-extern struct p9_transport *p9pci_trans_create(void);
-
-/*
- *  Parse option string.
- */
-
 /**
  * v9fs_parse_options - parse mount options into session structure
  * @options: options string passed from mount
@@ -95,23 +80,21 @@ extern struct p9_transport *p9pci_trans_create(void);
  *
  */
 
-static void v9fs_parse_options(char *options, struct v9fs_session_info *v9ses)
+static void v9fs_parse_options(struct v9fs_session_info *v9ses)
 {
-        char *p;
+        char *options = v9ses->options;
         substring_t args[MAX_OPT_ARGS];
+        char *p;
         int option;
         int ret;
+        char *s, *e;
 
         /* setup defaults */
-        v9ses->port = V9FS_PORT;
-        v9ses->maxdata = 9000;
-        v9ses->proto = PROTO_TCP;
-        v9ses->extended = 1;
+        v9ses->maxdata = 8192;
         v9ses->afid = ~0;
         v9ses->debug = 0;
-        v9ses->rfdno = ~0;
-        v9ses->wfdno = ~0;
         v9ses->cache = 0;
+        v9ses->trans = v9fs_default_trans();
 
         if (!options)
                 return;
@@ -135,47 +118,29 @@ static void v9fs_parse_options(char *options, struct v9fs_session_info *v9ses)
                         p9_debug_level = option;
 #endif
                         break;
-                case Opt_port:
-                        v9ses->port = option;
-                        break;
                 case Opt_msize:
                         v9ses->maxdata = option;
                         break;
-                case Opt_uid:
-                        v9ses->uid = option;
+                case Opt_dfltuid:
+                        v9ses->dfltuid = option;
                         break;
-                case Opt_gid:
-                        v9ses->gid = option;
+                case Opt_dfltgid:
+                        v9ses->dfltgid = option;
                         break;
                 case Opt_afid:
                         v9ses->afid = option;
                         break;
-                case Opt_rfdno:
-                        v9ses->rfdno = option;
-                        break;
-                case Opt_wfdno:
-                        v9ses->wfdno = option;
-                        break;
-                case Opt_tcp:
-                        v9ses->proto = PROTO_TCP;
-                        break;
-                case Opt_unix:
-                        v9ses->proto = PROTO_UNIX;
-                        break;
-                case Opt_pci:
-                        v9ses->proto = PROTO_PCI;
-                        break;
-                case Opt_fd:
-                        v9ses->proto = PROTO_FD;
+                case Opt_trans:
+                        v9ses->trans = v9fs_match_trans(&args[0]);
                         break;
                 case Opt_uname:
-                        match_strcpy(v9ses->name, &args[0]);
+                        match_strcpy(v9ses->uname, &args[0]);
                         break;
                 case Opt_remotename:
-                        match_strcpy(v9ses->remotename, &args[0]);
+                        match_strcpy(v9ses->aname, &args[0]);
                         break;
                 case Opt_legacy:
-                        v9ses->extended = 0;
+                        v9ses->flags &= ~V9FS_EXTENDED;
                         break;
                 case Opt_nodevmap:
                         v9ses->nodev = 1;
@@ -183,6 +148,22 @@ static void v9fs_parse_options(char *options, struct v9fs_session_info *v9ses)
                 case Opt_cache_loose:
                         v9ses->cache = CACHE_LOOSE;
                         break;
+
+                case Opt_access:
+                        s = match_strdup(&args[0]);
+                        v9ses->flags &= ~V9FS_ACCESS_MASK;
+                        if (strcmp(s, "user") == 0)
+                                v9ses->flags |= V9FS_ACCESS_USER;
+                        else if (strcmp(s, "any") == 0)
+                                v9ses->flags |= V9FS_ACCESS_ANY;
+                        else {
+                                v9ses->flags |= V9FS_ACCESS_SINGLE;
+                                v9ses->uid = simple_strtol(s, &e, 10);
+                                if (*e != '\0')
+                                        v9ses->uid = ~0;
+                        }
+                        break;
+
                 default:
                         continue;
                 }
@@ -201,56 +182,46 @@ struct p9_fid *v9fs_session_init(struct v9fs_session_info *v9ses,
                   const char *dev_name, char *data)
 {
         int retval = -EINVAL;
-        struct p9_transport *trans;
+        struct p9_trans *trans = NULL;
         struct p9_fid *fid;
 
-        v9ses->name = __getname();
-        if (!v9ses->name)
+        v9ses->uname = __getname();
+        if (!v9ses->uname)
                 return ERR_PTR(-ENOMEM);
 
-        v9ses->remotename = __getname();
-        if (!v9ses->remotename) {
-                __putname(v9ses->name);
+        v9ses->aname = __getname();
+        if (!v9ses->aname) {
+                __putname(v9ses->uname);
                 return ERR_PTR(-ENOMEM);
         }
 
-        strcpy(v9ses->name, V9FS_DEFUSER);
-        strcpy(v9ses->remotename, V9FS_DEFANAME);
-
-        v9fs_parse_options(data, v9ses);
-
-        switch (v9ses->proto) {
-        case PROTO_TCP:
-                trans = p9_trans_create_tcp(dev_name, v9ses->port);
-                break;
-        case PROTO_UNIX:
-                trans = p9_trans_create_unix(dev_name);
-                *v9ses->remotename = 0;
-                break;
-        case PROTO_FD:
-                trans = p9_trans_create_fd(v9ses->rfdno, v9ses->wfdno);
-                *v9ses->remotename = 0;
-                break;
-#ifdef CONFIG_PCI_9P
-        case PROTO_PCI:
-                trans = p9pci_trans_create();
-                *v9ses->remotename = 0;
-                break;
-#endif
-        default:
-                printk(KERN_ERR "v9fs: Bad mount protocol %d\n", v9ses->proto);
-                retval = -ENOPROTOOPT;
+        v9ses->flags = V9FS_EXTENDED | V9FS_ACCESS_USER;
+        strcpy(v9ses->uname, V9FS_DEFUSER);
+        strcpy(v9ses->aname, V9FS_DEFANAME);
+        v9ses->uid = ~0;
+        v9ses->dfltuid = V9FS_DEFUID;
+        v9ses->dfltgid = V9FS_DEFGID;
+        v9ses->options = kstrdup(data, GFP_KERNEL);
+        v9fs_parse_options(v9ses);
+
+        if (v9ses->trans == NULL) {
+                retval = -EPROTONOSUPPORT;
+                P9_DPRINTK(P9_DEBUG_ERROR,
+                                "No transport defined or default transport\n");
                 goto error;
-        };
+        }
 
+        trans = v9ses->trans->create(dev_name, v9ses->options);
         if (IS_ERR(trans)) {
                 retval = PTR_ERR(trans);
                 trans = NULL;
                 goto error;
         }
+        if ((v9ses->maxdata+P9_IOHDRSZ) > v9ses->trans->maxsize)
+                v9ses->maxdata = v9ses->trans->maxsize-P9_IOHDRSZ;
 
-        v9ses->clnt = p9_client_create(trans, v9ses->maxdata + P9_IOHDRSZ,
-                v9ses->extended);
+        v9ses->clnt = p9_client_create(trans, v9ses->maxdata+P9_IOHDRSZ,
+                v9fs_extended(v9ses));
 
         if (IS_ERR(v9ses->clnt)) {
                 retval = PTR_ERR(v9ses->clnt);
@@ -259,8 +230,20 @@ struct p9_fid *v9fs_session_init(struct v9fs_session_info *v9ses,
                 goto error;
         }
 
-        fid = p9_client_attach(v9ses->clnt, NULL, v9ses->name,
-                                                        v9ses->remotename);
+        if (!v9ses->clnt->dotu)
+                v9ses->flags &= ~V9FS_EXTENDED;
+
+        /* for legacy mode, fall back to V9FS_ACCESS_ANY */
+        if (!v9fs_extended(v9ses) &&
+                ((v9ses->flags&V9FS_ACCESS_MASK) == V9FS_ACCESS_USER)) {
+
+                v9ses->flags &= ~V9FS_ACCESS_MASK;
+                v9ses->flags |= V9FS_ACCESS_ANY;
+                v9ses->uid = ~0;
+        }
+
+        fid = p9_client_attach(v9ses->clnt, NULL, v9ses->uname, ~0,
+                                                        v9ses->aname);
         if (IS_ERR(fid)) {
                 retval = PTR_ERR(fid);
                 fid = NULL;
@@ -268,6 +251,11 @@ struct p9_fid *v9fs_session_init(struct v9fs_session_info *v9ses,
                 goto error;
         }
 
+        if ((v9ses->flags & V9FS_ACCESS_MASK) == V9FS_ACCESS_SINGLE)
+                fid->uid = v9ses->uid;
+        else
+                fid->uid = ~0;
+
         return fid;
 
 error:
@@ -288,8 +276,9 @@ void v9fs_session_close(struct v9fs_session_info *v9ses)
                 v9ses->clnt = NULL;
         }
 
-        __putname(v9ses->name);
-        __putname(v9ses->remotename);
+        __putname(v9ses->uname);
+        __putname(v9ses->aname);
+        kfree(v9ses->options);
 }
 
 /**
@@ -311,7 +300,7 @@ extern int v9fs_error_init(void);
 static int __init init_v9fs(void)
 {
         printk(KERN_INFO "Installing v9fs 9p2000 file system support\n");
-
+        /* TODO: Setup list of registered trasnport modules */
         return register_filesystem(&v9fs_fs_type);
 }
 
diff --git a/fs/9p/v9fs.h b/fs/9p/v9fs.h
index abc4b1668ace..db4b4193f2e2 100644
--- a/fs/9p/v9fs.h
+++ b/fs/9p/v9fs.h
@@ -29,31 +29,30 @@
 struct v9fs_session_info {
         /* options */
         unsigned int maxdata;
-        unsigned char extended; /* set to 1 if we are using UNIX extensions */
+        unsigned char flags;    /* session flags */
         unsigned char nodev;    /* set to 1 if no disable device mapping */
-        unsigned short port;    /* port to connect to */
         unsigned short debug;   /* debug level */
-        unsigned short proto;   /* protocol to use */
         unsigned int afid;      /* authentication fid */
-        unsigned int rfdno;     /* read file descriptor number */
-        unsigned int wfdno;     /* write file descriptor number */
         unsigned int cache;     /* cache mode */
 
-        char *name;             /* user name to mount as */
-        char *remotename;       /* name of remote hierarchy being mounted */
-        unsigned int uid;       /* default uid/muid for legacy support */
-        unsigned int gid;       /* default gid for legacy support */
-
+        char *options;          /* copy of mount options */
+        char *uname;            /* user name to mount as */
+        char *aname;            /* name of remote hierarchy being mounted */
+        unsigned int dfltuid;   /* default uid/muid for legacy support */
+        unsigned int dfltgid;   /* default gid for legacy support */
+        u32 uid;                /* if ACCESS_SINGLE, the uid that has access */
+        struct p9_trans_module *trans; /* 9p transport */
         struct p9_client *clnt; /* 9p client */
         struct dentry *debugfs_dir;
 };
 
-/* possible values of ->proto */
+/* session flags */
 enum {
-        PROTO_TCP,
-        PROTO_UNIX,
-        PROTO_FD,
-        PROTO_PCI,
+        V9FS_EXTENDED           = 0x01, /* 9P2000.u */
+        V9FS_ACCESS_MASK        = 0x06, /* access mask */
+        V9FS_ACCESS_SINGLE      = 0x02, /* only one user can access the files */
+        V9FS_ACCESS_USER        = 0x04, /* attache per user */
+        V9FS_ACCESS_ANY         = 0x06, /* use the same attach for all users */
 };
 
 /* possible values of ->cache */
@@ -73,11 +72,18 @@ void v9fs_session_cancel(struct v9fs_session_info *v9ses);
 #define V9FS_MAGIC 0x01021997
 
 /* other default globals */
-#define V9FS_PORT               564
+#define V9FS_PORT       564
 #define V9FS_DEFUSER    "nobody"
 #define V9FS_DEFANAME   ""
+#define V9FS_DEFUID     (-2)
+#define V9FS_DEFGID     (-2)
 
 static inline struct v9fs_session_info *v9fs_inode2v9ses(struct inode *inode)
 {
         return (inode->i_sb->s_fs_info);
 }
+
+static inline int v9fs_extended(struct v9fs_session_info *v9ses)
+{
+        return v9ses->flags & V9FS_EXTENDED;
+}
diff --git a/fs/9p/vfs_file.c b/fs/9p/vfs_file.c
index 716691689fd5..ba4b1caa9c43 100644
--- a/fs/9p/vfs_file.c
+++ b/fs/9p/vfs_file.c
@@ -162,15 +162,17 @@ v9fs_file_write(struct file *filp, const char __user * data,
 
         fid = filp->private_data;
         ret = p9_client_uwrite(fid, data, *offset, count);
-        if (ret > 0)
+        if (ret > 0) {
+                invalidate_inode_pages2_range(inode->i_mapping, *offset,
+                                                                *offset+ret);
                 *offset += ret;
+        }
 
         if (*offset > inode->i_size) {
                 inode->i_size = *offset;
                 inode->i_blocks = (inode->i_size + 512 - 1) >> 9;
         }
 
-        invalidate_inode_pages2(inode->i_mapping);
         return ret;
 }
 
diff --git a/fs/9p/vfs_inode.c b/fs/9p/vfs_inode.c
index e5c45eed58a9..175b4d9bf3f8 100644
--- a/fs/9p/vfs_inode.c
+++ b/fs/9p/vfs_inode.c
@@ -59,7 +59,7 @@ static int unixmode2p9mode(struct v9fs_session_info *v9ses, int mode)
         res = mode & 0777;
         if (S_ISDIR(mode))
                 res |= P9_DMDIR;
-        if (v9ses->extended) {
+        if (v9fs_extended(v9ses)) {
                 if (S_ISLNK(mode))
                         res |= P9_DMSYMLINK;
                 if (v9ses->nodev == 0) {
@@ -99,21 +99,21 @@ static int p9mode2unixmode(struct v9fs_session_info *v9ses, int mode)
 
         if ((mode & P9_DMDIR) == P9_DMDIR)
                 res |= S_IFDIR;
-        else if ((mode & P9_DMSYMLINK) && (v9ses->extended))
+        else if ((mode & P9_DMSYMLINK) && (v9fs_extended(v9ses)))
                 res |= S_IFLNK;
-        else if ((mode & P9_DMSOCKET) && (v9ses->extended)
+        else if ((mode & P9_DMSOCKET) && (v9fs_extended(v9ses))
                  && (v9ses->nodev == 0))
                 res |= S_IFSOCK;
-        else if ((mode & P9_DMNAMEDPIPE) && (v9ses->extended)
+        else if ((mode & P9_DMNAMEDPIPE) && (v9fs_extended(v9ses))
                  && (v9ses->nodev == 0))
                 res |= S_IFIFO;
-        else if ((mode & P9_DMDEVICE) && (v9ses->extended)
+        else if ((mode & P9_DMDEVICE) && (v9fs_extended(v9ses))
                  && (v9ses->nodev == 0))
                 res |= S_IFBLK;
         else
                 res |= S_IFREG;
 
-        if (v9ses->extended) {
+        if (v9fs_extended(v9ses)) {
                 if ((mode & P9_DMSETUID) == P9_DMSETUID)
                         res |= S_ISUID;
 
@@ -214,7 +214,7 @@ struct inode *v9fs_get_inode(struct super_block *sb, int mode)
                 case S_IFBLK:
                 case S_IFCHR:
                 case S_IFSOCK:
-                        if(!v9ses->extended) {
+                        if (!v9fs_extended(v9ses)) {
                                 P9_DPRINTK(P9_DEBUG_ERROR,
                                       "special files without extended mode\n");
                                 return ERR_PTR(-EINVAL);
@@ -227,7 +227,7 @@ struct inode *v9fs_get_inode(struct super_block *sb, int mode)
                         inode->i_fop = &v9fs_file_operations;
                         break;
                 case S_IFLNK:
-                        if(!v9ses->extended) {
+                        if (!v9fs_extended(v9ses)) {
                                 P9_DPRINTK(P9_DEBUG_ERROR,
                                         "extended modes used w/o 9P2000.u\n");
                                 return ERR_PTR(-EINVAL);
@@ -236,7 +236,7 @@ struct inode *v9fs_get_inode(struct super_block *sb, int mode)
                         break;
                 case S_IFDIR:
                         inc_nlink(inode);
-                        if(v9ses->extended)
+                        if (v9fs_extended(v9ses))
                                 inode->i_op = &v9fs_dir_inode_operations_ext;
                         else
                                 inode->i_op = &v9fs_dir_inode_operations;
@@ -364,7 +364,7 @@ static int v9fs_remove(struct inode *dir, struct dentry *file, int rmdir)
         file_inode = file->d_inode;
         v9ses = v9fs_inode2v9ses(file_inode);
         v9fid = v9fs_fid_clone(file);
-        if(IS_ERR(v9fid))
+        if (IS_ERR(v9fid))
                 return PTR_ERR(v9fid);
 
         return p9_client_remove(v9fid);
@@ -398,7 +398,7 @@ v9fs_create(struct v9fs_session_info *v9ses, struct inode *dir,
         fid = NULL;
         name = (char *) dentry->d_name.name;
         dfid = v9fs_fid_clone(dentry->d_parent);
-        if(IS_ERR(dfid)) {
+        if (IS_ERR(dfid)) {
                 err = PTR_ERR(dfid);
                 dfid = NULL;
                 goto error;
@@ -432,7 +432,7 @@ v9fs_create(struct v9fs_session_info *v9ses, struct inode *dir,
                 goto error;
         }
 
-        if(v9ses->cache)
+        if (v9ses->cache)
                 dentry->d_op = &v9fs_cached_dentry_operations;
         else
                 dentry->d_op = &v9fs_dentry_operations;
@@ -593,7 +593,7 @@ static struct dentry *v9fs_vfs_lookup(struct inode *dir, struct dentry *dentry,
         if (result < 0)
                 goto error;
 
-        if((fid->qid.version)&&(v9ses->cache))
+        if ((fid->qid.version) && (v9ses->cache))
                 dentry->d_op = &v9fs_cached_dentry_operations;
         else
                 dentry->d_op = &v9fs_dentry_operations;
@@ -658,17 +658,17 @@ v9fs_vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
         old_inode = old_dentry->d_inode;
         v9ses = v9fs_inode2v9ses(old_inode);
         oldfid = v9fs_fid_lookup(old_dentry);
-        if(IS_ERR(oldfid))
+        if (IS_ERR(oldfid))
                 return PTR_ERR(oldfid);
 
         olddirfid = v9fs_fid_clone(old_dentry->d_parent);
-        if(IS_ERR(olddirfid)) {
+        if (IS_ERR(olddirfid)) {
                 retval = PTR_ERR(olddirfid);
                 goto done;
         }
 
         newdirfid = v9fs_fid_clone(new_dentry->d_parent);
-        if(IS_ERR(newdirfid)) {
+        if (IS_ERR(newdirfid)) {
                 retval = PTR_ERR(newdirfid);
                 goto clunk_olddir;
         }
@@ -682,7 +682,7 @@ v9fs_vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
         }
 
         v9fs_blank_wstat(&wstat);
-        wstat.muid = v9ses->name;
+        wstat.muid = v9ses->uname;
         wstat.name = (char *) new_dentry->d_name.name;
         retval = p9_client_wstat(oldfid, &wstat);
 
@@ -768,7 +768,7 @@ static int v9fs_vfs_setattr(struct dentry *dentry, struct iattr *iattr)
         if (iattr->ia_valid & ATTR_SIZE)
                 wstat.length = iattr->ia_size;
 
-        if (v9ses->extended) {
+        if (v9fs_extended(v9ses)) {
                 if (iattr->ia_valid & ATTR_UID)
                         wstat.n_uid = iattr->ia_uid;
 
@@ -805,10 +805,10 @@ v9fs_stat2inode(struct p9_stat *stat, struct inode *inode,
         inode->i_mtime.tv_sec = stat->mtime;
         inode->i_ctime.tv_sec = stat->mtime;
 
-        inode->i_uid = v9ses->uid;
-        inode->i_gid = v9ses->gid;
+        inode->i_uid = v9ses->dfltuid;
+        inode->i_gid = v9ses->dfltgid;
 
-        if (v9ses->extended) {
+        if (v9fs_extended(v9ses)) {
                 inode->i_uid = stat->n_uid;
                 inode->i_gid = stat->n_gid;
         }
@@ -887,10 +887,10 @@ static int v9fs_readlink(struct dentry *dentry, char *buffer, int buflen)
         retval = -EPERM;
         v9ses = v9fs_inode2v9ses(dentry->d_inode);
         fid = v9fs_fid_lookup(dentry);
-        if(IS_ERR(fid))
+        if (IS_ERR(fid))
                 return PTR_ERR(fid);
 
-        if (!v9ses->extended)
+        if (!v9fs_extended(v9ses))
                 return -EBADF;
 
         st = p9_client_stat(fid);
@@ -1011,7 +1011,7 @@ static int v9fs_vfs_mkspecial(struct inode *dir, struct dentry *dentry,
         struct p9_fid *fid;
 
         v9ses = v9fs_inode2v9ses(dir);
-        if (!v9ses->extended) {
+        if (!v9fs_extended(v9ses)) {
                 P9_DPRINTK(P9_DEBUG_ERROR, "not extended\n");
                 return -EPERM;
         }
@@ -1070,7 +1070,7 @@ v9fs_vfs_link(struct dentry *old_dentry, struct inode *dir,
                 old_dentry->d_name.name);
 
         oldfid = v9fs_fid_clone(old_dentry);
-        if(IS_ERR(oldfid))
+        if (IS_ERR(oldfid))
                 return PTR_ERR(oldfid);
 
         name = __getname();
diff --git a/fs/9p/vfs_super.c b/fs/9p/vfs_super.c
index ba904371218b..bb0cef9a6b8a 100644
--- a/fs/9p/vfs_super.c
+++ b/fs/9p/vfs_super.c
@@ -216,24 +216,7 @@ static int v9fs_show_options(struct seq_file *m, struct vfsmount *mnt)
 {
         struct v9fs_session_info *v9ses = mnt->mnt_sb->s_fs_info;
 
-        if (v9ses->debug != 0)
-                seq_printf(m, ",debug=%x", v9ses->debug);
-        if (v9ses->port != V9FS_PORT)
-                seq_printf(m, ",port=%u", v9ses->port);
-        if (v9ses->maxdata != 9000)
-                seq_printf(m, ",msize=%u", v9ses->maxdata);
-        if (v9ses->afid != ~0)
-                seq_printf(m, ",afid=%u", v9ses->afid);
-        if (v9ses->proto == PROTO_UNIX)
-                seq_puts(m, ",proto=unix");
-        if (v9ses->extended == 0)
-                seq_puts(m, ",noextend");
-        if (v9ses->nodev == 1)
-                seq_puts(m, ",nodevmap");
-        seq_printf(m, ",name=%s", v9ses->name);
-        seq_printf(m, ",aname=%s", v9ses->remotename);
-        seq_printf(m, ",uid=%u", v9ses->uid);
-        seq_printf(m, ",gid=%u", v9ses->gid);
+        seq_printf(m, "%s", v9ses->options);
         return 0;
 }