[people/ms/linux.git] / fs / autofs / expire.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Copyright 1997-1998 Transmeta Corporation -- All Rights Reserved
 * Copyright 1999-2000 Jeremy Fitzhardinge <jeremy@goop.org>
 * Copyright 2001-2006 Ian Kent <raven@themaw.net>
 */

#include "autofs_i.h"

/* Check if a dentry can be expired */
static inline int autofs_can_expire(struct dentry *dentry,
				    unsigned long timeout, unsigned int how)
{
	struct autofs_info *ino = autofs_dentry_ino(dentry);

	/* dentry in the process of being deleted */
	if (ino == NULL)
		return 0;

	if (!(how & AUTOFS_EXP_IMMEDIATE)) {
		/* Too young to die */
		if (!timeout || time_after(ino->last_used + timeout, jiffies))
			return 0;
	}
	return 1;
}

/* Check a mount point for busyness */
static int autofs_mount_busy(struct vfsmount *mnt,
			     struct dentry *dentry, unsigned int how)
{
	struct dentry *top = dentry;
	struct path path = {.mnt = mnt, .dentry = dentry};
	int status = 1;

	pr_debug("dentry %p %pd\n", dentry, dentry);

	path_get(&path);

	if (!follow_down_one(&path))
		goto done;

	if (is_autofs_dentry(path.dentry)) {
		struct autofs_sb_info *sbi = autofs_sbi(path.dentry->d_sb);

		/* This is an autofs submount, we can't expire it */
		if (autofs_type_indirect(sbi->type))
			goto done;
	}

	/* Not a submount, has a forced expire been requested */
	if (how & AUTOFS_EXP_FORCED) {
		status = 0;
		goto done;
	}

	/* Update the expiry counter if fs is busy */
	if (!may_umount_tree(path.mnt)) {
		struct autofs_info *ino;

		ino = autofs_dentry_ino(top);
		ino->last_used = jiffies;
		goto done;
	}

	status = 0;
done:
	pr_debug("returning = %d\n", status);
	path_put(&path);
	return status;
}

/* p->d_lock held */
static struct dentry *positive_after(struct dentry *p, struct dentry *child)
{
	if (child)
		child = list_next_entry(child, d_child);
	else
		child = list_first_entry(&p->d_subdirs, struct dentry, d_child);

	list_for_each_entry_from(child, &p->d_subdirs, d_child) {
		spin_lock_nested(&child->d_lock, DENTRY_D_LOCK_NESTED);
		if (simple_positive(child)) {
			dget_dlock(child);
			spin_unlock(&child->d_lock);
			return child;
		}
		spin_unlock(&child->d_lock);
	}

	return NULL;
}

/*
 * Calculate and dget next entry in the subdirs list under root.
 */
static struct dentry *get_next_positive_subdir(struct dentry *prev,
					       struct dentry *root)
{
	struct autofs_sb_info *sbi = autofs_sbi(root->d_sb);
	struct dentry *q;

	spin_lock(&sbi->lookup_lock);
	spin_lock(&root->d_lock);
	q = positive_after(root, prev);
	spin_unlock(&root->d_lock);
	spin_unlock(&sbi->lookup_lock);
	dput(prev);
	return q;
}

/*
 * Calculate and dget next entry in top down tree traversal.
 */
static struct dentry *get_next_positive_dentry(struct dentry *prev,
					       struct dentry *root)
{
	struct autofs_sb_info *sbi = autofs_sbi(root->d_sb);
	struct dentry *p = prev, *ret = NULL, *d = NULL;

	if (prev == NULL)
		return dget(root);

	spin_lock(&sbi->lookup_lock);
	spin_lock(&p->d_lock);
	while (1) {
		struct dentry *parent;

		ret = positive_after(p, d);
		if (ret || p == root)
			break;
		parent = p->d_parent;
		spin_unlock(&p->d_lock);
		spin_lock(&parent->d_lock);
		d = p;
		p = parent;
	}
	spin_unlock(&p->d_lock);
	spin_unlock(&sbi->lookup_lock);
	dput(prev);
	return ret;
}

/*
 * Check a direct mount point for busyness.
 * Direct mounts have similar expiry semantics to tree mounts.
 * The tree is not busy iff no mountpoints are busy and there are no
 * autofs submounts.
 */
static int autofs_direct_busy(struct vfsmount *mnt,
			      struct dentry *top,
			      unsigned long timeout,
			      unsigned int how)
{
	pr_debug("top %p %pd\n", top, top);

	/* Forced expire, user space handles busy mounts */
	if (how & AUTOFS_EXP_FORCED)
		return 0;

	/* If it's busy update the expiry counters */
	if (!may_umount_tree(mnt)) {
		struct autofs_info *ino;

		ino = autofs_dentry_ino(top);
		if (ino)
			ino->last_used = jiffies;
		return 1;
	}

	/* Timeout of a direct mount is determined by its top dentry */
	if (!autofs_can_expire(top, timeout, how))
		return 1;

	return 0;
}

/*
 * Check a directory tree of mount points for busyness
 * The tree is not busy iff no mountpoints are busy
 */
