expire.c 10.6 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6
/* -*- c -*- --------------------------------------------------------------- *
 *
 * linux/fs/autofs/expire.c
 *
 *  Copyright 1997-1998 Transmeta Corporation -- All Rights Reserved
 *  Copyright 1999-2000 Jeremy Fitzhardinge <jeremy@goop.org>
I
Ian Kent 已提交
7
 *  Copyright 2001-2006 Ian Kent <raven@themaw.net>
L
Linus Torvalds 已提交
8 9 10 11 12 13 14 15 16 17 18
 *
 * This file is part of the Linux kernel and is made available under
 * the terms of the GNU General Public License, version 2, or at your
 * option, any later version, incorporated herein by reference.
 *
 * ------------------------------------------------------------------------- */

#include "autofs_i.h"

static unsigned long now;

19
/* Check if a dentry can be expired */
L
Linus Torvalds 已提交
20 21 22 23 24 25 26 27 28 29 30 31 32 33 34
static inline int autofs4_can_expire(struct dentry *dentry,
					unsigned long timeout, int do_now)
{
	struct autofs_info *ino = autofs4_dentry_ino(dentry);

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

	/* No point expiring a pending mount */
	if (dentry->d_flags & DCACHE_AUTOFS_PENDING)
		return 0;

	if (!do_now) {
		/* Too young to die */
35
		if (!timeout || time_after(ino->last_used + timeout, now))
L
Linus Torvalds 已提交
36 37 38 39 40 41 42 43 44 45 46
			return 0;

		/* update last_used here :-
		   - obviously makes sense if it is in use now
		   - less obviously, prevents rapid-fire expire
		     attempts if expire fails the first time */
		ino->last_used = now;
	}
	return 1;
}

47 48
/* Check a mount point for busyness */
static int autofs4_mount_busy(struct vfsmount *mnt, struct dentry *dentry)
L
Linus Torvalds 已提交
49
{
50
	struct dentry *top = dentry;
51
	int status = 1;
L
Linus Torvalds 已提交
52 53 54 55 56 57 58

	DPRINTK("dentry %p %.*s",
		dentry, (int)dentry->d_name.len, dentry->d_name.name);

	mntget(mnt);
	dget(dentry);

59
	if (!autofs4_follow_mount(&mnt, &dentry))
L
Linus Torvalds 已提交
60 61 62 63 64 65
		goto done;

	/* This is an autofs submount, we can't expire it */
	if (is_autofs4_dentry(dentry))
		goto done;

66
	/* Update the expiry counter if fs is busy */
67
	if (!may_umount_tree(mnt)) {
68 69 70 71 72 73
		struct autofs_info *ino = autofs4_dentry_ino(top);
		ino->last_used = jiffies;
		goto done;
	}

	status = 0;
L
Linus Torvalds 已提交
74 75 76
done:
	DPRINTK("returning = %d", status);
	dput(dentry);
J
Jan Blunck 已提交
77
	mntput(mnt);
L
Linus Torvalds 已提交
78 79 80
	return status;
}

81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101
/*
 * Calculate next entry in top down tree traversal.
 * From next_mnt in namespace.c - elegant.
 */
static struct dentry *next_dentry(struct dentry *p, struct dentry *root)
{
	struct list_head *next = p->d_subdirs.next;

	if (next == &p->d_subdirs) {
		while (1) {
			if (p == root)
				return NULL;
			next = p->d_u.d_child.next;
			if (next != &p->d_parent->d_subdirs)
				break;
			p = p->d_parent;
		}
	}
	return list_entry(next, struct dentry, d_u.d_child);
}

I
Ian Kent 已提交
102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130
/*
 * 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 autofs4_direct_busy(struct vfsmount *mnt,
				struct dentry *top,
				unsigned long timeout,
				int do_now)
{
	DPRINTK("top %p %.*s",
		top, (int) top->d_name.len, top->d_name.name);

	/* If it's busy update the expiry counters */
	if (!may_umount_tree(mnt)) {
		struct autofs_info *ino = autofs4_dentry_ino(top);
		if (ino)
			ino->last_used = jiffies;
		return 1;
	}

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

	return 0;
}

L
Linus Torvalds 已提交
131 132 133
/* Check a directory tree of mount points for busyness
 * The tree is not busy iff no mountpoints are busy
 */
134 135 136 137
static int autofs4_tree_busy(struct vfsmount *mnt,
	       		     struct dentry *top,
			     unsigned long timeout,
			     int do_now)
