fs/pnode.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 *  linux/fs/pnode.c
 *
 * (C) Copyright IBM Corporation 2005.
 *	Author : Ram Pai (linuxram@us.ibm.com)
 */
#include <linux/mnt_namespace.h>
#include <linux/mount.h>
#include <linux/fs.h>
#include <linux/nsproxy.h>
#include <uapi/linux/mount.h>
#include "internal.h"
#include "pnode.h"

/* return the next shared peer mount of @p */
static inline struct mount *next_peer(struct mount *p)
{
	return list_entry(p->mnt_share.next, struct mount, mnt_share);
}

static inline struct mount *first_slave(struct mount *p)
{
	return hlist_entry(p->mnt_slave_list.first, struct mount, mnt_slave);
}

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

/* locks: namespace_shared && is_mounted(mnt) */
static struct mount *get_peer_under_root(struct mount *mnt,
					 struct mnt_namespace *ns,
					 const struct path *root)
{
	struct mount *m = mnt;

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

		m = next_peer(m);
	} while (m != mnt);

	return NULL;
}

/*
 * Get ID of closest dominating peer group having a representative
 * under the given root.
 *
 * locks: namespace_shared
 */
int get_dominating_id(struct mount *mnt, const struct path *root)
{
	struct mount *m;

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

	return 0;
}

static inline bool will_be_unmounted(struct mount *m)
{
	return m->mnt.mnt_flags & MNT_UMOUNT;
}

static void transfer_propagation(struct mount *mnt, struct mount *to)
{
	struct hlist_node *p = NULL, *n;
	struct mount *m;

	hlist_for_each_entry_safe(m, n, &mnt->mnt_slave_list, mnt_slave) {
		m->mnt_master = to;
		if (!to)
			hlist_del_init(&m->mnt_slave);
		else
			p = &m->mnt_slave;
	}
	if (p)
		hlist_splice_init(&mnt->mnt_slave_list, p, &to->mnt_slave_list);
}

/*
 * EXCL[namespace_sem]
 */
void change_mnt_propagation(struct mount *mnt, int type)
{
	struct mount *m = mnt->mnt_master;

	if (type == MS_SHARED) {
		set_mnt_shared(mnt);
		return;
	}
	if (IS_MNT_SHARED(mnt)) {
		if (list_empty(&mnt->mnt_share)) {
			mnt_release_group_id(mnt);
		} else {
			m = next_peer(mnt);
			list_del_init(&mnt->mnt_share);
			mnt->mnt_group_id = 0;
		}
		CLEAR_MNT_SHARED(mnt);
		transfer_propagation(mnt, m);
	}
	hlist_del_init(&mnt->mnt_slave);
	if (type == MS_SLAVE) {
		mnt->mnt_master = m;
		if (m)
			hlist_add_head(&mnt->mnt_slave, &m->mnt_slave_list);
	} else {
		mnt->mnt_master = NULL;
		if (type == MS_UNBINDABLE)
			mnt->mnt_t_flags |= T_UNBINDABLE;
		else
			mnt->mnt_t_flags &= ~T_UNBINDABLE;
	}
}

static struct mount *trace_transfers(struct mount *m)
{
	while (1) {
		struct mount *next = next_peer(m);

		if (next != m) {
			list_del_init(&m->mnt_share);
			m->mnt_group_id = 0;
			m->mnt_master = next;
		} else {
			if (IS_MNT_SHARED(m))
				mnt_release_group_id(m);
			next = m->mnt_master;
		}
		hlist_del_init(&m->mnt_slave);
		CLEAR_MNT_SHARED(m);
		SET_MNT_MARK(m);

		if (!next || !will_be_unmounted(next))
			return next;
		if (IS_MNT_MARKED(next))
			return next->mnt_master;
		m = next;
	}
}

static void set_destinations(struct mount *m, struct mount *master)
{
	struct mount *next;

	while ((next = m->mnt_master) != master) {
		m->mnt_master = master;
		m = next;
	}
}

