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
61struct 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
69struct 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
81static int (*real_closedir)(DIR *dir) = 0;
82static DIR *(*real_opendir)(const char *name) = 0;
83static DIR *(*real_fdopendir)(int fd) = 0;
84static void *(*real_rewinddir)(DIR *dirp) = 0;
85static struct dirent *(*real_readdir)(DIR *dir) = 0;
86static int (*real_readdir_r)(DIR *dir, struct dirent *entry,
87			     struct dirent **result) = 0;
88static struct dirent64 *(*real_readdir64)(DIR *dir) = 0;
89static int (*real_readdir64_r)(DIR *dir, struct dirent64 *entry,
90			       struct dirent64 **result) = 0;
91static off_t (*real_telldir)(DIR *dir) = 0;
92static void (*real_seekdir)(DIR *dir, off_t offset) = 0;
93static int (*real_dirfd)(DIR *dir) = 0;
94static unsigned long max_dirsize = MAX_DIRSIZE;
95static int num_open = 0;
96#ifdef DEBUG
97static int do_debug = 0;
98#endif
99
100static 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
121static 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
147static 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
164static 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
189static 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
203static 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;
234nomem:
235	DEBUG_DIR(printf("No memory, backing off to direct readdir\n"));
236	free_cached_dir(dirstruct);
237	dirstruct->direct = 1;
238}
239
240DIR *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
273DIR *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
307int 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
320struct 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
342int 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
366struct 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
388int 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
414off_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
424void 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
436void 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
451int 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