1 /* 2 * readdir accelerator 3 * 4 * (C) Copyright 2003, 2004, 2008 by Theodore Ts'o. 5 * 6 * 2008-06-08 Modified by Ross Boylan <RossBoylan stanfordalumni org> 7 * Added support for readdir_r and readdir64_r calls. Note 8 * this has not been tested on anything other than GNU/Linux i386, 9 * and that the regular readdir wrapper will take slightly more 10 * space than Ted's original since it now includes a lock. 11 * 12 * Compile using the command: 13 * 14 * gcc -o spd_readdir.so -shared -fpic spd_readdir.c -ldl 15 * 16 * Use it by setting the LD_PRELOAD environment variable: 17 * 18 * export LD_PRELOAD=/usr/local/sbin/spd_readdir.so 19 * 20 * %Begin-Header% 21 * This file may be redistributed under the terms of the GNU Public 22 * License. 23 * %End-Header% 24 * 25 */ 26 27 #define ALLOC_STEPSIZE 100 28 #define MAX_DIRSIZE 0 29 30 #define DEBUG 31 /* Util we autoconfiscate spd_readdir... */ 32 #define HAVE___SECURE_GETENV 1 33 #define HAVE_PRCTL 1 34 #define HAVE_SYS_PRCTL_H 1 35 36 #ifdef DEBUG 37 #define DEBUG_DIR(x) {if (do_debug) { x; }} 38 #else 39 #define DEBUG_DIR(x) 40 #endif 41 42 #define _GNU_SOURCE 43 #define __USE_LARGEFILE64 44 45 #include <stdio.h> 46 #include <unistd.h> 47 #include <sys/types.h> 48 #include <sys/stat.h> 49 #include <stdlib.h> 50 #include <string.h> 51 #include <dirent.h> 52 #include <errno.h> 53 #include <dlfcn.h> 54 #ifdef HAVE_SYS_PRCTL_H 55 #include <sys/prctl.h> 56 #else 57 #define PR_GET_DUMPABLE 3 58 #endif 59 #include <pthread.h> 60 61 struct dirent_s { 62 unsigned long long d_ino; 63 long long d_off; 64 unsigned short int d_reclen; 65 unsigned char d_type; 66 char *d_name; 67 }; 68 69 struct dir_s { 70 DIR *dir; 71 pthread_mutex_t lock; /* Mutex lock for this structure. */ 72 int num; 73 int max; 74 struct dirent_s *dp; 75 int pos; 76 int direct; 77 struct dirent ret_dir; 78 struct dirent64 ret_dir64; 79 }; 80 81 static int (*real_closedir)(DIR *dir) = 0; 82 static DIR *(*real_opendir)(const char *name) = 0; 83 static DIR *(*real_fdopendir)(int fd) = 0; 84 static void *(*real_rewinddir)(DIR *dirp) = 0; 85 static struct dirent *(*real_readdir)(DIR *dir) = 0; 86 static int (*real_readdir_r)(DIR *dir, struct dirent *entry, 87 struct dirent **result) = 0; 88 static struct dirent64 *(*real_readdir64)(DIR *dir) = 0; 89 static int (*real_readdir64_r)(DIR *dir, struct dirent64 *entry, 90 struct dirent64 **result) = 0; 91 static off_t (*real_telldir)(DIR *dir) = 0; 92 static void (*real_seekdir)(DIR *dir, off_t offset) = 0; 93 static int (*real_dirfd)(DIR *dir) = 0; 94 static unsigned long max_dirsize = MAX_DIRSIZE; 95 static int num_open = 0; 96 #ifdef DEBUG 97 static int do_debug = 0; 98 #endif 99 100 static char *safe_getenv(const char *arg) 101 { 102 if ((getuid() != geteuid()) || (getgid() != getegid())) 103 return NULL; 104 #if HAVE_PRCTL 105 if (prctl(PR_GET_DUMPABLE, 0, 0, 0, 0) == 0) 106 return NULL; 107 #else 108 #if (defined(linux) && defined(SYS_prctl)) 109 if (syscall(SYS_prctl, PR_GET_DUMPABLE, 0, 0, 0, 0) == 0) 110 return NULL; 111 #endif 112 #endif 113 114 #if HAVE___SECURE_GETENV 115 return __secure_getenv(arg); 116 #else 117 return getenv(arg); 118 #endif 119 } 120 121 static void setup_ptr() 122 { 123 char *cp; 124 125 real_opendir = dlsym(RTLD_NEXT, "opendir"); 126 real_fdopendir = dlsym(RTLD_NEXT, "fdopendir"); 127 real_closedir = dlsym(RTLD_NEXT, "closedir"); 128 real_rewinddir = dlsym(RTLD_NEXT, "rewinddir"); 129 real_readdir = dlsym(RTLD_NEXT, "readdir"); 130 real_readdir_r = dlsym(RTLD_NEXT, "readdir_r"); 131 real_readdir64 = dlsym(RTLD_NEXT, "readdir64"); 132 real_readdir64_r = dlsym(RTLD_NEXT, "readdir64_r"); 133 real_telldir = dlsym(RTLD_NEXT, "telldir"); 134 real_seekdir = dlsym(RTLD_NEXT, "seekdir"); 135 real_dirfd = dlsym(RTLD_NEXT, "dirfd"); 136 if ((cp = safe_getenv("SPD_READDIR_MAX_SIZE")) != NULL) { 137 max_dirsize = atol(cp); 138 } 139 #ifdef DEBUG 140 if (safe_getenv("SPD_READDIR_DEBUG")) { 141 printf("initialized!\n"); 142 do_debug++; 143 } 144 #endif 145 } 146 147 static void free_cached_dir(struct dir_s *dirstruct) 148 { 149 int i; 150 151 pthread_mutex_destroy(&(dirstruct->lock)); 152 153 if (!dirstruct->dp) 154 return; 155 156 for (i=0; i < dirstruct->num; i++) { 157 free(dirstruct->dp[i].d_name); 158 } 159 free(dirstruct->dp); 160 dirstruct->dp = 0; 161 dirstruct->max = dirstruct->num = 0; 162 } 163 164 static int ino_cmp(const void *a, const void *b) 165 { 166 const struct dirent_s *ds_a = (const struct dirent_s *) a; 167 const struct dirent_s *ds_b = (const struct dirent_s *) b; 168 ino_t i_a, i_b; 169 170 i_a = ds_a->d_ino; 171 i_b = ds_b->d_ino; 172 173 if (ds_a->d_name[0] == '.') { 174 if (ds_a->d_name[1] == 0) 175 i_a = 0; 176 else if ((ds_a->d_name[1] == '.') && (ds_a->d_name[2] == 0)) 177 i_a = 1; 178 } 179 if (ds_b->d_name[0] == '.') { 180 if (ds_b->d_name[1] == 0) 181 i_b = 0; 182 else if ((ds_b->d_name[1] == '.') && (ds_b->d_name[2] == 0)) 183 i_b = 1; 184 } 185 186 return (i_a - i_b); 187 } 188 189 static struct dir_s *alloc_dirstruct(DIR *dir) 190 { 191 struct dir_s *dirstruct; 192 static pthread_mutexattr_t mutexattr; 193 mutexattr.__align = PTHREAD_MUTEX_RECURSIVE; 194 195 dirstruct = malloc(sizeof(struct dir_s)); 196 if (dirstruct) 197 memset(dirstruct, 0, sizeof(struct dir_s)); 198 dirstruct->dir = dir; 199 pthread_mutex_init(&(dirstruct->lock), &mutexattr); 200 return dirstruct; 201 } 202 203 static void cache_dirstruct(struct dir_s *dirstruct) 204 { 205 struct dirent_s *ds, *dnew; 206 struct dirent64 *d; 207 208 while ((d = (*real_readdir64)(dirstruct->dir)) != NULL) { 209 if (dirstruct->num >= dirstruct->max) { 210 dirstruct->max += ALLOC_STEPSIZE; 211 DEBUG_DIR(printf("Reallocating to size %d\n", 212 dirstruct->max)); 213 dnew = realloc(dirstruct->dp, 214 dirstruct->max * sizeof(struct dir_s)); 215 if (!dnew) 216 goto nomem; 217 dirstruct->dp = dnew; 218 } 219 ds = &dirstruct->dp[dirstruct->num++]; 220 ds->d_ino = d->d_ino; 221 ds->d_off = d->d_off; 222 ds->d_reclen = d->d_reclen; 223 ds->d_type = d->d_type; 224 if ((ds->d_name = malloc(strlen(d->d_name)+1)) == NULL) { 225 dirstruct->num--; 226 goto nomem; 227 } 228 strcpy(ds->d_name, d->d_name); 229 DEBUG_DIR(printf("readdir: %lu %s\n", 230 (unsigned long) d->d_ino, d->d_name)); 231 } 232 qsort(dirstruct->dp, dirstruct->num, sizeof(struct dirent_s), ino_cmp); 233 return; 234 nomem: 235 DEBUG_DIR(printf("No memory, backing off to direct readdir\n")); 236 free_cached_dir(dirstruct); 237 dirstruct->direct = 1; 238 } 239 240 DIR *opendir(const char *name) 241 { 242 DIR *dir; 243 struct dir_s *dirstruct; 244 struct stat st; 245 246 if (!real_opendir) 247 setup_ptr(); 248 249 DEBUG_DIR(printf("Opendir(%s) (%d open)\n", name, num_open++)); 250 dir = (*real_opendir)(name); 251 if (!dir) 252 return NULL; 253 254 dirstruct = alloc_dirstruct(dir); 255 if (!dirstruct) { 256 (*real_closedir)(dir); 257 errno = -ENOMEM; 258 return NULL; 259 } 260 261 if (max_dirsize && (stat(name, &st) == 0) && 262 (st.st_size > max_dirsize)) { 263 DEBUG_DIR(printf("Directory size %ld, using direct readdir\n", 264 st.st_size)); 265 dirstruct->direct = 1; 266 return (DIR *) dirstruct; 267 } 268 269 cache_dirstruct(dirstruct); 270 return ((DIR *) dirstruct); 271 } 272 273 DIR *fdopendir(int fd) 274 { 275 DIR *dir; 276 struct dir_s *dirstruct; 277 struct stat st; 278 279 if (!real_fdopendir) 280 setup_ptr(); 281 282 DEBUG_DIR(printf("fdopendir(%d) (%d open)\n", fd, num_open++)); 283 dir = (*real_fdopendir)(fd); 284 if (!dir) 285 return NULL; 286 287 dirstruct = alloc_dirstruct(dir); 288 if (!dirstruct) { 289 (*real_closedir)(dir); 290 errno = -ENOMEM; 291 return NULL; 292 } 293 294 if (max_dirsize && (fstat(fd, &st) == 0) && 295 (st.st_size > max_dirsize)) { 296 DEBUG_DIR(printf("Directory size %ld, using direct readdir\n", 297 st.st_size)); 298 dirstruct->dir = dir; 299 dirstruct->direct = 1; 300 return (DIR *) dirstruct; 301 } 302 303 cache_dirstruct(dirstruct); 304 return ((DIR *) dirstruct); 305 } 306 307 int closedir(DIR *dir) 308 { 309 struct dir_s *dirstruct = (struct dir_s *) dir; 310 311 DEBUG_DIR(printf("Closedir (%d open)\n", --num_open)); 312 if (dirstruct->dir) 313 (*real_closedir)(dirstruct->dir); 314 315 free_cached_dir(dirstruct); 316 free(dirstruct); 317 return 0; 318 } 319 320 struct dirent *readdir(DIR *dir) 321 { 322 struct dir_s *dirstruct = (struct dir_s *) dir; 323 struct dirent_s *ds; 324 325 if (dirstruct->direct) 326 return (*real_readdir)(dirstruct->dir); 327 328 if (dirstruct->pos >= dirstruct->num) 329 return NULL; 330 331 ds = &dirstruct->dp[dirstruct->pos++]; 332 dirstruct->ret_dir.d_ino = ds->d_ino; 333 dirstruct->ret_dir.d_off = ds->d_off; 334 dirstruct->ret_dir.d_reclen = ds->d_reclen; 335 dirstruct->ret_dir.d_type = ds->d_type; 336 strncpy(dirstruct->ret_dir.d_name, ds->d_name, 337 sizeof(dirstruct->ret_dir.d_name)); 338 339 return (&dirstruct->ret_dir); 340 } 341 342 int readdir_r(DIR *dir, struct dirent *entry, struct dirent **result) 343 { 344 struct dir_s *dirstruct = (struct dir_s *) dir; 345 struct dirent_s *ds; 346 347 if (dirstruct->direct) 348 return (*real_readdir_r)(dirstruct->dir, entry, result); 349 350 pthread_mutex_lock(&(dirstruct->lock)); 351 if (dirstruct->pos >= dirstruct->num) { 352 *result = NULL; 353 } else { 354 ds = &dirstruct->dp[dirstruct->pos++]; 355 entry->d_ino = ds->d_ino; 356 entry->d_off = ds->d_off; 357 entry->d_reclen = ds->d_reclen; 358 entry->d_type = ds->d_type; 359 strncpy(entry->d_name, ds->d_name, sizeof(entry->d_name)); 360 *result = entry; 361 } 362 pthread_mutex_unlock(&(dirstruct->lock)); 363 return 0; 364 } 365 366 struct dirent64 *readdir64(DIR *dir) 367 { 368 struct dir_s *dirstruct = (struct dir_s *) dir; 369 struct dirent_s *ds; 370 371 if (dirstruct->direct) 372 return (*real_readdir64)(dirstruct->dir); 373 374 if (dirstruct->pos >= dirstruct->num) 375 return NULL; 376 377 ds = &dirstruct->dp[dirstruct->pos++]; 378 dirstruct->ret_dir64.d_ino = ds->d_ino; 379 dirstruct->ret_dir64.d_off = ds->d_off; 380 dirstruct->ret_dir64.d_reclen = ds->d_reclen; 381 dirstruct->ret_dir64.d_type = ds->d_type; 382 strncpy(dirstruct->ret_dir64.d_name, ds->d_name, 383 sizeof(dirstruct->ret_dir64.d_name)); 384 385 return (&dirstruct->ret_dir64); 386 } 387 388 int readdir64_r (DIR *__restrict dir, 389 struct dirent64 *__restrict entry, 390 struct dirent64 **__restrict result) 391 { 392 struct dir_s *dirstruct = (struct dir_s *) dir; 393 struct dirent_s *ds; 394 395 if (dirstruct->direct) 396 return (*real_readdir64_r)(dir, entry, result); 397 pthread_mutex_lock(&(dirstruct->lock)); 398 if (dirstruct->pos >= dirstruct->num) { 399 *result = NULL; 400 } else { 401 ds = &dirstruct->dp[dirstruct->pos++]; 402 entry->d_ino = ds->d_ino; 403 entry->d_off = ds->d_off; 404 entry->d_reclen = ds->d_reclen; 405 entry->d_type = ds->d_type; 406 strncpy(entry->d_name, ds->d_name, 407 sizeof(entry->d_name)); 408 *result = entry; 409 } 410 pthread_mutex_unlock(&(dirstruct->lock)); 411 return 0; 412 } 413 414 off_t telldir(DIR *dir) 415 { 416 struct dir_s *dirstruct = (struct dir_s *) dir; 417 418 if (dirstruct->direct) 419 return (*real_telldir)(dirstruct->dir); 420 421 return ((off_t) dirstruct->pos); 422 } 423 424 void seekdir(DIR *dir, off_t offset) 425 { 426 struct dir_s *dirstruct = (struct dir_s *) dir; 427 428 if (dirstruct->direct) { 429 (*real_seekdir)(dirstruct->dir, offset); 430 return; 431 } 432 433 dirstruct->pos = offset; 434 } 435 436 void rewinddir(DIR *dir) 437 { 438 struct dir_s *dirstruct = (struct dir_s *) dir; 439 440 (*real_rewinddir)(dirstruct->dir); 441 if (dirstruct->direct) 442 return; 443 444 pthread_mutex_lock(&(dirstruct->lock)); 445 dirstruct->pos = 0; 446 free_cached_dir(dirstruct); 447 cache_dirstruct(dirstruct); 448 pthread_mutex_unlock(&(dirstruct->lock)); 449 } 450 451 int dirfd(DIR *dir) 452 { 453 struct dir_s *dirstruct = (struct dir_s *) dir; 454 int fd = (*real_dirfd)(dirstruct->dir); 455 456 DEBUG_DIR(printf("dirfd %d, %p\n", fd, real_dirfd)); 457 return fd; 458 } 459