void bulk_make_private(struct list_head *set)
{
	struct mount *m;

	list_for_each_entry(m, set, mnt_list)
		if (!IS_MNT_MARKED(m))
			set_destinations(m, trace_transfers(m));

	list_for_each_entry(m, set, mnt_list) {
		transfer_propagation(m, m->mnt_master);
		m->mnt_master = NULL;
		CLEAR_MNT_MARK(m);
	}
}

static struct mount *__propagation_next(struct mount *m,
					 struct mount *origin)
{
	while (1) {
		struct mount *master = m->mnt_master;

		if (master == origin->mnt_master) {
			struct mount *next = next_peer(m);
			return (next == origin) ? NULL : next;
		} else if (m->mnt_slave.next)
			return next_slave(m);

		/* back at master */
		m = master;
	}
}

/*
 * get the next mount in the propagation tree.
 * @m: the mount seen last
 * @origin: the original mount from where the tree walk initiated
 *
 * 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.
 */
static struct mount *propagation_next(struct mount *m,
					 struct mount *origin)
{
	/* are there any slaves of this mount? */
	if (!IS_MNT_NEW(m) && !hlist_empty(&m->mnt_slave_list))
		return first_slave(m);

	return __propagation_next(m, origin);
}

static struct mount *skip_propagation_subtree(struct mount *m,
						struct mount *origin)
{
	/*
	 * Advance m past everything that gets propagation from it.
	 */
	struct mount *p = __propagation_next(m, origin);

	while (p && peers(m, p))
		p = __propagation_next(p, origin);

	return p;
}

static struct mount *next_group(struct mount *m, struct mount *origin)
{
	while (1) {
		while (1) {
			struct mount *next;
			if (!IS_MNT_NEW(m) && !hlist_empty(&m->mnt_slave_list))
				return first_slave(m);
			next = next_peer(m);
			if (m->mnt_group_id == origin->mnt_group_id) {
				if (next == origin)
					return NULL;
			} else if (m->mnt_slave.next != &next->mnt_slave)
				break;
			m = next;
		}
		/* m is the last peer */
		while (1) {
			struct mount *master = m->mnt_master;
			if (m->mnt_slave.next)
				return next_slave(m);
			m = next_peer(master);
			if (master->mnt_group_id == origin->mnt_group_id)
				break;
			if (master->mnt_slave.next == &m->mnt_slave)
				break;
			m = master;
		}
		if (m == origin)
			return NULL;
	}
}

static bool need_secondary(struct mount *m, struct mountpoint *dest_mp)
{
	/* skip ones added by this propagate_mnt() */
	if (IS_MNT_NEW(m))
		return false;
	/* skip if mountpoint isn't visible in m */
	if (!is_subdir(dest_mp->m_dentry, m->mnt.mnt_root))
		return false;
	/* skip if m is in the anon_ns */
	if (is_anon_ns(m->mnt_ns))
		return false;
	return true;
}

static struct mount *find_master(struct mount *m,
				struct mount *last_copy,
				struct mount *original)
{
	struct mount *p;

	// ascend until there's a copy for something with the same master
	for (;;) {
		p = m->mnt_master;
		if (!p || IS_MNT_MARKED(p))
			break;
		m = p;
	}
	while (!peers(last_copy, original)) {
		struct mount *parent = last_copy->mnt_parent;
		if (parent->mnt_master == p) {
			if (!peers(parent, m))
				last_copy = last_copy->mnt_master;
			break;
		}
		last_copy = last_copy->mnt_master;
	}
	return last_copy;
}

/**
 * propagate_mnt() - create secondary copies for tree attachment
 * @dest_mnt:    destination mount.
 * @dest_mp:     destination mountpoint.
 * @source_mnt:  source mount.
 * @tree_list:   list of secondaries to be attached.
 *
 * Create secondary copies for attaching a tree with root @source_mnt
 * at mount @dest_mnt with mountpoint @dest_mp.  Link all new mounts
 * into a propagation graph.  Set mountpoints for all secondaries,
 * link their roots into @tree_list via ->mnt_hash.
 */
