1 files changed, 183 insertions, 109 deletions

diff --git a/fs/autofs4/expire.c b/fs/autofs4/expire.c
index dc39589df165..b8ce02607d66 100644
--- a/fs/autofs4/expire.c
+++ b/fs/autofs4/expire.c
@@ -4,7 +4,7 @@
  *
  *  Copyright 1997-1998 Transmeta Corporation -- All Rights Reserved
  *  Copyright 1999-2000 Jeremy Fitzhardinge <jeremy@goop.org>
- *  Copyright 2001-2003 Ian Kent <raven@themaw.net>
+ *  Copyright 2001-2006 Ian Kent <raven@themaw.net>
  *
  * This file is part of the Linux kernel and is made available under
  * the terms of the GNU General Public License, version 2, or at your
@@ -16,7 +16,7 @@
 
 static unsigned long now;
 
-/* Check if a dentry can be expired return 1 if it can else return 0 */
+/* Check if a dentry can be expired */
 static inline int autofs4_can_expire(struct dentry *dentry,
                                         unsigned long timeout, int do_now)
 {
@@ -41,14 +41,14 @@ static inline int autofs4_can_expire(struct dentry *dentry,
                      attempts if expire fails the first time */
                 ino->last_used = now;
         }
-
         return 1;
 }
 
-/* Check a mount point for busyness return 1 if not busy, otherwise */
-static int autofs4_check_mount(struct vfsmount *mnt, struct dentry *dentry)
+/* Check a mount point for busyness */
+static int autofs4_mount_busy(struct vfsmount *mnt, struct dentry *dentry)
 {
-        int status = 0;
+        struct dentry *top = dentry;
+        int status = 1;
 
         DPRINTK("dentry %p %.*s",
                 dentry, (int)dentry->d_name.len, dentry->d_name.name);
@@ -63,9 +63,14 @@ static int autofs4_check_mount(struct vfsmount *mnt, struct dentry *dentry)
         if (is_autofs4_dentry(dentry))
                 goto done;
 
-        /* The big question */
-        if (may_umount_tree(mnt) == 0)
-                status = 1;
+        /* Update the expiry counter if fs is busy */
+        if (!may_umount_tree(mnt)) {
+                struct autofs_info *ino = autofs4_dentry_ino(top);
+                ino->last_used = jiffies;
+                goto done;
+        }
+
+        status = 0;
 done:
         DPRINTK("returning = %d", status);
         mntput(mnt);
@@ -73,78 +78,124 @@ done:
         return status;
 }
 
+/*
+ * Calculate next entry in top down tree traversal.
+ * From next_mnt in namespace.c - elegant.
+ */
+static struct dentry *next_dentry(struct dentry *p, struct dentry *root)
+{
+        struct list_head *next = p->d_subdirs.next;
+
+        if (next == &p->d_subdirs) {
+                while (1) {
+                        if (p == root)
+                                return NULL;
+                        next = p->d_u.d_child.next;
+                        if (next != &p->d_parent->d_subdirs)
+                                break;
+                        p = p->d_parent;
+                }
+        }
+        return list_entry(next, struct dentry, d_u.d_child);
+}
+
+/*
+ * Check a direct mount point for busyness.
+ * Direct mounts have similar expiry semantics to tree mounts.
+ * The tree is not busy iff no mountpoints are busy and there are no
+ * autofs submounts.
+ */
+static int autofs4_direct_busy(struct vfsmount *mnt,
+                                struct dentry *top,
+                                unsigned long timeout,
+                                int do_now)
+{
+        DPRINTK("top %p %.*s",
+                top, (int) top->d_name.len, top->d_name.name);
+
+        /* If it's busy update the expiry counters */
+        if (!may_umount_tree(mnt)) {
+                struct autofs_info *ino = autofs4_dentry_ino(top);
+                if (ino)
+                        ino->last_used = jiffies;
+                return 1;
+        }
+
+        /* Timeout of a direct mount is determined by its top dentry */
+        if (!autofs4_can_expire(top, timeout, do_now))
+                return 1;
+
+        return 0;
+}
+
 /* Check a directory tree of mount points for busyness
  * The tree is not busy iff no mountpoints are busy
- * Return 1 if the tree is busy or 0 otherwise
  */
