[ViewVC] Diff of: cvs/libeio/eio.c

Comparing libeio/eio.c (file contents):
Revision 1.89 by root, Thu Jul 14 22:36:17 2011 UTC vs.
Revision 1.104 by root, Mon Sep 26 16:54:25 2011 UTC

…		…
43		43
44	#include "eio.h"	44	#include "eio.h"
45	#include "ecb.h"	45	#include "ecb.h"
46		46
47	#ifdef EIO_STACKSIZE	47	#ifdef EIO_STACKSIZE
48	# define XTHREAD_STACKSIZE EIO_STACKSIZE	48	# define X_STACKSIZE EIO_STACKSIZE
49	#endif	49	#endif
50	#include "xthread.h"	50	#include "xthread.h"
51		51
52	#include <errno.h>	52	#include <errno.h>
53	#include <stddef.h>	53	#include <stddef.h>
…		…
67	#endif	67	#endif
68		68
69	#ifndef ECANCELED	69	#ifndef ECANCELED
70	# define ECANCELED EDOM	70	# define ECANCELED EDOM
71	#endif	71	#endif
		72	#ifndef ELOOP
		73	# define ELOOP EDOM
		74	#endif
		75
		76	#if !defined(ENOTSOCK) && defined(WSAENOTSOCK)
		77	# define ENOTSOCK WSAENOTSOCK
		78	#endif
72		79
73	static void eio_destroy (eio_req *req);	80	static void eio_destroy (eio_req *req);
74		81
75	#ifndef EIO_FINISH	82	#ifndef EIO_FINISH
76	# define EIO_FINISH(req) ((req)->finish) && !EIO_CANCELLED (req) ? (req)->finish (req) : 0	83	# define EIO_FINISH(req) ((req)->finish) && !EIO_CANCELLED (req) ? (req)->finish (req) : 0
…		…
95		102
96	#define EIO_ENOSYS() EIO_ERRNO (ENOSYS, -1)	103	#define EIO_ENOSYS() EIO_ERRNO (ENOSYS, -1)
97		104
98	#ifdef _WIN32	105	#ifdef _WIN32
99		106
		107	#undef PAGESIZE
100	#define PAGESIZE 4096 /* GetSystemInfo? */	108	#define PAGESIZE 4096 /* GetSystemInfo? */
101		109
		110	/* TODO: look at how perl does stat (non-sloppy), unlink (ro-files), utime, link */
		111
102	#ifdef EIO_STRUCT_STATI64	112	#ifdef EIO_STRUCT_STATI64
		113	/* look at perl's non-sloppy stat */
103	#define stat(path,buf) _stati64 (path,buf)	114	#define stat(path,buf) _stati64 (path,buf)
104	#define fstat(fd,buf) _fstati64 (path,buf)	115	#define fstat(fd,buf) _fstati64 (fd,buf)
105	#endif	116	#endif
106	#define lstat(path,buf) stat (path,buf)	117	#define lstat(path,buf) stat (path,buf)
107	#define fsync(fd) (FlushFileBuffers (EIO_FD_TO_WIN32_HANDLE (fd)) ? 0 : EIO_ERRNO (EBADF, -1))	118	#define fsync(fd) (FlushFileBuffers ((HANDLE)EIO_FD_TO_WIN32_HANDLE (fd)) ? 0 : EIO_ERRNO (EBADF, -1))
108	#define mkdir(path,mode) _mkdir (path)	119	#define mkdir(path,mode) _mkdir (path)
109	#define link(old,neu) (CreateHardLink (neu, old, 0) ? 0 : EIO_ERRNO (ENOENT, -1))	120	#define link(old,neu) (CreateHardLink (neu, old, 0) ? 0 : EIO_ERRNO (ENOENT, -1))
110		121
		122	#define chmod(path,mode) _chmod (path, mode)
		123	#define dup(fd) _dup (fd)
		124	#define dup2(fd1,fd2) _dup2 (fd1, fd2)
		125
		126	#define fchmod(fd,mode) EIO_ENOSYS ()
111	#define chown(path,uid,gid) EIO_ENOSYS ()	127	#define chown(path,uid,gid) EIO_ENOSYS ()
112	#define fchown(fd,uid,gid) EIO_ENOSYS ()	128	#define fchown(fd,uid,gid) EIO_ENOSYS ()
113	#define truncate(path,offs) EIO_ENOSYS () /* far-miss: SetEndOfFile */	129	#define truncate(path,offs) EIO_ENOSYS () /* far-miss: SetEndOfFile */
114	#define ftruncate(fd,offs) EIO_ENOSYS () /* near-miss: SetEndOfFile */	130	#define ftruncate(fd,offs) EIO_ENOSYS () /* near-miss: SetEndOfFile */
115	#define mknod(path,mode,dev) EIO_ENOSYS ()	131	#define mknod(path,mode,dev) EIO_ENOSYS ()
116	#define sync() EIO_ENOSYS ()	132	#define sync() EIO_ENOSYS ()
		133	#define readlink(path,buf,s) EIO_ENOSYS ()
		134	#define statvfs(path,buf) EIO_ENOSYS ()
		135	#define fstatvfs(fd,buf) EIO_ENOSYS ()
		136
		137	/* rename() uses MoveFile, which fails to overwrite */
		138	#define rename(old,neu) eio__rename (old, neu)
		139
		140	static int
		141	eio__rename (const char old, const char neu)
		142	{
		143	if (MoveFileEx (old, neu, MOVEFILE_REPLACE_EXISTING))
		144	return 0;
		145
		146	/* should steal _dosmaperr */
		147	switch (GetLastError ())
		148	{
		149	case ERROR_FILE_NOT_FOUND:
		150	case ERROR_PATH_NOT_FOUND:
		151	case ERROR_INVALID_DRIVE:
		152	case ERROR_NO_MORE_FILES:
		153	case ERROR_BAD_NETPATH:
		154	case ERROR_BAD_NET_NAME:
		155	case ERROR_BAD_PATHNAME:
		156	case ERROR_FILENAME_EXCED_RANGE:
		157	errno = ENOENT;
		158	break;
		159
		160	default:
		161	errno = EACCES;
		162	break;
		163	}
		164
		165	return -1;
		166	}
117		167
118	/* we could even stat and see if it exists */	168	/* we could even stat and see if it exists */
119	static int	169	static int
120	symlink (const char old, const char neu)	170	symlink (const char old, const char neu)
121	{	171	{
		172	#if WINVER >= 0x0600
122	if (CreateSymbolicLink (neu, old, 1))	173	if (CreateSymbolicLink (neu, old, 1))
123	return 0;	174	return 0;
124		175
125	if (CreateSymbolicLink (neu, old, 0))	176	if (CreateSymbolicLink (neu, old, 0))
126	return 0;	177	return 0;
		178	#endif
127		179
128	return EIO_ERRNO (ENOENT, -1);	180	return EIO_ERRNO (ENOENT, -1);
129	}	181	}
		182
		183	/* POSIX API only */
		184	#define CreateHardLink(neu,old,flags) 0
		185	#define CreateSymbolicLink(neu,old,flags) 0
		186
		187	struct statvfs
		188	{
		189	int dummy;
		190	};
		191
		192	#define DT_DIR EIO_DT_DIR
		193	#define DT_REG EIO_DT_REG
		194	#define D_NAME(entp) entp.cFileName
		195	#define D_TYPE(entp) (entp.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ? DT_DIR : DT_REG)
130		196
131	#else	197	#else
132		198
133	#include <sys/time.h>	199	#include <sys/time.h>
134	#include <sys/select.h>	200	#include <sys/select.h>
135	#include <sys/statvfs.h>	201	#include <sys/statvfs.h>
136	#include <unistd.h>	202	#include <unistd.h>
137	#include <utime.h>
138	#include <signal.h>	203	#include <signal.h>
139	#include <dirent.h>	204	#include <dirent.h>
140		205
141	#if _POSIX_MEMLOCK \|\| _POSIX_MEMLOCK_RANGE \|\| _POSIX_MAPPED_FILES	206	#if _POSIX_MEMLOCK \|\| _POSIX_MEMLOCK_RANGE \|\| _POSIX_MAPPED_FILES
142	#include <sys/mman.h>	207	#include <sys/mman.h>
143	#endif	208	#endif
		209
		210	#define D_NAME(entp) entp->d_name
144		211
145	/* POSIX_SOURCE is useless on bsd's, and XOPEN_SOURCE is unreliable there, too */	212	/* POSIX_SOURCE is useless on bsd's, and XOPEN_SOURCE is unreliable there, too */
146	#if __FreeBSD__ \|\| defined __NetBSD__ \|\| defined __OpenBSD__	213	#if __FreeBSD__ \|\| defined __NetBSD__ \|\| defined __OpenBSD__
147	#define _DIRENT_HAVE_D_TYPE /* sigh */	214	#define _DIRENT_HAVE_D_TYPE /* sigh */
148	#define D_INO(de) (de)->d_fileno	215	#define D_INO(de) (de)->d_fileno
…		…
162		229
163	#ifndef EIO_STRUCT_DIRENT	230	#ifndef EIO_STRUCT_DIRENT
164	#define EIO_STRUCT_DIRENT struct dirent	231	#define EIO_STRUCT_DIRENT struct dirent
165	#endif	232	#endif
166		233
		234	#endif
		235
		236	#if HAVE_UTIMES
		237	# include <utime.h>
		238	#endif
		239
		240	#if HAVE_SYS_SYSCALL_H
		241	# include <sys/syscall.h>
		242	#endif
		243
		244	#if HAVE_SYS_PRCTL_H
		245	# include <sys/prctl.h>