int propagate_mnt(struct mount *dest_mnt, struct mountpoint *dest_mp,
		  struct mount *source_mnt, struct hlist_head *tree_list)
{
	struct mount *m, *n, *copy, *this;
	int err = 0, type;

	if (dest_mnt->mnt_master)
		SET_MNT_MARK(dest_mnt->mnt_master);

	/* iterate over peer groups, depth first */
	for (m = dest_mnt; m && !err; m = next_group(m, dest_mnt)) {
		if (m == dest_mnt) { // have one for dest_mnt itself
			copy = source_mnt;
			type = CL_MAKE_SHARED;
			n = next_peer(m);
			if (n == m)
				continue;
		} else {
			type = CL_SLAVE;
			/* beginning of peer group among the slaves? */
			if (IS_MNT_SHARED(m))
				type |= CL_MAKE_SHARED;
			n = m;
		}
		do {
			if (!need_secondary(n, dest_mp))
				continue;
			if (type & CL_SLAVE) // first in this peer group
				copy = find_master(n, copy, source_mnt);
			this = copy_tree(copy, copy->mnt.mnt_root, type);
			if (IS_ERR(this)) {
				err = PTR_ERR(this);
				break;
			}
			scoped_guard(mount_locked_reader)
				mnt_set_mountpoint(n, dest_mp, this);
			if (n->mnt_master)
				SET_MNT_MARK(n->mnt_master);
			copy = this;
			hlist_add_head(&this->mnt_hash, tree_list);
			err = count_mounts(n->mnt_ns, this);
			if (err)
				break;
			type = CL_MAKE_SHARED;
		} while ((n = next_peer(n)) != m);
	}

	hlist_for_each_entry(n, tree_list, mnt_hash) {
		m = n->mnt_parent;
		if (m->mnt_master)
			CLEAR_MNT_MARK(m->mnt_master);
	}
	if (dest_mnt->mnt_master)
		CLEAR_MNT_MARK(dest_mnt->mnt_master);
	return err;
}

/*
 * return true if the refcount is greater than count
 */
static inline int do_refcount_check(struct mount *mnt, int count)
{
	return mnt_get_count(mnt) > count;
}

/**
 * propagation_would_overmount - check whether propagation from @from
 *                               would overmount @to
 * @from: shared mount
 * @to:   mount to check
 * @mp:   future mountpoint of @to on @from
 *
 * If @from propagates mounts to @to, @from and @to must either be peers
 * or one of the masters in the hierarchy of masters of @to must be a
 * peer of @from.
 *
 * If the root of the @to mount is equal to the future mountpoint @mp of
 * the @to mount on @from then @to will be overmounted by whatever is
 * propagated to it.
 *
 * Context: This function expects namespace_lock() to be held and that
 *          @mp is stable.
 * Return: If @from overmounts @to, true is returned, false if not.
 */
bool propagation_would_overmount(const struct mount *from,
				 const struct mount *to,
				 const struct mountpoint *mp)
{
	if (!IS_MNT_SHARED(from))
		return false;

	if (to->mnt.mnt_root != mp->m_dentry)
		return false;

	for (const struct mount *m = to; m; m = m->mnt_master) {
		if (peers(from, m))
			return true;
	}

	return false;
}

/*
 * 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.
 *
 * vfsmount lock must be held for write
 */
