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