static int autofs_tree_busy(struct vfsmount *mnt,
			    struct dentry *top,
			    unsigned long timeout,
			    unsigned int how)
{
	struct autofs_info *top_ino = autofs_dentry_ino(top);
	struct dentry *p;

	pr_debug("top %p %pd\n", top, top);

	/* Negative dentry - give up */
	if (!simple_positive(top))
		return 1;

	p = NULL;
	while ((p = get_next_positive_dentry(p, top))) {
		pr_debug("dentry %p %pd\n", p, p);

		/*
		 * Is someone visiting anywhere in the subtree ?
		 * If there's no mount we need to check the usage
		 * count for the autofs dentry.
		 * If the fs is busy update the expiry counter.
		 */
		if (d_mountpoint(p)) {
			if (autofs_mount_busy(mnt, p, how)) {
				top_ino->last_used = jiffies;
				dput(p);
				return 1;
			}
		} else {
			struct autofs_info *ino = autofs_dentry_ino(p);
			unsigned int ino_count = READ_ONCE(ino->count);

			/* allow for dget above and top is already dgot */
			if (p == top)
				ino_count += 2;
			else
				ino_count++;

			if (d_count(p) > ino_count) {
				top_ino->last_used = jiffies;
				dput(p);
				return 1;
			}
		}
	}

	/* Forced expire, user space handles busy mounts */
	if (how & AUTOFS_EXP_FORCED)
		return 0;

	/* Timeout of a tree mount is ultimately determined by its top dentry */
	if (!autofs_can_expire(top, timeout, how))
		return 1;

	return 0;
}

static struct dentry *autofs_check_leaves(struct vfsmount *mnt,
					  struct dentry *parent,
					  unsigned long timeout,
					  unsigned int how)
{
	struct dentry *p;

	pr_debug("parent %p %pd\n", parent, parent);

	p = NULL;
	while ((p = get_next_positive_dentry(p, parent))) {
		pr_debug("dentry %p %pd\n", p, p);

		if (d_mountpoint(p)) {
			/* Can we umount this guy */
			if (autofs_mount_busy(mnt, p, how))
				continue;

			/* This isn't a submount so if a forced expire
			 * has been requested, user space handles busy
			 * mounts */
			if (how & AUTOFS_EXP_FORCED)
				return p;

			/* Can we expire this guy */
			if (autofs_can_expire(p, timeout, how))
				return p;
		}
	}
	return NULL;
}

/* Check if we can expire a direct mount (possibly a tree) */
static struct dentry *autofs_expire_direct(struct super_block *sb,
					   struct vfsmount *mnt,
					   struct autofs_sb_info *sbi,
					   unsigned int how)
{
	struct dentry *root = dget(sb->s_root);
	struct autofs_info *ino;
	unsigned long timeout;

	if (!root)
		return NULL;

	timeout = sbi->exp_timeout;

	if (!autofs_direct_busy(mnt, root, timeout, how)) {
		spin_lock(&sbi->fs_lock);
		ino = autofs_dentry_ino(root);
		/* No point expiring a pending mount */
		if (ino->flags & AUTOFS_INF_PENDING) {
			spin_unlock(&sbi->fs_lock);
			goto out;
		}
		ino->flags |= AUTOFS_INF_WANT_EXPIRE;
		spin_unlock(&sbi->fs_lock);
		synchronize_rcu();
		if (!autofs_direct_busy(mnt, root, timeout, how)) {
			spin_lock(&sbi->fs_lock);
			ino->flags |= AUTOFS_INF_EXPIRING;
			init_completion(&ino->expire_complete);
			spin_unlock(&sbi->fs_lock);
			return root;
		}
		spin_lock(&sbi->fs_lock);
		ino->flags &= ~AUTOFS_INF_WANT_EXPIRE;
		spin_unlock(&sbi->fs_lock);
	}
out:
	dput(root);

	return NULL;
}

/* Check if 'dentry' should expire, or return a nearby
 * dentry that is suitable.
 * If returned dentry is different from arg dentry,
 * then a dget() reference was taken, else not.
 */
static struct dentry *should_expire(struct dentry *dentry,
				    struct vfsmount *mnt,
				    unsigned long timeout,
				    unsigned int how)
{
	struct autofs_info *ino = autofs_dentry_ino(dentry);
	unsigned int ino_count;

	/* No point expiring a pending mount */
	if (ino->flags & AUTOFS_INF_PENDING)
		return NULL;

	/*
	 * Case 1: (i) indirect mount or top level pseudo direct mount
	 *	   (autofs-4.1).
	 *	   (ii) indirect mount with offset mount, check the "/"
	 *	   offset (autofs-5.0+).
	 */
	if (d_mountpoint(dentry)) {
		pr_debug("checking mountpoint %p %pd\n", dentry, dentry);

		/* Can we umount this guy */
		if (autofs_mount_busy(mnt, dentry, how))
			return NULL;

		/* This isn't a submount so if a forced expire
		 * has been requested, user space handles busy
		 * mounts */
		if (how & AUTOFS_EXP_FORCED)
			return dentry;

		/* Can we expire this guy */
		if (autofs_can_expire(dentry, timeout, how))
			return dentry;
		return NULL;
	}

	if (d_is_symlink(dentry)) {
		pr_debug("checking symlink %p %pd\n", dentry, dentry);

		/* Forced expire, user space handles busy mounts */
		if (how & AUTOFS_EXP_FORCED)
			return dentry;

		/*
		 * A symlink can't be "busy" in the usual sense so
		 * just check last used for expire timeout.
		 */
		if (autofs_can_expire(dentry, timeout, how))
			return dentry;
		return NULL;
	}

	if (autofs_empty(ino))
		return NULL;

	/* Case 2: tree mount, expire iff entire tree is not busy */
	if (!(how & AUTOFS_EXP_LEAVES)) {
		/* Not a forced expire? */
		if (!(how & AUTOFS_EXP_FORCED)) {
			/* ref-walk currently on this dentry? */
			ino_count = READ_ONCE(ino->count) + 1;
			if (d_count(dentry) > ino_count)
				return NULL;
		}

		if (!autofs_tree_busy(mnt, dentry, timeout, how))
			return dentry;
	/*
	 * Case 3: pseudo direct mount, expire individual leaves
	 *	   (autofs-4.1).
	 */
	} else {
		struct dentry *expired;

		/* Not a forced expire? */
		if (!(how & AUTOFS_EXP_FORCED)) {
			/* ref-walk currently on this dentry? */
			ino_count = READ_ONCE(ino->count) + 1;
			if (d_count(dentry) > ino_count)
				return NULL;
		}

		expired = autofs_check_leaves(mnt, dentry, timeout, how);
		if (expired) {
			if (expired == dentry)
				dput(dentry);
			return expired;
		}
	}
	return NULL;
}

