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