Merge branch 'work.mount' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs

Pull vfs mount infrastructure updates from Al Viro:
 "The rest of core infrastructure; no new syscalls in that pile, but the
  old parts are switched to new infrastructure. At that point
  conversions of individual filesystems can happen independently; some
  are done here (afs, cgroup, procfs, etc.), there's also a large series
  outside of that pile dealing with NFS (quite a bit of option-parsing
  stuff is getting used there - it's one of the most convoluted
  filesystems in terms of mount-related logics), but NFS bits are the
  next cycle fodder.

  It got seriously simplified since the last cycle; documentation is
  probably the weakest bit at the moment - I considered dropping the
  commit introducing Documentation/filesystems/mount_api.txt (cutting
  the size increase by quarter ;-), but decided that it would be better
  to fix it up after -rc1 instead.

  That pile allows to do followup work in independent branches, which
  should make life much easier for the next cycle. fs/super.c size
  increase is unpleasant; there's a followup series that allows to
  shrink it considerably, but I decided to leave that until the next
  cycle"

* 'work.mount' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs: (41 commits)
  afs: Use fs_context to pass parameters over automount
  afs: Add fs_context support
  vfs: Add some logging to the core users of the fs_context log
  vfs: Implement logging through fs_context
  vfs: Provide documentation for new mount API
  vfs: Remove kern_mount_data()
  hugetlbfs: Convert to fs_context
  cpuset: Use fs_context
  kernfs, sysfs, cgroup, intel_rdt: Support fs_context
  cgroup: store a reference to cgroup_ns into cgroup_fs_context
  cgroup1_get_tree(): separate "get cgroup_root to use" into a separate helper
  cgroup_do_mount(): massage calling conventions
  cgroup: stash cgroup_root reference into cgroup_fs_context
  cgroup2: switch to option-by-option parsing
  cgroup1: switch to option-by-option parsing
  cgroup: take options parsing into ->parse_monolithic()
  cgroup: fold cgroup1_mount() into cgroup1_get_tree()
  cgroup: start switching to fs_context
  ipc: Convert mqueue fs to fs_context
  proc: Add fs_context support to procfs
  ...

4 files changed, 304 insertions, 288 deletions

diff --git a/fs/afs/internal.h b/fs/afs/internal.h
index 8871b9e8645f..bb1f244b2b3a 100644
--- a/fs/afs/internal.h
+++ b/fs/afs/internal.h
@@ -36,15 +36,14 @@
 struct pagevec;
 struct afs_call;
 
-struct afs_mount_params {
-        bool                    rwpath;         /* T if the parent should be considered R/W */
+struct afs_fs_context {
         bool                    force;          /* T to force cell type */
         bool                    autocell;       /* T if set auto mount operation */
         bool                    dyn_root;       /* T if dynamic root */
+        bool                    no_cell;        /* T if the source is "none" (for dynroot) */
         afs_voltype_t           type;           /* type of volume requested */
-        int                     volnamesz;      /* size of volume name */
+        unsigned int            volnamesz;      /* size of volume name */
         const char              *volname;       /* name of volume to mount */
-        struct net              *net_ns;        /* Network namespace in effect */
         struct afs_net          *net;           /* the AFS net namespace stuff */
         struct afs_cell         *cell;          /* cell in which to find volume */
         struct afs_volume       *volume;        /* volume record */
@@ -1274,7 +1273,7 @@ static inline struct afs_volume *__afs_get_volume(struct afs_volume *volume)
         return volume;
 }
 
-extern struct afs_volume *afs_create_volume(struct afs_mount_params *);
+extern struct afs_volume *afs_create_volume(struct afs_fs_context *);
 extern void afs_activate_volume(struct afs_volume *);
 extern void afs_deactivate_volume(struct afs_volume *);
 extern void afs_put_volume(struct afs_cell *, struct afs_volume *);
diff --git a/fs/afs/mntpt.c b/fs/afs/mntpt.c
index 2e51c6994148..eecd8b699186 100644
--- a/fs/afs/mntpt.c
+++ b/fs/afs/mntpt.c
@@ -17,6 +17,7 @@
 #include <linux/mount.h>
 #include <linux/namei.h>
 #include <linux/gfp.h>
+#include <linux/fs_context.h>
 #include "internal.h"
 
 
@@ -47,6 +48,8 @@ static DECLARE_DELAYED_WORK(afs_mntpt_expiry_timer, afs_mntpt_expiry_timed_out);
 
 static unsigned long afs_mntpt_expiry_timeout = 10 * 60;
 
+static const char afs_root_volume[] = "root.cell";
+
 /*
  * no valid lookup procedure on this sort of dir
  */
@@ -68,108 +71,112 @@ static int afs_mntpt_open(struct inode *inode, struct file *file)
 }
 
 /*
- * create a vfsmount to be automounted
+ * Set the parameters for the proposed superblock.
  */
