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