L
Linus Torvalds 已提交
138
{
139
	struct autofs_info *top_ino = autofs4_dentry_ino(top);
140
	struct dentry *p;
L
Linus Torvalds 已提交
141

142
	DPRINTK("top %p %.*s",
L
Linus Torvalds 已提交
143 144 145 146
		top, (int)top->d_name.len, top->d_name.name);

	/* Negative dentry - give up */
	if (!simple_positive(top))
147
		return 1;
L
Linus Torvalds 已提交
148 149

	spin_lock(&dcache_lock);
150
	for (p = top; p; p = next_dentry(p, top)) {
L
Linus Torvalds 已提交
151
		/* Negative dentry - give up */
152
		if (!simple_positive(p))
L
Linus Torvalds 已提交
153 154 155
			continue;

		DPRINTK("dentry %p %.*s",
156
			p, (int) p->d_name.len, p->d_name.name);
L
Linus Torvalds 已提交
157

158
		p = dget(p);
L
Linus Torvalds 已提交
159 160
		spin_unlock(&dcache_lock);

161 162 163 164
		/*
		 * Is someone visiting anywhere in the subtree ?
		 * If there's no mount we need to check the usage
		 * count for the autofs dentry.
165
		 * If the fs is busy update the expiry counter.
166
		 */
167 168
		if (d_mountpoint(p)) {
			if (autofs4_mount_busy(mnt, p)) {
169
				top_ino->last_used = jiffies;
170
				dput(p);
171
				return 1;
L
Linus Torvalds 已提交
172
			}
173
		} else {
174
			struct autofs_info *ino = autofs4_dentry_ino(p);
175 176
			unsigned int ino_count = atomic_read(&ino->count);

177 178 179 180 181 182
			/*
			 * Clean stale dentries below that have not been
			 * invalidated after a mount fail during lookup
			 */
			d_invalidate(p);

183 184 185 186 187 188 189
			/* allow for dget above and top is already dgot */
			if (p == top)
				ino_count += 2;
			else
				ino_count++;

			if (atomic_read(&p->d_count) > ino_count) {
190
				top_ino->last_used = jiffies;
191 192 193
				dput(p);
				return 1;
			}
L
Linus Torvalds 已提交
194
		}
195
		dput(p);
L
Linus Torvalds 已提交
196 197 198
		spin_lock(&dcache_lock);
	}
	spin_unlock(&dcache_lock);
199 200 201 202 203

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

204
	return 0;
L
Linus Torvalds 已提交
205 206 207 208 209 210 211
}

static struct dentry *autofs4_check_leaves(struct vfsmount *mnt,
					   struct dentry *parent,
					   unsigned long timeout,
					   int do_now)
{
212
	struct dentry *p;
L
Linus Torvalds 已提交
213 214 215 216 217

	DPRINTK("parent %p %.*s",
		parent, (int)parent->d_name.len, parent->d_name.name);

	spin_lock(&dcache_lock);
218
	for (p = parent; p; p = next_dentry(p, parent)) {
L
Linus Torvalds 已提交
219
		/* Negative dentry - give up */
220
		if (!simple_positive(p))
L
Linus Torvalds 已提交
221 222 223
			continue;

		DPRINTK("dentry %p %.*s",
224
			p, (int) p->d_name.len, p->d_name.name);
L
Linus Torvalds 已提交
225

226
		p = dget(p);
L
Linus Torvalds 已提交
227 228
		spin_unlock(&dcache_lock);

229
		if (d_mountpoint(p)) {
230 231
			/* Can we umount this guy */
			if (autofs4_mount_busy(mnt, p))
L
Linus Torvalds 已提交
232 233
				goto cont;

234 235
			/* Can we expire this guy */
			if (autofs4_can_expire(p, timeout, do_now))
236
				return p;
L
Linus Torvalds 已提交
237 238
		}
cont:
239
		dput(p);
L
Linus Torvalds 已提交
240 241 242 243 244 245
		spin_lock(&dcache_lock);
	}
	spin_unlock(&dcache_lock);
	return NULL;
}

I
Ian Kent 已提交
246 247 248 249 250 251 252 253 254 255
/* Check if we can expire a direct mount (possibly a tree) */
static struct dentry *autofs4_expire_direct(struct super_block *sb,
					    struct vfsmount *mnt,
					    struct autofs_sb_info *sbi,
					    int how)
{
	unsigned long timeout;
	struct dentry *root = dget(sb->s_root);
	int do_now = how & AUTOFS_EXP_IMMEDIATE;

256
	if (!root)
I
Ian Kent 已提交
257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277
		return NULL;

	now = jiffies;
	timeout = sbi->exp_timeout;

	/* Lock the tree as we must expire as a whole */
	spin_lock(&sbi->fs_lock);
	if (!autofs4_direct_busy(mnt, root, timeout, do_now)) {
		struct autofs_info *ino = autofs4_dentry_ino(root);

		/* Set this flag early to catch sys_chdir and the like */
		ino->flags |= AUTOFS_INF_EXPIRING;
		spin_unlock(&sbi->fs_lock);
		return root;
	}
	spin_unlock(&sbi->fs_lock);
	dput(root);

	return NULL;
}

L
Linus Torvalds 已提交
278 279 280 281 282 283
/*
 * 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
 */
I
Ian Kent 已提交
284 285 286 287
static struct dentry *autofs4_expire_indirect(struct super_block *sb,
					      struct vfsmount *mnt,
					      struct autofs_sb_info *sbi,
					      int how)