/*
 * Find an eligible tree to time-out
 * A tree is eligible if :-
 *  - it is unused by any user process
 *  - it has been unused for exp_timeout time
 */
static struct dentry *autofs_expire_indirect(struct super_block *sb,
					     struct vfsmount *mnt,
					     struct autofs_sb_info *sbi,
					     unsigned int how)
{
	unsigned long timeout;
	struct dentry *root = sb->s_root;
	struct dentry *dentry;
	struct dentry *expired;
	struct dentry *found;
	struct autofs_info *ino;

	if (!root)
		return NULL;

	timeout = sbi->exp_timeout;

	dentry = NULL;
	while ((dentry = get_next_positive_subdir(dentry, root))) {
		spin_lock(&sbi->fs_lock);
		ino = autofs_dentry_ino(dentry);
		if (ino->flags & AUTOFS_INF_WANT_EXPIRE) {
			spin_unlock(&sbi->fs_lock);
			continue;
		}
		spin_unlock(&sbi->fs_lock);

		expired = should_expire(dentry, mnt, timeout, how);
		if (!expired)
			continue;

		spin_lock(&sbi->fs_lock);
		ino = autofs_dentry_ino(expired);
		ino->flags |= AUTOFS_INF_WANT_EXPIRE;
		spin_unlock(&sbi->fs_lock);
		synchronize_rcu();

		/* Make sure a reference is not taken on found if
		 * things have changed.
		 */
		how &= ~AUTOFS_EXP_LEAVES;
		found = should_expire(expired, mnt, timeout, how);
		if (found != expired) { // something has changed, continue
			dput(found);
			goto next;
		}

		if (expired != dentry)
			dput(dentry);

		spin_lock(&sbi->fs_lock);
		goto found;
next:
		spin_lock(&sbi->fs_lock);
		ino->flags &= ~AUTOFS_INF_WANT_EXPIRE;
		spin_unlock(&sbi->fs_lock);
		if (expired != dentry)
			dput(expired);
	}
	return NULL;

found:
	pr_debug("returning %p %pd\n", expired, expired);
	ino->flags |= AUTOFS_INF_EXPIRING;
	init_completion(&ino->expire_complete);
	spin_unlock(&sbi->fs_lock);
	return expired;
}

int autofs_expire_wait(const struct path *path, int rcu_walk)
{
	struct dentry *dentry = path->dentry;
	struct autofs_sb_info *sbi = autofs_sbi(dentry->d_sb);
	struct autofs_info *ino = autofs_dentry_ino(dentry);
	int status;
	int state;

	/* Block on any pending expire */
	if (!(ino->flags & AUTOFS_INF_WANT_EXPIRE))
		return 0;
	if (rcu_walk)
		return -ECHILD;

retry:
	spin_lock(&sbi->fs_lock);
	state = ino->flags & (AUTOFS_INF_WANT_EXPIRE | AUTOFS_INF_EXPIRING);
	if (state == AUTOFS_INF_WANT_EXPIRE) {
		spin_unlock(&sbi->fs_lock);
		/*
		 * Possibly being selected for expire, wait until
		 * it's selected or not.
		 */
		schedule_timeout_uninterruptible(HZ/10);
		goto retry;
	}
	if (state & AUTOFS_INF_EXPIRING) {
		spin_unlock(&sbi->fs_lock);

		pr_debug("waiting for expire %p name=%pd\n", dentry, dentry);

		status = autofs_wait(sbi, path, NFY_NONE);
		wait_for_completion(&ino->expire_complete);

		pr_debug("expire done status=%d\n", status);

		if (d_unhashed(dentry))
			return -EAGAIN;

		return status;
	}
	spin_unlock(&sbi->fs_lock);

	return 0;
}

/* Perform an expiry operation */
int autofs_expire_run(struct super_block *sb,
		      struct vfsmount *mnt,
		      struct autofs_sb_info *sbi,
		      struct autofs_packet_expire __user *pkt_p)
{
	struct autofs_packet_expire pkt;
	struct autofs_info *ino;
	struct dentry *dentry;
	int ret = 0;

	memset(&pkt, 0, sizeof(pkt));

	pkt.hdr.proto_version = sbi->version;
	pkt.hdr.type = autofs_ptype_expire;

