fs/autofs4/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 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         spin_lock(&sbi->fs_lock);
 314         ino = autofs4_dentry_ino(root);
 315         /* No point expiring a pending mount */
 316         if (ino->flags & AUTOFS_INF_PENDING)
 317                 goto out;
 318         if (!autofs4_direct_busy(mnt, root, timeout, do_now)) {
 319                 ino->flags |= AUTOFS_INF_WANT_EXPIRE;
 320                 spin_unlock(&sbi->fs_lock);
 321                 synchronize_rcu();
 322                 spin_lock(&sbi->fs_lock);
 323                 if (!autofs4_direct_busy(mnt, root, timeout, do_now)) {
 324                         ino->flags |= AUTOFS_INF_EXPIRING;
 325                         init_completion(&ino->expire_complete);
 326                         spin_unlock(&sbi->fs_lock);
 327                         return root;
 328                 }
 329                 ino->flags &= ~AUTOFS_INF_WANT_EXPIRE;
 330         }
 331 out:
 332         spin_unlock(&sbi->fs_lock);
 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 = autofs4_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 (autofs4_mount_busy(mnt, dentry))
 368                         return NULL;
 369
 370                 /* Can we expire this guy */
 371                 if (autofs4_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 (autofs4_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 (!autofs4_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 = autofs4_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 *autofs4_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         now = jiffies;
 443         timeout = sbi->exp_timeout;
 444
 445         dentry = NULL;
 446         while ((dentry = get_next_positive_subdir(dentry, root))) {
 447                 int flags = how;
 448
 449                 spin_lock(&sbi->fs_lock);
 450                 ino = autofs4_dentry_ino(dentry);
 451                 if (ino->flags & AUTOFS_INF_WANT_EXPIRE) {
 452                         spin_unlock(&sbi->fs_lock);
 453                         continue;
 454                 }
 455                 spin_unlock(&sbi->fs_lock);
 456
 457                 expired = should_expire(dentry, mnt, timeout, flags);
 458                 if (!expired)
 459                         continue;
 460
 461                 spin_lock(&sbi->fs_lock);
 462                 ino = autofs4_dentry_ino(expired);
 463                 ino->flags |= AUTOFS_INF_WANT_EXPIRE;
 464                 spin_unlock(&sbi->fs_lock);
 465                 synchronize_rcu();
 466
 467                 /* Make sure a reference is not taken on found if
 468                  * things have changed.
 469                  */
 470                 flags &= ~AUTOFS_EXP_LEAVES;
 471                 found = should_expire(expired, mnt, timeout, how);
 472                 if (!found || found != expired)
 473                         /* Something has changed, continue */
 474                         goto next;
 475
 476                 if (expired != dentry)
 477                         dput(dentry);
 478
 479                 spin_lock(&sbi->fs_lock);
 480                 goto found;
 481 next:
 482                 spin_lock(&sbi->fs_lock);
 483                 ino->flags &= ~AUTOFS_INF_WANT_EXPIRE;
 484                 spin_unlock(&sbi->fs_lock);
 485                 if (expired != dentry)
 486                         dput(expired);
 487         }
 488         return NULL;
 489
 490 found:
 491         pr_debug("returning %p %pd\n", expired, expired);
 492         ino->flags |= AUTOFS_INF_EXPIRING;
 493         init_completion(&ino->expire_complete);
 494         spin_unlock(&sbi->fs_lock);
 495         return expired;
 496 }
 497
 498 int autofs4_expire_wait(struct dentry *dentry, int rcu_walk)
 499 {
 500         struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
 501         struct autofs_info *ino = autofs4_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 = autofs4_wait(sbi, dentry, 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 autofs4_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 = autofs4_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 = autofs4_dentry_ino(dentry);
 573         /* avoid rapid-fire expire attempts if expiry fails */
 574         ino->last_used = now;
 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 autofs4_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 = autofs4_expire_direct(sb, mnt, sbi, when);
 590         else
 591                 dentry = autofs4_expire_indirect(sb, mnt, sbi, when);
 592
 593         if (dentry) {
 594                 struct autofs_info *ino = autofs4_dentry_ino(dentry);
 595
 596                 /* This is synchronous because it makes the daemon a
 597                  * little easier
 598                  */
 599                 ret = autofs4_wait(sbi, dentry, NFY_EXPIRE);
 600
 601                 spin_lock(&sbi->fs_lock);
 602                 /* avoid rapid-fire expire attempts if expiry fails */
 603                 ino->last_used = now;
 604                 ino->flags &= ~(AUTOFS_INF_EXPIRING|AUTOFS_INF_WANT_EXPIRE);
 605                 complete_all(&ino->expire_complete);
 606                 spin_unlock(&sbi->fs_lock);
 607                 dput(dentry);
 608         }
 609
 610         return ret;
 611 }
 612
 613 /*
 614  * Call repeatedly until it returns -EAGAIN, meaning there's nothing
 615  * more to be done.
 616  */
 617 int autofs4_expire_multi(struct super_block *sb, struct vfsmount *mnt,
 618                         struct autofs_sb_info *sbi, int __user *arg)
 619 {
 620         int do_now = 0;
 621
 622         if (arg && get_user(do_now, arg))
 623                 return -EFAULT;
 624
 625         return autofs4_do_expire_multi(sb, mnt, sbi, do_now);
 626 }
 627