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

source code of linux/fs/autofs/expire.c