	dentry = autofs_expire_indirect(sb, mnt, sbi, 0);
	if (!dentry)
		return -EAGAIN;

	pkt.len = dentry->d_name.len;
	memcpy(pkt.name, dentry->d_name.name, pkt.len);
	pkt.name[pkt.len] = '\0';

	if (copy_to_user(pkt_p, &pkt, sizeof(struct autofs_packet_expire)))
		ret = -EFAULT;

	spin_lock(&sbi->fs_lock);
	ino = autofs_dentry_ino(dentry);
	/* avoid rapid-fire expire attempts if expiry fails */
	ino->last_used = jiffies;
	ino->flags &= ~(AUTOFS_INF_EXPIRING|AUTOFS_INF_WANT_EXPIRE);
	complete_all(&ino->expire_complete);
	spin_unlock(&sbi->fs_lock);

	dput(dentry);

	return ret;
}

int autofs_do_expire_multi(struct super_block *sb, struct vfsmount *mnt,
			   struct autofs_sb_info *sbi, unsigned int how)
{
	struct dentry *dentry;
	int ret = -EAGAIN;

	if (autofs_type_trigger(sbi->type))
		dentry = autofs_expire_direct(sb, mnt, sbi, how);
	else
		dentry = autofs_expire_indirect(sb, mnt, sbi, how);

	if (dentry) {
		struct autofs_info *ino = autofs_dentry_ino(dentry);
		const struct path path = { .mnt = mnt, .dentry = dentry };

		/* This is synchronous because it makes the daemon a
		 * little easier
		 */
		ret = autofs_wait(sbi, &path, NFY_EXPIRE);

		spin_lock(&sbi->fs_lock);
		/* avoid rapid-fire expire attempts if expiry fails */
		ino->last_used = jiffies;
		ino->flags &= ~(AUTOFS_INF_EXPIRING|AUTOFS_INF_WANT_EXPIRE);
		complete_all(&ino->expire_complete);
		spin_unlock(&sbi->fs_lock);
		dput(dentry);
	}

	return ret;
}

/*
 * Call repeatedly until it returns -EAGAIN, meaning there's nothing
 * more to be done.
 */
int autofs_expire_multi(struct super_block *sb, struct vfsmount *mnt,
			struct autofs_sb_info *sbi, int __user *arg)
{
	unsigned int how = 0;

	if (arg && get_user(how, arg))
		return -EFAULT;

	return autofs_do_expire_multi(sb, mnt, sbi, how);
}
Commit	Line	Data
d6910058	1	// SPDX-License-Identifier: GPL-2.0-or-later
ebc921ca IK	2	/*
	3	* Copyright 1997-1998 Transmeta Corporation -- All Rights Reserved
	4	* Copyright 1999-2000 Jeremy Fitzhardinge <jeremy@goop.org>
	5	* Copyright 2001-2006 Ian Kent <raven@themaw.net>
ebc921ca IK	6	*/
	7
	8	#include "autofs_i.h"
	9
ebc921ca IK	10	/* Check if a dentry can be expired */
ebc921ca IK	11	static inline int autofs_can_expire(struct dentry *dentry,
e5c85e1f	12	unsigned long timeout, unsigned int how)
ebc921ca IK	13	{
	14	struct autofs_info *ino = autofs_dentry_ino(dentry);
	15
	16	/* dentry in the process of being deleted */
	17	if (ino == NULL)
	18	return 0;
	19
e5c85e1f	20	if (!(how & AUTOFS_EXP_IMMEDIATE)) {
ebc921ca	21	/* Too young to die */
2fd9944f	22	if (!timeout \|\| time_after(ino->last_used + timeout, jiffies))
ebc921ca IK	23	return 0;
	24	}
	25	return 1;
	26	}
	27
	28	/* Check a mount point for busyness */
cbf6898f IK	29	static int autofs_mount_busy(struct vfsmount *mnt,
cbf6898f IK	30	struct dentry *dentry, unsigned int how)
ebc921ca IK	31	{
	32	struct dentry *top = dentry;
	33	struct path path = {.mnt = mnt, .dentry = dentry};
	34	int status = 1;
	35
	36	pr_debug("dentry %p %pd\n", dentry, dentry);
	37
	38	path_get(&path);
	39
	40	if (!follow_down_one(&path))
	41	goto done;
	42
	43	if (is_autofs_dentry(path.dentry)) {
	44	struct autofs_sb_info *sbi = autofs_sbi(path.dentry->d_sb);
	45
	46	/* This is an autofs submount, we can't expire it */
	47	if (autofs_type_indirect(sbi->type))
	48	goto done;
	49	}
	50
cbf6898f IK	51	/* Not a submount, has a forced expire been requested */
	52	if (how & AUTOFS_EXP_FORCED) {
	53	status = 0;
	54	goto done;
	55	}
	56
ebc921ca IK	57	/* Update the expiry counter if fs is busy */
	58	if (!may_umount_tree(path.mnt)) {
	59	struct autofs_info *ino;
	60
	61	ino = autofs_dentry_ino(top);
	62	ino->last_used = jiffies;
	63	goto done;
	64	}
	65
	66	status = 0;
	67	done:
	68	pr_debug("returning = %d\n", status);
	69	path_put(&path);
	70	return status;
	71	}
	72
