[15/43] vfs: Add configuration parser helpers

Because the new API passes in key,value parameters, match_token() cannot be
used with it.  Instead, provide three new helpers to aid with parsing:

 (1) fs_parse().  This takes a parameter and a simple static description of
     all the parameters and maps the key name to an ID.  It returns 1 on a
     match, 0 on no match if unknowns should be ignored and some other
     negative error code on a parse error.

     The parameter description includes a list of key names to IDs, desired
     parameter types and a list of enumeration name -> ID mappings.

     [!] Note that for the moment I've required that the key->ID mapping
     array is expected to be sorted and unterminated.  The size of the
     array is noted in the fsconfig_parser struct.  This allows me to use
     bsearch(), but I'm not sure any performance gain is worth the hassle
     of requiring people to keep the array sorted.

     The parameter type array is sized according to the number of parameter
     IDs and is indexed directly.  The optional enum mapping array is an
     unterminated, unsorted list and the size goes into the fsconfig_parser
     struct.

     The function can do some additional things:

	(a) If it's not ambiguous and no value is given, the prefix "no" on
	    a key name is permitted to indicate that the parameter should
	    be considered negatory.

	(b) If the desired type is a single simple integer, it will perform
	    an appropriate conversion and store the result in a union in
	    the parse result.

	(c) If the desired type is an enumeration, {key ID, name} will be
	    looked up in the enumeration list and the matching value will
	    be stored in the parse result union.

	(d) Optionally generate an error if the key is unrecognised.

     This is called something like:

	enum rdt_param {
		Opt_cdp,
		Opt_cdpl2,
		Opt_mba_mpbs,
		nr__rdt_params
	};

	const struct fs_parameter_spec rdt_param_specs[nr__rdt_params] = {
		[Opt_cdp]	= { fs_param_is_bool },
		[Opt_cdpl2]	= { fs_param_is_bool },
		[Opt_mba_mpbs]	= { fs_param_is_bool },
	};

	const const char *const rdt_param_keys[nr__rdt_params] = {
		[Opt_cdp]	= "cdp",
		[Opt_cdpl2]	= "cdpl2",
		[Opt_mba_mpbs]	= "mba_mbps",
	};

	const struct fs_parameter_description rdt_parser = {
		.name		= "rdt",
		.nr_params	= nr__rdt_params,
		.keys		= rdt_param_keys,
		.specs		= rdt_param_specs,
		.no_source	= true,
	};

	int rdt_parse_param(struct fs_context *fc,
			    struct fs_parameter *param)
	{
		struct fs_parse_result parse;
		struct rdt_fs_context *ctx = rdt_fc2context(fc);
		int ret;

		ret = fs_parse(fc, &rdt_parser, param, &parse);
		if (ret < 0)
			return ret;

		switch (parse.key) {
		case Opt_cdp:
			ctx->enable_cdpl3 = true;
			return 0;
		case Opt_cdpl2:
			ctx->enable_cdpl2 = true;
			return 0;
		case Opt_mba_mpbs:
			ctx->enable_mba_mbps = true;
			return 0;
		}

		return -EINVAL;
	}

 (2) fs_lookup_param().  This takes a { dirfd, path, LOOKUP_EMPTY? } or
     string value and performs an appropriate path lookup to convert it
     into a path object, which it will then return.

     If the desired type was a blockdev, the type of the looked up inode
     will be checked to make sure it is one.

     This can be used like:

	enum foo_param {
		Opt_source,
		nr__foo_params
	};

	const struct fs_parameter_spec foo_param_specs[nr__foo_params] = {
		[Opt_source]	= { fs_param_is_blockdev },
	};

	const char *char foo_param_keys[nr__foo_params] = {
		[Opt_source]	= "source",
	};

	const struct constant_table foo_param_alt_keys[] = {
		{ "device",	Opt_source },
	};

	const struct fs_parameter_description foo_parser = {
		.name		= "foo",
		.nr_params	= nr__foo_params,
		.nr_alt_keys	= ARRAY_SIZE(foo_param_alt_keys),
		.keys		= foo_param_keys,
		.alt_keys	= foo_param_alt_keys,
		.specs		= foo_param_specs,
	};

	int foo_parse_param(struct fs_context *fc,
			    struct fs_parameter *param)
	{
		struct fs_parse_result parse;
		struct foo_fs_context *ctx = foo_fc2context(fc);
		int ret;

		ret = fs_parse(fc, &foo_parser, param, &parse);
		if (ret < 0)
			return ret;

		switch (parse.key) {
		case Opt_source:
			return fs_lookup_param(fc, &foo_parser, param,
					       &parse, &ctx->source);
		default:
			return -EINVAL;
		}
	}

 (3) lookup_constant().  This takes a table of named constants and looks up
     the given name within it.  The table is expected to be sorted such
     that bsearch() be used upon it.

     Possibly I should require the table be terminated and just use a
     for-loop to scan it instead of using bsearch() to reduce hassle.

     Tables look something like:

	static const struct constant_table bool_names[] = {
		{ "0",		false },
		{ "1",		true },
		{ "false",	false },
		{ "no",		false },
		{ "true",	true },
		{ "yes",	true },
	};

     and a lookup is done with something like:

	b = lookup_constant(bool_names, param->string, -1);

