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

Comparing libeio/eio.c (file contents):
Revision 1.77 by root, Tue Jul 5 14:02:15 2011 UTC vs.
Revision 1.89 by root, Thu Jul 14 22:36: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
73static void eio_destroy (eio_req *req);
74
70#ifndef EIO_FINISH 75#ifndef EIO_FINISH
71# define EIO_FINISH(req) ((req)->finish) && !EIO_CANCELLED (req) ? (req)->finish (req) : 0 76# define EIO_FINISH(req) ((req)->finish) && !EIO_CANCELLED (req) ? (req)->finish (req) : 0
72#endif 77#endif
73 78
74#ifndef EIO_DESTROY 79#ifndef EIO_DESTROY
… …
77 82
78#ifndef EIO_FEED 83#ifndef EIO_FEED
79# define EIO_FEED(req) do { if ((req)->feed ) (req)->feed (req); } while (0) 84# define EIO_FEED(req) do { if ((req)->feed ) (req)->feed (req); } while (0)
80#endif 85#endif
81 86
87#ifndef EIO_FD_TO_WIN32_HANDLE
88# define EIO_FD_TO_WIN32_HANDLE(fd) _get_osfhandle (fd)
89#endif
90#ifndef EIO_WIN32_HANDLE_TO_FD
91# define EIO_WIN32_HANDLE_TO_FD(handle) _open_osfhandle (handle, 0)
92#endif
93
94#define EIO_ERRNO(errval,retval) ((errno = errval), retval)
95
96#define EIO_ENOSYS() EIO_ERRNO (ENOSYS, -1)
97
82#ifdef _WIN32 98#ifdef _WIN32
83 99
84 /*doh*/ 100 #define PAGESIZE 4096 /* GetSystemInfo? */
101
102 #ifdef EIO_STRUCT_STATI64
103 #define stat(path,buf) _stati64 (path,buf)
104 #define fstat(fd,buf) _fstati64 (path,buf)
105 #endif
106 #define lstat(path,buf) stat (path,buf)
107 #define fsync(fd) (FlushFileBuffers (EIO_FD_TO_WIN32_HANDLE (fd)) ? 0 : EIO_ERRNO (EBADF, -1))
108 #define mkdir(path,mode) _mkdir (path)
109 #define link(old,neu) (CreateHardLink (neu, old, 0) ? 0 : EIO_ERRNO (ENOENT, -1))
110
111 #define chown(path,uid,gid) EIO_ENOSYS ()
112 #define fchown(fd,uid,gid) EIO_ENOSYS ()
113 #define truncate(path,offs) EIO_ENOSYS () /* far-miss: SetEndOfFile */
114 #define ftruncate(fd,offs) EIO_ENOSYS () /* near-miss: SetEndOfFile */
115 #define mknod(path,mode,dev) EIO_ENOSYS ()
116 #define sync() EIO_ENOSYS ()
117
118 /* we could even stat and see if it exists */
119 static int
120 symlink (const char *old, const char *neu)
121 {
122 if (CreateSymbolicLink (neu, old, 1))
123 return 0;
124
125 if (CreateSymbolicLink (neu, old, 0))
126 return 0;
127
128 return EIO_ERRNO (ENOENT, -1);
129 }
130
85#else 131#else
86 132
87# include <sys/time.h> 133 #include <sys/time.h>
88# include <sys/select.h> 134 #include <sys/select.h>
135 #include <sys/statvfs.h>
89# include <unistd.h> 136 #include <unistd.h>
90# include <utime.h> 137 #include <utime.h>
91# include <signal.h> 138 #include <signal.h>
92# include <dirent.h> 139 #include <dirent.h>
93 140
94#if _POSIX_MEMLOCK || _POSIX_MEMLOCK_RANGE || _POSIX_MAPPED_FILES 141 #if _POSIX_MEMLOCK || _POSIX_MEMLOCK_RANGE || _POSIX_MAPPED_FILES
95# include <sys/mman.h> 142 #include <sys/mman.h>
96#endif 143 #endif
97 144
98/* POSIX_SOURCE is useless on bsd's, and XOPEN_SOURCE is unreliable there, too */ 145 /* POSIX_SOURCE is useless on bsd's, and XOPEN_SOURCE is unreliable there, too */
99# if __FreeBSD__ || defined __NetBSD__ || defined __OpenBSD__ 146 #if __FreeBSD__ || defined __NetBSD__ || defined __OpenBSD__
100# define _DIRENT_HAVE_D_TYPE /* sigh */ 147 #define _DIRENT_HAVE_D_TYPE /* sigh */
101# define D_INO(de) (de)->d_fileno 148 #define D_INO(de) (de)->d_fileno
102# define D_NAMLEN(de) (de)->d_namlen 149 #define D_NAMLEN(de) (de)->d_namlen
103# elif __linux || defined d_ino || _XOPEN_SOURCE >= 600 150 #elif __linux || defined d_ino || _XOPEN_SOURCE >= 600
104# define D_INO(de) (de)->d_ino 151 #define D_INO(de) (de)->d_ino
105# endif 152 #endif
106 153
107#ifdef _D_EXACT_NAMLEN 154 #ifdef _D_EXACT_NAMLEN
108# undef D_NAMLEN 155 #undef D_NAMLEN
109# define D_NAMLEN(de) _D_EXACT_NAMLEN (de) 156 #define D_NAMLEN(de) _D_EXACT_NAMLEN (de)
110#endif 157 #endif
111 158
112# ifdef _DIRENT_HAVE_D_TYPE 159 #ifdef _DIRENT_HAVE_D_TYPE
113# define D_TYPE(de) (de)->d_type 160 #define D_TYPE(de) (de)->d_type
114# endif 161 #endif
115 162
116# ifndef EIO_STRUCT_DIRENT 163 #ifndef EIO_STRUCT_DIRENT
117# define EIO_STRUCT_DIRENT struct dirent 164 #define EIO_STRUCT_DIRENT struct dirent
118# endif 165 #endif
119 166
120#endif 167#endif
121 168
122#if HAVE_SENDFILE 169#if HAVE_SENDFILE
123# if __linux 170# if __linux
… …
375} 422}
376 423
377static void ecb_cold 424static void ecb_cold
378etp_thread_init (void) 425etp_thread_init (void)
379{ 426{
427#if !HAVE_PREADWRITE
428 X_MUTEX_CREATE (preadwritelock);
429#endif
380 X_MUTEX_CREATE (wrklock); 430 X_MUTEX_CREATE (wrklock);
381 X_MUTEX_CREATE (reslock); 431 X_MUTEX_CREATE (reslock);
382 X_MUTEX_CREATE (reqlock); 432 X_MUTEX_CREATE (reqlock);
383 X_COND_CREATE (reqwait); 433 X_COND_CREATE (reqwait);
384} 434}
385 435
386static void ecb_cold 436static void ecb_cold
387etp_atfork_prepare (void) 437etp_atfork_prepare (void)
388{ 438{
389 X_LOCK (wrklock);
390 X_LOCK (reqlock);
391 X_LOCK (reslock);
392#if !HAVE_PREADWRITE
393 X_LOCK (preadwritelock);
394#endif
395} 439}
396 440
397static void ecb_cold 441static void ecb_cold
398etp_atfork_parent (void) 442etp_atfork_parent (void)
399{ 443{
400#if !HAVE_PREADWRITE
401 X_UNLOCK (preadwritelock);
402#endif
403 X_UNLOCK (reslock);
404 X_UNLOCK (reqlock);
405 X_UNLOCK (wrklock);
406} 444}
407 445
408static void ecb_cold 446static void ecb_cold
409etp_atfork_child (void) 447etp_atfork_child (void)
410{ 448{
… …
583} 621}
584 622
585static void 623static void
586etp_cancel (ETP_REQ *req) 624etp_cancel (ETP_REQ *req)
587{ 625{
588 X_LOCK (wrklock); 626 req->cancelled = 1;
589 req->flags |= EIO_FLAG_CANCELLED;
590 X_UNLOCK (wrklock);
591 627
592 eio_grp_cancel (req); 628 eio_grp_cancel (req);
593} 629}
594 630
595static void 631static void
… …
711 return eio_finish (grp); 747 return eio_finish (grp);
712 else 748 else
713 return 0; 749 return 0;
714} 750}
715 751
716void 752static void
717eio_destroy (eio_req *req) 753eio_destroy (eio_req *req)
718{ 754{
719 if ((req)->flags & EIO_FLAG_PTR1_FREE) free (req->ptr1); 755 if ((req)->flags & EIO_FLAG_PTR1_FREE) free (req->ptr1);
720 if ((req)->flags & EIO_FLAG_PTR2_FREE) free (req->ptr2); 756 if ((req)->flags & EIO_FLAG_PTR2_FREE) free (req->ptr2);
721 757
… …
739 if (grp->grp_first == req) 775 if (grp->grp_first == req)
740 grp->grp_first = req->grp_next; 776 grp->grp_first = req->grp_next;
741 777
742 res2 = grp_dec (grp); 778 res2 = grp_dec (grp);
743 779
744 if (!res && res2) 780 if (!res)
745 res = res2; 781 res = res2;
746 } 782 }
747 783
748 eio_destroy (req); 784 eio_destroy (req);
749 785
… …
841# undef pread 877# undef pread
842# undef pwrite 878# undef pwrite
843# define pread eio__pread 879# define pread eio__pread
844# define pwrite eio__pwrite 880# define pwrite eio__pwrite
845 881
846static ssize_t 882static eio_ssize_t
847eio__pread (int fd, void *buf, size_t count, off_t offset) 883eio__pread (int fd, void *buf, size_t count, off_t offset)
848{ 884{
849 ssize_t res; 885 eio_ssize_t res;
850 off_t ooffset; 886 off_t ooffset;
851 887
852 X_LOCK (preadwritelock); 888 X_LOCK (preadwritelock);
853 ooffset = lseek (fd, 0, SEEK_CUR); 889 ooffset = lseek (fd, 0, SEEK_CUR);
854 lseek (fd, offset, SEEK_SET); 890 lseek (fd, offset, SEEK_SET);
… …
857 X_UNLOCK (preadwritelock); 893 X_UNLOCK (preadwritelock);
858 894
859 return res; 895 return res;
860} 896}
861 897
862static ssize_t 898static eio_ssize_t
863eio__pwrite (int fd, void *buf, size_t count, off_t offset) 899eio__pwrite (int fd, void *buf, size_t count, off_t offset)
864{ 900{
865 ssize_t res; 901 eio_ssize_t res;
866 off_t ooffset; 902 off_t ooffset;
867 903
868 X_LOCK (preadwritelock); 904 X_LOCK (preadwritelock);
869 ooffset = lseek (fd, 0, SEEK_CUR); 905 ooffset = lseek (fd, 0, SEEK_CUR);
870 lseek (fd, offset, SEEK_SET); 906 lseek (fd, offset, SEEK_SET);
… …
944 /* even though we could play tricks with the flags, it's better to always 980 /* 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 */ 981 * call fdatasync, as that matches the expectation of its users best */
946 return fdatasync (fd); 982 return fdatasync (fd);
947} 983}
948 984
985static int
986eio__fallocate (int fd, int mode, off_t offset, size_t len)
987{
988#if HAVE_FALLOCATE
989 return fallocate (fd, mode, offset, len);
990#else
991 errno = ENOSYS;
992 return -1;
993#endif
994}
995
949#if !HAVE_READAHEAD 996#if !HAVE_READAHEAD
950# undef readahead 997# undef readahead
951# define readahead(fd,offset,count) eio__readahead (fd, offset, count, self) 998# define readahead(fd,offset,count) eio__readahead (fd, offset, count, self)
952 999
953static ssize_t 1000static eio_ssize_t
954eio__readahead (int fd, off_t offset, size_t count, etp_worker *self) 1001eio__readahead (int fd, off_t offset, size_t count, etp_worker *self)
955{ 1002{
956 size_t todo = count; 1003 size_t todo = count;
957 dBUF; 1004 dBUF;
958 1005
… …
970} 1017}
971 1018
972#endif 1019#endif
973 1020
974/* sendfile always needs emulation */ 1021/* sendfile always needs emulation */
975static ssize_t 1022static eio_ssize_t
976eio__sendfile (int ofd, int ifd, off_t offset, size_t count, etp_worker *self) 1023eio__sendfile (int ofd, int ifd, off_t offset, size_t count, etp_worker *self)
977{ 1024{
978 ssize_t written = 0; 1025 eio_ssize_t written = 0;
979 ssize_t res; 1026 eio_ssize_t res;
980 1027
981 if (!count) 1028 if (!count)
982 return 0; 1029 return 0;
983 1030
984 for (;;) 1031 for (;;)
985 { 1032 {
1033#ifdef __APPLE__
1034# undef HAVE_SENDFILE /* broken, as everything on os x */
1035#endif
986#if HAVE_SENDFILE 1036#if HAVE_SENDFILE
987# if __linux 1037# if __linux
988 off_t soffset = offset; 1038 off_t soffset = offset;
989 res = sendfile (ofd, ifd, &soffset, count); 1039 res = sendfile (ofd, ifd, &soffset, count);
990 1040
… …
1006 1056
1007 /* according to source inspection, this is correct, and useful behaviour */ 1057 /* according to source inspection, this is correct, and useful behaviour */
1008 if (sbytes) 1058 if (sbytes)
1009 res = sbytes; 1059 res = sbytes;
1010 1060
1011# elif defined (__APPLE__) && 0 /* broken, as everything on os x */ 1061# elif defined (__APPLE__)
1012 off_t sbytes = count; 1062 off_t sbytes = count;
1013 res = sendfile (ifd, ofd, offset, &sbytes, 0, 0); 1063 res = sendfile (ifd, ofd, offset, &sbytes, 0, 0);
1014 1064
1015 /* according to the manpage, sbytes is always valid */ 1065 /* according to the manpage, sbytes is always valid */
1016 if (sbytes) 1066 if (sbytes)
… …
1033 if (res < 0 && sbytes) 1083 if (res < 0 && sbytes)
1034 res = sbytes; 1084 res = sbytes;
1035 1085
1036# endif 1086# endif
1037 1087
1038#elif defined (_WIN32) 1088#elif defined (_WIN32) && 0
1039 /* does not work, just for documentation of what would need to be done */ 1089 /* 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, */ 1090 /* actually, cannot be done like this, as TransmitFile changes the file offset, */
1041 /* libeio guarantees that the file offset does not change, and windows */ 1091 /* 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 */ 1092 /* has no way to get an independent handle to the same file description */
1043 HANDLE h = TO_SOCKET (ifd); 1093 HANDLE h = TO_SOCKET (ifd);
… …
1090 1140
1091 res = 0; 1141 res = 0;
1092 1142
1093 while (count) 1143 while (count)
1094 { 1144 {
1095 ssize_t cnt; 1145 eio_ssize_t cnt;
1096 1146
1097 cnt = pread (ifd, eio_buf, count > EIO_BUFSIZE ? EIO_BUFSIZE : count, offset); 1147 cnt = pread (ifd, eio_buf, count > EIO_BUFSIZE ? EIO_BUFSIZE : count, offset);
1098 1148
1099 if (cnt <= 0) 1149 if (cnt <= 0)
1100 { 1150 {
… …
1148 /* round up length */ 1198 /* round up length */
1149 *length = (*length + mask) & ~mask; 1199 *length = (*length + mask) & ~mask;
1150} 1200}
1151 1201
1152#if !_POSIX_MEMLOCK 1202#if !_POSIX_MEMLOCK
1153# define eio__mlockall(a) ((errno = ENOSYS), -1) 1203# define eio__mlockall(a) EIO_ENOSYS ()
1154#else 1204#else
1155 1205
1156static int 1206static int
1157eio__mlockall (int flags) 1207eio__mlockall (int flags)
1158{ 1208{
… …
1172 return mlockall (flags); 1222 return mlockall (flags);
1173} 1223}
1174#endif 1224#endif
1175 1225
1176#if !_POSIX_MEMLOCK_RANGE 1226#if !_POSIX_MEMLOCK_RANGE
1177# define eio__mlock(a,b) ((errno = ENOSYS), -1) 1227# define eio__mlock(a,b) EIO_ENOSYS ()
1178#else 1228#else
1179 1229
1180static int 1230static int
1181eio__mlock (void *addr, size_t length) 1231eio__mlock (void *addr, size_t length)
1182{ 1232{
… …
1186} 1236}
1187 1237
1188#endif 1238#endif
1189 1239
1190#if !(_POSIX_MAPPED_FILES && _POSIX_SYNCHRONIZED_IO) 1240#if !(_POSIX_MAPPED_FILES && _POSIX_SYNCHRONIZED_IO)
1191# define eio__msync(a,b,c) ((errno = ENOSYS), -1) 1241# define eio__msync(a,b,c) EIO_ENOSYS ()
1192#else 1242#else
1193 1243
1194static int 1244static int
1195eio__msync (void *mem, size_t len, int flags) 1245eio__msync (void *mem, size_t len, int flags)
1196{ 1246{
… …
1243{ 1293{
1244 char *rel = req->ptr1; 1294 char *rel = req->ptr1;
1245 char *res; 1295 char *res;
1246 char *tmp1, *tmp2; 1296 char *tmp1, *tmp2;
1247#if SYMLOOP_MAX > 32 1297#if SYMLOOP_MAX > 32
1248 int links = SYMLOOP_MAX; 1298 int symlinks = SYMLOOP_MAX;
1249#else 1299#else
1250 int links = 32; 1300 int symlinks = 32;
1251#endif 1301#endif
1252 1302
1253 req->result = -1; 1303 req->result = -1;
1254 1304
1255 errno = EINVAL; 1305 errno = EINVAL;
… …
1274 1324
1275 res = req->ptr2; 1325 res = req->ptr2;
1276 tmp1 = res + PATH_MAX; 1326 tmp1 = res + PATH_MAX;
1277 tmp2 = tmp1 + PATH_MAX; 1327 tmp2 = tmp1 + PATH_MAX;
1278 1328
1329#if 0 /* disabled, the musl way to do things is just too racy */
1330#if __linux && defined(O_NONBLOCK) && defined(O_NOATIME)
1331 /* on linux we may be able to ask the kernel */
1332 {
1333 int fd = open (rel, O_RDONLY | O_NONBLOCK | O_NOCTTY | O_NOATIME);
1334
1335 if (fd >= 0)
1336 {
1337 sprintf (tmp1, "/proc/self/fd/%d", fd);
1338 req->result = readlink (tmp1, res, PATH_MAX);
1339 close (fd);
1340
1341 /* here we should probably stat the open file and the disk file, to make sure they still match */
1342
1343 if (req->result > 0)
1344 goto done;
1345 }
1346 else if (errno == ELOOP || errno == ENAMETOOLONG || errno == ENOENT || errno == ENOTDIR || errno == EIO)
1347 return;
1348 }
1349#endif
1350#endif
1351
1279 if (*rel != '/') 1352 if (*rel != '/')
1280 { 1353 {
1281 if (!getcwd (res, PATH_MAX)) 1354 if (!getcwd (res, PATH_MAX))
1282 return; 1355 return;
1283 1356
… …
1285 res += strlen (res); 1358 res += strlen (res);
1286 } 1359 }
1287 1360
1288 while (*rel) 1361 while (*rel)
1289 { 1362 {
1290 ssize_t len, linklen; 1363 eio_ssize_t len, linklen;
1291 char *beg = rel; 1364 char *beg = rel;
1292 1365
1293 while (*rel && *rel != '/') 1366 while (*rel && *rel != '/')
1294 ++rel; 1367 ++rel;
1295 1368
… …
1347 1420
1348 errno = ENAMETOOLONG; 1421 errno = ENAMETOOLONG;
1349 if (linklen + 1 + rellen >= PATH_MAX) 1422 if (linklen + 1 + rellen >= PATH_MAX)
1350 return; 1423 return;
1351 1424
1425 errno = ELOOP;
1426 if (!--symlinks)
1427 return;
1428
1352 if (*tmp1 == '/') 1429 if (*tmp1 == '/')
1353 res = req->ptr2; /* symlink resolves to an absolute path */ 1430 res = req->ptr2; /* symlink resolves to an absolute path */
1354 1431
1355 /* we need to be careful, as rel might point into tmp2 already */ 1432 /* we need to be careful, as rel might point into tmp2 already */
1356 memmove (tmp2 + linklen + 1, rel, rellen + 1); 1433 memmove (tmp2 + linklen + 1, rel, rellen + 1);
… …
1364 /* special case for the lone root path */ 1441 /* special case for the lone root path */
1365 if (res == req->ptr2) 1442 if (res == req->ptr2)
1366 *res++ = '/'; 1443 *res++ = '/';
1367 1444
1368 req->result = res - (char *)req->ptr2; 1445 req->result = res - (char *)req->ptr2;
1446
1447done:
1369 req->ptr2 = realloc (req->ptr2, req->result); /* trade time for space savings */ 1448 req->ptr2 = realloc (req->ptr2, req->result); /* trade time for space savings */
1370} 1449}
1371 1450
1372static signed char 1451static signed char
1373eio_dent_cmp (const eio_dirent *a, const eio_dirent *b) 1452eio_dent_cmp (const eio_dirent *a, const eio_dirent *b)
… …
1756X_THREAD_PROC (etp_proc) 1835X_THREAD_PROC (etp_proc)
1757{ 1836{
1758 ETP_REQ *req; 1837 ETP_REQ *req;
1759 struct timespec ts; 1838 struct timespec ts;
1760 etp_worker *self = (etp_worker *)thr_arg; 1839 etp_worker *self = (etp_worker *)thr_arg;
1840 int timeout;
1761 1841
1762 /* try to distribute timeouts somewhat randomly */ 1842 /* try to distribute timeouts somewhat evenly */
1763 ts.tv_nsec = ((unsigned long)self & 1023UL) * (1000000000UL / 1024UL); 1843 ts.tv_nsec = ((unsigned long)self & 1023UL) * (1000000000UL / 1024UL);
1764 1844
1765 for (;;) 1845 for (;;)
1766 { 1846 {
1847 ts.tv_sec = 0;
1848
1767 X_LOCK (reqlock); 1849 X_LOCK (reqlock);
1768 1850
1769 for (;;) 1851 for (;;)
1770 { 1852 {
1771 self->req = req = reqq_shift (&req_queue); 1853 self->req = req = reqq_shift (&req_queue);
1772 1854
1773 if (req) 1855 if (req)
1774 break; 1856 break;
1775 1857
1858 if (ts.tv_sec == 1) /* no request, but timeout detected, let's quit */
1859 {
1860 X_UNLOCK (reqlock);
1861 X_LOCK (wrklock);
1862 --started;
1863 X_UNLOCK (wrklock);
1864 goto quit;
1865 }
1866
1776 ++idle; 1867 ++idle;
1777 1868
1778 ts.tv_sec = time (0) + idle_timeout; 1869 if (idle <= max_idle)
1779 if (X_COND_TIMEDWAIT (reqwait, reqlock, ts) == ETIMEDOUT) 1870 /* we are allowed to idle, so do so without any timeout */
1871 X_COND_WAIT (reqwait, reqlock);
1872 else
1780 { 1873 {
1781 if (idle > max_idle) 1874 /* initialise timeout once */
1782 { 1875 if (!ts.tv_sec)
1783 --idle; 1876 ts.tv_sec = time (0) + idle_timeout;
1784 X_UNLOCK (reqlock);
1785 X_LOCK (wrklock);
1786 --started;
1787 X_UNLOCK (wrklock);
1788 goto quit;
1789 }
1790 1877
1791 /* we are allowed to idle, so do so without any timeout */
1792 X_COND_WAIT (reqwait, reqlock); 1878 if (X_COND_TIMEDWAIT (reqwait, reqlock, ts) == ETIMEDOUT)
1879 ts.tv_sec = 1; /* assuming this is not a value computed above.,.. */
1793 } 1880 }
1794 1881
1795 --idle; 1882 --idle;
1796 } 1883 }
1797 1884
… …
1800 X_UNLOCK (reqlock); 1887 X_UNLOCK (reqlock);
1801 1888
1802 if (req->type < 0) 1889 if (req->type < 0)
1803 goto quit; 1890 goto quit;
1804 1891
1805 if (!EIO_CANCELLED (req))
1806 ETP_EXECUTE (self, req); 1892 ETP_EXECUTE (self, req);
1807 1893
1808 X_LOCK (reslock); 1894 X_LOCK (reslock);
1809 1895
1810 ++npending; 1896 ++npending;
1811 1897
… …
1865 } 1951 }
1866 1952
1867static void 1953static void
1868eio_execute (etp_worker *self, eio_req *req) 1954eio_execute (etp_worker *self, eio_req *req)
1869{ 1955{
1956 if (ecb_expect_false (EIO_CANCELLED (req)))
1957 {
1958 req->result = -1;
1959 req->errorno = ECANCELED;
1960 return;
1961 }
1962
1870 switch (req->type) 1963 switch (req->type)
1871 { 1964 {
1872 case EIO_READ: ALLOC (req->size); 1965 case EIO_READ: ALLOC (req->size);
1873 req->result = req->offs >= 0 1966 req->result = req->offs >= 0
1874 ? pread (req->int1, req->ptr2, req->size, req->offs) 1967 ? pread (req->int1, req->ptr2, req->size, req->offs)
… …
1921 case EIO_MSYNC: req->result = eio__msync (req->ptr2, req->size, req->int1); break; 2014 case EIO_MSYNC: req->result = eio__msync (req->ptr2, req->size, req->int1); break;
1922 case EIO_MTOUCH: req->result = eio__mtouch (req); break; 2015 case EIO_MTOUCH: req->result = eio__mtouch (req); break;
1923 case EIO_MLOCK: req->result = eio__mlock (req->ptr2, req->size); break; 2016 case EIO_MLOCK: req->result = eio__mlock (req->ptr2, req->size); break;
1924 case EIO_MLOCKALL: req->result = eio__mlockall (req->int1); break; 2017 case EIO_MLOCKALL: req->result = eio__mlockall (req->int1); break;
1925 case EIO_SYNC_FILE_RANGE: req->result = eio__sync_file_range (req->int1, req->offs, req->size, req->int2); 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;
1926 2020
1927 case EIO_READDIR: eio__scandir (req, self); break; 2021 case EIO_READDIR: eio__scandir (req, self); break;
1928 2022
1929 case EIO_BUSY: 2023 case EIO_BUSY:
1930#ifdef _WIN32 2024#ifdef _WIN32
… …
2030eio_req *eio_sync_file_range (int fd, off_t offset, size_t nbytes, unsigned int flags, int pri, eio_cb cb, void *data) 2124eio_req *eio_sync_file_range (int fd, off_t offset, size_t nbytes, unsigned int flags, int pri, eio_cb cb, void *data)
2031{ 2125{
2032 REQ (EIO_SYNC_FILE_RANGE); req->int1 = fd; req->offs = offset; req->size = nbytes; req->int2 = flags; SEND; 2126 REQ (EIO_SYNC_FILE_RANGE); req->int1 = fd; req->offs = offset; req->size = nbytes; req->int2 = flags; SEND;
2033} 2127}
2034 2128
2129eio_req *eio_fallocate (int fd, int mode, off_t offset, size_t len, int pri, eio_cb cb, void *data)
2130{
2131 REQ (EIO_FALLOCATE); req->int1 = fd; req->int2 = mode; req->offs = offset; req->size = len; SEND;
2132}
2133
2035eio_req *eio_fdatasync (int fd, int pri, eio_cb cb, void *data) 2134eio_req *eio_fdatasync (int fd, int pri, eio_cb cb, void *data)
2036{ 2135{
2037 REQ (EIO_FDATASYNC); req->int1 = fd; SEND; 2136 REQ (EIO_FDATASYNC); req->int1 = fd; SEND;
2038} 2137}
2039 2138
… …
2080eio_req *eio_fchmod (int fd, mode_t mode, int pri, eio_cb cb, void *data) 2179eio_req *eio_fchmod (int fd, mode_t mode, int pri, eio_cb cb, void *data)
2081{ 2180{
2082 REQ (EIO_FCHMOD); req->int1 = fd; req->int2 = (long)mode; SEND; 2181 REQ (EIO_FCHMOD); req->int1 = fd; req->int2 = (long)mode; SEND;
2083} 2182}
2084 2183
2085eio_req *eio_fchown (int fd, uid_t uid, gid_t gid, int pri, eio_cb cb, void *data) 2184eio_req *eio_fchown (int fd, eio_uid_t uid, eio_gid_t gid, int pri, eio_cb cb, void *data)
2086{ 2185{
2087 REQ (EIO_FCHOWN); req->int1 = fd; req->int2 = (long)uid; req->int3 = (long)gid; SEND; 2186 REQ (EIO_FCHOWN); req->int1 = fd; req->int2 = (long)uid; req->int3 = (long)gid; SEND;
2088} 2187}
2089 2188
2090eio_req *eio_dup2 (int fd, int fd2, int pri, eio_cb cb, void *data) 2189eio_req *eio_dup2 (int fd, int fd2, int pri, eio_cb cb, void *data)
… …
2110eio_req *eio_truncate (const char *path, off_t offset, int pri, eio_cb cb, void *data) 2209eio_req *eio_truncate (const char *path, off_t offset, int pri, eio_cb cb, void *data)
2111{ 2210{
2112 REQ (EIO_TRUNCATE); PATH; req->offs = offset; SEND; 2211 REQ (EIO_TRUNCATE); PATH; req->offs = offset; SEND;
2113} 2212}
2114 2213
2115eio_req *eio_chown (const char *path, uid_t uid, gid_t gid, int pri, eio_cb cb, void *data) 2214eio_req *eio_chown (const char *path, eio_uid_t uid, eio_gid_t gid, int pri, eio_cb cb, void *data)
2116{ 2215{
2117 REQ (EIO_CHOWN); PATH; req->int2 = (long)uid; req->int3 = (long)gid; SEND; 2216 REQ (EIO_CHOWN); PATH; req->int2 = (long)uid; req->int3 = (long)gid; SEND;
2118} 2217}
2119 2218
2120eio_req *eio_chmod (const char *path, mode_t mode, int pri, eio_cb cb, void *data) 2219eio_req *eio_chmod (const char *path, mode_t mode, int pri, eio_cb cb, void *data)
… …
2267} 2366}
2268 2367
2269/*****************************************************************************/ 2368/*****************************************************************************/
2270/* misc garbage */ 2369/* misc garbage */
2271 2370
2272ssize_t 2371eio_ssize_t
2273eio_sendfile_sync (int ofd, int ifd, off_t offset, size_t count) 2372eio_sendfile_sync (int ofd, int ifd, off_t offset, size_t count)
2274{ 2373{
2275 etp_worker wrk; 2374 etp_worker wrk;
2276 ssize_t ret; 2375 eio_ssize_t ret;
2277 2376
2278 wrk.dbuf = 0; 2377 wrk.dbuf = 0;
2279 2378
2280 ret = eio__sendfile (ofd, ifd, offset, count, &wrk); 2379 ret = eio__sendfile (ofd, ifd, offset, count, &wrk);
2281 2380

Diff Legend

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