[PATCH] autofs4: expire mounts that hold no (extra) references only

Alter the expire semantics that define how "busyness" is determined.
Currently a last_used counter is updated on every revalidate from processes
other than the mount owner process group.

This patch changes that so that an expire candidate is busy only if it has a
reference count greater than the expected minimum, such as when there is an
open file or working directory in use.

This method is the only way that busyness can be established for direct mounts
within the new implementation.  For consistency the expire semantic is made
the same for all mounts.

A side effect of the patch is that mounts which remain mounted unessessarily
in the presence of some GUI programs that scan the filesystem should now
expire.

Signed-off-by: Ian Kent <raven@themaw.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

2 files changed, 26 insertions, 14 deletions

diff --git a/fs/autofs4/expire.c b/fs/autofs4/expire.c
index 053d92a745b9..6ae2fc8233ff 100644
--- a/fs/autofs4/expire.c
+++ b/fs/autofs4/expire.c
@@ -47,6 +47,7 @@ static inline int autofs4_can_expire(struct dentry *dentry,
 /* Check a mount point for busyness */
 static int autofs4_mount_busy(struct vfsmount *mnt, struct dentry *dentry)
 {
+        struct dentry *top = dentry;
         int status = 1;
 
         DPRINTK("dentry %p %.*s",
@@ -62,9 +63,14 @@ static int autofs4_mount_busy(struct vfsmount *mnt, struct dentry *dentry)
         if (is_autofs4_dentry(dentry))
                 goto done;
 
-        /* The big question */
-        if (may_umount_tree(mnt) == 0)
-                status = 0;
+        /* 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);
@@ -101,7 +107,7 @@ static int autofs4_tree_busy(struct vfsmount *mnt,
                              unsigned long timeout,
                              int do_now)
 {
-        struct autofs_info *ino;
+        struct autofs_info *top_ino = autofs4_dentry_ino(top);
         struct dentry *p;
 
         DPRINTK("top %p %.*s",
@@ -127,14 +133,16 @@ static int autofs4_tree_busy(struct vfsmount *mnt,
                  * 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.
                  */
-                ino = autofs4_dentry_ino(p);
                 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 */
@@ -144,6 +152,7 @@ static int autofs4_tree_busy(struct vfsmount *mnt,
                                 ino_count++;
 
                         if (atomic_read(&p->d_count) > ino_count) {
+                                top_ino->last_used = jiffies;
                                 dput(p);
                                 return 1;
                         }
@@ -183,14 +192,13 @@ static struct dentry *autofs4_check_leaves(struct vfsmount *mnt,
                 spin_unlock(&dcache_lock);
 
                 if (d_mountpoint(p)) {
-                        /* Can we expire this guy */
-                        if (!autofs4_can_expire(p, timeout, do_now))
+                        /* Can we umount this guy */
+                        if (autofs4_mount_busy(mnt, p))
                                 goto cont;
 
-                        /* Can we umount this guy */
-                        if (!autofs4_mount_busy(mnt, p))
+                        /* Can we expire this guy */
+                        if (autofs4_can_expire(p, timeout, do_now))
                                 return p;
-
                 }
 cont:
                 dput(p);
@@ -246,12 +254,12 @@ static struct dentry *autofs4_expire(struct super_block *sb,
                         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_mount_busy(mnt, dentry)) {
+                        /* Can we expire this guy */
+                        if (autofs4_can_expire(dentry, timeout, do_now)) {
                                 expired = dentry;
                                 break;
                         }
diff --git a/fs/autofs4/root.c b/fs/autofs4/root.c
index d196712c4b94..3a4a5b47575c 100644
--- a/fs/autofs4/root.c
+++ b/fs/autofs4/root.c
@@ -330,6 +330,10 @@ static int try_to_fill_dentry(struct vfsmount *mnt, struct dentry *dentry, int f
         if (!autofs4_oz_mode(sbi))
                 autofs4_update_usage(mnt, dentry);
 
+        /* Initialize expiry counter after successful mount */
+        if (ino)
+                ino->last_used = jiffies;
+
         spin_lock(&dentry->d_lock);
         dentry->d_flags &= ~DCACHE_AUTOFS_PENDING;
         spin_unlock(&dentry->d_lock);