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