167	#endif	246	#endif
168		247
169	#if HAVE_SENDFILE	248	#if HAVE_SENDFILE
170	# if __linux	249	# if __linux
171	# include <sys/sendfile.h>	250	# include <sys/sendfile.h>
…		…
186	#endif	265	#endif
187	#ifndef D_INO	266	#ifndef D_INO
188	# define D_INO(de) 0	267	# define D_INO(de) 0
189	#endif	268	#endif
190	#ifndef D_NAMLEN	269	#ifndef D_NAMLEN
191	# define D_NAMLEN(de) strlen ((de)->d_name)	270	# define D_NAMLEN(entp) strlen (D_NAME (entp))
192	#endif	271	#endif
193		272
194	/* used for struct dirent, AIX doesn't provide it */	273	/* used for struct dirent, AIX doesn't provide it */
195	#ifndef NAME_MAX	274	#ifndef NAME_MAX
196	# define NAME_MAX 4096	275	# define NAME_MAX 4096
…		…
203		282
204	/* buffer size for various temporary buffers */	283	/* buffer size for various temporary buffers */
205	#define EIO_BUFSIZE 65536	284	#define EIO_BUFSIZE 65536
206		285
207	#define dBUF \	286	#define dBUF \
208	char *eio_buf; \
209	ETP_WORKER_LOCK (self); \
210	self->dbuf = eio_buf = malloc (EIO_BUFSIZE); \	287	char *eio_buf = malloc (EIO_BUFSIZE); \
211	ETP_WORKER_UNLOCK (self); \
212	errno = ENOMEM; \	288	errno = ENOMEM; \
213	if (!eio_buf) \	289	if (!eio_buf) \
214	return -1;	290	return -1
		291
		292	#define FUBd \
		293	free (eio_buf)
215		294
216	#define EIO_TICKS ((1000000 + 1023) >> 10)	295	#define EIO_TICKS ((1000000 + 1023) >> 10)
		296
		297	/*****************************************************************************/
		298
		299	struct tmpbuf
		300	{
		301	void *ptr;
		302	int len;
		303	};
		304
		305	static void *
		306	tmpbuf_get (struct tmpbuf *buf, int len)
		307	{
		308	if (buf->len < len)
		309	{
		310	free (buf->ptr);
		311	buf->ptr = malloc (buf->len = len);
		312	}
		313
		314	return buf->ptr;
		315	}
		316
		317	/*****************************************************************************/
217		318
218	#define ETP_PRI_MIN EIO_PRI_MIN	319	#define ETP_PRI_MIN EIO_PRI_MIN
219	#define ETP_PRI_MAX EIO_PRI_MAX	320	#define ETP_PRI_MAX EIO_PRI_MAX
220		321
221	struct etp_worker;	322	struct etp_worker;
…		…
225	static int eio_finish (eio_req *req);	326	static int eio_finish (eio_req *req);
226	#define ETP_FINISH(req) eio_finish (req)	327	#define ETP_FINISH(req) eio_finish (req)
227	static void eio_execute (struct etp_worker self, eio_req req);	328	static void eio_execute (struct etp_worker self, eio_req req);
228	#define ETP_EXECUTE(wrk,req) eio_execute (wrk,req)	329	#define ETP_EXECUTE(wrk,req) eio_execute (wrk,req)
229		330
230	#define ETP_WORKER_CLEAR(req) \
231	if (wrk->dbuf) \
232	{ \
233	free (wrk->dbuf); \
234	wrk->dbuf = 0; \
235	} \
236	\
237	if (wrk->dirp) \
238	{ \
239	closedir (wrk->dirp); \
240	wrk->dirp = 0; \
241	}
242
243	#define ETP_WORKER_COMMON \
244	void *dbuf; \
245	DIR *dirp;
246
247	/*****************************************************************************/	331	/*****************************************************************************/
248		332
249	#define ETP_NUM_PRI (ETP_PRI_MAX - ETP_PRI_MIN + 1)	333	#define ETP_NUM_PRI (ETP_PRI_MAX - ETP_PRI_MIN + 1)
250		334
251	/* calculate time difference in ~1/EIO_TICKS of a second */	335	/* calculate time difference in ~1/EIO_TICKS of a second */
…		…
262	static void (*done_poll_cb) (void);	346	static void (*done_poll_cb) (void);
263		347
264	static unsigned int max_poll_time; /* reslock */	348	static unsigned int max_poll_time; /* reslock */
265	static unsigned int max_poll_reqs; /* reslock */	349	static unsigned int max_poll_reqs; /* reslock */
266		350
267	static volatile unsigned int nreqs; /* reqlock */	351	static unsigned int nreqs; /* reqlock */
268	static volatile unsigned int nready; /* reqlock */	352	static unsigned int nready; /* reqlock */
269	static volatile unsigned int npending; /* reqlock */	353	static unsigned int npending; /* reqlock */
270	static volatile unsigned int max_idle = 4; /* maximum number of threads that can idle indefinitely */	354	static unsigned int max_idle = 4; /* maximum number of threads that can idle indefinitely */
271	static volatile unsigned int idle_timeout = 10; /* number of seconds after which an idle threads exit */	355	static unsigned int idle_timeout = 10; /* number of seconds after which an idle threads exit */
272		356
273	static xmutex_t wrklock;	357	static xmutex_t wrklock;
274	static xmutex_t reslock;	358	static xmutex_t reslock;
275	static xmutex_t reqlock;	359	static xmutex_t reqlock;
276	static xcond_t reqwait;	360	static xcond_t reqwait;
…		…
279	/*	363	/*
280	* make our pread/pwrite emulation safe against themselves, but not against	364	* make our pread/pwrite emulation safe against themselves, but not against
281	* normal read/write by using a mutex. slows down execution a lot,	365	* normal read/write by using a mutex. slows down execution a lot,
282	* but that's your problem, not mine.	366	* but that's your problem, not mine.
283	*/	367	*/
284	static xmutex_t preadwritelock = X_MUTEX_INIT;	368	static xmutex_t preadwritelock;
285	#endif	369	#endif
286		370
287	typedef struct etp_worker	371	typedef struct etp_worker
288	{	372	{
		373	struct tmpbuf tmpbuf;
		374
289	/* locked by wrklock */	375	/* locked by wrklock */
290	struct etp_worker prev, next;	376	struct etp_worker prev, next;
291		377
292	xthread_t tid;	378	xthread_t tid;
293		379
294	/* locked by reslock, reqlock or wrklock */	380	#ifdef ETP_WORKER_COMMON
295	ETP_REQ req; / currently processed request */
296
297	ETP_WORKER_COMMON	381	ETP_WORKER_COMMON
		382	#endif
298	} etp_worker;	383	} etp_worker;
299		384
300	static etp_worker wrk_first = { &wrk_first, &wrk_first, 0 }; /* NOT etp */	385	static etp_worker wrk_first; /* NOT etp */
301		386
302	#define ETP_WORKER_LOCK(wrk) X_LOCK (wrklock)	387	#define ETP_WORKER_LOCK(wrk) X_LOCK (wrklock)
303	#define ETP_WORKER_UNLOCK(wrk) X_UNLOCK (wrklock)	388	#define ETP_WORKER_UNLOCK(wrk) X_UNLOCK (wrklock)
304		389
305	/* worker threads management */	390	/* worker threads management */
306		391
307	static void ecb_cold	392	static void ecb_cold
308	etp_worker_clear (etp_worker *wrk)	393	etp_worker_clear (etp_worker *wrk)
309	{	394	{
310	ETP_WORKER_CLEAR (wrk);
311	}	395	}
312		396
313	static void ecb_cold	397	static void ecb_cold
314	etp_worker_free (etp_worker *wrk)	398	etp_worker_free (etp_worker *wrk)
315	{	399	{
		400	free (wrk->tmpbuf.ptr);
		401
316	wrk->next->prev = wrk->prev;	402	wrk->next->prev = wrk->prev;
317	wrk->prev->next = wrk->next;	403	wrk->prev->next = wrk->next;
318		404
319	free (wrk);	405	free (wrk);
320	}	406	}
…		…
376	} etp_reqq;	462	} etp_reqq;
377		463
378	static etp_reqq req_queue;	464	static etp_reqq req_queue;
379	static etp_reqq res_queue;	465	static etp_reqq res_queue;
380		466
		467	static void ecb_noinline ecb_cold
		468	reqq_init (etp_reqq *q)
		469	{
		470	int pri;
		471
		472	for (pri = 0; pri < ETP_NUM_PRI; ++pri)
		473	q->qs[pri] = q->qe[pri] = 0;
		474
		475	q->size = 0;
		476	}
		477
