ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/libeio/eio.c
(Generate patch)

Comparing libeio/eio.c (file contents):
Revision 1.74 by root, Mon Jun 20 07:28:15 2011 UTC vs.
Revision 1.92 by root, Sun Jul 17 18:27:17 2011 UTC

… …
54#include <stdlib.h> 54#include <stdlib.h>
55#include <string.h> 55#include <string.h>
56#include <errno.h> 56#include <errno.h>
57#include <sys/types.h> 57#include <sys/types.h>
58#include <sys/stat.h> 58#include <sys/stat.h>
59#include <sys/statvfs.h>
60#include <limits.h> 59#include <limits.h>
61#include <fcntl.h> 60#include <fcntl.h>
62#include <assert.h> 61#include <assert.h>
63 62
64/* intptr_t comes from unistd.h, says POSIX/UNIX/tradition */ 63/* intptr_t comes from unistd.h, says POSIX/UNIX/tradition */
65/* intptr_t only comes form stdint.h, says idiot openbsd coder */ 64/* intptr_t only comes from stdint.h, says idiot openbsd coder */
66#if HAVE_STDINT_H 65#if HAVE_STDINT_H
67# include <stdint.h> 66# include <stdint.h>
68#endif 67#endif
69 68
69#ifndef ECANCELED
70# define ECANCELED EDOM
71#endif
72#ifndef ELOOP
73# define ELOOP EDOM
74#endif
75
76static void eio_destroy (eio_req *req);
77
70#ifndef EIO_FINISH 78#ifndef EIO_FINISH
71# define EIO_FINISH(req) ((req)->finish) && !EIO_CANCELLED (req) ? (req)->finish (req) : 0 79# define EIO_FINISH(req) ((req)->finish) && !EIO_CANCELLED (req) ? (req)->finish (req) : 0
72#endif 80#endif
73 81
74#ifndef EIO_DESTROY 82#ifndef EIO_DESTROY
… …
77 85
78#ifndef EIO_FEED 86#ifndef EIO_FEED
79# define EIO_FEED(req) do { if ((req)->feed ) (req)->feed (req); } while (0) 87# define EIO_FEED(req) do { if ((req)->feed ) (req)->feed (req); } while (0)
80#endif 88#endif
81 89
90#ifndef EIO_FD_TO_WIN32_HANDLE
91# define EIO_FD_TO_WIN32_HANDLE(fd) _get_osfhandle (fd)
92#endif
93#ifndef EIO_WIN32_HANDLE_TO_FD
94# define EIO_WIN32_HANDLE_TO_FD(handle) _open_osfhandle (handle, 0)
95#endif
96
97#define EIO_ERRNO(errval,retval) ((errno = errval), retval)
98
99#define EIO_ENOSYS() EIO_ERRNO (ENOSYS, -1)
100
82#ifdef _WIN32 101#ifdef _WIN32
83 102
84 /*doh*/ 103 #undef PAGESIZE
104 #define PAGESIZE 4096 /* GetSystemInfo? */
105
106 #ifdef EIO_STRUCT_STATI64
107 #define stat(path,buf) _stati64 (path,buf)
108 #define fstat(fd,buf) _fstati64 (path,buf)
109 #endif
110 #define lstat(path,buf) stat (path,buf)
111 #define fsync(fd) (FlushFileBuffers ((HANDLE)EIO_FD_TO_WIN32_HANDLE (fd)) ? 0 : EIO_ERRNO (EBADF, -1))
112 #define mkdir(path,mode) _mkdir (path)
113 #define link(old,neu) (CreateHardLink (neu, old, 0) ? 0 : EIO_ERRNO (ENOENT, -1))
114
115 #define chmod(path,mode) _chmod (path, mode)
116 #define dup(fd) _dup (fd)
117 #define dup2(fd1,fd2) _dup2 (fd1, fd2)
118
119 #define fchmod(fd,mode) EIO_ENOSYS ()
120 #define chown(path,uid,gid) EIO_ENOSYS ()
121 #define fchown(fd,uid,gid) EIO_ENOSYS ()
122 #define truncate(path,offs) EIO_ENOSYS () /* far-miss: SetEndOfFile */
123 #define ftruncate(fd,offs) EIO_ENOSYS () /* near-miss: SetEndOfFile */
124 #define mknod(path,mode,dev) EIO_ENOSYS ()
125 #define sync() EIO_ENOSYS ()
126 #define readlink(path,buf,s) EIO_ENOSYS ()
127 #define statvfs(path,buf) EIO_ENOSYS ()
128 #define fstatvfs(fd,buf) EIO_ENOSYS ()
129
130 /* we could even stat and see if it exists */
131 static int
132 symlink (const char *old, const char *neu)
133 {
134 #if WINVER >= 0x0600
135 if (CreateSymbolicLink (neu, old, 1))
136 return 0;
137
138 if (CreateSymbolicLink (neu, old, 0))
139 return 0;
140 #endif
141
142 return EIO_ERRNO (ENOENT, -1);
143 }
144
145 /* POSIX API only */
146 #define CreateHardLink(neu,old,flags) 0
147 #define CreateSymbolicLink(neu,old,flags) 0
148
149 struct statvfs
150 {
151 int dummy;
152 };
153
154 #define DT_DIR EIO_DT_DIR
155 #define DT_REG EIO_DT_REG
156 #define D_NAME(entp) entp.cFileName
157 #define D_TYPE(entp) (entp.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ? DT_DIR : DT_REG)
158
85#else 159#else
86 160
87# include <sys/time.h> 161 #include <sys/time.h>
88# include <sys/select.h> 162 #include <sys/select.h>
163 #include <sys/statvfs.h>
89# include <unistd.h> 164 #include <unistd.h>
90# include <utime.h> 165 #include <utime.h>
91# include <signal.h> 166 #include <signal.h>
92# include <dirent.h> 167 #include <dirent.h>
93 168
94#if _POSIX_MEMLOCK || _POSIX_MEMLOCK_RANGE || _POSIX_MAPPED_FILES 169 #if _POSIX_MEMLOCK || _POSIX_MEMLOCK_RANGE || _POSIX_MAPPED_FILES
95# include <sys/mman.h> 170 #include <sys/mman.h>
96#endif 171 #endif
97 172
173 #define D_NAME(entp) entp->d_name
174
98/* POSIX_SOURCE is useless on bsd's, and XOPEN_SOURCE is unreliable there, too */ 175 /* POSIX_SOURCE is useless on bsd's, and XOPEN_SOURCE is unreliable there, too */
99# if __FreeBSD__ || defined __NetBSD__ || defined __OpenBSD__ 176 #if __FreeBSD__ || defined __NetBSD__ || defined __OpenBSD__
100# define _DIRENT_HAVE_D_TYPE /* sigh */ 177 #define _DIRENT_HAVE_D_TYPE /* sigh */
101# define D_INO(de) (de)->d_fileno 178 #define D_INO(de) (de)->d_fileno
102# define D_NAMLEN(de) (de)->d_namlen 179 #define D_NAMLEN(de) (de)->d_namlen
103# elif __linux || defined d_ino || _XOPEN_SOURCE >= 600 180 #elif __linux || defined d_ino || _XOPEN_SOURCE >= 600
104# define D_INO(de) (de)->d_ino 181 #define D_INO(de) (de)->d_ino
105# endif 182 #endif
106 183
107#ifdef _D_EXACT_NAMLEN 184 #ifdef _D_EXACT_NAMLEN
108# undef D_NAMLEN 185 #undef D_NAMLEN
109# define D_NAMLEN(de) _D_EXACT_NAMLEN (de) 186 #define D_NAMLEN(de) _D_EXACT_NAMLEN (de)
110#endif 187 #endif
111 188
112# ifdef _DIRENT_HAVE_D_TYPE 189 #ifdef _DIRENT_HAVE_D_TYPE
113# define D_TYPE(de) (de)->d_type 190 #define D_TYPE(de) (de)->d_type
114# endif 191 #endif
115 192
116# ifndef EIO_STRUCT_DIRENT 193 #ifndef EIO_STRUCT_DIRENT
117# define EIO_STRUCT_DIRENT struct dirent 194 #define EIO_STRUCT_DIRENT struct dirent
118# endif 195 #endif
119 196
120#endif 197#endif
121 198
122#if HAVE_SENDFILE 199#if HAVE_SENDFILE
123# if __linux 200# if __linux
… …
139#endif 216#endif
140#ifndef D_INO 217#ifndef D_INO
141# define D_INO(de) 0 218# define D_INO(de) 0
142#endif 219#endif
143#ifndef D_NAMLEN 220#ifndef D_NAMLEN
144# define D_NAMLEN(de) strlen ((de)->d_name) 221# define D_NAMLEN(entp) strlen (D_NAME (entp))
145#endif 222#endif
146 223
147/* used for struct dirent, AIX doesn't provide it */ 224/* used for struct dirent, AIX doesn't provide it */
148#ifndef NAME_MAX 225#ifndef NAME_MAX
149# define NAME_MAX 4096 226# define NAME_MAX 4096
… …
183#define ETP_WORKER_CLEAR(req) \ 260#define ETP_WORKER_CLEAR(req) \
184 if (wrk->dbuf) \ 261 if (wrk->dbuf) \
185 { \ 262 { \
186 free (wrk->dbuf); \ 263 free (wrk->dbuf); \
187 wrk->dbuf = 0; \ 264 wrk->dbuf = 0; \
188 } \
189 \
190 if (wrk->dirp) \
191 { \
192 closedir (wrk->dirp); \
193 wrk->dirp = 0; \
194 } 265 }
195 266
196#define ETP_WORKER_COMMON \ 267#define ETP_WORKER_COMMON \
197 void *dbuf; \ 268 void *dbuf;
198 DIR *dirp;
199 269
200/*****************************************************************************/ 270/*****************************************************************************/
201 271
202#define ETP_NUM_PRI (ETP_PRI_MAX - ETP_PRI_MIN + 1) 272#define ETP_NUM_PRI (ETP_PRI_MAX - ETP_PRI_MIN + 1)
203 273
… …
329} etp_reqq; 399} etp_reqq;
330 400
331static etp_reqq req_queue; 401static etp_reqq req_queue;
332static etp_reqq res_queue; 402static etp_reqq res_queue;
333 403
404static void ecb_noinline ecb_cold
405reqq_init (etp_reqq *q)
406{
407 int pri;
408
409 for (pri = 0; pri < ETP_NUM_PRI; ++pri)
410 q->qs[pri] = q->qe[pri] = 0;
411
412 q->size = 0;
413}
414
334static int ecb_noinline 415static int ecb_noinline
335reqq_push (etp_reqq *q, ETP_REQ *req) 416reqq_push (etp_reqq *q, ETP_REQ *req)
336{ 417{
337 int pri = req->pri; 418 int pri = req->pri;
338 req->next = 0; 419 req->next = 0;
… …
375} 456}
376 457
377static void ecb_cold 458static void ecb_cold
378etp_thread_init (void) 459etp_thread_init (void)
379{ 460{
461#if !HAVE_PREADWRITE
462 X_MUTEX_CREATE (preadwritelock);
463#endif
380 X_MUTEX_CREATE (wrklock); 464 X_MUTEX_CREATE (wrklock);
381 X_MUTEX_CREATE (reslock); 465 X_MUTEX_CREATE (reslock);
382 X_MUTEX_CREATE (reqlock); 466 X_MUTEX_CREATE (reqlock);
383 X_COND_CREATE (reqwait); 467 X_COND_CREATE (reqwait);
384} 468}
385 469
386static void ecb_cold 470static void ecb_cold
387etp_atfork_prepare (void)
388{
389 X_LOCK (wrklock);
390 X_LOCK (reqlock);
391 X_LOCK (reslock);
392#if !HAVE_PREADWRITE
393 X_LOCK (preadwritelock);
394#endif
395}
396
397static void ecb_cold
398etp_atfork_parent (void)
399{
400#if !HAVE_PREADWRITE
401 X_UNLOCK (preadwritelock);
402#endif
403 X_UNLOCK (reslock);
404 X_UNLOCK (reqlock);
405 X_UNLOCK (wrklock);
406}
407
408static void ecb_cold
409etp_atfork_child (void) 471etp_atfork_child (void)
410{ 472{
411 ETP_REQ *prv; 473 reqq_init (&req_queue);
474 reqq_init (&res_queue);
412 475
413 while ((prv = reqq_shift (&req_queue))) 476 wrk_first.next =
414 ETP_DESTROY (prv); 477 wrk_first.prev = &wrk_first;
415
416 while ((prv = reqq_shift (&res_queue)))
417 ETP_DESTROY (prv);
418
419 while (wrk_first.next != &wrk_first)
420 {
421 etp_worker *wrk = wrk_first.next;
422
423 if (wrk->req)
424 ETP_DESTROY (wrk->req);
425
426 etp_worker_clear (wrk);
427 etp_worker_free (wrk);
428 }
429 478
430 started = 0; 479 started = 0;
431 idle = 0; 480 idle = 0;
432 nreqs = 0; 481 nreqs = 0;
433 nready = 0; 482 nready = 0;
… …
438 487
439static void ecb_cold 488static void ecb_cold
440etp_once_init (void) 489etp_once_init (void)
441{ 490{
442 etp_thread_init (); 491 etp_thread_init ();
443 X_THREAD_ATFORK (etp_atfork_prepare, etp_atfork_parent, etp_atfork_child); 492 X_THREAD_ATFORK (0, 0, etp_atfork_child);
444} 493}
445 494
446static int ecb_cold 495static int ecb_cold
447etp_init (void (*want_poll)(void), void (*done_poll)(void)) 496etp_init (void (*want_poll)(void), void (*done_poll)(void))
448{ 497{
… …
583} 632}
584 633
585static void 634static void
586etp_cancel (ETP_REQ *req) 635etp_cancel (ETP_REQ *req)
587{ 636{
588 X_LOCK (wrklock); 637 req->cancelled = 1;
589 req->flags |= EIO_FLAG_CANCELLED;
590 X_UNLOCK (wrklock);
591 638
592 eio_grp_cancel (req); 639 eio_grp_cancel (req);
593} 640}
594 641
595static void 642static void
… …
711 return eio_finish (grp); 758 return eio_finish (grp);
712 else 759 else
713 return 0; 760 return 0;
714} 761}
715 762
716void 763static void
717eio_destroy (eio_req *req) 764eio_destroy (eio_req *req)
718{ 765{
719 if ((req)->flags & EIO_FLAG_PTR1_FREE) free (req->ptr1); 766 if ((req)->flags & EIO_FLAG_PTR1_FREE) free (req->ptr1);
720 if ((req)->flags & EIO_FLAG_PTR2_FREE) free (req->ptr2); 767 if ((req)->flags & EIO_FLAG_PTR2_FREE) free (req->ptr2);
721 768
… …
739 if (grp->grp_first == req) 786 if (grp->grp_first == req)
740 grp->grp_first = req->grp_next; 787 grp->grp_first = req->grp_next;
741 788
742 res2 = grp_dec (grp); 789 res2 = grp_dec (grp);
743 790
744 if (!res && res2) 791 if (!res)
745 res = res2; 792 res = res2;
746 } 793 }
747 794
748 eio_destroy (req); 795 eio_destroy (req);
749 796
… …
841# undef pread 888# undef pread
842# undef pwrite 889# undef pwrite
843# define pread eio__pread 890# define pread eio__pread
844# define pwrite eio__pwrite 891# define pwrite eio__pwrite
845 892
846static ssize_t 893static eio_ssize_t
847eio__pread (int fd, void *buf, size_t count, off_t offset) 894eio__pread (int fd, void *buf, size_t count, off_t offset)
848{ 895{
849 ssize_t res; 896 eio_ssize_t res;
850 off_t ooffset; 897 off_t ooffset;
851 898
852 X_LOCK (preadwritelock); 899 X_LOCK (preadwritelock);
853 ooffset = lseek (fd, 0, SEEK_CUR); 900 ooffset = lseek (fd, 0, SEEK_CUR);
854 lseek (fd, offset, SEEK_SET); 901 lseek (fd, offset, SEEK_SET);
… …
857 X_UNLOCK (preadwritelock); 904 X_UNLOCK (preadwritelock);
858 905
859 return res; 906 return res;
860} 907}
861 908
862static ssize_t 909static eio_ssize_t
863eio__pwrite (int fd, void *buf, size_t count, off_t offset) 910eio__pwrite (int fd, void *buf, size_t count, off_t offset)
864{ 911{
865 ssize_t res; 912 eio_ssize_t res;
866 off_t ooffset; 913 off_t ooffset;
867 914
868 X_LOCK (preadwritelock); 915 X_LOCK (preadwritelock);
869 ooffset = lseek (fd, 0, SEEK_CUR); 916 ooffset = lseek (fd, 0, SEEK_CUR);
870 lseek (fd, offset, SEEK_SET); 917 lseek (fd, offset, SEEK_SET);
… …
944 /* even though we could play tricks with the flags, it's better to always 991 /* even though we could play tricks with the flags, it's better to always
945 * call fdatasync, as that matches the expectation of its users best */ 992 * call fdatasync, as that matches the expectation of its users best */
946 return fdatasync (fd); 993 return fdatasync (fd);
947} 994}
948 995
996static int
997eio__fallocate (int fd, int mode, off_t offset, size_t len)
998{
999#if HAVE_FALLOCATE
1000 return fallocate (fd, mode, offset, len);
1001#else
1002 errno = ENOSYS;
1003 return -1;
1004#endif
1005}
1006
949#if !HAVE_READAHEAD 1007#if !HAVE_READAHEAD
950# undef readahead 1008# undef readahead
951# define readahead(fd,offset,count) eio__readahead (fd, offset, count, self) 1009# define readahead(fd,offset,count) eio__readahead (fd, offset, count, self)
952 1010
953static ssize_t 1011static eio_ssize_t
954eio__readahead (int fd, off_t offset, size_t count, etp_worker *self) 1012eio__readahead (int fd, off_t offset, size_t count, etp_worker *self)
955{ 1013{
956 size_t todo = count; 1014 size_t todo = count;
957 dBUF; 1015 dBUF;
958 1016
… …
970} 1028}
971 1029
972#endif 1030#endif
973 1031
974/* sendfile always needs emulation */ 1032/* sendfile always needs emulation */
975static ssize_t 1033static eio_ssize_t
976eio__sendfile (int ofd, int ifd, off_t offset, size_t count, etp_worker *self) 1034eio__sendfile (int ofd, int ifd, off_t offset, size_t count, etp_worker *self)
977{ 1035{
978 ssize_t written = 0; 1036 eio_ssize_t written = 0;
979 ssize_t res; 1037 eio_ssize_t res;
980 1038
981 if (!count) 1039 if (!count)
982 return 0; 1040 return 0;
983 1041
984 for (;;) 1042 for (;;)
985 { 1043 {
1044#ifdef __APPLE__
1045# undef HAVE_SENDFILE /* broken, as everything on os x */
1046#endif
986#if HAVE_SENDFILE 1047#if HAVE_SENDFILE
987# if __linux 1048# if __linux
988 off_t soffset = offset; 1049 off_t soffset = offset;
989 res = sendfile (ofd, ifd, &soffset, count); 1050 res = sendfile (ofd, ifd, &soffset, count);
990 1051
… …
1033 if (res < 0 && sbytes) 1094 if (res < 0 && sbytes)
1034 res = sbytes; 1095 res = sbytes;
1035 1096
1036# endif 1097# endif
1037 1098
1038#elif defined (_WIN32) 1099#elif defined (_WIN32) && 0
1039 /* does not work, just for documentation of what would need to be done */ 1100 /* does not work, just for documentation of what would need to be done */
1040 /* actually, cannot be done like this, as TransmitFile changes the file offset, */ 1101 /* actually, cannot be done like this, as TransmitFile changes the file offset, */
1041 /* libeio guarantees that the file offset does not change, and windows */ 1102 /* libeio guarantees that the file offset does not change, and windows */
1042 /* has no way to get an independent handle to the same file description */ 1103 /* has no way to get an independent handle to the same file description */
1043 HANDLE h = TO_SOCKET (ifd); 1104 HANDLE h = TO_SOCKET (ifd);
… …
1076 && (errno == ENOSYS || errno == EINVAL || errno == ENOTSOCK 1137 && (errno == ENOSYS || errno == EINVAL || errno == ENOTSOCK
1077 /* BSDs */ 1138 /* BSDs */
1078#ifdef ENOTSUP /* sigh, if the steenking pile called openbsd would only try to at least compile posix code... */ 1139#ifdef ENOTSUP /* sigh, if the steenking pile called openbsd would only try to at least compile posix code... */
1079 || errno == ENOTSUP 1140 || errno == ENOTSUP
1080#endif 1141#endif
1142#ifdef EOPNOTSUPP /* windows */
1081 || errno == EOPNOTSUPP /* BSDs */ 1143 || errno == EOPNOTSUPP /* BSDs */
1144#endif
1082#if __solaris 1145#if __solaris
1083 || errno == EAFNOSUPPORT || errno == EPROTOTYPE 1146 || errno == EAFNOSUPPORT || errno == EPROTOTYPE
1084#endif 1147#endif
1085 ) 1148 )
1086 ) 1149 )
… …
1090 1153
1091 res = 0; 1154 res = 0;
1092 1155
1093 while (count) 1156 while (count)
1094 { 1157 {
1095 ssize_t cnt; 1158 eio_ssize_t cnt;
1096 1159
1097 cnt = pread (ifd, eio_buf, count > EIO_BUFSIZE ? EIO_BUFSIZE : count, offset); 1160 cnt = pread (ifd, eio_buf, count > EIO_BUFSIZE ? EIO_BUFSIZE : count, offset);
1098 1161
1099 if (cnt <= 0) 1162 if (cnt <= 0)
1100 { 1163 {
… …
1117 } 1180 }
1118 1181
1119 return res; 1182 return res;
1120} 1183}
1121 1184
1185#ifdef PAGESIZE
1186# define eio_pagesize() PAGESIZE
1187#else
1188static intptr_t
1189eio_pagesize (void)
1190{
1191 static intptr_t page;
1192
1193 if (!page)
1194 page = sysconf (_SC_PAGESIZE);
1195
1196 return page;
1197}
1198#endif
1199
1200static void
1201eio_page_align (void **addr, size_t *length)
1202{
1203 intptr_t mask = eio_pagesize () - 1;
1204
1205 /* round down addr */
1206 intptr_t adj = mask & (intptr_t)*addr;
1207
1208 *addr = (void *)((intptr_t)*addr - adj);
1209 *length += adj;
1210
1211 /* round up length */
1212 *length = (*length + mask) & ~mask;
1213}
1214
1215#if !_POSIX_MEMLOCK
1216# define eio__mlockall(a) EIO_ENOSYS ()
1217#else
1218
1219static int
1220eio__mlockall (int flags)
1221{
1222 #if __GLIBC__ == 2 && __GLIBC_MINOR__ <= 7
1223 extern int mallopt (int, int);
1224 mallopt (-6, 238); /* http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=473812 */
1225 #endif
1226
1227 if (EIO_MCL_CURRENT != MCL_CURRENT
1228 || EIO_MCL_FUTURE != MCL_FUTURE)
1229 {
1230 flags = 0
1231 | (flags & EIO_MCL_CURRENT ? MCL_CURRENT : 0)
1232 | (flags & EIO_MCL_FUTURE ? MCL_FUTURE : 0);
1233 }
1234
1235 return mlockall (flags);
1236}
1237#endif
1238
1239#if !_POSIX_MEMLOCK_RANGE
1240# define eio__mlock(a,b) EIO_ENOSYS ()
1241#else
1242
1243static int
1244eio__mlock (void *addr, size_t length)
1245{
1246 eio_page_align (&addr, &length);
1247
1248 return mlock (addr, length);
1249}
1250
1251#endif
1252
1253#if !(_POSIX_MAPPED_FILES && _POSIX_SYNCHRONIZED_IO)
1254# define eio__msync(a,b,c) EIO_ENOSYS ()
1255#else
1256
1257static int
1258eio__msync (void *mem, size_t len, int flags)
1259{
1260 eio_page_align (&mem, &len);
1261
1262 if (EIO_MS_ASYNC != MS_SYNC
1263 || EIO_MS_INVALIDATE != MS_INVALIDATE
1264 || EIO_MS_SYNC != MS_SYNC)
1265 {
1266 flags = 0
1267 | (flags & EIO_MS_ASYNC ? MS_ASYNC : 0)
1268 | (flags & EIO_MS_INVALIDATE ? MS_INVALIDATE : 0)
1269 | (flags & EIO_MS_SYNC ? MS_SYNC : 0);
1270 }
1271
1272 return msync (mem, len, flags);
1273}
1274
1275#endif
1276
1277static int
1278eio__mtouch (eio_req *req)
1279{
1280 void *mem = req->ptr2;
1281 size_t len = req->size;
1282 int flags = req->int1;
1283
1284 eio_page_align (&mem, &len);
1285
1286 {
1287 intptr_t addr = (intptr_t)mem;
1288 intptr_t end = addr + len;
1289 intptr_t page = eio_pagesize ();
1290
1291 if (addr < end)
1292 if (flags & EIO_MT_MODIFY) /* modify */
1293 do { *((volatile sig_atomic_t *)addr) |= 0; } while ((addr += page) < len && !EIO_CANCELLED (req));
1294 else
1295 do { *((volatile sig_atomic_t *)addr) ; } while ((addr += page) < len && !EIO_CANCELLED (req));
1296 }
1297
1298 return 0;
1299}
1300
1301/*****************************************************************************/
1302/* requests implemented outside eio_execute, because they are so large */
1303
1304static void
1305eio__realpath (eio_req *req, etp_worker *self)
1306{
1307 char *rel = req->ptr1;
1308 char *res;
1309 char *tmp1, *tmp2;
1310#if SYMLOOP_MAX > 32
1311 int symlinks = SYMLOOP_MAX;
1312#else
1313 int symlinks = 32;
1314#endif
1315
1316 req->result = -1;
1317
1318 errno = EINVAL;
1319 if (!rel)
1320 return;
1321
1322 errno = ENOENT;
1323 if (!*rel)
1324 return;
1325
1326 if (!req->ptr2)
1327 {
1328 X_LOCK (wrklock);
1329 req->flags |= EIO_FLAG_PTR2_FREE;
1330 X_UNLOCK (wrklock);
1331 req->ptr2 = malloc (PATH_MAX * 3);
1332
1333 errno = ENOMEM;
1334 if (!req->ptr2)
1335 return;
1336 }
1337
1338 res = req->ptr2;
1339 tmp1 = res + PATH_MAX;
1340 tmp2 = tmp1 + PATH_MAX;
1341
1342#if 0 /* disabled, the musl way to do things is just too racy */
1343#if __linux && defined(O_NONBLOCK) && defined(O_NOATIME)
1344 /* on linux we may be able to ask the kernel */
1345 {
1346 int fd = open (rel, O_RDONLY | O_NONBLOCK | O_NOCTTY | O_NOATIME);
1347
1348 if (fd >= 0)
1349 {
1350 sprintf (tmp1, "/proc/self/fd/%d", fd);
1351 req->result = readlink (tmp1, res, PATH_MAX);
1352 close (fd);
1353
1354 /* here we should probably stat the open file and the disk file, to make sure they still match */
1355
1356 if (req->result > 0)
1357 goto done;
1358 }
1359 else if (errno == ELOOP || errno == ENAMETOOLONG || errno == ENOENT || errno == ENOTDIR || errno == EIO)
1360 return;
1361 }
1362#endif
1363#endif
1364
1365 if (*rel != '/')
1366 {
1367 if (!getcwd (res, PATH_MAX))
1368 return;
1369
1370 if (res [1]) /* only use if not / */
1371 res += strlen (res);
1372 }
1373
1374 while (*rel)
1375 {
1376 eio_ssize_t len, linklen;
1377 char *beg = rel;
1378
1379 while (*rel && *rel != '/')
1380 ++rel;
1381
1382 len = rel - beg;
1383
1384 if (!len) /* skip slashes */
1385 {
1386 ++rel;
1387 continue;
1388 }
1389
1390 if (beg [0] == '.')
1391 {
1392 if (len == 1)
1393 continue; /* . - nop */
1394
1395 if (beg [1] == '.' && len == 2)
1396 {
1397 /* .. - back up one component, if possible */
1398
1399 while (res != req->ptr2)
1400 if (*--res == '/')
1401 break;
1402
1403 continue;
1404 }
1405 }
1406
1407 errno = ENAMETOOLONG;
1408 if (res + 1 + len + 1 >= tmp1)
1409 return;
1410
1411 /* copy one component */
1412 *res = '/';
1413 memcpy (res + 1, beg, len);
1414
1415 /* zero-terminate, for readlink */
1416 res [len + 1] = 0;
1417
1418 /* now check if it's a symlink */
1419 linklen = readlink (req->ptr2, tmp1, PATH_MAX);
1420
1421 if (linklen < 0)
1422 {
1423 if (errno != EINVAL)
1424 return;
1425
1426 /* it's a normal directory. hopefully */
1427 res += len + 1;
1428 }
1429 else
1430 {
1431 /* yay, it was a symlink - build new path in tmp2 */
1432 int rellen = strlen (rel);
1433
1434 errno = ENAMETOOLONG;
1435 if (linklen + 1 + rellen >= PATH_MAX)
1436 return;
1437
1438 errno = ELOOP;
1439 if (!--symlinks)
1440 return;
1441
1442 if (*tmp1 == '/')
1443 res = req->ptr2; /* symlink resolves to an absolute path */
1444
1445 /* we need to be careful, as rel might point into tmp2 already */
1446 memmove (tmp2 + linklen + 1, rel, rellen + 1);
1447 tmp2 [linklen] = '/';
1448 memcpy (tmp2, tmp1, linklen);
1449
1450 rel = tmp2;
1451 }
1452 }
1453
1454 /* special case for the lone root path */
1455 if (res == req->ptr2)
1456 *res++ = '/';
1457
1458 req->result = res - (char *)req->ptr2;
1459
1460done:
1461 req->ptr2 = realloc (req->ptr2, req->result); /* trade time for space savings */
1462}
1463
1122static signed char 1464static signed char
1123eio_dent_cmp (const eio_dirent *a, const eio_dirent *b) 1465eio_dent_cmp (const eio_dirent *a, const eio_dirent *b)
1124{ 1466{
1125 return a->score - b->score ? a->score - b->score /* works because our signed char is always 0..100 */ 1467 return a->score - b->score ? a->score - b->score /* works because our signed char is always 0..100 */
1126 : a->inode < b->inode ? -1 1468 : a->inode < b->inode ? -1
… …
1132 1474
1133#define EIO_SORT_CUTOFF 30 /* quite high, but performs well on many filesystems */ 1475#define EIO_SORT_CUTOFF 30 /* quite high, but performs well on many filesystems */
1134#define EIO_SORT_FAST 60 /* when to only use insertion sort */ 1476#define EIO_SORT_FAST 60 /* when to only use insertion sort */
1135 1477
1136static void 1478static void
1137eio_dent_radix_sort (eio_dirent *dents, int size, signed char score_bits, ino_t inode_bits) 1479eio_dent_radix_sort (eio_dirent *dents, int size, signed char score_bits, eio_ino_t inode_bits)
1138{ 1480{
1139 unsigned char bits [9 + sizeof (ino_t) * 8]; 1481 unsigned char bits [9 + sizeof (eio_ino_t) * 8];
1140 unsigned char *bit = bits; 1482 unsigned char *bit = bits;
1141 1483
1142 assert (CHAR_BIT == 8); 1484 assert (CHAR_BIT == 8);
1143 assert (sizeof (eio_dirent) * 8 < 256); 1485 assert (sizeof (eio_dirent) * 8 < 256);
1144 assert (offsetof (eio_dirent, inode)); /* we use bit #0 as sentinel */ 1486 assert (offsetof (eio_dirent, inode)); /* we use bit #0 as sentinel */
… …
1146 1488
1147 if (size <= EIO_SORT_FAST) 1489 if (size <= EIO_SORT_FAST)
1148 return; 1490 return;
1149 1491
1150 /* first prepare an array of bits to test in our radix sort */ 1492 /* first prepare an array of bits to test in our radix sort */
1151 /* try to take endianness into account, as well as differences in ino_t sizes */ 1493 /* try to take endianness into account, as well as differences in eio_ino_t sizes */
1152 /* inode_bits must contain all inodes ORed together */ 1494 /* inode_bits must contain all inodes ORed together */
1153 /* which is used to skip bits that are 0 everywhere, which is very common */ 1495 /* which is used to skip bits that are 0 everywhere, which is very common */
1154 { 1496 {
1155 ino_t endianness; 1497 eio_ino_t endianness;
1156 int i, j; 1498 int i, j;
1157 1499
1158 /* we store the byte offset of byte n into byte n of "endianness" */ 1500 /* we store the byte offset of byte n into byte n of "endianness" */
1159 for (i = 0; i < sizeof (ino_t); ++i) 1501 for (i = 0; i < sizeof (eio_ino_t); ++i)
1160 ((unsigned char *)&endianness)[i] = i; 1502 ((unsigned char *)&endianness)[i] = i;
1161 1503
1162 *bit++ = 0; 1504 *bit++ = 0;
1163 1505
1164 for (i = 0; i < sizeof (ino_t); ++i) 1506 for (i = 0; i < sizeof (eio_ino_t); ++i)
1165 { 1507 {
1166 /* shifting off the byte offsets out of "endianness" */ 1508 /* shifting off the byte offsets out of "endianness" */
1167 int offs = (offsetof (eio_dirent, inode) + (endianness & 0xff)) * 8; 1509 int offs = (offsetof (eio_dirent, inode) + (endianness & 0xff)) * 8;
1168 endianness >>= 8; 1510 endianness >>= 8;
1169 1511
1170 for (j = 0; j < 8; ++j) 1512 for (j = 0; j < 8; ++j)
1171 if (inode_bits & (((ino_t)1) << (i * 8 + j))) 1513 if (inode_bits & (((eio_ino_t)1) << (i * 8 + j)))
1172 *bit++ = offs + j; 1514 *bit++ = offs + j;
1173 } 1515 }
1174 1516
1175 for (j = 0; j < 8; ++j) 1517 for (j = 0; j < 8; ++j)
1176 if (score_bits & (1 << j)) 1518 if (score_bits & (1 << j))
1177 *bit++ = offsetof (eio_dirent, score) * 8 + j; 1519 *bit++ = offsetof (eio_dirent, score) * 8 + j;
1178 } 1520 }
1179 1521
1180 /* now actually do the sorting (a variant of MSD radix sort) */ 1522 /* now actually do the sorting (a variant of MSD radix sort) */
1181 { 1523 {
1182 eio_dirent *base_stk [9 + sizeof (ino_t) * 8], *base; 1524 eio_dirent *base_stk [9 + sizeof (eio_ino_t) * 8], *base;
1183 eio_dirent *end_stk [9 + sizeof (ino_t) * 8], *end; 1525 eio_dirent *end_stk [9 + sizeof (eio_ino_t) * 8], *end;
1184 unsigned char *bit_stk [9 + sizeof (ino_t) * 8]; 1526 unsigned char *bit_stk [9 + sizeof (eio_ino_t) * 8];
1185 int stk_idx = 0; 1527 int stk_idx = 0;
1186 1528
1187 base_stk [stk_idx] = dents; 1529 base_stk [stk_idx] = dents;
1188 end_stk [stk_idx] = dents + size; 1530 end_stk [stk_idx] = dents + size;
1189 bit_stk [stk_idx] = bit - 1; 1531 bit_stk [stk_idx] = bit - 1;
… …
1268 } 1610 }
1269 } 1611 }
1270} 1612}
1271 1613
1272static void 1614static void
1273eio_dent_sort (eio_dirent *dents, int size, signed char score_bits, ino_t inode_bits) 1615eio_dent_sort (eio_dirent *dents, int size, signed char score_bits, eio_ino_t inode_bits)
1274{ 1616{
1275 if (size <= 1) 1617 if (size <= 1)
1276 return; /* our insertion sort relies on size > 0 */ 1618 return; /* our insertion sort relies on size > 0 */
1277 1619
1278 /* first we use a radix sort, but only for dirs >= EIO_SORT_FAST */ 1620 /* first we use a radix sort, but only for dirs >= EIO_SORT_FAST */
… …
1286 1628
1287/* read a full directory */ 1629/* read a full directory */
1288static void 1630static void
1289eio__scandir (eio_req *req, etp_worker *self) 1631eio__scandir (eio_req *req, etp_worker *self)
1290{ 1632{
1291 DIR *dirp;
1292 EIO_STRUCT_DIRENT *entp;
1293 char *name, *names; 1633 char *name, *names;
1294 int namesalloc = 4096; 1634 int namesalloc = 4096 - sizeof (void *) * 4;
1295 int namesoffs = 0; 1635 int namesoffs = 0;
1296 int flags = req->int1; 1636 int flags = req->int1;
1297 eio_dirent *dents = 0; 1637 eio_dirent *dents = 0;
1298 int dentalloc = 128; 1638 int dentalloc = 128;
1299 int dentoffs = 0; 1639 int dentoffs = 0;
1300 ino_t inode_bits = 0; 1640 eio_ino_t inode_bits = 0;
1641#ifdef _WIN32
1642 HANDLE dirp;
1643 WIN32_FIND_DATA entp;
1644#else
1645 DIR *dirp;
1646 EIO_STRUCT_DIRENT *entp;
1647#endif
1301 1648
1302 req->result = -1; 1649 req->result = -1;
1303 1650
1304 if (!(flags & EIO_READDIR_DENTS)) 1651 if (!(flags & EIO_READDIR_DENTS))
1305 flags &= ~(EIO_READDIR_DIRS_FIRST | EIO_READDIR_STAT_ORDER); 1652 flags &= ~(EIO_READDIR_DIRS_FIRST | EIO_READDIR_STAT_ORDER);
1306 1653
1307 X_LOCK (wrklock); 1654#ifdef _WIN32
1308 /* the corresponding closedir is in ETP_WORKER_CLEAR */ 1655 {
1656 int len = strlen ((const char *)req->ptr1);
1657 char *path = malloc (MAX_PATH);
1658 const char *fmt;
1659
1660 if (!len)
1661 fmt = "./*";
1662 else if (((const char *)req->ptr1)[len - 1] == '/' || ((const char *)req->ptr1)[len - 1] == '\\')
1663 fmt = "%s*";
1664 else
1665 fmt = "%s/*";
1666
1667 _snprintf (path, MAX_PATH, fmt, (const char *)req->ptr1);
1668 dirp = FindFirstFile (path, &entp);
1669 free (path);
1670
1671 if (dirp == INVALID_HANDLE_VALUE)
1672 {
1673 dirp = 0;
1674
1675 switch (GetLastError ())
1676 {
1677 case ERROR_FILE_NOT_FOUND:
1678 req->result = 0;
1679 break;
1680
1681 case ERROR_INVALID_NAME:
1682 case ERROR_PATH_NOT_FOUND:
1683 case ERROR_NO_MORE_FILES:
1684 errno = ENOENT;
1685 break;
1686
1687 case ERROR_NOT_ENOUGH_MEMORY:
1688 errno = ENOMEM;
1689 break;
1690
1691 default:
1692 errno = EINVAL;
1693 break;
1694 }
1695 }
1696 }
1697#else
1309 self->dirp = dirp = opendir (req->ptr1); 1698 dirp = opendir (req->ptr1);
1699#endif
1310 1700
1311 if (req->flags & EIO_FLAG_PTR1_FREE) 1701 if (req->flags & EIO_FLAG_PTR1_FREE)
1312 free (req->ptr1); 1702 free (req->ptr1);
1313 1703
1314 req->flags |= EIO_FLAG_PTR1_FREE | EIO_FLAG_PTR2_FREE; 1704 req->flags |= EIO_FLAG_PTR1_FREE | EIO_FLAG_PTR2_FREE;
1315 req->ptr1 = dents = flags ? malloc (dentalloc * sizeof (eio_dirent)) : 0; 1705 req->ptr1 = dents = flags ? malloc (dentalloc * sizeof (eio_dirent)) : 0;
1316 req->ptr2 = names = malloc (namesalloc); 1706 req->ptr2 = names = malloc (namesalloc);
1317 X_UNLOCK (wrklock);
1318 1707
1319 if (dirp && names && (!flags || dents)) 1708 if (dirp && names && (!flags || dents))
1320 for (;;) 1709 for (;;)
1321 { 1710 {
1711 int done;
1712
1713#ifdef _WIN32
1714 done = !dirp;
1715#else
1322 errno = 0; 1716 errno = 0;
1323 entp = readdir (dirp); 1717 entp = readdir (dirp);
1718 done = !entp;
1719#endif
1324 1720
1325 if (!entp) 1721 if (done)
1326 { 1722 {
1723#ifndef _WIN32
1724 int old_errno = errno;
1725 closedir (dirp);
1726 errno = old_errno;
1727
1327 if (errno) 1728 if (errno)
1328 break; 1729 break;
1730#endif
1329 1731
1330 /* sort etc. */ 1732 /* sort etc. */
1331 req->int1 = flags; 1733 req->int1 = flags;
1332 req->result = dentoffs; 1734 req->result = dentoffs;
1333 1735
… …
1362 1764
1363 break; 1765 break;
1364 } 1766 }
1365 1767
1366 /* now add the entry to our list(s) */ 1768 /* now add the entry to our list(s) */
1367 name = entp->d_name; 1769 name = D_NAME (entp);
1368 1770
1369 /* skip . and .. entries */ 1771 /* skip . and .. entries */
1370 if (name [0] != '.' || (name [1] && (name [1] != '.' || name [2]))) 1772 if (name [0] != '.' || (name [1] && (name [1] != '.' || name [2])))
1371 { 1773 {
1372 int len = D_NAMLEN (entp) + 1; 1774 int len = D_NAMLEN (entp) + 1;
1373 1775
1374 while (ecb_expect_false (namesoffs + len > namesalloc)) 1776 while (ecb_expect_false (namesoffs + len > namesalloc))
1375 { 1777 {
1376 namesalloc *= 2; 1778 namesalloc *= 2;
1377 X_LOCK (wrklock);
1378 req->ptr2 = names = realloc (names, namesalloc); 1779 req->ptr2 = names = realloc (names, namesalloc);
1379 X_UNLOCK (wrklock);
1380 1780
1381 if (!names) 1781 if (!names)
1382 break; 1782 break;
1383 } 1783 }
1384 1784
… …
1389 struct eio_dirent *ent; 1789 struct eio_dirent *ent;
1390 1790
1391 if (ecb_expect_false (dentoffs == dentalloc)) 1791 if (ecb_expect_false (dentoffs == dentalloc))
1392 { 1792 {
1393 dentalloc *= 2; 1793 dentalloc *= 2;
1394 X_LOCK (wrklock);
1395 req->ptr1 = dents = realloc (dents, dentalloc * sizeof (eio_dirent)); 1794 req->ptr1 = dents = realloc (dents, dentalloc * sizeof (eio_dirent));
1396 X_UNLOCK (wrklock);
1397 1795
1398 if (!dents) 1796 if (!dents)
1399 break; 1797 break;
1400 } 1798 }
1401 1799
… …
1481 if (EIO_CANCELLED (req)) 1879 if (EIO_CANCELLED (req))
1482 { 1880 {
1483 errno = ECANCELED; 1881 errno = ECANCELED;
1484 break; 1882 break;
1485 } 1883 }
1884
1885#ifdef _WIN32
1886 if (!FindNextFile (dirp, &entp))
1887 {
1888 FindClose (dirp);
1889 dirp = 0;
1890 }
1891#endif
1486 } 1892 }
1487}
1488
1489#ifdef PAGESIZE
1490# define eio_pagesize() PAGESIZE
1491#else
1492static intptr_t
1493eio_pagesize (void)
1494{
1495 static intptr_t page;
1496
1497 if (!page)
1498 page = sysconf (_SC_PAGESIZE);
1499
1500 return page;
1501}
1502#endif
1503
1504static void
1505eio_page_align (void **addr, size_t *length)
1506{
1507 intptr_t mask = eio_pagesize () - 1;
1508
1509 /* round down addr */
1510 intptr_t adj = mask & (intptr_t)*addr;
1511
1512 *addr = (void *)((intptr_t)*addr - adj);
1513 *length += adj;
1514
1515 /* round up length */
1516 *length = (*length + mask) & ~mask;
1517}
1518
1519#if !_POSIX_MEMLOCK
1520# define eio__mlockall(a) ((errno = ENOSYS), -1)
1521#else
1522
1523static int
1524eio__mlockall (int flags)
1525{
1526 #if __GLIBC__ == 2 && __GLIBC_MINOR__ <= 7
1527 extern int mallopt (int, int);
1528 mallopt (-6, 238); /* http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=473812 */
1529 #endif
1530
1531 if (EIO_MCL_CURRENT != MCL_CURRENT
1532 || EIO_MCL_FUTURE != MCL_FUTURE)
1533 {
1534 flags = 0
1535 | (flags & EIO_MCL_CURRENT ? MCL_CURRENT : 0)
1536 | (flags & EIO_MCL_FUTURE ? MCL_FUTURE : 0);
1537 }
1538
1539 return mlockall (flags);
1540}
1541#endif
1542
1543#if !_POSIX_MEMLOCK_RANGE
1544# define eio__mlock(a,b) ((errno = ENOSYS), -1)
1545#else
1546
1547static int
1548eio__mlock (void *addr, size_t length)
1549{
1550 eio_page_align (&addr, &length);
1551
1552 return mlock (addr, length);
1553}
1554
1555#endif
1556
1557#if !(_POSIX_MAPPED_FILES && _POSIX_SYNCHRONIZED_IO)
1558# define eio__msync(a,b,c) ((errno = ENOSYS), -1)
1559#else
1560
1561static int
1562eio__msync (void *mem, size_t len, int flags)
1563{
1564 eio_page_align (&mem, &len);
1565
1566 if (EIO_MS_ASYNC != MS_SYNC
1567 || EIO_MS_INVALIDATE != MS_INVALIDATE
1568 || EIO_MS_SYNC != MS_SYNC)
1569 {
1570 flags = 0
1571 | (flags & EIO_MS_ASYNC ? MS_ASYNC : 0)
1572 | (flags & EIO_MS_INVALIDATE ? MS_INVALIDATE : 0)
1573 | (flags & EIO_MS_SYNC ? MS_SYNC : 0);
1574 }
1575
1576 return msync (mem, len, flags);
1577}
1578
1579#endif
1580
1581static int
1582eio__mtouch (eio_req *req)
1583{
1584 void *mem = req->ptr2;
1585 size_t len = req->size;
1586 int flags = req->int1;
1587
1588 eio_page_align (&mem, &len);
1589
1590 {
1591 intptr_t addr = (intptr_t)mem;
1592 intptr_t end = addr + len;
1593 intptr_t page = eio_pagesize ();
1594
1595 if (addr < end)
1596 if (flags & EIO_MT_MODIFY) /* modify */
1597 do { *((volatile sig_atomic_t *)addr) |= 0; } while ((addr += page) < len && !EIO_CANCELLED (req));
1598 else
1599 do { *((volatile sig_atomic_t *)addr) ; } while ((addr += page) < len && !EIO_CANCELLED (req));
1600 }
1601
1602 return 0;
1603} 1893}
1604 1894
1605/*****************************************************************************/ 1895/*****************************************************************************/
1606 1896
1607#define ALLOC(len) \ 1897#define ALLOC(len) \
… …
1623{ 1913{
1624 ETP_REQ *req; 1914 ETP_REQ *req;
1625 struct timespec ts; 1915 struct timespec ts;
1626 etp_worker *self = (etp_worker *)thr_arg; 1916 etp_worker *self = (etp_worker *)thr_arg;
1627 1917
1628 /* try to distribute timeouts somewhat randomly */ 1918 /* try to distribute timeouts somewhat evenly */
1629 ts.tv_nsec = ((unsigned long)self & 1023UL) * (1000000000UL / 1024UL); 1919 ts.tv_nsec = ((unsigned long)self & 1023UL) * (1000000000UL / 1024UL);
1630 1920
1631 for (;;) 1921 for (;;)
1632 { 1922 {
1923 ts.tv_sec = 0;
1924
1633 X_LOCK (reqlock); 1925 X_LOCK (reqlock);
1634 1926
1635 for (;;) 1927 for (;;)
1636 { 1928 {
1637 self->req = req = reqq_shift (&req_queue); 1929 self->req = req = reqq_shift (&req_queue);
1638 1930
1639 if (req) 1931 if (req)
1640 break; 1932 break;
1641 1933
1934 if (ts.tv_sec == 1) /* no request, but timeout detected, let's quit */
1935 {
1936 X_UNLOCK (reqlock);
1937 X_LOCK (wrklock);
1938 --started;
1939 X_UNLOCK (wrklock);
1940 goto quit;
1941 }
1942
1642 ++idle; 1943 ++idle;
1643 1944
1644 ts.tv_sec = time (0) + idle_timeout; 1945 if (idle <= max_idle)
1645 if (X_COND_TIMEDWAIT (reqwait, reqlock, ts) == ETIMEDOUT) 1946 /* we are allowed to idle, so do so without any timeout */
1947 X_COND_WAIT (reqwait, reqlock);
1948 else
1646 { 1949 {
1647 if (idle > max_idle) 1950 /* initialise timeout once */
1648 { 1951 if (!ts.tv_sec)
1649 --idle; 1952 ts.tv_sec = time (0) + idle_timeout;
1650 X_UNLOCK (reqlock);
1651 X_LOCK (wrklock);
1652 --started;
1653 X_UNLOCK (wrklock);
1654 goto quit;
1655 }
1656 1953
1657 /* we are allowed to idle, so do so without any timeout */
1658 X_COND_WAIT (reqwait, reqlock); 1954 if (X_COND_TIMEDWAIT (reqwait, reqlock, ts) == ETIMEDOUT)
1955 ts.tv_sec = 1; /* assuming this is not a value computed above.,.. */
1659 } 1956 }
1660 1957
1661 --idle; 1958 --idle;
1662 } 1959 }
1663 1960
… …
1666 X_UNLOCK (reqlock); 1963 X_UNLOCK (reqlock);
1667 1964
1668 if (req->type < 0) 1965 if (req->type < 0)
1669 goto quit; 1966 goto quit;
1670 1967
1671 if (!EIO_CANCELLED (req))
1672 ETP_EXECUTE (self, req); 1968 ETP_EXECUTE (self, req);
1673 1969
1674 X_LOCK (reslock); 1970 X_LOCK (reslock);
1675 1971
1676 ++npending; 1972 ++npending;
1677 1973
… …
1731 } 2027 }
1732 2028
1733static void 2029static void
1734eio_execute (etp_worker *self, eio_req *req) 2030eio_execute (etp_worker *self, eio_req *req)
1735{ 2031{
2032 if (ecb_expect_false (EIO_CANCELLED (req)))
2033 {
2034 req->result = -1;
2035 req->errorno = ECANCELED;
2036 return;
2037 }
2038
1736 switch (req->type) 2039 switch (req->type)
1737 { 2040 {
1738 case EIO_READ: ALLOC (req->size); 2041 case EIO_READ: ALLOC (req->size);
1739 req->result = req->offs >= 0 2042 req->result = req->offs >= 0
1740 ? pread (req->int1, req->ptr2, req->size, req->offs) 2043 ? pread (req->int1, req->ptr2, req->size, req->offs)
… …
1774 case EIO_RENAME: req->result = rename (req->ptr1, req->ptr2); break; 2077 case EIO_RENAME: req->result = rename (req->ptr1, req->ptr2); break;
1775 case EIO_LINK: req->result = link (req->ptr1, req->ptr2); break; 2078 case EIO_LINK: req->result = link (req->ptr1, req->ptr2); break;
1776 case EIO_SYMLINK: req->result = symlink (req->ptr1, req->ptr2); break; 2079 case EIO_SYMLINK: req->result = symlink (req->ptr1, req->ptr2); break;
1777 case EIO_MKNOD: req->result = mknod (req->ptr1, (mode_t)req->int2, (dev_t)req->offs); break; 2080 case EIO_MKNOD: req->result = mknod (req->ptr1, (mode_t)req->int2, (dev_t)req->offs); break;
1778 2081
2082 case EIO_REALPATH: eio__realpath (req, self); break;
2083
1779 case EIO_READLINK: ALLOC (PATH_MAX); 2084 case EIO_READLINK: ALLOC (PATH_MAX);
1780 req->result = readlink (req->ptr1, req->ptr2, PATH_MAX); break; 2085 req->result = readlink (req->ptr1, req->ptr2, PATH_MAX); break;
1781 2086
1782 case EIO_SYNC: req->result = 0; sync (); break; 2087 case EIO_SYNC: req->result = 0; sync (); break;
1783 case EIO_FSYNC: req->result = fsync (req->int1); break; 2088 case EIO_FSYNC: req->result = fsync (req->int1); break;
… …
1785 case EIO_MSYNC: req->result = eio__msync (req->ptr2, req->size, req->int1); break; 2090 case EIO_MSYNC: req->result = eio__msync (req->ptr2, req->size, req->int1); break;
1786 case EIO_MTOUCH: req->result = eio__mtouch (req); break; 2091 case EIO_MTOUCH: req->result = eio__mtouch (req); break;
1787 case EIO_MLOCK: req->result = eio__mlock (req->ptr2, req->size); break; 2092 case EIO_MLOCK: req->result = eio__mlock (req->ptr2, req->size); break;
1788 case EIO_MLOCKALL: req->result = eio__mlockall (req->int1); break; 2093 case EIO_MLOCKALL: req->result = eio__mlockall (req->int1); break;
1789 case EIO_SYNC_FILE_RANGE: req->result = eio__sync_file_range (req->int1, req->offs, req->size, req->int2); break; 2094 case EIO_SYNC_FILE_RANGE: req->result = eio__sync_file_range (req->int1, req->offs, req->size, req->int2); break;
2095 case EIO_FALLOCATE: req->result = eio__fallocate (req->int1, req->int2, req->offs, req->size); break;
1790 2096
1791 case EIO_READDIR: eio__scandir (req, self); break; 2097 case EIO_READDIR: eio__scandir (req, self); break;
1792 2098
1793 case EIO_BUSY: 2099 case EIO_BUSY:
1794#ifdef _WIN32 2100#ifdef _WIN32
… …
1894eio_req *eio_sync_file_range (int fd, off_t offset, size_t nbytes, unsigned int flags, int pri, eio_cb cb, void *data) 2200eio_req *eio_sync_file_range (int fd, off_t offset, size_t nbytes, unsigned int flags, int pri, eio_cb cb, void *data)
1895{ 2201{
1896 REQ (EIO_SYNC_FILE_RANGE); req->int1 = fd; req->offs = offset; req->size = nbytes; req->int2 = flags; SEND; 2202 REQ (EIO_SYNC_FILE_RANGE); req->int1 = fd; req->offs = offset; req->size = nbytes; req->int2 = flags; SEND;
1897} 2203}
1898 2204
2205eio_req *eio_fallocate (int fd, int mode, off_t offset, size_t len, int pri, eio_cb cb, void *data)
2206{
2207 REQ (EIO_FALLOCATE); req->int1 = fd; req->int2 = mode; req->offs = offset; req->size = len; SEND;
2208}
2209
1899eio_req *eio_fdatasync (int fd, int pri, eio_cb cb, void *data) 2210eio_req *eio_fdatasync (int fd, int pri, eio_cb cb, void *data)
1900{ 2211{
1901 REQ (EIO_FDATASYNC); req->int1 = fd; SEND; 2212 REQ (EIO_FDATASYNC); req->int1 = fd; SEND;
1902} 2213}
1903 2214
… …
1944eio_req *eio_fchmod (int fd, mode_t mode, int pri, eio_cb cb, void *data) 2255eio_req *eio_fchmod (int fd, mode_t mode, int pri, eio_cb cb, void *data)
1945{ 2256{
1946 REQ (EIO_FCHMOD); req->int1 = fd; req->int2 = (long)mode; SEND; 2257 REQ (EIO_FCHMOD); req->int1 = fd; req->int2 = (long)mode; SEND;
1947} 2258}
1948 2259
1949eio_req *eio_fchown (int fd, uid_t uid, gid_t gid, int pri, eio_cb cb, void *data) 2260eio_req *eio_fchown (int fd, eio_uid_t uid, eio_gid_t gid, int pri, eio_cb cb, void *data)
1950{ 2261{
1951 REQ (EIO_FCHOWN); req->int1 = fd; req->int2 = (long)uid; req->int3 = (long)gid; SEND; 2262 REQ (EIO_FCHOWN); req->int1 = fd; req->int2 = (long)uid; req->int3 = (long)gid; SEND;
1952} 2263}
1953 2264
1954eio_req *eio_dup2 (int fd, int fd2, int pri, eio_cb cb, void *data) 2265eio_req *eio_dup2 (int fd, int fd2, int pri, eio_cb cb, void *data)
… …
1974eio_req *eio_truncate (const char *path, off_t offset, int pri, eio_cb cb, void *data) 2285eio_req *eio_truncate (const char *path, off_t offset, int pri, eio_cb cb, void *data)
1975{ 2286{
1976 REQ (EIO_TRUNCATE); PATH; req->offs = offset; SEND; 2287 REQ (EIO_TRUNCATE); PATH; req->offs = offset; SEND;
1977} 2288}
1978 2289
1979eio_req *eio_chown (const char *path, uid_t uid, gid_t gid, int pri, eio_cb cb, void *data) 2290eio_req *eio_chown (const char *path, eio_uid_t uid, eio_gid_t gid, int pri, eio_cb cb, void *data)
1980{ 2291{
1981 REQ (EIO_CHOWN); PATH; req->int2 = (long)uid; req->int3 = (long)gid; SEND; 2292 REQ (EIO_CHOWN); PATH; req->int2 = (long)uid; req->int3 = (long)gid; SEND;
1982} 2293}
1983 2294
1984eio_req *eio_chmod (const char *path, mode_t mode, int pri, eio_cb cb, void *data) 2295eio_req *eio_chmod (const char *path, mode_t mode, int pri, eio_cb cb, void *data)
… …
1998} 2309}
1999 2310
2000eio_req *eio_readlink (const char *path, int pri, eio_cb cb, void *data) 2311eio_req *eio_readlink (const char *path, int pri, eio_cb cb, void *data)
2001{ 2312{
2002 return eio__1path (EIO_READLINK, path, pri, cb, data); 2313 return eio__1path (EIO_READLINK, path, pri, cb, data);
2314}
2315
2316eio_req *eio_realpath (const char *path, int pri, eio_cb cb, void *data)
2317{
2318 return eio__1path (EIO_REALPATH, path, pri, cb, data);
2003} 2319}
2004 2320
2005eio_req *eio_stat (const char *path, int pri, eio_cb cb, void *data) 2321eio_req *eio_stat (const char *path, int pri, eio_cb cb, void *data)
2006{ 2322{
2007 return eio__1path (EIO_STAT, path, pri, cb, data); 2323 return eio__1path (EIO_STAT, path, pri, cb, data);
… …
2126} 2442}
2127 2443
2128/*****************************************************************************/ 2444/*****************************************************************************/
2129/* misc garbage */ 2445/* misc garbage */
2130 2446
2131ssize_t 2447eio_ssize_t
2132eio_sendfile_sync (int ofd, int ifd, off_t offset, size_t count) 2448eio_sendfile_sync (int ofd, int ifd, off_t offset, size_t count)
2133{ 2449{
2134 etp_worker wrk; 2450 etp_worker wrk;
2135 ssize_t ret; 2451 eio_ssize_t ret;
2136 2452
2137 wrk.dbuf = 0; 2453 wrk.dbuf = 0;
2138 2454
2139 ret = eio__sendfile (ofd, ifd, offset, count, &wrk); 2455 ret = eio__sendfile (ofd, ifd, offset, count, &wrk);
2140 2456

Diff Legend

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