pnode.c 9.09 KB
Newer Older
1 2 3 4 5 6 7 8
/*
 *  linux/fs/pnode.c
 *
 * (C) Copyright IBM Corporation 2005.
 *	Released under GPL v2.
 *	Author : Ram Pai (linuxram@us.ibm.com)
 *
 */
9
#include <linux/mnt_namespace.h>
10 11
#include <linux/mount.h>
#include <linux/fs.h>
12
#include "internal.h"
13 14
#include "pnode.h"

Ram Pai's avatar
Ram Pai committed
15 16 17 18 19 20
/* return the next shared peer mount of @p */
static inline struct vfsmount *next_peer(struct vfsmount *p)
{
	return list_entry(p->mnt_share.next, struct vfsmount, mnt_share);
}

Ram Pai's avatar
Ram Pai committed
21 22 23 24 25 26 27 28 29 30
static inline struct vfsmount *first_slave(struct vfsmount *p)
{
	return list_entry(p->mnt_slave_list.next, struct vfsmount, mnt_slave);
}

static inline struct vfsmount *next_slave(struct vfsmount *p)
{
	return list_entry(p->mnt_slave.next, struct vfsmount, mnt_slave);
}

31 32 33 34
static struct vfsmount *get_peer_under_root(struct vfsmount *mnt,
					    struct mnt_namespace *ns,
					    const struct path *root)
{
35
	struct mount *m = real_mount(mnt);
36 37 38

	do {
		/* Check the namespace first for optimization */
39 40
		if (m->mnt.mnt_ns == ns && is_path_reachable(m, m->mnt.mnt_root, root))
			return &m->mnt;
41

42 43
		m = real_mount(next_peer(&m->mnt));
	} while (&m->mnt != mnt);
44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66

	return NULL;
}

/*
 * Get ID of closest dominating peer group having a representative
 * under the given root.
 *
 * Caller must hold namespace_sem
 */
int get_dominating_id(struct vfsmount *mnt, const struct path *root)
{
	struct vfsmount *m;

	for (m = mnt->mnt_master; m != NULL; m = m->mnt_master) {
		struct vfsmount *d = get_peer_under_root(m, mnt->mnt_ns, root);
		if (d)
			return d->mnt_group_id;
	}

	return 0;
}

Ram Pai's avatar
Ram Pai committed
67 68 69 70 71 72 73
static int do_make_slave(struct vfsmount *mnt)
{
	struct vfsmount *peer_mnt = mnt, *master = mnt->mnt_master;
	struct vfsmount *slave_mnt;

	/*
	 * slave 'mnt' to a peer mount that has the
74
	 * same root dentry. If none is available then
Ram Pai's avatar
Ram Pai committed
75 76 77 78 79 80 81 82 83 84
	 * slave it to anything that is available.
	 */
	while ((peer_mnt = next_peer(peer_mnt)) != mnt &&
	       peer_mnt->mnt_root != mnt->mnt_root) ;

	if (peer_mnt == mnt) {
		peer_mnt = next_peer(mnt);
		if (peer_mnt == mnt)
			peer_mnt = NULL;
	}
85
	if (IS_MNT_SHARED(mnt) && list_empty(&mnt->mnt_share))
86
		mnt_release_group_id(real_mount(mnt));
87

Ram Pai's avatar
Ram Pai committed
88
	list_del_init(&mnt->mnt_share);
89
	mnt->mnt_group_id = 0;
Ram Pai's avatar
Ram Pai committed
90 91 92 93 94 95 96

	if (peer_mnt)
		master = peer_mnt;

	if (master) {
		list_for_each_entry(slave_mnt, &mnt->mnt_slave_list, mnt_slave)
			slave_mnt->mnt_master = master;
Akinobu Mita's avatar
Akinobu Mita committed
97
		list_move(&mnt->mnt_slave, &master->mnt_slave_list);
Ram Pai's avatar
Ram Pai committed
98 99 100 101 102
		list_splice(&mnt->mnt_slave_list, master->mnt_slave_list.prev);
		INIT_LIST_HEAD(&mnt->mnt_slave_list);
	} else {
		struct list_head *p = &mnt->mnt_slave_list;
		while (!list_empty(p)) {
103
                        slave_mnt = list_first_entry(p,
Ram Pai's avatar
Ram Pai committed
104 105 106 107 108 109 110 111 112 113
					struct vfsmount, mnt_slave);
			list_del_init(&slave_mnt->mnt_slave);
			slave_mnt->mnt_master = NULL;
		}
	}
	mnt->mnt_master = master;
	CLEAR_MNT_SHARED(mnt);
	return 0;
}