int propagate_mount_busy(struct mount *mnt, int refcnt)
{
	struct mount *parent = mnt->mnt_parent;

	/*
	 * quickly check if the current mount can be unmounted.
	 * If not, we don't have to go checking for all other
	 * mounts
	 */
	if (!list_empty(&mnt->mnt_mounts) || do_refcount_check(mnt, refcnt))
		return 1;

	if (mnt == parent)
		return 0;

	for (struct mount *m = propagation_next(parent, parent); m;
	     		m = propagation_next(m, parent)) {
		struct list_head *head;
		struct mount *child = __lookup_mnt(&m->mnt, mnt->mnt_mountpoint);

		if (!child)
			continue;

		head = &child->mnt_mounts;
		if (!list_empty(head)) {
			/*
			 * a mount that covers child completely wouldn't prevent
			 * it being pulled out; any other would.
			 */
			if (!list_is_singular(head) || !child->overmount)
				continue;
		}
		if (do_refcount_check(child, 1))
			return 1;
	}
	return 0;
}

/*
 * Clear MNT_LOCKED when it can be shown to be safe.
 *
 * mount_lock lock must be held for write
 */
void propagate_mount_unlock(struct mount *mnt)
{
	struct mount *parent = mnt->mnt_parent;
	struct mount *m, *child;

	BUG_ON(parent == mnt);

	for (m = propagation_next(parent, parent); m;
			m = propagation_next(m, parent)) {
		child = __lookup_mnt(&m->mnt, mnt->mnt_mountpoint);
		if (child)
			child->mnt.mnt_flags &= ~MNT_LOCKED;
	}
}

static inline bool is_candidate(struct mount *m)
{
	return m->mnt_t_flags & T_UMOUNT_CANDIDATE;
}

static void umount_one(struct mount *m, struct list_head *to_umount)
{
	m->mnt.mnt_flags |= MNT_UMOUNT;
	list_del_init(&m->mnt_child);
	move_from_ns(m);
	list_add_tail(&m->mnt_list, to_umount);
}

static void remove_from_candidate_list(struct mount *m)
{
	m->mnt_t_flags &= ~(T_MARKED | T_UMOUNT_CANDIDATE);
	list_del_init(&m->mnt_list);
}

static void gather_candidates(struct list_head *set,
			      struct list_head *candidates)
{
	struct mount *m, *p, *q;

	list_for_each_entry(m, set, mnt_list) {
		if (is_candidate(m))
			continue;
		m->mnt_t_flags |= T_UMOUNT_CANDIDATE;
		p = m->mnt_parent;
		q = propagation_next(p, p);
		while (q) {
			struct mount *child = __lookup_mnt(&q->mnt,
							   m->mnt_mountpoint);
			if (child) {
				/*
				 * We might've already run into this one.  That
				 * must've happened on earlier iteration of the
				 * outer loop; in that case we can skip those
				 * parents that get propagation from q - there
				 * will be nothing new on those as well.
				 */
				if (is_candidate(child)) {
					q = skip_propagation_subtree(q, p);
					continue;
				}
				child->mnt_t_flags |= T_UMOUNT_CANDIDATE;
				if (!will_be_unmounted(child))
					list_add(&child->mnt_list, candidates);
			}
			q = propagation_next(q, p);
		}
	}
	list_for_each_entry(m, set, mnt_list)
		m->mnt_t_flags &= ~T_UMOUNT_CANDIDATE;
}

/*
 * We know that some child of @m can't be unmounted.  In all places where the
 * chain of descent of @m has child not overmounting the root of parent,
 * the parent can't be unmounted either.
 */
static void trim_ancestors(struct mount *m)
{
	struct mount *p;

	for (p = m->mnt_parent; is_candidate(p); m = p, p = p->mnt_parent) {
		if (IS_MNT_MARKED(m))	// all candidates beneath are overmounts
			return;
		SET_MNT_MARK(m);
		if (m != p->overmount)
			p->mnt_t_flags &= ~T_UMOUNT_CANDIDATE;
	}
}

/*
 * Find and exclude all umount candidates forbidden by @m
 * (see Documentation/filesystems/propagate_umount.txt)
 * If we can immediately tell that @m is OK to unmount (unlocked
 * and all children are already committed to unmounting) commit
 * to unmounting it.
 * Only @m itself might be taken from the candidates list;
 * anything found by trim_ancestors() is marked non-candidate
 * and left on the list.
 */