L
Linus Torvalds 已提交
288 289 290 291 292 293 294 295
{
	unsigned long timeout;
	struct dentry *root = sb->s_root;
	struct dentry *expired = NULL;
	struct list_head *next;
	int do_now = how & AUTOFS_EXP_IMMEDIATE;
	int exp_leaves = how & AUTOFS_EXP_LEAVES;

296
	if (!root)
L
Linus Torvalds 已提交
297 298 299 300 301 302 303 304 305 306 307
		return NULL;

	now = jiffies;
	timeout = sbi->exp_timeout;

	spin_lock(&dcache_lock);
	next = root->d_subdirs.next;

	/* On exit from the loop expire is set to a dgot dentry
	 * to expire or it's NULL */
	while ( next != &root->d_subdirs ) {
E
Eric Dumazet 已提交
308
		struct dentry *dentry = list_entry(next, struct dentry, d_u.d_child);
L
Linus Torvalds 已提交
309 310

		/* Negative dentry - give up */
311
		if (!simple_positive(dentry)) {
L
Linus Torvalds 已提交
312 313 314 315 316 317 318
			next = next->next;
			continue;
		}

		dentry = dget(dentry);
		spin_unlock(&dcache_lock);

I
Ian Kent 已提交
319 320 321 322 323 324
		/*
		 * 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+).
		 */
L
Linus Torvalds 已提交
325 326 327 328
		if (d_mountpoint(dentry)) {
			DPRINTK("checking mountpoint %p %.*s",
				dentry, (int)dentry->d_name.len, dentry->d_name.name);

329 330
			/* Can we umount this guy */
			if (autofs4_mount_busy(mnt, dentry))
L
Linus Torvalds 已提交
331 332
				goto next;

333 334
			/* Can we expire this guy */
			if (autofs4_can_expire(dentry, timeout, do_now)) {
L
Linus Torvalds 已提交
335
				expired = dentry;
336
				goto found;
L
Linus Torvalds 已提交
337 338 339 340
			}
			goto next;
		}

341
		if (simple_empty(dentry))
L
Linus Torvalds 已提交
342 343 344 345
			goto next;

		/* Case 2: tree mount, expire iff entire tree is not busy */
		if (!exp_leaves) {
I
Ian Kent 已提交
346 347
			/* Lock the tree as we must expire as a whole */
			spin_lock(&sbi->fs_lock);
348
			if (!autofs4_tree_busy(mnt, dentry, timeout, do_now)) {
I
Ian Kent 已提交
349 350 351 352 353 354
				struct autofs_info *inf = autofs4_dentry_ino(dentry);

				/* Set this flag early to catch sys_chdir and the like */
				inf->flags |= AUTOFS_INF_EXPIRING;
				spin_unlock(&sbi->fs_lock);
				expired = dentry;
355
				goto found;
L
Linus Torvalds 已提交
356
			}
I
Ian Kent 已提交
357
			spin_unlock(&sbi->fs_lock);
I
Ian Kent 已提交
358 359 360 361
		/*
		 * Case 3: pseudo direct mount, expire individual leaves
		 *	   (autofs-4.1).
		 */
L
Linus Torvalds 已提交
362 363 364 365
		} else {
			expired = autofs4_check_leaves(mnt, dentry, timeout, do_now);
			if (expired) {
				dput(dentry);
366
				goto found;
L
Linus Torvalds 已提交
367 368 369 370 371 372 373 374 375
			}
		}
next:
		dput(dentry);
		spin_lock(&dcache_lock);
		next = next->next;
	}
	spin_unlock(&dcache_lock);
	return NULL;
376 377 378 379 380 381 382 383

found:
	DPRINTK("returning %p %.*s",
		expired, (int)expired->d_name.len, expired->d_name.name);
	spin_lock(&dcache_lock);
	list_move(&expired->d_parent->d_subdirs, &expired->d_u.d_child);
	spin_unlock(&dcache_lock);
	return expired;
L
Linus Torvalds 已提交
384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399
}

/* Perform an expiry operation */
int autofs4_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 dentry *dentry;

	memset(&pkt,0,sizeof pkt);

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

I
Ian Kent 已提交
400
	if ((dentry = autofs4_expire_indirect(sb, mnt, sbi, 0)) == NULL)
L
Linus Torvalds 已提交
401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425
		return -EAGAIN;

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

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

	return 0;
}

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

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

426
	if (sbi->type & AUTOFS_TYPE_DIRECT)
I
Ian Kent 已提交
427 428 429 430 431
		dentry = autofs4_expire_direct(sb, mnt, sbi, do_now);
	else
		dentry = autofs4_expire_indirect(sb, mnt, sbi, do_now);

	if (dentry) {
432
		struct autofs_info *ino = autofs4_dentry_ino(dentry);
L
Linus Torvalds 已提交
433 434 435

		/* This is synchronous because it makes the daemon a
                   little easier */
436
		ino->flags |= AUTOFS_INF_EXPIRING;
L
Linus Torvalds 已提交
437
		ret = autofs4_wait(sbi, dentry, NFY_EXPIRE);
438
		ino->flags &= ~AUTOFS_INF_EXPIRING;
L
Linus Torvalds 已提交
439 440
		dput(dentry);
	}
441

L
Linus Torvalds 已提交
442 443 444
	return ret;
}