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