ff09297e AV	73	/* p->d_lock held */
	74	static struct dentry positive_after(struct dentry p, struct dentry *child)
	75	{
	76	if (child)
	77	child = list_next_entry(child, d_child);
	78	else
	79	child = list_first_entry(&p->d_subdirs, struct dentry, d_child);
	80
	81	list_for_each_entry_from(child, &p->d_subdirs, d_child) {
	82	spin_lock_nested(&child->d_lock, DENTRY_D_LOCK_NESTED);
	83	if (simple_positive(child)) {
	84	dget_dlock(child);
	85	spin_unlock(&child->d_lock);
	86	return child;
	87	}
	88	spin_unlock(&child->d_lock);
	89	}
	90
	91	return NULL;
	92	}
	93
ebc921ca IK	94	/*
	95	* Calculate and dget next entry in the subdirs list under root.
	96	*/
	97	static struct dentry get_next_positive_subdir(struct dentry prev,
	98	struct dentry *root)
	99	{
	100	struct autofs_sb_info *sbi = autofs_sbi(root->d_sb);
ebc921ca IK	101	struct dentry *q;
	102
	103	spin_lock(&sbi->lookup_lock);
	104	spin_lock(&root->d_lock);
ff09297e	105	q = positive_after(root, prev);
ebc921ca IK	106	spin_unlock(&root->d_lock);
ebc921ca IK	107	spin_unlock(&sbi->lookup_lock);
ebc921ca	108	dput(prev);
ebc921ca IK	109	return q;
	110	}
	111
	112	/*
	113	* Calculate and dget next entry in top down tree traversal.
	114	*/
	115	static struct dentry get_next_positive_dentry(struct dentry prev,
	116	struct dentry *root)
	117	{
	118	struct autofs_sb_info *sbi = autofs_sbi(root->d_sb);
ff09297e	119	struct dentry p = prev, ret = NULL, *d = NULL;
ebc921ca IK	120
	121	if (prev == NULL)
	122	return dget(root);
	123
	124	spin_lock(&sbi->lookup_lock);
ebc921ca	125	spin_lock(&p->d_lock);
ff09297e AV	126	while (1) {
ff09297e AV	127	struct dentry *parent;
ebc921ca	128
ff09297e AV	129	ret = positive_after(p, d);
	130	if (ret \|\| p == root)
	131	break;
	132	parent = p->d_parent;
ebc921ca	133	spin_unlock(&p->d_lock);
ff09297e AV	134	spin_lock(&parent->d_lock);
	135	d = p;
	136	p = parent;
ebc921ca	137	}
ebc921ca IK	138	spin_unlock(&p->d_lock);
ebc921ca IK	139	spin_unlock(&sbi->lookup_lock);
ebc921ca	140	dput(prev);
ebc921ca IK	141	return ret;
	142	}
	143
	144	/*
	145	* Check a direct mount point for busyness.
	146	* Direct mounts have similar expiry semantics to tree mounts.
	147	* The tree is not busy iff no mountpoints are busy and there are no
	148	* autofs submounts.
	149	*/
	150	static int autofs_direct_busy(struct vfsmount *mnt,
	151	struct dentry *top,
	152	unsigned long timeout,
e5c85e1f	153	unsigned int how)
ebc921ca IK	154	{
	155	pr_debug("top %p %pd\n", top, top);
	156
cbf6898f IK	157	/* Forced expire, user space handles busy mounts */
	158	if (how & AUTOFS_EXP_FORCED)
	159	return 0;
	160
ebc921ca IK	161	/* If it's busy update the expiry counters */
	162	if (!may_umount_tree(mnt)) {
	163	struct autofs_info *ino;
	164
	165	ino = autofs_dentry_ino(top);
	166	if (ino)
	167	ino->last_used = jiffies;
	168	return 1;
	169	}
	170
	171	/* Timeout of a direct mount is determined by its top dentry */
e5c85e1f	172	if (!autofs_can_expire(top, timeout, how))
ebc921ca IK	173	return 1;
	174
	175	return 0;
	176	}
	177
	178	/*
	179	* Check a directory tree of mount points for busyness
	180	* The tree is not busy iff no mountpoints are busy
	181	*/
	182	static int autofs_tree_busy(struct vfsmount *mnt,
	183	struct dentry *top,
	184	unsigned long timeout,
e5c85e1f	185	unsigned int how)
ebc921ca IK	186	{
	187	struct autofs_info *top_ino = autofs_dentry_ino(top);
	188	struct dentry *p;
	189
	190	pr_debug("top %p %pd\n", top, top);
	191
	192	/* Negative dentry - give up */
	193	if (!simple_positive(top))
	194	return 1;
	195
	196	p = NULL;
	197	while ((p = get_next_positive_dentry(p, top))) {
	198	pr_debug("dentry %p %pd\n", p, p);
	199
	200	/*
	201	* Is someone visiting anywhere in the subtree ?
	202	* If there's no mount we need to check the usage
	203	* count for the autofs dentry.
	204	* If the fs is busy update the expiry counter.
	205	*/
	206	if (d_mountpoint(p)) {
cbf6898f	207	if (autofs_mount_busy(mnt, p, how)) {
ebc921ca IK	208	top_ino->last_used = jiffies;
	209	dput(p);
	210	return 1;
	211	}
	212	} else {
	213	struct autofs_info *ino = autofs_dentry_ino(p);
850d71ac	214	unsigned int ino_count = READ_ONCE(ino->count);
ebc921ca IK	215
	216	/* allow for dget above and top is already dgot */
	217	if (p == top)
	218	ino_count += 2;
	219	else
	220	ino_count++;
	221
	222	if (d_count(p) > ino_count) {
	223	top_ino->last_used = jiffies;
	224	dput(p);
	225	return 1;
	226	}
	227	}
	228	}
	229
cbf6898f IK	230	/* Forced expire, user space handles busy mounts */
	231	if (how & AUTOFS_EXP_FORCED)
	232	return 0;
	233
ebc921ca	234	/* Timeout of a tree mount is ultimately determined by its top dentry */
e5c85e1f	235	if (!autofs_can_expire(top, timeout, how))
ebc921ca IK	236	return 1;
	237
	238	return 0;
	239	}
	240
	241	static struct dentry autofs_check_leaves(struct vfsmount mnt,
	242	struct dentry *parent,
	243	unsigned long timeout,
e5c85e1f	244	unsigned int how)
ebc921ca IK	245	{
	246	struct dentry *p;
	247
	248	pr_debug("parent %p %pd\n", parent, parent);
	249
	250	p = NULL;
	251	while ((p = get_next_positive_dentry(p, parent))) {
	252	pr_debug("dentry %p %pd\n", p, p);
	253
	254	if (d_mountpoint(p)) {
	255	/* Can we umount this guy */
cbf6898f	256	if (autofs_mount_busy(mnt, p, how))
ebc921ca IK	257	continue;
ebc921ca IK	258
cbf6898f IK	259	/* This isn't a submount so if a forced expire
	260	* has been requested, user space handles busy
	261	* mounts */
	262	if (how & AUTOFS_EXP_FORCED)
	263	return p;
	264
ebc921ca	265	/* Can we expire this guy */
e5c85e1f	266	if (autofs_can_expire(p, timeout, how))
ebc921ca IK	267	return p;
	268	}
	269	}
	270	return NULL;
	271	}
	272
	273	/* Check if we can expire a direct mount (possibly a tree) */