-static struct vfsmount *afs_mntpt_do_automount(struct dentry *mntpt)
+static int afs_mntpt_set_params(struct fs_context *fc, struct dentry *mntpt)
 {
-        struct afs_super_info *as;
-        struct vfsmount *mnt;
-        struct afs_vnode *vnode;
-        struct page *page;
-        char *devname, *options;
-        bool rwpath = false;
+        struct afs_fs_context *ctx = fc->fs_private;
+        struct afs_super_info *src_as = AFS_FS_S(mntpt->d_sb);
+        struct afs_vnode *vnode = AFS_FS_I(d_inode(mntpt));
+        struct afs_cell *cell;
+        const char *p;
         int ret;
 
-        _enter("{%pd}", mntpt);
-
-        BUG_ON(!d_inode(mntpt));
-
-        ret = -ENOMEM;
-        devname = (char *) get_zeroed_page(GFP_KERNEL);
-        if (!devname)
-                goto error_no_devname;
-
-        options = (char *) get_zeroed_page(GFP_KERNEL);
-        if (!options)
-                goto error_no_options;
+        if (fc->net_ns != src_as->net_ns) {
+                put_net(fc->net_ns);
+                fc->net_ns = get_net(src_as->net_ns);
+        }
 
-        vnode = AFS_FS_I(d_inode(mntpt));
+        if (src_as->volume && src_as->volume->type == AFSVL_RWVOL) {
+                ctx->type = AFSVL_RWVOL;
+                ctx->force = true;
+        }
+        if (ctx->cell) {
+                afs_put_cell(ctx->net, ctx->cell);
+                ctx->cell = NULL;
+        }
         if (test_bit(AFS_VNODE_PSEUDODIR, &vnode->flags)) {
                 /* if the directory is a pseudo directory, use the d_name */
-                static const char afs_root_cell[] = ":root.cell.";
                 unsigned size = mntpt->d_name.len;
 
-                ret = -ENOENT;
-                if (size < 2 || size > AFS_MAXCELLNAME)
-                        goto error_no_page;
+                if (size < 2)
+                        return -ENOENT;
 
+                p = mntpt->d_name.name;
                 if (mntpt->d_name.name[0] == '.') {
-                        devname[0] = '%';
-                        memcpy(devname + 1, mntpt->d_name.name + 1, size - 1);
-                        memcpy(devname + size, afs_root_cell,
-                               sizeof(afs_root_cell));
-                        rwpath = true;
-                } else {
-                        devname[0] = '#';
-                        memcpy(devname + 1, mntpt->d_name.name, size);
-                        memcpy(devname + size + 1, afs_root_cell,
-                               sizeof(afs_root_cell));
+                        size--;
+                        p++;
+                        ctx->type = AFSVL_RWVOL;
+                        ctx->force = true;
                 }
+                if (size > AFS_MAXCELLNAME)
+                        return -ENAMETOOLONG;
+
+                cell = afs_lookup_cell(ctx->net, p, size, NULL, false);
+                if (IS_ERR(cell)) {
+                        pr_err("kAFS: unable to lookup cell '%pd'\n", mntpt);
+                        return PTR_ERR(cell);
+                }
+                ctx->cell = cell;
+
+                ctx->volname = afs_root_volume;
+                ctx->volnamesz = sizeof(afs_root_volume) - 1;
         } else {
                 /* read the contents of the AFS special symlink */
+                struct page *page;
                 loff_t size = i_size_read(d_inode(mntpt));
                 char *buf;
 
-                ret = -EINVAL;
+                if (src_as->cell)
+                        ctx->cell = afs_get_cell(src_as->cell);
+
                 if (size > PAGE_SIZE - 1)
-                        goto error_no_page;
+                        return -EINVAL;
 
                 page = read_mapping_page(d_inode(mntpt)->i_mapping, 0, NULL);
-                if (IS_ERR(page)) {
-                        ret = PTR_ERR(page);
-                        goto error_no_page;
-                }
+                if (IS_ERR(page))
+                        return PTR_ERR(page);
 
                 if (PageError(page)) {
                         ret = afs_bad(AFS_FS_I(d_inode(mntpt)), afs_file_error_mntpt);
-                        goto error;
+                        put_page(page);
+                        return ret;
                 }
 
-                buf = kmap_atomic(page);
-                memcpy(devname, buf, size);
-                kunmap_atomic(buf);
+                buf = kmap(page);
+                ret = vfs_parse_fs_string(fc, "source", buf, size);
+                kunmap(page);
                 put_page(page);
-                page = NULL;
+                if (ret < 0)
+                        return ret;
         }
 
-        /* work out what options we want */
-        as = AFS_FS_S(mntpt->d_sb);
-        if (as->cell) {
-                memcpy(options, "cell=", 5);
-                strcpy(options + 5, as->cell->name);
-                if ((as->volume && as->volume->type == AFSVL_RWVOL) || rwpath)
-                        strcat(options, ",rwpath");
-        }
+        return 0;
+}
 
