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