5d30517d IK	274	static struct dentry autofs_expire_direct(struct super_block sb,
	275	struct vfsmount *mnt,
	276	struct autofs_sb_info *sbi,
e5c85e1f	277	unsigned int how)
ebc921ca	278	{
ebc921ca	279	struct dentry *root = dget(sb->s_root);
ebc921ca	280	struct autofs_info *ino;
e5c85e1f	281	unsigned long timeout;
ebc921ca IK	282
	283	if (!root)
	284	return NULL;
	285
ebc921ca IK	286	timeout = sbi->exp_timeout;
ebc921ca IK	287
e5c85e1f	288	if (!autofs_direct_busy(mnt, root, timeout, how)) {
ebc921ca IK	289	spin_lock(&sbi->fs_lock);
	290	ino = autofs_dentry_ino(root);
	291	/* No point expiring a pending mount */
	292	if (ino->flags & AUTOFS_INF_PENDING) {
	293	spin_unlock(&sbi->fs_lock);
	294	goto out;
	295	}
	296	ino->flags \|= AUTOFS_INF_WANT_EXPIRE;
	297	spin_unlock(&sbi->fs_lock);
	298	synchronize_rcu();
e5c85e1f	299	if (!autofs_direct_busy(mnt, root, timeout, how)) {
ebc921ca IK	300	spin_lock(&sbi->fs_lock);
	301	ino->flags \|= AUTOFS_INF_EXPIRING;
	302	init_completion(&ino->expire_complete);
	303	spin_unlock(&sbi->fs_lock);
	304	return root;
	305	}
	306	spin_lock(&sbi->fs_lock);
	307	ino->flags &= ~AUTOFS_INF_WANT_EXPIRE;
	308	spin_unlock(&sbi->fs_lock);
	309	}
	310	out:
	311	dput(root);
	312
	313	return NULL;
	314	}
	315
	316	/* Check if 'dentry' should expire, or return a nearby
	317	* dentry that is suitable.
	318	* If returned dentry is different from arg dentry,
	319	* then a dget() reference was taken, else not.
	320	*/
	321	static struct dentry should_expire(struct dentry dentry,
	322	struct vfsmount *mnt,
	323	unsigned long timeout,
e5c85e1f	324	unsigned int how)
ebc921ca	325	{
ebc921ca IK	326	struct autofs_info *ino = autofs_dentry_ino(dentry);
	327	unsigned int ino_count;
	328
	329	/* No point expiring a pending mount */
	330	if (ino->flags & AUTOFS_INF_PENDING)
	331	return NULL;
	332
	333	/*
	334	* Case 1: (i) indirect mount or top level pseudo direct mount
	335	* (autofs-4.1).
	336	* (ii) indirect mount with offset mount, check the "/"
	337	* offset (autofs-5.0+).
	338	*/
	339	if (d_mountpoint(dentry)) {
	340	pr_debug("checking mountpoint %p %pd\n", dentry, dentry);
	341
	342	/* Can we umount this guy */
cbf6898f	343	if (autofs_mount_busy(mnt, dentry, how))
ebc921ca IK	344	return NULL;
ebc921ca IK	345
cbf6898f IK	346	/* This isn't a submount so if a forced expire
	347	* has been requested, user space handles busy
	348	* mounts */
	349	if (how & AUTOFS_EXP_FORCED)
	350	return dentry;
	351
ebc921ca	352	/* Can we expire this guy */
e5c85e1f	353	if (autofs_can_expire(dentry, timeout, how))
ebc921ca IK	354	return dentry;
	355	return NULL;
	356	}
	357
eecf77e0	358	if (d_is_symlink(dentry)) {
ebc921ca	359	pr_debug("checking symlink %p %pd\n", dentry, dentry);
cbf6898f IK	360
	361	/* Forced expire, user space handles busy mounts */
	362	if (how & AUTOFS_EXP_FORCED)
	363	return dentry;
	364
ebc921ca IK	365	/*
	366	* A symlink can't be "busy" in the usual sense so
	367	* just check last used for expire timeout.
	368	*/
e5c85e1f	369	if (autofs_can_expire(dentry, timeout, how))
ebc921ca IK	370	return dentry;
	371	return NULL;
	372	}
	373
a4a87303	374	if (autofs_empty(ino))
ebc921ca IK	375	return NULL;
	376
	377	/* Case 2: tree mount, expire iff entire tree is not busy */
e5c85e1f	378	if (!(how & AUTOFS_EXP_LEAVES)) {
cbf6898f IK	379	/* Not a forced expire? */
	380	if (!(how & AUTOFS_EXP_FORCED)) {
	381	/* ref-walk currently on this dentry? */
850d71ac	382	ino_count = READ_ONCE(ino->count) + 1;
cbf6898f IK	383	if (d_count(dentry) > ino_count)
	384	return NULL;
	385	}
ebc921ca	386
e5c85e1f	387	if (!autofs_tree_busy(mnt, dentry, timeout, how))
ebc921ca IK	388	return dentry;
	389	/*
	390	* Case 3: pseudo direct mount, expire individual leaves
	391	* (autofs-4.1).
	392	*/
	393	} else {
ebc921ca IK	394	struct dentry *expired;
ebc921ca IK	395
cbf6898f IK	396	/* Not a forced expire? */
	397	if (!(how & AUTOFS_EXP_FORCED)) {
	398	/* ref-walk currently on this dentry? */
850d71ac	399	ino_count = READ_ONCE(ino->count) + 1;
cbf6898f IK	400	if (d_count(dentry) > ino_count)
	401	return NULL;
	402	}
ebc921ca	403
e5c85e1f	404	expired = autofs_check_leaves(mnt, dentry, timeout, how);
ebc921ca IK	405	if (expired) {
	406	if (expired == dentry)
	407	dput(dentry);
	408	return expired;
	409	}
	410	}
	411	return NULL;
	412	}
	413
	414	/*
	415	* Find an eligible tree to time-out
	416	* A tree is eligible if :-
	417	* - it is unused by any user process
	418	* - it has been unused for exp_timeout time
	419	*/