381	static int ecb_noinline	478	static int ecb_noinline
382	reqq_push (etp_reqq q, ETP_REQ req)	479	reqq_push (etp_reqq q, ETP_REQ req)
383	{	480	{
384	int pri = req->pri;	481	int pri = req->pri;
385	req->next = 0;	482	req->next = 0;
…		…
419	}	516	}
420		517
421	abort ();	518	abort ();
422	}	519	}
423		520
424	static void ecb_cold	521	static int ecb_cold
425	etp_thread_init (void)	522	etp_init (void (want_poll)(void), void (done_poll)(void))
426	{	523	{
427	#if !HAVE_PREADWRITE
428	X_MUTEX_CREATE (preadwritelock);
429	#endif
430	X_MUTEX_CREATE (wrklock);	524	X_MUTEX_CREATE (wrklock);
431	X_MUTEX_CREATE (reslock);	525	X_MUTEX_CREATE (reslock);
432	X_MUTEX_CREATE (reqlock);	526	X_MUTEX_CREATE (reqlock);
433	X_COND_CREATE (reqwait);	527	X_COND_CREATE (reqwait);
434	}
435		528
436	static void ecb_cold	529	reqq_init (&req_queue);
437	etp_atfork_prepare (void)	530	reqq_init (&res_queue);
438	{
439	}
440		531
441	static void ecb_cold	532	wrk_first.next =
442	etp_atfork_parent (void)	533	wrk_first.prev = &wrk_first;
443	{
444	}
445
446	static void ecb_cold
447	etp_atfork_child (void)
448	{
449	ETP_REQ *prv;
450
451	while ((prv = reqq_shift (&req_queue)))
452	ETP_DESTROY (prv);
453
454	while ((prv = reqq_shift (&res_queue)))
455	ETP_DESTROY (prv);
456
457	while (wrk_first.next != &wrk_first)
458	{
459	etp_worker *wrk = wrk_first.next;
460
461	if (wrk->req)
462	ETP_DESTROY (wrk->req);
463
464	etp_worker_clear (wrk);
465	etp_worker_free (wrk);
466	}
467		534
468	started = 0;	535	started = 0;
469	idle = 0;	536	idle = 0;
470	nreqs = 0;	537	nreqs = 0;
471	nready = 0;	538	nready = 0;
472	npending = 0;	539	npending = 0;
473
474	etp_thread_init ();
475	}
476
477	static void ecb_cold
478	etp_once_init (void)
479	{
480	etp_thread_init ();
481	X_THREAD_ATFORK (etp_atfork_prepare, etp_atfork_parent, etp_atfork_child);
482	}
483
484	static int ecb_cold
485	etp_init (void (want_poll)(void), void (done_poll)(void))
486	{
487	static pthread_once_t doinit = PTHREAD_ONCE_INIT;
488
489	pthread_once (&doinit, etp_once_init);
490		540
491	want_poll_cb = want_poll;	541	want_poll_cb = want_poll;
492	done_poll_cb = done_poll;	542	done_poll_cb = done_poll;
493		543
494	return 0;	544	return 0;
…		…
952	#if !HAVE_FDATASYNC	1002	#if !HAVE_FDATASYNC
953	# undef fdatasync	1003	# undef fdatasync
954	# define fdatasync(fd) fsync (fd)	1004	# define fdatasync(fd) fsync (fd)
955	#endif	1005	#endif
956		1006
		1007	static int
		1008	eio__syncfs (int fd)
		1009	{
		1010	int res;
		1011
		1012	#if HAVE_SYS_SYNCFS
		1013	res = (int)syscall (__NR_syncfs, (int)(fd));
		1014	#else
		1015	res = -1;
		1016	errno = ENOSYS;
		1017	#endif
		1018
		1019	if (res < 0 && errno == ENOSYS && fd >= 0)
		1020	sync ();
		1021
		1022	return res;
		1023	}
		1024
957	/* sync_file_range always needs emulation */	1025	/* sync_file_range always needs emulation */
958	static int	1026	static int
959	eio__sync_file_range (int fd, off_t offset, size_t nbytes, unsigned int flags)	1027	eio__sync_file_range (int fd, off_t offset, size_t nbytes, unsigned int flags)
960	{	1028	{
961	#if HAVE_SYNC_FILE_RANGE	1029	#if HAVE_SYNC_FILE_RANGE
…		…
1010	pread (fd, eio_buf, len, offset);	1078	pread (fd, eio_buf, len, offset);
1011	offset += len;	1079	offset += len;
1012	todo -= len;	1080	todo -= len;
1013	}	1081	}
1014		1082
		1083	FUBd;
		1084
1015	errno = 0;	1085	errno = 0;
1016	return count;	1086	return count;
1017	}	1087	}
1018		1088
1019	#endif	1089	#endif
1020		1090
1021	/* sendfile always needs emulation */	1091	/* sendfile always needs emulation */
1022	static eio_ssize_t	1092	static eio_ssize_t
1023	eio__sendfile (int ofd, int ifd, off_t offset, size_t count, etp_worker *self)	1093	eio__sendfile (int ofd, int ifd, off_t offset, size_t count)
1024	{	1094	{
1025	eio_ssize_t written = 0;	1095	eio_ssize_t written = 0;
1026	eio_ssize_t res;	1096	eio_ssize_t res;
1027		1097
1028	if (!count)	1098	if (!count)
…		…
1126	&& (errno == ENOSYS \|\| errno == EINVAL \|\| errno == ENOTSOCK	1196	&& (errno == ENOSYS \|\| errno == EINVAL \|\| errno == ENOTSOCK
1127	/* BSDs */	1197	/* BSDs */
1128	#ifdef ENOTSUP /* sigh, if the steenking pile called openbsd would only try to at least compile posix code... */	1198	#ifdef ENOTSUP /* sigh, if the steenking pile called openbsd would only try to at least compile posix code... */
1129	\|\| errno == ENOTSUP	1199	\|\| errno == ENOTSUP
1130	#endif	1200	#endif
		1201	#ifdef EOPNOTSUPP /* windows */
1131	\|\| errno == EOPNOTSUPP /* BSDs */	1202	\|\| errno == EOPNOTSUPP /* BSDs */
		1203	#endif
1132	#if __solaris	1204	#if __solaris
1133	\|\| errno == EAFNOSUPPORT \|\| errno == EPROTOTYPE	1205	\|\| errno == EAFNOSUPPORT \|\| errno == EPROTOTYPE
1134	#endif	1206	#endif
1135	)	1207	)
1136	)	1208	)
…		…
1162		1234
1163	offset += cnt;	1235	offset += cnt;
1164	res += cnt;	1236	res += cnt;
1165	count -= cnt;	1237	count -= cnt;
1166	}	1238	}
		1239
		1240	FUBd;
1167	}	1241	}
1168		1242
1169	return res;	1243	return res;
1170	}	1244	}
1171		1245
…		…
1286	}	1360	}
1287		1361
1288	/*****************************************************************************/	1362	/*****************************************************************************/
1289	/* requests implemented outside eio_execute, because they are so large */	1363	/* requests implemented outside eio_execute, because they are so large */
1290		1364
		1365	/* copies some absolute path to tmpbuf */
		1366	static char *
		1367	eio__getwd (struct tmpbuf *tmpbuf, eio_wd wd)
		1368	{
		1369	if (wd == EIO_CWD)
		1370	return getcwd (tmpbuf->ptr, PATH_MAX);
		1371
		1372	#if HAVE_AT
		1373	abort (); /TODO/
		1374	#else
		1375	strcpy (tmpbuf->ptr, wd);
		1376	#endif
		1377	return tmpbuf->ptr;
		1378	}
		1379
		1380	/* result will always end up in tmpbuf, there is always space for adding a 0-byte */
