* [PATCH 01/21] Provide a function to create a NUL-terminated string from unterminated data [ver #3]
2017-05-15 15:17 [RFC][PATCH 00/21] VFS: Introduce superblock configuration context [ver #3] David Howells
@ 2017-05-15 15:18 ` David Howells
2017-05-15 15:18 ` [PATCH 02/21] Clean up whitespace in fs/namespace.c " David Howells
` (19 subsequent siblings)
20 siblings, 0 replies; 28+ messages in thread
From: David Howells @ 2017-05-15 15:18 UTC (permalink / raw)
To: mszeredi, viro, jlayton; +Cc: dhowells, linux-fsdevel, linux-nfs, linux-kernel
Provide a function, kmemdup_nul(), that will create a NUL-terminated string
from an unterminated character array where the length is known in advance.
This is better than kstrndup() in situations where we already know the
string length as the strnlen() in kstrndup() is superfluous.
Signed-off-by: David Howells <dhowells@redhat.com>
---
include/linux/string.h | 1 +
mm/util.c | 24 ++++++++++++++++++++++++
2 files changed, 25 insertions(+)
diff --git a/include/linux/string.h b/include/linux/string.h
index 537918f8a98e..3dd944cfe171 100644
--- a/include/linux/string.h
+++ b/include/linux/string.h
@@ -131,6 +131,7 @@ extern char *kstrdup(const char *s, gfp_t gfp) __malloc;
extern const char *kstrdup_const(const char *s, gfp_t gfp);
extern char *kstrndup(const char *s, size_t len, gfp_t gfp);
extern void *kmemdup(const void *src, size_t len, gfp_t gfp);
+extern char *kmemdup_nul(const char *s, size_t len, gfp_t gfp);
extern char **argv_split(gfp_t gfp, const char *str, int *argcp);
extern void argv_free(char **argv);
diff --git a/mm/util.c b/mm/util.c
index 464df3489903..cc9f0a2810bd 100644
--- a/mm/util.c
+++ b/mm/util.c
@@ -83,6 +83,8 @@ EXPORT_SYMBOL(kstrdup_const);
* @s: the string to duplicate
* @max: read at most @max chars from @s
* @gfp: the GFP mask used in the kmalloc() call when allocating memory
+ *
+ * Note: Use kmemdup_nul() instead if the size is known exactly.
*/
char *kstrndup(const char *s, size_t max, gfp_t gfp)
{
@@ -121,6 +123,28 @@ void *kmemdup(const void *src, size_t len, gfp_t gfp)
EXPORT_SYMBOL(kmemdup);
/**
+ * kmemdup_nul - Create a NUL-terminated string from unterminated data
+ * @s: The data to stringify
+ * @len: The size of the data
+ * @gfp: the GFP mask used in the kmalloc() call when allocating memory
+ */
+char *kmemdup_nul(const char *s, size_t len, gfp_t gfp)
+{
+ char *buf;
+
+ if (!s)
+ return NULL;
+
+ buf = kmalloc_track_caller(len + 1, gfp);
+ if (buf) {
+ memcpy(buf, s, len);
+ buf[len] = '\0';
+ }
+ return buf;
+}
+EXPORT_SYMBOL(kmemdup_nul);
+
+/**
* memdup_user - duplicate memory region from user space
*
* @src: source address in user space
^ permalink raw reply related [flat|nested] 28+ messages in thread* [PATCH 02/21] Clean up whitespace in fs/namespace.c [ver #3]
2017-05-15 15:17 [RFC][PATCH 00/21] VFS: Introduce superblock configuration context [ver #3] David Howells
2017-05-15 15:18 ` [PATCH 01/21] Provide a function to create a NUL-terminated string from unterminated data " David Howells
@ 2017-05-15 15:18 ` David Howells
2017-05-15 15:18 ` [PATCH 03/21] VFS: Make get_mnt_ns() return the namespace " David Howells
` (18 subsequent siblings)
20 siblings, 0 replies; 28+ messages in thread
From: David Howells @ 2017-05-15 15:18 UTC (permalink / raw)
To: mszeredi, viro, jlayton; +Cc: dhowells, linux-fsdevel, linux-nfs, linux-kernel
Clean up line terminal whitespace in fs/namespace.c.
Signed-off-by: David Howells <dhowells@redhat.com>
---
fs/namespace.c | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/fs/namespace.c b/fs/namespace.c
index 8bd3e4d448b9..c076787871e7 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -1656,7 +1656,7 @@ void __detach_mounts(struct dentry *dentry)
namespace_unlock();
}
-/*
+/*
* Is the caller allowed to modify his namespace?
*/
static inline bool may_mount(void)
@@ -2210,7 +2210,7 @@ static int do_loopback(struct path *path, const char *old_name,
err = -EINVAL;
if (mnt_ns_loop(old_path.dentry))
- goto out;
+ goto out;
mp = lock_mount(path);
err = PTR_ERR(mp);
^ permalink raw reply related [flat|nested] 28+ messages in thread* [PATCH 03/21] VFS: Make get_mnt_ns() return the namespace [ver #3]
2017-05-15 15:17 [RFC][PATCH 00/21] VFS: Introduce superblock configuration context [ver #3] David Howells
2017-05-15 15:18 ` [PATCH 01/21] Provide a function to create a NUL-terminated string from unterminated data " David Howells
2017-05-15 15:18 ` [PATCH 02/21] Clean up whitespace in fs/namespace.c " David Howells
@ 2017-05-15 15:18 ` David Howells
2017-05-15 15:18 ` [PATCH 04/21] VFS: Make get_filesystem() return the affected filesystem " David Howells
` (17 subsequent siblings)
20 siblings, 0 replies; 28+ messages in thread
From: David Howells @ 2017-05-15 15:18 UTC (permalink / raw)
To: mszeredi, viro, jlayton; +Cc: dhowells, linux-fsdevel, linux-nfs, linux-kernel
Make get_mnt_ns() return the namespace it got a ref on for consistency with
other namespace ref getting functions.
Signed-off-by: David Howells <dhowells@redhat.com>
---
fs/mount.h | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/fs/mount.h b/fs/mount.h
index bf1fda6eed8f..02ef292a77d7 100644
--- a/fs/mount.h
+++ b/fs/mount.h
@@ -108,9 +108,10 @@ static inline void detach_mounts(struct dentry *dentry)
__detach_mounts(dentry);
}
-static inline void get_mnt_ns(struct mnt_namespace *ns)
+static inline struct mnt_namespace *get_mnt_ns(struct mnt_namespace *ns)
{
atomic_inc(&ns->count);
+ return ns;
}
extern seqlock_t mount_lock;
^ permalink raw reply related [flat|nested] 28+ messages in thread* [PATCH 04/21] VFS: Make get_filesystem() return the affected filesystem [ver #3]
2017-05-15 15:17 [RFC][PATCH 00/21] VFS: Introduce superblock configuration context [ver #3] David Howells
` (2 preceding siblings ...)
2017-05-15 15:18 ` [PATCH 03/21] VFS: Make get_mnt_ns() return the namespace " David Howells
@ 2017-05-15 15:18 ` David Howells
2017-05-15 15:19 ` [PATCH 05/21] VFS: Provide empty name qstr " David Howells
` (16 subsequent siblings)
20 siblings, 0 replies; 28+ messages in thread
From: David Howells @ 2017-05-15 15:18 UTC (permalink / raw)
To: mszeredi, viro, jlayton; +Cc: dhowells, linux-fsdevel, linux-nfs, linux-kernel
Make get_filesystem() return a pointer to the filesystem on which it just
got a ref.
Suggested-by: Rasmus Villemoes <linux@rasmusvillemoes.dk>
Signed-off-by: David Howells <dhowells@redhat.com>
---
fs/filesystems.c | 3 ++-
include/linux/fs.h | 2 +-
2 files changed, 3 insertions(+), 2 deletions(-)
diff --git a/fs/filesystems.c b/fs/filesystems.c
index cac75547d35c..591e52d23ed4 100644
--- a/fs/filesystems.c
+++ b/fs/filesystems.c
@@ -33,9 +33,10 @@ static struct file_system_type *file_systems;
static DEFINE_RWLOCK(file_systems_lock);
/* WARNING: This can be used only if we _already_ own a reference */
-void get_filesystem(struct file_system_type *fs)
+struct file_system_type *get_filesystem(struct file_system_type *fs)
{
__module_get(fs->owner);
+ return fs;
}
void put_filesystem(struct file_system_type *fs)
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 803e5a9b2654..bc0c054894b9 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -2956,7 +2956,7 @@ extern int generic_block_fiemap(struct inode *inode,
struct fiemap_extent_info *fieinfo, u64 start,
u64 len, get_block_t *get_block);
-extern void get_filesystem(struct file_system_type *fs);
+extern struct file_system_type *get_filesystem(struct file_system_type *fs);
extern void put_filesystem(struct file_system_type *fs);
extern struct file_system_type *get_fs_type(const char *name);
extern struct super_block *get_super(struct block_device *);
^ permalink raw reply related [flat|nested] 28+ messages in thread* [PATCH 05/21] VFS: Provide empty name qstr [ver #3]
2017-05-15 15:17 [RFC][PATCH 00/21] VFS: Introduce superblock configuration context [ver #3] David Howells
` (3 preceding siblings ...)
2017-05-15 15:18 ` [PATCH 04/21] VFS: Make get_filesystem() return the affected filesystem " David Howells
@ 2017-05-15 15:19 ` David Howells
2017-05-15 15:19 ` [PATCH 06/21] VFS: Introduce a superblock configuration context " David Howells
` (15 subsequent siblings)
20 siblings, 0 replies; 28+ messages in thread
From: David Howells @ 2017-05-15 15:19 UTC (permalink / raw)
To: mszeredi, viro, jlayton; +Cc: dhowells, linux-fsdevel, linux-nfs, linux-kernel
Provide an empty name (ie. "") qstr for general use.
Signed-off-by: David Howells <dhowells@redhat.com>
---
fs/dcache.c | 8 ++++++--
fs/gfs2/dir.c | 3 +--
fs/namei.c | 3 +--
fs/nsfs.c | 3 +--
fs/pipe.c | 3 +--
include/linux/dcache.h | 5 +++++
6 files changed, 15 insertions(+), 10 deletions(-)
diff --git a/fs/dcache.c b/fs/dcache.c
index cddf39777835..d3da2a3ffd73 100644
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -90,6 +90,11 @@ EXPORT_SYMBOL(rename_lock);
static struct kmem_cache *dentry_cache __read_mostly;
+const struct qstr empty_name = QSTR_INIT("", 0);
+EXPORT_SYMBOL(empty_name);
+const struct qstr slash_name = QSTR_INIT("/", 1);
+EXPORT_SYMBOL(slash_name);
+
/*
* This is the single most critical data structure when it comes
* to the dcache: the hashtable for lookups. Somebody should try
@@ -1580,8 +1585,7 @@ struct dentry *__d_alloc(struct super_block *sb, const struct qstr *name)
*/
dentry->d_iname[DNAME_INLINE_LEN-1] = 0;
if (unlikely(!name)) {
- static const struct qstr anon = QSTR_INIT("/", 1);
- name = &anon;
+ name = &slash_name;
dname = dentry->d_iname;
} else if (name->len > DNAME_INLINE_LEN-1) {
size_t size = offsetof(struct external_name, name[1]);
diff --git a/fs/gfs2/dir.c b/fs/gfs2/dir.c
index 79113219be5f..a5dfff6a033e 100644
--- a/fs/gfs2/dir.c
+++ b/fs/gfs2/dir.c
@@ -872,7 +872,6 @@ static struct gfs2_leaf *new_leaf(struct inode *inode, struct buffer_head **pbh,
struct buffer_head *bh;
struct gfs2_leaf *leaf;
struct gfs2_dirent *dent;
- struct qstr name = { .name = "" };
struct timespec tv = current_time(inode);
error = gfs2_alloc_blocks(ip, &bn, &n, 0, NULL);
@@ -896,7 +895,7 @@ static struct gfs2_leaf *new_leaf(struct inode *inode, struct buffer_head **pbh,
leaf->lf_sec = cpu_to_be64(tv.tv_sec);
memset(leaf->lf_reserved2, 0, sizeof(leaf->lf_reserved2));
dent = (struct gfs2_dirent *)(leaf+1);
- gfs2_qstr2dirent(&name, bh->b_size - sizeof(struct gfs2_leaf), dent);
+ gfs2_qstr2dirent(&empty_name, bh->b_size - sizeof(struct gfs2_leaf), dent);
*pbh = bh;
return leaf;
}
diff --git a/fs/namei.c b/fs/namei.c
index 6571a5f5112e..0d35760fee00 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -3400,7 +3400,6 @@ static int do_last(struct nameidata *nd,
struct dentry *vfs_tmpfile(struct dentry *dentry, umode_t mode, int open_flag)
{
- static const struct qstr name = QSTR_INIT("/", 1);
struct dentry *child = NULL;
struct inode *dir = dentry->d_inode;
struct inode *inode;
@@ -3414,7 +3413,7 @@ struct dentry *vfs_tmpfile(struct dentry *dentry, umode_t mode, int open_flag)
if (!dir->i_op->tmpfile)
goto out_err;
error = -ENOMEM;
- child = d_alloc(dentry, &name);
+ child = d_alloc(dentry, &slash_name);
if (unlikely(!child))
goto out_err;
error = dir->i_op->tmpfile(dir, child, mode);
diff --git a/fs/nsfs.c b/fs/nsfs.c
index f3db56e83dd2..08127a2b8559 100644
--- a/fs/nsfs.c
+++ b/fs/nsfs.c
@@ -53,7 +53,6 @@ static void nsfs_evict(struct inode *inode)
static void *__ns_get_path(struct path *path, struct ns_common *ns)
{
struct vfsmount *mnt = nsfs_mnt;
- struct qstr qname = { .name = "", };
struct dentry *dentry;
struct inode *inode;
unsigned long d;
@@ -85,7 +84,7 @@ static void *__ns_get_path(struct path *path, struct ns_common *ns)
inode->i_fop = &ns_file_operations;
inode->i_private = ns;
- dentry = d_alloc_pseudo(mnt->mnt_sb, &qname);
+ dentry = d_alloc_pseudo(mnt->mnt_sb, &empty_name);
if (!dentry) {
iput(inode);
return ERR_PTR(-ENOMEM);
diff --git a/fs/pipe.c b/fs/pipe.c
index 73b84baf58f8..97e5be897753 100644
--- a/fs/pipe.c
+++ b/fs/pipe.c
@@ -739,13 +739,12 @@ int create_pipe_files(struct file **res, int flags)
struct inode *inode = get_pipe_inode();
struct file *f;
struct path path;
- static struct qstr name = { .name = "" };
if (!inode)
return -ENFILE;
err = -ENOMEM;
- path.dentry = d_alloc_pseudo(pipe_mnt->mnt_sb, &name);
+ path.dentry = d_alloc_pseudo(pipe_mnt->mnt_sb, &empty_name);
if (!path.dentry)
goto err_inode;
path.mnt = mntget(pipe_mnt);
diff --git a/include/linux/dcache.h b/include/linux/dcache.h
index d2e38dc6172c..3f65a4fa72ed 100644
--- a/include/linux/dcache.h
+++ b/include/linux/dcache.h
@@ -55,6 +55,11 @@ struct qstr {
#define QSTR_INIT(n,l) { { { .len = l } }, .name = n }
+extern const char empty_string[];
+extern const struct qstr empty_name;
+extern const char slash_string[];
+extern const struct qstr slash_name;
+
struct dentry_stat_t {
long nr_dentry;
long nr_unused;
^ permalink raw reply related [flat|nested] 28+ messages in thread* [PATCH 06/21] VFS: Introduce a superblock configuration context [ver #3]
2017-05-15 15:17 [RFC][PATCH 00/21] VFS: Introduce superblock configuration context [ver #3] David Howells
` (4 preceding siblings ...)
2017-05-15 15:19 ` [PATCH 05/21] VFS: Provide empty name qstr " David Howells
@ 2017-05-15 15:19 ` David Howells
2017-05-16 15:10 ` Miklos Szeredi
2017-05-16 16:33 ` David Howells
2017-05-15 15:19 ` [PATCH 07/21] Implement fsopen() to prepare for a mount " David Howells
` (14 subsequent siblings)
20 siblings, 2 replies; 28+ messages in thread
From: David Howells @ 2017-05-15 15:19 UTC (permalink / raw)
To: mszeredi, viro, jlayton; +Cc: dhowells, linux-fsdevel, linux-nfs, linux-kernel
Introduce a superblock configuration context concept to be used during
superblock creation for mount and superblock reconfiguration for remount.
This is allocated at the beginning of the mount procedure and into it is
placed:
(1) Filesystem type.
(2) Namespaces.
(3) Device name.
(4) Superblock flags (MS_*).
(5) Security details.
(6) Filesystem-specific data, as set by the mount options.
It also gives a place in which to hang an error message for later retrieval
(see the mount-by-fd syscall later in this series).
Rather than calling fs_type->mount(), an sb_config struct is created and
fs_type->init_sb_config() is called to set it up. fs_type->sb_config_size
says how much space should be allocated for the config context. The
sb_config struct is placed at the beginning and any extra space is for the
filesystem's use.
A set of operations have to be set by ->init_sb_config() to provide
freeing, duplication, option parsing, binary data parsing, validation,
mounting and superblock filling.
It should be noted that, whilst this patch adds a lot of lines of code,
there is quite a bit of duplication with existing code that can be
eliminated should all filesystems be converted over.
Signed-off-by: David Howells <dhowells@redhat.com>
---
Documentation/filesystems/mounting.txt | 456 ++++++++++++++++++++++++++++++++
fs/Makefile | 3
fs/internal.h | 2
fs/libfs.c | 1
fs/namespace.c | 256 ++++++++++++++++--
fs/nfs/nfs4super.c | 1
fs/proc/root.c | 1
fs/sb_config.c | 326 +++++++++++++++++++++++
fs/super.c | 54 +++-
include/linux/fs.h | 14 +
include/linux/lsm_hooks.h | 38 +++
include/linux/mount.h | 4
include/linux/sb_config.h | 93 +++++++
include/linux/security.h | 29 ++
security/security.c | 25 ++
security/selinux/hooks.c | 170 ++++++++++++
16 files changed, 1442 insertions(+), 31 deletions(-)
create mode 100644 Documentation/filesystems/mounting.txt
create mode 100644 fs/sb_config.c
create mode 100644 include/linux/sb_config.h
diff --git a/Documentation/filesystems/mounting.txt b/Documentation/filesystems/mounting.txt
new file mode 100644
index 000000000000..03e9086f754d
--- /dev/null
+++ b/Documentation/filesystems/mounting.txt
@@ -0,0 +1,456 @@
+ ===================
+ FILESYSTEM MOUNTING
+ ===================
+
+CONTENTS
+
+ (1) Overview.
+
+ (2) The superblock configuration context.
+
+ (3) The superblock config operations.
+
+ (4) Superblock config security.
+
+ (5) VFS superblock config operations.
+
+
+========
+OVERVIEW
+========
+
+The creation of new mounts is now to be done in a multistep process:
+
+ (1) Create a superblock configuration context.
+
+ (2) Parse the options and attach them to the context. Options may be passed
+ individually from userspace.
+
+ (3) Validate and pre-process the context.
+
+ (4) Get or create a superblock and mountable root.
+
+ (5) Perform the mount.
+
+ (6) Return an error message attached to the context.
+
+ (7) Destroy the context.
+
+To support this, the file_system_type struct gains two new fields:
+
+ unsigned short sb_config_size;
+
+which indicates the total amount of space that should be allocated for context
+data (see the Superblock Configuration Context section), and:
+
+ int (*init_sb_config)(struct sb_config *sc, struct super_block *src_sb);
+
+which is invoked to set up the filesystem-specific parts of a superblock
+configuration context, including the additional space. The src_sb parameter is
+used to convey the superblock from which the filesystem may draw extra
+information (such as namespaces), for submount (SB_CONFIG_FOR_SUBMOUNT) or
+remount (SB_CONFIG_FOR_REMOUNT) purposes or it will be NULL.
+
+Note that security initialisation is done *after* the filesystem is called so
+that the namespaces may be adjusted first.
+
+And the super_operations struct gains one:
+
+ int (*remount_fs_sc) (struct super_block *, struct sb_config *);
+
+This shadows the ->remount_fs() operation and takes a prepared superblock
+configuration context instead of the mount flags and data page. It may modify
+the ms_flags in the context for the caller to pick up.
+
+[NOTE] remount_fs_sc is intended as a replacement for remount_fs.
+
+
+====================================
+THE SUPERBLOCK CONFIGURATION CONTEXT
+====================================
+
+The creation and reconfiguration of a superblock is governed by a superblock
+configuration context. This is represented by the sb_config structure:
+
+ struct sb_config {
+ const struct sb_config_operations *ops;
+ struct file_system_type *fs;
+ struct user_namespace *user_ns;
+ struct net *net_ns;
+ const struct cred *cred;
+ char *device;
+ void *security;
+ const char *error_msg;
+ unsigned int ms_flags;
+ bool mounted;
+ bool sloppy;
+ bool silent;
+ enum mount_type mount_type : 8;
+ };
+
+When the VFS creates this, it allocates ->sb_config_size bytes (as specified by
+the file_system_type object) to hold both the sb_config struct and any extra
+data required by the filesystem. The sb_config struct is placed at the
+beginning of this space. Any extra space beyond that is for use by the
+filesystem. The filesystem should wrap the struct in its own, e.g.:
+
+ struct nfs_sb_config {
+ struct sb_config sc;
+ ...
+ };
+
+placing the sb_config struct first. container_of() can then be used. The
+file_system_type would be initialised thus:
+
+ struct file_system_type nfs = {
+ ...
+ .sb_config_size = sizeof(struct nfs_sb_config),
+ .init_sb_config = nfs_init_sb_config,
+ ...
+ };
+
+The sb_config fields are as follows:
+
+ (*) const struct sb_config_operations *ops
+
+ These are operations that can be done on a superblock configuration
+ context (see below). This must be set by the ->init_sb_config()
+ file_system_type operation.
+
+ (*) struct file_system_type *fs
+
+ A pointer to the file_system_type of the filesystem that is being
+ constructed or reconfigured. This retains a ref on the type owner.
+
+ (*) struct user_namespace *user_ns
+ (*) struct net *net_ns
+
+ This is a subset of the namespaces in use by the invoking process. This
+ retains a ref on each namespace. The subscribed namespaces may be
+ replaced by the filesystem to reflect other sources, such as the parent
+ mount superblock on an automount.
+
+ (*) struct cred *cred
+
+ The mounter's credentials. This retains a ref on the credentials.
+
+ (*) char *device
+
+ This is the device to be mounted. It may be a block device
+ (e.g. /dev/sda1) or something more exotic, such as the "host:/path" that
+ NFS desires.
+
+ (*) void *security
+
+ A place for the LSMs to hang their security data for the superblock. The
+ relevant security operations are described below.
+
+ (*) const char *error_msg
+
+ A place for the VFS and the filesystem to hang an error message. This
+ should be in the form of a static string that doesn't need deallocation
+ and the pointer to which can just be overwritten. Under some
+ circumstances, this can be retrieved by userspace.
+
+ Note that the existence of the error string is expected to be guaranteed
+ by the reference on the file_system_type object held by ->fs or any
+ filesystem-specific reference held in the filesystem context until the
+ ->free() operation is called.
+
+ Use sb_cfg_error() and sb_cfg_inval() to set this rather than setting it
+ directly.
+
+ (*) unsigned int ms_flags
+
+ This holds the MS_* flags mount flags.
+
+ (*) bool mounted
+
+ This is set to true once a mount attempt is made. This causes an error to
+ be given on subsequent mount attempts with the same context and prevents
+ multiple mount attempts.
+
+ (*) bool sloppy
+ (*) bool silent
+
+ These are set if the sloppy or silent mount options are given.
+
+ [NOTE] sloppy is probably unnecessary when userspace passes over one
+ option at a time since the error can just be ignored if userspace deems it
+ to be unimportant.
+
+ [NOTE] silent is probably redundant with ms_flags & MS_SILENT.
+
+ (*) enum mount_type
+
+ This indicates the type of mount operation. The available values are:
+
+ SB_CONFIG_FOR_NEW -- New mount
+ SB_CONFIG_FOR_SUBMOUNT -- New automatic submount of extant mount
+ SB_CONFIG_FOR_REMOUNT -- Change an existing mount
+
+The mount context is created by calling __vfs_new_sb_config(),
+vfs_new_sb_config(), vfs_sb_reconfig() or vfs_dup_sb_config() and is destroyed
+with put_sb_config(). Note that the structure is not refcounted.
+
+VFS, security and filesystem mount options are set individually with
+vfs_parse_mount_option() or in bulk with generic_monolithic_mount_data().
+
+When mounting, the filesystem is allowed to take data from any of the pointers
+and attach it to the superblock (or whatever), provided it clears the pointer
+in the mount context.
+
+The filesystem is also allowed to allocate resources and pin them with the
+mount context. For instance, NFS might pin the appropriate protocol version
+module.
+
+
+================================
+THE SUPERBLOCK CONFIG OPERATIONS
+================================
+
+The superblock configuration context points to a table of operations:
+
+ struct sb_config_operations {
+ void (*free)(struct sb_config *sc);
+ int (*dup)(struct sb_config *sc, struct sb_config *src_sc);
+ int (*parse_option)(struct sb_config *sc, char *p);
+ int (*monolithic_mount_data)(struct sb_config *sc, void *data);
+ int (*validate)(struct sb_config *sc);
+ struct dentry *(*mount)(struct sb_config *sc);
+ };
+
+These operations are invoked by the various stages of the mount procedure to
+manage the superblock configuration context. They are as follows:
+
+ (*) void (*free)(struct sb_config *sc);
+
+ Called to clean up the filesystem-specific part of the superblock
+ configuration context when the context is destroyed. It should be aware
+ that parts of the context may have been removed and NULL'd out by
+ ->mount().
+
+ (*) int (*dup)(struct sb_config *sc, struct sb_config *src_sc);
+
+ Called when a superblock configuration context has been duplicated to get
+ any refs or copy any non-referenced resources held in the
+ filesystem-specific part of the superblock configuration context. An
+ error may be returned to indicate failure to do this.
+
+ [!] Note that even if this fails, put_sb_config() will be called
+ immediately thereafter, so ->dup() *must* make the filesystem-specific
+ part safe for ->free().
+
+ (*) int (*parse_option)(struct sb_config *sc, char *p);
+
+ Called when an option is to be added to the superblock configuration
+ context. p points to the option string, likely in "key[=val]" format.
+ VFS-specific options will have been weeded out and sc->ms_flags updated in
+ the context. Security options will also have been weeded out and
+ sc->security updated.
+
+ If successful, 0 should be returned and a negative error code otherwise.
+ If an ambiguous error (such as -EINVAL) is returned, sb_cfg_error() or
+ sb_cfg_inval() should be used to provide a string that provides more
+ information.
+
+ (*) int (*monolithic_mount_data)(struct sb_config *sc, void *data);
+
+ Called when the mount(2) system call is invoked to pass the entire data
+ page in one go. If this is expected to be just a list of "key[=val]"
+ items separated by commas, then this may be set to NULL.
+
+ The return value is as for ->parse_option().
+
+ If the filesystem (eg. NFS) needs to examine the data first and then
+ finds it's the standard key-val list then it may pass it off to:
+
+ int generic_monolithic_mount_data(struct sb_config *sc, void *data);
+
+ (*) int (*validate)(struct sb_config *sc);
+
+ Called when all the options have been applied and the mount is about to
+ take place. It is should check for inconsistencies from mount options
+ and it is also allowed to do preliminary resource acquisition. For
+ instance, the core NFS module could load the NFS protocol module here.
+
+ Note that if sc->mount_type == SB_CONFIG_FOR_REMOUNT, some of the options
+ necessary for a new mount may not be set.
+
+ The return value is as for ->parse_option().
+
+ (*) struct dentry *(*mount)(struct sb_config *sc);
+
+ Called to effect a new mount or new submount using the information stored
+ in the superblock configuration context (remounts go via a different
+ vector). It may detach any resources it desires from the superblock
+ configuration context and transfer them to the superblock it creates.
+
+ On success it should return the dentry that's at the root of the mount.
+ In future, sc->root_path will then be applied to this.
+
+ In the case of an error, it should return a negative error code and invoke
+ sb_cfg_inval() or sb_cfg_error().
+
+
+=========================================
+SUPERBLOCK CONFIGURATION CONTEXT SECURITY
+========================================
+
+The superblock configuration context contains a security points that the LSMs can use for
+building up a security context for the superblock to be mounted. There are a
+number of operations used by the new mount code for this purpose:
+
+ (*) int security_sb_config_alloc(struct sb_config *sc,
+ struct super_block *src_sb);
+
+ Called to initialise sc->security (which is preset to NULL) and allocate
+ any resources needed. It should return 0 on success and a negative error
+ code on failure.
+
+ src_sb is non-NULL in the case of a remount (SB_CONFIG_FOR_REMOUNT) in
+ which case it indicates the superblock to be remounted or in the case of a
+ submount (SB_CONFIG_FOR_SUBMOUNT) in which case it indicates the parent
+ superblock.
+
+ (*) int security_sb_config_dup(struct sb_config *sc,
+ struct sb_config *src_mc);
+
+ Called to initialise sc->security (which is preset to NULL) and allocate
+ any resources needed. The original superblock configuration context is pointed to by src_mc
+ and may be used for reference. It should return 0 on success and a
+ negative error code on failure.
+
+ (*) void security_sb_config_free(struct sb_config *sc);
+
+ Called to clean up anything attached to sc->security. Note that the
+ contents may have been transferred to a superblock and the pointer NULL'd
+ out during mount.
+
+ (*) int security_sb_config_parse_option(struct sb_config *sc, char *opt);
+
+ Called for each mount option. The mount options are in "key[=val]"
+ form. An active LSM may reject one with an error, pass one over and
+ return 0 or consume one and return 1. If consumed, the option isn't
+ passed on to the filesystem.
+
+ If it returns an error, more information can be returned with
+ sb_cfg_inval() or sb_cfg_error().
+
+ (*) int security_sb_get_tree(struct sb_config *sc);
+
+ Called during the mount procedure to verify that the specified superblock
+ is allowed to be mounted and to transfer the security data there.
+
+ On success, it should return 0; otherwise it should return an error and
+ perhaps call sb_cfg_inval() or sb_cfg_error() to indicate the problem. It
+ should not return -ENOMEM as this should be taken care of in advance.
+
+ [NOTE] Should I add a security_sb_config_validate() operation so that the
+ LSM has the opportunity to allocate stuff and check the options as a
+ whole?
+
+
+================================
+VFS SUPERBLOCK CONFIG OPERATIONS
+================================
+
+There are four operations for creating a superblock configuration context and
+one for destroying a context:
+
+ (*) struct sb_config *__vfs_new_sb_config(struct file_system_type *fs_type,
+ struct super_block *src_sb;
+ unsigned int ms_flags);
+
+ Create a superblock configuration context given a filesystem type pointer.
+ This allocates the superblock configuration context, sets the flags,
+ initialises the security and calls fs_type->init_sb_config() to initialise
+ the filesystem context.
+
+ src_sb can be NULL or it may indicate a superblock that is going to be
+ remounted (SB_CONFIG_FOR_REMOUNT) or a superblock that is the parent of a
+ submount (SB_CONFIG_FOR_SUBMOUNT). This superblock is provided as a
+ source of namespace information.
+
+ (*) struct sb_config *vfs_sb_reconfig(struct vfsmount *mnt,
+ unsigned int ms_flags);
+
+ Create a superblock configuration context from the same filesystem as an
+ extant mount and initialise the mount parameters from the superblock
+ underlying that mount. This is for use by remount.
+
+ (*) struct sb_config *vfs_fsopen(const char *fs_name);
+
+ Create a superblock configuration context given a filesystem name. It is
+ assumed that the mount flags will be passed in as text options or set
+ directly later. This is intended to be called from sys_mount() or
+ sys_fsopen(). This copies current's namespaces to the superblock
+ configuration context.
+
+ (*) struct sb_config *vfs_dup_sb_config(struct sb_config *src_sc);
+
+ Duplicate a superblock configuration context, copying any options noted
+ and duplicating or additionally referencing any resources held therein.
+ This is available for use where a filesystem has to get a mount within a
+ mount, such as NFS4 does by internally mounting the root of the target
+ server and then doing a private pathwalk to the target directory.
+
+ (*) void put_sb_config(struct sb_config *sc);
+
+ Destroy a superblock configuration context, releasing any resources it
+ holds. This calls the ->free() operation. This is intended to be called
+ by anyone who created a superblock configuration context.
+
+ [!] superblock configuration contexts are not refcounted, so this causes
+ unconditional destruction.
+
+In all the above operations, apart from the put op, the return is a mount
+context pointer or a negative error code. No error string is saved as the
+error string is only guaranteed as long as the file_system_type is pinned (and
+thus the module).
+
+The next operations can be used to cache an error message in the context for
+the caller to collect.
+
+ (*) void sb_cfg_error(struct sb_config *sc, const char *msg);
+
+ Set an error message for the caller to pick up. For lifetime rules, see
+ the ->error_msg member description.
+
+ (*) void sb_cfg_inval(struct sb_config *sc, const char *msg);
+
+ As sb_cfg_error(), but returns -EINVAL for use with tail calling.
+
+In the remaining operations, if an error occurs, a negative error code is
+returned and, if not obvious, sc->error_msg may have been set to point to a
+useful string. This string should not be freed.
+
+ (*) struct vfsmount *vfs_kern_mount_sc(struct sb_config *sc);
+
+ Create a mount given the parameters in the specified superblock
+ configuration context. This invokes the ->validate() op and then the
+ ->mount() op.
+
+ (*) struct vfsmount *vfs_submount_sc(const struct dentry *mountpoint,
+ struct sb_config *sc);
+
+ Create a mount given a superblock configuration context and set
+ MS_SUBMOUNT on it. A wrapper around vfs_kern_mount_sc(). This is
+ intended to be called from filesystems that have automount points (NFS,
+ AFS, ...).
+
+ (*) int vfs_parse_mount_option(struct sb_config *sc, char *data);
+
+ Supply a single mount option to the superblock configuration context. The
+ mount option should likely be in a "key[=val]" string form. The option is
+ first checked to see if it corresponds to a standard mount flag (in which
+ case it is used to mark an MS_xxx flag and consumed) or a security option
+ (in which case the LSM consumes it) before it is passed on to the
+ filesystem.
+
+ (*) int generic_monolithic_mount_data(struct sb_config *sc, void *data);
+
+ Parse a sys_mount() data page, assuming the form to be a text list
+ consisting of key[=val] options separated by commas. Each item in the
+ list is passed to vfs_mount_option(). This is the default when the
+ ->monolithic_mount_data() operation is NULL.
diff --git a/fs/Makefile b/fs/Makefile
index 7bbaca9c67b1..8f5142525866 100644
--- a/fs/Makefile
+++ b/fs/Makefile
@@ -11,7 +11,8 @@ obj-y := open.o read_write.o file_table.o super.o \
attr.o bad_inode.o file.o filesystems.o namespace.o \
seq_file.o xattr.o libfs.o fs-writeback.o \
pnode.o splice.o sync.o utimes.o \
- stack.o fs_struct.o statfs.o fs_pin.o nsfs.o
+ stack.o fs_struct.o statfs.o fs_pin.o nsfs.o \
+ sb_config.o
ifeq ($(CONFIG_BLOCK),y)
obj-y += buffer.o block_dev.o direct-io.o mpage.o
diff --git a/fs/internal.h b/fs/internal.h
index 9676fe11c093..39121a99d930 100644
--- a/fs/internal.h
+++ b/fs/internal.h
@@ -87,7 +87,7 @@ extern struct file *get_empty_filp(void);
/*
* super.c
*/
-extern int do_remount_sb(struct super_block *, int, void *, int);
+extern int do_remount_sb(struct super_block *, int, void *, int, struct sb_config *);
extern bool trylock_super(struct super_block *sb);
extern struct dentry *mount_fs(struct file_system_type *,
int, const char *, void *);
diff --git a/fs/libfs.c b/fs/libfs.c
index a04395334bb1..8ef519709ee3 100644
--- a/fs/libfs.c
+++ b/fs/libfs.c
@@ -9,6 +9,7 @@
#include <linux/slab.h>
#include <linux/cred.h>
#include <linux/mount.h>
+#include <linux/sb_config.h>
#include <linux/vfs.h>
#include <linux/quotaops.h>
#include <linux/mutex.h>
diff --git a/fs/namespace.c b/fs/namespace.c
index c076787871e7..91f8a07532cd 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -25,7 +25,9 @@
#include <linux/magic.h>
#include <linux/bootmem.h>
#include <linux/task_work.h>
+#include <linux/file.h>
#include <linux/sched/task.h>
+#include <linux/sb_config.h>
#include "pnode.h"
#include "internal.h"
@@ -1593,7 +1595,7 @@ static int do_umount(struct mount *mnt, int flags)
return -EPERM;
down_write(&sb->s_umount);
if (!(sb->s_flags & MS_RDONLY))
- retval = do_remount_sb(sb, MS_RDONLY, NULL, 0);
+ retval = do_remount_sb(sb, MS_RDONLY, NULL, 0, NULL);
up_write(&sb->s_umount);
return retval;
}
@@ -2276,6 +2278,26 @@ static int change_mount_flags(struct vfsmount *mnt, int ms_flags)
}
/*
+ * Parse the monolithic page of mount data given to sys_mount().
+ */
+static int parse_monolithic_mount_data(struct sb_config *sc, void *data)
+{
+ int (*monolithic_mount_data)(struct sb_config *, void *);
+ int ret;
+
+ monolithic_mount_data = sc->ops->monolithic_mount_data;
+ if (!monolithic_mount_data)
+ monolithic_mount_data = generic_monolithic_mount_data;
+
+ ret = monolithic_mount_data(sc, data);
+ if (ret < 0)
+ return ret;
+ if (sc->ops->validate)
+ return sc->ops->validate(sc);
+ return 0;
+}
+
+/*
* change filesystem flags. dir should be a physical root of filesystem.
* If you've mounted a non-root directory somewhere and want to do remount
* on it - tough luck.
@@ -2283,13 +2305,14 @@ static int change_mount_flags(struct vfsmount *mnt, int ms_flags)
static int do_remount(struct path *path, int flags, int mnt_flags,
void *data)
{
+ struct sb_config *sc = NULL;
int err;
struct super_block *sb = path->mnt->mnt_sb;
struct mount *mnt = real_mount(path->mnt);
+ struct file_system_type *type = sb->s_type;
if (!check_mnt(mnt))
return -EINVAL;
-
if (path->dentry != path->mnt->mnt_root)
return -EINVAL;
@@ -2320,9 +2343,19 @@ static int do_remount(struct path *path, int flags, int mnt_flags,
return -EPERM;
}
- err = security_sb_remount(sb, data);
- if (err)
- return err;
+ if (type->init_sb_config) {
+ sc = vfs_sb_reconfig(path->mnt, flags);
+ if (IS_ERR(sc))
+ return PTR_ERR(sc);
+
+ err = parse_monolithic_mount_data(sc, data);
+ if (err < 0)
+ goto err_sc;
+ } else {
+ err = security_sb_remount(sb, data);
+ if (err)
+ return err;
+ }
down_write(&sb->s_umount);
if (flags & MS_BIND)
@@ -2330,7 +2363,7 @@ static int do_remount(struct path *path, int flags, int mnt_flags,
else if (!capable(CAP_SYS_ADMIN))
err = -EPERM;
else
- err = do_remount_sb(sb, flags, data, 0);
+ err = do_remount_sb(sb, flags, data, 0, sc);
if (!err) {
lock_mount_hash();
mnt_flags |= mnt->mnt.mnt_flags & ~MNT_USER_SETTABLE_MASK;
@@ -2339,6 +2372,9 @@ static int do_remount(struct path *path, int flags, int mnt_flags,
unlock_mount_hash();
}
up_write(&sb->s_umount);
+err_sc:
+ if (sc)
+ put_sb_config(sc);
return err;
}
@@ -2492,40 +2528,106 @@ static int do_add_mount(struct mount *newmnt, struct path *path, int mnt_flags)
static bool mount_too_revealing(struct vfsmount *mnt, int *new_mnt_flags);
/*
+ * Create a new mount using a superblock configuration and request it
+ * be added to the namespace tree.
+ */
+static int do_new_mount_sc(struct sb_config *sc, struct path *mountpoint,
+ unsigned int mnt_flags)
+{
+ struct vfsmount *mnt;
+ int ret;
+
+ mnt = vfs_kern_mount_sc(sc);
+ if (IS_ERR(mnt))
+ return PTR_ERR(mnt);
+
+ if ((sc->fs_type->fs_flags & FS_HAS_SUBTYPE) &&
+ !mnt->mnt_sb->s_subtype) {
+ mnt = fs_set_subtype(mnt, sc->fs_type->name);
+ if (IS_ERR(mnt))
+ return PTR_ERR(mnt);
+ }
+
+ ret = -EPERM;
+ if (mount_too_revealing(mnt, &mnt_flags)) {
+ sb_cfg_error(sc, "VFS: Mount too revealing");
+ goto err_mnt;
+ }
+
+ ret = do_add_mount(real_mount(mnt), mountpoint, mnt_flags);
+ if (ret < 0) {
+ sb_cfg_error(sc, "VFS: Failed to add mount");
+ goto err_mnt;
+ }
+ return ret;
+
+err_mnt:
+ mntput(mnt);
+ return ret;
+}
+
+/*
* create a new mount for userspace and request it to be added into the
* namespace's tree
*/
-static int do_new_mount(struct path *path, const char *fstype, int flags,
+static int do_new_mount(struct path *mountpoint, const char *fstype, int flags,
int mnt_flags, const char *name, void *data)
{
- struct file_system_type *type;
+ struct sb_config *sc;
struct vfsmount *mnt;
int err;
if (!fstype)
return -EINVAL;
- type = get_fs_type(fstype);
- if (!type)
- return -ENODEV;
+ sc = vfs_new_sb_config(fstype);
+ if (IS_ERR(sc))
+ return PTR_ERR(sc);
+ sc->ms_flags = flags;
- mnt = vfs_kern_mount(type, flags, name, data);
- if (!IS_ERR(mnt) && (type->fs_flags & FS_HAS_SUBTYPE) &&
- !mnt->mnt_sb->s_subtype)
- mnt = fs_set_subtype(mnt, fstype);
+ err = -ENOMEM;
+ sc->device = kstrdup(name, GFP_KERNEL);
+ if (!sc->device)
+ goto err_sc;
- put_filesystem(type);
- if (IS_ERR(mnt))
- return PTR_ERR(mnt);
+ if (sc->ops) {
+ err = parse_monolithic_mount_data(sc, data);
+ if (err < 0)
+ goto err_sc;
- if (mount_too_revealing(mnt, &mnt_flags)) {
- mntput(mnt);
- return -EPERM;
+ err = do_new_mount_sc(sc, mountpoint, mnt_flags);
+ if (err)
+ goto err_sc;
+
+ } else {
+ mnt = vfs_kern_mount(sc->fs_type, flags, name, data);
+ if (!IS_ERR(mnt) && (sc->fs_type->fs_flags & FS_HAS_SUBTYPE) &&
+ !mnt->mnt_sb->s_subtype)
+ mnt = fs_set_subtype(mnt, fstype);
+
+ if (IS_ERR(mnt)) {
+ err = PTR_ERR(mnt);
+ goto err_sc;
+ }
+
+ err = -EPERM;
+ if (mount_too_revealing(mnt, &mnt_flags))
+ goto err_mnt;
+
+ err = do_add_mount(real_mount(mnt), mountpoint, mnt_flags);
+ if (err)
+ goto err_mnt;
}
- err = do_add_mount(real_mount(mnt), path, mnt_flags);
- if (err)
- mntput(mnt);
+ put_sb_config(sc);
+ return 0;
+
+err_mnt:
+ mntput(mnt);
+err_sc:
+ if (sc->error_msg)
+ pr_info("Mount failed: %s\n", sc->error_msg);
+ put_sb_config(sc);
return err;
}
@@ -3058,6 +3160,95 @@ SYSCALL_DEFINE5(mount, char __user *, dev_name, char __user *, dir_name,
return ret;
}
+static struct dentry *__do_mount_sc(struct sb_config *sc)
+{
+ struct super_block *sb;
+ struct dentry *root;
+ int ret;
+
+ root = sc->ops->mount(sc);
+ if (IS_ERR(root))
+ return root;
+
+ sb = root->d_sb;
+ BUG_ON(!sb);
+ WARN_ON(!sb->s_bdi);
+ sb->s_flags |= MS_BORN;
+
+ ret = security_sb_config_kern_mount(sc, sb);
+ if (ret < 0)
+ goto err_sb;
+
+ /*
+ * filesystems should never set s_maxbytes larger than MAX_LFS_FILESIZE
+ * but s_maxbytes was an unsigned long long for many releases. Throw
+ * this warning for a little while to try and catch filesystems that
+ * violate this rule.
+ */
+ WARN((sb->s_maxbytes < 0), "%s set sb->s_maxbytes to "
+ "negative value (%lld)\n", sc->fs_type->name, sb->s_maxbytes);
+
+ up_write(&sb->s_umount);
+ return root;
+
+err_sb:
+ dput(root);
+ deactivate_locked_super(sb);
+ return ERR_PTR(ret);
+}
+
+struct vfsmount *vfs_kern_mount_sc(struct sb_config *sc)
+{
+ struct dentry *root;
+ struct mount *mnt;
+ int ret;
+
+ if (sc->ops->validate) {
+ ret = sc->ops->validate(sc);
+ if (ret < 0)
+ return ERR_PTR(ret);
+ }
+
+ mnt = alloc_vfsmnt(sc->device ?: "none");
+ if (!mnt)
+ return ERR_PTR(-ENOMEM);
+
+ if (sc->ms_flags & MS_KERNMOUNT)
+ mnt->mnt.mnt_flags = MNT_INTERNAL;
+
+ root = __do_mount_sc(sc);
+ if (IS_ERR(root)) {
+ mnt_free_id(mnt);
+ free_vfsmnt(mnt);
+ return ERR_CAST(root);
+ }
+
+ mnt->mnt.mnt_root = root;
+ mnt->mnt.mnt_sb = root->d_sb;
+ mnt->mnt_mountpoint = mnt->mnt.mnt_root;
+ mnt->mnt_parent = mnt;
+ lock_mount_hash();
+ list_add_tail(&mnt->mnt_instance, &root->d_sb->s_mounts);
+ unlock_mount_hash();
+ return &mnt->mnt;
+}
+EXPORT_SYMBOL_GPL(vfs_kern_mount_sc);
+
+struct vfsmount *
+vfs_submount_sc(const struct dentry *mountpoint, struct sb_config *sc)
+{
+ /* Until it is worked out how to pass the user namespace
+ * through from the parent mount to the submount don't support
+ * unprivileged mounts with submounts.
+ */
+ if (mountpoint->d_sb->s_user_ns != &init_user_ns)
+ return ERR_PTR(-EPERM);
+
+ sc->ms_flags = MS_SUBMOUNT;
+ return vfs_kern_mount_sc(sc);
+}
+EXPORT_SYMBOL_GPL(vfs_submount_sc);
+
/*
* Return true if path is reachable from root
*
@@ -3299,6 +3490,23 @@ struct vfsmount *kern_mount_data(struct file_system_type *type, void *data)
}
EXPORT_SYMBOL_GPL(kern_mount_data);
+struct vfsmount *kern_mount_data_sc(struct sb_config *sc)
+{
+ struct vfsmount *mnt;
+
+ sc->ms_flags = MS_KERNMOUNT;
+ mnt = vfs_kern_mount_sc(sc);
+ if (!IS_ERR(mnt)) {
+ /*
+ * it is a longterm mount, don't release mnt until
+ * we unmount before file sys is unregistered
+ */
+ real_mount(mnt)->mnt_ns = MNT_NS_INTERNAL;
+ }
+ return mnt;
+}
+EXPORT_SYMBOL_GPL(kern_mount_data_sc);
+
void kern_unmount(struct vfsmount *mnt)
{
/* release long term mount so mount point can be released */
diff --git a/fs/nfs/nfs4super.c b/fs/nfs/nfs4super.c
index 6fb7cb6b3f4b..967fa04d5c76 100644
--- a/fs/nfs/nfs4super.c
+++ b/fs/nfs/nfs4super.c
@@ -3,6 +3,7 @@
*/
#include <linux/init.h>
#include <linux/module.h>
+#include <linux/mount.h>
#include <linux/nfs4_mount.h>
#include <linux/nfs_fs.h>
#include "delegation.h"
diff --git a/fs/proc/root.c b/fs/proc/root.c
index deecb397daa3..3c47399bd095 100644
--- a/fs/proc/root.c
+++ b/fs/proc/root.c
@@ -19,6 +19,7 @@
#include <linux/bitops.h>
#include <linux/user_namespace.h>
#include <linux/mount.h>
+#include <linux/sb_config.h>
#include <linux/pid_namespace.h>
#include <linux/parser.h>
#include <linux/cred.h>
diff --git a/fs/sb_config.c b/fs/sb_config.c
new file mode 100644
index 000000000000..9c45e269b3cc
--- /dev/null
+++ b/fs/sb_config.c
@@ -0,0 +1,326 @@
+/* Provide a way to create a superblock configuration context within the kernel
+ * that allows a superblock to be set up prior to mounting.
+ *
+ * Copyright (C) 2017 Red Hat, Inc. All Rights Reserved.
+ * Written by David Howells (dhowells@redhat.com)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public Licence
+ * as published by the Free Software Foundation; either version
+ * 2 of the Licence, or (at your option) any later version.
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+#include <linux/sb_config.h>
+#include <linux/fs.h>
+#include <linux/mount.h>
+#include <linux/nsproxy.h>
+#include <linux/slab.h>
+#include <linux/magic.h>
+#include <linux/security.h>
+#include <linux/parser.h>
+#include <linux/mnt_namespace.h>
+#include <linux/pid_namespace.h>
+#include <linux/user_namespace.h>
+#include <net/net_namespace.h>
+#include "mount.h"
+
+static const match_table_t common_set_mount_options = {
+ { MS_DIRSYNC, "dirsync" },
+ { MS_I_VERSION, "iversion" },
+ { MS_LAZYTIME, "lazytime" },
+ { MS_MANDLOCK, "mand" },
+ { MS_NOATIME, "noatime" },
+ { MS_NODEV, "nodev" },
+ { MS_NODIRATIME, "nodiratime" },
+ { MS_NOEXEC, "noexec" },
+ { MS_NOSUID, "nosuid" },
+ { MS_POSIXACL, "posixacl" },
+ { MS_RDONLY, "ro" },
+ { MS_REC, "rec" },
+ { MS_RELATIME, "relatime" },
+ { MS_STRICTATIME, "strictatime" },
+ { MS_SYNCHRONOUS, "sync" },
+ { MS_VERBOSE, "verbose" },
+ { },
+};
+
+static const match_table_t common_clear_mount_options = {
+ { MS_LAZYTIME, "nolazytime" },
+ { MS_MANDLOCK, "nomand" },
+ { MS_NODEV, "dev" },
+ { MS_NOEXEC, "exec" },
+ { MS_NOSUID, "suid" },
+ { MS_RDONLY, "rw" },
+ { MS_RELATIME, "norelatime" },
+ { MS_SILENT, "silent" },
+ { MS_STRICTATIME, "nostrictatime" },
+ { MS_SYNCHRONOUS, "async" },
+ { },
+};
+
+static const match_table_t forbidden_mount_options = {
+ { MS_BIND, "bind" },
+ { MS_MOVE, "move" },
+ { MS_PRIVATE, "private" },
+ { MS_REMOUNT, "remount" },
+ { MS_SHARED, "shared" },
+ { MS_SLAVE, "slave" },
+ { MS_UNBINDABLE, "unbindable" },
+ { },
+};
+
+/*
+ * Check for a common mount option.
+ */
+static int vfs_parse_ms_mount_option(struct sb_config *sc, char *data)
+{
+ substring_t args[MAX_OPT_ARGS];
+ unsigned int token;
+
+ token = match_token(data, common_set_mount_options, args);
+ if (token) {
+ sc->ms_flags |= token;
+ return 1;
+ }
+
+ token = match_token(data, common_clear_mount_options, args);
+ if (token) {
+ sc->ms_flags &= ~token;
+ return 1;
+ }
+
+ token = match_token(data, forbidden_mount_options, args);
+ if (token)
+ return sb_cfg_inval(sc, "Mount option, not superblock option");
+
+ return 0;
+}
+
+/**
+ * vfs_parse_mount_option - Add a single mount option to a superblock config
+ * @mc: The superblock configuration to modify
+ * @p: The option to apply.
+ *
+ * A single mount option in string form is applied to the superblock
+ * configuration being set up. Certain standard options (for example "ro") are
+ * translated into flag bits without going to the filesystem. The active
+ * security module is allowed to observe and poach options. Any other options
+ * are passed over to the filesystem to parse.
+ *
+ * This may be called multiple times for a context.
+ *
+ * Returns 0 on success and a negative error code on failure. In the event of
+ * failure, sc->error may have been set to a non-allocated string that gives
+ * more information.
+ */
+int vfs_parse_mount_option(struct sb_config *sc, char *p)
+{
+ int ret;
+
+ if (sc->mounted)
+ return -EBUSY;
+
+ ret = vfs_parse_ms_mount_option(sc, p);
+ if (ret < 0)
+ return ret;
+ if (ret == 1)
+ return 0;
+
+ ret = security_sb_config_parse_option(sc, p);
+ if (ret < 0)
+ return ret;
+ if (ret == 1)
+ return 0;
+
+ return sc->ops->parse_option(sc, p);
+}
+EXPORT_SYMBOL(vfs_parse_mount_option);
+
+/**
+ * generic_monolithic_mount_data - Parse key[=val][,key[=val]]* mount data
+ * @mc: The superblock configuration to fill in.
+ * @data: The data to parse
+ *
+ * Parse a blob of data that's in key[=val][,key[=val]]* form. This can be
+ * called from the ->monolithic_mount_data() sb_config operation.
+ *
+ * Returns 0 on success or the error returned by the ->parse_option() sb_config
+ * operation on failure.
+ */
+int generic_monolithic_mount_data(struct sb_config *ctx, void *data)
+{
+ char *options = data, *p;
+ int ret;
+
+ if (!options)
+ return 0;
+
+ while ((p = strsep(&options, ",")) != NULL) {
+ if (*p) {
+ ret = vfs_parse_mount_option(ctx, p);
+ if (ret < 0)
+ return ret;
+ }
+ }
+
+ return 0;
+}
+EXPORT_SYMBOL(generic_monolithic_mount_data);
+
+/**
+ * __vfs_new_sb_config - Create a superblock config.
+ * @fs_type: The filesystem type.
+ * @src_sb: A superblock from which this one derives (or NULL)
+ * @ms_flags: Superblock flags and op flags (such as MS_REMOUNT)
+ * @purpose: The purpose that this configuration shall be used for.
+ *
+ * Open a filesystem and create a mount context. The mount context is
+ * initialised with the supplied flags and, if a submount/automount from
+ * another superblock (@src_sb), may have parameters such as namespaces copied
+ * across from that superblock.
+ */
+struct sb_config *__vfs_new_sb_config(struct file_system_type *fs_type,
+ struct super_block *src_sb,
+ unsigned int ms_flags,
+ enum sb_config_purpose purpose)
+{
+ struct sb_config *sc;
+ int ret;
+
+ BUG_ON(fs_type->init_sb_config &&
+ fs_type->sb_config_size < sizeof(*sc));
+
+ sc = kzalloc(max_t(size_t, fs_type->sb_config_size, sizeof(*sc)),
+ GFP_KERNEL);
+ if (!sc)
+ return ERR_PTR(-ENOMEM);
+
+ sc->purpose = purpose;
+ sc->ms_flags = ms_flags;
+ sc->fs_type = get_filesystem(fs_type);
+ sc->net_ns = get_net(current->nsproxy->net_ns);
+ sc->user_ns = get_user_ns(current_user_ns());
+ sc->cred = get_current_cred();
+
+ /* TODO: Make all filesystems support this unconditionally */
+ if (sc->fs_type->init_sb_config) {
+ ret = sc->fs_type->init_sb_config(sc, src_sb);
+ if (ret < 0)
+ goto err_sc;
+ }
+
+ /* Do the security check last because ->fsopen may change the
+ * namespace subscriptions.
+ */
+ ret = security_sb_config_alloc(sc, src_sb);
+ if (ret < 0)
+ goto err_sc;
+
+ return sc;
+
+err_sc:
+ put_sb_config(sc);
+ return ERR_PTR(ret);
+}
+EXPORT_SYMBOL(__vfs_new_sb_config);
+
+/**
+ * vfs_new_sb_config - Create a superblock config for a new mount.
+ * @fs_name: The name of the filesystem
+ *
+ * Open a filesystem and create a superblock config context for a new mount
+ * that will hold the mount options, device name, security details, etc.. Note
+ * that the caller should check the ->ops pointer in the returned context to
+ * determine whether the filesystem actually supports the superblock context
+ * itself.
+ */
+struct sb_config *vfs_new_sb_config(const char *fs_name)
+{
+ struct file_system_type *fs_type;
+ struct sb_config *sc;
+
+ fs_type = get_fs_type(fs_name);
+ if (!fs_type)
+ return ERR_PTR(-ENODEV);
+
+ sc = __vfs_new_sb_config(fs_type, NULL, 0, SB_CONFIG_FOR_NEW);
+ put_filesystem(fs_type);
+ return sc;
+}
+EXPORT_SYMBOL(vfs_new_sb_config);
+
+/**
+ * vfs_sb_reconfig - Create a superblock config for remount/reconfiguration
+ * @mnt: The mountpoint to open
+ * @ms_flags: Superblock flags and op flags (such as MS_REMOUNT)
+ *
+ * Open a mounted filesystem and create a mount context such that a remount can
+ * be effected.
+ */
+struct sb_config *vfs_sb_reconfig(struct vfsmount *mnt,
+ unsigned int ms_flags)
+{
+ return __vfs_new_sb_config(mnt->mnt_sb->s_type, mnt->mnt_sb,
+ ms_flags, SB_CONFIG_FOR_REMOUNT);
+}
+
+/**
+ * vfs_dup_sc_config: Duplicate a superblock configuration context.
+ * @src_sc: The context to copy.
+ */
+struct sb_config *vfs_dup_sb_config(struct sb_config *src_sc)
+{
+ struct sb_config *sc;
+ int ret;
+
+ if (!src_sc->ops->dup)
+ return ERR_PTR(-ENOTSUPP);
+
+ sc = kmemdup(src_sc, src_sc->fs_type->sb_config_size, GFP_KERNEL);
+ if (!sc)
+ return ERR_PTR(-ENOMEM);
+
+ sc->device = NULL;
+ sc->security = NULL;
+ sc->error_msg = NULL;
+ get_filesystem(sc->fs_type);
+ get_net(sc->net_ns);
+ get_user_ns(sc->user_ns);
+ get_cred(sc->cred);
+
+ /* Can't call put until we've called ->dup */
+ ret = sc->ops->dup(sc, src_sc);
+ if (ret < 0)
+ goto err_sc;
+
+ ret = security_sb_config_dup(sc, src_sc);
+ if (ret < 0)
+ goto err_sc;
+ return sc;
+
+err_sc:
+ put_sb_config(sc);
+ return ERR_PTR(ret);
+}
+EXPORT_SYMBOL(vfs_dup_sb_config);
+
+/**
+ * put_sb_config - Dispose of a superblock configuration context.
+ * @sc: The context to dispose of.
+ */
+void put_sb_config(struct sb_config *sc)
+{
+ if (sc->ops && sc->ops->free)
+ sc->ops->free(sc);
+ security_sb_config_free(sc);
+ if (sc->net_ns)
+ put_net(sc->net_ns);
+ put_user_ns(sc->user_ns);
+ if (sc->cred)
+ put_cred(sc->cred);
+ put_filesystem(sc->fs_type);
+ kfree(sc->device);
+ kfree(sc);
+}
+EXPORT_SYMBOL(put_sb_config);
diff --git a/fs/super.c b/fs/super.c
index adb0c0de428c..4d923a775bd0 100644
--- a/fs/super.c
+++ b/fs/super.c
@@ -34,6 +34,7 @@
#include <linux/fsnotify.h>
#include <linux/lockdep.h>
#include <linux/user_namespace.h>
+#include <linux/sb_config.h>
#include "internal.h"
@@ -805,10 +806,13 @@ struct super_block *user_get_super(dev_t dev)
* @flags: numeric part of options
* @data: the rest of options
* @force: whether or not to force the change
+ * @sc: the superblock config for filesystems that support it
+ * (NULL if called from emergency or umount)
*
* Alters the mount options of a mounted file system.
*/
-int do_remount_sb(struct super_block *sb, int flags, void *data, int force)
+int do_remount_sb(struct super_block *sb, int flags, void *data, int force,
+ struct sb_config *sc)
{
int retval;
int remount_ro;
@@ -850,8 +854,14 @@ int do_remount_sb(struct super_block *sb, int flags, void *data, int force)
}
}
- if (sb->s_op->remount_fs) {
- retval = sb->s_op->remount_fs(sb, &flags, data);
+ if (sb->s_op->remount_fs_sc ||
+ sb->s_op->remount_fs) {
+ if (sb->s_op->remount_fs_sc) {
+ retval = sb->s_op->remount_fs_sc(sb, sc);
+ flags = sc->ms_flags;
+ } else {
+ retval = sb->s_op->remount_fs(sb, &flags, data);
+ }
if (retval) {
if (!force)
goto cancel_readonly;
@@ -898,7 +908,7 @@ static void do_emergency_remount(struct work_struct *work)
/*
* What lock protects sb->s_flags??
*/
- do_remount_sb(sb, MS_RDONLY, NULL, 1);
+ do_remount_sb(sb, MS_RDONLY, NULL, 1, NULL);
}
up_write(&sb->s_umount);
spin_lock(&sb_lock);
@@ -1048,6 +1058,40 @@ struct dentry *mount_ns(struct file_system_type *fs_type,
EXPORT_SYMBOL(mount_ns);
+struct dentry *mount_ns_sc(struct sb_config *sc,
+ int (*fill_super)(struct super_block *sb,
+ struct sb_config *sc),
+ void *ns)
+{
+ struct super_block *sb;
+
+ /* Don't allow mounting unless the caller has CAP_SYS_ADMIN
+ * over the namespace.
+ */
+ if (!(sc->ms_flags & MS_KERNMOUNT) &&
+ !ns_capable(sc->user_ns, CAP_SYS_ADMIN))
+ return ERR_PTR(-EPERM);
+
+ sb = sget_userns(sc->fs_type, ns_test_super, ns_set_super,
+ sc->ms_flags, sc->user_ns, ns);
+ if (IS_ERR(sb))
+ return ERR_CAST(sb);
+
+ if (!sb->s_root) {
+ int err;
+ err = fill_super(sb, sc);
+ if (err) {
+ deactivate_locked_super(sb);
+ return ERR_PTR(err);
+ }
+
+ sb->s_flags |= MS_ACTIVE;
+ }
+
+ return dget(sb->s_root);
+}
+EXPORT_SYMBOL(mount_ns_sc);
+
#ifdef CONFIG_BLOCK
static int set_bdev_super(struct super_block *s, void *data)
{
@@ -1196,7 +1240,7 @@ struct dentry *mount_single(struct file_system_type *fs_type,
}
s->s_flags |= MS_ACTIVE;
} else {
- do_remount_sb(s, flags, data, 0);
+ do_remount_sb(s, flags, data, 0, NULL);
}
return dget(s->s_root);
}
diff --git a/include/linux/fs.h b/include/linux/fs.h
index bc0c054894b9..cd6cafcdd2ff 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -54,6 +54,7 @@ struct workqueue_struct;
struct iov_iter;
struct fscrypt_info;
struct fscrypt_operations;
+struct sb_config;
extern void __init inode_init(void);
extern void __init inode_init_early(void);
@@ -701,6 +702,11 @@ static inline void inode_unlock(struct inode *inode)
up_write(&inode->i_rwsem);
}
+static inline int inode_lock_killable(struct inode *inode)
+{
+ return down_write_killable(&inode->i_rwsem);
+}
+
static inline void inode_lock_shared(struct inode *inode)
{
down_read(&inode->i_rwsem);
@@ -1787,6 +1793,7 @@ struct super_operations {
int (*unfreeze_fs) (struct super_block *);
int (*statfs) (struct dentry *, struct kstatfs *);
int (*remount_fs) (struct super_block *, int *, char *);
+ int (*remount_fs_sc) (struct super_block *, struct sb_config *);
void (*umount_begin) (struct super_block *);
int (*show_options)(struct seq_file *, struct dentry *);
@@ -2021,8 +2028,10 @@ struct file_system_type {
#define FS_HAS_SUBTYPE 4
#define FS_USERNS_MOUNT 8 /* Can be mounted by userns root */
#define FS_RENAME_DOES_D_MOVE 32768 /* FS will handle d_move() during rename() internally. */
+ unsigned short sb_config_size; /* Size of superblock config context to allocate */
struct dentry *(*mount) (struct file_system_type *, int,
const char *, void *);
+ int (*init_sb_config)(struct sb_config *, struct super_block *);
void (*kill_sb) (struct super_block *);
struct module *owner;
struct file_system_type * next;
@@ -2040,6 +2049,10 @@ struct file_system_type {
#define MODULE_ALIAS_FS(NAME) MODULE_ALIAS("fs-" NAME)
+extern struct dentry *mount_ns_sc(struct sb_config *mc,
+ int (*fill_super)(struct super_block *sb,
+ struct sb_config *sc),
+ void *ns);
extern struct dentry *mount_ns(struct file_system_type *fs_type,
int flags, void *data, void *ns, struct user_namespace *user_ns,
int (*fill_super)(struct super_block *, void *, int));
@@ -2106,6 +2119,7 @@ extern int register_filesystem(struct file_system_type *);
extern int unregister_filesystem(struct file_system_type *);
extern struct vfsmount *kern_mount_data(struct file_system_type *, void *data);
#define kern_mount(type) kern_mount_data(type, NULL)
+extern struct vfsmount *kern_mount_data_sc(struct sb_config *);
extern void kern_unmount(struct vfsmount *mnt);
extern int may_umount_tree(struct vfsmount *);
extern int may_umount(struct vfsmount *);
diff --git a/include/linux/lsm_hooks.h b/include/linux/lsm_hooks.h
index 080f34e66017..48bfd49666bc 100644
--- a/include/linux/lsm_hooks.h
+++ b/include/linux/lsm_hooks.h
@@ -75,6 +75,33 @@
* should enable secure mode.
* @bprm contains the linux_binprm structure.
*
+ * Security hooks for mount using fd context.
+ *
+ * @sb_config_alloc:
+ * Allocate and attach a security structure to sc->security. This pointer
+ * is initialised to NULL by the caller.
+ * @sc indicates the new superblock configuration context.
+ * @src_sb indicates the source superblock of a submount.
+ * @sb_config_dup:
+ * Allocate and attach a security structure to sc->security. This pointer
+ * is initialised to NULL by the caller.
+ * @sc indicates the new superblock configuration context.
+ * @src_sc indicates the original superblock configuration context.
+ * @sb_config_free:
+ * Clean up a superblock configuration context.
+ * @sc indicates the superblock configuration context.
+ * @sb_config_parse_option:
+ * Userspace provided an option to configure a superblock. The LSM may
+ * reject it with an error and may use it for itself, in which case it
+ * should return 1; otherwise it should return 0 to pass it on to the
+ * filesystem.
+ * @sc indicates the superblock configuration context.
+ * @p indicates the option in "key[=val]" form.
+ * @sb_config_kern_mount:
+ * Equivalent of sb_kern_mount, but with a superblock configuration context.
+ * @sc indicates the superblock configuration context.
+ * @src_sb indicates the new superblock.
+ *
* Security hooks for filesystem operations.
*
* @sb_alloc_security:
@@ -1372,6 +1399,12 @@ union security_list_options {
void (*bprm_committing_creds)(struct linux_binprm *bprm);
void (*bprm_committed_creds)(struct linux_binprm *bprm);
+ int (*sb_config_alloc)(struct sb_config *sc, struct super_block *src_sb);
+ int (*sb_config_dup)(struct sb_config *sc, struct sb_config *src_sc);
+ void (*sb_config_free)(struct sb_config *sc);
+ int (*sb_config_parse_option)(struct sb_config *sc, char *opt);
+ int (*sb_config_kern_mount)(struct sb_config *sc, struct super_block *sb);
+
int (*sb_alloc_security)(struct super_block *sb);
void (*sb_free_security)(struct super_block *sb);
int (*sb_copy_data)(char *orig, char *copy);
@@ -1683,6 +1716,11 @@ struct security_hook_heads {
struct list_head bprm_secureexec;
struct list_head bprm_committing_creds;
struct list_head bprm_committed_creds;
+ struct list_head sb_config_alloc;
+ struct list_head sb_config_dup;
+ struct list_head sb_config_free;
+ struct list_head sb_config_parse_option;
+ struct list_head sb_config_kern_mount;
struct list_head sb_alloc_security;
struct list_head sb_free_security;
struct list_head sb_copy_data;
diff --git a/include/linux/mount.h b/include/linux/mount.h
index 8e0352af06b7..a5dca6abc4d5 100644
--- a/include/linux/mount.h
+++ b/include/linux/mount.h
@@ -20,6 +20,7 @@ struct super_block;
struct vfsmount;
struct dentry;
struct mnt_namespace;
+struct sb_config;
#define MNT_NOSUID 0x01
#define MNT_NODEV 0x02
@@ -90,9 +91,12 @@ struct file_system_type;
extern struct vfsmount *vfs_kern_mount(struct file_system_type *type,
int flags, const char *name,
void *data);
+extern struct vfsmount *vfs_kern_mount_sc(struct sb_config *sc);
extern struct vfsmount *vfs_submount(const struct dentry *mountpoint,
struct file_system_type *type,
const char *name, void *data);
+extern struct vfsmount *vfs_submount_sc(const struct dentry *mountpoint,
+ struct sb_config *sc);
extern void mnt_set_expiry(struct vfsmount *mnt, struct list_head *expiry_list);
extern void mark_mounts_for_expiry(struct list_head *mounts);
diff --git a/include/linux/sb_config.h b/include/linux/sb_config.h
new file mode 100644
index 000000000000..0b21e381d9f0
--- /dev/null
+++ b/include/linux/sb_config.h
@@ -0,0 +1,93 @@
+/* Superblock configuration and creation handling.
+ *
+ * Copyright (C) 2017 Red Hat, Inc. All Rights Reserved.
+ * Written by David Howells (dhowells@redhat.com)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public Licence
+ * as published by the Free Software Foundation; either version
+ * 2 of the Licence, or (at your option) any later version.
+ */
+
+#ifndef _LINUX_SB_CONFIG_H
+#define _LINUX_SB_CONFIG_H
+
+#include <linux/kernel.h>
+#include <linux/errno.h>
+
+struct cred;
+struct dentry;
+struct file_operations;
+struct file_system_type;
+struct mnt_namespace;
+struct net;
+struct pid_namespace;
+struct super_block;
+struct user_namespace;
+struct vfsmount;
+
+enum sb_config_purpose {
+ SB_CONFIG_FOR_NEW, /* New superblock for direct mount */
+ SB_CONFIG_FOR_SUBMOUNT, /* New superblock for automatic submount */
+ SB_CONFIG_FOR_REMOUNT, /* Superblock reconfiguration for remount */
+};
+
+/*
+ * Superblock configuration context as allocated and constructed by the
+ * ->init_sb_config() file_system_type operation. The size of the object
+ * allocated is specified in struct file_system_type::sb_config_size and this
+ * must include sufficient space for the sb_config struct.
+ *
+ * See Documentation/filesystems/mounting.txt
+ */
+struct sb_config {
+ const struct sb_config_operations *ops;
+ struct file_system_type *fs_type;
+ struct user_namespace *user_ns; /* The user namespace for this mount */
+ struct net *net_ns; /* The network namespace for this mount */
+ const struct cred *cred; /* The mounter's credentials */
+ char *device; /* The device name or mount target */
+ void *security; /* The LSM context */
+ const char *error_msg; /* Error string to be read by read() */
+ unsigned int ms_flags; /* The superblock flags (MS_*) */
+ bool mounted; /* Set when mounted */
+ bool sloppy; /* Unrecognised options are okay */
+ bool silent;
+ enum sb_config_purpose purpose : 8;
+};
+
+struct sb_config_operations {
+ void (*free)(struct sb_config *sc);
+ int (*dup)(struct sb_config *sc, struct sb_config *src);
+ int (*parse_option)(struct sb_config *sc, char *p);
+ int (*monolithic_mount_data)(struct sb_config *sc, void *data);
+ int (*validate)(struct sb_config *sc);
+ struct dentry *(*mount)(struct sb_config *sc);
+};
+
+extern const struct file_operations fs_fs_fops;
+
+extern struct sb_config *vfs_new_sb_config(const char *fs_name);
+extern struct sb_config *__vfs_new_sb_config(struct file_system_type *fs_type,
+ struct super_block *src_sb,
+ unsigned int ms_flags,
+ enum sb_config_purpose purpose);
+extern struct sb_config *vfs_sb_reconfig(struct vfsmount *mnt,
+ unsigned int ms_flags);
+extern struct sb_config *vfs_dup_sb_config(struct sb_config *src);
+extern int vfs_parse_mount_option(struct sb_config *sc, char *data);
+extern int generic_monolithic_mount_data(struct sb_config *sc, void *data);
+extern void put_sb_config(struct sb_config *sc);
+
+static inline void sb_cfg_error(struct sb_config *sc, const char *msg)
+{
+ sc->error_msg = msg;
+}
+
+static inline int sb_cfg_inval(struct sb_config *sc, const char *msg)
+{
+ sb_cfg_error(sc, msg);
+ return -EINVAL;
+}
+
+#endif /* _LINUX_SB_CONFIG_H */
diff --git a/include/linux/security.h b/include/linux/security.h
index af675b576645..36b3a6779986 100644
--- a/include/linux/security.h
+++ b/include/linux/security.h
@@ -55,6 +55,7 @@ struct msg_queue;
struct xattr;
struct xfrm_sec_ctx;
struct mm_struct;
+struct sb_config;
/* If capable should audit the security request */
#define SECURITY_CAP_NOAUDIT 0
@@ -224,6 +225,11 @@ int security_bprm_check(struct linux_binprm *bprm);
void security_bprm_committing_creds(struct linux_binprm *bprm);
void security_bprm_committed_creds(struct linux_binprm *bprm);
int security_bprm_secureexec(struct linux_binprm *bprm);
+int security_sb_config_alloc(struct sb_config *sc, struct super_block *sb);
+int security_sb_config_dup(struct sb_config *sc, struct sb_config *src_sc);
+void security_sb_config_free(struct sb_config *sc);
+int security_sb_config_parse_option(struct sb_config *sc, char *opt);
+int security_sb_config_kern_mount(struct sb_config *sc, struct super_block *sb);
int security_sb_alloc(struct super_block *sb);
void security_sb_free(struct super_block *sb);
int security_sb_copy_data(char *orig, char *copy);
@@ -520,6 +526,29 @@ static inline int security_bprm_secureexec(struct linux_binprm *bprm)
return cap_bprm_secureexec(bprm);
}
+static inline int security_sb_config_alloc(struct sb_config *sc,
+ struct super_block *src_sb)
+{
+ return 0;
+}
+static inline int security_sb_config_dup(struct sb_config *sc,
+ struct sb_config *src_sc)
+{
+ return 0;
+}
+static inline void security_sb_config_free(struct sb_config *sc)
+{
+}
+static inline int security_sb_config_parse_option(struct sb_config *sc, char *opt)
+{
+ return 0;
+}
+static inline int security_sb_config_kern_mount(struct sb_config *sc,
+ struct super_block *sb)
+{
+ return 0;
+}
+
static inline int security_sb_alloc(struct super_block *sb)
{
return 0;
diff --git a/security/security.c b/security/security.c
index b9fea3999cf8..3735fad91543 100644
--- a/security/security.c
+++ b/security/security.c
@@ -316,6 +316,31 @@ int security_bprm_secureexec(struct linux_binprm *bprm)
return call_int_hook(bprm_secureexec, 0, bprm);
}
+int security_sb_config_alloc(struct sb_config *sc, struct super_block *src_sb)
+{
+ return call_int_hook(sb_config_alloc, 0, sc, src_sb);
+}
+
+int security_sb_config_dup(struct sb_config *sc, struct sb_config *src_sc)
+{
+ return call_int_hook(sb_config_dup, 0, sc, src_sc);
+}
+
+void security_sb_config_free(struct sb_config *sc)
+{
+ call_void_hook(sb_config_free, sc);
+}
+
+int security_sb_config_parse_option(struct sb_config *sc, char *opt)
+{
+ return call_int_hook(sb_config_parse_option, 0, sc, opt);
+}
+
+int security_sb_config_kern_mount(struct sb_config *sc, struct super_block *sb)
+{
+ return call_int_hook(sb_config_kern_mount, 0, sc, sb);
+}
+
int security_sb_alloc(struct super_block *sb)
{
return call_int_hook(sb_alloc_security, 0, sb);
diff --git a/security/selinux/hooks.c b/security/selinux/hooks.c
index e67a526d1f30..286207bced52 100644
--- a/security/selinux/hooks.c
+++ b/security/selinux/hooks.c
@@ -47,6 +47,7 @@
#include <linux/fdtable.h>
#include <linux/namei.h>
#include <linux/mount.h>
+#include <linux/sb_config.h>
#include <linux/netfilter_ipv4.h>
#include <linux/netfilter_ipv6.h>
#include <linux/tty.h>
@@ -2826,6 +2827,169 @@ static int selinux_umount(struct vfsmount *mnt, int flags)
FILESYSTEM__UNMOUNT, NULL);
}
+/* fsopen mount context operations */
+
+static int selinux_sb_config_alloc(struct sb_config *sc,
+ struct super_block *src_sb)
+{
+ struct security_mnt_opts *opts;
+
+ opts = kzalloc(sizeof(*opts), GFP_KERNEL);
+ if (!opts)
+ return -ENOMEM;
+
+ sc->security = opts;
+ return 0;
+}
+
+static int selinux_sb_config_dup(struct sb_config *sc,
+ struct sb_config *src_sc)
+{
+ const struct security_mnt_opts *src = src_sc->security;
+ struct security_mnt_opts *opts;
+ int i, n;
+
+ opts = kzalloc(sizeof(*opts), GFP_KERNEL);
+ if (!opts)
+ return -ENOMEM;
+ sc->security = opts;
+
+ if (!src || !src->num_mnt_opts)
+ return 0;
+ n = opts->num_mnt_opts = src->num_mnt_opts;
+
+ if (src->mnt_opts) {
+ opts->mnt_opts = kcalloc(n, sizeof(char *), GFP_KERNEL);
+ if (!opts->mnt_opts)
+ return -ENOMEM;
+
+ for (i = 0; i < n; i++) {
+ if (src->mnt_opts[i]) {
+ opts->mnt_opts[i] = kstrdup(src->mnt_opts[i],
+ GFP_KERNEL);
+ if (!opts->mnt_opts[i])
+ return -ENOMEM;
+ }
+ }
+ }
+
+ if (src->mnt_opts_flags) {
+ opts->mnt_opts_flags = kmemdup(src->mnt_opts_flags,
+ n * sizeof(int), GFP_KERNEL);
+ if (!opts->mnt_opts_flags)
+ return -ENOMEM;
+ }
+
+ return 0;
+}
+
+static void selinux_sb_config_free(struct sb_config *sc)
+{
+ struct security_mnt_opts *opts = sc->security;
+
+ security_free_mnt_opts(opts);
+ sc->security = NULL;
+}
+
+static int selinux_sb_config_parse_option(struct sb_config *sc, char *opt)
+{
+ struct security_mnt_opts *opts = sc->security;
+ substring_t args[MAX_OPT_ARGS];
+ unsigned int have;
+ char *c, **oo;
+ int token, ctx, i, *of;
+
+ token = match_token(opt, tokens, args);
+ if (token == Opt_error)
+ return 0; /* Doesn't belong to us. */
+
+ have = 0;
+ for (i = 0; i < opts->num_mnt_opts; i++)
+ have |= 1 << opts->mnt_opts_flags[i];
+ if (have & (1 << token))
+ return sb_cfg_inval(sc, "SELinux: Duplicate mount options");
+
+ switch (token) {
+ case Opt_context:
+ if (have & (1 << Opt_defcontext))
+ goto incompatible;
+ ctx = CONTEXT_MNT;
+ goto copy_context_string;
+
+ case Opt_fscontext:
+ ctx = FSCONTEXT_MNT;
+ goto copy_context_string;
+
+ case Opt_rootcontext:
+ ctx = ROOTCONTEXT_MNT;
+ goto copy_context_string;
+
+ case Opt_defcontext:
+ if (have & (1 << Opt_context))
+ goto incompatible;
+ ctx = DEFCONTEXT_MNT;
+ goto copy_context_string;
+
+ case Opt_labelsupport:
+ return 1;
+
+ default:
+ return sb_cfg_inval(sc, "SELinux: Unknown mount option");
+ }
+
+copy_context_string:
+ if (opts->num_mnt_opts > 3)
+ return sb_cfg_inval(sc, "SELinux: Too many options");
+
+ of = krealloc(opts->mnt_opts_flags,
+ (opts->num_mnt_opts + 1) * sizeof(int), GFP_KERNEL);
+ if (!of)
+ return -ENOMEM;
+ of[opts->num_mnt_opts] = 0;
+ opts->mnt_opts_flags = of;
+
+ oo = krealloc(opts->mnt_opts,
+ (opts->num_mnt_opts + 1) * sizeof(char *), GFP_KERNEL);
+ if (!oo)
+ return -ENOMEM;
+ oo[opts->num_mnt_opts] = NULL;
+ opts->mnt_opts = oo;
+
+ c = match_strdup(&args[0]);
+ if (!c)
+ return -ENOMEM;
+ opts->mnt_opts[opts->num_mnt_opts] = c;
+ opts->mnt_opts_flags[opts->num_mnt_opts] = ctx;
+ opts->num_mnt_opts++;
+ return 1;
+
+incompatible:
+ return sb_cfg_inval(sc, "SELinux: Incompatible mount options");
+}
+
+static int selinux_sb_config_kern_mount(struct sb_config *sc,
+ struct super_block *sb)
+{
+ const struct cred *cred = current_cred();
+ struct common_audit_data ad;
+ int rc;
+
+ rc = selinux_set_mnt_opts(sb, sc->security, 0, NULL);
+ if (rc)
+ return rc;
+
+ /* Allow all mounts performed by the kernel */
+ if (sc->ms_flags & MS_KERNMOUNT)
+ return 0;
+
+ ad.type = LSM_AUDIT_DATA_DENTRY;
+ ad.u.dentry = sb->s_root;
+ rc = superblock_has_perm(cred, sb, FILESYSTEM__MOUNT, &ad);
+ if (rc < 0)
+ sb_cfg_error(sc, "SELinux: Mount of superblock not permitted");
+ return rc;
+}
+
/* inode security operations */
static int selinux_inode_alloc_security(struct inode *inode)
@@ -6154,6 +6318,12 @@ static struct security_hook_list selinux_hooks[] __lsm_ro_after_init = {
LSM_HOOK_INIT(bprm_committed_creds, selinux_bprm_committed_creds),
LSM_HOOK_INIT(bprm_secureexec, selinux_bprm_secureexec),
+ LSM_HOOK_INIT(sb_config_alloc, selinux_sb_config_alloc),
+ LSM_HOOK_INIT(sb_config_dup, selinux_sb_config_dup),
+ LSM_HOOK_INIT(sb_config_free, selinux_sb_config_free),
+ LSM_HOOK_INIT(sb_config_parse_option, selinux_sb_config_parse_option),
+ LSM_HOOK_INIT(sb_config_kern_mount, selinux_sb_config_kern_mount),
+
LSM_HOOK_INIT(sb_alloc_security, selinux_sb_alloc_security),
LSM_HOOK_INIT(sb_free_security, selinux_sb_free_security),
LSM_HOOK_INIT(sb_copy_data, selinux_sb_copy_data),
^ permalink raw reply related [flat|nested] 28+ messages in thread* Re: [PATCH 06/21] VFS: Introduce a superblock configuration context [ver #3]
2017-05-15 15:19 ` [PATCH 06/21] VFS: Introduce a superblock configuration context " David Howells
@ 2017-05-16 15:10 ` Miklos Szeredi
2017-05-16 16:33 ` David Howells
1 sibling, 0 replies; 28+ messages in thread
From: Miklos Szeredi @ 2017-05-16 15:10 UTC (permalink / raw)
To: David Howells; +Cc: viro, Jeff Layton, linux-fsdevel, linux-nfs, lkml
On Mon, May 15, 2017 at 5:19 PM, David Howells <dhowells@redhat.com> wrote:
> Introduce a superblock configuration context concept to be used during
> superblock creation for mount and superblock reconfiguration for remount.
> This is allocated at the beginning of the mount procedure and into it is
> placed:
>
> (1) Filesystem type.
>
> (2) Namespaces.
>
> (3) Device name.
>
> (4) Superblock flags (MS_*).
>
> (5) Security details.
>
> (6) Filesystem-specific data, as set by the mount options.
>
> It also gives a place in which to hang an error message for later retrieval
> (see the mount-by-fd syscall later in this series).
>
> Rather than calling fs_type->mount(), an sb_config struct is created and
> fs_type->init_sb_config() is called to set it up. fs_type->sb_config_size
> says how much space should be allocated for the config context. The
> sb_config struct is placed at the beginning and any extra space is for the
> filesystem's use.
>
> A set of operations have to be set by ->init_sb_config() to provide
> freeing, duplication, option parsing, binary data parsing, validation,
> mounting and superblock filling.
>
> It should be noted that, whilst this patch adds a lot of lines of code,
> there is quite a bit of duplication with existing code that can be
> eliminated should all filesystems be converted over.
<high level musings>
One way to split this large patch up into more managable chunks would be:
1) common infrastructure
2) new mount related changes
3) reconfig (remount) related changes
Would that work?
We currently have the following modes of operation:
(a) new mount with new super block created
(b) new mount with existing super block reused
(c) remount
In addition you there's a "submount" mode that is a subtype of the
"new mount" ones, but AFAICS it doesn't make a difference in how
options are parsed.
Question is, how the actual superblock options are calculated from the
given options. Currently we have
Case (a):
1) start out with the default options for the superblock
2) modify options ("foo" turns option on, "nofoo" turns it off)
3) create sb
Case (b):
1) find superblock based on some options
1) ignore other options
Case (c):
1) start out with the current options for the superblock
2) modify options ("foo" turns option on, "nofoo" turns it off)
3) commit changes to sb
The surprising thing here is that we do (a) and (b) via the same route
and (a) and (c) via a different ones. This doesn't feel right.
What we've largely ignored is the fact that there are several classes
of options that act completely differently:
i) options that determine the sb instance (such as the blockdev or
the server IP address)
ii) subpath: this can determine the sb as well as the subtree to use
iii) options that can be changed while sb in use
iv) ???
Would it make sense to make the "new mount" case be
A) find or create sb based on (i) and (ii) options
B) reconfigure the resulting sb based on (iii) options
This would make legacy new mount be: (A) + if new then (B). And
legacy remount just (B).
Also I think silently ignoring options is not always the right answer.
The user of the new uapi should at least have the option of knowing if
this is a new filesystem instance or essentially a bind mount without
any sb configuration. Maybe an O_EXCL type flag would do.
</high level musings>
More comments inline...
>
> Signed-off-by: David Howells <dhowells@redhat.com>
> ---
>
> Documentation/filesystems/mounting.txt | 456 ++++++++++++++++++++++++++++++++
> fs/Makefile | 3
> fs/internal.h | 2
> fs/libfs.c | 1
> fs/namespace.c | 256 ++++++++++++++++--
> fs/nfs/nfs4super.c | 1
> fs/proc/root.c | 1
> fs/sb_config.c | 326 +++++++++++++++++++++++
> fs/super.c | 54 +++-
> include/linux/fs.h | 14 +
> include/linux/lsm_hooks.h | 38 +++
> include/linux/mount.h | 4
> include/linux/sb_config.h | 93 +++++++
> include/linux/security.h | 29 ++
> security/security.c | 25 ++
> security/selinux/hooks.c | 170 ++++++++++++
> 16 files changed, 1442 insertions(+), 31 deletions(-)
> create mode 100644 Documentation/filesystems/mounting.txt
> create mode 100644 fs/sb_config.c
> create mode 100644 include/linux/sb_config.h
>
> diff --git a/Documentation/filesystems/mounting.txt b/Documentation/filesystems/mounting.txt
> new file mode 100644
> index 000000000000..03e9086f754d
> --- /dev/null
> +++ b/Documentation/filesystems/mounting.txt
> @@ -0,0 +1,456 @@
> + ===================
> + FILESYSTEM MOUNTING
> + ===================
> +
> +CONTENTS
> +
> + (1) Overview.
> +
> + (2) The superblock configuration context.
> +
> + (3) The superblock config operations.
> +
> + (4) Superblock config security.
> +
> + (5) VFS superblock config operations.
> +
> +
> +========
> +OVERVIEW
> +========
> +
> +The creation of new mounts is now to be done in a multistep process:
> +
> + (1) Create a superblock configuration context.
> +
> + (2) Parse the options and attach them to the context. Options may be passed
> + individually from userspace.
> +
> + (3) Validate and pre-process the context.
> +
> + (4) Get or create a superblock and mountable root.
> +
> + (5) Perform the mount.
> +
> + (6) Return an error message attached to the context.
> +
> + (7) Destroy the context.
> +
> +To support this, the file_system_type struct gains two new fields:
> +
> + unsigned short sb_config_size;
> +
> +which indicates the total amount of space that should be allocated for context
> +data (see the Superblock Configuration Context section), and:
> +
> + int (*init_sb_config)(struct sb_config *sc, struct super_block *src_sb);
> +
> +which is invoked to set up the filesystem-specific parts of a superblock
> +configuration context, including the additional space. The src_sb parameter is
> +used to convey the superblock from which the filesystem may draw extra
> +information (such as namespaces), for submount (SB_CONFIG_FOR_SUBMOUNT) or
> +remount (SB_CONFIG_FOR_REMOUNT) purposes or it will be NULL.
> +
> +Note that security initialisation is done *after* the filesystem is called so
> +that the namespaces may be adjusted first.
> +
> +And the super_operations struct gains one:
> +
> + int (*remount_fs_sc) (struct super_block *, struct sb_config *);
How about reconfig_fs() or just reconfig()?
> +
> +This shadows the ->remount_fs() operation and takes a prepared superblock
> +configuration context instead of the mount flags and data page. It may modify
> +the ms_flags in the context for the caller to pick up.
> +
> +[NOTE] remount_fs_sc is intended as a replacement for remount_fs.
> +
> +
> +====================================
> +THE SUPERBLOCK CONFIGURATION CONTEXT
> +====================================
> +
> +The creation and reconfiguration of a superblock is governed by a superblock
> +configuration context. This is represented by the sb_config structure:
> +
> + struct sb_config {
> + const struct sb_config_operations *ops;
> + struct file_system_type *fs;
> + struct user_namespace *user_ns;
> + struct net *net_ns;
> + const struct cred *cred;
> + char *device;
> + void *security;
> + const char *error_msg;
> + unsigned int ms_flags;
> + bool mounted;
> + bool sloppy;
> + bool silent;
> + enum mount_type mount_type : 8;
> + };
> +
> +When the VFS creates this, it allocates ->sb_config_size bytes (as specified by
> +the file_system_type object) to hold both the sb_config struct and any extra
> +data required by the filesystem. The sb_config struct is placed at the
> +beginning of this space. Any extra space beyond that is for use by the
> +filesystem. The filesystem should wrap the struct in its own, e.g.:
> +
> + struct nfs_sb_config {
> + struct sb_config sc;
> + ...
> + };
> +
> +placing the sb_config struct first. container_of() can then be used. The
> +file_system_type would be initialised thus:
> +
> + struct file_system_type nfs = {
> + ...
> + .sb_config_size = sizeof(struct nfs_sb_config),
> + .init_sb_config = nfs_init_sb_config,
> + ...
> + };
> +
> +The sb_config fields are as follows:
> +
> + (*) const struct sb_config_operations *ops
> +
> + These are operations that can be done on a superblock configuration
> + context (see below). This must be set by the ->init_sb_config()
> + file_system_type operation.
> +
> + (*) struct file_system_type *fs
> +
> + A pointer to the file_system_type of the filesystem that is being
> + constructed or reconfigured. This retains a ref on the type owner.
> +
> + (*) struct user_namespace *user_ns
> + (*) struct net *net_ns
> +
> + This is a subset of the namespaces in use by the invoking process. This
> + retains a ref on each namespace. The subscribed namespaces may be
> + replaced by the filesystem to reflect other sources, such as the parent
> + mount superblock on an automount.
> +
> + (*) struct cred *cred
> +
> + The mounter's credentials. This retains a ref on the credentials.
> +
> + (*) char *device
> +
> + This is the device to be mounted. It may be a block device
> + (e.g. /dev/sda1) or something more exotic, such as the "host:/path" that
> + NFS desires.
> +
> + (*) void *security
> +
> + A place for the LSMs to hang their security data for the superblock. The
> + relevant security operations are described below.
> +
> + (*) const char *error_msg
> +
> + A place for the VFS and the filesystem to hang an error message. This
> + should be in the form of a static string that doesn't need deallocation
> + and the pointer to which can just be overwritten. Under some
> + circumstances, this can be retrieved by userspace.
> +
> + Note that the existence of the error string is expected to be guaranteed
> + by the reference on the file_system_type object held by ->fs or any
> + filesystem-specific reference held in the filesystem context until the
> + ->free() operation is called.
> +
> + Use sb_cfg_error() and sb_cfg_inval() to set this rather than setting it
> + directly.
> +
> + (*) unsigned int ms_flags
> +
> + This holds the MS_* flags mount flags.
> +
> + (*) bool mounted
> +
> + This is set to true once a mount attempt is made. This causes an error to
> + be given on subsequent mount attempts with the same context and prevents
> + multiple mount attempts.
> +
> + (*) bool sloppy
> + (*) bool silent
> +
> + These are set if the sloppy or silent mount options are given.
> +
> + [NOTE] sloppy is probably unnecessary when userspace passes over one
> + option at a time since the error can just be ignored if userspace deems it
> + to be unimportant.
> +
> + [NOTE] silent is probably redundant with ms_flags & MS_SILENT.
> +
> + (*) enum mount_type
> +
> + This indicates the type of mount operation. The available values are:
> +
> + SB_CONFIG_FOR_NEW -- New mount
> + SB_CONFIG_FOR_SUBMOUNT -- New automatic submount of extant mount
> + SB_CONFIG_FOR_REMOUNT -- Change an existing mount
> +
> +The mount context is created by calling __vfs_new_sb_config(),
> +vfs_new_sb_config(), vfs_sb_reconfig() or vfs_dup_sb_config() and is destroyed
> +with put_sb_config(). Note that the structure is not refcounted.
> +
> +VFS, security and filesystem mount options are set individually with
> +vfs_parse_mount_option() or in bulk with generic_monolithic_mount_data().
> +
> +When mounting, the filesystem is allowed to take data from any of the pointers
> +and attach it to the superblock (or whatever), provided it clears the pointer
> +in the mount context.
> +
> +The filesystem is also allowed to allocate resources and pin them with the
> +mount context. For instance, NFS might pin the appropriate protocol version
> +module.
> +
> +
> +================================
> +THE SUPERBLOCK CONFIG OPERATIONS
> +================================
> +
> +The superblock configuration context points to a table of operations:
> +
> + struct sb_config_operations {
> + void (*free)(struct sb_config *sc);
> + int (*dup)(struct sb_config *sc, struct sb_config *src_sc);
> + int (*parse_option)(struct sb_config *sc, char *p);
> + int (*monolithic_mount_data)(struct sb_config *sc, void *data);
> + int (*validate)(struct sb_config *sc);
> + struct dentry *(*mount)(struct sb_config *sc);
> + };
> +
> +These operations are invoked by the various stages of the mount procedure to
> +manage the superblock configuration context. They are as follows:
> +
> + (*) void (*free)(struct sb_config *sc);
> +
> + Called to clean up the filesystem-specific part of the superblock
> + configuration context when the context is destroyed. It should be aware
> + that parts of the context may have been removed and NULL'd out by
> + ->mount().
> +
> + (*) int (*dup)(struct sb_config *sc, struct sb_config *src_sc);
> +
> + Called when a superblock configuration context has been duplicated to get
> + any refs or copy any non-referenced resources held in the
> + filesystem-specific part of the superblock configuration context. An
> + error may be returned to indicate failure to do this.
> +
> + [!] Note that even if this fails, put_sb_config() will be called
> + immediately thereafter, so ->dup() *must* make the filesystem-specific
> + part safe for ->free().
> +
> + (*) int (*parse_option)(struct sb_config *sc, char *p);
> +
> + Called when an option is to be added to the superblock configuration
> + context. p points to the option string, likely in "key[=val]" format.
> + VFS-specific options will have been weeded out and sc->ms_flags updated in
> + the context. Security options will also have been weeded out and
> + sc->security updated.
> +
> + If successful, 0 should be returned and a negative error code otherwise.
> + If an ambiguous error (such as -EINVAL) is returned, sb_cfg_error() or
> + sb_cfg_inval() should be used to provide a string that provides more
> + information.
> +
> + (*) int (*monolithic_mount_data)(struct sb_config *sc, void *data);
> +
> + Called when the mount(2) system call is invoked to pass the entire data
> + page in one go. If this is expected to be just a list of "key[=val]"
> + items separated by commas, then this may be set to NULL.
> +
> + The return value is as for ->parse_option().
> +
> + If the filesystem (eg. NFS) needs to examine the data first and then
> + finds it's the standard key-val list then it may pass it off to:
> +
> + int generic_monolithic_mount_data(struct sb_config *sc, void *data);
> +
> + (*) int (*validate)(struct sb_config *sc);
> +
> + Called when all the options have been applied and the mount is about to
> + take place. It is should check for inconsistencies from mount options
> + and it is also allowed to do preliminary resource acquisition. For
> + instance, the core NFS module could load the NFS protocol module here.
> +
> + Note that if sc->mount_type == SB_CONFIG_FOR_REMOUNT, some of the options
> + necessary for a new mount may not be set.
> +
> + The return value is as for ->parse_option().
> +
> + (*) struct dentry *(*mount)(struct sb_config *sc);
I'd be much happier with "get_root()" or something.
> +
> + Called to effect a new mount or new submount using the information stored
> + in the superblock configuration context (remounts go via a different
> + vector). It may detach any resources it desires from the superblock
> + configuration context and transfer them to the superblock it creates.
> +
> + On success it should return the dentry that's at the root of the mount.
> + In future, sc->root_path will then be applied to this.
> +
> + In the case of an error, it should return a negative error code and invoke
> + sb_cfg_inval() or sb_cfg_error().
> +
> +
> +=========================================
> +SUPERBLOCK CONFIGURATION CONTEXT SECURITY
> +========================================
> +
> +The superblock configuration context contains a security points that the LSMs can use for
> +building up a security context for the superblock to be mounted. There are a
> +number of operations used by the new mount code for this purpose:
> +
> + (*) int security_sb_config_alloc(struct sb_config *sc,
> + struct super_block *src_sb);
> +
> + Called to initialise sc->security (which is preset to NULL) and allocate
> + any resources needed. It should return 0 on success and a negative error
> + code on failure.
> +
> + src_sb is non-NULL in the case of a remount (SB_CONFIG_FOR_REMOUNT) in
> + which case it indicates the superblock to be remounted or in the case of a
> + submount (SB_CONFIG_FOR_SUBMOUNT) in which case it indicates the parent
> + superblock.
> +
> + (*) int security_sb_config_dup(struct sb_config *sc,
> + struct sb_config *src_mc);
> +
> + Called to initialise sc->security (which is preset to NULL) and allocate
> + any resources needed. The original superblock configuration context is pointed to by src_mc
> + and may be used for reference. It should return 0 on success and a
> + negative error code on failure.
> +
> + (*) void security_sb_config_free(struct sb_config *sc);
> +
> + Called to clean up anything attached to sc->security. Note that the
> + contents may have been transferred to a superblock and the pointer NULL'd
> + out during mount.
> +
> + (*) int security_sb_config_parse_option(struct sb_config *sc, char *opt);
> +
> + Called for each mount option. The mount options are in "key[=val]"
> + form. An active LSM may reject one with an error, pass one over and
> + return 0 or consume one and return 1. If consumed, the option isn't
> + passed on to the filesystem.
> +
> + If it returns an error, more information can be returned with
> + sb_cfg_inval() or sb_cfg_error().
> +
> + (*) int security_sb_get_tree(struct sb_config *sc);
> +
> + Called during the mount procedure to verify that the specified superblock
> + is allowed to be mounted and to transfer the security data there.
> +
> + On success, it should return 0; otherwise it should return an error and
> + perhaps call sb_cfg_inval() or sb_cfg_error() to indicate the problem. It
> + should not return -ENOMEM as this should be taken care of in advance.
> +
> + [NOTE] Should I add a security_sb_config_validate() operation so that the
> + LSM has the opportunity to allocate stuff and check the options as a
> + whole?
> +
> +
> +================================
> +VFS SUPERBLOCK CONFIG OPERATIONS
> +================================
> +
> +There are four operations for creating a superblock configuration context and
> +one for destroying a context:
> +
> + (*) struct sb_config *__vfs_new_sb_config(struct file_system_type *fs_type,
> + struct super_block *src_sb;
> + unsigned int ms_flags);
> +
> + Create a superblock configuration context given a filesystem type pointer.
> + This allocates the superblock configuration context, sets the flags,
> + initialises the security and calls fs_type->init_sb_config() to initialise
> + the filesystem context.
> +
> + src_sb can be NULL or it may indicate a superblock that is going to be
> + remounted (SB_CONFIG_FOR_REMOUNT) or a superblock that is the parent of a
> + submount (SB_CONFIG_FOR_SUBMOUNT). This superblock is provided as a
> + source of namespace information.
> +
> + (*) struct sb_config *vfs_sb_reconfig(struct vfsmount *mnt,
> + unsigned int ms_flags);
> +
> + Create a superblock configuration context from the same filesystem as an
> + extant mount and initialise the mount parameters from the superblock
> + underlying that mount. This is for use by remount.
> +
> + (*) struct sb_config *vfs_fsopen(const char *fs_name);
> +
> + Create a superblock configuration context given a filesystem name. It is
> + assumed that the mount flags will be passed in as text options or set
> + directly later. This is intended to be called from sys_mount() or
> + sys_fsopen(). This copies current's namespaces to the superblock
> + configuration context.
> +
> + (*) struct sb_config *vfs_dup_sb_config(struct sb_config *src_sc);
> +
> + Duplicate a superblock configuration context, copying any options noted
> + and duplicating or additionally referencing any resources held therein.
> + This is available for use where a filesystem has to get a mount within a
> + mount, such as NFS4 does by internally mounting the root of the target
> + server and then doing a private pathwalk to the target directory.
> +
> + (*) void put_sb_config(struct sb_config *sc);
> +
> + Destroy a superblock configuration context, releasing any resources it
> + holds. This calls the ->free() operation. This is intended to be called
> + by anyone who created a superblock configuration context.
> +
> + [!] superblock configuration contexts are not refcounted, so this causes
> + unconditional destruction.
> +
> +In all the above operations, apart from the put op, the return is a mount
> +context pointer or a negative error code. No error string is saved as the
> +error string is only guaranteed as long as the file_system_type is pinned (and
> +thus the module).
> +
> +The next operations can be used to cache an error message in the context for
> +the caller to collect.
> +
> + (*) void sb_cfg_error(struct sb_config *sc, const char *msg);
> +
> + Set an error message for the caller to pick up. For lifetime rules, see
> + the ->error_msg member description.
> +
> + (*) void sb_cfg_inval(struct sb_config *sc, const char *msg);
> +
> + As sb_cfg_error(), but returns -EINVAL for use with tail calling.
> +
> +In the remaining operations, if an error occurs, a negative error code is
> +returned and, if not obvious, sc->error_msg may have been set to point to a
> +useful string. This string should not be freed.
> +
> + (*) struct vfsmount *vfs_kern_mount_sc(struct sb_config *sc);
> +
> + Create a mount given the parameters in the specified superblock
> + configuration context. This invokes the ->validate() op and then the
> + ->mount() op.
> +
> + (*) struct vfsmount *vfs_submount_sc(const struct dentry *mountpoint,
> + struct sb_config *sc);
> +
> + Create a mount given a superblock configuration context and set
> + MS_SUBMOUNT on it. A wrapper around vfs_kern_mount_sc(). This is
> + intended to be called from filesystems that have automount points (NFS,
> + AFS, ...).
> +
> + (*) int vfs_parse_mount_option(struct sb_config *sc, char *data);
> +
> + Supply a single mount option to the superblock configuration context. The
> + mount option should likely be in a "key[=val]" string form. The option is
> + first checked to see if it corresponds to a standard mount flag (in which
> + case it is used to mark an MS_xxx flag and consumed) or a security option
> + (in which case the LSM consumes it) before it is passed on to the
> + filesystem.
> +
> + (*) int generic_monolithic_mount_data(struct sb_config *sc, void *data);
> +
> + Parse a sys_mount() data page, assuming the form to be a text list
> + consisting of key[=val] options separated by commas. Each item in the
> + list is passed to vfs_mount_option(). This is the default when the
> + ->monolithic_mount_data() operation is NULL.
> diff --git a/fs/Makefile b/fs/Makefile
> index 7bbaca9c67b1..8f5142525866 100644
> --- a/fs/Makefile
> +++ b/fs/Makefile
> @@ -11,7 +11,8 @@ obj-y := open.o read_write.o file_table.o super.o \
> attr.o bad_inode.o file.o filesystems.o namespace.o \
> seq_file.o xattr.o libfs.o fs-writeback.o \
> pnode.o splice.o sync.o utimes.o \
> - stack.o fs_struct.o statfs.o fs_pin.o nsfs.o
> + stack.o fs_struct.o statfs.o fs_pin.o nsfs.o \
> + sb_config.o
>
> ifeq ($(CONFIG_BLOCK),y)
> obj-y += buffer.o block_dev.o direct-io.o mpage.o
> diff --git a/fs/internal.h b/fs/internal.h
> index 9676fe11c093..39121a99d930 100644
> --- a/fs/internal.h
> +++ b/fs/internal.h
> @@ -87,7 +87,7 @@ extern struct file *get_empty_filp(void);
> /*
> * super.c
> */
> -extern int do_remount_sb(struct super_block *, int, void *, int);
> +extern int do_remount_sb(struct super_block *, int, void *, int, struct sb_config *);
> extern bool trylock_super(struct super_block *sb);
> extern struct dentry *mount_fs(struct file_system_type *,
> int, const char *, void *);
> diff --git a/fs/libfs.c b/fs/libfs.c
> index a04395334bb1..8ef519709ee3 100644
> --- a/fs/libfs.c
> +++ b/fs/libfs.c
> @@ -9,6 +9,7 @@
> #include <linux/slab.h>
> #include <linux/cred.h>
> #include <linux/mount.h>
> +#include <linux/sb_config.h>
> #include <linux/vfs.h>
> #include <linux/quotaops.h>
> #include <linux/mutex.h>
> diff --git a/fs/namespace.c b/fs/namespace.c
> index c076787871e7..91f8a07532cd 100644
> --- a/fs/namespace.c
> +++ b/fs/namespace.c
> @@ -25,7 +25,9 @@
> #include <linux/magic.h>
> #include <linux/bootmem.h>
> #include <linux/task_work.h>
> +#include <linux/file.h>
> #include <linux/sched/task.h>
> +#include <linux/sb_config.h>
>
> #include "pnode.h"
> #include "internal.h"
> @@ -1593,7 +1595,7 @@ static int do_umount(struct mount *mnt, int flags)
> return -EPERM;
> down_write(&sb->s_umount);
> if (!(sb->s_flags & MS_RDONLY))
> - retval = do_remount_sb(sb, MS_RDONLY, NULL, 0);
> + retval = do_remount_sb(sb, MS_RDONLY, NULL, 0, NULL);
> up_write(&sb->s_umount);
> return retval;
> }
> @@ -2276,6 +2278,26 @@ static int change_mount_flags(struct vfsmount *mnt, int ms_flags)
> }
>
> /*
> + * Parse the monolithic page of mount data given to sys_mount().
> + */
> +static int parse_monolithic_mount_data(struct sb_config *sc, void *data)
> +{
> + int (*monolithic_mount_data)(struct sb_config *, void *);
> + int ret;
> +
> + monolithic_mount_data = sc->ops->monolithic_mount_data;
> + if (!monolithic_mount_data)
> + monolithic_mount_data = generic_monolithic_mount_data;
> +
> + ret = monolithic_mount_data(sc, data);
> + if (ret < 0)
> + return ret;
> + if (sc->ops->validate)
> + return sc->ops->validate(sc);
> + return 0;
> +}
> +
> +/*
> * change filesystem flags. dir should be a physical root of filesystem.
> * If you've mounted a non-root directory somewhere and want to do remount
> * on it - tough luck.
> @@ -2283,13 +2305,14 @@ static int change_mount_flags(struct vfsmount *mnt, int ms_flags)
> static int do_remount(struct path *path, int flags, int mnt_flags,
> void *data)
> {
> + struct sb_config *sc = NULL;
> int err;
> struct super_block *sb = path->mnt->mnt_sb;
> struct mount *mnt = real_mount(path->mnt);
> + struct file_system_type *type = sb->s_type;
>
> if (!check_mnt(mnt))
> return -EINVAL;
> -
> if (path->dentry != path->mnt->mnt_root)
> return -EINVAL;
>
> @@ -2320,9 +2343,19 @@ static int do_remount(struct path *path, int flags, int mnt_flags,
> return -EPERM;
> }
>
> - err = security_sb_remount(sb, data);
> - if (err)
> - return err;
> + if (type->init_sb_config) {
> + sc = vfs_sb_reconfig(path->mnt, flags);
> + if (IS_ERR(sc))
> + return PTR_ERR(sc);
> +
> + err = parse_monolithic_mount_data(sc, data);
> + if (err < 0)
> + goto err_sc;
If filesystem defines ->monolithic_mount_data() who is responsible for
calling the security hook?
> + } else {
> + err = security_sb_remount(sb, data);
> + if (err)
> + return err;
> + }
>
> down_write(&sb->s_umount);
> if (flags & MS_BIND)
> @@ -2330,7 +2363,7 @@ static int do_remount(struct path *path, int flags, int mnt_flags,
> else if (!capable(CAP_SYS_ADMIN))
> err = -EPERM;
> else
> - err = do_remount_sb(sb, flags, data, 0);
> + err = do_remount_sb(sb, flags, data, 0, sc);
> if (!err) {
> lock_mount_hash();
> mnt_flags |= mnt->mnt.mnt_flags & ~MNT_USER_SETTABLE_MASK;
> @@ -2339,6 +2372,9 @@ static int do_remount(struct path *path, int flags, int mnt_flags,
> unlock_mount_hash();
> }
> up_write(&sb->s_umount);
> +err_sc:
> + if (sc)
> + put_sb_config(sc);
> return err;
> }
>
> @@ -2492,40 +2528,106 @@ static int do_add_mount(struct mount *newmnt, struct path *path, int mnt_flags)
> static bool mount_too_revealing(struct vfsmount *mnt, int *new_mnt_flags);
>
> /*
> + * Create a new mount using a superblock configuration and request it
> + * be added to the namespace tree.
> + */
> +static int do_new_mount_sc(struct sb_config *sc, struct path *mountpoint,
> + unsigned int mnt_flags)
> +{
> + struct vfsmount *mnt;
> + int ret;
> +
> + mnt = vfs_kern_mount_sc(sc);
> + if (IS_ERR(mnt))
> + return PTR_ERR(mnt);
> +
> + if ((sc->fs_type->fs_flags & FS_HAS_SUBTYPE) &&
> + !mnt->mnt_sb->s_subtype) {
> + mnt = fs_set_subtype(mnt, sc->fs_type->name);
> + if (IS_ERR(mnt))
> + return PTR_ERR(mnt);
> + }
> +
> + ret = -EPERM;
> + if (mount_too_revealing(mnt, &mnt_flags)) {
> + sb_cfg_error(sc, "VFS: Mount too revealing");
> + goto err_mnt;
> + }
> +
> + ret = do_add_mount(real_mount(mnt), mountpoint, mnt_flags);
> + if (ret < 0) {
> + sb_cfg_error(sc, "VFS: Failed to add mount");
> + goto err_mnt;
> + }
> + return ret;
> +
> +err_mnt:
> + mntput(mnt);
> + return ret;
> +}
> +
> +/*
> * create a new mount for userspace and request it to be added into the
> * namespace's tree
> */
> -static int do_new_mount(struct path *path, const char *fstype, int flags,
> +static int do_new_mount(struct path *mountpoint, const char *fstype, int flags,
> int mnt_flags, const char *name, void *data)
> {
> - struct file_system_type *type;
> + struct sb_config *sc;
> struct vfsmount *mnt;
> int err;
>
> if (!fstype)
> return -EINVAL;
>
> - type = get_fs_type(fstype);
> - if (!type)
> - return -ENODEV;
> + sc = vfs_new_sb_config(fstype);
> + if (IS_ERR(sc))
> + return PTR_ERR(sc);
> + sc->ms_flags = flags;
>
> - mnt = vfs_kern_mount(type, flags, name, data);
> - if (!IS_ERR(mnt) && (type->fs_flags & FS_HAS_SUBTYPE) &&
> - !mnt->mnt_sb->s_subtype)
> - mnt = fs_set_subtype(mnt, fstype);
> + err = -ENOMEM;
> + sc->device = kstrdup(name, GFP_KERNEL);
> + if (!sc->device)
> + goto err_sc;
>
> - put_filesystem(type);
> - if (IS_ERR(mnt))
> - return PTR_ERR(mnt);
> + if (sc->ops) {
> + err = parse_monolithic_mount_data(sc, data);
> + if (err < 0)
> + goto err_sc;
>
> - if (mount_too_revealing(mnt, &mnt_flags)) {
> - mntput(mnt);
> - return -EPERM;
> + err = do_new_mount_sc(sc, mountpoint, mnt_flags);
> + if (err)
> + goto err_sc;
> +
> + } else {
> + mnt = vfs_kern_mount(sc->fs_type, flags, name, data);
> + if (!IS_ERR(mnt) && (sc->fs_type->fs_flags & FS_HAS_SUBTYPE) &&
> + !mnt->mnt_sb->s_subtype)
> + mnt = fs_set_subtype(mnt, fstype);
> +
> + if (IS_ERR(mnt)) {
> + err = PTR_ERR(mnt);
> + goto err_sc;
> + }
> +
> + err = -EPERM;
> + if (mount_too_revealing(mnt, &mnt_flags))
> + goto err_mnt;
> +
> + err = do_add_mount(real_mount(mnt), mountpoint, mnt_flags);
> + if (err)
> + goto err_mnt;
Largely duplicated do_new_mount_sc(). What's the point?
> }
>
> - err = do_add_mount(real_mount(mnt), path, mnt_flags);
> - if (err)
> - mntput(mnt);
> + put_sb_config(sc);
> + return 0;
> +
> +err_mnt:
> + mntput(mnt);
> +err_sc:
> + if (sc->error_msg)
> + pr_info("Mount failed: %s\n", sc->error_msg);
> + put_sb_config(sc);
> return err;
> }
>
> @@ -3058,6 +3160,95 @@ SYSCALL_DEFINE5(mount, char __user *, dev_name, char __user *, dir_name,
> return ret;
> }
>
> +static struct dentry *__do_mount_sc(struct sb_config *sc)
> +{
> + struct super_block *sb;
> + struct dentry *root;
> + int ret;
> +
> + root = sc->ops->mount(sc);
> + if (IS_ERR(root))
> + return root;
> +
> + sb = root->d_sb;
> + BUG_ON(!sb);
> + WARN_ON(!sb->s_bdi);
> + sb->s_flags |= MS_BORN;
> +
> + ret = security_sb_config_kern_mount(sc, sb);
> + if (ret < 0)
> + goto err_sb;
> +
> + /*
> + * filesystems should never set s_maxbytes larger than MAX_LFS_FILESIZE
> + * but s_maxbytes was an unsigned long long for many releases. Throw
> + * this warning for a little while to try and catch filesystems that
> + * violate this rule.
> + */
> + WARN((sb->s_maxbytes < 0), "%s set sb->s_maxbytes to "
> + "negative value (%lld)\n", sc->fs_type->name, sb->s_maxbytes);
> +
> + up_write(&sb->s_umount);
> + return root;
> +
> +err_sb:
> + dput(root);
> + deactivate_locked_super(sb);
> + return ERR_PTR(ret);
> +}
> +
> +struct vfsmount *vfs_kern_mount_sc(struct sb_config *sc)
> +{
> + struct dentry *root;
> + struct mount *mnt;
> + int ret;
> +
> + if (sc->ops->validate) {
> + ret = sc->ops->validate(sc);
> + if (ret < 0)
> + return ERR_PTR(ret);
> + }
> +
> + mnt = alloc_vfsmnt(sc->device ?: "none");
> + if (!mnt)
> + return ERR_PTR(-ENOMEM);
> +
> + if (sc->ms_flags & MS_KERNMOUNT)
> + mnt->mnt.mnt_flags = MNT_INTERNAL;
> +
> + root = __do_mount_sc(sc);
> + if (IS_ERR(root)) {
> + mnt_free_id(mnt);
> + free_vfsmnt(mnt);
> + return ERR_CAST(root);
> + }
> +
> + mnt->mnt.mnt_root = root;
> + mnt->mnt.mnt_sb = root->d_sb;
> + mnt->mnt_mountpoint = mnt->mnt.mnt_root;
> + mnt->mnt_parent = mnt;
> + lock_mount_hash();
> + list_add_tail(&mnt->mnt_instance, &root->d_sb->s_mounts);
> + unlock_mount_hash();
> + return &mnt->mnt;
> +}
> +EXPORT_SYMBOL_GPL(vfs_kern_mount_sc);
> +
> +struct vfsmount *
> +vfs_submount_sc(const struct dentry *mountpoint, struct sb_config *sc)
> +{
> + /* Until it is worked out how to pass the user namespace
> + * through from the parent mount to the submount don't support
> + * unprivileged mounts with submounts.
> + */
> + if (mountpoint->d_sb->s_user_ns != &init_user_ns)
> + return ERR_PTR(-EPERM);
> +
> + sc->ms_flags = MS_SUBMOUNT;
> + return vfs_kern_mount_sc(sc);
> +}
> +EXPORT_SYMBOL_GPL(vfs_submount_sc);
> +
> /*
> * Return true if path is reachable from root
> *
> @@ -3299,6 +3490,23 @@ struct vfsmount *kern_mount_data(struct file_system_type *type, void *data)
> }
> EXPORT_SYMBOL_GPL(kern_mount_data);
>
> +struct vfsmount *kern_mount_data_sc(struct sb_config *sc)
> +{
> + struct vfsmount *mnt;
> +
> + sc->ms_flags = MS_KERNMOUNT;
> + mnt = vfs_kern_mount_sc(sc);
> + if (!IS_ERR(mnt)) {
> + /*
> + * it is a longterm mount, don't release mnt until
> + * we unmount before file sys is unregistered
> + */
> + real_mount(mnt)->mnt_ns = MNT_NS_INTERNAL;
> + }
> + return mnt;
> +}
> +EXPORT_SYMBOL_GPL(kern_mount_data_sc);
> +
> void kern_unmount(struct vfsmount *mnt)
> {
> /* release long term mount so mount point can be released */
> diff --git a/fs/nfs/nfs4super.c b/fs/nfs/nfs4super.c
> index 6fb7cb6b3f4b..967fa04d5c76 100644
> --- a/fs/nfs/nfs4super.c
> +++ b/fs/nfs/nfs4super.c
> @@ -3,6 +3,7 @@
> */
> #include <linux/init.h>
> #include <linux/module.h>
> +#include <linux/mount.h>
> #include <linux/nfs4_mount.h>
> #include <linux/nfs_fs.h>
> #include "delegation.h"
> diff --git a/fs/proc/root.c b/fs/proc/root.c
> index deecb397daa3..3c47399bd095 100644
> --- a/fs/proc/root.c
> +++ b/fs/proc/root.c
> @@ -19,6 +19,7 @@
> #include <linux/bitops.h>
> #include <linux/user_namespace.h>
> #include <linux/mount.h>
> +#include <linux/sb_config.h>
> #include <linux/pid_namespace.h>
> #include <linux/parser.h>
> #include <linux/cred.h>
> diff --git a/fs/sb_config.c b/fs/sb_config.c
> new file mode 100644
> index 000000000000..9c45e269b3cc
> --- /dev/null
> +++ b/fs/sb_config.c
> @@ -0,0 +1,326 @@
> +/* Provide a way to create a superblock configuration context within the kernel
> + * that allows a superblock to be set up prior to mounting.
> + *
> + * Copyright (C) 2017 Red Hat, Inc. All Rights Reserved.
> + * Written by David Howells (dhowells@redhat.com)
> + *
> + * This program is free software; you can redistribute it and/or
> + * modify it under the terms of the GNU General Public Licence
> + * as published by the Free Software Foundation; either version
> + * 2 of the Licence, or (at your option) any later version.
> + */
> +
> +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
> +#include <linux/sb_config.h>
> +#include <linux/fs.h>
> +#include <linux/mount.h>
> +#include <linux/nsproxy.h>
> +#include <linux/slab.h>
> +#include <linux/magic.h>
> +#include <linux/security.h>
> +#include <linux/parser.h>
> +#include <linux/mnt_namespace.h>
> +#include <linux/pid_namespace.h>
> +#include <linux/user_namespace.h>
> +#include <net/net_namespace.h>
> +#include "mount.h"
> +
> +static const match_table_t common_set_mount_options = {
> + { MS_DIRSYNC, "dirsync" },
> + { MS_I_VERSION, "iversion" },
> + { MS_LAZYTIME, "lazytime" },
> + { MS_MANDLOCK, "mand" },
> + { MS_NOATIME, "noatime" },
> + { MS_NODEV, "nodev" },
> + { MS_NODIRATIME, "nodiratime" },
> + { MS_NOEXEC, "noexec" },
> + { MS_NOSUID, "nosuid" },
> + { MS_POSIXACL, "posixacl" },
> + { MS_RDONLY, "ro" },
> + { MS_REC, "rec" },
> + { MS_RELATIME, "relatime" },
> + { MS_STRICTATIME, "strictatime" },
> + { MS_SYNCHRONOUS, "sync" },
> + { MS_VERBOSE, "verbose" },
> + { },
> +};
Lots of these are not superblock options, and should be moved over to
the forbidden ones. Look at do_mount() for a hint.
> +
> +static const match_table_t common_clear_mount_options = {
> + { MS_LAZYTIME, "nolazytime" },
> + { MS_MANDLOCK, "nomand" },
> + { MS_NODEV, "dev" },
> + { MS_NOEXEC, "exec" },
> + { MS_NOSUID, "suid" },
> + { MS_RDONLY, "rw" },
> + { MS_RELATIME, "norelatime" },
> + { MS_SILENT, "silent" },
> + { MS_STRICTATIME, "nostrictatime" },
> + { MS_SYNCHRONOUS, "async" },
> + { },
> +};
> +
> +static const match_table_t forbidden_mount_options = {
> + { MS_BIND, "bind" },
> + { MS_MOVE, "move" },
> + { MS_PRIVATE, "private" },
> + { MS_REMOUNT, "remount" },
> + { MS_SHARED, "shared" },
> + { MS_SLAVE, "slave" },
> + { MS_UNBINDABLE, "unbindable" },
> + { },
> +};
> +
> +/*
> + * Check for a common mount option.
> + */
> +static int vfs_parse_ms_mount_option(struct sb_config *sc, char *data)
> +{
> + substring_t args[MAX_OPT_ARGS];
> + unsigned int token;
> +
> + token = match_token(data, common_set_mount_options, args);
> + if (token) {
> + sc->ms_flags |= token;
> + return 1;
> + }
> +
> + token = match_token(data, common_clear_mount_options, args);
> + if (token) {
> + sc->ms_flags &= ~token;
> + return 1;
> + }
> +
> + token = match_token(data, forbidden_mount_options, args);
> + if (token)
> + return sb_cfg_inval(sc, "Mount option, not superblock option");
> +
> + return 0;
> +}
> +
> +/**
> + * vfs_parse_mount_option - Add a single mount option to a superblock config
> + * @mc: The superblock configuration to modify
> + * @p: The option to apply.
> + *
> + * A single mount option in string form is applied to the superblock
> + * configuration being set up. Certain standard options (for example "ro") are
> + * translated into flag bits without going to the filesystem. The active
> + * security module is allowed to observe and poach options. Any other options
> + * are passed over to the filesystem to parse.
> + *
> + * This may be called multiple times for a context.
> + *
> + * Returns 0 on success and a negative error code on failure. In the event of
> + * failure, sc->error may have been set to a non-allocated string that gives
> + * more information.
> + */
> +int vfs_parse_mount_option(struct sb_config *sc, char *p)
> +{
> + int ret;
> +
> + if (sc->mounted)
> + return -EBUSY;
> +
> + ret = vfs_parse_ms_mount_option(sc, p);
> + if (ret < 0)
> + return ret;
> + if (ret == 1)
> + return 0;
> +
> + ret = security_sb_config_parse_option(sc, p);
> + if (ret < 0)
> + return ret;
> + if (ret == 1)
> + return 0;
> +
> + return sc->ops->parse_option(sc, p);
> +}
> +EXPORT_SYMBOL(vfs_parse_mount_option);
> +
> +/**
> + * generic_monolithic_mount_data - Parse key[=val][,key[=val]]* mount data
> + * @mc: The superblock configuration to fill in.
> + * @data: The data to parse
> + *
> + * Parse a blob of data that's in key[=val][,key[=val]]* form. This can be
> + * called from the ->monolithic_mount_data() sb_config operation.
> + *
> + * Returns 0 on success or the error returned by the ->parse_option() sb_config
> + * operation on failure.
> + */
> +int generic_monolithic_mount_data(struct sb_config *ctx, void *data)
> +{
> + char *options = data, *p;
> + int ret;
> +
> + if (!options)
> + return 0;
> +
> + while ((p = strsep(&options, ",")) != NULL) {
> + if (*p) {
> + ret = vfs_parse_mount_option(ctx, p);
> + if (ret < 0)
> + return ret;
> + }
> + }
> +
> + return 0;
> +}
> +EXPORT_SYMBOL(generic_monolithic_mount_data);
> +
> +/**
> + * __vfs_new_sb_config - Create a superblock config.
> + * @fs_type: The filesystem type.
> + * @src_sb: A superblock from which this one derives (or NULL)
> + * @ms_flags: Superblock flags and op flags (such as MS_REMOUNT)
> + * @purpose: The purpose that this configuration shall be used for.
> + *
> + * Open a filesystem and create a mount context. The mount context is
> + * initialised with the supplied flags and, if a submount/automount from
> + * another superblock (@src_sb), may have parameters such as namespaces copied
> + * across from that superblock.
> + */
> +struct sb_config *__vfs_new_sb_config(struct file_system_type *fs_type,
> + struct super_block *src_sb,
> + unsigned int ms_flags,
> + enum sb_config_purpose purpose)
> +{
> + struct sb_config *sc;
> + int ret;
> +
> + BUG_ON(fs_type->init_sb_config &&
> + fs_type->sb_config_size < sizeof(*sc));
> +
> + sc = kzalloc(max_t(size_t, fs_type->sb_config_size, sizeof(*sc)),
> + GFP_KERNEL);
> + if (!sc)
> + return ERR_PTR(-ENOMEM);
> +
> + sc->purpose = purpose;
> + sc->ms_flags = ms_flags;
> + sc->fs_type = get_filesystem(fs_type);
> + sc->net_ns = get_net(current->nsproxy->net_ns);
> + sc->user_ns = get_user_ns(current_user_ns());
> + sc->cred = get_current_cred();
> +
> + /* TODO: Make all filesystems support this unconditionally */
> + if (sc->fs_type->init_sb_config) {
> + ret = sc->fs_type->init_sb_config(sc, src_sb);
> + if (ret < 0)
> + goto err_sc;
> + }
> +
> + /* Do the security check last because ->fsopen may change the
> + * namespace subscriptions.
> + */
> + ret = security_sb_config_alloc(sc, src_sb);
> + if (ret < 0)
> + goto err_sc;
> +
> + return sc;
> +
> +err_sc:
> + put_sb_config(sc);
> + return ERR_PTR(ret);
> +}
> +EXPORT_SYMBOL(__vfs_new_sb_config);
> +
> +/**
> + * vfs_new_sb_config - Create a superblock config for a new mount.
> + * @fs_name: The name of the filesystem
> + *
> + * Open a filesystem and create a superblock config context for a new mount
> + * that will hold the mount options, device name, security details, etc.. Note
> + * that the caller should check the ->ops pointer in the returned context to
> + * determine whether the filesystem actually supports the superblock context
> + * itself.
> + */
> +struct sb_config *vfs_new_sb_config(const char *fs_name)
> +{
> + struct file_system_type *fs_type;
> + struct sb_config *sc;
> +
> + fs_type = get_fs_type(fs_name);
> + if (!fs_type)
> + return ERR_PTR(-ENODEV);
> +
> + sc = __vfs_new_sb_config(fs_type, NULL, 0, SB_CONFIG_FOR_NEW);
> + put_filesystem(fs_type);
> + return sc;
> +}
> +EXPORT_SYMBOL(vfs_new_sb_config);
> +
> +/**
> + * vfs_sb_reconfig - Create a superblock config for remount/reconfiguration
> + * @mnt: The mountpoint to open
> + * @ms_flags: Superblock flags and op flags (such as MS_REMOUNT)
> + *
> + * Open a mounted filesystem and create a mount context such that a remount can
> + * be effected.
> + */
> +struct sb_config *vfs_sb_reconfig(struct vfsmount *mnt,
> + unsigned int ms_flags)
> +{
> + return __vfs_new_sb_config(mnt->mnt_sb->s_type, mnt->mnt_sb,
> + ms_flags, SB_CONFIG_FOR_REMOUNT);
> +}
> +
> +/**
> + * vfs_dup_sc_config: Duplicate a superblock configuration context.
> + * @src_sc: The context to copy.
> + */
> +struct sb_config *vfs_dup_sb_config(struct sb_config *src_sc)
> +{
> + struct sb_config *sc;
> + int ret;
> +
> + if (!src_sc->ops->dup)
> + return ERR_PTR(-ENOTSUPP);
> +
> + sc = kmemdup(src_sc, src_sc->fs_type->sb_config_size, GFP_KERNEL);
> + if (!sc)
> + return ERR_PTR(-ENOMEM);
> +
> + sc->device = NULL;
> + sc->security = NULL;
> + sc->error_msg = NULL;
> + get_filesystem(sc->fs_type);
> + get_net(sc->net_ns);
> + get_user_ns(sc->user_ns);
> + get_cred(sc->cred);
> +
> + /* Can't call put until we've called ->dup */
> + ret = sc->ops->dup(sc, src_sc);
> + if (ret < 0)
> + goto err_sc;
> +
> + ret = security_sb_config_dup(sc, src_sc);
> + if (ret < 0)
> + goto err_sc;
> + return sc;
> +
> +err_sc:
> + put_sb_config(sc);
> + return ERR_PTR(ret);
> +}
> +EXPORT_SYMBOL(vfs_dup_sb_config);
> +
> +/**
> + * put_sb_config - Dispose of a superblock configuration context.
> + * @sc: The context to dispose of.
> + */
> +void put_sb_config(struct sb_config *sc)
> +{
> + if (sc->ops && sc->ops->free)
> + sc->ops->free(sc);
> + security_sb_config_free(sc);
> + if (sc->net_ns)
> + put_net(sc->net_ns);
> + put_user_ns(sc->user_ns);
> + if (sc->cred)
> + put_cred(sc->cred);
> + put_filesystem(sc->fs_type);
> + kfree(sc->device);
> + kfree(sc);
> +}
> +EXPORT_SYMBOL(put_sb_config);
> diff --git a/fs/super.c b/fs/super.c
> index adb0c0de428c..4d923a775bd0 100644
> --- a/fs/super.c
> +++ b/fs/super.c
> @@ -34,6 +34,7 @@
> #include <linux/fsnotify.h>
> #include <linux/lockdep.h>
> #include <linux/user_namespace.h>
> +#include <linux/sb_config.h>
> #include "internal.h"
>
>
> @@ -805,10 +806,13 @@ struct super_block *user_get_super(dev_t dev)
> * @flags: numeric part of options
> * @data: the rest of options
> * @force: whether or not to force the change
> + * @sc: the superblock config for filesystems that support it
> + * (NULL if called from emergency or umount)
> *
> * Alters the mount options of a mounted file system.
> */
> -int do_remount_sb(struct super_block *sb, int flags, void *data, int force)
> +int do_remount_sb(struct super_block *sb, int flags, void *data, int force,
> + struct sb_config *sc)
> {
> int retval;
> int remount_ro;
> @@ -850,8 +854,14 @@ int do_remount_sb(struct super_block *sb, int flags, void *data, int force)
> }
> }
>
> - if (sb->s_op->remount_fs) {
> - retval = sb->s_op->remount_fs(sb, &flags, data);
> + if (sb->s_op->remount_fs_sc ||
> + sb->s_op->remount_fs) {
> + if (sb->s_op->remount_fs_sc) {
> + retval = sb->s_op->remount_fs_sc(sb, sc);
> + flags = sc->ms_flags;
> + } else {
> + retval = sb->s_op->remount_fs(sb, &flags, data);
> + }
> if (retval) {
> if (!force)
> goto cancel_readonly;
> @@ -898,7 +908,7 @@ static void do_emergency_remount(struct work_struct *work)
> /*
> * What lock protects sb->s_flags??
> */
> - do_remount_sb(sb, MS_RDONLY, NULL, 1);
> + do_remount_sb(sb, MS_RDONLY, NULL, 1, NULL);
> }
> up_write(&sb->s_umount);
> spin_lock(&sb_lock);
> @@ -1048,6 +1058,40 @@ struct dentry *mount_ns(struct file_system_type *fs_type,
>
> EXPORT_SYMBOL(mount_ns);
>
> +struct dentry *mount_ns_sc(struct sb_config *sc,
> + int (*fill_super)(struct super_block *sb,
> + struct sb_config *sc),
> + void *ns)
> +{
> + struct super_block *sb;
> +
> + /* Don't allow mounting unless the caller has CAP_SYS_ADMIN
> + * over the namespace.
> + */
> + if (!(sc->ms_flags & MS_KERNMOUNT) &&
> + !ns_capable(sc->user_ns, CAP_SYS_ADMIN))
> + return ERR_PTR(-EPERM);
> +
> + sb = sget_userns(sc->fs_type, ns_test_super, ns_set_super,
> + sc->ms_flags, sc->user_ns, ns);
> + if (IS_ERR(sb))
> + return ERR_CAST(sb);
> +
> + if (!sb->s_root) {
> + int err;
> + err = fill_super(sb, sc);
> + if (err) {
> + deactivate_locked_super(sb);
> + return ERR_PTR(err);
> + }
> +
> + sb->s_flags |= MS_ACTIVE;
> + }
> +
> + return dget(sb->s_root);
> +}
> +EXPORT_SYMBOL(mount_ns_sc);
> +
> #ifdef CONFIG_BLOCK
> static int set_bdev_super(struct super_block *s, void *data)
> {
> @@ -1196,7 +1240,7 @@ struct dentry *mount_single(struct file_system_type *fs_type,
> }
> s->s_flags |= MS_ACTIVE;
> } else {
> - do_remount_sb(s, flags, data, 0);
> + do_remount_sb(s, flags, data, 0, NULL);
> }
> return dget(s->s_root);
> }
> diff --git a/include/linux/fs.h b/include/linux/fs.h
> index bc0c054894b9..cd6cafcdd2ff 100644
> --- a/include/linux/fs.h
> +++ b/include/linux/fs.h
> @@ -54,6 +54,7 @@ struct workqueue_struct;
> struct iov_iter;
> struct fscrypt_info;
> struct fscrypt_operations;
> +struct sb_config;
>
> extern void __init inode_init(void);
> extern void __init inode_init_early(void);
> @@ -701,6 +702,11 @@ static inline void inode_unlock(struct inode *inode)
> up_write(&inode->i_rwsem);
> }
>
> +static inline int inode_lock_killable(struct inode *inode)
> +{
> + return down_write_killable(&inode->i_rwsem);
> +}
> +
> static inline void inode_lock_shared(struct inode *inode)
> {
> down_read(&inode->i_rwsem);
> @@ -1787,6 +1793,7 @@ struct super_operations {
> int (*unfreeze_fs) (struct super_block *);
> int (*statfs) (struct dentry *, struct kstatfs *);
> int (*remount_fs) (struct super_block *, int *, char *);
> + int (*remount_fs_sc) (struct super_block *, struct sb_config *);
> void (*umount_begin) (struct super_block *);
>
> int (*show_options)(struct seq_file *, struct dentry *);
> @@ -2021,8 +2028,10 @@ struct file_system_type {
> #define FS_HAS_SUBTYPE 4
> #define FS_USERNS_MOUNT 8 /* Can be mounted by userns root */
> #define FS_RENAME_DOES_D_MOVE 32768 /* FS will handle d_move() during rename() internally. */
> + unsigned short sb_config_size; /* Size of superblock config context to allocate */
> struct dentry *(*mount) (struct file_system_type *, int,
> const char *, void *);
> + int (*init_sb_config)(struct sb_config *, struct super_block *);
> void (*kill_sb) (struct super_block *);
> struct module *owner;
> struct file_system_type * next;
> @@ -2040,6 +2049,10 @@ struct file_system_type {
>
> #define MODULE_ALIAS_FS(NAME) MODULE_ALIAS("fs-" NAME)
>
> +extern struct dentry *mount_ns_sc(struct sb_config *mc,
> + int (*fill_super)(struct super_block *sb,
> + struct sb_config *sc),
> + void *ns);
> extern struct dentry *mount_ns(struct file_system_type *fs_type,
> int flags, void *data, void *ns, struct user_namespace *user_ns,
> int (*fill_super)(struct super_block *, void *, int));
> @@ -2106,6 +2119,7 @@ extern int register_filesystem(struct file_system_type *);
> extern int unregister_filesystem(struct file_system_type *);
> extern struct vfsmount *kern_mount_data(struct file_system_type *, void *data);
> #define kern_mount(type) kern_mount_data(type, NULL)
> +extern struct vfsmount *kern_mount_data_sc(struct sb_config *);
> extern void kern_unmount(struct vfsmount *mnt);
> extern int may_umount_tree(struct vfsmount *);
> extern int may_umount(struct vfsmount *);
> diff --git a/include/linux/lsm_hooks.h b/include/linux/lsm_hooks.h
> index 080f34e66017..48bfd49666bc 100644
> --- a/include/linux/lsm_hooks.h
> +++ b/include/linux/lsm_hooks.h
> @@ -75,6 +75,33 @@
> * should enable secure mode.
> * @bprm contains the linux_binprm structure.
> *
> + * Security hooks for mount using fd context.
> + *
> + * @sb_config_alloc:
> + * Allocate and attach a security structure to sc->security. This pointer
> + * is initialised to NULL by the caller.
> + * @sc indicates the new superblock configuration context.
> + * @src_sb indicates the source superblock of a submount.
> + * @sb_config_dup:
> + * Allocate and attach a security structure to sc->security. This pointer
> + * is initialised to NULL by the caller.
> + * @sc indicates the new superblock configuration context.
> + * @src_sc indicates the original superblock configuration context.
> + * @sb_config_free:
> + * Clean up a superblock configuration context.
> + * @sc indicates the superblock configuration context.
> + * @sb_config_parse_option:
> + * Userspace provided an option to configure a superblock. The LSM may
> + * reject it with an error and may use it for itself, in which case it
> + * should return 1; otherwise it should return 0 to pass it on to the
> + * filesystem.
> + * @sc indicates the superblock configuration context.
> + * @p indicates the option in "key[=val]" form.
> + * @sb_config_kern_mount:
> + * Equivalent of sb_kern_mount, but with a superblock configuration context.
> + * @sc indicates the superblock configuration context.
> + * @src_sb indicates the new superblock.
> + *
> * Security hooks for filesystem operations.
> *
> * @sb_alloc_security:
> @@ -1372,6 +1399,12 @@ union security_list_options {
> void (*bprm_committing_creds)(struct linux_binprm *bprm);
> void (*bprm_committed_creds)(struct linux_binprm *bprm);
>
> + int (*sb_config_alloc)(struct sb_config *sc, struct super_block *src_sb);
> + int (*sb_config_dup)(struct sb_config *sc, struct sb_config *src_sc);
> + void (*sb_config_free)(struct sb_config *sc);
> + int (*sb_config_parse_option)(struct sb_config *sc, char *opt);
> + int (*sb_config_kern_mount)(struct sb_config *sc, struct super_block *sb);
> +
> int (*sb_alloc_security)(struct super_block *sb);
> void (*sb_free_security)(struct super_block *sb);
> int (*sb_copy_data)(char *orig, char *copy);
> @@ -1683,6 +1716,11 @@ struct security_hook_heads {
> struct list_head bprm_secureexec;
> struct list_head bprm_committing_creds;
> struct list_head bprm_committed_creds;
> + struct list_head sb_config_alloc;
> + struct list_head sb_config_dup;
> + struct list_head sb_config_free;
> + struct list_head sb_config_parse_option;
> + struct list_head sb_config_kern_mount;
> struct list_head sb_alloc_security;
> struct list_head sb_free_security;
> struct list_head sb_copy_data;
> diff --git a/include/linux/mount.h b/include/linux/mount.h
> index 8e0352af06b7..a5dca6abc4d5 100644
> --- a/include/linux/mount.h
> +++ b/include/linux/mount.h
> @@ -20,6 +20,7 @@ struct super_block;
> struct vfsmount;
> struct dentry;
> struct mnt_namespace;
> +struct sb_config;
>
> #define MNT_NOSUID 0x01
> #define MNT_NODEV 0x02
> @@ -90,9 +91,12 @@ struct file_system_type;
> extern struct vfsmount *vfs_kern_mount(struct file_system_type *type,
> int flags, const char *name,
> void *data);
> +extern struct vfsmount *vfs_kern_mount_sc(struct sb_config *sc);
> extern struct vfsmount *vfs_submount(const struct dentry *mountpoint,
> struct file_system_type *type,
> const char *name, void *data);
> +extern struct vfsmount *vfs_submount_sc(const struct dentry *mountpoint,
> + struct sb_config *sc);
>
> extern void mnt_set_expiry(struct vfsmount *mnt, struct list_head *expiry_list);
> extern void mark_mounts_for_expiry(struct list_head *mounts);
> diff --git a/include/linux/sb_config.h b/include/linux/sb_config.h
> new file mode 100644
> index 000000000000..0b21e381d9f0
> --- /dev/null
> +++ b/include/linux/sb_config.h
> @@ -0,0 +1,93 @@
> +/* Superblock configuration and creation handling.
> + *
> + * Copyright (C) 2017 Red Hat, Inc. All Rights Reserved.
> + * Written by David Howells (dhowells@redhat.com)
> + *
> + * This program is free software; you can redistribute it and/or
> + * modify it under the terms of the GNU General Public Licence
> + * as published by the Free Software Foundation; either version
> + * 2 of the Licence, or (at your option) any later version.
> + */
> +
> +#ifndef _LINUX_SB_CONFIG_H
> +#define _LINUX_SB_CONFIG_H
> +
> +#include <linux/kernel.h>
> +#include <linux/errno.h>
> +
> +struct cred;
> +struct dentry;
> +struct file_operations;
> +struct file_system_type;
> +struct mnt_namespace;
> +struct net;
> +struct pid_namespace;
> +struct super_block;
> +struct user_namespace;
> +struct vfsmount;
> +
> +enum sb_config_purpose {
> + SB_CONFIG_FOR_NEW, /* New superblock for direct mount */
> + SB_CONFIG_FOR_SUBMOUNT, /* New superblock for automatic submount */
> + SB_CONFIG_FOR_REMOUNT, /* Superblock reconfiguration for remount */
> +};
> +
> +/*
> + * Superblock configuration context as allocated and constructed by the
> + * ->init_sb_config() file_system_type operation. The size of the object
> + * allocated is specified in struct file_system_type::sb_config_size and this
> + * must include sufficient space for the sb_config struct.
> + *
> + * See Documentation/filesystems/mounting.txt
> + */
> +struct sb_config {
> + const struct sb_config_operations *ops;
> + struct file_system_type *fs_type;
> + struct user_namespace *user_ns; /* The user namespace for this mount */
> + struct net *net_ns; /* The network namespace for this mount */
> + const struct cred *cred; /* The mounter's credentials */
> + char *device; /* The device name or mount target */
> + void *security; /* The LSM context */
> + const char *error_msg; /* Error string to be read by read() */
> + unsigned int ms_flags; /* The superblock flags (MS_*) */
> + bool mounted; /* Set when mounted */
> + bool sloppy; /* Unrecognised options are okay */
> + bool silent;
> + enum sb_config_purpose purpose : 8;
> +};
> +
> +struct sb_config_operations {
> + void (*free)(struct sb_config *sc);
> + int (*dup)(struct sb_config *sc, struct sb_config *src);
> + int (*parse_option)(struct sb_config *sc, char *p);
> + int (*monolithic_mount_data)(struct sb_config *sc, void *data);
> + int (*validate)(struct sb_config *sc);
> + struct dentry *(*mount)(struct sb_config *sc);
> +};
> +
> +extern const struct file_operations fs_fs_fops;
> +
> +extern struct sb_config *vfs_new_sb_config(const char *fs_name);
> +extern struct sb_config *__vfs_new_sb_config(struct file_system_type *fs_type,
> + struct super_block *src_sb,
> + unsigned int ms_flags,
> + enum sb_config_purpose purpose);
> +extern struct sb_config *vfs_sb_reconfig(struct vfsmount *mnt,
> + unsigned int ms_flags);
> +extern struct sb_config *vfs_dup_sb_config(struct sb_config *src);
> +extern int vfs_parse_mount_option(struct sb_config *sc, char *data);
> +extern int generic_monolithic_mount_data(struct sb_config *sc, void *data);
> +extern void put_sb_config(struct sb_config *sc);
> +
> +static inline void sb_cfg_error(struct sb_config *sc, const char *msg)
> +{
> + sc->error_msg = msg;
> +}
> +
> +static inline int sb_cfg_inval(struct sb_config *sc, const char *msg)
> +{
> + sb_cfg_error(sc, msg);
> + return -EINVAL;
> +}
> +
> +#endif /* _LINUX_SB_CONFIG_H */
> diff --git a/include/linux/security.h b/include/linux/security.h
> index af675b576645..36b3a6779986 100644
> --- a/include/linux/security.h
> +++ b/include/linux/security.h
> @@ -55,6 +55,7 @@ struct msg_queue;
> struct xattr;
> struct xfrm_sec_ctx;
> struct mm_struct;
> +struct sb_config;
>
> /* If capable should audit the security request */
> #define SECURITY_CAP_NOAUDIT 0
> @@ -224,6 +225,11 @@ int security_bprm_check(struct linux_binprm *bprm);
> void security_bprm_committing_creds(struct linux_binprm *bprm);
> void security_bprm_committed_creds(struct linux_binprm *bprm);
> int security_bprm_secureexec(struct linux_binprm *bprm);
> +int security_sb_config_alloc(struct sb_config *sc, struct super_block *sb);
> +int security_sb_config_dup(struct sb_config *sc, struct sb_config *src_sc);
> +void security_sb_config_free(struct sb_config *sc);
> +int security_sb_config_parse_option(struct sb_config *sc, char *opt);
> +int security_sb_config_kern_mount(struct sb_config *sc, struct super_block *sb);
> int security_sb_alloc(struct super_block *sb);
> void security_sb_free(struct super_block *sb);
> int security_sb_copy_data(char *orig, char *copy);
> @@ -520,6 +526,29 @@ static inline int security_bprm_secureexec(struct linux_binprm *bprm)
> return cap_bprm_secureexec(bprm);
> }
>
> +static inline int security_sb_config_alloc(struct sb_config *sc,
> + struct super_block *src_sb)
> +{
> + return 0;
> +}
> +static inline int security_sb_config_dup(struct sb_config *sc,
> + struct sb_config *src_sc)
> +{
> + return 0;
> +}
> +static inline void security_sb_config_free(struct sb_config *sc)
> +{
> +}
> +static inline int security_sb_config_parse_option(struct sb_config *sc, char *opt)
> +{
> + return 0;
> +}
> +static inline int security_sb_config_kern_mount(struct sb_config *sc,
> + struct super_block *sb)
> +{
> + return 0;
> +}
> +
> static inline int security_sb_alloc(struct super_block *sb)
> {
> return 0;
> diff --git a/security/security.c b/security/security.c
> index b9fea3999cf8..3735fad91543 100644
> --- a/security/security.c
> +++ b/security/security.c
> @@ -316,6 +316,31 @@ int security_bprm_secureexec(struct linux_binprm *bprm)
> return call_int_hook(bprm_secureexec, 0, bprm);
> }
>
> +int security_sb_config_alloc(struct sb_config *sc, struct super_block *src_sb)
> +{
> + return call_int_hook(sb_config_alloc, 0, sc, src_sb);
> +}
> +
> +int security_sb_config_dup(struct sb_config *sc, struct sb_config *src_sc)
> +{
> + return call_int_hook(sb_config_dup, 0, sc, src_sc);
> +}
> +
> +void security_sb_config_free(struct sb_config *sc)
> +{
> + call_void_hook(sb_config_free, sc);
> +}
> +
> +int security_sb_config_parse_option(struct sb_config *sc, char *opt)
> +{
> + return call_int_hook(sb_config_parse_option, 0, sc, opt);
> +}
> +
> +int security_sb_config_kern_mount(struct sb_config *sc, struct super_block *sb)
> +{
> + return call_int_hook(sb_config_kern_mount, 0, sc, sb);
> +}
> +
> int security_sb_alloc(struct super_block *sb)
> {
> return call_int_hook(sb_alloc_security, 0, sb);
> diff --git a/security/selinux/hooks.c b/security/selinux/hooks.c
> index e67a526d1f30..286207bced52 100644
> --- a/security/selinux/hooks.c
> +++ b/security/selinux/hooks.c
> @@ -47,6 +47,7 @@
> #include <linux/fdtable.h>
> #include <linux/namei.h>
> #include <linux/mount.h>
> +#include <linux/sb_config.h>
> #include <linux/netfilter_ipv4.h>
> #include <linux/netfilter_ipv6.h>
> #include <linux/tty.h>
> @@ -2826,6 +2827,169 @@ static int selinux_umount(struct vfsmount *mnt, int flags)
> FILESYSTEM__UNMOUNT, NULL);
> }
>
> +/* fsopen mount context operations */
> +
> +static int selinux_sb_config_alloc(struct sb_config *sc,
> + struct super_block *src_sb)
> +{
> + struct security_mnt_opts *opts;
> +
> + opts = kzalloc(sizeof(*opts), GFP_KERNEL);
> + if (!opts)
> + return -ENOMEM;
> +
> + sc->security = opts;
> + return 0;
> +}
> +
> +static int selinux_sb_config_dup(struct sb_config *sc,
> + struct sb_config *src_sc)
> +{
> + const struct security_mnt_opts *src = src_sc->security;
> + struct security_mnt_opts *opts;
> + int i, n;
> +
> + opts = kzalloc(sizeof(*opts), GFP_KERNEL);
> + if (!opts)
> + return -ENOMEM;
> + sc->security = opts;
> +
> + if (!src || !src->num_mnt_opts)
> + return 0;
> + n = opts->num_mnt_opts = src->num_mnt_opts;
> +
> + if (src->mnt_opts) {
> + opts->mnt_opts = kcalloc(n, sizeof(char *), GFP_KERNEL);
> + if (!opts->mnt_opts)
> + return -ENOMEM;
> +
> + for (i = 0; i < n; i++) {
> + if (src->mnt_opts[i]) {
> + opts->mnt_opts[i] = kstrdup(src->mnt_opts[i],
> + GFP_KERNEL);
> + if (!opts->mnt_opts[i])
> + return -ENOMEM;
> + }
> + }
> + }
> +
> + if (src->mnt_opts_flags) {
> + opts->mnt_opts_flags = kmemdup(src->mnt_opts_flags,
> + n * sizeof(int), GFP_KERNEL);
> + if (!opts->mnt_opts_flags)
> + return -ENOMEM;
> + }
> +
> + return 0;
> +}
> +
> +static void selinux_sb_config_free(struct sb_config *sc)
> +{
> + struct security_mnt_opts *opts = sc->security;
> +
> + security_free_mnt_opts(opts);
> + sc->security = NULL;
> +}
> +
> +static int selinux_sb_config_parse_option(struct sb_config *sc, char *opt)
> +{
> + struct security_mnt_opts *opts = sc->security;
> + substring_t args[MAX_OPT_ARGS];
> + unsigned int have;
> + char *c, **oo;
> + int token, ctx, i, *of;
> +
> + token = match_token(opt, tokens, args);
> + if (token == Opt_error)
> + return 0; /* Doesn't belong to us. */
> +
> + have = 0;
> + for (i = 0; i < opts->num_mnt_opts; i++)
> + have |= 1 << opts->mnt_opts_flags[i];
> + if (have & (1 << token))
> + return sb_cfg_inval(sc, "SELinux: Duplicate mount options");
> +
> + switch (token) {
> + case Opt_context:
> + if (have & (1 << Opt_defcontext))
> + goto incompatible;
> + ctx = CONTEXT_MNT;
> + goto copy_context_string;
> +
> + case Opt_fscontext:
> + ctx = FSCONTEXT_MNT;
> + goto copy_context_string;
> +
> + case Opt_rootcontext:
> + ctx = ROOTCONTEXT_MNT;
> + goto copy_context_string;
> +
> + case Opt_defcontext:
> + if (have & (1 << Opt_context))
> + goto incompatible;
> + ctx = DEFCONTEXT_MNT;
> + goto copy_context_string;
> +
> + case Opt_labelsupport:
> + return 1;
> +
> + default:
> + return sb_cfg_inval(sc, "SELinux: Unknown mount option");
> + }
> +
> +copy_context_string:
> + if (opts->num_mnt_opts > 3)
> + return sb_cfg_inval(sc, "SELinux: Too many options");
> +
> + of = krealloc(opts->mnt_opts_flags,
> + (opts->num_mnt_opts + 1) * sizeof(int), GFP_KERNEL);
> + if (!of)
> + return -ENOMEM;
> + of[opts->num_mnt_opts] = 0;
> + opts->mnt_opts_flags = of;
> +
> + oo = krealloc(opts->mnt_opts,
> + (opts->num_mnt_opts + 1) * sizeof(char *), GFP_KERNEL);
> + if (!oo)
> + return -ENOMEM;
> + oo[opts->num_mnt_opts] = NULL;
> + opts->mnt_opts = oo;
> +
> + c = match_strdup(&args[0]);
> + if (!c)
> + return -ENOMEM;
> + opts->mnt_opts[opts->num_mnt_opts] = c;
> + opts->mnt_opts_flags[opts->num_mnt_opts] = ctx;
> + opts->num_mnt_opts++;
> + return 1;
> +
> +incompatible:
> + return sb_cfg_inval(sc, "SELinux: Incompatible mount options");
> +}
> +
> +static int selinux_sb_config_kern_mount(struct sb_config *sc,
> + struct super_block *sb)
> +{
> + const struct cred *cred = current_cred();
> + struct common_audit_data ad;
> + int rc;
> +
> + rc = selinux_set_mnt_opts(sb, sc->security, 0, NULL);
> + if (rc)
> + return rc;
> +
> + /* Allow all mounts performed by the kernel */
> + if (sc->ms_flags & MS_KERNMOUNT)
> + return 0;
> +
> + ad.type = LSM_AUDIT_DATA_DENTRY;
> + ad.u.dentry = sb->s_root;
> + rc = superblock_has_perm(cred, sb, FILESYSTEM__MOUNT, &ad);
> + if (rc < 0)
> + sb_cfg_error(sc, "SELinux: Mount of superblock not permitted");
> + return rc;
> +}
> +
> /* inode security operations */
>
> static int selinux_inode_alloc_security(struct inode *inode)
> @@ -6154,6 +6318,12 @@ static struct security_hook_list selinux_hooks[] __lsm_ro_after_init = {
> LSM_HOOK_INIT(bprm_committed_creds, selinux_bprm_committed_creds),
> LSM_HOOK_INIT(bprm_secureexec, selinux_bprm_secureexec),
>
> + LSM_HOOK_INIT(sb_config_alloc, selinux_sb_config_alloc),
> + LSM_HOOK_INIT(sb_config_dup, selinux_sb_config_dup),
> + LSM_HOOK_INIT(sb_config_free, selinux_sb_config_free),
> + LSM_HOOK_INIT(sb_config_parse_option, selinux_sb_config_parse_option),
> + LSM_HOOK_INIT(sb_config_kern_mount, selinux_sb_config_kern_mount),
> +
> LSM_HOOK_INIT(sb_alloc_security, selinux_sb_alloc_security),
> LSM_HOOK_INIT(sb_free_security, selinux_sb_free_security),
> LSM_HOOK_INIT(sb_copy_data, selinux_sb_copy_data),
>
^ permalink raw reply [flat|nested] 28+ messages in thread* Re: [PATCH 06/21] VFS: Introduce a superblock configuration context [ver #3]
2017-05-15 15:19 ` [PATCH 06/21] VFS: Introduce a superblock configuration context " David Howells
2017-05-16 15:10 ` Miklos Szeredi
@ 2017-05-16 16:33 ` David Howells
2017-05-17 7:54 ` Miklos Szeredi
2017-05-17 11:31 ` David Howells
1 sibling, 2 replies; 28+ messages in thread
From: David Howells @ 2017-05-16 16:33 UTC (permalink / raw)
To: Miklos Szeredi
Cc: dhowells, viro, Jeff Layton, linux-fsdevel, linux-nfs, lkml
Miklos Szeredi <mszeredi@redhat.com> wrote:
> One way to split this large patch up into more managable chunks would be:
>
> 1) common infrastructure
> 2) new mount related changes
> 3) reconfig (remount) related changes
>
> Would that work?
The problem is that remount seems to generally use the same parsing code as
the new-mount entry point.
Before considering how to split it, can we consider whether to roll patches 20
and 21 into the preceding patches?
> (a) new mount with new super block created
> (b) new mount with existing super block reused
> (c) remount
(b) is internal-only at the moment, used by NFS submounts as triggered by
automounts. There isn't currently any way to supply mount options to this.
> 2) modify options ("foo" turns option on, "nofoo" turns it off)
Not all options are binary and some options may be mandatory.
> The surprising thing here is that we do (a) and (b) via the same route
> and (a) and (c) via a different ones. This doesn't feel right.
You need to look at it like this:
Case Options Ref Call Modify
super sget super
======= ======= ======= ======= =======
a Y - Y -
b - Y Y -
c Y [1] - Y
[1] We don't have a separate reference sb, only the one we're going to modify,
but we can preload the sb_config from that.
(a) and (b) have the same action.
> i) options that determine the sb instance (such as the blockdev or
> the server IP address)
> ii) subpath: this can determine the sb as well as the subtree to use
> iii) options that can be changed while sb in use
> iv) ???
Ah - but some of these options have to be set *inside* sget() or before the
superblock becomes live, even the ones that can be changed in-flight.
> Would it make sense to make the "new mount" case be
>
> A) find or create sb based on (i) and (ii) options
> B) reconfigure the resulting sb based on (iii) options
You would *have* to do the reconfiguration before making the superblock live
to prevent config/use races, and some options in (iii) may be required during
sget(), or even before you get as far as calling sget() (say you need to
access a server).
> This would make legacy new mount be: (A) + if new then (B). And
> legacy remount just (B).
It's not obvious that this is sufficiently equivalent from your brief
description.
> Also I think silently ignoring options is not always the right answer.
Example?
Do you mean like the NFS 'sloppy' option? I've noted that that might be best
handled in userspace.
> > + int (*remount_fs_sc) (struct super_block *, struct sb_config *);
>
> How about reconfig_fs() or just reconfig()?
Sure.
> > + (*) struct dentry *(*mount)(struct sb_config *sc);
>
> I'd be much happier with "get_root()" or something.
Changed in patch 21 to ->get_tree() as suggested by Al. Having looked over
the code, I'm tempted to change it back to ->mount() as being more obvious.
> > + err = parse_monolithic_mount_data(sc, data);
> > + if (err < 0)
> > + goto err_sc;
>
> If filesystem defines ->monolithic_mount_data() who is responsible for
> calling the security hook?
Which security hook? security_sb_remount()?
Note this code has changed in patch 20. I should update security_sb_remount()
to take an sb_config and call it in all paths.
> Largely duplicated do_new_mount_sc(). What's the point?
Legacy vs new. Fixed in patch 20.
> Lots of these are not superblock options, and should be moved over to
> the forbidden ones. Look at do_mount() for a hint.
I still have to support legacy mount option parsing. Do I actually see these
in legacy mount(2)? Or are they weeded out by mount(8)?
David
^ permalink raw reply [flat|nested] 28+ messages in thread* Re: [PATCH 06/21] VFS: Introduce a superblock configuration context [ver #3]
2017-05-16 16:33 ` David Howells
@ 2017-05-17 7:54 ` Miklos Szeredi
2017-05-17 11:31 ` David Howells
1 sibling, 0 replies; 28+ messages in thread
From: Miklos Szeredi @ 2017-05-17 7:54 UTC (permalink / raw)
To: David Howells; +Cc: viro, Jeff Layton, linux-fsdevel, linux-nfs, lkml
On Tue, May 16, 2017 at 6:33 PM, David Howells <dhowells@redhat.com> wrote:
> Miklos Szeredi <mszeredi@redhat.com> wrote:
>
>> One way to split this large patch up into more managable chunks would be:
>>
>> 1) common infrastructure
>> 2) new mount related changes
>> 3) reconfig (remount) related changes
>>
>> Would that work?
>
> The problem is that remount seems to generally use the same parsing code as
> the new-mount entry point.
You are talking about fs code?
I was just referring to this single patch, not the others.
>
> Before considering how to split it, can we consider whether to roll patches 20
> and 21 into the preceding patches?
>
>> (a) new mount with new super block created
>> (b) new mount with existing super block reused
>> (c) remount
>
> (b) is internal-only at the moment, used by NFS submounts as triggered by
> automounts. There isn't currently any way to supply mount options to this.
And all blockdev based fs.
>> 2) modify options ("foo" turns option on, "nofoo" turns it off)
>
> Not all options are binary and some options may be mandatory.
Right, I was simplifying.
>
>> The surprising thing here is that we do (a) and (b) via the same route
>> and (a) and (c) via a different ones. This doesn't feel right.
>
> You need to look at it like this:
>
> Case Options Ref Call Modify
> super sget super
> ======= ======= ======= ======= =======
> a Y - Y -
> b - Y Y -
> c Y [1] - Y
>
> [1] We don't have a separate reference sb, only the one we're going to modify,
> but we can preload the sb_config from that.
>
> (a) and (b) have the same action.
>
>> i) options that determine the sb instance (such as the blockdev or
>> the server IP address)
>> ii) subpath: this can determine the sb as well as the subtree to use
>> iii) options that can be changed while sb in use
>> iv) ???
>
> Ah - but some of these options have to be set *inside* sget() or before the
> superblock becomes live, even the ones that can be changed in-flight.
That would be the "???" category. Any concrete examples?
>
>> Would it make sense to make the "new mount" case be
>>
>> A) find or create sb based on (i) and (ii) options
>> B) reconfigure the resulting sb based on (iii) options
>
> You would *have* to do the reconfiguration before making the superblock live
> to prevent config/use races,
Indeed, the actual attaching into the mount namespace would be the
final step. I deliberately left it out, because it's largely
orthogonal to the superblock config question.
> and some options in (iii) may be required during
> sget(), or even before you get as far as calling sget() (say you need to
> access a server).
>
>> This would make legacy new mount be: (A) + if new then (B). And
>> legacy remount just (B).
>
> It's not obvious that this is sufficiently equivalent from your brief
> description.
It's not obvious. I'm just trying to explore the design space to fix
as much idiocy in the current one as possible.
>
>> Also I think silently ignoring options is not always the right answer.
>
> Example?
mount /dev/sda -oacl /mnt
mount /dev/sda -onoacl /mnt2
>
> Do you mean like the NFS 'sloppy' option? I've noted that that might be best
> handled in userspace.
>
>> > + int (*remount_fs_sc) (struct super_block *, struct sb_config *);
>>
>> How about reconfig_fs() or just reconfig()?
>
> Sure.
>
>> > + (*) struct dentry *(*mount)(struct sb_config *sc);
>>
>> I'd be much happier with "get_root()" or something.
>
> Changed in patch 21 to ->get_tree() as suggested by Al. Having looked over
> the code, I'm tempted to change it back to ->mount() as being more obvious.
Some definitions of mount:
- to increase in amount or extent
- to seat oneself (as on a horse) for riding
- to climb on top of for copulation
- to launch and carry out (something, such as an assault or a campaign)
- to attach to a support
No really good match for what this method is doing. We could call it
->get_tree_to_mount(), but calling it just ->mount() implies that it's
doing the mounting, which it is not.
>
>> > + err = parse_monolithic_mount_data(sc, data);
>> > + if (err < 0)
>> > + goto err_sc;
>>
>> If filesystem defines ->monolithic_mount_data() who is responsible for
>> calling the security hook?
>
> Which security hook? security_sb_remount()?
>
> Note this code has changed in patch 20. I should update security_sb_remount()
> to take an sb_config and call it in all paths.
>
>> Largely duplicated do_new_mount_sc(). What's the point?
>
> Legacy vs new. Fixed in patch 20.
>
>> Lots of these are not superblock options, and should be moved over to
>> the forbidden ones. Look at do_mount() for a hint.
>
> I still have to support legacy mount option parsing. Do I actually see these
> in legacy mount(2)? Or are they weeded out by mount(8)?
You are thinking on the wrong level. Of course mount(2) needs to
handle MS_NOSUID et al. But it's doing it now, and it isn't parsing
"nosuid", just translating MS_NOSUID to MNT_NOSUID. For the fsopen()
case you won't need to parse "nosuid" because that's a flag for
fsmount().
The only thing fsmount() should take from the sc is the root_dentry.
It should be equivalent to what currently is a bind mount, except it
should be able to fully configure the new mount.
I'm still hoping we can move subpath handling completely to fsmount()
in which case it would just take a struct super_block. But that would
have to start with lots of filesystem work (not just NFS but CEPH,
CIFS, etc..).
Thanks,
Miklos
^ permalink raw reply [flat|nested] 28+ messages in thread* Re: [PATCH 06/21] VFS: Introduce a superblock configuration context [ver #3]
2017-05-16 16:33 ` David Howells
2017-05-17 7:54 ` Miklos Szeredi
@ 2017-05-17 11:31 ` David Howells
2017-05-18 8:09 ` Miklos Szeredi
2017-05-19 14:05 ` David Howells
1 sibling, 2 replies; 28+ messages in thread
From: David Howells @ 2017-05-17 11:31 UTC (permalink / raw)
To: Miklos Szeredi
Cc: dhowells, viro, Jeff Layton, linux-fsdevel, linux-nfs, lkml
Miklos Szeredi <mszeredi@redhat.com> wrote:
> > (b) is internal-only at the moment, used by NFS submounts as triggered by
> > automounts. There isn't currently any way to supply mount options to this.
>
> And all blockdev based fs.
I see what you're getting at. In which case there are more cases:
(a) new mount, new sb struct with no source (eg. procfs, sysfs, tmpfs)
(b) new mount, new sb struct, params loaded from filesystem data (eg. bdev)
(c) new mount, new sb struct, params derived from parent (eg. NFS automount)
(d) new mount, shared extant sb struct
(e) remount
In the case of (d) where we're attempting to make another mount for an extant
super_block struct and we need to check the consistency of the parameters.
> > Ah - but some of these options have to be set *inside* sget() or before the
> > superblock becomes live, even the ones that can be changed in-flight.
>
> That would be the "???" category. Any concrete examples?
NFS is a good example. You need parameters that indicate the server to talk
to and specify I/O parameters before you even get the superblock as you have
to talk to the server first. I think this is particularly true of NFSv2/3
where you need to talk to mountd.
This would also be true of AFS. There you have to access the network to look
up the volume ID before you can call sget() as the volume ID is part of the
index key to the set of super_block structs.
Further, some of these values (I/O parameters in NFS's case, for example) form
part of the super_block struct index key, so you have to set those inside
sget()'s set callback.
> >> Also I think silently ignoring options is not always the right answer.
> >
> > Example?
>
> mount /dev/sda -oacl /mnt
> mount /dev/sda -onoacl /mnt2
So you'd like to give an error or a warning if ACLs are not supported, either
by the filesystem or the kernel as a whole?
> No really good match for what this method is doing. We could call it
> ->get_tree_to_mount(), but calling it just ->mount() implies that it's
> doing the mounting, which it is not.
Yes, but my point is that it's part of the mount procedure. We are, I assume,
intending to try and mount the thing at some point. I can leave it as
->get_tree() for the moment.
> You are thinking on the wrong level. Of course mount(2) needs to
> handle MS_NOSUID et al. But it's doing it now, and it isn't parsing
> "nosuid", just translating MS_NOSUID to MNT_NOSUID.
Ummm... That's done by the parser in this case, so effectively it is.
> For the fsopen() case you won't need to parse "nosuid" because that's a flag
> for fsmount().
Whilst this is true, that means that the parser has to operate differently in
the mount(2) and fsopen(2) cases - which I was trying to avoid. I guess I can
set a flag in the sb_config struct to indicate the source and then split out
these options into an only-for-mount(2) list.
> The only thing fsmount() should take from the sc is the root_dentry.
> It should be equivalent to what currently is a bind mount, except it
> should be able to fully configure the new mount.
It needs to take the device name as well. I wonder if it would be possible to
store the device name on the superblock and then leave a path-in-mount in the
vfsmount struct to fabricate a <source>:/<path> later. Though this would
change the behaviour if someone did:
mknod /dev/foo b 8 1
mknod /dev/bar b 8 1
mount /dev/foo /mnt/foo
mount /dev/bar /mnt/bar
as /proc/mounts would now show /dev/foo for /mnt/bar.
Also, I guess the subtype should be wangled in the superblock-getting code
(vfs_get_tree() as of patch 21) rather than in do_new_mount_sc(). If I do
that, then it may be that do_new_mount_sc() only needs the root dentry pointer
and not the sb_config pointer (except for error string passing).
> I'm still hoping we can move subpath handling completely to fsmount()
> in which case it would just take a struct super_block. But that would
> have to start with lots of filesystem work (not just NFS but CEPH,
> CIFS, etc..).
That would be nice, though NFSv2/3 might be tricky.
David
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH 06/21] VFS: Introduce a superblock configuration context [ver #3]
2017-05-17 11:31 ` David Howells
@ 2017-05-18 8:09 ` Miklos Szeredi
2017-05-19 14:05 ` David Howells
1 sibling, 0 replies; 28+ messages in thread
From: Miklos Szeredi @ 2017-05-18 8:09 UTC (permalink / raw)
To: David Howells; +Cc: viro, Jeff Layton, linux-fsdevel, linux-nfs, lkml
On Wed, May 17, 2017 at 1:31 PM, David Howells <dhowells@redhat.com> wrote:
> Miklos Szeredi <mszeredi@redhat.com> wrote:
>
>> > (b) is internal-only at the moment, used by NFS submounts as triggered by
>> > automounts. There isn't currently any way to supply mount options to this.
>>
>> And all blockdev based fs.
>
> I see what you're getting at. In which case there are more cases:
>
> (a) new mount, new sb struct with no source (eg. procfs, sysfs, tmpfs)
> (b) new mount, new sb struct, params loaded from filesystem data (eg. bdev)
> (c) new mount, new sb struct, params derived from parent (eg. NFS automount)
> (d) new mount, shared extant sb struct
> (e) remount
>
> In the case of (d) where we're attempting to make another mount for an extant
> super_block struct and we need to check the consistency of the parameters.
Yes. Current behavior seems to just ignore given options (except
MS_RDONLY) in that case, so we need to keep that possibility.
Also I think it would be good to allow selecting when superblock is created:
- non-exclusive create: if exists return it, if not create it
- exclusive create: only create if non-existent
- non-create: only return if exists
>
>> > Ah - but some of these options have to be set *inside* sget() or before the
>> > superblock becomes live, even the ones that can be changed in-flight.
>>
>> That would be the "???" category. Any concrete examples?
>
> NFS is a good example. You need parameters that indicate the server to talk
> to and specify I/O parameters before you even get the superblock as you have
> to talk to the server first. I think this is particularly true of NFSv2/3
> where you need to talk to mountd.
>
> This would also be true of AFS. There you have to access the network to look
> up the volume ID before you can call sget() as the volume ID is part of the
> index key to the set of super_block structs.
>
> Further, some of these values (I/O parameters in NFS's case, for example) form
> part of the super_block struct index key, so you have to set those inside
> sget()'s set callback.
So what I propose is:
1) call ->parse_option()
would get indication what we are trying to do (find and/or
create and/or reconfig)
this step is optional, the the filesystem type could possibly be
enough for the following steps
2) call ->get_tree()
pass sc containing parsed options and flags controlling the
creation of the superblock (create/exclusive)
this step is optional, not called if we are given an sb to work
with (i.e. only reconfig)
3) call ->reconfig()
pass sc containing parsed options
this step is optional, we might be instructed just to find or
create the sb
>
>> >> Also I think silently ignoring options is not always the right answer.
>> >
>> > Example?
>>
>> mount /dev/sda -oacl /mnt
>> mount /dev/sda -onoacl /mnt2
>
> So you'd like to give an error or a warning if ACLs are not supported, either
> by the filesystem or the kernel as a whole?
What I was getting at is that the second mount will ignore the "noacl"
option. It's not something we apparently care much about (but will
definitely want to keep as back-compat thing for the mount(2)
interface). But for the new interface I think we need something less
crazy. One solution would be the exclusive create, which doesn't have
this problem. Maybe that's enough; not sure if we need anything more
sophisticated.
>> You are thinking on the wrong level. Of course mount(2) needs to
>> handle MS_NOSUID et al. But it's doing it now, and it isn't parsing
>> "nosuid", just translating MS_NOSUID to MNT_NOSUID.
>
> Ummm... That's done by the parser in this case, so effectively it is.
Where exactly? You are not touching do_mount(), which is where the
MS_*** -> MNT_*** translation is done.
>> For the fsopen() case you won't need to parse "nosuid" because that's a flag
>> for fsmount().
>
> Whilst this is true, that means that the parser has to operate differently in
> the mount(2) and fsopen(2) cases - which I was trying to avoid.
I don't get it. We never passed MNT_* options as strings to the
kernel. That was parsed by mount(8) and translated to MS_* flags.
So how would mount(2) and fsopen(2) need to operate differently
regarding parsing MNT_* options, when we want neither to do it?
>> The only thing fsmount() should take from the sc is the root_dentry.
>> It should be equivalent to what currently is a bind mount, except it
>> should be able to fully configure the new mount.
>
> It needs to take the device name as well. I wonder if it would be possible to
> store the device name on the superblock and then leave a path-in-mount in the
Ah, mnt_devname. The device name as just a special type of option and
as such should be stored in the superblock.
> vfsmount struct to fabricate a <source>:/<path> later. Though this would
> change the behaviour if someone did:
>
> mknod /dev/foo b 8 1
> mknod /dev/bar b 8 1
> mount /dev/foo /mnt/foo
> mount /dev/bar /mnt/bar
>
> as /proc/mounts would now show /dev/foo for /mnt/bar.
I'd very much hope this doesn't introduce regressions, but if it did,
then we'd have to go back to using mnt_devname...
> Also, I guess the subtype should be wangled in the superblock-getting code
> (vfs_get_tree() as of patch 21) rather than in do_new_mount_sc(). If I do
> that, then it may be that do_new_mount_sc() only needs the root dentry pointer
> and not the sb_config pointer (except for error string passing).
Would be nice.
And hopefully error string passing can be made generic and be moved
out of this set.
Thanks,
Miklos
^ permalink raw reply [flat|nested] 28+ messages in thread* Re: [PATCH 06/21] VFS: Introduce a superblock configuration context [ver #3]
2017-05-17 11:31 ` David Howells
2017-05-18 8:09 ` Miklos Szeredi
@ 2017-05-19 14:05 ` David Howells
1 sibling, 0 replies; 28+ messages in thread
From: David Howells @ 2017-05-19 14:05 UTC (permalink / raw)
To: Miklos Szeredi
Cc: dhowells, viro, Jeff Layton, linux-fsdevel, linux-nfs, lkml
Miklos Szeredi <mszeredi@redhat.com> wrote:
> Yes. Current behavior seems to just ignore given options (except
> MS_RDONLY) in that case, so we need to keep that possibility.
Yeah. I wonder if we really should be consistency checking some parameters in
some filesystems - or, at least, offering the opportunity.
> Also I think it would be good to allow selecting when superblock is created:
>
> - non-exclusive create: if exists return it, if not create it
> - exclusive create: only create if non-existent
> - non-create: only return if exists
I quite like that idea. Use O_CREAT and O_EXCL? Probably better to define a
new flag space for fsopen() rather than trying to share with open(). I'm not
sure how likely it would be to be used, though.
> So what I propose is:
>
> 1) call ->parse_option()
>
> would get indication what we are trying to do (find and/or
> create and/or reconfig)
>
> this step is optional, the the filesystem type could possibly be
> enough for the following steps
>
> 2) call ->get_tree()
>
> pass sc containing parsed options and flags controlling the
> creation of the superblock (create/exclusive)
>
> this step is optional, not called if we are given an sb to work
> with (i.e. only reconfig)
No. We have to call this to get the root dentry. Whether or not it creates a
superblock - or even if it creates a superblock in someone else's filesystem
(the cpuset fs, for example) - is immaterial.
Further, we aren't given information as to whether the superblock was created
for us or not - though that can be changed.
Even further, I think by the time this returns, the superblock should be
live. It will be live if we're reusing it, though we can get s_umount to
prevent a race.
> 3) call ->reconfig()
>
> pass sc containing parsed options
>
> this step is optional, we might be instructed just to find or
> create the sb
Actually, it's arguable that we *shouldn't* be calling this if the superblock
already exists - otherwise we may end up changing the parameters someone else
has set.
For mount(2), for most filesystems, we have to leave the active parameters
unaltered for compatibility. For fsopen() I'm willing to add a consistency
check - but there probably has to be a flag to waive that as otherwise you
can't mount without determining what the other party's parameters were.
> I don't get it. We never passed MNT_* options as strings to the
> kernel.
You're right. I've moved all those flags over to the forbidden list.
> Ah, mnt_devname. The device name as just a special type of option and
> as such should be stored in the superblock.
I'll leave that for now and deal with it later. We have to be careful not to
break userspace by changing what's seen in /proc/mounts.
David
^ permalink raw reply [flat|nested] 28+ messages in thread
* [PATCH 07/21] Implement fsopen() to prepare for a mount [ver #3]
2017-05-15 15:17 [RFC][PATCH 00/21] VFS: Introduce superblock configuration context [ver #3] David Howells
` (5 preceding siblings ...)
2017-05-15 15:19 ` [PATCH 06/21] VFS: Introduce a superblock configuration context " David Howells
@ 2017-05-15 15:19 ` David Howells
2017-05-15 15:19 ` [PATCH 08/21] Implement fsmount() to effect a pre-configured " David Howells
` (13 subsequent siblings)
20 siblings, 0 replies; 28+ messages in thread
From: David Howells @ 2017-05-15 15:19 UTC (permalink / raw)
To: mszeredi, viro, jlayton; +Cc: dhowells, linux-fsdevel, linux-nfs, linux-kernel
Provide an fsopen() system call that starts the process of preparing to
mount, using an fd as a context handle. fsopen() is given the name of the
filesystem that will be used:
int mfd = fsopen(const char *fsname, int reserved,
int open_flags);
where reserved should be -1 for the moment (it will be used to pass the
namespace information in future) and open_flags can be 0 or O_CLOEXEC.
For example:
mfd = fsopen("ext4", -1, O_CLOEXEC);
write(mfd, "s /dev/sdb1"); // note I'm ignoring write's length arg
write(mfd, "o noatime");
write(mfd, "o acl");
write(mfd, "o user_attr");
write(mfd, "o iversion");
write(mfd, "o ");
write(mfd, "r /my/container"); // root inside the fs
fsmount(mfd, container_fd, "/mnt", AT_NO_FOLLOW);
mfd = fsopen("afs", -1);
write(mfd, "s %grand.central.org:root.cell");
write(mfd, "o cell=grand.central.org");
write(mfd, "r /");
fsmount(mfd, AT_FDCWD, "/mnt", 0);
If an error is reported at any step, an error message may be available to be
read() back (ENODATA will be reported if there isn't an error available) in
the form:
"e <subsys>:<problem>"
"e SELinux:Mount on mountpoint not permitted"
Once fsmount() has been called, further write() calls will incur EBUSY,
even if the fsmount() fails. read() is still possible to retrieve error
information.
The fsopen() syscall creates a mount context and hangs it of the fd that it
returns.
Netlink is not used because it is optional.
Signed-off-by: David Howells <dhowells@redhat.com>
---
arch/x86/entry/syscalls/syscall_32.tbl | 1
arch/x86/entry/syscalls/syscall_64.tbl | 1
fs/Makefile | 2
fs/fsopen.c | 279 ++++++++++++++++++++++++++++++++
include/linux/syscalls.h | 1
include/uapi/linux/magic.h | 1
kernel/sys_ni.c | 3
7 files changed, 287 insertions(+), 1 deletion(-)
create mode 100644 fs/fsopen.c
diff --git a/arch/x86/entry/syscalls/syscall_32.tbl b/arch/x86/entry/syscalls/syscall_32.tbl
index 448ac2161112..9bf8d4c62f85 100644
--- a/arch/x86/entry/syscalls/syscall_32.tbl
+++ b/arch/x86/entry/syscalls/syscall_32.tbl
@@ -391,3 +391,4 @@
382 i386 pkey_free sys_pkey_free
383 i386 statx sys_statx
384 i386 arch_prctl sys_arch_prctl compat_sys_arch_prctl
+385 i386 fsopen sys_fsopen
diff --git a/arch/x86/entry/syscalls/syscall_64.tbl b/arch/x86/entry/syscalls/syscall_64.tbl
index 5aef183e2f85..9b198c5fc412 100644
--- a/arch/x86/entry/syscalls/syscall_64.tbl
+++ b/arch/x86/entry/syscalls/syscall_64.tbl
@@ -339,6 +339,7 @@
330 common pkey_alloc sys_pkey_alloc
331 common pkey_free sys_pkey_free
332 common statx sys_statx
+333 common fsopen sys_fsopen
#
# x32-specific system call numbers start at 512 to avoid cache impact
diff --git a/fs/Makefile b/fs/Makefile
index 8f5142525866..b8fcf48b0400 100644
--- a/fs/Makefile
+++ b/fs/Makefile
@@ -12,7 +12,7 @@ obj-y := open.o read_write.o file_table.o super.o \
seq_file.o xattr.o libfs.o fs-writeback.o \
pnode.o splice.o sync.o utimes.o \
stack.o fs_struct.o statfs.o fs_pin.o nsfs.o \
- sb_config.o
+ sb_config.o fsopen.o
ifeq ($(CONFIG_BLOCK),y)
obj-y += buffer.o block_dev.o direct-io.o mpage.o
diff --git a/fs/fsopen.c b/fs/fsopen.c
new file mode 100644
index 000000000000..a4e9d5a7ce2b
--- /dev/null
+++ b/fs/fsopen.c
@@ -0,0 +1,279 @@
+/* Filesystem access-by-fd.
+ *
+ * Copyright (C) 2017 Red Hat, Inc. All Rights Reserved.
+ * Written by David Howells (dhowells@redhat.com)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public Licence
+ * as published by the Free Software Foundation; either version
+ * 2 of the Licence, or (at your option) any later version.
+ */
+
+#include <linux/sb_config.h>
+#include <linux/mount.h>
+#include <linux/slab.h>
+#include <linux/uaccess.h>
+#include <linux/file.h>
+#include <linux/magic.h>
+#include <linux/syscalls.h>
+
+static struct vfsmount *fs_fs_mnt __read_mostly;
+
+static int fs_fs_release(struct inode *inode, struct file *file)
+{
+ struct sb_config *sc = file->private_data;
+
+ file->private_data = NULL;
+
+ put_sb_config(sc);
+ return 0;
+}
+
+/*
+ * Read any error message back from the fd. Will be prefixed by "e ".
+ */
+static ssize_t fs_fs_read(struct file *file, char __user *_buf, size_t len, loff_t *pos)
+{
+ struct sb_config *sc = file->private_data;
+ const char *msg;
+ size_t mlen;
+
+ msg = READ_ONCE(sc->error_msg);
+ if (!msg)
+ return -ENODATA;
+
+ mlen = strlen(msg);
+ if (mlen + 2 > len)
+ return -ETOOSMALL;
+ if (copy_to_user(_buf, "e ", 2) != 0 ||
+ copy_to_user(_buf + 2, msg, mlen) != 0)
+ return -EFAULT;
+ return mlen + 2;
+}
+
+/*
+ * Userspace writes configuration data to the fd and we parse it here. For the
+ * moment, we assume a single option per write. Each line written is of the form
+ *
+ * <option_type><space><stuff...>
+ *
+ * d /dev/sda1 -- Device name
+ * o noatime -- Option without value
+ * o cell=grand.central.org -- Option with value
+ * r / -- Dir within device to mount
+ */
+static ssize_t fs_fs_write(struct file *file,
+ const char __user *_buf, size_t len, loff_t *pos)
+{
+ struct sb_config *sc = file->private_data;
+ struct inode *inode = file_inode(file);
+ char opt[2], *data;
+ ssize_t ret;
+
+ if (len < 3 || len > 4095)
+ return -EINVAL;
+
+ if (copy_from_user(opt, _buf, 2) != 0)
+ return -EFAULT;
+ switch (opt[0]) {
+ case 's':
+ case 'o':
+ break;
+ default:
+ return sb_cfg_inval(sc, "VFS: Unsupported write spec");
+ }
+ if (opt[1] != ' ')
+ return sb_cfg_inval(sc, "VFS: Unsupported write spec");
+
+ data = memdup_user_nul(_buf + 2, len - 2);
+ if (IS_ERR(data))
+ return PTR_ERR(data);
+
+ /* From this point onwards we need to lock the fd against someone
+ * trying to mount it.
+ */
+ ret = inode_lock_killable(inode);
+ if (ret < 0)
+ goto err_free;
+
+ ret = -EBUSY;
+ if (sc->mounted)
+ goto err_unlock;
+
+ ret = -EINVAL;
+ switch (opt[0]) {
+ case 's':
+ if (sc->device)
+ goto err_unlock;
+ sc->device = data;
+ data = NULL;
+ break;
+
+ case 'o':
+ ret = vfs_parse_mount_option(sc, data);
+ if (ret < 0)
+ goto err_unlock;
+ break;
+
+ default:
+ goto err_unlock;
+ }
+
+ ret = len;
+err_unlock:
+ inode_unlock(inode);
+err_free:
+ kfree(data);
+ return ret;
+}
+
+const struct file_operations fs_fs_fops = {
+ .read = fs_fs_read,
+ .write = fs_fs_write,
+ .release = fs_fs_release,
+ .llseek = no_llseek,
+};
+
+/*
+ * Indicate the name we want to display the filesystem file as.
+ */
+static char *fs_fs_dname(struct dentry *dentry, char *buffer, int buflen)
+{
+ return dynamic_dname(dentry, buffer, buflen, "fs:[%lu]",
+ d_inode(dentry)->i_ino);
+}
+
+static const struct dentry_operations fs_fs_dentry_operations = {
+ .d_dname = fs_fs_dname,
+};
+
+/*
+ * Create a file that can be used to configure a new mount.
+ */
+static struct file *create_fs_file(struct sb_config *sc)
+{
+ struct inode *inode;
+ struct file *f;
+ struct path path;
+ int ret;
+
+ inode = alloc_anon_inode(fs_fs_mnt->mnt_sb);
+ if (!inode)
+ return ERR_PTR(-ENFILE);
+ inode->i_fop = &fs_fs_fops;
+
+ ret = -ENOMEM;
+ path.dentry = d_alloc_pseudo(fs_fs_mnt->mnt_sb, &empty_name);
+ if (!path.dentry)
+ goto err_inode;
+ path.mnt = mntget(fs_fs_mnt);
+
+ d_instantiate(path.dentry, inode);
+
+ f = alloc_file(&path, FMODE_READ | FMODE_WRITE, &fs_fs_fops);
+ if (IS_ERR(f)) {
+ ret = PTR_ERR(f);
+ goto err_file;
+ }
+
+ f->private_data = sc;
+ return f;
+
+err_file:
+ path_put(&path);
+ return ERR_PTR(ret);
+
+err_inode:
+ iput(inode);
+ return ERR_PTR(ret);
+}
+
+ const struct super_operations fs_fs_ops = {
+ .drop_inode = generic_delete_inode,
+ .destroy_inode = free_inode_nonrcu,
+ .statfs = simple_statfs,
+};
+
+static struct dentry *fs_fs_mount(struct file_system_type *fs_type,
+ int flags, const char *dev_name,
+ void *data)
+{
+ return mount_pseudo(fs_type, "fs_fs:", &fs_fs_ops,
+ &fs_fs_dentry_operations, FS_FS_MAGIC);
+}
+
+static struct file_system_type fs_fs_type = {
+ .name = "fs_fs",
+ .mount = fs_fs_mount,
+ .kill_sb = kill_anon_super,
+};
+
+static int __init init_fs_fs(void)
+{
+ int ret;
+
+ ret = register_filesystem(&fs_fs_type);
+ if (ret < 0)
+ panic("Cannot register fs_fs\n");
+
+ fs_fs_mnt = kern_mount(&fs_fs_type);
+ if (IS_ERR(fs_fs_mnt))
+ panic("Cannot mount fs_fs: %ld\n", PTR_ERR(fs_fs_mnt));
+ return 0;
+}
+
+fs_initcall(init_fs_fs);
+
+/*
+ * Open a filesystem by name so that it can be configured for mounting.
+ *
+ * We are allowed to specify a container in which the filesystem will be
+ * opened, thereby indicating which namespaces will be used (notably, which
+ * network namespace will be used for network filesystems).
+ */
+SYSCALL_DEFINE3(fsopen, const char __user *, _fs_name, int, reserved,
+ unsigned int, flags)
+{
+ struct sb_config *sc;
+ struct file *file;
+ const char *fs_name;
+ int fd, ret;
+
+ if (flags & ~O_CLOEXEC || reserved != -1)
+ return -EINVAL;
+
+ fs_name = strndup_user(_fs_name, PAGE_SIZE);
+ if (IS_ERR(fs_name))
+ return PTR_ERR(fs_name);
+
+ sc = vfs_new_sb_config(fs_name);
+ kfree(fs_name);
+ if (IS_ERR(sc))
+ return PTR_ERR(sc);
+
+ ret = -ENOTSUPP;
+ if (!sc->ops)
+ goto err_sc;
+
+ file = create_fs_file(sc);
+ if (IS_ERR(file)) {
+ ret = PTR_ERR(file);
+ goto err_sc;
+ }
+
+ ret = get_unused_fd_flags(flags & O_CLOEXEC);
+ if (ret < 0)
+ goto err_file;
+
+ fd = ret;
+ fd_install(fd, file);
+ return fd;
+
+err_file:
+ fput(file);
+ return ret;
+
+err_sc:
+ put_sb_config(sc);
+ return ret;
+}
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index 980c3c9b06f8..91ec8802ad5d 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -905,5 +905,6 @@ asmlinkage long sys_pkey_alloc(unsigned long flags, unsigned long init_val);
asmlinkage long sys_pkey_free(int pkey);
asmlinkage long sys_statx(int dfd, const char __user *path, unsigned flags,
unsigned mask, struct statx __user *buffer);
+asmlinkage long sys_fsopen(const char *fs_name, int containerfd, unsigned int flags);
#endif
diff --git a/include/uapi/linux/magic.h b/include/uapi/linux/magic.h
index e230af2e6855..88ae83492f7c 100644
--- a/include/uapi/linux/magic.h
+++ b/include/uapi/linux/magic.h
@@ -84,5 +84,6 @@
#define UDF_SUPER_MAGIC 0x15013346
#define BALLOON_KVM_MAGIC 0x13661366
#define ZSMALLOC_MAGIC 0x58295829
+#define FS_FS_MAGIC 0x66736673
#endif /* __LINUX_MAGIC_H__ */
diff --git a/kernel/sys_ni.c b/kernel/sys_ni.c
index 8acef8576ce9..de1dc63e7e47 100644
--- a/kernel/sys_ni.c
+++ b/kernel/sys_ni.c
@@ -258,3 +258,6 @@ cond_syscall(sys_membarrier);
cond_syscall(sys_pkey_mprotect);
cond_syscall(sys_pkey_alloc);
cond_syscall(sys_pkey_free);
+
+/* fd-based mount */
+cond_syscall(sys_fsopen);
^ permalink raw reply related [flat|nested] 28+ messages in thread* [PATCH 08/21] Implement fsmount() to effect a pre-configured mount [ver #3]
2017-05-15 15:17 [RFC][PATCH 00/21] VFS: Introduce superblock configuration context [ver #3] David Howells
` (6 preceding siblings ...)
2017-05-15 15:19 ` [PATCH 07/21] Implement fsopen() to prepare for a mount " David Howells
@ 2017-05-15 15:19 ` David Howells
2017-05-15 15:19 ` [PATCH 09/21] Sample program for driving fsopen/fsmount " David Howells
` (12 subsequent siblings)
20 siblings, 0 replies; 28+ messages in thread
From: David Howells @ 2017-05-15 15:19 UTC (permalink / raw)
To: mszeredi, viro, jlayton; +Cc: dhowells, linux-fsdevel, linux-nfs, linux-kernel
Provide a system call by which a filesystem opened with fsopen() and
configured by a series of writes can be mounted:
int ret = fsmount(int fsfd, int dfd, const char *path,
unsigned int at_flags, unsigned int flags);
where fsfd is the fd returned by fsopen(), dfd, path and at_flags locate
the mountpoint and flags are the applicable MS_* flags. dfd can be
AT_FDCWD or an fd open to a directory.
In the event that fsmount() fails, it may be possible to get an error
message by calling read(). If no message is available, ENODATA will be
reported.
Signed-off-by: David Howells <dhowells@redhat.com>
---
arch/x86/entry/syscalls/syscall_32.tbl | 1
arch/x86/entry/syscalls/syscall_64.tbl | 1
fs/namespace.c | 99 ++++++++++++++++++++++++++++++++
include/linux/lsm_hooks.h | 6 ++
include/linux/security.h | 6 ++
include/linux/syscalls.h | 2 +
kernel/sys_ni.c | 1
security/security.c | 5 ++
security/selinux/hooks.c | 13 ++++
9 files changed, 134 insertions(+)
diff --git a/arch/x86/entry/syscalls/syscall_32.tbl b/arch/x86/entry/syscalls/syscall_32.tbl
index 9bf8d4c62f85..abe6ea95e0e6 100644
--- a/arch/x86/entry/syscalls/syscall_32.tbl
+++ b/arch/x86/entry/syscalls/syscall_32.tbl
@@ -392,3 +392,4 @@
383 i386 statx sys_statx
384 i386 arch_prctl sys_arch_prctl compat_sys_arch_prctl
385 i386 fsopen sys_fsopen
+386 i386 fsmount sys_fsmount
diff --git a/arch/x86/entry/syscalls/syscall_64.tbl b/arch/x86/entry/syscalls/syscall_64.tbl
index 9b198c5fc412..0977c5079831 100644
--- a/arch/x86/entry/syscalls/syscall_64.tbl
+++ b/arch/x86/entry/syscalls/syscall_64.tbl
@@ -340,6 +340,7 @@
331 common pkey_free sys_pkey_free
332 common statx sys_statx
333 common fsopen sys_fsopen
+334 common fsmount sys_fsmount
#
# x32-specific system call numbers start at 512 to avoid cache impact
diff --git a/fs/namespace.c b/fs/namespace.c
index 91f8a07532cd..cbac401e12a1 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -3250,6 +3250,105 @@ vfs_submount_sc(const struct dentry *mountpoint, struct sb_config *sc)
EXPORT_SYMBOL_GPL(vfs_submount_sc);
/*
+ * Mount a new, prepared superblock (specified by fs_fd) on the location
+ * specified by dfd and dir_name. dfd can be AT_FDCWD, a dir fd or a container
+ * fd. This cannot be used for binding, moving or remounting mounts.
+ */
+SYSCALL_DEFINE5(fsmount, int, fs_fd, int, dfd, const char __user *, dir_name,
+ unsigned int, at_flags, unsigned int, flags)
+{
+ struct sb_config *sc;
+ struct inode *inode;
+ struct path mountpoint;
+ struct fd f;
+ unsigned int lookup_flags, mnt_flags = 0;
+ long ret;
+
+ if ((at_flags & ~(AT_SYMLINK_NOFOLLOW | AT_NO_AUTOMOUNT |
+ AT_EMPTY_PATH)) != 0)
+ return -EINVAL;
+
+ if (flags & ~(MS_RDONLY | MS_NOSUID | MS_NODEV | MS_NOEXEC |
+ MS_NOATIME | MS_NODIRATIME | MS_RELATIME | MS_STRICTATIME))
+ return -EINVAL;
+
+ if (flags & MS_RDONLY)
+ mnt_flags |= MNT_READONLY;
+ if (flags & MS_NOSUID)
+ mnt_flags |= MNT_NOSUID;
+ if (flags & MS_NODEV)
+ mnt_flags |= MNT_NODEV;
+ if (flags & MS_NOEXEC)
+ mnt_flags |= MNT_NOEXEC;
+ if (flags & MS_NODIRATIME)
+ mnt_flags |= MNT_NODIRATIME;
+
+ if (flags & MS_STRICTATIME) {
+ if (flags & MS_NOATIME)
+ return -EINVAL;
+ } else if (flags & MS_NOATIME) {
+ mnt_flags |= MNT_NOATIME;
+ } else {
+ mnt_flags |= MNT_RELATIME;
+ }
+
+ f = fdget(fs_fd);
+ if (!f.file)
+ return -EBADF;
+
+ ret = -EINVAL;
+ if (f.file->f_op != &fs_fs_fops)
+ goto err_fsfd;
+
+ sc = f.file->private_data;
+
+ ret = -EPERM;
+ if (!may_mount() ||
+ ((sc->ms_flags & MS_MANDLOCK) && !may_mandlock()))
+ goto err_fsfd;
+
+ /* Prevent further changes. */
+ inode = file_inode(f.file);
+ ret = inode_lock_killable(inode);
+ if (ret < 0)
+ goto err_fsfd;
+ ret = -EBUSY;
+ if (!sc->mounted) {
+ sc->mounted = true;
+ ret = 0;
+ }
+ inode_unlock(inode);
+ if (ret < 0)
+ goto err_fsfd;
+
+ /* Find the mountpoint. A container can be specified in dfd. */
+ lookup_flags = LOOKUP_FOLLOW | LOOKUP_AUTOMOUNT;
+ if (at_flags & AT_SYMLINK_NOFOLLOW)
+ lookup_flags &= ~LOOKUP_FOLLOW;
+ if (at_flags & AT_NO_AUTOMOUNT)
+ lookup_flags &= ~LOOKUP_AUTOMOUNT;
+ if (at_flags & AT_EMPTY_PATH)
+ lookup_flags |= LOOKUP_EMPTY;
+ ret = user_path_at(dfd, dir_name, lookup_flags, &mountpoint);
+ if (ret < 0) {
+ sb_cfg_error(sc, "VFS: Mountpoint lookup failed");
+ goto err_fsfd;
+ }
+
+ ret = security_sb_config_mountpoint(sc, &mountpoint);
+ if (ret < 0)
+ goto err_mp;
+
+ ret = do_new_mount_sc(sc, &mountpoint, mnt_flags);
+
+err_mp:
+ path_put(&mountpoint);
+err_fsfd:
+ fdput(f);
+ return ret;
+}
+
+/*
* Return true if path is reachable from root
*
* namespace_sem or mount_lock is held
diff --git a/include/linux/lsm_hooks.h b/include/linux/lsm_hooks.h
index 48bfd49666bc..9d974074940b 100644
--- a/include/linux/lsm_hooks.h
+++ b/include/linux/lsm_hooks.h
@@ -101,6 +101,10 @@
* Equivalent of sb_kern_mount, but with a superblock configuration context.
* @sc indicates the superblock configuration context.
* @src_sb indicates the new superblock.
+ * @sb_config_mountpoint:
+ * Equivalent of sb_mount, but with an sb_config.
+ * @sc indicates the superblock configuration context.
+ * @mountpoint indicates the path on which the mount will take place.
*
* Security hooks for filesystem operations.
*
@@ -1404,6 +1408,7 @@ union security_list_options {
void (*sb_config_free)(struct sb_config *sc);
int (*sb_config_parse_option)(struct sb_config *sc, char *opt);
int (*sb_config_kern_mount)(struct sb_config *sc, struct super_block *sb);
+ int (*sb_config_mountpoint)(struct sb_config *sc, struct path *mountpoint);
int (*sb_alloc_security)(struct super_block *sb);
void (*sb_free_security)(struct super_block *sb);
@@ -1721,6 +1726,7 @@ struct security_hook_heads {
struct list_head sb_config_free;
struct list_head sb_config_parse_option;
struct list_head sb_config_kern_mount;
+ struct list_head sb_config_mountpoint;
struct list_head sb_alloc_security;
struct list_head sb_free_security;
struct list_head sb_copy_data;
diff --git a/include/linux/security.h b/include/linux/security.h
index 36b3a6779986..3d9d41d91a99 100644
--- a/include/linux/security.h
+++ b/include/linux/security.h
@@ -230,6 +230,7 @@ int security_sb_config_dup(struct sb_config *sc, struct sb_config *src_sc);
void security_sb_config_free(struct sb_config *sc);
int security_sb_config_parse_option(struct sb_config *sc, char *opt);
int security_sb_config_kern_mount(struct sb_config *sc, struct super_block *sb);
+int security_sb_config_mountpoint(struct sb_config *sc, struct path *mountpoint);
int security_sb_alloc(struct super_block *sb);
void security_sb_free(struct super_block *sb);
int security_sb_copy_data(char *orig, char *copy);
@@ -548,6 +549,11 @@ static inline int security_sb_config_kern_mount(struct sb_config *sc,
{
return 0;
}
+static inline int security_sb_config_mountpoint(struct sb_config *sc,
+ struct path *mountpoint)
+{
+ return 0;
+}
static inline int security_sb_alloc(struct super_block *sb)
{
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index 91ec8802ad5d..07e4f775f24d 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -906,5 +906,7 @@ asmlinkage long sys_pkey_free(int pkey);
asmlinkage long sys_statx(int dfd, const char __user *path, unsigned flags,
unsigned mask, struct statx __user *buffer);
asmlinkage long sys_fsopen(const char *fs_name, int containerfd, unsigned int flags);
+asmlinkage long sys_fsmount(int fsfd, int dfd, const char *path, unsigned int at_flags,
+ unsigned int flags);
#endif
diff --git a/kernel/sys_ni.c b/kernel/sys_ni.c
index de1dc63e7e47..a0fe764bd5dd 100644
--- a/kernel/sys_ni.c
+++ b/kernel/sys_ni.c
@@ -261,3 +261,4 @@ cond_syscall(sys_pkey_free);
/* fd-based mount */
cond_syscall(sys_fsopen);
+cond_syscall(sys_fsmount);
diff --git a/security/security.c b/security/security.c
index 3735fad91543..197ff60b57a7 100644
--- a/security/security.c
+++ b/security/security.c
@@ -341,6 +341,11 @@ int security_sb_config_kern_mount(struct sb_config *sc, struct super_block *sb)
return call_int_hook(sb_config_kern_mount, 0, sc, sb);
}
+int security_sb_config_mountpoint(struct sb_config *sc, struct path *mountpoint)
+{
+ return call_int_hook(sb_config_mountpoint, 0, sc, mountpoint);
+}
+
int security_sb_alloc(struct super_block *sb)
{
return call_int_hook(sb_alloc_security, 0, sb);
diff --git a/security/selinux/hooks.c b/security/selinux/hooks.c
index 286207bced52..f073b94c0035 100644
--- a/security/selinux/hooks.c
+++ b/security/selinux/hooks.c
@@ -2990,6 +2990,18 @@ static int selinux_sb_config_kern_mount(struct sb_config *sc,
return rc;
}
+static int selinux_sb_config_mountpoint(struct sb_config *sc,
+ struct path *mountpoint)
+{
+ const struct cred *cred = current_cred();
+ int ret;
+
+ ret = path_has_perm(cred, mountpoint, FILE__MOUNTON);
+ if (ret < 0)
+ sb_cfg_error(sc, "SELinux: Mount on mountpoint not permitted");
+ return ret;
+}
+
/* inode security operations */
static int selinux_inode_alloc_security(struct inode *inode)
@@ -6323,6 +6335,7 @@ static struct security_hook_list selinux_hooks[] __lsm_ro_after_init = {
LSM_HOOK_INIT(sb_config_free, selinux_sb_config_free),
LSM_HOOK_INIT(sb_config_parse_option, selinux_sb_config_parse_option),
LSM_HOOK_INIT(sb_config_kern_mount, selinux_sb_config_kern_mount),
+ LSM_HOOK_INIT(sb_config_mountpoint, selinux_sb_config_mountpoint),
LSM_HOOK_INIT(sb_alloc_security, selinux_sb_alloc_security),
LSM_HOOK_INIT(sb_free_security, selinux_sb_free_security),
^ permalink raw reply related [flat|nested] 28+ messages in thread* [PATCH 09/21] Sample program for driving fsopen/fsmount [ver #3]
2017-05-15 15:17 [RFC][PATCH 00/21] VFS: Introduce superblock configuration context [ver #3] David Howells
` (7 preceding siblings ...)
2017-05-15 15:19 ` [PATCH 08/21] Implement fsmount() to effect a pre-configured " David Howells
@ 2017-05-15 15:19 ` David Howells
2017-05-15 15:19 ` [PATCH 10/21] procfs: Move proc_fill_super() to fs/proc/root.c " David Howells
` (11 subsequent siblings)
20 siblings, 0 replies; 28+ messages in thread
From: David Howells @ 2017-05-15 15:19 UTC (permalink / raw)
To: mszeredi, viro, jlayton; +Cc: dhowells, linux-fsdevel, linux-nfs, linux-kernel
---
samples/fsmount/test-fsmount.c | 79 ++++++++++++++++++++++++++++++++++++++++
1 file changed, 79 insertions(+)
create mode 100644 samples/fsmount/test-fsmount.c
diff --git a/samples/fsmount/test-fsmount.c b/samples/fsmount/test-fsmount.c
new file mode 100644
index 000000000000..98b0258ae08f
--- /dev/null
+++ b/samples/fsmount/test-fsmount.c
@@ -0,0 +1,79 @@
+/* fd-based mount test.
+ *
+ * Copyright (C) 2017 Red Hat, Inc. All Rights Reserved.
+ * Written by David Howells (dhowells@redhat.com)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public Licence
+ * as published by the Free Software Foundation; either version
+ * 2 of the Licence, or (at your option) any later version.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/wait.h>
+
+#define E(x) do { if ((x) == -1) { perror(#x); exit(1); } } while(0)
+
+static __attribute__((noreturn))
+void mount_error(int fd, const char *s)
+{
+ char buf[4096];
+ int err, n;
+
+ err = errno;
+ n = read(fd, buf, sizeof(buf));
+ errno = err;
+ if (n > 0) {
+ n -= 2;
+ fprintf(stderr, "Error: '%s': %*.*s: %m\n", s, n, n, buf + 2);
+ } else {
+ fprintf(stderr, "%s: %m\n", s);
+ }
+ exit(1);
+}
+
+#define E_write(fd, s) \
+ do { \
+ if (write(fd, s, sizeof(s) - 1) == -1) \
+ mount_error(fd, s); \
+ } while (0)
+
+static inline int fsopen(const char *fs_name, int reserved, int flags)
+{
+ return syscall(333, fs_name, reserved, flags);
+}
+
+static inline int fsmount(int fsfd, int dfd, const char *path,
+ unsigned int at_flags, unsigned int flags)
+{
+ return syscall(334, fsfd, dfd, path, at_flags, flags);
+}
+
+int main()
+{
+ int mfd;
+
+ /* Mount an NFS filesystem */
+ mfd = fsopen("nfs4", -1, 0);
+ if (mfd == -1) {
+ perror("fsopen");
+ exit(1);
+ }
+
+ E_write(mfd, "s warthog:/data");
+ E_write(mfd, "o fsc");
+ E_write(mfd, "o sync");
+ E_write(mfd, "o intr");
+ E_write(mfd, "o vers=4.2");
+ E_write(mfd, "o addr=90.155.74.18");
+ E_write(mfd, "o clientaddr=90.155.74.21");
+ if (fsmount(mfd, AT_FDCWD, "/mnt", 0, 0) < 0)
+ mount_error(mfd, "fsmount");
+ E(close(mfd));
+
+ exit(0);
+}
^ permalink raw reply related [flat|nested] 28+ messages in thread* [PATCH 10/21] procfs: Move proc_fill_super() to fs/proc/root.c [ver #3]
2017-05-15 15:17 [RFC][PATCH 00/21] VFS: Introduce superblock configuration context [ver #3] David Howells
` (8 preceding siblings ...)
2017-05-15 15:19 ` [PATCH 09/21] Sample program for driving fsopen/fsmount " David Howells
@ 2017-05-15 15:19 ` David Howells
2017-05-15 15:19 ` [PATCH 11/21] proc: Add superblock config support to procfs " David Howells
` (10 subsequent siblings)
20 siblings, 0 replies; 28+ messages in thread
From: David Howells @ 2017-05-15 15:19 UTC (permalink / raw)
To: mszeredi, viro, jlayton; +Cc: dhowells, linux-fsdevel, linux-nfs, linux-kernel
Move proc_fill_super() to fs/proc/root.c as that's where the other
superblock stuff is.
Signed-off-by: David Howells <dhowells@redhat.com>
---
fs/proc/inode.c | 48 +-----------------------------------------------
fs/proc/internal.h | 4 +---
fs/proc/root.c | 48 +++++++++++++++++++++++++++++++++++++++++++++++-
3 files changed, 49 insertions(+), 51 deletions(-)
diff --git a/fs/proc/inode.c b/fs/proc/inode.c
index e250910cffc8..a4bf66af0ba9 100644
--- a/fs/proc/inode.c
+++ b/fs/proc/inode.c
@@ -22,7 +22,6 @@
#include <linux/seq_file.h>
#include <linux/slab.h>
#include <linux/mount.h>
-#include <linux/magic.h>
#include <linux/uaccess.h>
@@ -113,7 +112,7 @@ static int proc_show_options(struct seq_file *seq, struct dentry *root)
return 0;
}
-static const struct super_operations proc_sops = {
+const struct super_operations proc_sops = {
.alloc_inode = proc_alloc_inode,
.destroy_inode = proc_destroy_inode,
.drop_inode = generic_delete_inode,
@@ -470,48 +469,3 @@ struct inode *proc_get_inode(struct super_block *sb, struct proc_dir_entry *de)
pde_put(de);
return inode;
}
-
-int proc_fill_super(struct super_block *s, void *data, int silent)
-{
- struct pid_namespace *ns = get_pid_ns(s->s_fs_info);
- struct inode *root_inode;
- int ret;
-
- if (!proc_parse_options(data, ns))
- return -EINVAL;
-
- /* User space would break if executables or devices appear on proc */
- s->s_iflags |= SB_I_USERNS_VISIBLE | SB_I_NOEXEC | SB_I_NODEV;
- s->s_flags |= MS_NODIRATIME | MS_NOSUID | MS_NOEXEC;
- s->s_blocksize = 1024;
- s->s_blocksize_bits = 10;
- s->s_magic = PROC_SUPER_MAGIC;
- s->s_op = &proc_sops;
- s->s_time_gran = 1;
-
- /*
- * procfs isn't actually a stacking filesystem; however, there is
- * too much magic going on inside it to permit stacking things on
- * top of it
- */
- s->s_stack_depth = FILESYSTEM_MAX_STACK_DEPTH;
-
- pde_get(&proc_root);
- root_inode = proc_get_inode(s, &proc_root);
- if (!root_inode) {
- pr_err("proc_fill_super: get root inode failed\n");
- return -ENOMEM;
- }
-
- s->s_root = d_make_root(root_inode);
- if (!s->s_root) {
- pr_err("proc_fill_super: allocate dentry failed\n");
- return -ENOMEM;
- }
-
- ret = proc_setup_self(s);
- if (ret) {
- return ret;
- }
- return proc_setup_thread_self(s);
-}
diff --git a/fs/proc/internal.h b/fs/proc/internal.h
index c5ae09b6c726..b681533f59dd 100644
--- a/fs/proc/internal.h
+++ b/fs/proc/internal.h
@@ -197,13 +197,12 @@ struct pde_opener {
struct completion *c;
};
extern const struct inode_operations proc_link_inode_operations;
-
extern const struct inode_operations proc_pid_link_inode_operations;
+extern const struct super_operations proc_sops;
extern void proc_init_inodecache(void);
void set_proc_pid_nlink(void);
extern struct inode *proc_get_inode(struct super_block *, struct proc_dir_entry *);
-extern int proc_fill_super(struct super_block *, void *data, int flags);
extern void proc_entry_rundown(struct proc_dir_entry *);
/*
@@ -261,7 +260,6 @@ static inline void proc_tty_init(void) {}
* root.c
*/
extern struct proc_dir_entry proc_root;
-extern int proc_parse_options(char *options, struct pid_namespace *pid);
extern void proc_self_init(void);
extern int proc_remount(struct super_block *, int *, char *);
diff --git a/fs/proc/root.c b/fs/proc/root.c
index 3c47399bd095..ee1937b37370 100644
--- a/fs/proc/root.c
+++ b/fs/proc/root.c
@@ -23,6 +23,7 @@
#include <linux/pid_namespace.h>
#include <linux/parser.h>
#include <linux/cred.h>
+#include <linux/magic.h>
#include "internal.h"
@@ -36,7 +37,7 @@ static const match_table_t tokens = {
{Opt_err, NULL},
};
-int proc_parse_options(char *options, struct pid_namespace *pid)
+static int proc_parse_options(char *options, struct pid_namespace *pid)
{
char *p;
substring_t args[MAX_OPT_ARGS];
@@ -78,6 +79,51 @@ int proc_parse_options(char *options, struct pid_namespace *pid)
return 1;
}
+static int proc_fill_super(struct super_block *s, void *data, int silent)
+{
+ struct pid_namespace *ns = get_pid_ns(s->s_fs_info);
+ struct inode *root_inode;
+ int ret;
+
+ if (!proc_parse_options(data, ns))
+ return -EINVAL;
+
+ /* User space would break if executables or devices appear on proc */
+ s->s_iflags |= SB_I_USERNS_VISIBLE | SB_I_NOEXEC | SB_I_NODEV;
+ s->s_flags |= MS_NODIRATIME | MS_NOSUID | MS_NOEXEC;
+ s->s_blocksize = 1024;
+ s->s_blocksize_bits = 10;
+ s->s_magic = PROC_SUPER_MAGIC;
+ s->s_op = &proc_sops;
+ s->s_time_gran = 1;
+
+ /*
+ * procfs isn't actually a stacking filesystem; however, there is
+ * too much magic going on inside it to permit stacking things on
+ * top of it
+ */
+ s->s_stack_depth = FILESYSTEM_MAX_STACK_DEPTH;
+
+ pde_get(&proc_root);
+ root_inode = proc_get_inode(s, &proc_root);
+ if (!root_inode) {
+ pr_err("proc_fill_super: get root inode failed\n");
+ return -ENOMEM;
+ }
+
+ s->s_root = d_make_root(root_inode);
+ if (!s->s_root) {
+ pr_err("proc_fill_super: allocate dentry failed\n");
+ return -ENOMEM;
+ }
+
+ ret = proc_setup_self(s);
+ if (ret) {
+ return ret;
+ }
+ return proc_setup_thread_self(s);
+}
+
int proc_remount(struct super_block *sb, int *flags, char *data)
{
struct pid_namespace *pid = sb->s_fs_info;
^ permalink raw reply related [flat|nested] 28+ messages in thread* [PATCH 11/21] proc: Add superblock config support to procfs [ver #3]
2017-05-15 15:17 [RFC][PATCH 00/21] VFS: Introduce superblock configuration context [ver #3] David Howells
` (9 preceding siblings ...)
2017-05-15 15:19 ` [PATCH 10/21] procfs: Move proc_fill_super() to fs/proc/root.c " David Howells
@ 2017-05-15 15:19 ` David Howells
2017-05-15 15:19 ` [PATCH 12/21] NFS: Move mount bits into their own file " David Howells
` (9 subsequent siblings)
20 siblings, 0 replies; 28+ messages in thread
From: David Howells @ 2017-05-15 15:19 UTC (permalink / raw)
To: mszeredi, viro, jlayton; +Cc: dhowells, linux-fsdevel, linux-nfs, linux-kernel
Add superblock config support to procfs.
Signed-off-by: David Howells <dhowells@redhat.com>
---
fs/proc/inode.c | 2 -
fs/proc/internal.h | 2 -
fs/proc/root.c | 166 +++++++++++++++++++++++++++++++++-------------------
3 files changed, 108 insertions(+), 62 deletions(-)
diff --git a/fs/proc/inode.c b/fs/proc/inode.c
index a4bf66af0ba9..304e5c36b7ba 100644
--- a/fs/proc/inode.c
+++ b/fs/proc/inode.c
@@ -118,7 +118,7 @@ const struct super_operations proc_sops = {
.drop_inode = generic_delete_inode,
.evict_inode = proc_evict_inode,
.statfs = simple_statfs,
- .remount_fs = proc_remount,
+ .remount_fs_sc = proc_remount,
.show_options = proc_show_options,
};
diff --git a/fs/proc/internal.h b/fs/proc/internal.h
index b681533f59dd..4546372c2d13 100644
--- a/fs/proc/internal.h
+++ b/fs/proc/internal.h
@@ -262,7 +262,7 @@ static inline void proc_tty_init(void) {}
extern struct proc_dir_entry proc_root;
extern void proc_self_init(void);
-extern int proc_remount(struct super_block *, int *, char *);
+extern int proc_remount(struct super_block *, struct sb_config *);
/*
* task_[no]mmu.c
diff --git a/fs/proc/root.c b/fs/proc/root.c
index ee1937b37370..da5757d1c518 100644
--- a/fs/proc/root.c
+++ b/fs/proc/root.c
@@ -24,9 +24,18 @@
#include <linux/parser.h>
#include <linux/cred.h>
#include <linux/magic.h>
+#include <linux/slab.h>
#include "internal.h"
+struct proc_sb_config {
+ struct sb_config sc;
+ struct pid_namespace *pid_ns;
+ unsigned long mask;
+ int hidepid;
+ int gid;
+};
+
enum {
Opt_gid, Opt_hidepid, Opt_err,
};
@@ -37,56 +46,60 @@ static const match_table_t tokens = {
{Opt_err, NULL},
};
-static int proc_parse_options(char *options, struct pid_namespace *pid)
+static int proc_parse_mount_option(struct sb_config *sc, char *p)
{
- char *p;
+ struct proc_sb_config *cfg = container_of(sc, struct proc_sb_config, sc);
substring_t args[MAX_OPT_ARGS];
- int option;
-
- if (!options)
- return 1;
-
- while ((p = strsep(&options, ",")) != NULL) {
- int token;
- if (!*p)
- continue;
-
- args[0].to = args[0].from = NULL;
- token = match_token(p, tokens, args);
- switch (token) {
- case Opt_gid:
- if (match_int(&args[0], &option))
- return 0;
- pid->pid_gid = make_kgid(current_user_ns(), option);
- break;
- case Opt_hidepid:
- if (match_int(&args[0], &option))
- return 0;
- if (option < HIDEPID_OFF ||
- option > HIDEPID_INVISIBLE) {
- pr_err("proc: hidepid value must be between 0 and 2.\n");
- return 0;
- }
- pid->hide_pid = option;
- break;
- default:
- pr_err("proc: unrecognized mount option \"%s\" "
- "or missing value\n", p);
- return 0;
+ int token;
+
+ args[0].to = args[0].from = NULL;
+ token = match_token(p, tokens, args);
+ switch (token) {
+ case Opt_gid:
+ if (match_int(&args[0], &cfg->gid))
+ return sb_cfg_inval(sc, "procfs: Unparseable gid= argument");
+ break;
+
+ case Opt_hidepid:
+ if (match_int(&args[0], &cfg->hidepid))
+ return sb_cfg_inval(sc, "procfs: Unparseable hidepid= argument");
+ if (cfg->hidepid < HIDEPID_OFF ||
+ cfg->hidepid > HIDEPID_INVISIBLE) {
+ pr_err("proc: hidepid value must be between 0 and 2.\n");
+ return sb_cfg_inval(sc, "procfs: Invalid hidepid= argument");
}
+ break;
+
+ default:
+ pr_err("proc: unrecognized mount option \"%s\" "
+ "or missing value\n", p);
+ return sb_cfg_inval(sc, "procfs: Invalid mount option or missing value");
}
- return 1;
+ cfg->mask |= 1 << token;
+ return 0;
+}
+
+static void proc_set_options(struct super_block *s,
+ struct sb_config *sc,
+ struct pid_namespace *pid_ns,
+ struct user_namespace *user_ns)
+{
+ struct proc_sb_config *cfg = container_of(sc, struct proc_sb_config, sc);
+
+ if (cfg->mask & (1 << Opt_gid))
+ pid_ns->pid_gid = make_kgid(user_ns, cfg->gid);
+ if (cfg->mask & (1 << Opt_hidepid))
+ pid_ns->hide_pid = cfg->hidepid;
}
-static int proc_fill_super(struct super_block *s, void *data, int silent)
+static int proc_fill_super(struct super_block *s, struct sb_config *sc)
{
- struct pid_namespace *ns = get_pid_ns(s->s_fs_info);
+ struct pid_namespace *pid_ns = get_pid_ns(s->s_fs_info);
struct inode *root_inode;
int ret;
- if (!proc_parse_options(data, ns))
- return -EINVAL;
+ proc_set_options(s, sc, pid_ns, current_user_ns());
/* User space would break if executables or devices appear on proc */
s->s_iflags |= SB_I_USERNS_VISIBLE | SB_I_NOEXEC | SB_I_NODEV;
@@ -103,7 +116,7 @@ static int proc_fill_super(struct super_block *s, void *data, int silent)
* top of it
*/
s->s_stack_depth = FILESYSTEM_MAX_STACK_DEPTH;
-
+
pde_get(&proc_root);
root_inode = proc_get_inode(s, &proc_root);
if (!root_inode) {
@@ -124,27 +137,45 @@ static int proc_fill_super(struct super_block *s, void *data, int silent)
return proc_setup_thread_self(s);
}
-int proc_remount(struct super_block *sb, int *flags, char *data)
+int proc_remount(struct super_block *sb, struct sb_config *sc)
{
struct pid_namespace *pid = sb->s_fs_info;
sync_filesystem(sb);
- return !proc_parse_options(data, pid);
+
+ if (sc)
+ proc_set_options(sb, sc, pid, current_user_ns());
+ return 0;
}
-static struct dentry *proc_mount(struct file_system_type *fs_type,
- int flags, const char *dev_name, void *data)
+static struct dentry *proc_mount(struct sb_config *sc)
{
- struct pid_namespace *ns;
+ struct proc_sb_config *cfg = container_of(sc, struct proc_sb_config, sc);
- if (flags & MS_KERNMOUNT) {
- ns = data;
- data = NULL;
- } else {
- ns = task_active_pid_ns(current);
- }
+ return mount_ns_sc(sc, proc_fill_super, cfg->pid_ns);
+}
- return mount_ns(fs_type, flags, data, ns, ns->user_ns, proc_fill_super);
+static void proc_sb_config_free(struct sb_config *sc)
+{
+ struct proc_sb_config *cfg = container_of(sc, struct proc_sb_config, sc);
+
+ if (cfg->pid_ns)
+ put_pid_ns(cfg->pid_ns);
+}
+
+static const struct sb_config_operations proc_sb_config_ops = {
+ .free = proc_sb_config_free,
+ .parse_option = proc_parse_mount_option,
+ .mount = proc_mount,
+};
+
+static int proc_init_sb_config(struct sb_config *sc, struct super_block *src_sb)
+{
+ struct proc_sb_config *cfg = container_of(sc, struct proc_sb_config, sc);
+
+ cfg->pid_ns = get_pid_ns(task_active_pid_ns(current));
+ cfg->sc.ops = &proc_sb_config_ops;
+ return 0;
}
static void proc_kill_sb(struct super_block *sb)
@@ -162,7 +193,8 @@ static void proc_kill_sb(struct super_block *sb)
static struct file_system_type proc_fs_type = {
.name = "proc",
- .mount = proc_mount,
+ .sb_config_size = sizeof(struct proc_sb_config),
+ .init_sb_config = proc_init_sb_config,
.kill_sb = proc_kill_sb,
.fs_flags = FS_USERNS_MOUNT,
};
@@ -210,7 +242,7 @@ static struct dentry *proc_root_lookup(struct inode * dir, struct dentry * dentr
{
if (!proc_pid_lookup(dir, dentry, flags))
return NULL;
-
+
return proc_lookup(dir, dentry, flags);
}
@@ -249,12 +281,12 @@ static const struct inode_operations proc_root_inode_operations = {
* This is the root "inode" in the /proc tree..
*/
struct proc_dir_entry proc_root = {
- .low_ino = PROC_ROOT_INO,
- .namelen = 5,
- .mode = S_IFDIR | S_IRUGO | S_IXUGO,
- .nlink = 2,
+ .low_ino = PROC_ROOT_INO,
+ .namelen = 5,
+ .mode = S_IFDIR | S_IRUGO | S_IXUGO,
+ .nlink = 2,
.count = ATOMIC_INIT(1),
- .proc_iops = &proc_root_inode_operations,
+ .proc_iops = &proc_root_inode_operations,
.proc_fops = &proc_root_operations,
.parent = &proc_root,
.subdir = RB_ROOT,
@@ -263,9 +295,23 @@ struct proc_dir_entry proc_root = {
int pid_ns_prepare_proc(struct pid_namespace *ns)
{
+ struct proc_sb_config *cfg;
+ struct sb_config *sc;
struct vfsmount *mnt;
- mnt = kern_mount_data(&proc_fs_type, ns);
+ sc = __vfs_new_sb_config(&proc_fs_type, NULL, 0, SB_CONFIG_FOR_NEW);
+ if (IS_ERR(sc))
+ return PTR_ERR(sc);
+
+ cfg = container_of(sc, struct proc_sb_config, sc);
+ if (cfg->pid_ns != ns) {
+ put_pid_ns(cfg->pid_ns);
+ get_pid_ns(ns);
+ cfg->pid_ns = ns;
+ }
+
+ mnt = kern_mount_data_sc(sc);
+ put_sb_config(sc);
if (IS_ERR(mnt))
return PTR_ERR(mnt);
^ permalink raw reply related [flat|nested] 28+ messages in thread* [PATCH 12/21] NFS: Move mount bits into their own file [ver #3]
2017-05-15 15:17 [RFC][PATCH 00/21] VFS: Introduce superblock configuration context [ver #3] David Howells
` (10 preceding siblings ...)
2017-05-15 15:19 ` [PATCH 11/21] proc: Add superblock config support to procfs " David Howells
@ 2017-05-15 15:19 ` David Howells
2017-05-15 15:20 ` [PATCH 13/21] NFS: Constify mount argument match tables " David Howells
` (8 subsequent siblings)
20 siblings, 0 replies; 28+ messages in thread
From: David Howells @ 2017-05-15 15:19 UTC (permalink / raw)
To: mszeredi, viro, jlayton; +Cc: dhowells, linux-fsdevel, linux-nfs, linux-kernel
---
fs/nfs/Makefile | 2
fs/nfs/internal.h | 30 +
fs/nfs/mount.c | 1398 +++++++++++++++++++++++++++++++++++++++++++++++++++++
fs/nfs/super.c | 1391 -----------------------------------------------------
4 files changed, 1429 insertions(+), 1392 deletions(-)
create mode 100644 fs/nfs/mount.c
diff --git a/fs/nfs/Makefile b/fs/nfs/Makefile
index 98f4e5728a67..3880ef2fb69a 100644
--- a/fs/nfs/Makefile
+++ b/fs/nfs/Makefile
@@ -7,7 +7,7 @@ obj-$(CONFIG_NFS_FS) += nfs.o
CFLAGS_nfstrace.o += -I$(src)
nfs-y := client.o dir.o file.o getroot.o inode.o super.o \
io.o direct.o pagelist.o read.o symlink.o unlink.o \
- write.o namespace.o mount_clnt.o nfstrace.o
+ write.o namespace.o mount_clnt.o nfstrace.o mount.o
nfs-$(CONFIG_ROOT_NFS) += nfsroot.o
nfs-$(CONFIG_SYSCTL) += sysctl.o
nfs-$(CONFIG_NFS_FSCACHE) += fscache.o fscache-index.o
diff --git a/fs/nfs/internal.h b/fs/nfs/internal.h
index e9b4c3320e37..260494be399e 100644
--- a/fs/nfs/internal.h
+++ b/fs/nfs/internal.h
@@ -6,6 +6,7 @@
#include <linux/mount.h>
#include <linux/security.h>
#include <linux/crc32.h>
+#include <linux/sunrpc/addr.h>
#include <linux/nfs_page.h>
#define NFS_MS_MASK (MS_RDONLY|MS_NOSUID|MS_NODEV|MS_NOEXEC|MS_SYNCHRONOUS)
@@ -229,6 +230,22 @@ extern struct svc_version nfs4_callback_version1;
extern struct svc_version nfs4_callback_version4;
struct nfs_pageio_descriptor;
+
+/* mount.c */
+#define NFS_TEXT_DATA 1
+
+extern struct nfs_parsed_mount_data *nfs_alloc_parsed_mount_data(void);
+extern void nfs_free_parsed_mount_data(struct nfs_parsed_mount_data *data);
+extern int nfs_parse_mount_options(char *raw, struct nfs_parsed_mount_data *mnt);
+extern int nfs_validate_mount_data(struct file_system_type *fs_type,
+ void *options,
+ struct nfs_parsed_mount_data *args,
+ struct nfs_fh *mntfh,
+ const char *dev_name);
+extern int nfs_validate_text_mount_data(void *options,
+ struct nfs_parsed_mount_data *args,
+ const char *dev_name);
+
/* pagelist.c */
extern int __init nfs_init_nfspagecache(void);
extern void nfs_destroy_nfspagecache(void);
@@ -768,3 +785,16 @@ static inline bool nfs_error_is_fatal(int err)
return false;
}
}
+
+/*
+ * Select between a default port value and a user-specified port value.
+ * If a zero value is set, then autobind will be used.
+ */
+static inline void nfs_set_port(struct sockaddr *sap, int *port,
+ const unsigned short default_port)
+{
+ if (*port == NFS_UNSPEC_PORT)
+ *port = default_port;
+
+ rpc_set_port(sap, *port);
+}
diff --git a/fs/nfs/mount.c b/fs/nfs/mount.c
new file mode 100644
index 000000000000..eb77d9af6c35
--- /dev/null
+++ b/fs/nfs/mount.c
@@ -0,0 +1,1398 @@
+/* NFS mount handling.
+ *
+ * Copyright (C) 2017 Red Hat, Inc. All Rights Reserved.
+ * Written by David Howells (dhowells@redhat.com)
+ *
+ * Split from fs/nfs/super.c:
+ *
+ * Copyright (C) 1992 Rick Sladkey
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public Licence
+ * as published by the Free Software Foundation; either version
+ * 2 of the Licence, or (at your option) any later version.
+ */
+
+#include <linux/module.h>
+#include <linux/fs.h>
+#include <linux/parser.h>
+#include <linux/nfs_fs.h>
+#include <linux/nfs_mount.h>
+#include <linux/nfs4_mount.h>
+#include "nfs.h"
+#include "internal.h"
+
+#define NFSDBG_FACILITY NFSDBG_MOUNT
+
+#if IS_ENABLED(CONFIG_NFS_V3)
+#define NFS_DEFAULT_VERSION 3
+#else
+#define NFS_DEFAULT_VERSION 2
+#endif
+
+enum {
+ /* Mount options that take no arguments */
+ Opt_soft, Opt_hard,
+ Opt_posix, Opt_noposix,
+ Opt_cto, Opt_nocto,
+ Opt_ac, Opt_noac,
+ Opt_lock, Opt_nolock,
+ Opt_udp, Opt_tcp, Opt_rdma,
+ Opt_acl, Opt_noacl,
+ Opt_rdirplus, Opt_nordirplus,
+ Opt_sharecache, Opt_nosharecache,
+ Opt_resvport, Opt_noresvport,
+ Opt_fscache, Opt_nofscache,
+ Opt_migration, Opt_nomigration,
+
+ /* Mount options that take integer arguments */
+ Opt_port,
+ Opt_rsize, Opt_wsize, Opt_bsize,
+ Opt_timeo, Opt_retrans,
+ Opt_acregmin, Opt_acregmax,
+ Opt_acdirmin, Opt_acdirmax,
+ Opt_actimeo,
+ Opt_namelen,
+ Opt_mountport,
+ Opt_mountvers,
+ Opt_minorversion,
+
+ /* Mount options that take string arguments */
+ Opt_nfsvers,
+ Opt_sec, Opt_proto, Opt_mountproto, Opt_mounthost,
+ Opt_addr, Opt_mountaddr, Opt_clientaddr,
+ Opt_lookupcache,
+ Opt_fscache_uniq,
+ Opt_local_lock,
+
+ /* Special mount options */
+ Opt_userspace, Opt_deprecated, Opt_sloppy,
+
+ Opt_err
+};
+
+static const match_table_t nfs_mount_option_tokens = {
+ { Opt_userspace, "bg" },
+ { Opt_userspace, "fg" },
+ { Opt_userspace, "retry=%s" },
+
+ { Opt_sloppy, "sloppy" },
+
+ { Opt_soft, "soft" },
+ { Opt_hard, "hard" },
+ { Opt_deprecated, "intr" },
+ { Opt_deprecated, "nointr" },
+ { Opt_posix, "posix" },
+ { Opt_noposix, "noposix" },
+ { Opt_cto, "cto" },
+ { Opt_nocto, "nocto" },
+ { Opt_ac, "ac" },
+ { Opt_noac, "noac" },
+ { Opt_lock, "lock" },
+ { Opt_nolock, "nolock" },
+ { Opt_udp, "udp" },
+ { Opt_tcp, "tcp" },
+ { Opt_rdma, "rdma" },
+ { Opt_acl, "acl" },
+ { Opt_noacl, "noacl" },
+ { Opt_rdirplus, "rdirplus" },
+ { Opt_nordirplus, "nordirplus" },
+ { Opt_sharecache, "sharecache" },
+ { Opt_nosharecache, "nosharecache" },
+ { Opt_resvport, "resvport" },
+ { Opt_noresvport, "noresvport" },
+ { Opt_fscache, "fsc" },
+ { Opt_nofscache, "nofsc" },
+ { Opt_migration, "migration" },
+ { Opt_nomigration, "nomigration" },
+
+ { Opt_port, "port=%s" },
+ { Opt_rsize, "rsize=%s" },
+ { Opt_wsize, "wsize=%s" },
+ { Opt_bsize, "bsize=%s" },
+ { Opt_timeo, "timeo=%s" },
+ { Opt_retrans, "retrans=%s" },
+ { Opt_acregmin, "acregmin=%s" },
+ { Opt_acregmax, "acregmax=%s" },
+ { Opt_acdirmin, "acdirmin=%s" },
+ { Opt_acdirmax, "acdirmax=%s" },
+ { Opt_actimeo, "actimeo=%s" },
+ { Opt_namelen, "namlen=%s" },
+ { Opt_mountport, "mountport=%s" },
+ { Opt_mountvers, "mountvers=%s" },
+ { Opt_minorversion, "minorversion=%s" },
+
+ { Opt_nfsvers, "nfsvers=%s" },
+ { Opt_nfsvers, "vers=%s" },
+
+ { Opt_sec, "sec=%s" },
+ { Opt_proto, "proto=%s" },
+ { Opt_mountproto, "mountproto=%s" },
+ { Opt_addr, "addr=%s" },
+ { Opt_clientaddr, "clientaddr=%s" },
+ { Opt_mounthost, "mounthost=%s" },
+ { Opt_mountaddr, "mountaddr=%s" },
+
+ { Opt_lookupcache, "lookupcache=%s" },
+ { Opt_fscache_uniq, "fsc=%s" },
+ { Opt_local_lock, "local_lock=%s" },
+
+ /* The following needs to be listed after all other options */
+ { Opt_nfsvers, "v%s" },
+
+ { Opt_err, NULL }
+};
+
+enum {
+ Opt_xprt_udp, Opt_xprt_udp6, Opt_xprt_tcp, Opt_xprt_tcp6, Opt_xprt_rdma,
+ Opt_xprt_rdma6,
+
+ Opt_xprt_err
+};
+
+static const match_table_t nfs_xprt_protocol_tokens = {
+ { Opt_xprt_udp, "udp" },
+ { Opt_xprt_udp6, "udp6" },
+ { Opt_xprt_tcp, "tcp" },
+ { Opt_xprt_tcp6, "tcp6" },
+ { Opt_xprt_rdma, "rdma" },
+ { Opt_xprt_rdma6, "rdma6" },
+
+ { Opt_xprt_err, NULL }
+};
+
+enum {
+ Opt_sec_none, Opt_sec_sys,
+ Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
+ Opt_sec_lkey, Opt_sec_lkeyi, Opt_sec_lkeyp,
+ Opt_sec_spkm, Opt_sec_spkmi, Opt_sec_spkmp,
+
+ Opt_sec_err
+};
+
+static const match_table_t nfs_secflavor_tokens = {
+ { Opt_sec_none, "none" },
+ { Opt_sec_none, "null" },
+ { Opt_sec_sys, "sys" },
+
+ { Opt_sec_krb5, "krb5" },
+ { Opt_sec_krb5i, "krb5i" },
+ { Opt_sec_krb5p, "krb5p" },
+
+ { Opt_sec_lkey, "lkey" },
+ { Opt_sec_lkeyi, "lkeyi" },
+ { Opt_sec_lkeyp, "lkeyp" },
+
+ { Opt_sec_spkm, "spkm3" },
+ { Opt_sec_spkmi, "spkm3i" },
+ { Opt_sec_spkmp, "spkm3p" },
+
+ { Opt_sec_err, NULL }
+};
+
+enum {
+ Opt_lookupcache_all, Opt_lookupcache_positive,
+ Opt_lookupcache_none,
+
+ Opt_lookupcache_err
+};
+
+static match_table_t nfs_lookupcache_tokens = {
+ { Opt_lookupcache_all, "all" },
+ { Opt_lookupcache_positive, "pos" },
+ { Opt_lookupcache_positive, "positive" },
+ { Opt_lookupcache_none, "none" },
+
+ { Opt_lookupcache_err, NULL }
+};
+
+enum {
+ Opt_local_lock_all, Opt_local_lock_flock, Opt_local_lock_posix,
+ Opt_local_lock_none,
+
+ Opt_local_lock_err
+};
+
+static match_table_t nfs_local_lock_tokens = {
+ { Opt_local_lock_all, "all" },
+ { Opt_local_lock_flock, "flock" },
+ { Opt_local_lock_posix, "posix" },
+ { Opt_local_lock_none, "none" },
+
+ { Opt_local_lock_err, NULL }
+};
+
+enum {
+ Opt_vers_2, Opt_vers_3, Opt_vers_4, Opt_vers_4_0,
+ Opt_vers_4_1, Opt_vers_4_2,
+
+ Opt_vers_err
+};
+
+static match_table_t nfs_vers_tokens = {
+ { Opt_vers_2, "2" },
+ { Opt_vers_3, "3" },
+ { Opt_vers_4, "4" },
+ { Opt_vers_4_0, "4.0" },
+ { Opt_vers_4_1, "4.1" },
+ { Opt_vers_4_2, "4.2" },
+
+ { Opt_vers_err, NULL }
+};
+
+struct nfs_parsed_mount_data *nfs_alloc_parsed_mount_data(void)
+{
+ struct nfs_parsed_mount_data *data;
+
+ data = kzalloc(sizeof(*data), GFP_KERNEL);
+ if (data) {
+ data->timeo = NFS_UNSPEC_TIMEO;
+ data->retrans = NFS_UNSPEC_RETRANS;
+ data->acregmin = NFS_DEF_ACREGMIN;
+ data->acregmax = NFS_DEF_ACREGMAX;
+ data->acdirmin = NFS_DEF_ACDIRMIN;
+ data->acdirmax = NFS_DEF_ACDIRMAX;
+ data->mount_server.port = NFS_UNSPEC_PORT;
+ data->nfs_server.port = NFS_UNSPEC_PORT;
+ data->nfs_server.protocol = XPRT_TRANSPORT_TCP;
+ data->selected_flavor = RPC_AUTH_MAXFLAVOR;
+ data->minorversion = 0;
+ data->need_mount = true;
+ data->net = current->nsproxy->net_ns;
+ security_init_mnt_opts(&data->lsm_opts);
+ }
+ return data;
+}
+
+void nfs_free_parsed_mount_data(struct nfs_parsed_mount_data *data)
+{
+ if (data) {
+ kfree(data->client_address);
+ kfree(data->mount_server.hostname);
+ kfree(data->nfs_server.export_path);
+ kfree(data->nfs_server.hostname);
+ kfree(data->fscache_uniq);
+ security_free_mnt_opts(&data->lsm_opts);
+ kfree(data);
+ }
+}
+
+/*
+ * Sanity-check a server address provided by the mount command.
+ *
+ * Address family must be initialized, and address must not be
+ * the ANY address for that family.
+ */
+static int nfs_verify_server_address(struct sockaddr *addr)
+{
+ switch (addr->sa_family) {
+ case AF_INET: {
+ struct sockaddr_in *sa = (struct sockaddr_in *)addr;
+ return sa->sin_addr.s_addr != htonl(INADDR_ANY);
+ }
+ case AF_INET6: {
+ struct in6_addr *sa = &((struct sockaddr_in6 *)addr)->sin6_addr;
+ return !ipv6_addr_any(sa);
+ }
+ }
+
+ dfprintk(MOUNT, "NFS: Invalid IP address specified\n");
+ return 0;
+}
+
+/*
+ * Sanity check the NFS transport protocol.
+ *
+ */
+static void nfs_validate_transport_protocol(struct nfs_parsed_mount_data *mnt)
+{
+ switch (mnt->nfs_server.protocol) {
+ case XPRT_TRANSPORT_UDP:
+ case XPRT_TRANSPORT_TCP:
+ case XPRT_TRANSPORT_RDMA:
+ break;
+ default:
+ mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP;
+ }
+}
+
+/*
+ * For text based NFSv2/v3 mounts, the mount protocol transport default
+ * settings should depend upon the specified NFS transport.
+ */
+static void nfs_set_mount_transport_protocol(struct nfs_parsed_mount_data *mnt)
+{
+ nfs_validate_transport_protocol(mnt);
+
+ if (mnt->mount_server.protocol == XPRT_TRANSPORT_UDP ||
+ mnt->mount_server.protocol == XPRT_TRANSPORT_TCP)
+ return;
+ switch (mnt->nfs_server.protocol) {
+ case XPRT_TRANSPORT_UDP:
+ mnt->mount_server.protocol = XPRT_TRANSPORT_UDP;
+ break;
+ case XPRT_TRANSPORT_TCP:
+ case XPRT_TRANSPORT_RDMA:
+ mnt->mount_server.protocol = XPRT_TRANSPORT_TCP;
+ }
+}
+
+/*
+ * Add 'flavor' to 'auth_info' if not already present.
+ * Returns true if 'flavor' ends up in the list, false otherwise
+ */
+static bool nfs_auth_info_add(struct nfs_auth_info *auth_info,
+ rpc_authflavor_t flavor)
+{
+ unsigned int i;
+ unsigned int max_flavor_len = ARRAY_SIZE(auth_info->flavors);
+
+ /* make sure this flavor isn't already in the list */
+ for (i = 0; i < auth_info->flavor_len; i++) {
+ if (flavor == auth_info->flavors[i])
+ return true;
+ }
+
+ if (auth_info->flavor_len + 1 >= max_flavor_len) {
+ dfprintk(MOUNT, "NFS: too many sec= flavors\n");
+ return false;
+ }
+
+ auth_info->flavors[auth_info->flavor_len++] = flavor;
+ return true;
+}
+
+/*
+ * Parse the value of the 'sec=' option.
+ */
+static int nfs_parse_security_flavors(char *value,
+ struct nfs_parsed_mount_data *mnt)
+{
+ substring_t args[MAX_OPT_ARGS];
+ rpc_authflavor_t pseudoflavor;
+ char *p;
+
+ dfprintk(MOUNT, "NFS: parsing sec=%s option\n", value);
+
+ while ((p = strsep(&value, ":")) != NULL) {
+ switch (match_token(p, nfs_secflavor_tokens, args)) {
+ case Opt_sec_none:
+ pseudoflavor = RPC_AUTH_NULL;
+ break;
+ case Opt_sec_sys:
+ pseudoflavor = RPC_AUTH_UNIX;
+ break;
+ case Opt_sec_krb5:
+ pseudoflavor = RPC_AUTH_GSS_KRB5;
+ break;
+ case Opt_sec_krb5i:
+ pseudoflavor = RPC_AUTH_GSS_KRB5I;
+ break;
+ case Opt_sec_krb5p:
+ pseudoflavor = RPC_AUTH_GSS_KRB5P;
+ break;
+ case Opt_sec_lkey:
+ pseudoflavor = RPC_AUTH_GSS_LKEY;
+ break;
+ case Opt_sec_lkeyi:
+ pseudoflavor = RPC_AUTH_GSS_LKEYI;
+ break;
+ case Opt_sec_lkeyp:
+ pseudoflavor = RPC_AUTH_GSS_LKEYP;
+ break;
+ case Opt_sec_spkm:
+ pseudoflavor = RPC_AUTH_GSS_SPKM;
+ break;
+ case Opt_sec_spkmi:
+ pseudoflavor = RPC_AUTH_GSS_SPKMI;
+ break;
+ case Opt_sec_spkmp:
+ pseudoflavor = RPC_AUTH_GSS_SPKMP;
+ break;
+ default:
+ dfprintk(MOUNT,
+ "NFS: sec= option '%s' not recognized\n", p);
+ return 0;
+ }
+
+ if (!nfs_auth_info_add(&mnt->auth_info, pseudoflavor))
+ return 0;
+ }
+
+ return 1;
+}
+
+static int nfs_parse_version_string(char *string,
+ struct nfs_parsed_mount_data *mnt,
+ substring_t *args)
+{
+ mnt->flags &= ~NFS_MOUNT_VER3;
+ switch (match_token(string, nfs_vers_tokens, args)) {
+ case Opt_vers_2:
+ mnt->version = 2;
+ break;
+ case Opt_vers_3:
+ mnt->flags |= NFS_MOUNT_VER3;
+ mnt->version = 3;
+ break;
+ case Opt_vers_4:
+ /* Backward compatibility option. In future,
+ * the mount program should always supply
+ * a NFSv4 minor version number.
+ */
+ mnt->version = 4;
+ break;
+ case Opt_vers_4_0:
+ mnt->version = 4;
+ mnt->minorversion = 0;
+ break;
+ case Opt_vers_4_1:
+ mnt->version = 4;
+ mnt->minorversion = 1;
+ break;
+ case Opt_vers_4_2:
+ mnt->version = 4;
+ mnt->minorversion = 2;
+ break;
+ default:
+ return 0;
+ }
+ return 1;
+}
+
+static int nfs_get_option_str(substring_t args[], char **option)
+{
+ kfree(*option);
+ *option = match_strdup(args);
+ return !*option;
+}
+
+static int nfs_get_option_ul(substring_t args[], unsigned long *option)
+{
+ int rc;
+ char *string;
+
+ string = match_strdup(args);
+ if (string == NULL)
+ return -ENOMEM;
+ rc = kstrtoul(string, 10, option);
+ kfree(string);
+
+ return rc;
+}
+
+static int nfs_get_option_ul_bound(substring_t args[], unsigned long *option,
+ unsigned long l_bound, unsigned long u_bound)
+{
+ int ret;
+
+ ret = nfs_get_option_ul(args, option);
+ if (ret != 0)
+ return ret;
+ if (*option < l_bound || *option > u_bound)
+ return -ERANGE;
+ return 0;
+}
+
+/*
+ * Error-check and convert a string of mount options from user space into
+ * a data structure. The whole mount string is processed; bad options are
+ * skipped as they are encountered. If there were no errors, return 1;
+ * otherwise return 0 (zero).
+ */
+int nfs_parse_mount_options(char *raw, struct nfs_parsed_mount_data *mnt)
+{
+ char *p, *string, *secdata;
+ int rc, sloppy = 0, invalid_option = 0;
+ unsigned short protofamily = AF_UNSPEC;
+ unsigned short mountfamily = AF_UNSPEC;
+
+ if (!raw) {
+ dfprintk(MOUNT, "NFS: mount options string was NULL.\n");
+ return 1;
+ }
+ dfprintk(MOUNT, "NFS: nfs mount opts='%s'\n", raw);
+
+ secdata = alloc_secdata();
+ if (!secdata)
+ goto out_nomem;
+
+ rc = security_sb_copy_data(raw, secdata);
+ if (rc)
+ goto out_security_failure;
+
+ rc = security_sb_parse_opts_str(secdata, &mnt->lsm_opts);
+ if (rc)
+ goto out_security_failure;
+
+ free_secdata(secdata);
+
+ while ((p = strsep(&raw, ",")) != NULL) {
+ substring_t args[MAX_OPT_ARGS];
+ unsigned long option;
+ int token;
+
+ if (!*p)
+ continue;
+
+ dfprintk(MOUNT, "NFS: parsing nfs mount option '%s'\n", p);
+
+ token = match_token(p, nfs_mount_option_tokens, args);
+ switch (token) {
+
+ /*
+ * boolean options: foo/nofoo
+ */
+ case Opt_soft:
+ mnt->flags |= NFS_MOUNT_SOFT;
+ break;
+ case Opt_hard:
+ mnt->flags &= ~NFS_MOUNT_SOFT;
+ break;
+ case Opt_posix:
+ mnt->flags |= NFS_MOUNT_POSIX;
+ break;
+ case Opt_noposix:
+ mnt->flags &= ~NFS_MOUNT_POSIX;
+ break;
+ case Opt_cto:
+ mnt->flags &= ~NFS_MOUNT_NOCTO;
+ break;
+ case Opt_nocto:
+ mnt->flags |= NFS_MOUNT_NOCTO;
+ break;
+ case Opt_ac:
+ mnt->flags &= ~NFS_MOUNT_NOAC;
+ break;
+ case Opt_noac:
+ mnt->flags |= NFS_MOUNT_NOAC;
+ break;
+ case Opt_lock:
+ mnt->flags &= ~NFS_MOUNT_NONLM;
+ mnt->flags &= ~(NFS_MOUNT_LOCAL_FLOCK |
+ NFS_MOUNT_LOCAL_FCNTL);
+ break;
+ case Opt_nolock:
+ mnt->flags |= NFS_MOUNT_NONLM;
+ mnt->flags |= (NFS_MOUNT_LOCAL_FLOCK |
+ NFS_MOUNT_LOCAL_FCNTL);
+ break;
+ case Opt_udp:
+ mnt->flags &= ~NFS_MOUNT_TCP;
+ mnt->nfs_server.protocol = XPRT_TRANSPORT_UDP;
+ break;
+ case Opt_tcp:
+ mnt->flags |= NFS_MOUNT_TCP;
+ mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP;
+ break;
+ case Opt_rdma:
+ mnt->flags |= NFS_MOUNT_TCP; /* for side protocols */
+ mnt->nfs_server.protocol = XPRT_TRANSPORT_RDMA;
+ xprt_load_transport(p);
+ break;
+ case Opt_acl:
+ mnt->flags &= ~NFS_MOUNT_NOACL;
+ break;
+ case Opt_noacl:
+ mnt->flags |= NFS_MOUNT_NOACL;
+ break;
+ case Opt_rdirplus:
+ mnt->flags &= ~NFS_MOUNT_NORDIRPLUS;
+ break;
+ case Opt_nordirplus:
+ mnt->flags |= NFS_MOUNT_NORDIRPLUS;
+ break;
+ case Opt_sharecache:
+ mnt->flags &= ~NFS_MOUNT_UNSHARED;
+ break;
+ case Opt_nosharecache:
+ mnt->flags |= NFS_MOUNT_UNSHARED;
+ break;
+ case Opt_resvport:
+ mnt->flags &= ~NFS_MOUNT_NORESVPORT;
+ break;
+ case Opt_noresvport:
+ mnt->flags |= NFS_MOUNT_NORESVPORT;
+ break;
+ case Opt_fscache:
+ mnt->options |= NFS_OPTION_FSCACHE;
+ kfree(mnt->fscache_uniq);
+ mnt->fscache_uniq = NULL;
+ break;
+ case Opt_nofscache:
+ mnt->options &= ~NFS_OPTION_FSCACHE;
+ kfree(mnt->fscache_uniq);
+ mnt->fscache_uniq = NULL;
+ break;
+ case Opt_migration:
+ mnt->options |= NFS_OPTION_MIGRATION;
+ break;
+ case Opt_nomigration:
+ mnt->options &= NFS_OPTION_MIGRATION;
+ break;
+
+ /*
+ * options that take numeric values
+ */
+ case Opt_port:
+ if (nfs_get_option_ul(args, &option) ||
+ option > USHRT_MAX)
+ goto out_invalid_value;
+ mnt->nfs_server.port = option;
+ break;
+ case Opt_rsize:
+ if (nfs_get_option_ul(args, &option))
+ goto out_invalid_value;
+ mnt->rsize = option;
+ break;
+ case Opt_wsize:
+ if (nfs_get_option_ul(args, &option))
+ goto out_invalid_value;
+ mnt->wsize = option;
+ break;
+ case Opt_bsize:
+ if (nfs_get_option_ul(args, &option))
+ goto out_invalid_value;
+ mnt->bsize = option;
+ break;
+ case Opt_timeo:
+ if (nfs_get_option_ul_bound(args, &option, 1, INT_MAX))
+ goto out_invalid_value;
+ mnt->timeo = option;
+ break;
+ case Opt_retrans:
+ if (nfs_get_option_ul_bound(args, &option, 0, INT_MAX))
+ goto out_invalid_value;
+ mnt->retrans = option;
+ break;
+ case Opt_acregmin:
+ if (nfs_get_option_ul(args, &option))
+ goto out_invalid_value;
+ mnt->acregmin = option;
+ break;
+ case Opt_acregmax:
+ if (nfs_get_option_ul(args, &option))
+ goto out_invalid_value;
+ mnt->acregmax = option;
+ break;
+ case Opt_acdirmin:
+ if (nfs_get_option_ul(args, &option))
+ goto out_invalid_value;
+ mnt->acdirmin = option;
+ break;
+ case Opt_acdirmax:
+ if (nfs_get_option_ul(args, &option))
+ goto out_invalid_value;
+ mnt->acdirmax = option;
+ break;
+ case Opt_actimeo:
+ if (nfs_get_option_ul(args, &option))
+ goto out_invalid_value;
+ mnt->acregmin = mnt->acregmax =
+ mnt->acdirmin = mnt->acdirmax = option;
+ break;
+ case Opt_namelen:
+ if (nfs_get_option_ul(args, &option))
+ goto out_invalid_value;
+ mnt->namlen = option;
+ break;
+ case Opt_mountport:
+ if (nfs_get_option_ul(args, &option) ||
+ option > USHRT_MAX)
+ goto out_invalid_value;
+ mnt->mount_server.port = option;
+ break;
+ case Opt_mountvers:
+ if (nfs_get_option_ul(args, &option) ||
+ option < NFS_MNT_VERSION ||
+ option > NFS_MNT3_VERSION)
+ goto out_invalid_value;
+ mnt->mount_server.version = option;
+ break;
+ case Opt_minorversion:
+ if (nfs_get_option_ul(args, &option))
+ goto out_invalid_value;
+ if (option > NFS4_MAX_MINOR_VERSION)
+ goto out_invalid_value;
+ mnt->minorversion = option;
+ break;
+
+ /*
+ * options that take text values
+ */
+ case Opt_nfsvers:
+ string = match_strdup(args);
+ if (string == NULL)
+ goto out_nomem;
+ rc = nfs_parse_version_string(string, mnt, args);
+ kfree(string);
+ if (!rc)
+ goto out_invalid_value;
+ break;
+ case Opt_sec:
+ string = match_strdup(args);
+ if (string == NULL)
+ goto out_nomem;
+ rc = nfs_parse_security_flavors(string, mnt);
+ kfree(string);
+ if (!rc) {
+ dfprintk(MOUNT, "NFS: unrecognized "
+ "security flavor\n");
+ return 0;
+ }
+ break;
+ case Opt_proto:
+ string = match_strdup(args);
+ if (string == NULL)
+ goto out_nomem;
+ token = match_token(string,
+ nfs_xprt_protocol_tokens, args);
+
+ protofamily = AF_INET;
+ switch (token) {
+ case Opt_xprt_udp6:
+ protofamily = AF_INET6;
+ case Opt_xprt_udp:
+ mnt->flags &= ~NFS_MOUNT_TCP;
+ mnt->nfs_server.protocol = XPRT_TRANSPORT_UDP;
+ break;
+ case Opt_xprt_tcp6:
+ protofamily = AF_INET6;
+ case Opt_xprt_tcp:
+ mnt->flags |= NFS_MOUNT_TCP;
+ mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP;
+ break;
+ case Opt_xprt_rdma6:
+ protofamily = AF_INET6;
+ case Opt_xprt_rdma:
+ /* vector side protocols to TCP */
+ mnt->flags |= NFS_MOUNT_TCP;
+ mnt->nfs_server.protocol = XPRT_TRANSPORT_RDMA;
+ xprt_load_transport(string);
+ break;
+ default:
+ dfprintk(MOUNT, "NFS: unrecognized "
+ "transport protocol\n");
+ kfree(string);
+ return 0;
+ }
+ kfree(string);
+ break;
+ case Opt_mountproto:
+ string = match_strdup(args);
+ if (string == NULL)
+ goto out_nomem;
+ token = match_token(string,
+ nfs_xprt_protocol_tokens, args);
+ kfree(string);
+
+ mountfamily = AF_INET;
+ switch (token) {
+ case Opt_xprt_udp6:
+ mountfamily = AF_INET6;
+ case Opt_xprt_udp:
+ mnt->mount_server.protocol = XPRT_TRANSPORT_UDP;
+ break;
+ case Opt_xprt_tcp6:
+ mountfamily = AF_INET6;
+ case Opt_xprt_tcp:
+ mnt->mount_server.protocol = XPRT_TRANSPORT_TCP;
+ break;
+ case Opt_xprt_rdma: /* not used for side protocols */
+ default:
+ dfprintk(MOUNT, "NFS: unrecognized "
+ "transport protocol\n");
+ return 0;
+ }
+ break;
+ case Opt_addr:
+ string = match_strdup(args);
+ if (string == NULL)
+ goto out_nomem;
+ mnt->nfs_server.addrlen =
+ rpc_pton(mnt->net, string, strlen(string),
+ (struct sockaddr *)
+ &mnt->nfs_server.address,
+ sizeof(mnt->nfs_server.address));
+ kfree(string);
+ if (mnt->nfs_server.addrlen == 0)
+ goto out_invalid_address;
+ break;
+ case Opt_clientaddr:
+ if (nfs_get_option_str(args, &mnt->client_address))
+ goto out_nomem;
+ break;
+ case Opt_mounthost:
+ if (nfs_get_option_str(args,
+ &mnt->mount_server.hostname))
+ goto out_nomem;
+ break;
+ case Opt_mountaddr:
+ string = match_strdup(args);
+ if (string == NULL)
+ goto out_nomem;
+ mnt->mount_server.addrlen =
+ rpc_pton(mnt->net, string, strlen(string),
+ (struct sockaddr *)
+ &mnt->mount_server.address,
+ sizeof(mnt->mount_server.address));
+ kfree(string);
+ if (mnt->mount_server.addrlen == 0)
+ goto out_invalid_address;
+ break;
+ case Opt_lookupcache:
+ string = match_strdup(args);
+ if (string == NULL)
+ goto out_nomem;
+ token = match_token(string,
+ nfs_lookupcache_tokens, args);
+ kfree(string);
+ switch (token) {
+ case Opt_lookupcache_all:
+ mnt->flags &= ~(NFS_MOUNT_LOOKUP_CACHE_NONEG|NFS_MOUNT_LOOKUP_CACHE_NONE);
+ break;
+ case Opt_lookupcache_positive:
+ mnt->flags &= ~NFS_MOUNT_LOOKUP_CACHE_NONE;
+ mnt->flags |= NFS_MOUNT_LOOKUP_CACHE_NONEG;
+ break;
+ case Opt_lookupcache_none:
+ mnt->flags |= NFS_MOUNT_LOOKUP_CACHE_NONEG|NFS_MOUNT_LOOKUP_CACHE_NONE;
+ break;
+ default:
+ dfprintk(MOUNT, "NFS: invalid "
+ "lookupcache argument\n");
+ return 0;
+ };
+ break;
+ case Opt_fscache_uniq:
+ if (nfs_get_option_str(args, &mnt->fscache_uniq))
+ goto out_nomem;
+ mnt->options |= NFS_OPTION_FSCACHE;
+ break;
+ case Opt_local_lock:
+ string = match_strdup(args);
+ if (string == NULL)
+ goto out_nomem;
+ token = match_token(string, nfs_local_lock_tokens,
+ args);
+ kfree(string);
+ switch (token) {
+ case Opt_local_lock_all:
+ mnt->flags |= (NFS_MOUNT_LOCAL_FLOCK |
+ NFS_MOUNT_LOCAL_FCNTL);
+ break;
+ case Opt_local_lock_flock:
+ mnt->flags |= NFS_MOUNT_LOCAL_FLOCK;
+ break;
+ case Opt_local_lock_posix:
+ mnt->flags |= NFS_MOUNT_LOCAL_FCNTL;
+ break;
+ case Opt_local_lock_none:
+ mnt->flags &= ~(NFS_MOUNT_LOCAL_FLOCK |
+ NFS_MOUNT_LOCAL_FCNTL);
+ break;
+ default:
+ dfprintk(MOUNT, "NFS: invalid "
+ "local_lock argument\n");
+ return 0;
+ };
+ break;
+
+ /*
+ * Special options
+ */
+ case Opt_sloppy:
+ sloppy = 1;
+ dfprintk(MOUNT, "NFS: relaxing parsing rules\n");
+ break;
+ case Opt_userspace:
+ case Opt_deprecated:
+ dfprintk(MOUNT, "NFS: ignoring mount option "
+ "'%s'\n", p);
+ break;
+
+ default:
+ invalid_option = 1;
+ dfprintk(MOUNT, "NFS: unrecognized mount option "
+ "'%s'\n", p);
+ }
+ }
+
+ if (!sloppy && invalid_option)
+ return 0;
+
+ if (mnt->minorversion && mnt->version != 4)
+ goto out_minorversion_mismatch;
+
+ if (mnt->options & NFS_OPTION_MIGRATION &&
+ (mnt->version != 4 || mnt->minorversion != 0))
+ goto out_migration_misuse;
+
+ /*
+ * verify that any proto=/mountproto= options match the address
+ * families in the addr=/mountaddr= options.
+ */
+ if (protofamily != AF_UNSPEC &&
+ protofamily != mnt->nfs_server.address.ss_family)
+ goto out_proto_mismatch;
+
+ if (mountfamily != AF_UNSPEC) {
+ if (mnt->mount_server.addrlen) {
+ if (mountfamily != mnt->mount_server.address.ss_family)
+ goto out_mountproto_mismatch;
+ } else {
+ if (mountfamily != mnt->nfs_server.address.ss_family)
+ goto out_mountproto_mismatch;
+ }
+ }
+
+ return 1;
+
+out_mountproto_mismatch:
+ printk(KERN_INFO "NFS: mount server address does not match mountproto= "
+ "option\n");
+ return 0;
+out_proto_mismatch:
+ printk(KERN_INFO "NFS: server address does not match proto= option\n");
+ return 0;
+out_invalid_address:
+ printk(KERN_INFO "NFS: bad IP address specified: %s\n", p);
+ return 0;
+out_invalid_value:
+ printk(KERN_INFO "NFS: bad mount option value specified: %s\n", p);
+ return 0;
+out_minorversion_mismatch:
+ printk(KERN_INFO "NFS: mount option vers=%u does not support "
+ "minorversion=%u\n", mnt->version, mnt->minorversion);
+ return 0;
+out_migration_misuse:
+ printk(KERN_INFO
+ "NFS: 'migration' not supported for this NFS version\n");
+ return 0;
+out_nomem:
+ printk(KERN_INFO "NFS: not enough memory to parse option\n");
+ return 0;
+out_security_failure:
+ free_secdata(secdata);
+ printk(KERN_INFO "NFS: security options invalid: %d\n", rc);
+ return 0;
+}
+
+/*
+ * Split "dev_name" into "hostname:export_path".
+ *
+ * The leftmost colon demarks the split between the server's hostname
+ * and the export path. If the hostname starts with a left square
+ * bracket, then it may contain colons.
+ *
+ * Note: caller frees hostname and export path, even on error.
+ */
+static int nfs_parse_devname(const char *dev_name,
+ char **hostname, size_t maxnamlen,
+ char **export_path, size_t maxpathlen)
+{
+ size_t len;
+ char *end;
+
+ /* Is the host name protected with square brakcets? */
+ if (*dev_name == '[') {
+ end = strchr(++dev_name, ']');
+ if (end == NULL || end[1] != ':')
+ goto out_bad_devname;
+
+ len = end - dev_name;
+ end++;
+ } else {
+ char *comma;
+
+ end = strchr(dev_name, ':');
+ if (end == NULL)
+ goto out_bad_devname;
+ len = end - dev_name;
+
+ /* kill possible hostname list: not supported */
+ comma = strchr(dev_name, ',');
+ if (comma != NULL && comma < end)
+ *comma = 0;
+ }
+
+ if (len > maxnamlen)
+ goto out_hostname;
+
+ /* N.B. caller will free nfs_server.hostname in all cases */
+ *hostname = kstrndup(dev_name, len, GFP_KERNEL);
+ if (*hostname == NULL)
+ goto out_nomem;
+ len = strlen(++end);
+ if (len > maxpathlen)
+ goto out_path;
+ *export_path = kstrndup(end, len, GFP_KERNEL);
+ if (!*export_path)
+ goto out_nomem;
+
+ dfprintk(MOUNT, "NFS: MNTPATH: '%s'\n", *export_path);
+ return 0;
+
+out_bad_devname:
+ dfprintk(MOUNT, "NFS: device name not in host:path format\n");
+ return -EINVAL;
+
+out_nomem:
+ dfprintk(MOUNT, "NFS: not enough memory to parse device name\n");
+ return -ENOMEM;
+
+out_hostname:
+ dfprintk(MOUNT, "NFS: server hostname too long\n");
+ return -ENAMETOOLONG;
+
+out_path:
+ dfprintk(MOUNT, "NFS: export pathname too long\n");
+ return -ENAMETOOLONG;
+}
+
+/*
+ * Validate the NFS2/NFS3 mount data
+ * - fills in the mount root filehandle
+ *
+ * For option strings, user space handles the following behaviors:
+ *
+ * + DNS: mapping server host name to IP address ("addr=" option)
+ *
+ * + failure mode: how to behave if a mount request can't be handled
+ * immediately ("fg/bg" option)
+ *
+ * + retry: how often to retry a mount request ("retry=" option)
+ *
+ * + breaking back: trying proto=udp after proto=tcp, v2 after v3,
+ * mountproto=tcp after mountproto=udp, and so on
+ */
+static int nfs23_validate_mount_data(void *options,
+ struct nfs_parsed_mount_data *args,
+ struct nfs_fh *mntfh,
+ const char *dev_name)
+{
+ struct nfs_mount_data *data = (struct nfs_mount_data *)options;
+ struct sockaddr *sap = (struct sockaddr *)&args->nfs_server.address;
+ int extra_flags = NFS_MOUNT_LEGACY_INTERFACE;
+
+ if (data == NULL)
+ goto out_no_data;
+
+ args->version = NFS_DEFAULT_VERSION;
+ switch (data->version) {
+ case 1:
+ data->namlen = 0;
+ case 2:
+ data->bsize = 0;
+ case 3:
+ if (data->flags & NFS_MOUNT_VER3)
+ goto out_no_v3;
+ data->root.size = NFS2_FHSIZE;
+ memcpy(data->root.data, data->old_root.data, NFS2_FHSIZE);
+ /* Turn off security negotiation */
+ extra_flags |= NFS_MOUNT_SECFLAVOUR;
+ case 4:
+ if (data->flags & NFS_MOUNT_SECFLAVOUR)
+ goto out_no_sec;
+ case 5:
+ memset(data->context, 0, sizeof(data->context));
+ case 6:
+ if (data->flags & NFS_MOUNT_VER3) {
+ if (data->root.size > NFS3_FHSIZE || data->root.size == 0)
+ goto out_invalid_fh;
+ mntfh->size = data->root.size;
+ args->version = 3;
+ } else {
+ mntfh->size = NFS2_FHSIZE;
+ args->version = 2;
+ }
+
+
+ memcpy(mntfh->data, data->root.data, mntfh->size);
+ if (mntfh->size < sizeof(mntfh->data))
+ memset(mntfh->data + mntfh->size, 0,
+ sizeof(mntfh->data) - mntfh->size);
+
+ /*
+ * Translate to nfs_parsed_mount_data, which nfs_fill_super
+ * can deal with.
+ */
+ args->flags = data->flags & NFS_MOUNT_FLAGMASK;
+ args->flags |= extra_flags;
+ args->rsize = data->rsize;
+ args->wsize = data->wsize;
+ args->timeo = data->timeo;
+ args->retrans = data->retrans;
+ args->acregmin = data->acregmin;
+ args->acregmax = data->acregmax;
+ args->acdirmin = data->acdirmin;
+ args->acdirmax = data->acdirmax;
+ args->need_mount = false;
+
+ memcpy(sap, &data->addr, sizeof(data->addr));
+ args->nfs_server.addrlen = sizeof(data->addr);
+ args->nfs_server.port = ntohs(data->addr.sin_port);
+ if (!nfs_verify_server_address(sap))
+ goto out_no_address;
+
+ if (!(data->flags & NFS_MOUNT_TCP))
+ args->nfs_server.protocol = XPRT_TRANSPORT_UDP;
+ /* N.B. caller will free nfs_server.hostname in all cases */
+ args->nfs_server.hostname = kstrdup(data->hostname, GFP_KERNEL);
+ args->namlen = data->namlen;
+ args->bsize = data->bsize;
+
+ if (data->flags & NFS_MOUNT_SECFLAVOUR)
+ args->selected_flavor = data->pseudoflavor;
+ else
+ args->selected_flavor = RPC_AUTH_UNIX;
+ if (!args->nfs_server.hostname)
+ goto out_nomem;
+
+ if (!(data->flags & NFS_MOUNT_NONLM))
+ args->flags &= ~(NFS_MOUNT_LOCAL_FLOCK|
+ NFS_MOUNT_LOCAL_FCNTL);
+ else
+ args->flags |= (NFS_MOUNT_LOCAL_FLOCK|
+ NFS_MOUNT_LOCAL_FCNTL);
+ /*
+ * The legacy version 6 binary mount data from userspace has a
+ * field used only to transport selinux information into the
+ * the kernel. To continue to support that functionality we
+ * have a touch of selinux knowledge here in the NFS code. The
+ * userspace code converted context=blah to just blah so we are
+ * converting back to the full string selinux understands.
+ */
+ if (data->context[0]){
+#ifdef CONFIG_SECURITY_SELINUX
+ int rc;
+ char *opts_str = kmalloc(sizeof(data->context) + 8, GFP_KERNEL);
+ if (!opts_str)
+ return -ENOMEM;
+ strcpy(opts_str, "context=");
+ data->context[NFS_MAX_CONTEXT_LEN] = '\0';
+ strcat(opts_str, &data->context[0]);
+ rc = security_sb_parse_opts_str(opts_str, &args->lsm_opts);
+ kfree(opts_str);
+ if (rc)
+ return rc;
+#else
+ return -EINVAL;
+#endif
+ }
+
+ break;
+ default:
+ return NFS_TEXT_DATA;
+ }
+
+ return 0;
+
+out_no_data:
+ dfprintk(MOUNT, "NFS: mount program didn't pass any mount data\n");
+ return -EINVAL;
+
+out_no_v3:
+ dfprintk(MOUNT, "NFS: nfs_mount_data version %d does not support v3\n",
+ data->version);
+ return -EINVAL;
+
+out_no_sec:
+ dfprintk(MOUNT, "NFS: nfs_mount_data version supports only AUTH_SYS\n");
+ return -EINVAL;
+
+out_nomem:
+ dfprintk(MOUNT, "NFS: not enough memory to handle mount options\n");
+ return -ENOMEM;
+
+out_no_address:
+ dfprintk(MOUNT, "NFS: mount program didn't pass remote address\n");
+ return -EINVAL;
+
+out_invalid_fh:
+ dfprintk(MOUNT, "NFS: invalid root filehandle\n");
+ return -EINVAL;
+}
+
+#if IS_ENABLED(CONFIG_NFS_V4)
+
+static void nfs4_validate_mount_flags(struct nfs_parsed_mount_data *args)
+{
+ args->flags &= ~(NFS_MOUNT_NONLM|NFS_MOUNT_NOACL|NFS_MOUNT_VER3|
+ NFS_MOUNT_LOCAL_FLOCK|NFS_MOUNT_LOCAL_FCNTL);
+}
+
+/*
+ * Validate NFSv4 mount options
+ */
+static int nfs4_validate_mount_data(void *options,
+ struct nfs_parsed_mount_data *args,
+ const char *dev_name)
+{
+ struct sockaddr *sap = (struct sockaddr *)&args->nfs_server.address;
+ struct nfs4_mount_data *data = (struct nfs4_mount_data *)options;
+ char *c;
+
+ if (data == NULL)
+ goto out_no_data;
+
+ args->version = 4;
+
+ switch (data->version) {
+ case 1:
+ if (data->host_addrlen > sizeof(args->nfs_server.address))
+ goto out_no_address;
+ if (data->host_addrlen == 0)
+ goto out_no_address;
+ args->nfs_server.addrlen = data->host_addrlen;
+ if (copy_from_user(sap, data->host_addr, data->host_addrlen))
+ return -EFAULT;
+ if (!nfs_verify_server_address(sap))
+ goto out_no_address;
+ args->nfs_server.port = ntohs(((struct sockaddr_in *)sap)->sin_port);
+
+ if (data->auth_flavourlen) {
+ rpc_authflavor_t pseudoflavor;
+ if (data->auth_flavourlen > 1)
+ goto out_inval_auth;
+ if (copy_from_user(&pseudoflavor,
+ data->auth_flavours,
+ sizeof(pseudoflavor)))
+ return -EFAULT;
+ args->selected_flavor = pseudoflavor;
+ } else
+ args->selected_flavor = RPC_AUTH_UNIX;
+
+ c = strndup_user(data->hostname.data, NFS4_MAXNAMLEN);
+ if (IS_ERR(c))
+ return PTR_ERR(c);
+ args->nfs_server.hostname = c;
+
+ c = strndup_user(data->mnt_path.data, NFS4_MAXPATHLEN);
+ if (IS_ERR(c))
+ return PTR_ERR(c);
+ args->nfs_server.export_path = c;
+ dfprintk(MOUNT, "NFS: MNTPATH: '%s'\n", c);
+
+ c = strndup_user(data->client_addr.data, 16);
+ if (IS_ERR(c))
+ return PTR_ERR(c);
+ args->client_address = c;
+
+ /*
+ * Translate to nfs_parsed_mount_data, which nfs4_fill_super
+ * can deal with.
+ */
+
+ args->flags = data->flags & NFS4_MOUNT_FLAGMASK;
+ args->rsize = data->rsize;
+ args->wsize = data->wsize;
+ args->timeo = data->timeo;
+ args->retrans = data->retrans;
+ args->acregmin = data->acregmin;
+ args->acregmax = data->acregmax;
+ args->acdirmin = data->acdirmin;
+ args->acdirmax = data->acdirmax;
+ args->nfs_server.protocol = data->proto;
+ nfs_validate_transport_protocol(args);
+ if (args->nfs_server.protocol == XPRT_TRANSPORT_UDP)
+ goto out_invalid_transport_udp;
+
+ break;
+ default:
+ return NFS_TEXT_DATA;
+ }
+
+ return 0;
+
+out_no_data:
+ dfprintk(MOUNT, "NFS4: mount program didn't pass any mount data\n");
+ return -EINVAL;
+
+out_inval_auth:
+ dfprintk(MOUNT, "NFS4: Invalid number of RPC auth flavours %d\n",
+ data->auth_flavourlen);
+ return -EINVAL;
+
+out_no_address:
+ dfprintk(MOUNT, "NFS4: mount program didn't pass remote address\n");
+ return -EINVAL;
+
+out_invalid_transport_udp:
+ dfprintk(MOUNT, "NFSv4: Unsupported transport protocol udp\n");
+ return -EINVAL;
+}
+
+int nfs_validate_mount_data(struct file_system_type *fs_type,
+ void *options,
+ struct nfs_parsed_mount_data *args,
+ struct nfs_fh *mntfh,
+ const char *dev_name)
+{
+ if (fs_type == &nfs_fs_type)
+ return nfs23_validate_mount_data(options, args, mntfh, dev_name);
+ return nfs4_validate_mount_data(options, args, dev_name);
+}
+#else
+static int nfs_validate_mount_data(struct file_system_type *fs_type,
+ void *options,
+ struct nfs_parsed_mount_data *args,
+ struct nfs_fh *mntfh,
+ const char *dev_name)
+{
+ return nfs23_validate_mount_data(options, args, mntfh, dev_name);
+}
+#endif
+
+int nfs_validate_text_mount_data(void *options,
+ struct nfs_parsed_mount_data *args,
+ const char *dev_name)
+{
+ int port = 0;
+ int max_namelen = PAGE_SIZE;
+ int max_pathlen = NFS_MAXPATHLEN;
+ struct sockaddr *sap = (struct sockaddr *)&args->nfs_server.address;
+
+ if (nfs_parse_mount_options((char *)options, args) == 0)
+ return -EINVAL;
+
+ if (!nfs_verify_server_address(sap))
+ goto out_no_address;
+
+ if (args->version == 4) {
+#if IS_ENABLED(CONFIG_NFS_V4)
+ port = NFS_PORT;
+ max_namelen = NFS4_MAXNAMLEN;
+ max_pathlen = NFS4_MAXPATHLEN;
+ nfs_validate_transport_protocol(args);
+ if (args->nfs_server.protocol == XPRT_TRANSPORT_UDP)
+ goto out_invalid_transport_udp;
+ nfs4_validate_mount_flags(args);
+#else
+ goto out_v4_not_compiled;
+#endif /* CONFIG_NFS_V4 */
+ } else
+ nfs_set_mount_transport_protocol(args);
+
+ nfs_set_port(sap, &args->nfs_server.port, port);
+
+ return nfs_parse_devname(dev_name,
+ &args->nfs_server.hostname,
+ max_namelen,
+ &args->nfs_server.export_path,
+ max_pathlen);
+
+#if !IS_ENABLED(CONFIG_NFS_V4)
+out_v4_not_compiled:
+ dfprintk(MOUNT, "NFS: NFSv4 is not compiled into kernel\n");
+ return -EPROTONOSUPPORT;
+#else
+out_invalid_transport_udp:
+ dfprintk(MOUNT, "NFSv4: Unsupported transport protocol udp\n");
+ return -EINVAL;
+#endif /* !CONFIG_NFS_V4 */
+
+out_no_address:
+ dfprintk(MOUNT, "NFS: mount program didn't pass remote address\n");
+ return -EINVAL;
+}
diff --git a/fs/nfs/super.c b/fs/nfs/super.c
index 2f3822a4a7d5..1f39638f4d91 100644
--- a/fs/nfs/super.c
+++ b/fs/nfs/super.c
@@ -68,223 +68,6 @@
#include "nfs.h"
#define NFSDBG_FACILITY NFSDBG_VFS
-#define NFS_TEXT_DATA 1
-
-#if IS_ENABLED(CONFIG_NFS_V3)
-#define NFS_DEFAULT_VERSION 3
-#else
-#define NFS_DEFAULT_VERSION 2
-#endif
-
-enum {
- /* Mount options that take no arguments */
- Opt_soft, Opt_hard,
- Opt_posix, Opt_noposix,
- Opt_cto, Opt_nocto,
- Opt_ac, Opt_noac,
- Opt_lock, Opt_nolock,
- Opt_udp, Opt_tcp, Opt_rdma,
- Opt_acl, Opt_noacl,
- Opt_rdirplus, Opt_nordirplus,
- Opt_sharecache, Opt_nosharecache,
- Opt_resvport, Opt_noresvport,
- Opt_fscache, Opt_nofscache,
- Opt_migration, Opt_nomigration,
-
- /* Mount options that take integer arguments */
- Opt_port,
- Opt_rsize, Opt_wsize, Opt_bsize,
- Opt_timeo, Opt_retrans,
- Opt_acregmin, Opt_acregmax,
- Opt_acdirmin, Opt_acdirmax,
- Opt_actimeo,
- Opt_namelen,
- Opt_mountport,
- Opt_mountvers,
- Opt_minorversion,
-
- /* Mount options that take string arguments */
- Opt_nfsvers,
- Opt_sec, Opt_proto, Opt_mountproto, Opt_mounthost,
- Opt_addr, Opt_mountaddr, Opt_clientaddr,
- Opt_lookupcache,
- Opt_fscache_uniq,
- Opt_local_lock,
-
- /* Special mount options */
- Opt_userspace, Opt_deprecated, Opt_sloppy,
-
- Opt_err
-};
-
-static const match_table_t nfs_mount_option_tokens = {
- { Opt_userspace, "bg" },
- { Opt_userspace, "fg" },
- { Opt_userspace, "retry=%s" },
-
- { Opt_sloppy, "sloppy" },
-
- { Opt_soft, "soft" },
- { Opt_hard, "hard" },
- { Opt_deprecated, "intr" },
- { Opt_deprecated, "nointr" },
- { Opt_posix, "posix" },
- { Opt_noposix, "noposix" },
- { Opt_cto, "cto" },
- { Opt_nocto, "nocto" },
- { Opt_ac, "ac" },
- { Opt_noac, "noac" },
- { Opt_lock, "lock" },
- { Opt_nolock, "nolock" },
- { Opt_udp, "udp" },
- { Opt_tcp, "tcp" },
- { Opt_rdma, "rdma" },
- { Opt_acl, "acl" },
- { Opt_noacl, "noacl" },
- { Opt_rdirplus, "rdirplus" },
- { Opt_nordirplus, "nordirplus" },
- { Opt_sharecache, "sharecache" },
- { Opt_nosharecache, "nosharecache" },
- { Opt_resvport, "resvport" },
- { Opt_noresvport, "noresvport" },
- { Opt_fscache, "fsc" },
- { Opt_nofscache, "nofsc" },
- { Opt_migration, "migration" },
- { Opt_nomigration, "nomigration" },
-
- { Opt_port, "port=%s" },
- { Opt_rsize, "rsize=%s" },
- { Opt_wsize, "wsize=%s" },
- { Opt_bsize, "bsize=%s" },
- { Opt_timeo, "timeo=%s" },
- { Opt_retrans, "retrans=%s" },
- { Opt_acregmin, "acregmin=%s" },
- { Opt_acregmax, "acregmax=%s" },
- { Opt_acdirmin, "acdirmin=%s" },
- { Opt_acdirmax, "acdirmax=%s" },
- { Opt_actimeo, "actimeo=%s" },
- { Opt_namelen, "namlen=%s" },
- { Opt_mountport, "mountport=%s" },
- { Opt_mountvers, "mountvers=%s" },
- { Opt_minorversion, "minorversion=%s" },
-
- { Opt_nfsvers, "nfsvers=%s" },
- { Opt_nfsvers, "vers=%s" },
-
- { Opt_sec, "sec=%s" },
- { Opt_proto, "proto=%s" },
- { Opt_mountproto, "mountproto=%s" },
- { Opt_addr, "addr=%s" },
- { Opt_clientaddr, "clientaddr=%s" },
- { Opt_mounthost, "mounthost=%s" },
- { Opt_mountaddr, "mountaddr=%s" },
-
- { Opt_lookupcache, "lookupcache=%s" },
- { Opt_fscache_uniq, "fsc=%s" },
- { Opt_local_lock, "local_lock=%s" },
-
- /* The following needs to be listed after all other options */
- { Opt_nfsvers, "v%s" },
-
- { Opt_err, NULL }
-};
-
-enum {
- Opt_xprt_udp, Opt_xprt_udp6, Opt_xprt_tcp, Opt_xprt_tcp6, Opt_xprt_rdma,
- Opt_xprt_rdma6,
-
- Opt_xprt_err
-};
-
-static const match_table_t nfs_xprt_protocol_tokens = {
- { Opt_xprt_udp, "udp" },
- { Opt_xprt_udp6, "udp6" },
- { Opt_xprt_tcp, "tcp" },
- { Opt_xprt_tcp6, "tcp6" },
- { Opt_xprt_rdma, "rdma" },
- { Opt_xprt_rdma6, "rdma6" },
-
- { Opt_xprt_err, NULL }
-};
-
-enum {
- Opt_sec_none, Opt_sec_sys,
- Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
- Opt_sec_lkey, Opt_sec_lkeyi, Opt_sec_lkeyp,
- Opt_sec_spkm, Opt_sec_spkmi, Opt_sec_spkmp,
-
- Opt_sec_err
-};
-
-static const match_table_t nfs_secflavor_tokens = {
- { Opt_sec_none, "none" },
- { Opt_sec_none, "null" },
- { Opt_sec_sys, "sys" },
-
- { Opt_sec_krb5, "krb5" },
- { Opt_sec_krb5i, "krb5i" },
- { Opt_sec_krb5p, "krb5p" },
-
- { Opt_sec_lkey, "lkey" },
- { Opt_sec_lkeyi, "lkeyi" },
- { Opt_sec_lkeyp, "lkeyp" },
-
- { Opt_sec_spkm, "spkm3" },
- { Opt_sec_spkmi, "spkm3i" },
- { Opt_sec_spkmp, "spkm3p" },
-
- { Opt_sec_err, NULL }
-};
-
-enum {
- Opt_lookupcache_all, Opt_lookupcache_positive,
- Opt_lookupcache_none,
-
- Opt_lookupcache_err
-};
-
-static match_table_t nfs_lookupcache_tokens = {
- { Opt_lookupcache_all, "all" },
- { Opt_lookupcache_positive, "pos" },
- { Opt_lookupcache_positive, "positive" },
- { Opt_lookupcache_none, "none" },
-
- { Opt_lookupcache_err, NULL }
-};
-
-enum {
- Opt_local_lock_all, Opt_local_lock_flock, Opt_local_lock_posix,
- Opt_local_lock_none,
-
- Opt_local_lock_err
-};
-
-static match_table_t nfs_local_lock_tokens = {
- { Opt_local_lock_all, "all" },
- { Opt_local_lock_flock, "flock" },
- { Opt_local_lock_posix, "posix" },
- { Opt_local_lock_none, "none" },
-
- { Opt_local_lock_err, NULL }
-};
-
-enum {
- Opt_vers_2, Opt_vers_3, Opt_vers_4, Opt_vers_4_0,
- Opt_vers_4_1, Opt_vers_4_2,
-
- Opt_vers_err
-};
-
-static match_table_t nfs_vers_tokens = {
- { Opt_vers_2, "2" },
- { Opt_vers_3, "3" },
- { Opt_vers_4, "4" },
- { Opt_vers_4_0, "4.0" },
- { Opt_vers_4_1, "4.1" },
- { Opt_vers_4_2, "4.2" },
-
- { Opt_vers_err, NULL }
-};
static struct dentry *nfs_xdev_mount(struct file_system_type *fs_type,
int flags, const char *dev_name, void *raw_data);
@@ -324,10 +107,6 @@ const struct super_operations nfs_sops = {
EXPORT_SYMBOL_GPL(nfs_sops);
#if IS_ENABLED(CONFIG_NFS_V4)
-static void nfs4_validate_mount_flags(struct nfs_parsed_mount_data *);
-static int nfs4_validate_mount_data(void *options,
- struct nfs_parsed_mount_data *args, const char *dev_name);
-
struct file_system_type nfs4_fs_type = {
.owner = THIS_MODULE,
.name = "nfs4",
@@ -910,141 +689,6 @@ void nfs_umount_begin(struct super_block *sb)
}
EXPORT_SYMBOL_GPL(nfs_umount_begin);
-static struct nfs_parsed_mount_data *nfs_alloc_parsed_mount_data(void)
-{
- struct nfs_parsed_mount_data *data;
-
- data = kzalloc(sizeof(*data), GFP_KERNEL);
- if (data) {
- data->timeo = NFS_UNSPEC_TIMEO;
- data->retrans = NFS_UNSPEC_RETRANS;
- data->acregmin = NFS_DEF_ACREGMIN;
- data->acregmax = NFS_DEF_ACREGMAX;
- data->acdirmin = NFS_DEF_ACDIRMIN;
- data->acdirmax = NFS_DEF_ACDIRMAX;
- data->mount_server.port = NFS_UNSPEC_PORT;
- data->nfs_server.port = NFS_UNSPEC_PORT;
- data->nfs_server.protocol = XPRT_TRANSPORT_TCP;
- data->selected_flavor = RPC_AUTH_MAXFLAVOR;
- data->minorversion = 0;
- data->need_mount = true;
- data->net = current->nsproxy->net_ns;
- security_init_mnt_opts(&data->lsm_opts);
- }
- return data;
-}
-
-static void nfs_free_parsed_mount_data(struct nfs_parsed_mount_data *data)
-{
- if (data) {
- kfree(data->client_address);
- kfree(data->mount_server.hostname);
- kfree(data->nfs_server.export_path);
- kfree(data->nfs_server.hostname);
- kfree(data->fscache_uniq);
- security_free_mnt_opts(&data->lsm_opts);
- kfree(data);
- }
-}
-
-/*
- * Sanity-check a server address provided by the mount command.
- *
- * Address family must be initialized, and address must not be
- * the ANY address for that family.
- */
-static int nfs_verify_server_address(struct sockaddr *addr)
-{
- switch (addr->sa_family) {
- case AF_INET: {
- struct sockaddr_in *sa = (struct sockaddr_in *)addr;
- return sa->sin_addr.s_addr != htonl(INADDR_ANY);
- }
- case AF_INET6: {
- struct in6_addr *sa = &((struct sockaddr_in6 *)addr)->sin6_addr;
- return !ipv6_addr_any(sa);
- }
- }
-
- dfprintk(MOUNT, "NFS: Invalid IP address specified\n");
- return 0;
-}
-
-/*
- * Select between a default port value and a user-specified port value.
- * If a zero value is set, then autobind will be used.
- */
-static void nfs_set_port(struct sockaddr *sap, int *port,
- const unsigned short default_port)
-{
- if (*port == NFS_UNSPEC_PORT)
- *port = default_port;
-
- rpc_set_port(sap, *port);
-}
-
-/*
- * Sanity check the NFS transport protocol.
- *
- */
-static void nfs_validate_transport_protocol(struct nfs_parsed_mount_data *mnt)
-{
- switch (mnt->nfs_server.protocol) {
- case XPRT_TRANSPORT_UDP:
- case XPRT_TRANSPORT_TCP:
- case XPRT_TRANSPORT_RDMA:
- break;
- default:
- mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP;
- }
-}
-
-/*
- * For text based NFSv2/v3 mounts, the mount protocol transport default
- * settings should depend upon the specified NFS transport.
- */
-static void nfs_set_mount_transport_protocol(struct nfs_parsed_mount_data *mnt)
-{
- nfs_validate_transport_protocol(mnt);
-
- if (mnt->mount_server.protocol == XPRT_TRANSPORT_UDP ||
- mnt->mount_server.protocol == XPRT_TRANSPORT_TCP)
- return;
- switch (mnt->nfs_server.protocol) {
- case XPRT_TRANSPORT_UDP:
- mnt->mount_server.protocol = XPRT_TRANSPORT_UDP;
- break;
- case XPRT_TRANSPORT_TCP:
- case XPRT_TRANSPORT_RDMA:
- mnt->mount_server.protocol = XPRT_TRANSPORT_TCP;
- }
-}
-
-/*
- * Add 'flavor' to 'auth_info' if not already present.
- * Returns true if 'flavor' ends up in the list, false otherwise
- */
-static bool nfs_auth_info_add(struct nfs_auth_info *auth_info,
- rpc_authflavor_t flavor)
-{
- unsigned int i;
- unsigned int max_flavor_len = ARRAY_SIZE(auth_info->flavors);
-
- /* make sure this flavor isn't already in the list */
- for (i = 0; i < auth_info->flavor_len; i++) {
- if (flavor == auth_info->flavors[i])
- return true;
- }
-
- if (auth_info->flavor_len + 1 >= max_flavor_len) {
- dfprintk(MOUNT, "NFS: too many sec= flavors\n");
- return false;
- }
-
- auth_info->flavors[auth_info->flavor_len++] = flavor;
- return true;
-}
-
/*
* Return true if 'match' is in auth_info or auth_info is empty.
* Return false otherwise.
@@ -1066,623 +710,6 @@ bool nfs_auth_info_match(const struct nfs_auth_info *auth_info,
EXPORT_SYMBOL_GPL(nfs_auth_info_match);
/*
- * Parse the value of the 'sec=' option.
- */
-static int nfs_parse_security_flavors(char *value,
- struct nfs_parsed_mount_data *mnt)
-{
- substring_t args[MAX_OPT_ARGS];
- rpc_authflavor_t pseudoflavor;
- char *p;
-
- dfprintk(MOUNT, "NFS: parsing sec=%s option\n", value);
-
- while ((p = strsep(&value, ":")) != NULL) {
- switch (match_token(p, nfs_secflavor_tokens, args)) {
- case Opt_sec_none:
- pseudoflavor = RPC_AUTH_NULL;
- break;
- case Opt_sec_sys:
- pseudoflavor = RPC_AUTH_UNIX;
- break;
- case Opt_sec_krb5:
- pseudoflavor = RPC_AUTH_GSS_KRB5;
- break;
- case Opt_sec_krb5i:
- pseudoflavor = RPC_AUTH_GSS_KRB5I;
- break;
- case Opt_sec_krb5p:
- pseudoflavor = RPC_AUTH_GSS_KRB5P;
- break;
- case Opt_sec_lkey:
- pseudoflavor = RPC_AUTH_GSS_LKEY;
- break;
- case Opt_sec_lkeyi:
- pseudoflavor = RPC_AUTH_GSS_LKEYI;
- break;
- case Opt_sec_lkeyp:
- pseudoflavor = RPC_AUTH_GSS_LKEYP;
- break;
- case Opt_sec_spkm:
- pseudoflavor = RPC_AUTH_GSS_SPKM;
- break;
- case Opt_sec_spkmi:
- pseudoflavor = RPC_AUTH_GSS_SPKMI;
- break;
- case Opt_sec_spkmp:
- pseudoflavor = RPC_AUTH_GSS_SPKMP;
- break;
- default:
- dfprintk(MOUNT,
- "NFS: sec= option '%s' not recognized\n", p);
- return 0;
- }
-
- if (!nfs_auth_info_add(&mnt->auth_info, pseudoflavor))
- return 0;
- }
-
- return 1;
-}
-
-static int nfs_parse_version_string(char *string,
- struct nfs_parsed_mount_data *mnt,
- substring_t *args)
-{
- mnt->flags &= ~NFS_MOUNT_VER3;
- switch (match_token(string, nfs_vers_tokens, args)) {
- case Opt_vers_2:
- mnt->version = 2;
- break;
- case Opt_vers_3:
- mnt->flags |= NFS_MOUNT_VER3;
- mnt->version = 3;
- break;
- case Opt_vers_4:
- /* Backward compatibility option. In future,
- * the mount program should always supply
- * a NFSv4 minor version number.
- */
- mnt->version = 4;
- break;
- case Opt_vers_4_0:
- mnt->version = 4;
- mnt->minorversion = 0;
- break;
- case Opt_vers_4_1:
- mnt->version = 4;
- mnt->minorversion = 1;
- break;
- case Opt_vers_4_2:
- mnt->version = 4;
- mnt->minorversion = 2;
- break;
- default:
- return 0;
- }
- return 1;
-}
-
-static int nfs_get_option_str(substring_t args[], char **option)
-{
- kfree(*option);
- *option = match_strdup(args);
- return !*option;
-}
-
-static int nfs_get_option_ul(substring_t args[], unsigned long *option)
-{
- int rc;
- char *string;
-
- string = match_strdup(args);
- if (string == NULL)
- return -ENOMEM;
- rc = kstrtoul(string, 10, option);
- kfree(string);
-
- return rc;
-}
-
-static int nfs_get_option_ul_bound(substring_t args[], unsigned long *option,
- unsigned long l_bound, unsigned long u_bound)
-{
- int ret;
-
- ret = nfs_get_option_ul(args, option);
- if (ret != 0)
- return ret;
- if (*option < l_bound || *option > u_bound)
- return -ERANGE;
- return 0;
-}
-
-/*
- * Error-check and convert a string of mount options from user space into
- * a data structure. The whole mount string is processed; bad options are
- * skipped as they are encountered. If there were no errors, return 1;
- * otherwise return 0 (zero).
- */
-static int nfs_parse_mount_options(char *raw,
- struct nfs_parsed_mount_data *mnt)
-{
- char *p, *string, *secdata;
- int rc, sloppy = 0, invalid_option = 0;
- unsigned short protofamily = AF_UNSPEC;
- unsigned short mountfamily = AF_UNSPEC;
-
- if (!raw) {
- dfprintk(MOUNT, "NFS: mount options string was NULL.\n");
- return 1;
- }
- dfprintk(MOUNT, "NFS: nfs mount opts='%s'\n", raw);
-
- secdata = alloc_secdata();
- if (!secdata)
- goto out_nomem;
-
- rc = security_sb_copy_data(raw, secdata);
- if (rc)
- goto out_security_failure;
-
- rc = security_sb_parse_opts_str(secdata, &mnt->lsm_opts);
- if (rc)
- goto out_security_failure;
-
- free_secdata(secdata);
-
- while ((p = strsep(&raw, ",")) != NULL) {
- substring_t args[MAX_OPT_ARGS];
- unsigned long option;
- int token;
-
- if (!*p)
- continue;
-
- dfprintk(MOUNT, "NFS: parsing nfs mount option '%s'\n", p);
-
- token = match_token(p, nfs_mount_option_tokens, args);
- switch (token) {
-
- /*
- * boolean options: foo/nofoo
- */
- case Opt_soft:
- mnt->flags |= NFS_MOUNT_SOFT;
- break;
- case Opt_hard:
- mnt->flags &= ~NFS_MOUNT_SOFT;
- break;
- case Opt_posix:
- mnt->flags |= NFS_MOUNT_POSIX;
- break;
- case Opt_noposix:
- mnt->flags &= ~NFS_MOUNT_POSIX;
- break;
- case Opt_cto:
- mnt->flags &= ~NFS_MOUNT_NOCTO;
- break;
- case Opt_nocto:
- mnt->flags |= NFS_MOUNT_NOCTO;
- break;
- case Opt_ac:
- mnt->flags &= ~NFS_MOUNT_NOAC;
- break;
- case Opt_noac:
- mnt->flags |= NFS_MOUNT_NOAC;
- break;
- case Opt_lock:
- mnt->flags &= ~NFS_MOUNT_NONLM;
- mnt->flags &= ~(NFS_MOUNT_LOCAL_FLOCK |
- NFS_MOUNT_LOCAL_FCNTL);
- break;
- case Opt_nolock:
- mnt->flags |= NFS_MOUNT_NONLM;
- mnt->flags |= (NFS_MOUNT_LOCAL_FLOCK |
- NFS_MOUNT_LOCAL_FCNTL);
- break;
- case Opt_udp:
- mnt->flags &= ~NFS_MOUNT_TCP;
- mnt->nfs_server.protocol = XPRT_TRANSPORT_UDP;
- break;
- case Opt_tcp:
- mnt->flags |= NFS_MOUNT_TCP;
- mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP;
- break;
- case Opt_rdma:
- mnt->flags |= NFS_MOUNT_TCP; /* for side protocols */
- mnt->nfs_server.protocol = XPRT_TRANSPORT_RDMA;
- xprt_load_transport(p);
- break;
- case Opt_acl:
- mnt->flags &= ~NFS_MOUNT_NOACL;
- break;
- case Opt_noacl:
- mnt->flags |= NFS_MOUNT_NOACL;
- break;
- case Opt_rdirplus:
- mnt->flags &= ~NFS_MOUNT_NORDIRPLUS;
- break;
- case Opt_nordirplus:
- mnt->flags |= NFS_MOUNT_NORDIRPLUS;
- break;
- case Opt_sharecache:
- mnt->flags &= ~NFS_MOUNT_UNSHARED;
- break;
- case Opt_nosharecache:
- mnt->flags |= NFS_MOUNT_UNSHARED;
- break;
- case Opt_resvport:
- mnt->flags &= ~NFS_MOUNT_NORESVPORT;
- break;
- case Opt_noresvport:
- mnt->flags |= NFS_MOUNT_NORESVPORT;
- break;
- case Opt_fscache:
- mnt->options |= NFS_OPTION_FSCACHE;
- kfree(mnt->fscache_uniq);
- mnt->fscache_uniq = NULL;
- break;
- case Opt_nofscache:
- mnt->options &= ~NFS_OPTION_FSCACHE;
- kfree(mnt->fscache_uniq);
- mnt->fscache_uniq = NULL;
- break;
- case Opt_migration:
- mnt->options |= NFS_OPTION_MIGRATION;
- break;
- case Opt_nomigration:
- mnt->options &= NFS_OPTION_MIGRATION;
- break;
-
- /*
- * options that take numeric values
- */
- case Opt_port:
- if (nfs_get_option_ul(args, &option) ||
- option > USHRT_MAX)
- goto out_invalid_value;
- mnt->nfs_server.port = option;
- break;
- case Opt_rsize:
- if (nfs_get_option_ul(args, &option))
- goto out_invalid_value;
- mnt->rsize = option;
- break;
- case Opt_wsize:
- if (nfs_get_option_ul(args, &option))
- goto out_invalid_value;
- mnt->wsize = option;
- break;
- case Opt_bsize:
- if (nfs_get_option_ul(args, &option))
- goto out_invalid_value;
- mnt->bsize = option;
- break;
- case Opt_timeo:
- if (nfs_get_option_ul_bound(args, &option, 1, INT_MAX))
- goto out_invalid_value;
- mnt->timeo = option;
- break;
- case Opt_retrans:
- if (nfs_get_option_ul_bound(args, &option, 0, INT_MAX))
- goto out_invalid_value;
- mnt->retrans = option;
- break;
- case Opt_acregmin:
- if (nfs_get_option_ul(args, &option))
- goto out_invalid_value;
- mnt->acregmin = option;
- break;
- case Opt_acregmax:
- if (nfs_get_option_ul(args, &option))
- goto out_invalid_value;
- mnt->acregmax = option;
- break;
- case Opt_acdirmin:
- if (nfs_get_option_ul(args, &option))
- goto out_invalid_value;
- mnt->acdirmin = option;
- break;
- case Opt_acdirmax:
- if (nfs_get_option_ul(args, &option))
- goto out_invalid_value;
- mnt->acdirmax = option;
- break;
- case Opt_actimeo:
- if (nfs_get_option_ul(args, &option))
- goto out_invalid_value;
- mnt->acregmin = mnt->acregmax =
- mnt->acdirmin = mnt->acdirmax = option;
- break;
- case Opt_namelen:
- if (nfs_get_option_ul(args, &option))
- goto out_invalid_value;
- mnt->namlen = option;
- break;
- case Opt_mountport:
- if (nfs_get_option_ul(args, &option) ||
- option > USHRT_MAX)
- goto out_invalid_value;
- mnt->mount_server.port = option;
- break;
- case Opt_mountvers:
- if (nfs_get_option_ul(args, &option) ||
- option < NFS_MNT_VERSION ||
- option > NFS_MNT3_VERSION)
- goto out_invalid_value;
- mnt->mount_server.version = option;
- break;
- case Opt_minorversion:
- if (nfs_get_option_ul(args, &option))
- goto out_invalid_value;
- if (option > NFS4_MAX_MINOR_VERSION)
- goto out_invalid_value;
- mnt->minorversion = option;
- break;
-
- /*
- * options that take text values
- */
- case Opt_nfsvers:
- string = match_strdup(args);
- if (string == NULL)
- goto out_nomem;
- rc = nfs_parse_version_string(string, mnt, args);
- kfree(string);
- if (!rc)
- goto out_invalid_value;
- break;
- case Opt_sec:
- string = match_strdup(args);
- if (string == NULL)
- goto out_nomem;
- rc = nfs_parse_security_flavors(string, mnt);
- kfree(string);
- if (!rc) {
- dfprintk(MOUNT, "NFS: unrecognized "
- "security flavor\n");
- return 0;
- }
- break;
- case Opt_proto:
- string = match_strdup(args);
- if (string == NULL)
- goto out_nomem;
- token = match_token(string,
- nfs_xprt_protocol_tokens, args);
-
- protofamily = AF_INET;
- switch (token) {
- case Opt_xprt_udp6:
- protofamily = AF_INET6;
- case Opt_xprt_udp:
- mnt->flags &= ~NFS_MOUNT_TCP;
- mnt->nfs_server.protocol = XPRT_TRANSPORT_UDP;
- break;
- case Opt_xprt_tcp6:
- protofamily = AF_INET6;
- case Opt_xprt_tcp:
- mnt->flags |= NFS_MOUNT_TCP;
- mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP;
- break;
- case Opt_xprt_rdma6:
- protofamily = AF_INET6;
- case Opt_xprt_rdma:
- /* vector side protocols to TCP */
- mnt->flags |= NFS_MOUNT_TCP;
- mnt->nfs_server.protocol = XPRT_TRANSPORT_RDMA;
- xprt_load_transport(string);
- break;
- default:
- dfprintk(MOUNT, "NFS: unrecognized "
- "transport protocol\n");
- kfree(string);
- return 0;
- }
- kfree(string);
- break;
- case Opt_mountproto:
- string = match_strdup(args);
- if (string == NULL)
- goto out_nomem;
- token = match_token(string,
- nfs_xprt_protocol_tokens, args);
- kfree(string);
-
- mountfamily = AF_INET;
- switch (token) {
- case Opt_xprt_udp6:
- mountfamily = AF_INET6;
- case Opt_xprt_udp:
- mnt->mount_server.protocol = XPRT_TRANSPORT_UDP;
- break;
- case Opt_xprt_tcp6:
- mountfamily = AF_INET6;
- case Opt_xprt_tcp:
- mnt->mount_server.protocol = XPRT_TRANSPORT_TCP;
- break;
- case Opt_xprt_rdma: /* not used for side protocols */
- default:
- dfprintk(MOUNT, "NFS: unrecognized "
- "transport protocol\n");
- return 0;
- }
- break;
- case Opt_addr:
- string = match_strdup(args);
- if (string == NULL)
- goto out_nomem;
- mnt->nfs_server.addrlen =
- rpc_pton(mnt->net, string, strlen(string),
- (struct sockaddr *)
- &mnt->nfs_server.address,
- sizeof(mnt->nfs_server.address));
- kfree(string);
- if (mnt->nfs_server.addrlen == 0)
- goto out_invalid_address;
- break;
- case Opt_clientaddr:
- if (nfs_get_option_str(args, &mnt->client_address))
- goto out_nomem;
- break;
- case Opt_mounthost:
- if (nfs_get_option_str(args,
- &mnt->mount_server.hostname))
- goto out_nomem;
- break;
- case Opt_mountaddr:
- string = match_strdup(args);
- if (string == NULL)
- goto out_nomem;
- mnt->mount_server.addrlen =
- rpc_pton(mnt->net, string, strlen(string),
- (struct sockaddr *)
- &mnt->mount_server.address,
- sizeof(mnt->mount_server.address));
- kfree(string);
- if (mnt->mount_server.addrlen == 0)
- goto out_invalid_address;
- break;
- case Opt_lookupcache:
- string = match_strdup(args);
- if (string == NULL)
- goto out_nomem;
- token = match_token(string,
- nfs_lookupcache_tokens, args);
- kfree(string);
- switch (token) {
- case Opt_lookupcache_all:
- mnt->flags &= ~(NFS_MOUNT_LOOKUP_CACHE_NONEG|NFS_MOUNT_LOOKUP_CACHE_NONE);
- break;
- case Opt_lookupcache_positive:
- mnt->flags &= ~NFS_MOUNT_LOOKUP_CACHE_NONE;
- mnt->flags |= NFS_MOUNT_LOOKUP_CACHE_NONEG;
- break;
- case Opt_lookupcache_none:
- mnt->flags |= NFS_MOUNT_LOOKUP_CACHE_NONEG|NFS_MOUNT_LOOKUP_CACHE_NONE;
- break;
- default:
- dfprintk(MOUNT, "NFS: invalid "
- "lookupcache argument\n");
- return 0;
- };
- break;
- case Opt_fscache_uniq:
- if (nfs_get_option_str(args, &mnt->fscache_uniq))
- goto out_nomem;
- mnt->options |= NFS_OPTION_FSCACHE;
- break;
- case Opt_local_lock:
- string = match_strdup(args);
- if (string == NULL)
- goto out_nomem;
- token = match_token(string, nfs_local_lock_tokens,
- args);
- kfree(string);
- switch (token) {
- case Opt_local_lock_all:
- mnt->flags |= (NFS_MOUNT_LOCAL_FLOCK |
- NFS_MOUNT_LOCAL_FCNTL);
- break;
- case Opt_local_lock_flock:
- mnt->flags |= NFS_MOUNT_LOCAL_FLOCK;
- break;
- case Opt_local_lock_posix:
- mnt->flags |= NFS_MOUNT_LOCAL_FCNTL;
- break;
- case Opt_local_lock_none:
- mnt->flags &= ~(NFS_MOUNT_LOCAL_FLOCK |
- NFS_MOUNT_LOCAL_FCNTL);
- break;
- default:
- dfprintk(MOUNT, "NFS: invalid "
- "local_lock argument\n");
- return 0;
- };
- break;
-
- /*
- * Special options
- */
- case Opt_sloppy:
- sloppy = 1;
- dfprintk(MOUNT, "NFS: relaxing parsing rules\n");
- break;
- case Opt_userspace:
- case Opt_deprecated:
- dfprintk(MOUNT, "NFS: ignoring mount option "
- "'%s'\n", p);
- break;
-
- default:
- invalid_option = 1;
- dfprintk(MOUNT, "NFS: unrecognized mount option "
- "'%s'\n", p);
- }
- }
-
- if (!sloppy && invalid_option)
- return 0;
-
- if (mnt->minorversion && mnt->version != 4)
- goto out_minorversion_mismatch;
-
- if (mnt->options & NFS_OPTION_MIGRATION &&
- (mnt->version != 4 || mnt->minorversion != 0))
- goto out_migration_misuse;
-
- /*
- * verify that any proto=/mountproto= options match the address
- * families in the addr=/mountaddr= options.
- */
- if (protofamily != AF_UNSPEC &&
- protofamily != mnt->nfs_server.address.ss_family)
- goto out_proto_mismatch;
-
- if (mountfamily != AF_UNSPEC) {
- if (mnt->mount_server.addrlen) {
- if (mountfamily != mnt->mount_server.address.ss_family)
- goto out_mountproto_mismatch;
- } else {
- if (mountfamily != mnt->nfs_server.address.ss_family)
- goto out_mountproto_mismatch;
- }
- }
-
- return 1;
-
-out_mountproto_mismatch:
- printk(KERN_INFO "NFS: mount server address does not match mountproto= "
- "option\n");
- return 0;
-out_proto_mismatch:
- printk(KERN_INFO "NFS: server address does not match proto= option\n");
- return 0;
-out_invalid_address:
- printk(KERN_INFO "NFS: bad IP address specified: %s\n", p);
- return 0;
-out_invalid_value:
- printk(KERN_INFO "NFS: bad mount option value specified: %s\n", p);
- return 0;
-out_minorversion_mismatch:
- printk(KERN_INFO "NFS: mount option vers=%u does not support "
- "minorversion=%u\n", mnt->version, mnt->minorversion);
- return 0;
-out_migration_misuse:
- printk(KERN_INFO
- "NFS: 'migration' not supported for this NFS version\n");
- return 0;
-out_nomem:
- printk(KERN_INFO "NFS: not enough memory to parse option\n");
- return 0;
-out_security_failure:
- free_secdata(secdata);
- printk(KERN_INFO "NFS: security options invalid: %d\n", rc);
- return 0;
-}
-
-/*
* Ensure that a specified authtype in args->auth_info is supported by
* the server. Returns 0 and sets args->selected_flavor if it's ok, and
* -EACCES if not.
@@ -1881,317 +908,6 @@ struct dentry *nfs_try_mount(int flags, const char *dev_name,
}
EXPORT_SYMBOL_GPL(nfs_try_mount);
-/*
- * Split "dev_name" into "hostname:export_path".
- *
- * The leftmost colon demarks the split between the server's hostname
- * and the export path. If the hostname starts with a left square
- * bracket, then it may contain colons.
- *
- * Note: caller frees hostname and export path, even on error.
- */
-static int nfs_parse_devname(const char *dev_name,
- char **hostname, size_t maxnamlen,
- char **export_path, size_t maxpathlen)
-{
- size_t len;
- char *end;
-
- /* Is the host name protected with square brakcets? */
- if (*dev_name == '[') {
- end = strchr(++dev_name, ']');
- if (end == NULL || end[1] != ':')
- goto out_bad_devname;
-
- len = end - dev_name;
- end++;
- } else {
- char *comma;
-
- end = strchr(dev_name, ':');
- if (end == NULL)
- goto out_bad_devname;
- len = end - dev_name;
-
- /* kill possible hostname list: not supported */
- comma = strchr(dev_name, ',');
- if (comma != NULL && comma < end)
- *comma = 0;
- }
-
- if (len > maxnamlen)
- goto out_hostname;
-
- /* N.B. caller will free nfs_server.hostname in all cases */
- *hostname = kstrndup(dev_name, len, GFP_KERNEL);
- if (*hostname == NULL)
- goto out_nomem;
- len = strlen(++end);
- if (len > maxpathlen)
- goto out_path;
- *export_path = kstrndup(end, len, GFP_KERNEL);
- if (!*export_path)
- goto out_nomem;
-
- dfprintk(MOUNT, "NFS: MNTPATH: '%s'\n", *export_path);
- return 0;
-
-out_bad_devname:
- dfprintk(MOUNT, "NFS: device name not in host:path format\n");
- return -EINVAL;
-
-out_nomem:
- dfprintk(MOUNT, "NFS: not enough memory to parse device name\n");
- return -ENOMEM;
-
-out_hostname:
- dfprintk(MOUNT, "NFS: server hostname too long\n");
- return -ENAMETOOLONG;
-
-out_path:
- dfprintk(MOUNT, "NFS: export pathname too long\n");
- return -ENAMETOOLONG;
-}
-
-/*
- * Validate the NFS2/NFS3 mount data
- * - fills in the mount root filehandle
- *
- * For option strings, user space handles the following behaviors:
- *
- * + DNS: mapping server host name to IP address ("addr=" option)
- *
- * + failure mode: how to behave if a mount request can't be handled
- * immediately ("fg/bg" option)
- *
- * + retry: how often to retry a mount request ("retry=" option)
- *
- * + breaking back: trying proto=udp after proto=tcp, v2 after v3,
- * mountproto=tcp after mountproto=udp, and so on
- */
-static int nfs23_validate_mount_data(void *options,
- struct nfs_parsed_mount_data *args,
- struct nfs_fh *mntfh,
- const char *dev_name)
-{
- struct nfs_mount_data *data = (struct nfs_mount_data *)options;
- struct sockaddr *sap = (struct sockaddr *)&args->nfs_server.address;
- int extra_flags = NFS_MOUNT_LEGACY_INTERFACE;
-
- if (data == NULL)
- goto out_no_data;
-
- args->version = NFS_DEFAULT_VERSION;
- switch (data->version) {
- case 1:
- data->namlen = 0;
- case 2:
- data->bsize = 0;
- case 3:
- if (data->flags & NFS_MOUNT_VER3)
- goto out_no_v3;
- data->root.size = NFS2_FHSIZE;
- memcpy(data->root.data, data->old_root.data, NFS2_FHSIZE);
- /* Turn off security negotiation */
- extra_flags |= NFS_MOUNT_SECFLAVOUR;
- case 4:
- if (data->flags & NFS_MOUNT_SECFLAVOUR)
- goto out_no_sec;
- case 5:
- memset(data->context, 0, sizeof(data->context));
- case 6:
- if (data->flags & NFS_MOUNT_VER3) {
- if (data->root.size > NFS3_FHSIZE || data->root.size == 0)
- goto out_invalid_fh;
- mntfh->size = data->root.size;
- args->version = 3;
- } else {
- mntfh->size = NFS2_FHSIZE;
- args->version = 2;
- }
-
-
- memcpy(mntfh->data, data->root.data, mntfh->size);
- if (mntfh->size < sizeof(mntfh->data))
- memset(mntfh->data + mntfh->size, 0,
- sizeof(mntfh->data) - mntfh->size);
-
- /*
- * Translate to nfs_parsed_mount_data, which nfs_fill_super
- * can deal with.
- */
- args->flags = data->flags & NFS_MOUNT_FLAGMASK;
- args->flags |= extra_flags;
- args->rsize = data->rsize;
- args->wsize = data->wsize;
- args->timeo = data->timeo;
- args->retrans = data->retrans;
- args->acregmin = data->acregmin;
- args->acregmax = data->acregmax;
- args->acdirmin = data->acdirmin;
- args->acdirmax = data->acdirmax;
- args->need_mount = false;
-
- memcpy(sap, &data->addr, sizeof(data->addr));
- args->nfs_server.addrlen = sizeof(data->addr);
- args->nfs_server.port = ntohs(data->addr.sin_port);
- if (!nfs_verify_server_address(sap))
- goto out_no_address;
-
- if (!(data->flags & NFS_MOUNT_TCP))
- args->nfs_server.protocol = XPRT_TRANSPORT_UDP;
- /* N.B. caller will free nfs_server.hostname in all cases */
- args->nfs_server.hostname = kstrdup(data->hostname, GFP_KERNEL);
- args->namlen = data->namlen;
- args->bsize = data->bsize;
-
- if (data->flags & NFS_MOUNT_SECFLAVOUR)
- args->selected_flavor = data->pseudoflavor;
- else
- args->selected_flavor = RPC_AUTH_UNIX;
- if (!args->nfs_server.hostname)
- goto out_nomem;
-
- if (!(data->flags & NFS_MOUNT_NONLM))
- args->flags &= ~(NFS_MOUNT_LOCAL_FLOCK|
- NFS_MOUNT_LOCAL_FCNTL);
- else
- args->flags |= (NFS_MOUNT_LOCAL_FLOCK|
- NFS_MOUNT_LOCAL_FCNTL);
- /*
- * The legacy version 6 binary mount data from userspace has a
- * field used only to transport selinux information into the
- * the kernel. To continue to support that functionality we
- * have a touch of selinux knowledge here in the NFS code. The
- * userspace code converted context=blah to just blah so we are
- * converting back to the full string selinux understands.
- */
- if (data->context[0]){
-#ifdef CONFIG_SECURITY_SELINUX
- int rc;
- char *opts_str = kmalloc(sizeof(data->context) + 8, GFP_KERNEL);
- if (!opts_str)
- return -ENOMEM;
- strcpy(opts_str, "context=");
- data->context[NFS_MAX_CONTEXT_LEN] = '\0';
- strcat(opts_str, &data->context[0]);
- rc = security_sb_parse_opts_str(opts_str, &args->lsm_opts);
- kfree(opts_str);
- if (rc)
- return rc;
-#else
- return -EINVAL;
-#endif
- }
-
- break;
- default:
- return NFS_TEXT_DATA;
- }
-
- return 0;
-
-out_no_data:
- dfprintk(MOUNT, "NFS: mount program didn't pass any mount data\n");
- return -EINVAL;
-
-out_no_v3:
- dfprintk(MOUNT, "NFS: nfs_mount_data version %d does not support v3\n",
- data->version);
- return -EINVAL;
-
-out_no_sec:
- dfprintk(MOUNT, "NFS: nfs_mount_data version supports only AUTH_SYS\n");
- return -EINVAL;
-
-out_nomem:
- dfprintk(MOUNT, "NFS: not enough memory to handle mount options\n");
- return -ENOMEM;
-
-out_no_address:
- dfprintk(MOUNT, "NFS: mount program didn't pass remote address\n");
- return -EINVAL;
-
-out_invalid_fh:
- dfprintk(MOUNT, "NFS: invalid root filehandle\n");
- return -EINVAL;
-}
-
-#if IS_ENABLED(CONFIG_NFS_V4)
-static int nfs_validate_mount_data(struct file_system_type *fs_type,
- void *options,
- struct nfs_parsed_mount_data *args,
- struct nfs_fh *mntfh,
- const char *dev_name)
-{
- if (fs_type == &nfs_fs_type)
- return nfs23_validate_mount_data(options, args, mntfh, dev_name);
- return nfs4_validate_mount_data(options, args, dev_name);
-}
-#else
-static int nfs_validate_mount_data(struct file_system_type *fs_type,
- void *options,
- struct nfs_parsed_mount_data *args,
- struct nfs_fh *mntfh,
- const char *dev_name)
-{
- return nfs23_validate_mount_data(options, args, mntfh, dev_name);
-}
-#endif
-
-static int nfs_validate_text_mount_data(void *options,
- struct nfs_parsed_mount_data *args,
- const char *dev_name)
-{
- int port = 0;
- int max_namelen = PAGE_SIZE;
- int max_pathlen = NFS_MAXPATHLEN;
- struct sockaddr *sap = (struct sockaddr *)&args->nfs_server.address;
-
- if (nfs_parse_mount_options((char *)options, args) == 0)
- return -EINVAL;
-
- if (!nfs_verify_server_address(sap))
- goto out_no_address;
-
- if (args->version == 4) {
-#if IS_ENABLED(CONFIG_NFS_V4)
- port = NFS_PORT;
- max_namelen = NFS4_MAXNAMLEN;
- max_pathlen = NFS4_MAXPATHLEN;
- nfs_validate_transport_protocol(args);
- if (args->nfs_server.protocol == XPRT_TRANSPORT_UDP)
- goto out_invalid_transport_udp;
- nfs4_validate_mount_flags(args);
-#else
- goto out_v4_not_compiled;
-#endif /* CONFIG_NFS_V4 */
- } else
- nfs_set_mount_transport_protocol(args);
-
- nfs_set_port(sap, &args->nfs_server.port, port);
-
- return nfs_parse_devname(dev_name,
- &args->nfs_server.hostname,
- max_namelen,
- &args->nfs_server.export_path,
- max_pathlen);
-
-#if !IS_ENABLED(CONFIG_NFS_V4)
-out_v4_not_compiled:
- dfprintk(MOUNT, "NFS: NFSv4 is not compiled into kernel\n");
- return -EPROTONOSUPPORT;
-#else
-out_invalid_transport_udp:
- dfprintk(MOUNT, "NFSv4: Unsupported transport protocol udp\n");
- return -EINVAL;
-#endif /* !CONFIG_NFS_V4 */
-
-out_no_address:
- dfprintk(MOUNT, "NFS: mount program didn't pass remote address\n");
- return -EINVAL;
-}
-
#define NFS_REMOUNT_CMP_FLAGMASK ~(NFS_MOUNT_INTR \
| NFS_MOUNT_SECURE \
| NFS_MOUNT_TCP \
@@ -2724,113 +1440,6 @@ nfs_xdev_mount(struct file_system_type *fs_type, int flags,
#if IS_ENABLED(CONFIG_NFS_V4)
-static void nfs4_validate_mount_flags(struct nfs_parsed_mount_data *args)
-{
- args->flags &= ~(NFS_MOUNT_NONLM|NFS_MOUNT_NOACL|NFS_MOUNT_VER3|
- NFS_MOUNT_LOCAL_FLOCK|NFS_MOUNT_LOCAL_FCNTL);
-}
-
-/*
- * Validate NFSv4 mount options
- */
-static int nfs4_validate_mount_data(void *options,
- struct nfs_parsed_mount_data *args,
- const char *dev_name)
-{
- struct sockaddr *sap = (struct sockaddr *)&args->nfs_server.address;
- struct nfs4_mount_data *data = (struct nfs4_mount_data *)options;
- char *c;
-
- if (data == NULL)
- goto out_no_data;
-
- args->version = 4;
-
- switch (data->version) {
- case 1:
- if (data->host_addrlen > sizeof(args->nfs_server.address))
- goto out_no_address;
- if (data->host_addrlen == 0)
- goto out_no_address;
- args->nfs_server.addrlen = data->host_addrlen;
- if (copy_from_user(sap, data->host_addr, data->host_addrlen))
- return -EFAULT;
- if (!nfs_verify_server_address(sap))
- goto out_no_address;
- args->nfs_server.port = ntohs(((struct sockaddr_in *)sap)->sin_port);
-
- if (data->auth_flavourlen) {
- rpc_authflavor_t pseudoflavor;
- if (data->auth_flavourlen > 1)
- goto out_inval_auth;
- if (copy_from_user(&pseudoflavor,
- data->auth_flavours,
- sizeof(pseudoflavor)))
- return -EFAULT;
- args->selected_flavor = pseudoflavor;
- } else
- args->selected_flavor = RPC_AUTH_UNIX;
-
- c = strndup_user(data->hostname.data, NFS4_MAXNAMLEN);
- if (IS_ERR(c))
- return PTR_ERR(c);
- args->nfs_server.hostname = c;
-
- c = strndup_user(data->mnt_path.data, NFS4_MAXPATHLEN);
- if (IS_ERR(c))
- return PTR_ERR(c);
- args->nfs_server.export_path = c;
- dfprintk(MOUNT, "NFS: MNTPATH: '%s'\n", c);
-
- c = strndup_user(data->client_addr.data, 16);
- if (IS_ERR(c))
- return PTR_ERR(c);
- args->client_address = c;
-
- /*
- * Translate to nfs_parsed_mount_data, which nfs4_fill_super
- * can deal with.
- */
-
- args->flags = data->flags & NFS4_MOUNT_FLAGMASK;
- args->rsize = data->rsize;
- args->wsize = data->wsize;
- args->timeo = data->timeo;
- args->retrans = data->retrans;
- args->acregmin = data->acregmin;
- args->acregmax = data->acregmax;
- args->acdirmin = data->acdirmin;
- args->acdirmax = data->acdirmax;
- args->nfs_server.protocol = data->proto;
- nfs_validate_transport_protocol(args);
- if (args->nfs_server.protocol == XPRT_TRANSPORT_UDP)
- goto out_invalid_transport_udp;
-
- break;
- default:
- return NFS_TEXT_DATA;
- }
-
- return 0;
-
-out_no_data:
- dfprintk(MOUNT, "NFS4: mount program didn't pass any mount data\n");
- return -EINVAL;
-
-out_inval_auth:
- dfprintk(MOUNT, "NFS4: Invalid number of RPC auth flavours %d\n",
- data->auth_flavourlen);
- return -EINVAL;
-
-out_no_address:
- dfprintk(MOUNT, "NFS4: mount program didn't pass remote address\n");
- return -EINVAL;
-
-out_invalid_transport_udp:
- dfprintk(MOUNT, "NFSv4: Unsupported transport protocol udp\n");
- return -EINVAL;
-}
-
/*
* NFS v4 module parameters need to stay in the
* NFS client for backwards compatibility
^ permalink raw reply related [flat|nested] 28+ messages in thread* [PATCH 13/21] NFS: Constify mount argument match tables [ver #3]
2017-05-15 15:17 [RFC][PATCH 00/21] VFS: Introduce superblock configuration context [ver #3] David Howells
` (11 preceding siblings ...)
2017-05-15 15:19 ` [PATCH 12/21] NFS: Move mount bits into their own file " David Howells
@ 2017-05-15 15:20 ` David Howells
2017-05-15 15:20 ` [PATCH 14/21] NFS: Rename struct nfs_parsed_mount_data to struct nfs_sb_config " David Howells
` (7 subsequent siblings)
20 siblings, 0 replies; 28+ messages in thread
From: David Howells @ 2017-05-15 15:20 UTC (permalink / raw)
To: mszeredi, viro, jlayton; +Cc: dhowells, linux-fsdevel, linux-nfs, linux-kernel
---
fs/nfs/mount.c | 6 +++---
1 file changed, 3 insertions(+), 3 deletions(-)
diff --git a/fs/nfs/mount.c b/fs/nfs/mount.c
index eb77d9af6c35..9b5b89acf97a 100644
--- a/fs/nfs/mount.c
+++ b/fs/nfs/mount.c
@@ -197,7 +197,7 @@ enum {
Opt_lookupcache_err
};
-static match_table_t nfs_lookupcache_tokens = {
+static const match_table_t nfs_lookupcache_tokens = {
{ Opt_lookupcache_all, "all" },
{ Opt_lookupcache_positive, "pos" },
{ Opt_lookupcache_positive, "positive" },
@@ -213,7 +213,7 @@ enum {
Opt_local_lock_err
};
-static match_table_t nfs_local_lock_tokens = {
+static const match_table_t nfs_local_lock_tokens = {
{ Opt_local_lock_all, "all" },
{ Opt_local_lock_flock, "flock" },
{ Opt_local_lock_posix, "posix" },
@@ -229,7 +229,7 @@ enum {
Opt_vers_err
};
-static match_table_t nfs_vers_tokens = {
+static const match_table_t nfs_vers_tokens = {
{ Opt_vers_2, "2" },
{ Opt_vers_3, "3" },
{ Opt_vers_4, "4" },
^ permalink raw reply related [flat|nested] 28+ messages in thread* [PATCH 14/21] NFS: Rename struct nfs_parsed_mount_data to struct nfs_sb_config [ver #3]
2017-05-15 15:17 [RFC][PATCH 00/21] VFS: Introduce superblock configuration context [ver #3] David Howells
` (12 preceding siblings ...)
2017-05-15 15:20 ` [PATCH 13/21] NFS: Constify mount argument match tables " David Howells
@ 2017-05-15 15:20 ` David Howells
2017-05-15 15:20 ` [PATCH 15/21] NFS: Split nfs_parse_mount_options() " David Howells
` (6 subsequent siblings)
20 siblings, 0 replies; 28+ messages in thread
From: David Howells @ 2017-05-15 15:20 UTC (permalink / raw)
To: mszeredi, viro, jlayton; +Cc: dhowells, linux-fsdevel, linux-nfs, linux-kernel
Rename struct nfs_parsed_mount_data to struct nfs_sb_config and rename
pointers to it to "cfg". At some point this will acquire an sb_config
struct as the first term.
---
fs/nfs/client.c | 64 ++++----
fs/nfs/internal.h | 14 +-
fs/nfs/mount.c | 433 +++++++++++++++++++++++++--------------------------
fs/nfs/nfs4client.c | 58 +++----
fs/nfs/nfs4super.c | 10 +
fs/nfs/super.c | 184 +++++++++++-----------
6 files changed, 381 insertions(+), 382 deletions(-)
diff --git a/fs/nfs/client.c b/fs/nfs/client.c
index ee5ddbd36088..5701f5122a64 100644
--- a/fs/nfs/client.c
+++ b/fs/nfs/client.c
@@ -635,25 +635,25 @@ EXPORT_SYMBOL_GPL(nfs_init_client);
* Create a version 2 or 3 client
*/
static int nfs_init_server(struct nfs_server *server,
- const struct nfs_parsed_mount_data *data,
+ const struct nfs_sb_config *cfg,
struct nfs_subversion *nfs_mod)
{
struct rpc_timeout timeparms;
struct nfs_client_initdata cl_init = {
- .hostname = data->nfs_server.hostname,
- .addr = (const struct sockaddr *)&data->nfs_server.address,
- .addrlen = data->nfs_server.addrlen,
+ .hostname = cfg->nfs_server.hostname,
+ .addr = (const struct sockaddr *)&cfg->nfs_server.address,
+ .addrlen = cfg->nfs_server.addrlen,
.nfs_mod = nfs_mod,
- .proto = data->nfs_server.protocol,
- .net = data->net,
+ .proto = cfg->nfs_server.protocol,
+ .net = cfg->net,
.timeparms = &timeparms,
};
struct nfs_client *clp;
int error;
- nfs_init_timeout_values(&timeparms, data->nfs_server.protocol,
- data->timeo, data->retrans);
- if (data->flags & NFS_MOUNT_NORESVPORT)
+ nfs_init_timeout_values(&timeparms, cfg->nfs_server.protocol,
+ cfg->timeo, cfg->retrans);
+ if (cfg->flags & NFS_MOUNT_NORESVPORT)
set_bit(NFS_CS_NORESVPORT, &cl_init.init_flags);
/* Allocate or find a client reference we can use */
@@ -664,46 +664,46 @@ static int nfs_init_server(struct nfs_server *server,
server->nfs_client = clp;
/* Initialise the client representation from the mount data */
- server->flags = data->flags;
- server->options = data->options;
+ server->flags = cfg->flags;
+ server->options = cfg->options;
server->caps |= NFS_CAP_HARDLINKS|NFS_CAP_SYMLINKS|NFS_CAP_FILEID|
NFS_CAP_MODE|NFS_CAP_NLINK|NFS_CAP_OWNER|NFS_CAP_OWNER_GROUP|
NFS_CAP_ATIME|NFS_CAP_CTIME|NFS_CAP_MTIME;
- if (data->rsize)
- server->rsize = nfs_block_size(data->rsize, NULL);
- if (data->wsize)
- server->wsize = nfs_block_size(data->wsize, NULL);
+ if (cfg->rsize)
+ server->rsize = nfs_block_size(cfg->rsize, NULL);
+ if (cfg->wsize)
+ server->wsize = nfs_block_size(cfg->wsize, NULL);
- server->acregmin = data->acregmin * HZ;
- server->acregmax = data->acregmax * HZ;
- server->acdirmin = data->acdirmin * HZ;
- server->acdirmax = data->acdirmax * HZ;
+ server->acregmin = cfg->acregmin * HZ;
+ server->acregmax = cfg->acregmax * HZ;
+ server->acdirmin = cfg->acdirmin * HZ;
+ server->acdirmax = cfg->acdirmax * HZ;
/* Start lockd here, before we might error out */
error = nfs_start_lockd(server);
if (error < 0)
goto error;
- server->port = data->nfs_server.port;
- server->auth_info = data->auth_info;
+ server->port = cfg->nfs_server.port;
+ server->auth_info = cfg->auth_info;
error = nfs_init_server_rpcclient(server, &timeparms,
- data->selected_flavor);
+ cfg->selected_flavor);
if (error < 0)
goto error;
/* Preserve the values of mount_server-related mount options */
- if (data->mount_server.addrlen) {
- memcpy(&server->mountd_address, &data->mount_server.address,
- data->mount_server.addrlen);
- server->mountd_addrlen = data->mount_server.addrlen;
+ if (cfg->mount_server.addrlen) {
+ memcpy(&server->mountd_address, &cfg->mount_server.address,
+ cfg->mount_server.addrlen);
+ server->mountd_addrlen = cfg->mount_server.addrlen;
}
- server->mountd_version = data->mount_server.version;
- server->mountd_port = data->mount_server.port;
- server->mountd_protocol = data->mount_server.protocol;
+ server->mountd_version = cfg->mount_server.version;
+ server->mountd_port = cfg->mount_server.port;
+ server->mountd_protocol = cfg->mount_server.protocol;
- server->namelen = data->namlen;
+ server->namelen = cfg->namlen;
return 0;
error:
@@ -938,7 +938,7 @@ struct nfs_server *nfs_create_server(struct nfs_mount_info *mount_info,
goto error;
/* Get a client representation */
- error = nfs_init_server(server, mount_info->parsed, nfs_mod);
+ error = nfs_init_server(server, mount_info->cfg, nfs_mod);
if (error < 0)
goto error;
@@ -949,7 +949,7 @@ struct nfs_server *nfs_create_server(struct nfs_mount_info *mount_info,
if (server->nfs_client->rpc_ops->version == 3) {
if (server->namelen == 0 || server->namelen > NFS3_MAXNAMLEN)
server->namelen = NFS3_MAXNAMLEN;
- if (!(mount_info->parsed->flags & NFS_MOUNT_NORDIRPLUS))
+ if (!(mount_info->cfg->flags & NFS_MOUNT_NORDIRPLUS))
server->caps |= NFS_CAP_READDIRPLUS;
} else {
if (server->namelen == 0 || server->namelen > NFS2_MAXNAMLEN)
diff --git a/fs/nfs/internal.h b/fs/nfs/internal.h
index 260494be399e..af6ca28da48d 100644
--- a/fs/nfs/internal.h
+++ b/fs/nfs/internal.h
@@ -85,7 +85,7 @@ struct nfs_client_initdata {
/*
* In-kernel mount arguments
*/
-struct nfs_parsed_mount_data {
+struct nfs_sb_config {
int flags;
unsigned int rsize, wsize;
unsigned int timeo, retrans;
@@ -142,7 +142,7 @@ struct nfs_mount_request {
struct nfs_mount_info {
void (*fill_super)(struct super_block *, struct nfs_mount_info *);
int (*set_security)(struct super_block *, struct dentry *, struct nfs_mount_info *);
- struct nfs_parsed_mount_data *parsed;
+ struct nfs_sb_config *cfg;
struct nfs_clone_mount *cloned;
struct nfs_fh *mntfh;
};
@@ -234,16 +234,16 @@ struct nfs_pageio_descriptor;
/* mount.c */
#define NFS_TEXT_DATA 1
-extern struct nfs_parsed_mount_data *nfs_alloc_parsed_mount_data(void);
-extern void nfs_free_parsed_mount_data(struct nfs_parsed_mount_data *data);
-extern int nfs_parse_mount_options(char *raw, struct nfs_parsed_mount_data *mnt);
+extern struct nfs_sb_config *nfs_alloc_parsed_mount_data(void);
+extern void nfs_free_parsed_mount_data(struct nfs_sb_config *cfg);
+extern int nfs_parse_mount_options(char *raw, struct nfs_sb_config *cfg);
extern int nfs_validate_mount_data(struct file_system_type *fs_type,
void *options,
- struct nfs_parsed_mount_data *args,
+ struct nfs_sb_config *cfg,
struct nfs_fh *mntfh,
const char *dev_name);
extern int nfs_validate_text_mount_data(void *options,
- struct nfs_parsed_mount_data *args,
+ struct nfs_sb_config *cfg,
const char *dev_name);
/* pagelist.c */
diff --git a/fs/nfs/mount.c b/fs/nfs/mount.c
index 9b5b89acf97a..ef9683deb2a8 100644
--- a/fs/nfs/mount.c
+++ b/fs/nfs/mount.c
@@ -240,40 +240,40 @@ static const match_table_t nfs_vers_tokens = {
{ Opt_vers_err, NULL }
};
-struct nfs_parsed_mount_data *nfs_alloc_parsed_mount_data(void)
+struct nfs_sb_config *nfs_alloc_parsed_mount_data(void)
{
- struct nfs_parsed_mount_data *data;
-
- data = kzalloc(sizeof(*data), GFP_KERNEL);
- if (data) {
- data->timeo = NFS_UNSPEC_TIMEO;
- data->retrans = NFS_UNSPEC_RETRANS;
- data->acregmin = NFS_DEF_ACREGMIN;
- data->acregmax = NFS_DEF_ACREGMAX;
- data->acdirmin = NFS_DEF_ACDIRMIN;
- data->acdirmax = NFS_DEF_ACDIRMAX;
- data->mount_server.port = NFS_UNSPEC_PORT;
- data->nfs_server.port = NFS_UNSPEC_PORT;
- data->nfs_server.protocol = XPRT_TRANSPORT_TCP;
- data->selected_flavor = RPC_AUTH_MAXFLAVOR;
- data->minorversion = 0;
- data->need_mount = true;
- data->net = current->nsproxy->net_ns;
- security_init_mnt_opts(&data->lsm_opts);
+ struct nfs_sb_config *cfg;
+
+ cfg = kzalloc(sizeof(*cfg), GFP_KERNEL);
+ if (cfg) {
+ cfg->timeo = NFS_UNSPEC_TIMEO;
+ cfg->retrans = NFS_UNSPEC_RETRANS;
+ cfg->acregmin = NFS_DEF_ACREGMIN;
+ cfg->acregmax = NFS_DEF_ACREGMAX;
+ cfg->acdirmin = NFS_DEF_ACDIRMIN;
+ cfg->acdirmax = NFS_DEF_ACDIRMAX;
+ cfg->mount_server.port = NFS_UNSPEC_PORT;
+ cfg->nfs_server.port = NFS_UNSPEC_PORT;
+ cfg->nfs_server.protocol = XPRT_TRANSPORT_TCP;
+ cfg->selected_flavor = RPC_AUTH_MAXFLAVOR;
+ cfg->minorversion = 0;
+ cfg->need_mount = true;
+ cfg->net = current->nsproxy->net_ns;
+ security_init_mnt_opts(&cfg->lsm_opts);
}
- return data;
+ return cfg;
}
-void nfs_free_parsed_mount_data(struct nfs_parsed_mount_data *data)
+void nfs_free_parsed_mount_data(struct nfs_sb_config *cfg)
{
- if (data) {
- kfree(data->client_address);
- kfree(data->mount_server.hostname);
- kfree(data->nfs_server.export_path);
- kfree(data->nfs_server.hostname);
- kfree(data->fscache_uniq);
- security_free_mnt_opts(&data->lsm_opts);
- kfree(data);
+ if (cfg) {
+ kfree(cfg->client_address);
+ kfree(cfg->mount_server.hostname);
+ kfree(cfg->nfs_server.export_path);
+ kfree(cfg->nfs_server.hostname);
+ kfree(cfg->fscache_uniq);
+ security_free_mnt_opts(&cfg->lsm_opts);
+ kfree(cfg);
}
}
@@ -304,15 +304,15 @@ static int nfs_verify_server_address(struct sockaddr *addr)
* Sanity check the NFS transport protocol.
*
*/
-static void nfs_validate_transport_protocol(struct nfs_parsed_mount_data *mnt)
+static void nfs_validate_transport_protocol(struct nfs_sb_config *cfg)
{
- switch (mnt->nfs_server.protocol) {
+ switch (cfg->nfs_server.protocol) {
case XPRT_TRANSPORT_UDP:
case XPRT_TRANSPORT_TCP:
case XPRT_TRANSPORT_RDMA:
break;
default:
- mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP;
+ cfg->nfs_server.protocol = XPRT_TRANSPORT_TCP;
}
}
@@ -320,20 +320,20 @@ static void nfs_validate_transport_protocol(struct nfs_parsed_mount_data *mnt)
* For text based NFSv2/v3 mounts, the mount protocol transport default
* settings should depend upon the specified NFS transport.
*/
-static void nfs_set_mount_transport_protocol(struct nfs_parsed_mount_data *mnt)
+static void nfs_set_mount_transport_protocol(struct nfs_sb_config *cfg)
{
- nfs_validate_transport_protocol(mnt);
+ nfs_validate_transport_protocol(cfg);
- if (mnt->mount_server.protocol == XPRT_TRANSPORT_UDP ||
- mnt->mount_server.protocol == XPRT_TRANSPORT_TCP)
+ if (cfg->mount_server.protocol == XPRT_TRANSPORT_UDP ||
+ cfg->mount_server.protocol == XPRT_TRANSPORT_TCP)
return;
- switch (mnt->nfs_server.protocol) {
+ switch (cfg->nfs_server.protocol) {
case XPRT_TRANSPORT_UDP:
- mnt->mount_server.protocol = XPRT_TRANSPORT_UDP;
+ cfg->mount_server.protocol = XPRT_TRANSPORT_UDP;
break;
case XPRT_TRANSPORT_TCP:
case XPRT_TRANSPORT_RDMA:
- mnt->mount_server.protocol = XPRT_TRANSPORT_TCP;
+ cfg->mount_server.protocol = XPRT_TRANSPORT_TCP;
}
}
@@ -365,8 +365,7 @@ static bool nfs_auth_info_add(struct nfs_auth_info *auth_info,
/*
* Parse the value of the 'sec=' option.
*/
-static int nfs_parse_security_flavors(char *value,
- struct nfs_parsed_mount_data *mnt)
+static int nfs_parse_security_flavors(char *value, struct nfs_sb_config *cfg)
{
substring_t args[MAX_OPT_ARGS];
rpc_authflavor_t pseudoflavor;
@@ -415,7 +414,7 @@ static int nfs_parse_security_flavors(char *value,
return 0;
}
- if (!nfs_auth_info_add(&mnt->auth_info, pseudoflavor))
+ if (!nfs_auth_info_add(&cfg->auth_info, pseudoflavor))
return 0;
}
@@ -423,36 +422,36 @@ static int nfs_parse_security_flavors(char *value,
}
static int nfs_parse_version_string(char *string,
- struct nfs_parsed_mount_data *mnt,
+ struct nfs_sb_config *cfg,
substring_t *args)
{
- mnt->flags &= ~NFS_MOUNT_VER3;
+ cfg->flags &= ~NFS_MOUNT_VER3;
switch (match_token(string, nfs_vers_tokens, args)) {
case Opt_vers_2:
- mnt->version = 2;
+ cfg->version = 2;
break;
case Opt_vers_3:
- mnt->flags |= NFS_MOUNT_VER3;
- mnt->version = 3;
+ cfg->flags |= NFS_MOUNT_VER3;
+ cfg->version = 3;
break;
case Opt_vers_4:
/* Backward compatibility option. In future,
* the mount program should always supply
* a NFSv4 minor version number.
*/
- mnt->version = 4;
+ cfg->version = 4;
break;
case Opt_vers_4_0:
- mnt->version = 4;
- mnt->minorversion = 0;
+ cfg->version = 4;
+ cfg->minorversion = 0;
break;
case Opt_vers_4_1:
- mnt->version = 4;
- mnt->minorversion = 1;
+ cfg->version = 4;
+ cfg->minorversion = 1;
break;
case Opt_vers_4_2:
- mnt->version = 4;
- mnt->minorversion = 2;
+ cfg->version = 4;
+ cfg->minorversion = 2;
break;
default:
return 0;
@@ -500,7 +499,7 @@ static int nfs_get_option_ul_bound(substring_t args[], unsigned long *option,
* skipped as they are encountered. If there were no errors, return 1;
* otherwise return 0 (zero).
*/
-int nfs_parse_mount_options(char *raw, struct nfs_parsed_mount_data *mnt)
+int nfs_parse_mount_options(char *raw, struct nfs_sb_config *cfg)
{
char *p, *string, *secdata;
int rc, sloppy = 0, invalid_option = 0;
@@ -521,7 +520,7 @@ int nfs_parse_mount_options(char *raw, struct nfs_parsed_mount_data *mnt)
if (rc)
goto out_security_failure;
- rc = security_sb_parse_opts_str(secdata, &mnt->lsm_opts);
+ rc = security_sb_parse_opts_str(secdata, &cfg->lsm_opts);
if (rc)
goto out_security_failure;
@@ -544,91 +543,91 @@ int nfs_parse_mount_options(char *raw, struct nfs_parsed_mount_data *mnt)
* boolean options: foo/nofoo
*/
case Opt_soft:
- mnt->flags |= NFS_MOUNT_SOFT;
+ cfg->flags |= NFS_MOUNT_SOFT;
break;
case Opt_hard:
- mnt->flags &= ~NFS_MOUNT_SOFT;
+ cfg->flags &= ~NFS_MOUNT_SOFT;
break;
case Opt_posix:
- mnt->flags |= NFS_MOUNT_POSIX;
+ cfg->flags |= NFS_MOUNT_POSIX;
break;
case Opt_noposix:
- mnt->flags &= ~NFS_MOUNT_POSIX;
+ cfg->flags &= ~NFS_MOUNT_POSIX;
break;
case Opt_cto:
- mnt->flags &= ~NFS_MOUNT_NOCTO;
+ cfg->flags &= ~NFS_MOUNT_NOCTO;
break;
case Opt_nocto:
- mnt->flags |= NFS_MOUNT_NOCTO;
+ cfg->flags |= NFS_MOUNT_NOCTO;
break;
case Opt_ac:
- mnt->flags &= ~NFS_MOUNT_NOAC;
+ cfg->flags &= ~NFS_MOUNT_NOAC;
break;
case Opt_noac:
- mnt->flags |= NFS_MOUNT_NOAC;
+ cfg->flags |= NFS_MOUNT_NOAC;
break;
case Opt_lock:
- mnt->flags &= ~NFS_MOUNT_NONLM;
- mnt->flags &= ~(NFS_MOUNT_LOCAL_FLOCK |
+ cfg->flags &= ~NFS_MOUNT_NONLM;
+ cfg->flags &= ~(NFS_MOUNT_LOCAL_FLOCK |
NFS_MOUNT_LOCAL_FCNTL);
break;
case Opt_nolock:
- mnt->flags |= NFS_MOUNT_NONLM;
- mnt->flags |= (NFS_MOUNT_LOCAL_FLOCK |
+ cfg->flags |= NFS_MOUNT_NONLM;
+ cfg->flags |= (NFS_MOUNT_LOCAL_FLOCK |
NFS_MOUNT_LOCAL_FCNTL);
break;
case Opt_udp:
- mnt->flags &= ~NFS_MOUNT_TCP;
- mnt->nfs_server.protocol = XPRT_TRANSPORT_UDP;
+ cfg->flags &= ~NFS_MOUNT_TCP;
+ cfg->nfs_server.protocol = XPRT_TRANSPORT_UDP;
break;
case Opt_tcp:
- mnt->flags |= NFS_MOUNT_TCP;
- mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP;
+ cfg->flags |= NFS_MOUNT_TCP;
+ cfg->nfs_server.protocol = XPRT_TRANSPORT_TCP;
break;
case Opt_rdma:
- mnt->flags |= NFS_MOUNT_TCP; /* for side protocols */
- mnt->nfs_server.protocol = XPRT_TRANSPORT_RDMA;
+ cfg->flags |= NFS_MOUNT_TCP; /* for side protocols */
+ cfg->nfs_server.protocol = XPRT_TRANSPORT_RDMA;
xprt_load_transport(p);
break;
case Opt_acl:
- mnt->flags &= ~NFS_MOUNT_NOACL;
+ cfg->flags &= ~NFS_MOUNT_NOACL;
break;
case Opt_noacl:
- mnt->flags |= NFS_MOUNT_NOACL;
+ cfg->flags |= NFS_MOUNT_NOACL;
break;
case Opt_rdirplus:
- mnt->flags &= ~NFS_MOUNT_NORDIRPLUS;
+ cfg->flags &= ~NFS_MOUNT_NORDIRPLUS;
break;
case Opt_nordirplus:
- mnt->flags |= NFS_MOUNT_NORDIRPLUS;
+ cfg->flags |= NFS_MOUNT_NORDIRPLUS;
break;
case Opt_sharecache:
- mnt->flags &= ~NFS_MOUNT_UNSHARED;
+ cfg->flags &= ~NFS_MOUNT_UNSHARED;
break;
case Opt_nosharecache:
- mnt->flags |= NFS_MOUNT_UNSHARED;
+ cfg->flags |= NFS_MOUNT_UNSHARED;
break;
case Opt_resvport:
- mnt->flags &= ~NFS_MOUNT_NORESVPORT;
+ cfg->flags &= ~NFS_MOUNT_NORESVPORT;
break;
case Opt_noresvport:
- mnt->flags |= NFS_MOUNT_NORESVPORT;
+ cfg->flags |= NFS_MOUNT_NORESVPORT;
break;
case Opt_fscache:
- mnt->options |= NFS_OPTION_FSCACHE;
- kfree(mnt->fscache_uniq);
- mnt->fscache_uniq = NULL;
+ cfg->options |= NFS_OPTION_FSCACHE;
+ kfree(cfg->fscache_uniq);
+ cfg->fscache_uniq = NULL;
break;
case Opt_nofscache:
- mnt->options &= ~NFS_OPTION_FSCACHE;
- kfree(mnt->fscache_uniq);
- mnt->fscache_uniq = NULL;
+ cfg->options &= ~NFS_OPTION_FSCACHE;
+ kfree(cfg->fscache_uniq);
+ cfg->fscache_uniq = NULL;
break;
case Opt_migration:
- mnt->options |= NFS_OPTION_MIGRATION;
+ cfg->options |= NFS_OPTION_MIGRATION;
break;
case Opt_nomigration:
- mnt->options &= NFS_OPTION_MIGRATION;
+ cfg->options &= NFS_OPTION_MIGRATION;
break;
/*
@@ -638,83 +637,83 @@ int nfs_parse_mount_options(char *raw, struct nfs_parsed_mount_data *mnt)
if (nfs_get_option_ul(args, &option) ||
option > USHRT_MAX)
goto out_invalid_value;
- mnt->nfs_server.port = option;
+ cfg->nfs_server.port = option;
break;
case Opt_rsize:
if (nfs_get_option_ul(args, &option))
goto out_invalid_value;
- mnt->rsize = option;
+ cfg->rsize = option;
break;
case Opt_wsize:
if (nfs_get_option_ul(args, &option))
goto out_invalid_value;
- mnt->wsize = option;
+ cfg->wsize = option;
break;
case Opt_bsize:
if (nfs_get_option_ul(args, &option))
goto out_invalid_value;
- mnt->bsize = option;
+ cfg->bsize = option;
break;
case Opt_timeo:
if (nfs_get_option_ul_bound(args, &option, 1, INT_MAX))
goto out_invalid_value;
- mnt->timeo = option;
+ cfg->timeo = option;
break;
case Opt_retrans:
if (nfs_get_option_ul_bound(args, &option, 0, INT_MAX))
goto out_invalid_value;
- mnt->retrans = option;
+ cfg->retrans = option;
break;
case Opt_acregmin:
if (nfs_get_option_ul(args, &option))
goto out_invalid_value;
- mnt->acregmin = option;
+ cfg->acregmin = option;
break;
case Opt_acregmax:
if (nfs_get_option_ul(args, &option))
goto out_invalid_value;
- mnt->acregmax = option;
+ cfg->acregmax = option;
break;
case Opt_acdirmin:
if (nfs_get_option_ul(args, &option))
goto out_invalid_value;
- mnt->acdirmin = option;
+ cfg->acdirmin = option;
break;
case Opt_acdirmax:
if (nfs_get_option_ul(args, &option))
goto out_invalid_value;
- mnt->acdirmax = option;
+ cfg->acdirmax = option;
break;
case Opt_actimeo:
if (nfs_get_option_ul(args, &option))
goto out_invalid_value;
- mnt->acregmin = mnt->acregmax =
- mnt->acdirmin = mnt->acdirmax = option;
+ cfg->acregmin = cfg->acregmax =
+ cfg->acdirmin = cfg->acdirmax = option;
break;
case Opt_namelen:
if (nfs_get_option_ul(args, &option))
goto out_invalid_value;
- mnt->namlen = option;
+ cfg->namlen = option;
break;
case Opt_mountport:
if (nfs_get_option_ul(args, &option) ||
option > USHRT_MAX)
goto out_invalid_value;
- mnt->mount_server.port = option;
+ cfg->mount_server.port = option;
break;
case Opt_mountvers:
if (nfs_get_option_ul(args, &option) ||
option < NFS_MNT_VERSION ||
option > NFS_MNT3_VERSION)
goto out_invalid_value;
- mnt->mount_server.version = option;
+ cfg->mount_server.version = option;
break;
case Opt_minorversion:
if (nfs_get_option_ul(args, &option))
goto out_invalid_value;
if (option > NFS4_MAX_MINOR_VERSION)
goto out_invalid_value;
- mnt->minorversion = option;
+ cfg->minorversion = option;
break;
/*
@@ -724,7 +723,7 @@ int nfs_parse_mount_options(char *raw, struct nfs_parsed_mount_data *mnt)
string = match_strdup(args);
if (string == NULL)
goto out_nomem;
- rc = nfs_parse_version_string(string, mnt, args);
+ rc = nfs_parse_version_string(string, cfg, args);
kfree(string);
if (!rc)
goto out_invalid_value;
@@ -733,7 +732,7 @@ int nfs_parse_mount_options(char *raw, struct nfs_parsed_mount_data *mnt)
string = match_strdup(args);
if (string == NULL)
goto out_nomem;
- rc = nfs_parse_security_flavors(string, mnt);
+ rc = nfs_parse_security_flavors(string, cfg);
kfree(string);
if (!rc) {
dfprintk(MOUNT, "NFS: unrecognized "
@@ -753,21 +752,21 @@ int nfs_parse_mount_options(char *raw, struct nfs_parsed_mount_data *mnt)
case Opt_xprt_udp6:
protofamily = AF_INET6;
case Opt_xprt_udp:
- mnt->flags &= ~NFS_MOUNT_TCP;
- mnt->nfs_server.protocol = XPRT_TRANSPORT_UDP;
+ cfg->flags &= ~NFS_MOUNT_TCP;
+ cfg->nfs_server.protocol = XPRT_TRANSPORT_UDP;
break;
case Opt_xprt_tcp6:
protofamily = AF_INET6;
case Opt_xprt_tcp:
- mnt->flags |= NFS_MOUNT_TCP;
- mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP;
+ cfg->flags |= NFS_MOUNT_TCP;
+ cfg->nfs_server.protocol = XPRT_TRANSPORT_TCP;
break;
case Opt_xprt_rdma6:
protofamily = AF_INET6;
case Opt_xprt_rdma:
/* vector side protocols to TCP */
- mnt->flags |= NFS_MOUNT_TCP;
- mnt->nfs_server.protocol = XPRT_TRANSPORT_RDMA;
+ cfg->flags |= NFS_MOUNT_TCP;
+ cfg->nfs_server.protocol = XPRT_TRANSPORT_RDMA;
xprt_load_transport(string);
break;
default:
@@ -791,12 +790,12 @@ int nfs_parse_mount_options(char *raw, struct nfs_parsed_mount_data *mnt)
case Opt_xprt_udp6:
mountfamily = AF_INET6;
case Opt_xprt_udp:
- mnt->mount_server.protocol = XPRT_TRANSPORT_UDP;
+ cfg->mount_server.protocol = XPRT_TRANSPORT_UDP;
break;
case Opt_xprt_tcp6:
mountfamily = AF_INET6;
case Opt_xprt_tcp:
- mnt->mount_server.protocol = XPRT_TRANSPORT_TCP;
+ cfg->mount_server.protocol = XPRT_TRANSPORT_TCP;
break;
case Opt_xprt_rdma: /* not used for side protocols */
default:
@@ -809,35 +808,35 @@ int nfs_parse_mount_options(char *raw, struct nfs_parsed_mount_data *mnt)
string = match_strdup(args);
if (string == NULL)
goto out_nomem;
- mnt->nfs_server.addrlen =
- rpc_pton(mnt->net, string, strlen(string),
+ cfg->nfs_server.addrlen =
+ rpc_pton(cfg->net, string, strlen(string),
(struct sockaddr *)
- &mnt->nfs_server.address,
- sizeof(mnt->nfs_server.address));
+ &cfg->nfs_server.address,
+ sizeof(cfg->nfs_server.address));
kfree(string);
- if (mnt->nfs_server.addrlen == 0)
+ if (cfg->nfs_server.addrlen == 0)
goto out_invalid_address;
break;
case Opt_clientaddr:
- if (nfs_get_option_str(args, &mnt->client_address))
+ if (nfs_get_option_str(args, &cfg->client_address))
goto out_nomem;
break;
case Opt_mounthost:
if (nfs_get_option_str(args,
- &mnt->mount_server.hostname))
+ &cfg->mount_server.hostname))
goto out_nomem;
break;
case Opt_mountaddr:
string = match_strdup(args);
if (string == NULL)
goto out_nomem;
- mnt->mount_server.addrlen =
- rpc_pton(mnt->net, string, strlen(string),
+ cfg->mount_server.addrlen =
+ rpc_pton(cfg->net, string, strlen(string),
(struct sockaddr *)
- &mnt->mount_server.address,
- sizeof(mnt->mount_server.address));
+ &cfg->mount_server.address,
+ sizeof(cfg->mount_server.address));
kfree(string);
- if (mnt->mount_server.addrlen == 0)
+ if (cfg->mount_server.addrlen == 0)
goto out_invalid_address;
break;
case Opt_lookupcache:
@@ -849,14 +848,14 @@ int nfs_parse_mount_options(char *raw, struct nfs_parsed_mount_data *mnt)
kfree(string);
switch (token) {
case Opt_lookupcache_all:
- mnt->flags &= ~(NFS_MOUNT_LOOKUP_CACHE_NONEG|NFS_MOUNT_LOOKUP_CACHE_NONE);
+ cfg->flags &= ~(NFS_MOUNT_LOOKUP_CACHE_NONEG|NFS_MOUNT_LOOKUP_CACHE_NONE);
break;
case Opt_lookupcache_positive:
- mnt->flags &= ~NFS_MOUNT_LOOKUP_CACHE_NONE;
- mnt->flags |= NFS_MOUNT_LOOKUP_CACHE_NONEG;
+ cfg->flags &= ~NFS_MOUNT_LOOKUP_CACHE_NONE;
+ cfg->flags |= NFS_MOUNT_LOOKUP_CACHE_NONEG;
break;
case Opt_lookupcache_none:
- mnt->flags |= NFS_MOUNT_LOOKUP_CACHE_NONEG|NFS_MOUNT_LOOKUP_CACHE_NONE;
+ cfg->flags |= NFS_MOUNT_LOOKUP_CACHE_NONEG|NFS_MOUNT_LOOKUP_CACHE_NONE;
break;
default:
dfprintk(MOUNT, "NFS: invalid "
@@ -865,9 +864,9 @@ int nfs_parse_mount_options(char *raw, struct nfs_parsed_mount_data *mnt)
};
break;
case Opt_fscache_uniq:
- if (nfs_get_option_str(args, &mnt->fscache_uniq))
+ if (nfs_get_option_str(args, &cfg->fscache_uniq))
goto out_nomem;
- mnt->options |= NFS_OPTION_FSCACHE;
+ cfg->options |= NFS_OPTION_FSCACHE;
break;
case Opt_local_lock:
string = match_strdup(args);
@@ -878,17 +877,17 @@ int nfs_parse_mount_options(char *raw, struct nfs_parsed_mount_data *mnt)
kfree(string);
switch (token) {
case Opt_local_lock_all:
- mnt->flags |= (NFS_MOUNT_LOCAL_FLOCK |
+ cfg->flags |= (NFS_MOUNT_LOCAL_FLOCK |
NFS_MOUNT_LOCAL_FCNTL);
break;
case Opt_local_lock_flock:
- mnt->flags |= NFS_MOUNT_LOCAL_FLOCK;
+ cfg->flags |= NFS_MOUNT_LOCAL_FLOCK;
break;
case Opt_local_lock_posix:
- mnt->flags |= NFS_MOUNT_LOCAL_FCNTL;
+ cfg->flags |= NFS_MOUNT_LOCAL_FCNTL;
break;
case Opt_local_lock_none:
- mnt->flags &= ~(NFS_MOUNT_LOCAL_FLOCK |
+ cfg->flags &= ~(NFS_MOUNT_LOCAL_FLOCK |
NFS_MOUNT_LOCAL_FCNTL);
break;
default:
@@ -921,11 +920,11 @@ int nfs_parse_mount_options(char *raw, struct nfs_parsed_mount_data *mnt)
if (!sloppy && invalid_option)
return 0;
- if (mnt->minorversion && mnt->version != 4)
+ if (cfg->minorversion && cfg->version != 4)
goto out_minorversion_mismatch;
- if (mnt->options & NFS_OPTION_MIGRATION &&
- (mnt->version != 4 || mnt->minorversion != 0))
+ if (cfg->options & NFS_OPTION_MIGRATION &&
+ (cfg->version != 4 || cfg->minorversion != 0))
goto out_migration_misuse;
/*
@@ -933,15 +932,15 @@ int nfs_parse_mount_options(char *raw, struct nfs_parsed_mount_data *mnt)
* families in the addr=/mountaddr= options.
*/
if (protofamily != AF_UNSPEC &&
- protofamily != mnt->nfs_server.address.ss_family)
+ protofamily != cfg->nfs_server.address.ss_family)
goto out_proto_mismatch;
if (mountfamily != AF_UNSPEC) {
- if (mnt->mount_server.addrlen) {
- if (mountfamily != mnt->mount_server.address.ss_family)
+ if (cfg->mount_server.addrlen) {
+ if (mountfamily != cfg->mount_server.address.ss_family)
goto out_mountproto_mismatch;
} else {
- if (mountfamily != mnt->nfs_server.address.ss_family)
+ if (mountfamily != cfg->nfs_server.address.ss_family)
goto out_mountproto_mismatch;
}
}
@@ -963,7 +962,7 @@ int nfs_parse_mount_options(char *raw, struct nfs_parsed_mount_data *mnt)
return 0;
out_minorversion_mismatch:
printk(KERN_INFO "NFS: mount option vers=%u does not support "
- "minorversion=%u\n", mnt->version, mnt->minorversion);
+ "minorversion=%u\n", cfg->version, cfg->minorversion);
return 0;
out_migration_misuse:
printk(KERN_INFO
@@ -1067,18 +1066,18 @@ static int nfs_parse_devname(const char *dev_name,
* mountproto=tcp after mountproto=udp, and so on
*/
static int nfs23_validate_mount_data(void *options,
- struct nfs_parsed_mount_data *args,
+ struct nfs_sb_config *cfg,
struct nfs_fh *mntfh,
const char *dev_name)
{
struct nfs_mount_data *data = (struct nfs_mount_data *)options;
- struct sockaddr *sap = (struct sockaddr *)&args->nfs_server.address;
+ struct sockaddr *sap = (struct sockaddr *)&cfg->nfs_server.address;
int extra_flags = NFS_MOUNT_LEGACY_INTERFACE;
if (data == NULL)
goto out_no_data;
- args->version = NFS_DEFAULT_VERSION;
+ cfg->version = NFS_DEFAULT_VERSION;
switch (data->version) {
case 1:
data->namlen = 0;
@@ -1101,10 +1100,10 @@ static int nfs23_validate_mount_data(void *options,
if (data->root.size > NFS3_FHSIZE || data->root.size == 0)
goto out_invalid_fh;
mntfh->size = data->root.size;
- args->version = 3;
+ cfg->version = 3;
} else {
mntfh->size = NFS2_FHSIZE;
- args->version = 2;
+ cfg->version = 2;
}
@@ -1114,46 +1113,46 @@ static int nfs23_validate_mount_data(void *options,
sizeof(mntfh->data) - mntfh->size);
/*
- * Translate to nfs_parsed_mount_data, which nfs_fill_super
+ * Translate to nfs_sb_config, which nfs_fill_super
* can deal with.
*/
- args->flags = data->flags & NFS_MOUNT_FLAGMASK;
- args->flags |= extra_flags;
- args->rsize = data->rsize;
- args->wsize = data->wsize;
- args->timeo = data->timeo;
- args->retrans = data->retrans;
- args->acregmin = data->acregmin;
- args->acregmax = data->acregmax;
- args->acdirmin = data->acdirmin;
- args->acdirmax = data->acdirmax;
- args->need_mount = false;
+ cfg->flags = data->flags & NFS_MOUNT_FLAGMASK;
+ cfg->flags |= extra_flags;
+ cfg->rsize = data->rsize;
+ cfg->wsize = data->wsize;
+ cfg->timeo = data->timeo;
+ cfg->retrans = data->retrans;
+ cfg->acregmin = data->acregmin;
+ cfg->acregmax = data->acregmax;
+ cfg->acdirmin = data->acdirmin;
+ cfg->acdirmax = data->acdirmax;
+ cfg->need_mount = false;
memcpy(sap, &data->addr, sizeof(data->addr));
- args->nfs_server.addrlen = sizeof(data->addr);
- args->nfs_server.port = ntohs(data->addr.sin_port);
+ cfg->nfs_server.addrlen = sizeof(data->addr);
+ cfg->nfs_server.port = ntohs(data->addr.sin_port);
if (!nfs_verify_server_address(sap))
goto out_no_address;
if (!(data->flags & NFS_MOUNT_TCP))
- args->nfs_server.protocol = XPRT_TRANSPORT_UDP;
+ cfg->nfs_server.protocol = XPRT_TRANSPORT_UDP;
/* N.B. caller will free nfs_server.hostname in all cases */
- args->nfs_server.hostname = kstrdup(data->hostname, GFP_KERNEL);
- args->namlen = data->namlen;
- args->bsize = data->bsize;
+ cfg->nfs_server.hostname = kstrdup(data->hostname, GFP_KERNEL);
+ cfg->namlen = data->namlen;
+ cfg->bsize = data->bsize;
if (data->flags & NFS_MOUNT_SECFLAVOUR)
- args->selected_flavor = data->pseudoflavor;
+ cfg->selected_flavor = data->pseudoflavor;
else
- args->selected_flavor = RPC_AUTH_UNIX;
- if (!args->nfs_server.hostname)
+ cfg->selected_flavor = RPC_AUTH_UNIX;
+ if (!cfg->nfs_server.hostname)
goto out_nomem;
if (!(data->flags & NFS_MOUNT_NONLM))
- args->flags &= ~(NFS_MOUNT_LOCAL_FLOCK|
+ cfg->flags &= ~(NFS_MOUNT_LOCAL_FLOCK|
NFS_MOUNT_LOCAL_FCNTL);
else
- args->flags |= (NFS_MOUNT_LOCAL_FLOCK|
+ cfg->flags |= (NFS_MOUNT_LOCAL_FLOCK|
NFS_MOUNT_LOCAL_FCNTL);
/*
* The legacy version 6 binary mount data from userspace has a
@@ -1172,7 +1171,7 @@ static int nfs23_validate_mount_data(void *options,
strcpy(opts_str, "context=");
data->context[NFS_MAX_CONTEXT_LEN] = '\0';
strcat(opts_str, &data->context[0]);
- rc = security_sb_parse_opts_str(opts_str, &args->lsm_opts);
+ rc = security_sb_parse_opts_str(opts_str, &cfg->lsm_opts);
kfree(opts_str);
if (rc)
return rc;
@@ -1216,9 +1215,9 @@ static int nfs23_validate_mount_data(void *options,
#if IS_ENABLED(CONFIG_NFS_V4)
-static void nfs4_validate_mount_flags(struct nfs_parsed_mount_data *args)
+static void nfs4_validate_mount_flags(struct nfs_sb_config *cfg)
{
- args->flags &= ~(NFS_MOUNT_NONLM|NFS_MOUNT_NOACL|NFS_MOUNT_VER3|
+ cfg->flags &= ~(NFS_MOUNT_NONLM|NFS_MOUNT_NOACL|NFS_MOUNT_VER3|
NFS_MOUNT_LOCAL_FLOCK|NFS_MOUNT_LOCAL_FCNTL);
}
@@ -1226,30 +1225,30 @@ static void nfs4_validate_mount_flags(struct nfs_parsed_mount_data *args)
* Validate NFSv4 mount options
*/
static int nfs4_validate_mount_data(void *options,
- struct nfs_parsed_mount_data *args,
+ struct nfs_sb_config *cfg,
const char *dev_name)
{
- struct sockaddr *sap = (struct sockaddr *)&args->nfs_server.address;
+ struct sockaddr *sap = (struct sockaddr *)&cfg->nfs_server.address;
struct nfs4_mount_data *data = (struct nfs4_mount_data *)options;
char *c;
if (data == NULL)
goto out_no_data;
- args->version = 4;
+ cfg->version = 4;
switch (data->version) {
case 1:
- if (data->host_addrlen > sizeof(args->nfs_server.address))
+ if (data->host_addrlen > sizeof(cfg->nfs_server.address))
goto out_no_address;
if (data->host_addrlen == 0)
goto out_no_address;
- args->nfs_server.addrlen = data->host_addrlen;
+ cfg->nfs_server.addrlen = data->host_addrlen;
if (copy_from_user(sap, data->host_addr, data->host_addrlen))
return -EFAULT;
if (!nfs_verify_server_address(sap))
goto out_no_address;
- args->nfs_server.port = ntohs(((struct sockaddr_in *)sap)->sin_port);
+ cfg->nfs_server.port = ntohs(((struct sockaddr_in *)sap)->sin_port);
if (data->auth_flavourlen) {
rpc_authflavor_t pseudoflavor;
@@ -1259,43 +1258,43 @@ static int nfs4_validate_mount_data(void *options,
data->auth_flavours,
sizeof(pseudoflavor)))
return -EFAULT;
- args->selected_flavor = pseudoflavor;
+ cfg->selected_flavor = pseudoflavor;
} else
- args->selected_flavor = RPC_AUTH_UNIX;
+ cfg->selected_flavor = RPC_AUTH_UNIX;
c = strndup_user(data->hostname.data, NFS4_MAXNAMLEN);
if (IS_ERR(c))
return PTR_ERR(c);
- args->nfs_server.hostname = c;
+ cfg->nfs_server.hostname = c;
c = strndup_user(data->mnt_path.data, NFS4_MAXPATHLEN);
if (IS_ERR(c))
return PTR_ERR(c);
- args->nfs_server.export_path = c;
+ cfg->nfs_server.export_path = c;
dfprintk(MOUNT, "NFS: MNTPATH: '%s'\n", c);
c = strndup_user(data->client_addr.data, 16);
if (IS_ERR(c))
return PTR_ERR(c);
- args->client_address = c;
+ cfg->client_address = c;
/*
- * Translate to nfs_parsed_mount_data, which nfs4_fill_super
+ * Translate to nfs_sb_config, which nfs4_fill_super
* can deal with.
*/
- args->flags = data->flags & NFS4_MOUNT_FLAGMASK;
- args->rsize = data->rsize;
- args->wsize = data->wsize;
- args->timeo = data->timeo;
- args->retrans = data->retrans;
- args->acregmin = data->acregmin;
- args->acregmax = data->acregmax;
- args->acdirmin = data->acdirmin;
- args->acdirmax = data->acdirmax;
- args->nfs_server.protocol = data->proto;
- nfs_validate_transport_protocol(args);
- if (args->nfs_server.protocol == XPRT_TRANSPORT_UDP)
+ cfg->flags = data->flags & NFS4_MOUNT_FLAGMASK;
+ cfg->rsize = data->rsize;
+ cfg->wsize = data->wsize;
+ cfg->timeo = data->timeo;
+ cfg->retrans = data->retrans;
+ cfg->acregmin = data->acregmin;
+ cfg->acregmax = data->acregmax;
+ cfg->acdirmin = data->acdirmin;
+ cfg->acdirmax = data->acdirmax;
+ cfg->nfs_server.protocol = data->proto;
+ nfs_validate_transport_protocol(cfg);
+ if (cfg->nfs_server.protocol == XPRT_TRANSPORT_UDP)
goto out_invalid_transport_udp;
break;
@@ -1325,61 +1324,61 @@ static int nfs4_validate_mount_data(void *options,
int nfs_validate_mount_data(struct file_system_type *fs_type,
void *options,
- struct nfs_parsed_mount_data *args,
+ struct nfs_sb_config *cfg,
struct nfs_fh *mntfh,
const char *dev_name)
{
if (fs_type == &nfs_fs_type)
- return nfs23_validate_mount_data(options, args, mntfh, dev_name);
- return nfs4_validate_mount_data(options, args, dev_name);
+ return nfs23_validate_mount_data(options, cfg, mntfh, dev_name);
+ return nfs4_validate_mount_data(options, cfg, dev_name);
}
#else
static int nfs_validate_mount_data(struct file_system_type *fs_type,
void *options,
- struct nfs_parsed_mount_data *args,
+ struct nfs_sb_config *cfg,
struct nfs_fh *mntfh,
const char *dev_name)
{
- return nfs23_validate_mount_data(options, args, mntfh, dev_name);
+ return nfs23_validate_mount_data(options, cfg, mntfh, dev_name);
}
#endif
int nfs_validate_text_mount_data(void *options,
- struct nfs_parsed_mount_data *args,
+ struct nfs_sb_config *cfg,
const char *dev_name)
{
int port = 0;
int max_namelen = PAGE_SIZE;
int max_pathlen = NFS_MAXPATHLEN;
- struct sockaddr *sap = (struct sockaddr *)&args->nfs_server.address;
+ struct sockaddr *sap = (struct sockaddr *)&cfg->nfs_server.address;
- if (nfs_parse_mount_options((char *)options, args) == 0)
+ if (nfs_parse_mount_options((char *)options, cfg) == 0)
return -EINVAL;
if (!nfs_verify_server_address(sap))
goto out_no_address;
- if (args->version == 4) {
+ if (cfg->version == 4) {
#if IS_ENABLED(CONFIG_NFS_V4)
port = NFS_PORT;
max_namelen = NFS4_MAXNAMLEN;
max_pathlen = NFS4_MAXPATHLEN;
- nfs_validate_transport_protocol(args);
- if (args->nfs_server.protocol == XPRT_TRANSPORT_UDP)
+ nfs_validate_transport_protocol(cfg);
+ if (cfg->nfs_server.protocol == XPRT_TRANSPORT_UDP)
goto out_invalid_transport_udp;
- nfs4_validate_mount_flags(args);
+ nfs4_validate_mount_flags(cfg);
#else
goto out_v4_not_compiled;
#endif /* CONFIG_NFS_V4 */
} else
- nfs_set_mount_transport_protocol(args);
+ nfs_set_mount_transport_protocol(cfg);
- nfs_set_port(sap, &args->nfs_server.port, port);
+ nfs_set_port(sap, &cfg->nfs_server.port, port);
return nfs_parse_devname(dev_name,
- &args->nfs_server.hostname,
+ &cfg->nfs_server.hostname,
max_namelen,
- &args->nfs_server.export_path,
+ &cfg->nfs_server.export_path,
max_pathlen);
#if !IS_ENABLED(CONFIG_NFS_V4)
diff --git a/fs/nfs/nfs4client.c b/fs/nfs/nfs4client.c
index 692a7a8bfc7a..ec0c112d8148 100644
--- a/fs/nfs/nfs4client.c
+++ b/fs/nfs/nfs4client.c
@@ -1010,60 +1010,60 @@ static int nfs4_server_common_setup(struct nfs_server *server,
* Create a version 4 volume record
*/
static int nfs4_init_server(struct nfs_server *server,
- struct nfs_parsed_mount_data *data)
+ struct nfs_sb_config *cfg)
{
struct rpc_timeout timeparms;
int error;
- nfs_init_timeout_values(&timeparms, data->nfs_server.protocol,
- data->timeo, data->retrans);
+ nfs_init_timeout_values(&timeparms, cfg->nfs_server.protocol,
+ cfg->timeo, cfg->retrans);
/* Initialise the client representation from the mount data */
- server->flags = data->flags;
- server->options = data->options;
- server->auth_info = data->auth_info;
+ server->flags = cfg->flags;
+ server->options = cfg->options;
+ server->auth_info = cfg->auth_info;
/* Use the first specified auth flavor. If this flavor isn't
* allowed by the server, use the SECINFO path to try the
* other specified flavors */
- if (data->auth_info.flavor_len >= 1)
- data->selected_flavor = data->auth_info.flavors[0];
+ if (cfg->auth_info.flavor_len >= 1)
+ cfg->selected_flavor = cfg->auth_info.flavors[0];
else
- data->selected_flavor = RPC_AUTH_UNIX;
+ cfg->selected_flavor = RPC_AUTH_UNIX;
/* Get a client record */
error = nfs4_set_client(server,
- data->nfs_server.hostname,
- (const struct sockaddr *)&data->nfs_server.address,
- data->nfs_server.addrlen,
- data->client_address,
- data->nfs_server.protocol,
+ cfg->nfs_server.hostname,
+ (const struct sockaddr *)&cfg->nfs_server.address,
+ cfg->nfs_server.addrlen,
+ cfg->client_address,
+ cfg->nfs_server.protocol,
&timeparms,
- data->minorversion,
- data->net);
+ cfg->minorversion,
+ cfg->net);
if (error < 0)
return error;
- if (data->rsize)
- server->rsize = nfs_block_size(data->rsize, NULL);
- if (data->wsize)
- server->wsize = nfs_block_size(data->wsize, NULL);
+ if (cfg->rsize)
+ server->rsize = nfs_block_size(cfg->rsize, NULL);
+ if (cfg->wsize)
+ server->wsize = nfs_block_size(cfg->wsize, NULL);
- server->acregmin = data->acregmin * HZ;
- server->acregmax = data->acregmax * HZ;
- server->acdirmin = data->acdirmin * HZ;
- server->acdirmax = data->acdirmax * HZ;
- server->port = data->nfs_server.port;
+ server->acregmin = cfg->acregmin * HZ;
+ server->acregmax = cfg->acregmax * HZ;
+ server->acdirmin = cfg->acdirmin * HZ;
+ server->acdirmax = cfg->acdirmax * HZ;
+ server->port = cfg->nfs_server.port;
return nfs_init_server_rpcclient(server, &timeparms,
- data->selected_flavor);
+ cfg->selected_flavor);
}
/*
* Create a version 4 volume record
* - keyed on server and FSID
*/
-/*struct nfs_server *nfs4_create_server(const struct nfs_parsed_mount_data *data,
+/*struct nfs_server *nfs4_create_server(const struct nfs_sb_config *data,
struct nfs_fh *mntfh)*/
struct nfs_server *nfs4_create_server(struct nfs_mount_info *mount_info,
struct nfs_subversion *nfs_mod)
@@ -1076,10 +1076,10 @@ struct nfs_server *nfs4_create_server(struct nfs_mount_info *mount_info,
if (!server)
return ERR_PTR(-ENOMEM);
- auth_probe = mount_info->parsed->auth_info.flavor_len < 1;
+ auth_probe = mount_info->cfg->auth_info.flavor_len < 1;
/* set up the general RPC client */
- error = nfs4_init_server(server, mount_info->parsed);
+ error = nfs4_init_server(server, mount_info->cfg);
if (error < 0)
goto error;
diff --git a/fs/nfs/nfs4super.c b/fs/nfs/nfs4super.c
index 967fa04d5c76..5f5debfd4007 100644
--- a/fs/nfs/nfs4super.c
+++ b/fs/nfs/nfs4super.c
@@ -242,15 +242,15 @@ struct dentry *nfs4_try_mount(int flags, const char *dev_name,
char *export_path;
struct vfsmount *root_mnt;
struct dentry *res;
- struct nfs_parsed_mount_data *data = mount_info->parsed;
+ struct nfs_sb_config *cfg = mount_info->cfg;
dfprintk(MOUNT, "--> nfs4_try_mount()\n");
- export_path = data->nfs_server.export_path;
- data->nfs_server.export_path = "/";
+ export_path = cfg->nfs_server.export_path;
+ cfg->nfs_server.export_path = "/";
root_mnt = nfs_do_root_mount(&nfs4_remote_fs_type, flags, mount_info,
- data->nfs_server.hostname);
- data->nfs_server.export_path = export_path;
+ cfg->nfs_server.hostname);
+ cfg->nfs_server.export_path = export_path;
res = nfs_follow_remote_path(root_mnt, export_path);
diff --git a/fs/nfs/super.c b/fs/nfs/super.c
index 1f39638f4d91..26c1fca31e6b 100644
--- a/fs/nfs/super.c
+++ b/fs/nfs/super.c
@@ -710,11 +710,11 @@ bool nfs_auth_info_match(const struct nfs_auth_info *auth_info,
EXPORT_SYMBOL_GPL(nfs_auth_info_match);
/*
- * Ensure that a specified authtype in args->auth_info is supported by
- * the server. Returns 0 and sets args->selected_flavor if it's ok, and
+ * Ensure that a specified authtype in cfg->auth_info is supported by
+ * the server. Returns 0 and sets cfg->selected_flavor if it's ok, and
* -EACCES if not.
*/
-static int nfs_verify_authflavors(struct nfs_parsed_mount_data *args,
+static int nfs_verify_authflavors(struct nfs_sb_config *cfg,
rpc_authflavor_t *server_authlist, unsigned int count)
{
rpc_authflavor_t flavor = RPC_AUTH_MAXFLAVOR;
@@ -732,7 +732,7 @@ static int nfs_verify_authflavors(struct nfs_parsed_mount_data *args,
for (i = 0; i < count; i++) {
flavor = server_authlist[i];
- if (nfs_auth_info_match(&args->auth_info, flavor))
+ if (nfs_auth_info_match(&cfg->auth_info, flavor))
goto out;
if (flavor == RPC_AUTH_NULL)
@@ -749,8 +749,8 @@ static int nfs_verify_authflavors(struct nfs_parsed_mount_data *args,
return -EACCES;
out:
- args->selected_flavor = flavor;
- dfprintk(MOUNT, "NFS: using auth flavor %u\n", args->selected_flavor);
+ cfg->selected_flavor = flavor;
+ dfprintk(MOUNT, "NFS: using auth flavor %u\n", cfg->selected_flavor);
return 0;
}
@@ -758,50 +758,50 @@ static int nfs_verify_authflavors(struct nfs_parsed_mount_data *args,
* Use the remote server's MOUNT service to request the NFS file handle
* corresponding to the provided path.
*/
-static int nfs_request_mount(struct nfs_parsed_mount_data *args,
+static int nfs_request_mount(struct nfs_sb_config *cfg,
struct nfs_fh *root_fh,
rpc_authflavor_t *server_authlist,
unsigned int *server_authlist_len)
{
struct nfs_mount_request request = {
.sap = (struct sockaddr *)
- &args->mount_server.address,
- .dirpath = args->nfs_server.export_path,
- .protocol = args->mount_server.protocol,
+ &cfg->mount_server.address,
+ .dirpath = cfg->nfs_server.export_path,
+ .protocol = cfg->mount_server.protocol,
.fh = root_fh,
- .noresvport = args->flags & NFS_MOUNT_NORESVPORT,
+ .noresvport = cfg->flags & NFS_MOUNT_NORESVPORT,
.auth_flav_len = server_authlist_len,
.auth_flavs = server_authlist,
- .net = args->net,
+ .net = cfg->net,
};
int status;
- if (args->mount_server.version == 0) {
- switch (args->version) {
+ if (cfg->mount_server.version == 0) {
+ switch (cfg->version) {
default:
- args->mount_server.version = NFS_MNT3_VERSION;
+ cfg->mount_server.version = NFS_MNT3_VERSION;
break;
case 2:
- args->mount_server.version = NFS_MNT_VERSION;
+ cfg->mount_server.version = NFS_MNT_VERSION;
}
}
- request.version = args->mount_server.version;
+ request.version = cfg->mount_server.version;
- if (args->mount_server.hostname)
- request.hostname = args->mount_server.hostname;
+ if (cfg->mount_server.hostname)
+ request.hostname = cfg->mount_server.hostname;
else
- request.hostname = args->nfs_server.hostname;
+ request.hostname = cfg->nfs_server.hostname;
/*
* Construct the mount server's address.
*/
- if (args->mount_server.address.ss_family == AF_UNSPEC) {
- memcpy(request.sap, &args->nfs_server.address,
- args->nfs_server.addrlen);
- args->mount_server.addrlen = args->nfs_server.addrlen;
+ if (cfg->mount_server.address.ss_family == AF_UNSPEC) {
+ memcpy(request.sap, &cfg->nfs_server.address,
+ cfg->nfs_server.addrlen);
+ cfg->mount_server.addrlen = cfg->nfs_server.addrlen;
}
- request.salen = args->mount_server.addrlen;
- nfs_set_port(request.sap, &args->mount_server.port, 0);
+ request.salen = cfg->mount_server.addrlen;
+ nfs_set_port(request.sap, &cfg->mount_server.port, 0);
/*
* Now ask the mount server to map our export path
@@ -825,11 +825,11 @@ static struct nfs_server *nfs_try_mount_request(struct nfs_mount_info *mount_inf
bool tried_auth_unix = false;
bool auth_null_in_list = false;
struct nfs_server *server = ERR_PTR(-EACCES);
- struct nfs_parsed_mount_data *args = mount_info->parsed;
+ struct nfs_sb_config *cfg = mount_info->cfg;
rpc_authflavor_t authlist[NFS_MAX_SECFLAVORS];
unsigned int authlist_len = ARRAY_SIZE(authlist);
- status = nfs_request_mount(args, mount_info->mntfh, authlist,
+ status = nfs_request_mount(cfg, mount_info->mntfh, authlist,
&authlist_len);
if (status)
return ERR_PTR(status);
@@ -838,10 +838,10 @@ static struct nfs_server *nfs_try_mount_request(struct nfs_mount_info *mount_inf
* Was a sec= authflavor specified in the options? First, verify
* whether the server supports it, and then just try to use it if so.
*/
- if (args->auth_info.flavor_len > 0) {
- status = nfs_verify_authflavors(args, authlist, authlist_len);
+ if (cfg->auth_info.flavor_len > 0) {
+ status = nfs_verify_authflavors(cfg, authlist, authlist_len);
dfprintk(MOUNT, "NFS: using auth flavor %u\n",
- args->selected_flavor);
+ cfg->selected_flavor);
if (status)
return ERR_PTR(status);
return nfs_mod->rpc_ops->create_server(mount_info, nfs_mod);
@@ -870,7 +870,7 @@ static struct nfs_server *nfs_try_mount_request(struct nfs_mount_info *mount_inf
/* Fallthrough */
}
dfprintk(MOUNT, "NFS: attempting to use auth flavor %u\n", flavor);
- args->selected_flavor = flavor;
+ cfg->selected_flavor = flavor;
server = nfs_mod->rpc_ops->create_server(mount_info, nfs_mod);
if (!IS_ERR(server))
return server;
@@ -886,7 +886,7 @@ static struct nfs_server *nfs_try_mount_request(struct nfs_mount_info *mount_inf
/* Last chance! Try AUTH_UNIX */
dfprintk(MOUNT, "NFS: attempting to use auth flavor %u\n", RPC_AUTH_UNIX);
- args->selected_flavor = RPC_AUTH_UNIX;
+ cfg->selected_flavor = RPC_AUTH_UNIX;
return nfs_mod->rpc_ops->create_server(mount_info, nfs_mod);
}
@@ -896,7 +896,7 @@ struct dentry *nfs_try_mount(int flags, const char *dev_name,
{
struct nfs_server *server;
- if (mount_info->parsed->need_mount)
+ if (mount_info->cfg->need_mount)
server = nfs_try_mount_request(mount_info, nfs_mod);
else
server = nfs_mod->rpc_ops->create_server(mount_info, nfs_mod);
@@ -923,23 +923,23 @@ EXPORT_SYMBOL_GPL(nfs_try_mount);
static int
nfs_compare_remount_data(struct nfs_server *nfss,
- struct nfs_parsed_mount_data *data)
+ struct nfs_sb_config *cfg)
{
- if ((data->flags ^ nfss->flags) & NFS_REMOUNT_CMP_FLAGMASK ||
- data->rsize != nfss->rsize ||
- data->wsize != nfss->wsize ||
- data->version != nfss->nfs_client->rpc_ops->version ||
- data->minorversion != nfss->nfs_client->cl_minorversion ||
- data->retrans != nfss->client->cl_timeout->to_retries ||
- !nfs_auth_info_match(&data->auth_info, nfss->client->cl_auth->au_flavor) ||
- data->acregmin != nfss->acregmin / HZ ||
- data->acregmax != nfss->acregmax / HZ ||
- data->acdirmin != nfss->acdirmin / HZ ||
- data->acdirmax != nfss->acdirmax / HZ ||
- data->timeo != (10U * nfss->client->cl_timeout->to_initval / HZ) ||
- data->nfs_server.port != nfss->port ||
- data->nfs_server.addrlen != nfss->nfs_client->cl_addrlen ||
- !rpc_cmp_addr((struct sockaddr *)&data->nfs_server.address,
+ if ((cfg->flags ^ nfss->flags) & NFS_REMOUNT_CMP_FLAGMASK ||
+ cfg->rsize != nfss->rsize ||
+ cfg->wsize != nfss->wsize ||
+ cfg->version != nfss->nfs_client->rpc_ops->version ||
+ cfg->minorversion != nfss->nfs_client->cl_minorversion ||
+ cfg->retrans != nfss->client->cl_timeout->to_retries ||
+ !nfs_auth_info_match(&cfg->auth_info, nfss->client->cl_auth->au_flavor) ||
+ cfg->acregmin != nfss->acregmin / HZ ||
+ cfg->acregmax != nfss->acregmax / HZ ||
+ cfg->acdirmin != nfss->acdirmin / HZ ||
+ cfg->acdirmax != nfss->acdirmax / HZ ||
+ cfg->timeo != (10U * nfss->client->cl_timeout->to_initval / HZ) ||
+ cfg->nfs_server.port != nfss->port ||
+ cfg->nfs_server.addrlen != nfss->nfs_client->cl_addrlen ||
+ !rpc_cmp_addr((struct sockaddr *)&cfg->nfs_server.address,
(struct sockaddr *)&nfss->nfs_client->cl_addr))
return -EINVAL;
@@ -951,7 +951,7 @@ nfs_remount(struct super_block *sb, int *flags, char *raw_data)
{
int error;
struct nfs_server *nfss = sb->s_fs_info;
- struct nfs_parsed_mount_data *data;
+ struct nfs_sb_config *cfg;
struct nfs_mount_data *options = (struct nfs_mount_data *)raw_data;
struct nfs4_mount_data *options4 = (struct nfs4_mount_data *)raw_data;
u32 nfsvers = nfss->nfs_client->rpc_ops->version;
@@ -969,32 +969,32 @@ nfs_remount(struct super_block *sb, int *flags, char *raw_data)
options->version <= 6))))
return 0;
- data = kzalloc(sizeof(*data), GFP_KERNEL);
- if (data == NULL)
+ cfg = kzalloc(sizeof(*cfg), GFP_KERNEL);
+ if (cfg == NULL)
return -ENOMEM;
/* fill out struct with values from existing mount */
- data->flags = nfss->flags;
- data->rsize = nfss->rsize;
- data->wsize = nfss->wsize;
- data->retrans = nfss->client->cl_timeout->to_retries;
- data->selected_flavor = nfss->client->cl_auth->au_flavor;
- data->acregmin = nfss->acregmin / HZ;
- data->acregmax = nfss->acregmax / HZ;
- data->acdirmin = nfss->acdirmin / HZ;
- data->acdirmax = nfss->acdirmax / HZ;
- data->timeo = 10U * nfss->client->cl_timeout->to_initval / HZ;
- data->nfs_server.port = nfss->port;
- data->nfs_server.addrlen = nfss->nfs_client->cl_addrlen;
- data->version = nfsvers;
- data->minorversion = nfss->nfs_client->cl_minorversion;
- data->net = current->nsproxy->net_ns;
- memcpy(&data->nfs_server.address, &nfss->nfs_client->cl_addr,
- data->nfs_server.addrlen);
+ cfg->flags = nfss->flags;
+ cfg->rsize = nfss->rsize;
+ cfg->wsize = nfss->wsize;
+ cfg->retrans = nfss->client->cl_timeout->to_retries;
+ cfg->selected_flavor = nfss->client->cl_auth->au_flavor;
+ cfg->acregmin = nfss->acregmin / HZ;
+ cfg->acregmax = nfss->acregmax / HZ;
+ cfg->acdirmin = nfss->acdirmin / HZ;
+ cfg->acdirmax = nfss->acdirmax / HZ;
+ cfg->timeo = 10U * nfss->client->cl_timeout->to_initval / HZ;
+ cfg->nfs_server.port = nfss->port;
+ cfg->nfs_server.addrlen = nfss->nfs_client->cl_addrlen;
+ cfg->version = nfsvers;
+ cfg->minorversion = nfss->nfs_client->cl_minorversion;
+ cfg->net = current->nsproxy->net_ns;
+ memcpy(&cfg->nfs_server.address, &nfss->nfs_client->cl_addr,
+ cfg->nfs_server.addrlen);
/* overwrite those values with any that were specified */
error = -EINVAL;
- if (!nfs_parse_mount_options((char *)options, data))
+ if (!nfs_parse_mount_options((char *)options, cfg))
goto out;
/*
@@ -1003,13 +1003,13 @@ nfs_remount(struct super_block *sb, int *flags, char *raw_data)
* will clear MS_SYNCHRONOUS if -o sync wasn't specified in the
* remount options, so we have to explicitly reset it.
*/
- if (data->flags & NFS_MOUNT_NOAC)
+ if (cfg->flags & NFS_MOUNT_NOAC)
*flags |= MS_SYNCHRONOUS;
/* compare new mount options with old ones */
- error = nfs_compare_remount_data(nfss, data);
+ error = nfs_compare_remount_data(nfss, cfg);
out:
- kfree(data);
+ kfree(cfg);
return error;
}
EXPORT_SYMBOL_GPL(nfs_remount);
@@ -1039,15 +1039,15 @@ inline void nfs_initialise_sb(struct super_block *sb)
*/
void nfs_fill_super(struct super_block *sb, struct nfs_mount_info *mount_info)
{
- struct nfs_parsed_mount_data *data = mount_info->parsed;
+ struct nfs_sb_config *cfg = mount_info->cfg;
struct nfs_server *server = NFS_SB(sb);
sb->s_blocksize_bits = 0;
sb->s_blocksize = 0;
sb->s_xattr = server->nfs_client->cl_nfs_mod->xattr;
sb->s_op = server->nfs_client->cl_nfs_mod->sops;
- if (data && data->bsize)
- sb->s_blocksize = nfs_block_size(data->bsize, &sb->s_blocksize_bits);
+ if (cfg && cfg->bsize)
+ sb->s_blocksize = nfs_block_size(cfg->bsize, &sb->s_blocksize_bits);
if (server->nfs_client->rpc_ops->version != 2) {
/* The VFS shouldn't apply the umask to mode bits. We will do
@@ -1198,7 +1198,7 @@ static int nfs_compare_super(struct super_block *sb, void *data)
#ifdef CONFIG_NFS_FSCACHE
static void nfs_get_cache_cookie(struct super_block *sb,
- struct nfs_parsed_mount_data *parsed,
+ struct nfs_sb_config *cfg,
struct nfs_clone_mount *cloned)
{
struct nfs_server *nfss = NFS_SB(sb);
@@ -1208,12 +1208,12 @@ static void nfs_get_cache_cookie(struct super_block *sb,
nfss->fscache_key = NULL;
nfss->fscache = NULL;
- if (parsed) {
- if (!(parsed->options & NFS_OPTION_FSCACHE))
+ if (cfg) {
+ if (!(cfg->options & NFS_OPTION_FSCACHE))
return;
- if (parsed->fscache_uniq) {
- uniq = parsed->fscache_uniq;
- ulen = strlen(parsed->fscache_uniq);
+ if (cfg->fscache_uniq) {
+ uniq = cfg->fscache_uniq;
+ ulen = strlen(cfg->fscache_uniq);
}
} else if (cloned) {
struct nfs_server *mnt_s = NFS_SB(cloned->sb);
@@ -1230,7 +1230,7 @@ static void nfs_get_cache_cookie(struct super_block *sb,
}
#else
static void nfs_get_cache_cookie(struct super_block *sb,
- struct nfs_parsed_mount_data *parsed,
+ struct nfs_sb_config *parsed,
struct nfs_clone_mount *cloned)
{
}
@@ -1244,7 +1244,7 @@ int nfs_set_sb_security(struct super_block *s, struct dentry *mntroot,
if (NFS_SB(s)->caps & NFS_CAP_SECURITY_LABEL)
kflags |= SECURITY_LSM_NATIVE_LABELS;
- error = security_sb_set_mnt_opts(s, &mount_info->parsed->lsm_opts,
+ error = security_sb_set_mnt_opts(s, &mount_info->cfg->lsm_opts,
kflags, &kflags_out);
if (error)
goto err;
@@ -1316,7 +1316,7 @@ struct dentry *nfs_fs_mount_common(struct nfs_server *server,
if (!s->s_root) {
/* initial superblock/root creation */
mount_info->fill_super(s, mount_info);
- nfs_get_cache_cookie(s, mount_info->parsed, mount_info->cloned);
+ nfs_get_cache_cookie(s, mount_info->cfg, mount_info->cloned);
}
mntroot = nfs_get_root(s, mount_info->mntfh, dev_name);
@@ -1356,21 +1356,21 @@ struct dentry *nfs_fs_mount(struct file_system_type *fs_type,
struct nfs_subversion *nfs_mod;
int error;
- mount_info.parsed = nfs_alloc_parsed_mount_data();
+ mount_info.cfg = nfs_alloc_parsed_mount_data();
mount_info.mntfh = nfs_alloc_fhandle();
- if (mount_info.parsed == NULL || mount_info.mntfh == NULL)
+ if (mount_info.cfg == NULL || mount_info.mntfh == NULL)
goto out;
/* Validate the mount data */
- error = nfs_validate_mount_data(fs_type, raw_data, mount_info.parsed, mount_info.mntfh, dev_name);
+ error = nfs_validate_mount_data(fs_type, raw_data, mount_info.cfg, mount_info.mntfh, dev_name);
if (error == NFS_TEXT_DATA)
- error = nfs_validate_text_mount_data(raw_data, mount_info.parsed, dev_name);
+ error = nfs_validate_text_mount_data(raw_data, mount_info.cfg, dev_name);
if (error < 0) {
mntroot = ERR_PTR(error);
goto out;
}
- nfs_mod = get_nfs_version(mount_info.parsed->version);
+ nfs_mod = get_nfs_version(mount_info.cfg->version);
if (IS_ERR(nfs_mod)) {
mntroot = ERR_CAST(nfs_mod);
goto out;
@@ -1380,7 +1380,7 @@ struct dentry *nfs_fs_mount(struct file_system_type *fs_type,
put_nfs_version(nfs_mod);
out:
- nfs_free_parsed_mount_data(mount_info.parsed);
+ nfs_free_parsed_mount_data(mount_info.cfg);
nfs_free_fhandle(mount_info.mntfh);
return mntroot;
}
^ permalink raw reply related [flat|nested] 28+ messages in thread* [PATCH 15/21] NFS: Split nfs_parse_mount_options() [ver #3]
2017-05-15 15:17 [RFC][PATCH 00/21] VFS: Introduce superblock configuration context [ver #3] David Howells
` (13 preceding siblings ...)
2017-05-15 15:20 ` [PATCH 14/21] NFS: Rename struct nfs_parsed_mount_data to struct nfs_sb_config " David Howells
@ 2017-05-15 15:20 ` David Howells
2017-05-15 15:20 ` [PATCH 16/21] NFS: Deindent nfs_sb_config_parse_option() " David Howells
` (5 subsequent siblings)
20 siblings, 0 replies; 28+ messages in thread
From: David Howells @ 2017-05-15 15:20 UTC (permalink / raw)
To: mszeredi, viro, jlayton; +Cc: dhowells, linux-fsdevel, linux-nfs, linux-kernel
Split nfs_parse_mount_options() to move the prologue, list-splitting and
epilogue into one function and the per-option processing into another.
---
fs/nfs/internal.h | 3 +
fs/nfs/mount.c | 143 ++++++++++++++++++++++++++++++-----------------------
2 files changed, 83 insertions(+), 63 deletions(-)
diff --git a/fs/nfs/internal.h b/fs/nfs/internal.h
index af6ca28da48d..ed255241baa7 100644
--- a/fs/nfs/internal.h
+++ b/fs/nfs/internal.h
@@ -100,7 +100,10 @@ struct nfs_sb_config {
unsigned int version;
unsigned int minorversion;
char *fscache_uniq;
+ unsigned short protofamily;
+ unsigned short mountfamily;
bool need_mount;
+ bool sloppy;
struct {
struct sockaddr_storage address;
diff --git a/fs/nfs/mount.c b/fs/nfs/mount.c
index ef9683deb2a8..26153b471e48 100644
--- a/fs/nfs/mount.c
+++ b/fs/nfs/mount.c
@@ -494,46 +494,18 @@ static int nfs_get_option_ul_bound(substring_t args[], unsigned long *option,
}
/*
- * Error-check and convert a string of mount options from user space into
- * a data structure. The whole mount string is processed; bad options are
- * skipped as they are encountered. If there were no errors, return 1;
- * otherwise return 0 (zero).
+ * Parse a single mount option in "key[=val]" form.
*/
-int nfs_parse_mount_options(char *raw, struct nfs_sb_config *cfg)
+static int nfs_sb_config_parse_option(struct nfs_sb_config *cfg, char *p)
{
- char *p, *string, *secdata;
- int rc, sloppy = 0, invalid_option = 0;
- unsigned short protofamily = AF_UNSPEC;
- unsigned short mountfamily = AF_UNSPEC;
-
- if (!raw) {
- dfprintk(MOUNT, "NFS: mount options string was NULL.\n");
- return 1;
- }
- dfprintk(MOUNT, "NFS: nfs mount opts='%s'\n", raw);
-
- secdata = alloc_secdata();
- if (!secdata)
- goto out_nomem;
-
- rc = security_sb_copy_data(raw, secdata);
- if (rc)
- goto out_security_failure;
-
- rc = security_sb_parse_opts_str(secdata, &cfg->lsm_opts);
- if (rc)
- goto out_security_failure;
-
- free_secdata(secdata);
+ char *string;
+ int rc;
- while ((p = strsep(&raw, ",")) != NULL) {
+ {
substring_t args[MAX_OPT_ARGS];
unsigned long option;
int token;
- if (!*p)
- continue;
-
dfprintk(MOUNT, "NFS: parsing nfs mount option '%s'\n", p);
token = match_token(p, nfs_mount_option_tokens, args);
@@ -737,7 +709,7 @@ int nfs_parse_mount_options(char *raw, struct nfs_sb_config *cfg)
if (!rc) {
dfprintk(MOUNT, "NFS: unrecognized "
"security flavor\n");
- return 0;
+ return -EINVAL;
}
break;
case Opt_proto:
@@ -747,22 +719,22 @@ int nfs_parse_mount_options(char *raw, struct nfs_sb_config *cfg)
token = match_token(string,
nfs_xprt_protocol_tokens, args);
- protofamily = AF_INET;
+ cfg->protofamily = AF_INET;
switch (token) {
case Opt_xprt_udp6:
- protofamily = AF_INET6;
+ cfg->protofamily = AF_INET6;
case Opt_xprt_udp:
cfg->flags &= ~NFS_MOUNT_TCP;
cfg->nfs_server.protocol = XPRT_TRANSPORT_UDP;
break;
case Opt_xprt_tcp6:
- protofamily = AF_INET6;
+ cfg->protofamily = AF_INET6;
case Opt_xprt_tcp:
cfg->flags |= NFS_MOUNT_TCP;
cfg->nfs_server.protocol = XPRT_TRANSPORT_TCP;
break;
case Opt_xprt_rdma6:
- protofamily = AF_INET6;
+ cfg->protofamily = AF_INET6;
case Opt_xprt_rdma:
/* vector side protocols to TCP */
cfg->flags |= NFS_MOUNT_TCP;
@@ -773,7 +745,7 @@ int nfs_parse_mount_options(char *raw, struct nfs_sb_config *cfg)
dfprintk(MOUNT, "NFS: unrecognized "
"transport protocol\n");
kfree(string);
- return 0;
+ return -EINVAL;
}
kfree(string);
break;
@@ -785,15 +757,15 @@ int nfs_parse_mount_options(char *raw, struct nfs_sb_config *cfg)
nfs_xprt_protocol_tokens, args);
kfree(string);
- mountfamily = AF_INET;
+ cfg->mountfamily = AF_INET;
switch (token) {
case Opt_xprt_udp6:
- mountfamily = AF_INET6;
+ cfg->mountfamily = AF_INET6;
case Opt_xprt_udp:
cfg->mount_server.protocol = XPRT_TRANSPORT_UDP;
break;
case Opt_xprt_tcp6:
- mountfamily = AF_INET6;
+ cfg->mountfamily = AF_INET6;
case Opt_xprt_tcp:
cfg->mount_server.protocol = XPRT_TRANSPORT_TCP;
break;
@@ -801,7 +773,7 @@ int nfs_parse_mount_options(char *raw, struct nfs_sb_config *cfg)
default:
dfprintk(MOUNT, "NFS: unrecognized "
"transport protocol\n");
- return 0;
+ return -EINVAL;
}
break;
case Opt_addr:
@@ -860,7 +832,7 @@ int nfs_parse_mount_options(char *raw, struct nfs_sb_config *cfg)
default:
dfprintk(MOUNT, "NFS: invalid "
"lookupcache argument\n");
- return 0;
+ return -EINVAL;
};
break;
case Opt_fscache_uniq:
@@ -893,7 +865,7 @@ int nfs_parse_mount_options(char *raw, struct nfs_sb_config *cfg)
default:
dfprintk(MOUNT, "NFS: invalid "
"local_lock argument\n");
- return 0;
+ return -EINVAL;
};
break;
@@ -901,7 +873,7 @@ int nfs_parse_mount_options(char *raw, struct nfs_sb_config *cfg)
* Special options
*/
case Opt_sloppy:
- sloppy = 1;
+ cfg->sloppy = 1;
dfprintk(MOUNT, "NFS: relaxing parsing rules\n");
break;
case Opt_userspace:
@@ -911,12 +883,63 @@ int nfs_parse_mount_options(char *raw, struct nfs_sb_config *cfg)
break;
default:
- invalid_option = 1;
dfprintk(MOUNT, "NFS: unrecognized mount option "
"'%s'\n", p);
+ return -EINVAL;
}
}
+ return 0;
+
+out_invalid_address:
+ printk(KERN_INFO "NFS: bad IP address specified: %s\n", p);
+ return -EINVAL;
+out_invalid_value:
+ printk(KERN_INFO "NFS: bad mount option value specified: %s\n", p);
+ return -EINVAL;
+out_nomem:
+ printk(KERN_INFO "NFS: not enough memory to parse option\n");
+ return -ENOMEM;
+}
+
+/*
+ * Error-check and convert a string of mount options from user space into
+ * a data structure. The whole mount string is processed; bad options are
+ * skipped as they are encountered. If there were no errors, return 1;
+ * otherwise return 0 (zero).
+ */
+int nfs_parse_mount_options(char *raw, struct nfs_sb_config *cfg)
+{
+ char *p, *secdata;
+ int rc, sloppy = 0, invalid_option = 0;
+
+ if (!raw) {
+ dfprintk(MOUNT, "NFS: mount options string was NULL.\n");
+ return 1;
+ }
+ dfprintk(MOUNT, "NFS: nfs mount opts='%s'\n", raw);
+
+ secdata = alloc_secdata();
+ if (!secdata)
+ goto out_nomem;
+
+ rc = security_sb_copy_data(raw, secdata);
+ if (rc)
+ goto out_security_failure;
+
+ rc = security_sb_parse_opts_str(secdata, &cfg->lsm_opts);
+ if (rc)
+ goto out_security_failure;
+
+ free_secdata(secdata);
+
+ while ((p = strsep(&raw, ",")) != NULL) {
+ if (!*p)
+ continue;
+ if (nfs_sb_config_parse_option(cfg, p) < 0)
+ invalid_option = true;
+ }
+
if (!sloppy && invalid_option)
return 0;
@@ -931,22 +954,26 @@ int nfs_parse_mount_options(char *raw, struct nfs_sb_config *cfg)
* verify that any proto=/mountproto= options match the address
* families in the addr=/mountaddr= options.
*/
- if (protofamily != AF_UNSPEC &&
- protofamily != cfg->nfs_server.address.ss_family)
+ if (cfg->protofamily != AF_UNSPEC &&
+ cfg->protofamily != cfg->nfs_server.address.ss_family)
goto out_proto_mismatch;
- if (mountfamily != AF_UNSPEC) {
+ if (cfg->mountfamily != AF_UNSPEC) {
if (cfg->mount_server.addrlen) {
- if (mountfamily != cfg->mount_server.address.ss_family)
+ if (cfg->mountfamily != cfg->mount_server.address.ss_family)
goto out_mountproto_mismatch;
} else {
- if (mountfamily != cfg->nfs_server.address.ss_family)
+ if (cfg->mountfamily != cfg->nfs_server.address.ss_family)
goto out_mountproto_mismatch;
}
}
return 1;
+out_minorversion_mismatch:
+ printk(KERN_INFO "NFS: mount option vers=%u does not support "
+ "minorversion=%u\n", cfg->version, cfg->minorversion);
+ return 0;
out_mountproto_mismatch:
printk(KERN_INFO "NFS: mount server address does not match mountproto= "
"option\n");
@@ -954,20 +981,10 @@ int nfs_parse_mount_options(char *raw, struct nfs_sb_config *cfg)
out_proto_mismatch:
printk(KERN_INFO "NFS: server address does not match proto= option\n");
return 0;
-out_invalid_address:
- printk(KERN_INFO "NFS: bad IP address specified: %s\n", p);
- return 0;
-out_invalid_value:
- printk(KERN_INFO "NFS: bad mount option value specified: %s\n", p);
- return 0;
-out_minorversion_mismatch:
- printk(KERN_INFO "NFS: mount option vers=%u does not support "
- "minorversion=%u\n", cfg->version, cfg->minorversion);
- return 0;
out_migration_misuse:
printk(KERN_INFO
"NFS: 'migration' not supported for this NFS version\n");
- return 0;
+ return -EINVAL;
out_nomem:
printk(KERN_INFO "NFS: not enough memory to parse option\n");
return 0;
^ permalink raw reply related [flat|nested] 28+ messages in thread* [PATCH 16/21] NFS: Deindent nfs_sb_config_parse_option() [ver #3]
2017-05-15 15:17 [RFC][PATCH 00/21] VFS: Introduce superblock configuration context [ver #3] David Howells
` (14 preceding siblings ...)
2017-05-15 15:20 ` [PATCH 15/21] NFS: Split nfs_parse_mount_options() " David Howells
@ 2017-05-15 15:20 ` David Howells
2017-05-15 15:20 ` [PATCH 17/21] NFS: Add a small buffer in nfs_sb_config to avoid string dup " David Howells
` (4 subsequent siblings)
20 siblings, 0 replies; 28+ messages in thread
From: David Howells @ 2017-05-15 15:20 UTC (permalink / raw)
To: mszeredi, viro, jlayton; +Cc: dhowells, linux-fsdevel, linux-nfs, linux-kernel
Deindent nfs_sb_config_parse_option().
---
fs/nfs/mount.c | 706 ++++++++++++++++++++++++++++----------------------------
1 file changed, 351 insertions(+), 355 deletions(-)
diff --git a/fs/nfs/mount.c b/fs/nfs/mount.c
index 26153b471e48..54c38e0ed167 100644
--- a/fs/nfs/mount.c
+++ b/fs/nfs/mount.c
@@ -498,395 +498,391 @@ static int nfs_get_option_ul_bound(substring_t args[], unsigned long *option,
*/
static int nfs_sb_config_parse_option(struct nfs_sb_config *cfg, char *p)
{
+ substring_t args[MAX_OPT_ARGS];
+ unsigned long option;
char *string;
- int rc;
-
- {
- substring_t args[MAX_OPT_ARGS];
- unsigned long option;
- int token;
+ int rc, token;
- dfprintk(MOUNT, "NFS: parsing nfs mount option '%s'\n", p);
+ dfprintk(MOUNT, "NFS: parsing nfs mount option '%s'\n", p);
- token = match_token(p, nfs_mount_option_tokens, args);
- switch (token) {
+ token = match_token(p, nfs_mount_option_tokens, args);
+ switch (token) {
/*
* boolean options: foo/nofoo
*/
- case Opt_soft:
- cfg->flags |= NFS_MOUNT_SOFT;
- break;
- case Opt_hard:
- cfg->flags &= ~NFS_MOUNT_SOFT;
- break;
- case Opt_posix:
- cfg->flags |= NFS_MOUNT_POSIX;
- break;
- case Opt_noposix:
- cfg->flags &= ~NFS_MOUNT_POSIX;
- break;
- case Opt_cto:
- cfg->flags &= ~NFS_MOUNT_NOCTO;
- break;
- case Opt_nocto:
- cfg->flags |= NFS_MOUNT_NOCTO;
- break;
- case Opt_ac:
- cfg->flags &= ~NFS_MOUNT_NOAC;
- break;
- case Opt_noac:
- cfg->flags |= NFS_MOUNT_NOAC;
- break;
- case Opt_lock:
- cfg->flags &= ~NFS_MOUNT_NONLM;
- cfg->flags &= ~(NFS_MOUNT_LOCAL_FLOCK |
- NFS_MOUNT_LOCAL_FCNTL);
- break;
- case Opt_nolock:
- cfg->flags |= NFS_MOUNT_NONLM;
- cfg->flags |= (NFS_MOUNT_LOCAL_FLOCK |
- NFS_MOUNT_LOCAL_FCNTL);
- break;
- case Opt_udp:
- cfg->flags &= ~NFS_MOUNT_TCP;
- cfg->nfs_server.protocol = XPRT_TRANSPORT_UDP;
- break;
- case Opt_tcp:
- cfg->flags |= NFS_MOUNT_TCP;
- cfg->nfs_server.protocol = XPRT_TRANSPORT_TCP;
- break;
- case Opt_rdma:
- cfg->flags |= NFS_MOUNT_TCP; /* for side protocols */
- cfg->nfs_server.protocol = XPRT_TRANSPORT_RDMA;
- xprt_load_transport(p);
- break;
- case Opt_acl:
- cfg->flags &= ~NFS_MOUNT_NOACL;
- break;
- case Opt_noacl:
- cfg->flags |= NFS_MOUNT_NOACL;
- break;
- case Opt_rdirplus:
- cfg->flags &= ~NFS_MOUNT_NORDIRPLUS;
- break;
- case Opt_nordirplus:
- cfg->flags |= NFS_MOUNT_NORDIRPLUS;
- break;
- case Opt_sharecache:
- cfg->flags &= ~NFS_MOUNT_UNSHARED;
- break;
- case Opt_nosharecache:
- cfg->flags |= NFS_MOUNT_UNSHARED;
- break;
- case Opt_resvport:
- cfg->flags &= ~NFS_MOUNT_NORESVPORT;
- break;
- case Opt_noresvport:
- cfg->flags |= NFS_MOUNT_NORESVPORT;
- break;
- case Opt_fscache:
- cfg->options |= NFS_OPTION_FSCACHE;
- kfree(cfg->fscache_uniq);
- cfg->fscache_uniq = NULL;
- break;
- case Opt_nofscache:
- cfg->options &= ~NFS_OPTION_FSCACHE;
- kfree(cfg->fscache_uniq);
- cfg->fscache_uniq = NULL;
- break;
- case Opt_migration:
- cfg->options |= NFS_OPTION_MIGRATION;
- break;
- case Opt_nomigration:
- cfg->options &= NFS_OPTION_MIGRATION;
- break;
+ case Opt_soft:
+ cfg->flags |= NFS_MOUNT_SOFT;
+ break;
+ case Opt_hard:
+ cfg->flags &= ~NFS_MOUNT_SOFT;
+ break;
+ case Opt_posix:
+ cfg->flags |= NFS_MOUNT_POSIX;
+ break;
+ case Opt_noposix:
+ cfg->flags &= ~NFS_MOUNT_POSIX;
+ break;
+ case Opt_cto:
+ cfg->flags &= ~NFS_MOUNT_NOCTO;
+ break;
+ case Opt_nocto:
+ cfg->flags |= NFS_MOUNT_NOCTO;
+ break;
+ case Opt_ac:
+ cfg->flags &= ~NFS_MOUNT_NOAC;
+ break;
+ case Opt_noac:
+ cfg->flags |= NFS_MOUNT_NOAC;
+ break;
+ case Opt_lock:
+ cfg->flags &= ~NFS_MOUNT_NONLM;
+ cfg->flags &= ~(NFS_MOUNT_LOCAL_FLOCK |
+ NFS_MOUNT_LOCAL_FCNTL);
+ break;
+ case Opt_nolock:
+ cfg->flags |= NFS_MOUNT_NONLM;
+ cfg->flags |= (NFS_MOUNT_LOCAL_FLOCK |
+ NFS_MOUNT_LOCAL_FCNTL);
+ break;
+ case Opt_udp:
+ cfg->flags &= ~NFS_MOUNT_TCP;
+ cfg->nfs_server.protocol = XPRT_TRANSPORT_UDP;
+ break;
+ case Opt_tcp:
+ cfg->flags |= NFS_MOUNT_TCP;
+ cfg->nfs_server.protocol = XPRT_TRANSPORT_TCP;
+ break;
+ case Opt_rdma:
+ cfg->flags |= NFS_MOUNT_TCP; /* for side protocols */
+ cfg->nfs_server.protocol = XPRT_TRANSPORT_RDMA;
+ xprt_load_transport(p);
+ break;
+ case Opt_acl:
+ cfg->flags &= ~NFS_MOUNT_NOACL;
+ break;
+ case Opt_noacl:
+ cfg->flags |= NFS_MOUNT_NOACL;
+ break;
+ case Opt_rdirplus:
+ cfg->flags &= ~NFS_MOUNT_NORDIRPLUS;
+ break;
+ case Opt_nordirplus:
+ cfg->flags |= NFS_MOUNT_NORDIRPLUS;
+ break;
+ case Opt_sharecache:
+ cfg->flags &= ~NFS_MOUNT_UNSHARED;
+ break;
+ case Opt_nosharecache:
+ cfg->flags |= NFS_MOUNT_UNSHARED;
+ break;
+ case Opt_resvport:
+ cfg->flags &= ~NFS_MOUNT_NORESVPORT;
+ break;
+ case Opt_noresvport:
+ cfg->flags |= NFS_MOUNT_NORESVPORT;
+ break;
+ case Opt_fscache:
+ cfg->options |= NFS_OPTION_FSCACHE;
+ kfree(cfg->fscache_uniq);
+ cfg->fscache_uniq = NULL;
+ break;
+ case Opt_nofscache:
+ cfg->options &= ~NFS_OPTION_FSCACHE;
+ kfree(cfg->fscache_uniq);
+ cfg->fscache_uniq = NULL;
+ break;
+ case Opt_migration:
+ cfg->options |= NFS_OPTION_MIGRATION;
+ break;
+ case Opt_nomigration:
+ cfg->options &= NFS_OPTION_MIGRATION;
+ break;
/*
* options that take numeric values
*/
- case Opt_port:
- if (nfs_get_option_ul(args, &option) ||
- option > USHRT_MAX)
- goto out_invalid_value;
- cfg->nfs_server.port = option;
- break;
- case Opt_rsize:
- if (nfs_get_option_ul(args, &option))
- goto out_invalid_value;
- cfg->rsize = option;
- break;
- case Opt_wsize:
- if (nfs_get_option_ul(args, &option))
- goto out_invalid_value;
- cfg->wsize = option;
- break;
- case Opt_bsize:
- if (nfs_get_option_ul(args, &option))
- goto out_invalid_value;
- cfg->bsize = option;
- break;
- case Opt_timeo:
- if (nfs_get_option_ul_bound(args, &option, 1, INT_MAX))
- goto out_invalid_value;
- cfg->timeo = option;
- break;
- case Opt_retrans:
- if (nfs_get_option_ul_bound(args, &option, 0, INT_MAX))
- goto out_invalid_value;
- cfg->retrans = option;
- break;
- case Opt_acregmin:
- if (nfs_get_option_ul(args, &option))
- goto out_invalid_value;
- cfg->acregmin = option;
- break;
- case Opt_acregmax:
- if (nfs_get_option_ul(args, &option))
- goto out_invalid_value;
- cfg->acregmax = option;
- break;
- case Opt_acdirmin:
- if (nfs_get_option_ul(args, &option))
- goto out_invalid_value;
- cfg->acdirmin = option;
- break;
- case Opt_acdirmax:
- if (nfs_get_option_ul(args, &option))
- goto out_invalid_value;
- cfg->acdirmax = option;
- break;
- case Opt_actimeo:
- if (nfs_get_option_ul(args, &option))
- goto out_invalid_value;
- cfg->acregmin = cfg->acregmax =
+ case Opt_port:
+ if (nfs_get_option_ul(args, &option) ||
+ option > USHRT_MAX)
+ goto out_invalid_value;
+ cfg->nfs_server.port = option;
+ break;
+ case Opt_rsize:
+ if (nfs_get_option_ul(args, &option))
+ goto out_invalid_value;
+ cfg->rsize = option;
+ break;
+ case Opt_wsize:
+ if (nfs_get_option_ul(args, &option))
+ goto out_invalid_value;
+ cfg->wsize = option;
+ break;
+ case Opt_bsize:
+ if (nfs_get_option_ul(args, &option))
+ goto out_invalid_value;
+ cfg->bsize = option;
+ break;
+ case Opt_timeo:
+ if (nfs_get_option_ul_bound(args, &option, 1, INT_MAX))
+ goto out_invalid_value;
+ cfg->timeo = option;
+ break;
+ case Opt_retrans:
+ if (nfs_get_option_ul_bound(args, &option, 0, INT_MAX))
+ goto out_invalid_value;
+ cfg->retrans = option;
+ break;
+ case Opt_acregmin:
+ if (nfs_get_option_ul(args, &option))
+ goto out_invalid_value;
+ cfg->acregmin = option;
+ break;
+ case Opt_acregmax:
+ if (nfs_get_option_ul(args, &option))
+ goto out_invalid_value;
+ cfg->acregmax = option;
+ break;
+ case Opt_acdirmin:
+ if (nfs_get_option_ul(args, &option))
+ goto out_invalid_value;
+ cfg->acdirmin = option;
+ break;
+ case Opt_acdirmax:
+ if (nfs_get_option_ul(args, &option))
+ goto out_invalid_value;
+ cfg->acdirmax = option;
+ break;
+ case Opt_actimeo:
+ if (nfs_get_option_ul(args, &option))
+ goto out_invalid_value;
+ cfg->acregmin = cfg->acregmax =
cfg->acdirmin = cfg->acdirmax = option;
- break;
- case Opt_namelen:
- if (nfs_get_option_ul(args, &option))
- goto out_invalid_value;
- cfg->namlen = option;
- break;
- case Opt_mountport:
- if (nfs_get_option_ul(args, &option) ||
- option > USHRT_MAX)
- goto out_invalid_value;
- cfg->mount_server.port = option;
- break;
- case Opt_mountvers:
- if (nfs_get_option_ul(args, &option) ||
- option < NFS_MNT_VERSION ||
- option > NFS_MNT3_VERSION)
- goto out_invalid_value;
- cfg->mount_server.version = option;
- break;
- case Opt_minorversion:
- if (nfs_get_option_ul(args, &option))
- goto out_invalid_value;
- if (option > NFS4_MAX_MINOR_VERSION)
- goto out_invalid_value;
- cfg->minorversion = option;
- break;
+ break;
+ case Opt_namelen:
+ if (nfs_get_option_ul(args, &option))
+ goto out_invalid_value;
+ cfg->namlen = option;
+ break;
+ case Opt_mountport:
+ if (nfs_get_option_ul(args, &option) ||
+ option > USHRT_MAX)
+ goto out_invalid_value;
+ cfg->mount_server.port = option;
+ break;
+ case Opt_mountvers:
+ if (nfs_get_option_ul(args, &option) ||
+ option < NFS_MNT_VERSION ||
+ option > NFS_MNT3_VERSION)
+ goto out_invalid_value;
+ cfg->mount_server.version = option;
+ break;
+ case Opt_minorversion:
+ if (nfs_get_option_ul(args, &option))
+ goto out_invalid_value;
+ if (option > NFS4_MAX_MINOR_VERSION)
+ goto out_invalid_value;
+ cfg->minorversion = option;
+ break;
/*
* options that take text values
*/
- case Opt_nfsvers:
- string = match_strdup(args);
- if (string == NULL)
- goto out_nomem;
- rc = nfs_parse_version_string(string, cfg, args);
- kfree(string);
- if (!rc)
- goto out_invalid_value;
+ case Opt_nfsvers:
+ string = match_strdup(args);
+ if (string == NULL)
+ goto out_nomem;
+ rc = nfs_parse_version_string(string, cfg, args);
+ kfree(string);
+ if (!rc)
+ goto out_invalid_value;
+ break;
+ case Opt_sec:
+ string = match_strdup(args);
+ if (string == NULL)
+ goto out_nomem;
+ rc = nfs_parse_security_flavors(string, cfg);
+ kfree(string);
+ if (!rc) {
+ dfprintk(MOUNT, "NFS: unrecognized "
+ "security flavor\n");
+ return -EINVAL;
+ }
+ break;
+ case Opt_proto:
+ string = match_strdup(args);
+ if (string == NULL)
+ goto out_nomem;
+ token = match_token(string,
+ nfs_xprt_protocol_tokens, args);
+
+ cfg->protofamily = AF_INET;
+ switch (token) {
+ case Opt_xprt_udp6:
+ cfg->protofamily = AF_INET6;
+ case Opt_xprt_udp:
+ cfg->flags &= ~NFS_MOUNT_TCP;
+ cfg->nfs_server.protocol = XPRT_TRANSPORT_UDP;
break;
- case Opt_sec:
- string = match_strdup(args);
- if (string == NULL)
- goto out_nomem;
- rc = nfs_parse_security_flavors(string, cfg);
- kfree(string);
- if (!rc) {
- dfprintk(MOUNT, "NFS: unrecognized "
- "security flavor\n");
- return -EINVAL;
- }
+ case Opt_xprt_tcp6:
+ cfg->protofamily = AF_INET6;
+ case Opt_xprt_tcp:
+ cfg->flags |= NFS_MOUNT_TCP;
+ cfg->nfs_server.protocol = XPRT_TRANSPORT_TCP;
break;
- case Opt_proto:
- string = match_strdup(args);
- if (string == NULL)
- goto out_nomem;
- token = match_token(string,
- nfs_xprt_protocol_tokens, args);
-
- cfg->protofamily = AF_INET;
- switch (token) {
- case Opt_xprt_udp6:
- cfg->protofamily = AF_INET6;
- case Opt_xprt_udp:
- cfg->flags &= ~NFS_MOUNT_TCP;
- cfg->nfs_server.protocol = XPRT_TRANSPORT_UDP;
- break;
- case Opt_xprt_tcp6:
- cfg->protofamily = AF_INET6;
- case Opt_xprt_tcp:
- cfg->flags |= NFS_MOUNT_TCP;
- cfg->nfs_server.protocol = XPRT_TRANSPORT_TCP;
- break;
- case Opt_xprt_rdma6:
- cfg->protofamily = AF_INET6;
- case Opt_xprt_rdma:
- /* vector side protocols to TCP */
- cfg->flags |= NFS_MOUNT_TCP;
- cfg->nfs_server.protocol = XPRT_TRANSPORT_RDMA;
- xprt_load_transport(string);
- break;
- default:
- dfprintk(MOUNT, "NFS: unrecognized "
- "transport protocol\n");
- kfree(string);
- return -EINVAL;
- }
- kfree(string);
+ case Opt_xprt_rdma6:
+ cfg->protofamily = AF_INET6;
+ case Opt_xprt_rdma:
+ /* vector side protocols to TCP */
+ cfg->flags |= NFS_MOUNT_TCP;
+ cfg->nfs_server.protocol = XPRT_TRANSPORT_RDMA;
+ xprt_load_transport(string);
break;
- case Opt_mountproto:
- string = match_strdup(args);
- if (string == NULL)
- goto out_nomem;
- token = match_token(string,
- nfs_xprt_protocol_tokens, args);
+ default:
+ dfprintk(MOUNT, "NFS: unrecognized "
+ "transport protocol\n");
kfree(string);
+ return -EINVAL;
+ }
+ kfree(string);
+ break;
+ case Opt_mountproto:
+ string = match_strdup(args);
+ if (string == NULL)
+ goto out_nomem;
+ token = match_token(string,
+ nfs_xprt_protocol_tokens, args);
+ kfree(string);
- cfg->mountfamily = AF_INET;
- switch (token) {
- case Opt_xprt_udp6:
- cfg->mountfamily = AF_INET6;
- case Opt_xprt_udp:
- cfg->mount_server.protocol = XPRT_TRANSPORT_UDP;
- break;
- case Opt_xprt_tcp6:
- cfg->mountfamily = AF_INET6;
- case Opt_xprt_tcp:
- cfg->mount_server.protocol = XPRT_TRANSPORT_TCP;
- break;
- case Opt_xprt_rdma: /* not used for side protocols */
- default:
- dfprintk(MOUNT, "NFS: unrecognized "
- "transport protocol\n");
- return -EINVAL;
- }
+ cfg->mountfamily = AF_INET;
+ switch (token) {
+ case Opt_xprt_udp6:
+ cfg->mountfamily = AF_INET6;
+ case Opt_xprt_udp:
+ cfg->mount_server.protocol = XPRT_TRANSPORT_UDP;
break;
- case Opt_addr:
- string = match_strdup(args);
- if (string == NULL)
- goto out_nomem;
- cfg->nfs_server.addrlen =
- rpc_pton(cfg->net, string, strlen(string),
- (struct sockaddr *)
- &cfg->nfs_server.address,
- sizeof(cfg->nfs_server.address));
- kfree(string);
- if (cfg->nfs_server.addrlen == 0)
- goto out_invalid_address;
+ case Opt_xprt_tcp6:
+ cfg->mountfamily = AF_INET6;
+ case Opt_xprt_tcp:
+ cfg->mount_server.protocol = XPRT_TRANSPORT_TCP;
break;
- case Opt_clientaddr:
- if (nfs_get_option_str(args, &cfg->client_address))
- goto out_nomem;
+ case Opt_xprt_rdma: /* not used for side protocols */
+ default:
+ dfprintk(MOUNT, "NFS: unrecognized "
+ "transport protocol\n");
+ return -EINVAL;
+ }
+ break;
+ case Opt_addr:
+ string = match_strdup(args);
+ if (string == NULL)
+ goto out_nomem;
+ cfg->nfs_server.addrlen =
+ rpc_pton(cfg->net, string, strlen(string),
+ (struct sockaddr *)
+ &cfg->nfs_server.address,
+ sizeof(cfg->nfs_server.address));
+ kfree(string);
+ if (cfg->nfs_server.addrlen == 0)
+ goto out_invalid_address;
+ break;
+ case Opt_clientaddr:
+ if (nfs_get_option_str(args, &cfg->client_address))
+ goto out_nomem;
+ break;
+ case Opt_mounthost:
+ if (nfs_get_option_str(args,
+ &cfg->mount_server.hostname))
+ goto out_nomem;
+ break;
+ case Opt_mountaddr:
+ string = match_strdup(args);
+ if (string == NULL)
+ goto out_nomem;
+ cfg->mount_server.addrlen =
+ rpc_pton(cfg->net, string, strlen(string),
+ (struct sockaddr *)
+ &cfg->mount_server.address,
+ sizeof(cfg->mount_server.address));
+ kfree(string);
+ if (cfg->mount_server.addrlen == 0)
+ goto out_invalid_address;
+ break;
+ case Opt_lookupcache:
+ string = match_strdup(args);
+ if (string == NULL)
+ goto out_nomem;
+ token = match_token(string,
+ nfs_lookupcache_tokens, args);
+ kfree(string);
+ switch (token) {
+ case Opt_lookupcache_all:
+ cfg->flags &= ~(NFS_MOUNT_LOOKUP_CACHE_NONEG|NFS_MOUNT_LOOKUP_CACHE_NONE);
break;
- case Opt_mounthost:
- if (nfs_get_option_str(args,
- &cfg->mount_server.hostname))
- goto out_nomem;
+ case Opt_lookupcache_positive:
+ cfg->flags &= ~NFS_MOUNT_LOOKUP_CACHE_NONE;
+ cfg->flags |= NFS_MOUNT_LOOKUP_CACHE_NONEG;
break;
- case Opt_mountaddr:
- string = match_strdup(args);
- if (string == NULL)
- goto out_nomem;
- cfg->mount_server.addrlen =
- rpc_pton(cfg->net, string, strlen(string),
- (struct sockaddr *)
- &cfg->mount_server.address,
- sizeof(cfg->mount_server.address));
- kfree(string);
- if (cfg->mount_server.addrlen == 0)
- goto out_invalid_address;
+ case Opt_lookupcache_none:
+ cfg->flags |= NFS_MOUNT_LOOKUP_CACHE_NONEG|NFS_MOUNT_LOOKUP_CACHE_NONE;
break;
- case Opt_lookupcache:
- string = match_strdup(args);
- if (string == NULL)
- goto out_nomem;
- token = match_token(string,
- nfs_lookupcache_tokens, args);
- kfree(string);
- switch (token) {
- case Opt_lookupcache_all:
- cfg->flags &= ~(NFS_MOUNT_LOOKUP_CACHE_NONEG|NFS_MOUNT_LOOKUP_CACHE_NONE);
- break;
- case Opt_lookupcache_positive:
- cfg->flags &= ~NFS_MOUNT_LOOKUP_CACHE_NONE;
- cfg->flags |= NFS_MOUNT_LOOKUP_CACHE_NONEG;
- break;
- case Opt_lookupcache_none:
- cfg->flags |= NFS_MOUNT_LOOKUP_CACHE_NONEG|NFS_MOUNT_LOOKUP_CACHE_NONE;
- break;
- default:
- dfprintk(MOUNT, "NFS: invalid "
- "lookupcache argument\n");
- return -EINVAL;
- };
+ default:
+ dfprintk(MOUNT, "NFS: invalid "
+ "lookupcache argument\n");
+ return -EINVAL;
+ };
+ break;
+ case Opt_fscache_uniq:
+ if (nfs_get_option_str(args, &cfg->fscache_uniq))
+ goto out_nomem;
+ cfg->options |= NFS_OPTION_FSCACHE;
+ break;
+ case Opt_local_lock:
+ string = match_strdup(args);
+ if (string == NULL)
+ goto out_nomem;
+ token = match_token(string, nfs_local_lock_tokens,
+ args);
+ kfree(string);
+ switch (token) {
+ case Opt_local_lock_all:
+ cfg->flags |= (NFS_MOUNT_LOCAL_FLOCK |
+ NFS_MOUNT_LOCAL_FCNTL);
break;
- case Opt_fscache_uniq:
- if (nfs_get_option_str(args, &cfg->fscache_uniq))
- goto out_nomem;
- cfg->options |= NFS_OPTION_FSCACHE;
+ case Opt_local_lock_flock:
+ cfg->flags |= NFS_MOUNT_LOCAL_FLOCK;
break;
- case Opt_local_lock:
- string = match_strdup(args);
- if (string == NULL)
- goto out_nomem;
- token = match_token(string, nfs_local_lock_tokens,
- args);
- kfree(string);
- switch (token) {
- case Opt_local_lock_all:
- cfg->flags |= (NFS_MOUNT_LOCAL_FLOCK |
- NFS_MOUNT_LOCAL_FCNTL);
- break;
- case Opt_local_lock_flock:
- cfg->flags |= NFS_MOUNT_LOCAL_FLOCK;
- break;
- case Opt_local_lock_posix:
- cfg->flags |= NFS_MOUNT_LOCAL_FCNTL;
- break;
- case Opt_local_lock_none:
- cfg->flags &= ~(NFS_MOUNT_LOCAL_FLOCK |
- NFS_MOUNT_LOCAL_FCNTL);
- break;
- default:
- dfprintk(MOUNT, "NFS: invalid "
- "local_lock argument\n");
- return -EINVAL;
- };
+ case Opt_local_lock_posix:
+ cfg->flags |= NFS_MOUNT_LOCAL_FCNTL;
break;
+ case Opt_local_lock_none:
+ cfg->flags &= ~(NFS_MOUNT_LOCAL_FLOCK |
+ NFS_MOUNT_LOCAL_FCNTL);
+ break;
+ default:
+ dfprintk(MOUNT, "NFS: invalid "
+ "local_lock argument\n");
+ return -EINVAL;
+ };
+ break;
/*
* Special options
*/
- case Opt_sloppy:
- cfg->sloppy = 1;
- dfprintk(MOUNT, "NFS: relaxing parsing rules\n");
- break;
- case Opt_userspace:
- case Opt_deprecated:
- dfprintk(MOUNT, "NFS: ignoring mount option "
- "'%s'\n", p);
- break;
+ case Opt_sloppy:
+ cfg->sloppy = 1;
+ dfprintk(MOUNT, "NFS: relaxing parsing rules\n");
+ break;
+ case Opt_userspace:
+ case Opt_deprecated:
+ dfprintk(MOUNT, "NFS: ignoring mount option "
+ "'%s'\n", p);
+ break;
- default:
- dfprintk(MOUNT, "NFS: unrecognized mount option "
- "'%s'\n", p);
- return -EINVAL;
- }
+ default:
+ dfprintk(MOUNT, "NFS: unrecognized mount option "
+ "'%s'\n", p);
+ return -EINVAL;
}
return 0;
^ permalink raw reply related [flat|nested] 28+ messages in thread* [PATCH 17/21] NFS: Add a small buffer in nfs_sb_config to avoid string dup [ver #3]
2017-05-15 15:17 [RFC][PATCH 00/21] VFS: Introduce superblock configuration context [ver #3] David Howells
` (15 preceding siblings ...)
2017-05-15 15:20 ` [PATCH 16/21] NFS: Deindent nfs_sb_config_parse_option() " David Howells
@ 2017-05-15 15:20 ` David Howells
2017-05-15 15:20 ` [PATCH 18/21] NFS: Do some tidying of the parsing code " David Howells
` (3 subsequent siblings)
20 siblings, 0 replies; 28+ messages in thread
From: David Howells @ 2017-05-15 15:20 UTC (permalink / raw)
To: mszeredi, viro, jlayton; +Cc: dhowells, linux-fsdevel, linux-nfs, linux-kernel
Add a small buffer in nfs_sb_config to avoid string duplication when
parsing numbers. Also make the parsing function wrapper place the parsed
integer directly in the appropriate nfs_sb_config struct member.
---
fs/nfs/internal.h | 2 +
fs/nfs/mount.c | 83 +++++++++++++++++++----------------------------------
2 files changed, 32 insertions(+), 53 deletions(-)
diff --git a/fs/nfs/internal.h b/fs/nfs/internal.h
index ed255241baa7..52242240933f 100644
--- a/fs/nfs/internal.h
+++ b/fs/nfs/internal.h
@@ -125,6 +125,8 @@ struct nfs_sb_config {
struct security_mnt_opts lsm_opts;
struct net *net;
+
+ char buf[32]; /* Parse buffer */
};
/* mount_clnt.c */
diff --git a/fs/nfs/mount.c b/fs/nfs/mount.c
index 54c38e0ed167..bebc589badbb 100644
--- a/fs/nfs/mount.c
+++ b/fs/nfs/mount.c
@@ -466,27 +466,22 @@ static int nfs_get_option_str(substring_t args[], char **option)
return !*option;
}
-static int nfs_get_option_ul(substring_t args[], unsigned long *option)
+static int nfs_get_option_ui(struct nfs_sb_config *cfg,
+ substring_t args[], unsigned int *option)
{
- int rc;
- char *string;
-
- string = match_strdup(args);
- if (string == NULL)
- return -ENOMEM;
- rc = kstrtoul(string, 10, option);
- kfree(string);
-
- return rc;
+ match_strlcpy(cfg->buf, args, sizeof(cfg->buf));
+ return kstrtouint(cfg->buf, 10, option);
}
-static int nfs_get_option_ul_bound(substring_t args[], unsigned long *option,
- unsigned long l_bound, unsigned long u_bound)
+static int nfs_get_option_ui_bound(struct nfs_sb_config *cfg,
+ substring_t args[], unsigned int *option,
+ unsigned int l_bound, unsigned u_bound)
{
int ret;
- ret = nfs_get_option_ul(args, option);
- if (ret != 0)
+ match_strlcpy(cfg->buf, args, sizeof(cfg->buf));
+ ret = kstrtouint(cfg->buf, 10, option);
+ if (ret < 0)
return ret;
if (*option < l_bound || *option > u_bound)
return -ERANGE;
@@ -499,7 +494,6 @@ static int nfs_get_option_ul_bound(substring_t args[], unsigned long *option,
static int nfs_sb_config_parse_option(struct nfs_sb_config *cfg, char *p)
{
substring_t args[MAX_OPT_ARGS];
- unsigned long option;
char *string;
int rc, token;
@@ -507,7 +501,6 @@ static int nfs_sb_config_parse_option(struct nfs_sb_config *cfg, char *p)
token = match_token(p, nfs_mount_option_tokens, args);
switch (token) {
-
/*
* boolean options: foo/nofoo
*/
@@ -603,86 +596,70 @@ static int nfs_sb_config_parse_option(struct nfs_sb_config *cfg, char *p)
* options that take numeric values
*/
case Opt_port:
- if (nfs_get_option_ul(args, &option) ||
- option > USHRT_MAX)
+ if (nfs_get_option_ui_bound(cfg, args, &cfg->nfs_server.port,
+ 0, USHRT_MAX))
goto out_invalid_value;
- cfg->nfs_server.port = option;
break;
case Opt_rsize:
- if (nfs_get_option_ul(args, &option))
+ if (nfs_get_option_ui(cfg, args, &cfg->rsize))
goto out_invalid_value;
- cfg->rsize = option;
break;
case Opt_wsize:
- if (nfs_get_option_ul(args, &option))
+ if (nfs_get_option_ui(cfg, args, &cfg->wsize))
goto out_invalid_value;
- cfg->wsize = option;
break;
case Opt_bsize:
- if (nfs_get_option_ul(args, &option))
+ if (nfs_get_option_ui(cfg, args, &cfg->bsize))
goto out_invalid_value;
- cfg->bsize = option;
break;
case Opt_timeo:
- if (nfs_get_option_ul_bound(args, &option, 1, INT_MAX))
+ if (nfs_get_option_ui_bound(cfg, args, &cfg->timeo, 1, INT_MAX))
goto out_invalid_value;
- cfg->timeo = option;
break;
case Opt_retrans:
- if (nfs_get_option_ul_bound(args, &option, 0, INT_MAX))
+ if (nfs_get_option_ui_bound(cfg, args, &cfg->retrans, 0, INT_MAX))
goto out_invalid_value;
- cfg->retrans = option;
break;
case Opt_acregmin:
- if (nfs_get_option_ul(args, &option))
+ if (nfs_get_option_ui(cfg, args, &cfg->acregmin))
goto out_invalid_value;
- cfg->acregmin = option;
break;
case Opt_acregmax:
- if (nfs_get_option_ul(args, &option))
+ if (nfs_get_option_ui(cfg, args, &cfg->acregmax))
goto out_invalid_value;
- cfg->acregmax = option;
break;
case Opt_acdirmin:
- if (nfs_get_option_ul(args, &option))
+ if (nfs_get_option_ui(cfg, args, &cfg->acdirmin))
goto out_invalid_value;
- cfg->acdirmin = option;
break;
case Opt_acdirmax:
- if (nfs_get_option_ul(args, &option))
+ if (nfs_get_option_ui(cfg, args, &cfg->acdirmax))
goto out_invalid_value;
- cfg->acdirmax = option;
break;
case Opt_actimeo:
- if (nfs_get_option_ul(args, &option))
+ if (nfs_get_option_ui(cfg, args, &cfg->acdirmax))
goto out_invalid_value;
cfg->acregmin = cfg->acregmax =
- cfg->acdirmin = cfg->acdirmax = option;
+ cfg->acdirmin = cfg->acdirmax;
break;
case Opt_namelen:
- if (nfs_get_option_ul(args, &option))
+ if (nfs_get_option_ui(cfg, args, &cfg->namlen))
goto out_invalid_value;
- cfg->namlen = option;
break;
case Opt_mountport:
- if (nfs_get_option_ul(args, &option) ||
- option > USHRT_MAX)
+ if (nfs_get_option_ui_bound(cfg, args, &cfg->mount_server.port,
+ 0, USHRT_MAX))
goto out_invalid_value;
- cfg->mount_server.port = option;
break;
case Opt_mountvers:
- if (nfs_get_option_ul(args, &option) ||
- option < NFS_MNT_VERSION ||
- option > NFS_MNT3_VERSION)
+ if (nfs_get_option_ui_bound(cfg, args, &cfg->mount_server.version,
+ NFS_MNT_VERSION, NFS_MNT3_VERSION))
goto out_invalid_value;
- cfg->mount_server.version = option;
break;
case Opt_minorversion:
- if (nfs_get_option_ul(args, &option))
- goto out_invalid_value;
- if (option > NFS4_MAX_MINOR_VERSION)
+ if (nfs_get_option_ui_bound(cfg, args, &cfg->minorversion,
+ 0, NFS4_MAX_MINOR_VERSION))
goto out_invalid_value;
- cfg->minorversion = option;
break;
/*
^ permalink raw reply related [flat|nested] 28+ messages in thread* [PATCH 18/21] NFS: Do some tidying of the parsing code [ver #3]
2017-05-15 15:17 [RFC][PATCH 00/21] VFS: Introduce superblock configuration context [ver #3] David Howells
` (16 preceding siblings ...)
2017-05-15 15:20 ` [PATCH 17/21] NFS: Add a small buffer in nfs_sb_config to avoid string dup " David Howells
@ 2017-05-15 15:20 ` David Howells
2017-05-15 15:20 ` [PATCH 19/21] NFS: Add mount context support. " David Howells
` (2 subsequent siblings)
20 siblings, 0 replies; 28+ messages in thread
From: David Howells @ 2017-05-15 15:20 UTC (permalink / raw)
To: mszeredi, viro, jlayton; +Cc: dhowells, linux-fsdevel, linux-nfs, linux-kernel
Do some tidying of the parsing code, including:
(*) Returning 0/error rather than true/false.
(*) Putting the nfs_sb_config pointer first in some arg lists.
(*) Unwrap some lines that will now fit on one line.
(*) Provide unioned sockaddr/sockaddr_storage fields to avoid casts.
(*) nfs_parse_devname() can paste its return values directly into the
nfs_sb_config struct as that's where the caller puts them.
---
fs/nfs/internal.h | 16 +++++--
fs/nfs/mount.c | 128 +++++++++++++++++++++++------------------------------
fs/nfs/super.c | 2 -
3 files changed, 67 insertions(+), 79 deletions(-)
diff --git a/fs/nfs/internal.h b/fs/nfs/internal.h
index 52242240933f..79e77ff2061c 100644
--- a/fs/nfs/internal.h
+++ b/fs/nfs/internal.h
@@ -86,11 +86,11 @@ struct nfs_client_initdata {
* In-kernel mount arguments
*/
struct nfs_sb_config {
- int flags;
+ unsigned int flags; /* NFS{,4}_MOUNT_* flags */
unsigned int rsize, wsize;
unsigned int timeo, retrans;
- unsigned int acregmin, acregmax,
- acdirmin, acdirmax;
+ unsigned int acregmin, acregmax;
+ unsigned int acdirmin, acdirmax;
unsigned int namlen;
unsigned int options;
unsigned int bsize;
@@ -106,7 +106,10 @@ struct nfs_sb_config {
bool sloppy;
struct {
- struct sockaddr_storage address;
+ union {
+ struct sockaddr address;
+ struct sockaddr_storage _address;
+ };
size_t addrlen;
char *hostname;
u32 version;
@@ -115,7 +118,10 @@ struct nfs_sb_config {
} mount_server;
struct {
- struct sockaddr_storage address;
+ union {
+ struct sockaddr address;
+ struct sockaddr_storage _address;
+ };
size_t addrlen;
char *hostname;
char *export_path;
diff --git a/fs/nfs/mount.c b/fs/nfs/mount.c
index bebc589badbb..e0c3381ad5c5 100644
--- a/fs/nfs/mount.c
+++ b/fs/nfs/mount.c
@@ -341,8 +341,9 @@ static void nfs_set_mount_transport_protocol(struct nfs_sb_config *cfg)
* Add 'flavor' to 'auth_info' if not already present.
* Returns true if 'flavor' ends up in the list, false otherwise
*/
-static bool nfs_auth_info_add(struct nfs_auth_info *auth_info,
- rpc_authflavor_t flavor)
+static int nfs_auth_info_add(struct nfs_sb_config *cfg,
+ struct nfs_auth_info *auth_info,
+ rpc_authflavor_t flavor)
{
unsigned int i;
unsigned int max_flavor_len = ARRAY_SIZE(auth_info->flavors);
@@ -350,26 +351,27 @@ static bool nfs_auth_info_add(struct nfs_auth_info *auth_info,
/* make sure this flavor isn't already in the list */
for (i = 0; i < auth_info->flavor_len; i++) {
if (flavor == auth_info->flavors[i])
- return true;
+ return 0;
}
if (auth_info->flavor_len + 1 >= max_flavor_len) {
dfprintk(MOUNT, "NFS: too many sec= flavors\n");
- return false;
+ return -EINVAL;
}
auth_info->flavors[auth_info->flavor_len++] = flavor;
- return true;
+ return 0;
}
/*
* Parse the value of the 'sec=' option.
*/
-static int nfs_parse_security_flavors(char *value, struct nfs_sb_config *cfg)
+static int nfs_parse_security_flavors(struct nfs_sb_config *cfg, char *value)
{
substring_t args[MAX_OPT_ARGS];
rpc_authflavor_t pseudoflavor;
char *p;
+ int ret;
dfprintk(MOUNT, "NFS: parsing sec=%s option\n", value);
@@ -411,19 +413,20 @@ static int nfs_parse_security_flavors(char *value, struct nfs_sb_config *cfg)
default:
dfprintk(MOUNT,
"NFS: sec= option '%s' not recognized\n", p);
- return 0;
+ return -EINVAL;
}
- if (!nfs_auth_info_add(&cfg->auth_info, pseudoflavor))
- return 0;
+ ret = nfs_auth_info_add(cfg, &cfg->auth_info, pseudoflavor);
+ if (ret < 0)
+ return ret;
}
- return 1;
+ return 0;
}
-static int nfs_parse_version_string(char *string,
- struct nfs_sb_config *cfg,
- substring_t *args)
+static int nfs_parse_version_string(struct nfs_sb_config *cfg,
+ char *string,
+ substring_t *args)
{
cfg->flags &= ~NFS_MOUNT_VER3;
switch (match_token(string, nfs_vers_tokens, args)) {
@@ -454,9 +457,10 @@ static int nfs_parse_version_string(char *string,
cfg->minorversion = 2;
break;
default:
- return 0;
+ dfprintk(MOUNT, "NFS: Unsupported NFS version\n");
+ return -EINVAL;
}
- return 1;
+ return 0;
}
static int nfs_get_option_str(substring_t args[], char **option)
@@ -495,7 +499,7 @@ static int nfs_sb_config_parse_option(struct nfs_sb_config *cfg, char *p)
{
substring_t args[MAX_OPT_ARGS];
char *string;
- int rc, token;
+ int ret, token;
dfprintk(MOUNT, "NFS: parsing nfs mount option '%s'\n", p);
@@ -530,13 +534,11 @@ static int nfs_sb_config_parse_option(struct nfs_sb_config *cfg, char *p)
break;
case Opt_lock:
cfg->flags &= ~NFS_MOUNT_NONLM;
- cfg->flags &= ~(NFS_MOUNT_LOCAL_FLOCK |
- NFS_MOUNT_LOCAL_FCNTL);
+ cfg->flags &= ~(NFS_MOUNT_LOCAL_FLOCK | NFS_MOUNT_LOCAL_FCNTL);
break;
case Opt_nolock:
cfg->flags |= NFS_MOUNT_NONLM;
- cfg->flags |= (NFS_MOUNT_LOCAL_FLOCK |
- NFS_MOUNT_LOCAL_FCNTL);
+ cfg->flags |= (NFS_MOUNT_LOCAL_FLOCK | NFS_MOUNT_LOCAL_FCNTL);
break;
case Opt_udp:
cfg->flags &= ~NFS_MOUNT_TCP;
@@ -669,29 +671,25 @@ static int nfs_sb_config_parse_option(struct nfs_sb_config *cfg, char *p)
string = match_strdup(args);
if (string == NULL)
goto out_nomem;
- rc = nfs_parse_version_string(string, cfg, args);
+ ret = nfs_parse_version_string(cfg, string, args);
kfree(string);
- if (!rc)
- goto out_invalid_value;
+ if (ret < 0)
+ return ret;
break;
case Opt_sec:
string = match_strdup(args);
if (string == NULL)
goto out_nomem;
- rc = nfs_parse_security_flavors(string, cfg);
+ ret = nfs_parse_security_flavors(cfg, string);
kfree(string);
- if (!rc) {
- dfprintk(MOUNT, "NFS: unrecognized "
- "security flavor\n");
- return -EINVAL;
- }
+ if (ret < 0)
+ return ret;
break;
case Opt_proto:
string = match_strdup(args);
if (string == NULL)
goto out_nomem;
- token = match_token(string,
- nfs_xprt_protocol_tokens, args);
+ token = match_token(string, nfs_xprt_protocol_tokens, args);
cfg->protofamily = AF_INET;
switch (token) {
@@ -716,9 +714,8 @@ static int nfs_sb_config_parse_option(struct nfs_sb_config *cfg, char *p)
xprt_load_transport(string);
break;
default:
- dfprintk(MOUNT, "NFS: unrecognized "
- "transport protocol\n");
kfree(string);
+ dfprintk(MOUNT, "NFS: unrecognized transport protocol\n");
return -EINVAL;
}
kfree(string);
@@ -727,8 +724,7 @@ static int nfs_sb_config_parse_option(struct nfs_sb_config *cfg, char *p)
string = match_strdup(args);
if (string == NULL)
goto out_nomem;
- token = match_token(string,
- nfs_xprt_protocol_tokens, args);
+ token = match_token(string, nfs_xprt_protocol_tokens, args);
kfree(string);
cfg->mountfamily = AF_INET;
@@ -745,8 +741,7 @@ static int nfs_sb_config_parse_option(struct nfs_sb_config *cfg, char *p)
break;
case Opt_xprt_rdma: /* not used for side protocols */
default:
- dfprintk(MOUNT, "NFS: unrecognized "
- "transport protocol\n");
+ dfprintk(MOUNT, "NFS: unrecognized transport protocol\n");
return -EINVAL;
}
break;
@@ -756,9 +751,8 @@ static int nfs_sb_config_parse_option(struct nfs_sb_config *cfg, char *p)
goto out_nomem;
cfg->nfs_server.addrlen =
rpc_pton(cfg->net, string, strlen(string),
- (struct sockaddr *)
&cfg->nfs_server.address,
- sizeof(cfg->nfs_server.address));
+ sizeof(cfg->nfs_server._address));
kfree(string);
if (cfg->nfs_server.addrlen == 0)
goto out_invalid_address;
@@ -768,8 +762,7 @@ static int nfs_sb_config_parse_option(struct nfs_sb_config *cfg, char *p)
goto out_nomem;
break;
case Opt_mounthost:
- if (nfs_get_option_str(args,
- &cfg->mount_server.hostname))
+ if (nfs_get_option_str(args, &cfg->mount_server.hostname))
goto out_nomem;
break;
case Opt_mountaddr:
@@ -778,9 +771,8 @@ static int nfs_sb_config_parse_option(struct nfs_sb_config *cfg, char *p)
goto out_nomem;
cfg->mount_server.addrlen =
rpc_pton(cfg->net, string, strlen(string),
- (struct sockaddr *)
&cfg->mount_server.address,
- sizeof(cfg->mount_server.address));
+ sizeof(cfg->mount_server._address));
kfree(string);
if (cfg->mount_server.addrlen == 0)
goto out_invalid_address;
@@ -789,8 +781,7 @@ static int nfs_sb_config_parse_option(struct nfs_sb_config *cfg, char *p)
string = match_strdup(args);
if (string == NULL)
goto out_nomem;
- token = match_token(string,
- nfs_lookupcache_tokens, args);
+ token = match_token(string, nfs_lookupcache_tokens, args);
kfree(string);
switch (token) {
case Opt_lookupcache_all:
@@ -804,10 +795,9 @@ static int nfs_sb_config_parse_option(struct nfs_sb_config *cfg, char *p)
cfg->flags |= NFS_MOUNT_LOOKUP_CACHE_NONEG|NFS_MOUNT_LOOKUP_CACHE_NONE;
break;
default:
- dfprintk(MOUNT, "NFS: invalid "
- "lookupcache argument\n");
+ dfprintk(MOUNT, "NFS: invalid lookupcache argument\n");
return -EINVAL;
- };
+ }
break;
case Opt_fscache_uniq:
if (nfs_get_option_str(args, &cfg->fscache_uniq))
@@ -818,8 +808,7 @@ static int nfs_sb_config_parse_option(struct nfs_sb_config *cfg, char *p)
string = match_strdup(args);
if (string == NULL)
goto out_nomem;
- token = match_token(string, nfs_local_lock_tokens,
- args);
+ token = match_token(string, nfs_local_lock_tokens, args);
kfree(string);
switch (token) {
case Opt_local_lock_all:
@@ -837,8 +826,7 @@ static int nfs_sb_config_parse_option(struct nfs_sb_config *cfg, char *p)
NFS_MOUNT_LOCAL_FCNTL);
break;
default:
- dfprintk(MOUNT, "NFS: invalid "
- "local_lock argument\n");
+ dfprintk(MOUNT, "NFS: invalid local_lock argument\n");
return -EINVAL;
};
break;
@@ -852,13 +840,11 @@ static int nfs_sb_config_parse_option(struct nfs_sb_config *cfg, char *p)
break;
case Opt_userspace:
case Opt_deprecated:
- dfprintk(MOUNT, "NFS: ignoring mount option "
- "'%s'\n", p);
+ dfprintk(MOUNT, "NFS: ignoring mount option '%s'\n", p);
break;
default:
- dfprintk(MOUNT, "NFS: unrecognized mount option "
- "'%s'\n", p);
+ dfprintk(MOUNT, "NFS: unrecognized mount option '%s'\n", p);
return -EINVAL;
}
@@ -928,15 +914,15 @@ int nfs_parse_mount_options(char *raw, struct nfs_sb_config *cfg)
* families in the addr=/mountaddr= options.
*/
if (cfg->protofamily != AF_UNSPEC &&
- cfg->protofamily != cfg->nfs_server.address.ss_family)
+ cfg->protofamily != cfg->nfs_server.address.sa_family)
goto out_proto_mismatch;
if (cfg->mountfamily != AF_UNSPEC) {
if (cfg->mount_server.addrlen) {
- if (cfg->mountfamily != cfg->mount_server.address.ss_family)
+ if (cfg->mountfamily != cfg->mount_server.address.sa_family)
goto out_mountproto_mismatch;
} else {
- if (cfg->mountfamily != cfg->nfs_server.address.ss_family)
+ if (cfg->mountfamily != cfg->nfs_server.address.sa_family)
goto out_mountproto_mismatch;
}
}
@@ -976,9 +962,9 @@ int nfs_parse_mount_options(char *raw, struct nfs_sb_config *cfg)
*
* Note: caller frees hostname and export path, even on error.
*/
-static int nfs_parse_devname(const char *dev_name,
- char **hostname, size_t maxnamlen,
- char **export_path, size_t maxpathlen)
+static int nfs_parse_devname(struct nfs_sb_config *cfg,
+ const char *dev_name,
+ size_t maxnamlen, size_t maxpathlen)
{
size_t len;
char *end;
@@ -1009,17 +995,17 @@ static int nfs_parse_devname(const char *dev_name,
goto out_hostname;
/* N.B. caller will free nfs_server.hostname in all cases */
- *hostname = kstrndup(dev_name, len, GFP_KERNEL);
- if (*hostname == NULL)
+ cfg->nfs_server.hostname = kmemdup_nul(dev_name, len, GFP_KERNEL);
+ if (!cfg->nfs_server.hostname)
goto out_nomem;
len = strlen(++end);
if (len > maxpathlen)
goto out_path;
- *export_path = kstrndup(end, len, GFP_KERNEL);
- if (!*export_path)
+ cfg->nfs_server.export_path = kmemdup_nul(end, len, GFP_KERNEL);
+ if (!cfg->nfs_server.export_path)
goto out_nomem;
- dfprintk(MOUNT, "NFS: MNTPATH: '%s'\n", *export_path);
+ dfprintk(MOUNT, "NFS: MNTPATH: '%s'\n", cfg->nfs_server.export_path);
return 0;
out_bad_devname:
@@ -1040,7 +1026,7 @@ static int nfs_parse_devname(const char *dev_name,
}
/*
- * Validate the NFS2/NFS3 mount data
+ * Parse monolithic NFS2/NFS3 mount data
* - fills in the mount root filehandle
*
* For option strings, user space handles the following behaviors:
@@ -1365,11 +1351,7 @@ int nfs_validate_text_mount_data(void *options,
nfs_set_port(sap, &cfg->nfs_server.port, port);
- return nfs_parse_devname(dev_name,
- &cfg->nfs_server.hostname,
- max_namelen,
- &cfg->nfs_server.export_path,
- max_pathlen);
+ return nfs_parse_devname(cfg, dev_name, max_namelen, max_pathlen);
#if !IS_ENABLED(CONFIG_NFS_V4)
out_v4_not_compiled:
diff --git a/fs/nfs/super.c b/fs/nfs/super.c
index 26c1fca31e6b..acf935a6438d 100644
--- a/fs/nfs/super.c
+++ b/fs/nfs/super.c
@@ -795,7 +795,7 @@ static int nfs_request_mount(struct nfs_sb_config *cfg,
/*
* Construct the mount server's address.
*/
- if (cfg->mount_server.address.ss_family == AF_UNSPEC) {
+ if (cfg->mount_server.address.sa_family == AF_UNSPEC) {
memcpy(request.sap, &cfg->nfs_server.address,
cfg->nfs_server.addrlen);
cfg->mount_server.addrlen = cfg->nfs_server.addrlen;
^ permalink raw reply related [flat|nested] 28+ messages in thread* [PATCH 19/21] NFS: Add mount context support. [ver #3]
2017-05-15 15:17 [RFC][PATCH 00/21] VFS: Introduce superblock configuration context [ver #3] David Howells
` (17 preceding siblings ...)
2017-05-15 15:20 ` [PATCH 18/21] NFS: Do some tidying of the parsing code " David Howells
@ 2017-05-15 15:20 ` David Howells
2017-05-15 15:20 ` [PATCH 20/21] Support legacy filesystems " David Howells
2017-05-15 15:21 ` [PATCH 21/21] Add commands to create or update a superblock " David Howells
20 siblings, 0 replies; 28+ messages in thread
From: David Howells @ 2017-05-15 15:20 UTC (permalink / raw)
To: mszeredi, viro, jlayton; +Cc: dhowells, linux-fsdevel, linux-nfs, linux-kernel
Add mount context support to NFS, parsing the options in advance and
attaching the information to the mount context. The highlights are:
(*) Define a new nfs_mount_context struct that merges together
nfs_parsed_mount_data, nfs_mount_info and nfs_clone_mount. This
structure represents NFS's mount context.
(*) Split out the mount option parsing routines from super.c into their
own mount.c. The VFS then provides a parser for when the options are
in the form of a comma separated list of key[=val] items.
(*) Provide a small buffer in the NFS mount context for copying numbers
into prior to parsing them to avoid match_strdup() calls.
(*) Pin the NFS protocol module in the mount context.
(*) Return error information in mc->error. This has the downside that
these strings must be static and can't be formatted.
(*) Remove the auxiliary file_system_type structs since the information
necessary can be conveyed in the nfs_mount_context struct instead.
(*) Root mounts are made by duplicating the context for the requested
mount so as to have the same parameters. Submounts pick up their
parameters from the parent superblock.
Signed-off-by: David Howells <dhowells@redhat.com>
---
fs/nfs/client.c | 18 +
fs/nfs/internal.h | 110 +++-----
fs/nfs/mount.c | 656 ++++++++++++++++++++++++++++-------------------
fs/nfs/namespace.c | 66 +++--
fs/nfs/nfs3_fs.h | 2
fs/nfs/nfs3client.c | 6
fs/nfs/nfs3proc.c | 1
fs/nfs/nfs4_fs.h | 4
fs/nfs/nfs4client.c | 44 ++-
fs/nfs/nfs4namespace.c | 208 +++++++++------
fs/nfs/nfs4proc.c | 1
fs/nfs/nfs4super.c | 184 ++++++-------
fs/nfs/proc.c | 1
fs/nfs/super.c | 270 +++++--------------
include/linux/nfs_xdr.h | 7 -
15 files changed, 809 insertions(+), 769 deletions(-)
diff --git a/fs/nfs/client.c b/fs/nfs/client.c
index 5701f5122a64..acaab9ca0243 100644
--- a/fs/nfs/client.c
+++ b/fs/nfs/client.c
@@ -635,17 +635,16 @@ EXPORT_SYMBOL_GPL(nfs_init_client);
* Create a version 2 or 3 client
*/
static int nfs_init_server(struct nfs_server *server,
- const struct nfs_sb_config *cfg,
- struct nfs_subversion *nfs_mod)
+ const struct nfs_sb_config *cfg)
{
struct rpc_timeout timeparms;
struct nfs_client_initdata cl_init = {
.hostname = cfg->nfs_server.hostname,
.addr = (const struct sockaddr *)&cfg->nfs_server.address,
.addrlen = cfg->nfs_server.addrlen,
- .nfs_mod = nfs_mod,
+ .nfs_mod = cfg->nfs_mod,
.proto = cfg->nfs_server.protocol,
- .net = cfg->net,
+ .net = cfg->sc.net_ns,
.timeparms = &timeparms,
};
struct nfs_client *clp;
@@ -921,8 +920,7 @@ EXPORT_SYMBOL_GPL(nfs_free_server);
* Create a version 2 or 3 volume record
* - keyed on server and FSID
*/
-struct nfs_server *nfs_create_server(struct nfs_mount_info *mount_info,
- struct nfs_subversion *nfs_mod)
+struct nfs_server *nfs_create_server(struct nfs_sb_config *cfg)
{
struct nfs_server *server;
struct nfs_fattr *fattr;
@@ -938,18 +936,18 @@ struct nfs_server *nfs_create_server(struct nfs_mount_info *mount_info,
goto error;
/* Get a client representation */
- error = nfs_init_server(server, mount_info->cfg, nfs_mod);
+ error = nfs_init_server(server, cfg);
if (error < 0)
goto error;
/* Probe the root fh to retrieve its FSID */
- error = nfs_probe_fsinfo(server, mount_info->mntfh, fattr);
+ error = nfs_probe_fsinfo(server, cfg->mntfh, fattr);
if (error < 0)
goto error;
if (server->nfs_client->rpc_ops->version == 3) {
if (server->namelen == 0 || server->namelen > NFS3_MAXNAMLEN)
server->namelen = NFS3_MAXNAMLEN;
- if (!(mount_info->cfg->flags & NFS_MOUNT_NORDIRPLUS))
+ if (!(cfg->flags & NFS_MOUNT_NORDIRPLUS))
server->caps |= NFS_CAP_READDIRPLUS;
} else {
if (server->namelen == 0 || server->namelen > NFS2_MAXNAMLEN)
@@ -957,7 +955,7 @@ struct nfs_server *nfs_create_server(struct nfs_mount_info *mount_info,
}
if (!(fattr->valid & NFS_ATTR_FATTR)) {
- error = nfs_mod->rpc_ops->getattr(server, mount_info->mntfh, fattr, NULL);
+ error = cfg->nfs_mod->rpc_ops->getattr(server, cfg->mntfh, fattr, NULL);
if (error < 0) {
dprintk("nfs_create_server: getattr error = %d\n", -error);
goto error;
diff --git a/fs/nfs/internal.h b/fs/nfs/internal.h
index 79e77ff2061c..b9231c6359f2 100644
--- a/fs/nfs/internal.h
+++ b/fs/nfs/internal.h
@@ -3,7 +3,7 @@
*/
#include "nfs4_fs.h"
-#include <linux/mount.h>
+#include <linux/sb_config.h>
#include <linux/security.h>
#include <linux/crc32.h>
#include <linux/sunrpc/addr.h>
@@ -36,18 +36,6 @@ static inline int nfs_attr_use_mounted_on_fileid(struct nfs_fattr *fattr)
return 1;
}
-struct nfs_clone_mount {
- const struct super_block *sb;
- const struct dentry *dentry;
- struct nfs_fh *fh;
- struct nfs_fattr *fattr;
- char *hostname;
- char *mnt_path;
- struct sockaddr *addr;
- size_t addrlen;
- rpc_authflavor_t authflavor;
-};
-
/*
* Note: RFC 1813 doesn't limit the number of auth flavors that
* a server can return, so make something up.
@@ -82,10 +70,22 @@ struct nfs_client_initdata {
const struct rpc_timeout *timeparms;
};
+enum nfs_mount_type {
+ NFS_MOUNT_ORDINARY,
+ NFS_MOUNT_CROSS_DEV,
+ NFS4_MOUNT_REMOTE,
+ NFS4_MOUNT_REFERRAL,
+ NFS4_MOUNT_REMOTE_REFERRAL,
+};
+
/*
* In-kernel mount arguments
*/
struct nfs_sb_config {
+ struct sb_config sc;
+ enum nfs_mount_type mount_type : 8;
+ bool skip_remount_option_check;
+ bool need_mount;
unsigned int flags; /* NFS{,4}_MOUNT_* flags */
unsigned int rsize, wsize;
unsigned int timeo, retrans;
@@ -102,8 +102,6 @@ struct nfs_sb_config {
char *fscache_uniq;
unsigned short protofamily;
unsigned short mountfamily;
- bool need_mount;
- bool sloppy;
struct {
union {
@@ -127,10 +125,22 @@ struct nfs_sb_config {
char *export_path;
int port;
unsigned short protocol;
+ unsigned short export_path_len;
} nfs_server;
- struct security_mnt_opts lsm_opts;
- struct net *net;
+ struct nfs_fh *mntfh;
+ struct nfs_subversion *nfs_mod;
+
+ int (*set_security)(struct super_block *, struct dentry *,
+ struct nfs_sb_config *);
+
+ /* Information for a cloned mount. */
+ struct nfs_clone_mount {
+ struct super_block *sb;
+ struct dentry *dentry;
+ struct nfs_fattr *fattr;
+ bool cloned;
+ } clone_data;
char buf[32]; /* Parse buffer */
};
@@ -150,17 +160,19 @@ struct nfs_mount_request {
struct net *net;
};
-struct nfs_mount_info {
- void (*fill_super)(struct super_block *, struct nfs_mount_info *);
- int (*set_security)(struct super_block *, struct dentry *, struct nfs_mount_info *);
- struct nfs_sb_config *cfg;
- struct nfs_clone_mount *cloned;
- struct nfs_fh *mntfh;
-};
-
extern int nfs_mount(struct nfs_mount_request *info);
extern void nfs_umount(const struct nfs_mount_request *info);
+static inline void nfs_cfg_error(struct nfs_sb_config *cfg, const char *msg)
+{
+ sb_cfg_error(&cfg->sc, msg);
+}
+
+static inline int nfs_cfg_inval(struct nfs_sb_config *cfg, const char *msg)
+{
+ return sb_cfg_inval(&cfg->sc, msg);
+}
+
/* client.c */
extern const struct rpc_program nfs_program;
extern void nfs_clients_init(struct net *net);
@@ -183,13 +195,9 @@ extern struct nfs_client *nfs4_find_client_ident(struct net *, int);
extern struct nfs_client *
nfs4_find_client_sessionid(struct net *, const struct sockaddr *,
struct nfs4_sessionid *, u32);
-extern struct nfs_server *nfs_create_server(struct nfs_mount_info *,
- struct nfs_subversion *);
-extern struct nfs_server *nfs4_create_server(
- struct nfs_mount_info *,
- struct nfs_subversion *);
-extern struct nfs_server *nfs4_create_referral_server(struct nfs_clone_mount *,
- struct nfs_fh *);
+extern struct nfs_server *nfs_create_server(struct nfs_sb_config *);
+extern struct nfs_server *nfs4_create_server(struct nfs_sb_config *);
+extern struct nfs_server *nfs4_create_referral_server(struct nfs_sb_config *);
extern int nfs4_update_server(struct nfs_server *server, const char *hostname,
struct sockaddr *sap, size_t salen,
struct net *net);
@@ -243,19 +251,8 @@ extern struct svc_version nfs4_callback_version4;
struct nfs_pageio_descriptor;
/* mount.c */
-#define NFS_TEXT_DATA 1
-
-extern struct nfs_sb_config *nfs_alloc_parsed_mount_data(void);
-extern void nfs_free_parsed_mount_data(struct nfs_sb_config *cfg);
-extern int nfs_parse_mount_options(char *raw, struct nfs_sb_config *cfg);
-extern int nfs_validate_mount_data(struct file_system_type *fs_type,
- void *options,
- struct nfs_sb_config *cfg,
- struct nfs_fh *mntfh,
- const char *dev_name);
-extern int nfs_validate_text_mount_data(void *options,
- struct nfs_sb_config *cfg,
- const char *dev_name);
+extern const char nfs_slash[];
+extern struct dentry *nfs_general_mount(struct nfs_sb_config *ctx);
/* pagelist.c */
extern int __init nfs_init_nfspagecache(void);
@@ -418,24 +415,12 @@ extern int nfs_wait_atomic_killable(atomic_t *p);
/* super.c */
extern const struct super_operations nfs_sops;
extern struct file_system_type nfs_fs_type;
-extern struct file_system_type nfs_xdev_fs_type;
-#if IS_ENABLED(CONFIG_NFS_V4)
-extern struct file_system_type nfs4_xdev_fs_type;
-extern struct file_system_type nfs4_referral_fs_type;
-#endif
bool nfs_auth_info_match(const struct nfs_auth_info *, rpc_authflavor_t);
-struct dentry *nfs_try_mount(int, const char *, struct nfs_mount_info *,
- struct nfs_subversion *);
-void nfs_initialise_sb(struct super_block *);
-int nfs_set_sb_security(struct super_block *, struct dentry *, struct nfs_mount_info *);
-int nfs_clone_sb_security(struct super_block *, struct dentry *, struct nfs_mount_info *);
-struct dentry *nfs_fs_mount_common(struct nfs_server *, int, const char *,
- struct nfs_mount_info *, struct nfs_subversion *);
-struct dentry *nfs_fs_mount(struct file_system_type *, int, const char *, void *);
-struct dentry * nfs_xdev_mount_common(struct file_system_type *, int,
- const char *, struct nfs_mount_info *);
+struct dentry *nfs_try_mount(struct nfs_sb_config *);
+int nfs_set_sb_security(struct super_block *, struct dentry *, struct nfs_sb_config *);
+int nfs_clone_sb_security(struct super_block *, struct dentry *, struct nfs_sb_config *);
+struct dentry *nfs_fs_mount_common(struct nfs_server *, struct nfs_sb_config *);
void nfs_kill_super(struct super_block *);
-void nfs_fill_super(struct super_block *, struct nfs_mount_info *);
extern struct rpc_stat nfs_rpcstat;
@@ -486,14 +471,13 @@ extern void nfs_read_prepare(struct rpc_task *task, void *calldata);
extern void nfs_pageio_reset_read_mds(struct nfs_pageio_descriptor *pgio);
/* super.c */
-void nfs_clone_super(struct super_block *, struct nfs_mount_info *);
void nfs_umount_begin(struct super_block *);
int nfs_statfs(struct dentry *, struct kstatfs *);
int nfs_show_options(struct seq_file *, struct dentry *);
int nfs_show_devname(struct seq_file *, struct dentry *);
int nfs_show_path(struct seq_file *, struct dentry *);
int nfs_show_stats(struct seq_file *, struct dentry *);
-int nfs_remount(struct super_block *sb, int *flags, char *raw_data);
+int nfs_remount(struct super_block *sb, struct sb_config *sc);
/* write.c */
extern void nfs_pageio_init_write(struct nfs_pageio_descriptor *pgio,
diff --git a/fs/nfs/mount.c b/fs/nfs/mount.c
index e0c3381ad5c5..188ee4b324d9 100644
--- a/fs/nfs/mount.c
+++ b/fs/nfs/mount.c
@@ -240,42 +240,8 @@ static const match_table_t nfs_vers_tokens = {
{ Opt_vers_err, NULL }
};
-struct nfs_sb_config *nfs_alloc_parsed_mount_data(void)
-{
- struct nfs_sb_config *cfg;
-
- cfg = kzalloc(sizeof(*cfg), GFP_KERNEL);
- if (cfg) {
- cfg->timeo = NFS_UNSPEC_TIMEO;
- cfg->retrans = NFS_UNSPEC_RETRANS;
- cfg->acregmin = NFS_DEF_ACREGMIN;
- cfg->acregmax = NFS_DEF_ACREGMAX;
- cfg->acdirmin = NFS_DEF_ACDIRMIN;
- cfg->acdirmax = NFS_DEF_ACDIRMAX;
- cfg->mount_server.port = NFS_UNSPEC_PORT;
- cfg->nfs_server.port = NFS_UNSPEC_PORT;
- cfg->nfs_server.protocol = XPRT_TRANSPORT_TCP;
- cfg->selected_flavor = RPC_AUTH_MAXFLAVOR;
- cfg->minorversion = 0;
- cfg->need_mount = true;
- cfg->net = current->nsproxy->net_ns;
- security_init_mnt_opts(&cfg->lsm_opts);
- }
- return cfg;
-}
-
-void nfs_free_parsed_mount_data(struct nfs_sb_config *cfg)
-{
- if (cfg) {
- kfree(cfg->client_address);
- kfree(cfg->mount_server.hostname);
- kfree(cfg->nfs_server.export_path);
- kfree(cfg->nfs_server.hostname);
- kfree(cfg->fscache_uniq);
- security_free_mnt_opts(&cfg->lsm_opts);
- kfree(cfg);
- }
-}
+const char nfs_slash[] = "/";
+EXPORT_SYMBOL_GPL(nfs_slash);
/*
* Sanity-check a server address provided by the mount command.
@@ -354,10 +320,8 @@ static int nfs_auth_info_add(struct nfs_sb_config *cfg,
return 0;
}
- if (auth_info->flavor_len + 1 >= max_flavor_len) {
- dfprintk(MOUNT, "NFS: too many sec= flavors\n");
- return -EINVAL;
- }
+ if (auth_info->flavor_len + 1 >= max_flavor_len)
+ return nfs_cfg_inval(cfg, "NFS: too many sec= flavors");
auth_info->flavors[auth_info->flavor_len++] = flavor;
return 0;
@@ -411,9 +375,7 @@ static int nfs_parse_security_flavors(struct nfs_sb_config *cfg, char *value)
pseudoflavor = RPC_AUTH_GSS_SPKMP;
break;
default:
- dfprintk(MOUNT,
- "NFS: sec= option '%s' not recognized\n", p);
- return -EINVAL;
+ return nfs_cfg_inval(cfg, "NFS: sec= option not recognized");
}
ret = nfs_auth_info_add(cfg, &cfg->auth_info, pseudoflavor);
@@ -457,8 +419,7 @@ static int nfs_parse_version_string(struct nfs_sb_config *cfg,
cfg->minorversion = 2;
break;
default:
- dfprintk(MOUNT, "NFS: Unsupported NFS version\n");
- return -EINVAL;
+ return nfs_cfg_inval(cfg, "NFS: Unsupported NFS version");
}
return 0;
}
@@ -495,8 +456,9 @@ static int nfs_get_option_ui_bound(struct nfs_sb_config *cfg,
/*
* Parse a single mount option in "key[=val]" form.
*/
-static int nfs_sb_config_parse_option(struct nfs_sb_config *cfg, char *p)
+static int nfs_sb_config_parse_option(struct sb_config *sc, char *p)
{
+ struct nfs_sb_config *cfg = container_of(sc, struct nfs_sb_config, sc);
substring_t args[MAX_OPT_ARGS];
char *string;
int ret, token;
@@ -715,8 +677,7 @@ static int nfs_sb_config_parse_option(struct nfs_sb_config *cfg, char *p)
break;
default:
kfree(string);
- dfprintk(MOUNT, "NFS: unrecognized transport protocol\n");
- return -EINVAL;
+ return nfs_cfg_inval(cfg, "NFS: Unrecognized transport protocol");
}
kfree(string);
break;
@@ -741,8 +702,7 @@ static int nfs_sb_config_parse_option(struct nfs_sb_config *cfg, char *p)
break;
case Opt_xprt_rdma: /* not used for side protocols */
default:
- dfprintk(MOUNT, "NFS: unrecognized transport protocol\n");
- return -EINVAL;
+ return nfs_cfg_inval(cfg, "NFS: Unrecognized transport protocol");
}
break;
case Opt_addr:
@@ -750,7 +710,7 @@ static int nfs_sb_config_parse_option(struct nfs_sb_config *cfg, char *p)
if (string == NULL)
goto out_nomem;
cfg->nfs_server.addrlen =
- rpc_pton(cfg->net, string, strlen(string),
+ rpc_pton(sc->net_ns, string, strlen(string),
&cfg->nfs_server.address,
sizeof(cfg->nfs_server._address));
kfree(string);
@@ -770,7 +730,7 @@ static int nfs_sb_config_parse_option(struct nfs_sb_config *cfg, char *p)
if (string == NULL)
goto out_nomem;
cfg->mount_server.addrlen =
- rpc_pton(cfg->net, string, strlen(string),
+ rpc_pton(sc->net_ns, string, strlen(string),
&cfg->mount_server.address,
sizeof(cfg->mount_server._address));
kfree(string);
@@ -795,8 +755,7 @@ static int nfs_sb_config_parse_option(struct nfs_sb_config *cfg, char *p)
cfg->flags |= NFS_MOUNT_LOOKUP_CACHE_NONEG|NFS_MOUNT_LOOKUP_CACHE_NONE;
break;
default:
- dfprintk(MOUNT, "NFS: invalid lookupcache argument\n");
- return -EINVAL;
+ return nfs_cfg_inval(cfg, "NFS: Invalid lookupcache argument");
}
break;
case Opt_fscache_uniq:
@@ -826,16 +785,15 @@ static int nfs_sb_config_parse_option(struct nfs_sb_config *cfg, char *p)
NFS_MOUNT_LOCAL_FCNTL);
break;
default:
- dfprintk(MOUNT, "NFS: invalid local_lock argument\n");
- return -EINVAL;
- };
+ return nfs_cfg_inval(cfg, "NFS: invalid local_lock argument");
+ }
break;
/*
* Special options
*/
case Opt_sloppy:
- cfg->sloppy = 1;
+ sc->sloppy = 1;
dfprintk(MOUNT, "NFS: relaxing parsing rules\n");
break;
case Opt_userspace:
@@ -845,116 +803,24 @@ static int nfs_sb_config_parse_option(struct nfs_sb_config *cfg, char *p)
default:
dfprintk(MOUNT, "NFS: unrecognized mount option '%s'\n", p);
- return -EINVAL;
+ if (!sc->sloppy)
+ return nfs_cfg_inval(cfg, "NFS: Unrecognized mount option");
+ break;
}
return 0;
-out_invalid_address:
- printk(KERN_INFO "NFS: bad IP address specified: %s\n", p);
- return -EINVAL;
-out_invalid_value:
- printk(KERN_INFO "NFS: bad mount option value specified: %s\n", p);
- return -EINVAL;
out_nomem:
printk(KERN_INFO "NFS: not enough memory to parse option\n");
return -ENOMEM;
+out_invalid_value:
+ return nfs_cfg_inval(cfg, "NFS: Bad mount option value specified");
+out_invalid_address:
+ return nfs_cfg_inval(cfg, "NFS: Bad IP address specified");
}
/*
- * Error-check and convert a string of mount options from user space into
- * a data structure. The whole mount string is processed; bad options are
- * skipped as they are encountered. If there were no errors, return 1;
- * otherwise return 0 (zero).
- */
-int nfs_parse_mount_options(char *raw, struct nfs_sb_config *cfg)
-{
- char *p, *secdata;
- int rc, sloppy = 0, invalid_option = 0;
-
- if (!raw) {
- dfprintk(MOUNT, "NFS: mount options string was NULL.\n");
- return 1;
- }
- dfprintk(MOUNT, "NFS: nfs mount opts='%s'\n", raw);
-
- secdata = alloc_secdata();
- if (!secdata)
- goto out_nomem;
-
- rc = security_sb_copy_data(raw, secdata);
- if (rc)
- goto out_security_failure;
-
- rc = security_sb_parse_opts_str(secdata, &cfg->lsm_opts);
- if (rc)
- goto out_security_failure;
-
- free_secdata(secdata);
-
- while ((p = strsep(&raw, ",")) != NULL) {
- if (!*p)
- continue;
- if (nfs_sb_config_parse_option(cfg, p) < 0)
- invalid_option = true;
- }
-
- if (!sloppy && invalid_option)
- return 0;
-
- if (cfg->minorversion && cfg->version != 4)
- goto out_minorversion_mismatch;
-
- if (cfg->options & NFS_OPTION_MIGRATION &&
- (cfg->version != 4 || cfg->minorversion != 0))
- goto out_migration_misuse;
-
- /*
- * verify that any proto=/mountproto= options match the address
- * families in the addr=/mountaddr= options.
- */
- if (cfg->protofamily != AF_UNSPEC &&
- cfg->protofamily != cfg->nfs_server.address.sa_family)
- goto out_proto_mismatch;
-
- if (cfg->mountfamily != AF_UNSPEC) {
- if (cfg->mount_server.addrlen) {
- if (cfg->mountfamily != cfg->mount_server.address.sa_family)
- goto out_mountproto_mismatch;
- } else {
- if (cfg->mountfamily != cfg->nfs_server.address.sa_family)
- goto out_mountproto_mismatch;
- }
- }
-
- return 1;
-
-out_minorversion_mismatch:
- printk(KERN_INFO "NFS: mount option vers=%u does not support "
- "minorversion=%u\n", cfg->version, cfg->minorversion);
- return 0;
-out_mountproto_mismatch:
- printk(KERN_INFO "NFS: mount server address does not match mountproto= "
- "option\n");
- return 0;
-out_proto_mismatch:
- printk(KERN_INFO "NFS: server address does not match proto= option\n");
- return 0;
-out_migration_misuse:
- printk(KERN_INFO
- "NFS: 'migration' not supported for this NFS version\n");
- return -EINVAL;
-out_nomem:
- printk(KERN_INFO "NFS: not enough memory to parse option\n");
- return 0;
-out_security_failure:
- free_secdata(secdata);
- printk(KERN_INFO "NFS: security options invalid: %d\n", rc);
- return 0;
-}
-
-/*
- * Split "dev_name" into "hostname:export_path".
+ * Split sc->device into "hostname:export_path".
*
* The leftmost colon demarks the split between the server's hostname
* and the export path. If the hostname starts with a left square
@@ -963,9 +829,9 @@ int nfs_parse_mount_options(char *raw, struct nfs_sb_config *cfg)
* Note: caller frees hostname and export path, even on error.
*/
static int nfs_parse_devname(struct nfs_sb_config *cfg,
- const char *dev_name,
size_t maxnamlen, size_t maxpathlen)
{
+ char *dev_name = cfg->sc.device;
size_t len;
char *end;
@@ -1009,19 +875,15 @@ static int nfs_parse_devname(struct nfs_sb_config *cfg,
return 0;
out_bad_devname:
- dfprintk(MOUNT, "NFS: device name not in host:path format\n");
- return -EINVAL;
-
+ return nfs_cfg_inval(cfg, "NFS: device name not in host:path format");
out_nomem:
- dfprintk(MOUNT, "NFS: not enough memory to parse device name\n");
+ nfs_cfg_error(cfg, "NFS: not enough memory to parse device name");
return -ENOMEM;
-
out_hostname:
- dfprintk(MOUNT, "NFS: server hostname too long\n");
+ nfs_cfg_error(cfg, "NFS: server hostname too long");
return -ENAMETOOLONG;
-
out_path:
- dfprintk(MOUNT, "NFS: export pathname too long\n");
+ nfs_cfg_error(cfg, "NFS: export pathname too long");
return -ENAMETOOLONG;
}
@@ -1041,14 +903,14 @@ static int nfs_parse_devname(struct nfs_sb_config *cfg,
* + breaking back: trying proto=udp after proto=tcp, v2 after v3,
* mountproto=tcp after mountproto=udp, and so on
*/
-static int nfs23_validate_mount_data(void *options,
- struct nfs_sb_config *cfg,
- struct nfs_fh *mntfh,
- const char *dev_name)
+static int nfs23_monolithic_mount_data(struct sb_config *sc,
+ struct nfs_mount_data *data)
{
- struct nfs_mount_data *data = (struct nfs_mount_data *)options;
+ struct nfs_sb_config *cfg = container_of(sc, struct nfs_sb_config, sc);
+ struct nfs_fh *mntfh = cfg->mntfh;
struct sockaddr *sap = (struct sockaddr *)&cfg->nfs_server.address;
int extra_flags = NFS_MOUNT_LEGACY_INTERFACE;
+ int ret;
if (data == NULL)
goto out_no_data;
@@ -1114,6 +976,9 @@ static int nfs23_validate_mount_data(void *options,
cfg->nfs_server.protocol = XPRT_TRANSPORT_UDP;
/* N.B. caller will free nfs_server.hostname in all cases */
cfg->nfs_server.hostname = kstrdup(data->hostname, GFP_KERNEL);
+ if (!cfg->nfs_server.hostname)
+ goto out_nomem;
+
cfg->namlen = data->namlen;
cfg->bsize = data->bsize;
@@ -1121,8 +986,6 @@ static int nfs23_validate_mount_data(void *options,
cfg->selected_flavor = data->pseudoflavor;
else
cfg->selected_flavor = RPC_AUTH_UNIX;
- if (!cfg->nfs_server.hostname)
- goto out_nomem;
if (!(data->flags & NFS_MOUNT_NONLM))
cfg->flags &= ~(NFS_MOUNT_LOCAL_FLOCK|
@@ -1130,6 +993,7 @@ static int nfs23_validate_mount_data(void *options,
else
cfg->flags |= (NFS_MOUNT_LOCAL_FLOCK|
NFS_MOUNT_LOCAL_FCNTL);
+
/*
* The legacy version 6 binary mount data from userspace has a
* field used only to transport selinux information into the
@@ -1140,17 +1004,16 @@ static int nfs23_validate_mount_data(void *options,
*/
if (data->context[0]){
#ifdef CONFIG_SECURITY_SELINUX
- int rc;
char *opts_str = kmalloc(sizeof(data->context) + 8, GFP_KERNEL);
if (!opts_str)
return -ENOMEM;
strcpy(opts_str, "context=");
data->context[NFS_MAX_CONTEXT_LEN] = '\0';
strcat(opts_str, &data->context[0]);
- rc = security_sb_parse_opts_str(opts_str, &cfg->lsm_opts);
+ ret = vfs_parse_mount_option(sc, opts_str);
kfree(opts_str);
- if (rc)
- return rc;
+ if (ret)
+ return ret;
#else
return -EINVAL;
#endif
@@ -1158,54 +1021,44 @@ static int nfs23_validate_mount_data(void *options,
break;
default:
- return NFS_TEXT_DATA;
+ return generic_monolithic_mount_data(sc, data);
}
+ cfg->skip_remount_option_check = true;
return 0;
out_no_data:
- dfprintk(MOUNT, "NFS: mount program didn't pass any mount data\n");
- return -EINVAL;
+ if (sc->ms_flags & MS_REMOUNT) {
+ cfg->skip_remount_option_check = true;
+ return 0;
+ }
+ return nfs_cfg_inval(cfg, "NFS: mount program didn't pass any mount data");
out_no_v3:
- dfprintk(MOUNT, "NFS: nfs_mount_data version %d does not support v3\n",
- data->version);
- return -EINVAL;
+ return nfs_cfg_inval(cfg, "NFS: nfs_mount_data version does not support v3");
out_no_sec:
- dfprintk(MOUNT, "NFS: nfs_mount_data version supports only AUTH_SYS\n");
- return -EINVAL;
+ return nfs_cfg_inval(cfg, "NFS: nfs_mount_data version supports only AUTH_SYS");
out_nomem:
- dfprintk(MOUNT, "NFS: not enough memory to handle mount options\n");
+ dfprintk(MOUNT, "NFS: not enough memory to handle mount options");
return -ENOMEM;
out_no_address:
- dfprintk(MOUNT, "NFS: mount program didn't pass remote address\n");
- return -EINVAL;
+ return nfs_cfg_inval(cfg, "NFS: mount program didn't pass remote address");
out_invalid_fh:
- dfprintk(MOUNT, "NFS: invalid root filehandle\n");
- return -EINVAL;
-}
-
-#if IS_ENABLED(CONFIG_NFS_V4)
-
-static void nfs4_validate_mount_flags(struct nfs_sb_config *cfg)
-{
- cfg->flags &= ~(NFS_MOUNT_NONLM|NFS_MOUNT_NOACL|NFS_MOUNT_VER3|
- NFS_MOUNT_LOCAL_FLOCK|NFS_MOUNT_LOCAL_FCNTL);
+ return nfs_cfg_inval(cfg, "NFS: invalid root filehandle");
}
/*
* Validate NFSv4 mount options
*/
-static int nfs4_validate_mount_data(void *options,
- struct nfs_sb_config *cfg,
- const char *dev_name)
+static int nfs4_monolithic_mount_data(struct sb_config *sc,
+ struct nfs4_mount_data *data)
{
+ struct nfs_sb_config *cfg = container_of(sc, struct nfs_sb_config, sc);
struct sockaddr *sap = (struct sockaddr *)&cfg->nfs_server.address;
- struct nfs4_mount_data *data = (struct nfs4_mount_data *)options;
char *c;
if (data == NULL)
@@ -1255,7 +1108,7 @@ static int nfs4_validate_mount_data(void *options,
cfg->client_address = c;
/*
- * Translate to nfs_sb_config, which nfs4_fill_super
+ * Translate to nfs_sb_config, which nfs_fill_super
* can deal with.
*/
@@ -1275,95 +1128,376 @@ static int nfs4_validate_mount_data(void *options,
break;
default:
- return NFS_TEXT_DATA;
+ return generic_monolithic_mount_data(sc, data);
}
+ cfg->skip_remount_option_check = true;
return 0;
out_no_data:
- dfprintk(MOUNT, "NFS4: mount program didn't pass any mount data\n");
- return -EINVAL;
+ if (sc->ms_flags & MS_REMOUNT) {
+ cfg->skip_remount_option_check = true;
+ return 0;
+ }
+ return nfs_cfg_inval(cfg, "NFS4: mount program didn't pass any mount data");
out_inval_auth:
- dfprintk(MOUNT, "NFS4: Invalid number of RPC auth flavours %d\n",
- data->auth_flavourlen);
- return -EINVAL;
+ return nfs_cfg_inval(cfg, "NFS4: Invalid number of RPC auth flavours");
out_no_address:
- dfprintk(MOUNT, "NFS4: mount program didn't pass remote address\n");
- return -EINVAL;
+ return nfs_cfg_inval(cfg, "NFS4: mount program didn't pass remote address");
out_invalid_transport_udp:
- dfprintk(MOUNT, "NFSv4: Unsupported transport protocol udp\n");
- return -EINVAL;
+ return nfs_cfg_inval(cfg, "NFSv4: Unsupported transport protocol udp");
}
-int nfs_validate_mount_data(struct file_system_type *fs_type,
- void *options,
- struct nfs_sb_config *cfg,
- struct nfs_fh *mntfh,
- const char *dev_name)
-{
- if (fs_type == &nfs_fs_type)
- return nfs23_validate_mount_data(options, cfg, mntfh, dev_name);
- return nfs4_validate_mount_data(options, cfg, dev_name);
-}
-#else
-static int nfs_validate_mount_data(struct file_system_type *fs_type,
- void *options,
- struct nfs_sb_config *cfg,
- struct nfs_fh *mntfh,
- const char *dev_name)
+/*
+ * Parse a monolithic block of data from sys_mount().
+ */
+static int nfs_monolithic_mount_data(struct sb_config *sc, void *data)
{
- return nfs23_validate_mount_data(options, cfg, mntfh, dev_name);
-}
+ struct nfs_sb_config *cfg = container_of(sc, struct nfs_sb_config, sc);
+
+ if (sc->fs_type == &nfs_fs_type)
+ return nfs23_monolithic_mount_data(sc, data);
+
+#if IS_ENABLED(CONFIG_NFS_V4)
+ if (sc->fs_type == &nfs4_fs_type)
+ return nfs4_monolithic_mount_data(sc, data);
#endif
-int nfs_validate_text_mount_data(void *options,
- struct nfs_sb_config *cfg,
- const char *dev_name)
+ return nfs_cfg_inval(cfg, "NFS: Unsupported monolithic data version");
+}
+
+/*
+ * Validate the preparsed information in the mount context.
+ */
+static int nfs_sb_config_validate(struct sb_config *sc)
{
- int port = 0;
+ struct nfs_sb_config *cfg = container_of(sc, struct nfs_sb_config, sc);
+ struct nfs_subversion *nfs_mod;
+ struct sockaddr *sap = (struct sockaddr *)&cfg->nfs_server.address;
int max_namelen = PAGE_SIZE;
int max_pathlen = NFS_MAXPATHLEN;
- struct sockaddr *sap = (struct sockaddr *)&cfg->nfs_server.address;
+ int port = 0;
+ int ret;
+
+ if (cfg->sc.purpose == SB_CONFIG_FOR_REMOUNT)
+ return 0;
- if (nfs_parse_mount_options((char *)options, cfg) == 0)
- return -EINVAL;
+ if (!cfg->sc.device)
+ goto out_no_device_name;
+
+ /* Check for sanity first. */
+ if (cfg->minorversion && cfg->version != 4)
+ goto out_minorversion_mismatch;
+
+ if (cfg->options & NFS_OPTION_MIGRATION &&
+ (cfg->version != 4 || cfg->minorversion != 0))
+ goto out_migration_misuse;
+
+ /* Verify that any proto=/mountproto= options match the address
+ * families in the addr=/mountaddr= options.
+ */
+ if (cfg->protofamily != AF_UNSPEC &&
+ cfg->protofamily != cfg->nfs_server.address.sa_family)
+ goto out_proto_mismatch;
+
+ if (cfg->mountfamily != AF_UNSPEC) {
+ if (cfg->mount_server.addrlen) {
+ if (cfg->mountfamily != cfg->mount_server.address.sa_family)
+ goto out_mountproto_mismatch;
+ } else {
+ if (cfg->mountfamily != cfg->nfs_server.address.sa_family)
+ goto out_mountproto_mismatch;
+ }
+ }
if (!nfs_verify_server_address(sap))
goto out_no_address;
if (cfg->version == 4) {
-#if IS_ENABLED(CONFIG_NFS_V4)
- port = NFS_PORT;
- max_namelen = NFS4_MAXNAMLEN;
- max_pathlen = NFS4_MAXPATHLEN;
- nfs_validate_transport_protocol(cfg);
- if (cfg->nfs_server.protocol == XPRT_TRANSPORT_UDP)
- goto out_invalid_transport_udp;
- nfs4_validate_mount_flags(cfg);
-#else
- goto out_v4_not_compiled;
-#endif /* CONFIG_NFS_V4 */
- } else
+ if (IS_ENABLED(CONFIG_NFS_V4)) {
+ port = NFS_PORT;
+ max_namelen = NFS4_MAXNAMLEN;
+ max_pathlen = NFS4_MAXPATHLEN;
+ nfs_validate_transport_protocol(cfg);
+ if (cfg->nfs_server.protocol == XPRT_TRANSPORT_UDP)
+ goto out_invalid_transport_udp;
+ cfg->flags &= ~(NFS_MOUNT_NONLM | NFS_MOUNT_NOACL |
+ NFS_MOUNT_VER3 | NFS_MOUNT_LOCAL_FLOCK |
+ NFS_MOUNT_LOCAL_FCNTL);
+ } else {
+ goto out_v4_not_compiled;
+ }
+ } else {
nfs_set_mount_transport_protocol(cfg);
+ }
nfs_set_port(sap, &cfg->nfs_server.port, port);
- return nfs_parse_devname(cfg, dev_name, max_namelen, max_pathlen);
+ ret = nfs_parse_devname(cfg, max_namelen, max_pathlen);
+ if (ret < 0)
+ return ret;
+
+ /* Load the NFS protocol module if we haven't done so yet */
+ if (!cfg->nfs_mod) {
+ nfs_mod = get_nfs_version(cfg->version);
+ if (IS_ERR(nfs_mod)) {
+ ret = PTR_ERR(nfs_mod);
+ goto out_version_unavailable;
+ }
+ cfg->nfs_mod = nfs_mod;
+ }
+ return 0;
-#if !IS_ENABLED(CONFIG_NFS_V4)
+out_no_device_name:
+ return nfs_cfg_inval(cfg, "NFS: Device name not specified");
out_v4_not_compiled:
- dfprintk(MOUNT, "NFS: NFSv4 is not compiled into kernel\n");
+ nfs_cfg_error(cfg, "NFS: NFSv4 is not compiled into kernel");
return -EPROTONOSUPPORT;
-#else
out_invalid_transport_udp:
- dfprintk(MOUNT, "NFSv4: Unsupported transport protocol udp\n");
- return -EINVAL;
-#endif /* !CONFIG_NFS_V4 */
-
+ return nfs_cfg_inval(cfg, "NFSv4: Unsupported transport protocol udp");
out_no_address:
- dfprintk(MOUNT, "NFS: mount program didn't pass remote address\n");
- return -EINVAL;
+ return nfs_cfg_inval(cfg, "NFS: mount program didn't pass remote address");
+out_mountproto_mismatch:
+ return nfs_cfg_inval(cfg, "NFS: Mount server address does not match mountproto= option");
+out_proto_mismatch:
+ return nfs_cfg_inval(cfg, "NFS: Server address does not match proto= option");
+out_minorversion_mismatch:
+ return nfs_cfg_inval(cfg, "NFS: Mount option does not support minorversion");
+out_migration_misuse:
+ return nfs_cfg_inval(cfg, "NFS: 'Migration' not supported for this NFS version");
+out_version_unavailable:
+ nfs_cfg_inval(cfg, "NFS: Version unavailable");
+ return ret;
+}
+
+/*
+ * Use the preparsed information in the mount context to effect a mount.
+ */
+static struct dentry *nfs_ordinary_mount(struct nfs_sb_config *cfg)
+{
+ cfg->set_security = nfs_set_sb_security;
+
+ return cfg->nfs_mod->rpc_ops->try_mount(cfg);
+}
+
+/*
+ * Clone an NFS2/3/4 server record on xdev traversal (FSID-change)
+ */
+static struct dentry *nfs_xdev_mount(struct nfs_sb_config *cfg)
+{
+ struct nfs_server *server;
+ struct dentry *mntroot = ERR_PTR(-ENOMEM);
+
+ dprintk("--> nfs_xdev_mount()\n");
+
+ cfg->set_security = nfs_clone_sb_security;
+
+ /* create a new volume representation */
+ server = cfg->nfs_mod->rpc_ops->clone_server(NFS_SB(cfg->clone_data.sb),
+ cfg->mntfh,
+ cfg->clone_data.fattr,
+ cfg->selected_flavor);
+
+ if (IS_ERR(server))
+ mntroot = ERR_CAST(server);
+ else
+ mntroot = nfs_fs_mount_common(server, cfg);
+
+ dprintk("<-- nfs_xdev_mount() = %ld\n",
+ IS_ERR(mntroot) ? PTR_ERR(mntroot) : 0L);
+ return mntroot;
+}
+
+/*
+ * Handle ordinary mounts inspired by the user and cross-FSID mounts.
+ */
+struct dentry *nfs_general_mount(struct nfs_sb_config *cfg)
+{
+ switch (cfg->mount_type) {
+ case NFS_MOUNT_ORDINARY:
+ return nfs_ordinary_mount(cfg);
+
+ case NFS_MOUNT_CROSS_DEV:
+ return nfs_xdev_mount(cfg);
+
+ default:
+ nfs_cfg_error(cfg, "NFS: Unknown mount type");
+ return ERR_PTR(-ENOTSUPP);
+ }
+}
+EXPORT_SYMBOL_GPL(nfs_general_mount);
+
+static struct dentry *nfs_fs_mount(struct sb_config *sc)
+{
+ struct nfs_sb_config *cfg = container_of(sc, struct nfs_sb_config, sc);
+
+ if (!cfg->nfs_mod) {
+ pr_warn("Missing nfs_mod\n");
+ return ERR_PTR(-EINVAL);
+ }
+ if (!cfg->nfs_mod->rpc_ops) {
+ pr_warn("Missing rpc_ops\n");
+ return ERR_PTR(-EINVAL);
+ }
+ if (!cfg->nfs_mod->rpc_ops->mount) {
+ pr_warn("Missing mount\n");
+ return ERR_PTR(-EINVAL);
+ }
+
+ return cfg->nfs_mod->rpc_ops->mount(cfg);
+}
+
+/*
+ * Handle duplication of a mount context. The caller copied *src into *mc, but
+ * it can't deal with resource pointers in the filesystem context, so we have
+ * to do that. We need to clear pointers, copy data or get extra refs as
+ * appropriate.
+ */
+static int nfs_sb_config_dup(struct sb_config *sc, struct sb_config *src)
+{
+ struct nfs_sb_config *cfg = container_of(sc, struct nfs_sb_config, sc);
+
+ __module_get(cfg->nfs_mod->owner);
+ cfg->client_address = NULL;
+ cfg->mount_server.hostname = NULL;
+ cfg->nfs_server.export_path = NULL;
+ cfg->nfs_server.hostname = NULL;
+ cfg->fscache_uniq = NULL;
+
+ cfg->mntfh = nfs_alloc_fhandle();
+ if (!cfg->mntfh)
+ return -ENOMEM;
+ return 0;
+}
+
+static void nfs_sb_config_free(struct sb_config *sc)
+{
+ struct nfs_sb_config *cfg = container_of(sc, struct nfs_sb_config, sc);
+
+ if (cfg->nfs_mod)
+ put_nfs_version(cfg->nfs_mod);
+ kfree(cfg->client_address);
+ kfree(cfg->mount_server.hostname);
+ if (cfg->nfs_server.export_path != nfs_slash)
+ kfree(cfg->nfs_server.export_path);
+ kfree(cfg->nfs_server.hostname);
+ kfree(cfg->fscache_uniq);
+ nfs_free_fhandle(cfg->mntfh);
}
+
+static const struct sb_config_operations nfs_sb_config_ops = {
+ .free = nfs_sb_config_free,
+ .dup = nfs_sb_config_dup,
+ .parse_option = nfs_sb_config_parse_option,
+ .monolithic_mount_data = nfs_monolithic_mount_data,
+ .validate = nfs_sb_config_validate,
+ .mount = nfs_fs_mount,
+};
+
+/*
+ * Initialise a mount context from an extant superblock for remounting.
+ */
+static int nfs_mount_init_from_sb(struct sb_config *sc,
+ struct super_block *sb)
+{
+ struct nfs_sb_config *cfg = container_of(sc, struct nfs_sb_config, sc);
+ struct nfs_server *nfss = sb->s_fs_info;
+ struct net *net = nfss->nfs_client->cl_net;
+
+ cfg->flags = nfss->flags;
+ cfg->rsize = nfss->rsize;
+ cfg->wsize = nfss->wsize;
+ cfg->retrans = nfss->client->cl_timeout->to_retries;
+ cfg->selected_flavor = nfss->client->cl_auth->au_flavor;
+ cfg->acregmin = nfss->acregmin / HZ;
+ cfg->acregmax = nfss->acregmax / HZ;
+ cfg->acdirmin = nfss->acdirmin / HZ;
+ cfg->acdirmax = nfss->acdirmax / HZ;
+ cfg->timeo = 10U * nfss->client->cl_timeout->to_initval / HZ;
+ cfg->nfs_server.port = nfss->port;
+ cfg->nfs_server.addrlen = nfss->nfs_client->cl_addrlen;
+ cfg->version = nfss->nfs_client->rpc_ops->version;
+ cfg->minorversion = nfss->nfs_client->cl_minorversion;
+
+ memcpy(&cfg->nfs_server.address, &nfss->nfs_client->cl_addr,
+ cfg->nfs_server.addrlen);
+
+ if (cfg->sc.net_ns != net) {
+ put_net(cfg->sc.net_ns);
+ cfg->sc.net_ns = get_net(net);
+ }
+
+ cfg->nfs_mod = nfss->nfs_client->cl_nfs_mod;
+ if (!try_module_get(cfg->nfs_mod->owner)) {
+ cfg->nfs_mod = NULL;
+ nfs_cfg_error(cfg, "NFS: Protocol module not available");
+ return -ENOENT;
+ }
+
+ return 0;
+}
+
+/*
+ * Prepare mount context. We use the namespaces attached to the context. This
+ * may be the current process's namespaces, or it may be a container's
+ * namespaces.
+ */
+static int nfs_init_sb_config(struct sb_config *sc, struct super_block *src_sb)
+{
+ struct nfs_sb_config *cfg = container_of(sc, struct nfs_sb_config, sc);
+
+ cfg->mntfh = nfs_alloc_fhandle();
+ if (!cfg->mntfh)
+ return -ENOMEM;
+
+ cfg->sc.ops = &nfs_sb_config_ops;
+ cfg->mount_type = NFS_MOUNT_ORDINARY;
+ cfg->protofamily = AF_UNSPEC;
+ cfg->mountfamily = AF_UNSPEC;
+ cfg->mount_server.port = NFS_UNSPEC_PORT;
+
+ if (!src_sb) {
+ cfg->timeo = NFS_UNSPEC_TIMEO;
+ cfg->retrans = NFS_UNSPEC_RETRANS;
+ cfg->acregmin = NFS_DEF_ACREGMIN;
+ cfg->acregmax = NFS_DEF_ACREGMAX;
+ cfg->acdirmin = NFS_DEF_ACDIRMIN;
+ cfg->acdirmax = NFS_DEF_ACDIRMAX;
+ cfg->nfs_server.port = NFS_UNSPEC_PORT;
+ cfg->nfs_server.protocol = XPRT_TRANSPORT_TCP;
+ cfg->selected_flavor = RPC_AUTH_MAXFLAVOR;
+ cfg->minorversion = 0;
+ cfg->need_mount = true;
+ return 0;
+ }
+
+ return nfs_mount_init_from_sb(sc, src_sb);
+}
+
+struct file_system_type nfs_fs_type = {
+ .owner = THIS_MODULE,
+ .name = "nfs",
+ .init_sb_config = nfs_init_sb_config,
+ .sb_config_size = sizeof(struct nfs_sb_config),
+ .kill_sb = nfs_kill_super,
+ .fs_flags = FS_RENAME_DOES_D_MOVE|FS_BINARY_MOUNTDATA,
+};
+MODULE_ALIAS_FS("nfs");
+EXPORT_SYMBOL_GPL(nfs_fs_type);
+
+#if IS_ENABLED(CONFIG_NFS_V4)
+struct file_system_type nfs4_fs_type = {
+ .owner = THIS_MODULE,
+ .name = "nfs4",
+ .sb_config_size = sizeof(struct nfs_sb_config),
+ .init_sb_config = nfs_init_sb_config,
+ .kill_sb = nfs_kill_super,
+ .fs_flags = FS_RENAME_DOES_D_MOVE|FS_BINARY_MOUNTDATA,
+};
+MODULE_ALIAS_FS("nfs4");
+MODULE_ALIAS("nfs4");
+EXPORT_SYMBOL_GPL(nfs4_fs_type);
+#endif /* CONFIG_NFS_V4 */
diff --git a/fs/nfs/namespace.c b/fs/nfs/namespace.c
index 1a224a33a6c2..7f8775bd28a8 100644
--- a/fs/nfs/namespace.c
+++ b/fs/nfs/namespace.c
@@ -18,6 +18,7 @@
#include <linux/vfs.h>
#include <linux/sunrpc/gss_api.h>
#include "internal.h"
+#include "nfs.h"
#define NFSDBG_FACILITY NFSDBG_VFS
@@ -213,10 +214,9 @@ void nfs_release_automount_timer(void)
* Clone a mountpoint of the appropriate type
*/
static struct vfsmount *nfs_do_clone_mount(struct nfs_server *server,
- const char *devname,
- struct nfs_clone_mount *mountdata)
+ struct nfs_sb_config *cfg)
{
- return vfs_submount(mountdata->dentry, &nfs_xdev_fs_type, devname, mountdata);
+ return vfs_submount_sc(cfg->clone_data.dentry, &cfg->sc);
}
/**
@@ -230,27 +230,53 @@ static struct vfsmount *nfs_do_clone_mount(struct nfs_server *server,
struct vfsmount *nfs_do_submount(struct dentry *dentry, struct nfs_fh *fh,
struct nfs_fattr *fattr, rpc_authflavor_t authflavor)
{
- struct nfs_clone_mount mountdata = {
- .sb = dentry->d_sb,
- .dentry = dentry,
- .fh = fh,
- .fattr = fattr,
- .authflavor = authflavor,
- };
+ struct nfs_sb_config *cfg;
+ struct sb_config *sc;
struct vfsmount *mnt;
- char *page = (char *) __get_free_page(GFP_USER);
- char *devname;
+ char *buffer, *p;
- if (page == NULL)
- return ERR_PTR(-ENOMEM);
+ /* Open a new mount context, transferring parameters from the parent
+ * superblock, including the network namespace.
+ */
+ sc = __vfs_new_sb_config(&nfs_fs_type, dentry->d_sb, 0,
+ SB_CONFIG_FOR_SUBMOUNT);
+ if (IS_ERR(sc))
+ return ERR_CAST(sc);
+ cfg = container_of(sc, struct nfs_sb_config, sc);
- devname = nfs_devname(dentry, page, PAGE_SIZE);
- if (IS_ERR(devname))
- mnt = (struct vfsmount *)devname;
- else
- mnt = nfs_do_clone_mount(NFS_SB(dentry->d_sb), devname, &mountdata);
+ mnt = ERR_PTR(-ENOMEM);
+ buffer = kmalloc(4096, GFP_USER);
+ if (!buffer)
+ goto err_sc;
+
+ cfg->mount_type = NFS_MOUNT_CROSS_DEV;
+ cfg->selected_flavor = authflavor;
+ cfg->clone_data.sb = dentry->d_sb;
+ cfg->clone_data.dentry = dentry;
+ cfg->clone_data.fattr = fattr;
+ cfg->clone_data.cloned = true;
+
+ nfs_copy_fh(cfg->mntfh, fh);
+
+ p = nfs_devname(dentry, buffer, 4096);
+ if (IS_ERR(p)) {
+ nfs_cfg_error(cfg, "NFS: Couldn't determine submount pathname");
+ mnt = ERR_CAST(p);
+ goto err_buffer;
+ }
+
+ cfg->sc.device = kmemdup(p, buffer + 4096 - p, GFP_KERNEL);
+ if (!cfg->sc.device)
+ goto err_buffer;
+ kfree(buffer);
+
+ mnt = nfs_do_clone_mount(NFS_SB(dentry->d_sb), cfg);
+ goto err_sc;
- free_page((unsigned long)page);
+err_buffer:
+ kfree(buffer);
+err_sc:
+ put_sb_config(sc);
return mnt;
}
EXPORT_SYMBOL_GPL(nfs_do_submount);
diff --git a/fs/nfs/nfs3_fs.h b/fs/nfs/nfs3_fs.h
index e134d6548ab7..7187e2e28a65 100644
--- a/fs/nfs/nfs3_fs.h
+++ b/fs/nfs/nfs3_fs.h
@@ -26,7 +26,7 @@ static inline int nfs3_proc_setacls(struct inode *inode, struct posix_acl *acl,
#endif /* CONFIG_NFS_V3_ACL */
/* nfs3client.c */
-struct nfs_server *nfs3_create_server(struct nfs_mount_info *, struct nfs_subversion *);
+struct nfs_server *nfs3_create_server(struct nfs_sb_config *);
struct nfs_server *nfs3_clone_server(struct nfs_server *, struct nfs_fh *,
struct nfs_fattr *, rpc_authflavor_t);
diff --git a/fs/nfs/nfs3client.c b/fs/nfs/nfs3client.c
index 7879f2a0fcfd..8b688d71c37c 100644
--- a/fs/nfs/nfs3client.c
+++ b/fs/nfs/nfs3client.c
@@ -45,10 +45,10 @@ static inline void nfs_init_server_aclclient(struct nfs_server *server)
}
#endif
-struct nfs_server *nfs3_create_server(struct nfs_mount_info *mount_info,
- struct nfs_subversion *nfs_mod)
+struct nfs_server *nfs3_create_server(struct nfs_sb_config *cfg)
{
- struct nfs_server *server = nfs_create_server(mount_info, nfs_mod);
+ struct nfs_server *server = nfs_create_server(cfg);
+
/* Create a client RPC handle for the NFS v3 ACL management interface */
if (!IS_ERR(server))
nfs_init_server_aclclient(server);
diff --git a/fs/nfs/nfs3proc.c b/fs/nfs/nfs3proc.c
index 0c07b567118d..ce926c8431d4 100644
--- a/fs/nfs/nfs3proc.c
+++ b/fs/nfs/nfs3proc.c
@@ -974,6 +974,7 @@ const struct nfs_rpc_ops nfs_v3_clientops = {
.file_ops = &nfs_file_operations,
.nlmclnt_ops = &nlmclnt_fl_close_lock_ops,
.getroot = nfs3_proc_get_root,
+ .mount = nfs_general_mount,
.submount = nfs_submount,
.try_mount = nfs_try_mount,
.getattr = nfs3_proc_getattr,
diff --git a/fs/nfs/nfs4_fs.h b/fs/nfs/nfs4_fs.h
index af285cc27ccf..05769b633b76 100644
--- a/fs/nfs/nfs4_fs.h
+++ b/fs/nfs/nfs4_fs.h
@@ -467,7 +467,6 @@ extern const nfs4_stateid zero_stateid;
/* nfs4super.c */
struct nfs_mount_info;
extern struct nfs_subversion nfs_v4;
-struct dentry *nfs4_try_mount(int, const char *, struct nfs_mount_info *, struct nfs_subversion *);
extern bool nfs4_disable_idmapping;
extern unsigned short max_session_slots;
extern unsigned short max_session_cb_slots;
@@ -477,6 +476,9 @@ extern bool recover_lost_locks;
#define NFS4_CLIENT_ID_UNIQ_LEN (64)
extern char nfs4_client_id_uniquifier[NFS4_CLIENT_ID_UNIQ_LEN];
+extern struct dentry *nfs4_try_mount(struct nfs_sb_config *);
+extern struct dentry *nfs4_mount(struct nfs_sb_config *);
+
/* nfs4sysctl.c */
#ifdef CONFIG_SYSCTL
int nfs4_register_sysctl(void);
diff --git a/fs/nfs/nfs4client.c b/fs/nfs/nfs4client.c
index ec0c112d8148..f1b9b9c7db12 100644
--- a/fs/nfs/nfs4client.c
+++ b/fs/nfs/nfs4client.c
@@ -1033,14 +1033,14 @@ static int nfs4_init_server(struct nfs_server *server,
/* Get a client record */
error = nfs4_set_client(server,
- cfg->nfs_server.hostname,
- (const struct sockaddr *)&cfg->nfs_server.address,
- cfg->nfs_server.addrlen,
- cfg->client_address,
- cfg->nfs_server.protocol,
- &timeparms,
- cfg->minorversion,
- cfg->net);
+ cfg->nfs_server.hostname,
+ &cfg->nfs_server.address,
+ cfg->nfs_server.addrlen,
+ cfg->client_address,
+ cfg->nfs_server.protocol,
+ &timeparms,
+ cfg->minorversion,
+ cfg->sc.net_ns);
if (error < 0)
return error;
@@ -1063,10 +1063,7 @@ static int nfs4_init_server(struct nfs_server *server,
* Create a version 4 volume record
* - keyed on server and FSID
*/
-/*struct nfs_server *nfs4_create_server(const struct nfs_sb_config *data,
- struct nfs_fh *mntfh)*/
-struct nfs_server *nfs4_create_server(struct nfs_mount_info *mount_info,
- struct nfs_subversion *nfs_mod)
+struct nfs_server *nfs4_create_server(struct nfs_sb_config *cfg)
{
struct nfs_server *server;
bool auth_probe;
@@ -1076,14 +1073,14 @@ struct nfs_server *nfs4_create_server(struct nfs_mount_info *mount_info,
if (!server)
return ERR_PTR(-ENOMEM);
- auth_probe = mount_info->cfg->auth_info.flavor_len < 1;
+ auth_probe = cfg->auth_info.flavor_len < 1;
/* set up the general RPC client */
- error = nfs4_init_server(server, mount_info->cfg);
+ error = nfs4_init_server(server, cfg);
if (error < 0)
goto error;
- error = nfs4_server_common_setup(server, mount_info->mntfh, auth_probe);
+ error = nfs4_server_common_setup(server, cfg->mntfh, auth_probe);
if (error < 0)
goto error;
@@ -1097,8 +1094,7 @@ struct nfs_server *nfs4_create_server(struct nfs_mount_info *mount_info,
/*
* Create an NFS4 referral server record
*/
-struct nfs_server *nfs4_create_referral_server(struct nfs_clone_mount *data,
- struct nfs_fh *mntfh)
+struct nfs_server *nfs4_create_referral_server(struct nfs_sb_config *cfg)
{
struct nfs_client *parent_client;
struct nfs_server *server, *parent_server;
@@ -1109,7 +1105,7 @@ struct nfs_server *nfs4_create_referral_server(struct nfs_clone_mount *data,
if (!server)
return ERR_PTR(-ENOMEM);
- parent_server = NFS_SB(data->sb);
+ parent_server = NFS_SB(cfg->clone_data.sb);
parent_client = parent_server->nfs_client;
/* Initialise the client representation from the parent server */
@@ -1117,9 +1113,10 @@ struct nfs_server *nfs4_create_referral_server(struct nfs_clone_mount *data,
/* Get a client representation.
* Note: NFSv4 always uses TCP, */
- error = nfs4_set_client(server, data->hostname,
- data->addr,
- data->addrlen,
+ error = nfs4_set_client(server,
+ cfg->nfs_server.hostname,
+ &cfg->nfs_server.address,
+ cfg->nfs_server.addrlen,
parent_client->cl_ipaddr,
rpc_protocol(parent_server->client),
parent_server->client->cl_timeout,
@@ -1128,13 +1125,14 @@ struct nfs_server *nfs4_create_referral_server(struct nfs_clone_mount *data,
if (error < 0)
goto error;
- error = nfs_init_server_rpcclient(server, parent_server->client->cl_timeout, data->authflavor);
+ error = nfs_init_server_rpcclient(server, parent_server->client->cl_timeout,
+ cfg->selected_flavor);
if (error < 0)
goto error;
auth_probe = parent_server->auth_info.flavor_len < 1;
- error = nfs4_server_common_setup(server, mntfh, auth_probe);
+ error = nfs4_server_common_setup(server, cfg->mntfh, auth_probe);
if (error < 0)
goto error;
diff --git a/fs/nfs/nfs4namespace.c b/fs/nfs/nfs4namespace.c
index 7d531da1bae3..45c9d808e7f1 100644
--- a/fs/nfs/nfs4namespace.c
+++ b/fs/nfs/nfs4namespace.c
@@ -7,6 +7,7 @@
* NFSv4 namespace
*/
+#include <linux/module.h>
#include <linux/dcache.h>
#include <linux/mount.h>
#include <linux/namei.h>
@@ -20,37 +21,64 @@
#include <linux/inet.h>
#include "internal.h"
#include "nfs4_fs.h"
+#include "nfs.h"
#include "dns_resolve.h"
#define NFSDBG_FACILITY NFSDBG_VFS
/*
+ * Work out the length that an NFSv4 path would render to as a standard posix
+ * path, with a leading slash but no terminating slash.
+ */
+static ssize_t nfs4_pathname_len(const struct nfs4_pathname *pathname)
+{
+ ssize_t len;
+ int i;
+
+ for (i = 0; i < pathname->ncomponents; i++) {
+ const struct nfs4_string *component = &pathname->components[i];
+
+ if (component->len > NAME_MAX)
+ goto too_long;
+ len += 1 + component->len; /* Adding "/foo" */
+ if (len > PATH_MAX)
+ goto too_long;
+ }
+ return len;
+
+too_long:
+ return -ENAMETOOLONG;
+}
+
+/*
* Convert the NFSv4 pathname components into a standard posix path.
- *
- * Note that the resulting string will be placed at the end of the buffer
*/
-static inline char *nfs4_pathname_string(const struct nfs4_pathname *pathname,
- char *buffer, ssize_t buflen)
+static char *nfs4_pathname_string(const struct nfs4_pathname *pathname,
+ unsigned short *_len)
{
- char *end = buffer + buflen;
- int n;
+ ssize_t len;
+ char *buf, *p;
+ int i;
- *--end = '\0';
- buflen--;
-
- n = pathname->ncomponents;
- while (--n >= 0) {
- const struct nfs4_string *component = &pathname->components[n];
- buflen -= component->len + 1;
- if (buflen < 0)
- goto Elong;
- end -= component->len;
- memcpy(end, component->data, component->len);
- *--end = '/';
+ len = nfs4_pathname_len(pathname);
+ if (len < 0)
+ return ERR_PTR(len);
+ *_len = len;
+
+ p = buf = kmalloc(len + 1, GFP_KERNEL);
+ if (!buf)
+ return ERR_PTR(-ENOMEM);
+
+ for (i = 0; i < pathname->ncomponents; i++) {
+ const struct nfs4_string *component = &pathname->components[i];
+
+ *p++ = '/';
+ memcpy(p, component->data, component->len);
+ p += component->len;
}
- return end;
-Elong:
- return ERR_PTR(-ENAMETOOLONG);
+
+ *p = 0;
+ return buf;
}
/*
@@ -99,21 +127,25 @@ static char *nfs4_path(struct dentry *dentry, char *buffer, ssize_t buflen)
*/
static int nfs4_validate_fspath(struct dentry *dentry,
const struct nfs4_fs_locations *locations,
- char *page, char *page2)
+ struct nfs_sb_config *ctx)
{
- const char *path, *fs_path;
+ const char *path;
+ char *buf;
+ int n;
- path = nfs4_path(dentry, page, PAGE_SIZE);
- if (IS_ERR(path))
+ buf = kmalloc(4096, GFP_KERNEL);
+ path = nfs4_path(dentry, buf, 4096);
+ if (IS_ERR(path)) {
+ kfree(buf);
return PTR_ERR(path);
+ }
- fs_path = nfs4_pathname_string(&locations->fs_path, page2, PAGE_SIZE);
- if (IS_ERR(fs_path))
- return PTR_ERR(fs_path);
-
- if (strncmp(path, fs_path, strlen(fs_path)) != 0) {
+ n = strncmp(path, ctx->nfs_server.export_path,
+ ctx->nfs_server.export_path_len);
+ kfree(buf);
+ if (n != 0) {
dprintk("%s: path %s does not begin with fsroot %s\n",
- __func__, path, fs_path);
+ __func__, path, ctx->nfs_server.export_path);
return -ENOENT;
}
@@ -234,56 +266,66 @@ nfs4_negotiate_security(struct rpc_clnt *clnt, struct inode *inode,
return new;
}
-static struct vfsmount *try_location(struct nfs_clone_mount *mountdata,
- char *page, char *page2,
+static struct vfsmount *try_location(struct dentry *dentry,
+ struct nfs_sb_config *ctx,
const struct nfs4_fs_location *location)
{
- const size_t addr_bufsize = sizeof(struct sockaddr_storage);
- struct net *net = rpc_net_ns(NFS_SB(mountdata->sb)->client);
+ struct net *net = rpc_net_ns(NFS_SB(dentry->d_sb)->client);
struct vfsmount *mnt = ERR_PTR(-ENOENT);
- char *mnt_path;
- unsigned int maxbuflen;
- unsigned int s;
+ unsigned int len, s;
+ char *p;
- mnt_path = nfs4_pathname_string(&location->rootpath, page2, PAGE_SIZE);
- if (IS_ERR(mnt_path))
- return ERR_CAST(mnt_path);
- mountdata->mnt_path = mnt_path;
- maxbuflen = mnt_path - 1 - page2;
+ /* Allocate a buffer big enough to hold any of the hostnames plus a
+ * terminating char and also a buffer big enough to hold the hostname
+ * plus a colon plus the path.
+ */
+ len = 0;
+ for (s = 0; s < location->nservers; s++) {
+ const struct nfs4_string *buf = &location->servers[s];
+ if (buf->len > len)
+ len = buf->len;
+ }
- mountdata->addr = kmalloc(addr_bufsize, GFP_KERNEL);
- if (mountdata->addr == NULL)
+ ctx->nfs_server.hostname = kmalloc(len + 1, GFP_KERNEL);
+ if (!ctx->nfs_server.hostname)
return ERR_PTR(-ENOMEM);
+ ctx->sc.device = kmalloc(len + 1 + ctx->nfs_server.export_path_len + 1,
+ GFP_KERNEL);
+ if (!ctx->sc.device)
+ return ERR_PTR(-ENOMEM);
+
for (s = 0; s < location->nservers; s++) {
const struct nfs4_string *buf = &location->servers[s];
- if (buf->len <= 0 || buf->len >= maxbuflen)
- continue;
-
if (memchr(buf->data, IPV6_SCOPE_DELIMITER, buf->len))
continue;
- mountdata->addrlen = nfs_parse_server_name(buf->data, buf->len,
- mountdata->addr, addr_bufsize, net);
- if (mountdata->addrlen == 0)
+ ctx->nfs_server.addrlen =
+ nfs_parse_server_name(buf->data, buf->len,
+ &ctx->nfs_server.address,
+ sizeof(ctx->nfs_server._address),
+ net);
+ if (ctx->nfs_server.addrlen == 0)
continue;
- rpc_set_port(mountdata->addr, NFS_PORT);
+ rpc_set_port(&ctx->nfs_server.address, NFS_PORT);
- memcpy(page2, buf->data, buf->len);
- page2[buf->len] = '\0';
- mountdata->hostname = page2;
+ memcpy(ctx->nfs_server.hostname, buf->data, buf->len);
+ ctx->nfs_server.hostname[buf->len] = '\0';
- snprintf(page, PAGE_SIZE, "%s:%s",
- mountdata->hostname,
- mountdata->mnt_path);
+ p = ctx->sc.device;
+ memcpy(p, buf->data, buf->len);
+ p += buf->len;
+ *p++ = ':';
+ memcpy(p, ctx->nfs_server.export_path, ctx->nfs_server.export_path_len);
+ p += ctx->nfs_server.export_path_len;
+ *p = 0;
- mnt = vfs_submount(mountdata->dentry, &nfs4_referral_fs_type, page, mountdata);
+ mnt = vfs_submount_sc(ctx->clone_data.dentry, &ctx->sc);
if (!IS_ERR(mnt))
break;
}
- kfree(mountdata->addr);
return mnt;
}
@@ -296,33 +338,43 @@ static struct vfsmount *try_location(struct nfs_clone_mount *mountdata,
static struct vfsmount *nfs_follow_referral(struct dentry *dentry,
const struct nfs4_fs_locations *locations)
{
- struct vfsmount *mnt = ERR_PTR(-ENOENT);
- struct nfs_clone_mount mountdata = {
- .sb = dentry->d_sb,
- .dentry = dentry,
- .authflavor = NFS_SB(dentry->d_sb)->client->cl_auth->au_flavor,
- };
- char *page = NULL, *page2 = NULL;
+ struct nfs_sb_config *cfg;
+ struct sb_config *sc;
+ struct vfsmount *mnt;
+ char *export_path;
int loc, error;
if (locations == NULL || locations->nlocations <= 0)
goto out;
+ sc = __vfs_new_sb_config(&nfs4_fs_type, dentry->d_sb, 0,
+ SB_CONFIG_FOR_SUBMOUNT);
+ if (IS_ERR(sc)) {
+ mnt = ERR_CAST(sc);
+ goto out;
+ }
+ cfg = container_of(sc, struct nfs_sb_config, sc);
+
dprintk("%s: referral at %pd2\n", __func__, dentry);
- page = (char *) __get_free_page(GFP_USER);
- if (!page)
- goto out;
+ cfg->mount_type = NFS4_MOUNT_REFERRAL;
+ cfg->clone_data.sb = dentry->d_sb;
+ cfg->clone_data.dentry = dentry;
+ cfg->clone_data.cloned = true;
- page2 = (char *) __get_free_page(GFP_USER);
- if (!page2)
- goto out;
+ export_path = nfs4_pathname_string(&locations->fs_path,
+ &cfg->nfs_server.export_path_len);
+ if (IS_ERR(export_path)) {
+ mnt = ERR_CAST(export_path);
+ goto out_sc;
+ }
+ cfg->nfs_server.export_path = export_path;
/* Ensure fs path is a prefix of current dentry path */
- error = nfs4_validate_fspath(dentry, locations, page, page2);
+ error = nfs4_validate_fspath(dentry, locations, cfg);
if (error < 0) {
mnt = ERR_PTR(error);
- goto out;
+ goto out_sc;
}
for (loc = 0; loc < locations->nlocations; loc++) {
@@ -332,14 +384,14 @@ static struct vfsmount *nfs_follow_referral(struct dentry *dentry,
location->rootpath.ncomponents == 0)
continue;
- mnt = try_location(&mountdata, page, page2, location);
+ mnt = try_location(cfg->clone_data.dentry, cfg, location);
if (!IS_ERR(mnt))
break;
}
+out_sc:
+ put_sb_config(sc);
out:
- free_page((unsigned long) page);
- free_page((unsigned long) page2);
return mnt;
}
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index c08c46a3b8cd..9f9bacdf6f86 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -9307,6 +9307,7 @@ const struct nfs_rpc_ops nfs_v4_clientops = {
.file_inode_ops = &nfs4_file_inode_operations,
.file_ops = &nfs4_file_operations,
.getroot = nfs4_proc_get_root,
+ .mount = nfs4_mount,
.submount = nfs4_submount,
.try_mount = nfs4_try_mount,
.getattr = nfs4_proc_getattr,
diff --git a/fs/nfs/nfs4super.c b/fs/nfs/nfs4super.c
index 5f5debfd4007..7bc27a28d5da 100644
--- a/fs/nfs/nfs4super.c
+++ b/fs/nfs/nfs4super.c
@@ -18,36 +18,9 @@
static int nfs4_write_inode(struct inode *inode, struct writeback_control *wbc);
static void nfs4_evict_inode(struct inode *inode);
-static struct dentry *nfs4_remote_mount(struct file_system_type *fs_type,
- int flags, const char *dev_name, void *raw_data);
-static struct dentry *nfs4_referral_mount(struct file_system_type *fs_type,
- int flags, const char *dev_name, void *raw_data);
-static struct dentry *nfs4_remote_referral_mount(struct file_system_type *fs_type,
- int flags, const char *dev_name, void *raw_data);
-
-static struct file_system_type nfs4_remote_fs_type = {
- .owner = THIS_MODULE,
- .name = "nfs4",
- .mount = nfs4_remote_mount,
- .kill_sb = nfs_kill_super,
- .fs_flags = FS_RENAME_DOES_D_MOVE|FS_BINARY_MOUNTDATA,
-};
-
-static struct file_system_type nfs4_remote_referral_fs_type = {
- .owner = THIS_MODULE,
- .name = "nfs4",
- .mount = nfs4_remote_referral_mount,
- .kill_sb = nfs_kill_super,
- .fs_flags = FS_RENAME_DOES_D_MOVE|FS_BINARY_MOUNTDATA,
-};
-
-struct file_system_type nfs4_referral_fs_type = {
- .owner = THIS_MODULE,
- .name = "nfs4",
- .mount = nfs4_referral_mount,
- .kill_sb = nfs_kill_super,
- .fs_flags = FS_RENAME_DOES_D_MOVE|FS_BINARY_MOUNTDATA,
-};
+static struct dentry *nfs4_remote_mount(struct nfs_sb_config *cfg);
+static struct dentry *nfs4_referral_mount(struct nfs_sb_config *cfg);
+static struct dentry *nfs4_remote_referral_mount(struct nfs_sb_config *cfg);
static const struct super_operations nfs4_sops = {
.alloc_inode = nfs_alloc_inode,
@@ -61,16 +34,16 @@ static const struct super_operations nfs4_sops = {
.show_devname = nfs_show_devname,
.show_path = nfs_show_path,
.show_stats = nfs_show_stats,
- .remount_fs = nfs_remount,
+ .remount_fs_sc = nfs_remount,
};
struct nfs_subversion nfs_v4 = {
- .owner = THIS_MODULE,
- .nfs_fs = &nfs4_fs_type,
- .rpc_vers = &nfs_version4,
- .rpc_ops = &nfs_v4_clientops,
- .sops = &nfs4_sops,
- .xattr = nfs4_xattr_handlers,
+ .owner = THIS_MODULE,
+ .nfs_fs = &nfs4_fs_type,
+ .rpc_vers = &nfs_version4,
+ .rpc_ops = &nfs_v4_clientops,
+ .sops = &nfs4_sops,
+ .xattr = nfs4_xattr_handlers,
};
static int nfs4_write_inode(struct inode *inode, struct writeback_control *wbc)
@@ -104,47 +77,58 @@ static void nfs4_evict_inode(struct inode *inode)
/*
* Get the superblock for the NFS4 root partition
*/
-static struct dentry *
-nfs4_remote_mount(struct file_system_type *fs_type, int flags,
- const char *dev_name, void *info)
+static struct dentry *nfs4_remote_mount(struct nfs_sb_config *cfg)
{
- struct nfs_mount_info *mount_info = info;
struct nfs_server *server;
- struct dentry *mntroot = ERR_PTR(-ENOMEM);
- mount_info->set_security = nfs_set_sb_security;
+ cfg->set_security = nfs_set_sb_security;
/* Get a volume representation */
- server = nfs4_create_server(mount_info, &nfs_v4);
- if (IS_ERR(server)) {
- mntroot = ERR_CAST(server);
- goto out;
- }
-
- mntroot = nfs_fs_mount_common(server, flags, dev_name, mount_info, &nfs_v4);
+ server = nfs4_create_server(cfg);
+ if (IS_ERR(server))
+ return ERR_CAST(server);
-out:
- return mntroot;
+ return nfs_fs_mount_common(server, cfg);
}
-static struct vfsmount *nfs_do_root_mount(struct file_system_type *fs_type,
- int flags, void *data, const char *hostname)
+/*
+ * Create a mount for the root of the server. We copy the mount context we
+ * have for the parameters and set its hostname, path and type.
+ */
+static struct vfsmount *nfs_do_root_mount(struct nfs_sb_config *cfg,
+ const char *hostname,
+ enum nfs_mount_type type)
{
+ struct nfs_sb_config *root_cfg;
+ struct sb_config *root_sc;
struct vfsmount *root_mnt;
char *root_devname;
size_t len;
+ root_sc = vfs_dup_sb_config(&cfg->sc);
+ if (IS_ERR(root_sc))
+ return ERR_CAST(root_sc);
+ root_cfg = container_of(root_sc, struct nfs_sb_config, sc);
+
+ root_cfg->mount_type = type;
+ root_cfg->nfs_server.export_path = (char *)nfs_slash;
+
len = strlen(hostname) + 5;
+ root_mnt = ERR_PTR(-ENOMEM);
root_devname = kmalloc(len, GFP_KERNEL);
if (root_devname == NULL)
- return ERR_PTR(-ENOMEM);
+ goto out_sc;
+
/* Does hostname needs to be enclosed in brackets? */
if (strchr(hostname, ':'))
snprintf(root_devname, len, "[%s]:/", hostname);
else
snprintf(root_devname, len, "%s:/", hostname);
- root_mnt = vfs_kern_mount(fs_type, flags, root_devname, data);
- kfree(root_devname);
+ root_cfg->sc.device = root_devname;
+
+ root_mnt = vfs_kern_mount_sc(&root_cfg->sc);
+out_sc:
+ put_sb_config(root_sc);
return root_mnt;
}
@@ -235,24 +219,24 @@ static struct dentry *nfs_follow_remote_path(struct vfsmount *root_mnt,
return dentry;
}
-struct dentry *nfs4_try_mount(int flags, const char *dev_name,
- struct nfs_mount_info *mount_info,
- struct nfs_subversion *nfs_mod)
+struct dentry *nfs4_try_mount(struct nfs_sb_config *cfg)
{
- char *export_path;
struct vfsmount *root_mnt;
struct dentry *res;
- struct nfs_sb_config *cfg = mount_info->cfg;
dfprintk(MOUNT, "--> nfs4_try_mount()\n");
- export_path = cfg->nfs_server.export_path;
- cfg->nfs_server.export_path = "/";
- root_mnt = nfs_do_root_mount(&nfs4_remote_fs_type, flags, mount_info,
- cfg->nfs_server.hostname);
- cfg->nfs_server.export_path = export_path;
+ /* We create a mount for the server's root, walk to the requested
+ * location and then create another mount for that.
+ */
+ root_mnt = nfs_do_root_mount(cfg, cfg->nfs_server.hostname,
+ NFS4_MOUNT_REMOTE);
+ if (IS_ERR(root_mnt))
+ return ERR_CAST(root_mnt);
- res = nfs_follow_remote_path(root_mnt, export_path);
+ res = nfs_follow_remote_path(root_mnt, cfg->nfs_server.export_path);
+ if (IS_ERR(res))
+ nfs_cfg_error(cfg, "NFS4: Couldn't follow remote path");
dfprintk(MOUNT, "<-- nfs4_try_mount() = %d%s\n",
PTR_ERR_OR_ZERO(res),
@@ -260,64 +244,64 @@ struct dentry *nfs4_try_mount(int flags, const char *dev_name,
return res;
}
-static struct dentry *
-nfs4_remote_referral_mount(struct file_system_type *fs_type, int flags,
- const char *dev_name, void *raw_data)
+static struct dentry *nfs4_remote_referral_mount(struct nfs_sb_config *cfg)
{
- struct nfs_mount_info mount_info = {
- .fill_super = nfs_fill_super,
- .set_security = nfs_clone_sb_security,
- .cloned = raw_data,
- };
struct nfs_server *server;
- struct dentry *mntroot = ERR_PTR(-ENOMEM);
dprintk("--> nfs4_referral_get_sb()\n");
- mount_info.mntfh = nfs_alloc_fhandle();
- if (mount_info.cloned == NULL || mount_info.mntfh == NULL)
- goto out;
+ cfg->set_security = nfs_clone_sb_security;
+
+ if (!cfg->clone_data.cloned)
+ return ERR_PTR(-EINVAL);
/* create a new volume representation */
- server = nfs4_create_referral_server(mount_info.cloned, mount_info.mntfh);
- if (IS_ERR(server)) {
- mntroot = ERR_CAST(server);
- goto out;
- }
+ server = nfs4_create_referral_server(cfg);
+ if (IS_ERR(server))
+ return ERR_CAST(server);
- mntroot = nfs_fs_mount_common(server, flags, dev_name, &mount_info, &nfs_v4);
-out:
- nfs_free_fhandle(mount_info.mntfh);
- return mntroot;
+ return nfs_fs_mount_common(server, cfg);
}
/*
* Create an NFS4 server record on referral traversal
*/
-static struct dentry *nfs4_referral_mount(struct file_system_type *fs_type,
- int flags, const char *dev_name, void *raw_data)
+static struct dentry *nfs4_referral_mount(struct nfs_sb_config *cfg)
{
- struct nfs_clone_mount *data = raw_data;
- char *export_path;
struct vfsmount *root_mnt;
struct dentry *res;
dprintk("--> nfs4_referral_mount()\n");
- export_path = data->mnt_path;
- data->mnt_path = "/";
-
- root_mnt = nfs_do_root_mount(&nfs4_remote_referral_fs_type,
- flags, data, data->hostname);
- data->mnt_path = export_path;
+ root_mnt = nfs_do_root_mount(cfg, cfg->nfs_server.hostname,
+ NFS4_MOUNT_REMOTE_REFERRAL);
- res = nfs_follow_remote_path(root_mnt, export_path);
+ res = nfs_follow_remote_path(root_mnt, cfg->nfs_server.export_path);
dprintk("<-- nfs4_referral_mount() = %d%s\n",
PTR_ERR_OR_ZERO(res),
IS_ERR(res) ? " [error]" : "");
return res;
}
+/*
+ * Handle special NFS4 mount types.
+ */
+struct dentry *nfs4_mount(struct nfs_sb_config *cfg)
+{
+ switch (cfg->mount_type) {
+ case NFS4_MOUNT_REMOTE:
+ return nfs4_remote_mount(cfg);
+
+ case NFS4_MOUNT_REFERRAL:
+ return nfs4_referral_mount(cfg);
+
+ case NFS4_MOUNT_REMOTE_REFERRAL:
+ return nfs4_remote_referral_mount(cfg);
+
+ default:
+ return nfs_general_mount(cfg);
+ }
+}
static int __init init_nfs_v4(void)
{
diff --git a/fs/nfs/proc.c b/fs/nfs/proc.c
index 9872cf676a50..aab90fd09e75 100644
--- a/fs/nfs/proc.c
+++ b/fs/nfs/proc.c
@@ -704,6 +704,7 @@ const struct nfs_rpc_ops nfs_v2_clientops = {
.file_inode_ops = &nfs_file_inode_operations,
.file_ops = &nfs_file_operations,
.getroot = nfs_proc_get_root,
+ .mount = nfs_general_mount,
.submount = nfs_submount,
.try_mount = nfs_try_mount,
.getattr = nfs_proc_getattr,
diff --git a/fs/nfs/super.c b/fs/nfs/super.c
index acf935a6438d..a705d6730921 100644
--- a/fs/nfs/super.c
+++ b/fs/nfs/super.c
@@ -69,27 +69,6 @@
#define NFSDBG_FACILITY NFSDBG_VFS
-static struct dentry *nfs_xdev_mount(struct file_system_type *fs_type,
- int flags, const char *dev_name, void *raw_data);
-
-struct file_system_type nfs_fs_type = {
- .owner = THIS_MODULE,
- .name = "nfs",
- .mount = nfs_fs_mount,
- .kill_sb = nfs_kill_super,
- .fs_flags = FS_RENAME_DOES_D_MOVE|FS_BINARY_MOUNTDATA,
-};
-MODULE_ALIAS_FS("nfs");
-EXPORT_SYMBOL_GPL(nfs_fs_type);
-
-struct file_system_type nfs_xdev_fs_type = {
- .owner = THIS_MODULE,
- .name = "nfs",
- .mount = nfs_xdev_mount,
- .kill_sb = nfs_kill_super,
- .fs_flags = FS_RENAME_DOES_D_MOVE|FS_BINARY_MOUNTDATA,
-};
-
const struct super_operations nfs_sops = {
.alloc_inode = nfs_alloc_inode,
.destroy_inode = nfs_destroy_inode,
@@ -102,22 +81,11 @@ const struct super_operations nfs_sops = {
.show_devname = nfs_show_devname,
.show_path = nfs_show_path,
.show_stats = nfs_show_stats,
- .remount_fs = nfs_remount,
+ .remount_fs_sc = nfs_remount,
};
EXPORT_SYMBOL_GPL(nfs_sops);
#if IS_ENABLED(CONFIG_NFS_V4)
-struct file_system_type nfs4_fs_type = {
- .owner = THIS_MODULE,
- .name = "nfs4",
- .mount = nfs_fs_mount,
- .kill_sb = nfs_kill_super,
- .fs_flags = FS_RENAME_DOES_D_MOVE|FS_BINARY_MOUNTDATA,
-};
-MODULE_ALIAS_FS("nfs4");
-MODULE_ALIAS("nfs4");
-EXPORT_SYMBOL_GPL(nfs4_fs_type);
-
static int __init register_nfs4_fs(void)
{
return register_filesystem(&nfs4_fs_type);
@@ -772,7 +740,7 @@ static int nfs_request_mount(struct nfs_sb_config *cfg,
.noresvport = cfg->flags & NFS_MOUNT_NORESVPORT,
.auth_flav_len = server_authlist_len,
.auth_flavs = server_authlist,
- .net = cfg->net,
+ .net = cfg->sc.net_ns,
};
int status;
@@ -817,20 +785,17 @@ static int nfs_request_mount(struct nfs_sb_config *cfg,
return 0;
}
-static struct nfs_server *nfs_try_mount_request(struct nfs_mount_info *mount_info,
- struct nfs_subversion *nfs_mod)
+static struct nfs_server *nfs_try_mount_request(struct nfs_sb_config *cfg)
{
int status;
unsigned int i;
bool tried_auth_unix = false;
bool auth_null_in_list = false;
struct nfs_server *server = ERR_PTR(-EACCES);
- struct nfs_sb_config *cfg = mount_info->cfg;
rpc_authflavor_t authlist[NFS_MAX_SECFLAVORS];
unsigned int authlist_len = ARRAY_SIZE(authlist);
- status = nfs_request_mount(cfg, mount_info->mntfh, authlist,
- &authlist_len);
+ status = nfs_request_mount(cfg, cfg->mntfh, authlist, &authlist_len);
if (status)
return ERR_PTR(status);
@@ -844,7 +809,7 @@ static struct nfs_server *nfs_try_mount_request(struct nfs_mount_info *mount_inf
cfg->selected_flavor);
if (status)
return ERR_PTR(status);
- return nfs_mod->rpc_ops->create_server(mount_info, nfs_mod);
+ return cfg->nfs_mod->rpc_ops->create_server(cfg);
}
/*
@@ -871,7 +836,7 @@ static struct nfs_server *nfs_try_mount_request(struct nfs_mount_info *mount_inf
}
dfprintk(MOUNT, "NFS: attempting to use auth flavor %u\n", flavor);
cfg->selected_flavor = flavor;
- server = nfs_mod->rpc_ops->create_server(mount_info, nfs_mod);
+ server = cfg->nfs_mod->rpc_ops->create_server(cfg);
if (!IS_ERR(server))
return server;
}
@@ -887,27 +852,28 @@ static struct nfs_server *nfs_try_mount_request(struct nfs_mount_info *mount_inf
/* Last chance! Try AUTH_UNIX */
dfprintk(MOUNT, "NFS: attempting to use auth flavor %u\n", RPC_AUTH_UNIX);
cfg->selected_flavor = RPC_AUTH_UNIX;
- return nfs_mod->rpc_ops->create_server(mount_info, nfs_mod);
+ return cfg->nfs_mod->rpc_ops->create_server(cfg);
}
-struct dentry *nfs_try_mount(int flags, const char *dev_name,
- struct nfs_mount_info *mount_info,
- struct nfs_subversion *nfs_mod)
+struct dentry *nfs_try_mount(struct nfs_sb_config *cfg)
{
struct nfs_server *server;
- if (mount_info->cfg->need_mount)
- server = nfs_try_mount_request(mount_info, nfs_mod);
+ if (cfg->need_mount)
+ server = nfs_try_mount_request(cfg);
else
- server = nfs_mod->rpc_ops->create_server(mount_info, nfs_mod);
+ server = cfg->nfs_mod->rpc_ops->create_server(cfg);
- if (IS_ERR(server))
+ if (IS_ERR(server)) {
+ nfs_cfg_error(cfg, "NFS: Couldn't create server");
return ERR_CAST(server);
+ }
- return nfs_fs_mount_common(server, flags, dev_name, mount_info, nfs_mod);
+ return nfs_fs_mount_common(server, cfg);
}
EXPORT_SYMBOL_GPL(nfs_try_mount);
+
#define NFS_REMOUNT_CMP_FLAGMASK ~(NFS_MOUNT_INTR \
| NFS_MOUNT_SECURE \
| NFS_MOUNT_TCP \
@@ -946,15 +912,11 @@ nfs_compare_remount_data(struct nfs_server *nfss,
return 0;
}
-int
-nfs_remount(struct super_block *sb, int *flags, char *raw_data)
+int nfs_remount(struct super_block *sb, struct sb_config *sc)
{
- int error;
+ struct nfs_sb_config *cfg =
+ container_of(sc, struct nfs_sb_config, sc);
struct nfs_server *nfss = sb->s_fs_info;
- struct nfs_sb_config *cfg;
- struct nfs_mount_data *options = (struct nfs_mount_data *)raw_data;
- struct nfs4_mount_data *options4 = (struct nfs4_mount_data *)raw_data;
- u32 nfsvers = nfss->nfs_client->rpc_ops->version;
sync_filesystem(sb);
@@ -964,39 +926,9 @@ nfs_remount(struct super_block *sb, int *flags, char *raw_data)
* ones were explicitly specified. Fall back to legacy behavior and
* just return success.
*/
- if ((nfsvers == 4 && (!options4 || options4->version == 1)) ||
- (nfsvers <= 3 && (!options || (options->version >= 1 &&
- options->version <= 6))))
+ if (cfg->skip_remount_option_check)
return 0;
- cfg = kzalloc(sizeof(*cfg), GFP_KERNEL);
- if (cfg == NULL)
- return -ENOMEM;
-
- /* fill out struct with values from existing mount */
- cfg->flags = nfss->flags;
- cfg->rsize = nfss->rsize;
- cfg->wsize = nfss->wsize;
- cfg->retrans = nfss->client->cl_timeout->to_retries;
- cfg->selected_flavor = nfss->client->cl_auth->au_flavor;
- cfg->acregmin = nfss->acregmin / HZ;
- cfg->acregmax = nfss->acregmax / HZ;
- cfg->acdirmin = nfss->acdirmin / HZ;
- cfg->acdirmax = nfss->acdirmax / HZ;
- cfg->timeo = 10U * nfss->client->cl_timeout->to_initval / HZ;
- cfg->nfs_server.port = nfss->port;
- cfg->nfs_server.addrlen = nfss->nfs_client->cl_addrlen;
- cfg->version = nfsvers;
- cfg->minorversion = nfss->nfs_client->cl_minorversion;
- cfg->net = current->nsproxy->net_ns;
- memcpy(&cfg->nfs_server.address, &nfss->nfs_client->cl_addr,
- cfg->nfs_server.addrlen);
-
- /* overwrite those values with any that were specified */
- error = -EINVAL;
- if (!nfs_parse_mount_options((char *)options, cfg))
- goto out;
-
/*
* noac is a special case. It implies -o sync, but that's not
* necessarily reflected in the mtab options. do_remount_sb
@@ -1004,20 +936,17 @@ nfs_remount(struct super_block *sb, int *flags, char *raw_data)
* remount options, so we have to explicitly reset it.
*/
if (cfg->flags & NFS_MOUNT_NOAC)
- *flags |= MS_SYNCHRONOUS;
+ cfg->sc.ms_flags |= MS_SYNCHRONOUS;
/* compare new mount options with old ones */
- error = nfs_compare_remount_data(nfss, cfg);
-out:
- kfree(cfg);
- return error;
+ return nfs_compare_remount_data(nfss, cfg);
}
EXPORT_SYMBOL_GPL(nfs_remount);
/*
* Initialise the common bits of the superblock
*/
-inline void nfs_initialise_sb(struct super_block *sb)
+static inline void nfs_initialise_sb(struct super_block *sb)
{
struct nfs_server *server = NFS_SB(sb);
@@ -1037,9 +966,8 @@ inline void nfs_initialise_sb(struct super_block *sb)
/*
* Finish setting up an NFS2/3 superblock
*/
-void nfs_fill_super(struct super_block *sb, struct nfs_mount_info *mount_info)
+static void nfs_fill_super(struct super_block *sb, struct nfs_sb_config *cfg)
{
- struct nfs_sb_config *cfg = mount_info->cfg;
struct nfs_server *server = NFS_SB(sb);
sb->s_blocksize_bits = 0;
@@ -1059,14 +987,13 @@ void nfs_fill_super(struct super_block *sb, struct nfs_mount_info *mount_info)
nfs_initialise_sb(sb);
}
-EXPORT_SYMBOL_GPL(nfs_fill_super);
/*
* Finish setting up a cloned NFS2/3/4 superblock
*/
-void nfs_clone_super(struct super_block *sb, struct nfs_mount_info *mount_info)
+static void nfs_clone_super(struct super_block *sb, struct nfs_sb_config *cfg)
{
- const struct super_block *old_sb = mount_info->cloned->sb;
+ const struct super_block *old_sb = cfg->clone_data.sb;
struct nfs_server *server = NFS_SB(sb);
sb->s_blocksize_bits = old_sb->s_blocksize_bits;
@@ -1198,8 +1125,7 @@ static int nfs_compare_super(struct super_block *sb, void *data)
#ifdef CONFIG_NFS_FSCACHE
static void nfs_get_cache_cookie(struct super_block *sb,
- struct nfs_sb_config *cfg,
- struct nfs_clone_mount *cloned)
+ struct nfs_sb_config *cfg)
{
struct nfs_server *nfss = NFS_SB(sb);
char *uniq = NULL;
@@ -1208,44 +1134,47 @@ static void nfs_get_cache_cookie(struct super_block *sb,
nfss->fscache_key = NULL;
nfss->fscache = NULL;
- if (cfg) {
+ if (!cfg)
+ return;
+
+ if (cfg->clone_data.cloned) {
+ struct nfs_server *mnt_s = NFS_SB(cfg->clone_data.sb);
+ if (!(mnt_s->options & NFS_OPTION_FSCACHE))
+ return;
+ if (mnt_s->fscache_key) {
+ uniq = mnt_s->fscache_key->key.uniquifier;
+ ulen = mnt_s->fscache_key->key.uniq_len;
+ }
+ } else {
if (!(cfg->options & NFS_OPTION_FSCACHE))
return;
if (cfg->fscache_uniq) {
uniq = cfg->fscache_uniq;
ulen = strlen(cfg->fscache_uniq);
}
- } else if (cloned) {
- struct nfs_server *mnt_s = NFS_SB(cloned->sb);
- if (!(mnt_s->options & NFS_OPTION_FSCACHE))
- return;
- if (mnt_s->fscache_key) {
- uniq = mnt_s->fscache_key->key.uniquifier;
- ulen = mnt_s->fscache_key->key.uniq_len;
- };
- } else
return;
+ }
nfs_fscache_get_super_cookie(sb, uniq, ulen);
}
#else
static void nfs_get_cache_cookie(struct super_block *sb,
- struct nfs_sb_config *parsed,
- struct nfs_clone_mount *cloned)
+ struct nfs_sb_config *cfg)
{
}
#endif
int nfs_set_sb_security(struct super_block *s, struct dentry *mntroot,
- struct nfs_mount_info *mount_info)
+ struct nfs_sb_config *cfg)
{
int error;
unsigned long kflags = 0, kflags_out = 0;
+
if (NFS_SB(s)->caps & NFS_CAP_SECURITY_LABEL)
kflags |= SECURITY_LSM_NATIVE_LABELS;
- error = security_sb_set_mnt_opts(s, &mount_info->cfg->lsm_opts,
- kflags, &kflags_out);
+ error = security_sb_set_mnt_opts(s, cfg->sc.security,
+ kflags, &kflags_out);
if (error)
goto err;
@@ -1258,25 +1187,23 @@ int nfs_set_sb_security(struct super_block *s, struct dentry *mntroot,
EXPORT_SYMBOL_GPL(nfs_set_sb_security);
int nfs_clone_sb_security(struct super_block *s, struct dentry *mntroot,
- struct nfs_mount_info *mount_info)
+ struct nfs_sb_config *cfg)
{
/* clone any lsm security options from the parent to the new sb */
if (d_inode(mntroot)->i_op != NFS_SB(s)->nfs_client->rpc_ops->dir_inode_ops)
return -ESTALE;
- return security_sb_clone_mnt_opts(mount_info->cloned->sb, s);
+ return security_sb_clone_mnt_opts(cfg->clone_data.sb, s);
}
EXPORT_SYMBOL_GPL(nfs_clone_sb_security);
struct dentry *nfs_fs_mount_common(struct nfs_server *server,
- int flags, const char *dev_name,
- struct nfs_mount_info *mount_info,
- struct nfs_subversion *nfs_mod)
+ struct nfs_sb_config *cfg)
{
struct super_block *s;
struct dentry *mntroot = ERR_PTR(-ENOMEM);
int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
struct nfs_sb_mountdata sb_mntdata = {
- .mntflags = flags,
+ .mntflags = cfg->sc.ms_flags,
.server = server,
};
int error;
@@ -1288,14 +1215,16 @@ struct dentry *nfs_fs_mount_common(struct nfs_server *server,
if (server->flags & NFS_MOUNT_NOAC)
sb_mntdata.mntflags |= MS_SYNCHRONOUS;
- if (mount_info->cloned != NULL && mount_info->cloned->sb != NULL)
- if (mount_info->cloned->sb->s_flags & MS_SYNCHRONOUS)
+ if (cfg->clone_data.cloned && cfg->clone_data.sb != NULL)
+ if (cfg->clone_data.sb->s_flags & MS_SYNCHRONOUS)
sb_mntdata.mntflags |= MS_SYNCHRONOUS;
/* Get a superblock - note that we may end up sharing one that already exists */
- s = sget(nfs_mod->nfs_fs, compare_super, nfs_set_super, flags, &sb_mntdata);
+ s = sget(cfg->nfs_mod->nfs_fs, compare_super, nfs_set_super, cfg->sc.ms_flags,
+ &sb_mntdata);
if (IS_ERR(s)) {
mntroot = ERR_CAST(s);
+ nfs_cfg_error(cfg, "NFS: Couldn't get superblock");
goto out_err_nosb;
}
@@ -1315,15 +1244,20 @@ struct dentry *nfs_fs_mount_common(struct nfs_server *server,
if (!s->s_root) {
/* initial superblock/root creation */
- mount_info->fill_super(s, mount_info);
- nfs_get_cache_cookie(s, mount_info->cfg, mount_info->cloned);
+ if (cfg->clone_data.sb)
+ nfs_clone_super(s, cfg);
+ else
+ nfs_fill_super(s, cfg);
+ nfs_get_cache_cookie(s, cfg);
}
- mntroot = nfs_get_root(s, mount_info->mntfh, dev_name);
- if (IS_ERR(mntroot))
+ mntroot = nfs_get_root(s, cfg->mntfh, cfg->sc.device);
+ if (IS_ERR(mntroot)) {
+ nfs_cfg_error(cfg, "NFS: Couldn't get root dentry");
goto error_splat_super;
+ }
- error = mount_info->set_security(s, mntroot, mount_info);
+ error = cfg->set_security(s, mntroot, cfg);
if (error)
goto error_splat_root;
@@ -1345,47 +1279,6 @@ struct dentry *nfs_fs_mount_common(struct nfs_server *server,
}
EXPORT_SYMBOL_GPL(nfs_fs_mount_common);
-struct dentry *nfs_fs_mount(struct file_system_type *fs_type,
- int flags, const char *dev_name, void *raw_data)
-{
- struct nfs_mount_info mount_info = {
- .fill_super = nfs_fill_super,
- .set_security = nfs_set_sb_security,
- };
- struct dentry *mntroot = ERR_PTR(-ENOMEM);
- struct nfs_subversion *nfs_mod;
- int error;
-
- mount_info.cfg = nfs_alloc_parsed_mount_data();
- mount_info.mntfh = nfs_alloc_fhandle();
- if (mount_info.cfg == NULL || mount_info.mntfh == NULL)
- goto out;
-
- /* Validate the mount data */
- error = nfs_validate_mount_data(fs_type, raw_data, mount_info.cfg, mount_info.mntfh, dev_name);
- if (error == NFS_TEXT_DATA)
- error = nfs_validate_text_mount_data(raw_data, mount_info.cfg, dev_name);
- if (error < 0) {
- mntroot = ERR_PTR(error);
- goto out;
- }
-
- nfs_mod = get_nfs_version(mount_info.cfg->version);
- if (IS_ERR(nfs_mod)) {
- mntroot = ERR_CAST(nfs_mod);
- goto out;
- }
-
- mntroot = nfs_mod->rpc_ops->try_mount(flags, dev_name, &mount_info, nfs_mod);
-
- put_nfs_version(nfs_mod);
-out:
- nfs_free_parsed_mount_data(mount_info.cfg);
- nfs_free_fhandle(mount_info.mntfh);
- return mntroot;
-}
-EXPORT_SYMBOL_GPL(nfs_fs_mount);
-
/*
* Destroy an NFS2/3 superblock
*/
@@ -1403,41 +1296,6 @@ void nfs_kill_super(struct super_block *s)
}
EXPORT_SYMBOL_GPL(nfs_kill_super);
-/*
- * Clone an NFS2/3/4 server record on xdev traversal (FSID-change)
- */
-static struct dentry *
-nfs_xdev_mount(struct file_system_type *fs_type, int flags,
- const char *dev_name, void *raw_data)
-{
- struct nfs_clone_mount *data = raw_data;
- struct nfs_mount_info mount_info = {
- .fill_super = nfs_clone_super,
- .set_security = nfs_clone_sb_security,
- .cloned = data,
- };
- struct nfs_server *server;
- struct dentry *mntroot = ERR_PTR(-ENOMEM);
- struct nfs_subversion *nfs_mod = NFS_SB(data->sb)->nfs_client->cl_nfs_mod;
-
- dprintk("--> nfs_xdev_mount()\n");
-
- mount_info.mntfh = mount_info.cloned->fh;
-
- /* create a new volume representation */
- server = nfs_mod->rpc_ops->clone_server(NFS_SB(data->sb), data->fh, data->fattr, data->authflavor);
-
- if (IS_ERR(server))
- mntroot = ERR_CAST(server);
- else
- mntroot = nfs_fs_mount_common(server, flags,
- dev_name, &mount_info, nfs_mod);
-
- dprintk("<-- nfs_xdev_mount() = %ld\n",
- IS_ERR(mntroot) ? PTR_ERR(mntroot) : 0L);
- return mntroot;
-}
-
#if IS_ENABLED(CONFIG_NFS_V4)
/*
diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h
index b28c83475ee8..250d27088309 100644
--- a/include/linux/nfs_xdr.h
+++ b/include/linux/nfs_xdr.h
@@ -1542,6 +1542,7 @@ struct nfs_subversion;
struct nfs_mount_info;
struct nfs_client_initdata;
struct nfs_pageio_descriptor;
+struct nfs_sb_config;
/*
* RPC procedure vector for NFSv2/NFSv3 demuxing
@@ -1556,10 +1557,10 @@ struct nfs_rpc_ops {
int (*getroot) (struct nfs_server *, struct nfs_fh *,
struct nfs_fsinfo *);
+ struct dentry *(*mount)(struct nfs_sb_config *);
struct vfsmount *(*submount) (struct nfs_server *, struct dentry *,
struct nfs_fh *, struct nfs_fattr *);
- struct dentry *(*try_mount) (int, const char *, struct nfs_mount_info *,
- struct nfs_subversion *);
+ struct dentry *(*try_mount) (struct nfs_sb_config *);
int (*getattr) (struct nfs_server *, struct nfs_fh *,
struct nfs_fattr *, struct nfs4_label *);
int (*setattr) (struct dentry *, struct nfs_fattr *,
@@ -1620,7 +1621,7 @@ struct nfs_rpc_ops {
struct nfs_client *(*init_client) (struct nfs_client *,
const struct nfs_client_initdata *);
void (*free_client) (struct nfs_client *);
- struct nfs_server *(*create_server)(struct nfs_mount_info *, struct nfs_subversion *);
+ struct nfs_server *(*create_server)(struct nfs_sb_config *);
struct nfs_server *(*clone_server)(struct nfs_server *, struct nfs_fh *,
struct nfs_fattr *, rpc_authflavor_t);
};
^ permalink raw reply related [flat|nested] 28+ messages in thread* [PATCH 20/21] Support legacy filesystems [ver #3]
2017-05-15 15:17 [RFC][PATCH 00/21] VFS: Introduce superblock configuration context [ver #3] David Howells
` (18 preceding siblings ...)
2017-05-15 15:20 ` [PATCH 19/21] NFS: Add mount context support. " David Howells
@ 2017-05-15 15:20 ` David Howells
2017-05-15 15:21 ` [PATCH 21/21] Add commands to create or update a superblock " David Howells
20 siblings, 0 replies; 28+ messages in thread
From: David Howells @ 2017-05-15 15:20 UTC (permalink / raw)
To: mszeredi, viro, jlayton; +Cc: dhowells, linux-fsdevel, linux-nfs, linux-kernel
Support legacy filesystems by creating a set of legacy sb_config operations
that builds up a list of mount options and then invokes fs_type->mount()
within the sb_config mount operation.
All filesystems can then be accessed using sb_config and the
fs_type->mount() call is _only_ used from within legacy_mount(). This
allows some simplification to take place in the core mount code.
---
fs/namespace.c | 36 ++-----------
fs/sb_config.c | 160 ++++++++++++++++++++++++++++++++++++++++++++++++++++++--
2 files changed, 161 insertions(+), 35 deletions(-)
diff --git a/fs/namespace.c b/fs/namespace.c
index cbac401e12a1..ce892343d1de 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -2574,7 +2574,6 @@ static int do_new_mount(struct path *mountpoint, const char *fstype, int flags,
int mnt_flags, const char *name, void *data)
{
struct sb_config *sc;
- struct vfsmount *mnt;
int err;
if (!fstype)
@@ -2590,40 +2589,17 @@ static int do_new_mount(struct path *mountpoint, const char *fstype, int flags,
if (!sc->device)
goto err_sc;
- if (sc->ops) {
- err = parse_monolithic_mount_data(sc, data);
- if (err < 0)
- goto err_sc;
-
- err = do_new_mount_sc(sc, mountpoint, mnt_flags);
- if (err)
- goto err_sc;
-
- } else {
- mnt = vfs_kern_mount(sc->fs_type, flags, name, data);
- if (!IS_ERR(mnt) && (sc->fs_type->fs_flags & FS_HAS_SUBTYPE) &&
- !mnt->mnt_sb->s_subtype)
- mnt = fs_set_subtype(mnt, fstype);
-
- if (IS_ERR(mnt)) {
- err = PTR_ERR(mnt);
- goto err_sc;
- }
-
- err = -EPERM;
- if (mount_too_revealing(mnt, &mnt_flags))
- goto err_mnt;
+ err = parse_monolithic_mount_data(sc, data);
+ if (err < 0)
+ goto err_sc;
- err = do_add_mount(real_mount(mnt), mountpoint, mnt_flags);
- if (err)
- goto err_mnt;
- }
+ err = do_new_mount_sc(sc, mountpoint, mnt_flags);
+ if (err)
+ goto err_sc;
put_sb_config(sc);
return 0;
-err_mnt:
- mntput(mnt);
err_sc:
if (sc->error_msg)
pr_info("Mount failed: %s\n", sc->error_msg);
diff --git a/fs/sb_config.c b/fs/sb_config.c
index 9c45e269b3cc..62e309cd62ef 100644
--- a/fs/sb_config.c
+++ b/fs/sb_config.c
@@ -25,6 +25,15 @@
#include <net/net_namespace.h>
#include "mount.h"
+struct legacy_sb_config {
+ struct sb_config sc;
+ char *legacy_data; /* Data page for legacy filesystems */
+ char *secdata;
+ unsigned int data_usage;
+};
+
+static const struct sb_config_operations legacy_sb_config_ops;
+
static const match_table_t common_set_mount_options = {
{ MS_DIRSYNC, "dirsync" },
{ MS_I_VERSION, "iversion" },
@@ -186,13 +195,15 @@ struct sb_config *__vfs_new_sb_config(struct file_system_type *fs_type,
enum sb_config_purpose purpose)
{
struct sb_config *sc;
+ size_t sc_size = fs_type->sb_config_size;
int ret;
- BUG_ON(fs_type->init_sb_config &&
- fs_type->sb_config_size < sizeof(*sc));
+ BUG_ON(fs_type->init_sb_config && sc_size < sizeof(*sc));
+
+ if (!fs_type->init_sb_config)
+ sc_size = sizeof(struct legacy_sb_config);
- sc = kzalloc(max_t(size_t, fs_type->sb_config_size, sizeof(*sc)),
- GFP_KERNEL);
+ sc = kzalloc(sc_size, GFP_KERNEL);
if (!sc)
return ERR_PTR(-ENOMEM);
@@ -208,9 +219,11 @@ struct sb_config *__vfs_new_sb_config(struct file_system_type *fs_type,
ret = sc->fs_type->init_sb_config(sc, src_sb);
if (ret < 0)
goto err_sc;
+ } else {
+ sc->ops = &legacy_sb_config_ops;
}
- /* Do the security check last because ->fsopen may change the
+ /* Do the security check last because ->init_sb_config may change the
* namespace subscriptions.
*/
ret = security_sb_config_alloc(sc, src_sb);
@@ -272,11 +285,16 @@ struct sb_config *vfs_sb_reconfig(struct vfsmount *mnt,
struct sb_config *vfs_dup_sb_config(struct sb_config *src_sc)
{
struct sb_config *sc;
+ size_t sc_size;
int ret;
if (!src_sc->ops->dup)
return ERR_PTR(-ENOTSUPP);
+ sc_size = src_sc->fs_type->sb_config_size;
+ if (!src_sc->fs_type->init_sb_config)
+ sc_size = sizeof(struct legacy_sb_config);
+
sc = kmemdup(src_sc, src_sc->fs_type->sb_config_size, GFP_KERNEL);
if (!sc)
return ERR_PTR(-ENOMEM);
@@ -324,3 +342,135 @@ void put_sb_config(struct sb_config *sc)
kfree(sc);
}
EXPORT_SYMBOL(put_sb_config);
+
+/*
+ * Free the config for a filesystem that doesn't support sb_config.
+ */
+static void legacy_sb_config_free(struct sb_config *sc)
+{
+ struct legacy_sb_config *cfg = container_of(sc, struct legacy_sb_config, sc);
+
+ free_secdata(cfg->secdata);
+ kfree(cfg->legacy_data);
+}
+
+/*
+ * Duplicate a legacy config.
+ */
+static int legacy_sb_config_dup(struct sb_config *sc, struct sb_config *src_sc)
+{
+ struct legacy_sb_config *cfg = container_of(sc, struct legacy_sb_config, sc);
+ struct legacy_sb_config *src_cfg = container_of(src_sc, struct legacy_sb_config, sc);
+
+ cfg->legacy_data = kmalloc(PAGE_SIZE, GFP_KERNEL);
+ if (!cfg->legacy_data)
+ return -ENOMEM;
+ memcpy(cfg->legacy_data, src_cfg->legacy_data, sizeof(PAGE_SIZE));
+ return 0;
+}
+
+/*
+ * Add an option to a legacy config. We build up a comma-separated list of
+ * options.
+ */
+static int legacy_parse_option(struct sb_config *sc, char *p)
+{
+ struct legacy_sb_config *cfg = container_of(sc, struct legacy_sb_config, sc);
+ unsigned int usage = cfg->data_usage;
+ size_t len = strlen(p);
+
+ if (len > PAGE_SIZE - 2 - usage)
+ return sb_cfg_inval(sc, "VFS: Insufficient data buffer space");
+ if (memchr(p, ',', len) != NULL)
+ return sb_cfg_inval(sc, "VFS: Options cannot contain commas");
+ if (!cfg->legacy_data) {
+ cfg->legacy_data = kmalloc(PAGE_SIZE, GFP_KERNEL);
+ if (!cfg->legacy_data)
+ return -ENOMEM;
+ }
+
+ cfg->legacy_data[usage++] = ',';
+ memcpy(cfg->legacy_data + usage, p, len);
+ usage += len;
+ cfg->legacy_data[usage] = '\0';
+ cfg->data_usage = usage;
+ return 0;
+}
+
+/*
+ * Add monolithic mount data.
+ */
+static int legacy_monolithic_mount_data(struct sb_config *sc, void *data)
+{
+ struct legacy_sb_config *cfg = container_of(sc, struct legacy_sb_config, sc);
+
+ if (cfg->data_usage != 0)
+ return sb_cfg_inval(sc, "VFS: Can't mix monolithic and individual options");
+ if (!data)
+ return 0;
+ if (!cfg->legacy_data) {
+ cfg->legacy_data = kmalloc(PAGE_SIZE, GFP_KERNEL);
+ if (!cfg->legacy_data)
+ return -ENOMEM;
+ }
+
+ memcpy(cfg->legacy_data, data, PAGE_SIZE);
+ cfg->data_usage = PAGE_SIZE;
+ return 0;
+}
+
+/*
+ * Use the legacy mount validation step to strip out and process security
+ * config options.
+ */
+static int legacy_validate(struct sb_config *sc)
+{
+ struct legacy_sb_config *cfg = container_of(sc, struct legacy_sb_config, sc);
+
+ if (!cfg->legacy_data || cfg->sc.fs_type->fs_flags & FS_BINARY_MOUNTDATA)
+ return 0;
+
+ cfg->secdata = alloc_secdata();
+ if (!cfg->secdata)
+ return -ENOMEM;
+
+ return security_sb_copy_data(cfg->legacy_data, cfg->secdata);
+}
+
+/*
+ * Perform a legacy mount.
+ */
+static struct dentry *legacy_mount(struct sb_config *sc)
+{
+ struct legacy_sb_config *cfg = container_of(sc, struct legacy_sb_config, sc);
+ struct super_block *sb;
+ struct dentry *root;
+ int ret;
+
+ root = cfg->sc.fs_type->mount(cfg->sc.fs_type, cfg->sc.ms_flags,
+ cfg->sc.device, cfg->legacy_data);
+ if (IS_ERR(root))
+ return ERR_CAST(root);
+
+ sb = root->d_sb;
+ BUG_ON(!sb);
+ ret = security_sb_kern_mount(sb, cfg->sc.ms_flags, cfg->secdata);
+ if (ret < 0)
+ goto err_sb;
+
+ return root;
+
+err_sb:
+ dput(root);
+ deactivate_locked_super(sb);
+ return ERR_PTR(ret);
+}
+
+static const struct sb_config_operations legacy_sb_config_ops = {
+ .free = legacy_sb_config_free,
+ .dup = legacy_sb_config_dup,
+ .parse_option = legacy_parse_option,
+ .monolithic_mount_data = legacy_monolithic_mount_data,
+ .validate = legacy_validate,
+ .mount = legacy_mount,
+};
^ permalink raw reply related [flat|nested] 28+ messages in thread* [PATCH 21/21] Add commands to create or update a superblock [ver #3]
2017-05-15 15:17 [RFC][PATCH 00/21] VFS: Introduce superblock configuration context [ver #3] David Howells
` (19 preceding siblings ...)
2017-05-15 15:20 ` [PATCH 20/21] Support legacy filesystems " David Howells
@ 2017-05-15 15:21 ` David Howells
20 siblings, 0 replies; 28+ messages in thread
From: David Howells @ 2017-05-15 15:21 UTC (permalink / raw)
To: mszeredi, viro, jlayton; +Cc: dhowells, linux-fsdevel, linux-nfs, linux-kernel
Institute a separate step in the mounting procedure:
(1) Create new sb_config context.
(2) Configure the context.
(3) Create superblock.
(4) Mount the superblock any number of times.
(5) Destroy the context.
Step (3) is added and must be given by userspace before fsmount() may be
used:
mfd = fsopen("nfs4", -1, 0);
E_write(mfd, "d warthog:/root");
E_write(mfd, "o fsc");
E_write(mfd, "o sync");
E_write(mfd, "o intr");
E_write(mfd, "o foo");
E_write(mfd, "create"); <---- here
fsmount(mfd, ...);
This the sb_config context to be used to reconfigure a superblock (not
implemented yet):
mfd = mntopen("/mnt/foo);
E_write(mfd, "o foo=1");
E_write(mfd, "o nobar");
E_write(mfd, "update"); <---- atomically update the superblock
---
Documentation/filesystems/mounting.txt | 54 ++++--
fs/fsopen.c | 43 ++++-
fs/internal.h | 2
fs/libfs.c | 16 ++
fs/namespace.c | 270 +++++++++++++++++---------------
fs/nfs/getroot.c | 76 +++++----
fs/nfs/internal.h | 18 +-
fs/nfs/mount.c | 64 ++++----
fs/nfs/nfs3proc.c | 3
fs/nfs/nfs4_fs.h | 4
fs/nfs/nfs4proc.c | 4
fs/nfs/nfs4super.c | 77 +++++----
fs/nfs/proc.c | 3
fs/nfs/super.c | 46 +++--
fs/proc/root.c | 11 +
fs/sb_config.c | 74 +++++++--
fs/super.c | 72 +--------
include/linux/fs.h | 8 -
include/linux/lsm_hooks.h | 13 +-
include/linux/nfs_xdr.h | 4
include/linux/sb_config.h | 11 +
include/linux/security.h | 11 -
security/security.c | 9 -
security/selinux/hooks.c | 31 +---
24 files changed, 484 insertions(+), 440 deletions(-)
diff --git a/Documentation/filesystems/mounting.txt b/Documentation/filesystems/mounting.txt
index 03e9086f754d..4d920ad1ef05 100644
--- a/Documentation/filesystems/mounting.txt
+++ b/Documentation/filesystems/mounting.txt
@@ -75,6 +75,7 @@ configuration context. This is represented by the sb_config structure:
struct sb_config {
const struct sb_config_operations *ops;
struct file_system_type *fs;
+ struct dentry *root;
struct user_namespace *user_ns;
struct net *net_ns;
const struct cred *cred;
@@ -82,9 +83,9 @@ configuration context. This is represented by the sb_config structure:
void *security;
const char *error_msg;
unsigned int ms_flags;
- bool mounted;
bool sloppy;
bool silent;
+ bool degraded;
enum mount_type mount_type : 8;
};
@@ -122,6 +123,11 @@ The sb_config fields are as follows:
A pointer to the file_system_type of the filesystem that is being
constructed or reconfigured. This retains a ref on the type owner.
+ (*) struct dentry *root
+
+ A pointer to the root of the mountable tree (and indirectly, the
+ superblock thereof). This is filled in by the ->get_tree() op.
+
(*) struct user_namespace *user_ns
(*) struct net *net_ns
@@ -164,12 +170,6 @@ The sb_config fields are as follows:
This holds the MS_* flags mount flags.
- (*) bool mounted
-
- This is set to true once a mount attempt is made. This causes an error to
- be given on subsequent mount attempts with the same context and prevents
- multiple mount attempts.
-
(*) bool sloppy
(*) bool silent
@@ -181,6 +181,12 @@ The sb_config fields are as follows:
[NOTE] silent is probably redundant with ms_flags & MS_SILENT.
+ (*) bool degraded
+
+ This is set if any preallocated resources in the configuration have been
+ used up, thereby rendering the configuration unreusable for the
+ ->get_tree() op.
+
(*) enum mount_type
This indicates the type of mount operation. The available values are:
@@ -217,7 +223,7 @@ The superblock configuration context points to a table of operations:
int (*parse_option)(struct sb_config *sc, char *p);
int (*monolithic_mount_data)(struct sb_config *sc, void *data);
int (*validate)(struct sb_config *sc);
- struct dentry *(*mount)(struct sb_config *sc);
+ int (*get_tree)(struct sb_config *sc);
};
These operations are invoked by the various stages of the mount procedure to
@@ -279,18 +285,18 @@ manage the superblock configuration context. They are as follows:
The return value is as for ->parse_option().
- (*) struct dentry *(*mount)(struct sb_config *sc);
+ (*) int (*get_tree)(struct sb_config *sc);
- Called to effect a new mount or new submount using the information stored
- in the superblock configuration context (remounts go via a different
- vector). It may detach any resources it desires from the superblock
- configuration context and transfer them to the superblock it creates.
+ Called to get or create the mountable root and superblock, using the
+ information stored in the superblock configuration context (remounts go
+ via a different vector). It may detach any resources it desires from the
+ superblock configuration context and transfer them to the superblock it
+ creates.
- On success it should return the dentry that's at the root of the mount.
- In future, sc->root_path will then be applied to this.
+ On success it should set sc->root to the mountable root.
- In the case of an error, it should return a negative error code and invoke
- sb_cfg_inval() or sb_cfg_error().
+ In the case of an error, it should return a negative error code and
+ consider invoking sb_cfg_inval() or sb_cfg_error().
=========================================
@@ -379,7 +385,7 @@ one for destroying a context:
extant mount and initialise the mount parameters from the superblock
underlying that mount. This is for use by remount.
- (*) struct sb_config *vfs_fsopen(const char *fs_name);
+ (*) struct sb_config *vfs_new_sb_config(const char *fs_name);
Create a superblock configuration context given a filesystem name. It is
assumed that the mount flags will be passed in as text options or set
@@ -425,11 +431,19 @@ In the remaining operations, if an error occurs, a negative error code is
returned and, if not obvious, sc->error_msg may have been set to point to a
useful string. This string should not be freed.
+ (*) int vfs_get_tree(struct sb_config *sc);
+
+ Get or create the mountable root and superblock, using the parameters in
+ the parsed configuration to select/configure the superblock. This invokes
+ the ->validate() op and then the ->get_tree() op.
+
+ [NOTE] ->validate() can probably be rolled into ->get_tree() and
+ ->remount_fs_sc().
+
(*) struct vfsmount *vfs_kern_mount_sc(struct sb_config *sc);
Create a mount given the parameters in the specified superblock
- configuration context. This invokes the ->validate() op and then the
- ->mount() op.
+ configuration context.
(*) struct vfsmount *vfs_submount_sc(const struct dentry *mountpoint,
struct sb_config *sc);
diff --git a/fs/fsopen.c b/fs/fsopen.c
index a4e9d5a7ce2b..0cc79a4f8ae7 100644
--- a/fs/fsopen.c
+++ b/fs/fsopen.c
@@ -52,22 +52,25 @@ static ssize_t fs_fs_read(struct file *file, char __user *_buf, size_t len, loff
}
/*
- * Userspace writes configuration data to the fd and we parse it here. For the
- * moment, we assume a single option per write. Each line written is of the form
+ * Userspace writes configuration data and commands to the fd and we parse it
+ * here. For the moment, we assume a single option or command per write. Each
+ * line written is of the form
*
* <option_type><space><stuff...>
+ * <command>
*
* d /dev/sda1 -- Device name
* o noatime -- Option without value
* o cell=grand.central.org -- Option with value
- * r / -- Dir within device to mount
+ * create -- Create a superblock
+ * update -- Reconfigure a superblock
*/
static ssize_t fs_fs_write(struct file *file,
const char __user *_buf, size_t len, loff_t *pos)
{
struct sb_config *sc = file->private_data;
struct inode *inode = file_inode(file);
- char opt[2], *data;
+ char opt[8], *data;
ssize_t ret;
if (len < 3 || len > 4095)
@@ -79,11 +82,21 @@ static ssize_t fs_fs_write(struct file *file,
case 's':
case 'o':
break;
+ case 'c':
+ case 'u':
+ if (len != 6)
+ goto err_bad_cmd;
+ if (copy_from_user(opt, _buf, 6) != 0)
+ return -EFAULT;
+ if (memcmp(opt, "create", 6) == 0 ||
+ memcmp(opt, "update", 6) == 0)
+ break;
+ goto err_bad_cmd;
default:
- return sb_cfg_inval(sc, "VFS: Unsupported write spec");
+ goto err_bad_cmd;
}
if (opt[1] != ' ')
- return sb_cfg_inval(sc, "VFS: Unsupported write spec");
+ goto err_bad_cmd;
data = memdup_user_nul(_buf + 2, len - 2);
if (IS_ERR(data))
@@ -96,10 +109,6 @@ static ssize_t fs_fs_write(struct file *file,
if (ret < 0)
goto err_free;
- ret = -EBUSY;
- if (sc->mounted)
- goto err_unlock;
-
ret = -EINVAL;
switch (opt[0]) {
case 's':
@@ -115,6 +124,18 @@ static ssize_t fs_fs_write(struct file *file,
goto err_unlock;
break;
+ case 'c':
+ ret = vfs_get_tree(sc);
+ if (ret < 0)
+ goto err_unlock;
+ break;
+
+ case 'u':
+ ret = vfs_reconfigure_super(sc);
+ if (ret < 0)
+ goto err_unlock;
+ break;
+
default:
goto err_unlock;
}
@@ -125,6 +146,8 @@ static ssize_t fs_fs_write(struct file *file,
err_free:
kfree(data);
return ret;
+err_bad_cmd:
+ return sb_cfg_inval(sc, "VFS: Unsupported write spec");
}
const struct file_operations fs_fs_fops = {
diff --git a/fs/internal.h b/fs/internal.h
index 39121a99d930..de9b31568f15 100644
--- a/fs/internal.h
+++ b/fs/internal.h
@@ -89,8 +89,6 @@ extern struct file *get_empty_filp(void);
*/
extern int do_remount_sb(struct super_block *, int, void *, int, struct sb_config *);
extern bool trylock_super(struct super_block *sb);
-extern struct dentry *mount_fs(struct file_system_type *,
- int, const char *, void *);
extern struct super_block *user_get_super(dev_t);
/*
diff --git a/fs/libfs.c b/fs/libfs.c
index 8ef519709ee3..e8787adf0363 100644
--- a/fs/libfs.c
+++ b/fs/libfs.c
@@ -575,13 +575,27 @@ static DEFINE_SPINLOCK(pin_fs_lock);
int simple_pin_fs(struct file_system_type *type, struct vfsmount **mount, int *count)
{
+ struct sb_config *sc;
struct vfsmount *mnt = NULL;
+ int ret;
+
spin_lock(&pin_fs_lock);
if (unlikely(!*mount)) {
spin_unlock(&pin_fs_lock);
- mnt = vfs_kern_mount(type, MS_KERNMOUNT, type->name, NULL);
+
+ sc = __vfs_new_sb_config(type, NULL, MS_KERNMOUNT, SB_CONFIG_FOR_NEW);
+ if (IS_ERR(sc))
+ return PTR_ERR(sc);
+
+ ret = vfs_get_tree(sc);
+ if (ret < 0)
+ return ret;
+
+ mnt = vfs_kern_mount_sc(sc);
+ put_sb_config(sc);
if (IS_ERR(mnt))
return PTR_ERR(mnt);
+
spin_lock(&pin_fs_lock);
if (!*mount)
*mount = mnt;
diff --git a/fs/namespace.c b/fs/namespace.c
index ce892343d1de..00bd3d627bf3 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -959,55 +959,6 @@ static struct mount *skip_mnt_tree(struct mount *p)
return p;
}
-struct vfsmount *
-vfs_kern_mount(struct file_system_type *type, int flags, const char *name, void *data)
-{
- struct mount *mnt;
- struct dentry *root;
-
- if (!type)
- return ERR_PTR(-ENODEV);
-
- mnt = alloc_vfsmnt(name);
- if (!mnt)
- return ERR_PTR(-ENOMEM);
-
- if (flags & MS_KERNMOUNT)
- mnt->mnt.mnt_flags = MNT_INTERNAL;
-
- root = mount_fs(type, flags, name, data);
- if (IS_ERR(root)) {
- mnt_free_id(mnt);
- free_vfsmnt(mnt);
- return ERR_CAST(root);
- }
-
- mnt->mnt.mnt_root = root;
- mnt->mnt.mnt_sb = root->d_sb;
- mnt->mnt_mountpoint = mnt->mnt.mnt_root;
- mnt->mnt_parent = mnt;
- lock_mount_hash();
- list_add_tail(&mnt->mnt_instance, &root->d_sb->s_mounts);
- unlock_mount_hash();
- return &mnt->mnt;
-}
-EXPORT_SYMBOL_GPL(vfs_kern_mount);
-
-struct vfsmount *
-vfs_submount(const struct dentry *mountpoint, struct file_system_type *type,
- const char *name, void *data)
-{
- /* Until it is worked out how to pass the user namespace
- * through from the parent mount to the submount don't support
- * unprivileged mounts with submounts.
- */
- if (mountpoint->d_sb->s_user_ns != &init_user_ns)
- return ERR_PTR(-EPERM);
-
- return vfs_kern_mount(type, MS_SUBMOUNT, name, data);
-}
-EXPORT_SYMBOL_GPL(vfs_submount);
-
static struct mount *clone_mnt(struct mount *old, struct dentry *root,
int flag)
{
@@ -2283,18 +2234,12 @@ static int change_mount_flags(struct vfsmount *mnt, int ms_flags)
static int parse_monolithic_mount_data(struct sb_config *sc, void *data)
{
int (*monolithic_mount_data)(struct sb_config *, void *);
- int ret;
monolithic_mount_data = sc->ops->monolithic_mount_data;
if (!monolithic_mount_data)
monolithic_mount_data = generic_monolithic_mount_data;
- ret = monolithic_mount_data(sc, data);
- if (ret < 0)
- return ret;
- if (sc->ops->validate)
- return sc->ops->validate(sc);
- return 0;
+ return monolithic_mount_data(sc, data);
}
/*
@@ -2458,29 +2403,6 @@ static int do_move_mount(struct path *path, const char *old_name)
return err;
}
-static struct vfsmount *fs_set_subtype(struct vfsmount *mnt, const char *fstype)
-{
- int err;
- const char *subtype = strchr(fstype, '.');
- if (subtype) {
- subtype++;
- err = -EINVAL;
- if (!subtype[0])
- goto err;
- } else
- subtype = "";
-
- mnt->mnt_sb->s_subtype = kstrdup(subtype, GFP_KERNEL);
- err = -ENOMEM;
- if (!mnt->mnt_sb->s_subtype)
- goto err;
- return mnt;
-
- err:
- mntput(mnt);
- return ERR_PTR(err);
-}
-
/*
* add a mount into a namespace's mount tree
*/
@@ -2541,11 +2463,10 @@ static int do_new_mount_sc(struct sb_config *sc, struct path *mountpoint,
if (IS_ERR(mnt))
return PTR_ERR(mnt);
- if ((sc->fs_type->fs_flags & FS_HAS_SUBTYPE) &&
- !mnt->mnt_sb->s_subtype) {
- mnt = fs_set_subtype(mnt, sc->fs_type->name);
- if (IS_ERR(mnt))
- return PTR_ERR(mnt);
+ if (sc->subtype && !mnt->mnt_sb->s_subtype) {
+ mnt->mnt_sb->s_subtype = kstrdup(sc->subtype, GFP_KERNEL);
+ if (!mnt->mnt_sb->s_subtype)
+ return -ENOMEM;
}
ret = -EPERM;
@@ -2580,8 +2501,10 @@ static int do_new_mount(struct path *mountpoint, const char *fstype, int flags,
return -EINVAL;
sc = vfs_new_sb_config(fstype);
- if (IS_ERR(sc))
- return PTR_ERR(sc);
+ if (IS_ERR(sc)) {
+ err = PTR_ERR(sc);
+ goto err;
+ }
sc->ms_flags = flags;
err = -ENOMEM;
@@ -2593,6 +2516,10 @@ static int do_new_mount(struct path *mountpoint, const char *fstype, int flags,
if (err < 0)
goto err_sc;
+ err = vfs_get_tree(sc);
+ if (err < 0)
+ goto err_sc;
+
err = do_new_mount_sc(sc, mountpoint, mnt_flags);
if (err)
goto err_sc;
@@ -2604,6 +2531,7 @@ static int do_new_mount(struct path *mountpoint, const char *fstype, int flags,
if (sc->error_msg)
pr_info("Mount failed: %s\n", sc->error_msg);
put_sb_config(sc);
+err:
return err;
}
@@ -3136,54 +3064,87 @@ SYSCALL_DEFINE5(mount, char __user *, dev_name, char __user *, dir_name,
return ret;
}
-static struct dentry *__do_mount_sc(struct sb_config *sc)
+/**
+ * vfs_get_tree - Get the mountable root
+ * @sc: The superblock configuration context.
+ *
+ * The filesystem is invoked to get or create a superblock which can then later
+ * be used for mounting. The filesystem places a pointer to the root to be
+ * used for mounting in @sc->root.
+ */
+int vfs_get_tree(struct sb_config *sc)
{
struct super_block *sb;
- struct dentry *root;
int ret;
- root = sc->ops->mount(sc);
- if (IS_ERR(root))
- return root;
+ if (sc->root)
+ return -EBUSY;
+
+ if (sc->ops->validate) {
+ ret = sc->ops->validate(sc);
+ if (ret < 0)
+ return ret;
+ }
+
+ /* We assume that the filesystem may transfer preallocated resources
+ * from the configuration context to the superblock, thereby rendering
+ * the config unusable for another attempt at creation if this one
+ * fails.
+ */
+ if (sc->degraded)
+ return sb_cfg_inval(sc, "VFS: The config is degraded");
+ sc->degraded = true;
+
+ /* Get the mountable root in sc->root, with a ref on the root and a ref
+ * on the superblock.
+ */
+ ret = sc->ops->get_tree(sc);
+ if (ret < 0)
+ return ret;
- sb = root->d_sb;
- BUG_ON(!sb);
+ BUG_ON(!sc->root);
+ sb = sc->root->d_sb;
WARN_ON(!sb->s_bdi);
- sb->s_flags |= MS_BORN;
- ret = security_sb_config_kern_mount(sc, sb);
+ ret = security_sb_get_tree(sc);
if (ret < 0)
goto err_sb;
- /*
- * filesystems should never set s_maxbytes larger than MAX_LFS_FILESIZE
- * but s_maxbytes was an unsigned long long for many releases. Throw
+ sb->s_flags |= MS_BORN;
+
+ /* Filesystems should never set s_maxbytes larger than MAX_LFS_FILESIZE
+ * but s_maxbytes was an unsigned long long for many releases. Throw
* this warning for a little while to try and catch filesystems that
* violate this rule.
*/
- WARN((sb->s_maxbytes < 0), "%s set sb->s_maxbytes to "
- "negative value (%lld)\n", sc->fs_type->name, sb->s_maxbytes);
+ WARN(sb->s_maxbytes < 0,
+ "%s set sb->s_maxbytes to negative value (%lld)\n",
+ sc->fs_type->name, sb->s_maxbytes);
up_write(&sb->s_umount);
- return root;
+ return 0;
err_sb:
- dput(root);
+ dput(sc->root);
+ sc->root = NULL;
deactivate_locked_super(sb);
- return ERR_PTR(ret);
+ return ret;
}
+EXPORT_SYMBOL(vfs_get_tree);
+/**
+ * vfs_kern_mount_sc - Create a mount for a configured superblock
+ * sc: The configuration context with the superblock attached
+ *
+ * Create a mount to an already configured superblock. If necessary, the
+ * caller should invoke vfs_create_super() before calling this.
+ */
struct vfsmount *vfs_kern_mount_sc(struct sb_config *sc)
{
- struct dentry *root;
struct mount *mnt;
- int ret;
- if (sc->ops->validate) {
- ret = sc->ops->validate(sc);
- if (ret < 0)
- return ERR_PTR(ret);
- }
+ if (!sc->root)
+ return ERR_PTR(sb_cfg_inval(sc, "VFS: Root must be obtained before mount"));
mnt = alloc_vfsmnt(sc->device ?: "none");
if (!mnt)
@@ -3192,24 +3153,65 @@ struct vfsmount *vfs_kern_mount_sc(struct sb_config *sc)
if (sc->ms_flags & MS_KERNMOUNT)
mnt->mnt.mnt_flags = MNT_INTERNAL;
- root = __do_mount_sc(sc);
- if (IS_ERR(root)) {
- mnt_free_id(mnt);
- free_vfsmnt(mnt);
- return ERR_CAST(root);
- }
-
- mnt->mnt.mnt_root = root;
- mnt->mnt.mnt_sb = root->d_sb;
+ atomic_inc(&sc->root->d_sb->s_active);
+ mnt->mnt.mnt_sb = sc->root->d_sb;
+ mnt->mnt.mnt_root = dget(sc->root);
mnt->mnt_mountpoint = mnt->mnt.mnt_root;
mnt->mnt_parent = mnt;
+
lock_mount_hash();
- list_add_tail(&mnt->mnt_instance, &root->d_sb->s_mounts);
+ list_add_tail(&mnt->mnt_instance, &mnt->mnt.mnt_sb->s_mounts);
unlock_mount_hash();
return &mnt->mnt;
}
EXPORT_SYMBOL_GPL(vfs_kern_mount_sc);
+struct vfsmount *vfs_kern_mount(struct file_system_type *type,
+ int flags, const char *name, void *data)
+{
+ struct sb_config *sc;
+ struct vfsmount *mnt;
+ int ret;
+
+ if (!type)
+ return ERR_PTR(-EINVAL);
+
+ sc = __vfs_new_sb_config(type, NULL, flags, SB_CONFIG_FOR_NEW);
+ if (IS_ERR(sc))
+ return ERR_CAST(sc);
+
+ if (name) {
+ ret = -ENOMEM;
+ sc->device = kstrdup(name, GFP_KERNEL);
+ if (!sc->device)
+ goto err_sc;
+ }
+
+ ret = parse_monolithic_mount_data(sc, data);
+ if (ret < 0)
+ goto err_sc;
+
+ ret = vfs_get_tree(sc);
+ if (ret < 0)
+ goto err_sc;
+
+ mnt = vfs_kern_mount_sc(sc);
+ if (IS_ERR(mnt)) {
+ ret = PTR_ERR(mnt);
+ goto err_sc;
+ }
+
+ put_sb_config(sc);
+ return mnt;
+
+err_sc:
+ if (sc->error_msg)
+ pr_info("Kernmount failed: %s\n", sc->error_msg);
+ put_sb_config(sc);
+ return ERR_PTR(ret);
+}
+EXPORT_SYMBOL_GPL(vfs_kern_mount);
+
struct vfsmount *
vfs_submount_sc(const struct dentry *mountpoint, struct sb_config *sc)
{
@@ -3225,6 +3227,21 @@ vfs_submount_sc(const struct dentry *mountpoint, struct sb_config *sc)
}
EXPORT_SYMBOL_GPL(vfs_submount_sc);
+struct vfsmount *
+vfs_submount(const struct dentry *mountpoint, struct file_system_type *type,
+ const char *name, void *data)
+{
+ /* Until it is worked out how to pass the user namespace
+ * through from the parent mount to the submount don't support
+ * unprivileged mounts with submounts.
+ */
+ if (mountpoint->d_sb->s_user_ns != &init_user_ns)
+ return ERR_PTR(-EPERM);
+
+ return vfs_kern_mount(type, MS_SUBMOUNT, name, data);
+}
+EXPORT_SYMBOL_GPL(vfs_submount);
+
/*
* Mount a new, prepared superblock (specified by fs_fd) on the location
* specified by dfd and dir_name. dfd can be AT_FDCWD, a dir fd or a container
@@ -3283,17 +3300,14 @@ SYSCALL_DEFINE5(fsmount, int, fs_fd, int, dfd, const char __user *, dir_name,
((sc->ms_flags & MS_MANDLOCK) && !may_mandlock()))
goto err_fsfd;
- /* Prevent further changes. */
+ /* There must be a valid superblock or we can't mount it */
inode = file_inode(f.file);
ret = inode_lock_killable(inode);
- if (ret < 0)
- goto err_fsfd;
- ret = -EBUSY;
- if (!sc->mounted) {
- sc->mounted = true;
- ret = 0;
+ if (ret == 0) {
+ if (!sc->root)
+ ret = sb_cfg_inval(sc, "VFS: Root must be obtained before mount");
+ inode_unlock(inode);
}
- inode_unlock(inode);
if (ret < 0)
goto err_fsfd;
diff --git a/fs/nfs/getroot.c b/fs/nfs/getroot.c
index 391dafaf9182..f564ab76708f 100644
--- a/fs/nfs/getroot.c
+++ b/fs/nfs/getroot.c
@@ -66,68 +66,72 @@ static int nfs_superblock_set_dummy_root(struct super_block *sb, struct inode *i
}
/*
- * get an NFS2/NFS3 root dentry from the root filehandle
+ * get an NFS2/NFS3 root dentry from the root filehandle.
*/
-struct dentry *nfs_get_root(struct super_block *sb, struct nfs_fh *mntfh,
- const char *devname)
+int nfs_get_root(struct super_block *s, struct nfs_sb_config *cfg)
{
- struct nfs_server *server = NFS_SB(sb);
+ struct nfs_server *server = NFS_SB(s);
struct nfs_fsinfo fsinfo;
- struct dentry *ret;
+ struct dentry *root;
struct inode *inode;
- void *name = kstrdup(devname, GFP_KERNEL);
- int error;
+ char *name;
+ int error = -ENOMEM;
+ name = kstrdup(cfg->sc.device, GFP_KERNEL);
if (!name)
- return ERR_PTR(-ENOMEM);
-
+ goto out;
+
/* get the actual root for this mount */
fsinfo.fattr = nfs_alloc_fattr();
- if (fsinfo.fattr == NULL) {
- kfree(name);
- return ERR_PTR(-ENOMEM);
- }
+ if (fsinfo.fattr == NULL)
+ goto out_name;
- error = server->nfs_client->rpc_ops->getroot(server, mntfh, &fsinfo);
+ error = server->nfs_client->rpc_ops->getroot(server, cfg->mntfh, &fsinfo);
if (error < 0) {
dprintk("nfs_get_root: getattr error = %d\n", -error);
- ret = ERR_PTR(error);
- goto out;
+ nfs_cfg_error(cfg, "NFS: Couldn't getattr on root");
+ goto out_fattr;
}
- inode = nfs_fhget(sb, mntfh, fsinfo.fattr, NULL);
+ inode = nfs_fhget(s, cfg->mntfh, fsinfo.fattr, NULL);
if (IS_ERR(inode)) {
dprintk("nfs_get_root: get root inode failed\n");
- ret = ERR_CAST(inode);
- goto out;
+ error = PTR_ERR(inode);
+ nfs_cfg_error(cfg, "NFS: Couldn't get root inode");
+ goto out_fattr;
}
- error = nfs_superblock_set_dummy_root(sb, inode);
- if (error != 0) {
- ret = ERR_PTR(error);
- goto out;
- }
+ error = nfs_superblock_set_dummy_root(s, inode);
+ if (error != 0)
+ goto out_fattr;
/* root dentries normally start off anonymous and get spliced in later
* if the dentry tree reaches them; however if the dentry already
* exists, we'll pick it up at this point and use it as the root
*/
- ret = d_obtain_root(inode);
- if (IS_ERR(ret)) {
+ root = d_obtain_root(inode);
+ if (IS_ERR(root)) {
dprintk("nfs_get_root: get root dentry failed\n");
- goto out;
+ error = PTR_ERR(root);
+ nfs_cfg_error(cfg, "NFS: Couldn't get root dentry");
+ goto out_fattr;
}
- security_d_instantiate(ret, inode);
- spin_lock(&ret->d_lock);
- if (IS_ROOT(ret) && !ret->d_fsdata &&
- !(ret->d_flags & DCACHE_NFSFS_RENAMED)) {
- ret->d_fsdata = name;
+ security_d_instantiate(root, inode);
+ spin_lock(&root->d_lock);
+ if (IS_ROOT(root) && !root->d_fsdata &&
+ !(root->d_flags & DCACHE_NFSFS_RENAMED)) {
+ root->d_fsdata = name;
name = NULL;
}
- spin_unlock(&ret->d_lock);
-out:
- kfree(name);
+ spin_unlock(&root->d_lock);
+ cfg->sc.root = root;
+ error = 0;
+
+out_fattr:
nfs_free_fattr(fsinfo.fattr);
- return ret;
+out_name:
+ kfree(name);
+out:
+ return error;
}
diff --git a/fs/nfs/internal.h b/fs/nfs/internal.h
index b9231c6359f2..83e536e02208 100644
--- a/fs/nfs/internal.h
+++ b/fs/nfs/internal.h
@@ -131,8 +131,7 @@ struct nfs_sb_config {
struct nfs_fh *mntfh;
struct nfs_subversion *nfs_mod;
- int (*set_security)(struct super_block *, struct dentry *,
- struct nfs_sb_config *);
+ int (*set_security)(struct super_block *, struct nfs_sb_config *);
/* Information for a cloned mount. */
struct nfs_clone_mount {
@@ -416,10 +415,10 @@ extern int nfs_wait_atomic_killable(atomic_t *p);
extern const struct super_operations nfs_sops;
extern struct file_system_type nfs_fs_type;
bool nfs_auth_info_match(const struct nfs_auth_info *, rpc_authflavor_t);
-struct dentry *nfs_try_mount(struct nfs_sb_config *);
-int nfs_set_sb_security(struct super_block *, struct dentry *, struct nfs_sb_config *);
-int nfs_clone_sb_security(struct super_block *, struct dentry *, struct nfs_sb_config *);
-struct dentry *nfs_fs_mount_common(struct nfs_server *, struct nfs_sb_config *);
+int nfs_try_get_tree(struct nfs_sb_config *);
+int nfs_set_sb_security(struct super_block *, struct nfs_sb_config *);
+int nfs_clone_sb_security(struct super_block *, struct nfs_sb_config *);
+int nfs_get_tree_common(struct nfs_server *, struct nfs_sb_config *);
void nfs_kill_super(struct super_block *);
extern struct rpc_stat nfs_rpcstat;
@@ -453,12 +452,9 @@ struct vfsmount *nfs_do_submount(struct dentry *, struct nfs_fh *,
struct nfs_fattr *, rpc_authflavor_t);
/* getroot.c */
-extern struct dentry *nfs_get_root(struct super_block *, struct nfs_fh *,
- const char *);
+extern int nfs_get_root(struct super_block *s, struct nfs_sb_config *cfg);
#if IS_ENABLED(CONFIG_NFS_V4)
-extern struct dentry *nfs4_get_root(struct super_block *, struct nfs_fh *,
- const char *);
-
+extern int nfs4_get_root(struct super_block *s, struct nfs_sb_config *cfg);
extern int nfs4_get_rootfh(struct nfs_server *server, struct nfs_fh *mntfh, bool);
#endif
diff --git a/fs/nfs/mount.c b/fs/nfs/mount.c
index 188ee4b324d9..00946475abd2 100644
--- a/fs/nfs/mount.c
+++ b/fs/nfs/mount.c
@@ -1276,20 +1276,20 @@ static int nfs_sb_config_validate(struct sb_config *sc)
/*
* Use the preparsed information in the mount context to effect a mount.
*/
-static struct dentry *nfs_ordinary_mount(struct nfs_sb_config *cfg)
+static int nfs_get_ordinary_tree(struct nfs_sb_config *cfg)
{
cfg->set_security = nfs_set_sb_security;
- return cfg->nfs_mod->rpc_ops->try_mount(cfg);
+ return cfg->nfs_mod->rpc_ops->try_get_tree(cfg);
}
/*
* Clone an NFS2/3/4 server record on xdev traversal (FSID-change)
*/
-static struct dentry *nfs_xdev_mount(struct nfs_sb_config *cfg)
+static int nfs_get_xdev_tree(struct nfs_sb_config *cfg)
{
struct nfs_server *server;
- struct dentry *mntroot = ERR_PTR(-ENOMEM);
+ int ret;
dprintk("--> nfs_xdev_mount()\n");
@@ -1302,52 +1302,48 @@ static struct dentry *nfs_xdev_mount(struct nfs_sb_config *cfg)
cfg->selected_flavor);
if (IS_ERR(server))
- mntroot = ERR_CAST(server);
+ ret = PTR_ERR(server);
else
- mntroot = nfs_fs_mount_common(server, cfg);
+ ret = nfs_get_tree_common(server, cfg);
- dprintk("<-- nfs_xdev_mount() = %ld\n",
- IS_ERR(mntroot) ? PTR_ERR(mntroot) : 0L);
- return mntroot;
+ dprintk("<-- nfs_get_xdev_tree() = %d\n", ret);
+ return ret;
}
/*
- * Handle ordinary mounts inspired by the user and cross-FSID mounts.
+ * Create an NFS superblock by the appropriate method.
*/
-struct dentry *nfs_general_mount(struct nfs_sb_config *cfg)
-{
- switch (cfg->mount_type) {
- case NFS_MOUNT_ORDINARY:
- return nfs_ordinary_mount(cfg);
-
- case NFS_MOUNT_CROSS_DEV:
- return nfs_xdev_mount(cfg);
-
- default:
- nfs_cfg_error(cfg, "NFS: Unknown mount type");
- return ERR_PTR(-ENOTSUPP);
- }
-}
-EXPORT_SYMBOL_GPL(nfs_general_mount);
-
-static struct dentry *nfs_fs_mount(struct sb_config *sc)
+static int nfs_get_tree(struct sb_config *sc)
{
struct nfs_sb_config *cfg = container_of(sc, struct nfs_sb_config, sc);
+ int ret;
if (!cfg->nfs_mod) {
pr_warn("Missing nfs_mod\n");
- return ERR_PTR(-EINVAL);
+ return -EINVAL;
}
if (!cfg->nfs_mod->rpc_ops) {
pr_warn("Missing rpc_ops\n");
- return ERR_PTR(-EINVAL);
+ return -EINVAL;
}
- if (!cfg->nfs_mod->rpc_ops->mount) {
- pr_warn("Missing mount\n");
- return ERR_PTR(-EINVAL);
+
+ if (cfg->nfs_mod->rpc_ops->get_tree) {
+ ret = cfg->nfs_mod->rpc_ops->get_tree(cfg);
+ if (ret != 1)
+ return ret;
}
- return cfg->nfs_mod->rpc_ops->mount(cfg);
+ switch (cfg->mount_type) {
+ case NFS_MOUNT_ORDINARY:
+ return nfs_get_ordinary_tree(cfg);
+
+ case NFS_MOUNT_CROSS_DEV:
+ return nfs_get_xdev_tree(cfg);
+
+ default:
+ nfs_cfg_error(cfg, "NFS: Unknown mount type");
+ return -ENOTSUPP;
+ }
}
/*
@@ -1394,7 +1390,7 @@ static const struct sb_config_operations nfs_sb_config_ops = {
.parse_option = nfs_sb_config_parse_option,
.monolithic_mount_data = nfs_monolithic_mount_data,
.validate = nfs_sb_config_validate,
- .mount = nfs_fs_mount,
+ .get_tree = nfs_get_tree,
};
/*
diff --git a/fs/nfs/nfs3proc.c b/fs/nfs/nfs3proc.c
index ce926c8431d4..96e315916a34 100644
--- a/fs/nfs/nfs3proc.c
+++ b/fs/nfs/nfs3proc.c
@@ -974,9 +974,8 @@ const struct nfs_rpc_ops nfs_v3_clientops = {
.file_ops = &nfs_file_operations,
.nlmclnt_ops = &nlmclnt_fl_close_lock_ops,
.getroot = nfs3_proc_get_root,
- .mount = nfs_general_mount,
.submount = nfs_submount,
- .try_mount = nfs_try_mount,
+ .try_get_tree = nfs_try_get_tree,
.getattr = nfs3_proc_getattr,
.setattr = nfs3_proc_setattr,
.lookup = nfs3_proc_lookup,
diff --git a/fs/nfs/nfs4_fs.h b/fs/nfs/nfs4_fs.h
index 05769b633b76..effcea28d7cc 100644
--- a/fs/nfs/nfs4_fs.h
+++ b/fs/nfs/nfs4_fs.h
@@ -476,8 +476,8 @@ extern bool recover_lost_locks;
#define NFS4_CLIENT_ID_UNIQ_LEN (64)
extern char nfs4_client_id_uniquifier[NFS4_CLIENT_ID_UNIQ_LEN];
-extern struct dentry *nfs4_try_mount(struct nfs_sb_config *);
-extern struct dentry *nfs4_mount(struct nfs_sb_config *);
+extern int nfs4_try_get_tree(struct nfs_sb_config *);
+extern int nfs4_get_tree(struct nfs_sb_config *);
/* nfs4sysctl.c */
#ifdef CONFIG_SYSCTL
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index 9f9bacdf6f86..ca792f799941 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -9307,9 +9307,9 @@ const struct nfs_rpc_ops nfs_v4_clientops = {
.file_inode_ops = &nfs4_file_inode_operations,
.file_ops = &nfs4_file_operations,
.getroot = nfs4_proc_get_root,
- .mount = nfs4_mount,
+ .get_tree = nfs4_get_tree,
.submount = nfs4_submount,
- .try_mount = nfs4_try_mount,
+ .try_get_tree = nfs4_try_get_tree,
.getattr = nfs4_proc_getattr,
.setattr = nfs4_proc_setattr,
.lookup = nfs4_proc_lookup,
diff --git a/fs/nfs/nfs4super.c b/fs/nfs/nfs4super.c
index 7bc27a28d5da..853e20a25333 100644
--- a/fs/nfs/nfs4super.c
+++ b/fs/nfs/nfs4super.c
@@ -18,9 +18,6 @@
static int nfs4_write_inode(struct inode *inode, struct writeback_control *wbc);
static void nfs4_evict_inode(struct inode *inode);
-static struct dentry *nfs4_remote_mount(struct nfs_sb_config *cfg);
-static struct dentry *nfs4_referral_mount(struct nfs_sb_config *cfg);
-static struct dentry *nfs4_remote_referral_mount(struct nfs_sb_config *cfg);
static const struct super_operations nfs4_sops = {
.alloc_inode = nfs_alloc_inode,
@@ -77,7 +74,7 @@ static void nfs4_evict_inode(struct inode *inode)
/*
* Get the superblock for the NFS4 root partition
*/
-static struct dentry *nfs4_remote_mount(struct nfs_sb_config *cfg)
+static int nfs4_get_remote_tree(struct nfs_sb_config *cfg)
{
struct nfs_server *server;
@@ -86,9 +83,9 @@ static struct dentry *nfs4_remote_mount(struct nfs_sb_config *cfg)
/* Get a volume representation */
server = nfs4_create_server(cfg);
if (IS_ERR(server))
- return ERR_CAST(server);
+ return PTR_ERR(server);
- return nfs_fs_mount_common(server, cfg);
+ return nfs_get_tree_common(server, cfg);
}
/*
@@ -104,6 +101,7 @@ static struct vfsmount *nfs_do_root_mount(struct nfs_sb_config *cfg,
struct vfsmount *root_mnt;
char *root_devname;
size_t len;
+ int ret;
root_sc = vfs_dup_sb_config(&cfg->sc);
if (IS_ERR(root_sc))
@@ -126,6 +124,10 @@ static struct vfsmount *nfs_do_root_mount(struct nfs_sb_config *cfg,
snprintf(root_devname, len, "%s:/", hostname);
root_cfg->sc.device = root_devname;
+ ret = vfs_get_tree(&root_cfg->sc);
+ if (ret < 0)
+ return ERR_PTR(ret);
+
root_mnt = vfs_kern_mount_sc(&root_cfg->sc);
out_sc:
put_sb_config(root_sc);
@@ -219,12 +221,12 @@ static struct dentry *nfs_follow_remote_path(struct vfsmount *root_mnt,
return dentry;
}
-struct dentry *nfs4_try_mount(struct nfs_sb_config *cfg)
+int nfs4_try_get_tree(struct nfs_sb_config *cfg)
{
struct vfsmount *root_mnt;
- struct dentry *res;
+ struct dentry *root;
- dfprintk(MOUNT, "--> nfs4_try_mount()\n");
+ dfprintk(MOUNT, "--> nfs4_try_get_tree()\n");
/* We create a mount for the server's root, walk to the requested
* location and then create another mount for that.
@@ -232,74 +234,83 @@ struct dentry *nfs4_try_mount(struct nfs_sb_config *cfg)
root_mnt = nfs_do_root_mount(cfg, cfg->nfs_server.hostname,
NFS4_MOUNT_REMOTE);
if (IS_ERR(root_mnt))
- return ERR_CAST(root_mnt);
+ return PTR_ERR(root_mnt);
- res = nfs_follow_remote_path(root_mnt, cfg->nfs_server.export_path);
- if (IS_ERR(res))
+ root = nfs_follow_remote_path(root_mnt, cfg->nfs_server.export_path);
+ if (IS_ERR(root)) {
nfs_cfg_error(cfg, "NFS4: Couldn't follow remote path");
+ dfprintk(MOUNT, "<-- nfs4_try_mount() = %ld [error]\n",
+ PTR_ERR(root));
+ return PTR_ERR(root);
+ }
- dfprintk(MOUNT, "<-- nfs4_try_mount() = %d%s\n",
- PTR_ERR_OR_ZERO(res),
- IS_ERR(res) ? " [error]" : "");
- return res;
+ cfg->sc.root = root;
+ dfprintk(MOUNT, "<-- nfs4_try_get_tree() = 0\n");
+ return 0;
}
-static struct dentry *nfs4_remote_referral_mount(struct nfs_sb_config *cfg)
+static int nfs4_get_remote_referral_tree(struct nfs_sb_config *cfg)
{
struct nfs_server *server;
- dprintk("--> nfs4_referral_get_sb()\n");
+ dprintk("--> nfs4_get_remote_referral_tree()\n");
cfg->set_security = nfs_clone_sb_security;
if (!cfg->clone_data.cloned)
- return ERR_PTR(-EINVAL);
+ return -EINVAL;
/* create a new volume representation */
server = nfs4_create_referral_server(cfg);
if (IS_ERR(server))
- return ERR_CAST(server);
+ return PTR_ERR(server);
- return nfs_fs_mount_common(server, cfg);
+ return nfs_get_tree_common(server, cfg);
}
/*
* Create an NFS4 server record on referral traversal
*/
-static struct dentry *nfs4_referral_mount(struct nfs_sb_config *cfg)
+static int nfs4_get_referral_tree(struct nfs_sb_config *cfg)
{
struct vfsmount *root_mnt;
- struct dentry *res;
+ struct dentry *root;
dprintk("--> nfs4_referral_mount()\n");
root_mnt = nfs_do_root_mount(cfg, cfg->nfs_server.hostname,
NFS4_MOUNT_REMOTE_REFERRAL);
- res = nfs_follow_remote_path(root_mnt, cfg->nfs_server.export_path);
- dprintk("<-- nfs4_referral_mount() = %d%s\n",
- PTR_ERR_OR_ZERO(res),
- IS_ERR(res) ? " [error]" : "");
- return res;
+ root = nfs_follow_remote_path(root_mnt, cfg->nfs_server.export_path);
+ if (IS_ERR(root)) {
+ nfs_cfg_error(cfg, "NFS4: Couldn't follow remote path");
+ dfprintk(MOUNT, "<-- nfs4_referral_mount() = %ld [error]\n",
+ PTR_ERR(root));
+ return PTR_ERR(root);
+ }
+
+ cfg->sc.root = root;
+ dfprintk(MOUNT, "<-- nfs4_get_referral_tree() = 0\n");
+ return 0;
}
/*
* Handle special NFS4 mount types.
*/
-struct dentry *nfs4_mount(struct nfs_sb_config *cfg)
+int nfs4_get_tree(struct nfs_sb_config *cfg)
{
switch (cfg->mount_type) {
case NFS4_MOUNT_REMOTE:
- return nfs4_remote_mount(cfg);
+ return nfs4_get_remote_tree(cfg);
case NFS4_MOUNT_REFERRAL:
- return nfs4_referral_mount(cfg);
+ return nfs4_get_referral_tree(cfg);
case NFS4_MOUNT_REMOTE_REFERRAL:
- return nfs4_remote_referral_mount(cfg);
+ return nfs4_get_remote_referral_tree(cfg);
default:
- return nfs_general_mount(cfg);
+ return 1;
}
}
diff --git a/fs/nfs/proc.c b/fs/nfs/proc.c
index aab90fd09e75..cd22b82e7bb8 100644
--- a/fs/nfs/proc.c
+++ b/fs/nfs/proc.c
@@ -704,9 +704,8 @@ const struct nfs_rpc_ops nfs_v2_clientops = {
.file_inode_ops = &nfs_file_inode_operations,
.file_ops = &nfs_file_operations,
.getroot = nfs_proc_get_root,
- .mount = nfs_general_mount,
.submount = nfs_submount,
- .try_mount = nfs_try_mount,
+ .try_get_tree = nfs_try_get_tree,
.getattr = nfs_proc_getattr,
.setattr = nfs_proc_setattr,
.lookup = nfs_proc_lookup,
diff --git a/fs/nfs/super.c b/fs/nfs/super.c
index a705d6730921..240d48e040e6 100644
--- a/fs/nfs/super.c
+++ b/fs/nfs/super.c
@@ -855,7 +855,7 @@ static struct nfs_server *nfs_try_mount_request(struct nfs_sb_config *cfg)
return cfg->nfs_mod->rpc_ops->create_server(cfg);
}
-struct dentry *nfs_try_mount(struct nfs_sb_config *cfg)
+int nfs_try_get_tree(struct nfs_sb_config *cfg)
{
struct nfs_server *server;
@@ -866,12 +866,12 @@ struct dentry *nfs_try_mount(struct nfs_sb_config *cfg)
if (IS_ERR(server)) {
nfs_cfg_error(cfg, "NFS: Couldn't create server");
- return ERR_CAST(server);
+ return PTR_ERR(server);
}
- return nfs_fs_mount_common(server, cfg);
+ return nfs_get_tree_common(server, cfg);
}
-EXPORT_SYMBOL_GPL(nfs_try_mount);
+EXPORT_SYMBOL_GPL(nfs_try_get_tree);
#define NFS_REMOUNT_CMP_FLAGMASK ~(NFS_MOUNT_INTR \
@@ -1164,40 +1164,38 @@ static void nfs_get_cache_cookie(struct super_block *sb,
}
#endif
-int nfs_set_sb_security(struct super_block *s, struct dentry *mntroot,
- struct nfs_sb_config *cfg)
+int nfs_set_sb_security(struct super_block *sb, struct nfs_sb_config *cfg)
{
int error;
unsigned long kflags = 0, kflags_out = 0;
- if (NFS_SB(s)->caps & NFS_CAP_SECURITY_LABEL)
+ if (NFS_SB(sb)->caps & NFS_CAP_SECURITY_LABEL)
kflags |= SECURITY_LSM_NATIVE_LABELS;
- error = security_sb_set_mnt_opts(s, cfg->sc.security,
+ error = security_sb_set_mnt_opts(sb, cfg->sc.security,
kflags, &kflags_out);
if (error)
goto err;
- if (NFS_SB(s)->caps & NFS_CAP_SECURITY_LABEL &&
- !(kflags_out & SECURITY_LSM_NATIVE_LABELS))
- NFS_SB(s)->caps &= ~NFS_CAP_SECURITY_LABEL;
+ if (NFS_SB(sb)->caps & NFS_CAP_SECURITY_LABEL &&
+ !(kflags_out & SECURITY_LSM_NATIVE_LABELS))
+ NFS_SB(sb)->caps &= ~NFS_CAP_SECURITY_LABEL;
err:
return error;
}
EXPORT_SYMBOL_GPL(nfs_set_sb_security);
-int nfs_clone_sb_security(struct super_block *s, struct dentry *mntroot,
- struct nfs_sb_config *cfg)
+int nfs_clone_sb_security(struct super_block *sb, struct nfs_sb_config *cfg)
{
/* clone any lsm security options from the parent to the new sb */
- if (d_inode(mntroot)->i_op != NFS_SB(s)->nfs_client->rpc_ops->dir_inode_ops)
+ if (d_inode(cfg->sc.root)->i_op !=
+ NFS_SB(sb)->nfs_client->rpc_ops->dir_inode_ops)
return -ESTALE;
- return security_sb_clone_mnt_opts(cfg->clone_data.sb, s);
+ return security_sb_clone_mnt_opts(cfg->clone_data.sb, sb);
}
EXPORT_SYMBOL_GPL(nfs_clone_sb_security);
-struct dentry *nfs_fs_mount_common(struct nfs_server *server,
- struct nfs_sb_config *cfg)
+int nfs_get_tree_common(struct nfs_server *server, struct nfs_sb_config *cfg)
{
struct super_block *s;
struct dentry *mntroot = ERR_PTR(-ENOMEM);
@@ -1223,7 +1221,7 @@ struct dentry *nfs_fs_mount_common(struct nfs_server *server,
s = sget(cfg->nfs_mod->nfs_fs, compare_super, nfs_set_super, cfg->sc.ms_flags,
&sb_mntdata);
if (IS_ERR(s)) {
- mntroot = ERR_CAST(s);
+ error = PTR_ERR(s);
nfs_cfg_error(cfg, "NFS: Couldn't get superblock");
goto out_err_nosb;
}
@@ -1251,20 +1249,21 @@ struct dentry *nfs_fs_mount_common(struct nfs_server *server,
nfs_get_cache_cookie(s, cfg);
}
- mntroot = nfs_get_root(s, cfg->mntfh, cfg->sc.device);
- if (IS_ERR(mntroot)) {
+ error = nfs_get_root(s, cfg);
+ if (error < 0) {
nfs_cfg_error(cfg, "NFS: Couldn't get root dentry");
goto error_splat_super;
}
- error = cfg->set_security(s, mntroot, cfg);
+ error = cfg->set_security(s, cfg);
if (error)
goto error_splat_root;
s->s_flags |= MS_ACTIVE;
+ error = 0;
out:
- return mntroot;
+ return error;
out_err_nosb:
nfs_free_server(server);
@@ -1272,12 +1271,11 @@ struct dentry *nfs_fs_mount_common(struct nfs_server *server,
error_splat_root:
dput(mntroot);
- mntroot = ERR_PTR(error);
error_splat_super:
deactivate_locked_super(s);
goto out;
}
-EXPORT_SYMBOL_GPL(nfs_fs_mount_common);
+EXPORT_SYMBOL_GPL(nfs_get_tree_common);
/*
* Destroy an NFS2/3 superblock
diff --git a/fs/proc/root.c b/fs/proc/root.c
index da5757d1c518..8781415be2e0 100644
--- a/fs/proc/root.c
+++ b/fs/proc/root.c
@@ -148,7 +148,7 @@ int proc_remount(struct super_block *sb, struct sb_config *sc)
return 0;
}
-static struct dentry *proc_mount(struct sb_config *sc)
+static int proc_get_tree(struct sb_config *sc)
{
struct proc_sb_config *cfg = container_of(sc, struct proc_sb_config, sc);
@@ -166,7 +166,7 @@ static void proc_sb_config_free(struct sb_config *sc)
static const struct sb_config_operations proc_sb_config_ops = {
.free = proc_sb_config_free,
.parse_option = proc_parse_mount_option,
- .mount = proc_mount,
+ .get_tree = proc_get_tree,
};
static int proc_init_sb_config(struct sb_config *sc, struct super_block *src_sb)
@@ -298,6 +298,7 @@ int pid_ns_prepare_proc(struct pid_namespace *ns)
struct proc_sb_config *cfg;
struct sb_config *sc;
struct vfsmount *mnt;
+ int ret;
sc = __vfs_new_sb_config(&proc_fs_type, NULL, 0, SB_CONFIG_FOR_NEW);
if (IS_ERR(sc))
@@ -310,6 +311,12 @@ int pid_ns_prepare_proc(struct pid_namespace *ns)
cfg->pid_ns = ns;
}
+ ret = vfs_get_tree(sc);
+ if (ret < 0) {
+ put_sb_config(sc);
+ return ret;
+ }
+
mnt = kern_mount_data_sc(sc);
put_sb_config(sc);
if (IS_ERR(mnt))
diff --git a/fs/sb_config.c b/fs/sb_config.c
index 62e309cd62ef..6b6853b6d769 100644
--- a/fs/sb_config.c
+++ b/fs/sb_config.c
@@ -127,9 +127,6 @@ int vfs_parse_mount_option(struct sb_config *sc, char *p)
{
int ret;
- if (sc->mounted)
- return -EBUSY;
-
ret = vfs_parse_ms_mount_option(sc, p);
if (ret < 0)
return ret;
@@ -324,19 +321,44 @@ struct sb_config *vfs_dup_sb_config(struct sb_config *src_sc)
EXPORT_SYMBOL(vfs_dup_sb_config);
/**
+ * vfs_reconfigure_super - Reconfigure a superblock.
+ * @sc: The configuration updates to apply
+ */
+int vfs_reconfigure_super(struct sb_config *sc)
+{
+ pr_notice("*** vfs_reconfigure_super()\n");
+
+ if (!sc->root)
+ return -EINVAL;
+ return -ENOANO; // TODO
+}
+EXPORT_SYMBOL(vfs_reconfigure_super);
+
+/**
* put_sb_config - Dispose of a superblock configuration context.
* @sc: The context to dispose of.
*/
void put_sb_config(struct sb_config *sc)
{
+ struct super_block *sb;
+
+ if (sc->root) {
+ sb = sc->root->d_sb;
+ dput(sc->root);
+ sc->root = NULL;
+ deactivate_super(sb);
+ }
+
if (sc->ops && sc->ops->free)
sc->ops->free(sc);
+
security_sb_config_free(sc);
if (sc->net_ns)
put_net(sc->net_ns);
put_user_ns(sc->user_ns);
if (sc->cred)
put_cred(sc->cred);
+ kfree(sc->subtype);
put_filesystem(sc->fs_type);
kfree(sc->device);
kfree(sc);
@@ -438,9 +460,30 @@ static int legacy_validate(struct sb_config *sc)
}
/*
- * Perform a legacy mount.
+ * Determine the superblock subtype.
*/
-static struct dentry *legacy_mount(struct sb_config *sc)
+static int legacy_set_subtype(struct sb_config *sc)
+{
+ const char *subtype = strchr(sc->fs_type->name, '.');
+
+ if (subtype) {
+ subtype++;
+ if (!subtype[0])
+ return -EINVAL;
+ } else {
+ subtype = "";
+ }
+
+ sc->subtype = kstrdup(subtype, GFP_KERNEL);
+ if (!sc->subtype)
+ return -ENOMEM;
+ return 0;
+}
+
+/*
+ * Get a mountable root with the legacy mount command.
+ */
+static int legacy_get_tree(struct sb_config *sc)
{
struct legacy_sb_config *cfg = container_of(sc, struct legacy_sb_config, sc);
struct super_block *sb;
@@ -448,22 +491,27 @@ static struct dentry *legacy_mount(struct sb_config *sc)
int ret;
root = cfg->sc.fs_type->mount(cfg->sc.fs_type, cfg->sc.ms_flags,
- cfg->sc.device, cfg->legacy_data);
+ cfg->sc.device, cfg->legacy_data);
if (IS_ERR(root))
- return ERR_CAST(root);
+ return PTR_ERR(root);
sb = root->d_sb;
BUG_ON(!sb);
- ret = security_sb_kern_mount(sb, cfg->sc.ms_flags, cfg->secdata);
- if (ret < 0)
- goto err_sb;
- return root;
+ if ((cfg->sc.fs_type->fs_flags & FS_HAS_SUBTYPE) &&
+ !sc->subtype) {
+ ret = legacy_set_subtype(sc);
+ if (ret < 0)
+ goto err_sb;
+ }
+
+ cfg->sc.root = root;
+ return 0;
err_sb:
dput(root);
deactivate_locked_super(sb);
- return ERR_PTR(ret);
+ return ret;
}
static const struct sb_config_operations legacy_sb_config_ops = {
@@ -472,5 +520,5 @@ static const struct sb_config_operations legacy_sb_config_ops = {
.parse_option = legacy_parse_option,
.monolithic_mount_data = legacy_monolithic_mount_data,
.validate = legacy_validate,
- .mount = legacy_mount,
+ .get_tree = legacy_get_tree,
};
diff --git a/fs/super.c b/fs/super.c
index 4d923a775bd0..7ca217552977 100644
--- a/fs/super.c
+++ b/fs/super.c
@@ -1058,10 +1058,9 @@ struct dentry *mount_ns(struct file_system_type *fs_type,
EXPORT_SYMBOL(mount_ns);
-struct dentry *mount_ns_sc(struct sb_config *sc,
- int (*fill_super)(struct super_block *sb,
- struct sb_config *sc),
- void *ns)
+int mount_ns_sc(struct sb_config *sc,
+ int (*fill_super)(struct super_block *sb, struct sb_config *sc),
+ void *ns)
{
struct super_block *sb;
@@ -1070,25 +1069,29 @@ struct dentry *mount_ns_sc(struct sb_config *sc,
*/
if (!(sc->ms_flags & MS_KERNMOUNT) &&
!ns_capable(sc->user_ns, CAP_SYS_ADMIN))
- return ERR_PTR(-EPERM);
+ return -EPERM;
sb = sget_userns(sc->fs_type, ns_test_super, ns_set_super,
sc->ms_flags, sc->user_ns, ns);
if (IS_ERR(sb))
- return ERR_CAST(sb);
+ return PTR_ERR(sb);
if (!sb->s_root) {
int err;
err = fill_super(sb, sc);
if (err) {
deactivate_locked_super(sb);
- return ERR_PTR(err);
+ return err;
}
sb->s_flags |= MS_ACTIVE;
}
- return dget(sb->s_root);
+ if (!sc->root) {
+ sc->root = sb->s_root;
+ dget(sb->s_root);
+ }
+ return 0;
}
EXPORT_SYMBOL(mount_ns_sc);
@@ -1246,59 +1249,6 @@ struct dentry *mount_single(struct file_system_type *fs_type,
}
EXPORT_SYMBOL(mount_single);
-struct dentry *
-mount_fs(struct file_system_type *type, int flags, const char *name, void *data)
-{
- struct dentry *root;
- struct super_block *sb;
- char *secdata = NULL;
- int error = -ENOMEM;
-
- if (data && !(type->fs_flags & FS_BINARY_MOUNTDATA)) {
- secdata = alloc_secdata();
- if (!secdata)
- goto out;
-
- error = security_sb_copy_data(data, secdata);
- if (error)
- goto out_free_secdata;
- }
-
- root = type->mount(type, flags, name, data);
- if (IS_ERR(root)) {
- error = PTR_ERR(root);
- goto out_free_secdata;
- }
- sb = root->d_sb;
- BUG_ON(!sb);
- WARN_ON(!sb->s_bdi);
- sb->s_flags |= MS_BORN;
-
- error = security_sb_kern_mount(sb, flags, secdata);
- if (error)
- goto out_sb;
-
- /*
- * filesystems should never set s_maxbytes larger than MAX_LFS_FILESIZE
- * but s_maxbytes was an unsigned long long for many releases. Throw
- * this warning for a little while to try and catch filesystems that
- * violate this rule.
- */
- WARN((sb->s_maxbytes < 0), "%s set sb->s_maxbytes to "
- "negative value (%lld)\n", type->name, sb->s_maxbytes);
-
- up_write(&sb->s_umount);
- free_secdata(secdata);
- return root;
-out_sb:
- dput(root);
- deactivate_locked_super(sb);
-out_free_secdata:
- free_secdata(secdata);
-out:
- return ERR_PTR(error);
-}
-
/*
* Setup private BDI for given superblock. It gets automatically cleaned up
* in generic_shutdown_super().
diff --git a/include/linux/fs.h b/include/linux/fs.h
index cd6cafcdd2ff..1acb76f400c4 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -2049,10 +2049,10 @@ struct file_system_type {
#define MODULE_ALIAS_FS(NAME) MODULE_ALIAS("fs-" NAME)
-extern struct dentry *mount_ns_sc(struct sb_config *mc,
- int (*fill_super)(struct super_block *sb,
- struct sb_config *sc),
- void *ns);
+extern int mount_ns_sc(struct sb_config *mc,
+ int (*fill_super)(struct super_block *sb,
+ struct sb_config *sc),
+ void *ns);
extern struct dentry *mount_ns(struct file_system_type *fs_type,
int flags, void *data, void *ns, struct user_namespace *user_ns,
int (*fill_super)(struct super_block *, void *, int));
diff --git a/include/linux/lsm_hooks.h b/include/linux/lsm_hooks.h
index 9d974074940b..e80ff0a301d0 100644
--- a/include/linux/lsm_hooks.h
+++ b/include/linux/lsm_hooks.h
@@ -97,10 +97,11 @@
* filesystem.
* @sc indicates the superblock configuration context.
* @p indicates the option in "key[=val]" form.
- * @sb_config_kern_mount:
- * Equivalent of sb_kern_mount, but with a superblock configuration context.
+ * @sb_get_tree:
+ * Assign the security to a newly created superblock.
* @sc indicates the superblock configuration context.
- * @src_sb indicates the new superblock.
+ * @sc->root indicates the root that will be mounted.
+ * @sc->root->d_sb points to the superblock.
* @sb_config_mountpoint:
* Equivalent of sb_mount, but with an sb_config.
* @sc indicates the superblock configuration context.
@@ -1407,14 +1408,13 @@ union security_list_options {
int (*sb_config_dup)(struct sb_config *sc, struct sb_config *src_sc);
void (*sb_config_free)(struct sb_config *sc);
int (*sb_config_parse_option)(struct sb_config *sc, char *opt);
- int (*sb_config_kern_mount)(struct sb_config *sc, struct super_block *sb);
+ int (*sb_get_tree)(struct sb_config *sc);
int (*sb_config_mountpoint)(struct sb_config *sc, struct path *mountpoint);
int (*sb_alloc_security)(struct super_block *sb);
void (*sb_free_security)(struct super_block *sb);
int (*sb_copy_data)(char *orig, char *copy);
int (*sb_remount)(struct super_block *sb, void *data);
- int (*sb_kern_mount)(struct super_block *sb, int flags, void *data);
int (*sb_show_options)(struct seq_file *m, struct super_block *sb);
int (*sb_statfs)(struct dentry *dentry);
int (*sb_mount)(const char *dev_name, const struct path *path,
@@ -1725,13 +1725,12 @@ struct security_hook_heads {
struct list_head sb_config_dup;
struct list_head sb_config_free;
struct list_head sb_config_parse_option;
- struct list_head sb_config_kern_mount;
+ struct list_head sb_get_tree;
struct list_head sb_config_mountpoint;
struct list_head sb_alloc_security;
struct list_head sb_free_security;
struct list_head sb_copy_data;
struct list_head sb_remount;
- struct list_head sb_kern_mount;
struct list_head sb_show_options;
struct list_head sb_statfs;
struct list_head sb_mount;
diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h
index 250d27088309..7804241739a0 100644
--- a/include/linux/nfs_xdr.h
+++ b/include/linux/nfs_xdr.h
@@ -1557,10 +1557,10 @@ struct nfs_rpc_ops {
int (*getroot) (struct nfs_server *, struct nfs_fh *,
struct nfs_fsinfo *);
- struct dentry *(*mount)(struct nfs_sb_config *);
+ int (*get_tree)(struct nfs_sb_config *);
struct vfsmount *(*submount) (struct nfs_server *, struct dentry *,
struct nfs_fh *, struct nfs_fattr *);
- struct dentry *(*try_mount) (struct nfs_sb_config *);
+ int (*try_get_tree) (struct nfs_sb_config *);
int (*getattr) (struct nfs_server *, struct nfs_fh *,
struct nfs_fattr *, struct nfs4_label *);
int (*setattr) (struct dentry *, struct nfs_fattr *,
diff --git a/include/linux/sb_config.h b/include/linux/sb_config.h
index 0b21e381d9f0..5d84175386d3 100644
--- a/include/linux/sb_config.h
+++ b/include/linux/sb_config.h
@@ -38,21 +38,26 @@ enum sb_config_purpose {
* allocated is specified in struct file_system_type::sb_config_size and this
* must include sufficient space for the sb_config struct.
*
+ * Superblock creation fills in ->root whereas reconfiguration begins with this
+ * already set.
+ *
* See Documentation/filesystems/mounting.txt
*/
struct sb_config {
const struct sb_config_operations *ops;
struct file_system_type *fs_type;
+ struct dentry *root; /* The root and superblock */
struct user_namespace *user_ns; /* The user namespace for this mount */
struct net *net_ns; /* The network namespace for this mount */
const struct cred *cred; /* The mounter's credentials */
char *device; /* The device name or mount target */
+ char *subtype; /* The subtype to set on the superblock */
void *security; /* The LSM context */
const char *error_msg; /* Error string to be read by read() */
unsigned int ms_flags; /* The superblock flags (MS_*) */
- bool mounted; /* Set when mounted */
bool sloppy; /* Unrecognised options are okay */
bool silent;
+ bool degraded; /* True if the config can't be reused */
enum sb_config_purpose purpose : 8;
};
@@ -62,7 +67,7 @@ struct sb_config_operations {
int (*parse_option)(struct sb_config *sc, char *p);
int (*monolithic_mount_data)(struct sb_config *sc, void *data);
int (*validate)(struct sb_config *sc);
- struct dentry *(*mount)(struct sb_config *sc);
+ int (*get_tree)(struct sb_config *sc);
};
extern const struct file_operations fs_fs_fops;
@@ -77,6 +82,8 @@ extern struct sb_config *vfs_sb_reconfig(struct vfsmount *mnt,
extern struct sb_config *vfs_dup_sb_config(struct sb_config *src);
extern int vfs_parse_mount_option(struct sb_config *sc, char *data);
extern int generic_monolithic_mount_data(struct sb_config *sc, void *data);
+extern int vfs_get_tree(struct sb_config *sc);
+extern int vfs_reconfigure_super(struct sb_config *sc);
extern void put_sb_config(struct sb_config *sc);
static inline void sb_cfg_error(struct sb_config *sc, const char *msg)
diff --git a/include/linux/security.h b/include/linux/security.h
index 3d9d41d91a99..1307295db29a 100644
--- a/include/linux/security.h
+++ b/include/linux/security.h
@@ -229,13 +229,12 @@ int security_sb_config_alloc(struct sb_config *sc, struct super_block *sb);
int security_sb_config_dup(struct sb_config *sc, struct sb_config *src_sc);
void security_sb_config_free(struct sb_config *sc);
int security_sb_config_parse_option(struct sb_config *sc, char *opt);
-int security_sb_config_kern_mount(struct sb_config *sc, struct super_block *sb);
+int security_sb_get_tree(struct sb_config *sc);
int security_sb_config_mountpoint(struct sb_config *sc, struct path *mountpoint);
int security_sb_alloc(struct super_block *sb);
void security_sb_free(struct super_block *sb);
int security_sb_copy_data(char *orig, char *copy);
int security_sb_remount(struct super_block *sb, void *data);
-int security_sb_kern_mount(struct super_block *sb, int flags, void *data);
int security_sb_show_options(struct seq_file *m, struct super_block *sb);
int security_sb_statfs(struct dentry *dentry);
int security_sb_mount(const char *dev_name, const struct path *path,
@@ -544,8 +543,7 @@ static inline int security_sb_config_parse_option(struct sb_config *sc, char *op
{
return 0;
}
-static inline int security_sb_config_kern_mount(struct sb_config *sc,
- struct super_block *sb)
+static inline int security_sb_get_tree(struct sb_config *sc)
{
return 0;
}
@@ -573,11 +571,6 @@ static inline int security_sb_remount(struct super_block *sb, void *data)
return 0;
}
-static inline int security_sb_kern_mount(struct super_block *sb, int flags, void *data)
-{
- return 0;
-}
-
static inline int security_sb_show_options(struct seq_file *m,
struct super_block *sb)
{
diff --git a/security/security.c b/security/security.c
index 197ff60b57a7..3efe7d1c54a2 100644
--- a/security/security.c
+++ b/security/security.c
@@ -336,9 +336,9 @@ int security_sb_config_parse_option(struct sb_config *sc, char *opt)
return call_int_hook(sb_config_parse_option, 0, sc, opt);
}
-int security_sb_config_kern_mount(struct sb_config *sc, struct super_block *sb)
+int security_sb_get_tree(struct sb_config *sc)
{
- return call_int_hook(sb_config_kern_mount, 0, sc, sb);
+ return call_int_hook(sb_get_tree, 0, sc);
}
int security_sb_config_mountpoint(struct sb_config *sc, struct path *mountpoint)
@@ -367,11 +367,6 @@ int security_sb_remount(struct super_block *sb, void *data)
return call_int_hook(sb_remount, 0, sb, data);
}
-int security_sb_kern_mount(struct super_block *sb, int flags, void *data)
-{
- return call_int_hook(sb_kern_mount, 0, sb, flags, data);
-}
-
int security_sb_show_options(struct seq_file *m, struct super_block *sb)
{
return call_int_hook(sb_show_options, 0, m, sb);
diff --git a/security/selinux/hooks.c b/security/selinux/hooks.c
index f073b94c0035..7801d0c55f3f 100644
--- a/security/selinux/hooks.c
+++ b/security/selinux/hooks.c
@@ -2775,25 +2775,6 @@ static int selinux_sb_remount(struct super_block *sb, void *data)
goto out_free_opts;
}
-static int selinux_sb_kern_mount(struct super_block *sb, int flags, void *data)
-{
- const struct cred *cred = current_cred();
- struct common_audit_data ad;
- int rc;
-
- rc = superblock_doinit(sb, data);
- if (rc)
- return rc;
-
- /* Allow all mounts performed by the kernel */
- if (flags & MS_KERNMOUNT)
- return 0;
-
- ad.type = LSM_AUDIT_DATA_DENTRY;
- ad.u.dentry = sb->s_root;
- return superblock_has_perm(cred, sb, FILESYSTEM__MOUNT, &ad);
-}
-
static int selinux_sb_statfs(struct dentry *dentry)
{
const struct cred *cred = current_cred();
@@ -2967,14 +2948,13 @@ static int selinux_sb_config_parse_option(struct sb_config *sc, char *opt)
return sb_cfg_inval(sc, "SELinux: Incompatible mount options");
}
-static int selinux_sb_config_kern_mount(struct sb_config *sc,
- struct super_block *sb)
+static int selinux_sb_get_tree(struct sb_config *sc)
{
const struct cred *cred = current_cred();
struct common_audit_data ad;
int rc;
- rc = selinux_set_mnt_opts(sb, sc->security, 0, NULL);
+ rc = selinux_set_mnt_opts(sc->root->d_sb, sc->security, 0, NULL);
if (rc)
return rc;
@@ -2983,8 +2963,8 @@ static int selinux_sb_config_kern_mount(struct sb_config *sc,
return 0;
ad.type = LSM_AUDIT_DATA_DENTRY;
- ad.u.dentry = sb->s_root;
- rc = superblock_has_perm(cred, sb, FILESYSTEM__MOUNT, &ad);
+ ad.u.dentry = sc->root;
+ rc = superblock_has_perm(cred, sc->root->d_sb, FILESYSTEM__MOUNT, &ad);
if (rc < 0)
sb_cfg_error(sc, "SELinux: Mount of superblock not permitted");
return rc;
@@ -6334,14 +6314,13 @@ static struct security_hook_list selinux_hooks[] __lsm_ro_after_init = {
LSM_HOOK_INIT(sb_config_dup, selinux_sb_config_dup),
LSM_HOOK_INIT(sb_config_free, selinux_sb_config_free),
LSM_HOOK_INIT(sb_config_parse_option, selinux_sb_config_parse_option),
- LSM_HOOK_INIT(sb_config_kern_mount, selinux_sb_config_kern_mount),
+ LSM_HOOK_INIT(sb_get_tree, selinux_sb_get_tree),
LSM_HOOK_INIT(sb_config_mountpoint, selinux_sb_config_mountpoint),
LSM_HOOK_INIT(sb_alloc_security, selinux_sb_alloc_security),
LSM_HOOK_INIT(sb_free_security, selinux_sb_free_security),
LSM_HOOK_INIT(sb_copy_data, selinux_sb_copy_data),
LSM_HOOK_INIT(sb_remount, selinux_sb_remount),
- LSM_HOOK_INIT(sb_kern_mount, selinux_sb_kern_mount),
LSM_HOOK_INIT(sb_show_options, selinux_sb_show_options),
LSM_HOOK_INIT(sb_statfs, selinux_sb_statfs),
LSM_HOOK_INIT(sb_mount, selinux_mount),
^ permalink raw reply related [flat|nested] 28+ messages in thread