fs/autofs4/expire.c

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