contrib/spd_readdir.c

   1 /*
   2  * readdir accelerator
   3  *
   4  * (C) Copyright 2003, 2004 by Theodore Ts'o.
   5  *
   6  * Compile using the command:
   7  *
   8  * gcc -o spd_readdir.so -fPIC -shared spd_readdir.c -ldl
   9  *
  10  * Use it by setting the LD_PRELOAD environment variable:
  11  *
  12  * export LD_PRELOAD=/usr/local/sbin/spd_readdir.so
  13  *
  14  * Note that this preload is not going to work for all programs.  In
  15  * particular, although it does supply readdir_r(), it is *not* thread
  16  * safe.  So I can't recommend this as something to be dropped in
  17  * /etc/ld.so.preload.
  18  *
  19  * %Begin-Header%
  20  * This file may be redistributed under the terms of the GNU Public
  21  * License.
  22  * %End-Header%
  23  *
  24  */
  25
  26 #define ALLOC_STEPSIZE  100
  27 #define MAX_DIRSIZE     0
  28
  29 #define DEBUG
  30
  31 #ifdef DEBUG
  32 #define DEBUG_DIR(x)    {if (do_debug) { x; }}
  33 #else
  34 #define DEBUG_DIR(x)
  35 #endif
  36
  37 #define _GNU_SOURCE
  38 #define __USE_LARGEFILE64
  39
  40 #include <stdio.h>
  41 #include <unistd.h>
  42 #include <sys/types.h>
  43 #include <sys/stat.h>
  44 #include <stdlib.h>
  45 #include <string.h>
  46 #include <dirent.h>
  47 #include <errno.h>
  48 #include <dlfcn.h>
  49
  50 struct dirent_s {
  51         unsigned long long d_ino;
  52         long long d_off;
  53         unsigned short int d_reclen;
  54         unsigned char d_type;
  55         char *d_name;
  56 };
  57
  58 struct dir_s {
  59         DIR     *dir;
  60         int     num;
  61         int     max;
  62         struct dirent_s *dp;
  63         int     pos;
  64         int     direct;
  65         struct dirent ret_dir;
  66         struct dirent64 ret_dir64;
  67 };
  68
  69 static int (*real_closedir)(DIR *dir) = 0;
  70 static DIR *(*real_opendir)(const char *name) = 0;
  71 static DIR *(*real_fdopendir)(int fd) = 0;
  72 static void *(*real_rewinddir)(DIR *dirp) = 0;
  73 static struct dirent *(*real_readdir)(DIR *dir) = 0;
  74 static int (*real_readdir_r)(DIR *dir, struct dirent *entry,
  75                              struct dirent **result) = 0;
  76 static struct dirent64 *(*real_readdir64)(DIR *dir) = 0;
  77 static off_t (*real_telldir)(DIR *dir) = 0;
  78 static void (*real_seekdir)(DIR *dir, off_t offset) = 0;
  79 static int (*real_dirfd)(DIR *dir) = 0;
  80 static unsigned long max_dirsize = MAX_DIRSIZE;
  81 static int num_open = 0;
  82 #ifdef DEBUG
  83 static int do_debug = 0;
  84 #endif
  85
  86 static void setup_ptr()
  87 {
  88         char *cp;
  89
  90         real_opendir = dlsym(RTLD_NEXT, "opendir");
  91         real_fdopendir = dlsym(RTLD_NEXT, "fdopendir");
  92         real_closedir = dlsym(RTLD_NEXT, "closedir");
  93         real_rewinddir = dlsym(RTLD_NEXT, "rewinddir");
  94         real_readdir = dlsym(RTLD_NEXT, "readdir");
  95         real_readdir_r = dlsym(RTLD_NEXT, "readdir_r");
  96         real_readdir64 = dlsym(RTLD_NEXT, "readdir64");
  97         real_telldir = dlsym(RTLD_NEXT, "telldir");
  98         real_seekdir = dlsym(RTLD_NEXT, "seekdir");
  99         real_dirfd = dlsym(RTLD_NEXT, "dirfd");
 100         if ((cp = getenv("SPD_READDIR_MAX_SIZE")) != NULL) {
 101                 max_dirsize = atol(cp);
 102         }
 103 #ifdef DEBUG
 104         if (getenv("SPD_READDIR_DEBUG")) {
 105                 printf("initialized!\n");
 106                 do_debug++;
 107         }
 108 #endif
 109 }
 110
 111 static void free_cached_dir(struct dir_s *dirstruct)
 112 {
 113         int i;
 114
 115         if (!dirstruct->dp)
 116                 return;
 117
 118         for (i=0; i < dirstruct->num; i++) {
 119                 free(dirstruct->dp[i].d_name);
 120         }
 121         free(dirstruct->dp);
 122         dirstruct->dp = 0;
 123         dirstruct->max = dirstruct->num = 0;
 124 }
 125
 126 static int ino_cmp(const void *a, const void *b)
 127 {
 128         const struct dirent_s *ds_a = (const struct dirent_s *) a;
 129         const struct dirent_s *ds_b = (const struct dirent_s *) b;
 130         ino_t i_a, i_b;
 131
 132         i_a = ds_a->d_ino;
 133         i_b = ds_b->d_ino;
 134
 135         if (ds_a->d_name[0] == '.') {
 136                 if (ds_a->d_name[1] == 0)
 137                         i_a = 0;
 138                 else if ((ds_a->d_name[1] == '.') && (ds_a->d_name[2] == 0))
 139                         i_a = 1;
 140         }
 141         if (ds_b->d_name[0] == '.') {
 142                 if (ds_b->d_name[1] == 0)
 143                         i_b = 0;
 144                 else if ((ds_b->d_name[1] == '.') && (ds_b->d_name[2] == 0))
 145                         i_b = 1;
 146         }
 147
 148         return (i_a - i_b);
 149 }
 150
 151 struct dir_s *alloc_dirstruct(DIR *dir)
 152 {
 153         struct dir_s    *dirstruct;
 154
 155         dirstruct = malloc(sizeof(struct dir_s));
 156         if (dirstruct)
 157                 memset(dirstruct, 0, sizeof(struct dir_s));
 158         dirstruct->dir = dir;
 159         return dirstruct;
 160 }
 161
 162 void cache_dirstruct(struct dir_s *dirstruct)
 163 {
 164         struct dirent_s *ds, *dnew;
 165         struct dirent64 *d;
 166
 167         while ((d = (*real_readdir64)(dirstruct->dir)) != NULL) {
 168                 if (dirstruct->num >= dirstruct->max) {
 169                         dirstruct->max += ALLOC_STEPSIZE;
 170                         DEBUG_DIR(printf("Reallocating to size %d\n",
 171                                          dirstruct->max));
 172                         dnew = realloc(dirstruct->dp,
 173                                        dirstruct->max * sizeof(struct dir_s));
 174                         if (!dnew)
 175                                 goto nomem;
 176                         dirstruct->dp = dnew;
 177                 }
 178                 ds = &dirstruct->dp[dirstruct->num++];
 179                 ds->d_ino = d->d_ino;
 180                 ds->d_off = d->d_off;
 181                 ds->d_reclen = d->d_reclen;
 182                 ds->d_type = d->d_type;
 183                 if ((ds->d_name = malloc(strlen(d->d_name)+1)) == NULL) {
 184                         dirstruct->num--;
 185                         goto nomem;
 186                 }
 187                 strcpy(ds->d_name, d->d_name);
 188                 DEBUG_DIR(printf("readdir: %lu %s\n",
 189                                  (unsigned long) d->d_ino, d->d_name));
 190         }
 191         qsort(dirstruct->dp, dirstruct->num, sizeof(struct dirent_s), ino_cmp);
 192         return;
 193 nomem:
 194         DEBUG_DIR(printf("No memory, backing off to direct readdir\n"));
 195         free_cached_dir(dirstruct);
 196         dirstruct->direct = 1;
 197 }
 198
 199 DIR *opendir(const char *name)
 200 {
 201         DIR *dir;
 202         struct dir_s    *dirstruct;
 203         struct stat st;
 204
 205         if (!real_opendir)
 206                 setup_ptr();
 207
 208         DEBUG_DIR(printf("Opendir(%s) (%d open)\n", name, num_open++));
 209         dir = (*real_opendir)(name);
 210         if (!dir)
 211                 return NULL;
 212
 213         dirstruct = alloc_dirstruct(dir);
 214         if (!dirstruct) {
 215                 (*real_closedir)(dir);
 216                 errno = -ENOMEM;
 217                 return NULL;
 218         }
 219
 220         if (max_dirsize && (stat(name, &st) == 0) &&
 221             (st.st_size > max_dirsize)) {
 222                 DEBUG_DIR(printf("Directory size %ld, using direct readdir\n",
 223                                  st.st_size));
 224                 dirstruct->direct = 1;
 225                 return (DIR *) dirstruct;
 226         }
 227
 228         cache_dirstruct(dirstruct);
 229         return ((DIR *) dirstruct);
 230 }
 231
 232 DIR *fdopendir(int fd)
 233 {
 234         DIR *dir;
 235         struct dir_s    *dirstruct;
 236         struct stat st;
 237
 238         if (!real_fdopendir)
 239                 setup_ptr();
 240
 241         DEBUG_DIR(printf("fdpendir(%d) (%d open)\n", fd, num_open++));
 242         dir = (*real_fdopendir)(fd);
 243         if (!dir)
 244                 return NULL;
 245
 246         dirstruct = alloc_dirstruct(dir);
 247         if (!dirstruct) {
 248                 (*real_closedir)(dir);
 249                 errno = -ENOMEM;
 250                 return NULL;
 251         }
 252
 253         if (max_dirsize && (fstat(fd, &st) == 0) &&
 254             (st.st_size > max_dirsize)) {
 255                 DEBUG_DIR(printf("Directory size %ld, using direct readdir\n",
 256                                  st.st_size));
 257                 dirstruct->dir = dir;
 258                 dirstruct->direct = 1;
 259                 return (DIR *) dirstruct;
 260         }
 261
 262         cache_dirstruct(dirstruct);
 263         return ((DIR *) dirstruct);
 264 }
 265
 266 int closedir(DIR *dir)
 267 {
 268         struct dir_s    *dirstruct = (struct dir_s *) dir;
 269
 270         DEBUG_DIR(printf("Closedir (%d open)\n", --num_open));
 271         if (dirstruct->dir)
 272                 (*real_closedir)(dirstruct->dir);
 273
 274         free_cached_dir(dirstruct);
 275         free(dirstruct);
 276         return 0;
 277 }
 278
 279 struct dirent *readdir(DIR *dir)
 280 {
 281         struct dir_s    *dirstruct = (struct dir_s *) dir;
 282         struct dirent_s *ds;
 283
 284         if (dirstruct->direct)
 285                 return (*real_readdir)(dirstruct->dir);
 286
 287         if (dirstruct->pos >= dirstruct->num)
 288                 return NULL;
 289
 290         ds = &dirstruct->dp[dirstruct->pos++];
 291         dirstruct->ret_dir.d_ino = ds->d_ino;
 292         dirstruct->ret_dir.d_off = ds->d_off;
 293         dirstruct->ret_dir.d_reclen = ds->d_reclen;
 294         dirstruct->ret_dir.d_type = ds->d_type;
 295         strncpy(dirstruct->ret_dir.d_name, ds->d_name,
 296                 sizeof(dirstruct->ret_dir.d_name));
 297
 298         return (&dirstruct->ret_dir);
 299 }
 300
 301 int readdir_r(DIR *dir, struct dirent *entry, struct dirent **result)
 302 {
 303         struct dir_s    *dirstruct = (struct dir_s *) dir;
 304         struct dirent_s *ds;
 305
 306         if (dirstruct->direct)
 307                 return (*real_readdir_r)(dirstruct->dir, entry, result);
 308
 309         if (dirstruct->pos >= dirstruct->num) {
 310                 *result = NULL;
 311                 return 0;
 312         }
 313
 314         ds = &dirstruct->dp[dirstruct->pos++];
 315         entry->d_ino = ds->d_ino;
 316         entry->d_off = ds->d_off;
 317         entry->d_reclen = ds->d_reclen;
 318         entry->d_type = ds->d_type;
 319         strncpy(entry->d_name, ds->d_name, sizeof(entry->d_name));
 320         *result = entry;
 321
 322         return 0;
 323 }
 324
 325 struct dirent64 *readdir64(DIR *dir)
 326 {
 327         struct dir_s    *dirstruct = (struct dir_s *) dir;
 328         struct dirent_s *ds;
 329
 330         if (dirstruct->direct)
 331                 return (*real_readdir64)(dirstruct->dir);
 332
 333         if (dirstruct->pos >= dirstruct->num)
 334                 return NULL;
 335
 336         ds = &dirstruct->dp[dirstruct->pos++];
 337         dirstruct->ret_dir64.d_ino = ds->d_ino;
 338         dirstruct->ret_dir64.d_off = ds->d_off;
 339         dirstruct->ret_dir64.d_reclen = ds->d_reclen;
 340         dirstruct->ret_dir64.d_type = ds->d_type;
 341         strncpy(dirstruct->ret_dir64.d_name, ds->d_name,
 342                 sizeof(dirstruct->ret_dir64.d_name));
 343
 344         return (&dirstruct->ret_dir64);
 345 }
 346
 347 off_t telldir(DIR *dir)
 348 {
 349         struct dir_s    *dirstruct = (struct dir_s *) dir;
 350
 351         if (dirstruct->direct)
 352                 return (*real_telldir)(dirstruct->dir);
 353
 354         return ((off_t) dirstruct->pos);
 355 }
 356
 357 void seekdir(DIR *dir, off_t offset)
 358 {
 359         struct dir_s    *dirstruct = (struct dir_s *) dir;
 360
 361         if (dirstruct->direct) {
 362                 (*real_seekdir)(dirstruct->dir, offset);
 363                 return;
 364         }
 365
 366         dirstruct->pos = offset;
 367 }
 368
 369 void rewinddir(DIR *dir)
 370 {
 371         struct dir_s    *dirstruct = (struct dir_s *) dir;
 372
 373         (*real_rewinddir)(dirstruct->dir);
 374         if (dirstruct->direct)
 375                 return;
 376
 377         dirstruct->pos = 0;
 378         free_cached_dir(dirstruct);
 379         cache_dirstruct(dirstruct);
 380 }
 381
 382 int dirfd(DIR *dir)
 383 {
 384         struct dir_s    *dirstruct = (struct dir_s *) dir;
 385         int fd = (*real_dirfd)(dirstruct->dir);
 386
 387         DEBUG_DIR(printf("dirfd %d, %p\n", fd, real_dirfd));
 388         return fd;
 389 }