2019-05-28 20:10:12 +03:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-only
|
2005-04-17 02:20:36 +04:00
|
|
|
/*
|
|
|
|
* linux/fs/namespace.c
|
|
|
|
*
|
|
|
|
* (C) Copyright Al Viro 2000, 2001
|
|
|
|
*
|
|
|
|
* Based on code from fs/super.c, copyright Linus Torvalds and others.
|
|
|
|
* Heavily rewritten.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/syscalls.h>
|
2011-12-07 22:06:11 +04:00
|
|
|
#include <linux/export.h>
|
2006-01-11 23:17:46 +03:00
|
|
|
#include <linux/capability.h>
|
2006-12-08 13:37:56 +03:00
|
|
|
#include <linux/mnt_namespace.h>
|
2012-07-27 08:08:32 +04:00
|
|
|
#include <linux/user_namespace.h>
|
2005-04-17 02:20:36 +04:00
|
|
|
#include <linux/namei.h>
|
|
|
|
#include <linux/security.h>
|
2017-02-02 19:54:15 +03:00
|
|
|
#include <linux/cred.h>
|
2008-03-27 00:11:34 +03:00
|
|
|
#include <linux/idr.h>
|
2013-09-12 01:26:10 +04:00
|
|
|
#include <linux/init.h> /* init_rootfs */
|
2011-12-07 22:06:11 +04:00
|
|
|
#include <linux/fs_struct.h> /* get_fs_root et.al. */
|
|
|
|
#include <linux/fsnotify.h> /* fsnotify_vfsmount_delete */
|
2018-11-05 20:40:30 +03:00
|
|
|
#include <linux/file.h>
|
2011-12-07 22:06:11 +04:00
|
|
|
#include <linux/uaccess.h>
|
2013-04-12 04:50:06 +04:00
|
|
|
#include <linux/proc_ns.h>
|
2013-05-02 04:51:54 +04:00
|
|
|
#include <linux/magic.h>
|
2018-10-31 01:09:49 +03:00
|
|
|
#include <linux/memblock.h>
|
2021-01-21 16:19:54 +03:00
|
|
|
#include <linux/proc_fs.h>
|
2014-08-08 21:08:20 +04:00
|
|
|
#include <linux/task_work.h>
|
2017-02-04 03:20:53 +03:00
|
|
|
#include <linux/sched/task.h>
|
2018-11-02 02:07:23 +03:00
|
|
|
#include <uapi/linux/mount.h>
|
2018-11-04 11:19:03 +03:00
|
|
|
#include <linux/fs_context.h>
|
2019-06-02 01:09:44 +03:00
|
|
|
#include <linux/shmem_fs.h>
|
2021-12-03 14:17:07 +03:00
|
|
|
#include <linux/mnt_idmapping.h>
|
2017-02-04 03:20:53 +03:00
|
|
|
|
2005-11-08 01:19:07 +03:00
|
|
|
#include "pnode.h"
|
2007-07-16 10:41:25 +04:00
|
|
|
#include "internal.h"
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2016-09-28 08:27:17 +03:00
|
|
|
/* Maximum number of mounts in a mount namespace */
|
2022-01-22 09:13:27 +03:00
|
|
|
static unsigned int sysctl_mount_max __read_mostly = 100000;
|
2016-09-28 08:27:17 +03:00
|
|
|
|
2014-02-28 22:46:44 +04:00
|
|
|
static unsigned int m_hash_mask __read_mostly;
|
|
|
|
static unsigned int m_hash_shift __read_mostly;
|
|
|
|
static unsigned int mp_hash_mask __read_mostly;
|
|
|
|
static unsigned int mp_hash_shift __read_mostly;
|
|
|
|
|
|
|
|
static __initdata unsigned long mhash_entries;
|
|
|
|
static int __init set_mhash_entries(char *str)
|
|
|
|
{
|
|
|
|
if (!str)
|
|
|
|
return 0;
|
|
|
|
mhash_entries = simple_strtoul(str, &str, 0);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
__setup("mhash_entries=", set_mhash_entries);
|
|
|
|
|
|
|
|
static __initdata unsigned long mphash_entries;
|
|
|
|
static int __init set_mphash_entries(char *str)
|
|
|
|
{
|
|
|
|
if (!str)
|
|
|
|
return 0;
|
|
|
|
mphash_entries = simple_strtoul(str, &str, 0);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
__setup("mphash_entries=", set_mphash_entries);
|
2008-02-06 12:37:57 +03:00
|
|
|
|
2014-02-27 23:40:10 +04:00
|
|
|
static u64 event;
|
2008-03-27 00:11:34 +03:00
|
|
|
static DEFINE_IDA(mnt_id_ida);
|
2008-03-27 15:06:23 +03:00
|
|
|
static DEFINE_IDA(mnt_group_ida);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2014-03-21 05:10:51 +04:00
|
|
|
static struct hlist_head *mount_hashtable __read_mostly;
|
2014-02-28 22:46:44 +04:00
|
|
|
static struct hlist_head *mountpoint_hashtable __read_mostly;
|
2006-12-07 07:33:20 +03:00
|
|
|
static struct kmem_cache *mnt_cache __read_mostly;
|
2013-09-17 05:34:53 +04:00
|
|
|
static DECLARE_RWSEM(namespace_sem);
|
2019-06-30 17:39:08 +03:00
|
|
|
static HLIST_HEAD(unmounted); /* protected by namespace_sem */
|
|
|
|
static LIST_HEAD(ex_mountpoints); /* protected by namespace_sem */
|
2005-04-17 02:20:36 +04:00
|
|
|
|
fs: add mount_setattr()
This implements the missing mount_setattr() syscall. While the new mount
api allows to change the properties of a superblock there is currently
no way to change the properties of a mount or a mount tree using file
descriptors which the new mount api is based on. In addition the old
mount api has the restriction that mount options cannot be applied
recursively. This hasn't changed since changing mount options on a
per-mount basis was implemented in [1] and has been a frequent request
not just for convenience but also for security reasons. The legacy
mount syscall is unable to accommodate this behavior without introducing
a whole new set of flags because MS_REC | MS_REMOUNT | MS_BIND |
MS_RDONLY | MS_NOEXEC | [...] only apply the mount option to the topmost
mount. Changing MS_REC to apply to the whole mount tree would mean
introducing a significant uapi change and would likely cause significant
regressions.
The new mount_setattr() syscall allows to recursively clear and set
mount options in one shot. Multiple calls to change mount options
requesting the same changes are idempotent:
int mount_setattr(int dfd, const char *path, unsigned flags,
struct mount_attr *uattr, size_t usize);
Flags to modify path resolution behavior are specified in the @flags
argument. Currently, AT_EMPTY_PATH, AT_RECURSIVE, AT_SYMLINK_NOFOLLOW,
and AT_NO_AUTOMOUNT are supported. If useful, additional lookup flags to
restrict path resolution as introduced with openat2() might be supported
in the future.
The mount_setattr() syscall can be expected to grow over time and is
designed with extensibility in mind. It follows the extensible syscall
pattern we have used with other syscalls such as openat2(), clone3(),
sched_{set,get}attr(), and others.
The set of mount options is passed in the uapi struct mount_attr which
currently has the following layout:
struct mount_attr {
__u64 attr_set;
__u64 attr_clr;
__u64 propagation;
__u64 userns_fd;
};
The @attr_set and @attr_clr members are used to clear and set mount
options. This way a user can e.g. request that a set of flags is to be
raised such as turning mounts readonly by raising MOUNT_ATTR_RDONLY in
@attr_set while at the same time requesting that another set of flags is
to be lowered such as removing noexec from a mount tree by specifying
MOUNT_ATTR_NOEXEC in @attr_clr.
Note, since the MOUNT_ATTR_<atime> values are an enum starting from 0,
not a bitmap, users wanting to transition to a different atime setting
cannot simply specify the atime setting in @attr_set, but must also
specify MOUNT_ATTR__ATIME in the @attr_clr field. So we ensure that
MOUNT_ATTR__ATIME can't be partially set in @attr_clr and that @attr_set
can't have any atime bits set if MOUNT_ATTR__ATIME isn't set in
@attr_clr.
The @propagation field lets callers specify the propagation type of a
mount tree. Propagation is a single property that has four different
settings and as such is not really a flag argument but an enum.
Specifically, it would be unclear what setting and clearing propagation
settings in combination would amount to. The legacy mount() syscall thus
forbids the combination of multiple propagation settings too. The goal
is to keep the semantics of mount propagation somewhat simple as they
are overly complex as it is.
The @userns_fd field lets user specify a user namespace whose idmapping
becomes the idmapping of the mount. This is implemented and explained in
detail in the next patch.
[1]: commit 2e4b7fcd9260 ("[PATCH] r/o bind mounts: honor mount writer counts at remount")
Link: https://lore.kernel.org/r/20210121131959.646623-35-christian.brauner@ubuntu.com
Cc: David Howells <dhowells@redhat.com>
Cc: Aleksa Sarai <cyphar@cyphar.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: linux-fsdevel@vger.kernel.org
Cc: linux-api@vger.kernel.org
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Christian Brauner <christian.brauner@ubuntu.com>
2021-01-21 16:19:53 +03:00
|
|
|
struct mount_kattr {
|
|
|
|
unsigned int attr_set;
|
|
|
|
unsigned int attr_clr;
|
|
|
|
unsigned int propagation;
|
|
|
|
unsigned int lookup_flags;
|
|
|
|
bool recurse;
|
2021-01-21 16:19:54 +03:00
|
|
|
struct user_namespace *mnt_userns;
|
2022-10-26 13:51:27 +03:00
|
|
|
struct mnt_idmap *mnt_idmap;
|
fs: add mount_setattr()
This implements the missing mount_setattr() syscall. While the new mount
api allows to change the properties of a superblock there is currently
no way to change the properties of a mount or a mount tree using file
descriptors which the new mount api is based on. In addition the old
mount api has the restriction that mount options cannot be applied
recursively. This hasn't changed since changing mount options on a
per-mount basis was implemented in [1] and has been a frequent request
not just for convenience but also for security reasons. The legacy
mount syscall is unable to accommodate this behavior without introducing
a whole new set of flags because MS_REC | MS_REMOUNT | MS_BIND |
MS_RDONLY | MS_NOEXEC | [...] only apply the mount option to the topmost
mount. Changing MS_REC to apply to the whole mount tree would mean
introducing a significant uapi change and would likely cause significant
regressions.
The new mount_setattr() syscall allows to recursively clear and set
mount options in one shot. Multiple calls to change mount options
requesting the same changes are idempotent:
int mount_setattr(int dfd, const char *path, unsigned flags,
struct mount_attr *uattr, size_t usize);
Flags to modify path resolution behavior are specified in the @flags
argument. Currently, AT_EMPTY_PATH, AT_RECURSIVE, AT_SYMLINK_NOFOLLOW,
and AT_NO_AUTOMOUNT are supported. If useful, additional lookup flags to
restrict path resolution as introduced with openat2() might be supported
in the future.
The mount_setattr() syscall can be expected to grow over time and is
designed with extensibility in mind. It follows the extensible syscall
pattern we have used with other syscalls such as openat2(), clone3(),
sched_{set,get}attr(), and others.
The set of mount options is passed in the uapi struct mount_attr which
currently has the following layout:
struct mount_attr {
__u64 attr_set;
__u64 attr_clr;
__u64 propagation;
__u64 userns_fd;
};
The @attr_set and @attr_clr members are used to clear and set mount
options. This way a user can e.g. request that a set of flags is to be
raised such as turning mounts readonly by raising MOUNT_ATTR_RDONLY in
@attr_set while at the same time requesting that another set of flags is
to be lowered such as removing noexec from a mount tree by specifying
MOUNT_ATTR_NOEXEC in @attr_clr.
Note, since the MOUNT_ATTR_<atime> values are an enum starting from 0,
not a bitmap, users wanting to transition to a different atime setting
cannot simply specify the atime setting in @attr_set, but must also
specify MOUNT_ATTR__ATIME in the @attr_clr field. So we ensure that
MOUNT_ATTR__ATIME can't be partially set in @attr_clr and that @attr_set
can't have any atime bits set if MOUNT_ATTR__ATIME isn't set in
@attr_clr.
The @propagation field lets callers specify the propagation type of a
mount tree. Propagation is a single property that has four different
settings and as such is not really a flag argument but an enum.
Specifically, it would be unclear what setting and clearing propagation
settings in combination would amount to. The legacy mount() syscall thus
forbids the combination of multiple propagation settings too. The goal
is to keep the semantics of mount propagation somewhat simple as they
are overly complex as it is.
The @userns_fd field lets user specify a user namespace whose idmapping
becomes the idmapping of the mount. This is implemented and explained in
detail in the next patch.
[1]: commit 2e4b7fcd9260 ("[PATCH] r/o bind mounts: honor mount writer counts at remount")
Link: https://lore.kernel.org/r/20210121131959.646623-35-christian.brauner@ubuntu.com
Cc: David Howells <dhowells@redhat.com>
Cc: Aleksa Sarai <cyphar@cyphar.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: linux-fsdevel@vger.kernel.org
Cc: linux-api@vger.kernel.org
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Christian Brauner <christian.brauner@ubuntu.com>
2021-01-21 16:19:53 +03:00
|
|
|
};
|
|
|
|
|
2006-01-17 09:14:23 +03:00
|
|
|
/* /sys/fs */
|
2007-10-29 23:17:23 +03:00
|
|
|
struct kobject *fs_kobj;
|
|
|
|
EXPORT_SYMBOL_GPL(fs_kobj);
|
2006-01-17 09:14:23 +03:00
|
|
|
|
fs: brlock vfsmount_lock
fs: brlock vfsmount_lock
Use a brlock for the vfsmount lock. It must be taken for write whenever
modifying the mount hash or associated fields, and may be taken for read when
performing mount hash lookups.
A new lock is added for the mnt-id allocator, so it doesn't need to take
the heavy vfsmount write-lock.
The number of atomics should remain the same for fastpath rlock cases, though
code would be slightly slower due to per-cpu access. Scalability is not not be
much improved in common cases yet, due to other locks (ie. dcache_lock) getting
in the way. However path lookups crossing mountpoints should be one case where
scalability is improved (currently requiring the global lock).
The slowpath is slower due to use of brlock. On a 64 core, 64 socket, 32 node
Altix system (high latency to remote nodes), a simple umount microbenchmark
(mount --bind mnt mnt2 ; umount mnt2 loop 1000 times), before this patch it
took 6.8s, afterwards took 7.1s, about 5% slower.
Cc: Al Viro <viro@ZenIV.linux.org.uk>
Signed-off-by: Nick Piggin <npiggin@kernel.dk>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2010-08-17 22:37:39 +04:00
|
|
|
/*
|
|
|
|
* vfsmount lock may be taken for read to prevent changes to the
|
|
|
|
* vfsmount hash, ie. during mountpoint lookups or walking back
|
|
|
|
* up the tree.
|
|
|
|
*
|
|
|
|
* It should be taken for write in all cases where the vfsmount
|
|
|
|
* tree or hash is modified or when a vfsmount structure is modified.
|
|
|
|
*/
|
2013-09-30 06:06:07 +04:00
|
|
|
__cacheline_aligned_in_smp DEFINE_SEQLOCK(mount_lock);
|
fs: brlock vfsmount_lock
fs: brlock vfsmount_lock
Use a brlock for the vfsmount lock. It must be taken for write whenever
modifying the mount hash or associated fields, and may be taken for read when
performing mount hash lookups.
A new lock is added for the mnt-id allocator, so it doesn't need to take
the heavy vfsmount write-lock.
The number of atomics should remain the same for fastpath rlock cases, though
code would be slightly slower due to per-cpu access. Scalability is not not be
much improved in common cases yet, due to other locks (ie. dcache_lock) getting
in the way. However path lookups crossing mountpoints should be one case where
scalability is improved (currently requiring the global lock).
The slowpath is slower due to use of brlock. On a 64 core, 64 socket, 32 node
Altix system (high latency to remote nodes), a simple umount microbenchmark
(mount --bind mnt mnt2 ; umount mnt2 loop 1000 times), before this patch it
took 6.8s, afterwards took 7.1s, about 5% slower.
Cc: Al Viro <viro@ZenIV.linux.org.uk>
Signed-off-by: Nick Piggin <npiggin@kernel.dk>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2010-08-17 22:37:39 +04:00
|
|
|
|
2021-01-21 16:19:49 +03:00
|
|
|
static inline void lock_mount_hash(void)
|
|
|
|
{
|
|
|
|
write_seqlock(&mount_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void unlock_mount_hash(void)
|
|
|
|
{
|
|
|
|
write_sequnlock(&mount_lock);
|
|
|
|
}
|
|
|
|
|
2014-03-21 05:10:51 +04:00
|
|
|
static inline struct hlist_head *m_hash(struct vfsmount *mnt, struct dentry *dentry)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2005-11-08 01:16:09 +03:00
|
|
|
unsigned long tmp = ((unsigned long)mnt / L1_CACHE_BYTES);
|
|
|
|
tmp += ((unsigned long)dentry / L1_CACHE_BYTES);
|
2014-02-28 22:46:44 +04:00
|
|
|
tmp = tmp + (tmp >> m_hash_shift);
|
|
|
|
return &mount_hashtable[tmp & m_hash_mask];
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct hlist_head *mp_hash(struct dentry *dentry)
|
|
|
|
{
|
|
|
|
unsigned long tmp = ((unsigned long)dentry / L1_CACHE_BYTES);
|
|
|
|
tmp = tmp + (tmp >> mp_hash_shift);
|
|
|
|
return &mountpoint_hashtable[tmp & mp_hash_mask];
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2011-11-25 05:38:33 +04:00
|
|
|
static int mnt_alloc_id(struct mount *mnt)
|
2008-03-27 00:11:34 +03:00
|
|
|
{
|
2018-06-11 19:31:36 +03:00
|
|
|
int res = ida_alloc(&mnt_id_ida, GFP_KERNEL);
|
|
|
|
|
|
|
|
if (res < 0)
|
|
|
|
return res;
|
|
|
|
mnt->mnt_id = res;
|
|
|
|
return 0;
|
2008-03-27 00:11:34 +03:00
|
|
|
}
|
|
|
|
|
2011-11-25 05:38:33 +04:00
|
|
|
static void mnt_free_id(struct mount *mnt)
|
2008-03-27 00:11:34 +03:00
|
|
|
{
|
2018-06-11 19:31:36 +03:00
|
|
|
ida_free(&mnt_id_ida, mnt->mnt_id);
|
2008-03-27 00:11:34 +03:00
|
|
|
}
|
|
|
|
|
2008-03-27 15:06:23 +03:00
|
|
|
/*
|
|
|
|
* Allocate a new peer group ID
|
|
|
|
*/
|
2011-11-25 04:54:23 +04:00
|
|
|
static int mnt_alloc_group_id(struct mount *mnt)
|
2008-03-27 15:06:23 +03:00
|
|
|
{
|
2018-06-11 19:31:36 +03:00
|
|
|
int res = ida_alloc_min(&mnt_group_ida, 1, GFP_KERNEL);
|
2009-06-24 11:12:00 +04:00
|
|
|
|
2018-06-11 19:31:36 +03:00
|
|
|
if (res < 0)
|
|
|
|
return res;
|
|
|
|
mnt->mnt_group_id = res;
|
|
|
|
return 0;
|
2008-03-27 15:06:23 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Release a peer group ID
|
|
|
|
*/
|
2011-11-25 04:54:23 +04:00
|
|
|
void mnt_release_group_id(struct mount *mnt)
|
2008-03-27 15:06:23 +03:00
|
|
|
{
|
2018-06-11 19:31:36 +03:00
|
|
|
ida_free(&mnt_group_ida, mnt->mnt_group_id);
|
2011-11-25 09:50:41 +04:00
|
|
|
mnt->mnt_group_id = 0;
|
2008-03-27 15:06:23 +03:00
|
|
|
}
|
|
|
|
|
fs: scale mntget/mntput
The problem that this patch aims to fix is vfsmount refcounting scalability.
We need to take a reference on the vfsmount for every successful path lookup,
which often go to the same mount point.
The fundamental difficulty is that a "simple" reference count can never be made
scalable, because any time a reference is dropped, we must check whether that
was the last reference. To do that requires communication with all other CPUs
that may have taken a reference count.
We can make refcounts more scalable in a couple of ways, involving keeping
distributed counters, and checking for the global-zero condition less
frequently.
- check the global sum once every interval (this will delay zero detection
for some interval, so it's probably a showstopper for vfsmounts).
- keep a local count and only taking the global sum when local reaches 0 (this
is difficult for vfsmounts, because we can't hold preempt off for the life of
a reference, so a counter would need to be per-thread or tied strongly to a
particular CPU which requires more locking).
- keep a local difference of increments and decrements, which allows us to sum
the total difference and hence find the refcount when summing all CPUs. Then,
keep a single integer "long" refcount for slow and long lasting references,
and only take the global sum of local counters when the long refcount is 0.
This last scheme is what I implemented here. Attached mounts and process root
and working directory references are "long" references, and everything else is
a short reference.
This allows scalable vfsmount references during path walking over mounted
subtrees and unattached (lazy umounted) mounts with processes still running
in them.
This results in one fewer atomic op in the fastpath: mntget is now just a
per-CPU inc, rather than an atomic inc; and mntput just requires a spinlock
and non-atomic decrement in the common case. However code is otherwise bigger
and heavier, so single threaded performance is basically a wash.
Signed-off-by: Nick Piggin <npiggin@kernel.dk>
2011-01-07 09:50:11 +03:00
|
|
|
/*
|
|
|
|
* vfsmount lock must be held for read
|
|
|
|
*/
|
2011-11-25 07:37:54 +04:00
|
|
|
static inline void mnt_add_count(struct mount *mnt, int n)
|
fs: scale mntget/mntput
The problem that this patch aims to fix is vfsmount refcounting scalability.
We need to take a reference on the vfsmount for every successful path lookup,
which often go to the same mount point.
The fundamental difficulty is that a "simple" reference count can never be made
scalable, because any time a reference is dropped, we must check whether that
was the last reference. To do that requires communication with all other CPUs
that may have taken a reference count.
We can make refcounts more scalable in a couple of ways, involving keeping
distributed counters, and checking for the global-zero condition less
frequently.
- check the global sum once every interval (this will delay zero detection
for some interval, so it's probably a showstopper for vfsmounts).
- keep a local count and only taking the global sum when local reaches 0 (this
is difficult for vfsmounts, because we can't hold preempt off for the life of
a reference, so a counter would need to be per-thread or tied strongly to a
particular CPU which requires more locking).
- keep a local difference of increments and decrements, which allows us to sum
the total difference and hence find the refcount when summing all CPUs. Then,
keep a single integer "long" refcount for slow and long lasting references,
and only take the global sum of local counters when the long refcount is 0.
This last scheme is what I implemented here. Attached mounts and process root
and working directory references are "long" references, and everything else is
a short reference.
This allows scalable vfsmount references during path walking over mounted
subtrees and unattached (lazy umounted) mounts with processes still running
in them.
This results in one fewer atomic op in the fastpath: mntget is now just a
per-CPU inc, rather than an atomic inc; and mntput just requires a spinlock
and non-atomic decrement in the common case. However code is otherwise bigger
and heavier, so single threaded performance is basically a wash.
Signed-off-by: Nick Piggin <npiggin@kernel.dk>
2011-01-07 09:50:11 +03:00
|
|
|
{
|
|
|
|
#ifdef CONFIG_SMP
|
2011-11-25 07:53:09 +04:00
|
|
|
this_cpu_add(mnt->mnt_pcp->mnt_count, n);
|
fs: scale mntget/mntput
The problem that this patch aims to fix is vfsmount refcounting scalability.
We need to take a reference on the vfsmount for every successful path lookup,
which often go to the same mount point.
The fundamental difficulty is that a "simple" reference count can never be made
scalable, because any time a reference is dropped, we must check whether that
was the last reference. To do that requires communication with all other CPUs
that may have taken a reference count.
We can make refcounts more scalable in a couple of ways, involving keeping
distributed counters, and checking for the global-zero condition less
frequently.
- check the global sum once every interval (this will delay zero detection
for some interval, so it's probably a showstopper for vfsmounts).
- keep a local count and only taking the global sum when local reaches 0 (this
is difficult for vfsmounts, because we can't hold preempt off for the life of
a reference, so a counter would need to be per-thread or tied strongly to a
particular CPU which requires more locking).
- keep a local difference of increments and decrements, which allows us to sum
the total difference and hence find the refcount when summing all CPUs. Then,
keep a single integer "long" refcount for slow and long lasting references,
and only take the global sum of local counters when the long refcount is 0.
This last scheme is what I implemented here. Attached mounts and process root
and working directory references are "long" references, and everything else is
a short reference.
This allows scalable vfsmount references during path walking over mounted
subtrees and unattached (lazy umounted) mounts with processes still running
in them.
This results in one fewer atomic op in the fastpath: mntget is now just a
per-CPU inc, rather than an atomic inc; and mntput just requires a spinlock
and non-atomic decrement in the common case. However code is otherwise bigger
and heavier, so single threaded performance is basically a wash.
Signed-off-by: Nick Piggin <npiggin@kernel.dk>
2011-01-07 09:50:11 +03:00
|
|
|
#else
|
|
|
|
preempt_disable();
|
2011-11-25 07:53:09 +04:00
|
|
|
mnt->mnt_count += n;
|
fs: scale mntget/mntput
The problem that this patch aims to fix is vfsmount refcounting scalability.
We need to take a reference on the vfsmount for every successful path lookup,
which often go to the same mount point.
The fundamental difficulty is that a "simple" reference count can never be made
scalable, because any time a reference is dropped, we must check whether that
was the last reference. To do that requires communication with all other CPUs
that may have taken a reference count.
We can make refcounts more scalable in a couple of ways, involving keeping
distributed counters, and checking for the global-zero condition less
frequently.
- check the global sum once every interval (this will delay zero detection
for some interval, so it's probably a showstopper for vfsmounts).
- keep a local count and only taking the global sum when local reaches 0 (this
is difficult for vfsmounts, because we can't hold preempt off for the life of
a reference, so a counter would need to be per-thread or tied strongly to a
particular CPU which requires more locking).
- keep a local difference of increments and decrements, which allows us to sum
the total difference and hence find the refcount when summing all CPUs. Then,
keep a single integer "long" refcount for slow and long lasting references,
and only take the global sum of local counters when the long refcount is 0.
This last scheme is what I implemented here. Attached mounts and process root
and working directory references are "long" references, and everything else is
a short reference.
This allows scalable vfsmount references during path walking over mounted
subtrees and unattached (lazy umounted) mounts with processes still running
in them.
This results in one fewer atomic op in the fastpath: mntget is now just a
per-CPU inc, rather than an atomic inc; and mntput just requires a spinlock
and non-atomic decrement in the common case. However code is otherwise bigger
and heavier, so single threaded performance is basically a wash.
Signed-off-by: Nick Piggin <npiggin@kernel.dk>
2011-01-07 09:50:11 +03:00
|
|
|
preempt_enable();
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* vfsmount lock must be held for write
|
|
|
|
*/
|
2020-11-01 07:40:21 +03:00
|
|
|
int mnt_get_count(struct mount *mnt)
|
fs: scale mntget/mntput
The problem that this patch aims to fix is vfsmount refcounting scalability.
We need to take a reference on the vfsmount for every successful path lookup,
which often go to the same mount point.
The fundamental difficulty is that a "simple" reference count can never be made
scalable, because any time a reference is dropped, we must check whether that
was the last reference. To do that requires communication with all other CPUs
that may have taken a reference count.
We can make refcounts more scalable in a couple of ways, involving keeping
distributed counters, and checking for the global-zero condition less
frequently.
- check the global sum once every interval (this will delay zero detection
for some interval, so it's probably a showstopper for vfsmounts).
- keep a local count and only taking the global sum when local reaches 0 (this
is difficult for vfsmounts, because we can't hold preempt off for the life of
a reference, so a counter would need to be per-thread or tied strongly to a
particular CPU which requires more locking).
- keep a local difference of increments and decrements, which allows us to sum
the total difference and hence find the refcount when summing all CPUs. Then,
keep a single integer "long" refcount for slow and long lasting references,
and only take the global sum of local counters when the long refcount is 0.
This last scheme is what I implemented here. Attached mounts and process root
and working directory references are "long" references, and everything else is
a short reference.
This allows scalable vfsmount references during path walking over mounted
subtrees and unattached (lazy umounted) mounts with processes still running
in them.
This results in one fewer atomic op in the fastpath: mntget is now just a
per-CPU inc, rather than an atomic inc; and mntput just requires a spinlock
and non-atomic decrement in the common case. However code is otherwise bigger
and heavier, so single threaded performance is basically a wash.
Signed-off-by: Nick Piggin <npiggin@kernel.dk>
2011-01-07 09:50:11 +03:00
|
|
|
{
|
|
|
|
#ifdef CONFIG_SMP
|
2020-11-01 07:40:21 +03:00
|
|
|
int count = 0;
|
fs: scale mntget/mntput
The problem that this patch aims to fix is vfsmount refcounting scalability.
We need to take a reference on the vfsmount for every successful path lookup,
which often go to the same mount point.
The fundamental difficulty is that a "simple" reference count can never be made
scalable, because any time a reference is dropped, we must check whether that
was the last reference. To do that requires communication with all other CPUs
that may have taken a reference count.
We can make refcounts more scalable in a couple of ways, involving keeping
distributed counters, and checking for the global-zero condition less
frequently.
- check the global sum once every interval (this will delay zero detection
for some interval, so it's probably a showstopper for vfsmounts).
- keep a local count and only taking the global sum when local reaches 0 (this
is difficult for vfsmounts, because we can't hold preempt off for the life of
a reference, so a counter would need to be per-thread or tied strongly to a
particular CPU which requires more locking).
- keep a local difference of increments and decrements, which allows us to sum
the total difference and hence find the refcount when summing all CPUs. Then,
keep a single integer "long" refcount for slow and long lasting references,
and only take the global sum of local counters when the long refcount is 0.
This last scheme is what I implemented here. Attached mounts and process root
and working directory references are "long" references, and everything else is
a short reference.
This allows scalable vfsmount references during path walking over mounted
subtrees and unattached (lazy umounted) mounts with processes still running
in them.
This results in one fewer atomic op in the fastpath: mntget is now just a
per-CPU inc, rather than an atomic inc; and mntput just requires a spinlock
and non-atomic decrement in the common case. However code is otherwise bigger
and heavier, so single threaded performance is basically a wash.
Signed-off-by: Nick Piggin <npiggin@kernel.dk>
2011-01-07 09:50:11 +03:00
|
|
|
int cpu;
|
|
|
|
|
|
|
|
for_each_possible_cpu(cpu) {
|
2011-11-25 07:53:09 +04:00
|
|
|
count += per_cpu_ptr(mnt->mnt_pcp, cpu)->mnt_count;
|
fs: scale mntget/mntput
The problem that this patch aims to fix is vfsmount refcounting scalability.
We need to take a reference on the vfsmount for every successful path lookup,
which often go to the same mount point.
The fundamental difficulty is that a "simple" reference count can never be made
scalable, because any time a reference is dropped, we must check whether that
was the last reference. To do that requires communication with all other CPUs
that may have taken a reference count.
We can make refcounts more scalable in a couple of ways, involving keeping
distributed counters, and checking for the global-zero condition less
frequently.
- check the global sum once every interval (this will delay zero detection
for some interval, so it's probably a showstopper for vfsmounts).
- keep a local count and only taking the global sum when local reaches 0 (this
is difficult for vfsmounts, because we can't hold preempt off for the life of
a reference, so a counter would need to be per-thread or tied strongly to a
particular CPU which requires more locking).
- keep a local difference of increments and decrements, which allows us to sum
the total difference and hence find the refcount when summing all CPUs. Then,
keep a single integer "long" refcount for slow and long lasting references,
and only take the global sum of local counters when the long refcount is 0.
This last scheme is what I implemented here. Attached mounts and process root
and working directory references are "long" references, and everything else is
a short reference.
This allows scalable vfsmount references during path walking over mounted
subtrees and unattached (lazy umounted) mounts with processes still running
in them.
This results in one fewer atomic op in the fastpath: mntget is now just a
per-CPU inc, rather than an atomic inc; and mntput just requires a spinlock
and non-atomic decrement in the common case. However code is otherwise bigger
and heavier, so single threaded performance is basically a wash.
Signed-off-by: Nick Piggin <npiggin@kernel.dk>
2011-01-07 09:50:11 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
return count;
|
|
|
|
#else
|
2011-11-25 07:53:09 +04:00
|
|
|
return mnt->mnt_count;
|
fs: scale mntget/mntput
The problem that this patch aims to fix is vfsmount refcounting scalability.
We need to take a reference on the vfsmount for every successful path lookup,
which often go to the same mount point.
The fundamental difficulty is that a "simple" reference count can never be made
scalable, because any time a reference is dropped, we must check whether that
was the last reference. To do that requires communication with all other CPUs
that may have taken a reference count.
We can make refcounts more scalable in a couple of ways, involving keeping
distributed counters, and checking for the global-zero condition less
frequently.
- check the global sum once every interval (this will delay zero detection
for some interval, so it's probably a showstopper for vfsmounts).
- keep a local count and only taking the global sum when local reaches 0 (this
is difficult for vfsmounts, because we can't hold preempt off for the life of
a reference, so a counter would need to be per-thread or tied strongly to a
particular CPU which requires more locking).
- keep a local difference of increments and decrements, which allows us to sum
the total difference and hence find the refcount when summing all CPUs. Then,
keep a single integer "long" refcount for slow and long lasting references,
and only take the global sum of local counters when the long refcount is 0.
This last scheme is what I implemented here. Attached mounts and process root
and working directory references are "long" references, and everything else is
a short reference.
This allows scalable vfsmount references during path walking over mounted
subtrees and unattached (lazy umounted) mounts with processes still running
in them.
This results in one fewer atomic op in the fastpath: mntget is now just a
per-CPU inc, rather than an atomic inc; and mntput just requires a spinlock
and non-atomic decrement in the common case. However code is otherwise bigger
and heavier, so single threaded performance is basically a wash.
Signed-off-by: Nick Piggin <npiggin@kernel.dk>
2011-01-07 09:50:11 +03:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2011-11-25 05:38:33 +04:00
|
|
|
static struct mount *alloc_vfsmnt(const char *name)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2011-11-25 11:35:16 +04:00
|
|
|
struct mount *mnt = kmem_cache_zalloc(mnt_cache, GFP_KERNEL);
|
|
|
|
if (mnt) {
|
2008-03-27 00:11:34 +03:00
|
|
|
int err;
|
|
|
|
|
2011-11-25 11:35:16 +04:00
|
|
|
err = mnt_alloc_id(mnt);
|
2008-07-21 14:06:36 +04:00
|
|
|
if (err)
|
|
|
|
goto out_free_cache;
|
|
|
|
|
|
|
|
if (name) {
|
memcg: enable accounting for mnt_cache entries
Patch series "memcg accounting from OpenVZ", v7.
OpenVZ uses memory accounting 20+ years since v2.2.x linux kernels.
Initially we used our own accounting subsystem, then partially committed
it to upstream, and a few years ago switched to cgroups v1. Now we're
rebasing again, revising our old patches and trying to push them upstream.
We try to protect the host system from any misuse of kernel memory
allocation triggered by untrusted users inside the containers.
Patch-set is addressed mostly to cgroups maintainers and cgroups@ mailing
list, though I would be very grateful for any comments from maintainersi
of affected subsystems or other people added in cc:
Compared to the upstream, we additionally account the following kernel objects:
- network devices and its Tx/Rx queues
- ipv4/v6 addresses and routing-related objects
- inet_bind_bucket cache objects
- VLAN group arrays
- ipv6/sit: ip_tunnel_prl
- scm_fp_list objects used by SCM_RIGHTS messages of Unix sockets
- nsproxy and namespace objects itself
- IPC objects: semaphores, message queues and share memory segments
- mounts
- pollfd and select bits arrays
- signals and posix timers
- file lock
- fasync_struct used by the file lease code and driver's fasync queues
- tty objects
- per-mm LDT
We have an incorrect/incomplete/obsoleted accounting for few other kernel
objects: sk_filter, af_packets, netlink and xt_counters for iptables.
They require rework and probably will be dropped at all.
Also we're going to add an accounting for nft, however it is not ready
yet.
We have not tested performance on upstream, however, our performance team
compares our current RHEL7-based production kernel and reports that they
are at least not worse as the according original RHEL7 kernel.
This patch (of 10):
The kernel allocates ~400 bytes of 'struct mount' for any new mount.
Creating a new mount namespace clones most of the parent mounts, and this
can be repeated many times. Additionally, each mount allocates up to
PATH_MAX=4096 bytes for mnt->mnt_devname.
It makes sense to account for these allocations to restrict the host's
memory consumption from inside the memcg-limited container.
Link: https://lkml.kernel.org/r/045db11f-4a45-7c9b-2664-5b32c2b44943@virtuozzo.com
Signed-off-by: Vasily Averin <vvs@virtuozzo.com>
Reviewed-by: Shakeel Butt <shakeelb@google.com>
Acked-by: Christian Brauner <christian.brauner@ubuntu.com>
Cc: Tejun Heo <tj@kernel.org>
Cc: Michal Hocko <mhocko@kernel.org>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Vladimir Davydov <vdavydov.dev@gmail.com>
Cc: Roman Gushchin <guro@fb.com>
Cc: Yutian Yang <nglaive@gmail.com>
Cc: Alexander Viro <viro@zeniv.linux.org.uk>
Cc: Alexey Dobriyan <adobriyan@gmail.com>
Cc: Andrei Vagin <avagin@gmail.com>
Cc: Borislav Petkov <bp@alien8.de>
Cc: Dmitry Safonov <0x7f454c46@gmail.com>
Cc: "Eric W. Biederman" <ebiederm@xmission.com>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: "J. Bruce Fields" <bfields@fieldses.org>
Cc: Jeff Layton <jlayton@kernel.org>
Cc: Jens Axboe <axboe@kernel.dk>
Cc: Jiri Slaby <jirislaby@kernel.org>
Cc: Kirill Tkhai <ktkhai@virtuozzo.com>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Serge Hallyn <serge@hallyn.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Zefan Li <lizefan.x@bytedance.com>
Cc: Borislav Petkov <bp@suse.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-09-03 00:55:10 +03:00
|
|
|
mnt->mnt_devname = kstrdup_const(name,
|
|
|
|
GFP_KERNEL_ACCOUNT);
|
2011-11-25 11:35:16 +04:00
|
|
|
if (!mnt->mnt_devname)
|
2008-07-21 14:06:36 +04:00
|
|
|
goto out_free_id;
|
2008-03-27 00:11:34 +03:00
|
|
|
}
|
|
|
|
|
fs: scale mntget/mntput
The problem that this patch aims to fix is vfsmount refcounting scalability.
We need to take a reference on the vfsmount for every successful path lookup,
which often go to the same mount point.
The fundamental difficulty is that a "simple" reference count can never be made
scalable, because any time a reference is dropped, we must check whether that
was the last reference. To do that requires communication with all other CPUs
that may have taken a reference count.
We can make refcounts more scalable in a couple of ways, involving keeping
distributed counters, and checking for the global-zero condition less
frequently.
- check the global sum once every interval (this will delay zero detection
for some interval, so it's probably a showstopper for vfsmounts).
- keep a local count and only taking the global sum when local reaches 0 (this
is difficult for vfsmounts, because we can't hold preempt off for the life of
a reference, so a counter would need to be per-thread or tied strongly to a
particular CPU which requires more locking).
- keep a local difference of increments and decrements, which allows us to sum
the total difference and hence find the refcount when summing all CPUs. Then,
keep a single integer "long" refcount for slow and long lasting references,
and only take the global sum of local counters when the long refcount is 0.
This last scheme is what I implemented here. Attached mounts and process root
and working directory references are "long" references, and everything else is
a short reference.
This allows scalable vfsmount references during path walking over mounted
subtrees and unattached (lazy umounted) mounts with processes still running
in them.
This results in one fewer atomic op in the fastpath: mntget is now just a
per-CPU inc, rather than an atomic inc; and mntput just requires a spinlock
and non-atomic decrement in the common case. However code is otherwise bigger
and heavier, so single threaded performance is basically a wash.
Signed-off-by: Nick Piggin <npiggin@kernel.dk>
2011-01-07 09:50:11 +03:00
|
|
|
#ifdef CONFIG_SMP
|
2011-11-25 11:35:16 +04:00
|
|
|
mnt->mnt_pcp = alloc_percpu(struct mnt_pcp);
|
|
|
|
if (!mnt->mnt_pcp)
|
fs: scale mntget/mntput
The problem that this patch aims to fix is vfsmount refcounting scalability.
We need to take a reference on the vfsmount for every successful path lookup,
which often go to the same mount point.
The fundamental difficulty is that a "simple" reference count can never be made
scalable, because any time a reference is dropped, we must check whether that
was the last reference. To do that requires communication with all other CPUs
that may have taken a reference count.
We can make refcounts more scalable in a couple of ways, involving keeping
distributed counters, and checking for the global-zero condition less
frequently.
- check the global sum once every interval (this will delay zero detection
for some interval, so it's probably a showstopper for vfsmounts).
- keep a local count and only taking the global sum when local reaches 0 (this
is difficult for vfsmounts, because we can't hold preempt off for the life of
a reference, so a counter would need to be per-thread or tied strongly to a
particular CPU which requires more locking).
- keep a local difference of increments and decrements, which allows us to sum
the total difference and hence find the refcount when summing all CPUs. Then,
keep a single integer "long" refcount for slow and long lasting references,
and only take the global sum of local counters when the long refcount is 0.
This last scheme is what I implemented here. Attached mounts and process root
and working directory references are "long" references, and everything else is
a short reference.
This allows scalable vfsmount references during path walking over mounted
subtrees and unattached (lazy umounted) mounts with processes still running
in them.
This results in one fewer atomic op in the fastpath: mntget is now just a
per-CPU inc, rather than an atomic inc; and mntput just requires a spinlock
and non-atomic decrement in the common case. However code is otherwise bigger
and heavier, so single threaded performance is basically a wash.
Signed-off-by: Nick Piggin <npiggin@kernel.dk>
2011-01-07 09:50:11 +03:00
|
|
|
goto out_free_devname;
|
|
|
|
|
2011-11-25 11:35:16 +04:00
|
|
|
this_cpu_add(mnt->mnt_pcp->mnt_count, 1);
|
fs: scale mntget/mntput
The problem that this patch aims to fix is vfsmount refcounting scalability.
We need to take a reference on the vfsmount for every successful path lookup,
which often go to the same mount point.
The fundamental difficulty is that a "simple" reference count can never be made
scalable, because any time a reference is dropped, we must check whether that
was the last reference. To do that requires communication with all other CPUs
that may have taken a reference count.
We can make refcounts more scalable in a couple of ways, involving keeping
distributed counters, and checking for the global-zero condition less
frequently.
- check the global sum once every interval (this will delay zero detection
for some interval, so it's probably a showstopper for vfsmounts).
- keep a local count and only taking the global sum when local reaches 0 (this
is difficult for vfsmounts, because we can't hold preempt off for the life of
a reference, so a counter would need to be per-thread or tied strongly to a
particular CPU which requires more locking).
- keep a local difference of increments and decrements, which allows us to sum
the total difference and hence find the refcount when summing all CPUs. Then,
keep a single integer "long" refcount for slow and long lasting references,
and only take the global sum of local counters when the long refcount is 0.
This last scheme is what I implemented here. Attached mounts and process root
and working directory references are "long" references, and everything else is
a short reference.
This allows scalable vfsmount references during path walking over mounted
subtrees and unattached (lazy umounted) mounts with processes still running
in them.
This results in one fewer atomic op in the fastpath: mntget is now just a
per-CPU inc, rather than an atomic inc; and mntput just requires a spinlock
and non-atomic decrement in the common case. However code is otherwise bigger
and heavier, so single threaded performance is basically a wash.
Signed-off-by: Nick Piggin <npiggin@kernel.dk>
2011-01-07 09:50:11 +03:00
|
|
|
#else
|
2011-11-25 11:35:16 +04:00
|
|
|
mnt->mnt_count = 1;
|
|
|
|
mnt->mnt_writers = 0;
|
fs: scale mntget/mntput
The problem that this patch aims to fix is vfsmount refcounting scalability.
We need to take a reference on the vfsmount for every successful path lookup,
which often go to the same mount point.
The fundamental difficulty is that a "simple" reference count can never be made
scalable, because any time a reference is dropped, we must check whether that
was the last reference. To do that requires communication with all other CPUs
that may have taken a reference count.
We can make refcounts more scalable in a couple of ways, involving keeping
distributed counters, and checking for the global-zero condition less
frequently.
- check the global sum once every interval (this will delay zero detection
for some interval, so it's probably a showstopper for vfsmounts).
- keep a local count and only taking the global sum when local reaches 0 (this
is difficult for vfsmounts, because we can't hold preempt off for the life of
a reference, so a counter would need to be per-thread or tied strongly to a
particular CPU which requires more locking).
- keep a local difference of increments and decrements, which allows us to sum
the total difference and hence find the refcount when summing all CPUs. Then,
keep a single integer "long" refcount for slow and long lasting references,
and only take the global sum of local counters when the long refcount is 0.
This last scheme is what I implemented here. Attached mounts and process root
and working directory references are "long" references, and everything else is
a short reference.
This allows scalable vfsmount references during path walking over mounted
subtrees and unattached (lazy umounted) mounts with processes still running
in them.
This results in one fewer atomic op in the fastpath: mntget is now just a
per-CPU inc, rather than an atomic inc; and mntput just requires a spinlock
and non-atomic decrement in the common case. However code is otherwise bigger
and heavier, so single threaded performance is basically a wash.
Signed-off-by: Nick Piggin <npiggin@kernel.dk>
2011-01-07 09:50:11 +03:00
|
|
|
#endif
|
|
|
|
|
2014-03-21 05:10:51 +04:00
|
|
|
INIT_HLIST_NODE(&mnt->mnt_hash);
|
2011-11-25 11:35:16 +04:00
|
|
|
INIT_LIST_HEAD(&mnt->mnt_child);
|
|
|
|
INIT_LIST_HEAD(&mnt->mnt_mounts);
|
|
|
|
INIT_LIST_HEAD(&mnt->mnt_list);
|
|
|
|
INIT_LIST_HEAD(&mnt->mnt_expire);
|
|
|
|
INIT_LIST_HEAD(&mnt->mnt_share);
|
|
|
|
INIT_LIST_HEAD(&mnt->mnt_slave_list);
|
|
|
|
INIT_LIST_HEAD(&mnt->mnt_slave);
|
2013-09-23 06:37:01 +04:00
|
|
|
INIT_HLIST_NODE(&mnt->mnt_mp_list);
|
2016-10-25 00:16:13 +03:00
|
|
|
INIT_LIST_HEAD(&mnt->mnt_umounting);
|
2019-07-04 23:57:51 +03:00
|
|
|
INIT_HLIST_HEAD(&mnt->mnt_stuck_children);
|
2022-10-26 13:51:27 +03:00
|
|
|
mnt->mnt.mnt_idmap = &nop_mnt_idmap;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
2011-11-25 11:35:16 +04:00
|
|
|
return mnt;
|
2008-07-21 14:06:36 +04:00
|
|
|
|
2009-04-26 14:25:54 +04:00
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
out_free_devname:
|
2015-02-14 01:36:41 +03:00
|
|
|
kfree_const(mnt->mnt_devname);
|
2009-04-26 14:25:54 +04:00
|
|
|
#endif
|
2008-07-21 14:06:36 +04:00
|
|
|
out_free_id:
|
2011-11-25 11:35:16 +04:00
|
|
|
mnt_free_id(mnt);
|
2008-07-21 14:06:36 +04:00
|
|
|
out_free_cache:
|
2011-11-25 11:35:16 +04:00
|
|
|
kmem_cache_free(mnt_cache, mnt);
|
2008-07-21 14:06:36 +04:00
|
|
|
return NULL;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
[PATCH] r/o bind mounts: track numbers of writers to mounts
This is the real meat of the entire series. It actually
implements the tracking of the number of writers to a mount.
However, it causes scalability problems because there can be
hundreds of cpus doing open()/close() on files on the same mnt at
the same time. Even an atomic_t in the mnt has massive scalaing
problems because the cacheline gets so terribly contended.
This uses a statically-allocated percpu variable. All want/drop
operations are local to a cpu as long that cpu operates on the same
mount, and there are no writer count imbalances. Writer count
imbalances happen when a write is taken on one cpu, and released
on another, like when an open/close pair is performed on two
Upon a remount,ro request, all of the data from the percpu
variables is collected (expensive, but very rare) and we determine
if there are any outstanding writers to the mount.
I've written a little benchmark to sit in a loop for a couple of
seconds in several cpus in parallel doing open/write/close loops.
http://sr71.net/~dave/linux/openbench.c
The code in here is a a worst-possible case for this patch. It
does opens on a _pair_ of files in two different mounts in parallel.
This should cause my code to lose its "operate on the same mount"
optimization completely. This worst-case scenario causes a 3%
degredation in the benchmark.
I could probably get rid of even this 3%, but it would be more
complex than what I have here, and I think this is getting into
acceptable territory. In practice, I expect writing more than 3
bytes to a file, as well as disk I/O to mask any effects that this
has.
(To get rid of that 3%, we could have an #defined number of mounts
in the percpu variable. So, instead of a CPU getting operate only
on percpu data when it accesses only one mount, it could stay on
percpu data when it only accesses N or fewer mounts.)
[AV] merged fix for __clear_mnt_mount() stepping on freed vfsmount
Acked-by: Al Viro <viro@ZenIV.linux.org.uk>
Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2008-02-16 01:37:59 +03:00
|
|
|
/*
|
|
|
|
* Most r/o checks on a fs are for operations that take
|
|
|
|
* discrete amounts of time, like a write() or unlink().
|
|
|
|
* We must keep track of when those operations start
|
|
|
|
* (for permission checks) and when they end, so that
|
|
|
|
* we can determine when writes are able to occur to
|
|
|
|
* a filesystem.
|
|
|
|
*/
|
|
|
|
/*
|
|
|
|
* __mnt_is_readonly: check whether a mount is read-only
|
|
|
|
* @mnt: the mount to check for its write status
|
|
|
|
*
|
|
|
|
* This shouldn't be used directly ouside of the VFS.
|
|
|
|
* It does not guarantee that the filesystem will stay
|
|
|
|
* r/w, just that it is right *now*. This can not and
|
|
|
|
* should not be used in place of IS_RDONLY(inode).
|
|
|
|
* mnt_want/drop_write() will _keep_ the filesystem
|
|
|
|
* r/w.
|
|
|
|
*/
|
2018-11-02 02:07:25 +03:00
|
|
|
bool __mnt_is_readonly(struct vfsmount *mnt)
|
[PATCH] r/o bind mounts: track numbers of writers to mounts
This is the real meat of the entire series. It actually
implements the tracking of the number of writers to a mount.
However, it causes scalability problems because there can be
hundreds of cpus doing open()/close() on files on the same mnt at
the same time. Even an atomic_t in the mnt has massive scalaing
problems because the cacheline gets so terribly contended.
This uses a statically-allocated percpu variable. All want/drop
operations are local to a cpu as long that cpu operates on the same
mount, and there are no writer count imbalances. Writer count
imbalances happen when a write is taken on one cpu, and released
on another, like when an open/close pair is performed on two
Upon a remount,ro request, all of the data from the percpu
variables is collected (expensive, but very rare) and we determine
if there are any outstanding writers to the mount.
I've written a little benchmark to sit in a loop for a couple of
seconds in several cpus in parallel doing open/write/close loops.
http://sr71.net/~dave/linux/openbench.c
The code in here is a a worst-possible case for this patch. It
does opens on a _pair_ of files in two different mounts in parallel.
This should cause my code to lose its "operate on the same mount"
optimization completely. This worst-case scenario causes a 3%
degredation in the benchmark.
I could probably get rid of even this 3%, but it would be more
complex than what I have here, and I think this is getting into
acceptable territory. In practice, I expect writing more than 3
bytes to a file, as well as disk I/O to mask any effects that this
has.
(To get rid of that 3%, we could have an #defined number of mounts
in the percpu variable. So, instead of a CPU getting operate only
on percpu data when it accesses only one mount, it could stay on
percpu data when it only accesses N or fewer mounts.)
[AV] merged fix for __clear_mnt_mount() stepping on freed vfsmount
Acked-by: Al Viro <viro@ZenIV.linux.org.uk>
Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2008-02-16 01:37:59 +03:00
|
|
|
{
|
2018-11-02 02:07:25 +03:00
|
|
|
return (mnt->mnt_flags & MNT_READONLY) || sb_rdonly(mnt->mnt_sb);
|
[PATCH] r/o bind mounts: track numbers of writers to mounts
This is the real meat of the entire series. It actually
implements the tracking of the number of writers to a mount.
However, it causes scalability problems because there can be
hundreds of cpus doing open()/close() on files on the same mnt at
the same time. Even an atomic_t in the mnt has massive scalaing
problems because the cacheline gets so terribly contended.
This uses a statically-allocated percpu variable. All want/drop
operations are local to a cpu as long that cpu operates on the same
mount, and there are no writer count imbalances. Writer count
imbalances happen when a write is taken on one cpu, and released
on another, like when an open/close pair is performed on two
Upon a remount,ro request, all of the data from the percpu
variables is collected (expensive, but very rare) and we determine
if there are any outstanding writers to the mount.
I've written a little benchmark to sit in a loop for a couple of
seconds in several cpus in parallel doing open/write/close loops.
http://sr71.net/~dave/linux/openbench.c
The code in here is a a worst-possible case for this patch. It
does opens on a _pair_ of files in two different mounts in parallel.
This should cause my code to lose its "operate on the same mount"
optimization completely. This worst-case scenario causes a 3%
degredation in the benchmark.
I could probably get rid of even this 3%, but it would be more
complex than what I have here, and I think this is getting into
acceptable territory. In practice, I expect writing more than 3
bytes to a file, as well as disk I/O to mask any effects that this
has.
(To get rid of that 3%, we could have an #defined number of mounts
in the percpu variable. So, instead of a CPU getting operate only
on percpu data when it accesses only one mount, it could stay on
percpu data when it only accesses N or fewer mounts.)
[AV] merged fix for __clear_mnt_mount() stepping on freed vfsmount
Acked-by: Al Viro <viro@ZenIV.linux.org.uk>
Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2008-02-16 01:37:59 +03:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(__mnt_is_readonly);
|
|
|
|
|
2011-11-25 07:37:54 +04:00
|
|
|
static inline void mnt_inc_writers(struct mount *mnt)
|
2009-04-26 14:25:54 +04:00
|
|
|
{
|
|
|
|
#ifdef CONFIG_SMP
|
2011-11-25 07:53:09 +04:00
|
|
|
this_cpu_inc(mnt->mnt_pcp->mnt_writers);
|
2009-04-26 14:25:54 +04:00
|
|
|
#else
|
2011-11-25 07:53:09 +04:00
|
|
|
mnt->mnt_writers++;
|
2009-04-26 14:25:54 +04:00
|
|
|
#endif
|
|
|
|
}
|
[PATCH] r/o bind mounts: track numbers of writers to mounts
This is the real meat of the entire series. It actually
implements the tracking of the number of writers to a mount.
However, it causes scalability problems because there can be
hundreds of cpus doing open()/close() on files on the same mnt at
the same time. Even an atomic_t in the mnt has massive scalaing
problems because the cacheline gets so terribly contended.
This uses a statically-allocated percpu variable. All want/drop
operations are local to a cpu as long that cpu operates on the same
mount, and there are no writer count imbalances. Writer count
imbalances happen when a write is taken on one cpu, and released
on another, like when an open/close pair is performed on two
Upon a remount,ro request, all of the data from the percpu
variables is collected (expensive, but very rare) and we determine
if there are any outstanding writers to the mount.
I've written a little benchmark to sit in a loop for a couple of
seconds in several cpus in parallel doing open/write/close loops.
http://sr71.net/~dave/linux/openbench.c
The code in here is a a worst-possible case for this patch. It
does opens on a _pair_ of files in two different mounts in parallel.
This should cause my code to lose its "operate on the same mount"
optimization completely. This worst-case scenario causes a 3%
degredation in the benchmark.
I could probably get rid of even this 3%, but it would be more
complex than what I have here, and I think this is getting into
acceptable territory. In practice, I expect writing more than 3
bytes to a file, as well as disk I/O to mask any effects that this
has.
(To get rid of that 3%, we could have an #defined number of mounts
in the percpu variable. So, instead of a CPU getting operate only
on percpu data when it accesses only one mount, it could stay on
percpu data when it only accesses N or fewer mounts.)
[AV] merged fix for __clear_mnt_mount() stepping on freed vfsmount
Acked-by: Al Viro <viro@ZenIV.linux.org.uk>
Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2008-02-16 01:37:59 +03:00
|
|
|
|
2011-11-25 07:37:54 +04:00
|
|
|
static inline void mnt_dec_writers(struct mount *mnt)
|
[PATCH] r/o bind mounts: track numbers of writers to mounts
This is the real meat of the entire series. It actually
implements the tracking of the number of writers to a mount.
However, it causes scalability problems because there can be
hundreds of cpus doing open()/close() on files on the same mnt at
the same time. Even an atomic_t in the mnt has massive scalaing
problems because the cacheline gets so terribly contended.
This uses a statically-allocated percpu variable. All want/drop
operations are local to a cpu as long that cpu operates on the same
mount, and there are no writer count imbalances. Writer count
imbalances happen when a write is taken on one cpu, and released
on another, like when an open/close pair is performed on two
Upon a remount,ro request, all of the data from the percpu
variables is collected (expensive, but very rare) and we determine
if there are any outstanding writers to the mount.
I've written a little benchmark to sit in a loop for a couple of
seconds in several cpus in parallel doing open/write/close loops.
http://sr71.net/~dave/linux/openbench.c
The code in here is a a worst-possible case for this patch. It
does opens on a _pair_ of files in two different mounts in parallel.
This should cause my code to lose its "operate on the same mount"
optimization completely. This worst-case scenario causes a 3%
degredation in the benchmark.
I could probably get rid of even this 3%, but it would be more
complex than what I have here, and I think this is getting into
acceptable territory. In practice, I expect writing more than 3
bytes to a file, as well as disk I/O to mask any effects that this
has.
(To get rid of that 3%, we could have an #defined number of mounts
in the percpu variable. So, instead of a CPU getting operate only
on percpu data when it accesses only one mount, it could stay on
percpu data when it only accesses N or fewer mounts.)
[AV] merged fix for __clear_mnt_mount() stepping on freed vfsmount
Acked-by: Al Viro <viro@ZenIV.linux.org.uk>
Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2008-02-16 01:37:59 +03:00
|
|
|
{
|
2009-04-26 14:25:54 +04:00
|
|
|
#ifdef CONFIG_SMP
|
2011-11-25 07:53:09 +04:00
|
|
|
this_cpu_dec(mnt->mnt_pcp->mnt_writers);
|
2009-04-26 14:25:54 +04:00
|
|
|
#else
|
2011-11-25 07:53:09 +04:00
|
|
|
mnt->mnt_writers--;
|
2009-04-26 14:25:54 +04:00
|
|
|
#endif
|
[PATCH] r/o bind mounts: track numbers of writers to mounts
This is the real meat of the entire series. It actually
implements the tracking of the number of writers to a mount.
However, it causes scalability problems because there can be
hundreds of cpus doing open()/close() on files on the same mnt at
the same time. Even an atomic_t in the mnt has massive scalaing
problems because the cacheline gets so terribly contended.
This uses a statically-allocated percpu variable. All want/drop
operations are local to a cpu as long that cpu operates on the same
mount, and there are no writer count imbalances. Writer count
imbalances happen when a write is taken on one cpu, and released
on another, like when an open/close pair is performed on two
Upon a remount,ro request, all of the data from the percpu
variables is collected (expensive, but very rare) and we determine
if there are any outstanding writers to the mount.
I've written a little benchmark to sit in a loop for a couple of
seconds in several cpus in parallel doing open/write/close loops.
http://sr71.net/~dave/linux/openbench.c
The code in here is a a worst-possible case for this patch. It
does opens on a _pair_ of files in two different mounts in parallel.
This should cause my code to lose its "operate on the same mount"
optimization completely. This worst-case scenario causes a 3%
degredation in the benchmark.
I could probably get rid of even this 3%, but it would be more
complex than what I have here, and I think this is getting into
acceptable territory. In practice, I expect writing more than 3
bytes to a file, as well as disk I/O to mask any effects that this
has.
(To get rid of that 3%, we could have an #defined number of mounts
in the percpu variable. So, instead of a CPU getting operate only
on percpu data when it accesses only one mount, it could stay on
percpu data when it only accesses N or fewer mounts.)
[AV] merged fix for __clear_mnt_mount() stepping on freed vfsmount
Acked-by: Al Viro <viro@ZenIV.linux.org.uk>
Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2008-02-16 01:37:59 +03:00
|
|
|
}
|
|
|
|
|
2011-11-25 07:37:54 +04:00
|
|
|
static unsigned int mnt_get_writers(struct mount *mnt)
|
[PATCH] r/o bind mounts: track numbers of writers to mounts
This is the real meat of the entire series. It actually
implements the tracking of the number of writers to a mount.
However, it causes scalability problems because there can be
hundreds of cpus doing open()/close() on files on the same mnt at
the same time. Even an atomic_t in the mnt has massive scalaing
problems because the cacheline gets so terribly contended.
This uses a statically-allocated percpu variable. All want/drop
operations are local to a cpu as long that cpu operates on the same
mount, and there are no writer count imbalances. Writer count
imbalances happen when a write is taken on one cpu, and released
on another, like when an open/close pair is performed on two
Upon a remount,ro request, all of the data from the percpu
variables is collected (expensive, but very rare) and we determine
if there are any outstanding writers to the mount.
I've written a little benchmark to sit in a loop for a couple of
seconds in several cpus in parallel doing open/write/close loops.
http://sr71.net/~dave/linux/openbench.c
The code in here is a a worst-possible case for this patch. It
does opens on a _pair_ of files in two different mounts in parallel.
This should cause my code to lose its "operate on the same mount"
optimization completely. This worst-case scenario causes a 3%
degredation in the benchmark.
I could probably get rid of even this 3%, but it would be more
complex than what I have here, and I think this is getting into
acceptable territory. In practice, I expect writing more than 3
bytes to a file, as well as disk I/O to mask any effects that this
has.
(To get rid of that 3%, we could have an #defined number of mounts
in the percpu variable. So, instead of a CPU getting operate only
on percpu data when it accesses only one mount, it could stay on
percpu data when it only accesses N or fewer mounts.)
[AV] merged fix for __clear_mnt_mount() stepping on freed vfsmount
Acked-by: Al Viro <viro@ZenIV.linux.org.uk>
Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2008-02-16 01:37:59 +03:00
|
|
|
{
|
2009-04-26 14:25:54 +04:00
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
unsigned int count = 0;
|
[PATCH] r/o bind mounts: track numbers of writers to mounts
This is the real meat of the entire series. It actually
implements the tracking of the number of writers to a mount.
However, it causes scalability problems because there can be
hundreds of cpus doing open()/close() on files on the same mnt at
the same time. Even an atomic_t in the mnt has massive scalaing
problems because the cacheline gets so terribly contended.
This uses a statically-allocated percpu variable. All want/drop
operations are local to a cpu as long that cpu operates on the same
mount, and there are no writer count imbalances. Writer count
imbalances happen when a write is taken on one cpu, and released
on another, like when an open/close pair is performed on two
Upon a remount,ro request, all of the data from the percpu
variables is collected (expensive, but very rare) and we determine
if there are any outstanding writers to the mount.
I've written a little benchmark to sit in a loop for a couple of
seconds in several cpus in parallel doing open/write/close loops.
http://sr71.net/~dave/linux/openbench.c
The code in here is a a worst-possible case for this patch. It
does opens on a _pair_ of files in two different mounts in parallel.
This should cause my code to lose its "operate on the same mount"
optimization completely. This worst-case scenario causes a 3%
degredation in the benchmark.
I could probably get rid of even this 3%, but it would be more
complex than what I have here, and I think this is getting into
acceptable territory. In practice, I expect writing more than 3
bytes to a file, as well as disk I/O to mask any effects that this
has.
(To get rid of that 3%, we could have an #defined number of mounts
in the percpu variable. So, instead of a CPU getting operate only
on percpu data when it accesses only one mount, it could stay on
percpu data when it only accesses N or fewer mounts.)
[AV] merged fix for __clear_mnt_mount() stepping on freed vfsmount
Acked-by: Al Viro <viro@ZenIV.linux.org.uk>
Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2008-02-16 01:37:59 +03:00
|
|
|
int cpu;
|
|
|
|
|
|
|
|
for_each_possible_cpu(cpu) {
|
2011-11-25 07:53:09 +04:00
|
|
|
count += per_cpu_ptr(mnt->mnt_pcp, cpu)->mnt_writers;
|
[PATCH] r/o bind mounts: track numbers of writers to mounts
This is the real meat of the entire series. It actually
implements the tracking of the number of writers to a mount.
However, it causes scalability problems because there can be
hundreds of cpus doing open()/close() on files on the same mnt at
the same time. Even an atomic_t in the mnt has massive scalaing
problems because the cacheline gets so terribly contended.
This uses a statically-allocated percpu variable. All want/drop
operations are local to a cpu as long that cpu operates on the same
mount, and there are no writer count imbalances. Writer count
imbalances happen when a write is taken on one cpu, and released
on another, like when an open/close pair is performed on two
Upon a remount,ro request, all of the data from the percpu
variables is collected (expensive, but very rare) and we determine
if there are any outstanding writers to the mount.
I've written a little benchmark to sit in a loop for a couple of
seconds in several cpus in parallel doing open/write/close loops.
http://sr71.net/~dave/linux/openbench.c
The code in here is a a worst-possible case for this patch. It
does opens on a _pair_ of files in two different mounts in parallel.
This should cause my code to lose its "operate on the same mount"
optimization completely. This worst-case scenario causes a 3%
degredation in the benchmark.
I could probably get rid of even this 3%, but it would be more
complex than what I have here, and I think this is getting into
acceptable territory. In practice, I expect writing more than 3
bytes to a file, as well as disk I/O to mask any effects that this
has.
(To get rid of that 3%, we could have an #defined number of mounts
in the percpu variable. So, instead of a CPU getting operate only
on percpu data when it accesses only one mount, it could stay on
percpu data when it only accesses N or fewer mounts.)
[AV] merged fix for __clear_mnt_mount() stepping on freed vfsmount
Acked-by: Al Viro <viro@ZenIV.linux.org.uk>
Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2008-02-16 01:37:59 +03:00
|
|
|
}
|
|
|
|
|
2009-04-26 14:25:54 +04:00
|
|
|
return count;
|
|
|
|
#else
|
|
|
|
return mnt->mnt_writers;
|
|
|
|
#endif
|
[PATCH] r/o bind mounts: track numbers of writers to mounts
This is the real meat of the entire series. It actually
implements the tracking of the number of writers to a mount.
However, it causes scalability problems because there can be
hundreds of cpus doing open()/close() on files on the same mnt at
the same time. Even an atomic_t in the mnt has massive scalaing
problems because the cacheline gets so terribly contended.
This uses a statically-allocated percpu variable. All want/drop
operations are local to a cpu as long that cpu operates on the same
mount, and there are no writer count imbalances. Writer count
imbalances happen when a write is taken on one cpu, and released
on another, like when an open/close pair is performed on two
Upon a remount,ro request, all of the data from the percpu
variables is collected (expensive, but very rare) and we determine
if there are any outstanding writers to the mount.
I've written a little benchmark to sit in a loop for a couple of
seconds in several cpus in parallel doing open/write/close loops.
http://sr71.net/~dave/linux/openbench.c
The code in here is a a worst-possible case for this patch. It
does opens on a _pair_ of files in two different mounts in parallel.
This should cause my code to lose its "operate on the same mount"
optimization completely. This worst-case scenario causes a 3%
degredation in the benchmark.
I could probably get rid of even this 3%, but it would be more
complex than what I have here, and I think this is getting into
acceptable territory. In practice, I expect writing more than 3
bytes to a file, as well as disk I/O to mask any effects that this
has.
(To get rid of that 3%, we could have an #defined number of mounts
in the percpu variable. So, instead of a CPU getting operate only
on percpu data when it accesses only one mount, it could stay on
percpu data when it only accesses N or fewer mounts.)
[AV] merged fix for __clear_mnt_mount() stepping on freed vfsmount
Acked-by: Al Viro <viro@ZenIV.linux.org.uk>
Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2008-02-16 01:37:59 +03:00
|
|
|
}
|
|
|
|
|
2011-11-21 15:11:31 +04:00
|
|
|
static int mnt_is_readonly(struct vfsmount *mnt)
|
|
|
|
{
|
|
|
|
if (mnt->mnt_sb->s_readonly_remount)
|
|
|
|
return 1;
|
|
|
|
/* Order wrt setting s_flags/s_readonly_remount in do_remount() */
|
|
|
|
smp_rmb();
|
|
|
|
return __mnt_is_readonly(mnt);
|
|
|
|
}
|
|
|
|
|
2008-02-16 01:37:30 +03:00
|
|
|
/*
|
2012-06-12 18:20:35 +04:00
|
|
|
* Most r/o & frozen checks on a fs are for operations that take discrete
|
|
|
|
* amounts of time, like a write() or unlink(). We must keep track of when
|
|
|
|
* those operations start (for permission checks) and when they end, so that we
|
|
|
|
* can determine when writes are able to occur to a filesystem.
|
2008-02-16 01:37:30 +03:00
|
|
|
*/
|
|
|
|
/**
|
2012-06-12 18:20:35 +04:00
|
|
|
* __mnt_want_write - get write access to a mount without freeze protection
|
2011-11-25 07:37:54 +04:00
|
|
|
* @m: the mount on which to take a write
|
2008-02-16 01:37:30 +03:00
|
|
|
*
|
2012-06-12 18:20:35 +04:00
|
|
|
* This tells the low-level filesystem that a write is about to be performed to
|
|
|
|
* it, and makes sure that writes are allowed (mnt it read-write) before
|
|
|
|
* returning success. This operation does not protect against filesystem being
|
|
|
|
* frozen. When the write operation is finished, __mnt_drop_write() must be
|
|
|
|
* called. This is effectively a refcount.
|
2008-02-16 01:37:30 +03:00
|
|
|
*/
|
2012-06-12 18:20:35 +04:00
|
|
|
int __mnt_want_write(struct vfsmount *m)
|
2008-02-16 01:37:30 +03:00
|
|
|
{
|
2011-11-25 07:37:54 +04:00
|
|
|
struct mount *mnt = real_mount(m);
|
[PATCH] r/o bind mounts: track numbers of writers to mounts
This is the real meat of the entire series. It actually
implements the tracking of the number of writers to a mount.
However, it causes scalability problems because there can be
hundreds of cpus doing open()/close() on files on the same mnt at
the same time. Even an atomic_t in the mnt has massive scalaing
problems because the cacheline gets so terribly contended.
This uses a statically-allocated percpu variable. All want/drop
operations are local to a cpu as long that cpu operates on the same
mount, and there are no writer count imbalances. Writer count
imbalances happen when a write is taken on one cpu, and released
on another, like when an open/close pair is performed on two
Upon a remount,ro request, all of the data from the percpu
variables is collected (expensive, but very rare) and we determine
if there are any outstanding writers to the mount.
I've written a little benchmark to sit in a loop for a couple of
seconds in several cpus in parallel doing open/write/close loops.
http://sr71.net/~dave/linux/openbench.c
The code in here is a a worst-possible case for this patch. It
does opens on a _pair_ of files in two different mounts in parallel.
This should cause my code to lose its "operate on the same mount"
optimization completely. This worst-case scenario causes a 3%
degredation in the benchmark.
I could probably get rid of even this 3%, but it would be more
complex than what I have here, and I think this is getting into
acceptable territory. In practice, I expect writing more than 3
bytes to a file, as well as disk I/O to mask any effects that this
has.
(To get rid of that 3%, we could have an #defined number of mounts
in the percpu variable. So, instead of a CPU getting operate only
on percpu data when it accesses only one mount, it could stay on
percpu data when it only accesses N or fewer mounts.)
[AV] merged fix for __clear_mnt_mount() stepping on freed vfsmount
Acked-by: Al Viro <viro@ZenIV.linux.org.uk>
Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2008-02-16 01:37:59 +03:00
|
|
|
int ret = 0;
|
|
|
|
|
2009-04-26 14:25:54 +04:00
|
|
|
preempt_disable();
|
2011-01-07 09:50:10 +03:00
|
|
|
mnt_inc_writers(mnt);
|
2009-04-26 14:25:54 +04:00
|
|
|
/*
|
2011-01-07 09:50:10 +03:00
|
|
|
* The store to mnt_inc_writers must be visible before we pass
|
2009-04-26 14:25:54 +04:00
|
|
|
* MNT_WRITE_HOLD loop below, so that the slowpath can see our
|
|
|
|
* incremented count after it has set MNT_WRITE_HOLD.
|
|
|
|
*/
|
|
|
|
smp_mb();
|
2021-11-25 15:07:11 +03:00
|
|
|
might_lock(&mount_lock.lock);
|
|
|
|
while (READ_ONCE(mnt->mnt.mnt_flags) & MNT_WRITE_HOLD) {
|
|
|
|
if (!IS_ENABLED(CONFIG_PREEMPT_RT)) {
|
|
|
|
cpu_relax();
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* This prevents priority inversion, if the task
|
|
|
|
* setting MNT_WRITE_HOLD got preempted on a remote
|
|
|
|
* CPU, and it prevents life lock if the task setting
|
|
|
|
* MNT_WRITE_HOLD has a lower priority and is bound to
|
|
|
|
* the same CPU as the task that is spinning here.
|
|
|
|
*/
|
|
|
|
preempt_enable();
|
|
|
|
lock_mount_hash();
|
|
|
|
unlock_mount_hash();
|
|
|
|
preempt_disable();
|
|
|
|
}
|
|
|
|
}
|
2009-04-26 14:25:54 +04:00
|
|
|
/*
|
|
|
|
* After the slowpath clears MNT_WRITE_HOLD, mnt_is_readonly will
|
|
|
|
* be set to match its requirements. So we must not load that until
|
|
|
|
* MNT_WRITE_HOLD is cleared.
|
|
|
|
*/
|
|
|
|
smp_rmb();
|
2011-11-21 15:11:31 +04:00
|
|
|
if (mnt_is_readonly(m)) {
|
2011-01-07 09:50:10 +03:00
|
|
|
mnt_dec_writers(mnt);
|
[PATCH] r/o bind mounts: track numbers of writers to mounts
This is the real meat of the entire series. It actually
implements the tracking of the number of writers to a mount.
However, it causes scalability problems because there can be
hundreds of cpus doing open()/close() on files on the same mnt at
the same time. Even an atomic_t in the mnt has massive scalaing
problems because the cacheline gets so terribly contended.
This uses a statically-allocated percpu variable. All want/drop
operations are local to a cpu as long that cpu operates on the same
mount, and there are no writer count imbalances. Writer count
imbalances happen when a write is taken on one cpu, and released
on another, like when an open/close pair is performed on two
Upon a remount,ro request, all of the data from the percpu
variables is collected (expensive, but very rare) and we determine
if there are any outstanding writers to the mount.
I've written a little benchmark to sit in a loop for a couple of
seconds in several cpus in parallel doing open/write/close loops.
http://sr71.net/~dave/linux/openbench.c
The code in here is a a worst-possible case for this patch. It
does opens on a _pair_ of files in two different mounts in parallel.
This should cause my code to lose its "operate on the same mount"
optimization completely. This worst-case scenario causes a 3%
degredation in the benchmark.
I could probably get rid of even this 3%, but it would be more
complex than what I have here, and I think this is getting into
acceptable territory. In practice, I expect writing more than 3
bytes to a file, as well as disk I/O to mask any effects that this
has.
(To get rid of that 3%, we could have an #defined number of mounts
in the percpu variable. So, instead of a CPU getting operate only
on percpu data when it accesses only one mount, it could stay on
percpu data when it only accesses N or fewer mounts.)
[AV] merged fix for __clear_mnt_mount() stepping on freed vfsmount
Acked-by: Al Viro <viro@ZenIV.linux.org.uk>
Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2008-02-16 01:37:59 +03:00
|
|
|
ret = -EROFS;
|
|
|
|
}
|
2009-04-26 14:25:54 +04:00
|
|
|
preempt_enable();
|
2012-06-12 18:20:35 +04:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* mnt_want_write - get write access to a mount
|
|
|
|
* @m: the mount on which to take a write
|
|
|
|
*
|
|
|
|
* This tells the low-level filesystem that a write is about to be performed to
|
|
|
|
* it, and makes sure that writes are allowed (mount is read-write, filesystem
|
|
|
|
* is not frozen) before returning success. When the write operation is
|
|
|
|
* finished, mnt_drop_write() must be called. This is effectively a refcount.
|
|
|
|
*/
|
|
|
|
int mnt_want_write(struct vfsmount *m)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
sb_start_write(m->mnt_sb);
|
|
|
|
ret = __mnt_want_write(m);
|
|
|
|
if (ret)
|
|
|
|
sb_end_write(m->mnt_sb);
|
[PATCH] r/o bind mounts: track numbers of writers to mounts
This is the real meat of the entire series. It actually
implements the tracking of the number of writers to a mount.
However, it causes scalability problems because there can be
hundreds of cpus doing open()/close() on files on the same mnt at
the same time. Even an atomic_t in the mnt has massive scalaing
problems because the cacheline gets so terribly contended.
This uses a statically-allocated percpu variable. All want/drop
operations are local to a cpu as long that cpu operates on the same
mount, and there are no writer count imbalances. Writer count
imbalances happen when a write is taken on one cpu, and released
on another, like when an open/close pair is performed on two
Upon a remount,ro request, all of the data from the percpu
variables is collected (expensive, but very rare) and we determine
if there are any outstanding writers to the mount.
I've written a little benchmark to sit in a loop for a couple of
seconds in several cpus in parallel doing open/write/close loops.
http://sr71.net/~dave/linux/openbench.c
The code in here is a a worst-possible case for this patch. It
does opens on a _pair_ of files in two different mounts in parallel.
This should cause my code to lose its "operate on the same mount"
optimization completely. This worst-case scenario causes a 3%
degredation in the benchmark.
I could probably get rid of even this 3%, but it would be more
complex than what I have here, and I think this is getting into
acceptable territory. In practice, I expect writing more than 3
bytes to a file, as well as disk I/O to mask any effects that this
has.
(To get rid of that 3%, we could have an #defined number of mounts
in the percpu variable. So, instead of a CPU getting operate only
on percpu data when it accesses only one mount, it could stay on
percpu data when it only accesses N or fewer mounts.)
[AV] merged fix for __clear_mnt_mount() stepping on freed vfsmount
Acked-by: Al Viro <viro@ZenIV.linux.org.uk>
Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2008-02-16 01:37:59 +03:00
|
|
|
return ret;
|
2008-02-16 01:37:30 +03:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(mnt_want_write);
|
|
|
|
|
2009-04-26 14:25:55 +04:00
|
|
|
/**
|
2012-06-12 18:20:35 +04:00
|
|
|
* __mnt_want_write_file - get write access to a file's mount
|
2009-04-26 14:25:55 +04:00
|
|
|
* @file: the file who's mount on which to take a write
|
|
|
|
*
|
2020-09-22 19:44:18 +03:00
|
|
|
* This is like __mnt_want_write, but if the file is already open for writing it
|
|
|
|
* skips incrementing mnt_writers (since the open file already has a reference)
|
|
|
|
* and instead only does the check for emergency r/o remounts. This must be
|
|
|
|
* paired with __mnt_drop_write_file.
|
2009-04-26 14:25:55 +04:00
|
|
|
*/
|
2012-06-12 18:20:35 +04:00
|
|
|
int __mnt_want_write_file(struct file *file)
|
2009-04-26 14:25:55 +04:00
|
|
|
{
|
2020-09-22 19:44:18 +03:00
|
|
|
if (file->f_mode & FMODE_WRITER) {
|
|
|
|
/*
|
|
|
|
* Superblock may have become readonly while there are still
|
|
|
|
* writable fd's, e.g. due to a fs error with errors=remount-ro
|
|
|
|
*/
|
|
|
|
if (__mnt_is_readonly(file->f_path.mnt))
|
|
|
|
return -EROFS;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return __mnt_want_write(file->f_path.mnt);
|
2009-04-26 14:25:55 +04:00
|
|
|
}
|
2012-06-12 18:20:35 +04:00
|
|
|
|
2017-09-05 13:53:12 +03:00
|
|
|
/**
|
|
|
|
* mnt_want_write_file - get write access to a file's mount
|
|
|
|
* @file: the file who's mount on which to take a write
|
|
|
|
*
|
2020-09-22 19:44:18 +03:00
|
|
|
* This is like mnt_want_write, but if the file is already open for writing it
|
|
|
|
* skips incrementing mnt_writers (since the open file already has a reference)
|
|
|
|
* and instead only does the freeze protection and the check for emergency r/o
|
|
|
|
* remounts. This must be paired with mnt_drop_write_file.
|
2017-09-05 13:53:12 +03:00
|
|
|
*/
|
|
|
|
int mnt_want_write_file(struct file *file)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2018-07-18 16:44:43 +03:00
|
|
|
sb_start_write(file_inode(file)->i_sb);
|
2012-06-12 18:20:35 +04:00
|
|
|
ret = __mnt_want_write_file(file);
|
|
|
|
if (ret)
|
2018-07-18 16:44:43 +03:00
|
|
|
sb_end_write(file_inode(file)->i_sb);
|
2017-09-05 13:53:12 +03:00
|
|
|
return ret;
|
|
|
|
}
|
2009-04-26 14:25:55 +04:00
|
|
|
EXPORT_SYMBOL_GPL(mnt_want_write_file);
|
|
|
|
|
2008-02-16 01:37:30 +03:00
|
|
|
/**
|
2012-06-12 18:20:35 +04:00
|
|
|
* __mnt_drop_write - give up write access to a mount
|
2008-02-16 01:37:30 +03:00
|
|
|
* @mnt: the mount on which to give up write access
|
|
|
|
*
|
|
|
|
* Tells the low-level filesystem that we are done
|
|
|
|
* performing writes to it. Must be matched with
|
2012-06-12 18:20:35 +04:00
|
|
|
* __mnt_want_write() call above.
|
2008-02-16 01:37:30 +03:00
|
|
|
*/
|
2012-06-12 18:20:35 +04:00
|
|
|
void __mnt_drop_write(struct vfsmount *mnt)
|
2008-02-16 01:37:30 +03:00
|
|
|
{
|
2009-04-26 14:25:54 +04:00
|
|
|
preempt_disable();
|
2011-11-25 07:37:54 +04:00
|
|
|
mnt_dec_writers(real_mount(mnt));
|
2009-04-26 14:25:54 +04:00
|
|
|
preempt_enable();
|
2008-02-16 01:37:30 +03:00
|
|
|
}
|
2012-06-12 18:20:35 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* mnt_drop_write - give up write access to a mount
|
|
|
|
* @mnt: the mount on which to give up write access
|
|
|
|
*
|
|
|
|
* Tells the low-level filesystem that we are done performing writes to it and
|
|
|
|
* also allows filesystem to be frozen again. Must be matched with
|
|
|
|
* mnt_want_write() call above.
|
|
|
|
*/
|
|
|
|
void mnt_drop_write(struct vfsmount *mnt)
|
|
|
|
{
|
|
|
|
__mnt_drop_write(mnt);
|
|
|
|
sb_end_write(mnt->mnt_sb);
|
|
|
|
}
|
2008-02-16 01:37:30 +03:00
|
|
|
EXPORT_SYMBOL_GPL(mnt_drop_write);
|
|
|
|
|
2012-06-12 18:20:35 +04:00
|
|
|
void __mnt_drop_write_file(struct file *file)
|
|
|
|
{
|
2020-09-22 19:44:18 +03:00
|
|
|
if (!(file->f_mode & FMODE_WRITER))
|
|
|
|
__mnt_drop_write(file->f_path.mnt);
|
2012-06-12 18:20:35 +04:00
|
|
|
}
|
|
|
|
|
2017-09-05 13:53:12 +03:00
|
|
|
void mnt_drop_write_file(struct file *file)
|
|
|
|
{
|
2018-07-18 16:44:43 +03:00
|
|
|
__mnt_drop_write_file(file);
|
2017-09-05 13:53:12 +03:00
|
|
|
sb_end_write(file_inode(file)->i_sb);
|
|
|
|
}
|
2011-12-09 17:06:57 +04:00
|
|
|
EXPORT_SYMBOL(mnt_drop_write_file);
|
|
|
|
|
2022-02-03 16:14:07 +03:00
|
|
|
/**
|
|
|
|
* mnt_hold_writers - prevent write access to the given mount
|
|
|
|
* @mnt: mnt to prevent write access to
|
|
|
|
*
|
|
|
|
* Prevents write access to @mnt if there are no active writers for @mnt.
|
|
|
|
* This function needs to be called and return successfully before changing
|
|
|
|
* properties of @mnt that need to remain stable for callers with write access
|
|
|
|
* to @mnt.
|
|
|
|
*
|
|
|
|
* After this functions has been called successfully callers must pair it with
|
|
|
|
* a call to mnt_unhold_writers() in order to stop preventing write access to
|
|
|
|
* @mnt.
|
|
|
|
*
|
|
|
|
* Context: This function expects lock_mount_hash() to be held serializing
|
|
|
|
* setting MNT_WRITE_HOLD.
|
|
|
|
* Return: On success 0 is returned.
|
|
|
|
* On error, -EBUSY is returned.
|
|
|
|
*/
|
2021-01-21 16:19:51 +03:00
|
|
|
static inline int mnt_hold_writers(struct mount *mnt)
|
2008-02-16 01:37:30 +03:00
|
|
|
{
|
2011-11-25 07:37:54 +04:00
|
|
|
mnt->mnt.mnt_flags |= MNT_WRITE_HOLD;
|
[PATCH] r/o bind mounts: track numbers of writers to mounts
This is the real meat of the entire series. It actually
implements the tracking of the number of writers to a mount.
However, it causes scalability problems because there can be
hundreds of cpus doing open()/close() on files on the same mnt at
the same time. Even an atomic_t in the mnt has massive scalaing
problems because the cacheline gets so terribly contended.
This uses a statically-allocated percpu variable. All want/drop
operations are local to a cpu as long that cpu operates on the same
mount, and there are no writer count imbalances. Writer count
imbalances happen when a write is taken on one cpu, and released
on another, like when an open/close pair is performed on two
Upon a remount,ro request, all of the data from the percpu
variables is collected (expensive, but very rare) and we determine
if there are any outstanding writers to the mount.
I've written a little benchmark to sit in a loop for a couple of
seconds in several cpus in parallel doing open/write/close loops.
http://sr71.net/~dave/linux/openbench.c
The code in here is a a worst-possible case for this patch. It
does opens on a _pair_ of files in two different mounts in parallel.
This should cause my code to lose its "operate on the same mount"
optimization completely. This worst-case scenario causes a 3%
degredation in the benchmark.
I could probably get rid of even this 3%, but it would be more
complex than what I have here, and I think this is getting into
acceptable territory. In practice, I expect writing more than 3
bytes to a file, as well as disk I/O to mask any effects that this
has.
(To get rid of that 3%, we could have an #defined number of mounts
in the percpu variable. So, instead of a CPU getting operate only
on percpu data when it accesses only one mount, it could stay on
percpu data when it only accesses N or fewer mounts.)
[AV] merged fix for __clear_mnt_mount() stepping on freed vfsmount
Acked-by: Al Viro <viro@ZenIV.linux.org.uk>
Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2008-02-16 01:37:59 +03:00
|
|
|
/*
|
2009-04-26 14:25:54 +04:00
|
|
|
* After storing MNT_WRITE_HOLD, we'll read the counters. This store
|
|
|
|
* should be visible before we do.
|
[PATCH] r/o bind mounts: track numbers of writers to mounts
This is the real meat of the entire series. It actually
implements the tracking of the number of writers to a mount.
However, it causes scalability problems because there can be
hundreds of cpus doing open()/close() on files on the same mnt at
the same time. Even an atomic_t in the mnt has massive scalaing
problems because the cacheline gets so terribly contended.
This uses a statically-allocated percpu variable. All want/drop
operations are local to a cpu as long that cpu operates on the same
mount, and there are no writer count imbalances. Writer count
imbalances happen when a write is taken on one cpu, and released
on another, like when an open/close pair is performed on two
Upon a remount,ro request, all of the data from the percpu
variables is collected (expensive, but very rare) and we determine
if there are any outstanding writers to the mount.
I've written a little benchmark to sit in a loop for a couple of
seconds in several cpus in parallel doing open/write/close loops.
http://sr71.net/~dave/linux/openbench.c
The code in here is a a worst-possible case for this patch. It
does opens on a _pair_ of files in two different mounts in parallel.
This should cause my code to lose its "operate on the same mount"
optimization completely. This worst-case scenario causes a 3%
degredation in the benchmark.
I could probably get rid of even this 3%, but it would be more
complex than what I have here, and I think this is getting into
acceptable territory. In practice, I expect writing more than 3
bytes to a file, as well as disk I/O to mask any effects that this
has.
(To get rid of that 3%, we could have an #defined number of mounts
in the percpu variable. So, instead of a CPU getting operate only
on percpu data when it accesses only one mount, it could stay on
percpu data when it only accesses N or fewer mounts.)
[AV] merged fix for __clear_mnt_mount() stepping on freed vfsmount
Acked-by: Al Viro <viro@ZenIV.linux.org.uk>
Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2008-02-16 01:37:59 +03:00
|
|
|
*/
|
2009-04-26 14:25:54 +04:00
|
|
|
smp_mb();
|
|
|
|
|
[PATCH] r/o bind mounts: track numbers of writers to mounts
This is the real meat of the entire series. It actually
implements the tracking of the number of writers to a mount.
However, it causes scalability problems because there can be
hundreds of cpus doing open()/close() on files on the same mnt at
the same time. Even an atomic_t in the mnt has massive scalaing
problems because the cacheline gets so terribly contended.
This uses a statically-allocated percpu variable. All want/drop
operations are local to a cpu as long that cpu operates on the same
mount, and there are no writer count imbalances. Writer count
imbalances happen when a write is taken on one cpu, and released
on another, like when an open/close pair is performed on two
Upon a remount,ro request, all of the data from the percpu
variables is collected (expensive, but very rare) and we determine
if there are any outstanding writers to the mount.
I've written a little benchmark to sit in a loop for a couple of
seconds in several cpus in parallel doing open/write/close loops.
http://sr71.net/~dave/linux/openbench.c
The code in here is a a worst-possible case for this patch. It
does opens on a _pair_ of files in two different mounts in parallel.
This should cause my code to lose its "operate on the same mount"
optimization completely. This worst-case scenario causes a 3%
degredation in the benchmark.
I could probably get rid of even this 3%, but it would be more
complex than what I have here, and I think this is getting into
acceptable territory. In practice, I expect writing more than 3
bytes to a file, as well as disk I/O to mask any effects that this
has.
(To get rid of that 3%, we could have an #defined number of mounts
in the percpu variable. So, instead of a CPU getting operate only
on percpu data when it accesses only one mount, it could stay on
percpu data when it only accesses N or fewer mounts.)
[AV] merged fix for __clear_mnt_mount() stepping on freed vfsmount
Acked-by: Al Viro <viro@ZenIV.linux.org.uk>
Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2008-02-16 01:37:59 +03:00
|
|
|
/*
|
2009-04-26 14:25:54 +04:00
|
|
|
* With writers on hold, if this value is zero, then there are
|
|
|
|
* definitely no active writers (although held writers may subsequently
|
|
|
|
* increment the count, they'll have to wait, and decrement it after
|
|
|
|
* seeing MNT_READONLY).
|
|
|
|
*
|
|
|
|
* It is OK to have counter incremented on one CPU and decremented on
|
|
|
|
* another: the sum will add up correctly. The danger would be when we
|
|
|
|
* sum up each counter, if we read a counter before it is incremented,
|
|
|
|
* but then read another CPU's count which it has been subsequently
|
|
|
|
* decremented from -- we would see more decrements than we should.
|
|
|
|
* MNT_WRITE_HOLD protects against this scenario, because
|
|
|
|
* mnt_want_write first increments count, then smp_mb, then spins on
|
|
|
|
* MNT_WRITE_HOLD, so it can't be decremented by another CPU while
|
|
|
|
* we're counting up here.
|
[PATCH] r/o bind mounts: track numbers of writers to mounts
This is the real meat of the entire series. It actually
implements the tracking of the number of writers to a mount.
However, it causes scalability problems because there can be
hundreds of cpus doing open()/close() on files on the same mnt at
the same time. Even an atomic_t in the mnt has massive scalaing
problems because the cacheline gets so terribly contended.
This uses a statically-allocated percpu variable. All want/drop
operations are local to a cpu as long that cpu operates on the same
mount, and there are no writer count imbalances. Writer count
imbalances happen when a write is taken on one cpu, and released
on another, like when an open/close pair is performed on two
Upon a remount,ro request, all of the data from the percpu
variables is collected (expensive, but very rare) and we determine
if there are any outstanding writers to the mount.
I've written a little benchmark to sit in a loop for a couple of
seconds in several cpus in parallel doing open/write/close loops.
http://sr71.net/~dave/linux/openbench.c
The code in here is a a worst-possible case for this patch. It
does opens on a _pair_ of files in two different mounts in parallel.
This should cause my code to lose its "operate on the same mount"
optimization completely. This worst-case scenario causes a 3%
degredation in the benchmark.
I could probably get rid of even this 3%, but it would be more
complex than what I have here, and I think this is getting into
acceptable territory. In practice, I expect writing more than 3
bytes to a file, as well as disk I/O to mask any effects that this
has.
(To get rid of that 3%, we could have an #defined number of mounts
in the percpu variable. So, instead of a CPU getting operate only
on percpu data when it accesses only one mount, it could stay on
percpu data when it only accesses N or fewer mounts.)
[AV] merged fix for __clear_mnt_mount() stepping on freed vfsmount
Acked-by: Al Viro <viro@ZenIV.linux.org.uk>
Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2008-02-16 01:37:59 +03:00
|
|
|
*/
|
2011-01-07 09:50:10 +03:00
|
|
|
if (mnt_get_writers(mnt) > 0)
|
2021-01-21 16:19:51 +03:00
|
|
|
return -EBUSY;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2022-02-03 16:14:07 +03:00
|
|
|
/**
|
|
|
|
* mnt_unhold_writers - stop preventing write access to the given mount
|
|
|
|
* @mnt: mnt to stop preventing write access to
|
|
|
|
*
|
|
|
|
* Stop preventing write access to @mnt allowing callers to gain write access
|
|
|
|
* to @mnt again.
|
|
|
|
*
|
|
|
|
* This function can only be called after a successful call to
|
|
|
|
* mnt_hold_writers().
|
|
|
|
*
|
|
|
|
* Context: This function expects lock_mount_hash() to be held.
|
|
|
|
*/
|
2021-01-21 16:19:51 +03:00
|
|
|
static inline void mnt_unhold_writers(struct mount *mnt)
|
|
|
|
{
|
2009-04-26 14:25:54 +04:00
|
|
|
/*
|
|
|
|
* MNT_READONLY must become visible before ~MNT_WRITE_HOLD, so writers
|
|
|
|
* that become unheld will see MNT_READONLY.
|
|
|
|
*/
|
|
|
|
smp_wmb();
|
2011-11-25 07:37:54 +04:00
|
|
|
mnt->mnt.mnt_flags &= ~MNT_WRITE_HOLD;
|
2021-01-21 16:19:51 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static int mnt_make_readonly(struct mount *mnt)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = mnt_hold_writers(mnt);
|
|
|
|
if (!ret)
|
|
|
|
mnt->mnt.mnt_flags |= MNT_READONLY;
|
|
|
|
mnt_unhold_writers(mnt);
|
[PATCH] r/o bind mounts: track numbers of writers to mounts
This is the real meat of the entire series. It actually
implements the tracking of the number of writers to a mount.
However, it causes scalability problems because there can be
hundreds of cpus doing open()/close() on files on the same mnt at
the same time. Even an atomic_t in the mnt has massive scalaing
problems because the cacheline gets so terribly contended.
This uses a statically-allocated percpu variable. All want/drop
operations are local to a cpu as long that cpu operates on the same
mount, and there are no writer count imbalances. Writer count
imbalances happen when a write is taken on one cpu, and released
on another, like when an open/close pair is performed on two
Upon a remount,ro request, all of the data from the percpu
variables is collected (expensive, but very rare) and we determine
if there are any outstanding writers to the mount.
I've written a little benchmark to sit in a loop for a couple of
seconds in several cpus in parallel doing open/write/close loops.
http://sr71.net/~dave/linux/openbench.c
The code in here is a a worst-possible case for this patch. It
does opens on a _pair_ of files in two different mounts in parallel.
This should cause my code to lose its "operate on the same mount"
optimization completely. This worst-case scenario causes a 3%
degredation in the benchmark.
I could probably get rid of even this 3%, but it would be more
complex than what I have here, and I think this is getting into
acceptable territory. In practice, I expect writing more than 3
bytes to a file, as well as disk I/O to mask any effects that this
has.
(To get rid of that 3%, we could have an #defined number of mounts
in the percpu variable. So, instead of a CPU getting operate only
on percpu data when it accesses only one mount, it could stay on
percpu data when it only accesses N or fewer mounts.)
[AV] merged fix for __clear_mnt_mount() stepping on freed vfsmount
Acked-by: Al Viro <viro@ZenIV.linux.org.uk>
Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2008-02-16 01:37:59 +03:00
|
|
|
return ret;
|
2008-02-16 01:37:30 +03:00
|
|
|
}
|
|
|
|
|
2011-11-21 15:11:31 +04:00
|
|
|
int sb_prepare_remount_readonly(struct super_block *sb)
|
|
|
|
{
|
|
|
|
struct mount *mnt;
|
|
|
|
int err = 0;
|
|
|
|
|
2011-11-21 15:11:33 +04:00
|
|
|
/* Racy optimization. Recheck the counter under MNT_WRITE_HOLD */
|
|
|
|
if (atomic_long_read(&sb->s_remove_count))
|
|
|
|
return -EBUSY;
|
|
|
|
|
2013-09-29 19:24:49 +04:00
|
|
|
lock_mount_hash();
|
2011-11-21 15:11:31 +04:00
|
|
|
list_for_each_entry(mnt, &sb->s_mounts, mnt_instance) {
|
|
|
|
if (!(mnt->mnt.mnt_flags & MNT_READONLY)) {
|
2022-02-03 16:14:10 +03:00
|
|
|
err = mnt_hold_writers(mnt);
|
|
|
|
if (err)
|
2011-11-21 15:11:31 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2011-11-21 15:11:33 +04:00
|
|
|
if (!err && atomic_long_read(&sb->s_remove_count))
|
|
|
|
err = -EBUSY;
|
|
|
|
|
2011-11-21 15:11:31 +04:00
|
|
|
if (!err) {
|
|
|
|
sb->s_readonly_remount = 1;
|
|
|
|
smp_wmb();
|
|
|
|
}
|
|
|
|
list_for_each_entry(mnt, &sb->s_mounts, mnt_instance) {
|
|
|
|
if (mnt->mnt.mnt_flags & MNT_WRITE_HOLD)
|
|
|
|
mnt->mnt.mnt_flags &= ~MNT_WRITE_HOLD;
|
|
|
|
}
|
2013-09-29 19:24:49 +04:00
|
|
|
unlock_mount_hash();
|
2011-11-21 15:11:31 +04:00
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2011-11-25 05:38:33 +04:00
|
|
|
static void free_vfsmnt(struct mount *mnt)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2022-10-26 13:51:27 +03:00
|
|
|
mnt_idmap_put(mnt_idmap(&mnt->mnt));
|
2015-02-14 01:36:41 +03:00
|
|
|
kfree_const(mnt->mnt_devname);
|
2009-04-26 14:25:54 +04:00
|
|
|
#ifdef CONFIG_SMP
|
2011-11-25 07:53:09 +04:00
|
|
|
free_percpu(mnt->mnt_pcp);
|
2009-04-26 14:25:54 +04:00
|
|
|
#endif
|
2011-11-25 05:38:33 +04:00
|
|
|
kmem_cache_free(mnt_cache, mnt);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2014-01-24 16:17:54 +04:00
|
|
|
static void delayed_free_vfsmnt(struct rcu_head *head)
|
|
|
|
{
|
|
|
|
free_vfsmnt(container_of(head, struct mount, mnt_rcu));
|
|
|
|
}
|
|
|
|
|
2013-09-30 06:06:07 +04:00
|
|
|
/* call under rcu_read_lock */
|
2015-05-08 18:43:53 +03:00
|
|
|
int __legitimize_mnt(struct vfsmount *bastard, unsigned seq)
|
2013-09-30 06:06:07 +04:00
|
|
|
{
|
|
|
|
struct mount *mnt;
|
|
|
|
if (read_seqretry(&mount_lock, seq))
|
2015-05-08 18:43:53 +03:00
|
|
|
return 1;
|
2013-09-30 06:06:07 +04:00
|
|
|
if (bastard == NULL)
|
2015-05-08 18:43:53 +03:00
|
|
|
return 0;
|
2013-09-30 06:06:07 +04:00
|
|
|
mnt = real_mount(bastard);
|
|
|
|
mnt_add_count(mnt, 1);
|
2018-08-10 00:51:32 +03:00
|
|
|
smp_mb(); // see mntput_no_expire()
|
2013-09-30 06:06:07 +04:00
|
|
|
if (likely(!read_seqretry(&mount_lock, seq)))
|
2015-05-08 18:43:53 +03:00
|
|
|
return 0;
|
2013-09-30 06:06:07 +04:00
|
|
|
if (bastard->mnt_flags & MNT_SYNC_UMOUNT) {
|
|
|
|
mnt_add_count(mnt, -1);
|
2015-05-08 18:43:53 +03:00
|
|
|
return 1;
|
|
|
|
}
|
2018-08-10 00:51:32 +03:00
|
|
|
lock_mount_hash();
|
|
|
|
if (unlikely(bastard->mnt_flags & MNT_DOOMED)) {
|
|
|
|
mnt_add_count(mnt, -1);
|
|
|
|
unlock_mount_hash();
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
unlock_mount_hash();
|
|
|
|
/* caller will mntput() */
|
2015-05-08 18:43:53 +03:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* call under rcu_read_lock */
|
2022-07-05 19:22:46 +03:00
|
|
|
static bool legitimize_mnt(struct vfsmount *bastard, unsigned seq)
|
2015-05-08 18:43:53 +03:00
|
|
|
{
|
|
|
|
int res = __legitimize_mnt(bastard, seq);
|
|
|
|
if (likely(!res))
|
|
|
|
return true;
|
|
|
|
if (unlikely(res < 0)) {
|
|
|
|
rcu_read_unlock();
|
|
|
|
mntput(bastard);
|
|
|
|
rcu_read_lock();
|
2013-09-30 06:06:07 +04:00
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/*
|
2013-10-02 00:11:26 +04:00
|
|
|
* find the first mount at @dentry on vfsmount @mnt.
|
2013-09-30 06:06:07 +04:00
|
|
|
* call under rcu_read_lock()
|
2005-04-17 02:20:36 +04:00
|
|
|
*/
|
2013-10-02 00:11:26 +04:00
|
|
|
struct mount *__lookup_mnt(struct vfsmount *mnt, struct dentry *dentry)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2014-03-21 05:10:51 +04:00
|
|
|
struct hlist_head *head = m_hash(mnt, dentry);
|
2013-10-02 00:11:26 +04:00
|
|
|
struct mount *p;
|
|
|
|
|
2014-03-21 05:10:51 +04:00
|
|
|
hlist_for_each_entry_rcu(p, head, mnt_hash)
|
2013-10-02 00:11:26 +04:00
|
|
|
if (&p->mnt_parent->mnt == mnt && p->mnt_mountpoint == dentry)
|
|
|
|
return p;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2005-11-08 01:20:17 +03:00
|
|
|
/*
|
2012-06-25 15:55:28 +04:00
|
|
|
* lookup_mnt - Return the first child mount mounted at path
|
|
|
|
*
|
|
|
|
* "First" means first mounted chronologically. If you create the
|
|
|
|
* following mounts:
|
|
|
|
*
|
|
|
|
* mount /dev/sda1 /mnt
|
|
|
|
* mount /dev/sda2 /mnt
|
|
|
|
* mount /dev/sda3 /mnt
|
|
|
|
*
|
|
|
|
* Then lookup_mnt() on the base /mnt dentry in the root mount will
|
|
|
|
* return successively the root dentry and vfsmount of /dev/sda1, then
|
|
|
|
* /dev/sda2, then /dev/sda3, then NULL.
|
|
|
|
*
|
|
|
|
* lookup_mnt takes a reference to the found vfsmount.
|
2005-11-08 01:20:17 +03:00
|
|
|
*/
|
2016-11-21 03:45:28 +03:00
|
|
|
struct vfsmount *lookup_mnt(const struct path *path)
|
2005-11-08 01:20:17 +03:00
|
|
|
{
|
2011-11-25 03:22:03 +04:00
|
|
|
struct mount *child_mnt;
|
2013-09-30 06:06:07 +04:00
|
|
|
struct vfsmount *m;
|
|
|
|
unsigned seq;
|
fs: brlock vfsmount_lock
fs: brlock vfsmount_lock
Use a brlock for the vfsmount lock. It must be taken for write whenever
modifying the mount hash or associated fields, and may be taken for read when
performing mount hash lookups.
A new lock is added for the mnt-id allocator, so it doesn't need to take
the heavy vfsmount write-lock.
The number of atomics should remain the same for fastpath rlock cases, though
code would be slightly slower due to per-cpu access. Scalability is not not be
much improved in common cases yet, due to other locks (ie. dcache_lock) getting
in the way. However path lookups crossing mountpoints should be one case where
scalability is improved (currently requiring the global lock).
The slowpath is slower due to use of brlock. On a 64 core, 64 socket, 32 node
Altix system (high latency to remote nodes), a simple umount microbenchmark
(mount --bind mnt mnt2 ; umount mnt2 loop 1000 times), before this patch it
took 6.8s, afterwards took 7.1s, about 5% slower.
Cc: Al Viro <viro@ZenIV.linux.org.uk>
Signed-off-by: Nick Piggin <npiggin@kernel.dk>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2010-08-17 22:37:39 +04:00
|
|
|
|
2013-09-30 06:06:07 +04:00
|
|
|
rcu_read_lock();
|
|
|
|
do {
|
|
|
|
seq = read_seqbegin(&mount_lock);
|
|
|
|
child_mnt = __lookup_mnt(path->mnt, path->dentry);
|
|
|
|
m = child_mnt ? &child_mnt->mnt : NULL;
|
|
|
|
} while (!legitimize_mnt(m, seq));
|
|
|
|
rcu_read_unlock();
|
|
|
|
return m;
|
2005-11-08 01:20:17 +03:00
|
|
|
}
|
|
|
|
|
2020-05-14 17:44:24 +03:00
|
|
|
static inline void lock_ns_list(struct mnt_namespace *ns)
|
|
|
|
{
|
|
|
|
spin_lock(&ns->ns_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void unlock_ns_list(struct mnt_namespace *ns)
|
|
|
|
{
|
|
|
|
spin_unlock(&ns->ns_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool mnt_is_cursor(struct mount *mnt)
|
|
|
|
{
|
|
|
|
return mnt->mnt.mnt_flags & MNT_CURSOR;
|
|
|
|
}
|
|
|
|
|
2013-10-05 06:15:13 +04:00
|
|
|
/*
|
|
|
|
* __is_local_mountpoint - Test to see if dentry is a mountpoint in the
|
|
|
|
* current mount namespace.
|
|
|
|
*
|
|
|
|
* The common case is dentries are not mountpoints at all and that
|
|
|
|
* test is handled inline. For the slow case when we are actually
|
|
|
|
* dealing with a mountpoint of some kind, walk through all of the
|
|
|
|
* mounts in the current mount namespace and test to see if the dentry
|
|
|
|
* is a mountpoint.
|
|
|
|
*
|
|
|
|
* The mount_hashtable is not usable in the context because we
|
|
|
|
* need to identify all mounts that may be in the current mount
|
|
|
|
* namespace not just a mount that happens to have some specified
|
|
|
|
* parent mount.
|
|
|
|
*/
|
|
|
|
bool __is_local_mountpoint(struct dentry *dentry)
|
|
|
|
{
|
|
|
|
struct mnt_namespace *ns = current->nsproxy->mnt_ns;
|
|
|
|
struct mount *mnt;
|
|
|
|
bool is_covered = false;
|
|
|
|
|
|
|
|
down_read(&namespace_sem);
|
2020-05-14 17:44:24 +03:00
|
|
|
lock_ns_list(ns);
|
2013-10-05 06:15:13 +04:00
|
|
|
list_for_each_entry(mnt, &ns->list, mnt_list) {
|
2020-05-14 17:44:24 +03:00
|
|
|
if (mnt_is_cursor(mnt))
|
|
|
|
continue;
|
2013-10-05 06:15:13 +04:00
|
|
|
is_covered = (mnt->mnt_mountpoint == dentry);
|
|
|
|
if (is_covered)
|
|
|
|
break;
|
|
|
|
}
|
2020-05-14 17:44:24 +03:00
|
|
|
unlock_ns_list(ns);
|
2013-10-05 06:15:13 +04:00
|
|
|
up_read(&namespace_sem);
|
2020-03-04 19:12:45 +03:00
|
|
|
|
2013-10-05 06:15:13 +04:00
|
|
|
return is_covered;
|
|
|
|
}
|
|
|
|
|
2014-02-25 05:32:34 +04:00
|
|
|
static struct mountpoint *lookup_mountpoint(struct dentry *dentry)
|
2013-03-15 18:53:28 +04:00
|
|
|
{
|
2014-02-28 22:46:44 +04:00
|
|
|
struct hlist_head *chain = mp_hash(dentry);
|
2013-03-15 18:53:28 +04:00
|
|
|
struct mountpoint *mp;
|
|
|
|
|
2014-02-28 22:46:44 +04:00
|
|
|
hlist_for_each_entry(mp, chain, m_hash) {
|
2013-03-15 18:53:28 +04:00
|
|
|
if (mp->m_dentry == dentry) {
|
|
|
|
mp->m_count++;
|
|
|
|
return mp;
|
|
|
|
}
|
|
|
|
}
|
2014-02-25 05:32:34 +04:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2017-01-03 04:18:43 +03:00
|
|
|
static struct mountpoint *get_mountpoint(struct dentry *dentry)
|
2014-02-25 05:32:34 +04:00
|
|
|
{
|
2017-01-03 04:18:43 +03:00
|
|
|
struct mountpoint *mp, *new = NULL;
|
2014-02-25 05:32:34 +04:00
|
|
|
int ret;
|
2013-03-15 18:53:28 +04:00
|
|
|
|
2017-01-03 04:18:43 +03:00
|
|
|
if (d_mountpoint(dentry)) {
|
2018-10-03 17:18:33 +03:00
|
|
|
/* might be worth a WARN_ON() */
|
|
|
|
if (d_unlinked(dentry))
|
|
|
|
return ERR_PTR(-ENOENT);
|
2017-01-03 04:18:43 +03:00
|
|
|
mountpoint:
|
|
|
|
read_seqlock_excl(&mount_lock);
|
|
|
|
mp = lookup_mountpoint(dentry);
|
|
|
|
read_sequnlock_excl(&mount_lock);
|
|
|
|
if (mp)
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!new)
|
|
|
|
new = kmalloc(sizeof(struct mountpoint), GFP_KERNEL);
|
|
|
|
if (!new)
|
2013-03-15 18:53:28 +04:00
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
2017-01-03 04:18:43 +03:00
|
|
|
|
|
|
|
/* Exactly one processes may set d_mounted */
|
2013-09-05 16:39:11 +04:00
|
|
|
ret = d_set_mounted(dentry);
|
|
|
|
|
2017-01-03 04:18:43 +03:00
|
|
|
/* Someone else set d_mounted? */
|
|
|
|
if (ret == -EBUSY)
|
|
|
|
goto mountpoint;
|
|
|
|
|
|
|
|
/* The dentry is not available as a mountpoint? */
|
|
|
|
mp = ERR_PTR(ret);
|
|
|
|
if (ret)
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
/* Add the new mountpoint to the hash table */
|
|
|
|
read_seqlock_excl(&mount_lock);
|
2019-06-30 17:39:08 +03:00
|
|
|
new->m_dentry = dget(dentry);
|
2017-01-03 04:18:43 +03:00
|
|
|
new->m_count = 1;
|
|
|
|
hlist_add_head(&new->m_hash, mp_hash(dentry));
|
|
|
|
INIT_HLIST_HEAD(&new->m_list);
|
|
|
|
read_sequnlock_excl(&mount_lock);
|
|
|
|
|
|
|
|
mp = new;
|
|
|
|
new = NULL;
|
|
|
|
done:
|
|
|
|
kfree(new);
|
2013-03-15 18:53:28 +04:00
|
|
|
return mp;
|
|
|
|
}
|
|
|
|
|
2019-06-30 17:39:08 +03:00
|
|
|
/*
|
|
|
|
* vfsmount lock must be held. Additionally, the caller is responsible
|
|
|
|
* for serializing calls for given disposal list.
|
|
|
|
*/
|
|
|
|
static void __put_mountpoint(struct mountpoint *mp, struct list_head *list)
|
2013-03-15 18:53:28 +04:00
|
|
|
{
|
|
|
|
if (!--mp->m_count) {
|
|
|
|
struct dentry *dentry = mp->m_dentry;
|
2013-09-23 06:37:01 +04:00
|
|
|
BUG_ON(!hlist_empty(&mp->m_list));
|
2013-03-15 18:53:28 +04:00
|
|
|
spin_lock(&dentry->d_lock);
|
|
|
|
dentry->d_flags &= ~DCACHE_MOUNTED;
|
|
|
|
spin_unlock(&dentry->d_lock);
|
2019-06-30 17:39:08 +03:00
|
|
|
dput_to_list(dentry, list);
|
2014-02-28 22:46:44 +04:00
|
|
|
hlist_del(&mp->m_hash);
|
2013-03-15 18:53:28 +04:00
|
|
|
kfree(mp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-30 17:39:08 +03:00
|
|
|
/* called with namespace_lock and vfsmount lock */
|
|
|
|
static void put_mountpoint(struct mountpoint *mp)
|
|
|
|
{
|
|
|
|
__put_mountpoint(mp, &ex_mountpoints);
|
|
|
|
}
|
|
|
|
|
2011-11-25 09:46:35 +04:00
|
|
|
static inline int check_mnt(struct mount *mnt)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2006-12-08 13:37:56 +03:00
|
|
|
return mnt->mnt_ns == current->nsproxy->mnt_ns;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
fs: brlock vfsmount_lock
fs: brlock vfsmount_lock
Use a brlock for the vfsmount lock. It must be taken for write whenever
modifying the mount hash or associated fields, and may be taken for read when
performing mount hash lookups.
A new lock is added for the mnt-id allocator, so it doesn't need to take
the heavy vfsmount write-lock.
The number of atomics should remain the same for fastpath rlock cases, though
code would be slightly slower due to per-cpu access. Scalability is not not be
much improved in common cases yet, due to other locks (ie. dcache_lock) getting
in the way. However path lookups crossing mountpoints should be one case where
scalability is improved (currently requiring the global lock).
The slowpath is slower due to use of brlock. On a 64 core, 64 socket, 32 node
Altix system (high latency to remote nodes), a simple umount microbenchmark
(mount --bind mnt mnt2 ; umount mnt2 loop 1000 times), before this patch it
took 6.8s, afterwards took 7.1s, about 5% slower.
Cc: Al Viro <viro@ZenIV.linux.org.uk>
Signed-off-by: Nick Piggin <npiggin@kernel.dk>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2010-08-17 22:37:39 +04:00
|
|
|
/*
|
|
|
|
* vfsmount lock must be held for write
|
|
|
|
*/
|
2006-12-08 13:37:56 +03:00
|
|
|
static void touch_mnt_namespace(struct mnt_namespace *ns)
|
2005-11-08 01:15:49 +03:00
|
|
|
{
|
|
|
|
if (ns) {
|
|
|
|
ns->event = ++event;
|
|
|
|
wake_up_interruptible(&ns->poll);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
fs: brlock vfsmount_lock
fs: brlock vfsmount_lock
Use a brlock for the vfsmount lock. It must be taken for write whenever
modifying the mount hash or associated fields, and may be taken for read when
performing mount hash lookups.
A new lock is added for the mnt-id allocator, so it doesn't need to take
the heavy vfsmount write-lock.
The number of atomics should remain the same for fastpath rlock cases, though
code would be slightly slower due to per-cpu access. Scalability is not not be
much improved in common cases yet, due to other locks (ie. dcache_lock) getting
in the way. However path lookups crossing mountpoints should be one case where
scalability is improved (currently requiring the global lock).
The slowpath is slower due to use of brlock. On a 64 core, 64 socket, 32 node
Altix system (high latency to remote nodes), a simple umount microbenchmark
(mount --bind mnt mnt2 ; umount mnt2 loop 1000 times), before this patch it
took 6.8s, afterwards took 7.1s, about 5% slower.
Cc: Al Viro <viro@ZenIV.linux.org.uk>
Signed-off-by: Nick Piggin <npiggin@kernel.dk>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2010-08-17 22:37:39 +04:00
|
|
|
/*
|
|
|
|
* vfsmount lock must be held for write
|
|
|
|
*/
|
2006-12-08 13:37:56 +03:00
|
|
|
static void __touch_mnt_namespace(struct mnt_namespace *ns)
|
2005-11-08 01:15:49 +03:00
|
|
|
{
|
|
|
|
if (ns && ns->event != event) {
|
|
|
|
ns->event = event;
|
|
|
|
wake_up_interruptible(&ns->poll);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
fs: brlock vfsmount_lock
fs: brlock vfsmount_lock
Use a brlock for the vfsmount lock. It must be taken for write whenever
modifying the mount hash or associated fields, and may be taken for read when
performing mount hash lookups.
A new lock is added for the mnt-id allocator, so it doesn't need to take
the heavy vfsmount write-lock.
The number of atomics should remain the same for fastpath rlock cases, though
code would be slightly slower due to per-cpu access. Scalability is not not be
much improved in common cases yet, due to other locks (ie. dcache_lock) getting
in the way. However path lookups crossing mountpoints should be one case where
scalability is improved (currently requiring the global lock).
The slowpath is slower due to use of brlock. On a 64 core, 64 socket, 32 node
Altix system (high latency to remote nodes), a simple umount microbenchmark
(mount --bind mnt mnt2 ; umount mnt2 loop 1000 times), before this patch it
took 6.8s, afterwards took 7.1s, about 5% slower.
Cc: Al Viro <viro@ZenIV.linux.org.uk>
Signed-off-by: Nick Piggin <npiggin@kernel.dk>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2010-08-17 22:37:39 +04:00
|
|
|
/*
|
|
|
|
* vfsmount lock must be held for write
|
|
|
|
*/
|
2019-06-29 19:58:42 +03:00
|
|
|
static struct mountpoint *unhash_mnt(struct mount *mnt)
|
2011-11-25 04:41:16 +04:00
|
|
|
{
|
2019-06-29 19:58:42 +03:00
|
|
|
struct mountpoint *mp;
|
2011-11-25 07:19:58 +04:00
|
|
|
mnt->mnt_parent = mnt;
|
2011-11-25 07:25:07 +04:00
|
|
|
mnt->mnt_mountpoint = mnt->mnt.mnt_root;
|
2011-11-25 08:24:33 +04:00
|
|
|
list_del_init(&mnt->mnt_child);
|
2014-03-21 05:10:51 +04:00
|
|
|
hlist_del_init_rcu(&mnt->mnt_hash);
|
2013-09-23 06:37:01 +04:00
|
|
|
hlist_del_init(&mnt->mnt_mp_list);
|
2019-06-29 19:58:42 +03:00
|
|
|
mp = mnt->mnt_mp;
|
2013-03-15 18:53:28 +04:00
|
|
|
mnt->mnt_mp = NULL;
|
2019-06-29 19:58:42 +03:00
|
|
|
return mp;
|
2014-12-29 22:03:41 +03:00
|
|
|
}
|
|
|
|
|
2015-01-16 07:58:33 +03:00
|
|
|
/*
|
|
|
|
* vfsmount lock must be held for write
|
|
|
|
*/
|
|
|
|
static void umount_mnt(struct mount *mnt)
|
|
|
|
{
|
2019-06-29 19:58:42 +03:00
|
|
|
put_mountpoint(unhash_mnt(mnt));
|
2015-01-16 07:58:33 +03:00
|
|
|
}
|
|
|
|
|
fs: brlock vfsmount_lock
fs: brlock vfsmount_lock
Use a brlock for the vfsmount lock. It must be taken for write whenever
modifying the mount hash or associated fields, and may be taken for read when
performing mount hash lookups.
A new lock is added for the mnt-id allocator, so it doesn't need to take
the heavy vfsmount write-lock.
The number of atomics should remain the same for fastpath rlock cases, though
code would be slightly slower due to per-cpu access. Scalability is not not be
much improved in common cases yet, due to other locks (ie. dcache_lock) getting
in the way. However path lookups crossing mountpoints should be one case where
scalability is improved (currently requiring the global lock).
The slowpath is slower due to use of brlock. On a 64 core, 64 socket, 32 node
Altix system (high latency to remote nodes), a simple umount microbenchmark
(mount --bind mnt mnt2 ; umount mnt2 loop 1000 times), before this patch it
took 6.8s, afterwards took 7.1s, about 5% slower.
Cc: Al Viro <viro@ZenIV.linux.org.uk>
Signed-off-by: Nick Piggin <npiggin@kernel.dk>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2010-08-17 22:37:39 +04:00
|
|
|
/*
|
|
|
|
* vfsmount lock must be held for write
|
|
|
|
*/
|
2013-03-15 18:53:28 +04:00
|
|
|
void mnt_set_mountpoint(struct mount *mnt,
|
|
|
|
struct mountpoint *mp,
|
2011-11-25 06:28:22 +04:00
|
|
|
struct mount *child_mnt)
|
2005-11-08 01:19:50 +03:00
|
|
|
{
|
2013-03-15 18:53:28 +04:00
|
|
|
mp->m_count++;
|
2011-11-25 12:19:09 +04:00
|
|
|
mnt_add_count(mnt, 1); /* essentially, that's mntget */
|
2019-06-30 17:39:08 +03:00
|
|
|
child_mnt->mnt_mountpoint = mp->m_dentry;
|
2011-11-25 12:19:09 +04:00
|
|
|
child_mnt->mnt_parent = mnt;
|
2013-03-15 18:53:28 +04:00
|
|
|
child_mnt->mnt_mp = mp;
|
2013-09-23 06:37:01 +04:00
|
|
|
hlist_add_head(&child_mnt->mnt_mp_list, &mp->m_list);
|
2005-11-08 01:19:50 +03:00
|
|
|
}
|
|
|
|
|
2017-01-20 08:28:35 +03:00
|
|
|
static void __attach_mnt(struct mount *mnt, struct mount *parent)
|
|
|
|
{
|
|
|
|
hlist_add_head_rcu(&mnt->mnt_hash,
|
|
|
|
m_hash(&parent->mnt, mnt->mnt_mountpoint));
|
|
|
|
list_add_tail(&mnt->mnt_child, &parent->mnt_mounts);
|
|
|
|
}
|
|
|
|
|
fs: brlock vfsmount_lock
fs: brlock vfsmount_lock
Use a brlock for the vfsmount lock. It must be taken for write whenever
modifying the mount hash or associated fields, and may be taken for read when
performing mount hash lookups.
A new lock is added for the mnt-id allocator, so it doesn't need to take
the heavy vfsmount write-lock.
The number of atomics should remain the same for fastpath rlock cases, though
code would be slightly slower due to per-cpu access. Scalability is not not be
much improved in common cases yet, due to other locks (ie. dcache_lock) getting
in the way. However path lookups crossing mountpoints should be one case where
scalability is improved (currently requiring the global lock).
The slowpath is slower due to use of brlock. On a 64 core, 64 socket, 32 node
Altix system (high latency to remote nodes), a simple umount microbenchmark
(mount --bind mnt mnt2 ; umount mnt2 loop 1000 times), before this patch it
took 6.8s, afterwards took 7.1s, about 5% slower.
Cc: Al Viro <viro@ZenIV.linux.org.uk>
Signed-off-by: Nick Piggin <npiggin@kernel.dk>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2010-08-17 22:37:39 +04:00
|
|
|
/*
|
|
|
|
* vfsmount lock must be held for write
|
|
|
|
*/
|
2013-03-15 18:53:28 +04:00
|
|
|
static void attach_mnt(struct mount *mnt,
|
|
|
|
struct mount *parent,
|
|
|
|
struct mountpoint *mp)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2013-03-15 18:53:28 +04:00
|
|
|
mnt_set_mountpoint(parent, mp, mnt);
|
2017-01-20 08:28:35 +03:00
|
|
|
__attach_mnt(mnt, parent);
|
2005-11-08 01:19:50 +03:00
|
|
|
}
|
|
|
|
|
2017-01-20 08:28:35 +03:00
|
|
|
void mnt_change_mountpoint(struct mount *parent, struct mountpoint *mp, struct mount *mnt)
|
2014-08-10 11:44:55 +04:00
|
|
|
{
|
2017-01-20 08:28:35 +03:00
|
|
|
struct mountpoint *old_mp = mnt->mnt_mp;
|
|
|
|
struct mount *old_parent = mnt->mnt_parent;
|
|
|
|
|
|
|
|
list_del_init(&mnt->mnt_child);
|
|
|
|
hlist_del_init(&mnt->mnt_mp_list);
|
|
|
|
hlist_del_init_rcu(&mnt->mnt_hash);
|
|
|
|
|
|
|
|
attach_mnt(mnt, parent, mp);
|
|
|
|
|
|
|
|
put_mountpoint(old_mp);
|
|
|
|
mnt_add_count(old_parent, -1);
|
2014-08-10 11:44:55 +04:00
|
|
|
}
|
|
|
|
|
2005-11-08 01:19:50 +03:00
|
|
|
/*
|
fs: brlock vfsmount_lock
fs: brlock vfsmount_lock
Use a brlock for the vfsmount lock. It must be taken for write whenever
modifying the mount hash or associated fields, and may be taken for read when
performing mount hash lookups.
A new lock is added for the mnt-id allocator, so it doesn't need to take
the heavy vfsmount write-lock.
The number of atomics should remain the same for fastpath rlock cases, though
code would be slightly slower due to per-cpu access. Scalability is not not be
much improved in common cases yet, due to other locks (ie. dcache_lock) getting
in the way. However path lookups crossing mountpoints should be one case where
scalability is improved (currently requiring the global lock).
The slowpath is slower due to use of brlock. On a 64 core, 64 socket, 32 node
Altix system (high latency to remote nodes), a simple umount microbenchmark
(mount --bind mnt mnt2 ; umount mnt2 loop 1000 times), before this patch it
took 6.8s, afterwards took 7.1s, about 5% slower.
Cc: Al Viro <viro@ZenIV.linux.org.uk>
Signed-off-by: Nick Piggin <npiggin@kernel.dk>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2010-08-17 22:37:39 +04:00
|
|
|
* vfsmount lock must be held for write
|
2005-11-08 01:19:50 +03:00
|
|
|
*/
|
2017-01-20 08:28:35 +03:00
|
|
|
static void commit_tree(struct mount *mnt)
|
2005-11-08 01:19:50 +03:00
|
|
|
{
|
2011-11-25 07:19:58 +04:00
|
|
|
struct mount *parent = mnt->mnt_parent;
|
2011-11-25 07:37:54 +04:00
|
|
|
struct mount *m;
|
2005-11-08 01:19:50 +03:00
|
|
|
LIST_HEAD(head);
|
2011-11-25 09:46:35 +04:00
|
|
|
struct mnt_namespace *n = parent->mnt_ns;
|
2005-11-08 01:19:50 +03:00
|
|
|
|
2011-11-25 07:19:58 +04:00
|
|
|
BUG_ON(parent == mnt);
|
2005-11-08 01:19:50 +03:00
|
|
|
|
2011-11-25 11:19:55 +04:00
|
|
|
list_add_tail(&head, &mnt->mnt_list);
|
2012-06-09 08:59:08 +04:00
|
|
|
list_for_each_entry(m, &head, mnt_list)
|
2011-11-25 09:46:35 +04:00
|
|
|
m->mnt_ns = n;
|
2011-01-15 06:30:21 +03:00
|
|
|
|
2005-11-08 01:19:50 +03:00
|
|
|
list_splice(&head, n->list.prev);
|
|
|
|
|
2016-09-28 08:27:17 +03:00
|
|
|
n->mounts += n->pending_mounts;
|
|
|
|
n->pending_mounts = 0;
|
|
|
|
|
2017-01-20 08:28:35 +03:00
|
|
|
__attach_mnt(mnt, parent);
|
2006-12-08 13:37:56 +03:00
|
|
|
touch_mnt_namespace(n);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2011-11-25 12:06:56 +04:00
|
|
|
static struct mount *next_mnt(struct mount *p, struct mount *root)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2011-11-25 08:24:33 +04:00
|
|
|
struct list_head *next = p->mnt_mounts.next;
|
|
|
|
if (next == &p->mnt_mounts) {
|
2005-04-17 02:20:36 +04:00
|
|
|
while (1) {
|
2011-11-25 12:06:56 +04:00
|
|
|
if (p == root)
|
2005-04-17 02:20:36 +04:00
|
|
|
return NULL;
|
2011-11-25 08:24:33 +04:00
|
|
|
next = p->mnt_child.next;
|
|
|
|
if (next != &p->mnt_parent->mnt_mounts)
|
2005-04-17 02:20:36 +04:00
|
|
|
break;
|
2011-11-25 07:19:58 +04:00
|
|
|
p = p->mnt_parent;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
}
|
2011-11-25 08:24:33 +04:00
|
|
|
return list_entry(next, struct mount, mnt_child);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2011-11-25 03:57:30 +04:00
|
|
|
static struct mount *skip_mnt_tree(struct mount *p)
|
2005-11-08 01:21:20 +03:00
|
|
|
{
|
2011-11-25 08:24:33 +04:00
|
|
|
struct list_head *prev = p->mnt_mounts.prev;
|
|
|
|
while (prev != &p->mnt_mounts) {
|
|
|
|
p = list_entry(prev, struct mount, mnt_child);
|
|
|
|
prev = p->mnt_mounts.prev;
|
2005-11-08 01:21:20 +03:00
|
|
|
}
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
2018-11-04 14:48:34 +03:00
|
|
|
/**
|
|
|
|
* vfs_create_mount - Create a mount for a configured superblock
|
|
|
|
* @fc: The configuration context with the superblock attached
|
|
|
|
*
|
|
|
|
* Create a mount to an already configured superblock. If necessary, the
|
|
|
|
* caller should invoke vfs_get_tree() before calling this.
|
|
|
|
*
|
|
|
|
* Note that this does not attach the mount to anything.
|
|
|
|
*/
|
|
|
|
struct vfsmount *vfs_create_mount(struct fs_context *fc)
|
2011-03-18 05:08:28 +03:00
|
|
|
{
|
2011-11-25 05:38:33 +04:00
|
|
|
struct mount *mnt;
|
2011-03-18 05:08:28 +03:00
|
|
|
|
2018-11-04 14:48:34 +03:00
|
|
|
if (!fc->root)
|
|
|
|
return ERR_PTR(-EINVAL);
|
2011-03-18 05:08:28 +03:00
|
|
|
|
2018-11-04 14:48:34 +03:00
|
|
|
mnt = alloc_vfsmnt(fc->source ?: "none");
|
2011-03-18 05:08:28 +03:00
|
|
|
if (!mnt)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
2018-11-04 14:48:34 +03:00
|
|
|
if (fc->sb_flags & SB_KERNMOUNT)
|
2011-11-25 05:38:33 +04:00
|
|
|
mnt->mnt.mnt_flags = MNT_INTERNAL;
|
2011-03-18 05:08:28 +03:00
|
|
|
|
2018-11-04 14:48:34 +03:00
|
|
|
atomic_inc(&fc->root->d_sb->s_active);
|
|
|
|
mnt->mnt.mnt_sb = fc->root->d_sb;
|
|
|
|
mnt->mnt.mnt_root = dget(fc->root);
|
|
|
|
mnt->mnt_mountpoint = mnt->mnt.mnt_root;
|
|
|
|
mnt->mnt_parent = mnt;
|
2011-03-18 05:08:28 +03:00
|
|
|
|
2013-09-29 19:24:49 +04:00
|
|
|
lock_mount_hash();
|
2018-11-04 14:48:34 +03:00
|
|
|
list_add_tail(&mnt->mnt_instance, &mnt->mnt.mnt_sb->s_mounts);
|
2013-09-29 19:24:49 +04:00
|
|
|
unlock_mount_hash();
|
2011-11-25 05:38:33 +04:00
|
|
|
return &mnt->mnt;
|
2011-03-18 05:08:28 +03:00
|
|
|
}
|
2018-11-04 14:48:34 +03:00
|
|
|
EXPORT_SYMBOL(vfs_create_mount);
|
|
|
|
|
|
|
|
struct vfsmount *fc_mount(struct fs_context *fc)
|
|
|
|
{
|
|
|
|
int err = vfs_get_tree(fc);
|
|
|
|
if (!err) {
|
|
|
|
up_write(&fc->root->d_sb->s_umount);
|
|
|
|
return vfs_create_mount(fc);
|
|
|
|
}
|
|
|
|
return ERR_PTR(err);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(fc_mount);
|
|
|
|
|
2018-11-04 11:19:03 +03:00
|
|
|
struct vfsmount *vfs_kern_mount(struct file_system_type *type,
|
|
|
|
int flags, const char *name,
|
|
|
|
void *data)
|
2011-03-18 05:08:28 +03:00
|
|
|
{
|
2018-11-04 11:19:03 +03:00
|
|
|
struct fs_context *fc;
|
2018-11-04 14:48:34 +03:00
|
|
|
struct vfsmount *mnt;
|
2018-11-04 11:19:03 +03:00
|
|
|
int ret = 0;
|
2011-03-18 05:08:28 +03:00
|
|
|
|
|
|
|
if (!type)
|
2018-11-02 02:07:25 +03:00
|
|
|
return ERR_PTR(-EINVAL);
|
2011-03-18 05:08:28 +03:00
|
|
|
|
2018-11-04 11:19:03 +03:00
|
|
|
fc = fs_context_for_mount(type, flags);
|
|
|
|
if (IS_ERR(fc))
|
|
|
|
return ERR_CAST(fc);
|
|
|
|
|
2018-11-02 02:07:25 +03:00
|
|
|
if (name)
|
|
|
|
ret = vfs_parse_fs_string(fc, "source",
|
|
|
|
name, strlen(name));
|
2018-11-04 11:19:03 +03:00
|
|
|
if (!ret)
|
|
|
|
ret = parse_monolithic_mount_data(fc, data);
|
|
|
|
if (!ret)
|
2018-11-04 14:48:34 +03:00
|
|
|
mnt = fc_mount(fc);
|
|
|
|
else
|
|
|
|
mnt = ERR_PTR(ret);
|
2011-03-18 05:08:28 +03:00
|
|
|
|
2018-11-04 11:19:03 +03:00
|
|
|
put_fs_context(fc);
|
2018-11-04 14:48:34 +03:00
|
|
|
return mnt;
|
2011-03-18 05:08:28 +03:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(vfs_kern_mount);
|
|
|
|
|
2017-01-31 20:06:16 +03:00
|
|
|
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);
|
|
|
|
|
2017-07-17 10:45:35 +03:00
|
|
|
return vfs_kern_mount(type, SB_SUBMOUNT, name, data);
|
2017-01-31 20:06:16 +03:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(vfs_submount);
|
|
|
|
|
2011-11-25 06:24:27 +04:00
|
|
|
static struct mount *clone_mnt(struct mount *old, struct dentry *root,
|
2005-11-08 01:17:22 +03:00
|
|
|
int flag)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2011-11-25 06:24:27 +04:00
|
|
|
struct super_block *sb = old->mnt.mnt_sb;
|
2012-06-25 15:55:18 +04:00
|
|
|
struct mount *mnt;
|
|
|
|
int err;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2012-06-25 15:55:18 +04:00
|
|
|
mnt = alloc_vfsmnt(old->mnt_devname);
|
|
|
|
if (!mnt)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
2008-03-27 15:06:23 +03:00
|
|
|
|
2012-08-01 00:13:04 +04:00
|
|
|
if (flag & (CL_SLAVE | CL_PRIVATE | CL_SHARED_TO_SLAVE))
|
2012-06-25 15:55:18 +04:00
|
|
|
mnt->mnt_group_id = 0; /* not a peer of original */
|
|
|
|
else
|
|
|
|
mnt->mnt_group_id = old->mnt_group_id;
|
2005-11-08 01:19:50 +03:00
|
|
|
|
2012-06-25 15:55:18 +04:00
|
|
|
if ((flag & CL_MAKE_SHARED) && !mnt->mnt_group_id) {
|
|
|
|
err = mnt_alloc_group_id(mnt);
|
|
|
|
if (err)
|
|
|
|
goto out_free;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
2012-06-25 15:55:18 +04:00
|
|
|
|
2018-04-20 05:03:08 +03:00
|
|
|
mnt->mnt.mnt_flags = old->mnt.mnt_flags;
|
|
|
|
mnt->mnt.mnt_flags &= ~(MNT_WRITE_HOLD|MNT_MARKED|MNT_INTERNAL);
|
2013-03-30 08:04:39 +04:00
|
|
|
|
2012-06-25 15:55:18 +04:00
|
|
|
atomic_inc(&sb->s_active);
|
2022-10-26 13:51:27 +03:00
|
|
|
mnt->mnt.mnt_idmap = mnt_idmap_get(mnt_idmap(&old->mnt));
|
|
|
|
|
2012-06-25 15:55:18 +04:00
|
|
|
mnt->mnt.mnt_sb = sb;
|
|
|
|
mnt->mnt.mnt_root = dget(root);
|
|
|
|
mnt->mnt_mountpoint = mnt->mnt.mnt_root;
|
|
|
|
mnt->mnt_parent = mnt;
|
2013-09-29 19:24:49 +04:00
|
|
|
lock_mount_hash();
|
2012-06-25 15:55:18 +04:00
|
|
|
list_add_tail(&mnt->mnt_instance, &sb->s_mounts);
|
2013-09-29 19:24:49 +04:00
|
|
|
unlock_mount_hash();
|
2012-06-25 15:55:18 +04:00
|
|
|
|
2012-08-01 00:13:04 +04:00
|
|
|
if ((flag & CL_SLAVE) ||
|
|
|
|
((flag & CL_SHARED_TO_SLAVE) && IS_MNT_SHARED(old))) {
|
2012-06-25 15:55:18 +04:00
|
|
|
list_add(&mnt->mnt_slave, &old->mnt_slave_list);
|
|
|
|
mnt->mnt_master = old;
|
|
|
|
CLEAR_MNT_SHARED(mnt);
|
|
|
|
} else if (!(flag & CL_PRIVATE)) {
|
|
|
|
if ((flag & CL_MAKE_SHARED) || IS_MNT_SHARED(old))
|
|
|
|
list_add(&mnt->mnt_share, &old->mnt_share);
|
|
|
|
if (IS_MNT_SLAVE(old))
|
|
|
|
list_add(&mnt->mnt_slave, &old->mnt_slave);
|
|
|
|
mnt->mnt_master = old->mnt_master;
|
2016-11-21 03:33:09 +03:00
|
|
|
} else {
|
|
|
|
CLEAR_MNT_SHARED(mnt);
|
2012-06-25 15:55:18 +04:00
|
|
|
}
|
|
|
|
if (flag & CL_MAKE_SHARED)
|
|
|
|
set_mnt_shared(mnt);
|
|
|
|
|
|
|
|
/* stick the duplicate mount on the same expiry list
|
|
|
|
* as the original if that was on one */
|
|
|
|
if (flag & CL_EXPIRE) {
|
|
|
|
if (!list_empty(&old->mnt_expire))
|
|
|
|
list_add(&mnt->mnt_expire, &old->mnt_expire);
|
|
|
|
}
|
|
|
|
|
2011-11-25 05:55:08 +04:00
|
|
|
return mnt;
|
2008-03-27 15:06:23 +03:00
|
|
|
|
|
|
|
out_free:
|
2014-01-24 16:17:54 +04:00
|
|
|
mnt_free_id(mnt);
|
2008-03-27 15:06:23 +03:00
|
|
|
free_vfsmnt(mnt);
|
2012-06-25 15:55:18 +04:00
|
|
|
return ERR_PTR(err);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2014-08-08 21:08:20 +04:00
|
|
|
static void cleanup_mnt(struct mount *mnt)
|
|
|
|
{
|
2019-07-04 23:57:51 +03:00
|
|
|
struct hlist_node *p;
|
|
|
|
struct mount *m;
|
2014-08-08 21:08:20 +04:00
|
|
|
/*
|
2019-07-04 23:57:51 +03:00
|
|
|
* The warning here probably indicates that somebody messed
|
|
|
|
* up a mnt_want/drop_write() pair. If this happens, the
|
|
|
|
* filesystem was probably unable to make r/w->r/o transitions.
|
2014-08-08 21:08:20 +04:00
|
|
|
* The locking used to deal with mnt_count decrement provides barriers,
|
|
|
|
* so mnt_get_writers() below is safe.
|
|
|
|
*/
|
|
|
|
WARN_ON(mnt_get_writers(mnt));
|
|
|
|
if (unlikely(mnt->mnt_pins.first))
|
|
|
|
mnt_pin_kill(mnt);
|
2019-07-04 23:57:51 +03:00
|
|
|
hlist_for_each_entry_safe(m, p, &mnt->mnt_stuck_children, mnt_umount) {
|
|
|
|
hlist_del(&m->mnt_umount);
|
|
|
|
mntput(&m->mnt);
|
|
|
|
}
|
2014-08-08 21:08:20 +04:00
|
|
|
fsnotify_vfsmount_delete(&mnt->mnt);
|
|
|
|
dput(mnt->mnt.mnt_root);
|
|
|
|
deactivate_super(mnt->mnt.mnt_sb);
|
|
|
|
mnt_free_id(mnt);
|
|
|
|
call_rcu(&mnt->mnt_rcu, delayed_free_vfsmnt);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __cleanup_mnt(struct rcu_head *head)
|
|
|
|
{
|
|
|
|
cleanup_mnt(container_of(head, struct mount, mnt_rcu));
|
|
|
|
}
|
|
|
|
|
|
|
|
static LLIST_HEAD(delayed_mntput_list);
|
|
|
|
static void delayed_mntput(struct work_struct *unused)
|
|
|
|
{
|
|
|
|
struct llist_node *node = llist_del_all(&delayed_mntput_list);
|
2017-08-07 11:44:45 +03:00
|
|
|
struct mount *m, *t;
|
2014-08-08 21:08:20 +04:00
|
|
|
|
2017-08-07 11:44:45 +03:00
|
|
|
llist_for_each_entry_safe(m, t, node, mnt_llist)
|
|
|
|
cleanup_mnt(m);
|
2014-08-08 21:08:20 +04:00
|
|
|
}
|
|
|
|
static DECLARE_DELAYED_WORK(delayed_mntput_work, delayed_mntput);
|
|
|
|
|
2011-11-25 09:33:11 +04:00
|
|
|
static void mntput_no_expire(struct mount *mnt)
|
fs: scale mntget/mntput
The problem that this patch aims to fix is vfsmount refcounting scalability.
We need to take a reference on the vfsmount for every successful path lookup,
which often go to the same mount point.
The fundamental difficulty is that a "simple" reference count can never be made
scalable, because any time a reference is dropped, we must check whether that
was the last reference. To do that requires communication with all other CPUs
that may have taken a reference count.
We can make refcounts more scalable in a couple of ways, involving keeping
distributed counters, and checking for the global-zero condition less
frequently.
- check the global sum once every interval (this will delay zero detection
for some interval, so it's probably a showstopper for vfsmounts).
- keep a local count and only taking the global sum when local reaches 0 (this
is difficult for vfsmounts, because we can't hold preempt off for the life of
a reference, so a counter would need to be per-thread or tied strongly to a
particular CPU which requires more locking).
- keep a local difference of increments and decrements, which allows us to sum
the total difference and hence find the refcount when summing all CPUs. Then,
keep a single integer "long" refcount for slow and long lasting references,
and only take the global sum of local counters when the long refcount is 0.
This last scheme is what I implemented here. Attached mounts and process root
and working directory references are "long" references, and everything else is
a short reference.
This allows scalable vfsmount references during path walking over mounted
subtrees and unattached (lazy umounted) mounts with processes still running
in them.
This results in one fewer atomic op in the fastpath: mntget is now just a
per-CPU inc, rather than an atomic inc; and mntput just requires a spinlock
and non-atomic decrement in the common case. However code is otherwise bigger
and heavier, so single threaded performance is basically a wash.
Signed-off-by: Nick Piggin <npiggin@kernel.dk>
2011-01-07 09:50:11 +03:00
|
|
|
{
|
2019-06-30 17:39:08 +03:00
|
|
|
LIST_HEAD(list);
|
2020-11-01 07:40:21 +03:00
|
|
|
int count;
|
2019-06-30 17:39:08 +03:00
|
|
|
|
2013-09-30 06:06:07 +04:00
|
|
|
rcu_read_lock();
|
fix mntput/mntput race
mntput_no_expire() does the calculation of total refcount under mount_lock;
unfortunately, the decrement (as well as all increments) are done outside
of it, leading to false positives in the "are we dropping the last reference"
test. Consider the following situation:
* mnt is a lazy-umounted mount, kept alive by two opened files. One
of those files gets closed. Total refcount of mnt is 2. On CPU 42
mntput(mnt) (called from __fput()) drops one reference, decrementing component
* After it has looked at component #0, the process on CPU 0 does
mntget(), incrementing component #0, gets preempted and gets to run again -
on CPU 69. There it does mntput(), which drops the reference (component #69)
and proceeds to spin on mount_lock.
* On CPU 42 our first mntput() finishes counting. It observes the
decrement of component #69, but not the increment of component #0. As the
result, the total it gets is not 1 as it should've been - it's 0. At which
point we decide that vfsmount needs to be killed and proceed to free it and
shut the filesystem down. However, there's still another opened file
on that filesystem, with reference to (now freed) vfsmount, etc. and we are
screwed.
It's not a wide race, but it can be reproduced with artificial slowdown of
the mnt_get_count() loop, and it should be easier to hit on SMP KVM setups.
Fix consists of moving the refcount decrement under mount_lock; the tricky
part is that we want (and can) keep the fast case (i.e. mount that still
has non-NULL ->mnt_ns) entirely out of mount_lock. All places that zero
mnt->mnt_ns are dropping some reference to mnt and they call synchronize_rcu()
before that mntput(). IOW, if mntput() observes (under rcu_read_lock())
a non-NULL ->mnt_ns, it is guaranteed that there is another reference yet to
be dropped.
Reported-by: Jann Horn <jannh@google.com>
Tested-by: Jann Horn <jannh@google.com>
Fixes: 48a066e72d97 ("RCU'd vsfmounts")
Cc: stable@vger.kernel.org
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2018-08-10 00:21:17 +03:00
|
|
|
if (likely(READ_ONCE(mnt->mnt_ns))) {
|
|
|
|
/*
|
|
|
|
* Since we don't do lock_mount_hash() here,
|
|
|
|
* ->mnt_ns can change under us. However, if it's
|
|
|
|
* non-NULL, then there's a reference that won't
|
|
|
|
* be dropped until after an RCU delay done after
|
|
|
|
* turning ->mnt_ns NULL. So if we observe it
|
|
|
|
* non-NULL under rcu_read_lock(), the reference
|
|
|
|
* we are dropping is not the final one.
|
|
|
|
*/
|
|
|
|
mnt_add_count(mnt, -1);
|
2013-09-30 06:06:07 +04:00
|
|
|
rcu_read_unlock();
|
2011-01-15 06:30:21 +03:00
|
|
|
return;
|
fs: scale mntget/mntput
The problem that this patch aims to fix is vfsmount refcounting scalability.
We need to take a reference on the vfsmount for every successful path lookup,
which often go to the same mount point.
The fundamental difficulty is that a "simple" reference count can never be made
scalable, because any time a reference is dropped, we must check whether that
was the last reference. To do that requires communication with all other CPUs
that may have taken a reference count.
We can make refcounts more scalable in a couple of ways, involving keeping
distributed counters, and checking for the global-zero condition less
frequently.
- check the global sum once every interval (this will delay zero detection
for some interval, so it's probably a showstopper for vfsmounts).
- keep a local count and only taking the global sum when local reaches 0 (this
is difficult for vfsmounts, because we can't hold preempt off for the life of
a reference, so a counter would need to be per-thread or tied strongly to a
particular CPU which requires more locking).
- keep a local difference of increments and decrements, which allows us to sum
the total difference and hence find the refcount when summing all CPUs. Then,
keep a single integer "long" refcount for slow and long lasting references,
and only take the global sum of local counters when the long refcount is 0.
This last scheme is what I implemented here. Attached mounts and process root
and working directory references are "long" references, and everything else is
a short reference.
This allows scalable vfsmount references during path walking over mounted
subtrees and unattached (lazy umounted) mounts with processes still running
in them.
This results in one fewer atomic op in the fastpath: mntget is now just a
per-CPU inc, rather than an atomic inc; and mntput just requires a spinlock
and non-atomic decrement in the common case. However code is otherwise bigger
and heavier, so single threaded performance is basically a wash.
Signed-off-by: Nick Piggin <npiggin@kernel.dk>
2011-01-07 09:50:11 +03:00
|
|
|
}
|
2013-09-29 19:24:49 +04:00
|
|
|
lock_mount_hash();
|
2018-08-10 00:51:32 +03:00
|
|
|
/*
|
|
|
|
* make sure that if __legitimize_mnt() has not seen us grab
|
|
|
|
* mount_lock, we'll see their refcount increment here.
|
|
|
|
*/
|
|
|
|
smp_mb();
|
fix mntput/mntput race
mntput_no_expire() does the calculation of total refcount under mount_lock;
unfortunately, the decrement (as well as all increments) are done outside
of it, leading to false positives in the "are we dropping the last reference"
test. Consider the following situation:
* mnt is a lazy-umounted mount, kept alive by two opened files. One
of those files gets closed. Total refcount of mnt is 2. On CPU 42
mntput(mnt) (called from __fput()) drops one reference, decrementing component
* After it has looked at component #0, the process on CPU 0 does
mntget(), incrementing component #0, gets preempted and gets to run again -
on CPU 69. There it does mntput(), which drops the reference (component #69)
and proceeds to spin on mount_lock.
* On CPU 42 our first mntput() finishes counting. It observes the
decrement of component #69, but not the increment of component #0. As the
result, the total it gets is not 1 as it should've been - it's 0. At which
point we decide that vfsmount needs to be killed and proceed to free it and
shut the filesystem down. However, there's still another opened file
on that filesystem, with reference to (now freed) vfsmount, etc. and we are
screwed.
It's not a wide race, but it can be reproduced with artificial slowdown of
the mnt_get_count() loop, and it should be easier to hit on SMP KVM setups.
Fix consists of moving the refcount decrement under mount_lock; the tricky
part is that we want (and can) keep the fast case (i.e. mount that still
has non-NULL ->mnt_ns) entirely out of mount_lock. All places that zero
mnt->mnt_ns are dropping some reference to mnt and they call synchronize_rcu()
before that mntput(). IOW, if mntput() observes (under rcu_read_lock())
a non-NULL ->mnt_ns, it is guaranteed that there is another reference yet to
be dropped.
Reported-by: Jann Horn <jannh@google.com>
Tested-by: Jann Horn <jannh@google.com>
Fixes: 48a066e72d97 ("RCU'd vsfmounts")
Cc: stable@vger.kernel.org
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2018-08-10 00:21:17 +03:00
|
|
|
mnt_add_count(mnt, -1);
|
2020-11-01 07:40:21 +03:00
|
|
|
count = mnt_get_count(mnt);
|
|
|
|
if (count != 0) {
|
|
|
|
WARN_ON(count < 0);
|
2013-09-30 06:06:07 +04:00
|
|
|
rcu_read_unlock();
|
2013-09-29 19:24:49 +04:00
|
|
|
unlock_mount_hash();
|
fs: brlock vfsmount_lock
fs: brlock vfsmount_lock
Use a brlock for the vfsmount lock. It must be taken for write whenever
modifying the mount hash or associated fields, and may be taken for read when
performing mount hash lookups.
A new lock is added for the mnt-id allocator, so it doesn't need to take
the heavy vfsmount write-lock.
The number of atomics should remain the same for fastpath rlock cases, though
code would be slightly slower due to per-cpu access. Scalability is not not be
much improved in common cases yet, due to other locks (ie. dcache_lock) getting
in the way. However path lookups crossing mountpoints should be one case where
scalability is improved (currently requiring the global lock).
The slowpath is slower due to use of brlock. On a 64 core, 64 socket, 32 node
Altix system (high latency to remote nodes), a simple umount microbenchmark
(mount --bind mnt mnt2 ; umount mnt2 loop 1000 times), before this patch it
took 6.8s, afterwards took 7.1s, about 5% slower.
Cc: Al Viro <viro@ZenIV.linux.org.uk>
Signed-off-by: Nick Piggin <npiggin@kernel.dk>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2010-08-17 22:37:39 +04:00
|
|
|
return;
|
|
|
|
}
|
2013-09-30 06:06:07 +04:00
|
|
|
if (unlikely(mnt->mnt.mnt_flags & MNT_DOOMED)) {
|
|
|
|
rcu_read_unlock();
|
|
|
|
unlock_mount_hash();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
mnt->mnt.mnt_flags |= MNT_DOOMED;
|
|
|
|
rcu_read_unlock();
|
2012-05-08 08:02:02 +04:00
|
|
|
|
2011-11-21 15:11:30 +04:00
|
|
|
list_del(&mnt->mnt_instance);
|
2014-12-24 06:37:03 +03:00
|
|
|
|
|
|
|
if (unlikely(!list_empty(&mnt->mnt_mounts))) {
|
|
|
|
struct mount *p, *tmp;
|
|
|
|
list_for_each_entry_safe(p, tmp, &mnt->mnt_mounts, mnt_child) {
|
2019-06-30 17:39:08 +03:00
|
|
|
__put_mountpoint(unhash_mnt(p), &list);
|
2019-07-04 23:57:51 +03:00
|
|
|
hlist_add_head(&p->mnt_umount, &mnt->mnt_stuck_children);
|
2014-12-24 06:37:03 +03:00
|
|
|
}
|
|
|
|
}
|
2013-09-29 19:24:49 +04:00
|
|
|
unlock_mount_hash();
|
2019-06-30 17:39:08 +03:00
|
|
|
shrink_dentry_list(&list);
|
2013-09-28 20:41:25 +04:00
|
|
|
|
2014-08-08 21:08:20 +04:00
|
|
|
if (likely(!(mnt->mnt.mnt_flags & MNT_INTERNAL))) {
|
|
|
|
struct task_struct *task = current;
|
|
|
|
if (likely(!(task->flags & PF_KTHREAD))) {
|
|
|
|
init_task_work(&mnt->mnt_rcu, __cleanup_mnt);
|
task_work: cleanup notification modes
A previous commit changed the notification mode from true/false to an
int, allowing notify-no, notify-yes, or signal-notify. This was
backwards compatible in the sense that any existing true/false user
would translate to either 0 (on notification sent) or 1, the latter
which mapped to TWA_RESUME. TWA_SIGNAL was assigned a value of 2.
Clean this up properly, and define a proper enum for the notification
mode. Now we have:
- TWA_NONE. This is 0, same as before the original change, meaning no
notification requested.
- TWA_RESUME. This is 1, same as before the original change, meaning
that we use TIF_NOTIFY_RESUME.
- TWA_SIGNAL. This uses TIF_SIGPENDING/JOBCTL_TASK_WORK for the
notification.
Clean up all the callers, switching their 0/1/false/true to using the
appropriate TWA_* mode for notifications.
Fixes: e91b48162332 ("task_work: teach task_work_add() to do signal_wake_up()")
Reviewed-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2020-10-16 18:02:26 +03:00
|
|
|
if (!task_work_add(task, &mnt->mnt_rcu, TWA_RESUME))
|
2014-08-08 21:08:20 +04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (llist_add(&mnt->mnt_llist, &delayed_mntput_list))
|
|
|
|
schedule_delayed_work(&delayed_mntput_work, 1);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
cleanup_mnt(mnt);
|
fs: scale mntget/mntput
The problem that this patch aims to fix is vfsmount refcounting scalability.
We need to take a reference on the vfsmount for every successful path lookup,
which often go to the same mount point.
The fundamental difficulty is that a "simple" reference count can never be made
scalable, because any time a reference is dropped, we must check whether that
was the last reference. To do that requires communication with all other CPUs
that may have taken a reference count.
We can make refcounts more scalable in a couple of ways, involving keeping
distributed counters, and checking for the global-zero condition less
frequently.
- check the global sum once every interval (this will delay zero detection
for some interval, so it's probably a showstopper for vfsmounts).
- keep a local count and only taking the global sum when local reaches 0 (this
is difficult for vfsmounts, because we can't hold preempt off for the life of
a reference, so a counter would need to be per-thread or tied strongly to a
particular CPU which requires more locking).
- keep a local difference of increments and decrements, which allows us to sum
the total difference and hence find the refcount when summing all CPUs. Then,
keep a single integer "long" refcount for slow and long lasting references,
and only take the global sum of local counters when the long refcount is 0.
This last scheme is what I implemented here. Attached mounts and process root
and working directory references are "long" references, and everything else is
a short reference.
This allows scalable vfsmount references during path walking over mounted
subtrees and unattached (lazy umounted) mounts with processes still running
in them.
This results in one fewer atomic op in the fastpath: mntget is now just a
per-CPU inc, rather than an atomic inc; and mntput just requires a spinlock
and non-atomic decrement in the common case. However code is otherwise bigger
and heavier, so single threaded performance is basically a wash.
Signed-off-by: Nick Piggin <npiggin@kernel.dk>
2011-01-07 09:50:11 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
void mntput(struct vfsmount *mnt)
|
|
|
|
{
|
|
|
|
if (mnt) {
|
2011-11-25 09:57:42 +04:00
|
|
|
struct mount *m = real_mount(mnt);
|
fs: scale mntget/mntput
The problem that this patch aims to fix is vfsmount refcounting scalability.
We need to take a reference on the vfsmount for every successful path lookup,
which often go to the same mount point.
The fundamental difficulty is that a "simple" reference count can never be made
scalable, because any time a reference is dropped, we must check whether that
was the last reference. To do that requires communication with all other CPUs
that may have taken a reference count.
We can make refcounts more scalable in a couple of ways, involving keeping
distributed counters, and checking for the global-zero condition less
frequently.
- check the global sum once every interval (this will delay zero detection
for some interval, so it's probably a showstopper for vfsmounts).
- keep a local count and only taking the global sum when local reaches 0 (this
is difficult for vfsmounts, because we can't hold preempt off for the life of
a reference, so a counter would need to be per-thread or tied strongly to a
particular CPU which requires more locking).
- keep a local difference of increments and decrements, which allows us to sum
the total difference and hence find the refcount when summing all CPUs. Then,
keep a single integer "long" refcount for slow and long lasting references,
and only take the global sum of local counters when the long refcount is 0.
This last scheme is what I implemented here. Attached mounts and process root
and working directory references are "long" references, and everything else is
a short reference.
This allows scalable vfsmount references during path walking over mounted
subtrees and unattached (lazy umounted) mounts with processes still running
in them.
This results in one fewer atomic op in the fastpath: mntget is now just a
per-CPU inc, rather than an atomic inc; and mntput just requires a spinlock
and non-atomic decrement in the common case. However code is otherwise bigger
and heavier, so single threaded performance is basically a wash.
Signed-off-by: Nick Piggin <npiggin@kernel.dk>
2011-01-07 09:50:11 +03:00
|
|
|
/* avoid cacheline pingpong, hope gcc doesn't get "smart" */
|
2011-11-25 09:57:42 +04:00
|
|
|
if (unlikely(m->mnt_expiry_mark))
|
|
|
|
m->mnt_expiry_mark = 0;
|
|
|
|
mntput_no_expire(m);
|
fs: scale mntget/mntput
The problem that this patch aims to fix is vfsmount refcounting scalability.
We need to take a reference on the vfsmount for every successful path lookup,
which often go to the same mount point.
The fundamental difficulty is that a "simple" reference count can never be made
scalable, because any time a reference is dropped, we must check whether that
was the last reference. To do that requires communication with all other CPUs
that may have taken a reference count.
We can make refcounts more scalable in a couple of ways, involving keeping
distributed counters, and checking for the global-zero condition less
frequently.
- check the global sum once every interval (this will delay zero detection
for some interval, so it's probably a showstopper for vfsmounts).
- keep a local count and only taking the global sum when local reaches 0 (this
is difficult for vfsmounts, because we can't hold preempt off for the life of
a reference, so a counter would need to be per-thread or tied strongly to a
particular CPU which requires more locking).
- keep a local difference of increments and decrements, which allows us to sum
the total difference and hence find the refcount when summing all CPUs. Then,
keep a single integer "long" refcount for slow and long lasting references,
and only take the global sum of local counters when the long refcount is 0.
This last scheme is what I implemented here. Attached mounts and process root
and working directory references are "long" references, and everything else is
a short reference.
This allows scalable vfsmount references during path walking over mounted
subtrees and unattached (lazy umounted) mounts with processes still running
in them.
This results in one fewer atomic op in the fastpath: mntget is now just a
per-CPU inc, rather than an atomic inc; and mntput just requires a spinlock
and non-atomic decrement in the common case. However code is otherwise bigger
and heavier, so single threaded performance is basically a wash.
Signed-off-by: Nick Piggin <npiggin@kernel.dk>
2011-01-07 09:50:11 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mntput);
|
|
|
|
|
|
|
|
struct vfsmount *mntget(struct vfsmount *mnt)
|
|
|
|
{
|
|
|
|
if (mnt)
|
2011-11-25 07:37:54 +04:00
|
|
|
mnt_add_count(real_mount(mnt), 1);
|
fs: scale mntget/mntput
The problem that this patch aims to fix is vfsmount refcounting scalability.
We need to take a reference on the vfsmount for every successful path lookup,
which often go to the same mount point.
The fundamental difficulty is that a "simple" reference count can never be made
scalable, because any time a reference is dropped, we must check whether that
was the last reference. To do that requires communication with all other CPUs
that may have taken a reference count.
We can make refcounts more scalable in a couple of ways, involving keeping
distributed counters, and checking for the global-zero condition less
frequently.
- check the global sum once every interval (this will delay zero detection
for some interval, so it's probably a showstopper for vfsmounts).
- keep a local count and only taking the global sum when local reaches 0 (this
is difficult for vfsmounts, because we can't hold preempt off for the life of
a reference, so a counter would need to be per-thread or tied strongly to a
particular CPU which requires more locking).
- keep a local difference of increments and decrements, which allows us to sum
the total difference and hence find the refcount when summing all CPUs. Then,
keep a single integer "long" refcount for slow and long lasting references,
and only take the global sum of local counters when the long refcount is 0.
This last scheme is what I implemented here. Attached mounts and process root
and working directory references are "long" references, and everything else is
a short reference.
This allows scalable vfsmount references during path walking over mounted
subtrees and unattached (lazy umounted) mounts with processes still running
in them.
This results in one fewer atomic op in the fastpath: mntget is now just a
per-CPU inc, rather than an atomic inc; and mntput just requires a spinlock
and non-atomic decrement in the common case. However code is otherwise bigger
and heavier, so single threaded performance is basically a wash.
Signed-off-by: Nick Piggin <npiggin@kernel.dk>
2011-01-07 09:50:11 +03:00
|
|
|
return mnt;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mntget);
|
|
|
|
|
2023-01-27 21:46:51 +03:00
|
|
|
/*
|
|
|
|
* Make a mount point inaccessible to new lookups.
|
|
|
|
* Because there may still be current users, the caller MUST WAIT
|
|
|
|
* for an RCU grace period before destroying the mount point.
|
|
|
|
*/
|
|
|
|
void mnt_make_shortterm(struct vfsmount *mnt)
|
|
|
|
{
|
|
|
|
if (mnt)
|
|
|
|
real_mount(mnt)->mnt_ns = NULL;
|
|
|
|
}
|
|
|
|
|
2021-03-18 05:52:25 +03:00
|
|
|
/**
|
|
|
|
* path_is_mountpoint() - Check if path is a mount in the current namespace.
|
|
|
|
* @path: path to check
|
2016-11-24 00:03:41 +03:00
|
|
|
*
|
|
|
|
* d_mountpoint() can only be used reliably to establish if a dentry is
|
|
|
|
* not mounted in any namespace and that common case is handled inline.
|
|
|
|
* d_mountpoint() isn't aware of the possibility there may be multiple
|
|
|
|
* mounts using a given dentry in a different namespace. This function
|
|
|
|
* checks if the passed in path is a mountpoint rather than the dentry
|
|
|
|
* alone.
|
|
|
|
*/
|
|
|
|
bool path_is_mountpoint(const struct path *path)
|
|
|
|
{
|
|
|
|
unsigned seq;
|
|
|
|
bool res;
|
|
|
|
|
|
|
|
if (!d_mountpoint(path->dentry))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
do {
|
|
|
|
seq = read_seqbegin(&mount_lock);
|
|
|
|
res = __path_is_mountpoint(path);
|
|
|
|
} while (read_seqretry(&mount_lock, seq));
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(path_is_mountpoint);
|
|
|
|
|
2016-11-21 03:45:28 +03:00
|
|
|
struct vfsmount *mnt_clone_internal(const struct path *path)
|
2005-11-08 01:13:39 +03:00
|
|
|
{
|
2014-08-07 17:12:31 +04:00
|
|
|
struct mount *p;
|
|
|
|
p = clone_mnt(real_mount(path->mnt), path->dentry, CL_PRIVATE);
|
|
|
|
if (IS_ERR(p))
|
|
|
|
return ERR_CAST(p);
|
|
|
|
p->mnt.mnt_flags |= MNT_INTERNAL;
|
|
|
|
return &p->mnt;
|
2005-11-08 01:13:39 +03:00
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2008-03-27 15:06:24 +03:00
|
|
|
#ifdef CONFIG_PROC_FS
|
2020-05-14 17:44:24 +03:00
|
|
|
static struct mount *mnt_list_next(struct mnt_namespace *ns,
|
|
|
|
struct list_head *p)
|
|
|
|
{
|
|
|
|
struct mount *mnt, *ret = NULL;
|
|
|
|
|
|
|
|
lock_ns_list(ns);
|
|
|
|
list_for_each_continue(p, &ns->list) {
|
|
|
|
mnt = list_entry(p, typeof(*mnt), mnt_list);
|
|
|
|
if (!mnt_is_cursor(mnt)) {
|
|
|
|
ret = mnt;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
unlock_ns_list(ns);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-12-06 21:21:54 +04:00
|
|
|
/* iterator; we want it to have access to namespace_sem, thus here... */
|
2005-04-17 02:20:36 +04:00
|
|
|
static void *m_start(struct seq_file *m, loff_t *pos)
|
|
|
|
{
|
fs: use seq_open_private() for proc_mounts
A patchset to remove support for passing pre-allocated struct seq_file to
seq_open(). Such feature is undocumented and prone to error.
In particular, if seq_release() is used in release handler, it will
kfree() a pointer which was not allocated by seq_open().
So this patchset drops support for pre-allocated struct seq_file: it's
only of use in proc_namespace.c and can be easily replaced by using
seq_open_private()/seq_release_private().
Additionally, it documents the use of file->private_data to hold pointer
to struct seq_file by seq_open().
This patch (of 3):
Since patch described below, from v2.6.15-rc1, seq_open() could use a
struct seq_file already allocated by the caller if the pointer to the
structure is stored in file->private_data before calling the function.
Commit 1abe77b0fc4b485927f1f798ae81a752677e1d05
Author: Al Viro <viro@zeniv.linux.org.uk>
Date: Mon Nov 7 17:15:34 2005 -0500
[PATCH] allow callers of seq_open do allocation themselves
Allow caller of seq_open() to kmalloc() seq_file + whatever else they
want and set ->private_data to it. seq_open() will then abstain from
doing allocation itself.
Such behavior is only used by mounts_open_common().
In order to drop support for such uncommon feature, proc_mounts is
converted to use seq_open_private(), which take care of allocating the
proc_mounts structure, making it available through ->private in struct
seq_file.
Conversely, proc_mounts is converted to use seq_release_private(), in
order to release the private structure allocated by seq_open_private().
Then, ->private is used directly instead of proc_mounts() macro to access
to the proc_mounts structure.
Link: http://lkml.kernel.org/r/cover.1433193673.git.ydroneaud@opteya.com
Signed-off-by: Yann Droneaud <ydroneaud@opteya.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-07-01 00:57:30 +03:00
|
|
|
struct proc_mounts *p = m->private;
|
2020-05-14 17:44:24 +03:00
|
|
|
struct list_head *prev;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2005-11-08 01:17:51 +03:00
|
|
|
down_read(&namespace_sem);
|
2020-05-14 17:44:24 +03:00
|
|
|
if (!*pos) {
|
|
|
|
prev = &p->ns->list;
|
|
|
|
} else {
|
|
|
|
prev = &p->cursor.mnt_list;
|
|
|
|
|
|
|
|
/* Read after we'd reached the end? */
|
|
|
|
if (list_empty(prev))
|
|
|
|
return NULL;
|
2014-02-27 23:40:10 +04:00
|
|
|
}
|
|
|
|
|
2020-05-14 17:44:24 +03:00
|
|
|
return mnt_list_next(p->ns, prev);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void *m_next(struct seq_file *m, void *v, loff_t *pos)
|
|
|
|
{
|
fs: use seq_open_private() for proc_mounts
A patchset to remove support for passing pre-allocated struct seq_file to
seq_open(). Such feature is undocumented and prone to error.
In particular, if seq_release() is used in release handler, it will
kfree() a pointer which was not allocated by seq_open().
So this patchset drops support for pre-allocated struct seq_file: it's
only of use in proc_namespace.c and can be easily replaced by using
seq_open_private()/seq_release_private().
Additionally, it documents the use of file->private_data to hold pointer
to struct seq_file by seq_open().
This patch (of 3):
Since patch described below, from v2.6.15-rc1, seq_open() could use a
struct seq_file already allocated by the caller if the pointer to the
structure is stored in file->private_data before calling the function.
Commit 1abe77b0fc4b485927f1f798ae81a752677e1d05
Author: Al Viro <viro@zeniv.linux.org.uk>
Date: Mon Nov 7 17:15:34 2005 -0500
[PATCH] allow callers of seq_open do allocation themselves
Allow caller of seq_open() to kmalloc() seq_file + whatever else they
want and set ->private_data to it. seq_open() will then abstain from
doing allocation itself.
Such behavior is only used by mounts_open_common().
In order to drop support for such uncommon feature, proc_mounts is
converted to use seq_open_private(), which take care of allocating the
proc_mounts structure, making it available through ->private in struct
seq_file.
Conversely, proc_mounts is converted to use seq_release_private(), in
order to release the private structure allocated by seq_open_private().
Then, ->private is used directly instead of proc_mounts() macro to access
to the proc_mounts structure.
Link: http://lkml.kernel.org/r/cover.1433193673.git.ydroneaud@opteya.com
Signed-off-by: Yann Droneaud <ydroneaud@opteya.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-07-01 00:57:30 +03:00
|
|
|
struct proc_mounts *p = m->private;
|
2020-05-14 17:44:24 +03:00
|
|
|
struct mount *mnt = v;
|
2007-07-16 10:39:55 +04:00
|
|
|
|
2020-05-14 17:44:24 +03:00
|
|
|
++*pos;
|
|
|
|
return mnt_list_next(p->ns, &mnt->mnt_list);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void m_stop(struct seq_file *m, void *v)
|
|
|
|
{
|
2020-05-14 17:44:24 +03:00
|
|
|
struct proc_mounts *p = m->private;
|
|
|
|
struct mount *mnt = v;
|
|
|
|
|
|
|
|
lock_ns_list(p->ns);
|
|
|
|
if (mnt)
|
|
|
|
list_move_tail(&p->cursor.mnt_list, &mnt->mnt_list);
|
|
|
|
else
|
|
|
|
list_del_init(&p->cursor.mnt_list);
|
|
|
|
unlock_ns_list(p->ns);
|
2005-11-08 01:17:51 +03:00
|
|
|
up_read(&namespace_sem);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2011-12-06 21:21:54 +04:00
|
|
|
static int m_show(struct seq_file *m, void *v)
|
2008-03-27 15:06:25 +03:00
|
|
|
{
|
fs: use seq_open_private() for proc_mounts
A patchset to remove support for passing pre-allocated struct seq_file to
seq_open(). Such feature is undocumented and prone to error.
In particular, if seq_release() is used in release handler, it will
kfree() a pointer which was not allocated by seq_open().
So this patchset drops support for pre-allocated struct seq_file: it's
only of use in proc_namespace.c and can be easily replaced by using
seq_open_private()/seq_release_private().
Additionally, it documents the use of file->private_data to hold pointer
to struct seq_file by seq_open().
This patch (of 3):
Since patch described below, from v2.6.15-rc1, seq_open() could use a
struct seq_file already allocated by the caller if the pointer to the
structure is stored in file->private_data before calling the function.
Commit 1abe77b0fc4b485927f1f798ae81a752677e1d05
Author: Al Viro <viro@zeniv.linux.org.uk>
Date: Mon Nov 7 17:15:34 2005 -0500
[PATCH] allow callers of seq_open do allocation themselves
Allow caller of seq_open() to kmalloc() seq_file + whatever else they
want and set ->private_data to it. seq_open() will then abstain from
doing allocation itself.
Such behavior is only used by mounts_open_common().
In order to drop support for such uncommon feature, proc_mounts is
converted to use seq_open_private(), which take care of allocating the
proc_mounts structure, making it available through ->private in struct
seq_file.
Conversely, proc_mounts is converted to use seq_release_private(), in
order to release the private structure allocated by seq_open_private().
Then, ->private is used directly instead of proc_mounts() macro to access
to the proc_mounts structure.
Link: http://lkml.kernel.org/r/cover.1433193673.git.ydroneaud@opteya.com
Signed-off-by: Yann Droneaud <ydroneaud@opteya.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-07-01 00:57:30 +03:00
|
|
|
struct proc_mounts *p = m->private;
|
2020-05-14 17:44:24 +03:00
|
|
|
struct mount *r = v;
|
2011-12-06 21:21:54 +04:00
|
|
|
return p->show(m, &r->mnt);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2008-03-27 15:06:24 +03:00
|
|
|
const struct seq_operations mounts_op = {
|
2005-04-17 02:20:36 +04:00
|
|
|
.start = m_start,
|
|
|
|
.next = m_next,
|
|
|
|
.stop = m_stop,
|
2011-12-06 21:21:54 +04:00
|
|
|
.show = m_show,
|
2006-03-20 21:44:12 +03:00
|
|
|
};
|
2020-05-14 17:44:24 +03:00
|
|
|
|
|
|
|
void mnt_cursor_del(struct mnt_namespace *ns, struct mount *cursor)
|
|
|
|
{
|
|
|
|
down_read(&namespace_sem);
|
|
|
|
lock_ns_list(ns);
|
|
|
|
list_del(&cursor->mnt_list);
|
|
|
|
unlock_ns_list(ns);
|
|
|
|
up_read(&namespace_sem);
|
|
|
|
}
|
2008-03-27 15:06:24 +03:00
|
|
|
#endif /* CONFIG_PROC_FS */
|
2006-03-20 21:44:12 +03:00
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/**
|
|
|
|
* may_umount_tree - check if a mount tree is busy
|
2021-03-18 05:52:25 +03:00
|
|
|
* @m: root of mount tree
|
2005-04-17 02:20:36 +04:00
|
|
|
*
|
|
|
|
* This is called to check if a tree of mounts has any
|
|
|
|
* open files, pwds, chroots or sub mounts that are
|
|
|
|
* busy.
|
|
|
|
*/
|
2011-11-25 12:06:56 +04:00
|
|
|
int may_umount_tree(struct vfsmount *m)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2011-11-25 12:06:56 +04:00
|
|
|
struct mount *mnt = real_mount(m);
|
2005-11-08 01:17:22 +03:00
|
|
|
int actual_refs = 0;
|
|
|
|
int minimum_refs = 0;
|
2011-11-25 03:57:30 +04:00
|
|
|
struct mount *p;
|
2011-11-25 12:06:56 +04:00
|
|
|
BUG_ON(!m);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
fs: scale mntget/mntput
The problem that this patch aims to fix is vfsmount refcounting scalability.
We need to take a reference on the vfsmount for every successful path lookup,
which often go to the same mount point.
The fundamental difficulty is that a "simple" reference count can never be made
scalable, because any time a reference is dropped, we must check whether that
was the last reference. To do that requires communication with all other CPUs
that may have taken a reference count.
We can make refcounts more scalable in a couple of ways, involving keeping
distributed counters, and checking for the global-zero condition less
frequently.
- check the global sum once every interval (this will delay zero detection
for some interval, so it's probably a showstopper for vfsmounts).
- keep a local count and only taking the global sum when local reaches 0 (this
is difficult for vfsmounts, because we can't hold preempt off for the life of
a reference, so a counter would need to be per-thread or tied strongly to a
particular CPU which requires more locking).
- keep a local difference of increments and decrements, which allows us to sum
the total difference and hence find the refcount when summing all CPUs. Then,
keep a single integer "long" refcount for slow and long lasting references,
and only take the global sum of local counters when the long refcount is 0.
This last scheme is what I implemented here. Attached mounts and process root
and working directory references are "long" references, and everything else is
a short reference.
This allows scalable vfsmount references during path walking over mounted
subtrees and unattached (lazy umounted) mounts with processes still running
in them.
This results in one fewer atomic op in the fastpath: mntget is now just a
per-CPU inc, rather than an atomic inc; and mntput just requires a spinlock
and non-atomic decrement in the common case. However code is otherwise bigger
and heavier, so single threaded performance is basically a wash.
Signed-off-by: Nick Piggin <npiggin@kernel.dk>
2011-01-07 09:50:11 +03:00
|
|
|
/* write lock needed for mnt_get_count */
|
2013-09-29 19:24:49 +04:00
|
|
|
lock_mount_hash();
|
2011-11-25 12:06:56 +04:00
|
|
|
for (p = mnt; p; p = next_mnt(p, mnt)) {
|
2011-11-25 07:37:54 +04:00
|
|
|
actual_refs += mnt_get_count(p);
|
2005-04-17 02:20:36 +04:00
|
|
|
minimum_refs += 2;
|
|
|
|
}
|
2013-09-29 19:24:49 +04:00
|
|
|
unlock_mount_hash();
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
if (actual_refs > minimum_refs)
|
2006-03-27 13:14:51 +04:00
|
|
|
return 0;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2006-03-27 13:14:51 +04:00
|
|
|
return 1;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(may_umount_tree);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* may_umount - check if a mount point is busy
|
|
|
|
* @mnt: root of mount
|
|
|
|
*
|
|
|
|
* This is called to check if a mount point has any
|
|
|
|
* open files, pwds, chroots or sub mounts. If the
|
|
|
|
* mount has sub mounts this will return busy
|
|
|
|
* regardless of whether the sub mounts are busy.
|
|
|
|
*
|
|
|
|
* Doesn't take quota and stuff into account. IOW, in some cases it will
|
|
|
|
* give false negatives. The main reason why it's here is that we need
|
|
|
|
* a non-destructive way to look for easily umountable filesystems.
|
|
|
|
*/
|
|
|
|
int may_umount(struct vfsmount *mnt)
|
|
|
|
{
|
2006-03-27 13:14:51 +04:00
|
|
|
int ret = 1;
|
2010-01-16 20:56:08 +03:00
|
|
|
down_read(&namespace_sem);
|
2013-09-29 19:24:49 +04:00
|
|
|
lock_mount_hash();
|
2011-11-25 06:35:16 +04:00
|
|
|
if (propagate_mount_busy(real_mount(mnt), 2))
|
2006-03-27 13:14:51 +04:00
|
|
|
ret = 0;
|
2013-09-29 19:24:49 +04:00
|
|
|
unlock_mount_hash();
|
2010-01-16 20:56:08 +03:00
|
|
|
up_read(&namespace_sem);
|
2005-11-08 01:20:17 +03:00
|
|
|
return ret;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(may_umount);
|
|
|
|
|
2013-03-16 23:12:40 +04:00
|
|
|
static void namespace_unlock(void)
|
2005-11-08 01:17:04 +03:00
|
|
|
{
|
2015-04-03 04:33:53 +03:00
|
|
|
struct hlist_head head;
|
2019-07-04 23:57:51 +03:00
|
|
|
struct hlist_node *p;
|
|
|
|
struct mount *m;
|
2019-06-30 17:39:08 +03:00
|
|
|
LIST_HEAD(list);
|
2013-03-16 23:12:40 +04:00
|
|
|
|
2015-04-03 04:33:53 +03:00
|
|
|
hlist_move_list(&unmounted, &head);
|
2019-06-30 17:39:08 +03:00
|
|
|
list_splice_init(&ex_mountpoints, &list);
|
2013-03-16 23:12:40 +04:00
|
|
|
|
|
|
|
up_write(&namespace_sem);
|
|
|
|
|
2019-06-30 17:39:08 +03:00
|
|
|
shrink_dentry_list(&list);
|
|
|
|
|
2015-04-03 04:33:53 +03:00
|
|
|
if (likely(hlist_empty(&head)))
|
|
|
|
return;
|
|
|
|
|
2018-11-30 02:33:18 +03:00
|
|
|
synchronize_rcu_expedited();
|
2013-09-30 06:06:07 +04:00
|
|
|
|
2019-07-04 23:57:51 +03:00
|
|
|
hlist_for_each_entry_safe(m, p, &head, mnt_umount) {
|
|
|
|
hlist_del(&m->mnt_umount);
|
|
|
|
mntput(&m->mnt);
|
|
|
|
}
|
2005-11-08 01:17:04 +03:00
|
|
|
}
|
|
|
|
|
2013-03-16 23:12:40 +04:00
|
|
|
static inline void namespace_lock(void)
|
2013-03-16 22:35:16 +04:00
|
|
|
{
|
2013-03-16 23:12:40 +04:00
|
|
|
down_write(&namespace_sem);
|
2013-03-16 22:35:16 +04:00
|
|
|
}
|
|
|
|
|
2014-12-24 16:20:01 +03:00
|
|
|
enum umount_tree_flags {
|
|
|
|
UMOUNT_SYNC = 1,
|
|
|
|
UMOUNT_PROPAGATE = 2,
|
2015-04-02 02:30:06 +03:00
|
|
|
UMOUNT_CONNECTED = 4,
|
2014-12-24 16:20:01 +03:00
|
|
|
};
|
2015-07-17 22:15:30 +03:00
|
|
|
|
|
|
|
static bool disconnect_mount(struct mount *mnt, enum umount_tree_flags how)
|
|
|
|
{
|
|
|
|
/* Leaving mounts connected is only valid for lazy umounts */
|
|
|
|
if (how & UMOUNT_SYNC)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
/* A mount without a parent has nothing to be connected to */
|
|
|
|
if (!mnt_has_parent(mnt))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
/* Because the reference counting rules change when mounts are
|
|
|
|
* unmounted and connected, umounted mounts may not be
|
|
|
|
* connected to mounted mounts.
|
|
|
|
*/
|
|
|
|
if (!(mnt->mnt_parent->mnt.mnt_flags & MNT_UMOUNT))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
/* Has it been requested that the mount remain connected? */
|
|
|
|
if (how & UMOUNT_CONNECTED)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/* Is the mount locked such that it needs to remain connected? */
|
|
|
|
if (IS_MNT_LOCKED(mnt))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/* By default disconnect the mount */
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
fs: brlock vfsmount_lock
fs: brlock vfsmount_lock
Use a brlock for the vfsmount lock. It must be taken for write whenever
modifying the mount hash or associated fields, and may be taken for read when
performing mount hash lookups.
A new lock is added for the mnt-id allocator, so it doesn't need to take
the heavy vfsmount write-lock.
The number of atomics should remain the same for fastpath rlock cases, though
code would be slightly slower due to per-cpu access. Scalability is not not be
much improved in common cases yet, due to other locks (ie. dcache_lock) getting
in the way. However path lookups crossing mountpoints should be one case where
scalability is improved (currently requiring the global lock).
The slowpath is slower due to use of brlock. On a 64 core, 64 socket, 32 node
Altix system (high latency to remote nodes), a simple umount microbenchmark
(mount --bind mnt mnt2 ; umount mnt2 loop 1000 times), before this patch it
took 6.8s, afterwards took 7.1s, about 5% slower.
Cc: Al Viro <viro@ZenIV.linux.org.uk>
Signed-off-by: Nick Piggin <npiggin@kernel.dk>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2010-08-17 22:37:39 +04:00
|
|
|
/*
|
2013-09-30 06:06:07 +04:00
|
|
|
* mount_lock must be held
|
fs: brlock vfsmount_lock
fs: brlock vfsmount_lock
Use a brlock for the vfsmount lock. It must be taken for write whenever
modifying the mount hash or associated fields, and may be taken for read when
performing mount hash lookups.
A new lock is added for the mnt-id allocator, so it doesn't need to take
the heavy vfsmount write-lock.
The number of atomics should remain the same for fastpath rlock cases, though
code would be slightly slower due to per-cpu access. Scalability is not not be
much improved in common cases yet, due to other locks (ie. dcache_lock) getting
in the way. However path lookups crossing mountpoints should be one case where
scalability is improved (currently requiring the global lock).
The slowpath is slower due to use of brlock. On a 64 core, 64 socket, 32 node
Altix system (high latency to remote nodes), a simple umount microbenchmark
(mount --bind mnt mnt2 ; umount mnt2 loop 1000 times), before this patch it
took 6.8s, afterwards took 7.1s, about 5% slower.
Cc: Al Viro <viro@ZenIV.linux.org.uk>
Signed-off-by: Nick Piggin <npiggin@kernel.dk>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2010-08-17 22:37:39 +04:00
|
|
|
* namespace_sem must be held for write
|
|
|
|
*/
|
2014-12-24 16:20:01 +03:00
|
|
|
static void umount_tree(struct mount *mnt, enum umount_tree_flags how)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2014-12-18 22:10:48 +03:00
|
|
|
LIST_HEAD(tmp_list);
|
2011-11-25 03:57:30 +04:00
|
|
|
struct mount *p;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2015-01-03 14:39:35 +03:00
|
|
|
if (how & UMOUNT_PROPAGATE)
|
|
|
|
propagate_mount_unlock(mnt);
|
|
|
|
|
2014-12-18 22:10:48 +03:00
|
|
|
/* Gather the mounts to umount */
|
2014-12-23 03:30:08 +03:00
|
|
|
for (p = mnt; p; p = next_mnt(p, mnt)) {
|
|
|
|
p->mnt.mnt_flags |= MNT_UMOUNT;
|
2014-12-18 22:10:48 +03:00
|
|
|
list_move(&p->mnt_list, &tmp_list);
|
2014-12-23 03:30:08 +03:00
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2014-12-23 04:12:07 +03:00
|
|
|
/* Hide the mounts from mnt_mounts */
|
2014-12-18 22:10:48 +03:00
|
|
|
list_for_each_entry(p, &tmp_list, mnt_list) {
|
2014-08-18 23:09:26 +04:00
|
|
|
list_del_init(&p->mnt_child);
|
2014-12-18 22:10:48 +03:00
|
|
|
}
|
2014-08-18 23:09:26 +04:00
|
|
|
|
2014-12-18 22:10:48 +03:00
|
|
|
/* Add propogated mounts to the tmp_list */
|
2014-12-24 16:20:01 +03:00
|
|
|
if (how & UMOUNT_PROPAGATE)
|
2011-01-16 04:08:44 +03:00
|
|
|
propagate_umount(&tmp_list);
|
2005-11-08 01:20:17 +03:00
|
|
|
|
2014-12-18 22:10:48 +03:00
|
|
|
while (!list_empty(&tmp_list)) {
|
2016-09-28 08:27:17 +03:00
|
|
|
struct mnt_namespace *ns;
|
2014-12-24 06:37:03 +03:00
|
|
|
bool disconnect;
|
2014-12-18 22:10:48 +03:00
|
|
|
p = list_first_entry(&tmp_list, struct mount, mnt_list);
|
2011-11-25 09:22:05 +04:00
|
|
|
list_del_init(&p->mnt_expire);
|
2011-11-25 11:19:55 +04:00
|
|
|
list_del_init(&p->mnt_list);
|
2016-09-28 08:27:17 +03:00
|
|
|
ns = p->mnt_ns;
|
|
|
|
if (ns) {
|
|
|
|
ns->mounts--;
|
|
|
|
__touch_mnt_namespace(ns);
|
|
|
|
}
|
2011-11-25 09:46:35 +04:00
|
|
|
p->mnt_ns = NULL;
|
2014-12-24 16:20:01 +03:00
|
|
|
if (how & UMOUNT_SYNC)
|
2013-09-30 06:06:07 +04:00
|
|
|
p->mnt.mnt_flags |= MNT_SYNC_UMOUNT;
|
2015-01-11 03:01:08 +03:00
|
|
|
|
2015-07-17 22:15:30 +03:00
|
|
|
disconnect = disconnect_mount(p, how);
|
2011-11-25 06:47:05 +04:00
|
|
|
if (mnt_has_parent(p)) {
|
2014-08-31 02:32:05 +04:00
|
|
|
mnt_add_count(p->mnt_parent, -1);
|
2014-12-24 06:37:03 +03:00
|
|
|
if (!disconnect) {
|
|
|
|
/* Don't forget about p */
|
|
|
|
list_add_tail(&p->mnt_child, &p->mnt_parent->mnt_mounts);
|
|
|
|
} else {
|
|
|
|
umount_mnt(p);
|
|
|
|
}
|
2008-03-22 06:59:49 +03:00
|
|
|
}
|
2011-11-25 05:43:10 +04:00
|
|
|
change_mnt_propagation(p, MS_PRIVATE);
|
2019-07-24 19:45:46 +03:00
|
|
|
if (disconnect)
|
|
|
|
hlist_add_head(&p->mnt_umount, &unmounted);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-03-16 22:39:34 +04:00
|
|
|
static void shrink_submounts(struct mount *mnt);
|
2008-03-22 07:46:23 +03:00
|
|
|
|
2018-11-04 17:28:36 +03:00
|
|
|
static int do_umount_root(struct super_block *sb)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
down_write(&sb->s_umount);
|
|
|
|
if (!sb_rdonly(sb)) {
|
|
|
|
struct fs_context *fc;
|
|
|
|
|
|
|
|
fc = fs_context_for_reconfigure(sb->s_root, SB_RDONLY,
|
|
|
|
SB_RDONLY);
|
|
|
|
if (IS_ERR(fc)) {
|
|
|
|
ret = PTR_ERR(fc);
|
|
|
|
} else {
|
|
|
|
ret = parse_monolithic_mount_data(fc, NULL);
|
|
|
|
if (!ret)
|
|
|
|
ret = reconfigure_super(fc);
|
|
|
|
put_fs_context(fc);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
up_write(&sb->s_umount);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-11-25 06:35:16 +04:00
|
|
|
static int do_umount(struct mount *mnt, int flags)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2011-11-25 06:35:16 +04:00
|
|
|
struct super_block *sb = mnt->mnt.mnt_sb;
|
2005-04-17 02:20:36 +04:00
|
|
|
int retval;
|
|
|
|
|
2011-11-25 06:35:16 +04:00
|
|
|
retval = security_sb_umount(&mnt->mnt, flags);
|
2005-04-17 02:20:36 +04:00
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Allow userspace to request a mountpoint be expired rather than
|
|
|
|
* unmounting unconditionally. Unmount only happens if:
|
|
|
|
* (1) the mark is already set (the mark is cleared by mntput())
|
|
|
|
* (2) the usage count == 1 [parent vfsmount] + 1 [sys_umount]
|
|
|
|
*/
|
|
|
|
if (flags & MNT_EXPIRE) {
|
2011-11-25 06:35:16 +04:00
|
|
|
if (&mnt->mnt == current->fs->root.mnt ||
|
2005-04-17 02:20:36 +04:00
|
|
|
flags & (MNT_FORCE | MNT_DETACH))
|
|
|
|
return -EINVAL;
|
|
|
|
|
fs: scale mntget/mntput
The problem that this patch aims to fix is vfsmount refcounting scalability.
We need to take a reference on the vfsmount for every successful path lookup,
which often go to the same mount point.
The fundamental difficulty is that a "simple" reference count can never be made
scalable, because any time a reference is dropped, we must check whether that
was the last reference. To do that requires communication with all other CPUs
that may have taken a reference count.
We can make refcounts more scalable in a couple of ways, involving keeping
distributed counters, and checking for the global-zero condition less
frequently.
- check the global sum once every interval (this will delay zero detection
for some interval, so it's probably a showstopper for vfsmounts).
- keep a local count and only taking the global sum when local reaches 0 (this
is difficult for vfsmounts, because we can't hold preempt off for the life of
a reference, so a counter would need to be per-thread or tied strongly to a
particular CPU which requires more locking).
- keep a local difference of increments and decrements, which allows us to sum
the total difference and hence find the refcount when summing all CPUs. Then,
keep a single integer "long" refcount for slow and long lasting references,
and only take the global sum of local counters when the long refcount is 0.
This last scheme is what I implemented here. Attached mounts and process root
and working directory references are "long" references, and everything else is
a short reference.
This allows scalable vfsmount references during path walking over mounted
subtrees and unattached (lazy umounted) mounts with processes still running
in them.
This results in one fewer atomic op in the fastpath: mntget is now just a
per-CPU inc, rather than an atomic inc; and mntput just requires a spinlock
and non-atomic decrement in the common case. However code is otherwise bigger
and heavier, so single threaded performance is basically a wash.
Signed-off-by: Nick Piggin <npiggin@kernel.dk>
2011-01-07 09:50:11 +03:00
|
|
|
/*
|
|
|
|
* probably don't strictly need the lock here if we examined
|
|
|
|
* all race cases, but it's a slowpath.
|
|
|
|
*/
|
2013-09-29 19:24:49 +04:00
|
|
|
lock_mount_hash();
|
2011-11-25 07:37:54 +04:00
|
|
|
if (mnt_get_count(mnt) != 2) {
|
2013-09-29 19:24:49 +04:00
|
|
|
unlock_mount_hash();
|
2005-04-17 02:20:36 +04:00
|
|
|
return -EBUSY;
|
fs: scale mntget/mntput
The problem that this patch aims to fix is vfsmount refcounting scalability.
We need to take a reference on the vfsmount for every successful path lookup,
which often go to the same mount point.
The fundamental difficulty is that a "simple" reference count can never be made
scalable, because any time a reference is dropped, we must check whether that
was the last reference. To do that requires communication with all other CPUs
that may have taken a reference count.
We can make refcounts more scalable in a couple of ways, involving keeping
distributed counters, and checking for the global-zero condition less
frequently.
- check the global sum once every interval (this will delay zero detection
for some interval, so it's probably a showstopper for vfsmounts).
- keep a local count and only taking the global sum when local reaches 0 (this
is difficult for vfsmounts, because we can't hold preempt off for the life of
a reference, so a counter would need to be per-thread or tied strongly to a
particular CPU which requires more locking).
- keep a local difference of increments and decrements, which allows us to sum
the total difference and hence find the refcount when summing all CPUs. Then,
keep a single integer "long" refcount for slow and long lasting references,
and only take the global sum of local counters when the long refcount is 0.
This last scheme is what I implemented here. Attached mounts and process root
and working directory references are "long" references, and everything else is
a short reference.
This allows scalable vfsmount references during path walking over mounted
subtrees and unattached (lazy umounted) mounts with processes still running
in them.
This results in one fewer atomic op in the fastpath: mntget is now just a
per-CPU inc, rather than an atomic inc; and mntput just requires a spinlock
and non-atomic decrement in the common case. However code is otherwise bigger
and heavier, so single threaded performance is basically a wash.
Signed-off-by: Nick Piggin <npiggin@kernel.dk>
2011-01-07 09:50:11 +03:00
|
|
|
}
|
2013-09-29 19:24:49 +04:00
|
|
|
unlock_mount_hash();
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2011-11-25 09:57:42 +04:00
|
|
|
if (!xchg(&mnt->mnt_expiry_mark, 1))
|
2005-04-17 02:20:36 +04:00
|
|
|
return -EAGAIN;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we may have to abort operations to get out of this
|
|
|
|
* mount, and they will themselves hold resources we must
|
|
|
|
* allow the fs to do things. In the Unix tradition of
|
|
|
|
* 'Gee thats tricky lets do it in userspace' the umount_begin
|
|
|
|
* might fail to complete on the first run through as other tasks
|
|
|
|
* must return, and the like. Thats for the mount program to worry
|
|
|
|
* about for the moment.
|
|
|
|
*/
|
|
|
|
|
2008-04-24 15:21:56 +04:00
|
|
|
if (flags & MNT_FORCE && sb->s_op->umount_begin) {
|
|
|
|
sb->s_op->umount_begin(sb);
|
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* No sense to grab the lock for this test, but test itself looks
|
|
|
|
* somewhat bogus. Suggestions for better replacement?
|
|
|
|
* Ho-hum... In principle, we might treat that as umount + switch
|
|
|
|
* to rootfs. GC would eventually take care of the old vfsmount.
|
|
|
|
* Actually it makes sense, especially if rootfs would contain a
|
|
|
|
* /reboot - static binary that would close all descriptors and
|
|
|
|
* call reboot(9). Then init(8) could umount root and exec /reboot.
|
|
|
|
*/
|
2011-11-25 06:35:16 +04:00
|
|
|
if (&mnt->mnt == current->fs->root.mnt && !(flags & MNT_DETACH)) {
|
2005-04-17 02:20:36 +04:00
|
|
|
/*
|
|
|
|
* Special case for "unmounting" root ...
|
|
|
|
* we just try to remount it readonly.
|
|
|
|
*/
|
2017-09-19 01:58:08 +03:00
|
|
|
if (!ns_capable(sb->s_user_ns, CAP_SYS_ADMIN))
|
2014-10-08 23:32:47 +04:00
|
|
|
return -EPERM;
|
2018-11-04 17:28:36 +03:00
|
|
|
return do_umount_root(sb);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2013-03-16 23:12:40 +04:00
|
|
|
namespace_lock();
|
2013-09-29 19:24:49 +04:00
|
|
|
lock_mount_hash();
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2018-10-22 18:21:38 +03:00
|
|
|
/* Recheck MNT_LOCKED with the locks held */
|
|
|
|
retval = -EINVAL;
|
|
|
|
if (mnt->mnt.mnt_flags & MNT_LOCKED)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
event++;
|
2013-09-30 06:06:07 +04:00
|
|
|
if (flags & MNT_DETACH) {
|
2011-11-25 11:19:55 +04:00
|
|
|
if (!list_empty(&mnt->mnt_list))
|
2014-12-24 16:20:01 +03:00
|
|
|
umount_tree(mnt, UMOUNT_PROPAGATE);
|
2005-04-17 02:20:36 +04:00
|
|
|
retval = 0;
|
2013-09-30 06:06:07 +04:00
|
|
|
} else {
|
|
|
|
shrink_submounts(mnt);
|
|
|
|
retval = -EBUSY;
|
|
|
|
if (!propagate_mount_busy(mnt, 2)) {
|
|
|
|
if (!list_empty(&mnt->mnt_list))
|
2014-12-24 16:20:01 +03:00
|
|
|
umount_tree(mnt, UMOUNT_PROPAGATE|UMOUNT_SYNC);
|
2013-09-30 06:06:07 +04:00
|
|
|
retval = 0;
|
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
2018-10-22 18:21:38 +03:00
|
|
|
out:
|
2013-09-29 19:24:49 +04:00
|
|
|
unlock_mount_hash();
|
2013-03-16 22:35:16 +04:00
|
|
|
namespace_unlock();
|
2005-04-17 02:20:36 +04:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2013-10-03 12:31:18 +04:00
|
|
|
/*
|
|
|
|
* __detach_mounts - lazily unmount all mounts on the specified dentry
|
|
|
|
*
|
|
|
|
* During unlink, rmdir, and d_drop it is possible to loose the path
|
|
|
|
* to an existing mountpoint, and wind up leaking the mount.
|
|
|
|
* detach_mounts allows lazily unmounting those mounts instead of
|
|
|
|
* leaking them.
|
|
|
|
*
|
|
|
|
* The caller may hold dentry->d_inode->i_mutex.
|
|
|
|
*/
|
|
|
|
void __detach_mounts(struct dentry *dentry)
|
|
|
|
{
|
|
|
|
struct mountpoint *mp;
|
|
|
|
struct mount *mnt;
|
|
|
|
|
|
|
|
namespace_lock();
|
2017-01-03 04:18:43 +03:00
|
|
|
lock_mount_hash();
|
2013-10-03 12:31:18 +04:00
|
|
|
mp = lookup_mountpoint(dentry);
|
2019-06-29 19:06:51 +03:00
|
|
|
if (!mp)
|
2013-10-03 12:31:18 +04:00
|
|
|
goto out_unlock;
|
|
|
|
|
2016-04-16 00:24:41 +03:00
|
|
|
event++;
|
2013-10-03 12:31:18 +04:00
|
|
|
while (!hlist_empty(&mp->m_list)) {
|
|
|
|
mnt = hlist_entry(mp->m_list.first, struct mount, mnt_mp_list);
|
2014-12-24 06:37:03 +03:00
|
|
|
if (mnt->mnt.mnt_flags & MNT_UMOUNT) {
|
2015-07-17 22:54:27 +03:00
|
|
|
umount_mnt(mnt);
|
2019-07-04 23:57:51 +03:00
|
|
|
hlist_add_head(&mnt->mnt_umount, &unmounted);
|
2014-12-24 06:37:03 +03:00
|
|
|
}
|
2015-04-02 02:30:06 +03:00
|
|
|
else umount_tree(mnt, UMOUNT_CONNECTED);
|
2013-10-03 12:31:18 +04:00
|
|
|
}
|
|
|
|
put_mountpoint(mp);
|
|
|
|
out_unlock:
|
2017-01-03 04:18:43 +03:00
|
|
|
unlock_mount_hash();
|
2013-10-03 12:31:18 +04:00
|
|
|
namespace_unlock();
|
|
|
|
}
|
|
|
|
|
2017-07-04 19:25:09 +03:00
|
|
|
/*
|
2013-02-23 07:45:42 +04:00
|
|
|
* Is the caller allowed to modify his namespace?
|
|
|
|
*/
|
2022-03-01 08:05:29 +03:00
|
|
|
bool may_mount(void)
|
2013-02-23 07:45:42 +04:00
|
|
|
{
|
|
|
|
return ns_capable(current->nsproxy->mnt_ns->user_ns, CAP_SYS_ADMIN);
|
|
|
|
}
|
|
|
|
|
2021-08-19 21:56:38 +03:00
|
|
|
static void warn_mandlock(void)
|
2015-11-16 17:49:34 +03:00
|
|
|
{
|
2021-08-19 21:56:38 +03:00
|
|
|
pr_warn_once("=======================================================\n"
|
|
|
|
"WARNING: The mand mount option has been deprecated and\n"
|
|
|
|
" and is ignored by this kernel. Remove the mand\n"
|
|
|
|
" option from the mount to silence this warning.\n"
|
|
|
|
"=======================================================\n");
|
2015-11-16 17:49:34 +03:00
|
|
|
}
|
|
|
|
|
2020-08-06 17:07:10 +03:00
|
|
|
static int can_umount(const struct path *path, int flags)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2020-08-06 17:07:10 +03:00
|
|
|
struct mount *mnt = real_mount(path->mnt);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2013-02-23 07:45:42 +04:00
|
|
|
if (!may_mount())
|
|
|
|
return -EPERM;
|
2020-07-21 11:54:34 +03:00
|
|
|
if (path->dentry != path->mnt->mnt_root)
|
2020-08-06 17:07:10 +03:00
|
|
|
return -EINVAL;
|
2011-11-25 09:46:35 +04:00
|
|
|
if (!check_mnt(mnt))
|
2020-08-06 17:07:10 +03:00
|
|
|
return -EINVAL;
|
2018-10-22 18:21:38 +03:00
|
|
|
if (mnt->mnt.mnt_flags & MNT_LOCKED) /* Check optimistically */
|
2020-08-06 17:07:10 +03:00
|
|
|
return -EINVAL;
|
2014-10-05 01:44:03 +04:00
|
|
|
if (flags & MNT_FORCE && !capable(CAP_SYS_ADMIN))
|
2020-08-06 17:07:10 +03:00
|
|
|
return -EPERM;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2021-01-04 23:25:34 +03:00
|
|
|
// caller is responsible for flags being sane
|
2020-08-06 17:07:10 +03:00
|
|
|
int path_umount(struct path *path, int flags)
|
|
|
|
{
|
|
|
|
struct mount *mnt = real_mount(path->mnt);
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = can_umount(path, flags);
|
|
|
|
if (!ret)
|
|
|
|
ret = do_umount(mnt, flags);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2008-02-15 06:34:31 +03:00
|
|
|
/* we mustn't call path_put() as that would clear mnt_expiry_mark */
|
2020-07-21 11:54:34 +03:00
|
|
|
dput(path->dentry);
|
2011-11-25 09:33:11 +04:00
|
|
|
mntput_no_expire(mnt);
|
2020-08-06 17:07:10 +03:00
|
|
|
return ret;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2020-07-23 09:23:08 +03:00
|
|
|
static int ksys_umount(char __user *name, int flags)
|
2020-07-21 11:54:34 +03:00
|
|
|
{
|
|
|
|
int lookup_flags = LOOKUP_MOUNTPOINT;
|
|
|
|
struct path path;
|
|
|
|
int ret;
|
|
|
|
|
2021-01-04 23:25:34 +03:00
|
|
|
// basic validity checks done first
|
|
|
|
if (flags & ~(MNT_FORCE | MNT_DETACH | MNT_EXPIRE | UMOUNT_NOFOLLOW))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2020-07-21 11:54:34 +03:00
|
|
|
if (!(flags & UMOUNT_NOFOLLOW))
|
|
|
|
lookup_flags |= LOOKUP_FOLLOW;
|
|
|
|
ret = user_path_at(AT_FDCWD, name, lookup_flags, &path);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
return path_umount(&path, flags);
|
|
|
|
}
|
|
|
|
|
2018-03-11 13:34:40 +03:00
|
|
|
SYSCALL_DEFINE2(umount, char __user *, name, int, flags)
|
|
|
|
{
|
|
|
|
return ksys_umount(name, flags);
|
|
|
|
}
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
#ifdef __ARCH_WANT_SYS_OLDUMOUNT
|
|
|
|
|
|
|
|
/*
|
2005-11-08 01:16:09 +03:00
|
|
|
* The 2.0 compatible umount. No flags.
|
2005-04-17 02:20:36 +04:00
|
|
|
*/
|
2009-01-14 16:14:12 +03:00
|
|
|
SYSCALL_DEFINE1(oldumount, char __user *, name)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2018-03-11 13:34:40 +03:00
|
|
|
return ksys_umount(name, 0);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2013-03-30 12:35:18 +04:00
|
|
|
static bool is_mnt_ns_file(struct dentry *dentry)
|
2010-03-08 05:49:36 +03:00
|
|
|
{
|
2013-03-30 12:35:18 +04:00
|
|
|
/* Is this a proxy for a mount namespace? */
|
take the targets of /proc/*/ns/* symlinks to separate fs
New pseudo-filesystem: nsfs. Targets of /proc/*/ns/* live there now.
It's not mountable (not even registered, so it's not in /proc/filesystems,
etc.). Files on it *are* bindable - we explicitly permit that in do_loopback().
This stuff lives in fs/nsfs.c now; proc_ns_fget() moved there as well.
get_proc_ns() is a macro now (it's simply returning ->i_private; would
have been an inline, if not for header ordering headache).
proc_ns_inode() is an ex-parrot. The interface used in procfs is
ns_get_path(path, task, ops) and ns_get_name(buf, size, task, ops).
Dentries and inodes are never hashed; a non-counting reference to dentry
is stashed in ns_common (removed by ->d_prune()) and reused by ns_get_path()
if present. See ns_get_path()/ns_prune_dentry/nsfs_evict() for details
of that mechanism.
As the result, proc_ns_follow_link() has stopped poking in nd->path.mnt;
it does nd_jump_link() on a consistent <vfsmount,dentry> pair it gets
from ns_get_path().
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2014-11-01 17:57:28 +03:00
|
|
|
return dentry->d_op == &ns_dentry_operations &&
|
|
|
|
dentry->d_fsdata == &mntns_operations;
|
2013-03-30 12:35:18 +04:00
|
|
|
}
|
|
|
|
|
2020-01-04 23:59:55 +03:00
|
|
|
static struct mnt_namespace *to_mnt_ns(struct ns_common *ns)
|
2014-11-01 07:00:23 +03:00
|
|
|
{
|
|
|
|
return container_of(ns, struct mnt_namespace, ns);
|
|
|
|
}
|
|
|
|
|
nsproxy: attach to namespaces via pidfds
For quite a while we have been thinking about using pidfds to attach to
namespaces. This patchset has existed for about a year already but we've
wanted to wait to see how the general api would be received and adopted.
Now that more and more programs in userspace have started using pidfds
for process management it's time to send this one out.
This patch makes it possible to use pidfds to attach to the namespaces
of another process, i.e. they can be passed as the first argument to the
setns() syscall. When only a single namespace type is specified the
semantics are equivalent to passing an nsfd. That means
setns(nsfd, CLONE_NEWNET) equals setns(pidfd, CLONE_NEWNET). However,
when a pidfd is passed, multiple namespace flags can be specified in the
second setns() argument and setns() will attach the caller to all the
specified namespaces all at once or to none of them. Specifying 0 is not
valid together with a pidfd.
Here are just two obvious examples:
setns(pidfd, CLONE_NEWPID | CLONE_NEWNS | CLONE_NEWNET);
setns(pidfd, CLONE_NEWUSER);
Allowing to also attach subsets of namespaces supports various use-cases
where callers setns to a subset of namespaces to retain privilege, perform
an action and then re-attach another subset of namespaces.
If the need arises, as Eric suggested, we can extend this patchset to
assume even more context than just attaching all namespaces. His suggestion
specifically was about assuming the process' root directory when
setns(pidfd, 0) or setns(pidfd, SETNS_PIDFD) is specified. For now, just
keep it flexible in terms of supporting subsets of namespaces but let's
wait until we have users asking for even more context to be assumed. At
that point we can add an extension.
The obvious example where this is useful is a standard container
manager interacting with a running container: pushing and pulling files
or directories, injecting mounts, attaching/execing any kind of process,
managing network devices all these operations require attaching to all
or at least multiple namespaces at the same time. Given that nowadays
most containers are spawned with all namespaces enabled we're currently
looking at at least 14 syscalls, 7 to open the /proc/<pid>/ns/<ns>
nsfds, another 7 to actually perform the namespace switch. With time
namespaces we're looking at about 16 syscalls.
(We could amortize the first 7 or 8 syscalls for opening the nsfds by
stashing them in each container's monitor process but that would mean
we need to send around those file descriptors through unix sockets
everytime we want to interact with the container or keep on-disk
state. Even in scenarios where a caller wants to join a particular
namespace in a particular order callers still profit from batching
other namespaces. That mostly applies to the user namespace but
all container runtimes I found join the user namespace first no matter
if it privileges or deprivileges the container similar to how unshare
behaves.)
With pidfds this becomes a single syscall no matter how many namespaces
are supposed to be attached to.
A decently designed, large-scale container manager usually isn't the
parent of any of the containers it spawns so the containers don't die
when it crashes or needs to update or reinitialize. This means that
for the manager to interact with containers through pids is inherently
racy especially on systems where the maximum pid number is not
significicantly bumped. This is even more problematic since we often spawn
and manage thousands or ten-thousands of containers. Interacting with a
container through a pid thus can become risky quite quickly. Especially
since we allow for an administrator to enable advanced features such as
syscall interception where we're performing syscalls in lieu of the
container. In all of those cases we use pidfds if they are available and
we pass them around as stable references. Using them to setns() to the
target process' namespaces is as reliable as using nsfds. Either the
target process is already dead and we get ESRCH or we manage to attach
to its namespaces but we can't accidently attach to another process'
namespaces. So pidfds lend themselves to be used with this api.
The other main advantage is that with this change the pidfd becomes the
only relevant token for most container interactions and it's the only
token we need to create and send around.
Apart from significiantly reducing the number of syscalls from double
digit to single digit which is a decent reason post-spectre/meltdown
this also allows to switch to a set of namespaces atomically, i.e.
either attaching to all the specified namespaces succeeds or we fail. If
we fail we haven't changed a single namespace. There are currently three
namespaces that can fail (other than for ENOMEM which really is not
very interesting since we then have other problems anyway) for
non-trivial reasons, user, mount, and pid namespaces. We can fail to
attach to a pid namespace if it is not our current active pid namespace
or a descendant of it. We can fail to attach to a user namespace because
we are multi-threaded or because our current mount namespace shares
filesystem state with other tasks, or because we're trying to setns()
to the same user namespace, i.e. the target task has the same user
namespace as we do. We can fail to attach to a mount namespace because
it shares filesystem state with other tasks or because we fail to lookup
the new root for the new mount namespace. In most non-pathological
scenarios these issues can be somewhat mitigated. But there are cases where
we're half-attached to some namespace and failing to attach to another one.
I've talked about some of these problem during the hallway track (something
only the pre-COVID-19 generation will remember) of Plumbers in Los Angeles
in 2018(?). Even if all these issues could be avoided with super careful
userspace coding it would be nicer to have this done in-kernel. Pidfds seem
to lend themselves nicely for this.
The other neat thing about this is that setns() becomes an actual
counterpart to the namespace bits of unshare().
Signed-off-by: Christian Brauner <christian.brauner@ubuntu.com>
Reviewed-by: Serge Hallyn <serge@hallyn.com>
Cc: Eric W. Biederman <ebiederm@xmission.com>
Cc: Serge Hallyn <serge@hallyn.com>
Cc: Jann Horn <jannh@google.com>
Cc: Michael Kerrisk <mtk.manpages@gmail.com>
Cc: Aleksa Sarai <cyphar@cyphar.com>
Link: https://lore.kernel.org/r/20200505140432.181565-3-christian.brauner@ubuntu.com
2020-05-05 17:04:31 +03:00
|
|
|
struct ns_common *from_mnt_ns(struct mnt_namespace *mnt)
|
|
|
|
{
|
|
|
|
return &mnt->ns;
|
|
|
|
}
|
|
|
|
|
2013-03-30 12:35:18 +04:00
|
|
|
static bool mnt_ns_loop(struct dentry *dentry)
|
|
|
|
{
|
|
|
|
/* Could bind mounting the mount namespace inode cause a
|
|
|
|
* mount namespace loop?
|
|
|
|
*/
|
|
|
|
struct mnt_namespace *mnt_ns;
|
|
|
|
if (!is_mnt_ns_file(dentry))
|
|
|
|
return false;
|
|
|
|
|
2014-11-01 10:13:17 +03:00
|
|
|
mnt_ns = to_mnt_ns(get_proc_ns(dentry->d_inode));
|
2010-03-08 05:49:36 +03:00
|
|
|
return current->nsproxy->mnt_ns->seq >= mnt_ns->seq;
|
|
|
|
}
|
|
|
|
|
2011-11-25 06:24:27 +04:00
|
|
|
struct mount *copy_tree(struct mount *mnt, struct dentry *dentry,
|
2005-11-08 01:17:22 +03:00
|
|
|
int flag)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2013-03-15 18:53:28 +04:00
|
|
|
struct mount *res, *p, *q, *r, *parent;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2013-03-30 12:35:18 +04:00
|
|
|
if (!(flag & CL_COPY_UNBINDABLE) && IS_MNT_UNBINDABLE(mnt))
|
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
|
|
|
|
if (!(flag & CL_COPY_MNT_NS_FILE) && is_mnt_ns_file(dentry))
|
2012-06-25 15:55:18 +04:00
|
|
|
return ERR_PTR(-EINVAL);
|
2005-11-08 01:21:20 +03:00
|
|
|
|
2005-11-08 01:17:22 +03:00
|
|
|
res = q = clone_mnt(mnt, dentry, flag);
|
2012-06-25 15:55:18 +04:00
|
|
|
if (IS_ERR(q))
|
|
|
|
return q;
|
|
|
|
|
2011-11-25 07:25:07 +04:00
|
|
|
q->mnt_mountpoint = mnt->mnt_mountpoint;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
p = mnt;
|
2011-11-25 08:24:33 +04:00
|
|
|
list_for_each_entry(r, &mnt->mnt_mounts, mnt_child) {
|
2011-11-25 03:57:30 +04:00
|
|
|
struct mount *s;
|
2008-04-29 11:59:40 +04:00
|
|
|
if (!is_subdir(r->mnt_mountpoint, dentry))
|
2005-04-17 02:20:36 +04:00
|
|
|
continue;
|
|
|
|
|
2011-11-25 12:06:56 +04:00
|
|
|
for (s = r; s; s = next_mnt(s, r)) {
|
2013-03-30 12:35:18 +04:00
|
|
|
if (!(flag & CL_COPY_UNBINDABLE) &&
|
|
|
|
IS_MNT_UNBINDABLE(s)) {
|
2018-10-25 17:04:18 +03:00
|
|
|
if (s->mnt.mnt_flags & MNT_LOCKED) {
|
|
|
|
/* Both unbindable and locked. */
|
|
|
|
q = ERR_PTR(-EPERM);
|
|
|
|
goto out;
|
|
|
|
} else {
|
|
|
|
s = skip_mnt_tree(s);
|
|
|
|
continue;
|
|
|
|
}
|
2013-03-30 12:35:18 +04:00
|
|
|
}
|
|
|
|
if (!(flag & CL_COPY_MNT_NS_FILE) &&
|
|
|
|
is_mnt_ns_file(s->mnt.mnt_root)) {
|
2005-11-08 01:21:20 +03:00
|
|
|
s = skip_mnt_tree(s);
|
|
|
|
continue;
|
|
|
|
}
|
2011-11-25 07:19:58 +04:00
|
|
|
while (p != s->mnt_parent) {
|
|
|
|
p = p->mnt_parent;
|
|
|
|
q = q->mnt_parent;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
2011-11-25 06:24:27 +04:00
|
|
|
p = s;
|
2013-03-15 18:53:28 +04:00
|
|
|
parent = q;
|
2011-11-25 06:24:27 +04:00
|
|
|
q = clone_mnt(p, p->mnt.mnt_root, flag);
|
2012-06-25 15:55:18 +04:00
|
|
|
if (IS_ERR(q))
|
|
|
|
goto out;
|
2013-09-29 19:24:49 +04:00
|
|
|
lock_mount_hash();
|
2011-11-25 11:19:55 +04:00
|
|
|
list_add_tail(&q->mnt_list, &res->mnt_list);
|
2017-01-20 08:28:35 +03:00
|
|
|
attach_mnt(q, parent, p->mnt_mp);
|
2013-09-29 19:24:49 +04:00
|
|
|
unlock_mount_hash();
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return res;
|
2012-06-25 15:55:18 +04:00
|
|
|
out:
|
2005-04-17 02:20:36 +04:00
|
|
|
if (res) {
|
2013-09-29 19:24:49 +04:00
|
|
|
lock_mount_hash();
|
2014-12-24 16:20:01 +03:00
|
|
|
umount_tree(res, UMOUNT_SYNC);
|
2013-09-29 19:24:49 +04:00
|
|
|
unlock_mount_hash();
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
2012-06-25 15:55:18 +04:00
|
|
|
return q;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2012-06-25 15:55:18 +04:00
|
|
|
/* Caller should check returned pointer for errors */
|
|
|
|
|
2016-11-21 03:45:28 +03:00
|
|
|
struct vfsmount *collect_mounts(const struct path *path)
|
2007-06-07 20:20:32 +04:00
|
|
|
{
|
2011-11-25 05:55:08 +04:00
|
|
|
struct mount *tree;
|
2013-03-16 23:12:40 +04:00
|
|
|
namespace_lock();
|
2015-01-07 23:28:26 +03:00
|
|
|
if (!check_mnt(real_mount(path->mnt)))
|
|
|
|
tree = ERR_PTR(-EINVAL);
|
|
|
|
else
|
|
|
|
tree = copy_tree(real_mount(path->mnt), path->dentry,
|
|
|
|
CL_COPY_ALL | CL_PRIVATE);
|
2013-03-16 22:49:45 +04:00
|
|
|
namespace_unlock();
|
2012-06-25 15:55:18 +04:00
|
|
|
if (IS_ERR(tree))
|
2013-08-14 13:44:39 +04:00
|
|
|
return ERR_CAST(tree);
|
2012-06-25 15:55:18 +04:00
|
|
|
return &tree->mnt;
|
2007-06-07 20:20:32 +04:00
|
|
|
}
|
|
|
|
|
2018-11-05 20:40:30 +03:00
|
|
|
static void free_mnt_ns(struct mnt_namespace *);
|
|
|
|
static struct mnt_namespace *alloc_mnt_ns(struct user_namespace *, bool);
|
|
|
|
|
|
|
|
void dissolve_on_fput(struct vfsmount *mnt)
|
|
|
|
{
|
|
|
|
struct mnt_namespace *ns;
|
|
|
|
namespace_lock();
|
|
|
|
lock_mount_hash();
|
|
|
|
ns = real_mount(mnt)->mnt_ns;
|
2018-11-05 20:40:31 +03:00
|
|
|
if (ns) {
|
|
|
|
if (is_anon_ns(ns))
|
|
|
|
umount_tree(real_mount(mnt), UMOUNT_CONNECTED);
|
|
|
|
else
|
|
|
|
ns = NULL;
|
|
|
|
}
|
2018-11-05 20:40:30 +03:00
|
|
|
unlock_mount_hash();
|
|
|
|
namespace_unlock();
|
2018-11-05 20:40:31 +03:00
|
|
|
if (ns)
|
|
|
|
free_mnt_ns(ns);
|
2018-11-05 20:40:30 +03:00
|
|
|
}
|
|
|
|
|
2007-06-07 20:20:32 +04:00
|
|
|
void drop_collected_mounts(struct vfsmount *mnt)
|
|
|
|
{
|
2013-03-16 23:12:40 +04:00
|
|
|
namespace_lock();
|
2013-09-29 19:24:49 +04:00
|
|
|
lock_mount_hash();
|
2018-10-25 20:05:11 +03:00
|
|
|
umount_tree(real_mount(mnt), 0);
|
2013-09-29 19:24:49 +04:00
|
|
|
unlock_mount_hash();
|
2013-03-16 22:42:19 +04:00
|
|
|
namespace_unlock();
|
2007-06-07 20:20:32 +04:00
|
|
|
}
|
|
|
|
|
2021-08-09 11:19:47 +03:00
|
|
|
static bool has_locked_children(struct mount *mnt, struct dentry *dentry)
|
|
|
|
{
|
|
|
|
struct mount *child;
|
|
|
|
|
|
|
|
list_for_each_entry(child, &mnt->mnt_mounts, mnt_child) {
|
|
|
|
if (!is_subdir(child->mnt_mountpoint, dentry))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (child->mnt.mnt_flags & MNT_LOCKED)
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2014-10-24 02:14:36 +04:00
|
|
|
/**
|
|
|
|
* clone_private_mount - create a private clone of a path
|
2021-03-18 05:52:25 +03:00
|
|
|
* @path: path to clone
|
2014-10-24 02:14:36 +04:00
|
|
|
*
|
2021-03-18 05:52:25 +03:00
|
|
|
* This creates a new vfsmount, which will be the clone of @path. The new mount
|
|
|
|
* will not be attached anywhere in the namespace and will be private (i.e.
|
|
|
|
* changes to the originating mount won't be propagated into this).
|
2014-10-24 02:14:36 +04:00
|
|
|
*
|
|
|
|
* Release with mntput().
|
|
|
|
*/
|
2016-11-21 03:45:28 +03:00
|
|
|
struct vfsmount *clone_private_mount(const struct path *path)
|
2014-10-24 02:14:36 +04:00
|
|
|
{
|
|
|
|
struct mount *old_mnt = real_mount(path->mnt);
|
|
|
|
struct mount *new_mnt;
|
|
|
|
|
2021-08-09 11:19:47 +03:00
|
|
|
down_read(&namespace_sem);
|
2014-10-24 02:14:36 +04:00
|
|
|
if (IS_MNT_UNBINDABLE(old_mnt))
|
2021-08-09 11:19:47 +03:00
|
|
|
goto invalid;
|
|
|
|
|
|
|
|
if (!check_mnt(old_mnt))
|
|
|
|
goto invalid;
|
|
|
|
|
|
|
|
if (has_locked_children(old_mnt, path->dentry))
|
|
|
|
goto invalid;
|
2014-10-24 02:14:36 +04:00
|
|
|
|
|
|
|
new_mnt = clone_mnt(old_mnt, path->dentry, CL_PRIVATE);
|
2021-08-09 11:19:47 +03:00
|
|
|
up_read(&namespace_sem);
|
|
|
|
|
2014-10-24 02:14:36 +04:00
|
|
|
if (IS_ERR(new_mnt))
|
|
|
|
return ERR_CAST(new_mnt);
|
|
|
|
|
2020-06-04 11:48:19 +03:00
|
|
|
/* Longterm mount to be removed by kern_unmount*() */
|
|
|
|
new_mnt->mnt_ns = MNT_NS_INTERNAL;
|
|
|
|
|
2014-10-24 02:14:36 +04:00
|
|
|
return &new_mnt->mnt;
|
2021-08-09 11:19:47 +03:00
|
|
|
|
|
|
|
invalid:
|
|
|
|
up_read(&namespace_sem);
|
|
|
|
return ERR_PTR(-EINVAL);
|
2014-10-24 02:14:36 +04:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(clone_private_mount);
|
|
|
|
|
2010-01-31 06:51:25 +03:00
|
|
|
int iterate_mounts(int (*f)(struct vfsmount *, void *), void *arg,
|
|
|
|
struct vfsmount *root)
|
|
|
|
{
|
2011-11-25 11:19:55 +04:00
|
|
|
struct mount *mnt;
|
2010-01-31 06:51:25 +03:00
|
|
|
int res = f(root, arg);
|
|
|
|
if (res)
|
|
|
|
return res;
|
2011-11-25 11:19:55 +04:00
|
|
|
list_for_each_entry(mnt, &real_mount(root)->mnt_list, mnt_list) {
|
|
|
|
res = f(&mnt->mnt, arg);
|
2010-01-31 06:51:25 +03:00
|
|
|
if (res)
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-01-30 21:15:45 +03:00
|
|
|
static void lock_mnt_tree(struct mount *mnt)
|
|
|
|
{
|
|
|
|
struct mount *p;
|
|
|
|
|
|
|
|
for (p = mnt; p; p = next_mnt(p, mnt)) {
|
|
|
|
int flags = p->mnt.mnt_flags;
|
|
|
|
/* Don't allow unprivileged users to change mount flags */
|
|
|
|
flags |= MNT_LOCK_ATIME;
|
|
|
|
|
|
|
|
if (flags & MNT_READONLY)
|
|
|
|
flags |= MNT_LOCK_READONLY;
|
|
|
|
|
|
|
|
if (flags & MNT_NODEV)
|
|
|
|
flags |= MNT_LOCK_NODEV;
|
|
|
|
|
|
|
|
if (flags & MNT_NOSUID)
|
|
|
|
flags |= MNT_LOCK_NOSUID;
|
|
|
|
|
|
|
|
if (flags & MNT_NOEXEC)
|
|
|
|
flags |= MNT_LOCK_NOEXEC;
|
|
|
|
/* Don't allow unprivileged users to reveal what is under a mount */
|
|
|
|
if (list_empty(&p->mnt_expire))
|
|
|
|
flags |= MNT_LOCKED;
|
|
|
|
p->mnt.mnt_flags = flags;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-11-25 04:54:23 +04:00
|
|
|
static void cleanup_group_ids(struct mount *mnt, struct mount *end)
|
2008-03-27 15:06:23 +03:00
|
|
|
{
|
2011-11-25 03:57:30 +04:00
|
|
|
struct mount *p;
|
2008-03-27 15:06:23 +03:00
|
|
|
|
2011-11-25 12:06:56 +04:00
|
|
|
for (p = mnt; p != end; p = next_mnt(p, mnt)) {
|
2011-11-25 10:05:37 +04:00
|
|
|
if (p->mnt_group_id && !IS_MNT_SHARED(p))
|
2011-11-25 04:54:23 +04:00
|
|
|
mnt_release_group_id(p);
|
2008-03-27 15:06:23 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-11-25 04:54:23 +04:00
|
|
|
static int invent_group_ids(struct mount *mnt, bool recurse)
|
2008-03-27 15:06:23 +03:00
|
|
|
{
|
2011-11-25 03:57:30 +04:00
|
|
|
struct mount *p;
|
2008-03-27 15:06:23 +03:00
|
|
|
|
2011-11-25 12:06:56 +04:00
|
|
|
for (p = mnt; p; p = recurse ? next_mnt(p, mnt) : NULL) {
|
2011-11-25 10:05:37 +04:00
|
|
|
if (!p->mnt_group_id && !IS_MNT_SHARED(p)) {
|
2011-11-25 04:54:23 +04:00
|
|
|
int err = mnt_alloc_group_id(p);
|
2008-03-27 15:06:23 +03:00
|
|
|
if (err) {
|
2011-11-25 04:54:23 +04:00
|
|
|
cleanup_group_ids(mnt, p);
|
2008-03-27 15:06:23 +03:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-09-28 08:27:17 +03:00
|
|
|
int count_mounts(struct mnt_namespace *ns, struct mount *mnt)
|
|
|
|
{
|
|
|
|
unsigned int max = READ_ONCE(sysctl_mount_max);
|
2022-02-14 06:42:30 +03:00
|
|
|
unsigned int mounts = 0;
|
2016-09-28 08:27:17 +03:00
|
|
|
struct mount *p;
|
|
|
|
|
2022-02-14 06:42:30 +03:00
|
|
|
if (ns->mounts >= max)
|
|
|
|
return -ENOSPC;
|
|
|
|
max -= ns->mounts;
|
|
|
|
if (ns->pending_mounts >= max)
|
|
|
|
return -ENOSPC;
|
|
|
|
max -= ns->pending_mounts;
|
|
|
|
|
2016-09-28 08:27:17 +03:00
|
|
|
for (p = mnt; p; p = next_mnt(p, mnt))
|
|
|
|
mounts++;
|
|
|
|
|
2022-02-14 06:42:30 +03:00
|
|
|
if (mounts > max)
|
2016-09-28 08:27:17 +03:00
|
|
|
return -ENOSPC;
|
|
|
|
|
2022-02-14 06:42:30 +03:00
|
|
|
ns->pending_mounts += mounts;
|
2016-09-28 08:27:17 +03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-11-08 01:19:50 +03:00
|
|
|
/*
|
|
|
|
* @source_mnt : mount tree to be attached
|
2005-11-08 01:20:03 +03:00
|
|
|
* @nd : place the mount tree @source_mnt is attached
|
|
|
|
* @parent_nd : if non-null, detach the source_mnt from its parent and
|
|
|
|
* store the parent mount and mountpoint dentry.
|
|
|
|
* (done when source_mnt is moved)
|
2005-11-08 01:19:50 +03:00
|
|
|
*
|
|
|
|
* NOTE: in the table below explains the semantics when a source mount
|
|
|
|
* of a given type is attached to a destination mount of a given type.
|
2005-11-08 01:21:20 +03:00
|
|
|
* ---------------------------------------------------------------------------
|
|
|
|
* | BIND MOUNT OPERATION |
|
|
|
|
* |**************************************************************************
|
|
|
|
* | source-->| shared | private | slave | unbindable |
|
|
|
|
* | dest | | | | |
|
|
|
|
* | | | | | | |
|
|
|
|
* | v | | | | |
|
|
|
|
* |**************************************************************************
|
|
|
|
* | shared | shared (++) | shared (+) | shared(+++)| invalid |
|
|
|
|
* | | | | | |
|
|
|
|
* |non-shared| shared (+) | private | slave (*) | invalid |
|
|
|
|
* ***************************************************************************
|
2005-11-08 01:19:50 +03:00
|
|
|
* A bind operation clones the source mount and mounts the clone on the
|
|
|
|
* destination mount.
|
|
|
|
*
|
|
|
|
* (++) the cloned mount is propagated to all the mounts in the propagation
|
|
|
|
* tree of the destination mount and the cloned mount is added to
|
|
|
|
* the peer group of the source mount.
|
|
|
|
* (+) the cloned mount is created under the destination mount and is marked
|
|
|
|
* as shared. The cloned mount is added to the peer group of the source
|
|
|
|
* mount.
|
2005-11-08 01:21:01 +03:00
|
|
|
* (+++) the mount is propagated to all the mounts in the propagation tree
|
|
|
|
* of the destination mount and the cloned mount is made slave
|
|
|
|
* of the same master as that of the source mount. The cloned mount
|
|
|
|
* is marked as 'shared and slave'.
|
|
|
|
* (*) the cloned mount is made a slave of the same master as that of the
|
|
|
|
* source mount.
|
|
|
|
*
|
2005-11-08 01:21:20 +03:00
|
|
|
* ---------------------------------------------------------------------------
|
|
|
|
* | MOVE MOUNT OPERATION |
|
|
|
|
* |**************************************************************************
|
|
|
|
* | source-->| shared | private | slave | unbindable |
|
|
|
|
* | dest | | | | |
|
|
|
|
* | | | | | | |
|
|
|
|
* | v | | | | |
|
|
|
|
* |**************************************************************************
|
|
|
|
* | shared | shared (+) | shared (+) | shared(+++) | invalid |
|
|
|
|
* | | | | | |
|
|
|
|
* |non-shared| shared (+*) | private | slave (*) | unbindable |
|
|
|
|
* ***************************************************************************
|
2005-11-08 01:21:01 +03:00
|
|
|
*
|
|
|
|
* (+) the mount is moved to the destination. And is then propagated to
|
|
|
|
* all the mounts in the propagation tree of the destination mount.
|
2005-11-08 01:20:03 +03:00
|
|
|
* (+*) the mount is moved to the destination.
|
2005-11-08 01:21:01 +03:00
|
|
|
* (+++) the mount is moved to the destination and is then propagated to
|
|
|
|
* all the mounts belonging to the destination mount's propagation tree.
|
|
|
|
* the mount is marked as 'shared and slave'.
|
|
|
|
* (*) the mount continues to be a slave at the new location.
|
2005-11-08 01:19:50 +03:00
|
|
|
*
|
|
|
|
* if the source mount is a tree, the operations explained above is
|
|
|
|
* applied to each mount in the tree.
|
|
|
|
* Must be called without spinlocks held, since this function can sleep
|
|
|
|
* in allocations.
|
|
|
|
*/
|
2011-11-25 04:59:16 +04:00
|
|
|
static int attach_recursive_mnt(struct mount *source_mnt,
|
2013-03-15 18:53:28 +04:00
|
|
|
struct mount *dest_mnt,
|
|
|
|
struct mountpoint *dest_mp,
|
2019-07-01 02:18:53 +03:00
|
|
|
bool moving)
|
2005-11-08 01:19:50 +03:00
|
|
|
{
|
2019-01-30 21:15:45 +03:00
|
|
|
struct user_namespace *user_ns = current->nsproxy->mnt_ns->user_ns;
|
2014-03-21 05:10:51 +04:00
|
|
|
HLIST_HEAD(tree_list);
|
2016-09-28 08:27:17 +03:00
|
|
|
struct mnt_namespace *ns = dest_mnt->mnt_ns;
|
2017-01-20 08:28:35 +03:00
|
|
|
struct mountpoint *smp;
|
2011-11-25 03:57:30 +04:00
|
|
|
struct mount *child, *p;
|
2014-03-21 05:10:51 +04:00
|
|
|
struct hlist_node *n;
|
2008-03-27 15:06:23 +03:00
|
|
|
int err;
|
2005-11-08 01:19:50 +03:00
|
|
|
|
2017-01-20 08:28:35 +03:00
|
|
|
/* Preallocate a mountpoint in case the new mounts need
|
|
|
|
* to be tucked under other mounts.
|
|
|
|
*/
|
|
|
|
smp = get_mountpoint(source_mnt->mnt.mnt_root);
|
|
|
|
if (IS_ERR(smp))
|
|
|
|
return PTR_ERR(smp);
|
|
|
|
|
2016-09-28 08:27:17 +03:00
|
|
|
/* Is there space to add these mounts to the mount namespace? */
|
2019-07-01 02:18:53 +03:00
|
|
|
if (!moving) {
|
2016-09-28 08:27:17 +03:00
|
|
|
err = count_mounts(ns, source_mnt);
|
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2011-11-25 10:05:37 +04:00
|
|
|
if (IS_MNT_SHARED(dest_mnt)) {
|
2011-11-25 04:59:16 +04:00
|
|
|
err = invent_group_ids(source_mnt, true);
|
2008-03-27 15:06:23 +03:00
|
|
|
if (err)
|
|
|
|
goto out;
|
2014-03-21 18:14:08 +04:00
|
|
|
err = propagate_mnt(dest_mnt, dest_mp, source_mnt, &tree_list);
|
smarter propagate_mnt()
The current mainline has copies propagated to *all* nodes, then
tears down the copies we made for nodes that do not contain
counterparts of the desired mountpoint. That sets the right
propagation graph for the copies (at teardown time we move
the slaves of removed node to a surviving peer or directly
to master), but we end up paying a fairly steep price in
useless allocations. It's fairly easy to create a situation
where N calls of mount(2) create exactly N bindings, with
O(N^2) vfsmounts allocated and freed in process.
Fortunately, it is possible to avoid those allocations/freeings.
The trick is to create copies in the right order and find which
one would've eventually become a master with the current algorithm.
It turns out to be possible in O(nodes getting propagation) time
and with no extra allocations at all.
One part is that we need to make sure that eventual master will be
created before its slaves, so we need to walk the propagation
tree in a different order - by peer groups. And iterate through
the peers before dealing with the next group.
Another thing is finding the (earlier) copy that will be a master
of one we are about to create; to do that we are (temporary) marking
the masters of mountpoints we are attaching the copies to.
Either we are in a peer of the last mountpoint we'd dealt with,
or we have the following situation: we are attaching to mountpoint M,
the last copy S_0 had been attached to M_0 and there are sequences
S_0...S_n, M_0...M_n such that S_{i+1} is a master of S_{i},
S_{i} mounted on M{i} and we need to create a slave of the first S_{k}
such that M is getting propagation from M_{k}. It means that the master
of M_{k} will be among the sequence of masters of M. On the
other hand, the nearest marked node in that sequence will either
be the master of M_{k} or the master of M_{k-1} (the latter -
in the case if M_{k-1} is a slave of something M gets propagation
from, but in a wrong peer group).
So we go through the sequence of masters of M until we find
a marked one (P). Let N be the one before it. Then we go through
the sequence of masters of S_0 until we find one (say, S) mounted
on a node D that has P as master and check if D is a peer of N.
If it is, S will be the master of new copy, if not - the master of S
will be.
That's it for the hard part; the rest is fairly simple. Iterator
is in next_group(), handling of one prospective mountpoint is
propagate_one().
It seems to survive all tests and gives a noticably better performance
than the current mainline for setups that are seriously using shared
subtrees.
Cc: stable@vger.kernel.org
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2014-02-27 18:35:45 +04:00
|
|
|
lock_mount_hash();
|
2014-03-21 18:14:08 +04:00
|
|
|
if (err)
|
|
|
|
goto out_cleanup_ids;
|
2011-11-25 12:06:56 +04:00
|
|
|
for (p = source_mnt; p; p = next_mnt(p, source_mnt))
|
2011-11-25 05:43:10 +04:00
|
|
|
set_mnt_shared(p);
|
2014-03-21 18:14:08 +04:00
|
|
|
} else {
|
|
|
|
lock_mount_hash();
|
2005-11-08 01:19:50 +03:00
|
|
|
}
|
2019-07-01 02:18:53 +03:00
|
|
|
if (moving) {
|
|
|
|
unhash_mnt(source_mnt);
|
2013-03-15 18:53:28 +04:00
|
|
|
attach_mnt(source_mnt, dest_mnt, dest_mp);
|
2011-11-25 09:46:35 +04:00
|
|
|
touch_mnt_namespace(source_mnt->mnt_ns);
|
2005-11-08 01:20:03 +03:00
|
|
|
} else {
|
2018-11-05 20:40:31 +03:00
|
|
|
if (source_mnt->mnt_ns) {
|
|
|
|
/* move from anon - the caller will destroy */
|
|
|
|
list_del_init(&source_mnt->mnt_ns->list);
|
|
|
|
}
|
2013-03-15 18:53:28 +04:00
|
|
|
mnt_set_mountpoint(dest_mnt, dest_mp, source_mnt);
|
2017-01-20 08:28:35 +03:00
|
|
|
commit_tree(source_mnt);
|
2005-11-08 01:20:03 +03:00
|
|
|
}
|
2005-11-08 01:19:50 +03:00
|
|
|
|
2014-03-21 05:10:51 +04:00
|
|
|
hlist_for_each_entry_safe(child, n, &tree_list, mnt_hash) {
|
2014-03-21 04:34:43 +04:00
|
|
|
struct mount *q;
|
2014-03-21 05:10:51 +04:00
|
|
|
hlist_del_init(&child->mnt_hash);
|
2017-01-20 08:28:35 +03:00
|
|
|
q = __lookup_mnt(&child->mnt_parent->mnt,
|
|
|
|
child->mnt_mountpoint);
|
|
|
|
if (q)
|
|
|
|
mnt_change_mountpoint(child, smp, q);
|
2019-01-30 21:15:45 +03:00
|
|
|
/* Notice when we are propagating across user namespaces */
|
|
|
|
if (child->mnt_parent->mnt_ns->user_ns != user_ns)
|
|
|
|
lock_mnt_tree(child);
|
2019-06-18 00:22:14 +03:00
|
|
|
child->mnt.mnt_flags &= ~MNT_LOCKED;
|
2017-01-20 08:28:35 +03:00
|
|
|
commit_tree(child);
|
2005-11-08 01:19:50 +03:00
|
|
|
}
|
2017-01-20 08:28:35 +03:00
|
|
|
put_mountpoint(smp);
|
2013-09-29 19:24:49 +04:00
|
|
|
unlock_mount_hash();
|
fs: brlock vfsmount_lock
fs: brlock vfsmount_lock
Use a brlock for the vfsmount lock. It must be taken for write whenever
modifying the mount hash or associated fields, and may be taken for read when
performing mount hash lookups.
A new lock is added for the mnt-id allocator, so it doesn't need to take
the heavy vfsmount write-lock.
The number of atomics should remain the same for fastpath rlock cases, though
code would be slightly slower due to per-cpu access. Scalability is not not be
much improved in common cases yet, due to other locks (ie. dcache_lock) getting
in the way. However path lookups crossing mountpoints should be one case where
scalability is improved (currently requiring the global lock).
The slowpath is slower due to use of brlock. On a 64 core, 64 socket, 32 node
Altix system (high latency to remote nodes), a simple umount microbenchmark
(mount --bind mnt mnt2 ; umount mnt2 loop 1000 times), before this patch it
took 6.8s, afterwards took 7.1s, about 5% slower.
Cc: Al Viro <viro@ZenIV.linux.org.uk>
Signed-off-by: Nick Piggin <npiggin@kernel.dk>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2010-08-17 22:37:39 +04:00
|
|
|
|
2005-11-08 01:19:50 +03:00
|
|
|
return 0;
|
2008-03-27 15:06:23 +03:00
|
|
|
|
|
|
|
out_cleanup_ids:
|
smarter propagate_mnt()
The current mainline has copies propagated to *all* nodes, then
tears down the copies we made for nodes that do not contain
counterparts of the desired mountpoint. That sets the right
propagation graph for the copies (at teardown time we move
the slaves of removed node to a surviving peer or directly
to master), but we end up paying a fairly steep price in
useless allocations. It's fairly easy to create a situation
where N calls of mount(2) create exactly N bindings, with
O(N^2) vfsmounts allocated and freed in process.
Fortunately, it is possible to avoid those allocations/freeings.
The trick is to create copies in the right order and find which
one would've eventually become a master with the current algorithm.
It turns out to be possible in O(nodes getting propagation) time
and with no extra allocations at all.
One part is that we need to make sure that eventual master will be
created before its slaves, so we need to walk the propagation
tree in a different order - by peer groups. And iterate through
the peers before dealing with the next group.
Another thing is finding the (earlier) copy that will be a master
of one we are about to create; to do that we are (temporary) marking
the masters of mountpoints we are attaching the copies to.
Either we are in a peer of the last mountpoint we'd dealt with,
or we have the following situation: we are attaching to mountpoint M,
the last copy S_0 had been attached to M_0 and there are sequences
S_0...S_n, M_0...M_n such that S_{i+1} is a master of S_{i},
S_{i} mounted on M{i} and we need to create a slave of the first S_{k}
such that M is getting propagation from M_{k}. It means that the master
of M_{k} will be among the sequence of masters of M. On the
other hand, the nearest marked node in that sequence will either
be the master of M_{k} or the master of M_{k-1} (the latter -
in the case if M_{k-1} is a slave of something M gets propagation
from, but in a wrong peer group).
So we go through the sequence of masters of M until we find
a marked one (P). Let N be the one before it. Then we go through
the sequence of masters of S_0 until we find one (say, S) mounted
on a node D that has P as master and check if D is a peer of N.
If it is, S will be the master of new copy, if not - the master of S
will be.
That's it for the hard part; the rest is fairly simple. Iterator
is in next_group(), handling of one prospective mountpoint is
propagate_one().
It seems to survive all tests and gives a noticably better performance
than the current mainline for setups that are seriously using shared
subtrees.
Cc: stable@vger.kernel.org
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2014-02-27 18:35:45 +04:00
|
|
|
while (!hlist_empty(&tree_list)) {
|
|
|
|
child = hlist_entry(tree_list.first, struct mount, mnt_hash);
|
2016-09-28 08:27:17 +03:00
|
|
|
child->mnt_parent->mnt_ns->pending_mounts = 0;
|
2014-12-24 16:20:01 +03:00
|
|
|
umount_tree(child, UMOUNT_SYNC);
|
smarter propagate_mnt()
The current mainline has copies propagated to *all* nodes, then
tears down the copies we made for nodes that do not contain
counterparts of the desired mountpoint. That sets the right
propagation graph for the copies (at teardown time we move
the slaves of removed node to a surviving peer or directly
to master), but we end up paying a fairly steep price in
useless allocations. It's fairly easy to create a situation
where N calls of mount(2) create exactly N bindings, with
O(N^2) vfsmounts allocated and freed in process.
Fortunately, it is possible to avoid those allocations/freeings.
The trick is to create copies in the right order and find which
one would've eventually become a master with the current algorithm.
It turns out to be possible in O(nodes getting propagation) time
and with no extra allocations at all.
One part is that we need to make sure that eventual master will be
created before its slaves, so we need to walk the propagation
tree in a different order - by peer groups. And iterate through
the peers before dealing with the next group.
Another thing is finding the (earlier) copy that will be a master
of one we are about to create; to do that we are (temporary) marking
the masters of mountpoints we are attaching the copies to.
Either we are in a peer of the last mountpoint we'd dealt with,
or we have the following situation: we are attaching to mountpoint M,
the last copy S_0 had been attached to M_0 and there are sequences
S_0...S_n, M_0...M_n such that S_{i+1} is a master of S_{i},
S_{i} mounted on M{i} and we need to create a slave of the first S_{k}
such that M is getting propagation from M_{k}. It means that the master
of M_{k} will be among the sequence of masters of M. On the
other hand, the nearest marked node in that sequence will either
be the master of M_{k} or the master of M_{k-1} (the latter -
in the case if M_{k-1} is a slave of something M gets propagation
from, but in a wrong peer group).
So we go through the sequence of masters of M until we find
a marked one (P). Let N be the one before it. Then we go through
the sequence of masters of S_0 until we find one (say, S) mounted
on a node D that has P as master and check if D is a peer of N.
If it is, S will be the master of new copy, if not - the master of S
will be.
That's it for the hard part; the rest is fairly simple. Iterator
is in next_group(), handling of one prospective mountpoint is
propagate_one().
It seems to survive all tests and gives a noticably better performance
than the current mainline for setups that are seriously using shared
subtrees.
Cc: stable@vger.kernel.org
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2014-02-27 18:35:45 +04:00
|
|
|
}
|
|
|
|
unlock_mount_hash();
|
2014-03-21 18:14:08 +04:00
|
|
|
cleanup_group_ids(source_mnt, NULL);
|
2008-03-27 15:06:23 +03:00
|
|
|
out:
|
2016-09-28 08:27:17 +03:00
|
|
|
ns->pending_mounts = 0;
|
2017-01-20 08:28:35 +03:00
|
|
|
|
|
|
|
read_seqlock_excl(&mount_lock);
|
|
|
|
put_mountpoint(smp);
|
|
|
|
read_sequnlock_excl(&mount_lock);
|
|
|
|
|
2008-03-27 15:06:23 +03:00
|
|
|
return err;
|
2005-11-08 01:19:50 +03:00
|
|
|
}
|
|
|
|
|
2013-03-15 18:53:28 +04:00
|
|
|
static struct mountpoint *lock_mount(struct path *path)
|
2011-03-18 15:55:38 +03:00
|
|
|
{
|
|
|
|
struct vfsmount *mnt;
|
2013-03-15 18:53:28 +04:00
|
|
|
struct dentry *dentry = path->dentry;
|
2011-03-18 15:55:38 +03:00
|
|
|
retry:
|
2016-01-22 23:40:57 +03:00
|
|
|
inode_lock(dentry->d_inode);
|
2013-03-15 18:53:28 +04:00
|
|
|
if (unlikely(cant_mount(dentry))) {
|
2016-01-22 23:40:57 +03:00
|
|
|
inode_unlock(dentry->d_inode);
|
2013-03-15 18:53:28 +04:00
|
|
|
return ERR_PTR(-ENOENT);
|
2011-03-18 15:55:38 +03:00
|
|
|
}
|
2013-03-16 23:12:40 +04:00
|
|
|
namespace_lock();
|
2011-03-18 15:55:38 +03:00
|
|
|
mnt = lookup_mnt(path);
|
2013-03-15 18:53:28 +04:00
|
|
|
if (likely(!mnt)) {
|
2017-01-03 04:18:43 +03:00
|
|
|
struct mountpoint *mp = get_mountpoint(dentry);
|
2013-03-15 18:53:28 +04:00
|
|
|
if (IS_ERR(mp)) {
|
2013-03-16 23:12:40 +04:00
|
|
|
namespace_unlock();
|
2016-01-22 23:40:57 +03:00
|
|
|
inode_unlock(dentry->d_inode);
|
2013-03-15 18:53:28 +04:00
|
|
|
return mp;
|
|
|
|
}
|
|
|
|
return mp;
|
|
|
|
}
|
2013-03-16 23:12:40 +04:00
|
|
|
namespace_unlock();
|
2016-01-22 23:40:57 +03:00
|
|
|
inode_unlock(path->dentry->d_inode);
|
2011-03-18 15:55:38 +03:00
|
|
|
path_put(path);
|
|
|
|
path->mnt = mnt;
|
2013-03-15 18:53:28 +04:00
|
|
|
dentry = path->dentry = dget(mnt->mnt_root);
|
2011-03-18 15:55:38 +03:00
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
|
2013-03-15 18:53:28 +04:00
|
|
|
static void unlock_mount(struct mountpoint *where)
|
2011-03-18 15:55:38 +03:00
|
|
|
{
|
2013-03-15 18:53:28 +04:00
|
|
|
struct dentry *dentry = where->m_dentry;
|
2017-01-03 04:18:43 +03:00
|
|
|
|
|
|
|
read_seqlock_excl(&mount_lock);
|
2013-03-15 18:53:28 +04:00
|
|
|
put_mountpoint(where);
|
2017-01-03 04:18:43 +03:00
|
|
|
read_sequnlock_excl(&mount_lock);
|
|
|
|
|
2013-03-16 22:49:45 +04:00
|
|
|
namespace_unlock();
|
2016-01-22 23:40:57 +03:00
|
|
|
inode_unlock(dentry->d_inode);
|
2011-03-18 15:55:38 +03:00
|
|
|
}
|
|
|
|
|
2013-03-15 18:53:28 +04:00
|
|
|
static int graft_tree(struct mount *mnt, struct mount *p, struct mountpoint *mp)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2017-07-17 10:45:35 +03:00
|
|
|
if (mnt->mnt.mnt_sb->s_flags & SB_NOUSER)
|
2005-04-17 02:20:36 +04:00
|
|
|
return -EINVAL;
|
|
|
|
|
VFS: (Scripted) Convert S_ISLNK/DIR/REG(dentry->d_inode) to d_is_*(dentry)
Convert the following where appropriate:
(1) S_ISLNK(dentry->d_inode) to d_is_symlink(dentry).
(2) S_ISREG(dentry->d_inode) to d_is_reg(dentry).
(3) S_ISDIR(dentry->d_inode) to d_is_dir(dentry). This is actually more
complicated than it appears as some calls should be converted to
d_can_lookup() instead. The difference is whether the directory in
question is a real dir with a ->lookup op or whether it's a fake dir with
a ->d_automount op.
In some circumstances, we can subsume checks for dentry->d_inode not being
NULL into this, provided we the code isn't in a filesystem that expects
d_inode to be NULL if the dirent really *is* negative (ie. if we're going to
use d_inode() rather than d_backing_inode() to get the inode pointer).
Note that the dentry type field may be set to something other than
DCACHE_MISS_TYPE when d_inode is NULL in the case of unionmount, where the VFS
manages the fall-through from a negative dentry to a lower layer. In such a
case, the dentry type of the negative union dentry is set to the same as the
type of the lower dentry.
However, if you know d_inode is not NULL at the call site, then you can use
the d_is_xxx() functions even in a filesystem.
There is one further complication: a 0,0 chardev dentry may be labelled
DCACHE_WHITEOUT_TYPE rather than DCACHE_SPECIAL_TYPE. Strictly, this was
intended for special directory entry types that don't have attached inodes.
The following perl+coccinelle script was used:
use strict;
my @callers;
open($fd, 'git grep -l \'S_IS[A-Z].*->d_inode\' |') ||
die "Can't grep for S_ISDIR and co. callers";
@callers = <$fd>;
close($fd);
unless (@callers) {
print "No matches\n";
exit(0);
}
my @cocci = (
'@@',
'expression E;',
'@@',
'',
'- S_ISLNK(E->d_inode->i_mode)',
'+ d_is_symlink(E)',
'',
'@@',
'expression E;',
'@@',
'',
'- S_ISDIR(E->d_inode->i_mode)',
'+ d_is_dir(E)',
'',
'@@',
'expression E;',
'@@',
'',
'- S_ISREG(E->d_inode->i_mode)',
'+ d_is_reg(E)' );
my $coccifile = "tmp.sp.cocci";
open($fd, ">$coccifile") || die $coccifile;
print($fd "$_\n") || die $coccifile foreach (@cocci);
close($fd);
foreach my $file (@callers) {
chomp $file;
print "Processing ", $file, "\n";
system("spatch", "--sp-file", $coccifile, $file, "--in-place", "--no-show-diff") == 0 ||
die "spatch failed";
}
[AV: overlayfs parts skipped]
Signed-off-by: David Howells <dhowells@redhat.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2015-01-29 15:02:35 +03:00
|
|
|
if (d_is_dir(mp->m_dentry) !=
|
|
|
|
d_is_dir(mnt->mnt.mnt_root))
|
2005-04-17 02:20:36 +04:00
|
|
|
return -ENOTDIR;
|
|
|
|
|
2019-07-01 02:18:53 +03:00
|
|
|
return attach_recursive_mnt(mnt, p, mp, false);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2010-08-26 22:07:22 +04:00
|
|
|
/*
|
|
|
|
* Sanity check the flags to change_mnt_propagation.
|
|
|
|
*/
|
|
|
|
|
2017-07-17 10:45:35 +03:00
|
|
|
static int flags_to_propagation_type(int ms_flags)
|
2010-08-26 22:07:22 +04:00
|
|
|
{
|
2017-07-17 10:45:35 +03:00
|
|
|
int type = ms_flags & ~(MS_REC | MS_SILENT);
|
2010-08-26 22:07:22 +04:00
|
|
|
|
|
|
|
/* Fail if any non-propagation flags are set */
|
|
|
|
if (type & ~(MS_SHARED | MS_PRIVATE | MS_SLAVE | MS_UNBINDABLE))
|
|
|
|
return 0;
|
|
|
|
/* Only one propagation flag should be set */
|
|
|
|
if (!is_power_of_2(type))
|
|
|
|
return 0;
|
|
|
|
return type;
|
|
|
|
}
|
|
|
|
|
2005-11-08 01:19:07 +03:00
|
|
|
/*
|
|
|
|
* recursively change the type of the mountpoint.
|
|
|
|
*/
|
2017-07-17 10:45:35 +03:00
|
|
|
static int do_change_type(struct path *path, int ms_flags)
|
2005-11-08 01:19:07 +03:00
|
|
|
{
|
2011-11-25 03:57:30 +04:00
|
|
|
struct mount *m;
|
2011-11-25 04:54:23 +04:00
|
|
|
struct mount *mnt = real_mount(path->mnt);
|
2017-07-17 10:45:35 +03:00
|
|
|
int recurse = ms_flags & MS_REC;
|
2010-08-26 22:07:22 +04:00
|
|
|
int type;
|
2008-03-27 15:06:23 +03:00
|
|
|
int err = 0;
|
2005-11-08 01:19:07 +03:00
|
|
|
|
2008-08-02 08:51:11 +04:00
|
|
|
if (path->dentry != path->mnt->mnt_root)
|
2005-11-08 01:19:07 +03:00
|
|
|
return -EINVAL;
|
|
|
|
|
2017-07-17 10:45:35 +03:00
|
|
|
type = flags_to_propagation_type(ms_flags);
|
2010-08-26 22:07:22 +04:00
|
|
|
if (!type)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2013-03-16 23:12:40 +04:00
|
|
|
namespace_lock();
|
2008-03-27 15:06:23 +03:00
|
|
|
if (type == MS_SHARED) {
|
|
|
|
err = invent_group_ids(mnt, recurse);
|
|
|
|
if (err)
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
2013-09-29 19:24:49 +04:00
|
|
|
lock_mount_hash();
|
2011-11-25 12:06:56 +04:00
|
|
|
for (m = mnt; m; m = (recurse ? next_mnt(m, mnt) : NULL))
|
2011-11-25 05:43:10 +04:00
|
|
|
change_mnt_propagation(m, type);
|
2013-09-29 19:24:49 +04:00
|
|
|
unlock_mount_hash();
|
2008-03-27 15:06:23 +03:00
|
|
|
|
|
|
|
out_unlock:
|
2013-03-16 23:12:40 +04:00
|
|
|
namespace_unlock();
|
2008-03-27 15:06:23 +03:00
|
|
|
return err;
|
2005-11-08 01:19:07 +03:00
|
|
|
}
|
|
|
|
|
2018-11-05 20:40:30 +03:00
|
|
|
static struct mount *__do_loopback(struct path *old_path, int recurse)
|
|
|
|
{
|
|
|
|
struct mount *mnt = ERR_PTR(-EINVAL), *old = real_mount(old_path->mnt);
|
|
|
|
|
|
|
|
if (IS_MNT_UNBINDABLE(old))
|
|
|
|
return mnt;
|
|
|
|
|
|
|
|
if (!check_mnt(old) && old_path->dentry->d_op != &ns_dentry_operations)
|
|
|
|
return mnt;
|
|
|
|
|
|
|
|
if (!recurse && has_locked_children(old, old_path->dentry))
|
|
|
|
return mnt;
|
|
|
|
|
|
|
|
if (recurse)
|
|
|
|
mnt = copy_tree(old, old_path->dentry, CL_COPY_MNT_NS_FILE);
|
|
|
|
else
|
|
|
|
mnt = clone_mnt(old, old_path->dentry, 0);
|
|
|
|
|
|
|
|
if (!IS_ERR(mnt))
|
|
|
|
mnt->mnt.mnt_flags &= ~MNT_LOCKED;
|
|
|
|
|
|
|
|
return mnt;
|
|
|
|
}
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/*
|
|
|
|
* do loopback mount.
|
|
|
|
*/
|
2012-10-11 19:42:01 +04:00
|
|
|
static int do_loopback(struct path *path, const char *old_name,
|
2008-02-08 15:22:12 +03:00
|
|
|
int recurse)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2008-08-02 08:51:11 +04:00
|
|
|
struct path old_path;
|
2018-11-05 20:40:30 +03:00
|
|
|
struct mount *mnt = NULL, *parent;
|
2013-03-15 18:53:28 +04:00
|
|
|
struct mountpoint *mp;
|
2013-02-23 07:49:10 +04:00
|
|
|
int err;
|
2005-04-17 02:20:36 +04:00
|
|
|
if (!old_name || !*old_name)
|
|
|
|
return -EINVAL;
|
2011-09-27 04:36:09 +04:00
|
|
|
err = kern_path(old_name, LOOKUP_FOLLOW|LOOKUP_AUTOMOUNT, &old_path);
|
2005-04-17 02:20:36 +04:00
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
2010-03-08 05:49:36 +03:00
|
|
|
err = -EINVAL;
|
2013-03-30 12:35:18 +04:00
|
|
|
if (mnt_ns_loop(old_path.dentry))
|
2017-07-04 19:25:09 +03:00
|
|
|
goto out;
|
2010-03-08 05:49:36 +03:00
|
|
|
|
2013-03-15 18:53:28 +04:00
|
|
|
mp = lock_mount(path);
|
2018-11-05 20:40:30 +03:00
|
|
|
if (IS_ERR(mp)) {
|
|
|
|
err = PTR_ERR(mp);
|
2011-03-18 15:55:38 +03:00
|
|
|
goto out;
|
2018-11-05 20:40:30 +03:00
|
|
|
}
|
2011-03-18 15:55:38 +03:00
|
|
|
|
2013-03-15 18:53:28 +04:00
|
|
|
parent = real_mount(path->mnt);
|
take the targets of /proc/*/ns/* symlinks to separate fs
New pseudo-filesystem: nsfs. Targets of /proc/*/ns/* live there now.
It's not mountable (not even registered, so it's not in /proc/filesystems,
etc.). Files on it *are* bindable - we explicitly permit that in do_loopback().
This stuff lives in fs/nsfs.c now; proc_ns_fget() moved there as well.
get_proc_ns() is a macro now (it's simply returning ->i_private; would
have been an inline, if not for header ordering headache).
proc_ns_inode() is an ex-parrot. The interface used in procfs is
ns_get_path(path, task, ops) and ns_get_name(buf, size, task, ops).
Dentries and inodes are never hashed; a non-counting reference to dentry
is stashed in ns_common (removed by ->d_prune()) and reused by ns_get_path()
if present. See ns_get_path()/ns_prune_dentry/nsfs_evict() for details
of that mechanism.
As the result, proc_ns_follow_link() has stopped poking in nd->path.mnt;
it does nd_jump_link() on a consistent <vfsmount,dentry> pair it gets
from ns_get_path().
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2014-11-01 17:57:28 +03:00
|
|
|
if (!check_mnt(parent))
|
|
|
|
goto out2;
|
|
|
|
|
2018-11-05 20:40:30 +03:00
|
|
|
mnt = __do_loopback(&old_path, recurse);
|
2012-06-25 15:55:18 +04:00
|
|
|
if (IS_ERR(mnt)) {
|
|
|
|
err = PTR_ERR(mnt);
|
2013-04-09 17:33:29 +04:00
|
|
|
goto out2;
|
2012-06-25 15:55:18 +04:00
|
|
|
}
|
2005-11-08 01:15:04 +03:00
|
|
|
|
2013-03-15 18:53:28 +04:00
|
|
|
err = graft_tree(mnt, parent, mp);
|
2005-11-08 01:15:04 +03:00
|
|
|
if (err) {
|
2013-09-29 19:24:49 +04:00
|
|
|
lock_mount_hash();
|
2014-12-24 16:20:01 +03:00
|
|
|
umount_tree(mnt, UMOUNT_SYNC);
|
2013-09-29 19:24:49 +04:00
|
|
|
unlock_mount_hash();
|
2005-11-08 01:16:29 +03:00
|
|
|
}
|
2011-03-18 15:55:38 +03:00
|
|
|
out2:
|
2013-03-15 18:53:28 +04:00
|
|
|
unlock_mount(mp);
|
2005-11-08 01:15:04 +03:00
|
|
|
out:
|
2008-08-02 08:51:11 +04:00
|
|
|
path_put(&old_path);
|
2005-04-17 02:20:36 +04:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2018-11-05 20:40:30 +03:00
|
|
|
static struct file *open_detached_copy(struct path *path, bool recursive)
|
|
|
|
{
|
|
|
|
struct user_namespace *user_ns = current->nsproxy->mnt_ns->user_ns;
|
|
|
|
struct mnt_namespace *ns = alloc_mnt_ns(user_ns, true);
|
|
|
|
struct mount *mnt, *p;
|
|
|
|
struct file *file;
|
|
|
|
|
|
|
|
if (IS_ERR(ns))
|
|
|
|
return ERR_CAST(ns);
|
|
|
|
|
|
|
|
namespace_lock();
|
|
|
|
mnt = __do_loopback(path, recursive);
|
|
|
|
if (IS_ERR(mnt)) {
|
|
|
|
namespace_unlock();
|
|
|
|
free_mnt_ns(ns);
|
|
|
|
return ERR_CAST(mnt);
|
|
|
|
}
|
|
|
|
|
|
|
|
lock_mount_hash();
|
|
|
|
for (p = mnt; p; p = next_mnt(p, mnt)) {
|
|
|
|
p->mnt_ns = ns;
|
|
|
|
ns->mounts++;
|
|
|
|
}
|
|
|
|
ns->root = mnt;
|
|
|
|
list_add_tail(&ns->list, &mnt->mnt_list);
|
|
|
|
mntget(&mnt->mnt);
|
|
|
|
unlock_mount_hash();
|
|
|
|
namespace_unlock();
|
|
|
|
|
|
|
|
mntput(path->mnt);
|
|
|
|
path->mnt = &mnt->mnt;
|
|
|
|
file = dentry_open(path, O_PATH, current_cred());
|
|
|
|
if (IS_ERR(file))
|
|
|
|
dissolve_on_fput(path->mnt);
|
|
|
|
else
|
|
|
|
file->f_mode |= FMODE_NEED_UNMOUNT;
|
|
|
|
return file;
|
|
|
|
}
|
|
|
|
|
2019-10-15 13:35:02 +03:00
|
|
|
SYSCALL_DEFINE3(open_tree, int, dfd, const char __user *, filename, unsigned, flags)
|
2018-11-05 20:40:30 +03:00
|
|
|
{
|
|
|
|
struct file *file;
|
|
|
|
struct path path;
|
|
|
|
int lookup_flags = LOOKUP_AUTOMOUNT | LOOKUP_FOLLOW;
|
|
|
|
bool detached = flags & OPEN_TREE_CLONE;
|
|
|
|
int error;
|
|
|
|
int fd;
|
|
|
|
|
|
|
|
BUILD_BUG_ON(OPEN_TREE_CLOEXEC != O_CLOEXEC);
|
|
|
|
|
|
|
|
if (flags & ~(AT_EMPTY_PATH | AT_NO_AUTOMOUNT | AT_RECURSIVE |
|
|
|
|
AT_SYMLINK_NOFOLLOW | OPEN_TREE_CLONE |
|
|
|
|
OPEN_TREE_CLOEXEC))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if ((flags & (AT_RECURSIVE | OPEN_TREE_CLONE)) == AT_RECURSIVE)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (flags & AT_NO_AUTOMOUNT)
|
|
|
|
lookup_flags &= ~LOOKUP_AUTOMOUNT;
|
|
|
|
if (flags & AT_SYMLINK_NOFOLLOW)
|
|
|
|
lookup_flags &= ~LOOKUP_FOLLOW;
|
|
|
|
if (flags & AT_EMPTY_PATH)
|
|
|
|
lookup_flags |= LOOKUP_EMPTY;
|
|
|
|
|
|
|
|
if (detached && !may_mount())
|
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
fd = get_unused_fd_flags(flags & O_CLOEXEC);
|
|
|
|
if (fd < 0)
|
|
|
|
return fd;
|
|
|
|
|
|
|
|
error = user_path_at(dfd, filename, lookup_flags, &path);
|
|
|
|
if (unlikely(error)) {
|
|
|
|
file = ERR_PTR(error);
|
|
|
|
} else {
|
|
|
|
if (detached)
|
|
|
|
file = open_detached_copy(&path, flags & AT_RECURSIVE);
|
|
|
|
else
|
|
|
|
file = dentry_open(&path, O_PATH, current_cred());
|
|
|
|
path_put(&path);
|
|
|
|
}
|
|
|
|
if (IS_ERR(file)) {
|
|
|
|
put_unused_fd(fd);
|
|
|
|
return PTR_ERR(file);
|
|
|
|
}
|
|
|
|
fd_install(fd, file);
|
|
|
|
return fd;
|
|
|
|
}
|
|
|
|
|
2018-11-02 02:07:25 +03:00
|
|
|
/*
|
|
|
|
* Don't allow locked mount flags to be cleared.
|
|
|
|
*
|
|
|
|
* No locks need to be held here while testing the various MNT_LOCK
|
|
|
|
* flags because those flags can never be cleared once they are set.
|
|
|
|
*/
|
|
|
|
static bool can_change_locked_flags(struct mount *mnt, unsigned int mnt_flags)
|
2008-02-16 01:38:00 +03:00
|
|
|
{
|
2018-11-02 02:07:25 +03:00
|
|
|
unsigned int fl = mnt->mnt.mnt_flags;
|
|
|
|
|
|
|
|
if ((fl & MNT_LOCK_READONLY) &&
|
|
|
|
!(mnt_flags & MNT_READONLY))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if ((fl & MNT_LOCK_NODEV) &&
|
|
|
|
!(mnt_flags & MNT_NODEV))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if ((fl & MNT_LOCK_NOSUID) &&
|
|
|
|
!(mnt_flags & MNT_NOSUID))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if ((fl & MNT_LOCK_NOEXEC) &&
|
|
|
|
!(mnt_flags & MNT_NOEXEC))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if ((fl & MNT_LOCK_ATIME) &&
|
|
|
|
((fl & MNT_ATIME_MASK) != (mnt_flags & MNT_ATIME_MASK)))
|
|
|
|
return false;
|
2008-02-16 01:38:00 +03:00
|
|
|
|
2018-11-02 02:07:25 +03:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int change_mount_ro_state(struct mount *mnt, unsigned int mnt_flags)
|
2008-02-16 01:38:00 +03:00
|
|
|
{
|
2018-11-02 02:07:25 +03:00
|
|
|
bool readonly_request = (mnt_flags & MNT_READONLY);
|
2008-02-16 01:38:00 +03:00
|
|
|
|
2018-11-02 02:07:25 +03:00
|
|
|
if (readonly_request == __mnt_is_readonly(&mnt->mnt))
|
2008-02-16 01:38:00 +03:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (readonly_request)
|
2018-11-02 02:07:25 +03:00
|
|
|
return mnt_make_readonly(mnt);
|
|
|
|
|
2021-01-21 16:19:48 +03:00
|
|
|
mnt->mnt.mnt_flags &= ~MNT_READONLY;
|
|
|
|
return 0;
|
2018-11-02 02:07:25 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void set_mount_attributes(struct mount *mnt, unsigned int mnt_flags)
|
|
|
|
{
|
|
|
|
mnt_flags |= mnt->mnt.mnt_flags & ~MNT_USER_SETTABLE_MASK;
|
|
|
|
mnt->mnt.mnt_flags = mnt_flags;
|
|
|
|
touch_mnt_namespace(mnt->mnt_ns);
|
|
|
|
}
|
|
|
|
|
2019-04-16 00:17:12 +03:00
|
|
|
static void mnt_warn_timestamp_expiry(struct path *mountpoint, struct vfsmount *mnt)
|
|
|
|
{
|
|
|
|
struct super_block *sb = mnt->mnt_sb;
|
|
|
|
|
|
|
|
if (!__mnt_is_readonly(mnt) &&
|
2022-03-23 00:39:22 +03:00
|
|
|
(!(sb->s_iflags & SB_I_TS_EXPIRY_WARNED)) &&
|
2019-04-16 00:17:12 +03:00
|
|
|
(ktime_get_real_seconds() + TIME_UPTIME_SEC_MAX > sb->s_time_max)) {
|
|
|
|
char *buf = (char *)__get_free_page(GFP_KERNEL);
|
|
|
|
char *mntpath = buf ? d_path(mountpoint, buf, PAGE_SIZE) : ERR_PTR(-ENOMEM);
|
|
|
|
struct tm tm;
|
|
|
|
|
|
|
|
time64_to_tm(sb->s_time_max, 0, &tm);
|
|
|
|
|
2019-10-17 05:48:14 +03:00
|
|
|
pr_warn("%s filesystem being %s at %s supports timestamps until %04ld (0x%llx)\n",
|
|
|
|
sb->s_type->name,
|
|
|
|
is_mounted(mnt) ? "remounted" : "mounted",
|
|
|
|
mntpath,
|
2019-04-16 00:17:12 +03:00
|
|
|
tm.tm_year+1900, (unsigned long long)sb->s_time_max);
|
|
|
|
|
|
|
|
free_page((unsigned long)buf);
|
2022-03-23 00:39:22 +03:00
|
|
|
sb->s_iflags |= SB_I_TS_EXPIRY_WARNED;
|
2019-04-16 00:17:12 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-11-02 02:07:25 +03:00
|
|
|
/*
|
|
|
|
* Handle reconfiguration of the mountpoint only without alteration of the
|
|
|
|
* superblock it refers to. This is triggered by specifying MS_REMOUNT|MS_BIND
|
|
|
|
* to mount(2).
|
|
|
|
*/
|
|
|
|
static int do_reconfigure_mnt(struct path *path, unsigned int mnt_flags)
|
|
|
|
{
|
|
|
|
struct super_block *sb = path->mnt->mnt_sb;
|
|
|
|
struct mount *mnt = real_mount(path->mnt);
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!check_mnt(mnt))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (path->dentry != mnt->mnt.mnt_root)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (!can_change_locked_flags(mnt, mnt_flags))
|
|
|
|
return -EPERM;
|
|
|
|
|
2021-01-21 16:19:50 +03:00
|
|
|
/*
|
|
|
|
* We're only checking whether the superblock is read-only not
|
|
|
|
* changing it, so only take down_read(&sb->s_umount).
|
|
|
|
*/
|
|
|
|
down_read(&sb->s_umount);
|
2021-01-21 16:19:48 +03:00
|
|
|
lock_mount_hash();
|
2018-11-02 02:07:25 +03:00
|
|
|
ret = change_mount_ro_state(mnt, mnt_flags);
|
|
|
|
if (ret == 0)
|
|
|
|
set_mount_attributes(mnt, mnt_flags);
|
2021-01-21 16:19:48 +03:00
|
|
|
unlock_mount_hash();
|
2021-01-21 16:19:50 +03:00
|
|
|
up_read(&sb->s_umount);
|
2019-04-16 00:17:12 +03:00
|
|
|
|
|
|
|
mnt_warn_timestamp_expiry(path, &mnt->mnt);
|
|
|
|
|
2018-11-02 02:07:25 +03:00
|
|
|
return ret;
|
2008-02-16 01:38:00 +03:00
|
|
|
}
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2017-07-17 10:45:35 +03:00
|
|
|
static int do_remount(struct path *path, int ms_flags, int sb_flags,
|
|
|
|
int mnt_flags, void *data)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
|
|
|
int err;
|
2008-08-02 08:51:11 +04:00
|
|
|
struct super_block *sb = path->mnt->mnt_sb;
|
2011-11-25 09:46:35 +04:00
|
|
|
struct mount *mnt = real_mount(path->mnt);
|
2018-11-04 17:28:36 +03:00
|
|
|
struct fs_context *fc;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2011-11-25 09:46:35 +04:00
|
|
|
if (!check_mnt(mnt))
|
2005-04-17 02:20:36 +04:00
|
|
|
return -EINVAL;
|
|
|
|
|
2008-08-02 08:51:11 +04:00
|
|
|
if (path->dentry != path->mnt->mnt_root)
|
2005-04-17 02:20:36 +04:00
|
|
|
return -EINVAL;
|
|
|
|
|
2018-11-02 02:07:25 +03:00
|
|
|
if (!can_change_locked_flags(mnt, mnt_flags))
|
mnt: Correct permission checks in do_remount
While invesgiating the issue where in "mount --bind -oremount,ro ..."
would result in later "mount --bind -oremount,rw" succeeding even if
the mount started off locked I realized that there are several
additional mount flags that should be locked and are not.
In particular MNT_NOSUID, MNT_NODEV, MNT_NOEXEC, and the atime
flags in addition to MNT_READONLY should all be locked. These
flags are all per superblock, can all be changed with MS_BIND,
and should not be changable if set by a more privileged user.
The following additions to the current logic are added in this patch.
- nosuid may not be clearable by a less privileged user.
- nodev may not be clearable by a less privielged user.
- noexec may not be clearable by a less privileged user.
- atime flags may not be changeable by a less privileged user.
The logic with atime is that always setting atime on access is a
global policy and backup software and auditing software could break if
atime bits are not updated (when they are configured to be updated),
and serious performance degradation could result (DOS attack) if atime
updates happen when they have been explicitly disabled. Therefore an
unprivileged user should not be able to mess with the atime bits set
by a more privileged user.
The additional restrictions are implemented with the addition of
MNT_LOCK_NOSUID, MNT_LOCK_NODEV, MNT_LOCK_NOEXEC, and MNT_LOCK_ATIME
mnt flags.
Taken together these changes and the fixes for MNT_LOCK_READONLY
should make it safe for an unprivileged user to create a user
namespace and to call "mount --bind -o remount,... ..." without
the danger of mount flags being changed maliciously.
Cc: stable@vger.kernel.org
Acked-by: Serge E. Hallyn <serge.hallyn@ubuntu.com>
Signed-off-by: "Eric W. Biederman" <ebiederm@xmission.com>
2014-07-29 04:26:07 +04:00
|
|
|
return -EPERM;
|
|
|
|
|
2018-11-04 17:28:36 +03:00
|
|
|
fc = fs_context_for_reconfigure(path->dentry, sb_flags, MS_RMT_MASK);
|
|
|
|
if (IS_ERR(fc))
|
|
|
|
return PTR_ERR(fc);
|
2011-03-04 00:09:14 +03:00
|
|
|
|
2020-07-14 15:45:41 +03:00
|
|
|
fc->oldapi = true;
|
2018-11-04 17:28:36 +03:00
|
|
|
err = parse_monolithic_mount_data(fc, data);
|
|
|
|
if (!err) {
|
|
|
|
down_write(&sb->s_umount);
|
|
|
|
err = -EPERM;
|
|
|
|
if (ns_capable(sb->s_user_ns, CAP_SYS_ADMIN)) {
|
|
|
|
err = reconfigure_super(fc);
|
2021-01-21 16:19:48 +03:00
|
|
|
if (!err) {
|
|
|
|
lock_mount_hash();
|
2018-11-04 17:28:36 +03:00
|
|
|
set_mount_attributes(mnt, mnt_flags);
|
2021-01-21 16:19:48 +03:00
|
|
|
unlock_mount_hash();
|
|
|
|
}
|
2018-11-04 17:28:36 +03:00
|
|
|
}
|
|
|
|
up_write(&sb->s_umount);
|
2008-09-27 06:01:20 +04:00
|
|
|
}
|
2019-04-16 00:17:12 +03:00
|
|
|
|
|
|
|
mnt_warn_timestamp_expiry(path, &mnt->mnt);
|
|
|
|
|
2018-11-04 17:28:36 +03:00
|
|
|
put_fs_context(fc);
|
2005-04-17 02:20:36 +04:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2011-11-25 05:01:19 +04:00
|
|
|
static inline int tree_contains_unbindable(struct mount *mnt)
|
2005-11-08 01:21:20 +03:00
|
|
|
{
|
2011-11-25 03:57:30 +04:00
|
|
|
struct mount *p;
|
2011-11-25 12:06:56 +04:00
|
|
|
for (p = mnt; p; p = next_mnt(p, mnt)) {
|
2011-11-25 10:05:37 +04:00
|
|
|
if (IS_MNT_UNBINDABLE(p))
|
2005-11-08 01:21:20 +03:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-11-05 20:40:31 +03:00
|
|
|
/*
|
|
|
|
* Check that there aren't references to earlier/same mount namespaces in the
|
|
|
|
* specified subtree. Such references can act as pins for mount namespaces
|
|
|
|
* that aren't checked by the mount-cycle checking code, thereby allowing
|
|
|
|
* cycles to be made.
|
|
|
|
*/
|
|
|
|
static bool check_for_nsfs_mounts(struct mount *subtree)
|
|
|
|
{
|
|
|
|
struct mount *p;
|
|
|
|
bool ret = false;
|
|
|
|
|
|
|
|
lock_mount_hash();
|
|
|
|
for (p = subtree; p; p = next_mnt(p, subtree))
|
|
|
|
if (mnt_ns_loop(p->mnt.mnt_root))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
ret = true;
|
|
|
|
out:
|
|
|
|
unlock_mount_hash();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2021-07-15 13:07:13 +03:00
|
|
|
static int do_set_group(struct path *from_path, struct path *to_path)
|
|
|
|
{
|
|
|
|
struct mount *from, *to;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
from = real_mount(from_path->mnt);
|
|
|
|
to = real_mount(to_path->mnt);
|
|
|
|
|
|
|
|
namespace_lock();
|
|
|
|
|
|
|
|
err = -EINVAL;
|
|
|
|
/* To and From must be mounted */
|
|
|
|
if (!is_mounted(&from->mnt))
|
|
|
|
goto out;
|
|
|
|
if (!is_mounted(&to->mnt))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
err = -EPERM;
|
|
|
|
/* We should be allowed to modify mount namespaces of both mounts */
|
|
|
|
if (!ns_capable(from->mnt_ns->user_ns, CAP_SYS_ADMIN))
|
|
|
|
goto out;
|
|
|
|
if (!ns_capable(to->mnt_ns->user_ns, CAP_SYS_ADMIN))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
err = -EINVAL;
|
|
|
|
/* To and From paths should be mount roots */
|
|
|
|
if (from_path->dentry != from_path->mnt->mnt_root)
|
|
|
|
goto out;
|
|
|
|
if (to_path->dentry != to_path->mnt->mnt_root)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* Setting sharing groups is only allowed across same superblock */
|
|
|
|
if (from->mnt.mnt_sb != to->mnt.mnt_sb)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* From mount root should be wider than To mount root */
|
|
|
|
if (!is_subdir(to->mnt.mnt_root, from->mnt.mnt_root))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* From mount should not have locked children in place of To's root */
|
|
|
|
if (has_locked_children(from, to->mnt.mnt_root))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* Setting sharing groups is only allowed on private mounts */
|
|
|
|
if (IS_MNT_SHARED(to) || IS_MNT_SLAVE(to))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* From should not be private */
|
|
|
|
if (!IS_MNT_SHARED(from) && !IS_MNT_SLAVE(from))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (IS_MNT_SLAVE(from)) {
|
|
|
|
struct mount *m = from->mnt_master;
|
|
|
|
|
|
|
|
list_add(&to->mnt_slave, &m->mnt_slave_list);
|
|
|
|
to->mnt_master = m;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (IS_MNT_SHARED(from)) {
|
|
|
|
to->mnt_group_id = from->mnt_group_id;
|
|
|
|
list_add(&to->mnt_share, &from->mnt_share);
|
|
|
|
lock_mount_hash();
|
|
|
|
set_mnt_shared(to);
|
|
|
|
unlock_mount_hash();
|
|
|
|
}
|
|
|
|
|
|
|
|
err = 0;
|
|
|
|
out:
|
|
|
|
namespace_unlock();
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2018-11-05 20:40:30 +03:00
|
|
|
static int do_move_mount(struct path *old_path, struct path *new_path)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2018-11-05 20:40:31 +03:00
|
|
|
struct mnt_namespace *ns;
|
2011-11-25 06:47:05 +04:00
|
|
|
struct mount *p;
|
2011-11-25 04:59:16 +04:00
|
|
|
struct mount *old;
|
2019-07-01 02:18:53 +03:00
|
|
|
struct mount *parent;
|
|
|
|
struct mountpoint *mp, *old_mp;
|
2013-02-23 07:49:10 +04:00
|
|
|
int err;
|
2018-11-05 20:40:31 +03:00
|
|
|
bool attached;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2018-11-05 20:40:30 +03:00
|
|
|
mp = lock_mount(new_path);
|
2013-03-15 18:53:28 +04:00
|
|
|
if (IS_ERR(mp))
|
2018-11-05 20:40:30 +03:00
|
|
|
return PTR_ERR(mp);
|
Add a dentry op to allow processes to be held during pathwalk transit
Add a dentry op (d_manage) to permit a filesystem to hold a process and make it
sleep when it tries to transit away from one of that filesystem's directories
during a pathwalk. The operation is keyed off a new dentry flag
(DCACHE_MANAGE_TRANSIT).
The filesystem is allowed to be selective about which processes it holds and
which it permits to continue on or prohibits from transiting from each flagged
directory. This will allow autofs to hold up client processes whilst letting
its userspace daemon through to maintain the directory or the stuff behind it
or mounted upon it.
The ->d_manage() dentry operation:
int (*d_manage)(struct path *path, bool mounting_here);
takes a pointer to the directory about to be transited away from and a flag
indicating whether the transit is undertaken by do_add_mount() or
do_move_mount() skipping through a pile of filesystems mounted on a mountpoint.
It should return 0 if successful and to let the process continue on its way;
-EISDIR to prohibit the caller from skipping to overmounted filesystems or
automounting, and to use this directory; or some other error code to return to
the user.
->d_manage() is called with namespace_sem writelocked if mounting_here is true
and no other locks held, so it may sleep. However, if mounting_here is true,
it may not initiate or wait for a mount or unmount upon the parameter
directory, even if the act is actually performed by userspace.
Within fs/namei.c, follow_managed() is extended to check with d_manage() first
on each managed directory, before transiting away from it or attempting to
automount upon it.
follow_down() is renamed follow_down_one() and should only be used where the
filesystem deliberately intends to avoid management steps (e.g. autofs).
A new follow_down() is added that incorporates the loop done by all other
callers of follow_down() (do_add/move_mount(), autofs and NFSD; whilst AFS, NFS
and CIFS do use it, their use is removed by converting them to use
d_automount()). The new follow_down() calls d_manage() as appropriate. It
also takes an extra parameter to indicate if it is being called from mount code
(with namespace_sem writelocked) which it passes to d_manage(). follow_down()
ignores automount points so that it can be used to mount on them.
__follow_mount_rcu() is made to abort rcu-walk mode if it hits a directory with
DCACHE_MANAGE_TRANSIT set on the basis that we're probably going to have to
sleep. It would be possible to enter d_manage() in rcu-walk mode too, and have
that determine whether to abort or not itself. That would allow the autofs
daemon to continue on in rcu-walk mode.
Note that DCACHE_MANAGE_TRANSIT on a directory should be cleared when it isn't
required as every tranist from that directory will cause d_manage() to be
invoked. It can always be set again when necessary.
==========================
WHAT THIS MEANS FOR AUTOFS
==========================
Autofs currently uses the lookup() inode op and the d_revalidate() dentry op to
trigger the automounting of indirect mounts, and both of these can be called
with i_mutex held.
autofs knows that the i_mutex will be held by the caller in lookup(), and so
can drop it before invoking the daemon - but this isn't so for d_revalidate(),
since the lock is only held on _some_ of the code paths that call it. This
means that autofs can't risk dropping i_mutex from its d_revalidate() function
before it calls the daemon.
The bug could manifest itself as, for example, a process that's trying to
validate an automount dentry that gets made to wait because that dentry is
expired and needs cleaning up:
mkdir S ffffffff8014e05a 0 32580 24956
Call Trace:
[<ffffffff885371fd>] :autofs4:autofs4_wait+0x674/0x897
[<ffffffff80127f7d>] avc_has_perm+0x46/0x58
[<ffffffff8009fdcf>] autoremove_wake_function+0x0/0x2e
[<ffffffff88537be6>] :autofs4:autofs4_expire_wait+0x41/0x6b
[<ffffffff88535cfc>] :autofs4:autofs4_revalidate+0x91/0x149
[<ffffffff80036d96>] __lookup_hash+0xa0/0x12f
[<ffffffff80057a2f>] lookup_create+0x46/0x80
[<ffffffff800e6e31>] sys_mkdirat+0x56/0xe4
versus the automount daemon which wants to remove that dentry, but can't
because the normal process is holding the i_mutex lock:
automount D ffffffff8014e05a 0 32581 1 32561
Call Trace:
[<ffffffff80063c3f>] __mutex_lock_slowpath+0x60/0x9b
[<ffffffff8000ccf1>] do_path_lookup+0x2ca/0x2f1
[<ffffffff80063c89>] .text.lock.mutex+0xf/0x14
[<ffffffff800e6d55>] do_rmdir+0x77/0xde
[<ffffffff8005d229>] tracesys+0x71/0xe0
[<ffffffff8005d28d>] tracesys+0xd5/0xe0
which means that the system is deadlocked.
This patch allows autofs to hold up normal processes whilst the daemon goes
ahead and does things to the dentry tree behind the automouter point without
risking a deadlock as almost no locks are held in d_manage() and none in
d_automount().
Signed-off-by: David Howells <dhowells@redhat.com>
Was-Acked-by: Ian Kent <raven@themaw.net>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2011-01-14 21:45:26 +03:00
|
|
|
|
2018-11-05 20:40:30 +03:00
|
|
|
old = real_mount(old_path->mnt);
|
|
|
|
p = real_mount(new_path->mnt);
|
2019-07-01 02:18:53 +03:00
|
|
|
parent = old->mnt_parent;
|
2018-11-05 20:40:31 +03:00
|
|
|
attached = mnt_has_parent(old);
|
2019-07-01 02:18:53 +03:00
|
|
|
old_mp = old->mnt_mp;
|
2018-11-05 20:40:31 +03:00
|
|
|
ns = old->mnt_ns;
|
2011-11-25 09:46:35 +04:00
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
err = -EINVAL;
|
2018-11-05 20:40:31 +03:00
|
|
|
/* The mountpoint must be in our namespace. */
|
|
|
|
if (!check_mnt(p))
|
2018-11-05 20:40:30 +03:00
|
|
|
goto out;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2019-06-29 23:27:44 +03:00
|
|
|
/* The thing moved must be mounted... */
|
|
|
|
if (!is_mounted(&old->mnt))
|
2018-11-05 20:40:31 +03:00
|
|
|
goto out;
|
|
|
|
|
2019-06-29 23:27:44 +03:00
|
|
|
/* ... and either ours or the root of anon namespace */
|
|
|
|
if (!(attached ? check_mnt(old) : is_anon_ns(ns)))
|
2018-11-05 20:40:30 +03:00
|
|
|
goto out;
|
2013-03-30 08:04:39 +04:00
|
|
|
|
2018-11-05 20:40:30 +03:00
|
|
|
if (old->mnt.mnt_flags & MNT_LOCKED)
|
|
|
|
goto out;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2018-11-05 20:40:30 +03:00
|
|
|
if (old_path->dentry != old_path->mnt->mnt_root)
|
|
|
|
goto out;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2018-11-05 20:40:30 +03:00
|
|
|
if (d_is_dir(new_path->dentry) !=
|
|
|
|
d_is_dir(old_path->dentry))
|
|
|
|
goto out;
|
2005-11-08 01:20:03 +03:00
|
|
|
/*
|
|
|
|
* Don't move a mount residing in a shared parent.
|
|
|
|
*/
|
2019-07-01 02:18:53 +03:00
|
|
|
if (attached && IS_MNT_SHARED(parent))
|
2018-11-05 20:40:30 +03:00
|
|
|
goto out;
|
2005-11-08 01:21:20 +03:00
|
|
|
/*
|
|
|
|
* Don't move a mount tree containing unbindable mounts to a destination
|
|
|
|
* mount which is shared.
|
|
|
|
*/
|
2011-11-25 10:05:37 +04:00
|
|
|
if (IS_MNT_SHARED(p) && tree_contains_unbindable(old))
|
2018-11-05 20:40:30 +03:00
|
|
|
goto out;
|
2005-04-17 02:20:36 +04:00
|
|
|
err = -ELOOP;
|
2018-11-05 20:40:31 +03:00
|
|
|
if (!check_for_nsfs_mounts(old))
|
|
|
|
goto out;
|
2011-11-25 10:05:37 +04:00
|
|
|
for (; mnt_has_parent(p); p = p->mnt_parent)
|
2011-11-25 06:47:05 +04:00
|
|
|
if (p == old)
|
2018-11-05 20:40:30 +03:00
|
|
|
goto out;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2018-11-05 20:40:30 +03:00
|
|
|
err = attach_recursive_mnt(old, real_mount(new_path->mnt), mp,
|
2019-07-01 02:18:53 +03:00
|
|
|
attached);
|
2008-02-15 06:34:32 +03:00
|
|
|
if (err)
|
2018-11-05 20:40:30 +03:00
|
|
|
goto out;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
/* if the mount is moved, it should no longer be expire
|
|
|
|
* automatically */
|
2011-11-25 09:22:05 +04:00
|
|
|
list_del_init(&old->mnt_expire);
|
2019-07-01 02:18:53 +03:00
|
|
|
if (attached)
|
|
|
|
put_mountpoint(old_mp);
|
2005-04-17 02:20:36 +04:00
|
|
|
out:
|
2018-11-05 20:40:30 +03:00
|
|
|
unlock_mount(mp);
|
2018-11-05 20:40:31 +03:00
|
|
|
if (!err) {
|
2019-07-01 02:18:53 +03:00
|
|
|
if (attached)
|
|
|
|
mntput_no_expire(parent);
|
|
|
|
else
|
2018-11-05 20:40:31 +03:00
|
|
|
free_mnt_ns(ns);
|
|
|
|
}
|
2018-11-05 20:40:30 +03:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int do_move_mount_old(struct path *path, const char *old_name)
|
|
|
|
{
|
|
|
|
struct path old_path;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (!old_name || !*old_name)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
err = kern_path(old_name, LOOKUP_FOLLOW, &old_path);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
err = do_move_mount(&old_path, path);
|
2008-08-02 08:51:11 +04:00
|
|
|
path_put(&old_path);
|
2005-04-17 02:20:36 +04:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2011-03-18 05:08:28 +03:00
|
|
|
/*
|
|
|
|
* add a mount into a namespace's mount tree
|
|
|
|
*/
|
2020-01-11 18:14:09 +03:00
|
|
|
static int do_add_mount(struct mount *newmnt, struct mountpoint *mp,
|
2021-06-19 03:27:57 +03:00
|
|
|
const struct path *path, int mnt_flags)
|
2011-03-18 05:08:28 +03:00
|
|
|
{
|
2020-01-11 18:14:09 +03:00
|
|
|
struct mount *parent = real_mount(path->mnt);
|
2011-03-18 05:08:28 +03:00
|
|
|
|
smarter propagate_mnt()
The current mainline has copies propagated to *all* nodes, then
tears down the copies we made for nodes that do not contain
counterparts of the desired mountpoint. That sets the right
propagation graph for the copies (at teardown time we move
the slaves of removed node to a surviving peer or directly
to master), but we end up paying a fairly steep price in
useless allocations. It's fairly easy to create a situation
where N calls of mount(2) create exactly N bindings, with
O(N^2) vfsmounts allocated and freed in process.
Fortunately, it is possible to avoid those allocations/freeings.
The trick is to create copies in the right order and find which
one would've eventually become a master with the current algorithm.
It turns out to be possible in O(nodes getting propagation) time
and with no extra allocations at all.
One part is that we need to make sure that eventual master will be
created before its slaves, so we need to walk the propagation
tree in a different order - by peer groups. And iterate through
the peers before dealing with the next group.
Another thing is finding the (earlier) copy that will be a master
of one we are about to create; to do that we are (temporary) marking
the masters of mountpoints we are attaching the copies to.
Either we are in a peer of the last mountpoint we'd dealt with,
or we have the following situation: we are attaching to mountpoint M,
the last copy S_0 had been attached to M_0 and there are sequences
S_0...S_n, M_0...M_n such that S_{i+1} is a master of S_{i},
S_{i} mounted on M{i} and we need to create a slave of the first S_{k}
such that M is getting propagation from M_{k}. It means that the master
of M_{k} will be among the sequence of masters of M. On the
other hand, the nearest marked node in that sequence will either
be the master of M_{k} or the master of M_{k-1} (the latter -
in the case if M_{k-1} is a slave of something M gets propagation
from, but in a wrong peer group).
So we go through the sequence of masters of M until we find
a marked one (P). Let N be the one before it. Then we go through
the sequence of masters of S_0 until we find one (say, S) mounted
on a node D that has P as master and check if D is a peer of N.
If it is, S will be the master of new copy, if not - the master of S
will be.
That's it for the hard part; the rest is fairly simple. Iterator
is in next_group(), handling of one prospective mountpoint is
propagate_one().
It seems to survive all tests and gives a noticably better performance
than the current mainline for setups that are seriously using shared
subtrees.
Cc: stable@vger.kernel.org
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2014-02-27 18:35:45 +04:00
|
|
|
mnt_flags &= ~MNT_INTERNAL_FLAGS;
|
2011-03-18 05:08:28 +03:00
|
|
|
|
2013-03-15 18:53:28 +04:00
|
|
|
if (unlikely(!check_mnt(parent))) {
|
2012-09-21 16:19:02 +04:00
|
|
|
/* that's acceptable only for automounts done in private ns */
|
|
|
|
if (!(mnt_flags & MNT_SHRINKABLE))
|
2020-01-11 18:14:09 +03:00
|
|
|
return -EINVAL;
|
2012-09-21 16:19:02 +04:00
|
|
|
/* ... and for those we'd better have mountpoint still alive */
|
2013-03-15 18:53:28 +04:00
|
|
|
if (!parent->mnt_ns)
|
2020-01-11 18:14:09 +03:00
|
|
|
return -EINVAL;
|
2012-09-21 16:19:02 +04:00
|
|
|
}
|
2011-03-18 05:08:28 +03:00
|
|
|
|
|
|
|
/* Refuse the same filesystem on the same mount point */
|
2011-11-25 09:30:56 +04:00
|
|
|
if (path->mnt->mnt_sb == newmnt->mnt.mnt_sb &&
|
2011-03-18 05:08:28 +03:00
|
|
|
path->mnt->mnt_root == path->dentry)
|
2020-01-11 18:14:09 +03:00
|
|
|
return -EBUSY;
|
2011-03-18 05:08:28 +03:00
|
|
|
|
VFS: (Scripted) Convert S_ISLNK/DIR/REG(dentry->d_inode) to d_is_*(dentry)
Convert the following where appropriate:
(1) S_ISLNK(dentry->d_inode) to d_is_symlink(dentry).
(2) S_ISREG(dentry->d_inode) to d_is_reg(dentry).
(3) S_ISDIR(dentry->d_inode) to d_is_dir(dentry). This is actually more
complicated than it appears as some calls should be converted to
d_can_lookup() instead. The difference is whether the directory in
question is a real dir with a ->lookup op or whether it's a fake dir with
a ->d_automount op.
In some circumstances, we can subsume checks for dentry->d_inode not being
NULL into this, provided we the code isn't in a filesystem that expects
d_inode to be NULL if the dirent really *is* negative (ie. if we're going to
use d_inode() rather than d_backing_inode() to get the inode pointer).
Note that the dentry type field may be set to something other than
DCACHE_MISS_TYPE when d_inode is NULL in the case of unionmount, where the VFS
manages the fall-through from a negative dentry to a lower layer. In such a
case, the dentry type of the negative union dentry is set to the same as the
type of the lower dentry.
However, if you know d_inode is not NULL at the call site, then you can use
the d_is_xxx() functions even in a filesystem.
There is one further complication: a 0,0 chardev dentry may be labelled
DCACHE_WHITEOUT_TYPE rather than DCACHE_SPECIAL_TYPE. Strictly, this was
intended for special directory entry types that don't have attached inodes.
The following perl+coccinelle script was used:
use strict;
my @callers;
open($fd, 'git grep -l \'S_IS[A-Z].*->d_inode\' |') ||
die "Can't grep for S_ISDIR and co. callers";
@callers = <$fd>;
close($fd);
unless (@callers) {
print "No matches\n";
exit(0);
}
my @cocci = (
'@@',
'expression E;',
'@@',
'',
'- S_ISLNK(E->d_inode->i_mode)',
'+ d_is_symlink(E)',
'',
'@@',
'expression E;',
'@@',
'',
'- S_ISDIR(E->d_inode->i_mode)',
'+ d_is_dir(E)',
'',
'@@',
'expression E;',
'@@',
'',
'- S_ISREG(E->d_inode->i_mode)',
'+ d_is_reg(E)' );
my $coccifile = "tmp.sp.cocci";
open($fd, ">$coccifile") || die $coccifile;
print($fd "$_\n") || die $coccifile foreach (@cocci);
close($fd);
foreach my $file (@callers) {
chomp $file;
print "Processing ", $file, "\n";
system("spatch", "--sp-file", $coccifile, $file, "--in-place", "--no-show-diff") == 0 ||
die "spatch failed";
}
[AV: overlayfs parts skipped]
Signed-off-by: David Howells <dhowells@redhat.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2015-01-29 15:02:35 +03:00
|
|
|
if (d_is_symlink(newmnt->mnt.mnt_root))
|
2020-01-11 18:14:09 +03:00
|
|
|
return -EINVAL;
|
2011-03-18 05:08:28 +03:00
|
|
|
|
2011-11-25 09:30:56 +04:00
|
|
|
newmnt->mnt.mnt_flags = mnt_flags;
|
2020-01-11 18:14:09 +03:00
|
|
|
return graft_tree(newmnt, parent, mp);
|
2011-03-18 05:08:28 +03:00
|
|
|
}
|
2011-01-17 09:47:59 +03:00
|
|
|
|
2018-11-04 15:43:08 +03:00
|
|
|
static bool mount_too_revealing(const struct super_block *sb, 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_fc(struct fs_context *fc, struct path *mountpoint,
|
|
|
|
unsigned int mnt_flags)
|
|
|
|
{
|
|
|
|
struct vfsmount *mnt;
|
2020-01-11 18:14:09 +03:00
|
|
|
struct mountpoint *mp;
|
2018-11-04 15:43:08 +03:00
|
|
|
struct super_block *sb = fc->root->d_sb;
|
|
|
|
int error;
|
|
|
|
|
2018-12-20 23:04:50 +03:00
|
|
|
error = security_sb_kern_mount(sb);
|
|
|
|
if (!error && mount_too_revealing(sb, &mnt_flags))
|
|
|
|
error = -EPERM;
|
|
|
|
|
|
|
|
if (unlikely(error)) {
|
|
|
|
fc_drop_locked(fc);
|
|
|
|
return error;
|
2018-11-04 15:43:08 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
up_write(&sb->s_umount);
|
|
|
|
|
|
|
|
mnt = vfs_create_mount(fc);
|
|
|
|
if (IS_ERR(mnt))
|
|
|
|
return PTR_ERR(mnt);
|
|
|
|
|
2019-04-16 00:17:12 +03:00
|
|
|
mnt_warn_timestamp_expiry(mountpoint, mnt);
|
|
|
|
|
2020-01-11 18:14:09 +03:00
|
|
|
mp = lock_mount(mountpoint);
|
|
|
|
if (IS_ERR(mp)) {
|
|
|
|
mntput(mnt);
|
|
|
|
return PTR_ERR(mp);
|
|
|
|
}
|
|
|
|
error = do_add_mount(real_mount(mnt), mp, mountpoint, mnt_flags);
|
|
|
|
unlock_mount(mp);
|
2019-10-17 05:48:14 +03:00
|
|
|
if (error < 0)
|
|
|
|
mntput(mnt);
|
2018-11-04 15:43:08 +03:00
|
|
|
return error;
|
|
|
|
}
|
2015-05-09 07:22:29 +03:00
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/*
|
|
|
|
* create a new mount for userspace and request it to be added into the
|
|
|
|
* namespace's tree
|
|
|
|
*/
|
2017-07-17 10:45:35 +03:00
|
|
|
static int do_new_mount(struct path *path, const char *fstype, int sb_flags,
|
2012-10-11 19:42:01 +04:00
|
|
|
int mnt_flags, const char *name, void *data)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2012-07-27 08:42:03 +04:00
|
|
|
struct file_system_type *type;
|
2018-11-04 15:18:51 +03:00
|
|
|
struct fs_context *fc;
|
|
|
|
const char *subtype = NULL;
|
|
|
|
int err = 0;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2012-07-27 08:42:03 +04:00
|
|
|
if (!fstype)
|
2005-04-17 02:20:36 +04:00
|
|
|
return -EINVAL;
|
|
|
|
|
2012-07-27 08:42:03 +04:00
|
|
|
type = get_fs_type(fstype);
|
|
|
|
if (!type)
|
|
|
|
return -ENODEV;
|
|
|
|
|
2018-11-04 15:18:51 +03:00
|
|
|
if (type->fs_flags & FS_HAS_SUBTYPE) {
|
|
|
|
subtype = strchr(fstype, '.');
|
|
|
|
if (subtype) {
|
|
|
|
subtype++;
|
|
|
|
if (!*subtype) {
|
|
|
|
put_filesystem(type);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2012-07-27 08:42:03 +04:00
|
|
|
|
2018-11-04 15:18:51 +03:00
|
|
|
fc = fs_context_for_mount(type, sb_flags);
|
2012-07-27 08:42:03 +04:00
|
|
|
put_filesystem(type);
|
2018-11-04 15:18:51 +03:00
|
|
|
if (IS_ERR(fc))
|
|
|
|
return PTR_ERR(fc);
|
|
|
|
|
2018-11-02 02:07:25 +03:00
|
|
|
if (subtype)
|
|
|
|
err = vfs_parse_fs_string(fc, "subtype",
|
|
|
|
subtype, strlen(subtype));
|
|
|
|
if (!err && name)
|
|
|
|
err = vfs_parse_fs_string(fc, "source", name, strlen(name));
|
2018-11-04 15:18:51 +03:00
|
|
|
if (!err)
|
|
|
|
err = parse_monolithic_mount_data(fc, data);
|
2019-05-13 19:57:22 +03:00
|
|
|
if (!err && !mount_capable(fc))
|
|
|
|
err = -EPERM;
|
2018-11-04 15:18:51 +03:00
|
|
|
if (!err)
|
|
|
|
err = vfs_get_tree(fc);
|
2018-11-04 15:43:08 +03:00
|
|
|
if (!err)
|
|
|
|
err = do_new_mount_fc(fc, path, mnt_flags);
|
2016-06-10 00:06:06 +03:00
|
|
|
|
2018-11-04 15:18:51 +03:00
|
|
|
put_fs_context(fc);
|
2011-01-17 09:41:58 +03:00
|
|
|
return err;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2021-06-19 03:27:57 +03:00
|
|
|
int finish_automount(struct vfsmount *m, const struct path *path)
|
2011-01-17 09:35:23 +03:00
|
|
|
{
|
fix automount/automount race properly
Protection against automount/automount races (two threads hitting the same
referral point at the same time) is based upon do_add_mount() prevention of
identical overmounts - trying to overmount the root of mounted tree with
the same tree fails with -EBUSY. It's unreliable (the other thread might've
mounted something on top of the automount it has triggered) *and* causes
no end of headache for follow_automount() and its caller, since
finish_automount() behaves like do_new_mount() - if the mountpoint to be is
overmounted, it mounts on top what's overmounting it. It's not only wrong
(we want to go into what's overmounting the automount point and quietly
discard what we planned to mount there), it introduces the possibility of
original parent mount getting dropped. That's what 8aef18845266 (VFS: Fix
vfsmount overput on simultaneous automount) deals with, but it can't do
anything about the reliability of conflict detection - if something had
been overmounted the other thread's automount (e.g. that other thread
having stepped into automount in mount(2)), we don't get that -EBUSY and
the result is
referral point under automounted NFS under explicit overmount
under another copy of automounted NFS
What we need is finish_automount() *NOT* digging into overmounts - if it
finds one, it should just quietly discard the thing it was asked to mount.
And don't bother with actually crossing into the results of finish_automount() -
the same loop that calls follow_automount() will do that just fine on the
next iteration.
IOW, instead of calling lock_mount() have finish_automount() do it manually,
_without_ the "move into overmount and retry" part. And leave crossing into
the results to the caller of follow_automount(), which simplifies it a lot.
Moral: if you end up with a lot of glue working around the calling conventions
of something, perhaps these calling conventions are simply wrong...
Fixes: 8aef18845266 (VFS: Fix vfsmount overput on simultaneous automount)
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2020-01-11 18:44:29 +03:00
|
|
|
struct dentry *dentry = path->dentry;
|
2020-01-11 18:14:09 +03:00
|
|
|
struct mountpoint *mp;
|
2020-01-11 19:27:46 +03:00
|
|
|
struct mount *mnt;
|
2011-01-17 09:35:23 +03:00
|
|
|
int err;
|
2020-01-11 19:27:46 +03:00
|
|
|
|
|
|
|
if (!m)
|
|
|
|
return 0;
|
|
|
|
if (IS_ERR(m))
|
|
|
|
return PTR_ERR(m);
|
|
|
|
|
|
|
|
mnt = real_mount(m);
|
2011-01-17 09:35:23 +03:00
|
|
|
/* The new mount record should have at least 2 refs to prevent it being
|
|
|
|
* expired before we get a chance to add it
|
|
|
|
*/
|
2011-11-25 09:22:05 +04:00
|
|
|
BUG_ON(mnt_get_count(mnt) < 2);
|
2011-01-17 09:35:23 +03:00
|
|
|
|
|
|
|
if (m->mnt_sb == path->mnt->mnt_sb &&
|
fix automount/automount race properly
Protection against automount/automount races (two threads hitting the same
referral point at the same time) is based upon do_add_mount() prevention of
identical overmounts - trying to overmount the root of mounted tree with
the same tree fails with -EBUSY. It's unreliable (the other thread might've
mounted something on top of the automount it has triggered) *and* causes
no end of headache for follow_automount() and its caller, since
finish_automount() behaves like do_new_mount() - if the mountpoint to be is
overmounted, it mounts on top what's overmounting it. It's not only wrong
(we want to go into what's overmounting the automount point and quietly
discard what we planned to mount there), it introduces the possibility of
original parent mount getting dropped. That's what 8aef18845266 (VFS: Fix
vfsmount overput on simultaneous automount) deals with, but it can't do
anything about the reliability of conflict detection - if something had
been overmounted the other thread's automount (e.g. that other thread
having stepped into automount in mount(2)), we don't get that -EBUSY and
the result is
referral point under automounted NFS under explicit overmount
under another copy of automounted NFS
What we need is finish_automount() *NOT* digging into overmounts - if it
finds one, it should just quietly discard the thing it was asked to mount.
And don't bother with actually crossing into the results of finish_automount() -
the same loop that calls follow_automount() will do that just fine on the
next iteration.
IOW, instead of calling lock_mount() have finish_automount() do it manually,
_without_ the "move into overmount and retry" part. And leave crossing into
the results to the caller of follow_automount(), which simplifies it a lot.
Moral: if you end up with a lot of glue working around the calling conventions
of something, perhaps these calling conventions are simply wrong...
Fixes: 8aef18845266 (VFS: Fix vfsmount overput on simultaneous automount)
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2020-01-11 18:44:29 +03:00
|
|
|
m->mnt_root == dentry) {
|
2011-01-17 09:47:59 +03:00
|
|
|
err = -ELOOP;
|
fix automount/automount race properly
Protection against automount/automount races (two threads hitting the same
referral point at the same time) is based upon do_add_mount() prevention of
identical overmounts - trying to overmount the root of mounted tree with
the same tree fails with -EBUSY. It's unreliable (the other thread might've
mounted something on top of the automount it has triggered) *and* causes
no end of headache for follow_automount() and its caller, since
finish_automount() behaves like do_new_mount() - if the mountpoint to be is
overmounted, it mounts on top what's overmounting it. It's not only wrong
(we want to go into what's overmounting the automount point and quietly
discard what we planned to mount there), it introduces the possibility of
original parent mount getting dropped. That's what 8aef18845266 (VFS: Fix
vfsmount overput on simultaneous automount) deals with, but it can't do
anything about the reliability of conflict detection - if something had
been overmounted the other thread's automount (e.g. that other thread
having stepped into automount in mount(2)), we don't get that -EBUSY and
the result is
referral point under automounted NFS under explicit overmount
under another copy of automounted NFS
What we need is finish_automount() *NOT* digging into overmounts - if it
finds one, it should just quietly discard the thing it was asked to mount.
And don't bother with actually crossing into the results of finish_automount() -
the same loop that calls follow_automount() will do that just fine on the
next iteration.
IOW, instead of calling lock_mount() have finish_automount() do it manually,
_without_ the "move into overmount and retry" part. And leave crossing into
the results to the caller of follow_automount(), which simplifies it a lot.
Moral: if you end up with a lot of glue working around the calling conventions
of something, perhaps these calling conventions are simply wrong...
Fixes: 8aef18845266 (VFS: Fix vfsmount overput on simultaneous automount)
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2020-01-11 18:44:29 +03:00
|
|
|
goto discard;
|
2011-01-17 09:35:23 +03:00
|
|
|
}
|
|
|
|
|
fix automount/automount race properly
Protection against automount/automount races (two threads hitting the same
referral point at the same time) is based upon do_add_mount() prevention of
identical overmounts - trying to overmount the root of mounted tree with
the same tree fails with -EBUSY. It's unreliable (the other thread might've
mounted something on top of the automount it has triggered) *and* causes
no end of headache for follow_automount() and its caller, since
finish_automount() behaves like do_new_mount() - if the mountpoint to be is
overmounted, it mounts on top what's overmounting it. It's not only wrong
(we want to go into what's overmounting the automount point and quietly
discard what we planned to mount there), it introduces the possibility of
original parent mount getting dropped. That's what 8aef18845266 (VFS: Fix
vfsmount overput on simultaneous automount) deals with, but it can't do
anything about the reliability of conflict detection - if something had
been overmounted the other thread's automount (e.g. that other thread
having stepped into automount in mount(2)), we don't get that -EBUSY and
the result is
referral point under automounted NFS under explicit overmount
under another copy of automounted NFS
What we need is finish_automount() *NOT* digging into overmounts - if it
finds one, it should just quietly discard the thing it was asked to mount.
And don't bother with actually crossing into the results of finish_automount() -
the same loop that calls follow_automount() will do that just fine on the
next iteration.
IOW, instead of calling lock_mount() have finish_automount() do it manually,
_without_ the "move into overmount and retry" part. And leave crossing into
the results to the caller of follow_automount(), which simplifies it a lot.
Moral: if you end up with a lot of glue working around the calling conventions
of something, perhaps these calling conventions are simply wrong...
Fixes: 8aef18845266 (VFS: Fix vfsmount overput on simultaneous automount)
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2020-01-11 18:44:29 +03:00
|
|
|
/*
|
|
|
|
* we don't want to use lock_mount() - in this case finding something
|
|
|
|
* that overmounts our mountpoint to be means "quitely drop what we've
|
|
|
|
* got", not "try to mount it on top".
|
|
|
|
*/
|
|
|
|
inode_lock(dentry->d_inode);
|
|
|
|
namespace_lock();
|
|
|
|
if (unlikely(cant_mount(dentry))) {
|
|
|
|
err = -ENOENT;
|
|
|
|
goto discard_locked;
|
|
|
|
}
|
|
|
|
rcu_read_lock();
|
|
|
|
if (unlikely(__lookup_mnt(path->mnt, dentry))) {
|
|
|
|
rcu_read_unlock();
|
|
|
|
err = 0;
|
|
|
|
goto discard_locked;
|
|
|
|
}
|
|
|
|
rcu_read_unlock();
|
|
|
|
mp = get_mountpoint(dentry);
|
2020-01-11 18:14:09 +03:00
|
|
|
if (IS_ERR(mp)) {
|
|
|
|
err = PTR_ERR(mp);
|
fix automount/automount race properly
Protection against automount/automount races (two threads hitting the same
referral point at the same time) is based upon do_add_mount() prevention of
identical overmounts - trying to overmount the root of mounted tree with
the same tree fails with -EBUSY. It's unreliable (the other thread might've
mounted something on top of the automount it has triggered) *and* causes
no end of headache for follow_automount() and its caller, since
finish_automount() behaves like do_new_mount() - if the mountpoint to be is
overmounted, it mounts on top what's overmounting it. It's not only wrong
(we want to go into what's overmounting the automount point and quietly
discard what we planned to mount there), it introduces the possibility of
original parent mount getting dropped. That's what 8aef18845266 (VFS: Fix
vfsmount overput on simultaneous automount) deals with, but it can't do
anything about the reliability of conflict detection - if something had
been overmounted the other thread's automount (e.g. that other thread
having stepped into automount in mount(2)), we don't get that -EBUSY and
the result is
referral point under automounted NFS under explicit overmount
under another copy of automounted NFS
What we need is finish_automount() *NOT* digging into overmounts - if it
finds one, it should just quietly discard the thing it was asked to mount.
And don't bother with actually crossing into the results of finish_automount() -
the same loop that calls follow_automount() will do that just fine on the
next iteration.
IOW, instead of calling lock_mount() have finish_automount() do it manually,
_without_ the "move into overmount and retry" part. And leave crossing into
the results to the caller of follow_automount(), which simplifies it a lot.
Moral: if you end up with a lot of glue working around the calling conventions
of something, perhaps these calling conventions are simply wrong...
Fixes: 8aef18845266 (VFS: Fix vfsmount overput on simultaneous automount)
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2020-01-11 18:44:29 +03:00
|
|
|
goto discard_locked;
|
2020-01-11 18:14:09 +03:00
|
|
|
}
|
fix automount/automount race properly
Protection against automount/automount races (two threads hitting the same
referral point at the same time) is based upon do_add_mount() prevention of
identical overmounts - trying to overmount the root of mounted tree with
the same tree fails with -EBUSY. It's unreliable (the other thread might've
mounted something on top of the automount it has triggered) *and* causes
no end of headache for follow_automount() and its caller, since
finish_automount() behaves like do_new_mount() - if the mountpoint to be is
overmounted, it mounts on top what's overmounting it. It's not only wrong
(we want to go into what's overmounting the automount point and quietly
discard what we planned to mount there), it introduces the possibility of
original parent mount getting dropped. That's what 8aef18845266 (VFS: Fix
vfsmount overput on simultaneous automount) deals with, but it can't do
anything about the reliability of conflict detection - if something had
been overmounted the other thread's automount (e.g. that other thread
having stepped into automount in mount(2)), we don't get that -EBUSY and
the result is
referral point under automounted NFS under explicit overmount
under another copy of automounted NFS
What we need is finish_automount() *NOT* digging into overmounts - if it
finds one, it should just quietly discard the thing it was asked to mount.
And don't bother with actually crossing into the results of finish_automount() -
the same loop that calls follow_automount() will do that just fine on the
next iteration.
IOW, instead of calling lock_mount() have finish_automount() do it manually,
_without_ the "move into overmount and retry" part. And leave crossing into
the results to the caller of follow_automount(), which simplifies it a lot.
Moral: if you end up with a lot of glue working around the calling conventions
of something, perhaps these calling conventions are simply wrong...
Fixes: 8aef18845266 (VFS: Fix vfsmount overput on simultaneous automount)
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2020-01-11 18:44:29 +03:00
|
|
|
|
2020-01-11 18:14:09 +03:00
|
|
|
err = do_add_mount(mnt, mp, path, path->mnt->mnt_flags | MNT_SHRINKABLE);
|
|
|
|
unlock_mount(mp);
|
fix automount/automount race properly
Protection against automount/automount races (two threads hitting the same
referral point at the same time) is based upon do_add_mount() prevention of
identical overmounts - trying to overmount the root of mounted tree with
the same tree fails with -EBUSY. It's unreliable (the other thread might've
mounted something on top of the automount it has triggered) *and* causes
no end of headache for follow_automount() and its caller, since
finish_automount() behaves like do_new_mount() - if the mountpoint to be is
overmounted, it mounts on top what's overmounting it. It's not only wrong
(we want to go into what's overmounting the automount point and quietly
discard what we planned to mount there), it introduces the possibility of
original parent mount getting dropped. That's what 8aef18845266 (VFS: Fix
vfsmount overput on simultaneous automount) deals with, but it can't do
anything about the reliability of conflict detection - if something had
been overmounted the other thread's automount (e.g. that other thread
having stepped into automount in mount(2)), we don't get that -EBUSY and
the result is
referral point under automounted NFS under explicit overmount
under another copy of automounted NFS
What we need is finish_automount() *NOT* digging into overmounts - if it
finds one, it should just quietly discard the thing it was asked to mount.
And don't bother with actually crossing into the results of finish_automount() -
the same loop that calls follow_automount() will do that just fine on the
next iteration.
IOW, instead of calling lock_mount() have finish_automount() do it manually,
_without_ the "move into overmount and retry" part. And leave crossing into
the results to the caller of follow_automount(), which simplifies it a lot.
Moral: if you end up with a lot of glue working around the calling conventions
of something, perhaps these calling conventions are simply wrong...
Fixes: 8aef18845266 (VFS: Fix vfsmount overput on simultaneous automount)
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2020-01-11 18:44:29 +03:00
|
|
|
if (unlikely(err))
|
|
|
|
goto discard;
|
|
|
|
mntput(m);
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
discard_locked:
|
|
|
|
namespace_unlock();
|
|
|
|
inode_unlock(dentry->d_inode);
|
|
|
|
discard:
|
2011-01-17 09:47:59 +03:00
|
|
|
/* remove m from any expiration list it may be on */
|
2011-11-25 09:22:05 +04:00
|
|
|
if (!list_empty(&mnt->mnt_expire)) {
|
2013-03-16 23:12:40 +04:00
|
|
|
namespace_lock();
|
2011-11-25 09:22:05 +04:00
|
|
|
list_del_init(&mnt->mnt_expire);
|
2013-03-16 23:12:40 +04:00
|
|
|
namespace_unlock();
|
2011-01-17 09:35:23 +03:00
|
|
|
}
|
2011-01-17 09:47:59 +03:00
|
|
|
mntput(m);
|
|
|
|
mntput(m);
|
2011-01-17 09:35:23 +03:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2011-01-14 22:10:03 +03:00
|
|
|
/**
|
|
|
|
* mnt_set_expiry - Put a mount on an expiration list
|
|
|
|
* @mnt: The mount to list.
|
|
|
|
* @expiry_list: The list to add the mount to.
|
|
|
|
*/
|
|
|
|
void mnt_set_expiry(struct vfsmount *mnt, struct list_head *expiry_list)
|
|
|
|
{
|
2013-03-16 23:12:40 +04:00
|
|
|
namespace_lock();
|
2011-01-14 22:10:03 +03:00
|
|
|
|
2011-11-25 09:22:05 +04:00
|
|
|
list_add_tail(&real_mount(mnt)->mnt_expire, expiry_list);
|
2011-01-14 22:10:03 +03:00
|
|
|
|
2013-03-16 23:12:40 +04:00
|
|
|
namespace_unlock();
|
2011-01-14 22:10:03 +03:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mnt_set_expiry);
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/*
|
|
|
|
* process a list of expirable mountpoints with the intent of discarding any
|
|
|
|
* mountpoints that aren't in use and haven't been touched since last we came
|
|
|
|
* here
|
|
|
|
*/
|
|
|
|
void mark_mounts_for_expiry(struct list_head *mounts)
|
|
|
|
{
|
2011-11-25 06:07:43 +04:00
|
|
|
struct mount *mnt, *next;
|
2005-04-17 02:20:36 +04:00
|
|
|
LIST_HEAD(graveyard);
|
|
|
|
|
|
|
|
if (list_empty(mounts))
|
|
|
|
return;
|
|
|
|
|
2013-03-16 23:12:40 +04:00
|
|
|
namespace_lock();
|
2013-09-29 19:24:49 +04:00
|
|
|
lock_mount_hash();
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
/* extract from the expiration list every vfsmount that matches the
|
|
|
|
* following criteria:
|
|
|
|
* - only referenced by its parent vfsmount
|
|
|
|
* - still marked for expiry (marked on the last call here; marks are
|
|
|
|
* cleared by mntput())
|
|
|
|
*/
|
2011-11-25 09:22:05 +04:00
|
|
|
list_for_each_entry_safe(mnt, next, mounts, mnt_expire) {
|
2011-11-25 09:57:42 +04:00
|
|
|
if (!xchg(&mnt->mnt_expiry_mark, 1) ||
|
2011-11-25 06:35:16 +04:00
|
|
|
propagate_mount_busy(mnt, 1))
|
2005-04-17 02:20:36 +04:00
|
|
|
continue;
|
2011-11-25 09:22:05 +04:00
|
|
|
list_move(&mnt->mnt_expire, &graveyard);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
2008-03-22 07:21:53 +03:00
|
|
|
while (!list_empty(&graveyard)) {
|
2011-11-25 09:22:05 +04:00
|
|
|
mnt = list_first_entry(&graveyard, struct mount, mnt_expire);
|
2011-11-25 09:46:35 +04:00
|
|
|
touch_mnt_namespace(mnt->mnt_ns);
|
2014-12-24 16:20:01 +03:00
|
|
|
umount_tree(mnt, UMOUNT_PROPAGATE|UMOUNT_SYNC);
|
2008-03-22 07:21:53 +03:00
|
|
|
}
|
2013-09-29 19:24:49 +04:00
|
|
|
unlock_mount_hash();
|
2013-03-16 22:42:19 +04:00
|
|
|
namespace_unlock();
|
2006-06-09 17:34:17 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL_GPL(mark_mounts_for_expiry);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Ripoff of 'select_parent()'
|
|
|
|
*
|
|
|
|
* search the list of submounts for a given mountpoint, and move any
|
|
|
|
* shrinkable submounts to the 'graveyard' list.
|
|
|
|
*/
|
2011-11-25 06:15:14 +04:00
|
|
|
static int select_submounts(struct mount *parent, struct list_head *graveyard)
|
2006-06-09 17:34:17 +04:00
|
|
|
{
|
2011-11-25 06:15:14 +04:00
|
|
|
struct mount *this_parent = parent;
|
2006-06-09 17:34:17 +04:00
|
|
|
struct list_head *next;
|
|
|
|
int found = 0;
|
|
|
|
|
|
|
|
repeat:
|
2011-11-25 08:24:33 +04:00
|
|
|
next = this_parent->mnt_mounts.next;
|
2006-06-09 17:34:17 +04:00
|
|
|
resume:
|
2011-11-25 08:24:33 +04:00
|
|
|
while (next != &this_parent->mnt_mounts) {
|
2006-06-09 17:34:17 +04:00
|
|
|
struct list_head *tmp = next;
|
2011-11-25 08:24:33 +04:00
|
|
|
struct mount *mnt = list_entry(tmp, struct mount, mnt_child);
|
2006-06-09 17:34:17 +04:00
|
|
|
|
|
|
|
next = tmp->next;
|
2011-11-25 06:15:14 +04:00
|
|
|
if (!(mnt->mnt.mnt_flags & MNT_SHRINKABLE))
|
2005-04-17 02:20:36 +04:00
|
|
|
continue;
|
2006-06-09 17:34:17 +04:00
|
|
|
/*
|
|
|
|
* Descend a level if the d_mounts list is non-empty.
|
|
|
|
*/
|
2011-11-25 08:24:33 +04:00
|
|
|
if (!list_empty(&mnt->mnt_mounts)) {
|
2006-06-09 17:34:17 +04:00
|
|
|
this_parent = mnt;
|
|
|
|
goto repeat;
|
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2011-11-25 06:35:16 +04:00
|
|
|
if (!propagate_mount_busy(mnt, 1)) {
|
2011-11-25 09:22:05 +04:00
|
|
|
list_move_tail(&mnt->mnt_expire, graveyard);
|
2006-06-09 17:34:17 +04:00
|
|
|
found++;
|
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
2006-06-09 17:34:17 +04:00
|
|
|
/*
|
|
|
|
* All done at this level ... ascend and resume the search
|
|
|
|
*/
|
|
|
|
if (this_parent != parent) {
|
2011-11-25 08:24:33 +04:00
|
|
|
next = this_parent->mnt_child.next;
|
2011-11-25 07:19:58 +04:00
|
|
|
this_parent = this_parent->mnt_parent;
|
2006-06-09 17:34:17 +04:00
|
|
|
goto resume;
|
|
|
|
}
|
|
|
|
return found;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* process a list of expirable mountpoints with the intent of discarding any
|
|
|
|
* submounts of a specific parent mountpoint
|
fs: brlock vfsmount_lock
fs: brlock vfsmount_lock
Use a brlock for the vfsmount lock. It must be taken for write whenever
modifying the mount hash or associated fields, and may be taken for read when
performing mount hash lookups.
A new lock is added for the mnt-id allocator, so it doesn't need to take
the heavy vfsmount write-lock.
The number of atomics should remain the same for fastpath rlock cases, though
code would be slightly slower due to per-cpu access. Scalability is not not be
much improved in common cases yet, due to other locks (ie. dcache_lock) getting
in the way. However path lookups crossing mountpoints should be one case where
scalability is improved (currently requiring the global lock).
The slowpath is slower due to use of brlock. On a 64 core, 64 socket, 32 node
Altix system (high latency to remote nodes), a simple umount microbenchmark
(mount --bind mnt mnt2 ; umount mnt2 loop 1000 times), before this patch it
took 6.8s, afterwards took 7.1s, about 5% slower.
Cc: Al Viro <viro@ZenIV.linux.org.uk>
Signed-off-by: Nick Piggin <npiggin@kernel.dk>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2010-08-17 22:37:39 +04:00
|
|
|
*
|
2013-09-30 06:06:07 +04:00
|
|
|
* mount_lock must be held for write
|
2006-06-09 17:34:17 +04:00
|
|
|
*/
|
2013-03-16 22:39:34 +04:00
|
|
|
static void shrink_submounts(struct mount *mnt)
|
2006-06-09 17:34:17 +04:00
|
|
|
{
|
|
|
|
LIST_HEAD(graveyard);
|
2011-11-25 06:07:43 +04:00
|
|
|
struct mount *m;
|
2006-06-09 17:34:17 +04:00
|
|
|
|
|
|
|
/* extract submounts of 'mountpoint' from the expiration list */
|
2008-03-22 07:46:23 +03:00
|
|
|
while (select_submounts(mnt, &graveyard)) {
|
2008-03-22 07:21:53 +03:00
|
|
|
while (!list_empty(&graveyard)) {
|
2011-11-25 06:07:43 +04:00
|
|
|
m = list_first_entry(&graveyard, struct mount,
|
2011-11-25 09:22:05 +04:00
|
|
|
mnt_expire);
|
2011-11-25 09:46:35 +04:00
|
|
|
touch_mnt_namespace(m->mnt_ns);
|
2014-12-24 16:20:01 +03:00
|
|
|
umount_tree(m, UMOUNT_PROPAGATE|UMOUNT_SYNC);
|
2008-03-22 07:21:53 +03:00
|
|
|
}
|
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2020-09-17 11:22:34 +03:00
|
|
|
static void *copy_mount_options(const void __user * data)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2015-12-15 02:44:44 +03:00
|
|
|
char *copy;
|
2020-07-01 19:46:06 +03:00
|
|
|
unsigned left, offset;
|
2005-11-08 01:16:09 +03:00
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
if (!data)
|
2015-12-15 02:44:44 +03:00
|
|
|
return NULL;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2015-12-15 02:44:44 +03:00
|
|
|
copy = kmalloc(PAGE_SIZE, GFP_KERNEL);
|
|
|
|
if (!copy)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2020-07-01 19:46:06 +03:00
|
|
|
left = copy_from_user(copy, data, PAGE_SIZE);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2020-07-01 19:46:06 +03:00
|
|
|
/*
|
|
|
|
* Not all architectures have an exact copy_from_user(). Resort to
|
|
|
|
* byte at a time.
|
|
|
|
*/
|
|
|
|
offset = PAGE_SIZE - left;
|
|
|
|
while (left) {
|
|
|
|
char c;
|
|
|
|
if (get_user(c, (const char __user *)data + offset))
|
|
|
|
break;
|
|
|
|
copy[offset] = c;
|
|
|
|
left--;
|
|
|
|
offset++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (left == PAGE_SIZE) {
|
2015-12-15 02:44:44 +03:00
|
|
|
kfree(copy);
|
|
|
|
return ERR_PTR(-EFAULT);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
2020-07-01 19:46:06 +03:00
|
|
|
|
2015-12-15 02:44:44 +03:00
|
|
|
return copy;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2020-09-17 11:22:34 +03:00
|
|
|
static char *copy_mount_string(const void __user *data)
|
fs: fix overflow in sys_mount() for in-kernel calls
sys_mount() reads/copies a whole page for its "type" parameter. When
do_mount_root() passes a kernel address that points to an object which is
smaller than a whole page, copy_mount_options() will happily go past this
memory object, possibly dereferencing "wild" pointers that could be in any
state (hence the kmemcheck warning, which shows that parts of the next
page are not even allocated).
(The likelihood of something going wrong here is pretty low -- first of
all this only applies to kernel calls to sys_mount(), which are mostly
found in the boot code. Secondly, I guess if the page was not mapped,
exact_copy_from_user() _would_ in fact handle it correctly because of its
access_ok(), etc. checks.)
But it is much nicer to avoid the dubious reads altogether, by stopping as
soon as we find a NUL byte. Is there a good reason why we can't do
something like this, using the already existing strndup_from_user()?
[akpm@linux-foundation.org: make copy_mount_string() static]
[AV: fix compat mount breakage, which involves undoing akpm's change above]
Reported-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Vegard Nossum <vegard.nossum@gmail.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Pekka Enberg <penberg@cs.helsinki.fi>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: al <al@dizzy.pdmi.ras.ru>
2009-09-19 00:05:45 +04:00
|
|
|
{
|
2019-01-22 09:51:52 +03:00
|
|
|
return data ? strndup_user(data, PATH_MAX) : NULL;
|
fs: fix overflow in sys_mount() for in-kernel calls
sys_mount() reads/copies a whole page for its "type" parameter. When
do_mount_root() passes a kernel address that points to an object which is
smaller than a whole page, copy_mount_options() will happily go past this
memory object, possibly dereferencing "wild" pointers that could be in any
state (hence the kmemcheck warning, which shows that parts of the next
page are not even allocated).
(The likelihood of something going wrong here is pretty low -- first of
all this only applies to kernel calls to sys_mount(), which are mostly
found in the boot code. Secondly, I guess if the page was not mapped,
exact_copy_from_user() _would_ in fact handle it correctly because of its
access_ok(), etc. checks.)
But it is much nicer to avoid the dubious reads altogether, by stopping as
soon as we find a NUL byte. Is there a good reason why we can't do
something like this, using the already existing strndup_from_user()?
[akpm@linux-foundation.org: make copy_mount_string() static]
[AV: fix compat mount breakage, which involves undoing akpm's change above]
Reported-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Vegard Nossum <vegard.nossum@gmail.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Pekka Enberg <penberg@cs.helsinki.fi>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: al <al@dizzy.pdmi.ras.ru>
2009-09-19 00:05:45 +04:00
|
|
|
}
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/*
|
|
|
|
* Flags is a 32-bit value that allows up to 31 non-fs dependent flags to
|
|
|
|
* be given to the mount() call (ie: read-only, no-dev, no-suid etc).
|
|
|
|
*
|
|
|
|
* data is a (void *) that can point to any structure up to
|
|
|
|
* PAGE_SIZE-1 bytes, which can contain arbitrary fs-dependent
|
|
|
|
* information (or be NULL).
|
|
|
|
*
|
|
|
|
* Pre-0.97 versions of mount() didn't have a flags word.
|
|
|
|
* When the flags word was introduced its top half was required
|
|
|
|
* to have the magic value 0xC0ED, and this remained so until 2.4.0-test9.
|
|
|
|
* Therefore, if this magic number is present, it carries no information
|
|
|
|
* and must be discarded.
|
|
|
|
*/
|
2020-07-21 12:12:08 +03:00
|
|
|
int path_mount(const char *dev_name, struct path *path,
|
2012-10-11 19:42:01 +04:00
|
|
|
const char *type_page, unsigned long flags, void *data_page)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2017-07-17 10:45:35 +03:00
|
|
|
unsigned int mnt_flags = 0, sb_flags;
|
2020-06-04 10:41:08 +03:00
|
|
|
int ret;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
/* Discard magic */
|
|
|
|
if ((flags & MS_MGC_MSK) == MS_MGC_VAL)
|
|
|
|
flags &= ~MS_MGC_MSK;
|
|
|
|
|
|
|
|
/* Basic sanity checks */
|
|
|
|
if (data_page)
|
|
|
|
((char *)data_page)[PAGE_SIZE - 1] = 0;
|
|
|
|
|
2017-07-17 10:45:35 +03:00
|
|
|
if (flags & MS_NOUSER)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2020-06-04 10:41:08 +03:00
|
|
|
ret = security_sb_mount(dev_name, path, type_page, flags, data_page);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
if (!may_mount())
|
|
|
|
return -EPERM;
|
2021-08-19 21:56:38 +03:00
|
|
|
if (flags & SB_MANDLOCK)
|
|
|
|
warn_mandlock();
|
2009-10-04 16:49:49 +04:00
|
|
|
|
2009-04-19 20:40:43 +04:00
|
|
|
/* Default to relatime unless overriden */
|
|
|
|
if (!(flags & MS_NOATIME))
|
|
|
|
mnt_flags |= MNT_RELATIME;
|
2009-03-26 20:53:14 +03:00
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/* Separate the per-mountpoint flags */
|
|
|
|
if (flags & MS_NOSUID)
|
|
|
|
mnt_flags |= MNT_NOSUID;
|
|
|
|
if (flags & MS_NODEV)
|
|
|
|
mnt_flags |= MNT_NODEV;
|
|
|
|
if (flags & MS_NOEXEC)
|
|
|
|
mnt_flags |= MNT_NOEXEC;
|
2006-01-10 07:52:17 +03:00
|
|
|
if (flags & MS_NOATIME)
|
|
|
|
mnt_flags |= MNT_NOATIME;
|
|
|
|
if (flags & MS_NODIRATIME)
|
|
|
|
mnt_flags |= MNT_NODIRATIME;
|
2009-03-26 20:49:56 +03:00
|
|
|
if (flags & MS_STRICTATIME)
|
|
|
|
mnt_flags &= ~(MNT_RELATIME | MNT_NOATIME);
|
2018-04-20 15:35:02 +03:00
|
|
|
if (flags & MS_RDONLY)
|
2008-02-16 01:38:00 +03:00
|
|
|
mnt_flags |= MNT_READONLY;
|
2020-08-27 20:09:46 +03:00
|
|
|
if (flags & MS_NOSYMFOLLOW)
|
|
|
|
mnt_flags |= MNT_NOSYMFOLLOW;
|
2006-01-10 07:52:17 +03:00
|
|
|
|
2014-07-29 04:36:04 +04:00
|
|
|
/* The default atime for remount is preservation */
|
|
|
|
if ((flags & MS_REMOUNT) &&
|
|
|
|
((flags & (MS_NOATIME | MS_NODIRATIME | MS_RELATIME |
|
|
|
|
MS_STRICTATIME)) == 0)) {
|
|
|
|
mnt_flags &= ~MNT_ATIME_MASK;
|
2020-06-04 10:41:08 +03:00
|
|
|
mnt_flags |= path->mnt->mnt_flags & MNT_ATIME_MASK;
|
2014-07-29 04:36:04 +04:00
|
|
|
}
|
|
|
|
|
2017-07-17 10:45:35 +03:00
|
|
|
sb_flags = flags & (SB_RDONLY |
|
|
|
|
SB_SYNCHRONOUS |
|
|
|
|
SB_MANDLOCK |
|
|
|
|
SB_DIRSYNC |
|
|
|
|
SB_SILENT |
|
2017-10-08 07:28:21 +03:00
|
|
|
SB_POSIXACL |
|
2017-10-11 08:01:31 +03:00
|
|
|
SB_LAZYTIME |
|
2017-10-08 07:28:21 +03:00
|
|
|
SB_I_VERSION);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2018-11-02 02:07:25 +03:00
|
|
|
if ((flags & (MS_REMOUNT | MS_BIND)) == (MS_REMOUNT | MS_BIND))
|
2020-06-04 10:41:08 +03:00
|
|
|
return do_reconfigure_mnt(path, mnt_flags);
|
|
|
|
if (flags & MS_REMOUNT)
|
|
|
|
return do_remount(path, flags, sb_flags, mnt_flags, data_page);
|
|
|
|
if (flags & MS_BIND)
|
|
|
|
return do_loopback(path, dev_name, flags & MS_REC);
|
|
|
|
if (flags & (MS_SHARED | MS_PRIVATE | MS_SLAVE | MS_UNBINDABLE))
|
|
|
|
return do_change_type(path, flags);
|
|
|
|
if (flags & MS_MOVE)
|
|
|
|
return do_move_mount_old(path, dev_name);
|
|
|
|
|
|
|
|
return do_new_mount(path, type_page, sb_flags, mnt_flags, dev_name,
|
|
|
|
data_page);
|
|
|
|
}
|
|
|
|
|
|
|
|
long do_mount(const char *dev_name, const char __user *dir_name,
|
|
|
|
const char *type_page, unsigned long flags, void *data_page)
|
|
|
|
{
|
|
|
|
struct path path;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = user_path_at(AT_FDCWD, dir_name, LOOKUP_FOLLOW, &path);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
ret = path_mount(dev_name, &path, type_page, flags, data_page);
|
2008-08-02 08:51:11 +04:00
|
|
|
path_put(&path);
|
2020-06-04 10:41:08 +03:00
|
|
|
return ret;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2016-08-08 22:37:37 +03:00
|
|
|
static struct ucounts *inc_mnt_namespaces(struct user_namespace *ns)
|
|
|
|
{
|
|
|
|
return inc_ucount(ns, current_euid(), UCOUNT_MNT_NAMESPACES);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dec_mnt_namespaces(struct ucounts *ucounts)
|
|
|
|
{
|
|
|
|
dec_ucount(ucounts, UCOUNT_MNT_NAMESPACES);
|
|
|
|
}
|
|
|
|
|
2012-07-27 08:08:32 +04:00
|
|
|
static void free_mnt_ns(struct mnt_namespace *ns)
|
|
|
|
{
|
2019-01-30 21:30:21 +03:00
|
|
|
if (!is_anon_ns(ns))
|
|
|
|
ns_free_inum(&ns->ns);
|
2016-08-08 22:37:37 +03:00
|
|
|
dec_mnt_namespaces(ns->ucounts);
|
2012-07-27 08:08:32 +04:00
|
|
|
put_user_ns(ns->user_ns);
|
|
|
|
kfree(ns);
|
|
|
|
}
|
|
|
|
|
2010-03-08 05:49:36 +03:00
|
|
|
/*
|
|
|
|
* Assign a sequence number so we can detect when we attempt to bind
|
|
|
|
* mount a reference to an older mount namespace into the current
|
|
|
|
* mount namespace, preventing reference counting loops. A 64bit
|
|
|
|
* number incrementing at 10Ghz will take 12,427 years to wrap which
|
|
|
|
* is effectively never, so we can ignore the possibility.
|
|
|
|
*/
|
|
|
|
static atomic64_t mnt_ns_seq = ATOMIC64_INIT(1);
|
|
|
|
|
2019-01-30 21:30:21 +03:00
|
|
|
static struct mnt_namespace *alloc_mnt_ns(struct user_namespace *user_ns, bool anon)
|
2009-06-22 23:09:13 +04:00
|
|
|
{
|
|
|
|
struct mnt_namespace *new_ns;
|
2016-08-08 22:37:37 +03:00
|
|
|
struct ucounts *ucounts;
|
2011-06-15 21:21:48 +04:00
|
|
|
int ret;
|
2009-06-22 23:09:13 +04:00
|
|
|
|
2016-08-08 22:37:37 +03:00
|
|
|
ucounts = inc_mnt_namespaces(user_ns);
|
|
|
|
if (!ucounts)
|
2016-09-22 21:08:36 +03:00
|
|
|
return ERR_PTR(-ENOSPC);
|
2016-08-08 22:37:37 +03:00
|
|
|
|
2021-09-03 00:55:27 +03:00
|
|
|
new_ns = kzalloc(sizeof(struct mnt_namespace), GFP_KERNEL_ACCOUNT);
|
2016-08-08 22:37:37 +03:00
|
|
|
if (!new_ns) {
|
|
|
|
dec_mnt_namespaces(ucounts);
|
2009-06-22 23:09:13 +04:00
|
|
|
return ERR_PTR(-ENOMEM);
|
2016-08-08 22:37:37 +03:00
|
|
|
}
|
2019-01-30 21:30:21 +03:00
|
|
|
if (!anon) {
|
|
|
|
ret = ns_alloc_inum(&new_ns->ns);
|
|
|
|
if (ret) {
|
|
|
|
kfree(new_ns);
|
|
|
|
dec_mnt_namespaces(ucounts);
|
|
|
|
return ERR_PTR(ret);
|
|
|
|
}
|
2011-06-15 21:21:48 +04:00
|
|
|
}
|
2014-11-01 09:32:53 +03:00
|
|
|
new_ns->ns.ops = &mntns_operations;
|
2019-01-30 21:30:21 +03:00
|
|
|
if (!anon)
|
|
|
|
new_ns->seq = atomic64_add_return(1, &mnt_ns_seq);
|
2020-08-03 13:16:42 +03:00
|
|
|
refcount_set(&new_ns->ns.count, 1);
|
2009-06-22 23:09:13 +04:00
|
|
|
INIT_LIST_HEAD(&new_ns->list);
|
|
|
|
init_waitqueue_head(&new_ns->poll);
|
2020-05-14 17:44:24 +03:00
|
|
|
spin_lock_init(&new_ns->ns_lock);
|
2012-07-27 08:08:32 +04:00
|
|
|
new_ns->user_ns = get_user_ns(user_ns);
|
2016-08-08 22:37:37 +03:00
|
|
|
new_ns->ucounts = ucounts;
|
2009-06-22 23:09:13 +04:00
|
|
|
return new_ns;
|
|
|
|
}
|
|
|
|
|
2016-06-20 21:42:34 +03:00
|
|
|
__latent_entropy
|
2013-09-29 04:47:57 +04:00
|
|
|
struct mnt_namespace *copy_mnt_ns(unsigned long flags, struct mnt_namespace *ns,
|
|
|
|
struct user_namespace *user_ns, struct fs_struct *new_fs)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2006-12-08 13:37:56 +03:00
|
|
|
struct mnt_namespace *new_ns;
|
2008-05-11 04:44:54 +04:00
|
|
|
struct vfsmount *rootmnt = NULL, *pwdmnt = NULL;
|
2011-11-25 03:57:30 +04:00
|
|
|
struct mount *p, *q;
|
2013-09-29 04:47:57 +04:00
|
|
|
struct mount *old;
|
2011-11-25 05:55:08 +04:00
|
|
|
struct mount *new;
|
2012-08-01 00:13:04 +04:00
|
|
|
int copy_flags;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2013-09-29 04:47:57 +04:00
|
|
|
BUG_ON(!ns);
|
|
|
|
|
|
|
|
if (likely(!(flags & CLONE_NEWNS))) {
|
|
|
|
get_mnt_ns(ns);
|
|
|
|
return ns;
|
|
|
|
}
|
|
|
|
|
|
|
|
old = ns->root;
|
|
|
|
|
2019-01-30 21:30:21 +03:00
|
|
|
new_ns = alloc_mnt_ns(user_ns, false);
|
2009-06-22 23:09:13 +04:00
|
|
|
if (IS_ERR(new_ns))
|
|
|
|
return new_ns;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2013-03-16 23:12:40 +04:00
|
|
|
namespace_lock();
|
2005-04-17 02:20:36 +04:00
|
|
|
/* First pass: copy the tree topology */
|
2013-03-30 12:35:18 +04:00
|
|
|
copy_flags = CL_COPY_UNBINDABLE | CL_EXPIRE;
|
2013-09-29 04:47:57 +04:00
|
|
|
if (user_ns != ns->user_ns)
|
2019-01-30 21:15:45 +03:00
|
|
|
copy_flags |= CL_SHARED_TO_SLAVE;
|
2012-08-01 00:13:04 +04:00
|
|
|
new = copy_tree(old, old->mnt.mnt_root, copy_flags);
|
2012-06-25 15:55:18 +04:00
|
|
|
if (IS_ERR(new)) {
|
2013-03-16 22:49:45 +04:00
|
|
|
namespace_unlock();
|
2012-07-27 08:08:32 +04:00
|
|
|
free_mnt_ns(new_ns);
|
2012-06-25 15:55:18 +04:00
|
|
|
return ERR_CAST(new);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
2019-01-30 21:15:45 +03:00
|
|
|
if (user_ns != ns->user_ns) {
|
|
|
|
lock_mount_hash();
|
|
|
|
lock_mnt_tree(new);
|
|
|
|
unlock_mount_hash();
|
|
|
|
}
|
2011-12-06 22:32:36 +04:00
|
|
|
new_ns->root = new;
|
2011-11-25 11:19:55 +04:00
|
|
|
list_add_tail(&new_ns->list, &new->mnt_list);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Second pass: switch the tsk->fs->* elements and mark new vfsmounts
|
|
|
|
* as belonging to new namespace. We have already acquired a private
|
|
|
|
* fs_struct, so tsk->fs->lock is not needed.
|
|
|
|
*/
|
2011-11-25 12:06:56 +04:00
|
|
|
p = old;
|
2011-11-25 05:55:08 +04:00
|
|
|
q = new;
|
2005-04-17 02:20:36 +04:00
|
|
|
while (p) {
|
2011-11-25 09:46:35 +04:00
|
|
|
q->mnt_ns = new_ns;
|
2016-09-28 08:27:17 +03:00
|
|
|
new_ns->mounts++;
|
2013-09-29 04:47:57 +04:00
|
|
|
if (new_fs) {
|
|
|
|
if (&p->mnt == new_fs->root.mnt) {
|
|
|
|
new_fs->root.mnt = mntget(&q->mnt);
|
2011-11-25 03:57:30 +04:00
|
|
|
rootmnt = &p->mnt;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
2013-09-29 04:47:57 +04:00
|
|
|
if (&p->mnt == new_fs->pwd.mnt) {
|
|
|
|
new_fs->pwd.mnt = mntget(&q->mnt);
|
2011-11-25 03:57:30 +04:00
|
|
|
pwdmnt = &p->mnt;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
}
|
2011-11-25 12:06:56 +04:00
|
|
|
p = next_mnt(p, old);
|
|
|
|
q = next_mnt(q, new);
|
2013-03-30 12:35:18 +04:00
|
|
|
if (!q)
|
|
|
|
break;
|
2022-11-25 06:55:57 +03:00
|
|
|
// an mntns binding we'd skipped?
|
2013-03-30 12:35:18 +04:00
|
|
|
while (p->mnt.mnt_root != q->mnt.mnt_root)
|
2022-11-25 06:55:57 +03:00
|
|
|
p = next_mnt(skip_mnt_tree(p), old);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
2013-03-16 22:49:45 +04:00
|
|
|
namespace_unlock();
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
if (rootmnt)
|
2011-01-15 06:30:21 +03:00
|
|
|
mntput(rootmnt);
|
2005-04-17 02:20:36 +04:00
|
|
|
if (pwdmnt)
|
2011-01-15 06:30:21 +03:00
|
|
|
mntput(pwdmnt);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2006-02-07 23:59:00 +03:00
|
|
|
return new_ns;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2019-01-30 21:30:21 +03:00
|
|
|
struct dentry *mount_subtree(struct vfsmount *m, const char *name)
|
2011-11-17 06:43:59 +04:00
|
|
|
{
|
2019-01-30 21:30:21 +03:00
|
|
|
struct mount *mnt = real_mount(m);
|
2011-11-17 06:43:59 +04:00
|
|
|
struct mnt_namespace *ns;
|
2011-11-22 21:31:21 +04:00
|
|
|
struct super_block *s;
|
2011-11-17 06:43:59 +04:00
|
|
|
struct path path;
|
|
|
|
int err;
|
|
|
|
|
2019-01-30 21:30:21 +03:00
|
|
|
ns = alloc_mnt_ns(&init_user_ns, true);
|
|
|
|
if (IS_ERR(ns)) {
|
|
|
|
mntput(m);
|
2011-11-17 06:43:59 +04:00
|
|
|
return ERR_CAST(ns);
|
2019-01-30 21:30:21 +03:00
|
|
|
}
|
|
|
|
mnt->mnt_ns = ns;
|
|
|
|
ns->root = mnt;
|
|
|
|
ns->mounts++;
|
|
|
|
list_add(&mnt->mnt_list, &ns->list);
|
2011-11-17 06:43:59 +04:00
|
|
|
|
2019-01-30 21:30:21 +03:00
|
|
|
err = vfs_path_lookup(m->mnt_root, m,
|
2011-11-17 06:43:59 +04:00
|
|
|
name, LOOKUP_FOLLOW|LOOKUP_AUTOMOUNT, &path);
|
|
|
|
|
|
|
|
put_mnt_ns(ns);
|
|
|
|
|
|
|
|
if (err)
|
|
|
|
return ERR_PTR(err);
|
|
|
|
|
|
|
|
/* trade a vfsmount reference for active sb one */
|
2011-11-22 21:31:21 +04:00
|
|
|
s = path.mnt->mnt_sb;
|
|
|
|
atomic_inc(&s->s_active);
|
2011-11-17 06:43:59 +04:00
|
|
|
mntput(path.mnt);
|
|
|
|
/* lock the sucker */
|
2011-11-22 21:31:21 +04:00
|
|
|
down_write(&s->s_umount);
|
2011-11-17 06:43:59 +04:00
|
|
|
/* ... and return the root of (sub)tree on it */
|
|
|
|
return path.dentry;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mount_subtree);
|
|
|
|
|
init: use do_mount() instead of ksys_mount()
In prepare_namespace(), do_mount() can be used instead of ksys_mount()
as the first and third argument are const strings in the kernel, the
second and fourth argument are passed through anyway, and the fifth
argument is NULL.
In do_mount_root(), ksys_mount() is called with the first and third
argument being already kernelspace strings, which do not need to be
copied over from userspace to kernelspace (again). The second and
fourth arguments are passed through to do_mount() anyway. The fifth
argument, while already residing in kernelspace, needs to be put into
a page of its own. Then, do_mount() can be used instead of
ksys_mount().
Once this is done, there are no in-kernel users to ksys_mount() left,
which can therefore be removed.
Signed-off-by: Dominik Brodowski <linux@dominikbrodowski.net>
2018-10-23 23:41:09 +03:00
|
|
|
SYSCALL_DEFINE5(mount, char __user *, dev_name, char __user *, dir_name,
|
|
|
|
char __user *, type, unsigned long, flags, void __user *, data)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
fs: fix overflow in sys_mount() for in-kernel calls
sys_mount() reads/copies a whole page for its "type" parameter. When
do_mount_root() passes a kernel address that points to an object which is
smaller than a whole page, copy_mount_options() will happily go past this
memory object, possibly dereferencing "wild" pointers that could be in any
state (hence the kmemcheck warning, which shows that parts of the next
page are not even allocated).
(The likelihood of something going wrong here is pretty low -- first of
all this only applies to kernel calls to sys_mount(), which are mostly
found in the boot code. Secondly, I guess if the page was not mapped,
exact_copy_from_user() _would_ in fact handle it correctly because of its
access_ok(), etc. checks.)
But it is much nicer to avoid the dubious reads altogether, by stopping as
soon as we find a NUL byte. Is there a good reason why we can't do
something like this, using the already existing strndup_from_user()?
[akpm@linux-foundation.org: make copy_mount_string() static]
[AV: fix compat mount breakage, which involves undoing akpm's change above]
Reported-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Vegard Nossum <vegard.nossum@gmail.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Pekka Enberg <penberg@cs.helsinki.fi>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: al <al@dizzy.pdmi.ras.ru>
2009-09-19 00:05:45 +04:00
|
|
|
int ret;
|
|
|
|
char *kernel_type;
|
|
|
|
char *kernel_dev;
|
2015-12-15 02:44:44 +03:00
|
|
|
void *options;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2014-08-28 21:26:03 +04:00
|
|
|
kernel_type = copy_mount_string(type);
|
|
|
|
ret = PTR_ERR(kernel_type);
|
|
|
|
if (IS_ERR(kernel_type))
|
fs: fix overflow in sys_mount() for in-kernel calls
sys_mount() reads/copies a whole page for its "type" parameter. When
do_mount_root() passes a kernel address that points to an object which is
smaller than a whole page, copy_mount_options() will happily go past this
memory object, possibly dereferencing "wild" pointers that could be in any
state (hence the kmemcheck warning, which shows that parts of the next
page are not even allocated).
(The likelihood of something going wrong here is pretty low -- first of
all this only applies to kernel calls to sys_mount(), which are mostly
found in the boot code. Secondly, I guess if the page was not mapped,
exact_copy_from_user() _would_ in fact handle it correctly because of its
access_ok(), etc. checks.)
But it is much nicer to avoid the dubious reads altogether, by stopping as
soon as we find a NUL byte. Is there a good reason why we can't do
something like this, using the already existing strndup_from_user()?
[akpm@linux-foundation.org: make copy_mount_string() static]
[AV: fix compat mount breakage, which involves undoing akpm's change above]
Reported-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Vegard Nossum <vegard.nossum@gmail.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Pekka Enberg <penberg@cs.helsinki.fi>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: al <al@dizzy.pdmi.ras.ru>
2009-09-19 00:05:45 +04:00
|
|
|
goto out_type;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2014-08-28 21:26:03 +04:00
|
|
|
kernel_dev = copy_mount_string(dev_name);
|
|
|
|
ret = PTR_ERR(kernel_dev);
|
|
|
|
if (IS_ERR(kernel_dev))
|
fs: fix overflow in sys_mount() for in-kernel calls
sys_mount() reads/copies a whole page for its "type" parameter. When
do_mount_root() passes a kernel address that points to an object which is
smaller than a whole page, copy_mount_options() will happily go past this
memory object, possibly dereferencing "wild" pointers that could be in any
state (hence the kmemcheck warning, which shows that parts of the next
page are not even allocated).
(The likelihood of something going wrong here is pretty low -- first of
all this only applies to kernel calls to sys_mount(), which are mostly
found in the boot code. Secondly, I guess if the page was not mapped,
exact_copy_from_user() _would_ in fact handle it correctly because of its
access_ok(), etc. checks.)
But it is much nicer to avoid the dubious reads altogether, by stopping as
soon as we find a NUL byte. Is there a good reason why we can't do
something like this, using the already existing strndup_from_user()?
[akpm@linux-foundation.org: make copy_mount_string() static]
[AV: fix compat mount breakage, which involves undoing akpm's change above]
Reported-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Vegard Nossum <vegard.nossum@gmail.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Pekka Enberg <penberg@cs.helsinki.fi>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: al <al@dizzy.pdmi.ras.ru>
2009-09-19 00:05:45 +04:00
|
|
|
goto out_dev;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2015-12-15 02:44:44 +03:00
|
|
|
options = copy_mount_options(data);
|
|
|
|
ret = PTR_ERR(options);
|
|
|
|
if (IS_ERR(options))
|
fs: fix overflow in sys_mount() for in-kernel calls
sys_mount() reads/copies a whole page for its "type" parameter. When
do_mount_root() passes a kernel address that points to an object which is
smaller than a whole page, copy_mount_options() will happily go past this
memory object, possibly dereferencing "wild" pointers that could be in any
state (hence the kmemcheck warning, which shows that parts of the next
page are not even allocated).
(The likelihood of something going wrong here is pretty low -- first of
all this only applies to kernel calls to sys_mount(), which are mostly
found in the boot code. Secondly, I guess if the page was not mapped,
exact_copy_from_user() _would_ in fact handle it correctly because of its
access_ok(), etc. checks.)
But it is much nicer to avoid the dubious reads altogether, by stopping as
soon as we find a NUL byte. Is there a good reason why we can't do
something like this, using the already existing strndup_from_user()?
[akpm@linux-foundation.org: make copy_mount_string() static]
[AV: fix compat mount breakage, which involves undoing akpm's change above]
Reported-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Vegard Nossum <vegard.nossum@gmail.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Pekka Enberg <penberg@cs.helsinki.fi>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: al <al@dizzy.pdmi.ras.ru>
2009-09-19 00:05:45 +04:00
|
|
|
goto out_data;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2015-12-15 02:44:44 +03:00
|
|
|
ret = do_mount(kernel_dev, dir_name, kernel_type, flags, options);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2015-12-15 02:44:44 +03:00
|
|
|
kfree(options);
|
fs: fix overflow in sys_mount() for in-kernel calls
sys_mount() reads/copies a whole page for its "type" parameter. When
do_mount_root() passes a kernel address that points to an object which is
smaller than a whole page, copy_mount_options() will happily go past this
memory object, possibly dereferencing "wild" pointers that could be in any
state (hence the kmemcheck warning, which shows that parts of the next
page are not even allocated).
(The likelihood of something going wrong here is pretty low -- first of
all this only applies to kernel calls to sys_mount(), which are mostly
found in the boot code. Secondly, I guess if the page was not mapped,
exact_copy_from_user() _would_ in fact handle it correctly because of its
access_ok(), etc. checks.)
But it is much nicer to avoid the dubious reads altogether, by stopping as
soon as we find a NUL byte. Is there a good reason why we can't do
something like this, using the already existing strndup_from_user()?
[akpm@linux-foundation.org: make copy_mount_string() static]
[AV: fix compat mount breakage, which involves undoing akpm's change above]
Reported-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Vegard Nossum <vegard.nossum@gmail.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Pekka Enberg <penberg@cs.helsinki.fi>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: al <al@dizzy.pdmi.ras.ru>
2009-09-19 00:05:45 +04:00
|
|
|
out_data:
|
|
|
|
kfree(kernel_dev);
|
|
|
|
out_dev:
|
|
|
|
kfree(kernel_type);
|
|
|
|
out_type:
|
|
|
|
return ret;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2021-06-01 12:33:59 +03:00
|
|
|
#define FSMOUNT_VALID_FLAGS \
|
|
|
|
(MOUNT_ATTR_RDONLY | MOUNT_ATTR_NOSUID | MOUNT_ATTR_NODEV | \
|
|
|
|
MOUNT_ATTR_NOEXEC | MOUNT_ATTR__ATIME | MOUNT_ATTR_NODIRATIME | \
|
|
|
|
MOUNT_ATTR_NOSYMFOLLOW)
|
2021-01-21 16:19:52 +03:00
|
|
|
|
2021-01-21 16:19:54 +03:00
|
|
|
#define MOUNT_SETATTR_VALID_FLAGS (FSMOUNT_VALID_FLAGS | MOUNT_ATTR_IDMAP)
|
fs: add mount_setattr()
This implements the missing mount_setattr() syscall. While the new mount
api allows to change the properties of a superblock there is currently
no way to change the properties of a mount or a mount tree using file
descriptors which the new mount api is based on. In addition the old
mount api has the restriction that mount options cannot be applied
recursively. This hasn't changed since changing mount options on a
per-mount basis was implemented in [1] and has been a frequent request
not just for convenience but also for security reasons. The legacy
mount syscall is unable to accommodate this behavior without introducing
a whole new set of flags because MS_REC | MS_REMOUNT | MS_BIND |
MS_RDONLY | MS_NOEXEC | [...] only apply the mount option to the topmost
mount. Changing MS_REC to apply to the whole mount tree would mean
introducing a significant uapi change and would likely cause significant
regressions.
The new mount_setattr() syscall allows to recursively clear and set
mount options in one shot. Multiple calls to change mount options
requesting the same changes are idempotent:
int mount_setattr(int dfd, const char *path, unsigned flags,
struct mount_attr *uattr, size_t usize);
Flags to modify path resolution behavior are specified in the @flags
argument. Currently, AT_EMPTY_PATH, AT_RECURSIVE, AT_SYMLINK_NOFOLLOW,
and AT_NO_AUTOMOUNT are supported. If useful, additional lookup flags to
restrict path resolution as introduced with openat2() might be supported
in the future.
The mount_setattr() syscall can be expected to grow over time and is
designed with extensibility in mind. It follows the extensible syscall
pattern we have used with other syscalls such as openat2(), clone3(),
sched_{set,get}attr(), and others.
The set of mount options is passed in the uapi struct mount_attr which
currently has the following layout:
struct mount_attr {
__u64 attr_set;
__u64 attr_clr;
__u64 propagation;
__u64 userns_fd;
};
The @attr_set and @attr_clr members are used to clear and set mount
options. This way a user can e.g. request that a set of flags is to be
raised such as turning mounts readonly by raising MOUNT_ATTR_RDONLY in
@attr_set while at the same time requesting that another set of flags is
to be lowered such as removing noexec from a mount tree by specifying
MOUNT_ATTR_NOEXEC in @attr_clr.
Note, since the MOUNT_ATTR_<atime> values are an enum starting from 0,
not a bitmap, users wanting to transition to a different atime setting
cannot simply specify the atime setting in @attr_set, but must also
specify MOUNT_ATTR__ATIME in the @attr_clr field. So we ensure that
MOUNT_ATTR__ATIME can't be partially set in @attr_clr and that @attr_set
can't have any atime bits set if MOUNT_ATTR__ATIME isn't set in
@attr_clr.
The @propagation field lets callers specify the propagation type of a
mount tree. Propagation is a single property that has four different
settings and as such is not really a flag argument but an enum.
Specifically, it would be unclear what setting and clearing propagation
settings in combination would amount to. The legacy mount() syscall thus
forbids the combination of multiple propagation settings too. The goal
is to keep the semantics of mount propagation somewhat simple as they
are overly complex as it is.
The @userns_fd field lets user specify a user namespace whose idmapping
becomes the idmapping of the mount. This is implemented and explained in
detail in the next patch.
[1]: commit 2e4b7fcd9260 ("[PATCH] r/o bind mounts: honor mount writer counts at remount")
Link: https://lore.kernel.org/r/20210121131959.646623-35-christian.brauner@ubuntu.com
Cc: David Howells <dhowells@redhat.com>
Cc: Aleksa Sarai <cyphar@cyphar.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: linux-fsdevel@vger.kernel.org
Cc: linux-api@vger.kernel.org
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Christian Brauner <christian.brauner@ubuntu.com>
2021-01-21 16:19:53 +03:00
|
|
|
|
|
|
|
#define MOUNT_SETATTR_PROPAGATION_FLAGS \
|
|
|
|
(MS_UNBINDABLE | MS_PRIVATE | MS_SLAVE | MS_SHARED)
|
|
|
|
|
2021-01-21 16:19:52 +03:00
|
|
|
static unsigned int attr_flags_to_mnt_flags(u64 attr_flags)
|
|
|
|
{
|
|
|
|
unsigned int mnt_flags = 0;
|
|
|
|
|
|
|
|
if (attr_flags & MOUNT_ATTR_RDONLY)
|
|
|
|
mnt_flags |= MNT_READONLY;
|
|
|
|
if (attr_flags & MOUNT_ATTR_NOSUID)
|
|
|
|
mnt_flags |= MNT_NOSUID;
|
|
|
|
if (attr_flags & MOUNT_ATTR_NODEV)
|
|
|
|
mnt_flags |= MNT_NODEV;
|
|
|
|
if (attr_flags & MOUNT_ATTR_NOEXEC)
|
|
|
|
mnt_flags |= MNT_NOEXEC;
|
|
|
|
if (attr_flags & MOUNT_ATTR_NODIRATIME)
|
|
|
|
mnt_flags |= MNT_NODIRATIME;
|
2021-06-01 12:33:59 +03:00
|
|
|
if (attr_flags & MOUNT_ATTR_NOSYMFOLLOW)
|
|
|
|
mnt_flags |= MNT_NOSYMFOLLOW;
|
2021-01-21 16:19:52 +03:00
|
|
|
|
|
|
|
return mnt_flags;
|
|
|
|
}
|
|
|
|
|
2018-11-05 20:40:30 +03:00
|
|
|
/*
|
2018-11-02 02:36:14 +03:00
|
|
|
* Create a kernel mount representation for a new, prepared superblock
|
|
|
|
* (specified by fs_fd) and attach to an open_tree-like file descriptor.
|
|
|
|
*/
|
|
|
|
SYSCALL_DEFINE3(fsmount, int, fs_fd, unsigned int, flags,
|
|
|
|
unsigned int, attr_flags)
|
|
|
|
{
|
|
|
|
struct mnt_namespace *ns;
|
|
|
|
struct fs_context *fc;
|
|
|
|
struct file *file;
|
|
|
|
struct path newmount;
|
|
|
|
struct mount *mnt;
|
|
|
|
struct fd f;
|
|
|
|
unsigned int mnt_flags = 0;
|
|
|
|
long ret;
|
|
|
|
|
|
|
|
if (!may_mount())
|
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
if ((flags & ~(FSMOUNT_CLOEXEC)) != 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2021-01-21 16:19:52 +03:00
|
|
|
if (attr_flags & ~FSMOUNT_VALID_FLAGS)
|
2018-11-02 02:36:14 +03:00
|
|
|
return -EINVAL;
|
|
|
|
|
2021-01-21 16:19:52 +03:00
|
|
|
mnt_flags = attr_flags_to_mnt_flags(attr_flags);
|
2018-11-02 02:36:14 +03:00
|
|
|
|
|
|
|
switch (attr_flags & MOUNT_ATTR__ATIME) {
|
|
|
|
case MOUNT_ATTR_STRICTATIME:
|
|
|
|
break;
|
|
|
|
case MOUNT_ATTR_NOATIME:
|
|
|
|
mnt_flags |= MNT_NOATIME;
|
|
|
|
break;
|
|
|
|
case MOUNT_ATTR_RELATIME:
|
|
|
|
mnt_flags |= MNT_RELATIME;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
f = fdget(fs_fd);
|
|
|
|
if (!f.file)
|
|
|
|
return -EBADF;
|
|
|
|
|
|
|
|
ret = -EINVAL;
|
|
|
|
if (f.file->f_op != &fscontext_fops)
|
|
|
|
goto err_fsfd;
|
|
|
|
|
|
|
|
fc = f.file->private_data;
|
|
|
|
|
|
|
|
ret = mutex_lock_interruptible(&fc->uapi_mutex);
|
|
|
|
if (ret < 0)
|
|
|
|
goto err_fsfd;
|
|
|
|
|
|
|
|
/* There must be a valid superblock or we can't mount it */
|
|
|
|
ret = -EINVAL;
|
|
|
|
if (!fc->root)
|
|
|
|
goto err_unlock;
|
|
|
|
|
|
|
|
ret = -EPERM;
|
|
|
|
if (mount_too_revealing(fc->root->d_sb, &mnt_flags)) {
|
|
|
|
pr_warn("VFS: Mount too revealing\n");
|
|
|
|
goto err_unlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = -EBUSY;
|
|
|
|
if (fc->phase != FS_CONTEXT_AWAITING_MOUNT)
|
|
|
|
goto err_unlock;
|
|
|
|
|
2021-08-19 21:56:38 +03:00
|
|
|
if (fc->sb_flags & SB_MANDLOCK)
|
|
|
|
warn_mandlock();
|
2018-11-02 02:36:14 +03:00
|
|
|
|
|
|
|
newmount.mnt = vfs_create_mount(fc);
|
|
|
|
if (IS_ERR(newmount.mnt)) {
|
|
|
|
ret = PTR_ERR(newmount.mnt);
|
|
|
|
goto err_unlock;
|
|
|
|
}
|
|
|
|
newmount.dentry = dget(fc->root);
|
|
|
|
newmount.mnt->mnt_flags = mnt_flags;
|
|
|
|
|
|
|
|
/* We've done the mount bit - now move the file context into more or
|
|
|
|
* less the same state as if we'd done an fspick(). We don't want to
|
|
|
|
* do any memory allocation or anything like that at this point as we
|
|
|
|
* don't want to have to handle any errors incurred.
|
|
|
|
*/
|
|
|
|
vfs_clean_context(fc);
|
|
|
|
|
|
|
|
ns = alloc_mnt_ns(current->nsproxy->mnt_ns->user_ns, true);
|
|
|
|
if (IS_ERR(ns)) {
|
|
|
|
ret = PTR_ERR(ns);
|
|
|
|
goto err_path;
|
|
|
|
}
|
|
|
|
mnt = real_mount(newmount.mnt);
|
|
|
|
mnt->mnt_ns = ns;
|
|
|
|
ns->root = mnt;
|
|
|
|
ns->mounts = 1;
|
|
|
|
list_add(&mnt->mnt_list, &ns->list);
|
2019-06-12 21:43:13 +03:00
|
|
|
mntget(newmount.mnt);
|
2018-11-02 02:36:14 +03:00
|
|
|
|
|
|
|
/* Attach to an apparent O_PATH fd with a note that we need to unmount
|
|
|
|
* it, not just simply put it.
|
|
|
|
*/
|
|
|
|
file = dentry_open(&newmount, O_PATH, fc->cred);
|
|
|
|
if (IS_ERR(file)) {
|
|
|
|
dissolve_on_fput(newmount.mnt);
|
|
|
|
ret = PTR_ERR(file);
|
|
|
|
goto err_path;
|
|
|
|
}
|
|
|
|
file->f_mode |= FMODE_NEED_UNMOUNT;
|
|
|
|
|
|
|
|
ret = get_unused_fd_flags((flags & FSMOUNT_CLOEXEC) ? O_CLOEXEC : 0);
|
|
|
|
if (ret >= 0)
|
|
|
|
fd_install(ret, file);
|
|
|
|
else
|
|
|
|
fput(file);
|
|
|
|
|
|
|
|
err_path:
|
|
|
|
path_put(&newmount);
|
|
|
|
err_unlock:
|
|
|
|
mutex_unlock(&fc->uapi_mutex);
|
|
|
|
err_fsfd:
|
|
|
|
fdput(f);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Move a mount from one place to another. In combination with
|
|
|
|
* fsopen()/fsmount() this is used to install a new mount and in combination
|
|
|
|
* with open_tree(OPEN_TREE_CLONE [| AT_RECURSIVE]) it can be used to copy
|
|
|
|
* a mount subtree.
|
2018-11-05 20:40:30 +03:00
|
|
|
*
|
|
|
|
* Note the flags value is a combination of MOVE_MOUNT_* flags.
|
|
|
|
*/
|
|
|
|
SYSCALL_DEFINE5(move_mount,
|
2019-10-15 13:35:02 +03:00
|
|
|
int, from_dfd, const char __user *, from_pathname,
|
|
|
|
int, to_dfd, const char __user *, to_pathname,
|
2018-11-05 20:40:30 +03:00
|
|
|
unsigned int, flags)
|
|
|
|
{
|
|
|
|
struct path from_path, to_path;
|
|
|
|
unsigned int lflags;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (!may_mount())
|
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
if (flags & ~MOVE_MOUNT__MASK)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
/* If someone gives a pathname, they aren't permitted to move
|
|
|
|
* from an fd that requires unmount as we can't get at the flag
|
|
|
|
* to clear it afterwards.
|
|
|
|
*/
|
|
|
|
lflags = 0;
|
|
|
|
if (flags & MOVE_MOUNT_F_SYMLINKS) lflags |= LOOKUP_FOLLOW;
|
|
|
|
if (flags & MOVE_MOUNT_F_AUTOMOUNTS) lflags |= LOOKUP_AUTOMOUNT;
|
|
|
|
if (flags & MOVE_MOUNT_F_EMPTY_PATH) lflags |= LOOKUP_EMPTY;
|
|
|
|
|
|
|
|
ret = user_path_at(from_dfd, from_pathname, lflags, &from_path);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
lflags = 0;
|
|
|
|
if (flags & MOVE_MOUNT_T_SYMLINKS) lflags |= LOOKUP_FOLLOW;
|
|
|
|
if (flags & MOVE_MOUNT_T_AUTOMOUNTS) lflags |= LOOKUP_AUTOMOUNT;
|
|
|
|
if (flags & MOVE_MOUNT_T_EMPTY_PATH) lflags |= LOOKUP_EMPTY;
|
|
|
|
|
|
|
|
ret = user_path_at(to_dfd, to_pathname, lflags, &to_path);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out_from;
|
|
|
|
|
|
|
|
ret = security_move_mount(&from_path, &to_path);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out_to;
|
|
|
|
|
2021-07-15 13:07:13 +03:00
|
|
|
if (flags & MOVE_MOUNT_SET_GROUP)
|
|
|
|
ret = do_set_group(&from_path, &to_path);
|
|
|
|
else
|
|
|
|
ret = do_move_mount(&from_path, &to_path);
|
2018-11-05 20:40:30 +03:00
|
|
|
|
|
|
|
out_to:
|
|
|
|
path_put(&to_path);
|
|
|
|
out_from:
|
|
|
|
path_put(&from_path);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-11-24 04:34:49 +04:00
|
|
|
/*
|
|
|
|
* Return true if path is reachable from root
|
|
|
|
*
|
2013-09-30 06:06:07 +04:00
|
|
|
* namespace_sem or mount_lock is held
|
2011-11-24 04:34:49 +04:00
|
|
|
*/
|
2011-11-25 07:00:28 +04:00
|
|
|
bool is_path_reachable(struct mount *mnt, struct dentry *dentry,
|
2011-11-24 04:34:49 +04:00
|
|
|
const struct path *root)
|
|
|
|
{
|
2011-11-25 07:00:28 +04:00
|
|
|
while (&mnt->mnt != root->mnt && mnt_has_parent(mnt)) {
|
2011-11-25 07:25:07 +04:00
|
|
|
dentry = mnt->mnt_mountpoint;
|
2011-11-25 07:19:58 +04:00
|
|
|
mnt = mnt->mnt_parent;
|
2011-11-24 04:34:49 +04:00
|
|
|
}
|
2011-11-25 07:00:28 +04:00
|
|
|
return &mnt->mnt == root->mnt && is_subdir(dentry, root->dentry);
|
2011-11-24 04:34:49 +04:00
|
|
|
}
|
|
|
|
|
2016-11-15 00:14:35 +03:00
|
|
|
bool path_is_under(const struct path *path1, const struct path *path2)
|
2011-11-24 04:34:49 +04:00
|
|
|
{
|
2015-11-17 09:40:10 +03:00
|
|
|
bool res;
|
2013-09-30 06:06:07 +04:00
|
|
|
read_seqlock_excl(&mount_lock);
|
2011-11-25 07:00:28 +04:00
|
|
|
res = is_path_reachable(real_mount(path1->mnt), path1->dentry, path2);
|
2013-09-30 06:06:07 +04:00
|
|
|
read_sequnlock_excl(&mount_lock);
|
2011-11-24 04:34:49 +04:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(path_is_under);
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/*
|
|
|
|
* pivot_root Semantics:
|
|
|
|
* Moves the root file system of the current process to the directory put_old,
|
|
|
|
* makes new_root as the new root file system of the current process, and sets
|
|
|
|
* root/cwd of all processes which had them on the current root to new_root.
|
|
|
|
*
|
|
|
|
* Restrictions:
|
|
|
|
* The new_root and put_old must be directories, and must not be on the
|
|
|
|
* same file system as the current process root. The put_old must be
|
|
|
|
* underneath new_root, i.e. adding a non-zero number of /.. to the string
|
|
|
|
* pointed to by put_old must yield the same directory as new_root. No other
|
|
|
|
* file system may be mounted on put_old. After all, new_root is a mountpoint.
|
|
|
|
*
|
2006-01-08 12:03:18 +03:00
|
|
|
* Also, the current root cannot be on the 'rootfs' (initial ramfs) filesystem.
|
2020-04-14 19:48:37 +03:00
|
|
|
* See Documentation/filesystems/ramfs-rootfs-initramfs.rst for alternatives
|
2006-01-08 12:03:18 +03:00
|
|
|
* in this situation.
|
|
|
|
*
|
2005-04-17 02:20:36 +04:00
|
|
|
* Notes:
|
|
|
|
* - we don't move root/cwd if they are not at the root (reason: if something
|
|
|
|
* cared enough to change them, it's probably wrong to force them elsewhere)
|
|
|
|
* - it's okay to pick a root that isn't the root of a file system, e.g.
|
|
|
|
* /nfs/my_root where /nfs is the mount point. It must be a mountpoint,
|
|
|
|
* though, so you may need to say mount --bind /nfs/my_root /nfs/my_root
|
|
|
|
* first.
|
|
|
|
*/
|
2009-01-14 16:14:16 +03:00
|
|
|
SYSCALL_DEFINE2(pivot_root, const char __user *, new_root,
|
|
|
|
const char __user *, put_old)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2019-07-01 02:18:53 +03:00
|
|
|
struct path new, old, root;
|
|
|
|
struct mount *new_mnt, *root_mnt, *old_mnt, *root_parent, *ex_parent;
|
2013-03-15 18:53:28 +04:00
|
|
|
struct mountpoint *old_mp, *root_mp;
|
2005-04-17 02:20:36 +04:00
|
|
|
int error;
|
|
|
|
|
2013-02-23 07:45:42 +04:00
|
|
|
if (!may_mount())
|
2005-04-17 02:20:36 +04:00
|
|
|
return -EPERM;
|
|
|
|
|
2019-07-14 23:42:44 +03:00
|
|
|
error = user_path_at(AT_FDCWD, new_root,
|
|
|
|
LOOKUP_FOLLOW | LOOKUP_DIRECTORY, &new);
|
2005-04-17 02:20:36 +04:00
|
|
|
if (error)
|
|
|
|
goto out0;
|
|
|
|
|
2019-07-14 23:42:44 +03:00
|
|
|
error = user_path_at(AT_FDCWD, put_old,
|
|
|
|
LOOKUP_FOLLOW | LOOKUP_DIRECTORY, &old);
|
2005-04-17 02:20:36 +04:00
|
|
|
if (error)
|
|
|
|
goto out1;
|
|
|
|
|
2008-07-22 17:59:21 +04:00
|
|
|
error = security_sb_pivotroot(&old, &new);
|
2011-03-18 15:55:38 +03:00
|
|
|
if (error)
|
|
|
|
goto out2;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2010-08-10 13:41:36 +04:00
|
|
|
get_fs_root(current->fs, &root);
|
2013-03-15 18:53:28 +04:00
|
|
|
old_mp = lock_mount(&old);
|
|
|
|
error = PTR_ERR(old_mp);
|
|
|
|
if (IS_ERR(old_mp))
|
2011-03-18 15:55:38 +03:00
|
|
|
goto out3;
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
error = -EINVAL;
|
2011-11-25 04:41:16 +04:00
|
|
|
new_mnt = real_mount(new.mnt);
|
|
|
|
root_mnt = real_mount(root.mnt);
|
2013-03-15 18:53:28 +04:00
|
|
|
old_mnt = real_mount(old.mnt);
|
2019-07-01 02:18:53 +03:00
|
|
|
ex_parent = new_mnt->mnt_parent;
|
|
|
|
root_parent = root_mnt->mnt_parent;
|
2013-03-15 18:53:28 +04:00
|
|
|
if (IS_MNT_SHARED(old_mnt) ||
|
2019-07-01 02:18:53 +03:00
|
|
|
IS_MNT_SHARED(ex_parent) ||
|
|
|
|
IS_MNT_SHARED(root_parent))
|
2011-03-18 15:55:38 +03:00
|
|
|
goto out4;
|
2011-11-25 09:46:35 +04:00
|
|
|
if (!check_mnt(root_mnt) || !check_mnt(new_mnt))
|
2011-03-18 15:55:38 +03:00
|
|
|
goto out4;
|
2013-03-30 08:04:39 +04:00
|
|
|
if (new_mnt->mnt.mnt_flags & MNT_LOCKED)
|
|
|
|
goto out4;
|
2005-04-17 02:20:36 +04:00
|
|
|
error = -ENOENT;
|
2009-05-04 03:32:03 +04:00
|
|
|
if (d_unlinked(new.dentry))
|
2011-03-18 15:55:38 +03:00
|
|
|
goto out4;
|
2005-04-17 02:20:36 +04:00
|
|
|
error = -EBUSY;
|
2013-03-15 18:53:28 +04:00
|
|
|
if (new_mnt == root_mnt || old_mnt == root_mnt)
|
2011-03-18 15:55:38 +03:00
|
|
|
goto out4; /* loop, on the same file system */
|
2005-04-17 02:20:36 +04:00
|
|
|
error = -EINVAL;
|
2008-03-23 01:00:39 +03:00
|
|
|
if (root.mnt->mnt_root != root.dentry)
|
2011-03-18 15:55:38 +03:00
|
|
|
goto out4; /* not a mountpoint */
|
2011-11-25 06:47:05 +04:00
|
|
|
if (!mnt_has_parent(root_mnt))
|
2011-03-18 15:55:38 +03:00
|
|
|
goto out4; /* not attached */
|
2008-07-22 17:59:21 +04:00
|
|
|
if (new.mnt->mnt_root != new.dentry)
|
2011-03-18 15:55:38 +03:00
|
|
|
goto out4; /* not a mountpoint */
|
2011-11-25 06:47:05 +04:00
|
|
|
if (!mnt_has_parent(new_mnt))
|
2011-03-18 15:55:38 +03:00
|
|
|
goto out4; /* not attached */
|
2008-02-15 06:34:32 +03:00
|
|
|
/* make sure we can reach put_old from new_root */
|
2013-03-15 18:53:28 +04:00
|
|
|
if (!is_path_reachable(old_mnt, old.dentry, &new))
|
2011-03-18 15:55:38 +03:00
|
|
|
goto out4;
|
2014-10-08 21:42:27 +04:00
|
|
|
/* make certain new is below the root */
|
|
|
|
if (!is_path_reachable(new_mnt, new.dentry, &root))
|
|
|
|
goto out4;
|
2013-09-29 19:24:49 +04:00
|
|
|
lock_mount_hash();
|
2019-07-01 02:18:53 +03:00
|
|
|
umount_mnt(new_mnt);
|
|
|
|
root_mp = unhash_mnt(root_mnt); /* we'll need its mountpoint */
|
2013-03-30 08:04:39 +04:00
|
|
|
if (root_mnt->mnt.mnt_flags & MNT_LOCKED) {
|
|
|
|
new_mnt->mnt.mnt_flags |= MNT_LOCKED;
|
|
|
|
root_mnt->mnt.mnt_flags &= ~MNT_LOCKED;
|
|
|
|
}
|
2008-02-15 06:34:32 +03:00
|
|
|
/* mount old root on put_old */
|
2013-03-15 18:53:28 +04:00
|
|
|
attach_mnt(root_mnt, old_mnt, old_mp);
|
2008-02-15 06:34:32 +03:00
|
|
|
/* mount new_root on / */
|
2019-07-01 02:18:53 +03:00
|
|
|
attach_mnt(new_mnt, root_parent, root_mp);
|
|
|
|
mnt_add_count(root_parent, -1);
|
2006-12-08 13:37:56 +03:00
|
|
|
touch_mnt_namespace(current->nsproxy->mnt_ns);
|
2014-10-08 21:42:57 +04:00
|
|
|
/* A moved mount should not expire automatically */
|
|
|
|
list_del_init(&new_mnt->mnt_expire);
|
2017-01-03 04:18:43 +03:00
|
|
|
put_mountpoint(root_mp);
|
2013-09-29 19:24:49 +04:00
|
|
|
unlock_mount_hash();
|
2008-07-22 17:59:21 +04:00
|
|
|
chroot_fs_refs(&root, &new);
|
2005-04-17 02:20:36 +04:00
|
|
|
error = 0;
|
2011-03-18 15:55:38 +03:00
|
|
|
out4:
|
2013-03-15 18:53:28 +04:00
|
|
|
unlock_mount(old_mp);
|
2019-07-01 02:18:53 +03:00
|
|
|
if (!error)
|
|
|
|
mntput_no_expire(ex_parent);
|
2011-03-18 15:55:38 +03:00
|
|
|
out3:
|
2008-03-23 01:00:39 +03:00
|
|
|
path_put(&root);
|
2011-03-18 15:55:38 +03:00
|
|
|
out2:
|
2008-07-22 17:59:21 +04:00
|
|
|
path_put(&old);
|
2005-04-17 02:20:36 +04:00
|
|
|
out1:
|
2008-07-22 17:59:21 +04:00
|
|
|
path_put(&new);
|
2005-04-17 02:20:36 +04:00
|
|
|
out0:
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
fs: add mount_setattr()
This implements the missing mount_setattr() syscall. While the new mount
api allows to change the properties of a superblock there is currently
no way to change the properties of a mount or a mount tree using file
descriptors which the new mount api is based on. In addition the old
mount api has the restriction that mount options cannot be applied
recursively. This hasn't changed since changing mount options on a
per-mount basis was implemented in [1] and has been a frequent request
not just for convenience but also for security reasons. The legacy
mount syscall is unable to accommodate this behavior without introducing
a whole new set of flags because MS_REC | MS_REMOUNT | MS_BIND |
MS_RDONLY | MS_NOEXEC | [...] only apply the mount option to the topmost
mount. Changing MS_REC to apply to the whole mount tree would mean
introducing a significant uapi change and would likely cause significant
regressions.
The new mount_setattr() syscall allows to recursively clear and set
mount options in one shot. Multiple calls to change mount options
requesting the same changes are idempotent:
int mount_setattr(int dfd, const char *path, unsigned flags,
struct mount_attr *uattr, size_t usize);
Flags to modify path resolution behavior are specified in the @flags
argument. Currently, AT_EMPTY_PATH, AT_RECURSIVE, AT_SYMLINK_NOFOLLOW,
and AT_NO_AUTOMOUNT are supported. If useful, additional lookup flags to
restrict path resolution as introduced with openat2() might be supported
in the future.
The mount_setattr() syscall can be expected to grow over time and is
designed with extensibility in mind. It follows the extensible syscall
pattern we have used with other syscalls such as openat2(), clone3(),
sched_{set,get}attr(), and others.
The set of mount options is passed in the uapi struct mount_attr which
currently has the following layout:
struct mount_attr {
__u64 attr_set;
__u64 attr_clr;
__u64 propagation;
__u64 userns_fd;
};
The @attr_set and @attr_clr members are used to clear and set mount
options. This way a user can e.g. request that a set of flags is to be
raised such as turning mounts readonly by raising MOUNT_ATTR_RDONLY in
@attr_set while at the same time requesting that another set of flags is
to be lowered such as removing noexec from a mount tree by specifying
MOUNT_ATTR_NOEXEC in @attr_clr.
Note, since the MOUNT_ATTR_<atime> values are an enum starting from 0,
not a bitmap, users wanting to transition to a different atime setting
cannot simply specify the atime setting in @attr_set, but must also
specify MOUNT_ATTR__ATIME in the @attr_clr field. So we ensure that
MOUNT_ATTR__ATIME can't be partially set in @attr_clr and that @attr_set
can't have any atime bits set if MOUNT_ATTR__ATIME isn't set in
@attr_clr.
The @propagation field lets callers specify the propagation type of a
mount tree. Propagation is a single property that has four different
settings and as such is not really a flag argument but an enum.
Specifically, it would be unclear what setting and clearing propagation
settings in combination would amount to. The legacy mount() syscall thus
forbids the combination of multiple propagation settings too. The goal
is to keep the semantics of mount propagation somewhat simple as they
are overly complex as it is.
The @userns_fd field lets user specify a user namespace whose idmapping
becomes the idmapping of the mount. This is implemented and explained in
detail in the next patch.
[1]: commit 2e4b7fcd9260 ("[PATCH] r/o bind mounts: honor mount writer counts at remount")
Link: https://lore.kernel.org/r/20210121131959.646623-35-christian.brauner@ubuntu.com
Cc: David Howells <dhowells@redhat.com>
Cc: Aleksa Sarai <cyphar@cyphar.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: linux-fsdevel@vger.kernel.org
Cc: linux-api@vger.kernel.org
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Christian Brauner <christian.brauner@ubuntu.com>
2021-01-21 16:19:53 +03:00
|
|
|
static unsigned int recalc_flags(struct mount_kattr *kattr, struct mount *mnt)
|
|
|
|
{
|
|
|
|
unsigned int flags = mnt->mnt.mnt_flags;
|
|
|
|
|
|
|
|
/* flags to clear */
|
|
|
|
flags &= ~kattr->attr_clr;
|
|
|
|
/* flags to raise */
|
|
|
|
flags |= kattr->attr_set;
|
|
|
|
|
|
|
|
return flags;
|
|
|
|
}
|
|
|
|
|
2021-01-21 16:19:54 +03:00
|
|
|
static int can_idmap_mount(const struct mount_kattr *kattr, struct mount *mnt)
|
|
|
|
{
|
|
|
|
struct vfsmount *m = &mnt->mnt;
|
2021-12-03 14:17:07 +03:00
|
|
|
struct user_namespace *fs_userns = m->mnt_sb->s_user_ns;
|
2021-01-21 16:19:54 +03:00
|
|
|
|
2022-10-26 13:51:27 +03:00
|
|
|
if (!kattr->mnt_idmap)
|
2021-01-21 16:19:54 +03:00
|
|
|
return 0;
|
|
|
|
|
2021-12-03 14:17:07 +03:00
|
|
|
/*
|
|
|
|
* Creating an idmapped mount with the filesystem wide idmapping
|
|
|
|
* doesn't make sense so block that. We don't allow mushy semantics.
|
|
|
|
*/
|
2023-01-13 14:49:33 +03:00
|
|
|
if (!check_fsmapping(kattr->mnt_idmap, m->mnt_sb))
|
2021-12-03 14:17:07 +03:00
|
|
|
return -EINVAL;
|
|
|
|
|
2021-01-21 16:19:54 +03:00
|
|
|
/*
|
|
|
|
* Once a mount has been idmapped we don't allow it to change its
|
|
|
|
* mapping. It makes things simpler and callers can just create
|
|
|
|
* another bind-mount they can idmap if they want to.
|
|
|
|
*/
|
2021-12-03 14:16:58 +03:00
|
|
|
if (is_idmapped_mnt(m))
|
2021-01-21 16:19:54 +03:00
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
/* The underlying filesystem doesn't support idmapped mounts yet. */
|
|
|
|
if (!(m->mnt_sb->s_type->fs_flags & FS_ALLOW_IDMAP))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
/* We're not controlling the superblock. */
|
2021-12-03 14:17:07 +03:00
|
|
|
if (!ns_capable(fs_userns, CAP_SYS_ADMIN))
|
2021-01-21 16:19:54 +03:00
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
/* Mount has already been visible in the filesystem hierarchy. */
|
|
|
|
if (!is_anon_ns(mnt->mnt_ns))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2022-02-03 16:14:08 +03:00
|
|
|
/**
|
|
|
|
* mnt_allow_writers() - check whether the attribute change allows writers
|
|
|
|
* @kattr: the new mount attributes
|
|
|
|
* @mnt: the mount to which @kattr will be applied
|
|
|
|
*
|
|
|
|
* Check whether thew new mount attributes in @kattr allow concurrent writers.
|
|
|
|
*
|
|
|
|
* Return: true if writers need to be held, false if not
|
|
|
|
*/
|
|
|
|
static inline bool mnt_allow_writers(const struct mount_kattr *kattr,
|
|
|
|
const struct mount *mnt)
|
fs: add mount_setattr()
This implements the missing mount_setattr() syscall. While the new mount
api allows to change the properties of a superblock there is currently
no way to change the properties of a mount or a mount tree using file
descriptors which the new mount api is based on. In addition the old
mount api has the restriction that mount options cannot be applied
recursively. This hasn't changed since changing mount options on a
per-mount basis was implemented in [1] and has been a frequent request
not just for convenience but also for security reasons. The legacy
mount syscall is unable to accommodate this behavior without introducing
a whole new set of flags because MS_REC | MS_REMOUNT | MS_BIND |
MS_RDONLY | MS_NOEXEC | [...] only apply the mount option to the topmost
mount. Changing MS_REC to apply to the whole mount tree would mean
introducing a significant uapi change and would likely cause significant
regressions.
The new mount_setattr() syscall allows to recursively clear and set
mount options in one shot. Multiple calls to change mount options
requesting the same changes are idempotent:
int mount_setattr(int dfd, const char *path, unsigned flags,
struct mount_attr *uattr, size_t usize);
Flags to modify path resolution behavior are specified in the @flags
argument. Currently, AT_EMPTY_PATH, AT_RECURSIVE, AT_SYMLINK_NOFOLLOW,
and AT_NO_AUTOMOUNT are supported. If useful, additional lookup flags to
restrict path resolution as introduced with openat2() might be supported
in the future.
The mount_setattr() syscall can be expected to grow over time and is
designed with extensibility in mind. It follows the extensible syscall
pattern we have used with other syscalls such as openat2(), clone3(),
sched_{set,get}attr(), and others.
The set of mount options is passed in the uapi struct mount_attr which
currently has the following layout:
struct mount_attr {
__u64 attr_set;
__u64 attr_clr;
__u64 propagation;
__u64 userns_fd;
};
The @attr_set and @attr_clr members are used to clear and set mount
options. This way a user can e.g. request that a set of flags is to be
raised such as turning mounts readonly by raising MOUNT_ATTR_RDONLY in
@attr_set while at the same time requesting that another set of flags is
to be lowered such as removing noexec from a mount tree by specifying
MOUNT_ATTR_NOEXEC in @attr_clr.
Note, since the MOUNT_ATTR_<atime> values are an enum starting from 0,
not a bitmap, users wanting to transition to a different atime setting
cannot simply specify the atime setting in @attr_set, but must also
specify MOUNT_ATTR__ATIME in the @attr_clr field. So we ensure that
MOUNT_ATTR__ATIME can't be partially set in @attr_clr and that @attr_set
can't have any atime bits set if MOUNT_ATTR__ATIME isn't set in
@attr_clr.
The @propagation field lets callers specify the propagation type of a
mount tree. Propagation is a single property that has four different
settings and as such is not really a flag argument but an enum.
Specifically, it would be unclear what setting and clearing propagation
settings in combination would amount to. The legacy mount() syscall thus
forbids the combination of multiple propagation settings too. The goal
is to keep the semantics of mount propagation somewhat simple as they
are overly complex as it is.
The @userns_fd field lets user specify a user namespace whose idmapping
becomes the idmapping of the mount. This is implemented and explained in
detail in the next patch.
[1]: commit 2e4b7fcd9260 ("[PATCH] r/o bind mounts: honor mount writer counts at remount")
Link: https://lore.kernel.org/r/20210121131959.646623-35-christian.brauner@ubuntu.com
Cc: David Howells <dhowells@redhat.com>
Cc: Aleksa Sarai <cyphar@cyphar.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: linux-fsdevel@vger.kernel.org
Cc: linux-api@vger.kernel.org
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Christian Brauner <christian.brauner@ubuntu.com>
2021-01-21 16:19:53 +03:00
|
|
|
{
|
2022-05-10 12:58:40 +03:00
|
|
|
return (!(kattr->attr_set & MNT_READONLY) ||
|
|
|
|
(mnt->mnt.mnt_flags & MNT_READONLY)) &&
|
2022-10-26 13:51:27 +03:00
|
|
|
!kattr->mnt_idmap;
|
2022-02-03 16:14:08 +03:00
|
|
|
}
|
fs: add mount_setattr()
This implements the missing mount_setattr() syscall. While the new mount
api allows to change the properties of a superblock there is currently
no way to change the properties of a mount or a mount tree using file
descriptors which the new mount api is based on. In addition the old
mount api has the restriction that mount options cannot be applied
recursively. This hasn't changed since changing mount options on a
per-mount basis was implemented in [1] and has been a frequent request
not just for convenience but also for security reasons. The legacy
mount syscall is unable to accommodate this behavior without introducing
a whole new set of flags because MS_REC | MS_REMOUNT | MS_BIND |
MS_RDONLY | MS_NOEXEC | [...] only apply the mount option to the topmost
mount. Changing MS_REC to apply to the whole mount tree would mean
introducing a significant uapi change and would likely cause significant
regressions.
The new mount_setattr() syscall allows to recursively clear and set
mount options in one shot. Multiple calls to change mount options
requesting the same changes are idempotent:
int mount_setattr(int dfd, const char *path, unsigned flags,
struct mount_attr *uattr, size_t usize);
Flags to modify path resolution behavior are specified in the @flags
argument. Currently, AT_EMPTY_PATH, AT_RECURSIVE, AT_SYMLINK_NOFOLLOW,
and AT_NO_AUTOMOUNT are supported. If useful, additional lookup flags to
restrict path resolution as introduced with openat2() might be supported
in the future.
The mount_setattr() syscall can be expected to grow over time and is
designed with extensibility in mind. It follows the extensible syscall
pattern we have used with other syscalls such as openat2(), clone3(),
sched_{set,get}attr(), and others.
The set of mount options is passed in the uapi struct mount_attr which
currently has the following layout:
struct mount_attr {
__u64 attr_set;
__u64 attr_clr;
__u64 propagation;
__u64 userns_fd;
};
The @attr_set and @attr_clr members are used to clear and set mount
options. This way a user can e.g. request that a set of flags is to be
raised such as turning mounts readonly by raising MOUNT_ATTR_RDONLY in
@attr_set while at the same time requesting that another set of flags is
to be lowered such as removing noexec from a mount tree by specifying
MOUNT_ATTR_NOEXEC in @attr_clr.
Note, since the MOUNT_ATTR_<atime> values are an enum starting from 0,
not a bitmap, users wanting to transition to a different atime setting
cannot simply specify the atime setting in @attr_set, but must also
specify MOUNT_ATTR__ATIME in the @attr_clr field. So we ensure that
MOUNT_ATTR__ATIME can't be partially set in @attr_clr and that @attr_set
can't have any atime bits set if MOUNT_ATTR__ATIME isn't set in
@attr_clr.
The @propagation field lets callers specify the propagation type of a
mount tree. Propagation is a single property that has four different
settings and as such is not really a flag argument but an enum.
Specifically, it would be unclear what setting and clearing propagation
settings in combination would amount to. The legacy mount() syscall thus
forbids the combination of multiple propagation settings too. The goal
is to keep the semantics of mount propagation somewhat simple as they
are overly complex as it is.
The @userns_fd field lets user specify a user namespace whose idmapping
becomes the idmapping of the mount. This is implemented and explained in
detail in the next patch.
[1]: commit 2e4b7fcd9260 ("[PATCH] r/o bind mounts: honor mount writer counts at remount")
Link: https://lore.kernel.org/r/20210121131959.646623-35-christian.brauner@ubuntu.com
Cc: David Howells <dhowells@redhat.com>
Cc: Aleksa Sarai <cyphar@cyphar.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: linux-fsdevel@vger.kernel.org
Cc: linux-api@vger.kernel.org
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Christian Brauner <christian.brauner@ubuntu.com>
2021-01-21 16:19:53 +03:00
|
|
|
|
2022-02-03 16:14:11 +03:00
|
|
|
static int mount_setattr_prepare(struct mount_kattr *kattr, struct mount *mnt)
|
fs: add mount_setattr()
This implements the missing mount_setattr() syscall. While the new mount
api allows to change the properties of a superblock there is currently
no way to change the properties of a mount or a mount tree using file
descriptors which the new mount api is based on. In addition the old
mount api has the restriction that mount options cannot be applied
recursively. This hasn't changed since changing mount options on a
per-mount basis was implemented in [1] and has been a frequent request
not just for convenience but also for security reasons. The legacy
mount syscall is unable to accommodate this behavior without introducing
a whole new set of flags because MS_REC | MS_REMOUNT | MS_BIND |
MS_RDONLY | MS_NOEXEC | [...] only apply the mount option to the topmost
mount. Changing MS_REC to apply to the whole mount tree would mean
introducing a significant uapi change and would likely cause significant
regressions.
The new mount_setattr() syscall allows to recursively clear and set
mount options in one shot. Multiple calls to change mount options
requesting the same changes are idempotent:
int mount_setattr(int dfd, const char *path, unsigned flags,
struct mount_attr *uattr, size_t usize);
Flags to modify path resolution behavior are specified in the @flags
argument. Currently, AT_EMPTY_PATH, AT_RECURSIVE, AT_SYMLINK_NOFOLLOW,
and AT_NO_AUTOMOUNT are supported. If useful, additional lookup flags to
restrict path resolution as introduced with openat2() might be supported
in the future.
The mount_setattr() syscall can be expected to grow over time and is
designed with extensibility in mind. It follows the extensible syscall
pattern we have used with other syscalls such as openat2(), clone3(),
sched_{set,get}attr(), and others.
The set of mount options is passed in the uapi struct mount_attr which
currently has the following layout:
struct mount_attr {
__u64 attr_set;
__u64 attr_clr;
__u64 propagation;
__u64 userns_fd;
};
The @attr_set and @attr_clr members are used to clear and set mount
options. This way a user can e.g. request that a set of flags is to be
raised such as turning mounts readonly by raising MOUNT_ATTR_RDONLY in
@attr_set while at the same time requesting that another set of flags is
to be lowered such as removing noexec from a mount tree by specifying
MOUNT_ATTR_NOEXEC in @attr_clr.
Note, since the MOUNT_ATTR_<atime> values are an enum starting from 0,
not a bitmap, users wanting to transition to a different atime setting
cannot simply specify the atime setting in @attr_set, but must also
specify MOUNT_ATTR__ATIME in the @attr_clr field. So we ensure that
MOUNT_ATTR__ATIME can't be partially set in @attr_clr and that @attr_set
can't have any atime bits set if MOUNT_ATTR__ATIME isn't set in
@attr_clr.
The @propagation field lets callers specify the propagation type of a
mount tree. Propagation is a single property that has four different
settings and as such is not really a flag argument but an enum.
Specifically, it would be unclear what setting and clearing propagation
settings in combination would amount to. The legacy mount() syscall thus
forbids the combination of multiple propagation settings too. The goal
is to keep the semantics of mount propagation somewhat simple as they
are overly complex as it is.
The @userns_fd field lets user specify a user namespace whose idmapping
becomes the idmapping of the mount. This is implemented and explained in
detail in the next patch.
[1]: commit 2e4b7fcd9260 ("[PATCH] r/o bind mounts: honor mount writer counts at remount")
Link: https://lore.kernel.org/r/20210121131959.646623-35-christian.brauner@ubuntu.com
Cc: David Howells <dhowells@redhat.com>
Cc: Aleksa Sarai <cyphar@cyphar.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: linux-fsdevel@vger.kernel.org
Cc: linux-api@vger.kernel.org
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Christian Brauner <christian.brauner@ubuntu.com>
2021-01-21 16:19:53 +03:00
|
|
|
{
|
2022-03-01 07:04:20 +03:00
|
|
|
struct mount *m;
|
|
|
|
int err;
|
fs: add mount_setattr()
This implements the missing mount_setattr() syscall. While the new mount
api allows to change the properties of a superblock there is currently
no way to change the properties of a mount or a mount tree using file
descriptors which the new mount api is based on. In addition the old
mount api has the restriction that mount options cannot be applied
recursively. This hasn't changed since changing mount options on a
per-mount basis was implemented in [1] and has been a frequent request
not just for convenience but also for security reasons. The legacy
mount syscall is unable to accommodate this behavior without introducing
a whole new set of flags because MS_REC | MS_REMOUNT | MS_BIND |
MS_RDONLY | MS_NOEXEC | [...] only apply the mount option to the topmost
mount. Changing MS_REC to apply to the whole mount tree would mean
introducing a significant uapi change and would likely cause significant
regressions.
The new mount_setattr() syscall allows to recursively clear and set
mount options in one shot. Multiple calls to change mount options
requesting the same changes are idempotent:
int mount_setattr(int dfd, const char *path, unsigned flags,
struct mount_attr *uattr, size_t usize);
Flags to modify path resolution behavior are specified in the @flags
argument. Currently, AT_EMPTY_PATH, AT_RECURSIVE, AT_SYMLINK_NOFOLLOW,
and AT_NO_AUTOMOUNT are supported. If useful, additional lookup flags to
restrict path resolution as introduced with openat2() might be supported
in the future.
The mount_setattr() syscall can be expected to grow over time and is
designed with extensibility in mind. It follows the extensible syscall
pattern we have used with other syscalls such as openat2(), clone3(),
sched_{set,get}attr(), and others.
The set of mount options is passed in the uapi struct mount_attr which
currently has the following layout:
struct mount_attr {
__u64 attr_set;
__u64 attr_clr;
__u64 propagation;
__u64 userns_fd;
};
The @attr_set and @attr_clr members are used to clear and set mount
options. This way a user can e.g. request that a set of flags is to be
raised such as turning mounts readonly by raising MOUNT_ATTR_RDONLY in
@attr_set while at the same time requesting that another set of flags is
to be lowered such as removing noexec from a mount tree by specifying
MOUNT_ATTR_NOEXEC in @attr_clr.
Note, since the MOUNT_ATTR_<atime> values are an enum starting from 0,
not a bitmap, users wanting to transition to a different atime setting
cannot simply specify the atime setting in @attr_set, but must also
specify MOUNT_ATTR__ATIME in the @attr_clr field. So we ensure that
MOUNT_ATTR__ATIME can't be partially set in @attr_clr and that @attr_set
can't have any atime bits set if MOUNT_ATTR__ATIME isn't set in
@attr_clr.
The @propagation field lets callers specify the propagation type of a
mount tree. Propagation is a single property that has four different
settings and as such is not really a flag argument but an enum.
Specifically, it would be unclear what setting and clearing propagation
settings in combination would amount to. The legacy mount() syscall thus
forbids the combination of multiple propagation settings too. The goal
is to keep the semantics of mount propagation somewhat simple as they
are overly complex as it is.
The @userns_fd field lets user specify a user namespace whose idmapping
becomes the idmapping of the mount. This is implemented and explained in
detail in the next patch.
[1]: commit 2e4b7fcd9260 ("[PATCH] r/o bind mounts: honor mount writer counts at remount")
Link: https://lore.kernel.org/r/20210121131959.646623-35-christian.brauner@ubuntu.com
Cc: David Howells <dhowells@redhat.com>
Cc: Aleksa Sarai <cyphar@cyphar.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: linux-fsdevel@vger.kernel.org
Cc: linux-api@vger.kernel.org
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Christian Brauner <christian.brauner@ubuntu.com>
2021-01-21 16:19:53 +03:00
|
|
|
|
2022-03-01 07:04:20 +03:00
|
|
|
for (m = mnt; m; m = next_mnt(m, mnt)) {
|
|
|
|
if (!can_change_locked_flags(m, recalc_flags(kattr, m))) {
|
|
|
|
err = -EPERM;
|
|
|
|
break;
|
|
|
|
}
|
fs: add mount_setattr()
This implements the missing mount_setattr() syscall. While the new mount
api allows to change the properties of a superblock there is currently
no way to change the properties of a mount or a mount tree using file
descriptors which the new mount api is based on. In addition the old
mount api has the restriction that mount options cannot be applied
recursively. This hasn't changed since changing mount options on a
per-mount basis was implemented in [1] and has been a frequent request
not just for convenience but also for security reasons. The legacy
mount syscall is unable to accommodate this behavior without introducing
a whole new set of flags because MS_REC | MS_REMOUNT | MS_BIND |
MS_RDONLY | MS_NOEXEC | [...] only apply the mount option to the topmost
mount. Changing MS_REC to apply to the whole mount tree would mean
introducing a significant uapi change and would likely cause significant
regressions.
The new mount_setattr() syscall allows to recursively clear and set
mount options in one shot. Multiple calls to change mount options
requesting the same changes are idempotent:
int mount_setattr(int dfd, const char *path, unsigned flags,
struct mount_attr *uattr, size_t usize);
Flags to modify path resolution behavior are specified in the @flags
argument. Currently, AT_EMPTY_PATH, AT_RECURSIVE, AT_SYMLINK_NOFOLLOW,
and AT_NO_AUTOMOUNT are supported. If useful, additional lookup flags to
restrict path resolution as introduced with openat2() might be supported
in the future.
The mount_setattr() syscall can be expected to grow over time and is
designed with extensibility in mind. It follows the extensible syscall
pattern we have used with other syscalls such as openat2(), clone3(),
sched_{set,get}attr(), and others.
The set of mount options is passed in the uapi struct mount_attr which
currently has the following layout:
struct mount_attr {
__u64 attr_set;
__u64 attr_clr;
__u64 propagation;
__u64 userns_fd;
};
The @attr_set and @attr_clr members are used to clear and set mount
options. This way a user can e.g. request that a set of flags is to be
raised such as turning mounts readonly by raising MOUNT_ATTR_RDONLY in
@attr_set while at the same time requesting that another set of flags is
to be lowered such as removing noexec from a mount tree by specifying
MOUNT_ATTR_NOEXEC in @attr_clr.
Note, since the MOUNT_ATTR_<atime> values are an enum starting from 0,
not a bitmap, users wanting to transition to a different atime setting
cannot simply specify the atime setting in @attr_set, but must also
specify MOUNT_ATTR__ATIME in the @attr_clr field. So we ensure that
MOUNT_ATTR__ATIME can't be partially set in @attr_clr and that @attr_set
can't have any atime bits set if MOUNT_ATTR__ATIME isn't set in
@attr_clr.
The @propagation field lets callers specify the propagation type of a
mount tree. Propagation is a single property that has four different
settings and as such is not really a flag argument but an enum.
Specifically, it would be unclear what setting and clearing propagation
settings in combination would amount to. The legacy mount() syscall thus
forbids the combination of multiple propagation settings too. The goal
is to keep the semantics of mount propagation somewhat simple as they
are overly complex as it is.
The @userns_fd field lets user specify a user namespace whose idmapping
becomes the idmapping of the mount. This is implemented and explained in
detail in the next patch.
[1]: commit 2e4b7fcd9260 ("[PATCH] r/o bind mounts: honor mount writer counts at remount")
Link: https://lore.kernel.org/r/20210121131959.646623-35-christian.brauner@ubuntu.com
Cc: David Howells <dhowells@redhat.com>
Cc: Aleksa Sarai <cyphar@cyphar.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: linux-fsdevel@vger.kernel.org
Cc: linux-api@vger.kernel.org
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Christian Brauner <christian.brauner@ubuntu.com>
2021-01-21 16:19:53 +03:00
|
|
|
|
2022-02-03 16:14:11 +03:00
|
|
|
err = can_idmap_mount(kattr, m);
|
|
|
|
if (err)
|
2022-03-01 07:04:20 +03:00
|
|
|
break;
|
fs: add mount_setattr()
This implements the missing mount_setattr() syscall. While the new mount
api allows to change the properties of a superblock there is currently
no way to change the properties of a mount or a mount tree using file
descriptors which the new mount api is based on. In addition the old
mount api has the restriction that mount options cannot be applied
recursively. This hasn't changed since changing mount options on a
per-mount basis was implemented in [1] and has been a frequent request
not just for convenience but also for security reasons. The legacy
mount syscall is unable to accommodate this behavior without introducing
a whole new set of flags because MS_REC | MS_REMOUNT | MS_BIND |
MS_RDONLY | MS_NOEXEC | [...] only apply the mount option to the topmost
mount. Changing MS_REC to apply to the whole mount tree would mean
introducing a significant uapi change and would likely cause significant
regressions.
The new mount_setattr() syscall allows to recursively clear and set
mount options in one shot. Multiple calls to change mount options
requesting the same changes are idempotent:
int mount_setattr(int dfd, const char *path, unsigned flags,
struct mount_attr *uattr, size_t usize);
Flags to modify path resolution behavior are specified in the @flags
argument. Currently, AT_EMPTY_PATH, AT_RECURSIVE, AT_SYMLINK_NOFOLLOW,
and AT_NO_AUTOMOUNT are supported. If useful, additional lookup flags to
restrict path resolution as introduced with openat2() might be supported
in the future.
The mount_setattr() syscall can be expected to grow over time and is
designed with extensibility in mind. It follows the extensible syscall
pattern we have used with other syscalls such as openat2(), clone3(),
sched_{set,get}attr(), and others.
The set of mount options is passed in the uapi struct mount_attr which
currently has the following layout:
struct mount_attr {
__u64 attr_set;
__u64 attr_clr;
__u64 propagation;
__u64 userns_fd;
};
The @attr_set and @attr_clr members are used to clear and set mount
options. This way a user can e.g. request that a set of flags is to be
raised such as turning mounts readonly by raising MOUNT_ATTR_RDONLY in
@attr_set while at the same time requesting that another set of flags is
to be lowered such as removing noexec from a mount tree by specifying
MOUNT_ATTR_NOEXEC in @attr_clr.
Note, since the MOUNT_ATTR_<atime> values are an enum starting from 0,
not a bitmap, users wanting to transition to a different atime setting
cannot simply specify the atime setting in @attr_set, but must also
specify MOUNT_ATTR__ATIME in the @attr_clr field. So we ensure that
MOUNT_ATTR__ATIME can't be partially set in @attr_clr and that @attr_set
can't have any atime bits set if MOUNT_ATTR__ATIME isn't set in
@attr_clr.
The @propagation field lets callers specify the propagation type of a
mount tree. Propagation is a single property that has four different
settings and as such is not really a flag argument but an enum.
Specifically, it would be unclear what setting and clearing propagation
settings in combination would amount to. The legacy mount() syscall thus
forbids the combination of multiple propagation settings too. The goal
is to keep the semantics of mount propagation somewhat simple as they
are overly complex as it is.
The @userns_fd field lets user specify a user namespace whose idmapping
becomes the idmapping of the mount. This is implemented and explained in
detail in the next patch.
[1]: commit 2e4b7fcd9260 ("[PATCH] r/o bind mounts: honor mount writer counts at remount")
Link: https://lore.kernel.org/r/20210121131959.646623-35-christian.brauner@ubuntu.com
Cc: David Howells <dhowells@redhat.com>
Cc: Aleksa Sarai <cyphar@cyphar.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: linux-fsdevel@vger.kernel.org
Cc: linux-api@vger.kernel.org
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Christian Brauner <christian.brauner@ubuntu.com>
2021-01-21 16:19:53 +03:00
|
|
|
|
2022-03-01 07:04:20 +03:00
|
|
|
if (!mnt_allow_writers(kattr, m)) {
|
|
|
|
err = mnt_hold_writers(m);
|
|
|
|
if (err)
|
|
|
|
break;
|
fs: add mount_setattr()
This implements the missing mount_setattr() syscall. While the new mount
api allows to change the properties of a superblock there is currently
no way to change the properties of a mount or a mount tree using file
descriptors which the new mount api is based on. In addition the old
mount api has the restriction that mount options cannot be applied
recursively. This hasn't changed since changing mount options on a
per-mount basis was implemented in [1] and has been a frequent request
not just for convenience but also for security reasons. The legacy
mount syscall is unable to accommodate this behavior without introducing
a whole new set of flags because MS_REC | MS_REMOUNT | MS_BIND |
MS_RDONLY | MS_NOEXEC | [...] only apply the mount option to the topmost
mount. Changing MS_REC to apply to the whole mount tree would mean
introducing a significant uapi change and would likely cause significant
regressions.
The new mount_setattr() syscall allows to recursively clear and set
mount options in one shot. Multiple calls to change mount options
requesting the same changes are idempotent:
int mount_setattr(int dfd, const char *path, unsigned flags,
struct mount_attr *uattr, size_t usize);
Flags to modify path resolution behavior are specified in the @flags
argument. Currently, AT_EMPTY_PATH, AT_RECURSIVE, AT_SYMLINK_NOFOLLOW,
and AT_NO_AUTOMOUNT are supported. If useful, additional lookup flags to
restrict path resolution as introduced with openat2() might be supported
in the future.
The mount_setattr() syscall can be expected to grow over time and is
designed with extensibility in mind. It follows the extensible syscall
pattern we have used with other syscalls such as openat2(), clone3(),
sched_{set,get}attr(), and others.
The set of mount options is passed in the uapi struct mount_attr which
currently has the following layout:
struct mount_attr {
__u64 attr_set;
__u64 attr_clr;
__u64 propagation;
__u64 userns_fd;
};
The @attr_set and @attr_clr members are used to clear and set mount
options. This way a user can e.g. request that a set of flags is to be
raised such as turning mounts readonly by raising MOUNT_ATTR_RDONLY in
@attr_set while at the same time requesting that another set of flags is
to be lowered such as removing noexec from a mount tree by specifying
MOUNT_ATTR_NOEXEC in @attr_clr.
Note, since the MOUNT_ATTR_<atime> values are an enum starting from 0,
not a bitmap, users wanting to transition to a different atime setting
cannot simply specify the atime setting in @attr_set, but must also
specify MOUNT_ATTR__ATIME in the @attr_clr field. So we ensure that
MOUNT_ATTR__ATIME can't be partially set in @attr_clr and that @attr_set
can't have any atime bits set if MOUNT_ATTR__ATIME isn't set in
@attr_clr.
The @propagation field lets callers specify the propagation type of a
mount tree. Propagation is a single property that has four different
settings and as such is not really a flag argument but an enum.
Specifically, it would be unclear what setting and clearing propagation
settings in combination would amount to. The legacy mount() syscall thus
forbids the combination of multiple propagation settings too. The goal
is to keep the semantics of mount propagation somewhat simple as they
are overly complex as it is.
The @userns_fd field lets user specify a user namespace whose idmapping
becomes the idmapping of the mount. This is implemented and explained in
detail in the next patch.
[1]: commit 2e4b7fcd9260 ("[PATCH] r/o bind mounts: honor mount writer counts at remount")
Link: https://lore.kernel.org/r/20210121131959.646623-35-christian.brauner@ubuntu.com
Cc: David Howells <dhowells@redhat.com>
Cc: Aleksa Sarai <cyphar@cyphar.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: linux-fsdevel@vger.kernel.org
Cc: linux-api@vger.kernel.org
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Christian Brauner <christian.brauner@ubuntu.com>
2021-01-21 16:19:53 +03:00
|
|
|
}
|
|
|
|
|
2022-03-01 07:04:20 +03:00
|
|
|
if (!kattr->recurse)
|
|
|
|
return 0;
|
|
|
|
}
|
2021-01-21 16:19:54 +03:00
|
|
|
|
2022-03-01 07:04:20 +03:00
|
|
|
if (err) {
|
|
|
|
struct mount *p;
|
fs: add mount_setattr()
This implements the missing mount_setattr() syscall. While the new mount
api allows to change the properties of a superblock there is currently
no way to change the properties of a mount or a mount tree using file
descriptors which the new mount api is based on. In addition the old
mount api has the restriction that mount options cannot be applied
recursively. This hasn't changed since changing mount options on a
per-mount basis was implemented in [1] and has been a frequent request
not just for convenience but also for security reasons. The legacy
mount syscall is unable to accommodate this behavior without introducing
a whole new set of flags because MS_REC | MS_REMOUNT | MS_BIND |
MS_RDONLY | MS_NOEXEC | [...] only apply the mount option to the topmost
mount. Changing MS_REC to apply to the whole mount tree would mean
introducing a significant uapi change and would likely cause significant
regressions.
The new mount_setattr() syscall allows to recursively clear and set
mount options in one shot. Multiple calls to change mount options
requesting the same changes are idempotent:
int mount_setattr(int dfd, const char *path, unsigned flags,
struct mount_attr *uattr, size_t usize);
Flags to modify path resolution behavior are specified in the @flags
argument. Currently, AT_EMPTY_PATH, AT_RECURSIVE, AT_SYMLINK_NOFOLLOW,
and AT_NO_AUTOMOUNT are supported. If useful, additional lookup flags to
restrict path resolution as introduced with openat2() might be supported
in the future.
The mount_setattr() syscall can be expected to grow over time and is
designed with extensibility in mind. It follows the extensible syscall
pattern we have used with other syscalls such as openat2(), clone3(),
sched_{set,get}attr(), and others.
The set of mount options is passed in the uapi struct mount_attr which
currently has the following layout:
struct mount_attr {
__u64 attr_set;
__u64 attr_clr;
__u64 propagation;
__u64 userns_fd;
};
The @attr_set and @attr_clr members are used to clear and set mount
options. This way a user can e.g. request that a set of flags is to be
raised such as turning mounts readonly by raising MOUNT_ATTR_RDONLY in
@attr_set while at the same time requesting that another set of flags is
to be lowered such as removing noexec from a mount tree by specifying
MOUNT_ATTR_NOEXEC in @attr_clr.
Note, since the MOUNT_ATTR_<atime> values are an enum starting from 0,
not a bitmap, users wanting to transition to a different atime setting
cannot simply specify the atime setting in @attr_set, but must also
specify MOUNT_ATTR__ATIME in the @attr_clr field. So we ensure that
MOUNT_ATTR__ATIME can't be partially set in @attr_clr and that @attr_set
can't have any atime bits set if MOUNT_ATTR__ATIME isn't set in
@attr_clr.
The @propagation field lets callers specify the propagation type of a
mount tree. Propagation is a single property that has four different
settings and as such is not really a flag argument but an enum.
Specifically, it would be unclear what setting and clearing propagation
settings in combination would amount to. The legacy mount() syscall thus
forbids the combination of multiple propagation settings too. The goal
is to keep the semantics of mount propagation somewhat simple as they
are overly complex as it is.
The @userns_fd field lets user specify a user namespace whose idmapping
becomes the idmapping of the mount. This is implemented and explained in
detail in the next patch.
[1]: commit 2e4b7fcd9260 ("[PATCH] r/o bind mounts: honor mount writer counts at remount")
Link: https://lore.kernel.org/r/20210121131959.646623-35-christian.brauner@ubuntu.com
Cc: David Howells <dhowells@redhat.com>
Cc: Aleksa Sarai <cyphar@cyphar.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: linux-fsdevel@vger.kernel.org
Cc: linux-api@vger.kernel.org
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Christian Brauner <christian.brauner@ubuntu.com>
2021-01-21 16:19:53 +03:00
|
|
|
|
2022-04-20 16:19:25 +03:00
|
|
|
/*
|
|
|
|
* If we had to call mnt_hold_writers() MNT_WRITE_HOLD will
|
|
|
|
* be set in @mnt_flags. The loop unsets MNT_WRITE_HOLD for all
|
|
|
|
* mounts and needs to take care to include the first mount.
|
|
|
|
*/
|
|
|
|
for (p = mnt; p; p = next_mnt(p, mnt)) {
|
2022-03-01 07:04:20 +03:00
|
|
|
/* If we had to hold writers unblock them. */
|
|
|
|
if (p->mnt.mnt_flags & MNT_WRITE_HOLD)
|
|
|
|
mnt_unhold_writers(p);
|
2022-04-20 16:19:25 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We're done once the first mount we changed got
|
|
|
|
* MNT_WRITE_HOLD unset.
|
|
|
|
*/
|
|
|
|
if (p == m)
|
|
|
|
break;
|
fs: add mount_setattr()
This implements the missing mount_setattr() syscall. While the new mount
api allows to change the properties of a superblock there is currently
no way to change the properties of a mount or a mount tree using file
descriptors which the new mount api is based on. In addition the old
mount api has the restriction that mount options cannot be applied
recursively. This hasn't changed since changing mount options on a
per-mount basis was implemented in [1] and has been a frequent request
not just for convenience but also for security reasons. The legacy
mount syscall is unable to accommodate this behavior without introducing
a whole new set of flags because MS_REC | MS_REMOUNT | MS_BIND |
MS_RDONLY | MS_NOEXEC | [...] only apply the mount option to the topmost
mount. Changing MS_REC to apply to the whole mount tree would mean
introducing a significant uapi change and would likely cause significant
regressions.
The new mount_setattr() syscall allows to recursively clear and set
mount options in one shot. Multiple calls to change mount options
requesting the same changes are idempotent:
int mount_setattr(int dfd, const char *path, unsigned flags,
struct mount_attr *uattr, size_t usize);
Flags to modify path resolution behavior are specified in the @flags
argument. Currently, AT_EMPTY_PATH, AT_RECURSIVE, AT_SYMLINK_NOFOLLOW,
and AT_NO_AUTOMOUNT are supported. If useful, additional lookup flags to
restrict path resolution as introduced with openat2() might be supported
in the future.
The mount_setattr() syscall can be expected to grow over time and is
designed with extensibility in mind. It follows the extensible syscall
pattern we have used with other syscalls such as openat2(), clone3(),
sched_{set,get}attr(), and others.
The set of mount options is passed in the uapi struct mount_attr which
currently has the following layout:
struct mount_attr {
__u64 attr_set;
__u64 attr_clr;
__u64 propagation;
__u64 userns_fd;
};
The @attr_set and @attr_clr members are used to clear and set mount
options. This way a user can e.g. request that a set of flags is to be
raised such as turning mounts readonly by raising MOUNT_ATTR_RDONLY in
@attr_set while at the same time requesting that another set of flags is
to be lowered such as removing noexec from a mount tree by specifying
MOUNT_ATTR_NOEXEC in @attr_clr.
Note, since the MOUNT_ATTR_<atime> values are an enum starting from 0,
not a bitmap, users wanting to transition to a different atime setting
cannot simply specify the atime setting in @attr_set, but must also
specify MOUNT_ATTR__ATIME in the @attr_clr field. So we ensure that
MOUNT_ATTR__ATIME can't be partially set in @attr_clr and that @attr_set
can't have any atime bits set if MOUNT_ATTR__ATIME isn't set in
@attr_clr.
The @propagation field lets callers specify the propagation type of a
mount tree. Propagation is a single property that has four different
settings and as such is not really a flag argument but an enum.
Specifically, it would be unclear what setting and clearing propagation
settings in combination would amount to. The legacy mount() syscall thus
forbids the combination of multiple propagation settings too. The goal
is to keep the semantics of mount propagation somewhat simple as they
are overly complex as it is.
The @userns_fd field lets user specify a user namespace whose idmapping
becomes the idmapping of the mount. This is implemented and explained in
detail in the next patch.
[1]: commit 2e4b7fcd9260 ("[PATCH] r/o bind mounts: honor mount writer counts at remount")
Link: https://lore.kernel.org/r/20210121131959.646623-35-christian.brauner@ubuntu.com
Cc: David Howells <dhowells@redhat.com>
Cc: Aleksa Sarai <cyphar@cyphar.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: linux-fsdevel@vger.kernel.org
Cc: linux-api@vger.kernel.org
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Christian Brauner <christian.brauner@ubuntu.com>
2021-01-21 16:19:53 +03:00
|
|
|
}
|
2022-03-01 07:04:20 +03:00
|
|
|
}
|
|
|
|
return err;
|
fs: add mount_setattr()
This implements the missing mount_setattr() syscall. While the new mount
api allows to change the properties of a superblock there is currently
no way to change the properties of a mount or a mount tree using file
descriptors which the new mount api is based on. In addition the old
mount api has the restriction that mount options cannot be applied
recursively. This hasn't changed since changing mount options on a
per-mount basis was implemented in [1] and has been a frequent request
not just for convenience but also for security reasons. The legacy
mount syscall is unable to accommodate this behavior without introducing
a whole new set of flags because MS_REC | MS_REMOUNT | MS_BIND |
MS_RDONLY | MS_NOEXEC | [...] only apply the mount option to the topmost
mount. Changing MS_REC to apply to the whole mount tree would mean
introducing a significant uapi change and would likely cause significant
regressions.
The new mount_setattr() syscall allows to recursively clear and set
mount options in one shot. Multiple calls to change mount options
requesting the same changes are idempotent:
int mount_setattr(int dfd, const char *path, unsigned flags,
struct mount_attr *uattr, size_t usize);
Flags to modify path resolution behavior are specified in the @flags
argument. Currently, AT_EMPTY_PATH, AT_RECURSIVE, AT_SYMLINK_NOFOLLOW,
and AT_NO_AUTOMOUNT are supported. If useful, additional lookup flags to
restrict path resolution as introduced with openat2() might be supported
in the future.
The mount_setattr() syscall can be expected to grow over time and is
designed with extensibility in mind. It follows the extensible syscall
pattern we have used with other syscalls such as openat2(), clone3(),
sched_{set,get}attr(), and others.
The set of mount options is passed in the uapi struct mount_attr which
currently has the following layout:
struct mount_attr {
__u64 attr_set;
__u64 attr_clr;
__u64 propagation;
__u64 userns_fd;
};
The @attr_set and @attr_clr members are used to clear and set mount
options. This way a user can e.g. request that a set of flags is to be
raised such as turning mounts readonly by raising MOUNT_ATTR_RDONLY in
@attr_set while at the same time requesting that another set of flags is
to be lowered such as removing noexec from a mount tree by specifying
MOUNT_ATTR_NOEXEC in @attr_clr.
Note, since the MOUNT_ATTR_<atime> values are an enum starting from 0,
not a bitmap, users wanting to transition to a different atime setting
cannot simply specify the atime setting in @attr_set, but must also
specify MOUNT_ATTR__ATIME in the @attr_clr field. So we ensure that
MOUNT_ATTR__ATIME can't be partially set in @attr_clr and that @attr_set
can't have any atime bits set if MOUNT_ATTR__ATIME isn't set in
@attr_clr.
The @propagation field lets callers specify the propagation type of a
mount tree. Propagation is a single property that has four different
settings and as such is not really a flag argument but an enum.
Specifically, it would be unclear what setting and clearing propagation
settings in combination would amount to. The legacy mount() syscall thus
forbids the combination of multiple propagation settings too. The goal
is to keep the semantics of mount propagation somewhat simple as they
are overly complex as it is.
The @userns_fd field lets user specify a user namespace whose idmapping
becomes the idmapping of the mount. This is implemented and explained in
detail in the next patch.
[1]: commit 2e4b7fcd9260 ("[PATCH] r/o bind mounts: honor mount writer counts at remount")
Link: https://lore.kernel.org/r/20210121131959.646623-35-christian.brauner@ubuntu.com
Cc: David Howells <dhowells@redhat.com>
Cc: Aleksa Sarai <cyphar@cyphar.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: linux-fsdevel@vger.kernel.org
Cc: linux-api@vger.kernel.org
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Christian Brauner <christian.brauner@ubuntu.com>
2021-01-21 16:19:53 +03:00
|
|
|
}
|
|
|
|
|
2021-01-21 16:19:54 +03:00
|
|
|
static void do_idmap_mount(const struct mount_kattr *kattr, struct mount *mnt)
|
|
|
|
{
|
2022-10-26 13:51:27 +03:00
|
|
|
if (!kattr->mnt_idmap)
|
2021-01-21 16:19:54 +03:00
|
|
|
return;
|
|
|
|
|
2021-12-03 14:17:07 +03:00
|
|
|
/*
|
2022-10-26 13:51:27 +03:00
|
|
|
* Pairs with smp_load_acquire() in mnt_idmap().
|
|
|
|
*
|
|
|
|
* Since we only allow a mount to change the idmapping once and
|
|
|
|
* verified this in can_idmap_mount() we know that the mount has
|
|
|
|
* @nop_mnt_idmap attached to it. So there's no need to drop any
|
|
|
|
* references.
|
2021-12-03 14:17:07 +03:00
|
|
|
*/
|
2022-10-26 13:51:27 +03:00
|
|
|
smp_store_release(&mnt->mnt.mnt_idmap, mnt_idmap_get(kattr->mnt_idmap));
|
2021-01-21 16:19:54 +03:00
|
|
|
}
|
|
|
|
|
2022-03-01 07:04:20 +03:00
|
|
|
static void mount_setattr_commit(struct mount_kattr *kattr, struct mount *mnt)
|
fs: add mount_setattr()
This implements the missing mount_setattr() syscall. While the new mount
api allows to change the properties of a superblock there is currently
no way to change the properties of a mount or a mount tree using file
descriptors which the new mount api is based on. In addition the old
mount api has the restriction that mount options cannot be applied
recursively. This hasn't changed since changing mount options on a
per-mount basis was implemented in [1] and has been a frequent request
not just for convenience but also for security reasons. The legacy
mount syscall is unable to accommodate this behavior without introducing
a whole new set of flags because MS_REC | MS_REMOUNT | MS_BIND |
MS_RDONLY | MS_NOEXEC | [...] only apply the mount option to the topmost
mount. Changing MS_REC to apply to the whole mount tree would mean
introducing a significant uapi change and would likely cause significant
regressions.
The new mount_setattr() syscall allows to recursively clear and set
mount options in one shot. Multiple calls to change mount options
requesting the same changes are idempotent:
int mount_setattr(int dfd, const char *path, unsigned flags,
struct mount_attr *uattr, size_t usize);
Flags to modify path resolution behavior are specified in the @flags
argument. Currently, AT_EMPTY_PATH, AT_RECURSIVE, AT_SYMLINK_NOFOLLOW,
and AT_NO_AUTOMOUNT are supported. If useful, additional lookup flags to
restrict path resolution as introduced with openat2() might be supported
in the future.
The mount_setattr() syscall can be expected to grow over time and is
designed with extensibility in mind. It follows the extensible syscall
pattern we have used with other syscalls such as openat2(), clone3(),
sched_{set,get}attr(), and others.
The set of mount options is passed in the uapi struct mount_attr which
currently has the following layout:
struct mount_attr {
__u64 attr_set;
__u64 attr_clr;
__u64 propagation;
__u64 userns_fd;
};
The @attr_set and @attr_clr members are used to clear and set mount
options. This way a user can e.g. request that a set of flags is to be
raised such as turning mounts readonly by raising MOUNT_ATTR_RDONLY in
@attr_set while at the same time requesting that another set of flags is
to be lowered such as removing noexec from a mount tree by specifying
MOUNT_ATTR_NOEXEC in @attr_clr.
Note, since the MOUNT_ATTR_<atime> values are an enum starting from 0,
not a bitmap, users wanting to transition to a different atime setting
cannot simply specify the atime setting in @attr_set, but must also
specify MOUNT_ATTR__ATIME in the @attr_clr field. So we ensure that
MOUNT_ATTR__ATIME can't be partially set in @attr_clr and that @attr_set
can't have any atime bits set if MOUNT_ATTR__ATIME isn't set in
@attr_clr.
The @propagation field lets callers specify the propagation type of a
mount tree. Propagation is a single property that has four different
settings and as such is not really a flag argument but an enum.
Specifically, it would be unclear what setting and clearing propagation
settings in combination would amount to. The legacy mount() syscall thus
forbids the combination of multiple propagation settings too. The goal
is to keep the semantics of mount propagation somewhat simple as they
are overly complex as it is.
The @userns_fd field lets user specify a user namespace whose idmapping
becomes the idmapping of the mount. This is implemented and explained in
detail in the next patch.
[1]: commit 2e4b7fcd9260 ("[PATCH] r/o bind mounts: honor mount writer counts at remount")
Link: https://lore.kernel.org/r/20210121131959.646623-35-christian.brauner@ubuntu.com
Cc: David Howells <dhowells@redhat.com>
Cc: Aleksa Sarai <cyphar@cyphar.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: linux-fsdevel@vger.kernel.org
Cc: linux-api@vger.kernel.org
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Christian Brauner <christian.brauner@ubuntu.com>
2021-01-21 16:19:53 +03:00
|
|
|
{
|
2022-03-01 07:04:20 +03:00
|
|
|
struct mount *m;
|
fs: add mount_setattr()
This implements the missing mount_setattr() syscall. While the new mount
api allows to change the properties of a superblock there is currently
no way to change the properties of a mount or a mount tree using file
descriptors which the new mount api is based on. In addition the old
mount api has the restriction that mount options cannot be applied
recursively. This hasn't changed since changing mount options on a
per-mount basis was implemented in [1] and has been a frequent request
not just for convenience but also for security reasons. The legacy
mount syscall is unable to accommodate this behavior without introducing
a whole new set of flags because MS_REC | MS_REMOUNT | MS_BIND |
MS_RDONLY | MS_NOEXEC | [...] only apply the mount option to the topmost
mount. Changing MS_REC to apply to the whole mount tree would mean
introducing a significant uapi change and would likely cause significant
regressions.
The new mount_setattr() syscall allows to recursively clear and set
mount options in one shot. Multiple calls to change mount options
requesting the same changes are idempotent:
int mount_setattr(int dfd, const char *path, unsigned flags,
struct mount_attr *uattr, size_t usize);
Flags to modify path resolution behavior are specified in the @flags
argument. Currently, AT_EMPTY_PATH, AT_RECURSIVE, AT_SYMLINK_NOFOLLOW,
and AT_NO_AUTOMOUNT are supported. If useful, additional lookup flags to
restrict path resolution as introduced with openat2() might be supported
in the future.
The mount_setattr() syscall can be expected to grow over time and is
designed with extensibility in mind. It follows the extensible syscall
pattern we have used with other syscalls such as openat2(), clone3(),
sched_{set,get}attr(), and others.
The set of mount options is passed in the uapi struct mount_attr which
currently has the following layout:
struct mount_attr {
__u64 attr_set;
__u64 attr_clr;
__u64 propagation;
__u64 userns_fd;
};
The @attr_set and @attr_clr members are used to clear and set mount
options. This way a user can e.g. request that a set of flags is to be
raised such as turning mounts readonly by raising MOUNT_ATTR_RDONLY in
@attr_set while at the same time requesting that another set of flags is
to be lowered such as removing noexec from a mount tree by specifying
MOUNT_ATTR_NOEXEC in @attr_clr.
Note, since the MOUNT_ATTR_<atime> values are an enum starting from 0,
not a bitmap, users wanting to transition to a different atime setting
cannot simply specify the atime setting in @attr_set, but must also
specify MOUNT_ATTR__ATIME in the @attr_clr field. So we ensure that
MOUNT_ATTR__ATIME can't be partially set in @attr_clr and that @attr_set
can't have any atime bits set if MOUNT_ATTR__ATIME isn't set in
@attr_clr.
The @propagation field lets callers specify the propagation type of a
mount tree. Propagation is a single property that has four different
settings and as such is not really a flag argument but an enum.
Specifically, it would be unclear what setting and clearing propagation
settings in combination would amount to. The legacy mount() syscall thus
forbids the combination of multiple propagation settings too. The goal
is to keep the semantics of mount propagation somewhat simple as they
are overly complex as it is.
The @userns_fd field lets user specify a user namespace whose idmapping
becomes the idmapping of the mount. This is implemented and explained in
detail in the next patch.
[1]: commit 2e4b7fcd9260 ("[PATCH] r/o bind mounts: honor mount writer counts at remount")
Link: https://lore.kernel.org/r/20210121131959.646623-35-christian.brauner@ubuntu.com
Cc: David Howells <dhowells@redhat.com>
Cc: Aleksa Sarai <cyphar@cyphar.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: linux-fsdevel@vger.kernel.org
Cc: linux-api@vger.kernel.org
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Christian Brauner <christian.brauner@ubuntu.com>
2021-01-21 16:19:53 +03:00
|
|
|
|
2022-03-01 07:04:20 +03:00
|
|
|
for (m = mnt; m; m = next_mnt(m, mnt)) {
|
|
|
|
unsigned int flags;
|
fs: add mount_setattr()
This implements the missing mount_setattr() syscall. While the new mount
api allows to change the properties of a superblock there is currently
no way to change the properties of a mount or a mount tree using file
descriptors which the new mount api is based on. In addition the old
mount api has the restriction that mount options cannot be applied
recursively. This hasn't changed since changing mount options on a
per-mount basis was implemented in [1] and has been a frequent request
not just for convenience but also for security reasons. The legacy
mount syscall is unable to accommodate this behavior without introducing
a whole new set of flags because MS_REC | MS_REMOUNT | MS_BIND |
MS_RDONLY | MS_NOEXEC | [...] only apply the mount option to the topmost
mount. Changing MS_REC to apply to the whole mount tree would mean
introducing a significant uapi change and would likely cause significant
regressions.
The new mount_setattr() syscall allows to recursively clear and set
mount options in one shot. Multiple calls to change mount options
requesting the same changes are idempotent:
int mount_setattr(int dfd, const char *path, unsigned flags,
struct mount_attr *uattr, size_t usize);
Flags to modify path resolution behavior are specified in the @flags
argument. Currently, AT_EMPTY_PATH, AT_RECURSIVE, AT_SYMLINK_NOFOLLOW,
and AT_NO_AUTOMOUNT are supported. If useful, additional lookup flags to
restrict path resolution as introduced with openat2() might be supported
in the future.
The mount_setattr() syscall can be expected to grow over time and is
designed with extensibility in mind. It follows the extensible syscall
pattern we have used with other syscalls such as openat2(), clone3(),
sched_{set,get}attr(), and others.
The set of mount options is passed in the uapi struct mount_attr which
currently has the following layout:
struct mount_attr {
__u64 attr_set;
__u64 attr_clr;
__u64 propagation;
__u64 userns_fd;
};
The @attr_set and @attr_clr members are used to clear and set mount
options. This way a user can e.g. request that a set of flags is to be
raised such as turning mounts readonly by raising MOUNT_ATTR_RDONLY in
@attr_set while at the same time requesting that another set of flags is
to be lowered such as removing noexec from a mount tree by specifying
MOUNT_ATTR_NOEXEC in @attr_clr.
Note, since the MOUNT_ATTR_<atime> values are an enum starting from 0,
not a bitmap, users wanting to transition to a different atime setting
cannot simply specify the atime setting in @attr_set, but must also
specify MOUNT_ATTR__ATIME in the @attr_clr field. So we ensure that
MOUNT_ATTR__ATIME can't be partially set in @attr_clr and that @attr_set
can't have any atime bits set if MOUNT_ATTR__ATIME isn't set in
@attr_clr.
The @propagation field lets callers specify the propagation type of a
mount tree. Propagation is a single property that has four different
settings and as such is not really a flag argument but an enum.
Specifically, it would be unclear what setting and clearing propagation
settings in combination would amount to. The legacy mount() syscall thus
forbids the combination of multiple propagation settings too. The goal
is to keep the semantics of mount propagation somewhat simple as they
are overly complex as it is.
The @userns_fd field lets user specify a user namespace whose idmapping
becomes the idmapping of the mount. This is implemented and explained in
detail in the next patch.
[1]: commit 2e4b7fcd9260 ("[PATCH] r/o bind mounts: honor mount writer counts at remount")
Link: https://lore.kernel.org/r/20210121131959.646623-35-christian.brauner@ubuntu.com
Cc: David Howells <dhowells@redhat.com>
Cc: Aleksa Sarai <cyphar@cyphar.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: linux-fsdevel@vger.kernel.org
Cc: linux-api@vger.kernel.org
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Christian Brauner <christian.brauner@ubuntu.com>
2021-01-21 16:19:53 +03:00
|
|
|
|
2022-03-01 07:04:20 +03:00
|
|
|
do_idmap_mount(kattr, m);
|
|
|
|
flags = recalc_flags(kattr, m);
|
|
|
|
WRITE_ONCE(m->mnt.mnt_flags, flags);
|
fs: add mount_setattr()
This implements the missing mount_setattr() syscall. While the new mount
api allows to change the properties of a superblock there is currently
no way to change the properties of a mount or a mount tree using file
descriptors which the new mount api is based on. In addition the old
mount api has the restriction that mount options cannot be applied
recursively. This hasn't changed since changing mount options on a
per-mount basis was implemented in [1] and has been a frequent request
not just for convenience but also for security reasons. The legacy
mount syscall is unable to accommodate this behavior without introducing
a whole new set of flags because MS_REC | MS_REMOUNT | MS_BIND |
MS_RDONLY | MS_NOEXEC | [...] only apply the mount option to the topmost
mount. Changing MS_REC to apply to the whole mount tree would mean
introducing a significant uapi change and would likely cause significant
regressions.
The new mount_setattr() syscall allows to recursively clear and set
mount options in one shot. Multiple calls to change mount options
requesting the same changes are idempotent:
int mount_setattr(int dfd, const char *path, unsigned flags,
struct mount_attr *uattr, size_t usize);
Flags to modify path resolution behavior are specified in the @flags
argument. Currently, AT_EMPTY_PATH, AT_RECURSIVE, AT_SYMLINK_NOFOLLOW,
and AT_NO_AUTOMOUNT are supported. If useful, additional lookup flags to
restrict path resolution as introduced with openat2() might be supported
in the future.
The mount_setattr() syscall can be expected to grow over time and is
designed with extensibility in mind. It follows the extensible syscall
pattern we have used with other syscalls such as openat2(), clone3(),
sched_{set,get}attr(), and others.
The set of mount options is passed in the uapi struct mount_attr which
currently has the following layout:
struct mount_attr {
__u64 attr_set;
__u64 attr_clr;
__u64 propagation;
__u64 userns_fd;
};
The @attr_set and @attr_clr members are used to clear and set mount
options. This way a user can e.g. request that a set of flags is to be
raised such as turning mounts readonly by raising MOUNT_ATTR_RDONLY in
@attr_set while at the same time requesting that another set of flags is
to be lowered such as removing noexec from a mount tree by specifying
MOUNT_ATTR_NOEXEC in @attr_clr.
Note, since the MOUNT_ATTR_<atime> values are an enum starting from 0,
not a bitmap, users wanting to transition to a different atime setting
cannot simply specify the atime setting in @attr_set, but must also
specify MOUNT_ATTR__ATIME in the @attr_clr field. So we ensure that
MOUNT_ATTR__ATIME can't be partially set in @attr_clr and that @attr_set
can't have any atime bits set if MOUNT_ATTR__ATIME isn't set in
@attr_clr.
The @propagation field lets callers specify the propagation type of a
mount tree. Propagation is a single property that has four different
settings and as such is not really a flag argument but an enum.
Specifically, it would be unclear what setting and clearing propagation
settings in combination would amount to. The legacy mount() syscall thus
forbids the combination of multiple propagation settings too. The goal
is to keep the semantics of mount propagation somewhat simple as they
are overly complex as it is.
The @userns_fd field lets user specify a user namespace whose idmapping
becomes the idmapping of the mount. This is implemented and explained in
detail in the next patch.
[1]: commit 2e4b7fcd9260 ("[PATCH] r/o bind mounts: honor mount writer counts at remount")
Link: https://lore.kernel.org/r/20210121131959.646623-35-christian.brauner@ubuntu.com
Cc: David Howells <dhowells@redhat.com>
Cc: Aleksa Sarai <cyphar@cyphar.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: linux-fsdevel@vger.kernel.org
Cc: linux-api@vger.kernel.org
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Christian Brauner <christian.brauner@ubuntu.com>
2021-01-21 16:19:53 +03:00
|
|
|
|
2022-02-03 16:14:09 +03:00
|
|
|
/* If we had to hold writers unblock them. */
|
|
|
|
if (m->mnt.mnt_flags & MNT_WRITE_HOLD)
|
fs: add mount_setattr()
This implements the missing mount_setattr() syscall. While the new mount
api allows to change the properties of a superblock there is currently
no way to change the properties of a mount or a mount tree using file
descriptors which the new mount api is based on. In addition the old
mount api has the restriction that mount options cannot be applied
recursively. This hasn't changed since changing mount options on a
per-mount basis was implemented in [1] and has been a frequent request
not just for convenience but also for security reasons. The legacy
mount syscall is unable to accommodate this behavior without introducing
a whole new set of flags because MS_REC | MS_REMOUNT | MS_BIND |
MS_RDONLY | MS_NOEXEC | [...] only apply the mount option to the topmost
mount. Changing MS_REC to apply to the whole mount tree would mean
introducing a significant uapi change and would likely cause significant
regressions.
The new mount_setattr() syscall allows to recursively clear and set
mount options in one shot. Multiple calls to change mount options
requesting the same changes are idempotent:
int mount_setattr(int dfd, const char *path, unsigned flags,
struct mount_attr *uattr, size_t usize);
Flags to modify path resolution behavior are specified in the @flags
argument. Currently, AT_EMPTY_PATH, AT_RECURSIVE, AT_SYMLINK_NOFOLLOW,
and AT_NO_AUTOMOUNT are supported. If useful, additional lookup flags to
restrict path resolution as introduced with openat2() might be supported
in the future.
The mount_setattr() syscall can be expected to grow over time and is
designed with extensibility in mind. It follows the extensible syscall
pattern we have used with other syscalls such as openat2(), clone3(),
sched_{set,get}attr(), and others.
The set of mount options is passed in the uapi struct mount_attr which
currently has the following layout:
struct mount_attr {
__u64 attr_set;
__u64 attr_clr;
__u64 propagation;
__u64 userns_fd;
};
The @attr_set and @attr_clr members are used to clear and set mount
options. This way a user can e.g. request that a set of flags is to be
raised such as turning mounts readonly by raising MOUNT_ATTR_RDONLY in
@attr_set while at the same time requesting that another set of flags is
to be lowered such as removing noexec from a mount tree by specifying
MOUNT_ATTR_NOEXEC in @attr_clr.
Note, since the MOUNT_ATTR_<atime> values are an enum starting from 0,
not a bitmap, users wanting to transition to a different atime setting
cannot simply specify the atime setting in @attr_set, but must also
specify MOUNT_ATTR__ATIME in the @attr_clr field. So we ensure that
MOUNT_ATTR__ATIME can't be partially set in @attr_clr and that @attr_set
can't have any atime bits set if MOUNT_ATTR__ATIME isn't set in
@attr_clr.
The @propagation field lets callers specify the propagation type of a
mount tree. Propagation is a single property that has four different
settings and as such is not really a flag argument but an enum.
Specifically, it would be unclear what setting and clearing propagation
settings in combination would amount to. The legacy mount() syscall thus
forbids the combination of multiple propagation settings too. The goal
is to keep the semantics of mount propagation somewhat simple as they
are overly complex as it is.
The @userns_fd field lets user specify a user namespace whose idmapping
becomes the idmapping of the mount. This is implemented and explained in
detail in the next patch.
[1]: commit 2e4b7fcd9260 ("[PATCH] r/o bind mounts: honor mount writer counts at remount")
Link: https://lore.kernel.org/r/20210121131959.646623-35-christian.brauner@ubuntu.com
Cc: David Howells <dhowells@redhat.com>
Cc: Aleksa Sarai <cyphar@cyphar.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: linux-fsdevel@vger.kernel.org
Cc: linux-api@vger.kernel.org
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Christian Brauner <christian.brauner@ubuntu.com>
2021-01-21 16:19:53 +03:00
|
|
|
mnt_unhold_writers(m);
|
|
|
|
|
2022-03-01 07:04:20 +03:00
|
|
|
if (kattr->propagation)
|
fs: add mount_setattr()
This implements the missing mount_setattr() syscall. While the new mount
api allows to change the properties of a superblock there is currently
no way to change the properties of a mount or a mount tree using file
descriptors which the new mount api is based on. In addition the old
mount api has the restriction that mount options cannot be applied
recursively. This hasn't changed since changing mount options on a
per-mount basis was implemented in [1] and has been a frequent request
not just for convenience but also for security reasons. The legacy
mount syscall is unable to accommodate this behavior without introducing
a whole new set of flags because MS_REC | MS_REMOUNT | MS_BIND |
MS_RDONLY | MS_NOEXEC | [...] only apply the mount option to the topmost
mount. Changing MS_REC to apply to the whole mount tree would mean
introducing a significant uapi change and would likely cause significant
regressions.
The new mount_setattr() syscall allows to recursively clear and set
mount options in one shot. Multiple calls to change mount options
requesting the same changes are idempotent:
int mount_setattr(int dfd, const char *path, unsigned flags,
struct mount_attr *uattr, size_t usize);
Flags to modify path resolution behavior are specified in the @flags
argument. Currently, AT_EMPTY_PATH, AT_RECURSIVE, AT_SYMLINK_NOFOLLOW,
and AT_NO_AUTOMOUNT are supported. If useful, additional lookup flags to
restrict path resolution as introduced with openat2() might be supported
in the future.
The mount_setattr() syscall can be expected to grow over time and is
designed with extensibility in mind. It follows the extensible syscall
pattern we have used with other syscalls such as openat2(), clone3(),
sched_{set,get}attr(), and others.
The set of mount options is passed in the uapi struct mount_attr which
currently has the following layout:
struct mount_attr {
__u64 attr_set;
__u64 attr_clr;
__u64 propagation;
__u64 userns_fd;
};
The @attr_set and @attr_clr members are used to clear and set mount
options. This way a user can e.g. request that a set of flags is to be
raised such as turning mounts readonly by raising MOUNT_ATTR_RDONLY in
@attr_set while at the same time requesting that another set of flags is
to be lowered such as removing noexec from a mount tree by specifying
MOUNT_ATTR_NOEXEC in @attr_clr.
Note, since the MOUNT_ATTR_<atime> values are an enum starting from 0,
not a bitmap, users wanting to transition to a different atime setting
cannot simply specify the atime setting in @attr_set, but must also
specify MOUNT_ATTR__ATIME in the @attr_clr field. So we ensure that
MOUNT_ATTR__ATIME can't be partially set in @attr_clr and that @attr_set
can't have any atime bits set if MOUNT_ATTR__ATIME isn't set in
@attr_clr.
The @propagation field lets callers specify the propagation type of a
mount tree. Propagation is a single property that has four different
settings and as such is not really a flag argument but an enum.
Specifically, it would be unclear what setting and clearing propagation
settings in combination would amount to. The legacy mount() syscall thus
forbids the combination of multiple propagation settings too. The goal
is to keep the semantics of mount propagation somewhat simple as they
are overly complex as it is.
The @userns_fd field lets user specify a user namespace whose idmapping
becomes the idmapping of the mount. This is implemented and explained in
detail in the next patch.
[1]: commit 2e4b7fcd9260 ("[PATCH] r/o bind mounts: honor mount writer counts at remount")
Link: https://lore.kernel.org/r/20210121131959.646623-35-christian.brauner@ubuntu.com
Cc: David Howells <dhowells@redhat.com>
Cc: Aleksa Sarai <cyphar@cyphar.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: linux-fsdevel@vger.kernel.org
Cc: linux-api@vger.kernel.org
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Christian Brauner <christian.brauner@ubuntu.com>
2021-01-21 16:19:53 +03:00
|
|
|
change_mnt_propagation(m, kattr->propagation);
|
2022-03-01 07:04:20 +03:00
|
|
|
if (!kattr->recurse)
|
fs: add mount_setattr()
This implements the missing mount_setattr() syscall. While the new mount
api allows to change the properties of a superblock there is currently
no way to change the properties of a mount or a mount tree using file
descriptors which the new mount api is based on. In addition the old
mount api has the restriction that mount options cannot be applied
recursively. This hasn't changed since changing mount options on a
per-mount basis was implemented in [1] and has been a frequent request
not just for convenience but also for security reasons. The legacy
mount syscall is unable to accommodate this behavior without introducing
a whole new set of flags because MS_REC | MS_REMOUNT | MS_BIND |
MS_RDONLY | MS_NOEXEC | [...] only apply the mount option to the topmost
mount. Changing MS_REC to apply to the whole mount tree would mean
introducing a significant uapi change and would likely cause significant
regressions.
The new mount_setattr() syscall allows to recursively clear and set
mount options in one shot. Multiple calls to change mount options
requesting the same changes are idempotent:
int mount_setattr(int dfd, const char *path, unsigned flags,
struct mount_attr *uattr, size_t usize);
Flags to modify path resolution behavior are specified in the @flags
argument. Currently, AT_EMPTY_PATH, AT_RECURSIVE, AT_SYMLINK_NOFOLLOW,
and AT_NO_AUTOMOUNT are supported. If useful, additional lookup flags to
restrict path resolution as introduced with openat2() might be supported
in the future.
The mount_setattr() syscall can be expected to grow over time and is
designed with extensibility in mind. It follows the extensible syscall
pattern we have used with other syscalls such as openat2(), clone3(),
sched_{set,get}attr(), and others.
The set of mount options is passed in the uapi struct mount_attr which
currently has the following layout:
struct mount_attr {
__u64 attr_set;
__u64 attr_clr;
__u64 propagation;
__u64 userns_fd;
};
The @attr_set and @attr_clr members are used to clear and set mount
options. This way a user can e.g. request that a set of flags is to be
raised such as turning mounts readonly by raising MOUNT_ATTR_RDONLY in
@attr_set while at the same time requesting that another set of flags is
to be lowered such as removing noexec from a mount tree by specifying
MOUNT_ATTR_NOEXEC in @attr_clr.
Note, since the MOUNT_ATTR_<atime> values are an enum starting from 0,
not a bitmap, users wanting to transition to a different atime setting
cannot simply specify the atime setting in @attr_set, but must also
specify MOUNT_ATTR__ATIME in the @attr_clr field. So we ensure that
MOUNT_ATTR__ATIME can't be partially set in @attr_clr and that @attr_set
can't have any atime bits set if MOUNT_ATTR__ATIME isn't set in
@attr_clr.
The @propagation field lets callers specify the propagation type of a
mount tree. Propagation is a single property that has four different
settings and as such is not really a flag argument but an enum.
Specifically, it would be unclear what setting and clearing propagation
settings in combination would amount to. The legacy mount() syscall thus
forbids the combination of multiple propagation settings too. The goal
is to keep the semantics of mount propagation somewhat simple as they
are overly complex as it is.
The @userns_fd field lets user specify a user namespace whose idmapping
becomes the idmapping of the mount. This is implemented and explained in
detail in the next patch.
[1]: commit 2e4b7fcd9260 ("[PATCH] r/o bind mounts: honor mount writer counts at remount")
Link: https://lore.kernel.org/r/20210121131959.646623-35-christian.brauner@ubuntu.com
Cc: David Howells <dhowells@redhat.com>
Cc: Aleksa Sarai <cyphar@cyphar.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: linux-fsdevel@vger.kernel.org
Cc: linux-api@vger.kernel.org
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Christian Brauner <christian.brauner@ubuntu.com>
2021-01-21 16:19:53 +03:00
|
|
|
break;
|
2022-03-01 07:04:20 +03:00
|
|
|
}
|
|
|
|
touch_mnt_namespace(mnt->mnt_ns);
|
fs: add mount_setattr()
This implements the missing mount_setattr() syscall. While the new mount
api allows to change the properties of a superblock there is currently
no way to change the properties of a mount or a mount tree using file
descriptors which the new mount api is based on. In addition the old
mount api has the restriction that mount options cannot be applied
recursively. This hasn't changed since changing mount options on a
per-mount basis was implemented in [1] and has been a frequent request
not just for convenience but also for security reasons. The legacy
mount syscall is unable to accommodate this behavior without introducing
a whole new set of flags because MS_REC | MS_REMOUNT | MS_BIND |
MS_RDONLY | MS_NOEXEC | [...] only apply the mount option to the topmost
mount. Changing MS_REC to apply to the whole mount tree would mean
introducing a significant uapi change and would likely cause significant
regressions.
The new mount_setattr() syscall allows to recursively clear and set
mount options in one shot. Multiple calls to change mount options
requesting the same changes are idempotent:
int mount_setattr(int dfd, const char *path, unsigned flags,
struct mount_attr *uattr, size_t usize);
Flags to modify path resolution behavior are specified in the @flags
argument. Currently, AT_EMPTY_PATH, AT_RECURSIVE, AT_SYMLINK_NOFOLLOW,
and AT_NO_AUTOMOUNT are supported. If useful, additional lookup flags to
restrict path resolution as introduced with openat2() might be supported
in the future.
The mount_setattr() syscall can be expected to grow over time and is
designed with extensibility in mind. It follows the extensible syscall
pattern we have used with other syscalls such as openat2(), clone3(),
sched_{set,get}attr(), and others.
The set of mount options is passed in the uapi struct mount_attr which
currently has the following layout:
struct mount_attr {
__u64 attr_set;
__u64 attr_clr;
__u64 propagation;
__u64 userns_fd;
};
The @attr_set and @attr_clr members are used to clear and set mount
options. This way a user can e.g. request that a set of flags is to be
raised such as turning mounts readonly by raising MOUNT_ATTR_RDONLY in
@attr_set while at the same time requesting that another set of flags is
to be lowered such as removing noexec from a mount tree by specifying
MOUNT_ATTR_NOEXEC in @attr_clr.
Note, since the MOUNT_ATTR_<atime> values are an enum starting from 0,
not a bitmap, users wanting to transition to a different atime setting
cannot simply specify the atime setting in @attr_set, but must also
specify MOUNT_ATTR__ATIME in the @attr_clr field. So we ensure that
MOUNT_ATTR__ATIME can't be partially set in @attr_clr and that @attr_set
can't have any atime bits set if MOUNT_ATTR__ATIME isn't set in
@attr_clr.
The @propagation field lets callers specify the propagation type of a
mount tree. Propagation is a single property that has four different
settings and as such is not really a flag argument but an enum.
Specifically, it would be unclear what setting and clearing propagation
settings in combination would amount to. The legacy mount() syscall thus
forbids the combination of multiple propagation settings too. The goal
is to keep the semantics of mount propagation somewhat simple as they
are overly complex as it is.
The @userns_fd field lets user specify a user namespace whose idmapping
becomes the idmapping of the mount. This is implemented and explained in
detail in the next patch.
[1]: commit 2e4b7fcd9260 ("[PATCH] r/o bind mounts: honor mount writer counts at remount")
Link: https://lore.kernel.org/r/20210121131959.646623-35-christian.brauner@ubuntu.com
Cc: David Howells <dhowells@redhat.com>
Cc: Aleksa Sarai <cyphar@cyphar.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: linux-fsdevel@vger.kernel.org
Cc: linux-api@vger.kernel.org
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Christian Brauner <christian.brauner@ubuntu.com>
2021-01-21 16:19:53 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static int do_mount_setattr(struct path *path, struct mount_kattr *kattr)
|
|
|
|
{
|
2022-02-03 16:14:11 +03:00
|
|
|
struct mount *mnt = real_mount(path->mnt);
|
fs: add mount_setattr()
This implements the missing mount_setattr() syscall. While the new mount
api allows to change the properties of a superblock there is currently
no way to change the properties of a mount or a mount tree using file
descriptors which the new mount api is based on. In addition the old
mount api has the restriction that mount options cannot be applied
recursively. This hasn't changed since changing mount options on a
per-mount basis was implemented in [1] and has been a frequent request
not just for convenience but also for security reasons. The legacy
mount syscall is unable to accommodate this behavior without introducing
a whole new set of flags because MS_REC | MS_REMOUNT | MS_BIND |
MS_RDONLY | MS_NOEXEC | [...] only apply the mount option to the topmost
mount. Changing MS_REC to apply to the whole mount tree would mean
introducing a significant uapi change and would likely cause significant
regressions.
The new mount_setattr() syscall allows to recursively clear and set
mount options in one shot. Multiple calls to change mount options
requesting the same changes are idempotent:
int mount_setattr(int dfd, const char *path, unsigned flags,
struct mount_attr *uattr, size_t usize);
Flags to modify path resolution behavior are specified in the @flags
argument. Currently, AT_EMPTY_PATH, AT_RECURSIVE, AT_SYMLINK_NOFOLLOW,
and AT_NO_AUTOMOUNT are supported. If useful, additional lookup flags to
restrict path resolution as introduced with openat2() might be supported
in the future.
The mount_setattr() syscall can be expected to grow over time and is
designed with extensibility in mind. It follows the extensible syscall
pattern we have used with other syscalls such as openat2(), clone3(),
sched_{set,get}attr(), and others.
The set of mount options is passed in the uapi struct mount_attr which
currently has the following layout:
struct mount_attr {
__u64 attr_set;
__u64 attr_clr;
__u64 propagation;
__u64 userns_fd;
};
The @attr_set and @attr_clr members are used to clear and set mount
options. This way a user can e.g. request that a set of flags is to be
raised such as turning mounts readonly by raising MOUNT_ATTR_RDONLY in
@attr_set while at the same time requesting that another set of flags is
to be lowered such as removing noexec from a mount tree by specifying
MOUNT_ATTR_NOEXEC in @attr_clr.
Note, since the MOUNT_ATTR_<atime> values are an enum starting from 0,
not a bitmap, users wanting to transition to a different atime setting
cannot simply specify the atime setting in @attr_set, but must also
specify MOUNT_ATTR__ATIME in the @attr_clr field. So we ensure that
MOUNT_ATTR__ATIME can't be partially set in @attr_clr and that @attr_set
can't have any atime bits set if MOUNT_ATTR__ATIME isn't set in
@attr_clr.
The @propagation field lets callers specify the propagation type of a
mount tree. Propagation is a single property that has four different
settings and as such is not really a flag argument but an enum.
Specifically, it would be unclear what setting and clearing propagation
settings in combination would amount to. The legacy mount() syscall thus
forbids the combination of multiple propagation settings too. The goal
is to keep the semantics of mount propagation somewhat simple as they
are overly complex as it is.
The @userns_fd field lets user specify a user namespace whose idmapping
becomes the idmapping of the mount. This is implemented and explained in
detail in the next patch.
[1]: commit 2e4b7fcd9260 ("[PATCH] r/o bind mounts: honor mount writer counts at remount")
Link: https://lore.kernel.org/r/20210121131959.646623-35-christian.brauner@ubuntu.com
Cc: David Howells <dhowells@redhat.com>
Cc: Aleksa Sarai <cyphar@cyphar.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: linux-fsdevel@vger.kernel.org
Cc: linux-api@vger.kernel.org
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Christian Brauner <christian.brauner@ubuntu.com>
2021-01-21 16:19:53 +03:00
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
if (path->dentry != mnt->mnt.mnt_root)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2022-10-26 13:51:27 +03:00
|
|
|
if (kattr->mnt_userns) {
|
|
|
|
struct mnt_idmap *mnt_idmap;
|
|
|
|
|
|
|
|
mnt_idmap = alloc_mnt_idmap(kattr->mnt_userns);
|
|
|
|
if (IS_ERR(mnt_idmap))
|
|
|
|
return PTR_ERR(mnt_idmap);
|
|
|
|
kattr->mnt_idmap = mnt_idmap;
|
|
|
|
}
|
|
|
|
|
fs: add mount_setattr()
This implements the missing mount_setattr() syscall. While the new mount
api allows to change the properties of a superblock there is currently
no way to change the properties of a mount or a mount tree using file
descriptors which the new mount api is based on. In addition the old
mount api has the restriction that mount options cannot be applied
recursively. This hasn't changed since changing mount options on a
per-mount basis was implemented in [1] and has been a frequent request
not just for convenience but also for security reasons. The legacy
mount syscall is unable to accommodate this behavior without introducing
a whole new set of flags because MS_REC | MS_REMOUNT | MS_BIND |
MS_RDONLY | MS_NOEXEC | [...] only apply the mount option to the topmost
mount. Changing MS_REC to apply to the whole mount tree would mean
introducing a significant uapi change and would likely cause significant
regressions.
The new mount_setattr() syscall allows to recursively clear and set
mount options in one shot. Multiple calls to change mount options
requesting the same changes are idempotent:
int mount_setattr(int dfd, const char *path, unsigned flags,
struct mount_attr *uattr, size_t usize);
Flags to modify path resolution behavior are specified in the @flags
argument. Currently, AT_EMPTY_PATH, AT_RECURSIVE, AT_SYMLINK_NOFOLLOW,
and AT_NO_AUTOMOUNT are supported. If useful, additional lookup flags to
restrict path resolution as introduced with openat2() might be supported
in the future.
The mount_setattr() syscall can be expected to grow over time and is
designed with extensibility in mind. It follows the extensible syscall
pattern we have used with other syscalls such as openat2(), clone3(),
sched_{set,get}attr(), and others.
The set of mount options is passed in the uapi struct mount_attr which
currently has the following layout:
struct mount_attr {
__u64 attr_set;
__u64 attr_clr;
__u64 propagation;
__u64 userns_fd;
};
The @attr_set and @attr_clr members are used to clear and set mount
options. This way a user can e.g. request that a set of flags is to be
raised such as turning mounts readonly by raising MOUNT_ATTR_RDONLY in
@attr_set while at the same time requesting that another set of flags is
to be lowered such as removing noexec from a mount tree by specifying
MOUNT_ATTR_NOEXEC in @attr_clr.
Note, since the MOUNT_ATTR_<atime> values are an enum starting from 0,
not a bitmap, users wanting to transition to a different atime setting
cannot simply specify the atime setting in @attr_set, but must also
specify MOUNT_ATTR__ATIME in the @attr_clr field. So we ensure that
MOUNT_ATTR__ATIME can't be partially set in @attr_clr and that @attr_set
can't have any atime bits set if MOUNT_ATTR__ATIME isn't set in
@attr_clr.
The @propagation field lets callers specify the propagation type of a
mount tree. Propagation is a single property that has four different
settings and as such is not really a flag argument but an enum.
Specifically, it would be unclear what setting and clearing propagation
settings in combination would amount to. The legacy mount() syscall thus
forbids the combination of multiple propagation settings too. The goal
is to keep the semantics of mount propagation somewhat simple as they
are overly complex as it is.
The @userns_fd field lets user specify a user namespace whose idmapping
becomes the idmapping of the mount. This is implemented and explained in
detail in the next patch.
[1]: commit 2e4b7fcd9260 ("[PATCH] r/o bind mounts: honor mount writer counts at remount")
Link: https://lore.kernel.org/r/20210121131959.646623-35-christian.brauner@ubuntu.com
Cc: David Howells <dhowells@redhat.com>
Cc: Aleksa Sarai <cyphar@cyphar.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: linux-fsdevel@vger.kernel.org
Cc: linux-api@vger.kernel.org
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Christian Brauner <christian.brauner@ubuntu.com>
2021-01-21 16:19:53 +03:00
|
|
|
if (kattr->propagation) {
|
|
|
|
/*
|
|
|
|
* Only take namespace_lock() if we're actually changing
|
|
|
|
* propagation.
|
|
|
|
*/
|
|
|
|
namespace_lock();
|
|
|
|
if (kattr->propagation == MS_SHARED) {
|
|
|
|
err = invent_group_ids(mnt, kattr->recurse);
|
|
|
|
if (err) {
|
|
|
|
namespace_unlock();
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-02-03 16:14:11 +03:00
|
|
|
err = -EINVAL;
|
fs: add mount_setattr()
This implements the missing mount_setattr() syscall. While the new mount
api allows to change the properties of a superblock there is currently
no way to change the properties of a mount or a mount tree using file
descriptors which the new mount api is based on. In addition the old
mount api has the restriction that mount options cannot be applied
recursively. This hasn't changed since changing mount options on a
per-mount basis was implemented in [1] and has been a frequent request
not just for convenience but also for security reasons. The legacy
mount syscall is unable to accommodate this behavior without introducing
a whole new set of flags because MS_REC | MS_REMOUNT | MS_BIND |
MS_RDONLY | MS_NOEXEC | [...] only apply the mount option to the topmost
mount. Changing MS_REC to apply to the whole mount tree would mean
introducing a significant uapi change and would likely cause significant
regressions.
The new mount_setattr() syscall allows to recursively clear and set
mount options in one shot. Multiple calls to change mount options
requesting the same changes are idempotent:
int mount_setattr(int dfd, const char *path, unsigned flags,
struct mount_attr *uattr, size_t usize);
Flags to modify path resolution behavior are specified in the @flags
argument. Currently, AT_EMPTY_PATH, AT_RECURSIVE, AT_SYMLINK_NOFOLLOW,
and AT_NO_AUTOMOUNT are supported. If useful, additional lookup flags to
restrict path resolution as introduced with openat2() might be supported
in the future.
The mount_setattr() syscall can be expected to grow over time and is
designed with extensibility in mind. It follows the extensible syscall
pattern we have used with other syscalls such as openat2(), clone3(),
sched_{set,get}attr(), and others.
The set of mount options is passed in the uapi struct mount_attr which
currently has the following layout:
struct mount_attr {
__u64 attr_set;
__u64 attr_clr;
__u64 propagation;
__u64 userns_fd;
};
The @attr_set and @attr_clr members are used to clear and set mount
options. This way a user can e.g. request that a set of flags is to be
raised such as turning mounts readonly by raising MOUNT_ATTR_RDONLY in
@attr_set while at the same time requesting that another set of flags is
to be lowered such as removing noexec from a mount tree by specifying
MOUNT_ATTR_NOEXEC in @attr_clr.
Note, since the MOUNT_ATTR_<atime> values are an enum starting from 0,
not a bitmap, users wanting to transition to a different atime setting
cannot simply specify the atime setting in @attr_set, but must also
specify MOUNT_ATTR__ATIME in the @attr_clr field. So we ensure that
MOUNT_ATTR__ATIME can't be partially set in @attr_clr and that @attr_set
can't have any atime bits set if MOUNT_ATTR__ATIME isn't set in
@attr_clr.
The @propagation field lets callers specify the propagation type of a
mount tree. Propagation is a single property that has four different
settings and as such is not really a flag argument but an enum.
Specifically, it would be unclear what setting and clearing propagation
settings in combination would amount to. The legacy mount() syscall thus
forbids the combination of multiple propagation settings too. The goal
is to keep the semantics of mount propagation somewhat simple as they
are overly complex as it is.
The @userns_fd field lets user specify a user namespace whose idmapping
becomes the idmapping of the mount. This is implemented and explained in
detail in the next patch.
[1]: commit 2e4b7fcd9260 ("[PATCH] r/o bind mounts: honor mount writer counts at remount")
Link: https://lore.kernel.org/r/20210121131959.646623-35-christian.brauner@ubuntu.com
Cc: David Howells <dhowells@redhat.com>
Cc: Aleksa Sarai <cyphar@cyphar.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: linux-fsdevel@vger.kernel.org
Cc: linux-api@vger.kernel.org
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Christian Brauner <christian.brauner@ubuntu.com>
2021-01-21 16:19:53 +03:00
|
|
|
lock_mount_hash();
|
|
|
|
|
2022-02-03 16:14:11 +03:00
|
|
|
/* Ensure that this isn't anything purely vfs internal. */
|
|
|
|
if (!is_mounted(&mnt->mnt))
|
|
|
|
goto out;
|
|
|
|
|
fs: add mount_setattr()
This implements the missing mount_setattr() syscall. While the new mount
api allows to change the properties of a superblock there is currently
no way to change the properties of a mount or a mount tree using file
descriptors which the new mount api is based on. In addition the old
mount api has the restriction that mount options cannot be applied
recursively. This hasn't changed since changing mount options on a
per-mount basis was implemented in [1] and has been a frequent request
not just for convenience but also for security reasons. The legacy
mount syscall is unable to accommodate this behavior without introducing
a whole new set of flags because MS_REC | MS_REMOUNT | MS_BIND |
MS_RDONLY | MS_NOEXEC | [...] only apply the mount option to the topmost
mount. Changing MS_REC to apply to the whole mount tree would mean
introducing a significant uapi change and would likely cause significant
regressions.
The new mount_setattr() syscall allows to recursively clear and set
mount options in one shot. Multiple calls to change mount options
requesting the same changes are idempotent:
int mount_setattr(int dfd, const char *path, unsigned flags,
struct mount_attr *uattr, size_t usize);
Flags to modify path resolution behavior are specified in the @flags
argument. Currently, AT_EMPTY_PATH, AT_RECURSIVE, AT_SYMLINK_NOFOLLOW,
and AT_NO_AUTOMOUNT are supported. If useful, additional lookup flags to
restrict path resolution as introduced with openat2() might be supported
in the future.
The mount_setattr() syscall can be expected to grow over time and is
designed with extensibility in mind. It follows the extensible syscall
pattern we have used with other syscalls such as openat2(), clone3(),
sched_{set,get}attr(), and others.
The set of mount options is passed in the uapi struct mount_attr which
currently has the following layout:
struct mount_attr {
__u64 attr_set;
__u64 attr_clr;
__u64 propagation;
__u64 userns_fd;
};
The @attr_set and @attr_clr members are used to clear and set mount
options. This way a user can e.g. request that a set of flags is to be
raised such as turning mounts readonly by raising MOUNT_ATTR_RDONLY in
@attr_set while at the same time requesting that another set of flags is
to be lowered such as removing noexec from a mount tree by specifying
MOUNT_ATTR_NOEXEC in @attr_clr.
Note, since the MOUNT_ATTR_<atime> values are an enum starting from 0,
not a bitmap, users wanting to transition to a different atime setting
cannot simply specify the atime setting in @attr_set, but must also
specify MOUNT_ATTR__ATIME in the @attr_clr field. So we ensure that
MOUNT_ATTR__ATIME can't be partially set in @attr_clr and that @attr_set
can't have any atime bits set if MOUNT_ATTR__ATIME isn't set in
@attr_clr.
The @propagation field lets callers specify the propagation type of a
mount tree. Propagation is a single property that has four different
settings and as such is not really a flag argument but an enum.
Specifically, it would be unclear what setting and clearing propagation
settings in combination would amount to. The legacy mount() syscall thus
forbids the combination of multiple propagation settings too. The goal
is to keep the semantics of mount propagation somewhat simple as they
are overly complex as it is.
The @userns_fd field lets user specify a user namespace whose idmapping
becomes the idmapping of the mount. This is implemented and explained in
detail in the next patch.
[1]: commit 2e4b7fcd9260 ("[PATCH] r/o bind mounts: honor mount writer counts at remount")
Link: https://lore.kernel.org/r/20210121131959.646623-35-christian.brauner@ubuntu.com
Cc: David Howells <dhowells@redhat.com>
Cc: Aleksa Sarai <cyphar@cyphar.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: linux-fsdevel@vger.kernel.org
Cc: linux-api@vger.kernel.org
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Christian Brauner <christian.brauner@ubuntu.com>
2021-01-21 16:19:53 +03:00
|
|
|
/*
|
2022-02-03 16:14:11 +03:00
|
|
|
* If this is an attached mount make sure it's located in the callers
|
|
|
|
* mount namespace. If it's not don't let the caller interact with it.
|
|
|
|
* If this is a detached mount make sure it has an anonymous mount
|
|
|
|
* namespace attached to it, i.e. we've created it via OPEN_TREE_CLONE.
|
fs: add mount_setattr()
This implements the missing mount_setattr() syscall. While the new mount
api allows to change the properties of a superblock there is currently
no way to change the properties of a mount or a mount tree using file
descriptors which the new mount api is based on. In addition the old
mount api has the restriction that mount options cannot be applied
recursively. This hasn't changed since changing mount options on a
per-mount basis was implemented in [1] and has been a frequent request
not just for convenience but also for security reasons. The legacy
mount syscall is unable to accommodate this behavior without introducing
a whole new set of flags because MS_REC | MS_REMOUNT | MS_BIND |
MS_RDONLY | MS_NOEXEC | [...] only apply the mount option to the topmost
mount. Changing MS_REC to apply to the whole mount tree would mean
introducing a significant uapi change and would likely cause significant
regressions.
The new mount_setattr() syscall allows to recursively clear and set
mount options in one shot. Multiple calls to change mount options
requesting the same changes are idempotent:
int mount_setattr(int dfd, const char *path, unsigned flags,
struct mount_attr *uattr, size_t usize);
Flags to modify path resolution behavior are specified in the @flags
argument. Currently, AT_EMPTY_PATH, AT_RECURSIVE, AT_SYMLINK_NOFOLLOW,
and AT_NO_AUTOMOUNT are supported. If useful, additional lookup flags to
restrict path resolution as introduced with openat2() might be supported
in the future.
The mount_setattr() syscall can be expected to grow over time and is
designed with extensibility in mind. It follows the extensible syscall
pattern we have used with other syscalls such as openat2(), clone3(),
sched_{set,get}attr(), and others.
The set of mount options is passed in the uapi struct mount_attr which
currently has the following layout:
struct mount_attr {
__u64 attr_set;
__u64 attr_clr;
__u64 propagation;
__u64 userns_fd;
};
The @attr_set and @attr_clr members are used to clear and set mount
options. This way a user can e.g. request that a set of flags is to be
raised such as turning mounts readonly by raising MOUNT_ATTR_RDONLY in
@attr_set while at the same time requesting that another set of flags is
to be lowered such as removing noexec from a mount tree by specifying
MOUNT_ATTR_NOEXEC in @attr_clr.
Note, since the MOUNT_ATTR_<atime> values are an enum starting from 0,
not a bitmap, users wanting to transition to a different atime setting
cannot simply specify the atime setting in @attr_set, but must also
specify MOUNT_ATTR__ATIME in the @attr_clr field. So we ensure that
MOUNT_ATTR__ATIME can't be partially set in @attr_clr and that @attr_set
can't have any atime bits set if MOUNT_ATTR__ATIME isn't set in
@attr_clr.
The @propagation field lets callers specify the propagation type of a
mount tree. Propagation is a single property that has four different
settings and as such is not really a flag argument but an enum.
Specifically, it would be unclear what setting and clearing propagation
settings in combination would amount to. The legacy mount() syscall thus
forbids the combination of multiple propagation settings too. The goal
is to keep the semantics of mount propagation somewhat simple as they
are overly complex as it is.
The @userns_fd field lets user specify a user namespace whose idmapping
becomes the idmapping of the mount. This is implemented and explained in
detail in the next patch.
[1]: commit 2e4b7fcd9260 ("[PATCH] r/o bind mounts: honor mount writer counts at remount")
Link: https://lore.kernel.org/r/20210121131959.646623-35-christian.brauner@ubuntu.com
Cc: David Howells <dhowells@redhat.com>
Cc: Aleksa Sarai <cyphar@cyphar.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: linux-fsdevel@vger.kernel.org
Cc: linux-api@vger.kernel.org
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Christian Brauner <christian.brauner@ubuntu.com>
2021-01-21 16:19:53 +03:00
|
|
|
*/
|
2022-02-03 16:14:11 +03:00
|
|
|
if (!(mnt_has_parent(mnt) ? check_mnt(mnt) : is_anon_ns(mnt->mnt_ns)))
|
|
|
|
goto out;
|
fs: add mount_setattr()
This implements the missing mount_setattr() syscall. While the new mount
api allows to change the properties of a superblock there is currently
no way to change the properties of a mount or a mount tree using file
descriptors which the new mount api is based on. In addition the old
mount api has the restriction that mount options cannot be applied
recursively. This hasn't changed since changing mount options on a
per-mount basis was implemented in [1] and has been a frequent request
not just for convenience but also for security reasons. The legacy
mount syscall is unable to accommodate this behavior without introducing
a whole new set of flags because MS_REC | MS_REMOUNT | MS_BIND |
MS_RDONLY | MS_NOEXEC | [...] only apply the mount option to the topmost
mount. Changing MS_REC to apply to the whole mount tree would mean
introducing a significant uapi change and would likely cause significant
regressions.
The new mount_setattr() syscall allows to recursively clear and set
mount options in one shot. Multiple calls to change mount options
requesting the same changes are idempotent:
int mount_setattr(int dfd, const char *path, unsigned flags,
struct mount_attr *uattr, size_t usize);
Flags to modify path resolution behavior are specified in the @flags
argument. Currently, AT_EMPTY_PATH, AT_RECURSIVE, AT_SYMLINK_NOFOLLOW,
and AT_NO_AUTOMOUNT are supported. If useful, additional lookup flags to
restrict path resolution as introduced with openat2() might be supported
in the future.
The mount_setattr() syscall can be expected to grow over time and is
designed with extensibility in mind. It follows the extensible syscall
pattern we have used with other syscalls such as openat2(), clone3(),
sched_{set,get}attr(), and others.
The set of mount options is passed in the uapi struct mount_attr which
currently has the following layout:
struct mount_attr {
__u64 attr_set;
__u64 attr_clr;
__u64 propagation;
__u64 userns_fd;
};
The @attr_set and @attr_clr members are used to clear and set mount
options. This way a user can e.g. request that a set of flags is to be
raised such as turning mounts readonly by raising MOUNT_ATTR_RDONLY in
@attr_set while at the same time requesting that another set of flags is
to be lowered such as removing noexec from a mount tree by specifying
MOUNT_ATTR_NOEXEC in @attr_clr.
Note, since the MOUNT_ATTR_<atime> values are an enum starting from 0,
not a bitmap, users wanting to transition to a different atime setting
cannot simply specify the atime setting in @attr_set, but must also
specify MOUNT_ATTR__ATIME in the @attr_clr field. So we ensure that
MOUNT_ATTR__ATIME can't be partially set in @attr_clr and that @attr_set
can't have any atime bits set if MOUNT_ATTR__ATIME isn't set in
@attr_clr.
The @propagation field lets callers specify the propagation type of a
mount tree. Propagation is a single property that has four different
settings and as such is not really a flag argument but an enum.
Specifically, it would be unclear what setting and clearing propagation
settings in combination would amount to. The legacy mount() syscall thus
forbids the combination of multiple propagation settings too. The goal
is to keep the semantics of mount propagation somewhat simple as they
are overly complex as it is.
The @userns_fd field lets user specify a user namespace whose idmapping
becomes the idmapping of the mount. This is implemented and explained in
detail in the next patch.
[1]: commit 2e4b7fcd9260 ("[PATCH] r/o bind mounts: honor mount writer counts at remount")
Link: https://lore.kernel.org/r/20210121131959.646623-35-christian.brauner@ubuntu.com
Cc: David Howells <dhowells@redhat.com>
Cc: Aleksa Sarai <cyphar@cyphar.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: linux-fsdevel@vger.kernel.org
Cc: linux-api@vger.kernel.org
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Christian Brauner <christian.brauner@ubuntu.com>
2021-01-21 16:19:53 +03:00
|
|
|
|
2022-02-03 16:14:11 +03:00
|
|
|
/*
|
|
|
|
* First, we get the mount tree in a shape where we can change mount
|
|
|
|
* properties without failure. If we succeeded to do so we commit all
|
|
|
|
* changes and if we failed we clean up.
|
|
|
|
*/
|
|
|
|
err = mount_setattr_prepare(kattr, mnt);
|
2022-03-01 07:04:20 +03:00
|
|
|
if (!err)
|
|
|
|
mount_setattr_commit(kattr, mnt);
|
fs: add mount_setattr()
This implements the missing mount_setattr() syscall. While the new mount
api allows to change the properties of a superblock there is currently
no way to change the properties of a mount or a mount tree using file
descriptors which the new mount api is based on. In addition the old
mount api has the restriction that mount options cannot be applied
recursively. This hasn't changed since changing mount options on a
per-mount basis was implemented in [1] and has been a frequent request
not just for convenience but also for security reasons. The legacy
mount syscall is unable to accommodate this behavior without introducing
a whole new set of flags because MS_REC | MS_REMOUNT | MS_BIND |
MS_RDONLY | MS_NOEXEC | [...] only apply the mount option to the topmost
mount. Changing MS_REC to apply to the whole mount tree would mean
introducing a significant uapi change and would likely cause significant
regressions.
The new mount_setattr() syscall allows to recursively clear and set
mount options in one shot. Multiple calls to change mount options
requesting the same changes are idempotent:
int mount_setattr(int dfd, const char *path, unsigned flags,
struct mount_attr *uattr, size_t usize);
Flags to modify path resolution behavior are specified in the @flags
argument. Currently, AT_EMPTY_PATH, AT_RECURSIVE, AT_SYMLINK_NOFOLLOW,
and AT_NO_AUTOMOUNT are supported. If useful, additional lookup flags to
restrict path resolution as introduced with openat2() might be supported
in the future.
The mount_setattr() syscall can be expected to grow over time and is
designed with extensibility in mind. It follows the extensible syscall
pattern we have used with other syscalls such as openat2(), clone3(),
sched_{set,get}attr(), and others.
The set of mount options is passed in the uapi struct mount_attr which
currently has the following layout:
struct mount_attr {
__u64 attr_set;
__u64 attr_clr;
__u64 propagation;
__u64 userns_fd;
};
The @attr_set and @attr_clr members are used to clear and set mount
options. This way a user can e.g. request that a set of flags is to be
raised such as turning mounts readonly by raising MOUNT_ATTR_RDONLY in
@attr_set while at the same time requesting that another set of flags is
to be lowered such as removing noexec from a mount tree by specifying
MOUNT_ATTR_NOEXEC in @attr_clr.
Note, since the MOUNT_ATTR_<atime> values are an enum starting from 0,
not a bitmap, users wanting to transition to a different atime setting
cannot simply specify the atime setting in @attr_set, but must also
specify MOUNT_ATTR__ATIME in the @attr_clr field. So we ensure that
MOUNT_ATTR__ATIME can't be partially set in @attr_clr and that @attr_set
can't have any atime bits set if MOUNT_ATTR__ATIME isn't set in
@attr_clr.
The @propagation field lets callers specify the propagation type of a
mount tree. Propagation is a single property that has four different
settings and as such is not really a flag argument but an enum.
Specifically, it would be unclear what setting and clearing propagation
settings in combination would amount to. The legacy mount() syscall thus
forbids the combination of multiple propagation settings too. The goal
is to keep the semantics of mount propagation somewhat simple as they
are overly complex as it is.
The @userns_fd field lets user specify a user namespace whose idmapping
becomes the idmapping of the mount. This is implemented and explained in
detail in the next patch.
[1]: commit 2e4b7fcd9260 ("[PATCH] r/o bind mounts: honor mount writer counts at remount")
Link: https://lore.kernel.org/r/20210121131959.646623-35-christian.brauner@ubuntu.com
Cc: David Howells <dhowells@redhat.com>
Cc: Aleksa Sarai <cyphar@cyphar.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: linux-fsdevel@vger.kernel.org
Cc: linux-api@vger.kernel.org
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Christian Brauner <christian.brauner@ubuntu.com>
2021-01-21 16:19:53 +03:00
|
|
|
|
2022-02-03 16:14:11 +03:00
|
|
|
out:
|
fs: add mount_setattr()
This implements the missing mount_setattr() syscall. While the new mount
api allows to change the properties of a superblock there is currently
no way to change the properties of a mount or a mount tree using file
descriptors which the new mount api is based on. In addition the old
mount api has the restriction that mount options cannot be applied
recursively. This hasn't changed since changing mount options on a
per-mount basis was implemented in [1] and has been a frequent request
not just for convenience but also for security reasons. The legacy
mount syscall is unable to accommodate this behavior without introducing
a whole new set of flags because MS_REC | MS_REMOUNT | MS_BIND |
MS_RDONLY | MS_NOEXEC | [...] only apply the mount option to the topmost
mount. Changing MS_REC to apply to the whole mount tree would mean
introducing a significant uapi change and would likely cause significant
regressions.
The new mount_setattr() syscall allows to recursively clear and set
mount options in one shot. Multiple calls to change mount options
requesting the same changes are idempotent:
int mount_setattr(int dfd, const char *path, unsigned flags,
struct mount_attr *uattr, size_t usize);
Flags to modify path resolution behavior are specified in the @flags
argument. Currently, AT_EMPTY_PATH, AT_RECURSIVE, AT_SYMLINK_NOFOLLOW,
and AT_NO_AUTOMOUNT are supported. If useful, additional lookup flags to
restrict path resolution as introduced with openat2() might be supported
in the future.
The mount_setattr() syscall can be expected to grow over time and is
designed with extensibility in mind. It follows the extensible syscall
pattern we have used with other syscalls such as openat2(), clone3(),
sched_{set,get}attr(), and others.
The set of mount options is passed in the uapi struct mount_attr which
currently has the following layout:
struct mount_attr {
__u64 attr_set;
__u64 attr_clr;
__u64 propagation;
__u64 userns_fd;
};
The @attr_set and @attr_clr members are used to clear and set mount
options. This way a user can e.g. request that a set of flags is to be
raised such as turning mounts readonly by raising MOUNT_ATTR_RDONLY in
@attr_set while at the same time requesting that another set of flags is
to be lowered such as removing noexec from a mount tree by specifying
MOUNT_ATTR_NOEXEC in @attr_clr.
Note, since the MOUNT_ATTR_<atime> values are an enum starting from 0,
not a bitmap, users wanting to transition to a different atime setting
cannot simply specify the atime setting in @attr_set, but must also
specify MOUNT_ATTR__ATIME in the @attr_clr field. So we ensure that
MOUNT_ATTR__ATIME can't be partially set in @attr_clr and that @attr_set
can't have any atime bits set if MOUNT_ATTR__ATIME isn't set in
@attr_clr.
The @propagation field lets callers specify the propagation type of a
mount tree. Propagation is a single property that has four different
settings and as such is not really a flag argument but an enum.
Specifically, it would be unclear what setting and clearing propagation
settings in combination would amount to. The legacy mount() syscall thus
forbids the combination of multiple propagation settings too. The goal
is to keep the semantics of mount propagation somewhat simple as they
are overly complex as it is.
The @userns_fd field lets user specify a user namespace whose idmapping
becomes the idmapping of the mount. This is implemented and explained in
detail in the next patch.
[1]: commit 2e4b7fcd9260 ("[PATCH] r/o bind mounts: honor mount writer counts at remount")
Link: https://lore.kernel.org/r/20210121131959.646623-35-christian.brauner@ubuntu.com
Cc: David Howells <dhowells@redhat.com>
Cc: Aleksa Sarai <cyphar@cyphar.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: linux-fsdevel@vger.kernel.org
Cc: linux-api@vger.kernel.org
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Christian Brauner <christian.brauner@ubuntu.com>
2021-01-21 16:19:53 +03:00
|
|
|
unlock_mount_hash();
|
|
|
|
|
|
|
|
if (kattr->propagation) {
|
|
|
|
if (err)
|
|
|
|
cleanup_group_ids(mnt, NULL);
|
2023-03-30 10:13:16 +03:00
|
|
|
namespace_unlock();
|
fs: add mount_setattr()
This implements the missing mount_setattr() syscall. While the new mount
api allows to change the properties of a superblock there is currently
no way to change the properties of a mount or a mount tree using file
descriptors which the new mount api is based on. In addition the old
mount api has the restriction that mount options cannot be applied
recursively. This hasn't changed since changing mount options on a
per-mount basis was implemented in [1] and has been a frequent request
not just for convenience but also for security reasons. The legacy
mount syscall is unable to accommodate this behavior without introducing
a whole new set of flags because MS_REC | MS_REMOUNT | MS_BIND |
MS_RDONLY | MS_NOEXEC | [...] only apply the mount option to the topmost
mount. Changing MS_REC to apply to the whole mount tree would mean
introducing a significant uapi change and would likely cause significant
regressions.
The new mount_setattr() syscall allows to recursively clear and set
mount options in one shot. Multiple calls to change mount options
requesting the same changes are idempotent:
int mount_setattr(int dfd, const char *path, unsigned flags,
struct mount_attr *uattr, size_t usize);
Flags to modify path resolution behavior are specified in the @flags
argument. Currently, AT_EMPTY_PATH, AT_RECURSIVE, AT_SYMLINK_NOFOLLOW,
and AT_NO_AUTOMOUNT are supported. If useful, additional lookup flags to
restrict path resolution as introduced with openat2() might be supported
in the future.
The mount_setattr() syscall can be expected to grow over time and is
designed with extensibility in mind. It follows the extensible syscall
pattern we have used with other syscalls such as openat2(), clone3(),
sched_{set,get}attr(), and others.
The set of mount options is passed in the uapi struct mount_attr which
currently has the following layout:
struct mount_attr {
__u64 attr_set;
__u64 attr_clr;
__u64 propagation;
__u64 userns_fd;
};
The @attr_set and @attr_clr members are used to clear and set mount
options. This way a user can e.g. request that a set of flags is to be
raised such as turning mounts readonly by raising MOUNT_ATTR_RDONLY in
@attr_set while at the same time requesting that another set of flags is
to be lowered such as removing noexec from a mount tree by specifying
MOUNT_ATTR_NOEXEC in @attr_clr.
Note, since the MOUNT_ATTR_<atime> values are an enum starting from 0,
not a bitmap, users wanting to transition to a different atime setting
cannot simply specify the atime setting in @attr_set, but must also
specify MOUNT_ATTR__ATIME in the @attr_clr field. So we ensure that
MOUNT_ATTR__ATIME can't be partially set in @attr_clr and that @attr_set
can't have any atime bits set if MOUNT_ATTR__ATIME isn't set in
@attr_clr.
The @propagation field lets callers specify the propagation type of a
mount tree. Propagation is a single property that has four different
settings and as such is not really a flag argument but an enum.
Specifically, it would be unclear what setting and clearing propagation
settings in combination would amount to. The legacy mount() syscall thus
forbids the combination of multiple propagation settings too. The goal
is to keep the semantics of mount propagation somewhat simple as they
are overly complex as it is.
The @userns_fd field lets user specify a user namespace whose idmapping
becomes the idmapping of the mount. This is implemented and explained in
detail in the next patch.
[1]: commit 2e4b7fcd9260 ("[PATCH] r/o bind mounts: honor mount writer counts at remount")
Link: https://lore.kernel.org/r/20210121131959.646623-35-christian.brauner@ubuntu.com
Cc: David Howells <dhowells@redhat.com>
Cc: Aleksa Sarai <cyphar@cyphar.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: linux-fsdevel@vger.kernel.org
Cc: linux-api@vger.kernel.org
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Christian Brauner <christian.brauner@ubuntu.com>
2021-01-21 16:19:53 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2021-01-21 16:19:54 +03:00
|
|
|
static int build_mount_idmapped(const struct mount_attr *attr, size_t usize,
|
|
|
|
struct mount_kattr *kattr, unsigned int flags)
|
|
|
|
{
|
|
|
|
int err = 0;
|
|
|
|
struct ns_common *ns;
|
|
|
|
struct user_namespace *mnt_userns;
|
|
|
|
struct file *file;
|
|
|
|
|
|
|
|
if (!((attr->attr_set | attr->attr_clr) & MOUNT_ATTR_IDMAP))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We currently do not support clearing an idmapped mount. If this ever
|
|
|
|
* is a use-case we can revisit this but for now let's keep it simple
|
|
|
|
* and not allow it.
|
|
|
|
*/
|
|
|
|
if (attr->attr_clr & MOUNT_ATTR_IDMAP)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (attr->userns_fd > INT_MAX)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
file = fget(attr->userns_fd);
|
|
|
|
if (!file)
|
|
|
|
return -EBADF;
|
|
|
|
|
|
|
|
if (!proc_ns_file(file)) {
|
|
|
|
err = -EINVAL;
|
|
|
|
goto out_fput;
|
|
|
|
}
|
|
|
|
|
|
|
|
ns = get_proc_ns(file_inode(file));
|
|
|
|
if (ns->ops->type != CLONE_NEWUSER) {
|
|
|
|
err = -EINVAL;
|
|
|
|
goto out_fput;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2021-12-03 14:17:07 +03:00
|
|
|
* The initial idmapping cannot be used to create an idmapped
|
|
|
|
* mount. We use the initial idmapping as an indicator of a mount
|
|
|
|
* that is not idmapped. It can simply be passed into helpers that
|
|
|
|
* are aware of idmapped mounts as a convenient shortcut. A user
|
|
|
|
* can just create a dedicated identity mapping to achieve the same
|
|
|
|
* result.
|
2021-01-21 16:19:54 +03:00
|
|
|
*/
|
|
|
|
mnt_userns = container_of(ns, struct user_namespace, ns);
|
2023-01-13 14:49:33 +03:00
|
|
|
if (mnt_userns == &init_user_ns) {
|
2021-01-21 16:19:54 +03:00
|
|
|
err = -EPERM;
|
|
|
|
goto out_fput;
|
|
|
|
}
|
2022-08-16 19:47:52 +03:00
|
|
|
|
|
|
|
/* We're not controlling the target namespace. */
|
|
|
|
if (!ns_capable(mnt_userns, CAP_SYS_ADMIN)) {
|
|
|
|
err = -EPERM;
|
|
|
|
goto out_fput;
|
|
|
|
}
|
|
|
|
|
2021-01-21 16:19:54 +03:00
|
|
|
kattr->mnt_userns = get_user_ns(mnt_userns);
|
|
|
|
|
|
|
|
out_fput:
|
|
|
|
fput(file);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int build_mount_kattr(const struct mount_attr *attr, size_t usize,
|
fs: add mount_setattr()
This implements the missing mount_setattr() syscall. While the new mount
api allows to change the properties of a superblock there is currently
no way to change the properties of a mount or a mount tree using file
descriptors which the new mount api is based on. In addition the old
mount api has the restriction that mount options cannot be applied
recursively. This hasn't changed since changing mount options on a
per-mount basis was implemented in [1] and has been a frequent request
not just for convenience but also for security reasons. The legacy
mount syscall is unable to accommodate this behavior without introducing
a whole new set of flags because MS_REC | MS_REMOUNT | MS_BIND |
MS_RDONLY | MS_NOEXEC | [...] only apply the mount option to the topmost
mount. Changing MS_REC to apply to the whole mount tree would mean
introducing a significant uapi change and would likely cause significant
regressions.
The new mount_setattr() syscall allows to recursively clear and set
mount options in one shot. Multiple calls to change mount options
requesting the same changes are idempotent:
int mount_setattr(int dfd, const char *path, unsigned flags,
struct mount_attr *uattr, size_t usize);
Flags to modify path resolution behavior are specified in the @flags
argument. Currently, AT_EMPTY_PATH, AT_RECURSIVE, AT_SYMLINK_NOFOLLOW,
and AT_NO_AUTOMOUNT are supported. If useful, additional lookup flags to
restrict path resolution as introduced with openat2() might be supported
in the future.
The mount_setattr() syscall can be expected to grow over time and is
designed with extensibility in mind. It follows the extensible syscall
pattern we have used with other syscalls such as openat2(), clone3(),
sched_{set,get}attr(), and others.
The set of mount options is passed in the uapi struct mount_attr which
currently has the following layout:
struct mount_attr {
__u64 attr_set;
__u64 attr_clr;
__u64 propagation;
__u64 userns_fd;
};
The @attr_set and @attr_clr members are used to clear and set mount
options. This way a user can e.g. request that a set of flags is to be
raised such as turning mounts readonly by raising MOUNT_ATTR_RDONLY in
@attr_set while at the same time requesting that another set of flags is
to be lowered such as removing noexec from a mount tree by specifying
MOUNT_ATTR_NOEXEC in @attr_clr.
Note, since the MOUNT_ATTR_<atime> values are an enum starting from 0,
not a bitmap, users wanting to transition to a different atime setting
cannot simply specify the atime setting in @attr_set, but must also
specify MOUNT_ATTR__ATIME in the @attr_clr field. So we ensure that
MOUNT_ATTR__ATIME can't be partially set in @attr_clr and that @attr_set
can't have any atime bits set if MOUNT_ATTR__ATIME isn't set in
@attr_clr.
The @propagation field lets callers specify the propagation type of a
mount tree. Propagation is a single property that has four different
settings and as such is not really a flag argument but an enum.
Specifically, it would be unclear what setting and clearing propagation
settings in combination would amount to. The legacy mount() syscall thus
forbids the combination of multiple propagation settings too. The goal
is to keep the semantics of mount propagation somewhat simple as they
are overly complex as it is.
The @userns_fd field lets user specify a user namespace whose idmapping
becomes the idmapping of the mount. This is implemented and explained in
detail in the next patch.
[1]: commit 2e4b7fcd9260 ("[PATCH] r/o bind mounts: honor mount writer counts at remount")
Link: https://lore.kernel.org/r/20210121131959.646623-35-christian.brauner@ubuntu.com
Cc: David Howells <dhowells@redhat.com>
Cc: Aleksa Sarai <cyphar@cyphar.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: linux-fsdevel@vger.kernel.org
Cc: linux-api@vger.kernel.org
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Christian Brauner <christian.brauner@ubuntu.com>
2021-01-21 16:19:53 +03:00
|
|
|
struct mount_kattr *kattr, unsigned int flags)
|
|
|
|
{
|
|
|
|
unsigned int lookup_flags = LOOKUP_AUTOMOUNT | LOOKUP_FOLLOW;
|
|
|
|
|
|
|
|
if (flags & AT_NO_AUTOMOUNT)
|
|
|
|
lookup_flags &= ~LOOKUP_AUTOMOUNT;
|
|
|
|
if (flags & AT_SYMLINK_NOFOLLOW)
|
|
|
|
lookup_flags &= ~LOOKUP_FOLLOW;
|
|
|
|
if (flags & AT_EMPTY_PATH)
|
|
|
|
lookup_flags |= LOOKUP_EMPTY;
|
|
|
|
|
|
|
|
*kattr = (struct mount_kattr) {
|
|
|
|
.lookup_flags = lookup_flags,
|
|
|
|
.recurse = !!(flags & AT_RECURSIVE),
|
|
|
|
};
|
|
|
|
|
|
|
|
if (attr->propagation & ~MOUNT_SETATTR_PROPAGATION_FLAGS)
|
|
|
|
return -EINVAL;
|
|
|
|
if (hweight32(attr->propagation & MOUNT_SETATTR_PROPAGATION_FLAGS) > 1)
|
|
|
|
return -EINVAL;
|
|
|
|
kattr->propagation = attr->propagation;
|
|
|
|
|
|
|
|
if ((attr->attr_set | attr->attr_clr) & ~MOUNT_SETATTR_VALID_FLAGS)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
kattr->attr_set = attr_flags_to_mnt_flags(attr->attr_set);
|
|
|
|
kattr->attr_clr = attr_flags_to_mnt_flags(attr->attr_clr);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Since the MOUNT_ATTR_<atime> values are an enum, not a bitmap,
|
|
|
|
* users wanting to transition to a different atime setting cannot
|
|
|
|
* simply specify the atime setting in @attr_set, but must also
|
|
|
|
* specify MOUNT_ATTR__ATIME in the @attr_clr field.
|
|
|
|
* So ensure that MOUNT_ATTR__ATIME can't be partially set in
|
|
|
|
* @attr_clr and that @attr_set can't have any atime bits set if
|
|
|
|
* MOUNT_ATTR__ATIME isn't set in @attr_clr.
|
|
|
|
*/
|
|
|
|
if (attr->attr_clr & MOUNT_ATTR__ATIME) {
|
|
|
|
if ((attr->attr_clr & MOUNT_ATTR__ATIME) != MOUNT_ATTR__ATIME)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Clear all previous time settings as they are mutually
|
|
|
|
* exclusive.
|
|
|
|
*/
|
|
|
|
kattr->attr_clr |= MNT_RELATIME | MNT_NOATIME;
|
|
|
|
switch (attr->attr_set & MOUNT_ATTR__ATIME) {
|
|
|
|
case MOUNT_ATTR_RELATIME:
|
|
|
|
kattr->attr_set |= MNT_RELATIME;
|
|
|
|
break;
|
|
|
|
case MOUNT_ATTR_NOATIME:
|
|
|
|
kattr->attr_set |= MNT_NOATIME;
|
|
|
|
break;
|
|
|
|
case MOUNT_ATTR_STRICTATIME:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (attr->attr_set & MOUNT_ATTR__ATIME)
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2021-01-21 16:19:54 +03:00
|
|
|
return build_mount_idmapped(attr, usize, kattr, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void finish_mount_kattr(struct mount_kattr *kattr)
|
|
|
|
{
|
|
|
|
put_user_ns(kattr->mnt_userns);
|
|
|
|
kattr->mnt_userns = NULL;
|
2022-10-26 13:51:27 +03:00
|
|
|
|
|
|
|
if (kattr->mnt_idmap)
|
|
|
|
mnt_idmap_put(kattr->mnt_idmap);
|
fs: add mount_setattr()
This implements the missing mount_setattr() syscall. While the new mount
api allows to change the properties of a superblock there is currently
no way to change the properties of a mount or a mount tree using file
descriptors which the new mount api is based on. In addition the old
mount api has the restriction that mount options cannot be applied
recursively. This hasn't changed since changing mount options on a
per-mount basis was implemented in [1] and has been a frequent request
not just for convenience but also for security reasons. The legacy
mount syscall is unable to accommodate this behavior without introducing
a whole new set of flags because MS_REC | MS_REMOUNT | MS_BIND |
MS_RDONLY | MS_NOEXEC | [...] only apply the mount option to the topmost
mount. Changing MS_REC to apply to the whole mount tree would mean
introducing a significant uapi change and would likely cause significant
regressions.
The new mount_setattr() syscall allows to recursively clear and set
mount options in one shot. Multiple calls to change mount options
requesting the same changes are idempotent:
int mount_setattr(int dfd, const char *path, unsigned flags,
struct mount_attr *uattr, size_t usize);
Flags to modify path resolution behavior are specified in the @flags
argument. Currently, AT_EMPTY_PATH, AT_RECURSIVE, AT_SYMLINK_NOFOLLOW,
and AT_NO_AUTOMOUNT are supported. If useful, additional lookup flags to
restrict path resolution as introduced with openat2() might be supported
in the future.
The mount_setattr() syscall can be expected to grow over time and is
designed with extensibility in mind. It follows the extensible syscall
pattern we have used with other syscalls such as openat2(), clone3(),
sched_{set,get}attr(), and others.
The set of mount options is passed in the uapi struct mount_attr which
currently has the following layout:
struct mount_attr {
__u64 attr_set;
__u64 attr_clr;
__u64 propagation;
__u64 userns_fd;
};
The @attr_set and @attr_clr members are used to clear and set mount
options. This way a user can e.g. request that a set of flags is to be
raised such as turning mounts readonly by raising MOUNT_ATTR_RDONLY in
@attr_set while at the same time requesting that another set of flags is
to be lowered such as removing noexec from a mount tree by specifying
MOUNT_ATTR_NOEXEC in @attr_clr.
Note, since the MOUNT_ATTR_<atime> values are an enum starting from 0,
not a bitmap, users wanting to transition to a different atime setting
cannot simply specify the atime setting in @attr_set, but must also
specify MOUNT_ATTR__ATIME in the @attr_clr field. So we ensure that
MOUNT_ATTR__ATIME can't be partially set in @attr_clr and that @attr_set
can't have any atime bits set if MOUNT_ATTR__ATIME isn't set in
@attr_clr.
The @propagation field lets callers specify the propagation type of a
mount tree. Propagation is a single property that has four different
settings and as such is not really a flag argument but an enum.
Specifically, it would be unclear what setting and clearing propagation
settings in combination would amount to. The legacy mount() syscall thus
forbids the combination of multiple propagation settings too. The goal
is to keep the semantics of mount propagation somewhat simple as they
are overly complex as it is.
The @userns_fd field lets user specify a user namespace whose idmapping
becomes the idmapping of the mount. This is implemented and explained in
detail in the next patch.
[1]: commit 2e4b7fcd9260 ("[PATCH] r/o bind mounts: honor mount writer counts at remount")
Link: https://lore.kernel.org/r/20210121131959.646623-35-christian.brauner@ubuntu.com
Cc: David Howells <dhowells@redhat.com>
Cc: Aleksa Sarai <cyphar@cyphar.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: linux-fsdevel@vger.kernel.org
Cc: linux-api@vger.kernel.org
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Christian Brauner <christian.brauner@ubuntu.com>
2021-01-21 16:19:53 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
SYSCALL_DEFINE5(mount_setattr, int, dfd, const char __user *, path,
|
|
|
|
unsigned int, flags, struct mount_attr __user *, uattr,
|
|
|
|
size_t, usize)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
struct path target;
|
|
|
|
struct mount_attr attr;
|
|
|
|
struct mount_kattr kattr;
|
|
|
|
|
|
|
|
BUILD_BUG_ON(sizeof(struct mount_attr) != MOUNT_ATTR_SIZE_VER0);
|
|
|
|
|
|
|
|
if (flags & ~(AT_EMPTY_PATH |
|
|
|
|
AT_RECURSIVE |
|
|
|
|
AT_SYMLINK_NOFOLLOW |
|
|
|
|
AT_NO_AUTOMOUNT))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (unlikely(usize > PAGE_SIZE))
|
|
|
|
return -E2BIG;
|
|
|
|
if (unlikely(usize < MOUNT_ATTR_SIZE_VER0))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (!may_mount())
|
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
err = copy_struct_from_user(&attr, sizeof(attr), uattr, usize);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
/* Don't bother walking through the mounts if this is a nop. */
|
|
|
|
if (attr.attr_set == 0 &&
|
|
|
|
attr.attr_clr == 0 &&
|
|
|
|
attr.propagation == 0)
|
|
|
|
return 0;
|
|
|
|
|
2021-01-21 16:19:54 +03:00
|
|
|
err = build_mount_kattr(&attr, usize, &kattr, flags);
|
fs: add mount_setattr()
This implements the missing mount_setattr() syscall. While the new mount
api allows to change the properties of a superblock there is currently
no way to change the properties of a mount or a mount tree using file
descriptors which the new mount api is based on. In addition the old
mount api has the restriction that mount options cannot be applied
recursively. This hasn't changed since changing mount options on a
per-mount basis was implemented in [1] and has been a frequent request
not just for convenience but also for security reasons. The legacy
mount syscall is unable to accommodate this behavior without introducing
a whole new set of flags because MS_REC | MS_REMOUNT | MS_BIND |
MS_RDONLY | MS_NOEXEC | [...] only apply the mount option to the topmost
mount. Changing MS_REC to apply to the whole mount tree would mean
introducing a significant uapi change and would likely cause significant
regressions.
The new mount_setattr() syscall allows to recursively clear and set
mount options in one shot. Multiple calls to change mount options
requesting the same changes are idempotent:
int mount_setattr(int dfd, const char *path, unsigned flags,
struct mount_attr *uattr, size_t usize);
Flags to modify path resolution behavior are specified in the @flags
argument. Currently, AT_EMPTY_PATH, AT_RECURSIVE, AT_SYMLINK_NOFOLLOW,
and AT_NO_AUTOMOUNT are supported. If useful, additional lookup flags to
restrict path resolution as introduced with openat2() might be supported
in the future.
The mount_setattr() syscall can be expected to grow over time and is
designed with extensibility in mind. It follows the extensible syscall
pattern we have used with other syscalls such as openat2(), clone3(),
sched_{set,get}attr(), and others.
The set of mount options is passed in the uapi struct mount_attr which
currently has the following layout:
struct mount_attr {
__u64 attr_set;
__u64 attr_clr;
__u64 propagation;
__u64 userns_fd;
};
The @attr_set and @attr_clr members are used to clear and set mount
options. This way a user can e.g. request that a set of flags is to be
raised such as turning mounts readonly by raising MOUNT_ATTR_RDONLY in
@attr_set while at the same time requesting that another set of flags is
to be lowered such as removing noexec from a mount tree by specifying
MOUNT_ATTR_NOEXEC in @attr_clr.
Note, since the MOUNT_ATTR_<atime> values are an enum starting from 0,
not a bitmap, users wanting to transition to a different atime setting
cannot simply specify the atime setting in @attr_set, but must also
specify MOUNT_ATTR__ATIME in the @attr_clr field. So we ensure that
MOUNT_ATTR__ATIME can't be partially set in @attr_clr and that @attr_set
can't have any atime bits set if MOUNT_ATTR__ATIME isn't set in
@attr_clr.
The @propagation field lets callers specify the propagation type of a
mount tree. Propagation is a single property that has four different
settings and as such is not really a flag argument but an enum.
Specifically, it would be unclear what setting and clearing propagation
settings in combination would amount to. The legacy mount() syscall thus
forbids the combination of multiple propagation settings too. The goal
is to keep the semantics of mount propagation somewhat simple as they
are overly complex as it is.
The @userns_fd field lets user specify a user namespace whose idmapping
becomes the idmapping of the mount. This is implemented and explained in
detail in the next patch.
[1]: commit 2e4b7fcd9260 ("[PATCH] r/o bind mounts: honor mount writer counts at remount")
Link: https://lore.kernel.org/r/20210121131959.646623-35-christian.brauner@ubuntu.com
Cc: David Howells <dhowells@redhat.com>
Cc: Aleksa Sarai <cyphar@cyphar.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: linux-fsdevel@vger.kernel.org
Cc: linux-api@vger.kernel.org
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Christian Brauner <christian.brauner@ubuntu.com>
2021-01-21 16:19:53 +03:00
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
err = user_path_at(dfd, path, kattr.lookup_flags, &target);
|
2021-12-30 22:23:09 +03:00
|
|
|
if (!err) {
|
|
|
|
err = do_mount_setattr(&target, &kattr);
|
|
|
|
path_put(&target);
|
|
|
|
}
|
2021-01-21 16:19:54 +03:00
|
|
|
finish_mount_kattr(&kattr);
|
fs: add mount_setattr()
This implements the missing mount_setattr() syscall. While the new mount
api allows to change the properties of a superblock there is currently
no way to change the properties of a mount or a mount tree using file
descriptors which the new mount api is based on. In addition the old
mount api has the restriction that mount options cannot be applied
recursively. This hasn't changed since changing mount options on a
per-mount basis was implemented in [1] and has been a frequent request
not just for convenience but also for security reasons. The legacy
mount syscall is unable to accommodate this behavior without introducing
a whole new set of flags because MS_REC | MS_REMOUNT | MS_BIND |
MS_RDONLY | MS_NOEXEC | [...] only apply the mount option to the topmost
mount. Changing MS_REC to apply to the whole mount tree would mean
introducing a significant uapi change and would likely cause significant
regressions.
The new mount_setattr() syscall allows to recursively clear and set
mount options in one shot. Multiple calls to change mount options
requesting the same changes are idempotent:
int mount_setattr(int dfd, const char *path, unsigned flags,
struct mount_attr *uattr, size_t usize);
Flags to modify path resolution behavior are specified in the @flags
argument. Currently, AT_EMPTY_PATH, AT_RECURSIVE, AT_SYMLINK_NOFOLLOW,
and AT_NO_AUTOMOUNT are supported. If useful, additional lookup flags to
restrict path resolution as introduced with openat2() might be supported
in the future.
The mount_setattr() syscall can be expected to grow over time and is
designed with extensibility in mind. It follows the extensible syscall
pattern we have used with other syscalls such as openat2(), clone3(),
sched_{set,get}attr(), and others.
The set of mount options is passed in the uapi struct mount_attr which
currently has the following layout:
struct mount_attr {
__u64 attr_set;
__u64 attr_clr;
__u64 propagation;
__u64 userns_fd;
};
The @attr_set and @attr_clr members are used to clear and set mount
options. This way a user can e.g. request that a set of flags is to be
raised such as turning mounts readonly by raising MOUNT_ATTR_RDONLY in
@attr_set while at the same time requesting that another set of flags is
to be lowered such as removing noexec from a mount tree by specifying
MOUNT_ATTR_NOEXEC in @attr_clr.
Note, since the MOUNT_ATTR_<atime> values are an enum starting from 0,
not a bitmap, users wanting to transition to a different atime setting
cannot simply specify the atime setting in @attr_set, but must also
specify MOUNT_ATTR__ATIME in the @attr_clr field. So we ensure that
MOUNT_ATTR__ATIME can't be partially set in @attr_clr and that @attr_set
can't have any atime bits set if MOUNT_ATTR__ATIME isn't set in
@attr_clr.
The @propagation field lets callers specify the propagation type of a
mount tree. Propagation is a single property that has four different
settings and as such is not really a flag argument but an enum.
Specifically, it would be unclear what setting and clearing propagation
settings in combination would amount to. The legacy mount() syscall thus
forbids the combination of multiple propagation settings too. The goal
is to keep the semantics of mount propagation somewhat simple as they
are overly complex as it is.
The @userns_fd field lets user specify a user namespace whose idmapping
becomes the idmapping of the mount. This is implemented and explained in
detail in the next patch.
[1]: commit 2e4b7fcd9260 ("[PATCH] r/o bind mounts: honor mount writer counts at remount")
Link: https://lore.kernel.org/r/20210121131959.646623-35-christian.brauner@ubuntu.com
Cc: David Howells <dhowells@redhat.com>
Cc: Aleksa Sarai <cyphar@cyphar.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: linux-fsdevel@vger.kernel.org
Cc: linux-api@vger.kernel.org
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Christian Brauner <christian.brauner@ubuntu.com>
2021-01-21 16:19:53 +03:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
static void __init init_mount_tree(void)
|
|
|
|
{
|
|
|
|
struct vfsmount *mnt;
|
2019-01-30 21:30:21 +03:00
|
|
|
struct mount *m;
|
2006-12-08 13:37:56 +03:00
|
|
|
struct mnt_namespace *ns;
|
2008-02-15 06:34:39 +03:00
|
|
|
struct path root;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2019-05-31 00:48:35 +03:00
|
|
|
mnt = vfs_kern_mount(&rootfs_fs_type, 0, "rootfs", NULL);
|
2005-04-17 02:20:36 +04:00
|
|
|
if (IS_ERR(mnt))
|
|
|
|
panic("Can't create rootfs");
|
fs: scale mntget/mntput
The problem that this patch aims to fix is vfsmount refcounting scalability.
We need to take a reference on the vfsmount for every successful path lookup,
which often go to the same mount point.
The fundamental difficulty is that a "simple" reference count can never be made
scalable, because any time a reference is dropped, we must check whether that
was the last reference. To do that requires communication with all other CPUs
that may have taken a reference count.
We can make refcounts more scalable in a couple of ways, involving keeping
distributed counters, and checking for the global-zero condition less
frequently.
- check the global sum once every interval (this will delay zero detection
for some interval, so it's probably a showstopper for vfsmounts).
- keep a local count and only taking the global sum when local reaches 0 (this
is difficult for vfsmounts, because we can't hold preempt off for the life of
a reference, so a counter would need to be per-thread or tied strongly to a
particular CPU which requires more locking).
- keep a local difference of increments and decrements, which allows us to sum
the total difference and hence find the refcount when summing all CPUs. Then,
keep a single integer "long" refcount for slow and long lasting references,
and only take the global sum of local counters when the long refcount is 0.
This last scheme is what I implemented here. Attached mounts and process root
and working directory references are "long" references, and everything else is
a short reference.
This allows scalable vfsmount references during path walking over mounted
subtrees and unattached (lazy umounted) mounts with processes still running
in them.
This results in one fewer atomic op in the fastpath: mntget is now just a
per-CPU inc, rather than an atomic inc; and mntput just requires a spinlock
and non-atomic decrement in the common case. However code is otherwise bigger
and heavier, so single threaded performance is basically a wash.
Signed-off-by: Nick Piggin <npiggin@kernel.dk>
2011-01-07 09:50:11 +03:00
|
|
|
|
2019-01-30 21:30:21 +03:00
|
|
|
ns = alloc_mnt_ns(&init_user_ns, false);
|
2009-06-24 01:29:49 +04:00
|
|
|
if (IS_ERR(ns))
|
2005-04-17 02:20:36 +04:00
|
|
|
panic("Can't allocate initial namespace");
|
2019-01-30 21:30:21 +03:00
|
|
|
m = real_mount(mnt);
|
|
|
|
m->mnt_ns = ns;
|
|
|
|
ns->root = m;
|
|
|
|
ns->mounts = 1;
|
|
|
|
list_add(&m->mnt_list, &ns->list);
|
2006-12-08 13:37:56 +03:00
|
|
|
init_task.nsproxy->mnt_ns = ns;
|
|
|
|
get_mnt_ns(ns);
|
|
|
|
|
2011-12-06 22:32:36 +04:00
|
|
|
root.mnt = mnt;
|
|
|
|
root.dentry = mnt->mnt_root;
|
umount: Do not allow unmounting rootfs.
Andrew Vagin <avagin@parallels.com> writes:
> #define _GNU_SOURCE
> #include <sys/types.h>
> #include <sys/stat.h>
> #include <fcntl.h>
> #include <sched.h>
> #include <unistd.h>
> #include <sys/mount.h>
>
> int main(int argc, char **argv)
> {
> int fd;
>
> fd = open("/proc/self/ns/mnt", O_RDONLY);
> if (fd < 0)
> return 1;
> while (1) {
> if (umount2("/", MNT_DETACH) ||
> setns(fd, CLONE_NEWNS))
> break;
> }
>
> return 0;
> }
>
> root@ubuntu:/home/avagin# gcc -Wall nsenter.c -o nsenter
> root@ubuntu:/home/avagin# strace ./nsenter
> execve("./nsenter", ["./nsenter"], [/* 22 vars */]) = 0
> ...
> open("/proc/self/ns/mnt", O_RDONLY) = 3
> umount("/", MNT_DETACH) = 0
> setns(3, 131072) = 0
> umount("/", MNT_DETACH
>
causes:
> [ 260.548301] ------------[ cut here ]------------
> [ 260.550941] kernel BUG at /build/buildd/linux-3.13.0/fs/pnode.c:372!
> [ 260.552068] invalid opcode: 0000 [#1] SMP
> [ 260.552068] Modules linked in: xt_CHECKSUM iptable_mangle xt_tcpudp xt_addrtype xt_conntrack ipt_MASQUERADE iptable_nat nf_conntrack_ipv4 nf_defrag_ipv4 nf_nat_ipv4 nf_nat nf_conntrack bridge stp llc dm_thin_pool dm_persistent_data dm_bufio dm_bio_prison iptable_filter ip_tables x_tables crct10dif_pclmul crc32_pclmul ghash_clmulni_intel binfmt_misc nfsd auth_rpcgss nfs_acl aesni_intel nfs lockd aes_x86_64 sunrpc fscache lrw gf128mul glue_helper ablk_helper cryptd serio_raw ppdev parport_pc lp parport btrfs xor raid6_pq libcrc32c psmouse floppy
> [ 260.552068] CPU: 0 PID: 1723 Comm: nsenter Not tainted 3.13.0-30-generic #55-Ubuntu
> [ 260.552068] Hardware name: Bochs Bochs, BIOS Bochs 01/01/2011
> [ 260.552068] task: ffff8800376097f0 ti: ffff880074824000 task.ti: ffff880074824000
> [ 260.552068] RIP: 0010:[<ffffffff811e9483>] [<ffffffff811e9483>] propagate_umount+0x123/0x130
> [ 260.552068] RSP: 0018:ffff880074825e98 EFLAGS: 00010246
> [ 260.552068] RAX: ffff88007c741140 RBX: 0000000000000002 RCX: ffff88007c741190
> [ 260.552068] RDX: ffff88007c741190 RSI: ffff880074825ec0 RDI: ffff880074825ec0
> [ 260.552068] RBP: ffff880074825eb0 R08: 00000000000172e0 R09: ffff88007fc172e0
> [ 260.552068] R10: ffffffff811cc642 R11: ffffea0001d59000 R12: ffff88007c741140
> [ 260.552068] R13: ffff88007c741140 R14: ffff88007c741140 R15: 0000000000000000
> [ 260.552068] FS: 00007fd5c7e41740(0000) GS:ffff88007fc00000(0000) knlGS:0000000000000000
> [ 260.552068] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
> [ 260.552068] CR2: 00007fd5c7968050 CR3: 0000000070124000 CR4: 00000000000406f0
> [ 260.552068] Stack:
> [ 260.552068] 0000000000000002 0000000000000002 ffff88007c631000 ffff880074825ed8
> [ 260.552068] ffffffff811dcfac ffff88007c741140 0000000000000002 ffff88007c741160
> [ 260.552068] ffff880074825f38 ffffffff811dd12b ffffffff811cc642 0000000075640000
> [ 260.552068] Call Trace:
> [ 260.552068] [<ffffffff811dcfac>] umount_tree+0x20c/0x260
> [ 260.552068] [<ffffffff811dd12b>] do_umount+0x12b/0x300
> [ 260.552068] [<ffffffff811cc642>] ? final_putname+0x22/0x50
> [ 260.552068] [<ffffffff811cc849>] ? putname+0x29/0x40
> [ 260.552068] [<ffffffff811dd88c>] SyS_umount+0xdc/0x100
> [ 260.552068] [<ffffffff8172aeff>] tracesys+0xe1/0xe6
> [ 260.552068] Code: 89 50 08 48 8b 50 08 48 89 02 49 89 45 08 e9 72 ff ff ff 0f 1f 44 00 00 4c 89 e6 4c 89 e7 e8 f5 f6 ff ff 48 89 c3 e9 39 ff ff ff <0f> 0b 66 2e 0f 1f 84 00 00 00 00 00 90 66 66 66 66 90 55 b8 01
> [ 260.552068] RIP [<ffffffff811e9483>] propagate_umount+0x123/0x130
> [ 260.552068] RSP <ffff880074825e98>
> [ 260.611451] ---[ end trace 11c33d85f1d4c652 ]--
Which in practice is totally uninteresting. Only the global root user can
do it, and it is just a stupid thing to do.
However that is no excuse to allow a silly way to oops the kernel.
We can avoid this silly problem by setting MNT_LOCKED on the rootfs
mount point and thus avoid needing any special cases in the unmount
code.
Signed-off-by: "Eric W. Biederman" <ebiederm@xmission.com>
2014-10-07 23:19:53 +04:00
|
|
|
mnt->mnt_flags |= MNT_LOCKED;
|
2008-02-15 06:34:39 +03:00
|
|
|
|
|
|
|
set_fs_pwd(current->fs, &root);
|
|
|
|
set_fs_root(current->fs, &root);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2007-10-17 10:26:30 +04:00
|
|
|
void __init mnt_init(void)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2006-09-29 12:58:57 +04:00
|
|
|
int err;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2011-11-23 21:14:10 +04:00
|
|
|
mnt_cache = kmem_cache_create("mnt_cache", sizeof(struct mount),
|
memcg: enable accounting for mnt_cache entries
Patch series "memcg accounting from OpenVZ", v7.
OpenVZ uses memory accounting 20+ years since v2.2.x linux kernels.
Initially we used our own accounting subsystem, then partially committed
it to upstream, and a few years ago switched to cgroups v1. Now we're
rebasing again, revising our old patches and trying to push them upstream.
We try to protect the host system from any misuse of kernel memory
allocation triggered by untrusted users inside the containers.
Patch-set is addressed mostly to cgroups maintainers and cgroups@ mailing
list, though I would be very grateful for any comments from maintainersi
of affected subsystems or other people added in cc:
Compared to the upstream, we additionally account the following kernel objects:
- network devices and its Tx/Rx queues
- ipv4/v6 addresses and routing-related objects
- inet_bind_bucket cache objects
- VLAN group arrays
- ipv6/sit: ip_tunnel_prl
- scm_fp_list objects used by SCM_RIGHTS messages of Unix sockets
- nsproxy and namespace objects itself
- IPC objects: semaphores, message queues and share memory segments
- mounts
- pollfd and select bits arrays
- signals and posix timers
- file lock
- fasync_struct used by the file lease code and driver's fasync queues
- tty objects
- per-mm LDT
We have an incorrect/incomplete/obsoleted accounting for few other kernel
objects: sk_filter, af_packets, netlink and xt_counters for iptables.
They require rework and probably will be dropped at all.
Also we're going to add an accounting for nft, however it is not ready
yet.
We have not tested performance on upstream, however, our performance team
compares our current RHEL7-based production kernel and reports that they
are at least not worse as the according original RHEL7 kernel.
This patch (of 10):
The kernel allocates ~400 bytes of 'struct mount' for any new mount.
Creating a new mount namespace clones most of the parent mounts, and this
can be repeated many times. Additionally, each mount allocates up to
PATH_MAX=4096 bytes for mnt->mnt_devname.
It makes sense to account for these allocations to restrict the host's
memory consumption from inside the memcg-limited container.
Link: https://lkml.kernel.org/r/045db11f-4a45-7c9b-2664-5b32c2b44943@virtuozzo.com
Signed-off-by: Vasily Averin <vvs@virtuozzo.com>
Reviewed-by: Shakeel Butt <shakeelb@google.com>
Acked-by: Christian Brauner <christian.brauner@ubuntu.com>
Cc: Tejun Heo <tj@kernel.org>
Cc: Michal Hocko <mhocko@kernel.org>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Vladimir Davydov <vdavydov.dev@gmail.com>
Cc: Roman Gushchin <guro@fb.com>
Cc: Yutian Yang <nglaive@gmail.com>
Cc: Alexander Viro <viro@zeniv.linux.org.uk>
Cc: Alexey Dobriyan <adobriyan@gmail.com>
Cc: Andrei Vagin <avagin@gmail.com>
Cc: Borislav Petkov <bp@alien8.de>
Cc: Dmitry Safonov <0x7f454c46@gmail.com>
Cc: "Eric W. Biederman" <ebiederm@xmission.com>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: "J. Bruce Fields" <bfields@fieldses.org>
Cc: Jeff Layton <jlayton@kernel.org>
Cc: Jens Axboe <axboe@kernel.dk>
Cc: Jiri Slaby <jirislaby@kernel.org>
Cc: Kirill Tkhai <ktkhai@virtuozzo.com>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Serge Hallyn <serge@hallyn.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Zefan Li <lizefan.x@bytedance.com>
Cc: Borislav Petkov <bp@suse.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-09-03 00:55:10 +03:00
|
|
|
0, SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_ACCOUNT, NULL);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2014-02-28 22:46:44 +04:00
|
|
|
mount_hashtable = alloc_large_system_hash("Mount-cache",
|
2014-03-21 05:10:51 +04:00
|
|
|
sizeof(struct hlist_head),
|
2014-02-28 22:46:44 +04:00
|
|
|
mhash_entries, 19,
|
2017-07-07 01:39:11 +03:00
|
|
|
HASH_ZERO,
|
2014-02-28 22:46:44 +04:00
|
|
|
&m_hash_shift, &m_hash_mask, 0, 0);
|
|
|
|
mountpoint_hashtable = alloc_large_system_hash("Mountpoint-cache",
|
|
|
|
sizeof(struct hlist_head),
|
|
|
|
mphash_entries, 19,
|
2017-07-07 01:39:11 +03:00
|
|
|
HASH_ZERO,
|
2014-02-28 22:46:44 +04:00
|
|
|
&mp_hash_shift, &mp_hash_mask, 0, 0);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2013-03-15 18:53:28 +04:00
|
|
|
if (!mount_hashtable || !mountpoint_hashtable)
|
2005-04-17 02:20:36 +04:00
|
|
|
panic("Failed to allocate mount hash table\n");
|
|
|
|
|
2013-11-28 23:54:43 +04:00
|
|
|
kernfs_init();
|
|
|
|
|
2006-09-29 12:58:57 +04:00
|
|
|
err = sysfs_init();
|
|
|
|
if (err)
|
|
|
|
printk(KERN_WARNING "%s: sysfs_init error: %d\n",
|
2008-04-30 11:55:09 +04:00
|
|
|
__func__, err);
|
2007-10-29 23:17:23 +03:00
|
|
|
fs_kobj = kobject_create_and_add("fs", NULL);
|
|
|
|
if (!fs_kobj)
|
2008-04-30 11:55:09 +04:00
|
|
|
printk(KERN_WARNING "%s: kobj create error\n", __func__);
|
2019-06-02 01:09:44 +03:00
|
|
|
shmem_init();
|
2005-04-17 02:20:36 +04:00
|
|
|
init_rootfs();
|
|
|
|
init_mount_tree();
|
|
|
|
}
|
|
|
|
|
2009-06-22 23:09:13 +04:00
|
|
|
void put_mnt_ns(struct mnt_namespace *ns)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2020-08-03 13:16:42 +03:00
|
|
|
if (!refcount_dec_and_test(&ns->ns.count))
|
2009-06-22 23:09:13 +04:00
|
|
|
return;
|
2013-09-17 05:19:20 +04:00
|
|
|
drop_collected_mounts(&ns->root->mnt);
|
2012-07-27 08:08:32 +04:00
|
|
|
free_mnt_ns(ns);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
2011-03-18 05:08:28 +03:00
|
|
|
|
2018-11-02 02:07:26 +03:00
|
|
|
struct vfsmount *kern_mount(struct file_system_type *type)
|
2011-03-18 05:08:28 +03:00
|
|
|
{
|
2011-07-19 20:32:38 +04:00
|
|
|
struct vfsmount *mnt;
|
2018-11-02 02:07:26 +03:00
|
|
|
mnt = vfs_kern_mount(type, SB_KERNMOUNT, type->name, NULL);
|
2011-07-19 20:32:38 +04:00
|
|
|
if (!IS_ERR(mnt)) {
|
|
|
|
/*
|
|
|
|
* it is a longterm mount, don't release mnt until
|
|
|
|
* we unmount before file sys is unregistered
|
|
|
|
*/
|
2012-06-09 08:59:08 +04:00
|
|
|
real_mount(mnt)->mnt_ns = MNT_NS_INTERNAL;
|
2011-07-19 20:32:38 +04:00
|
|
|
}
|
|
|
|
return mnt;
|
2011-03-18 05:08:28 +03:00
|
|
|
}
|
2018-11-02 02:07:26 +03:00
|
|
|
EXPORT_SYMBOL_GPL(kern_mount);
|
2011-07-19 20:32:38 +04:00
|
|
|
|
|
|
|
void kern_unmount(struct vfsmount *mnt)
|
|
|
|
{
|
|
|
|
/* release long term mount so mount point can be released */
|
2023-01-27 21:46:51 +03:00
|
|
|
if (!IS_ERR(mnt)) {
|
|
|
|
mnt_make_shortterm(mnt);
|
2013-09-30 06:06:07 +04:00
|
|
|
synchronize_rcu(); /* yecchhh... */
|
2011-07-19 20:32:38 +04:00
|
|
|
mntput(mnt);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(kern_unmount);
|
fix apparmor dereferencing potentially freed dentry, sanitize __d_path() API
__d_path() API is asking for trouble and in case of apparmor d_namespace_path()
getting just that. The root cause is that when __d_path() misses the root
it had been told to look for, it stores the location of the most remote ancestor
in *root. Without grabbing references. Sure, at the moment of call it had
been pinned down by what we have in *path. And if we raced with umount -l, we
could have very well stopped at vfsmount/dentry that got freed as soon as
prepend_path() dropped vfsmount_lock.
It is safe to compare these pointers with pre-existing (and known to be still
alive) vfsmount and dentry, as long as all we are asking is "is it the same
address?". Dereferencing is not safe and apparmor ended up stepping into
that. d_namespace_path() really wants to examine the place where we stopped,
even if it's not connected to our namespace. As the result, it looked
at ->d_sb->s_magic of a dentry that might've been already freed by that point.
All other callers had been careful enough to avoid that, but it's really
a bad interface - it invites that kind of trouble.
The fix is fairly straightforward, even though it's bigger than I'd like:
* prepend_path() root argument becomes const.
* __d_path() is never called with NULL/NULL root. It was a kludge
to start with. Instead, we have an explicit function - d_absolute_root().
Same as __d_path(), except that it doesn't get root passed and stops where
it stops. apparmor and tomoyo are using it.
* __d_path() returns NULL on path outside of root. The main
caller is show_mountinfo() and that's precisely what we pass root for - to
skip those outside chroot jail. Those who don't want that can (and do)
use d_path().
* __d_path() root argument becomes const. Everyone agrees, I hope.
* apparmor does *NOT* try to use __d_path() or any of its variants
when it sees that path->mnt is an internal vfsmount. In that case it's
definitely not mounted anywhere and dentry_path() is exactly what we want
there. Handling of sysctl()-triggered weirdness is moved to that place.
* if apparmor is asked to do pathname relative to chroot jail
and __d_path() tells it we it's not in that jail, the sucker just calls
d_absolute_path() instead. That's the other remaining caller of __d_path(),
BTW.
* seq_path_root() does _NOT_ return -ENAMETOOLONG (it's stupid anyway -
the normal seq_file logics will take care of growing the buffer and redoing
the call of ->show() just fine). However, if it gets path not reachable
from root, it returns SEQ_SKIP. The only caller adjusted (i.e. stopped
ignoring the return value as it used to do).
Reviewed-by: John Johansen <john.johansen@canonical.com>
ACKed-by: John Johansen <john.johansen@canonical.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
Cc: stable@vger.kernel.org
2011-12-05 17:43:34 +04:00
|
|
|
|
2020-06-04 11:48:19 +03:00
|
|
|
void kern_unmount_array(struct vfsmount *mnt[], unsigned int num)
|
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
for (i = 0; i < num; i++)
|
2023-01-27 21:46:51 +03:00
|
|
|
mnt_make_shortterm(mnt[i]);
|
2020-06-04 11:48:19 +03:00
|
|
|
synchronize_rcu_expedited();
|
|
|
|
for (i = 0; i < num; i++)
|
|
|
|
mntput(mnt[i]);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(kern_unmount_array);
|
|
|
|
|
fix apparmor dereferencing potentially freed dentry, sanitize __d_path() API
__d_path() API is asking for trouble and in case of apparmor d_namespace_path()
getting just that. The root cause is that when __d_path() misses the root
it had been told to look for, it stores the location of the most remote ancestor
in *root. Without grabbing references. Sure, at the moment of call it had
been pinned down by what we have in *path. And if we raced with umount -l, we
could have very well stopped at vfsmount/dentry that got freed as soon as
prepend_path() dropped vfsmount_lock.
It is safe to compare these pointers with pre-existing (and known to be still
alive) vfsmount and dentry, as long as all we are asking is "is it the same
address?". Dereferencing is not safe and apparmor ended up stepping into
that. d_namespace_path() really wants to examine the place where we stopped,
even if it's not connected to our namespace. As the result, it looked
at ->d_sb->s_magic of a dentry that might've been already freed by that point.
All other callers had been careful enough to avoid that, but it's really
a bad interface - it invites that kind of trouble.
The fix is fairly straightforward, even though it's bigger than I'd like:
* prepend_path() root argument becomes const.
* __d_path() is never called with NULL/NULL root. It was a kludge
to start with. Instead, we have an explicit function - d_absolute_root().
Same as __d_path(), except that it doesn't get root passed and stops where
it stops. apparmor and tomoyo are using it.
* __d_path() returns NULL on path outside of root. The main
caller is show_mountinfo() and that's precisely what we pass root for - to
skip those outside chroot jail. Those who don't want that can (and do)
use d_path().
* __d_path() root argument becomes const. Everyone agrees, I hope.
* apparmor does *NOT* try to use __d_path() or any of its variants
when it sees that path->mnt is an internal vfsmount. In that case it's
definitely not mounted anywhere and dentry_path() is exactly what we want
there. Handling of sysctl()-triggered weirdness is moved to that place.
* if apparmor is asked to do pathname relative to chroot jail
and __d_path() tells it we it's not in that jail, the sucker just calls
d_absolute_path() instead. That's the other remaining caller of __d_path(),
BTW.
* seq_path_root() does _NOT_ return -ENAMETOOLONG (it's stupid anyway -
the normal seq_file logics will take care of growing the buffer and redoing
the call of ->show() just fine). However, if it gets path not reachable
from root, it returns SEQ_SKIP. The only caller adjusted (i.e. stopped
ignoring the return value as it used to do).
Reviewed-by: John Johansen <john.johansen@canonical.com>
ACKed-by: John Johansen <john.johansen@canonical.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
Cc: stable@vger.kernel.org
2011-12-05 17:43:34 +04:00
|
|
|
bool our_mnt(struct vfsmount *mnt)
|
|
|
|
{
|
2011-11-25 09:46:35 +04:00
|
|
|
return check_mnt(real_mount(mnt));
|
fix apparmor dereferencing potentially freed dentry, sanitize __d_path() API
__d_path() API is asking for trouble and in case of apparmor d_namespace_path()
getting just that. The root cause is that when __d_path() misses the root
it had been told to look for, it stores the location of the most remote ancestor
in *root. Without grabbing references. Sure, at the moment of call it had
been pinned down by what we have in *path. And if we raced with umount -l, we
could have very well stopped at vfsmount/dentry that got freed as soon as
prepend_path() dropped vfsmount_lock.
It is safe to compare these pointers with pre-existing (and known to be still
alive) vfsmount and dentry, as long as all we are asking is "is it the same
address?". Dereferencing is not safe and apparmor ended up stepping into
that. d_namespace_path() really wants to examine the place where we stopped,
even if it's not connected to our namespace. As the result, it looked
at ->d_sb->s_magic of a dentry that might've been already freed by that point.
All other callers had been careful enough to avoid that, but it's really
a bad interface - it invites that kind of trouble.
The fix is fairly straightforward, even though it's bigger than I'd like:
* prepend_path() root argument becomes const.
* __d_path() is never called with NULL/NULL root. It was a kludge
to start with. Instead, we have an explicit function - d_absolute_root().
Same as __d_path(), except that it doesn't get root passed and stops where
it stops. apparmor and tomoyo are using it.
* __d_path() returns NULL on path outside of root. The main
caller is show_mountinfo() and that's precisely what we pass root for - to
skip those outside chroot jail. Those who don't want that can (and do)
use d_path().
* __d_path() root argument becomes const. Everyone agrees, I hope.
* apparmor does *NOT* try to use __d_path() or any of its variants
when it sees that path->mnt is an internal vfsmount. In that case it's
definitely not mounted anywhere and dentry_path() is exactly what we want
there. Handling of sysctl()-triggered weirdness is moved to that place.
* if apparmor is asked to do pathname relative to chroot jail
and __d_path() tells it we it's not in that jail, the sucker just calls
d_absolute_path() instead. That's the other remaining caller of __d_path(),
BTW.
* seq_path_root() does _NOT_ return -ENAMETOOLONG (it's stupid anyway -
the normal seq_file logics will take care of growing the buffer and redoing
the call of ->show() just fine). However, if it gets path not reachable
from root, it returns SEQ_SKIP. The only caller adjusted (i.e. stopped
ignoring the return value as it used to do).
Reviewed-by: John Johansen <john.johansen@canonical.com>
ACKed-by: John Johansen <john.johansen@canonical.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
Cc: stable@vger.kernel.org
2011-12-05 17:43:34 +04:00
|
|
|
}
|
2010-03-08 05:49:36 +03:00
|
|
|
|
2013-03-15 12:45:51 +04:00
|
|
|
bool current_chrooted(void)
|
|
|
|
{
|
|
|
|
/* Does the current process have a non-standard root */
|
|
|
|
struct path ns_root;
|
|
|
|
struct path fs_root;
|
|
|
|
bool chrooted;
|
|
|
|
|
|
|
|
/* Find the namespace root */
|
|
|
|
ns_root.mnt = ¤t->nsproxy->mnt_ns->root->mnt;
|
|
|
|
ns_root.dentry = ns_root.mnt->mnt_root;
|
|
|
|
path_get(&ns_root);
|
|
|
|
while (d_mountpoint(ns_root.dentry) && follow_down_one(&ns_root))
|
|
|
|
;
|
|
|
|
|
|
|
|
get_fs_root(current->fs, &fs_root);
|
|
|
|
|
|
|
|
chrooted = !path_equal(&fs_root, &ns_root);
|
|
|
|
|
|
|
|
path_put(&fs_root);
|
|
|
|
path_put(&ns_root);
|
|
|
|
|
|
|
|
return chrooted;
|
|
|
|
}
|
|
|
|
|
2018-11-04 15:43:08 +03:00
|
|
|
static bool mnt_already_visible(struct mnt_namespace *ns,
|
|
|
|
const struct super_block *sb,
|
2016-06-10 00:06:06 +03:00
|
|
|
int *new_mnt_flags)
|
2013-03-25 01:28:27 +04:00
|
|
|
{
|
2015-05-09 07:49:47 +03:00
|
|
|
int new_flags = *new_mnt_flags;
|
2013-03-25 01:28:27 +04:00
|
|
|
struct mount *mnt;
|
2013-03-31 06:57:41 +04:00
|
|
|
bool visible = false;
|
2013-03-25 01:28:27 +04:00
|
|
|
|
2013-09-17 05:37:36 +04:00
|
|
|
down_read(&namespace_sem);
|
2020-05-14 17:44:24 +03:00
|
|
|
lock_ns_list(ns);
|
2013-03-25 01:28:27 +04:00
|
|
|
list_for_each_entry(mnt, &ns->list, mnt_list) {
|
2013-03-31 06:57:41 +04:00
|
|
|
struct mount *child;
|
2015-06-04 17:43:11 +03:00
|
|
|
int mnt_flags;
|
|
|
|
|
2020-05-14 17:44:24 +03:00
|
|
|
if (mnt_is_cursor(mnt))
|
|
|
|
continue;
|
|
|
|
|
2018-11-04 15:43:08 +03:00
|
|
|
if (mnt->mnt.mnt_sb->s_type != sb->s_type)
|
2013-03-31 06:57:41 +04:00
|
|
|
continue;
|
|
|
|
|
2015-05-09 00:36:50 +03:00
|
|
|
/* This mount is not fully visible if it's root directory
|
|
|
|
* is not the root directory of the filesystem.
|
|
|
|
*/
|
|
|
|
if (mnt->mnt.mnt_root != mnt->mnt.mnt_sb->s_root)
|
|
|
|
continue;
|
|
|
|
|
2016-06-15 14:59:49 +03:00
|
|
|
/* A local view of the mount flags */
|
2015-06-04 17:43:11 +03:00
|
|
|
mnt_flags = mnt->mnt.mnt_flags;
|
|
|
|
|
2016-06-10 20:21:40 +03:00
|
|
|
/* Don't miss readonly hidden in the superblock flags */
|
2017-07-17 10:45:34 +03:00
|
|
|
if (sb_rdonly(mnt->mnt.mnt_sb))
|
2016-06-10 20:21:40 +03:00
|
|
|
mnt_flags |= MNT_LOCK_READONLY;
|
|
|
|
|
2015-05-09 07:49:47 +03:00
|
|
|
/* Verify the mount flags are equal to or more permissive
|
|
|
|
* than the proposed new mount.
|
|
|
|
*/
|
2015-06-04 17:43:11 +03:00
|
|
|
if ((mnt_flags & MNT_LOCK_READONLY) &&
|
2015-05-09 07:49:47 +03:00
|
|
|
!(new_flags & MNT_READONLY))
|
|
|
|
continue;
|
2015-06-04 17:43:11 +03:00
|
|
|
if ((mnt_flags & MNT_LOCK_ATIME) &&
|
|
|
|
((mnt_flags & MNT_ATIME_MASK) != (new_flags & MNT_ATIME_MASK)))
|
2015-05-09 07:49:47 +03:00
|
|
|
continue;
|
|
|
|
|
2015-01-07 17:10:09 +03:00
|
|
|
/* This mount is not fully visible if there are any
|
|
|
|
* locked child mounts that cover anything except for
|
|
|
|
* empty directories.
|
2013-03-31 06:57:41 +04:00
|
|
|
*/
|
|
|
|
list_for_each_entry(child, &mnt->mnt_mounts, mnt_child) {
|
|
|
|
struct inode *inode = child->mnt_mountpoint->d_inode;
|
2015-01-07 17:10:09 +03:00
|
|
|
/* Only worry about locked mounts */
|
2016-05-27 22:50:05 +03:00
|
|
|
if (!(child->mnt.mnt_flags & MNT_LOCKED))
|
2015-01-07 17:10:09 +03:00
|
|
|
continue;
|
2015-05-14 04:51:09 +03:00
|
|
|
/* Is the directory permanetly empty? */
|
|
|
|
if (!is_empty_dir_inode(inode))
|
2013-03-31 06:57:41 +04:00
|
|
|
goto next;
|
2013-03-25 01:28:27 +04:00
|
|
|
}
|
2015-05-09 07:49:47 +03:00
|
|
|
/* Preserve the locked attributes */
|
2015-06-04 17:43:11 +03:00
|
|
|
*new_mnt_flags |= mnt_flags & (MNT_LOCK_READONLY | \
|
|
|
|
MNT_LOCK_ATIME);
|
2013-03-31 06:57:41 +04:00
|
|
|
visible = true;
|
|
|
|
goto found;
|
|
|
|
next: ;
|
2013-03-25 01:28:27 +04:00
|
|
|
}
|
2013-03-31 06:57:41 +04:00
|
|
|
found:
|
2020-05-14 17:44:24 +03:00
|
|
|
unlock_ns_list(ns);
|
2013-09-17 05:37:36 +04:00
|
|
|
up_read(&namespace_sem);
|
2013-03-31 06:57:41 +04:00
|
|
|
return visible;
|
2013-03-25 01:28:27 +04:00
|
|
|
}
|
|
|
|
|
2018-11-04 15:43:08 +03:00
|
|
|
static bool mount_too_revealing(const struct super_block *sb, int *new_mnt_flags)
|
2016-06-10 00:06:06 +03:00
|
|
|
{
|
2016-06-15 14:59:49 +03:00
|
|
|
const unsigned long required_iflags = SB_I_NOEXEC | SB_I_NODEV;
|
2016-06-10 00:06:06 +03:00
|
|
|
struct mnt_namespace *ns = current->nsproxy->mnt_ns;
|
|
|
|
unsigned long s_iflags;
|
|
|
|
|
|
|
|
if (ns->user_ns == &init_user_ns)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/* Can this filesystem be too revealing? */
|
2018-11-04 15:43:08 +03:00
|
|
|
s_iflags = sb->s_iflags;
|
2016-06-10 00:06:06 +03:00
|
|
|
if (!(s_iflags & SB_I_USERNS_VISIBLE))
|
|
|
|
return false;
|
|
|
|
|
2016-06-15 14:59:49 +03:00
|
|
|
if ((s_iflags & required_iflags) != required_iflags) {
|
|
|
|
WARN_ONCE(1, "Expected s_iflags to contain 0x%lx\n",
|
|
|
|
required_iflags);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2018-11-04 15:43:08 +03:00
|
|
|
return !mnt_already_visible(ns, sb, new_mnt_flags);
|
2016-06-10 00:06:06 +03:00
|
|
|
}
|
|
|
|
|
fs: Treat foreign mounts as nosuid
If a process gets access to a mount from a different user
namespace, that process should not be able to take advantage of
setuid files or selinux entrypoints from that filesystem. Prevent
this by treating mounts from other mount namespaces and those not
owned by current_user_ns() or an ancestor as nosuid.
This will make it safer to allow more complex filesystems to be
mounted in non-root user namespaces.
This does not remove the need for MNT_LOCK_NOSUID. The setuid,
setgid, and file capability bits can no longer be abused if code in
a user namespace were to clear nosuid on an untrusted filesystem,
but this patch, by itself, is insufficient to protect the system
from abuse of files that, when execed, would increase MAC privilege.
As a more concrete explanation, any task that can manipulate a
vfsmount associated with a given user namespace already has
capabilities in that namespace and all of its descendents. If they
can cause a malicious setuid, setgid, or file-caps executable to
appear in that mount, then that executable will only allow them to
elevate privileges in exactly the set of namespaces in which they
are already privileges.
On the other hand, if they can cause a malicious executable to
appear with a dangerous MAC label, running it could change the
caller's security context in a way that should not have been
possible, even inside the namespace in which the task is confined.
As a hardening measure, this would have made CVE-2014-5207 much
more difficult to exploit.
Signed-off-by: Andy Lutomirski <luto@amacapital.net>
Signed-off-by: Seth Forshee <seth.forshee@canonical.com>
Acked-by: James Morris <james.l.morris@oracle.com>
Acked-by: Serge Hallyn <serge.hallyn@canonical.com>
Signed-off-by: Eric W. Biederman <ebiederm@xmission.com>
2016-06-24 00:41:05 +03:00
|
|
|
bool mnt_may_suid(struct vfsmount *mnt)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Foreign mounts (accessed via fchdir or through /proc
|
|
|
|
* symlinks) are always treated as if they are nosuid. This
|
|
|
|
* prevents namespaces from trusting potentially unsafe
|
|
|
|
* suid/sgid bits, file caps, or security labels that originate
|
|
|
|
* in other namespaces.
|
|
|
|
*/
|
|
|
|
return !(mnt->mnt_flags & MNT_NOSUID) && check_mnt(real_mount(mnt)) &&
|
|
|
|
current_in_userns(mnt->mnt_sb->s_user_ns);
|
|
|
|
}
|
|
|
|
|
2014-11-01 07:37:32 +03:00
|
|
|
static struct ns_common *mntns_get(struct task_struct *task)
|
2010-03-08 05:49:36 +03:00
|
|
|
{
|
2014-11-01 07:00:23 +03:00
|
|
|
struct ns_common *ns = NULL;
|
2010-03-08 05:49:36 +03:00
|
|
|
struct nsproxy *nsproxy;
|
|
|
|
|
2014-02-04 07:13:49 +04:00
|
|
|
task_lock(task);
|
|
|
|
nsproxy = task->nsproxy;
|
2010-03-08 05:49:36 +03:00
|
|
|
if (nsproxy) {
|
2014-11-01 07:00:23 +03:00
|
|
|
ns = &nsproxy->mnt_ns->ns;
|
|
|
|
get_mnt_ns(to_mnt_ns(ns));
|
2010-03-08 05:49:36 +03:00
|
|
|
}
|
2014-02-04 07:13:49 +04:00
|
|
|
task_unlock(task);
|
2010-03-08 05:49:36 +03:00
|
|
|
|
|
|
|
return ns;
|
|
|
|
}
|
|
|
|
|
2014-11-01 07:37:32 +03:00
|
|
|
static void mntns_put(struct ns_common *ns)
|
2010-03-08 05:49:36 +03:00
|
|
|
{
|
2014-11-01 07:00:23 +03:00
|
|
|
put_mnt_ns(to_mnt_ns(ns));
|
2010-03-08 05:49:36 +03:00
|
|
|
}
|
|
|
|
|
2020-05-05 17:04:30 +03:00
|
|
|
static int mntns_install(struct nsset *nsset, struct ns_common *ns)
|
2010-03-08 05:49:36 +03:00
|
|
|
{
|
2020-05-05 17:04:30 +03:00
|
|
|
struct nsproxy *nsproxy = nsset->nsproxy;
|
|
|
|
struct fs_struct *fs = nsset->fs;
|
2017-04-16 00:31:22 +03:00
|
|
|
struct mnt_namespace *mnt_ns = to_mnt_ns(ns), *old_mnt_ns;
|
2020-05-05 17:04:30 +03:00
|
|
|
struct user_namespace *user_ns = nsset->cred->user_ns;
|
2010-03-08 05:49:36 +03:00
|
|
|
struct path root;
|
2017-04-16 00:31:22 +03:00
|
|
|
int err;
|
2010-03-08 05:49:36 +03:00
|
|
|
|
2012-07-27 08:42:03 +04:00
|
|
|
if (!ns_capable(mnt_ns->user_ns, CAP_SYS_ADMIN) ||
|
2020-05-05 17:04:30 +03:00
|
|
|
!ns_capable(user_ns, CAP_SYS_CHROOT) ||
|
|
|
|
!ns_capable(user_ns, CAP_SYS_ADMIN))
|
2012-09-13 12:38:03 +04:00
|
|
|
return -EPERM;
|
2010-03-08 05:49:36 +03:00
|
|
|
|
2019-01-30 21:30:21 +03:00
|
|
|
if (is_anon_ns(mnt_ns))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2010-03-08 05:49:36 +03:00
|
|
|
if (fs->users != 1)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
get_mnt_ns(mnt_ns);
|
2017-04-16 00:31:22 +03:00
|
|
|
old_mnt_ns = nsproxy->mnt_ns;
|
2010-03-08 05:49:36 +03:00
|
|
|
nsproxy->mnt_ns = mnt_ns;
|
|
|
|
|
|
|
|
/* Find the root */
|
2017-04-16 00:31:22 +03:00
|
|
|
err = vfs_path_lookup(mnt_ns->root->mnt.mnt_root, &mnt_ns->root->mnt,
|
|
|
|
"/", LOOKUP_DOWN, &root);
|
|
|
|
if (err) {
|
|
|
|
/* revert to old namespace */
|
|
|
|
nsproxy->mnt_ns = old_mnt_ns;
|
|
|
|
put_mnt_ns(mnt_ns);
|
|
|
|
return err;
|
|
|
|
}
|
2010-03-08 05:49:36 +03:00
|
|
|
|
2017-06-09 03:32:29 +03:00
|
|
|
put_mnt_ns(old_mnt_ns);
|
|
|
|
|
2010-03-08 05:49:36 +03:00
|
|
|
/* Update the pwd and root */
|
|
|
|
set_fs_pwd(fs, &root);
|
|
|
|
set_fs_root(fs, &root);
|
|
|
|
|
|
|
|
path_put(&root);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-09-06 10:47:13 +03:00
|
|
|
static struct user_namespace *mntns_owner(struct ns_common *ns)
|
|
|
|
{
|
|
|
|
return to_mnt_ns(ns)->user_ns;
|
|
|
|
}
|
|
|
|
|
2010-03-08 05:49:36 +03:00
|
|
|
const struct proc_ns_operations mntns_operations = {
|
|
|
|
.name = "mnt",
|
|
|
|
.type = CLONE_NEWNS,
|
|
|
|
.get = mntns_get,
|
|
|
|
.put = mntns_put,
|
|
|
|
.install = mntns_install,
|
2016-09-06 10:47:13 +03:00
|
|
|
.owner = mntns_owner,
|
2010-03-08 05:49:36 +03:00
|
|
|
};
|
2022-01-22 09:13:27 +03:00
|
|
|
|
|
|
|
#ifdef CONFIG_SYSCTL
|
|
|
|
static struct ctl_table fs_namespace_sysctls[] = {
|
|
|
|
{
|
|
|
|
.procname = "mount-max",
|
|
|
|
.data = &sysctl_mount_max,
|
|
|
|
.maxlen = sizeof(unsigned int),
|
|
|
|
.mode = 0644,
|
|
|
|
.proc_handler = proc_dointvec_minmax,
|
|
|
|
.extra1 = SYSCTL_ONE,
|
|
|
|
},
|
|
|
|
{ }
|
|
|
|
};
|
|
|
|
|
|
|
|
static int __init init_fs_namespace_sysctls(void)
|
|
|
|
{
|
|
|
|
register_sysctl_init("fs", fs_namespace_sysctls);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
fs_initcall(init_fs_namespace_sysctls);
|
|
|
|
|
|
|
|
#endif /* CONFIG_SYSCTL */
|