static void trim_one(struct mount *m, struct list_head *to_umount)
{
	bool remove_this = false, found = false, umount_this = false;
	struct mount *n;

	if (!is_candidate(m)) { // trim_ancestors() left it on list
		remove_from_candidate_list(m);
		return;
	}

	list_for_each_entry(n, &m->mnt_mounts, mnt_child) {
		if (!is_candidate(n)) {
			found = true;
			if (n != m->overmount) {
				remove_this = true;
				break;
			}
		}
	}
	if (found) {
		trim_ancestors(m);
	} else if (!IS_MNT_LOCKED(m) && list_empty(&m->mnt_mounts)) {
		remove_this = true;
		umount_this = true;
	}
	if (remove_this) {
		remove_from_candidate_list(m);
		if (umount_this)
			umount_one(m, to_umount);
	}
}

static void handle_locked(struct mount *m, struct list_head *to_umount)
{
	struct mount *cutoff = m, *p;

	if (!is_candidate(m)) { // trim_ancestors() left it on list
		remove_from_candidate_list(m);
		return;
	}
	for (p = m; is_candidate(p); p = p->mnt_parent) {
		remove_from_candidate_list(p);
		if (!IS_MNT_LOCKED(p))
			cutoff = p->mnt_parent;
	}
	if (will_be_unmounted(p))
		cutoff = p;
	while (m != cutoff) {
		umount_one(m, to_umount);
		m = m->mnt_parent;
	}
}

/*
 * @m is not to going away, and it overmounts the top of a stack of mounts
 * that are going away.  We know that all of those are fully overmounted
 * by the one above (@m being the topmost of the chain), so @m can be slid
 * in place where the bottom of the stack is attached.
 *
 * NOTE: here we temporarily violate a constraint - two mounts end up with
 * the same parent and mountpoint; that will be remedied as soon as we
 * return from propagate_umount() - its caller (umount_tree()) will detach
 * the stack from the parent it (and now @m) is attached to.  umount_tree()
 * might choose to keep unmounted pieces stuck to each other, but it always
 * detaches them from the mounts that remain in the tree.
 */
static void reparent(struct mount *m)
{
	struct mount *p = m;
	struct mountpoint *mp;

	do {
		mp = p->mnt_mp;
		p = p->mnt_parent;
	} while (will_be_unmounted(p));

	mnt_change_mountpoint(p, mp, m);
	mnt_notify_add(m);
}

/**
 * propagate_umount - apply propagation rules to the set of mounts for umount()
 * @set: the list of mounts to be unmounted.
 *
 * Collect all mounts that receive propagation from the mount in @set and have
 * no obstacles to being unmounted.  Add these additional mounts to the set.
 *
 * See Documentation/filesystems/propagate_umount.txt if you do anything in
 * this area.
 *
 * Locks held:
 * mount_lock (write_seqlock), namespace_sem (exclusive).
 */
void propagate_umount(struct list_head *set)
{
	struct mount *m, *p;
	LIST_HEAD(to_umount);	// committed to unmounting
	LIST_HEAD(candidates);	// undecided umount candidates

	// collect all candidates
	gather_candidates(set, &candidates);

	// reduce the set until it's non-shifting
	list_for_each_entry_safe(m, p, &candidates, mnt_list)
		trim_one(m, &to_umount);

	// ... and non-revealing
	while (!list_empty(&candidates)) {
		m = list_first_entry(&candidates,struct mount, mnt_list);
		handle_locked(m, &to_umount);
	}

	// now to_umount consists of all acceptable candidates
	// deal with reparenting of surviving overmounts on those
	list_for_each_entry(m, &to_umount, mnt_list) {
		struct mount *over = m->overmount;
		if (over && !will_be_unmounted(over))
			reparent(over);
	}

	// and fold them into the set
	list_splice_tail_init(&to_umount, set);
}