fs/autofs/expire.c

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