1 files changed, 249 insertions, 0 deletions

diff --git a/fs/autofs/dirhash.c b/fs/autofs/dirhash.c
new file mode 100644
index 000000000000..448143fd0796
--- /dev/null
+++ b/fs/autofs/dirhash.c
@@ -0,0 +1,249 @@
+/* -*- linux-c -*- --------------------------------------------------------- *
+ *
+ * linux/fs/autofs/dirhash.c
+ *
+ *  Copyright 1997-1998 Transmeta Corporation -- All Rights Reserved
+ *
+ * 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
+ * option, any later version, incorporated herein by reference.
+ *
+ * ------------------------------------------------------------------------- */
+
+#include "autofs_i.h"
+
+/* Functions for maintenance of expiry queue */
+
+static void autofs_init_usage(struct autofs_dirhash *dh,
+                              struct autofs_dir_ent *ent)
+{
+        list_add_tail(&ent->exp, &dh->expiry_head);
+        ent->last_usage = jiffies;
+}
+
+static void autofs_delete_usage(struct autofs_dir_ent *ent)
+{
+        list_del(&ent->exp);
+}
+
+void autofs_update_usage(struct autofs_dirhash *dh,
+                         struct autofs_dir_ent *ent)
+{
+        autofs_delete_usage(ent);   /* Unlink from current position */
+        autofs_init_usage(dh,ent);  /* Relink at queue tail */
+}
+
+struct autofs_dir_ent *autofs_expire(struct super_block *sb,
+                                     struct autofs_sb_info *sbi,
+                                     struct vfsmount *mnt)
+{
+        struct autofs_dirhash *dh = &sbi->dirhash;
+        struct autofs_dir_ent *ent;
+        struct dentry *dentry;
+        unsigned long timeout = sbi->exp_timeout;
+
+        while (1) {
+                if ( list_empty(&dh->expiry_head) || sbi->catatonic )
+                        return NULL;    /* No entries */
+                /* We keep the list sorted by last_usage and want old stuff */
+                ent = list_entry(dh->expiry_head.next, struct autofs_dir_ent, exp);
+                if (jiffies - ent->last_usage < timeout)
+                        break;
+                /* Move to end of list in case expiry isn't desirable */
+                autofs_update_usage(dh, ent);
+
+                /* Check to see that entry is expirable */
+                if ( ent->ino < AUTOFS_FIRST_DIR_INO )
+                        return ent; /* Symlinks are always expirable */
+
+                /* Get the dentry for the autofs subdirectory */
+                dentry = ent->dentry;
+
+                if ( !dentry ) {
+                        /* Should only happen in catatonic mode */
+                        printk("autofs: dentry == NULL but inode range is directory, entry %s\n", ent->name);
+                        autofs_delete_usage(ent);
+                        continue;
+                }
+
+                if ( !dentry->d_inode ) {
+                        dput(dentry);
+                        printk("autofs: negative dentry on expiry queue: %s\n",
+                               ent->name);
+                        autofs_delete_usage(ent);
+                        continue;
+                }
+
+                /* Make sure entry is mounted and unused; note that dentry will
+                   point to the mounted-on-top root. */
+                if (!S_ISDIR(dentry->d_inode->i_mode)||!d_mountpoint(dentry)) {
+                        DPRINTK(("autofs: not expirable (not a mounted directory): %s\n", ent->name));
+                        continue;
+                }
+                mntget(mnt);
+                dget(dentry);
+                if (!follow_down(&mnt, &dentry)) {
+                        dput(dentry);
+                        mntput(mnt);
+                        DPRINTK(("autofs: not expirable (not a mounted directory): %s\n", ent->name));
+                        continue;
+                }
+                while (d_mountpoint(dentry) && follow_down(&mnt, &dentry))
+                        ;
+                dput(dentry);
+
+                if ( may_umount(mnt) == 0 ) {
+                        mntput(mnt);
+                        DPRINTK(("autofs: signaling expire on %s\n", ent->name));
+                        return ent; /* Expirable! */
+                }
+                DPRINTK(("autofs: didn't expire due to may_umount: %s\n", ent->name));
+                mntput(mnt);
+        }
+        return NULL;            /* No expirable entries */
+}
+
+void autofs_initialize_hash(struct autofs_dirhash *dh) {
+        memset(&dh->h, 0, AUTOFS_HASH_SIZE*sizeof(struct autofs_dir_ent *));
+        INIT_LIST_HEAD(&dh->expiry_head);
+}
+
+struct autofs_dir_ent *autofs_hash_lookup(const struct autofs_dirhash *dh, struct qstr *name)
+{
+        struct autofs_dir_ent *dhn;
+
+        DPRINTK(("autofs_hash_lookup: hash = 0x%08x, name = ", name->hash));
+        autofs_say(name->name,name->len);
+
+        for ( dhn = dh->h[(unsigned) name->hash % AUTOFS_HASH_SIZE] ; dhn ; dhn = dhn->next ) {
+                if ( name->hash == dhn->hash &&
+                     name->len == dhn->len &&
+                     !memcmp(name->name, dhn->name, name->len) )
+                        break;
+        }
+
+        return dhn;
+}
+
+void autofs_hash_insert(struct autofs_dirhash *dh, struct autofs_dir_ent *ent)
+{
+        struct autofs_dir_ent **dhnp;
+
+        DPRINTK(("autofs_hash_insert: hash = 0x%08x, name = ", ent->hash));
+        autofs_say(ent->name,ent->len);
+
+        autofs_init_usage(dh,ent);
+        if (ent->dentry)
+                dget(ent->dentry);
+
+        dhnp = &dh->h[(unsigned) ent->hash % AUTOFS_HASH_SIZE];
+        ent->next = *dhnp;
+        ent->back = dhnp;
+        *dhnp = ent;
+        if ( ent->next )
+                ent->next->back = &(ent->next);
+}
+
+void autofs_hash_delete(struct autofs_dir_ent *ent)
+{
+        *(ent->back) = ent->next;
+        if ( ent->next )
+                ent->next->back = ent->back;
+
+        autofs_delete_usage(ent);
+
+        if ( ent->dentry )
+                dput(ent->dentry);
+        kfree(ent->name);
+        kfree(ent);
+}
+
+/*
+ * Used by readdir().  We must validate "ptr", so we can't simply make it
+ * a pointer.  Values below 0xffff are reserved; calling with any value
+ * <= 0x10000 will return the first entry found.
+ *
+ * "last" can be NULL or the value returned by the last search *if* we
+ * want the next sequential entry.
+ */
+struct autofs_dir_ent *autofs_hash_enum(const struct autofs_dirhash *dh,
+                                        off_t *ptr, struct autofs_dir_ent *last)
+{
+        int bucket, ecount, i;
+        struct autofs_dir_ent *ent;
+
+        bucket = (*ptr >> 16) - 1;
+        ecount = *ptr & 0xffff;
+
+        if ( bucket < 0 ) {
+                bucket = ecount = 0;
+        } 
+
+        DPRINTK(("autofs_hash_enum: bucket %d, entry %d\n", bucket, ecount));
+
+        ent = last ? last->next : NULL;
+
+        if ( ent ) {
+                ecount++;
+        } else {
+                while  ( bucket < AUTOFS_HASH_SIZE ) {
+                        ent = dh->h[bucket];
+                        for ( i = ecount ; ent && i ; i-- )
+                                ent = ent->next;
+                        
+                        if (ent) {
+                                ecount++; /* Point to *next* entry */
+                                break;
+                        }
+                        
+                        bucket++; ecount = 0;
+                }
+        }
+
+#ifdef DEBUG
+        if ( !ent )
+                printk("autofs_hash_enum: nothing found\n");
+        else {
+                printk("autofs_hash_enum: found hash %08x, name", ent->hash);
+                autofs_say(ent->name,ent->len);
+        }
+#endif
+
+        *ptr = ((bucket+1) << 16) + ecount;
+        return ent;
+}
+
+/* Iterate over all the ents, and remove all dentry pointers.  Used on
+   entering catatonic mode, in order to make the filesystem unmountable. */
+void autofs_hash_dputall(struct autofs_dirhash *dh)
+{
+        int i;
+        struct autofs_dir_ent *ent;
+
+        for ( i = 0 ; i < AUTOFS_HASH_SIZE ; i++ ) {
+                for ( ent = dh->h[i] ; ent ; ent = ent->next ) {
+                        if ( ent->dentry ) {
+                                dput(ent->dentry);
+                                ent->dentry = NULL;
+                        }
+                }
+        }
+}
+
+/* Delete everything.  This is used on filesystem destruction, so we
+   make no attempt to keep the pointers valid */
+void autofs_hash_nuke(struct autofs_dirhash *dh)
+{
+        int i;
+        struct autofs_dir_ent *ent, *nent;
+
+        for ( i = 0 ; i < AUTOFS_HASH_SIZE ; i++ ) {
+                for ( ent = dh->h[i] ; ent ; ent = nent ) {
+                        nent = ent->next;
+                        if ( ent->dentry )
+                                dput(ent->dentry);
+                        kfree(ent->name);
+                        kfree(ent);
+                }
+        }
+}