*
* Copyright 1997-1998 Transmeta Corporation -- All Rights Reserved
* Copyright 1999-2000 Jeremy Fitzhardinge <jeremy@goop.org>
- * Copyright 2001-2006 Ian Kent <raven@themaw.net>
+ * Copyright 2001-2003 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
static unsigned long now;
-/* Check if a dentry can be expired */
+/* Check if a dentry can be expired return 1 if it can else return 0 */
static inline int autofs4_can_expire(struct dentry *dentry,
unsigned long timeout, int do_now)
{
attempts if expire fails the first time */
ino->last_used = now;
}
+
return 1;
}
-/* Check a mount point for busyness */
-static int autofs4_mount_busy(struct vfsmount *mnt, struct dentry *dentry)
+/* Check a mount point for busyness return 1 if not busy, otherwise */
+static int autofs4_check_mount(struct vfsmount *mnt, struct dentry *dentry)
{
- struct dentry *top = dentry;
- int status = 1;
+ int status = 0;
DPRINTK("dentry %p %.*s",
dentry, (int)dentry->d_name.len, dentry->d_name.name);
if (is_autofs4_dentry(dentry))
goto done;
- /* 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;
+ /* The big question */
+ if (may_umount_tree(mnt) == 0)
+ status = 1;
done:
DPRINTK("returning = %d", status);
mntput(mnt);
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_tree_busy(struct vfsmount *mnt,
- struct dentry *top,
- unsigned long timeout,
- int do_now)
+static int autofs4_check_tree(struct vfsmount *mnt,
+ struct dentry *top,
+ unsigned long timeout,
+ int do_now)
{
- struct autofs_info *top_ino = autofs4_dentry_ino(top);
- struct dentry *p;
+ struct dentry *this_parent = top;
+ struct list_head *next;
- DPRINTK("top %p %.*s",
+ DPRINTK("parent %p %.*s",
top, (int)top->d_name.len, top->d_name.name);
/* Negative dentry - give up */
if (!simple_positive(top))
- return 1;
+ 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;
spin_lock(&dcache_lock);
- for (p = top; p; p = next_dentry(p, top)) {
+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);
+
/* Negative dentry - give up */
- if (!simple_positive(p))
+ if (!simple_positive(dentry)) {
+ next = next->next;
continue;
+ }
DPRINTK("dentry %p %.*s",
- p, (int) p->d_name.len, p->d_name.name);
+ dentry, (int)dentry->d_name.len, dentry->d_name.name);
+
+ if (!simple_empty_nolock(dentry)) {
+ this_parent = dentry;
+ goto repeat;
+ }
- p = dget(p);
+ dentry = dget(dentry);
spin_unlock(&dcache_lock);
- /*
- * 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);
-
- /*
- * Clean stale dentries below that have not been
- * invalidated after a mount fail during lookup
- */
- d_invalidate(p);
-
- /* 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;
+ if (d_mountpoint(dentry)) {
+ /* First busy => tree busy */
+ if (!autofs4_check_mount(mnt, dentry)) {
+ dput(dentry);
+ return 0;
}
}
- dput(p);
+
+ dput(dentry);
spin_lock(&dcache_lock);
+ next = next->next;
}
- spin_unlock(&dcache_lock);
- /* Timeout of a tree mount is ultimately determined by its top dentry */
- if (!autofs4_can_expire(top, timeout, do_now))
- return 1;
+ 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 0;
+ return 1;
}
static struct dentry *autofs4_check_leaves(struct vfsmount *mnt,
unsigned long timeout,
int do_now)
{
- struct dentry *p;
+ struct dentry *this_parent = parent;
+ struct list_head *next;
DPRINTK("parent %p %.*s",
parent, (int)parent->d_name.len, parent->d_name.name);
spin_lock(&dcache_lock);
- for (p = parent; p; p = next_dentry(p, parent)) {
+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);
+
/* Negative dentry - give up */
- if (!simple_positive(p))
+ if (!simple_positive(dentry)) {
+ next = next->next;
continue;
+ }
DPRINTK("dentry %p %.*s",
- p, (int) p->d_name.len, p->d_name.name);
+ dentry, (int)dentry->d_name.len, dentry->d_name.name);
+
+ if (!list_empty(&dentry->d_subdirs)) {
+ this_parent = dentry;
+ goto repeat;
+ }
- p = dget(p);
+ dentry = dget(dentry);
spin_unlock(&dcache_lock);
- if (d_mountpoint(p)) {
- /* Can we umount this guy */
- if (autofs4_mount_busy(mnt, p))
+ if (d_mountpoint(dentry)) {
+ /* Can we expire this guy */
+ if (!autofs4_can_expire(dentry, timeout, do_now))
goto cont;
- /* Can we expire this guy */
- if (autofs4_can_expire(p, timeout, do_now))
- return p;
+ /* Can we umount this guy */
+ if (autofs4_check_mount(mnt, dentry))
+ return dentry;
+
}
cont:
- dput(p);
+ dput(dentry);
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);
- /* Set this flag early to catch sys_chdir and the like */
- ino->flags |= AUTOFS_INF_EXPIRING;
- spin_unlock(&sbi->fs_lock);
- return root;
+ if (this_parent != parent) {
+ next = this_parent->d_u.d_child.next;
+ this_parent = this_parent->d_parent;
+ goto resume;
}
- spin_unlock(&sbi->fs_lock);
- dput(root);
+ spin_unlock(&dcache_lock);
return NULL;
}
* - it is unused by any user process
* - it has been unused for exp_timeout time
*/
-static struct dentry *autofs4_expire_indirect(struct super_block *sb,
- struct vfsmount *mnt,
- struct autofs_sb_info *sbi,
- int how)
+static struct dentry *autofs4_expire(struct super_block *sb,
+ struct vfsmount *mnt,
+ struct autofs_sb_info *sbi,
+ int how)
{
unsigned long timeout;
struct dentry *root = sb->s_root;
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;
}
dentry = dget(dentry);
spin_unlock(&dcache_lock);
- /*
- * 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+).
- */
+ /* Case 1: indirect mount or top level direct mount */
if (d_mountpoint(dentry)) {
DPRINTK("checking mountpoint %p %.*s",
dentry, (int)dentry->d_name.len, dentry->d_name.name);
- /* Can we umount this guy */
- if (autofs4_mount_busy(mnt, dentry))
+ /* Can we expire this guy */
+ if (!autofs4_can_expire(dentry, timeout, do_now))
goto next;
- /* Can we expire this guy */
- if (autofs4_can_expire(dentry, timeout, do_now)) {
+ /* Can we umount this guy */
+ if (autofs4_check_mount(mnt, dentry)) {
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_tree_busy(mnt, dentry, timeout, do_now)) {
+ if (autofs4_check_tree(mnt, dentry, timeout, do_now)) {
struct autofs_info *inf = autofs4_dentry_ino(dentry);
/* Set this flag early to catch sys_chdir and the like */
break;
}
spin_unlock(&sbi->fs_lock);
- /*
- * Case 3: pseudo direct mount, expire individual leaves
- * (autofs-4.1).
- */
+ /* Case 3: direct mount, expire individual leaves */
} else {
expired = autofs4_check_leaves(mnt, dentry, timeout, do_now);
if (expired) {
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);
- list_move(&expired->d_parent->d_subdirs, &expired->d_u.d_child);
+ list_del(&expired->d_parent->d_subdirs);
+ list_add(&expired->d_parent->d_subdirs, &expired->d_u.d_child);
spin_unlock(&dcache_lock);
return expired;
}
pkt.hdr.proto_version = sbi->version;
pkt.hdr.type = autofs_ptype_expire;
- if ((dentry = autofs4_expire_indirect(sb, mnt, sbi, 0)) == NULL)
+ if ((dentry = autofs4_expire(sb, mnt, sbi, 0)) == NULL)
return -EAGAIN;
pkt.len = dentry->d_name.len;
if (arg && get_user(do_now, arg))
return -EFAULT;
- 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);
+ if ((dentry = autofs4_expire(sb, mnt, sbi, do_now)) != NULL) {
+ struct autofs_info *de_info = autofs4_dentry_ino(dentry);
/* This is synchronous because it makes the daemon a
little easier */
- ino->flags |= AUTOFS_INF_EXPIRING;
+ de_info->flags |= AUTOFS_INF_EXPIRING;
ret = autofs4_wait(sbi, dentry, NFY_EXPIRE);
- ino->flags &= ~AUTOFS_INF_EXPIRING;
+ de_info->flags &= ~AUTOFS_INF_EXPIRING;
dput(dentry);
}
-
+
return ret;
}
git://git.onelab.eu / linux-2.6.git / blobdiff