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
17 static unsigned long now;
18
19 /* Check if a dentry can be expired */
autofs4_can_expire(struct dentry * dentry,unsigned long timeout,int do_now)20 static 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 /* No point expiring a pending mount */
30 if (dentry->d_flags & DCACHE_AUTOFS_PENDING)
31 return 0;
32
33 if (!do_now) {
34 /* Too young to die */
35 if (!timeout || time_after(ino->last_used + timeout, now))
36 return 0;
37
38 /* update last_used here :-
39 - obviously makes sense if it is in use now
40 - less obviously, prevents rapid-fire expire
41 attempts if expire fails the first time */
42 ino->last_used = now;
43 }
44 return 1;
45 }
46
47 /* Check a mount point for busyness */
autofs4_mount_busy(struct vfsmount * mnt,struct dentry * dentry)48 static int autofs4_mount_busy(struct vfsmount *mnt, struct dentry *dentry)
49 {
50 struct dentry *top = dentry;
51 int status = 1;
52
53 DPRINTK("dentry %p %.*s",
54 dentry, (int)dentry->d_name.len, dentry->d_name.name);
55
56 mntget(mnt);
57 dget(dentry);
58
59 if (!follow_down(&mnt, &dentry))
60 goto done;
61
62 if (is_autofs4_dentry(dentry)) {
63 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
64
65 /* This is an autofs submount, we can't expire it */
66 if (autofs_type_indirect(sbi->type))
67 goto done;
68
69 /*
70 * Otherwise it's an offset mount and we need to check
71 * if we can umount its mount, if there is one.
72 */
73 if (!d_mountpoint(dentry))
74 goto done;
75 }
76
77 /* Update the expiry counter if fs is busy */
78 if (!may_umount_tree(mnt)) {
79 struct autofs_info *ino = autofs4_dentry_ino(top);
80 ino->last_used = jiffies;
81 goto done;
82 }
83
84 status = 0;
85 done:
86 DPRINTK("returning = %d", status);
87 dput(dentry);
88 mntput(mnt);
89 return status;
90 }
91
92 /*
93 * Calculate next entry in top down tree traversal.
94 * From next_mnt in namespace.c - elegant.
95 */
next_dentry(struct dentry * p,struct dentry * root)96 static struct dentry *next_dentry(struct dentry *p, struct dentry *root)
97 {
98 struct list_head *next = p->d_subdirs.next;
99
100 if (next == &p->d_subdirs) {
101 while (1) {
102 if (p == root)
103 return NULL;
104 next = p->d_u.d_child.next;
105 if (next != &p->d_parent->d_subdirs)
106 break;
107 p = p->d_parent;
108 }
109 }
110 return list_entry(next, struct dentry, d_u.d_child);
111 }
112
113 /*
114 * Check a direct mount point for busyness.
115 * Direct mounts have similar expiry semantics to tree mounts.
116 * The tree is not busy iff no mountpoints are busy and there are no
117 * autofs submounts.
118 */
autofs4_direct_busy(struct vfsmount * mnt,struct dentry * top,unsigned long timeout,int do_now)119 static int autofs4_direct_busy(struct vfsmount *mnt,
120 struct dentry *top,
121 unsigned long timeout,
122 int do_now)
123 {
124 DPRINTK("top %p %.*s",
125 top, (int) top->d_name.len, top->d_name.name);
126
127 /* If it's busy update the expiry counters */
128 if (!may_umount_tree(mnt)) {
129 struct autofs_info *ino = autofs4_dentry_ino(top);
130 if (ino)
131 ino->last_used = jiffies;
132 return 1;
133 }
134
135 /* Timeout of a direct mount is determined by its top dentry */
136 if (!autofs4_can_expire(top, timeout, do_now))
137 return 1;
138
139 return 0;
140 }
141
142 /* Check a directory tree of mount points for busyness
143 * The tree is not busy iff no mountpoints are busy
144 */
autofs4_tree_busy(struct vfsmount * mnt,struct dentry * top,unsigned long timeout,int do_now)145 static int autofs4_tree_busy(struct vfsmount *mnt,
146 struct dentry *top,
147 unsigned long timeout,
148 int do_now)
149 {
150 struct autofs_info *top_ino = autofs4_dentry_ino(top);
151 struct dentry *p;
152
153 DPRINTK("top %p %.*s",
154 top, (int)top->d_name.len, top->d_name.name);
155
156 /* Negative dentry - give up */
157 if (!simple_positive(top))
158 return 1;
159
160 spin_lock(&dcache_lock);
161 for (p = top; p; p = next_dentry(p, top)) {
162 /* Negative dentry - give up */
163 if (!simple_positive(p))
164 continue;
165
166 DPRINTK("dentry %p %.*s",
167 p, (int) p->d_name.len, p->d_name.name);
168
169 p = dget(p);
170 spin_unlock(&dcache_lock);
171
172 /*
173 * Is someone visiting anywhere in the subtree ?
174 * If there's no mount we need to check the usage
175 * count for the autofs dentry.
176 * If the fs is busy update the expiry counter.
177 */
178 if (d_mountpoint(p)) {
179 if (autofs4_mount_busy(mnt, p)) {
180 top_ino->last_used = jiffies;
181 dput(p);
182 return 1;
183 }
184 } else {
185 struct autofs_info *ino = autofs4_dentry_ino(p);
186 unsigned int ino_count = atomic_read(&ino->count);
187
188 /*
189 * Clean stale dentries below that have not been
190 * invalidated after a mount fail during lookup
191 */
192 d_invalidate(p);
193
194 /* allow for dget above and top is already dgot */
195 if (p == top)
196 ino_count += 2;
197 else
198 ino_count++;
199
200 if (atomic_read(&p->d_count) > ino_count) {
201 top_ino->last_used = jiffies;
202 dput(p);
203 return 1;
204 }
205 }
206 dput(p);
207 spin_lock(&dcache_lock);
208 }
209 spin_unlock(&dcache_lock);
210
211 /* Timeout of a tree mount is ultimately determined by its top dentry */
212 if (!autofs4_can_expire(top, timeout, do_now))
213 return 1;
214
215 return 0;
216 }
217
autofs4_check_leaves(struct vfsmount * mnt,struct dentry * parent,unsigned long timeout,int do_now)218 static struct dentry *autofs4_check_leaves(struct vfsmount *mnt,
219 struct dentry *parent,
220 unsigned long timeout,
221 int do_now)
222 {
223 struct dentry *p;
224
225 DPRINTK("parent %p %.*s",
226 parent, (int)parent->d_name.len, parent->d_name.name);
227
228 spin_lock(&dcache_lock);
229 for (p = parent; p; p = next_dentry(p, parent)) {
230 /* Negative dentry - give up */
231 if (!simple_positive(p))
232 continue;
233
234 DPRINTK("dentry %p %.*s",
235 p, (int) p->d_name.len, p->d_name.name);
236
237 p = dget(p);
238 spin_unlock(&dcache_lock);
239
240 if (d_mountpoint(p)) {
241 /* Can we umount this guy */
242 if (autofs4_mount_busy(mnt, p))
243 goto cont;
244
245 /* Can we expire this guy */
246 if (autofs4_can_expire(p, timeout, do_now))
247 return p;
248 }
249 cont:
250 dput(p);
251 spin_lock(&dcache_lock);
252 }
253 spin_unlock(&dcache_lock);
254 return NULL;
255 }
256
257 /* Check if we can expire a direct mount (possibly a tree) */
autofs4_expire_direct(struct super_block * sb,struct vfsmount * mnt,struct autofs_sb_info * sbi,int how)258 struct dentry *autofs4_expire_direct(struct super_block *sb,
259 struct vfsmount *mnt,
260 struct autofs_sb_info *sbi,
261 int how)
262 {
263 unsigned long timeout;
264 struct dentry *root = dget(sb->s_root);
265 int do_now = how & AUTOFS_EXP_IMMEDIATE;
266
267 if (!root)
268 return NULL;
269
270 now = jiffies;
271 timeout = sbi->exp_timeout;
272
273 spin_lock(&sbi->fs_lock);
274 if (!autofs4_direct_busy(mnt, root, timeout, do_now)) {
275 struct autofs_info *ino = autofs4_dentry_ino(root);
276 if (d_mountpoint(root)) {
277 ino->flags |= AUTOFS_INF_MOUNTPOINT;
278 root->d_mounted--;
279 }
280 ino->flags |= AUTOFS_INF_EXPIRING;
281 init_completion(&ino->expire_complete);
282 spin_unlock(&sbi->fs_lock);
283 return root;
284 }
285 spin_unlock(&sbi->fs_lock);
286 dput(root);
287
288 return NULL;
289 }
290
291 /*
292 * Find an eligible tree to time-out
293 * A tree is eligible if :-
294 * - it is unused by any user process
295 * - it has been unused for exp_timeout time
296 */
autofs4_expire_indirect(struct super_block * sb,struct vfsmount * mnt,struct autofs_sb_info * sbi,int how)297 struct dentry *autofs4_expire_indirect(struct super_block *sb,
298 struct vfsmount *mnt,
299 struct autofs_sb_info *sbi,
300 int how)
301 {
302 unsigned long timeout;
303 struct dentry *root = sb->s_root;
304 struct dentry *expired = NULL;
305 struct list_head *next;
306 int do_now = how & AUTOFS_EXP_IMMEDIATE;
307 int exp_leaves = how & AUTOFS_EXP_LEAVES;
308 struct autofs_info *ino;
309 unsigned int ino_count;
310
311 if (!root)
312 return NULL;
313
314 now = jiffies;
315 timeout = sbi->exp_timeout;
316
317 spin_lock(&dcache_lock);
318 next = root->d_subdirs.next;
319
320 /* On exit from the loop expire is set to a dgot dentry
321 * to expire or it's NULL */
322 while ( next != &root->d_subdirs ) {
323 struct dentry *dentry = list_entry(next, struct dentry, d_u.d_child);
324
325 /* Negative dentry - give up */
326 if (!simple_positive(dentry)) {
327 next = next->next;
328 continue;
329 }
330
331 dentry = dget(dentry);
332 spin_unlock(&dcache_lock);
333
334 spin_lock(&sbi->fs_lock);
335 ino = autofs4_dentry_ino(dentry);
336
337 /*
338 * Case 1: (i) indirect mount or top level pseudo direct mount
339 * (autofs-4.1).
340 * (ii) indirect mount with offset mount, check the "/"
341 * offset (autofs-5.0+).
342 */
343 if (d_mountpoint(dentry)) {
344 DPRINTK("checking mountpoint %p %.*s",
345 dentry, (int)dentry->d_name.len, dentry->d_name.name);
346
347 /* Path walk currently on this dentry? */
348 ino_count = atomic_read(&ino->count) + 2;
349 if (atomic_read(&dentry->d_count) > ino_count)
350 goto next;
351
352 /* Can we umount this guy */
353 if (autofs4_mount_busy(mnt, dentry))
354 goto next;
355
356 /* Can we expire this guy */
357 if (autofs4_can_expire(dentry, timeout, do_now)) {
358 expired = dentry;
359 goto found;
360 }
361 goto next;
362 }
363
364 if (simple_empty(dentry))
365 goto next;
366
367 /* Case 2: tree mount, expire iff entire tree is not busy */
368 if (!exp_leaves) {
369 /* Path walk currently on this dentry? */
370 ino_count = atomic_read(&ino->count) + 1;
371 if (atomic_read(&dentry->d_count) > ino_count)
372 goto next;
373
374 if (!autofs4_tree_busy(mnt, dentry, timeout, do_now)) {
375 expired = dentry;
376 goto found;
377 }
378 /*
379 * Case 3: pseudo direct mount, expire individual leaves
380 * (autofs-4.1).
381 */
382 } else {
383 /* Path walk currently on this dentry? */
384 ino_count = atomic_read(&ino->count) + 1;
385 if (atomic_read(&dentry->d_count) > ino_count)
386 goto next;
387
388 expired = autofs4_check_leaves(mnt, dentry, timeout, do_now);
389 if (expired) {
390 dput(dentry);
391 goto found;
392 }
393 }
394 next:
395 spin_unlock(&sbi->fs_lock);
396 dput(dentry);
397 spin_lock(&dcache_lock);
398 next = next->next;
399 }
400 spin_unlock(&dcache_lock);
401 return NULL;
402
403 found:
404 DPRINTK("returning %p %.*s",
405 expired, (int)expired->d_name.len, expired->d_name.name);
406 ino = autofs4_dentry_ino(expired);
407 ino->flags |= AUTOFS_INF_EXPIRING;
408 init_completion(&ino->expire_complete);
409 spin_unlock(&sbi->fs_lock);
410 spin_lock(&dcache_lock);
411 list_move(&expired->d_parent->d_subdirs, &expired->d_u.d_child);
412 spin_unlock(&dcache_lock);
413 return expired;
414 }
415
autofs4_expire_wait(struct dentry * dentry)416 int autofs4_expire_wait(struct dentry *dentry)
417 {
418 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
419 struct autofs_info *ino = autofs4_dentry_ino(dentry);
420 int status;
421
422 /* Block on any pending expire */
423 spin_lock(&sbi->fs_lock);
424 if (ino->flags & AUTOFS_INF_EXPIRING) {
425 spin_unlock(&sbi->fs_lock);
426
427 DPRINTK("waiting for expire %p name=%.*s",
428 dentry, dentry->d_name.len, dentry->d_name.name);
429
430 status = autofs4_wait(sbi, dentry, NFY_NONE);
431 wait_for_completion(&ino->expire_complete);
432
433 DPRINTK("expire done status=%d", status);
434
435 if (d_unhashed(dentry))
436 return -EAGAIN;
437
438 return status;
439 }
440 spin_unlock(&sbi->fs_lock);
441
442 return 0;
443 }
444
445 /* Perform an expiry operation */
autofs4_expire_run(struct super_block * sb,struct vfsmount * mnt,struct autofs_sb_info * sbi,struct autofs_packet_expire __user * pkt_p)446 int autofs4_expire_run(struct super_block *sb,
447 struct vfsmount *mnt,
448 struct autofs_sb_info *sbi,
449 struct autofs_packet_expire __user *pkt_p)
450 {
451 struct autofs_packet_expire pkt;
452 struct autofs_info *ino;
453 struct dentry *dentry;
454 int ret = 0;
455
456 memset(&pkt,0,sizeof pkt);
457
458 pkt.hdr.proto_version = sbi->version;
459 pkt.hdr.type = autofs_ptype_expire;
460
461 if ((dentry = autofs4_expire_indirect(sb, mnt, sbi, 0)) == NULL)
462 return -EAGAIN;
463
464 pkt.len = dentry->d_name.len;
465 memcpy(pkt.name, dentry->d_name.name, pkt.len);
466 pkt.name[pkt.len] = '\0';
467 dput(dentry);
468
469 if ( copy_to_user(pkt_p, &pkt, sizeof(struct autofs_packet_expire)) )
470 ret = -EFAULT;
471
472 spin_lock(&sbi->fs_lock);
473 ino = autofs4_dentry_ino(dentry);
474 ino->flags &= ~AUTOFS_INF_EXPIRING;
475 complete_all(&ino->expire_complete);
476 spin_unlock(&sbi->fs_lock);
477
478 return ret;
479 }
480
481 /* Call repeatedly until it returns -EAGAIN, meaning there's nothing
482 more to be done */
autofs4_expire_multi(struct super_block * sb,struct vfsmount * mnt,struct autofs_sb_info * sbi,int __user * arg)483 int autofs4_expire_multi(struct super_block *sb, struct vfsmount *mnt,
484 struct autofs_sb_info *sbi, int __user *arg)
485 {
486 struct dentry *dentry;
487 int ret = -EAGAIN;
488 int do_now = 0;
489
490 if (arg && get_user(do_now, arg))
491 return -EFAULT;
492
493 if (autofs_type_trigger(sbi->type))
494 dentry = autofs4_expire_direct(sb, mnt, sbi, do_now);
495 else
496 dentry = autofs4_expire_indirect(sb, mnt, sbi, do_now);
497
498 if (dentry) {
499 struct autofs_info *ino = autofs4_dentry_ino(dentry);
500
501 /* This is synchronous because it makes the daemon a
502 little easier */
503 ret = autofs4_wait(sbi, dentry, NFY_EXPIRE);
504
505 spin_lock(&sbi->fs_lock);
506 if (ino->flags & AUTOFS_INF_MOUNTPOINT) {
507 sb->s_root->d_mounted++;
508 ino->flags &= ~AUTOFS_INF_MOUNTPOINT;
509 }
510 ino->flags &= ~AUTOFS_INF_EXPIRING;
511 complete_all(&ino->expire_complete);
512 spin_unlock(&sbi->fs_lock);
513 dput(dentry);
514 }
515
516 return ret;
517 }
518
519