1 files changed, 200 insertions, 158 deletions

diff --git a/fs/hugetlbfs/inode.c b/fs/hugetlbfs/inode.c
index 32920a10100e..239c7ca09b74 100644
--- a/fs/hugetlbfs/inode.c
+++ b/fs/hugetlbfs/inode.c
@@ -27,7 +27,7 @@
 #include <linux/backing-dev.h>
 #include <linux/hugetlb.h>
 #include <linux/pagevec.h>
-#include <linux/parser.h>
+#include <linux/fs_parser.h>
 #include <linux/mman.h>
 #include <linux/slab.h>
 #include <linux/dnotify.h>
@@ -45,11 +45,17 @@ const struct file_operations hugetlbfs_file_operations;
 static const struct inode_operations hugetlbfs_dir_inode_operations;
 static const struct inode_operations hugetlbfs_inode_operations;
 
-struct hugetlbfs_config {
+enum hugetlbfs_size_type { NO_SIZE, SIZE_STD, SIZE_PERCENT };
+
+struct hugetlbfs_fs_context {
         struct hstate           *hstate;
+        unsigned long long      max_size_opt;
+        unsigned long long      min_size_opt;
         long                    max_hpages;
         long                    nr_inodes;
         long                    min_hpages;
+        enum hugetlbfs_size_type max_val_type;
+        enum hugetlbfs_size_type min_val_type;
         kuid_t                  uid;
         kgid_t                  gid;
         umode_t                 mode;
@@ -57,22 +63,30 @@ struct hugetlbfs_config {
 
 int sysctl_hugetlb_shm_group;
 
-enum {
-        Opt_size, Opt_nr_inodes,
-        Opt_mode, Opt_uid, Opt_gid,
-        Opt_pagesize, Opt_min_size,
-        Opt_err,
+enum hugetlb_param {
+        Opt_gid,
+        Opt_min_size,
+        Opt_mode,
+        Opt_nr_inodes,
+        Opt_pagesize,
+        Opt_size,
+        Opt_uid,
 };
 
-static const match_table_t tokens = {
-        {Opt_size,      "size=%s"},
-        {Opt_nr_inodes, "nr_inodes=%s"},
-        {Opt_mode,      "mode=%o"},
-        {Opt_uid,       "uid=%u"},
-        {Opt_gid,       "gid=%u"},
-        {Opt_pagesize,  "pagesize=%s"},
-        {Opt_min_size,  "min_size=%s"},
-        {Opt_err,       NULL},
+static const struct fs_parameter_spec hugetlb_param_specs[] = {
+        fsparam_u32   ("gid",           Opt_gid),
+        fsparam_string("min_size",      Opt_min_size),
+        fsparam_u32   ("mode",          Opt_mode),
+        fsparam_string("nr_inodes",     Opt_nr_inodes),
+        fsparam_string("pagesize",      Opt_pagesize),
+        fsparam_string("size",          Opt_size),
+        fsparam_u32   ("uid",           Opt_uid),
+        {}
+};
+
+static const struct fs_parameter_description hugetlb_fs_parameters = {
+        .name           = "hugetlbfs",
+        .specs          = hugetlb_param_specs,
 };
 
 #ifdef CONFIG_NUMA
@@ -708,16 +722,16 @@ static int hugetlbfs_setattr(struct dentry *dentry, struct iattr *attr)
 }
 
 static struct inode *hugetlbfs_get_root(struct super_block *sb,
-                                        struct hugetlbfs_config *config)
+                                        struct hugetlbfs_fs_context *ctx)
 {
         struct inode *inode;
 
         inode = new_inode(sb);
         if (inode) {
                 inode->i_ino = get_next_ino();
-                inode->i_mode = S_IFDIR | config->mode;
-                inode->i_uid = config->uid;
-                inode->i_gid = config->gid;
+                inode->i_mode = S_IFDIR | ctx->mode;
+                inode->i_uid = ctx->uid;
+                inode->i_gid = ctx->gid;
                 inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
                 inode->i_op = &hugetlbfs_dir_inode_operations;
                 inode->i_fop = &simple_dir_operations;
@@ -1081,8 +1095,6 @@ static const struct super_operations hugetlbfs_ops = {
         .show_options   = hugetlbfs_show_options,
 };
 
-enum hugetlbfs_size_type { NO_SIZE, SIZE_STD, SIZE_PERCENT };
-
 /*
  * Convert size option passed from command line to number of huge pages
  * in the pool specified by hstate.  Size option could be in bytes
@@ -1105,170 +1117,151 @@ hugetlbfs_size_to_hpages(struct hstate *h, unsigned long long size_opt,
         return size_opt;
 }
 
-static int
-hugetlbfs_parse_options(char *options, struct hugetlbfs_config *pconfig)
+/*
+ * Parse one mount parameter.
+ */
+static int hugetlbfs_parse_param(struct fs_context *fc, struct fs_parameter *param)
 {
-        char *p, *rest;
-        substring_t args[MAX_OPT_ARGS];
-        int option;
-        unsigned long long max_size_opt = 0, min_size_opt = 0;
-        enum hugetlbfs_size_type max_val_type = NO_SIZE, min_val_type = NO_SIZE;
-
-        if (!options)
+        struct hugetlbfs_fs_context *ctx = fc->fs_private;
+        struct fs_parse_result result;
+        char *rest;
+        unsigned long ps;
+        int opt;
+
+        opt = fs_parse(fc, &hugetlb_fs_parameters, param, &result);
+        if (opt < 0)
+                return opt;
+
+        switch (opt) {
+        case Opt_uid:
+                ctx->uid = make_kuid(current_user_ns(), result.uint_32);
+                if (!uid_valid(ctx->uid))
+                        goto bad_val;
                 return 0;
 
-        while ((p = strsep(&options, ",")) != NULL) {
-                int token;
-                if (!*p)
-                        continue;
+        case Opt_gid:
+                ctx->gid = make_kgid(current_user_ns(), result.uint_32);
+                if (!gid_valid(ctx->gid))
+                        goto bad_val;
+                return 0;
 
-                token = match_token(p, tokens, args);
-                switch (token) {
-                case Opt_uid:
-                        if (match_int(&args[0], &option))
-                                goto bad_val;
-                        pconfig->uid = make_kuid(current_user_ns(), option);
-                        if (!uid_valid(pconfig->uid))
-                                goto bad_val;
-                        break;
+        case Opt_mode:
+                ctx->mode = result.uint_32 & 01777U;
+                return 0;
 
-                case Opt_gid:
-                        if (match_int(&args[0], &option))
-                                goto bad_val;
-                        pconfig->gid = make_kgid(current_user_ns(), option);
-                        if (!gid_valid(pconfig->gid))
-                                goto bad_val;
-                        break;
+        case Opt_size:
+                /* memparse() will accept a K/M/G without a digit */
+                if (!isdigit(param->string[0]))
+                        goto bad_val;
+                ctx->max_size_opt = memparse(param->string, &rest);
+                ctx->max_val_type = SIZE_STD;
+                if (*rest == '%')
+                        ctx->max_val_type = SIZE_PERCENT;
+                return 0;
 
-                case Opt_mode:
-                        if (match_octal(&args[0], &option))
-                                goto bad_val;
-                        pconfig->mode = option & 01777U;
-                        break;
+        case Opt_nr_inodes:
+                /* memparse() will accept a K/M/G without a digit */
+                if (!isdigit(param->string[0]))
+                        goto bad_val;
+                ctx->nr_inodes = memparse(param->string, &rest);
+                return 0;
 
-                case Opt_size: {
-                        /* memparse() will accept a K/M/G without a digit */
-                        if (!isdigit(*args[0].from))
-                                goto bad_val;
-                        max_size_opt = memparse(args[0].from, &rest);
-                        max_val_type = SIZE_STD;
-                        if (*rest == '%')
-                                max_val_type = SIZE_PERCENT;
-                        break;
+        case Opt_pagesize:
+                ps = memparse(param->string, &rest);
+                ctx->hstate = size_to_hstate(ps);
+                if (!ctx->hstate) {
+                        pr_err("Unsupported page size %lu MB\n", ps >> 20);
+                        return -EINVAL;
                 }
+                return 0;
 
-                case Opt_nr_inodes:
-                        /* memparse() will accept a K/M/G without a digit */
+        case Opt_min_size:
+                /* memparse() will accept a K/M/G without a digit */