571bc35c IK	420	static struct dentry autofs_expire_indirect(struct super_block sb,
	421	struct vfsmount *mnt,
	422	struct autofs_sb_info *sbi,
e5c85e1f	423	unsigned int how)
ebc921ca IK	424	{
	425	unsigned long timeout;
	426	struct dentry *root = sb->s_root;
	427	struct dentry *dentry;
	428	struct dentry *expired;
	429	struct dentry *found;
	430	struct autofs_info *ino;
	431
	432	if (!root)
	433	return NULL;
	434
ebc921ca IK	435	timeout = sbi->exp_timeout;
	436
	437	dentry = NULL;
	438	while ((dentry = get_next_positive_subdir(dentry, root))) {
ebc921ca IK	439	spin_lock(&sbi->fs_lock);
	440	ino = autofs_dentry_ino(dentry);
	441	if (ino->flags & AUTOFS_INF_WANT_EXPIRE) {
	442	spin_unlock(&sbi->fs_lock);
	443	continue;
	444	}
	445	spin_unlock(&sbi->fs_lock);
	446
e5c85e1f	447	expired = should_expire(dentry, mnt, timeout, how);
ebc921ca IK	448	if (!expired)
	449	continue;
	450
	451	spin_lock(&sbi->fs_lock);
	452	ino = autofs_dentry_ino(expired);
	453	ino->flags \|= AUTOFS_INF_WANT_EXPIRE;
	454	spin_unlock(&sbi->fs_lock);
	455	synchronize_rcu();
	456
	457	/* Make sure a reference is not taken on found if
	458	* things have changed.
	459	*/
e5c85e1f IK	460	how &= ~AUTOFS_EXP_LEAVES;
e5c85e1f IK	461	found = should_expire(expired, mnt, timeout, how);
03ad0d70 AV	462	if (found != expired) { // something has changed, continue
03ad0d70 AV	463	dput(found);
ebc921ca	464	goto next;
03ad0d70	465	}
ebc921ca IK	466
	467	if (expired != dentry)
	468	dput(dentry);
	469
	470	spin_lock(&sbi->fs_lock);
	471	goto found;
	472	next:
	473	spin_lock(&sbi->fs_lock);
	474	ino->flags &= ~AUTOFS_INF_WANT_EXPIRE;
	475	spin_unlock(&sbi->fs_lock);
	476	if (expired != dentry)
	477	dput(expired);
	478	}
	479	return NULL;
	480
	481	found:
	482	pr_debug("returning %p %pd\n", expired, expired);
	483	ino->flags \|= AUTOFS_INF_EXPIRING;
	484	init_completion(&ino->expire_complete);
	485	spin_unlock(&sbi->fs_lock);
	486	return expired;
	487	}
	488
	489	int autofs_expire_wait(const struct path *path, int rcu_walk)
	490	{
	491	struct dentry *dentry = path->dentry;
	492	struct autofs_sb_info *sbi = autofs_sbi(dentry->d_sb);
	493	struct autofs_info *ino = autofs_dentry_ino(dentry);
	494	int status;
	495	int state;
	496
	497	/* Block on any pending expire */
	498	if (!(ino->flags & AUTOFS_INF_WANT_EXPIRE))
	499	return 0;
	500	if (rcu_walk)
	501	return -ECHILD;
	502
	503	retry:
	504	spin_lock(&sbi->fs_lock);
	505	state = ino->flags & (AUTOFS_INF_WANT_EXPIRE \| AUTOFS_INF_EXPIRING);
	506	if (state == AUTOFS_INF_WANT_EXPIRE) {
	507	spin_unlock(&sbi->fs_lock);
	508	/*
	509	* Possibly being selected for expire, wait until
	510	* it's selected or not.
	511	*/
	512	schedule_timeout_uninterruptible(HZ/10);
	513	goto retry;
	514	}
	515	if (state & AUTOFS_INF_EXPIRING) {
	516	spin_unlock(&sbi->fs_lock);
	517
	518	pr_debug("waiting for expire %p name=%pd\n", dentry, dentry);
	519
	520	status = autofs_wait(sbi, path, NFY_NONE);
	521	wait_for_completion(&ino->expire_complete);
	522
	523	pr_debug("expire done status=%d\n", status);
	524
	525	if (d_unhashed(dentry))
	526	return -EAGAIN;
	527
	528	return status;
	529	}
530	spin_unlock(&sbi->fs_lock);
531
532	return 0;
533	}
534
535	/* Perform an expiry operation */
536	int autofs_expire_run(struct super_block *sb,
537	struct vfsmount *mnt,
538	struct autofs_sb_info *sbi,
539	struct autofs_packet_expire __user *pkt_p)
540	{
541	struct autofs_packet_expire pkt;
542	struct autofs_info *ino;
543	struct dentry *dentry;
544	int ret = 0;
545
546	memset(&pkt, 0, sizeof(pkt));
547
548	pkt.hdr.proto_version = sbi->version;
549	pkt.hdr.type = autofs_ptype_expire;
550
551	dentry = autofs_expire_indirect(sb, mnt, sbi, 0);
552	if (!dentry)
553	return -EAGAIN;
554
555	pkt.len = dentry->d_name.len;
556	memcpy(pkt.name, dentry->d_name.name, pkt.len);
557	pkt.name[pkt.len] = '\0';
ebc921ca IK	558
	559	if (copy_to_user(pkt_p, &pkt, sizeof(struct autofs_packet_expire)))
	560	ret = -EFAULT;
	561
	562	spin_lock(&sbi->fs_lock);
	563	ino = autofs_dentry_ino(dentry);
	564	/* avoid rapid-fire expire attempts if expiry fails */
2fd9944f	565	ino->last_used = jiffies;
ebc921ca IK	566	ino->flags &= ~(AUTOFS_INF_EXPIRING\|AUTOFS_INF_WANT_EXPIRE);
	567	complete_all(&ino->expire_complete);
	568	spin_unlock(&sbi->fs_lock);
	569
63ce5f55 PB	570	dput(dentry);
63ce5f55 PB	571
ebc921ca IK	572	return ret;
	573	}
	574
	575	int autofs_do_expire_multi(struct super_block sb, struct vfsmount mnt,
e5c85e1f	576	struct autofs_sb_info *sbi, unsigned int how)
ebc921ca IK	577	{
	578	struct dentry *dentry;
	579	int ret = -EAGAIN;
	580
	581	if (autofs_type_trigger(sbi->type))
e5c85e1f	582	dentry = autofs_expire_direct(sb, mnt, sbi, how);
ebc921ca	583	else
e5c85e1f	584	dentry = autofs_expire_indirect(sb, mnt, sbi, how);
ebc921ca IK	585
	586	if (dentry) {
	587	struct autofs_info *ino = autofs_dentry_ino(dentry);
	588	const struct path path = { .mnt = mnt, .dentry = dentry };
	589
	590	/* This is synchronous because it makes the daemon a
	591	* little easier
	592	*/
	593	ret = autofs_wait(sbi, &path, NFY_EXPIRE);
	594
	595	spin_lock(&sbi->fs_lock);
	596	/* avoid rapid-fire expire attempts if expiry fails */
2fd9944f	597	ino->last_used = jiffies;
ebc921ca IK	598	ino->flags &= ~(AUTOFS_INF_EXPIRING\|AUTOFS_INF_WANT_EXPIRE);
	599	complete_all(&ino->expire_complete);
	600	spin_unlock(&sbi->fs_lock);
	601	dput(dentry);
	602	}
	603
	604	return ret;
	605	}
	606
	607	/*
	608	* Call repeatedly until it returns -EAGAIN, meaning there's nothing
	609	* more to be done.
	610	*/
	611	int autofs_expire_multi(struct super_block sb, struct vfsmount mnt,
	612	struct autofs_sb_info sbi, int __user arg)
	613	{
e5c85e1f	614	unsigned int how = 0;
ebc921ca	615
e5c85e1f	616	if (arg && get_user(how, arg))
ebc921ca IK	617	return -EFAULT;
ebc921ca IK	618
e5c85e1f	619	return autofs_do_expire_multi(sb, mnt, sbi, how);
ebc921ca	620	}