fs/autofs4/expire.c

   1 /*
   2  * Copyright 1997-1998 Transmeta Corporation -- All Rights Reserved
   3  * Copyright 1999-2000 Jeremy Fitzhardinge <[email protected]>
   4  * Copyright 2001-2006 Ian Kent <[email protected]>
   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 autofs4_can_expire(struct dentry *dentry,
  17                                      unsigned long timeout, int do_now)
  18 {
  19         struct autofs_info *ino = autofs4_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 autofs4_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_autofs4_dentry(path.dentry)) {
  48                 struct autofs_sb_info *sbi = autofs4_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 = autofs4_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 = autofs4_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 = autofs4_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 autofs4_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 = autofs4_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 (!autofs4_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 autofs4_tree_busy(struct vfsmount *mnt,
 216                              struct dentry *top,
 217                              unsigned long timeout,
 218                              int do_now)
 219 {
 220         struct autofs_info *top_ino = autofs4_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 (autofs4_mount_busy(mnt, p)) {
 241                                 top_ino->last_used = jiffies;
 242                                 dput(p);
 243                                 return 1;
 244                         }
 245                 } else {
 246                         struct autofs_info *ino = autofs4_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 (!autofs4_can_expire(top, timeout, do_now))
 265                 return 1;
 266
 267         return 0;
 268 }
 269
 270 static struct dentry *autofs4_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 (autofs4_mount_busy(mnt, p))
 286                                 continue;
 287
 288                         /* Can we expire this guy */
 289                         if (autofs4_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 *autofs4_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 (!autofs4_direct_busy(mnt, root, timeout, do_now)) {
 314                 spin_lock(&sbi->fs_lock);
 315                 ino = autofs4_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 (!autofs4_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 = autofs4_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 (autofs4_mount_busy(mnt, dentry))
 371                         return NULL;
 372
 373                 /* Can we expire this guy */
 374                 if (autofs4_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 (autofs4_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 (!autofs4_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 = autofs4_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 *autofs4_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 = autofs4_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 = autofs4_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 autofs4_expire_wait(const struct path *path, int rcu_walk)
 502 {
 503         struct dentry *dentry = path->dentry;
 504         struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
 505         struct autofs_info *ino = autofs4_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 = autofs4_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 autofs4_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 = autofs4_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 = autofs4_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 autofs4_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 = autofs4_expire_direct(sb, mnt, sbi, when);
 594         else
 595                 dentry = autofs4_expire_indirect(sb, mnt, sbi, when);
 596
 597         if (dentry) {
 598                 struct autofs_info *ino = autofs4_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 = autofs4_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 autofs4_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 autofs4_do_expire_multi(sb, mnt, sbi, do_now);
 631 }
 632