• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
safe_getenv(const char * arg)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 
setup_ptr()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 
free_cached_dir(struct dir_s * dirstruct)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 
ino_cmp(const void * a,const void * b)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 
alloc_dirstruct(DIR * dir)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 
cache_dirstruct(struct dir_s * dirstruct)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 
opendir(const char * name)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 
fdopendir(int fd)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 
closedir(DIR * dir)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 
readdir(DIR * dir)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 
readdir_r(DIR * dir,struct dirent * entry,struct dirent ** result)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 
readdir64(DIR * dir)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 
readdir64_r(DIR * __restrict dir,struct dirent64 * __restrict entry,struct dirent64 ** __restrict result)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 
telldir(DIR * dir)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 
seekdir(DIR * dir,off_t offset)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 
rewinddir(DIR * dir)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 
dirfd(DIR * dir)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