1291	static void	1381	static int
1292	eio__realpath (eio_req req, etp_worker self)	1382	eio__realpath (struct tmpbuf tmpbuf, eio_wd wd, const char path)
1293	{	1383	{
1294	char *rel = req->ptr1;	1384	const char *rel = path;
1295	char *res;	1385	char *res;
1296	char tmp1, tmp2;	1386	char tmp1, tmp2;
1297	#if SYMLOOP_MAX > 32	1387	#if SYMLOOP_MAX > 32
1298	int symlinks = SYMLOOP_MAX;	1388	int symlinks = SYMLOOP_MAX;
1299	#else	1389	#else
1300	int symlinks = 32;	1390	int symlinks = 32;
1301	#endif	1391	#endif
1302		1392
1303	req->result = -1;	1393	/D/ /TODO: wd ignored /
1304		1394
1305	errno = EINVAL;	1395	errno = EINVAL;
1306	if (!rel)	1396	if (!rel)
1307	return;	1397	return -1;
1308		1398
1309	errno = ENOENT;	1399	errno = ENOENT;
1310	if (!*rel)	1400	if (!*rel)
1311	return;	1401	return -1;
1312		1402
1313	if (!req->ptr2)	1403	res = tmpbuf_get (tmpbuf, PATH_MAX * 3);
1314	{
1315	X_LOCK (wrklock);
1316	req->flags \|= EIO_FLAG_PTR2_FREE;
1317	X_UNLOCK (wrklock);
1318	req->ptr2 = malloc (PATH_MAX * 3);
1319
1320	errno = ENOMEM;
1321	if (!req->ptr2)
1322	return;
1323	}
1324
1325	res = req->ptr2;
1326	tmp1 = res + PATH_MAX;	1404	tmp1 = res + PATH_MAX;
1327	tmp2 = tmp1 + PATH_MAX;	1405	tmp2 = tmp1 + PATH_MAX;
1328		1406
1329	#if 0 /* disabled, the musl way to do things is just too racy */	1407	#if 0 /* disabled, the musl way to do things is just too racy */
1330	#if __linux && defined(O_NONBLOCK) && defined(O_NOATIME)	1408	#if __linux && defined(O_NONBLOCK) && defined(O_NOATIME)
…		…
1349	#endif	1427	#endif
1350	#endif	1428	#endif
1351		1429
1352	if (*rel != '/')	1430	if (*rel != '/')
1353	{	1431	{
1354	if (!getcwd (res, PATH_MAX))	1432	if (!eio__getwd (tmpbuf, wd))
1355	return;	1433	return -1;
1356		1434
1357	if (res [1]) /* only use if not / */	1435	if (res [1]) /* only use if not / */
1358	res += strlen (res);	1436	res += strlen (res);
1359	}	1437	}
1360		1438
1361	while (*rel)	1439	while (*rel)
1362	{	1440	{
1363	eio_ssize_t len, linklen;	1441	eio_ssize_t len, linklen;
1364	char *beg = rel;	1442	const char *beg = rel;
1365		1443
1366	while (rel && rel != '/')	1444	while (rel && rel != '/')
1367	++rel;	1445	++rel;
1368		1446
1369	len = rel - beg;	1447	len = rel - beg;
…		…
1381		1459
1382	if (beg [1] == '.' && len == 2)	1460	if (beg [1] == '.' && len == 2)
1383	{	1461	{
1384	/* .. - back up one component, if possible */	1462	/* .. - back up one component, if possible */
1385		1463
1386	while (res != req->ptr2)	1464	while (res != tmpbuf->ptr)
1387	if (*--res == '/')	1465	if (*--res == '/')
1388	break;	1466	break;
1389		1467
1390	continue;	1468	continue;
1391	}	1469	}
…		…
1401		1479
1402	/* zero-terminate, for readlink */	1480	/* zero-terminate, for readlink */
1403	res [len + 1] = 0;	1481	res [len + 1] = 0;
1404		1482
1405	/* now check if it's a symlink */	1483	/* now check if it's a symlink */
1406	linklen = readlink (req->ptr2, tmp1, PATH_MAX);	1484	linklen = readlink (tmpbuf->ptr, tmp1, PATH_MAX);
1407		1485
1408	if (linklen < 0)	1486	if (linklen < 0)
1409	{	1487	{
1410	if (errno != EINVAL)	1488	if (errno != EINVAL)
1411	return;	1489	return -1;
1412		1490
1413	/* it's a normal directory. hopefully */	1491	/* it's a normal directory. hopefully */
1414	res += len + 1;	1492	res += len + 1;
1415	}	1493	}
1416	else	1494	else
…		…
1418	/* yay, it was a symlink - build new path in tmp2 */	1496	/* yay, it was a symlink - build new path in tmp2 */
1419	int rellen = strlen (rel);	1497	int rellen = strlen (rel);
1420		1498
1421	errno = ENAMETOOLONG;	1499	errno = ENAMETOOLONG;
1422	if (linklen + 1 + rellen >= PATH_MAX)	1500	if (linklen + 1 + rellen >= PATH_MAX)
1423	return;	1501	return -1;
1424		1502
1425	errno = ELOOP;	1503	errno = ELOOP;
1426	if (!--symlinks)	1504	if (!--symlinks)
1427	return;	1505	return -1;
1428		1506
1429	if (*tmp1 == '/')	1507	if (*tmp1 == '/')
1430	res = req->ptr2; /* symlink resolves to an absolute path */	1508	res = tmpbuf->ptr; /* symlink resolves to an absolute path */
1431		1509
1432	/* we need to be careful, as rel might point into tmp2 already */	1510	/* we need to be careful, as rel might point into tmp2 already */
1433	memmove (tmp2 + linklen + 1, rel, rellen + 1);	1511	memmove (tmp2 + linklen + 1, rel, rellen + 1);
1434	tmp2 [linklen] = '/';	1512	tmp2 [linklen] = '/';
1435	memcpy (tmp2, tmp1, linklen);	1513	memcpy (tmp2, tmp1, linklen);
…		…
1437	rel = tmp2;	1515	rel = tmp2;
1438	}	1516	}
1439	}	1517	}
1440		1518
1441	/* special case for the lone root path */	1519	/* special case for the lone root path */
1442	if (res == req->ptr2)	1520	if (res == tmpbuf->ptr)
1443	*res++ = '/';	1521	*res++ = '/';
1444		1522
1445	req->result = res - (char *)req->ptr2;	1523	return res - (char *)tmpbuf->ptr;
1446
1447	done:
1448	req->ptr2 = realloc (req->ptr2, req->result); /* trade time for space savings */
1449	}	1524	}
1450		1525
1451	static signed char	1526	static signed char
1452	eio_dent_cmp (const eio_dirent a, const eio_dirent b)	1527	eio_dent_cmp (const eio_dirent a, const eio_dirent b)
1453	{	1528	{
…		…
1461		1536
1462	#define EIO_SORT_CUTOFF 30 /* quite high, but performs well on many filesystems */	1537	#define EIO_SORT_CUTOFF 30 /* quite high, but performs well on many filesystems */
1463	#define EIO_SORT_FAST 60 /* when to only use insertion sort */	1538	#define EIO_SORT_FAST 60 /* when to only use insertion sort */
1464		1539
1465	static void	1540	static void
1466	eio_dent_radix_sort (eio_dirent *dents, int size, signed char score_bits, ino_t inode_bits)	1541	eio_dent_radix_sort (eio_dirent *dents, int size, signed char score_bits, eio_ino_t inode_bits)
1467	{	1542	{
1468	unsigned char bits [9 + sizeof (ino_t) * 8];	1543	unsigned char bits [9 + sizeof (eio_ino_t) * 8];
1469	unsigned char *bit = bits;	1544	unsigned char *bit = bits;
1470		1545
1471	assert (CHAR_BIT == 8);	1546	assert (CHAR_BIT == 8);
1472	assert (sizeof (eio_dirent) * 8 < 256);	1547	assert (sizeof (eio_dirent) * 8 < 256);
1473	assert (offsetof (eio_dirent, inode)); /* we use bit #0 as sentinel */	1548	assert (offsetof (eio_dirent, inode)); /* we use bit #0 as sentinel */
…		…
1475		1550
1476	if (size <= EIO_SORT_FAST)	1551	if (size <= EIO_SORT_FAST)
1477	return;	1552	return;
1478		1553
1479	/* first prepare an array of bits to test in our radix sort */	1554	/* first prepare an array of bits to test in our radix sort */
1480	/* try to take endianness into account, as well as differences in ino_t sizes */	1555	/* try to take endianness into account, as well as differences in eio_ino_t sizes */
1481	/* inode_bits must contain all inodes ORed together */	1556	/* inode_bits must contain all inodes ORed together */
1482	/* which is used to skip bits that are 0 everywhere, which is very common */	1557	/* which is used to skip bits that are 0 everywhere, which is very common */
1483	{	1558	{
1484	ino_t endianness;	1559	eio_ino_t endianness;
1485	int i, j;	1560	int i, j;
1486		1561
1487	/* we store the byte offset of byte n into byte n of "endianness" */	1562	/* we store the byte offset of byte n into byte n of "endianness" */
1488	for (i = 0; i < sizeof (ino_t); ++i)	1563	for (i = 0; i < sizeof (eio_ino_t); ++i)
1489	((unsigned char *)&endianness)[i] = i;	1564	((unsigned char *)&endianness)[i] = i;
1490		1565
1491	*bit++ = 0;	1566	*bit++ = 0;
1492		1567
1493	for (i = 0; i < sizeof (ino_t); ++i)	1568	for (i = 0; i < sizeof (eio_ino_t); ++i)
1494	{	1569	{
1495	/* shifting off the byte offsets out of "endianness" */	1570	/* shifting off the byte offsets out of "endianness" */
1496	int offs = (offsetof (eio_dirent, inode) + (endianness & 0xff)) * 8;	1571	int offs = (offsetof (eio_dirent, inode) + (endianness & 0xff)) * 8;
1497	endianness >>= 8;	1572	endianness >>= 8;
1498		1573
1499	for (j = 0; j < 8; ++j)	1574	for (j = 0; j < 8; ++j)
1500	if (inode_bits & (((ino_t)1) << (i * 8 + j)))	1575	if (inode_bits & (((eio_ino_t)1) << (i * 8 + j)))
1501	*bit++ = offs + j;	1576	*bit++ = offs + j;
1502	}	1577	}
1503		1578
1504	for (j = 0; j < 8; ++j)	1579	for (j = 0; j < 8; ++j)
1505	if (score_bits & (1 << j))	1580	if (score_bits & (1 << j))
1506	bit++ = offsetof (eio_dirent, score) 8 + j;	1581	bit++ = offsetof (eio_dirent, score) 8 + j;
1507	}	1582	}
1508		1583
1509	/* now actually do the sorting (a variant of MSD radix sort) */	1584	/* now actually do the sorting (a variant of MSD radix sort) */
1510	{	1585	{
1511	eio_dirent base_stk [9 + sizeof (ino_t) 8], *base;	1586	eio_dirent base_stk [9 + sizeof (eio_ino_t) 8], *base;
1512	eio_dirent end_stk [9 + sizeof (ino_t) 8], *end;	1587	eio_dirent end_stk [9 + sizeof (eio_ino_t) 8], *end;
1513	unsigned char bit_stk [9 + sizeof (ino_t) 8];	1588	unsigned char bit_stk [9 + sizeof (eio_ino_t) 8];
1514	int stk_idx = 0;	1589	int stk_idx = 0;
1515		1590
1516	base_stk [stk_idx] = dents;	1591	base_stk [stk_idx] = dents;
1517	end_stk [stk_idx] = dents + size;	1592	end_stk [stk_idx] = dents + size;
1518	bit_stk [stk_idx] = bit - 1;	1593	bit_stk [stk_idx] = bit - 1;
…		…
1597	}	1672	}
1598	}	1673	}
1599	}	1674	}
1600		1675
1601	static void	1676	static void
1602	eio_dent_sort (eio_dirent *dents, int size, signed char score_bits, ino_t inode_bits)	1677	eio_dent_sort (eio_dirent *dents, int size, signed char score_bits, eio_ino_t inode_bits)
1603	{	1678	{
1604	if (size <= 1)	1679	if (size <= 1)
1605	return; /* our insertion sort relies on size > 0 */	1680	return; /* our insertion sort relies on size > 0 */
1606		1681
1607	/* first we use a radix sort, but only for dirs >= EIO_SORT_FAST */	1682	/* first we use a radix sort, but only for dirs >= EIO_SORT_FAST */
…		…
1613	eio_dent_insertion_sort (dents, size);	1688	eio_dent_insertion_sort (dents, size);
1614	}	1689	}
1615		1690
1616	/* read a full directory */	1691	/* read a full directory */
1617	static void	1692	static void
1618	eio__scandir (eio_req req, etp_worker self)	1693	eio__scandir (eio_req *req)
1619	{	1694	{
1620	DIR *dirp;
1621	EIO_STRUCT_DIRENT *entp;
1622	char name, names;	1695	char name, names;
1623	int namesalloc = 4096;	1696	int namesalloc = 4096 - sizeof (void ) 4;
1624	int namesoffs = 0;	1697	int namesoffs = 0;
1625	int flags = req->int1;	1698	int flags = req->int1;
1626	eio_dirent *dents = 0;	1699	eio_dirent *dents = 0;
1627	int dentalloc = 128;	1700	int dentalloc = 128;
1628	int dentoffs = 0;	1701	int dentoffs = 0;
1629	ino_t inode_bits = 0;	1702	eio_ino_t inode_bits = 0;
		1703	#ifdef _WIN32
		1704	HANDLE dirp;
		1705	WIN32_FIND_DATA entp;
		1706	#else
		1707	DIR *dirp;
		1708	EIO_STRUCT_DIRENT *entp;
		1709	#endif
1630		1710
1631	req->result = -1;	1711	req->result = -1;
1632		1712
1633	if (!(flags & EIO_READDIR_DENTS))	1713	if (!(flags & EIO_READDIR_DENTS))
1634	flags &= ~(EIO_READDIR_DIRS_FIRST \| EIO_READDIR_STAT_ORDER);	1714	flags &= ~(EIO_READDIR_DIRS_FIRST \| EIO_READDIR_STAT_ORDER);
1635		1715
1636	X_LOCK (wrklock);	1716	#ifdef _WIN32
1637	/* the corresponding closedir is in ETP_WORKER_CLEAR */	1717	{
		1718	int len = strlen ((const char *)req->ptr1);
		1719	char *path = malloc (MAX_PATH);
		1720	const char *fmt;
		1721
		1722	if (!len)
		1723	fmt = "./*";
		1724	else if (((const char )req->ptr1)[len - 1] == '/' \|\| ((const char )req->ptr1)[len - 1] == '\\')
		1725	fmt = "%s*";
		1726	else
		1727	fmt = "%s/*";
		1728
		1729	_snprintf (path, MAX_PATH, fmt, (const char *)req->ptr1);
		1730	dirp = FindFirstFile (path, &entp);
		1731	free (path);
		1732
		1733	if (dirp == INVALID_HANDLE_VALUE)
		1734	{
		1735	/* should steal _dosmaperr */
		1736	switch (GetLastError ())
		1737	{
		1738	case ERROR_FILE_NOT_FOUND:
		1739	req->result = 0;
		1740	break;
		1741
		1742	case ERROR_INVALID_NAME:
		1743	case ERROR_PATH_NOT_FOUND:
		1744	case ERROR_NO_MORE_FILES:
		1745	errno = ENOENT;
		1746	break;
		1747
		1748	case ERROR_NOT_ENOUGH_MEMORY:
		1749	errno = ENOMEM;
		1750	break;
		1751
		1752	default:
		1753	errno = EINVAL;
		1754	break;
		1755	}
		1756
		1757	return;
		1758	}
		1759	}
		1760	#else
1638	self->dirp = dirp = opendir (req->ptr1);	1761	dirp = opendir (req->ptr1);
		1762
		1763	if (!dirp)
		1764	return;
		1765	#endif
1639		1766
1640	if (req->flags & EIO_FLAG_PTR1_FREE)	1767	if (req->flags & EIO_FLAG_PTR1_FREE)
1641	free (req->ptr1);	1768	free (req->ptr1);
1642		1769
1643	req->flags \|= EIO_FLAG_PTR1_FREE \| EIO_FLAG_PTR2_FREE;	1770	req->flags \|= EIO_FLAG_PTR1_FREE \| EIO_FLAG_PTR2_FREE;
1644	req->ptr1 = dents = flags ? malloc (dentalloc * sizeof (eio_dirent)) : 0;	1771	req->ptr1 = dents = flags ? malloc (dentalloc * sizeof (eio_dirent)) : 0;
1645	req->ptr2 = names = malloc (namesalloc);	1772	req->ptr2 = names = malloc (namesalloc);
1646	X_UNLOCK (wrklock);
1647		1773
1648	if (dirp && names && (!flags \|\| dents))	1774	if (!names \|\| (flags && !dents))
		1775	return;
		1776
1649	for (;;)	1777	for (;;)
1650	{	1778	{
		1779	int done;
		1780
		1781	#ifdef _WIN32
		1782	done = !dirp;
		1783	#else
1651	errno = 0;	1784	errno = 0;
1652	entp = readdir (dirp);	1785	entp = readdir (dirp);
		1786	done = !entp;
		1787	#endif
1653		1788
1654	if (!entp)	1789	if (done)
1655	{	1790	{
		1791	#ifndef _WIN32
		1792	int old_errno = errno;
		1793	closedir (dirp);
		1794	errno = old_errno;
		1795
1656	if (errno)	1796	if (errno)
1657	break;	1797	break;
		1798	#endif
1658		1799
1659	/* sort etc. */	1800	/* sort etc. */
1660	req->int1 = flags;	1801	req->int1 = flags;
1661	req->result = dentoffs;	1802	req->result = dentoffs;
1662		1803
1663	if (flags & EIO_READDIR_STAT_ORDER)	1804	if (flags & EIO_READDIR_STAT_ORDER)
1664	eio_dent_sort (dents, dentoffs, flags & EIO_READDIR_DIRS_FIRST ? 7 : 0, inode_bits);	1805	eio_dent_sort (dents, dentoffs, flags & EIO_READDIR_DIRS_FIRST ? 7 : 0, inode_bits);
1665	else if (flags & EIO_READDIR_DIRS_FIRST)	1806	else if (flags & EIO_READDIR_DIRS_FIRST)
1666	if (flags & EIO_READDIR_FOUND_UNKNOWN)	1807	if (flags & EIO_READDIR_FOUND_UNKNOWN)
1667	eio_dent_sort (dents, dentoffs, 7, inode_bits); /* sort by score and inode */	1808	eio_dent_sort (dents, dentoffs, 7, inode_bits); /* sort by score and inode */
1668	else	1809	else
		1810	{
		1811	/* in this case, all is known, and we just put dirs first and sort them */
		1812	eio_dirent *oth = dents + dentoffs;
		1813	eio_dirent *dir = dents;
		1814
		1815	/* now partition dirs to the front, and non-dirs to the back */
		1816	/* by walking from both sides and swapping if necessary */
		1817	while (oth > dir)
		1818	{
		1819	if (dir->type == EIO_DT_DIR)
		1820	++dir;
		1821	else if ((--oth)->type == EIO_DT_DIR)
		1822	{
		1823	eio_dirent tmp = dir; dir = oth; oth = tmp;
		1824
		1825	++dir;
		1826	}
		1827	}
		1828
		1829	/* now sort the dirs only (dirs all have the same score) */
		1830	eio_dent_sort (dents, dir - dents, 0, inode_bits);
		1831	}
		1832
		1833	break;
		1834	}
		1835
		1836	/* now add the entry to our list(s) */
		1837	name = D_NAME (entp);
		1838
		1839	/* skip . and .. entries */
		1840	if (name [0] != '.' \|\| (name [1] && (name [1] != '.' \|\| name [2])))
		1841	{
		1842	int len = D_NAMLEN (entp) + 1;
		1843
		1844	while (ecb_expect_false (namesoffs + len > namesalloc))
		1845	{
		1846	namesalloc *= 2;
		1847	req->ptr2 = names = realloc (names, namesalloc);
		1848
		1849	if (!names)
		1850	break;
		1851	}
		1852
		1853	memcpy (names + namesoffs, name, len);
		1854
		1855	if (dents)
		1856	{
		1857	struct eio_dirent *ent;
		1858
		1859	if (ecb_expect_false (dentoffs == dentalloc))
1669	{	1860	{
1670	/* in this case, all is known, and we just put dirs first and sort them */	1861	dentalloc *= 2;
		1862	req->ptr1 = dents = realloc (dents, dentalloc * sizeof (eio_dirent));
		1863
		1864	if (!dents)
		1865	break;
		1866	}
		1867
1671	eio_dirent *oth = dents + dentoffs;	1868	ent = dents + dentoffs;
1672	eio_dirent *dir = dents;
1673		1869
1674	/* now partition dirs to the front, and non-dirs to the back */	1870	ent->nameofs = namesoffs; /* rather dirtily we store the offset in the pointer */
1675	/* by walking from both sides and swapping if necessary */	1871	ent->namelen = len - 1;
1676	while (oth > dir)	1872	ent->inode = D_INO (entp);
		1873
		1874	inode_bits \|= ent->inode;
		1875
		1876	switch (D_TYPE (entp))
		1877	{
		1878	default:
		1879	ent->type = EIO_DT_UNKNOWN;
		1880	flags \|= EIO_READDIR_FOUND_UNKNOWN;
		1881	break;
		1882
		1883	#ifdef DT_FIFO
		1884	case DT_FIFO: ent->type = EIO_DT_FIFO; break;
		1885	#endif
		1886	#ifdef DT_CHR
		1887	case DT_CHR: ent->type = EIO_DT_CHR; break;
		1888	#endif
		1889	#ifdef DT_MPC
		1890	case DT_MPC: ent->type = EIO_DT_MPC; break;
		1891	#endif
		1892	#ifdef DT_DIR
		1893	case DT_DIR: ent->type = EIO_DT_DIR; break;
		1894	#endif
		1895	#ifdef DT_NAM
		1896	case DT_NAM: ent->type = EIO_DT_NAM; break;
		1897	#endif
		1898	#ifdef DT_BLK
		1899	case DT_BLK: ent->type = EIO_DT_BLK; break;
		1900	#endif
		1901	#ifdef DT_MPB
		1902	case DT_MPB: ent->type = EIO_DT_MPB; break;
		1903	#endif
		1904	#ifdef DT_REG
		1905	case DT_REG: ent->type = EIO_DT_REG; break;
		1906	#endif
		1907	#ifdef DT_NWK
		1908	case DT_NWK: ent->type = EIO_DT_NWK; break;
		1909	#endif
		1910	#ifdef DT_CMP
		1911	case DT_CMP: ent->type = EIO_DT_CMP; break;
		1912	#endif
		1913	#ifdef DT_LNK
		1914	case DT_LNK: ent->type = EIO_DT_LNK; break;
		1915	#endif
		1916	#ifdef DT_SOCK
		1917	case DT_SOCK: ent->type = EIO_DT_SOCK; break;
		1918	#endif
		1919	#ifdef DT_DOOR
		1920	case DT_DOOR: ent->type = EIO_DT_DOOR; break;
		1921	#endif
		1922	#ifdef DT_WHT
		1923	case DT_WHT: ent->type = EIO_DT_WHT; break;
		1924	#endif
		1925	}
		1926
		1927	ent->score = 7;
		1928
		1929	if (flags & EIO_READDIR_DIRS_FIRST)
		1930	{
		1931	if (ent->type == EIO_DT_UNKNOWN)
1677	{	1932	{
1678	if (dir->type == EIO_DT_DIR)	1933	if (name == '.') / leading dots are likely directories, and, in any case, rare */
1679	++dir;	1934	ent->score = 1;
1680	else if ((--oth)->type == EIO_DT_DIR)	1935	else if (!strchr (name, '.')) /* absense of dots indicate likely dirs */
1681	{	1936	ent->score = len <= 2 ? 4 - len : len <= 4 ? 4 : len <= 7 ? 5 : 6; /* shorter == more likely dir, but avoid too many classes */
1682	eio_dirent tmp = dir; dir = oth; oth = tmp;
1683
1684	++dir;
1685	}
1686	}	1937	}
1687		1938	else if (ent->type == EIO_DT_DIR)
1688	/* now sort the dirs only (dirs all have the same score) */	1939	ent->score = 0;
1689	eio_dent_sort (dents, dir - dents, 0, inode_bits);
1690	}	1940	}
1691
1692	break;
1693	}
1694
1695	/* now add the entry to our list(s) */
1696	name = entp->d_name;
1697
1698	/* skip . and .. entries */
1699	if (name [0] != '.' \|\| (name [1] && (name [1] != '.' \|\| name [2])))
1700	{
1701	int len = D_NAMLEN (entp) + 1;
1702
1703	while (ecb_expect_false (namesoffs + len > namesalloc))
1704	{
1705	namesalloc *= 2;
1706	X_LOCK (wrklock);
1707	req->ptr2 = names = realloc (names, namesalloc);
1708	X_UNLOCK (wrklock);
1709
1710	if (!names)
1711	break;
1712	}	1941	}
1713		1942
1714	memcpy (names + namesoffs, name, len);
1715
1716	if (dents)
1717	{
1718	struct eio_dirent *ent;
1719
1720	if (ecb_expect_false (dentoffs == dentalloc))
1721	{
1722	dentalloc *= 2;
1723	X_LOCK (wrklock);
1724	req->ptr1 = dents = realloc (dents, dentalloc * sizeof (eio_dirent));
1725	X_UNLOCK (wrklock);
1726
1727	if (!dents)
1728	break;
1729	}
1730
1731	ent = dents + dentoffs;
1732
1733	ent->nameofs = namesoffs; /* rather dirtily we store the offset in the pointer */
1734	ent->namelen = len - 1;
1735	ent->inode = D_INO (entp);
1736
1737	inode_bits \|= ent->inode;
1738
1739	switch (D_TYPE (entp))
1740	{
1741	default:
1742	ent->type = EIO_DT_UNKNOWN;
1743	flags \|= EIO_READDIR_FOUND_UNKNOWN;
1744	break;
1745
1746	#ifdef DT_FIFO
1747	case DT_FIFO: ent->type = EIO_DT_FIFO; break;
1748	#endif
1749	#ifdef DT_CHR
1750	case DT_CHR: ent->type = EIO_DT_CHR; break;
1751	#endif
1752	#ifdef DT_MPC
1753	case DT_MPC: ent->type = EIO_DT_MPC; break;
1754	#endif
1755	#ifdef DT_DIR
1756	case DT_DIR: ent->type = EIO_DT_DIR; break;
1757	#endif
1758	#ifdef DT_NAM
1759	case DT_NAM: ent->type = EIO_DT_NAM; break;
1760	#endif
1761	#ifdef DT_BLK
1762	case DT_BLK: ent->type = EIO_DT_BLK; break;
1763	#endif
1764	#ifdef DT_MPB
1765	case DT_MPB: ent->type = EIO_DT_MPB; break;
1766	#endif
1767	#ifdef DT_REG
1768	case DT_REG: ent->type = EIO_DT_REG; break;
1769	#endif
1770	#ifdef DT_NWK
1771	case DT_NWK: ent->type = EIO_DT_NWK; break;
1772	#endif
1773	#ifdef DT_CMP
1774	case DT_CMP: ent->type = EIO_DT_CMP; break;
1775	#endif
1776	#ifdef DT_LNK
1777	case DT_LNK: ent->type = EIO_DT_LNK; break;
1778	#endif
1779	#ifdef DT_SOCK
1780	case DT_SOCK: ent->type = EIO_DT_SOCK; break;
1781	#endif
1782	#ifdef DT_DOOR
1783	case DT_DOOR: ent->type = EIO_DT_DOOR; break;
1784	#endif
1785	#ifdef DT_WHT
1786	case DT_WHT: ent->type = EIO_DT_WHT; break;
1787	#endif
1788	}
1789
1790	ent->score = 7;
1791
1792	if (flags & EIO_READDIR_DIRS_FIRST)
1793	{
1794	if (ent->type == EIO_DT_UNKNOWN)
1795	{
1796	if (name == '.') / leading dots are likely directories, and, in any case, rare */
1797	ent->score = 1;
1798	else if (!strchr (name, '.')) /* absense of dots indicate likely dirs */
1799	ent->score = len <= 2 ? 4 - len : len <= 4 ? 4 : len <= 7 ? 5 : 6; /* shorter == more likely dir, but avoid too many classes */
1800	}
1801	else if (ent->type == EIO_DT_DIR)
1802	ent->score = 0;
1803	}
1804	}
1805
1806	namesoffs += len;	1943	namesoffs += len;
1807	++dentoffs;	1944	++dentoffs;
1808	}	1945	}
1809		1946
1810	if (EIO_CANCELLED (req))	1947	if (EIO_CANCELLED (req))
1811	{	1948	{
1812	errno = ECANCELED;	1949	errno = ECANCELED;
1813	break;	1950	break;
1814	}	1951	}
		1952
		1953	#ifdef _WIN32
		1954	if (!FindNextFile (dirp, &entp))
		1955	{
		1956	FindClose (dirp);
		1957	dirp = 0;
1815	}	1958	}
		1959	#endif
		1960	}
1816	}	1961	}
		1962
		1963	/*****************************************************************************/
		1964	/* working directory stuff */
		1965
		1966	#if HAVE_AT
		1967
		1968	#define WD2FD(wd) (wd ? ((int)wd) - 1 : AT_FDCWD)
		1969
		1970	eio_wd
		1971	eio_wd_open_sync (eio_wd wd, const char *path)
		1972	{
		1973	int fd = openat (WD2FD (wd), path, O_CLOEXEC \| O_SEARCH \| O_DIRECTORY);
		1974
		1975	return fd >= 0 ? (eio_wd)(fd + 1) : EIO_INVALID_WD;
		1976	}
		1977
		1978	void
		1979	eio_wd_close_sync (eio_wd wd)
		1980	{
		1981	int fd = WD2FD (wd);
		1982
		1983	if (fd >= 0)
		1984	close (fd);
		1985	}
		1986
		1987	#else
		1988
		1989	/* on legacy systems, we represent the working directories simply by their path strings */
		1990
		1991	static const char *
		1992	wd_expand (struct tmpbuf tmpbuf, eio_wd wd, const char path)
		1993	{
		1994	if (!wd \|\| *path == '/')
		1995	return path;
		1996
		1997	{
		1998	int l1 = strlen ((const char *)wd);
		1999	int l2 = strlen (path);
		2000
		2001	char *res = tmpbuf_get (tmpbuf, l1 + l2 + 2);
		2002
		2003	memcpy (res, wd, l1);
		2004	res [l1] = '/';
		2005	memcpy (res + l1 + 1, path, l2 + 1);
		2006
		2007	return res;
		2008	}
		2009	}
		2010
		2011	eio_wd
		2012	eio__wd_open_sync (struct tmpbuf tmpbuf, eio_wd wd, const char path)
		2013	{
		2014	if (path == '/') / absolute paths ignore wd */
		2015	path = strdup (path);
		2016	else if (path [0] == '.' && !path [1]) /* special case '.', as it is common */
		2017	return wd;
		2018	else
		2019	{
		2020	int len = eio__realpath (tmpbuf, wd, path);
		2021
		2022	path = EIO_INVALID_WD;
		2023
		2024	if (len >= 0)
		2025	{
		2026	((char *)tmpbuf->ptr)[len] = 0;
		2027	path = strdup (tmpbuf->ptr);
		2028	}
		2029	}
		2030
		2031	if (!path)
		2032	path = EIO_INVALID_WD;
		2033
		2034	return (eio_wd)path;
		2035	}
		2036
		2037	eio_wd
		2038	eio_wd_open_sync (eio_wd wd, const char *path)
		2039	{
		2040	struct tmpbuf tmpbuf = { 0 };
		2041	wd = eio__wd_open_sync (&tmpbuf, wd, path);
		2042	free (tmpbuf.ptr);
		2043
		2044	return wd;
		2045	}
		2046
		2047	void
		2048	eio_wd_close_sync (eio_wd wd)
		2049	{
		2050	if (wd != EIO_INVALID_WD)
		2051	free (wd);
		2052	}
		2053
		2054	#endif