Nick Piggin's avatar
Nick Piggin committed
114 115 116
/*
 * vfsmount lock must be held for write
 */
117
void change_mnt_propagation(struct mount *mnt, int type)
118
{
Ram Pai's avatar
Ram Pai committed
119
	if (type == MS_SHARED) {
120
		set_mnt_shared(mnt);
Ram Pai's avatar
Ram Pai committed
121 122
		return;
	}
123
	do_make_slave(&mnt->mnt);
Ram Pai's avatar
Ram Pai committed
124
	if (type != MS_SLAVE) {
125 126
		list_del_init(&mnt->mnt.mnt_slave);
		mnt->mnt.mnt_master = NULL;
Ram Pai's avatar
Ram Pai committed
127
		if (type == MS_UNBINDABLE)
128
			mnt->mnt.mnt_flags |= MNT_UNBINDABLE;
Andries E. Brouwer's avatar
Andries E. Brouwer committed
129
		else
130
			mnt->mnt.mnt_flags &= ~MNT_UNBINDABLE;
Ram Pai's avatar
Ram Pai committed
131
	}
132
}
133 134 135 136 137

/*
 * get the next mount in the propagation tree.
 * @m: the mount seen last
 * @origin: the original mount from where the tree walk initiated
138 139 140 141 142
 *
 * 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.
143 144 145 146
 */
static struct vfsmount *propagation_next(struct vfsmount *m,
					 struct vfsmount *origin)
{
Ram Pai's avatar
Ram Pai committed
147 148 149 150 151 152 153 154
	/* are there any slaves of this mount? */
	if (!IS_MNT_NEW(m) && !list_empty(&m->mnt_slave_list))
		return first_slave(m);

