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