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