drivers/staging/autofs/dirhash.c

   1 /* -*- linux-c -*- --------------------------------------------------------- *
   2  *
   3  * drivers/staging/autofs/dirhash.c
   4  *
   5  *  Copyright 1997-1998 Transmeta Corporation -- All Rights Reserved
   6  *
   7  * This file is part of the Linux kernel and is made available under
   8  * the terms of the GNU General Public License, version 2, or at your
   9  * option, any later version, incorporated herein by reference.
  10  *
  11  * ------------------------------------------------------------------------- */
  12
  13 #include "autofs_i.h"
  14
  15 /* Functions for maintenance of expiry queue */
  16
  17 static void autofs_init_usage(struct autofs_dirhash *dh,
  18                               struct autofs_dir_ent *ent)
  19 {
  20         list_add_tail(&ent->exp, &dh->expiry_head);
  21         ent->last_usage = jiffies;
  22 }
  23
  24 static void autofs_delete_usage(struct autofs_dir_ent *ent)
  25 {
  26         list_del(&ent->exp);
  27 }
  28
  29 void autofs_update_usage(struct autofs_dirhash *dh,
  30                          struct autofs_dir_ent *ent)
  31 {
  32         autofs_delete_usage(ent);   /* Unlink from current position */
  33         autofs_init_usage(dh, ent);  /* Relink at queue tail */
  34 }
  35
  36 struct autofs_dir_ent *autofs_expire(struct super_block *sb,
  37                                      struct autofs_sb_info *sbi,
  38                                      struct vfsmount *mnt)
  39 {
  40         struct autofs_dirhash *dh = &sbi->dirhash;
  41         struct autofs_dir_ent *ent;
  42         unsigned long timeout = sbi->exp_timeout;
  43
  44         while (1) {
  45                 struct path path;
  46                 int umount_ok;
  47
  48                 if (list_empty(&dh->expiry_head) || sbi->catatonic)
  49                         return NULL;    /* No entries */
  50                 /* We keep the list sorted by last_usage and want old stuff */
  51                 ent = list_entry(dh->expiry_head.next,
  52                                                 struct autofs_dir_ent, exp);
  53                 if (jiffies - ent->last_usage < timeout)
  54                         break;
  55                 /* Move to end of list in case expiry isn't desirable */
  56                 autofs_update_usage(dh, ent);
  57
  58                 /* Check to see that entry is expirable */
  59                 if (ent->ino < AUTOFS_FIRST_DIR_INO)
  60                         return ent; /* Symlinks are always expirable */
  61
  62                 /* Get the dentry for the autofs subdirectory */
  63                 path.dentry = ent->dentry;
  64
  65                 if (!path.dentry) {
  66                         /* Should only happen in catatonic mode */
  67                         printk(KERN_DEBUG "autofs: dentry == NULL but inode \
  68                                 range is directory, entry %s\n", ent->name);
  69                         autofs_delete_usage(ent);
  70                         continue;
  71                 }
  72
  73                 if (!path.dentry->d_inode) {
  74                         dput(path.dentry);
  75                         printk(KERN_DEBUG "autofs: negative dentry on expiry queue: %s\n",
  76                                ent->name);
  77                         autofs_delete_usage(ent);
  78                         continue;
  79                 }
  80
  81                 /* Make sure entry is mounted and unused; note that dentry will
  82                    point to the mounted-on-top root. */
  83                 if (!S_ISDIR(path.dentry->d_inode->i_mode) ||
  84                     !d_mountpoint(path.dentry)) {
  85                         DPRINTK(("autofs: not expirable \
  86                                 (not a mounted directory): %s\n", ent->name));
  87                         continue;
  88                 }
  89                 path.mnt = mnt;
  90                 path_get(&path);
  91                 if (!follow_down(&path)) {
  92                         path_put(&path);
  93                         DPRINTK(("autofs: not expirable\
  94                         (not a mounted directory): %s\n", ent->name));
  95                         continue;
  96                 }
  97                 while (d_mountpoint(path.dentry) && follow_down(&path))
  98                         ;
  99                 umount_ok = may_umount(path.mnt);
 100                 path_put(&path);
 101
 102                 if (umount_ok) {
 103                         DPRINTK(("autofs: signaling expire on %s\n",
 104                                                                 ent->name));
 105                         return ent; /* Expirable! */
 106                 }
 107
 108                 DPRINTK(("autofs: didn't expire due to may_umount: %s\n",
 109                                                                 ent->name));
 110         }
 111         return NULL;            /* No expirable entries */
 112 }
 113
 114 void autofs_initialize_hash(struct autofs_dirhash *dh)
 115 {
 116         memset(&dh->h, 0, AUTOFS_HASH_SIZE*sizeof(struct autofs_dir_ent *));
 117         INIT_LIST_HEAD(&dh->expiry_head);
 118 }
 119
 120 struct autofs_dir_ent *autofs_hash_lookup(const struct autofs_dirhash *dh,
 121                                                 struct qstr *name)
 122 {
 123         struct autofs_dir_ent *dhn;
 124
 125         DPRINTK(("autofs_hash_lookup: hash = 0x%08x, name = ", name->hash));
 126         autofs_say(name->name, name->len);
 127
 128         for (dhn = dh->h[(unsigned) name->hash % AUTOFS_HASH_SIZE];
 129                 dhn;
 130                 dhn = dhn->next) {
 131                 if (name->hash == dhn->hash &&
 132                      name->len == dhn->len &&
 133                      !memcmp(name->name, dhn->name, name->len))
 134                         break;
 135         }
 136
 137         return dhn;
 138 }
 139
 140 void autofs_hash_insert(struct autofs_dirhash *dh, struct autofs_dir_ent *ent)
 141 {
 142         struct autofs_dir_ent **dhnp;
 143
 144         DPRINTK(("autofs_hash_insert: hash = 0x%08x, name = ", ent->hash));
 145         autofs_say(ent->name, ent->len);
 146
 147         autofs_init_usage(dh, ent);
 148         if (ent->dentry)
 149                 dget(ent->dentry);
 150
 151         dhnp = &dh->h[(unsigned) ent->hash % AUTOFS_HASH_SIZE];
 152         ent->next = *dhnp;
 153         ent->back = dhnp;
 154         *dhnp = ent;
 155         if (ent->next)
 156                 ent->next->back = &(ent->next);
 157 }
 158
 159 void autofs_hash_delete(struct autofs_dir_ent *ent)
 160 {
 161         *(ent->back) = ent->next;
 162         if (ent->next)
 163                 ent->next->back = ent->back;
 164
 165         autofs_delete_usage(ent);
 166
 167         if (ent->dentry)
 168                 dput(ent->dentry);
 169         kfree(ent->name);
 170         kfree(ent);
 171 }
 172
 173 /*
 174  * Used by readdir().  We must validate "ptr", so we can't simply make it
 175  * a pointer.  Values below 0xffff are reserved; calling with any value
 176  * <= 0x10000 will return the first entry found.
 177  *
 178  * "last" can be NULL or the value returned by the last search *if* we
 179  * want the next sequential entry.
 180  */
 181 struct autofs_dir_ent *autofs_hash_enum(const struct autofs_dirhash *dh,
 182                                         off_t *ptr, struct autofs_dir_ent *last)
 183 {
 184         int bucket, ecount, i;
 185         struct autofs_dir_ent *ent;
 186
 187         bucket = (*ptr >> 16) - 1;
 188         ecount = *ptr & 0xffff;
 189
 190         if (bucket < 0)
 191                 bucket = ecount = 0;
 192
 193         DPRINTK(("autofs_hash_enum: bucket %d, entry %d\n", bucket, ecount));
 194
 195         ent = last ? last->next : NULL;
 196
 197         if (ent) {
 198                 ecount++;
 199         } else {
 200                 while  (bucket < AUTOFS_HASH_SIZE) {
 201                         ent = dh->h[bucket];
 202                         for (i = ecount ; ent && i ; i--)
 203                                 ent = ent->next;
 204
 205                         if (ent) {
 206                                 ecount++; /* Point to *next* entry */
 207                                 break;
 208                         }
 209
 210                         bucket++; ecount = 0;
 211                 }
 212         }
 213
 214 #ifdef DEBUG
 215         if (!ent)
 216                 printk(KERN_DEBUG "autofs_hash_enum: nothing found\n");
 217         else {
 218                 printk(KERN_DEBUG "autofs_hash_enum: found hash %08x, name",
 219                                                                 ent->hash);
 220                 autofs_say(ent->name, ent->len);
 221         }
 222 #endif
 223
 224         *ptr = ((bucket+1) << 16) + ecount;
 225         return ent;
 226 }
 227
 228 /* Iterate over all the ents, and remove all dentry pointers.  Used on
 229    entering catatonic mode, in order to make the filesystem unmountable. */
 230 void autofs_hash_dputall(struct autofs_dirhash *dh)
 231 {
 232         int i;
 233         struct autofs_dir_ent *ent;
 234
 235         for (i = 0 ; i < AUTOFS_HASH_SIZE ; i++) {
 236                 for (ent = dh->h[i] ; ent ; ent = ent->next) {
 237                         if (ent->dentry) {
 238                                 dput(ent->dentry);
 239                                 ent->dentry = NULL;
 240                         }
 241                 }
 242         }
 243 }
 244
 245 /* Delete everything.  This is used on filesystem destruction, so we
 246    make no attempt to keep the pointers valid */
 247 void autofs_hash_nuke(struct autofs_sb_info *sbi)
 248 {
 249         int i;
 250         struct autofs_dir_ent *ent, *nent;
 251
 252         for (i = 0 ; i < AUTOFS_HASH_SIZE ; i++) {
 253                 for (ent = sbi->dirhash.h[i] ; ent ; ent = nent) {
 254                         nent = ent->next;
 255                         if (ent->dentry)
 256                                 dput(ent->dentry);
 257                         kfree(ent->name);
 258                         kfree(ent);
 259                 }
 260         }
 261 }