	while (1) {
		struct vfsmount *next;
		struct vfsmount *master = m->mnt_master;

155
		if (master == origin->mnt_master) {
Ram Pai's avatar
Ram Pai committed
156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193
			next = next_peer(m);
			return ((next == origin) ? NULL : next);
		} else if (m->mnt_slave.next != &master->mnt_slave_list)
			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.
 */
static struct vfsmount *get_source(struct vfsmount *dest,
					struct vfsmount *last_dest,
					struct vfsmount *last_src,
					int *type)
{
	struct vfsmount *p_last_src = NULL;
	struct vfsmount *p_last_dest = NULL;

	while (last_dest != dest->mnt_master) {
		p_last_dest = last_dest;
		p_last_src = last_src;
		last_dest = last_dest->mnt_master;
		last_src = last_src->mnt_master;
	}

	if (p_last_dest) {
		do {
			p_last_dest = next_peer(p_last_dest);
		} while (IS_MNT_NEW(p_last_dest));
194 195 196 197 198
		/* is that a peer of the earlier? */
		if (dest == p_last_dest) {
			*type = CL_MAKE_SHARED;
			return p_last_src;
		}
Ram Pai's avatar
Ram Pai committed
199
	}
200 201 202 203 204 205
	/* slave of the earlier, then */
	*type = CL_SLAVE;
	/* beginning of peer group among the slaves? */
	if (IS_MNT_SHARED(dest))
		*type |= CL_MAKE_SHARED;
	return last_src;
206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223
}

/*
 * 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.
 */
int propagate_mnt(struct vfsmount *dest_mnt, struct dentry *dest_dentry,
		    struct vfsmount *source_mnt, struct list_head *tree_list)
{
224 225
	struct vfsmount *m;
	struct mount *child;
226 227 228 229 230 231 232 233
	int ret = 0;
	struct vfsmount *prev_dest_mnt = dest_mnt;
	struct vfsmount *prev_src_mnt  = source_mnt;
	LIST_HEAD(tmp_list);
	LIST_HEAD(umount_list);

	for (m = propagation_next(dest_mnt, dest_mnt); m;
			m = propagation_next(m, dest_mnt)) {
Ram Pai's avatar
Ram Pai committed
234 235
		int type;
		struct vfsmount *source;
236 237 238 239

		if (IS_MNT_NEW(m))
			continue;

Ram Pai's avatar
Ram Pai committed
240
		source =  get_source(m, prev_dest_mnt, prev_src_mnt, &type);
241

242
		if (!(child = copy_tree(real_mount(source), source->mnt_root, type))) {
243 244 245 246 247 248
			ret = -ENOMEM;
			list_splice(tree_list, tmp_list.prev);
			goto out;
		}

		if (is_subdir(dest_dentry, m->mnt_root)) {
249
			mnt_set_mountpoint(m, dest_dentry, child);
250
			list_add_tail(&child->mnt_hash, tree_list);
251 252 253 254 255
		} else {
			/*
			 * This can happen if the parent mount was bind mounted
			 * on some subdirectory of a shared/slave mount.
			 */
256
			list_add_tail(&child->mnt_hash, &tmp_list);
257 258
		}
		prev_dest_mnt = m;
259
		prev_src_mnt  = &child->mnt;
260 261
	}
out:
Nick Piggin's avatar
Nick Piggin committed
262
	br_write_lock(vfsmount_lock);
263
	while (!list_empty(&tmp_list)) {
264
		child = list_first_entry(&tmp_list, struct mount, mnt_hash);
265
		umount_tree(child, 0, &umount_list);
266
	}
Nick Piggin's avatar
Nick Piggin committed
267
	br_write_unlock(vfsmount_lock);
268 269 270
	release_mounts(&umount_list);
	return ret;
}
271 272 273 274

/*
 * return true if the refcount is greater than count
 */
275
static inline int do_refcount_check(struct mount *mnt, int count)
276
{
277
	int mycount = mnt_get_count(mnt) - mnt->mnt.mnt_ghosts;
278 279 280 281 282 283 284 285 286 287
	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.
Nick Piggin's avatar
Nick Piggin committed
288
 *
Nick Piggin's avatar
Nick Piggin committed
289
 * vfsmount lock must be held for write
290
 */
291
int propagate_mount_busy(struct mount *mnt, int refcnt)
292
{
293 294
	struct vfsmount *m;
	struct mount *child;
295
	struct mount *parent = mnt->mnt_parent;
296 297
	int ret = 0;

298
	if (mnt == parent)
299 300 301 302 303 304 305
		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
	 */
306
	if (!list_empty(&mnt->mnt.mnt_mounts) || do_refcount_check(mnt, refcnt))
307 308
		return 1;

309 310
	for (m = propagation_next(&parent->mnt, &parent->mnt); m;
	     		m = propagation_next(m, &parent->mnt)) {
311
		child = __lookup_mnt(m, mnt->mnt_mountpoint, 0);
312
		if (child && list_empty(&child->mnt.mnt_mounts) &&
313
		    (ret = do_refcount_check(child, 1)))
314 315 316 317 318 319 320 321 322
			break;
	}
	return ret;
}

/*
 * NOTE: unmounting 'mnt' naturally propagates to all other mounts its
 * parent propagates to.
 */
323
static void __propagate_umount(struct mount *mnt)
324
{
325
	struct mount *parent = mnt->mnt_parent;
326 327
	struct vfsmount *m;

328
	BUG_ON(parent == mnt);
329

330 331
	for (m = propagation_next(&parent->mnt, &parent->mnt); m;
			m = propagation_next(m, &parent->mnt)) {
332

333
		struct mount *child = __lookup_mnt(m,
334
					mnt->mnt_mountpoint, 0);
335 336 337 338
		/*
		 * umount the child only if the child has no
		 * other children
		 */
339
		if (child && list_empty(&child->mnt.mnt_mounts))
340
			list_move_tail(&child->mnt_hash, &mnt->mnt_hash);
341 342 343 344 345 346 347
	}
}

/*
 * 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.
Nick Piggin's avatar
Nick Piggin committed
348 349
 *
 * vfsmount lock must be held for write
350 351 352
 */
int propagate_umount(struct list_head *list)
{
353
	struct mount *mnt;
354

355
	list_for_each_entry(mnt, list, mnt_hash)
356 357 358
		__propagate_umount(mnt);
	return 0;
}