1817		2055
1818	/*****************************************************************************/	2056	/*****************************************************************************/
1819		2057
1820	#define ALLOC(len) \	2058	#define ALLOC(len) \
1821	if (!req->ptr2) \	2059	if (!req->ptr2) \
…		…
1835	X_THREAD_PROC (etp_proc)	2073	X_THREAD_PROC (etp_proc)
1836	{	2074	{
1837	ETP_REQ *req;	2075	ETP_REQ *req;
1838	struct timespec ts;	2076	struct timespec ts;
1839	etp_worker self = (etp_worker )thr_arg;	2077	etp_worker self = (etp_worker )thr_arg;
1840	int timeout;	2078
		2079	#if HAVE_PRCTL_SET_NAME
		2080	prctl (PR_SET_NAME, (unsigned long)"eio_thread", 0, 0, 0);
		2081	#endif
1841		2082
1842	/* try to distribute timeouts somewhat evenly */	2083	/* try to distribute timeouts somewhat evenly */
1843	ts.tv_nsec = ((unsigned long)self & 1023UL) * (1000000000UL / 1024UL);	2084	ts.tv_nsec = ((unsigned long)self & 1023UL) * (1000000000UL / 1024UL);
1844		2085
1845	for (;;)	2086	for (;;)
…		…
1848		2089
1849	X_LOCK (reqlock);	2090	X_LOCK (reqlock);
1850		2091
1851	for (;;)	2092	for (;;)
1852	{	2093	{
1853	self->req = req = reqq_shift (&req_queue);	2094	req = reqq_shift (&req_queue);
1854		2095
1855	if (req)	2096	if (req)
1856	break;	2097	break;
1857		2098
1858	if (ts.tv_sec == 1) /* no request, but timeout detected, let's quit */	2099	if (ts.tv_sec == 1) /* no request, but timeout detected, let's quit */
…		…
1896	++npending;	2137	++npending;
1897		2138
1898	if (!reqq_push (&res_queue, req) && want_poll_cb)	2139	if (!reqq_push (&res_queue, req) && want_poll_cb)
1899	want_poll_cb ();	2140	want_poll_cb ();
1900		2141
1901	self->req = 0;
1902	etp_worker_clear (self);	2142	etp_worker_clear (self);
1903		2143
1904	X_UNLOCK (reslock);	2144	X_UNLOCK (reslock);
1905	}	2145	}
1906		2146
1907	quit:	2147	quit:
		2148	free (req);
		2149
1908	X_LOCK (wrklock);	2150	X_LOCK (wrklock);
1909	etp_worker_free (self);	2151	etp_worker_free (self);
1910	X_UNLOCK (wrklock);	2152	X_UNLOCK (wrklock);
1911		2153
1912	return 0;	2154	return 0;
…		…
1915	/*****************************************************************************/	2157	/*****************************************************************************/
1916		2158
1917	int ecb_cold	2159	int ecb_cold
1918	eio_init (void (want_poll)(void), void (done_poll)(void))	2160	eio_init (void (want_poll)(void), void (done_poll)(void))
1919	{	2161	{
		2162	#if !HAVE_PREADWRITE
		2163	X_MUTEX_CREATE (preadwritelock);
		2164	#endif
		2165
1920	return etp_init (want_poll, done_poll);	2166	return etp_init (want_poll, done_poll);
1921	}	2167	}
1922		2168
1923	ecb_inline void	2169	ecb_inline void
1924	eio_api_destroy (eio_req *req)	2170	eio_api_destroy (eio_req *req)
…		…
1951	}	2197	}
1952		2198
1953	static void	2199	static void
1954	eio_execute (etp_worker self, eio_req req)	2200	eio_execute (etp_worker self, eio_req req)
1955	{	2201	{
		2202	#if HAVE_AT
		2203	int dirfd;
		2204	#else
		2205	const char *path;
		2206	#endif
		2207
1956	if (ecb_expect_false (EIO_CANCELLED (req)))	2208	if (ecb_expect_false (EIO_CANCELLED (req)))
1957	{	2209	{
1958	req->result = -1;	2210	req->result = -1;
1959	req->errorno = ECANCELED;	2211	req->errorno = ECANCELED;
1960	return;	2212	return;
1961	}	2213	}
1962		2214
		2215	if (ecb_expect_false (req->wd == EIO_INVALID_WD))
		2216	{
		2217	req->result = -1;
		2218	req->errorno = ENOENT;
		2219	return;
		2220	}
		2221
		2222	if (req->type >= EIO_OPEN)
		2223	{
		2224	#if HAVE_AT
		2225	dirfd = WD2FD (req->wd);
		2226	#else
		2227	path = wd_expand (&self->tmpbuf, req->wd, req->ptr1);
		2228	#endif
		2229	}
		2230
1963	switch (req->type)	2231	switch (req->type)
1964	{	2232	{
		2233	case EIO_WD_OPEN: req->wd = eio__wd_open_sync (&self->tmpbuf, req->wd, req->ptr1);
		2234	req->result = req->wd == EIO_INVALID_WD ? -1 : 0;
		2235	break;
		2236	case EIO_WD_CLOSE: eio_wd_close_sync (req->wd); break;
		2237
1965	case EIO_READ: ALLOC (req->size);	2238	case EIO_READ: ALLOC (req->size);
1966	req->result = req->offs >= 0	2239	req->result = req->offs >= 0
1967	? pread (req->int1, req->ptr2, req->size, req->offs)	2240	? pread (req->int1, req->ptr2, req->size, req->offs)
1968	: read (req->int1, req->ptr2, req->size); break;	2241	: read (req->int1, req->ptr2, req->size); break;
1969	case EIO_WRITE: req->result = req->offs >= 0	2242	case EIO_WRITE: req->result = req->offs >= 0
1970	? pwrite (req->int1, req->ptr2, req->size, req->offs)	2243	? pwrite (req->int1, req->ptr2, req->size, req->offs)
1971	: write (req->int1, req->ptr2, req->size); break;	2244	: write (req->int1, req->ptr2, req->size); break;
1972		2245
1973	case EIO_READAHEAD: req->result = readahead (req->int1, req->offs, req->size); break;	2246	case EIO_READAHEAD: req->result = readahead (req->int1, req->offs, req->size); break;
1974	case EIO_SENDFILE: req->result = eio__sendfile (req->int1, req->int2, req->offs, req->size, self); break;	2247	case EIO_SENDFILE: req->result = eio__sendfile (req->int1, req->int2, req->offs, req->size); break;
1975		2248
		2249	#if HAVE_AT
		2250	case EIO_GETPATH: abort ();
1976	case EIO_STAT: ALLOC (sizeof (EIO_STRUCT_STAT));	2251	case EIO_STAT: ALLOC (sizeof (EIO_STRUCT_STAT));
1977	req->result = stat (req->ptr1, (EIO_STRUCT_STAT *)req->ptr2); break;	2252	req->result = fstatat (dirfd, path, (EIO_STRUCT_STAT *)req->ptr2); break;
1978	case EIO_LSTAT: ALLOC (sizeof (EIO_STRUCT_STAT));	2253	case EIO_LSTAT: ALLOC (sizeof (EIO_STRUCT_STAT));
1979	req->result = lstat (req->ptr1, (EIO_STRUCT_STAT *)req->ptr2); break;	2254	req->result = lstat (dirfd, path, (EIO_STRUCT_STAT *)req->ptr2); break;
		2255	#if 0/D/
		2256	case EIO_STATVFS: ALLOC (sizeof (EIO_STRUCT_STATVFS));
		2257	req->result = statvfs (dirfd, path, (EIO_STRUCT_STATVFS *)req->ptr2); break;
		2258	#endif
		2259	case EIO_CHOWN: req->result = chown (dirfd, path, req->int2, req->int3); break;
		2260	case EIO_CHMOD: req->result = chmod (dirfd, path, (mode_t)req->int2); break;
		2261	case EIO_TRUNCATE: req->result = truncate (dirfd, path, req->offs); break;
		2262	case EIO_OPEN: req->result = open (dirfd, path, req->int1, (mode_t)req->int2); break;
		2263
		2264	case EIO_UNLINK: req->result = unlink (dirfd, path); break;
		2265	case EIO_RMDIR: req->result = rmdir (dirfd, path); break;
		2266	case EIO_MKDIR: req->result = mkdir (dirfd, path, (mode_t)req->int2); break;
		2267	case EIO_RENAME: req->result = rename (dirfd, path, req->ptr2); break;
		2268	case EIO_LINK: req->result = link (dirfd, path, req->ptr2); break;
		2269	case EIO_SYMLINK: req->result = symlink (dirfd, path, req->ptr2); break;
		2270	case EIO_MKNOD: req->result = mknod (dirfd, path, (mode_t)req->int2, (dev_t)req->offs); break;
		2271	#else
		2272	case EIO_STAT: ALLOC (sizeof (EIO_STRUCT_STAT));
		2273	req->result = stat (path , (EIO_STRUCT_STAT *)req->ptr2); break;
		2274	case EIO_LSTAT: ALLOC (sizeof (EIO_STRUCT_STAT));
		2275	req->result = lstat (path , (EIO_STRUCT_STAT *)req->ptr2); break;
		2276	case EIO_CHOWN: req->result = chown (path , req->int2, req->int3); break;
		2277	case EIO_CHMOD: req->result = chmod (path , (mode_t)req->int2); break;
		2278	case EIO_TRUNCATE: req->result = truncate (path , req->offs); break;
		2279	case EIO_OPEN: req->result = open (path , req->int1, (mode_t)req->int2); break;
		2280
		2281	case EIO_UNLINK: req->result = unlink (path ); break;
		2282	case EIO_RMDIR: req->result = rmdir (path ); break;
		2283	case EIO_MKDIR: req->result = mkdir (path , (mode_t)req->int2); break;
		2284	case EIO_RENAME: req->result = rename (path , req->ptr2); break;
		2285	case EIO_LINK: req->result = link (path , req->ptr2); break;
		2286	case EIO_SYMLINK: req->result = symlink (path , req->ptr2); break;
		2287	case EIO_MKNOD: req->result = mknod (path , (mode_t)req->int2, (dev_t)req->offs); break;
		2288
		2289	case EIO_READLINK: ALLOC (PATH_MAX);
		2290	req->result = readlink (path, req->ptr2, PATH_MAX); break;
		2291	#endif
		2292
		2293	case EIO_REALPATH: if (0 <= (req->result = eio__realpath (&self->tmpbuf, req->wd, req->ptr1)))
		2294	{
		2295	ALLOC (req->result);
		2296	memcpy (req->ptr2, self->tmpbuf.ptr, req->result);
		2297	}
		2298	break;
		2299
		2300	case EIO_STATVFS: ALLOC (sizeof (EIO_STRUCT_STATVFS)); /D/
		2301	req->result = statvfs (path , (EIO_STRUCT_STATVFS *)req->ptr2); break;
		2302
1980	case EIO_FSTAT: ALLOC (sizeof (EIO_STRUCT_STAT));	2303	case EIO_FSTAT: ALLOC (sizeof (EIO_STRUCT_STAT));
1981	req->result = fstat (req->int1, (EIO_STRUCT_STAT *)req->ptr2); break;	2304	req->result = fstat (req->int1, (EIO_STRUCT_STAT *)req->ptr2); break;
1982		2305
1983	case EIO_STATVFS: ALLOC (sizeof (EIO_STRUCT_STATVFS));
1984	req->result = statvfs (req->ptr1, (EIO_STRUCT_STATVFS *)req->ptr2); break;
1985	case EIO_FSTATVFS: ALLOC (sizeof (EIO_STRUCT_STATVFS));	2306	case EIO_FSTATVFS: ALLOC (sizeof (EIO_STRUCT_STATVFS));
1986	req->result = fstatvfs (req->int1, (EIO_STRUCT_STATVFS *)req->ptr2); break;	2307	req->result = fstatvfs (req->int1, (EIO_STRUCT_STATVFS *)req->ptr2); break;
1987		2308
1988	case EIO_CHOWN: req->result = chown (req->ptr1, req->int2, req->int3); break;
1989	case EIO_FCHOWN: req->result = fchown (req->int1, req->int2, req->int3); break;	2309	case EIO_FCHOWN: req->result = fchown (req->int1, req->int2, req->int3); break;
1990	case EIO_CHMOD: req->result = chmod (req->ptr1, (mode_t)req->int2); break;
1991	case EIO_FCHMOD: req->result = fchmod (req->int1, (mode_t)req->int2); break;	2310	case EIO_FCHMOD: req->result = fchmod (req->int1, (mode_t)req->int2); break;
1992	case EIO_TRUNCATE: req->result = truncate (req->ptr1, req->offs); break;
1993	case EIO_FTRUNCATE: req->result = ftruncate (req->int1, req->offs); break;	2311	case EIO_FTRUNCATE: req->result = ftruncate (req->int1, req->offs); break;
1994		2312
1995	case EIO_OPEN: req->result = open (req->ptr1, req->int1, (mode_t)req->int2); break;
1996	case EIO_CLOSE: req->result = close (req->int1); break;	2313	case EIO_CLOSE: req->result = close (req->int1); break;
1997	case EIO_DUP2: req->result = dup2 (req->int1, req->int2); break;	2314	case EIO_DUP2: req->result = dup2 (req->int1, req->int2); break;
1998	case EIO_UNLINK: req->result = unlink (req->ptr1); break;
1999	case EIO_RMDIR: req->result = rmdir (req->ptr1); break;
2000	case EIO_MKDIR: req->result = mkdir (req->ptr1, (mode_t)req->int2); break;
2001	case EIO_RENAME: req->result = rename (req->ptr1, req->ptr2); break;
2002	case EIO_LINK: req->result = link (req->ptr1, req->ptr2); break;
2003	case EIO_SYMLINK: req->result = symlink (req->ptr1, req->ptr2); break;
2004	case EIO_MKNOD: req->result = mknod (req->ptr1, (mode_t)req->int2, (dev_t)req->offs); break;
2005
2006	case EIO_REALPATH: eio__realpath (req, self); break;
2007
2008	case EIO_READLINK: ALLOC (PATH_MAX);
2009	req->result = readlink (req->ptr1, req->ptr2, PATH_MAX); break;
2010
2011	case EIO_SYNC: req->result = 0; sync (); break;	2315	case EIO_SYNC: req->result = 0; sync (); break;
2012	case EIO_FSYNC: req->result = fsync (req->int1); break;	2316	case EIO_FSYNC: req->result = fsync (req->int1); break;
2013	case EIO_FDATASYNC: req->result = fdatasync (req->int1); break;	2317	case EIO_FDATASYNC: req->result = fdatasync (req->int1); break;
		2318	case EIO_SYNCFS: req->result = eio__syncfs (req->int1); break;
		2319	case EIO_SYNC_FILE_RANGE: req->result = eio__sync_file_range (req->int1, req->offs, req->size, req->int2); break;
2014	case EIO_MSYNC: req->result = eio__msync (req->ptr2, req->size, req->int1); break;	2320	case EIO_MSYNC: req->result = eio__msync (req->ptr2, req->size, req->int1); break;
2015	case EIO_MTOUCH: req->result = eio__mtouch (req); break;	2321	case EIO_MTOUCH: req->result = eio__mtouch (req); break;
2016	case EIO_MLOCK: req->result = eio__mlock (req->ptr2, req->size); break;	2322	case EIO_MLOCK: req->result = eio__mlock (req->ptr2, req->size); break;
2017	case EIO_MLOCKALL: req->result = eio__mlockall (req->int1); break;	2323	case EIO_MLOCKALL: req->result = eio__mlockall (req->int1); break;
2018	case EIO_SYNC_FILE_RANGE: req->result = eio__sync_file_range (req->int1, req->offs, req->size, req->int2); break;
2019	case EIO_FALLOCATE: req->result = eio__fallocate (req->int1, req->int2, req->offs, req->size); break;	2324	case EIO_FALLOCATE: req->result = eio__fallocate (req->int1, req->int2, req->offs, req->size); break;
2020		2325
2021	case EIO_READDIR: eio__scandir (req, self); break;	2326	case EIO_READDIR: eio__scandir (req); break;
2022		2327
2023	case EIO_BUSY:	2328	case EIO_BUSY:
2024	#ifdef _WIN32	2329	#ifdef _WIN32
2025	Sleep (req->nv1 * 1e3);	2330	Sleep (req->nv1 * 1e3);
2026	#else	2331	#else
…		…
2104	eio_req eio_msync (void addr, size_t length, int flags, int pri, eio_cb cb, void *data)	2409	eio_req eio_msync (void addr, size_t length, int flags, int pri, eio_cb cb, void *data)
2105	{	2410	{
2106	REQ (EIO_MSYNC); req->ptr2 = addr; req->size = length; req->int1 = flags; SEND;	2411	REQ (EIO_MSYNC); req->ptr2 = addr; req->size = length; req->int1 = flags; SEND;
2107	}	2412	}
2108		2413
		2414	eio_req eio_fdatasync (int fd, int pri, eio_cb cb, void data)
		2415	{
		2416	REQ (EIO_FDATASYNC); req->int1 = fd; SEND;
		2417	}
		2418
		2419	eio_req eio_syncfs (int fd, int pri, eio_cb cb, void data)
		2420	{
		2421	REQ (EIO_SYNCFS); req->int1 = fd; SEND;
		2422	}
		2423
		2424	eio_req eio_sync_file_range (int fd, off_t offset, size_t nbytes, unsigned int flags, int pri, eio_cb cb, void data)
		2425	{
		2426	REQ (EIO_SYNC_FILE_RANGE); req->int1 = fd; req->offs = offset; req->size = nbytes; req->int2 = flags; SEND;
		2427	}
		2428
2109	eio_req eio_mtouch (void addr, size_t length, int flags, int pri, eio_cb cb, void *data)	2429	eio_req eio_mtouch (void addr, size_t length, int flags, int pri, eio_cb cb, void *data)
2110	{	2430	{
2111	REQ (EIO_MTOUCH); req->ptr2 = addr; req->size = length; req->int1 = flags; SEND;	2431	REQ (EIO_MTOUCH); req->ptr2 = addr; req->size = length; req->int1 = flags; SEND;
2112	}	2432	}
2113		2433
…		…
2119	eio_req eio_mlockall (int flags, int pri, eio_cb cb, void data)	2439	eio_req eio_mlockall (int flags, int pri, eio_cb cb, void data)
2120	{	2440	{
2121	REQ (EIO_MLOCKALL); req->int1 = flags; SEND;	2441	REQ (EIO_MLOCKALL); req->int1 = flags; SEND;
2122	}	2442	}
2123		2443
2124	eio_req eio_sync_file_range (int fd, off_t offset, size_t nbytes, unsigned int flags, int pri, eio_cb cb, void data)
2125	{
2126	REQ (EIO_SYNC_FILE_RANGE); req->int1 = fd; req->offs = offset; req->size = nbytes; req->int2 = flags; SEND;
2127	}
2128
2129	eio_req eio_fallocate (int fd, int mode, off_t offset, size_t len, int pri, eio_cb cb, void data)	2444	eio_req eio_fallocate (int fd, int mode, off_t offset, size_t len, int pri, eio_cb cb, void data)
2130	{	2445	{
2131	REQ (EIO_FALLOCATE); req->int1 = fd; req->int2 = mode; req->offs = offset; req->size = len; SEND;	2446	REQ (EIO_FALLOCATE); req->int1 = fd; req->int2 = mode; req->offs = offset; req->size = len; SEND;
2132	}
2133
2134	eio_req eio_fdatasync (int fd, int pri, eio_cb cb, void data)
2135	{
2136	REQ (EIO_FDATASYNC); req->int1 = fd; SEND;
2137	}	2447	}
2138		2448
2139	eio_req eio_close (int fd, int pri, eio_cb cb, void data)	2449	eio_req eio_close (int fd, int pri, eio_cb cb, void data)
2140	{	2450	{
2141	REQ (EIO_CLOSE); req->int1 = fd; SEND;	2451	REQ (EIO_CLOSE); req->int1 = fd; SEND;
…		…
2369	/* misc garbage */	2679	/* misc garbage */
2370		2680
2371	eio_ssize_t	2681	eio_ssize_t
2372	eio_sendfile_sync (int ofd, int ifd, off_t offset, size_t count)	2682	eio_sendfile_sync (int ofd, int ifd, off_t offset, size_t count)
2373	{	2683	{
2374	etp_worker wrk;
2375	eio_ssize_t ret;
2376
2377	wrk.dbuf = 0;
2378
2379	ret = eio__sendfile (ofd, ifd, offset, count, &wrk);	2684	return eio__sendfile (ofd, ifd, offset, count);
2380
2381	if (wrk.dbuf)
2382	free (wrk.dbuf);
2383
2384	return ret;
2385	}	2685	}
2386		2686

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing libeio/eio.c (file contents): Revision 1.89 by root, Thu Jul 14 22:36:17 2011 UTC vs. Revision 1.104 by root, Mon Sep 26 16:54:25 2011 UTC

Diff Legend

Comparing libeio/eio.c (file contents):
Revision 1.89 by root, Thu Jul 14 22:36:17 2011 UTC vs.
Revision 1.104 by root, Mon Sep 26 16:54:25 2011 UTC