-static int autofs4_check_tree(struct vfsmount *mnt,
-                              struct dentry *top,
-                              unsigned long timeout,
-                              int do_now)
+static int autofs4_tree_busy(struct vfsmount *mnt,
+                             struct dentry *top,
+                             unsigned long timeout,
+                             int do_now)
 {
-        struct dentry *this_parent = top;
-        struct list_head *next;
+        struct autofs_info *top_ino = autofs4_dentry_ino(top);
+        struct dentry *p;
 
-        DPRINTK("parent %p %.*s",
+        DPRINTK("top %p %.*s",
                 top, (int)top->d_name.len, top->d_name.name);
 
         /* Negative dentry - give up */
         if (!simple_positive(top))
-                return 0;
-
-        /* Timeout of a tree mount is determined by its top dentry */
-        if (!autofs4_can_expire(top, timeout, do_now))
-                return 0;
-
-        /* Is someone visiting anywhere in the tree ? */
-        if (may_umount_tree(mnt))
-                return 0;
+                return 1;
 
         spin_lock(&dcache_lock);
-repeat:
-        next = this_parent->d_subdirs.next;
-resume:
-        while (next != &this_parent->d_subdirs) {
-                struct dentry *dentry = list_entry(next, struct dentry, d_u.d_child);
-
+        for (p = top; p; p = next_dentry(p, top)) {
                 /* Negative dentry - give up */
-                if (!simple_positive(dentry)) {
-                        next = next->next;
+                if (!simple_positive(p))
                         continue;
-                }
 
                 DPRINTK("dentry %p %.*s",
-                        dentry, (int)dentry->d_name.len, dentry->d_name.name);
-
-                if (!simple_empty_nolock(dentry)) {
-                        this_parent = dentry;
-                        goto repeat;
-                }
+                        p, (int) p->d_name.len, p->d_name.name);
 
-                dentry = dget(dentry);
+                p = dget(p);
                 spin_unlock(&dcache_lock);
 
-                if (d_mountpoint(dentry)) {
-                        /* First busy => tree busy */
-                        if (!autofs4_check_mount(mnt, dentry)) {
-                                dput(dentry);
-                                return 0;
+                /*
+                 * Is someone visiting anywhere in the subtree ?
+                 * If there's no mount we need to check the usage
+                 * count for the autofs dentry.
+                 * If the fs is busy update the expiry counter.
+                 */
+                if (d_mountpoint(p)) {
+                        if (autofs4_mount_busy(mnt, p)) {
+                                top_ino->last_used = jiffies;
+                                dput(p);
+                                return 1;
+                        }
+                } else {
+                        struct autofs_info *ino = autofs4_dentry_ino(p);
+                        unsigned int ino_count = atomic_read(&ino->count);
+
+                        /* allow for dget above and top is already dgot */
+                        if (p == top)
+                                ino_count += 2;
+                        else
+                                ino_count++;
+
+                        if (atomic_read(&p->d_count) > ino_count) {
+                                top_ino->last_used = jiffies;
+                                dput(p);
+                                return 1;
                         }
                 }
-
-                dput(dentry);
+                dput(p);
                 spin_lock(&dcache_lock);
-                next = next->next;
-        }
-
-        if (this_parent != top) {
-                next = this_parent->d_u.d_child.next;
-                this_parent = this_parent->d_parent;
-                goto resume;
         }
         spin_unlock(&dcache_lock);
 
-        return 1;
+        /* Timeout of a tree mount is ultimately determined by its top dentry */
+        if (!autofs4_can_expire(top, timeout, do_now))
+                return 1;
+
+        return 0;
 }
 
 static struct dentry *autofs4_check_leaves(struct vfsmount *mnt,
@@ -152,58 +203,68 @@ static struct dentry *autofs4_check_leaves(struct vfsmount *mnt,
                                            unsigned long timeout,
                                            int do_now)
 {
-        struct dentry *this_parent = parent;
-        struct list_head *next;
+        struct dentry *p;
 
         DPRINTK("parent %p %.*s",
                 parent, (int)parent->d_name.len, parent->d_name.name);
 
         spin_lock(&dcache_lock);
-repeat:
-        next = this_parent->d_subdirs.next;
-resume:
-        while (next != &this_parent->d_subdirs) {
-                struct dentry *dentry = list_entry(next, struct dentry, d_u.d_child);
-
+        for (p = parent; p; p = next_dentry(p, parent)) {
                 /* Negative dentry - give up */
-                if (!simple_positive(dentry)) {
-                        next = next->next;
+                if (!simple_positive(p))
                         continue;
-                }
 
                 DPRINTK("dentry %p %.*s",
-                        dentry, (int)dentry->d_name.len, dentry->d_name.name);
-
-                if (!list_empty(&dentry->d_subdirs)) {
-                        this_parent = dentry;
-                        goto repeat;
-                }
+                        p, (int) p->d_name.len, p->d_name.name);
 
-                dentry = dget(dentry);
+                p = dget(p);
                 spin_unlock(&dcache_lock);
 
-                if (d_mountpoint(dentry)) {
-                        /* Can we expire this guy */
-                        if (!autofs4_can_expire(dentry, timeout, do_now))
-                                goto cont;
-
+                if (d_mountpoint(p)) {
                         /* Can we umount this guy */
-                        if (autofs4_check_mount(mnt, dentry))
-                                return dentry;
+                        if (autofs4_mount_busy(mnt, p))
+                                goto cont;
 
+                        /* Can we expire this guy */
+                        if (autofs4_can_expire(p, timeout, do_now))
+                                return p;
                 }
 cont:
-                dput(dentry);
+                dput(p);
                 spin_lock(&dcache_lock);
-                next = next->next;
         }
+        spin_unlock(&dcache_lock);
+        return NULL;
+}
+
+/* Check if we can expire a direct mount (possibly a tree) */
+static struct dentry *autofs4_expire_direct(struct super_block *sb,
+                                            struct vfsmount *mnt,
+                                            struct autofs_sb_info *sbi,
+                                            int how)
+{
+        unsigned long timeout;
+        struct dentry *root = dget(sb->s_root);
+        int do_now = how & AUTOFS_EXP_IMMEDIATE;
+
+        if (!sbi->exp_timeout || !root)
+                return NULL;
+
+        now = jiffies;
+        timeout = sbi->exp_timeout;
+
+        /* Lock the tree as we must expire as a whole */
+        spin_lock(&sbi->fs_lock);
+        if (!autofs4_direct_busy(mnt, root, timeout, do_now)) {
+                struct autofs_info *ino = autofs4_dentry_ino(root);
 
-        if (this_parent != parent) {
-                next = this_parent->d_u.d_child.next;
-                this_parent = this_parent->d_parent;
-                goto resume;
+                /* Set this flag early to catch sys_chdir and the like */
+                ino->flags |= AUTOFS_INF_EXPIRING;
+                spin_unlock(&sbi->fs_lock);
+                return root;
         }
-        spin_unlock(&dcache_lock);
+        spin_unlock(&sbi->fs_lock);
+        dput(root);
 
         return NULL;
 }
@@ -214,10 +275,10 @@ cont:
  *  - it is unused by any user process
  *  - it has been unused for exp_timeout time
  */
-static struct dentry *autofs4_expire(struct super_block *sb,
-                                     struct vfsmount *mnt,
-                                     struct autofs_sb_info *sbi,
-                                     int how)
+static struct dentry *autofs4_expire_indirect(struct super_block *sb,
+                                              struct vfsmount *mnt,
+                                              struct autofs_sb_info *sbi,
+                                              int how)
 {
         unsigned long timeout;
         struct dentry *root = sb->s_root;
@@ -241,7 +302,7 @@ static struct dentry *autofs4_expire(struct super_block *sb,
                 struct dentry *dentry = list_entry(next, struct dentry, d_u.d_child);
 
                 /* Negative dentry - give up */
-                if ( !simple_positive(dentry) ) {
+                if (!simple_positive(dentry)) {
                         next = next->next;
                         continue;
                 }
@@ -249,31 +310,36 @@ static struct dentry *autofs4_expire(struct super_block *sb,
                 dentry = dget(dentry);
                 spin_unlock(&dcache_lock);
 
-                /* Case 1: indirect mount or top level direct mount */
+                /*
+                 * Case 1: (i) indirect mount or top level pseudo direct mount
+                 *         (autofs-4.1).
+                 *         (ii) indirect mount with offset mount, check the "/"
+                 *         offset (autofs-5.0+).
+                 */
                 if (d_mountpoint(dentry)) {
                         DPRINTK("checking mountpoint %p %.*s",
                                 dentry, (int)dentry->d_name.len, dentry->d_name.name);
 
-                        /* Can we expire this guy */
-                        if (!autofs4_can_expire(dentry, timeout, do_now))
+                        /* Can we umount this guy */
+                        if (autofs4_mount_busy(mnt, dentry))
                                 goto next;
 
-                        /* Can we umount this guy */
-                        if (autofs4_check_mount(mnt, dentry)) {
+                        /* Can we expire this guy */
+                        if (autofs4_can_expire(dentry, timeout, do_now)) {
                                 expired = dentry;
                                 break;
                         }
                         goto next;
                 }
 
-                if ( simple_empty(dentry) )
+                if (simple_empty(dentry))
                         goto next;
 
                 /* Case 2: tree mount, expire iff entire tree is not busy */
                 if (!exp_leaves) {
                         /* Lock the tree as we must expire as a whole */
                         spin_lock(&sbi->fs_lock);
-                        if (autofs4_check_tree(mnt, dentry, timeout, do_now)) {
+                        if (!autofs4_tree_busy(mnt, dentry, timeout, do_now)) {
                                 struct autofs_info *inf = autofs4_dentry_ino(dentry);
 
                                 /* Set this flag early to catch sys_chdir and the like */
@@ -283,7 +349,10 @@ static struct dentry *autofs4_expire(struct super_block *sb,
                                 break;
                         }
                         spin_unlock(&sbi->fs_lock);
-                /* Case 3: direct mount, expire individual leaves */
+                /*
+                 * Case 3: pseudo direct mount, expire individual leaves
+                 *         (autofs-4.1).
+                 */
                 } else {
                         expired = autofs4_check_leaves(mnt, dentry, timeout, do_now);
                         if (expired) {
@@ -297,7 +366,7 @@ next:
                 next = next->next;
         }
 
-        if ( expired ) {
+        if (expired) {
                 DPRINTK("returning %p %.*s",
                         expired, (int)expired->d_name.len, expired->d_name.name);
                 spin_lock(&dcache_lock);
@@ -325,7 +394,7 @@ int autofs4_expire_run(struct super_block *sb,
         pkt.hdr.proto_version = sbi->version;
         pkt.hdr.type = autofs_ptype_expire;
 
-        if ((dentry = autofs4_expire(sb, mnt, sbi, 0)) == NULL)
+        if ((dentry = autofs4_expire_indirect(sb, mnt, sbi, 0)) == NULL)
                 return -EAGAIN;
 
         pkt.len = dentry->d_name.len;
@@ -351,17 +420,22 @@ int autofs4_expire_multi(struct super_block *sb, struct vfsmount *mnt,
         if (arg && get_user(do_now, arg))
                 return -EFAULT;
 
-        if ((dentry = autofs4_expire(sb, mnt, sbi, do_now)) != NULL) {
-                struct autofs_info *de_info = autofs4_dentry_ino(dentry);
+        if (sbi->type & AUTOFS_TYPE_DIRECT)
+                dentry = autofs4_expire_direct(sb, mnt, sbi, do_now);
+        else
+                dentry = autofs4_expire_indirect(sb, mnt, sbi, do_now);
+
+        if (dentry) {
+                struct autofs_info *ino = autofs4_dentry_ino(dentry);
 
                 /* This is synchronous because it makes the daemon a
                    little easier */
-                de_info->flags |= AUTOFS_INF_EXPIRING;
+                ino->flags |= AUTOFS_INF_EXPIRING;
                 ret = autofs4_wait(sbi, dentry, NFY_EXPIRE);
-                de_info->flags &= ~AUTOFS_INF_EXPIRING;
+                ino->flags &= ~AUTOFS_INF_EXPIRING;
                 dput(dentry);
         }
-                
+
         return ret;
 }