2005-04-17 05:20:36 +07: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 03:58:07 +07:00
|
|
|
#include <linux/types.h>
|
2005-04-17 05:20:36 +07: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 05:37:59 +07:00
|
|
|
#include <linux/nodemask.h>
|
2005-04-17 05:20:36 +07: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 13:50:11 +07:00
|
|
|
#include <linux/seqlock.h>
|
2011-07-27 06:09:06 +07:00
|
|
|
#include <linux/atomic.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-06-23 16:02:58 +07:00
|
|
|
struct super_block;
|
|
|
|
|
struct vfsmount;
|
|
|
|
|
struct dentry;
|
2006-12-08 17:37:56 +07:00
|
|
|
struct mnt_namespace;
|
2006-06-23 16:02:58 +07:00
|
|
|
|
2005-11-08 05:19:07 +07:00
|
|
|
#define MNT_NOSUID 0x01
|
|
|
|
|
#define MNT_NODEV 0x02
|
|
|
|
|
#define MNT_NOEXEC 0x04
|
2006-01-10 11:52:17 +07:00
|
|
|
#define MNT_NOATIME 0x08
|
|
|
|
|
#define MNT_NODIRATIME 0x10
|
2006-12-13 15:34:34 +07:00
|
|
|
#define MNT_RELATIME 0x20
|
2008-02-16 05:38:00 +07:00
|
|
|
#define MNT_READONLY 0x40 /* does the user want this to be r/o? */
|
2006-01-08 16:03:19 +07:00
|
|
|
|
2006-06-09 20:34:17 +07:00
|
|
|
#define MNT_SHRINKABLE 0x100
|
2009-04-26 17:25:54 +07:00
|
|
|
#define MNT_WRITE_HOLD 0x200
|
2006-06-09 20:34:17 +07:00
|
|
|
|
2006-01-10 11:52:17 +07: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 02:20:47 +07: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)
|
|
|
|
|
#define MNT_PROPAGATION_MASK (MNT_SHARED | MNT_UNBINDABLE)
|
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2010-02-05 21:30:46 +07:00
|
|
|
#define MNT_INTERNAL 0x4000
|
2005-04-17 05:20:36 +07: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 13:50:11 +07:00
|
|
|
struct mnt_pcp {
|
|
|
|
|
int mnt_count;
|
|
|
|
|
int mnt_writers;
|
|
|
|
|
};
|
|
|
|
|
|
2005-11-08 05:19:07 +07:00
|
|
|
struct vfsmount {
|
2005-04-17 05:20:36 +07:00
|
|
|
struct list_head mnt_hash;
|
|
|
|
|
struct vfsmount *mnt_parent; /* fs we are mounted on */
|
|
|
|
|
struct dentry *mnt_mountpoint; /* dentry of mountpoint */
|
|
|
|
|
struct dentry *mnt_root; /* root of the mounted tree */
|
|
|
|
|
struct super_block *mnt_sb; /* pointer to superblock */
|
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 13:50:11 +07:00
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
|
struct mnt_pcp __percpu *mnt_pcp;
|
2011-01-15 10:30:21 +07:00
|
|
|
atomic_t mnt_longterm; /* how many of the refs are longterm */
|
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 13:50:11 +07:00
|
|
|
#else
|
|
|
|
|
int mnt_count;
|
|
|
|
|
int mnt_writers;
|
|
|
|
|
#endif
|
2005-04-17 05:20:36 +07:00
|
|
|
struct list_head mnt_mounts; /* list of children, anchored here */
|
|
|
|
|
struct list_head mnt_child; /* and going through their mnt_child */
|
|
|
|
|
int mnt_flags;
|
2009-12-18 09:24:27 +07:00
|
|
|
/* 4 bytes hole on 64bits arches without fsnotify */
|
|
|
|
|
#ifdef CONFIG_FSNOTIFY
|
|
|
|
|
__u32 mnt_fsnotify_mask;
|
|
|
|
|
struct hlist_head mnt_fsnotify_marks;
|
|
|
|
|
#endif
|
2008-07-21 17:06:36 +07:00
|
|
|
const char *mnt_devname; /* Name of device e.g. /dev/dsk/hda1 */
|
2005-04-17 05:20:36 +07:00
|
|
|
struct list_head mnt_list;
|
2005-07-08 07:57:30 +07:00
|
|
|
struct list_head mnt_expire; /* link in fs-specific expiry list */
|
2005-11-08 05:19:33 +07:00
|
|
|
struct list_head mnt_share; /* circular list of shared mounts */
|
2005-11-08 05:20:48 +07:00
|
|
|
struct list_head mnt_slave_list;/* list of slave mounts */
|
|
|
|
|
struct list_head mnt_slave; /* slave list entry */
|
|
|
|
|
struct vfsmount *mnt_master; /* slave is on master->mnt_slave_list */
|
2006-12-08 17:37:56 +07:00
|
|
|
struct mnt_namespace *mnt_ns; /* containing namespace */
|
2008-03-27 04:11:34 +07:00
|
|
|
int mnt_id; /* mount identifier */
|
2008-03-27 19:06:23 +07:00
|
|
|
int mnt_group_id; /* peer group identifier */
|
2007-02-10 16:44:48 +07:00
|
|
|
int mnt_expiry_mark; /* true if marked for expiry */
|
2005-11-08 05:13:39 +07:00
|
|
|
int mnt_pinned;
|
2008-03-22 10:59:49 +07:00
|
|
|
int mnt_ghosts;
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
|
|
|
|
|
2009-04-26 17:25:55 +07:00
|
|
|
struct file; /* forward dec */
|
|
|
|
|
|
2008-02-16 05:37:30 +07:00
|
|
|
extern int mnt_want_write(struct vfsmount *mnt);
|
2009-04-26 17:25:55 +07:00
|
|
|
extern int mnt_want_write_file(struct file *file);
|
|
|
|
|
extern int mnt_clone_write(struct vfsmount *mnt);
|
2008-02-16 05:37:30 +07:00
|
|
|
extern void mnt_drop_write(struct vfsmount *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 13:50:11 +07:00
|
|
|
extern void mntput(struct vfsmount *mnt);
|
|
|
|
|
extern struct vfsmount *mntget(struct vfsmount *mnt);
|
2005-11-08 05:13:39 +07:00
|
|
|
extern void mnt_pin(struct vfsmount *mnt);
|
|
|
|
|
extern void mnt_unpin(struct vfsmount *mnt);
|
2008-02-16 05:37:30 +07:00
|
|
|
extern int __mnt_is_readonly(struct vfsmount *mnt);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
|
extern struct vfsmount *do_kern_mount(const char *fstype, int flags,
|
|
|
|
|
const char *name, void *data);
|
|
|
|
|
|
2006-06-09 20:34:15 +07: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 02:10:03 +07:00
|
|
|
extern void mnt_set_expiry(struct vfsmount *mnt, struct list_head *expiry_list);
|
2005-04-17 05:20:36 +07:00
|
|
|
extern void mark_mounts_for_expiry(struct list_head *mounts);
|
|
|
|
|
|
2005-07-13 03:58:07 +07:00
|
|
|
extern dev_t name_to_dev_t(char *name);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
|
#endif /* _LINUX_MOUNT_H */
|