blob: a7be57e39be78791930c2dc362507d53e9ec6174 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* -*- 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>
Ian Kent3a15e2a2006-03-27 01:14:55 -08007 * Copyright 2001-2006 Ian Kent <raven@themaw.net>
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 *
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
Ian Kent1f5f2c32006-03-27 01:14:44 -080019/* Check if a dentry can be expired */
Linus Torvalds1da177e2005-04-16 15:20:36 -070020static 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070029 if (!do_now) {
30 /* Too young to die */
Ian Kentc0ba7e52006-09-25 16:24:16 -070031 if (!timeout || time_after(ino->last_used + timeout, now))
Linus Torvalds1da177e2005-04-16 15:20:36 -070032 return 0;
33
34 /* update last_used here :-
35 - obviously makes sense if it is in use now
36 - less obviously, prevents rapid-fire expire
37 attempts if expire fails the first time */
38 ino->last_used = now;
39 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070040 return 1;
41}
42
Ian Kent1f5f2c32006-03-27 01:14:44 -080043/* Check a mount point for busyness */
44static int autofs4_mount_busy(struct vfsmount *mnt, struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -070045{
Ian Kente0a7aae2006-03-27 01:14:47 -080046 struct dentry *top = dentry;
Al Viro9393bd02009-04-18 13:58:15 -040047 struct path path = {.mnt = mnt, .dentry = dentry};
Ian Kent1f5f2c32006-03-27 01:14:44 -080048 int status = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -070049
50 DPRINTK("dentry %p %.*s",
51 dentry, (int)dentry->d_name.len, dentry->d_name.name);
52
Al Viro9393bd02009-04-18 13:58:15 -040053 path_get(&path);
Linus Torvalds1da177e2005-04-16 15:20:36 -070054
David Howellscc53ce52011-01-14 18:45:26 +000055 if (!follow_down_one(&path))
Linus Torvalds1da177e2005-04-16 15:20:36 -070056 goto done;
57
Al Viro9393bd02009-04-18 13:58:15 -040058 if (is_autofs4_dentry(path.dentry)) {
59 struct autofs_sb_info *sbi = autofs4_sbi(path.dentry->d_sb);
Ian Kentbc9c4062008-11-06 12:53:22 -080060
61 /* This is an autofs submount, we can't expire it */
Ian Kenta92daf62009-01-06 14:42:08 -080062 if (autofs_type_indirect(sbi->type))
Ian Kentbc9c4062008-11-06 12:53:22 -080063 goto done;
Ian Kentbc9c4062008-11-06 12:53:22 -080064 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
Ian Kente0a7aae2006-03-27 01:14:47 -080066 /* Update the expiry counter if fs is busy */
Ian Kent37d08922009-09-01 11:26:22 +080067 if (!may_umount_tree(path.mnt)) {
Ian Kente0a7aae2006-03-27 01:14:47 -080068 struct autofs_info *ino = autofs4_dentry_ino(top);
69 ino->last_used = jiffies;
70 goto done;
71 }
72
73 status = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070074done:
75 DPRINTK("returning = %d", status);
Al Viro9393bd02009-04-18 13:58:15 -040076 path_put(&path);
Linus Torvalds1da177e2005-04-16 15:20:36 -070077 return status;
78}
79
Ian Kent1ce12ba2006-03-27 01:14:45 -080080/*
Ian Kentd4a85e32011-03-25 01:51:20 +080081 * Calculate and dget next entry in the subdirs list under root.
82 */
83static struct dentry *get_next_positive_subdir(struct dentry *prev,
84 struct dentry *root)
85{
Ian Kente7854722011-03-25 01:51:31 +080086 struct autofs_sb_info *sbi = autofs4_sbi(root->d_sb);
Ian Kentd4a85e32011-03-25 01:51:20 +080087 struct list_head *next;
Ian Kenta45440f2012-08-06 09:37:47 +080088 struct dentry *q;
Ian Kentd4a85e32011-03-25 01:51:20 +080089
Ian Kente7854722011-03-25 01:51:31 +080090 spin_lock(&sbi->lookup_lock);
Ian Kenta45440f2012-08-06 09:37:47 +080091 spin_lock(&root->d_lock);
Ian Kentd4a85e32011-03-25 01:51:20 +080092
Ian Kenta45440f2012-08-06 09:37:47 +080093 if (prev)
94 next = prev->d_u.d_child.next;
95 else {
Ian Kentd4a85e32011-03-25 01:51:20 +080096 prev = dget_dlock(root);
97 next = prev->d_subdirs.next;
Ian Kentd4a85e32011-03-25 01:51:20 +080098 }
99
Ian Kenta45440f2012-08-06 09:37:47 +0800100cont:
Ian Kentd4a85e32011-03-25 01:51:20 +0800101 if (next == &root->d_subdirs) {
Ian Kenta45440f2012-08-06 09:37:47 +0800102 spin_unlock(&root->d_lock);
Ian Kente7854722011-03-25 01:51:31 +0800103 spin_unlock(&sbi->lookup_lock);
Ian Kentd4a85e32011-03-25 01:51:20 +0800104 dput(prev);
105 return NULL;
106 }
107
108 q = list_entry(next, struct dentry, d_u.d_child);
109
110 spin_lock_nested(&q->d_lock, DENTRY_D_LOCK_NESTED);
Ian Kenta45440f2012-08-06 09:37:47 +0800111 /* Already gone or negative dentry (under construction) - try next */
Al Viro84d08fa2013-07-05 18:59:33 +0400112 if (!d_count(q) || !simple_positive(q)) {
Ian Kenta45440f2012-08-06 09:37:47 +0800113 spin_unlock(&q->d_lock);
114 next = q->d_u.d_child.next;
115 goto cont;
Ian Kentd4a85e32011-03-25 01:51:20 +0800116 }
117 dget_dlock(q);
118 spin_unlock(&q->d_lock);
Ian Kenta45440f2012-08-06 09:37:47 +0800119 spin_unlock(&root->d_lock);
Ian Kente7854722011-03-25 01:51:31 +0800120 spin_unlock(&sbi->lookup_lock);
Ian Kentd4a85e32011-03-25 01:51:20 +0800121
122 dput(prev);
123
124 return q;
125}
126
127/*
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100128 * Calculate and dget next entry in top down tree traversal.
Ian Kent1ce12ba2006-03-27 01:14:45 -0800129 */
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100130static struct dentry *get_next_positive_dentry(struct dentry *prev,
131 struct dentry *root)
Ian Kent1ce12ba2006-03-27 01:14:45 -0800132{
Ian Kente7854722011-03-25 01:51:31 +0800133 struct autofs_sb_info *sbi = autofs4_sbi(root->d_sb);
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100134 struct list_head *next;
135 struct dentry *p, *ret;
Ian Kent1ce12ba2006-03-27 01:14:45 -0800136
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100137 if (prev == NULL)
Ian Kentc14cc632011-01-18 12:06:04 +0800138 return dget(root);
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100139
Ian Kente7854722011-03-25 01:51:31 +0800140 spin_lock(&sbi->lookup_lock);
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100141relock:
142 p = prev;
143 spin_lock(&p->d_lock);
144again:
145 next = p->d_subdirs.next;
Ian Kent1ce12ba2006-03-27 01:14:45 -0800146 if (next == &p->d_subdirs) {
147 while (1) {
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100148 struct dentry *parent;
149
150 if (p == root) {
151 spin_unlock(&p->d_lock);
Ian Kente7854722011-03-25 01:51:31 +0800152 spin_unlock(&sbi->lookup_lock);
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100153 dput(prev);
Ian Kent1ce12ba2006-03-27 01:14:45 -0800154 return NULL;
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100155 }
156
157 parent = p->d_parent;
158 if (!spin_trylock(&parent->d_lock)) {
159 spin_unlock(&p->d_lock);
160 cpu_relax();
161 goto relock;
162 }
163 spin_unlock(&p->d_lock);
Ian Kent1ce12ba2006-03-27 01:14:45 -0800164 next = p->d_u.d_child.next;
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100165 p = parent;
166 if (next != &parent->d_subdirs)
Ian Kent1ce12ba2006-03-27 01:14:45 -0800167 break;
Ian Kent1ce12ba2006-03-27 01:14:45 -0800168 }
169 }
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100170 ret = list_entry(next, struct dentry, d_u.d_child);
171
172 spin_lock_nested(&ret->d_lock, DENTRY_D_LOCK_NESTED);
173 /* Negative dentry - try next */
174 if (!simple_positive(ret)) {
Ian Kentc14cc632011-01-18 12:06:04 +0800175 spin_unlock(&p->d_lock);
Steven Rostedt1d6f2092011-08-22 11:52:28 +0800176 lock_set_subclass(&ret->d_lock.dep_map, 0, _RET_IP_);
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100177 p = ret;
178 goto again;
179 }
180 dget_dlock(ret);
181 spin_unlock(&ret->d_lock);
182 spin_unlock(&p->d_lock);
Ian Kente7854722011-03-25 01:51:31 +0800183 spin_unlock(&sbi->lookup_lock);
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100184
185 dput(prev);
186
187 return ret;
Ian Kent1ce12ba2006-03-27 01:14:45 -0800188}
189
Ian Kent3a15e2a2006-03-27 01:14:55 -0800190/*
191 * Check a direct mount point for busyness.
192 * Direct mounts have similar expiry semantics to tree mounts.
193 * The tree is not busy iff no mountpoints are busy and there are no
194 * autofs submounts.
195 */
196static int autofs4_direct_busy(struct vfsmount *mnt,
197 struct dentry *top,
198 unsigned long timeout,
199 int do_now)
200{
201 DPRINTK("top %p %.*s",
202 top, (int) top->d_name.len, top->d_name.name);
203
Ian Kent3a15e2a2006-03-27 01:14:55 -0800204 /* If it's busy update the expiry counters */
205 if (!may_umount_tree(mnt)) {
206 struct autofs_info *ino = autofs4_dentry_ino(top);
207 if (ino)
208 ino->last_used = jiffies;
209 return 1;
210 }
211
212 /* Timeout of a direct mount is determined by its top dentry */
213 if (!autofs4_can_expire(top, timeout, do_now))
214 return 1;
215
216 return 0;
217}
218
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219/* Check a directory tree of mount points for busyness
220 * The tree is not busy iff no mountpoints are busy
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 */
Ian Kent1f5f2c32006-03-27 01:14:44 -0800222static int autofs4_tree_busy(struct vfsmount *mnt,
223 struct dentry *top,
224 unsigned long timeout,
225 int do_now)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226{
Ian Kente0a7aae2006-03-27 01:14:47 -0800227 struct autofs_info *top_ino = autofs4_dentry_ino(top);
Ian Kent1ce12ba2006-03-27 01:14:45 -0800228 struct dentry *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229
Ian Kent1f5f2c32006-03-27 01:14:44 -0800230 DPRINTK("top %p %.*s",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 top, (int)top->d_name.len, top->d_name.name);
232
233 /* Negative dentry - give up */
234 if (!simple_positive(top))
Ian Kent1f5f2c32006-03-27 01:14:44 -0800235 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100237 p = NULL;
238 while ((p = get_next_positive_dentry(p, top))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 DPRINTK("dentry %p %.*s",
Ian Kent1ce12ba2006-03-27 01:14:45 -0800240 p, (int) p->d_name.len, p->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241
Ian Kent1aff3c82006-03-27 01:14:46 -0800242 /*
243 * Is someone visiting anywhere in the subtree ?
244 * If there's no mount we need to check the usage
245 * count for the autofs dentry.
Ian Kente0a7aae2006-03-27 01:14:47 -0800246 * If the fs is busy update the expiry counter.
Ian Kent1aff3c82006-03-27 01:14:46 -0800247 */
Ian Kent1ce12ba2006-03-27 01:14:45 -0800248 if (d_mountpoint(p)) {
Ian Kent1ce12ba2006-03-27 01:14:45 -0800249 if (autofs4_mount_busy(mnt, p)) {
Ian Kente0a7aae2006-03-27 01:14:47 -0800250 top_ino->last_used = jiffies;
Ian Kent1ce12ba2006-03-27 01:14:45 -0800251 dput(p);
Ian Kent1f5f2c32006-03-27 01:14:44 -0800252 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 }
Ian Kent1aff3c82006-03-27 01:14:46 -0800254 } else {
Ian Kente0a7aae2006-03-27 01:14:47 -0800255 struct autofs_info *ino = autofs4_dentry_ino(p);
Ian Kent1aff3c82006-03-27 01:14:46 -0800256 unsigned int ino_count = atomic_read(&ino->count);
257
Ian Kentf9022f62006-06-25 05:48:47 -0700258 /*
259 * Clean stale dentries below that have not been
260 * invalidated after a mount fail during lookup
261 */
262 d_invalidate(p);
263
Ian Kent1aff3c82006-03-27 01:14:46 -0800264 /* allow for dget above and top is already dgot */
265 if (p == top)
266 ino_count += 2;
267 else
268 ino_count++;
269
Al Viro84d08fa2013-07-05 18:59:33 +0400270 if (d_count(p) > ino_count) {
Ian Kente0a7aae2006-03-27 01:14:47 -0800271 top_ino->last_used = jiffies;
Ian Kent1aff3c82006-03-27 01:14:46 -0800272 dput(p);
273 return 1;
274 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 }
Ian Kent1aff3c82006-03-27 01:14:46 -0800277
278 /* Timeout of a tree mount is ultimately determined by its top dentry */
279 if (!autofs4_can_expire(top, timeout, do_now))
280 return 1;
281
Ian Kent1f5f2c32006-03-27 01:14:44 -0800282 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283}
284
285static struct dentry *autofs4_check_leaves(struct vfsmount *mnt,
286 struct dentry *parent,
287 unsigned long timeout,
288 int do_now)
289{
Ian Kent1ce12ba2006-03-27 01:14:45 -0800290 struct dentry *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291
292 DPRINTK("parent %p %.*s",
293 parent, (int)parent->d_name.len, parent->d_name.name);
294
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100295 p = NULL;
296 while ((p = get_next_positive_dentry(p, parent))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 DPRINTK("dentry %p %.*s",
Ian Kent1ce12ba2006-03-27 01:14:45 -0800298 p, (int) p->d_name.len, p->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299
Ian Kent1ce12ba2006-03-27 01:14:45 -0800300 if (d_mountpoint(p)) {
Ian Kente0a7aae2006-03-27 01:14:47 -0800301 /* Can we umount this guy */
302 if (autofs4_mount_busy(mnt, p))
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100303 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304
Ian Kente0a7aae2006-03-27 01:14:47 -0800305 /* Can we expire this guy */
306 if (autofs4_can_expire(p, timeout, do_now))
Ian Kent1ce12ba2006-03-27 01:14:45 -0800307 return p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 return NULL;
311}
312
Ian Kent3a15e2a2006-03-27 01:14:55 -0800313/* Check if we can expire a direct mount (possibly a tree) */
Ian Kent8d7b48e2008-10-15 22:02:54 -0700314struct dentry *autofs4_expire_direct(struct super_block *sb,
315 struct vfsmount *mnt,
316 struct autofs_sb_info *sbi,
317 int how)
Ian Kent3a15e2a2006-03-27 01:14:55 -0800318{
319 unsigned long timeout;
320 struct dentry *root = dget(sb->s_root);
321 int do_now = how & AUTOFS_EXP_IMMEDIATE;
Ian Kentb5b80172011-01-14 18:46:03 +0000322 struct autofs_info *ino;
Ian Kent3a15e2a2006-03-27 01:14:55 -0800323
Ian Kentc0ba7e52006-09-25 16:24:16 -0700324 if (!root)
Ian Kent3a15e2a2006-03-27 01:14:55 -0800325 return NULL;
326
327 now = jiffies;
328 timeout = sbi->exp_timeout;
329
Ian Kent3a15e2a2006-03-27 01:14:55 -0800330 spin_lock(&sbi->fs_lock);
Ian Kentb5b80172011-01-14 18:46:03 +0000331 ino = autofs4_dentry_ino(root);
332 /* No point expiring a pending mount */
Ian Kentf9398c22011-03-25 01:51:14 +0800333 if (ino->flags & AUTOFS_INF_PENDING)
334 goto out;
Ian Kent3a15e2a2006-03-27 01:14:55 -0800335 if (!autofs4_direct_busy(mnt, root, timeout, do_now)) {
Ian Kent3a15e2a2006-03-27 01:14:55 -0800336 ino->flags |= AUTOFS_INF_EXPIRING;
Ian Kent6e60a9a2008-07-23 21:30:27 -0700337 init_completion(&ino->expire_complete);
Ian Kent3a15e2a2006-03-27 01:14:55 -0800338 spin_unlock(&sbi->fs_lock);
339 return root;
340 }
Ian Kentf9398c22011-03-25 01:51:14 +0800341out:
Ian Kent3a15e2a2006-03-27 01:14:55 -0800342 spin_unlock(&sbi->fs_lock);
343 dput(root);
344
345 return NULL;
346}
347
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348/*
349 * Find an eligible tree to time-out
350 * A tree is eligible if :-
351 * - it is unused by any user process
352 * - it has been unused for exp_timeout time
353 */
Ian Kent8d7b48e2008-10-15 22:02:54 -0700354struct dentry *autofs4_expire_indirect(struct super_block *sb,
355 struct vfsmount *mnt,
356 struct autofs_sb_info *sbi,
357 int how)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358{
359 unsigned long timeout;
360 struct dentry *root = sb->s_root;
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100361 struct dentry *dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 struct dentry *expired = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 int do_now = how & AUTOFS_EXP_IMMEDIATE;
364 int exp_leaves = how & AUTOFS_EXP_LEAVES;
Ian Kent97e74492008-07-23 21:30:26 -0700365 struct autofs_info *ino;
366 unsigned int ino_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367
Ian Kentc0ba7e52006-09-25 16:24:16 -0700368 if (!root)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 return NULL;
370
371 now = jiffies;
372 timeout = sbi->exp_timeout;
373
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100374 dentry = NULL;
Ian Kentd4a85e32011-03-25 01:51:20 +0800375 while ((dentry = get_next_positive_subdir(dentry, root))) {
Ian Kent97e74492008-07-23 21:30:26 -0700376 spin_lock(&sbi->fs_lock);
377 ino = autofs4_dentry_ino(dentry);
Ian Kentb5b80172011-01-14 18:46:03 +0000378 /* No point expiring a pending mount */
379 if (ino->flags & AUTOFS_INF_PENDING)
Ian Kent3c319982011-03-25 01:51:08 +0800380 goto next;
Ian Kent97e74492008-07-23 21:30:26 -0700381
Ian Kent3a15e2a2006-03-27 01:14:55 -0800382 /*
383 * Case 1: (i) indirect mount or top level pseudo direct mount
384 * (autofs-4.1).
385 * (ii) indirect mount with offset mount, check the "/"
386 * offset (autofs-5.0+).
387 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 if (d_mountpoint(dentry)) {
389 DPRINTK("checking mountpoint %p %.*s",
390 dentry, (int)dentry->d_name.len, dentry->d_name.name);
391
Ian Kente0a7aae2006-03-27 01:14:47 -0800392 /* Can we umount this guy */
393 if (autofs4_mount_busy(mnt, dentry))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 goto next;
395
Ian Kente0a7aae2006-03-27 01:14:47 -0800396 /* Can we expire this guy */
397 if (autofs4_can_expire(dentry, timeout, do_now)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 expired = dentry;
Ian Kentafec5702008-05-01 04:35:06 -0700399 goto found;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 }
401 goto next;
402 }
403
Ian Kent8dc51fe2014-01-23 15:55:01 -0800404 if (dentry->d_inode && S_ISLNK(dentry->d_inode->i_mode)) {
405 DPRINTK("checking symlink %p %.*s",
406 dentry, (int)dentry->d_name.len, dentry->d_name.name);
407 /*
408 * A symlink can't be "busy" in the usual sense so
409 * just check last used for expire timeout.
410 */
411 if (autofs4_can_expire(dentry, timeout, do_now)) {
412 expired = dentry;
413 goto found;
414 }
415 goto next;
416 }
417
Ian Kent1f5f2c32006-03-27 01:14:44 -0800418 if (simple_empty(dentry))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 goto next;
420
421 /* Case 2: tree mount, expire iff entire tree is not busy */
422 if (!exp_leaves) {
Ian Kent97e74492008-07-23 21:30:26 -0700423 /* Path walk currently on this dentry? */
424 ino_count = atomic_read(&ino->count) + 1;
Al Viro84d08fa2013-07-05 18:59:33 +0400425 if (d_count(dentry) > ino_count)
Ian Kent97e74492008-07-23 21:30:26 -0700426 goto next;
Ian Kent3a9720c2005-05-01 08:59:17 -0700427
Ian Kent97e74492008-07-23 21:30:26 -0700428 if (!autofs4_tree_busy(mnt, dentry, timeout, do_now)) {
Ian Kent3a9720c2005-05-01 08:59:17 -0700429 expired = dentry;
Ian Kentafec5702008-05-01 04:35:06 -0700430 goto found;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 }
Ian Kent3a15e2a2006-03-27 01:14:55 -0800432 /*
433 * Case 3: pseudo direct mount, expire individual leaves
434 * (autofs-4.1).
435 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 } else {
Ian Kent97e74492008-07-23 21:30:26 -0700437 /* Path walk currently on this dentry? */
438 ino_count = atomic_read(&ino->count) + 1;
Al Viro84d08fa2013-07-05 18:59:33 +0400439 if (d_count(dentry) > ino_count)
Ian Kent97e74492008-07-23 21:30:26 -0700440 goto next;
441
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442 expired = autofs4_check_leaves(mnt, dentry, timeout, do_now);
443 if (expired) {
444 dput(dentry);
Ian Kentafec5702008-05-01 04:35:06 -0700445 goto found;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446 }
447 }
448next:
Ian Kent97e74492008-07-23 21:30:26 -0700449 spin_unlock(&sbi->fs_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 return NULL;
Ian Kentafec5702008-05-01 04:35:06 -0700452
453found:
454 DPRINTK("returning %p %.*s",
455 expired, (int)expired->d_name.len, expired->d_name.name);
Ian Kent97e74492008-07-23 21:30:26 -0700456 ino = autofs4_dentry_ino(expired);
457 ino->flags |= AUTOFS_INF_EXPIRING;
Ian Kent6e60a9a2008-07-23 21:30:27 -0700458 init_completion(&ino->expire_complete);
Ian Kent97e74492008-07-23 21:30:26 -0700459 spin_unlock(&sbi->fs_lock);
Ian Kente7854722011-03-25 01:51:31 +0800460 spin_lock(&sbi->lookup_lock);
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100461 spin_lock(&expired->d_parent->d_lock);
462 spin_lock_nested(&expired->d_lock, DENTRY_D_LOCK_NESTED);
Ian Kentafec5702008-05-01 04:35:06 -0700463 list_move(&expired->d_parent->d_subdirs, &expired->d_u.d_child);
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100464 spin_unlock(&expired->d_lock);
465 spin_unlock(&expired->d_parent->d_lock);
Ian Kente7854722011-03-25 01:51:31 +0800466 spin_unlock(&sbi->lookup_lock);
Ian Kentafec5702008-05-01 04:35:06 -0700467 return expired;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468}
469
Ian Kent06a35982008-07-23 21:30:28 -0700470int autofs4_expire_wait(struct dentry *dentry)
471{
472 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
473 struct autofs_info *ino = autofs4_dentry_ino(dentry);
474 int status;
475
476 /* Block on any pending expire */
477 spin_lock(&sbi->fs_lock);
478 if (ino->flags & AUTOFS_INF_EXPIRING) {
479 spin_unlock(&sbi->fs_lock);
480
481 DPRINTK("waiting for expire %p name=%.*s",
482 dentry, dentry->d_name.len, dentry->d_name.name);
483
484 status = autofs4_wait(sbi, dentry, NFY_NONE);
485 wait_for_completion(&ino->expire_complete);
486
487 DPRINTK("expire done status=%d", status);
488
Al Viro4b1ae272010-03-03 12:58:31 -0500489 if (d_unhashed(dentry))
Ian Kent06a35982008-07-23 21:30:28 -0700490 return -EAGAIN;
491
492 return status;
493 }
494 spin_unlock(&sbi->fs_lock);
495
496 return 0;
497}
498
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499/* Perform an expiry operation */
500int autofs4_expire_run(struct super_block *sb,
501 struct vfsmount *mnt,
502 struct autofs_sb_info *sbi,
503 struct autofs_packet_expire __user *pkt_p)
504{
505 struct autofs_packet_expire pkt;
Ian Kent97e74492008-07-23 21:30:26 -0700506 struct autofs_info *ino;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 struct dentry *dentry;
Ian Kent97e74492008-07-23 21:30:26 -0700508 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509
510 memset(&pkt,0,sizeof pkt);
511
512 pkt.hdr.proto_version = sbi->version;
513 pkt.hdr.type = autofs_ptype_expire;
514
Ian Kent3a15e2a2006-03-27 01:14:55 -0800515 if ((dentry = autofs4_expire_indirect(sb, mnt, sbi, 0)) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 return -EAGAIN;
517
518 pkt.len = dentry->d_name.len;
519 memcpy(pkt.name, dentry->d_name.name, pkt.len);
520 pkt.name[pkt.len] = '\0';
521 dput(dentry);
522
523 if ( copy_to_user(pkt_p, &pkt, sizeof(struct autofs_packet_expire)) )
Ian Kent97e74492008-07-23 21:30:26 -0700524 ret = -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525
Ian Kent97e74492008-07-23 21:30:26 -0700526 spin_lock(&sbi->fs_lock);
527 ino = autofs4_dentry_ino(dentry);
528 ino->flags &= ~AUTOFS_INF_EXPIRING;
Ian Kent6e60a9a2008-07-23 21:30:27 -0700529 complete_all(&ino->expire_complete);
Ian Kent97e74492008-07-23 21:30:26 -0700530 spin_unlock(&sbi->fs_lock);
531
532 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533}
534
Ian Kent56fcef72009-03-31 15:24:43 -0700535int autofs4_do_expire_multi(struct super_block *sb, struct vfsmount *mnt,
536 struct autofs_sb_info *sbi, int when)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537{
538 struct dentry *dentry;
539 int ret = -EAGAIN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540
Ian Kenta92daf62009-01-06 14:42:08 -0800541 if (autofs_type_trigger(sbi->type))
Ian Kent56fcef72009-03-31 15:24:43 -0700542 dentry = autofs4_expire_direct(sb, mnt, sbi, when);
Ian Kent3a15e2a2006-03-27 01:14:55 -0800543 else
Ian Kent56fcef72009-03-31 15:24:43 -0700544 dentry = autofs4_expire_indirect(sb, mnt, sbi, when);
Ian Kent3a15e2a2006-03-27 01:14:55 -0800545
546 if (dentry) {
Ian Kent1f5f2c32006-03-27 01:14:44 -0800547 struct autofs_info *ino = autofs4_dentry_ino(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548
549 /* This is synchronous because it makes the daemon a
550 little easier */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551 ret = autofs4_wait(sbi, dentry, NFY_EXPIRE);
Ian Kent6e60a9a2008-07-23 21:30:27 -0700552
Ian Kent97e74492008-07-23 21:30:26 -0700553 spin_lock(&sbi->fs_lock);
Ian Kent1f5f2c32006-03-27 01:14:44 -0800554 ino->flags &= ~AUTOFS_INF_EXPIRING;
Ian Kent6e60a9a2008-07-23 21:30:27 -0700555 complete_all(&ino->expire_complete);
Ian Kent97e74492008-07-23 21:30:26 -0700556 spin_unlock(&sbi->fs_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 dput(dentry);
558 }
Ian Kent1f5f2c32006-03-27 01:14:44 -0800559
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 return ret;
561}
562
Ian Kent56fcef72009-03-31 15:24:43 -0700563/* Call repeatedly until it returns -EAGAIN, meaning there's nothing
564 more to be done */
565int autofs4_expire_multi(struct super_block *sb, struct vfsmount *mnt,
566 struct autofs_sb_info *sbi, int __user *arg)
567{
568 int do_now = 0;
569
570 if (arg && get_user(do_now, arg))
571 return -EFAULT;
572
573 return autofs4_do_expire_multi(sb, mnt, sbi, do_now);
574}
575