-        /* try and do the mount */
-        _debug("--- attempting mount %s -o %s ---", devname, options);
-        mnt = vfs_submount(mntpt, &afs_fs_type, devname, options);
-        _debug("--- mount result %p ---", mnt);
+/*
+ * create a vfsmount to be automounted
+ */
+static struct vfsmount *afs_mntpt_do_automount(struct dentry *mntpt)
+{
+        struct fs_context *fc;
+        struct vfsmount *mnt;
+        int ret;
 
-        free_page((unsigned long) devname);
-        free_page((unsigned long) options);
-        _leave(" = %p", mnt);
-        return mnt;
+        BUG_ON(!d_inode(mntpt));
 
-error:
-        put_page(page);
-error_no_page:
-        free_page((unsigned long) options);
-error_no_options:
-        free_page((unsigned long) devname);
-error_no_devname:
-        _leave(" = %d", ret);
-        return ERR_PTR(ret);
+        fc = fs_context_for_submount(&afs_fs_type, mntpt);
+        if (IS_ERR(fc))
+                return ERR_CAST(fc);
+
+        ret = afs_mntpt_set_params(fc, mntpt);
+        if (!ret)
+                mnt = fc_mount(fc);
+        else
+                mnt = ERR_PTR(ret);
+
+        put_fs_context(fc);
+        return mnt;
 }
 
 /*
diff --git a/fs/afs/super.c b/fs/afs/super.c
index e684f6769b15..5adf012b8e27 100644
--- a/fs/afs/super.c
+++ b/fs/afs/super.c
@@ -1,6 +1,6 @@
 /* AFS superblock handling
  *
- * Copyright (c) 2002, 2007 Red Hat, Inc. All rights reserved.
+ * Copyright (c) 2002, 2007, 2018 Red Hat, Inc. All rights reserved.
  *
  * This software may be freely redistributed under the terms of the
  * GNU General Public License.
@@ -21,7 +21,7 @@
 #include <linux/slab.h>
 #include <linux/fs.h>
 #include <linux/pagemap.h>
-#include <linux/parser.h>
+#include <linux/fs_parser.h>
 #include <linux/statfs.h>
 #include <linux/sched.h>
 #include <linux/nsproxy.h>
@@ -30,21 +30,22 @@
 #include "internal.h"
 
 static void afs_i_init_once(void *foo);
-static struct dentry *afs_mount(struct file_system_type *fs_type,
-                      int flags, const char *dev_name, void *data);
 static void afs_kill_super(struct super_block *sb);
 static struct inode *afs_alloc_inode(struct super_block *sb);
 static void afs_destroy_inode(struct inode *inode);
 static int afs_statfs(struct dentry *dentry, struct kstatfs *buf);
 static int afs_show_devname(struct seq_file *m, struct dentry *root);
 static int afs_show_options(struct seq_file *m, struct dentry *root);
+static int afs_init_fs_context(struct fs_context *fc);
+static const struct fs_parameter_description afs_fs_parameters;
 
 struct file_system_type afs_fs_type = {
-        .owner          = THIS_MODULE,
-        .name           = "afs",
-        .mount          = afs_mount,
-        .kill_sb        = afs_kill_super,
-        .fs_flags       = 0,
+        .owner                  = THIS_MODULE,
+        .name                   = "afs",
+        .init_fs_context        = afs_init_fs_context,
+        .parameters             = &afs_fs_parameters,
+        .kill_sb                = afs_kill_super,
+        .fs_flags               = 0,
 };
 MODULE_ALIAS_FS("afs");
 
@@ -63,22 +64,22 @@ static const struct super_operations afs_super_ops = {
 static struct kmem_cache *afs_inode_cachep;
 static atomic_t afs_count_active_inodes;
 
-enum {
-        afs_no_opt,
-        afs_opt_cell,
-        afs_opt_dyn,
-        afs_opt_rwpath,
-        afs_opt_vol,
-        afs_opt_autocell,
+enum afs_param {
+        Opt_autocell,
+        Opt_dyn,
+        Opt_source,
 };
 
-static const match_table_t afs_options_list = {
-        { afs_opt_cell,         "cell=%s"       },
-        { afs_opt_dyn,          "dyn"           },
-        { afs_opt_rwpath,       "rwpath"        },
-        { afs_opt_vol,          "vol=%s"        },
-        { afs_opt_autocell,     "autocell"      },
-        { afs_no_opt,           NULL            },
+static const struct fs_parameter_spec afs_param_specs[] = {
+        fsparam_flag  ("autocell",      Opt_autocell),
+        fsparam_flag  ("dyn",           Opt_dyn),
+        fsparam_string("source",        Opt_source),
+        {}
+};
+
+static const struct fs_parameter_description afs_fs_parameters = {
+        .name           = "kAFS",
+        .specs          = afs_param_specs,
 };
 
 /*
@@ -190,84 +191,23 @@ static int afs_show_options(struct seq_file *m, struct dentry *root)
 }
 
 /*
- * parse the mount options
- * - this function has been shamelessly adapted from the ext3 fs which
- *   shamelessly adapted it from the msdos fs
- */
-static int afs_parse_options(struct afs_mount_params *params,
-                             char *options, const char **devname)
-{
-        struct afs_cell *cell;
-        substring_t args[MAX_OPT_ARGS];
-        char *p;
-        int token;
-
-        _enter("%s", options);
-
-        options[PAGE_SIZE - 1] = 0;
-
-        while ((p = strsep(&options, ","))) {
-                if (!*p)
-                        continue;
-
-                token = match_token(p, afs_options_list, args);
-                switch (token) {
-                case afs_opt_cell:
-                        rcu_read_lock();
-                        cell = afs_lookup_cell_rcu(params->net,
-                                                   args[0].from,
-                                                   args[0].to - args[0].from);
-                        rcu_read_unlock();
-                        if (IS_ERR(cell))
-                                return PTR_ERR(cell);
-                        afs_put_cell(params->net, params->cell);
-                        params->cell = cell;
-                        break;
-
-                case afs_opt_rwpath:
-                        params->rwpath = true;
-                        break;
-
-                case afs_opt_vol:
-                        *devname = args[0].from;
-                        break;
-
-                case afs_opt_autocell:
-                        params->autocell = true;
-                        break;
-
-                case afs_opt_dyn:
-                        params->dyn_root = true;
-                        break;
-
-                default:
-                        printk(KERN_ERR "kAFS:"
-                               " Unknown or invalid mount option: '%s'\n", p);
-                        return -EINVAL;
-                }
-        }
-
-        _leave(" = 0");
-        return 0;
-}
-
-/*
- * parse a device name to get cell name, volume name, volume type and R/W
- * selector
- * - this can be one of the following:
+ * Parse the source name to get cell name, volume name, volume type and R/W
+ * selector.
+ *
+ * This can be one of the following:
  *      "%[cell:]volume[.]"             R/W volume
- *      "#[cell:]volume[.]"             R/O or R/W volume (rwpath=0),
- *                                       or R/W (rwpath=1) volume
+ *      "#[cell:]volume[.]"             R/O or R/W volume (R/O parent),
+ *                                       or R/W (R/W parent) volume
  *      "%[cell:]volume.readonly"       R/O volume
  *      "#[cell:]volume.readonly"       R/O volume
  *      "%[cell:]volume.backup"         Backup volume
  *      "#[cell:]volume.backup"         Backup volume
  */
