2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
|
*
|
|
|
|
|
* Definitions for mount interface. This describes the in the kernel build
|
|
|
|
|
* linkedlist with mounted filesystems.
|
|
|
|
|
*
|
|
|
|
|
* Author: Marco van Wieringen <mvw@planets.elm.net>
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
#ifndef _LINUX_MOUNT_H
|
|
|
|
|
#define _LINUX_MOUNT_H
|
|
|
|
|
|
2005-07-13 04:58:07 +08:00
|
|
|
#include <linux/types.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/list.h>
|
[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 06:37:59 +08:00
|
|
|
#include <linux/nodemask.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/spinlock.h>
|
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 14:50:11 +08:00
|
|
|
#include <linux/seqlock.h>
|
2011-07-27 07:09:06 +08:00
|
|
|
#include <linux/atomic.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-06-23 17:02:58 +08:00
|
|
|
struct super_block;
|
|
|
|
|
struct vfsmount;
|
|
|
|
|
struct dentry;
|
2006-12-08 18:37:56 +08:00
|
|
|
struct mnt_namespace;
|
2006-06-23 17:02:58 +08:00
|
|
|
|
2005-11-08 06:19:07 +08:00
|
|
|
#define MNT_NOSUID 0x01
|
|
|
|
|
#define MNT_NODEV 0x02
|
|
|
|
|
#define MNT_NOEXEC 0x04
|
2006-01-10 12:52:17 +08:00
|
|
|
#define MNT_NOATIME 0x08
|
|
|
|
|
#define MNT_NODIRATIME 0x10
|
2006-12-13 16:34:34 +08:00
|
|
|
#define MNT_RELATIME 0x20
|
2008-02-16 06:38:00 +08:00
|
|
|
#define MNT_READONLY 0x40 /* does the user want this to be r/o? */
|
2006-01-08 17:03:19 +08:00
|
|
|
|
2006-06-09 21:34:17 +08:00
|
|
|
#define MNT_SHRINKABLE 0x100
|
2009-04-26 18:25:54 +08:00
|
|
|
#define MNT_WRITE_HOLD 0x200
|
2006-06-09 21:34:17 +08:00
|
|
|
|
2006-01-10 12:52:17 +08:00
|
|
|
#define MNT_SHARED 0x1000 /* if the vfsmount is a shared mount */
|
|
|
|
|
#define MNT_UNBINDABLE 0x2000 /* if the vfsmount is a unbindable mount */
|
2010-01-27 03:20:47 +08:00
|
|
|
/*
|
|
|
|
|
* MNT_SHARED_MASK is the set of flags that should be cleared when a
|
|
|
|
|
* mount becomes shared. Currently, this is only the flag that says a
|
|
|
|
|
* mount cannot be bind mounted, since this is how we create a mount
|
|
|
|
|
* that shares events with another mount. If you add a new MNT_*
|
|
|
|
|
* flag, consider how it interacts with shared mounts.
|
|
|
|
|
*/
|
|
|
|
|
#define MNT_SHARED_MASK (MNT_UNBINDABLE)
|
2014-07-29 07:26:53 +08:00
|
|
|
#define MNT_USER_SETTABLE_MASK (MNT_NOSUID | MNT_NODEV | MNT_NOEXEC \
|
|
|
|
|
| MNT_NOATIME | MNT_NODIRATIME | MNT_RELATIME \
|
|
|
|
|
| MNT_READONLY)
|
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 08:26:07 +08:00
|
|
|
#define MNT_ATIME_MASK (MNT_NOATIME | MNT_NODIRATIME | MNT_RELATIME )
|
2010-01-27 03:20:47 +08: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 22:35:45 +08:00
|
|
|
#define MNT_INTERNAL_FLAGS (MNT_SHARED | MNT_WRITE_HOLD | MNT_INTERNAL | \
|
|
|
|
|
MNT_DOOMED | MNT_SYNC_UMOUNT | MNT_MARKED)
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2010-02-05 22:30:46 +08:00
|
|
|
#define MNT_INTERNAL 0x4000
|
2005-04-17 06:20:36 +08:00
|
|
|
|
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 08:26:07 +08:00
|
|
|
#define MNT_LOCK_ATIME 0x040000
|
|
|
|
|
#define MNT_LOCK_NOEXEC 0x080000
|
|
|
|
|
#define MNT_LOCK_NOSUID 0x100000
|
|
|
|
|
#define MNT_LOCK_NODEV 0x200000
|
2013-03-22 18:10:15 +08:00
|
|
|
#define MNT_LOCK_READONLY 0x400000
|
2013-03-30 12:04:39 +08:00
|
|
|
#define MNT_LOCKED 0x800000
|
2013-09-30 10:06:07 +08:00
|
|
|
#define MNT_DOOMED 0x1000000
|
|
|
|
|
#define MNT_SYNC_UMOUNT 0x2000000
|
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 22:35:45 +08:00
|
|
|
#define MNT_MARKED 0x4000000
|
2014-12-23 08:30:08 +08:00
|
|
|
#define MNT_UMOUNT 0x8000000
|
2013-03-22 18:10:15 +08:00
|
|
|
|
2005-11-08 06:19:07 +08:00
|
|
|
struct vfsmount {
|
2005-04-17 06:20:36 +08:00
|
|
|
struct dentry *mnt_root; /* root of the mounted tree */
|
|
|
|
|
struct super_block *mnt_sb; /* pointer to superblock */
|
|
|
|
|
int mnt_flags;
|
|
|
|
|
};
|
|
|
|
|
|
2009-04-26 18:25:55 +08:00
|
|
|
struct file; /* forward dec */
|
2014-08-07 21:12:31 +08:00
|
|
|
struct path;
|
2009-04-26 18:25:55 +08:00
|
|
|
|
2008-02-16 06:37:30 +08:00
|
|
|
extern int mnt_want_write(struct vfsmount *mnt);
|
2009-04-26 18:25:55 +08:00
|
|
|
extern int mnt_want_write_file(struct file *file);
|
|
|
|
|
extern int mnt_clone_write(struct vfsmount *mnt);
|
2008-02-16 06:37:30 +08:00
|
|
|
extern void mnt_drop_write(struct vfsmount *mnt);
|
2011-12-09 21:06:57 +08:00
|
|
|
extern void mnt_drop_write_file(struct file *file);
|
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 14:50:11 +08:00
|
|
|
extern void mntput(struct vfsmount *mnt);
|
|
|
|
|
extern struct vfsmount *mntget(struct vfsmount *mnt);
|
2014-08-07 21:12:31 +08:00
|
|
|
extern struct vfsmount *mnt_clone_internal(struct path *path);
|
2008-02-16 06:37:30 +08:00
|
|
|
extern int __mnt_is_readonly(struct vfsmount *mnt);
|
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 05:41:05 +08:00
|
|
|
extern bool mnt_may_suid(struct vfsmount *mnt);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2014-10-24 06:14:36 +08:00
|
|
|
struct path;
|
|
|
|
|
extern struct vfsmount *clone_private_mount(struct path *path);
|
|
|
|
|
|
2006-06-09 21:34:15 +08:00
|
|
|
struct file_system_type;
|
|
|
|
|
extern struct vfsmount *vfs_kern_mount(struct file_system_type *type,
|
|
|
|
|
int flags, const char *name,
|
|
|
|
|
void *data);
|
|
|
|
|
|
2011-01-15 03:10:03 +08:00
|
|
|
extern void mnt_set_expiry(struct vfsmount *mnt, struct list_head *expiry_list);
|
2005-04-17 06:20:36 +08:00
|
|
|
extern void mark_mounts_for_expiry(struct list_head *mounts);
|
|
|
|
|
|
2015-02-11 07:20:49 +08:00
|
|
|
extern dev_t name_to_dev_t(const char *name);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
#endif /* _LINUX_MOUNT_H */
|