2005-11-07 22:19:07 +00:00
|
|
|
/*
|
|
|
|
* linux/fs/pnode.c
|
|
|
|
*
|
|
|
|
* (C) Copyright IBM Corporation 2005.
|
|
|
|
* Released under GPL v2.
|
|
|
|
* Author : Ram Pai (linuxram@us.ibm.com)
|
|
|
|
*
|
|
|
|
*/
|
2006-12-08 10:37:56 +00:00
|
|
|
#include <linux/mnt_namespace.h>
|
2005-11-07 22:19:07 +00:00
|
|
|
#include <linux/mount.h>
|
|
|
|
#include <linux/fs.h>
|
2008-03-22 19:48:17 +00:00
|
|
|
#include "internal.h"
|
2005-11-07 22:19:07 +00:00
|
|
|
#include "pnode.h"
|
|
|
|
|
2005-11-07 22:19:33 +00:00
|
|
|
/* return the next shared peer mount of @p */
|
2011-11-25 04:56:26 +00:00
|
|
|
static inline struct mount *next_peer(struct mount *p)
|
2005-11-07 22:19:33 +00:00
|
|
|
{
|
2011-11-25 05:22:05 +00:00
|
|
|
return list_entry(p->mnt_share.next, struct mount, mnt_share);
|
2005-11-07 22:19:33 +00:00
|
|
|
}
|
|
|
|
|
2011-11-25 04:56:26 +00:00
|
|
|
static inline struct mount *first_slave(struct mount *p)
|
2005-11-07 22:21:01 +00:00
|
|
|
{
|
2011-11-25 05:22:05 +00:00
|
|
|
return list_entry(p->mnt_slave_list.next, struct mount, mnt_slave);
|
2005-11-07 22:21:01 +00:00
|
|
|
}
|
|
|
|
|
2011-11-25 04:56:26 +00:00
|
|
|
static inline struct mount *next_slave(struct mount *p)
|
2005-11-07 22:21:01 +00:00
|
|
|
{
|
2011-11-25 05:22:05 +00:00
|
|
|
return list_entry(p->mnt_slave.next, struct mount, mnt_slave);
|
2005-11-07 22:21:01 +00:00
|
|
|
}
|
|
|
|
|
2011-11-25 04:35:54 +00:00
|
|
|
static struct mount *get_peer_under_root(struct mount *mnt,
|
|
|
|
struct mnt_namespace *ns,
|
|
|
|
const struct path *root)
|
2008-03-27 12:06:26 +00:00
|
|
|
{
|
2011-11-25 04:35:54 +00:00
|
|
|
struct mount *m = mnt;
|
2008-03-27 12:06:26 +00:00
|
|
|
|
|
|
|
do {
|
|
|
|
/* Check the namespace first for optimization */
|
2011-11-25 05:46:35 +00:00
|
|
|
if (m->mnt_ns == ns && is_path_reachable(m, m->mnt.mnt_root, root))
|
2011-11-25 04:35:54 +00:00
|
|
|
return m;
|
2008-03-27 12:06:26 +00:00
|
|
|
|
2011-11-25 04:56:26 +00:00
|
|
|
m = next_peer(m);
|
2011-11-25 04:35:54 +00:00
|
|
|
} while (m != mnt);
|
2008-03-27 12:06:26 +00:00
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get ID of closest dominating peer group having a representative
|
|
|
|
* under the given root.
|
|
|
|
*
|
|
|
|
* Caller must hold namespace_sem
|
|
|
|
*/
|
2011-11-25 04:35:54 +00:00
|
|
|
int get_dominating_id(struct mount *mnt, const struct path *root)
|
2008-03-27 12:06:26 +00:00
|
|
|
{
|
2011-11-25 04:35:54 +00:00
|
|
|
struct mount *m;
|
2008-03-27 12:06:26 +00:00
|
|
|
|
2011-11-25 05:10:28 +00:00
|
|
|
for (m = mnt->mnt_master; m != NULL; m = m->mnt_master) {
|
2011-11-25 05:46:35 +00:00
|
|
|
struct mount *d = get_peer_under_root(m, mnt->mnt_ns, root);
|
2008-03-27 12:06:26 +00:00
|
|
|
if (d)
|
2011-11-25 05:50:41 +00:00
|
|
|
return d->mnt_group_id;
|
2008-03-27 12:06:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-11-25 04:35:54 +00:00
|
|
|
static int do_make_slave(struct mount *mnt)
|
2005-11-07 22:20:48 +00:00
|
|
|
{
|
2011-11-25 05:10:28 +00:00
|
|
|
struct mount *peer_mnt = mnt, *master = mnt->mnt_master;
|
2011-11-25 05:07:16 +00:00
|
|
|
struct mount *slave_mnt;
|
2005-11-07 22:20:48 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* slave 'mnt' to a peer mount that has the
|
2010-01-16 18:28:47 +00:00
|
|
|
* same root dentry. If none is available then
|
2005-11-07 22:20:48 +00:00
|
|
|
* slave it to anything that is available.
|
|
|
|
*/
|
2011-11-25 04:56:26 +00:00
|
|
|
while ((peer_mnt = next_peer(peer_mnt)) != mnt &&
|
2011-11-25 04:35:54 +00:00
|
|
|
peer_mnt->mnt.mnt_root != mnt->mnt.mnt_root) ;
|
2005-11-07 22:20:48 +00:00
|
|
|
|
|
|
|
if (peer_mnt == mnt) {
|
2011-11-25 04:56:26 +00:00
|
|
|
peer_mnt = next_peer(mnt);
|
2005-11-07 22:20:48 +00:00
|
|
|
if (peer_mnt == mnt)
|
|
|
|
peer_mnt = NULL;
|
|
|
|
}
|
2011-11-25 06:05:37 +00:00
|
|
|
if (IS_MNT_SHARED(mnt) && list_empty(&mnt->mnt_share))
|
2011-11-25 04:35:54 +00:00
|
|
|
mnt_release_group_id(mnt);
|
2008-03-27 12:06:23 +00:00
|
|
|
|
2011-11-25 05:22:05 +00:00
|
|
|
list_del_init(&mnt->mnt_share);
|
2011-11-25 05:50:41 +00:00
|
|
|
mnt->mnt_group_id = 0;
|
2005-11-07 22:20:48 +00:00
|
|
|
|
|
|
|
if (peer_mnt)
|
|
|
|
master = peer_mnt;
|
|
|
|
|
|
|
|
if (master) {
|
2011-11-25 05:22:05 +00:00
|
|
|
list_for_each_entry(slave_mnt, &mnt->mnt_slave_list, mnt_slave)
|
2011-11-25 05:10:28 +00:00
|
|
|
slave_mnt->mnt_master = master;
|
2011-11-25 05:22:05 +00:00
|
|
|
list_move(&mnt->mnt_slave, &master->mnt_slave_list);
|
|
|
|
list_splice(&mnt->mnt_slave_list, master->mnt_slave_list.prev);
|
|
|
|
INIT_LIST_HEAD(&mnt->mnt_slave_list);
|
2005-11-07 22:20:48 +00:00
|
|
|
} else {
|
2011-11-25 05:22:05 +00:00
|
|
|
struct list_head *p = &mnt->mnt_slave_list;
|
2005-11-07 22:20:48 +00:00
|
|
|
while (!list_empty(p)) {
|
Introduce a handy list_first_entry macro
There are many places in the kernel where the construction like
foo = list_entry(head->next, struct foo_struct, list);
are used.
The code might look more descriptive and neat if using the macro
list_first_entry(head, type, member) \
list_entry((head)->next, type, member)
Here is the macro itself and the examples of its usage in the generic code.
If it will turn out to be useful, I can prepare the set of patches to
inject in into arch-specific code, drivers, networking, etc.
Signed-off-by: Pavel Emelianov <xemul@openvz.org>
Signed-off-by: Kirill Korotaev <dev@openvz.org>
Cc: Randy Dunlap <randy.dunlap@oracle.com>
Cc: Andi Kleen <andi@firstfloor.org>
Cc: Zach Brown <zach.brown@oracle.com>
Cc: Davide Libenzi <davidel@xmailserver.org>
Cc: John McCutchan <ttb@tentacle.dhs.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: john stultz <johnstul@us.ibm.com>
Cc: Ram Pai <linuxram@us.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-05-08 07:30:19 +00:00
|
|
|
slave_mnt = list_first_entry(p,
|
2011-11-25 05:22:05 +00:00
|
|
|
struct mount, mnt_slave);
|
|
|
|
list_del_init(&slave_mnt->mnt_slave);
|
2005-11-07 22:20:48 +00:00
|
|
|
slave_mnt->mnt_master = NULL;
|
|
|
|
}
|
|
|
|
}
|
2011-11-25 05:10:28 +00:00
|
|
|
mnt->mnt_master = master;
|
2011-11-25 06:05:37 +00:00
|
|
|
CLEAR_MNT_SHARED(mnt);
|
2005-11-07 22:20:48 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
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 18:37:39 +00:00
|
|
|
/*
|
|
|
|
* vfsmount lock must be held for write
|
|
|
|
*/
|
2011-11-25 01:43:10 +00:00
|
|
|
void change_mnt_propagation(struct mount *mnt, int type)
|
2005-11-07 22:19:07 +00:00
|
|
|
{
|
2005-11-07 22:19:33 +00:00
|
|
|
if (type == MS_SHARED) {
|
2005-11-07 22:19:50 +00:00
|
|
|
set_mnt_shared(mnt);
|
2005-11-07 22:20:48 +00:00
|
|
|
return;
|
|
|
|
}
|
2011-11-25 04:35:54 +00:00
|
|
|
do_make_slave(mnt);
|
2005-11-07 22:20:48 +00:00
|
|
|
if (type != MS_SLAVE) {
|
2011-11-25 05:22:05 +00:00
|
|
|
list_del_init(&mnt->mnt_slave);
|
2011-11-25 05:07:16 +00:00
|
|
|
mnt->mnt_master = NULL;
|
2005-11-07 22:21:20 +00:00
|
|
|
if (type == MS_UNBINDABLE)
|
2011-11-25 01:43:10 +00:00
|
|
|
mnt->mnt.mnt_flags |= MNT_UNBINDABLE;
|
2008-02-06 09:36:32 +00:00
|
|
|
else
|
2011-11-25 01:43:10 +00:00
|
|
|
mnt->mnt.mnt_flags &= ~MNT_UNBINDABLE;
|
2005-11-07 22:19:33 +00:00
|
|
|
}
|
2005-11-07 22:19:07 +00:00
|
|
|
}
|
2005-11-07 22:19:50 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* get the next mount in the propagation tree.
|
|
|
|
* @m: the mount seen last
|
|
|
|
* @origin: the original mount from where the tree walk initiated
|
2010-01-16 18:28:47 +00:00
|
|
|
*
|
|
|
|
* Note that peer groups form contiguous segments of slave lists.
|
|
|
|
* We rely on that in get_source() to be able to find out if
|
|
|
|
* vfsmount found while iterating with propagation_next() is
|
|
|
|
* a peer of one we'd found earlier.
|
2005-11-07 22:19:50 +00:00
|
|
|
*/
|
2011-11-25 04:56:26 +00:00
|
|
|
static struct mount *propagation_next(struct mount *m,
|
|
|
|
struct mount *origin)
|
2005-11-07 22:19:50 +00:00
|
|
|
{
|
2005-11-07 22:21:01 +00:00
|
|
|
/* are there any slaves of this mount? */
|
2011-11-25 05:46:35 +00:00
|
|
|
if (!IS_MNT_NEW(m) && !list_empty(&m->mnt_slave_list))
|
2005-11-07 22:21:01 +00:00
|
|
|
return first_slave(m);
|
|
|
|
|
|
|
|
while (1) {
|
2011-11-25 05:10:28 +00:00
|
|
|
struct mount *master = m->mnt_master;
|
2005-11-07 22:21:01 +00:00
|
|
|
|
2011-11-25 05:10:28 +00:00
|
|
|
if (master == origin->mnt_master) {
|
2011-11-25 04:56:26 +00:00
|
|
|
struct mount *next = next_peer(m);
|
|
|
|
return (next == origin) ? NULL : next;
|
2011-11-25 05:22:05 +00:00
|
|
|
} else if (m->mnt_slave.next != &master->mnt_slave_list)
|
2005-11-07 22:21:01 +00:00
|
|
|
return next_slave(m);
|
|
|
|
|
|
|
|
/* back at master */
|
|
|
|
m = master;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* return the source mount to be used for cloning
|
|
|
|
*
|
|
|
|
* @dest the current destination mount
|
|
|
|
* @last_dest the last seen destination mount
|
|
|
|
* @last_src the last seen source mount
|
|
|
|
* @type return CL_SLAVE if the new mount has to be
|
|
|
|
* cloned as a slave.
|
|
|
|
*/
|
2011-11-25 04:56:26 +00:00
|
|
|
static struct mount *get_source(struct mount *dest,
|
|
|
|
struct mount *last_dest,
|
|
|
|
struct mount *last_src,
|
|
|
|
int *type)
|
2005-11-07 22:21:01 +00:00
|
|
|
{
|
2011-11-25 04:56:26 +00:00
|
|
|
struct mount *p_last_src = NULL;
|
|
|
|
struct mount *p_last_dest = NULL;
|
2005-11-07 22:21:01 +00:00
|
|
|
|
2011-11-25 05:10:28 +00:00
|
|
|
while (last_dest != dest->mnt_master) {
|
2005-11-07 22:21:01 +00:00
|
|
|
p_last_dest = last_dest;
|
|
|
|
p_last_src = last_src;
|
2011-11-25 05:10:28 +00:00
|
|
|
last_dest = last_dest->mnt_master;
|
|
|
|
last_src = last_src->mnt_master;
|
2005-11-07 22:21:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (p_last_dest) {
|
|
|
|
do {
|
|
|
|
p_last_dest = next_peer(p_last_dest);
|
2011-11-25 05:46:35 +00:00
|
|
|
} while (IS_MNT_NEW(p_last_dest));
|
2010-01-16 18:28:47 +00:00
|
|
|
/* is that a peer of the earlier? */
|
|
|
|
if (dest == p_last_dest) {
|
|
|
|
*type = CL_MAKE_SHARED;
|
|
|
|
return p_last_src;
|
|
|
|
}
|
2005-11-07 22:21:01 +00:00
|
|
|
}
|
2010-01-16 18:28:47 +00:00
|
|
|
/* slave of the earlier, then */
|
|
|
|
*type = CL_SLAVE;
|
|
|
|
/* beginning of peer group among the slaves? */
|
2011-11-25 06:05:37 +00:00
|
|
|
if (IS_MNT_SHARED(dest))
|
2010-01-16 18:28:47 +00:00
|
|
|
*type |= CL_MAKE_SHARED;
|
|
|
|
return last_src;
|
2005-11-07 22:19:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* mount 'source_mnt' under the destination 'dest_mnt' at
|
|
|
|
* dentry 'dest_dentry'. And propagate that mount to
|
|
|
|
* all the peer and slave mounts of 'dest_mnt'.
|
|
|
|
* Link all the new mounts into a propagation tree headed at
|
|
|
|
* source_mnt. Also link all the new mounts using ->mnt_list
|
|
|
|
* headed at source_mnt's ->mnt_list
|
|
|
|
*
|
|
|
|
* @dest_mnt: destination mount.
|
|
|
|
* @dest_dentry: destination dentry.
|
|
|
|
* @source_mnt: source mount.
|
|
|
|
* @tree_list : list of heads of trees to be attached.
|
|
|
|
*/
|
2013-03-15 14:53:28 +00:00
|
|
|
int propagate_mnt(struct mount *dest_mnt, struct mountpoint *dest_mp,
|
2011-11-25 04:59:29 +00:00
|
|
|
struct mount *source_mnt, struct list_head *tree_list)
|
2005-11-07 22:19:50 +00:00
|
|
|
{
|
2011-11-25 04:56:26 +00:00
|
|
|
struct mount *m, *child;
|
2005-11-07 22:19:50 +00:00
|
|
|
int ret = 0;
|
2011-11-25 04:59:29 +00:00
|
|
|
struct mount *prev_dest_mnt = dest_mnt;
|
|
|
|
struct mount *prev_src_mnt = source_mnt;
|
2005-11-07 22:19:50 +00:00
|
|
|
LIST_HEAD(tmp_list);
|
|
|
|
|
2011-11-25 04:59:29 +00:00
|
|
|
for (m = propagation_next(dest_mnt, dest_mnt); m;
|
|
|
|
m = propagation_next(m, dest_mnt)) {
|
2005-11-07 22:21:01 +00:00
|
|
|
int type;
|
2011-11-25 04:56:26 +00:00
|
|
|
struct mount *source;
|
2005-11-07 22:19:50 +00:00
|
|
|
|
2011-11-25 05:46:35 +00:00
|
|
|
if (IS_MNT_NEW(m))
|
2005-11-07 22:19:50 +00:00
|
|
|
continue;
|
|
|
|
|
2005-11-07 22:21:01 +00:00
|
|
|
source = get_source(m, prev_dest_mnt, prev_src_mnt, &type);
|
2005-11-07 22:19:50 +00:00
|
|
|
|
2012-06-25 11:55:18 +00:00
|
|
|
child = copy_tree(source, source->mnt.mnt_root, type);
|
|
|
|
if (IS_ERR(child)) {
|
|
|
|
ret = PTR_ERR(child);
|
2005-11-07 22:19:50 +00:00
|
|
|
list_splice(tree_list, tmp_list.prev);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2013-03-15 14:53:28 +00:00
|
|
|
if (is_subdir(dest_mp->m_dentry, m->mnt.mnt_root)) {
|
|
|
|
mnt_set_mountpoint(m, dest_mp, child);
|
2011-11-25 02:01:32 +00:00
|
|
|
list_add_tail(&child->mnt_hash, tree_list);
|
2005-11-07 22:19:50 +00:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* This can happen if the parent mount was bind mounted
|
|
|
|
* on some subdirectory of a shared/slave mount.
|
|
|
|
*/
|
2011-11-25 02:01:32 +00:00
|
|
|
list_add_tail(&child->mnt_hash, &tmp_list);
|
2005-11-07 22:19:50 +00:00
|
|
|
}
|
|
|
|
prev_dest_mnt = m;
|
2011-11-25 04:56:26 +00:00
|
|
|
prev_src_mnt = child;
|
2005-11-07 22:19:50 +00:00
|
|
|
}
|
|
|
|
out:
|
2012-05-08 04:02:02 +00:00
|
|
|
br_write_lock(&vfsmount_lock);
|
2005-11-07 22:19:50 +00:00
|
|
|
while (!list_empty(&tmp_list)) {
|
2011-11-25 02:01:32 +00:00
|
|
|
child = list_first_entry(&tmp_list, struct mount, mnt_hash);
|
2013-03-16 18:49:45 +00:00
|
|
|
umount_tree(child, 0);
|
2005-11-07 22:19:50 +00:00
|
|
|
}
|
2012-05-08 04:02:02 +00:00
|
|
|
br_write_unlock(&vfsmount_lock);
|
2005-11-07 22:19:50 +00:00
|
|
|
return ret;
|
|
|
|
}
|
2005-11-07 22:20:17 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* return true if the refcount is greater than count
|
|
|
|
*/
|
2011-11-25 02:35:16 +00:00
|
|
|
static inline int do_refcount_check(struct mount *mnt, int count)
|
2005-11-07 22:20:17 +00:00
|
|
|
{
|
2011-11-25 05:57:42 +00:00
|
|
|
int mycount = mnt_get_count(mnt) - mnt->mnt_ghosts;
|
2005-11-07 22:20:17 +00:00
|
|
|
return (mycount > count);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* check if the mount 'mnt' can be unmounted successfully.
|
|
|
|
* @mnt: the mount to be checked for unmount
|
|
|
|
* NOTE: unmounting 'mnt' would naturally propagate to all
|
|
|
|
* other mounts its parent propagates to.
|
|
|
|
* Check if any of these mounts that **do not have submounts**
|
|
|
|
* have more references than 'refcnt'. If so return busy.
|
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 18:37:39 +00: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 06:50:11 +00:00
|
|
|
* vfsmount lock must be held for write
|
2005-11-07 22:20:17 +00:00
|
|
|
*/
|
2011-11-25 02:35:16 +00:00
|
|
|
int propagate_mount_busy(struct mount *mnt, int refcnt)
|
2005-11-07 22:20:17 +00:00
|
|
|
{
|
2011-11-25 04:56:26 +00:00
|
|
|
struct mount *m, *child;
|
2011-11-25 03:19:58 +00:00
|
|
|
struct mount *parent = mnt->mnt_parent;
|
2005-11-07 22:20:17 +00:00
|
|
|
int ret = 0;
|
|
|
|
|
2011-11-25 03:19:58 +00:00
|
|
|
if (mnt == parent)
|
2005-11-07 22:20:17 +00:00
|
|
|
return do_refcount_check(mnt, refcnt);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* quickly check if the current mount can be unmounted.
|
|
|
|
* If not, we don't have to go checking for all other
|
|
|
|
* mounts
|
|
|
|
*/
|
2011-11-25 04:24:33 +00:00
|
|
|
if (!list_empty(&mnt->mnt_mounts) || do_refcount_check(mnt, refcnt))
|
2005-11-07 22:20:17 +00:00
|
|
|
return 1;
|
|
|
|
|
2011-11-25 04:56:26 +00:00
|
|
|
for (m = propagation_next(parent, parent); m;
|
|
|
|
m = propagation_next(m, parent)) {
|
|
|
|
child = __lookup_mnt(&m->mnt, mnt->mnt_mountpoint, 0);
|
2011-11-25 04:24:33 +00:00
|
|
|
if (child && list_empty(&child->mnt_mounts) &&
|
2011-11-25 02:35:16 +00:00
|
|
|
(ret = do_refcount_check(child, 1)))
|
2005-11-07 22:20:17 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* NOTE: unmounting 'mnt' naturally propagates to all other mounts its
|
|
|
|
* parent propagates to.
|
|
|
|
*/
|
2011-11-24 23:25:28 +00:00
|
|
|
static void __propagate_umount(struct mount *mnt)
|
2005-11-07 22:20:17 +00:00
|
|
|
{
|
2011-11-25 03:19:58 +00:00
|
|
|
struct mount *parent = mnt->mnt_parent;
|
2011-11-25 04:56:26 +00:00
|
|
|
struct mount *m;
|
2005-11-07 22:20:17 +00:00
|
|
|
|
2011-11-25 03:19:58 +00:00
|
|
|
BUG_ON(parent == mnt);
|
2005-11-07 22:20:17 +00:00
|
|
|
|
2011-11-25 04:56:26 +00:00
|
|
|
for (m = propagation_next(parent, parent); m;
|
|
|
|
m = propagation_next(m, parent)) {
|
2005-11-07 22:20:17 +00:00
|
|
|
|
2011-11-25 04:56:26 +00:00
|
|
|
struct mount *child = __lookup_mnt(&m->mnt,
|
2011-11-25 03:25:07 +00:00
|
|
|
mnt->mnt_mountpoint, 0);
|
2005-11-07 22:20:17 +00:00
|
|
|
/*
|
|
|
|
* umount the child only if the child has no
|
|
|
|
* other children
|
|
|
|
*/
|
2011-11-25 04:24:33 +00:00
|
|
|
if (child && list_empty(&child->mnt_mounts))
|
2011-11-25 02:01:32 +00:00
|
|
|
list_move_tail(&child->mnt_hash, &mnt->mnt_hash);
|
2005-11-07 22:20:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* collect all mounts that receive propagation from the mount in @list,
|
|
|
|
* and return these additional mounts in the same list.
|
|
|
|
* @list: the list of mounts to be unmounted.
|
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 18:37:39 +00:00
|
|
|
*
|
|
|
|
* vfsmount lock must be held for write
|
2005-11-07 22:20:17 +00:00
|
|
|
*/
|
|
|
|
int propagate_umount(struct list_head *list)
|
|
|
|
{
|
2011-11-24 23:25:28 +00:00
|
|
|
struct mount *mnt;
|
2005-11-07 22:20:17 +00:00
|
|
|
|
2011-11-25 02:01:32 +00:00
|
|
|
list_for_each_entry(mnt, list, mnt_hash)
|
2005-11-07 22:20:17 +00:00
|
|
|
__propagate_umount(mnt);
|
|
|
|
return 0;
|
|
|
|
}
|