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