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 /* p->d_lock held */ 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 */ 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 */ 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 */ 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 */ 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 = atomic_read(&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 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) */ 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 */ 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_really_is_positive(dentry) && 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 (simple_empty(dentry)) 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 = atomic_read(&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 = atomic_read(&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 */ 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 || found != expired) 463 /* Something has changed, continue */ 464 goto next; 465 466 if (expired != dentry) 467 dput(dentry); 468 469 spin_lock(&sbi->fs_lock); 470 goto found; 471 next: 472 spin_lock(&sbi->fs_lock); 473 ino->flags &= ~AUTOFS_INF_WANT_EXPIRE; 474 spin_unlock(&sbi->fs_lock); 475 if (expired != dentry) 476 dput(expired); 477 } 478 return NULL; 479 480 found: 481 pr_debug("returning %p %pd\n", expired, expired); 482 ino->flags |= AUTOFS_INF_EXPIRING; 483 init_completion(&ino->expire_complete); 484 spin_unlock(&sbi->fs_lock); 485 return expired; 486 } 487 488 int autofs_expire_wait(const struct path *path, int rcu_walk) 489 { 490 struct dentry *dentry = path->dentry; 491 struct autofs_sb_info *sbi = autofs_sbi(dentry->d_sb); 492 struct autofs_info *ino = autofs_dentry_ino(dentry); 493 int status; 494 int state; 495 496 /* Block on any pending expire */ 497 if (!(ino->flags & AUTOFS_INF_WANT_EXPIRE)) 498 return 0; 499 if (rcu_walk) 500 return -ECHILD; 501 502 retry: 503 spin_lock(&sbi->fs_lock); 504 state = ino->flags & (AUTOFS_INF_WANT_EXPIRE | AUTOFS_INF_EXPIRING); 505 if (state == AUTOFS_INF_WANT_EXPIRE) { 506 spin_unlock(&sbi->fs_lock); 507 /* 508 * Possibly being selected for expire, wait until 509 * it's selected or not. 510 */ 511 schedule_timeout_uninterruptible(HZ/10); 512 goto retry; 513 } 514 if (state & AUTOFS_INF_EXPIRING) { 515 spin_unlock(&sbi->fs_lock); 516 517 pr_debug("waiting for expire %p name=%pd\n", dentry, dentry); 518 519 status = autofs_wait(sbi, path, NFY_NONE); 520 wait_for_completion(&ino->expire_complete); 521 522 pr_debug("expire done status=%d\n", status); 523 524 if (d_unhashed(dentry)) 525 return -EAGAIN; 526 527 return status; 528 } 529 spin_unlock(&sbi->fs_lock); 530 531 return 0; 532 } 533 534 /* Perform an expiry operation */ 535 int autofs_expire_run(struct super_block *sb, 536 struct vfsmount *mnt, 537 struct autofs_sb_info *sbi, 538 struct autofs_packet_expire __user *pkt_p) 539 { 540 struct autofs_packet_expire pkt; 541 struct autofs_info *ino; 542 struct dentry *dentry; 543 int ret = 0; 544 545 memset(&pkt, 0, sizeof(pkt)); 546 547 pkt.hdr.proto_version = sbi->version; 548 pkt.hdr.type = autofs_ptype_expire; 549 550 dentry = autofs_expire_indirect(sb, mnt, sbi, 0); 551 if (!dentry) 552 return -EAGAIN; 553 554 pkt.len = dentry->d_name.len; 555 memcpy(pkt.name, dentry->d_name.name, pkt.len); 556 pkt.name[pkt.len] = '\0'; 557 558 if (copy_to_user(pkt_p, &pkt, sizeof(struct autofs_packet_expire))) 559 ret = -EFAULT; 560 561 spin_lock(&sbi->fs_lock); 562 ino = autofs_dentry_ino(dentry); 563 /* avoid rapid-fire expire attempts if expiry fails */ 564 ino->last_used = jiffies; 565 ino->flags &= ~(AUTOFS_INF_EXPIRING|AUTOFS_INF_WANT_EXPIRE); 566 complete_all(&ino->expire_complete); 567 spin_unlock(&sbi->fs_lock); 568 569 dput(dentry); 570 571 return ret; 572 } 573 574 int autofs_do_expire_multi(struct super_block *sb, struct vfsmount *mnt, 575 struct autofs_sb_info *sbi, unsigned int how) 576 { 577 struct dentry *dentry; 578 int ret = -EAGAIN; 579 580 if (autofs_type_trigger(sbi->type)) 581 dentry = autofs_expire_direct(sb, mnt, sbi, how); 582 else 583 dentry = autofs_expire_indirect(sb, mnt, sbi, how); 584 585 if (dentry) { 586 struct autofs_info *ino = autofs_dentry_ino(dentry); 587 const struct path path = { .mnt = mnt, .dentry = dentry }; 588 589 /* This is synchronous because it makes the daemon a 590 * little easier 591 */ 592 ret = autofs_wait(sbi, &path, NFY_EXPIRE); 593 594 spin_lock(&sbi->fs_lock); 595 /* avoid rapid-fire expire attempts if expiry fails */ 596 ino->last_used = jiffies; 597 ino->flags &= ~(AUTOFS_INF_EXPIRING|AUTOFS_INF_WANT_EXPIRE); 598 complete_all(&ino->expire_complete); 599 spin_unlock(&sbi->fs_lock); 600 dput(dentry); 601 } 602 603 return ret; 604 } 605 606 /* 607 * Call repeatedly until it returns -EAGAIN, meaning there's nothing 608 * more to be done. 609 */ 610 int autofs_expire_multi(struct super_block *sb, struct vfsmount *mnt, 611 struct autofs_sb_info *sbi, int __user *arg) 612 { 613 unsigned int how = 0; 614 615 if (arg && get_user(how, arg)) 616 return -EFAULT; 617 618 return autofs_do_expire_multi(sb, mnt, sbi, how); 619 } 620