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
13 static unsigned long now;
14
15 /* Check if a dentry can be expired */
autofs4_can_expire(struct dentry * dentry,unsigned long timeout,int do_now)16 static 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 */
autofs4_mount_busy(struct vfsmount * mnt,struct dentry * dentry)34 static 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;
65 done:
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 */
get_next_positive_subdir(struct dentry * prev,struct dentry * root)74 static 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
91 cont:
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 */
get_next_positive_dentry(struct dentry * prev,struct dentry * root)121 static 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);
132 relock:
133 p = prev;
134 spin_lock(&p->d_lock);
135 again:
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 */
autofs4_direct_busy(struct vfsmount * mnt,struct dentry * top,unsigned long timeout,int do_now)187 static 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 */
autofs4_tree_busy(struct vfsmount * mnt,struct dentry * top,unsigned long timeout,int do_now)215 static 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
autofs4_check_leaves(struct vfsmount * mnt,struct dentry * parent,unsigned long timeout,int do_now)270 static 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) */
autofs4_expire_direct(struct super_block * sb,struct vfsmount * mnt,struct autofs_sb_info * sbi,int how)297 struct 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_WANT_EXPIRE;
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 init_completion(&ino->expire_complete);
326 spin_unlock(&sbi->fs_lock);
327 return root;
328 }
329 ino->flags &= ~AUTOFS_INF_WANT_EXPIRE;
330 }
331 out:
332 spin_unlock(&sbi->fs_lock);
333 dput(root);
334
335 return NULL;
336 }
337
338 /* Check if 'dentry' should expire, or return a nearby
339 * dentry that is suitable.
340 * If returned dentry is different from arg dentry,
341 * then a dget() reference was taken, else not.
342 */
should_expire(struct dentry * dentry,struct vfsmount * mnt,unsigned long timeout,int how)343 static struct dentry *should_expire(struct dentry *dentry,
344 struct vfsmount *mnt,
345 unsigned long timeout,
346 int how)
347 {
348 int do_now = how & AUTOFS_EXP_IMMEDIATE;
349 int exp_leaves = how & AUTOFS_EXP_LEAVES;
350 struct autofs_info *ino = autofs4_dentry_ino(dentry);
351 unsigned int ino_count;
352
353 /* No point expiring a pending mount */
354 if (ino->flags & AUTOFS_INF_PENDING)
355 return NULL;
356
357 /*
358 * Case 1: (i) indirect mount or top level pseudo direct mount
359 * (autofs-4.1).
360 * (ii) indirect mount with offset mount, check the "/"
361 * offset (autofs-5.0+).
362 */
363 if (d_mountpoint(dentry)) {
364 pr_debug("checking mountpoint %p %pd\n", dentry, dentry);
365
366 /* Can we umount this guy */
367 if (autofs4_mount_busy(mnt, dentry))
368 return NULL;
369
370 /* Can we expire this guy */
371 if (autofs4_can_expire(dentry, timeout, do_now))
372 return dentry;
373 return NULL;
374 }
375
376 if (d_really_is_positive(dentry) && d_is_symlink(dentry)) {
377 pr_debug("checking symlink %p %pd\n", dentry, dentry);
378 /*
379 * A symlink can't be "busy" in the usual sense so
380 * just check last used for expire timeout.
381 */
382 if (autofs4_can_expire(dentry, timeout, do_now))
383 return dentry;
384 return NULL;
385 }
386
387 if (simple_empty(dentry))
388 return NULL;
389
390 /* Case 2: tree mount, expire iff entire tree is not busy */
391 if (!exp_leaves) {
392 /* Path walk currently on this dentry? */
393 ino_count = atomic_read(&ino->count) + 1;
394 if (d_count(dentry) > ino_count)
395 return NULL;
396
397 if (!autofs4_tree_busy(mnt, dentry, timeout, do_now))
398 return dentry;
399 /*
400 * Case 3: pseudo direct mount, expire individual leaves
401 * (autofs-4.1).
402 */
403 } else {
404 /* Path walk currently on this dentry? */
405 struct dentry *expired;
406
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 /*
422 * Find an eligible tree to time-out
423 * A tree is eligible if :-
424 * - it is unused by any user process
425 * - it has been unused for exp_timeout time
426 */
autofs4_expire_indirect(struct super_block * sb,struct vfsmount * mnt,struct autofs_sb_info * sbi,int how)427 struct dentry *autofs4_expire_indirect(struct super_block *sb,
428 struct vfsmount *mnt,
429 struct autofs_sb_info *sbi,
430 int how)
431 {
432 unsigned long timeout;
433 struct dentry *root = sb->s_root;
434 struct dentry *dentry;
435 struct dentry *expired;
436 struct dentry *found;
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 int flags = how;
448
449 spin_lock(&sbi->fs_lock);
450 ino = autofs4_dentry_ino(dentry);
451 if (ino->flags & AUTOFS_INF_WANT_EXPIRE) {
452 spin_unlock(&sbi->fs_lock);
453 continue;
454 }
455 spin_unlock(&sbi->fs_lock);
456
457 expired = should_expire(dentry, mnt, timeout, flags);
458 if (!expired)
459 continue;
460
461 spin_lock(&sbi->fs_lock);
462 ino = autofs4_dentry_ino(expired);
463 ino->flags |= AUTOFS_INF_WANT_EXPIRE;
464 spin_unlock(&sbi->fs_lock);
465 synchronize_rcu();
466
467 /* Make sure a reference is not taken on found if
468 * things have changed.
469 */
470 flags &= ~AUTOFS_EXP_LEAVES;
471 found = should_expire(expired, mnt, timeout, how);
472 if (!found || found != expired)
473 /* Something has changed, continue */
474 goto next;
475
476 if (expired != dentry)
477 dput(dentry);
478
479 spin_lock(&sbi->fs_lock);
480 goto found;
481 next:
482 spin_lock(&sbi->fs_lock);
483 ino->flags &= ~AUTOFS_INF_WANT_EXPIRE;
484 spin_unlock(&sbi->fs_lock);
485 if (expired != dentry)
486 dput(expired);
487 }
488 return NULL;
489
490 found:
491 pr_debug("returning %p %pd\n", expired, expired);
492 ino->flags |= AUTOFS_INF_EXPIRING;
493 init_completion(&ino->expire_complete);
494 spin_unlock(&sbi->fs_lock);
495 return expired;
496 }
497
autofs4_expire_wait(struct dentry * dentry,int rcu_walk)498 int autofs4_expire_wait(struct dentry *dentry, int rcu_walk)
499 {
500 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
501 struct autofs_info *ino = autofs4_dentry_ino(dentry);
502 int status;
503 int state;
504
505 /* Block on any pending expire */
506 if (!(ino->flags & AUTOFS_INF_WANT_EXPIRE))
507 return 0;
508 if (rcu_walk)
509 return -ECHILD;
510
511 retry:
512 spin_lock(&sbi->fs_lock);
513 state = ino->flags & (AUTOFS_INF_WANT_EXPIRE | AUTOFS_INF_EXPIRING);
514 if (state == AUTOFS_INF_WANT_EXPIRE) {
515 spin_unlock(&sbi->fs_lock);
516 /*
517 * Possibly being selected for expire, wait until
518 * it's selected or not.
519 */
520 schedule_timeout_uninterruptible(HZ/10);
521 goto retry;
522 }
523 if (state & AUTOFS_INF_EXPIRING) {
524 spin_unlock(&sbi->fs_lock);
525
526 pr_debug("waiting for expire %p name=%pd\n", dentry, dentry);
527
528 status = autofs4_wait(sbi, dentry, NFY_NONE);
529 wait_for_completion(&ino->expire_complete);
530
531 pr_debug("expire done status=%d\n", status);
532
533 if (d_unhashed(dentry))
534 return -EAGAIN;
535
536 return status;
537 }
538 spin_unlock(&sbi->fs_lock);
539
540 return 0;
541 }
542
543 /* 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)544 int autofs4_expire_run(struct super_block *sb,
545 struct vfsmount *mnt,
546 struct autofs_sb_info *sbi,
547 struct autofs_packet_expire __user *pkt_p)
548 {
549 struct autofs_packet_expire pkt;
550 struct autofs_info *ino;
551 struct dentry *dentry;
552 int ret = 0;
553
554 memset(&pkt, 0, sizeof(pkt));
555
556 pkt.hdr.proto_version = sbi->version;
557 pkt.hdr.type = autofs_ptype_expire;
558
559 dentry = autofs4_expire_indirect(sb, mnt, sbi, 0);
560 if (!dentry)
561 return -EAGAIN;
562
563 pkt.len = dentry->d_name.len;
564 memcpy(pkt.name, dentry->d_name.name, pkt.len);
565 pkt.name[pkt.len] = '\0';
566 dput(dentry);
567
568 if (copy_to_user(pkt_p, &pkt, sizeof(struct autofs_packet_expire)))
569 ret = -EFAULT;
570
571 spin_lock(&sbi->fs_lock);
572 ino = autofs4_dentry_ino(dentry);
573 /* avoid rapid-fire expire attempts if expiry fails */
574 ino->last_used = now;
575 ino->flags &= ~(AUTOFS_INF_EXPIRING|AUTOFS_INF_WANT_EXPIRE);
576 complete_all(&ino->expire_complete);
577 spin_unlock(&sbi->fs_lock);
578
579 return ret;
580 }
581
autofs4_do_expire_multi(struct super_block * sb,struct vfsmount * mnt,struct autofs_sb_info * sbi,int when)582 int autofs4_do_expire_multi(struct super_block *sb, struct vfsmount *mnt,
583 struct autofs_sb_info *sbi, int when)
584 {
585 struct dentry *dentry;
586 int ret = -EAGAIN;
587
588 if (autofs_type_trigger(sbi->type))
589 dentry = autofs4_expire_direct(sb, mnt, sbi, when);
590 else
591 dentry = autofs4_expire_indirect(sb, mnt, sbi, when);
592
593 if (dentry) {
594 struct autofs_info *ino = autofs4_dentry_ino(dentry);
595
596 /* This is synchronous because it makes the daemon a
597 * little easier
598 */
599 ret = autofs4_wait(sbi, dentry, NFY_EXPIRE);
600
601 spin_lock(&sbi->fs_lock);
602 /* avoid rapid-fire expire attempts if expiry fails */
603 ino->last_used = now;
604 ino->flags &= ~(AUTOFS_INF_EXPIRING|AUTOFS_INF_WANT_EXPIRE);
605 complete_all(&ino->expire_complete);
606 spin_unlock(&sbi->fs_lock);
607 dput(dentry);
608 }
609
610 return ret;
611 }
612
613 /*
614 * Call repeatedly until it returns -EAGAIN, meaning there's nothing
615 * more to be done.
616 */
autofs4_expire_multi(struct super_block * sb,struct vfsmount * mnt,struct autofs_sb_info * sbi,int __user * arg)617 int autofs4_expire_multi(struct super_block *sb, struct vfsmount *mnt,
618 struct autofs_sb_info *sbi, int __user *arg)
619 {
620 int do_now = 0;
621
622 if (arg && get_user(do_now, arg))
623 return -EFAULT;
624
625 return autofs4_do_expire_multi(sb, mnt, sbi, do_now);
626 }
627
628