Additionally, optional validation routines for the parameter description
are provided that can be enabled at compile time.  A later patch will
invoke these when a filesystem is registered.

Signed-off-by: David Howells <dhowells@redhat.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
---

 fs/Kconfig                 |    7 +
 fs/Makefile                |    2 
 fs/fs_parser.c             |  447 ++++++++++++++++++++++++++++++++++++++++++++
 fs/internal.h              |    2 
 fs/namei.c                 |    4 
 include/linux/errno.h      |    1 
 include/linux/fs_context.h |   29 +++
 include/linux/fs_parser.h  |  176 +++++++++++++++++
 8 files changed, 665 insertions(+), 3 deletions(-)
 create mode 100644 fs/fs_parser.c
 create mode 100644 include/linux/fs_parser.h

Message ID	155059382463.12449.9058984258656142511.stgit@warthog.procyon.org.uk (mailing list archive)
State	New, archived
Headers	show Return-Path: <linux-security-module-owner@kernel.org> Organization: Red Hat UK Ltd. Registered Address: Red Hat UK Ltd, Amberley Place, 107-111 Peascod Street, Windsor, Berkshire, SI4 1TE, United Kingdom. Registered in England and Wales under Company Registration No. 3798903 Subject: [PATCH 15/43] vfs: Add configuration parser helpers From: David Howells <dhowells@redhat.com> To: viro@zeniv.linux.org.uk Cc: linux-fsdevel@vger.kernel.org, dhowells@redhat.com, torvalds@linux-foundation.org, ebiederm@xmission.com, linux-security-module@vger.kernel.org Date: Tue, 19 Feb 2019 16:30:24 +0000 Message-ID: <155059382463.12449.9058984258656142511.stgit@warthog.procyon.org.uk> In-Reply-To: <155059366914.12449.4669870128936536848.stgit@warthog.procyon.org.uk> References: <155059366914.12449.4669870128936536848.stgit@warthog.procyon.org.uk> User-Agent: StGit/unknown-version MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: 7bit Sender: owner-linux-security-module@vger.kernel.org Precedence: bulk
Series	VFS: Introduce filesystem context \| expand [00/43] VFS: Introduce filesystem context [01/43] fix cgroup_do_mount() handling of failure exits [02/43] cgroup: saner refcounting for cgroup_root [03/43] kill kernfs_pin_sb() [04/43] separate copying and locking mount tree on cross-userns copies [05/43] saner handling of temporary namespaces [06/43] vfs: Introduce fs_context, switch vfs_kern_mount() to it. [07/43] new helpers: vfs_create_mount(), fc_mount() [08/43] teach vfs_get_tree() to handle subtype, switch do_new_mount() to it [09/43] new helper: do_new_mount_fc() [10/43] vfs_get_tree(): evict the call of security_sb_kern_mount() [11/43] convert do_remount_sb() to fs_context [12/43] fs_context flavour for submounts [13/43] introduce fs_context methods [14/43] vfs: Introduce logging functions [15/43] vfs: Add configuration parser helpers [16/43] vfs: Add LSM hooks for the new mount API [17/43] selinux: Implement the new mount API LSM hooks [18/43] smack: Implement filesystem context security hooks [19/43] vfs: Put security flags into the fs_context struct [20/43] vfs: Implement a filesystem superblock creation/configuration context [21/43] convenience helpers: vfs_get_super() and sget_fc() [22/43] introduce cloning of fs_context [23/43] procfs: Move proc_fill_super() to fs/proc/root.c [24/43] proc: Add fs_context support to procfs [25/43] ipc: Convert mqueue fs to fs_context [26/43] cgroup: start switching to fs_context [27/43] cgroup: fold cgroup1_mount() into cgroup1_get_tree() [28/43] cgroup: take options parsing into ->parse_monolithic() [29/43] cgroup1: switch to option-by-option parsing [30/43] cgroup2: switch to option-by-option parsing [31/43] cgroup: stash cgroup_root reference into cgroup_fs_context [32/43] cgroup_do_mount(): massage calling conventions [33/43] cgroup1_get_tree(): separate "get cgroup_root to use" into a separate helper [34/43] cgroup: store a reference to cgroup_ns into cgroup_fs_context [35/43] kernfs, sysfs, cgroup, intel_rdt: Support fs_context [36/43] cpuset: Use fs_context [37/43] hugetlbfs: Convert to fs_context [38/43] vfs: Remove kern_mount_data() [39/43] vfs: Provide documentation for new mount API [40/43] vfs: Implement logging through fs_context [41/43] vfs: Add some logging to the core users of the fs_context log [42/43] afs: Add fs_context support [43/43] afs: Use fs_context to pass parameters over automount

[15/43] vfs: Add configuration parser helpers

Commit Message

Comments

Patch