-static int afs_parse_device_name(struct afs_mount_params *params,
-                                 const char *name)
+static int afs_parse_source(struct fs_context *fc, struct fs_parameter *param)
 {
+        struct afs_fs_context *ctx = fc->fs_private;
         struct afs_cell *cell;
-        const char *cellname, *suffix;
+        const char *cellname, *suffix, *name = param->string;
         int cellnamesz;
 
         _enter(",%s", name);
@@ -278,69 +218,149 @@ static int afs_parse_device_name(struct afs_mount_params *params,
         }
 
         if ((name[0] != '%' && name[0] != '#') || !name[1]) {
+                /* To use dynroot, we don't want to have to provide a source */
+                if (strcmp(name, "none") == 0) {
+                        ctx->no_cell = true;
+                        return 0;
+                }
                 printk(KERN_ERR "kAFS: unparsable volume name\n");
                 return -EINVAL;
         }
 
         /* determine the type of volume we're looking for */
-        params->type = AFSVL_ROVOL;
-        params->force = false;
-        if (params->rwpath || name[0] == '%') {
-                params->type = AFSVL_RWVOL;
-                params->force = true;
+        if (name[0] == '%') {
+                ctx->type = AFSVL_RWVOL;
+                ctx->force = true;
         }
         name++;
 
         /* split the cell name out if there is one */
-        params->volname = strchr(name, ':');
-        if (params->volname) {
+        ctx->volname = strchr(name, ':');
+        if (ctx->volname) {
                 cellname = name;
-                cellnamesz = params->volname - name;
-                params->volname++;
+                cellnamesz = ctx->volname - name;
+                ctx->volname++;
         } else {
-                params->volname = name;
+                ctx->volname = name;
                 cellname = NULL;
                 cellnamesz = 0;
         }
 
         /* the volume type is further affected by a possible suffix */
-        suffix = strrchr(params->volname, '.');
+        suffix = strrchr(ctx->volname, '.');
         if (suffix) {
                 if (strcmp(suffix, ".readonly") == 0) {
-                        params->type = AFSVL_ROVOL;
-                        params->force = true;
+                        ctx->type = AFSVL_ROVOL;
+                        ctx->force = true;
                 } else if (strcmp(suffix, ".backup") == 0) {
-                        params->type = AFSVL_BACKVOL;
-                        params->force = true;
+                        ctx->type = AFSVL_BACKVOL;
+                        ctx->force = true;
                 } else if (suffix[1] == 0) {
                 } else {
                         suffix = NULL;
                 }
         }
 
-        params->volnamesz = suffix ?
-                suffix - params->volname : strlen(params->volname);
+        ctx->volnamesz = suffix ?
+                suffix - ctx->volname : strlen(ctx->volname);
 
         _debug("cell %*.*s [%p]",
-               cellnamesz, cellnamesz, cellname ?: "", params->cell);
+               cellnamesz, cellnamesz, cellname ?: "", ctx->cell);
 
         /* lookup the cell record */
-        if (cellname || !params->cell) {
-                cell = afs_lookup_cell(params->net, cellname, cellnamesz,
+        if (cellname) {
+                cell = afs_lookup_cell(ctx->net, cellname, cellnamesz,
                                        NULL, false);
                 if (IS_ERR(cell)) {
-                        printk(KERN_ERR "kAFS: unable to lookup cell '%*.*s'\n",
+                        pr_err("kAFS: unable to lookup cell '%*.*s'\n",
                                cellnamesz, cellnamesz, cellname ?: "");
                         return PTR_ERR(cell);
                 }
-                afs_put_cell(params->net, params->cell);
-                params->cell = cell;
+                afs_put_cell(ctx->net, ctx->cell);
+                ctx->cell = cell;
         }
 
         _debug("CELL:%s [%p] VOLUME:%*.*s SUFFIX:%s TYPE:%d%s",
-               params->cell->name, params->cell,
-               params->volnamesz, params->volnamesz, params->volname,
-               suffix ?: "-", params->type, params->force ? " FORCE" : "");
+               ctx->cell->name, ctx->cell,
+               ctx->volnamesz, ctx->volnamesz, ctx->volname,
+               suffix ?: "-", ctx->type, ctx->force ? " FORCE" : "");
+
+        fc->source = param->string;
+        param->string = NULL;
+        return 0;
+}
+
+/*
+ * Parse a single mount parameter.
+ */
+static int afs_parse_param(struct fs_context *fc, struct fs_parameter *param)
+{
+        struct fs_parse_result result;
+        struct afs_fs_context *ctx = fc->fs_private;
+        int opt;
+
+        opt = fs_parse(fc, &afs_fs_parameters, param, &result);
+        if (opt < 0)
+                return opt;
+
+        switch (opt) {
+        case Opt_source:
+                return afs_parse_source(fc, param);
+
+        case Opt_autocell:
+                ctx->autocell = true;
+                break;
+
+        case Opt_dyn:
+                ctx->dyn_root = true;
+                break;
+
+        default:
+                return -EINVAL;
+        }
+
+        _leave(" = 0");
+        return 0;
+}
+
+/*
+ * Validate the options, get the cell key and look up the volume.
+ */
+static int afs_validate_fc(struct fs_context *fc)
+{
+        struct afs_fs_context *ctx = fc->fs_private;
+        struct afs_volume *volume;
+        struct key *key;
+
+        if (!ctx->dyn_root) {
+                if (ctx->no_cell) {
+                        pr_warn("kAFS: Can only specify source 'none' with -o dyn\n");
+                        return -EINVAL;
+                }
+
+                if (!ctx->cell) {
+                        pr_warn("kAFS: No cell specified\n");
+                        return -EDESTADDRREQ;
+                }
+
+                /* We try to do the mount securely. */
+                key = afs_request_key(ctx->cell);
+                if (IS_ERR(key))
+                        return PTR_ERR(key);
+
+                ctx->key = key;
+
+                if (ctx->volume) {
+                        afs_put_volume(ctx->cell, ctx->volume);
+                        ctx->volume = NULL;
+                }
+
+                volume = afs_create_volume(ctx);
+                if (IS_ERR(volume))
+                        return PTR_ERR(volume);
+
+                ctx->volume = volume;
+        }
 
         return 0;
 }
@@ -348,39 +368,34 @@ static int afs_parse_device_name(struct afs_mount_params *params,
 /*
  * check a superblock to see if it's the one we're looking for
  */
-static int afs_test_super(struct super_block *sb, void *data)
+static int afs_test_super(struct super_block *sb, struct fs_context *fc)
 {
-        struct afs_super_info *as1 = data;
+        struct afs_fs_context *ctx = fc->fs_private;
         struct afs_super_info *as = AFS_FS_S(sb);
 
-        return (as->net_ns == as1->net_ns &&
+        return (as->net_ns == fc->net_ns &&
                 as->volume &&
-                as->volume->vid == as1->volume->vid &&
+                as->volume->vid == ctx->volume->vid &&
                 !as->dyn_root);
 }
 
-static int afs_dynroot_test_super(struct super_block *sb, void *data)
+static int afs_dynroot_test_super(struct super_block *sb, struct fs_context *fc)
 {
-        struct afs_super_info *as1 = data;
         struct afs_super_info *as = AFS_FS_S(sb);
 
-        return (as->net_ns == as1->net_ns &&
+        return (as->net_ns == fc->net_ns &&
                 as->dyn_root);
 }
 
-static int afs_set_super(struct super_block *sb, void *data)
+static int afs_set_super(struct super_block *sb, struct fs_context *fc)
 {
-        struct afs_super_info *as = data;
-
-        sb->s_fs_info = as;
         return set_anon_super(sb, NULL);
 }
 
 /*
  * fill in the superblock
  */
-static int afs_fill_super(struct super_block *sb,
-                          struct afs_mount_params *params)
+static int afs_fill_super(struct super_block *sb, struct afs_fs_context *ctx)
 {
         struct afs_super_info *as = AFS_FS_S(sb);
         struct afs_fid fid;
@@ -412,13 +427,13 @@ static int afs_fill_super(struct super_block *sb,
                 fid.vnode       = 1;
                 fid.vnode_hi    = 0;
                 fid.unique      = 1;
-                inode = afs_iget(sb, params->key, &fid, NULL, NULL, NULL);
+                inode = afs_iget(sb, ctx->key, &fid, NULL, NULL, NULL);
         }
 
         if (IS_ERR(inode))
                 return PTR_ERR(inode);
 
-        if (params->autocell || params->dyn_root)
+        if (ctx->autocell || as->dyn_root)
                 set_bit(AFS_VNODE_AUTOCELL, &AFS_FS_I(inode)->flags);
 
         ret = -ENOMEM;
@@ -443,17 +458,20 @@ error:
         return ret;
 }
 
-static struct afs_super_info *afs_alloc_sbi(struct afs_mount_params *params)
+static struct afs_super_info *afs_alloc_sbi(struct fs_context *fc)
 {
+        struct afs_fs_context *ctx = fc->fs_private;
         struct afs_super_info *as;
 
         as = kzalloc(sizeof(struct afs_super_info), GFP_KERNEL);
         if (as) {
-                as->net_ns = get_net(params->net_ns);
-                if (params->dyn_root)
+                as->net_ns = get_net(fc->net_ns);
+                if (ctx->dyn_root) {
                         as->dyn_root = true;
-                else
-                        as->cell = afs_get_cell(params->cell);
+                } else {
+                        as->cell = afs_get_cell(ctx->cell);
+                        as->volume = __afs_get_volume(ctx->volume);
+                }
         }
         return as;
 }
@@ -475,7 +493,7 @@ static void afs_kill_super(struct super_block *sb)
 
         if (as->dyn_root)
                 afs_dynroot_depopulate(sb);
-        
+
         /* Clear the callback interests (which will do ilookup5) before
          * deactivating the superblock.
          */
@@ -488,111 +506,103 @@ static void afs_kill_super(struct super_block *sb)
 }
 
 /*
- * get an AFS superblock
+ * Get an AFS superblock and root directory.
  */
-static struct dentry *afs_mount(struct file_system_type *fs_type,
-                                int flags, const char *dev_name, void *options)
+static int afs_get_tree(struct fs_context *fc)
 {
-        struct afs_mount_params params;
+        struct afs_fs_context *ctx = fc->fs_private;
         struct super_block *sb;
-        struct afs_volume *candidate;
-        struct key *key;
         struct afs_super_info *as;
         int ret;
 
-        _enter(",,%s,%p", dev_name, options);
-
-        memset(&params, 0, sizeof(params));
-
-        ret = -EINVAL;
-        if (current->nsproxy->net_ns != &init_net)
+        ret = afs_validate_fc(fc);
+        if (ret)
                 goto error;
-        params.net_ns = current->nsproxy->net_ns;
-        params.net = afs_net(params.net_ns);
-        
-        /* parse the options and device name */
-        if (options) {
-                ret = afs_parse_options(&params, options, &dev_name);
-                if (ret < 0)
-                        goto error;
-        }
-
-        if (!params.dyn_root) {
-                ret = afs_parse_device_name(&params, dev_name);
-                if (ret < 0)
-                        goto error;
 
-                /* try and do the mount securely */
-                key = afs_request_key(params.cell);
-                if (IS_ERR(key)) {
-                        _leave(" = %ld [key]", PTR_ERR(key));
-                        ret = PTR_ERR(key);
-                        goto error;
-                }
-                params.key = key;
-        }
+        _enter("");
 
         /* allocate a superblock info record */
         ret = -ENOMEM;
-        as = afs_alloc_sbi(&params);
+        as = afs_alloc_sbi(fc);
         if (!as)
-                goto error_key;
-
-        if (!params.dyn_root) {
-                /* Assume we're going to need a volume record; at the very
-                 * least we can use it to update the volume record if we have
-                 * one already.  This checks that the volume exists within the
-                 * cell.
-                 */
-                candidate = afs_create_volume(&params);
-                if (IS_ERR(candidate)) {
-                        ret = PTR_ERR(candidate);
-                        goto error_as;
-                }
-
-                as->volume = candidate;
-        }
+                goto error;
+        fc->s_fs_info = as;
 
         /* allocate a deviceless superblock */
-        sb = sget(fs_type,
-                  as->dyn_root ? afs_dynroot_test_super : afs_test_super,
-                  afs_set_super, flags, as);
+        sb = sget_fc(fc,
+                     as->dyn_root ? afs_dynroot_test_super : afs_test_super,
+                     afs_set_super);
         if (IS_ERR(sb)) {
                 ret = PTR_ERR(sb);
-                goto error_as;
+                goto error;
         }
 
         if (!sb->s_root) {
                 /* initial superblock/root creation */
                 _debug("create");
-                ret = afs_fill_super(sb, &params);
+                ret = afs_fill_super(sb, ctx);
                 if (ret < 0)
                         goto error_sb;
-                as = NULL;
                 sb->s_flags |= SB_ACTIVE;
         } else {
                 _debug("reuse");
                 ASSERTCMP(sb->s_flags, &, SB_ACTIVE);
-                afs_destroy_sbi(as);
-                as = NULL;
         }
 
-        afs_put_cell(params.net, params.cell);
-        key_put(params.key);
+        fc->root = dget(sb->s_root);
         _leave(" = 0 [%p]", sb);
-        return dget(sb->s_root);
+        return 0;
 
 error_sb:
         deactivate_locked_super(sb);
-        goto error_key;
-error_as:
-        afs_destroy_sbi(as);
-error_key:
-        key_put(params.key);
 error:
-        afs_put_cell(params.net, params.cell);
         _leave(" = %d", ret);
-        return ERR_PTR(ret);
+        return ret;
+}
+
+static void afs_free_fc(struct fs_context *fc)
+{
+        struct afs_fs_context *ctx = fc->fs_private;
+
+        afs_destroy_sbi(fc->s_fs_info);
+        afs_put_volume(ctx->cell, ctx->volume);
+        afs_put_cell(ctx->net, ctx->cell);
+        key_put(ctx->key);
+        kfree(ctx);
+}
+
+static const struct fs_context_operations afs_context_ops = {
+        .free           = afs_free_fc,
+        .parse_param    = afs_parse_param,
+        .get_tree       = afs_get_tree,
+};
+
+/*
+ * Set up the filesystem mount context.
+ */
+static int afs_init_fs_context(struct fs_context *fc)
+{
+        struct afs_fs_context *ctx;
+        struct afs_cell *cell;
+
+        ctx = kzalloc(sizeof(struct afs_fs_context), GFP_KERNEL);
+        if (!ctx)
+                return -ENOMEM;
+
+        ctx->type = AFSVL_ROVOL;
+        ctx->net = afs_net(fc->net_ns);
+
+        /* Default to the workstation cell. */
+        rcu_read_lock();
+        cell = afs_lookup_cell_rcu(ctx->net, NULL, 0);
+        rcu_read_unlock();
+        if (IS_ERR(cell))
+                cell = NULL;
+        ctx->cell = cell;
+
+        fc->fs_private = ctx;
+        fc->ops = &afs_context_ops;
+        return 0;
 }
 
 /*
diff --git a/fs/afs/volume.c b/fs/afs/volume.c
index 00975ed3640f..f6eba2def0a1 100644
--- a/fs/afs/volume.c
+++ b/fs/afs/volume.c
@@ -21,7 +21,7 @@ static const char *const afs_voltypes[] = { "R/W", "R/O", "BAK" };
 /*
  * Allocate a volume record and load it up from a vldb record.
  */
-static struct afs_volume *afs_alloc_volume(struct afs_mount_params *params,
+static struct afs_volume *afs_alloc_volume(struct afs_fs_context *params,
                                            struct afs_vldb_entry *vldb,
                                            unsigned long type_mask)
 {
@@ -113,7 +113,7 @@ static struct afs_vldb_entry *afs_vl_lookup_vldb(struct afs_cell *cell,
  * - Rule 3: If parent volume is R/W, then only mount R/W volume unless
  *           explicitly told otherwise
  */
-struct afs_volume *afs_create_volume(struct afs_mount_params *params)
+struct afs_volume *afs_create_volume(struct afs_fs_context *params)
 {
         struct afs_vldb_entry *vldb;
         struct afs_volume *volume;