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

Comparing libeio/eio.c (file contents):
Revision 1.76 by root, Tue Jul 5 09:24:12 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
… …
834 return etp_poll (); 870 return etp_poll ();
835} 871}
836 872
837/*****************************************************************************/ 873/*****************************************************************************/
838/* work around various missing functions */ 874/* work around various missing functions */
839
840#if _POSIX_VERSION < 200809L
841# define realpath(path,resolved_path) (errno = ENOSYS, 0)
842#endif
843 875
844#if !HAVE_PREADWRITE 876#if !HAVE_PREADWRITE
845# undef pread 877# undef pread
846# undef pwrite 878# undef pwrite
847# define pread eio__pread 879# define pread eio__pread
848# define pwrite eio__pwrite 880# define pwrite eio__pwrite
849 881
850static ssize_t 882static eio_ssize_t
851eio__pread (int fd, void *buf, size_t count, off_t offset) 883eio__pread (int fd, void *buf, size_t count, off_t offset)
852{ 884{
853 ssize_t res; 885 eio_ssize_t res;
854 off_t ooffset; 886 off_t ooffset;
855 887
856 X_LOCK (preadwritelock); 888 X_LOCK (preadwritelock);
857 ooffset = lseek (fd, 0, SEEK_CUR); 889 ooffset = lseek (fd, 0, SEEK_CUR);
858 lseek (fd, offset, SEEK_SET); 890 lseek (fd, offset, SEEK_SET);
… …
861 X_UNLOCK (preadwritelock); 893 X_UNLOCK (preadwritelock);
862 894
863 return res; 895 return res;
864} 896}
865 897
866static ssize_t 898static eio_ssize_t
867eio__pwrite (int fd, void *buf, size_t count, off_t offset) 899eio__pwrite (int fd, void *buf, size_t count, off_t offset)
868{ 900{
869 ssize_t res; 901 eio_ssize_t res;
870 off_t ooffset; 902 off_t ooffset;
871 903
872 X_LOCK (preadwritelock); 904 X_LOCK (preadwritelock);
873 ooffset = lseek (fd, 0, SEEK_CUR); 905 ooffset = lseek (fd, 0, SEEK_CUR);
874 lseek (fd, offset, SEEK_SET); 906 lseek (fd, offset, SEEK_SET);
… …
948 /* 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
949 * call fdatasync, as that matches the expectation of its users best */ 981 * call fdatasync, as that matches the expectation of its users best */
950 return fdatasync (fd); 982 return fdatasync (fd);
951} 983}
952 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
953#if !HAVE_READAHEAD 996#if !HAVE_READAHEAD
954# undef readahead 997# undef readahead
955# define readahead(fd,offset,count) eio__readahead (fd, offset, count, self) 998# define readahead(fd,offset,count) eio__readahead (fd, offset, count, self)
956 999
957static ssize_t 1000static eio_ssize_t
958eio__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)
959{ 1002{
960 size_t todo = count; 1003 size_t todo = count;
961 dBUF; 1004 dBUF;
962 1005
… …
974} 1017}
975 1018
976#endif 1019#endif
977 1020
978/* sendfile always needs emulation */ 1021/* sendfile always needs emulation */
979static ssize_t 1022static eio_ssize_t
980eio__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)
981{ 1024{
982 ssize_t written = 0; 1025 eio_ssize_t written = 0;
983 ssize_t res; 1026 eio_ssize_t res;
984 1027
985 if (!count) 1028 if (!count)
986 return 0; 1029 return 0;
987 1030
988 for (;;) 1031 for (;;)
989 { 1032 {
1033#ifdef __APPLE__
1034# undef HAVE_SENDFILE /* broken, as everything on os x */
1035#endif
990#if HAVE_SENDFILE 1036#if HAVE_SENDFILE
991# if __linux 1037# if __linux
992 off_t soffset = offset; 1038 off_t soffset = offset;
993 res = sendfile (ofd, ifd, &soffset, count); 1039 res = sendfile (ofd, ifd, &soffset, count);
994 1040
… …
1010 1056
1011 /* according to source inspection, this is correct, and useful behaviour */ 1057 /* according to source inspection, this is correct, and useful behaviour */
1012 if (sbytes) 1058 if (sbytes)
1013 res = sbytes; 1059 res = sbytes;
1014 1060
1015# elif defined (__APPLE__) && 0 /* broken, as everything on os x */ 1061# elif defined (__APPLE__)
1016 off_t sbytes = count; 1062 off_t sbytes = count;
1017 res = sendfile (ifd, ofd, offset, &sbytes, 0, 0); 1063 res = sendfile (ifd, ofd, offset, &sbytes, 0, 0);
1018 1064
1019 /* according to the manpage, sbytes is always valid */ 1065 /* according to the manpage, sbytes is always valid */
1020 if (sbytes) 1066 if (sbytes)
… …
1037 if (res < 0 && sbytes) 1083 if (res < 0 && sbytes)
1038 res = sbytes; 1084 res = sbytes;
1039 1085
1040# endif 1086# endif
1041 1087
1042#elif defined (_WIN32) 1088#elif defined (_WIN32) && 0
1043 /* 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 */
1044 /* 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, */
1045 /* libeio guarantees that the file offset does not change, and windows */ 1091 /* libeio guarantees that the file offset does not change, and windows */
1046 /* 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 */
1047 HANDLE h = TO_SOCKET (ifd); 1093 HANDLE h = TO_SOCKET (ifd);
… …
1094 1140
1095 res = 0; 1141 res = 0;
1096 1142
1097 while (count) 1143 while (count)
1098 { 1144 {
1099 ssize_t cnt; 1145 eio_ssize_t cnt;
1100 1146
1101 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);
1102 1148
1103 if (cnt <= 0) 1149 if (cnt <= 0)
1104 { 1150 {
… …
1119 count -= cnt; 1165 count -= cnt;
1120 } 1166 }
1121 } 1167 }
1122 1168
1123 return res; 1169 return res;
1170}
1171
1172#ifdef PAGESIZE
1173# define eio_pagesize() PAGESIZE
1174#else
1175static intptr_t
1176eio_pagesize (void)
1177{
1178 static intptr_t page;
1179
1180 if (!page)
1181 page = sysconf (_SC_PAGESIZE);
1182
1183 return page;
1184}
1185#endif
1186
1187static void
1188eio_page_align (void **addr, size_t *length)
1189{
1190 intptr_t mask = eio_pagesize () - 1;
1191
1192 /* round down addr */
1193 intptr_t adj = mask & (intptr_t)*addr;
1194
1195 *addr = (void *)((intptr_t)*addr - adj);
1196 *length += adj;
1197
1198 /* round up length */
1199 *length = (*length + mask) & ~mask;
1200}
1201
1202#if !_POSIX_MEMLOCK
1203# define eio__mlockall(a) EIO_ENOSYS ()
1204#else
1205
1206static int
1207eio__mlockall (int flags)
1208{
1209 #if __GLIBC__ == 2 && __GLIBC_MINOR__ <= 7
1210 extern int mallopt (int, int);
1211 mallopt (-6, 238); /* http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=473812 */
1212 #endif
1213
1214 if (EIO_MCL_CURRENT != MCL_CURRENT
1215 || EIO_MCL_FUTURE != MCL_FUTURE)
1216 {
1217 flags = 0
1218 | (flags & EIO_MCL_CURRENT ? MCL_CURRENT : 0)
1219 | (flags & EIO_MCL_FUTURE ? MCL_FUTURE : 0);
1220 }
1221
1222 return mlockall (flags);
1223}
1224#endif
1225
1226#if !_POSIX_MEMLOCK_RANGE
1227# define eio__mlock(a,b) EIO_ENOSYS ()
1228#else
1229
1230static int
1231eio__mlock (void *addr, size_t length)
1232{
1233 eio_page_align (&addr, &length);
1234
1235 return mlock (addr, length);
1236}
1237
1238#endif
1239
1240#if !(_POSIX_MAPPED_FILES && _POSIX_SYNCHRONIZED_IO)
1241# define eio__msync(a,b,c) EIO_ENOSYS ()
1242#else
1243
1244static int
1245eio__msync (void *mem, size_t len, int flags)
1246{
1247 eio_page_align (&mem, &len);
1248
1249 if (EIO_MS_ASYNC != MS_SYNC
1250 || EIO_MS_INVALIDATE != MS_INVALIDATE
1251 || EIO_MS_SYNC != MS_SYNC)
1252 {
1253 flags = 0
1254 | (flags & EIO_MS_ASYNC ? MS_ASYNC : 0)
1255 | (flags & EIO_MS_INVALIDATE ? MS_INVALIDATE : 0)
1256 | (flags & EIO_MS_SYNC ? MS_SYNC : 0);
1257 }
1258
1259 return msync (mem, len, flags);
1260}
1261
1262#endif
1263
1264static int
1265eio__mtouch (eio_req *req)
1266{
1267 void *mem = req->ptr2;
1268 size_t len = req->size;
1269 int flags = req->int1;
1270
1271 eio_page_align (&mem, &len);
1272
1273 {
1274 intptr_t addr = (intptr_t)mem;
1275 intptr_t end = addr + len;
1276 intptr_t page = eio_pagesize ();
1277
1278 if (addr < end)
1279 if (flags & EIO_MT_MODIFY) /* modify */
1280 do { *((volatile sig_atomic_t *)addr) |= 0; } while ((addr += page) < len && !EIO_CANCELLED (req));
1281 else
1282 do { *((volatile sig_atomic_t *)addr) ; } while ((addr += page) < len && !EIO_CANCELLED (req));
1283 }
1284
1285 return 0;
1286}
1287
1288/*****************************************************************************/
1289/* requests implemented outside eio_execute, because they are so large */
1290
1291static void
1292eio__realpath (eio_req *req, etp_worker *self)
1293{
1294 char *rel = req->ptr1;
1295 char *res;
1296 char *tmp1, *tmp2;
1297#if SYMLOOP_MAX > 32
1298 int symlinks = SYMLOOP_MAX;
1299#else
1300 int symlinks = 32;
1301#endif
1302
1303 req->result = -1;
1304
1305 errno = EINVAL;
1306 if (!rel)
1307 return;
1308
1309 errno = ENOENT;
1310 if (!*rel)
1311 return;
1312
1313 if (!req->ptr2)
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;
1327 tmp2 = tmp1 + PATH_MAX;
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
1352 if (*rel != '/')
1353 {
1354 if (!getcwd (res, PATH_MAX))
1355 return;
1356
1357 if (res [1]) /* only use if not / */
1358 res += strlen (res);
1359 }
1360
1361 while (*rel)
1362 {
1363 eio_ssize_t len, linklen;
1364 char *beg = rel;
1365
1366 while (*rel && *rel != '/')
1367 ++rel;
1368
1369 len = rel - beg;
1370
1371 if (!len) /* skip slashes */
1372 {
1373 ++rel;
1374 continue;
1375 }
1376
1377 if (beg [0] == '.')
1378 {
1379 if (len == 1)
1380 continue; /* . - nop */
1381
1382 if (beg [1] == '.' && len == 2)
1383 {
1384 /* .. - back up one component, if possible */
1385
1386 while (res != req->ptr2)
1387 if (*--res == '/')
1388 break;
1389
1390 continue;
1391 }
1392 }
1393
1394 errno = ENAMETOOLONG;
1395 if (res + 1 + len + 1 >= tmp1)
1396 return;
1397
1398 /* copy one component */
1399 *res = '/';
1400 memcpy (res + 1, beg, len);
1401
1402 /* zero-terminate, for readlink */
1403 res [len + 1] = 0;
1404
1405 /* now check if it's a symlink */
1406 linklen = readlink (req->ptr2, tmp1, PATH_MAX);
1407
1408 if (linklen < 0)
1409 {
1410 if (errno != EINVAL)
1411 return;
1412
1413 /* it's a normal directory. hopefully */
1414 res += len + 1;
1415 }
1416 else
1417 {
1418 /* yay, it was a symlink - build new path in tmp2 */
1419 int rellen = strlen (rel);
1420
1421 errno = ENAMETOOLONG;
1422 if (linklen + 1 + rellen >= PATH_MAX)
1423 return;
1424
1425 errno = ELOOP;
1426 if (!--symlinks)
1427 return;
1428
1429 if (*tmp1 == '/')
1430 res = req->ptr2; /* symlink resolves to an absolute path */
1431
1432 /* we need to be careful, as rel might point into tmp2 already */
1433 memmove (tmp2 + linklen + 1, rel, rellen + 1);
1434 tmp2 [linklen] = '/';
1435 memcpy (tmp2, tmp1, linklen);
1436
1437 rel = tmp2;
1438 }
1439 }
1440
1441 /* special case for the lone root path */
1442 if (res == req->ptr2)
1443 *res++ = '/';
1444
1445 req->result = res - (char *)req->ptr2;
1446
1447done:
1448 req->ptr2 = realloc (req->ptr2, req->result); /* trade time for space savings */
1124} 1449}
1125 1450
1126static signed char 1451static signed char
1127eio_dent_cmp (const eio_dirent *a, const eio_dirent *b) 1452eio_dent_cmp (const eio_dirent *a, const eio_dirent *b)
1128{ 1453{
… …
1488 break; 1813 break;
1489 } 1814 }
1490 } 1815 }
1491} 1816}
1492 1817
1493#ifdef PAGESIZE
1494# define eio_pagesize() PAGESIZE
1495#else
1496static intptr_t
1497eio_pagesize (void)
1498{
1499 static intptr_t page;
1500
1501 if (!page)
1502 page = sysconf (_SC_PAGESIZE);
1503
1504 return page;
1505}
1506#endif
1507
1508static void
1509eio_page_align (void **addr, size_t *length)
1510{
1511 intptr_t mask = eio_pagesize () - 1;
1512
1513 /* round down addr */
1514 intptr_t adj = mask & (intptr_t)*addr;
1515
1516 *addr = (void *)((intptr_t)*addr - adj);
1517 *length += adj;
1518
1519 /* round up length */
1520 *length = (*length + mask) & ~mask;
1521}
1522
1523#if !_POSIX_MEMLOCK
1524# define eio__mlockall(a) ((errno = ENOSYS), -1)
1525#else
1526
1527static int
1528eio__mlockall (int flags)
1529{
1530 #if __GLIBC__ == 2 && __GLIBC_MINOR__ <= 7
1531 extern int mallopt (int, int);
1532 mallopt (-6, 238); /* http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=473812 */
1533 #endif
1534
1535 if (EIO_MCL_CURRENT != MCL_CURRENT
1536 || EIO_MCL_FUTURE != MCL_FUTURE)
1537 {
1538 flags = 0
1539 | (flags & EIO_MCL_CURRENT ? MCL_CURRENT : 0)
1540 | (flags & EIO_MCL_FUTURE ? MCL_FUTURE : 0);
1541 }
1542
1543 return mlockall (flags);
1544}
1545#endif
1546
1547#if !_POSIX_MEMLOCK_RANGE
1548# define eio__mlock(a,b) ((errno = ENOSYS), -1)
1549#else
1550
1551static int
1552eio__mlock (void *addr, size_t length)
1553{
1554 eio_page_align (&addr, &length);
1555
1556 return mlock (addr, length);
1557}
1558
1559#endif
1560
1561#if !(_POSIX_MAPPED_FILES && _POSIX_SYNCHRONIZED_IO)
1562# define eio__msync(a,b,c) ((errno = ENOSYS), -1)
1563#else
1564
1565static int
1566eio__msync (void *mem, size_t len, int flags)
1567{
1568 eio_page_align (&mem, &len);
1569
1570 if (EIO_MS_ASYNC != MS_SYNC
1571 || EIO_MS_INVALIDATE != MS_INVALIDATE
1572 || EIO_MS_SYNC != MS_SYNC)
1573 {
1574 flags = 0
1575 | (flags & EIO_MS_ASYNC ? MS_ASYNC : 0)
1576 | (flags & EIO_MS_INVALIDATE ? MS_INVALIDATE : 0)
1577 | (flags & EIO_MS_SYNC ? MS_SYNC : 0);
1578 }
1579
1580 return msync (mem, len, flags);
1581}
1582
1583#endif
1584
1585static int
1586eio__mtouch (eio_req *req)
1587{
1588 void *mem = req->ptr2;
1589 size_t len = req->size;
1590 int flags = req->int1;
1591
1592 eio_page_align (&mem, &len);
1593
1594 {
1595 intptr_t addr = (intptr_t)mem;
1596 intptr_t end = addr + len;
1597 intptr_t page = eio_pagesize ();
1598
1599 if (addr < end)
1600 if (flags & EIO_MT_MODIFY) /* modify */
1601 do { *((volatile sig_atomic_t *)addr) |= 0; } while ((addr += page) < len && !EIO_CANCELLED (req));
1602 else
1603 do { *((volatile sig_atomic_t *)addr) ; } while ((addr += page) < len && !EIO_CANCELLED (req));
1604 }
1605
1606 return 0;
1607}
1608
1609/*****************************************************************************/ 1818/*****************************************************************************/
1610 1819
1611#define ALLOC(len) \ 1820#define ALLOC(len) \
1612 if (!req->ptr2) \ 1821 if (!req->ptr2) \
1613 { \ 1822 { \
… …
1626X_THREAD_PROC (etp_proc) 1835X_THREAD_PROC (etp_proc)
1627{ 1836{
1628 ETP_REQ *req; 1837 ETP_REQ *req;
1629 struct timespec ts; 1838 struct timespec ts;
1630 etp_worker *self = (etp_worker *)thr_arg; 1839 etp_worker *self = (etp_worker *)thr_arg;
1840 int timeout;
1631 1841
1632 /* try to distribute timeouts somewhat randomly */ 1842 /* try to distribute timeouts somewhat evenly */
1633 ts.tv_nsec = ((unsigned long)self & 1023UL) * (1000000000UL / 1024UL); 1843 ts.tv_nsec = ((unsigned long)self & 1023UL) * (1000000000UL / 1024UL);
1634 1844
1635 for (;;) 1845 for (;;)
1636 { 1846 {
1847 ts.tv_sec = 0;
1848
1637 X_LOCK (reqlock); 1849 X_LOCK (reqlock);
1638 1850
1639 for (;;) 1851 for (;;)
1640 { 1852 {
1641 self->req = req = reqq_shift (&req_queue); 1853 self->req = req = reqq_shift (&req_queue);
1642 1854
1643 if (req) 1855 if (req)
1644 break; 1856 break;
1645 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
1646 ++idle; 1867 ++idle;
1647 1868
1648 ts.tv_sec = time (0) + idle_timeout; 1869 if (idle <= max_idle)
1649 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
1650 { 1873 {
1651 if (idle > max_idle) 1874 /* initialise timeout once */
1652 { 1875 if (!ts.tv_sec)
1653 --idle; 1876 ts.tv_sec = time (0) + idle_timeout;
1654 X_UNLOCK (reqlock);
1655 X_LOCK (wrklock);
1656 --started;
1657 X_UNLOCK (wrklock);
1658 goto quit;
1659 }
1660 1877
1661 /* we are allowed to idle, so do so without any timeout */
1662 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.,.. */
1663 } 1880 }
1664 1881
1665 --idle; 1882 --idle;
1666 } 1883 }
1667 1884
… …
1670 X_UNLOCK (reqlock); 1887 X_UNLOCK (reqlock);
1671 1888
1672 if (req->type < 0) 1889 if (req->type < 0)
1673 goto quit; 1890 goto quit;
1674 1891
1675 if (!EIO_CANCELLED (req))
1676 ETP_EXECUTE (self, req); 1892 ETP_EXECUTE (self, req);
1677 1893
1678 X_LOCK (reslock); 1894 X_LOCK (reslock);
1679 1895
1680 ++npending; 1896 ++npending;
1681 1897
… …
1735 } 1951 }
1736 1952
1737static void 1953static void
1738eio_execute (etp_worker *self, eio_req *req) 1954eio_execute (etp_worker *self, eio_req *req)
1739{ 1955{
1956 if (ecb_expect_false (EIO_CANCELLED (req)))
1957 {
1958 req->result = -1;
1959 req->errorno = ECANCELED;
1960 return;
1961 }
1962
1740 switch (req->type) 1963 switch (req->type)
1741 { 1964 {
1742 case EIO_READ: ALLOC (req->size); 1965 case EIO_READ: ALLOC (req->size);
1743 req->result = req->offs >= 0 1966 req->result = req->offs >= 0
1744 ? pread (req->int1, req->ptr2, req->size, req->offs) 1967 ? pread (req->int1, req->ptr2, req->size, req->offs)
… …
1778 case EIO_RENAME: req->result = rename (req->ptr1, req->ptr2); break; 2001 case EIO_RENAME: req->result = rename (req->ptr1, req->ptr2); break;
1779 case EIO_LINK: req->result = link (req->ptr1, req->ptr2); break; 2002 case EIO_LINK: req->result = link (req->ptr1, req->ptr2); break;
1780 case EIO_SYMLINK: req->result = symlink (req->ptr1, req->ptr2); break; 2003 case EIO_SYMLINK: req->result = symlink (req->ptr1, req->ptr2); break;
1781 case EIO_MKNOD: req->result = mknod (req->ptr1, (mode_t)req->int2, (dev_t)req->offs); break; 2004 case EIO_MKNOD: req->result = mknod (req->ptr1, (mode_t)req->int2, (dev_t)req->offs); break;
1782 2005
1783 case EIO_REALPATH: req->flags |= EIO_FLAG_PTR2_FREE; 2006 case EIO_REALPATH: eio__realpath (req, self); break;
1784 req->ptr2 = realpath (req->ptr1, 0);
1785 req->result = req->ptr2 ? strlen (req->ptr2) : -1;
1786 break;
1787 2007
1788 case EIO_READLINK: ALLOC (PATH_MAX); 2008 case EIO_READLINK: ALLOC (PATH_MAX);
1789 req->result = readlink (req->ptr1, req->ptr2, PATH_MAX); break; 2009 req->result = readlink (req->ptr1, req->ptr2, PATH_MAX); break;
1790 2010
1791 case EIO_SYNC: req->result = 0; sync (); break; 2011 case EIO_SYNC: req->result = 0; sync (); break;
… …
1794 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;
1795 case EIO_MTOUCH: req->result = eio__mtouch (req); break; 2015 case EIO_MTOUCH: req->result = eio__mtouch (req); break;
1796 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;
1797 case EIO_MLOCKALL: req->result = eio__mlockall (req->int1); break; 2017 case EIO_MLOCKALL: req->result = eio__mlockall (req->int1); break;
1798 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;
1799 2020
1800 case EIO_READDIR: eio__scandir (req, self); break; 2021 case EIO_READDIR: eio__scandir (req, self); break;
1801 2022
1802 case EIO_BUSY: 2023 case EIO_BUSY:
1803#ifdef _WIN32 2024#ifdef _WIN32
… …
1903eio_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)
1904{ 2125{
1905 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;
1906} 2127}
1907 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
1908eio_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)
1909{ 2135{
1910 REQ (EIO_FDATASYNC); req->int1 = fd; SEND; 2136 REQ (EIO_FDATASYNC); req->int1 = fd; SEND;
1911} 2137}
1912 2138
… …
1953eio_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)
1954{ 2180{
1955 REQ (EIO_FCHMOD); req->int1 = fd; req->int2 = (long)mode; SEND; 2181 REQ (EIO_FCHMOD); req->int1 = fd; req->int2 = (long)mode; SEND;
1956} 2182}
1957 2183
1958eio_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)
1959{ 2185{
1960 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;
1961} 2187}
1962 2188
1963eio_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)
… …
1983eio_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)
1984{ 2210{
1985 REQ (EIO_TRUNCATE); PATH; req->offs = offset; SEND; 2211 REQ (EIO_TRUNCATE); PATH; req->offs = offset; SEND;
1986} 2212}
1987 2213
1988eio_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)
1989{ 2215{
1990 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;
1991} 2217}
1992 2218
1993eio_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)
… …
2140} 2366}
2141 2367
2142/*****************************************************************************/ 2368/*****************************************************************************/
2143/* misc garbage */ 2369/* misc garbage */
2144 2370
2145ssize_t 2371eio_ssize_t
2146eio_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)
2147{ 2373{
2148 etp_worker wrk; 2374 etp_worker wrk;
2149 ssize_t ret; 2375 eio_ssize_t ret;
2150 2376
2151 wrk.dbuf = 0; 2377 wrk.dbuf = 0;
2152 2378
2153 ret = eio__sendfile (ofd, ifd, offset, count, &wrk); 2379 ret = eio__sendfile (ofd, ifd, offset, count, &wrk);
2154 2380

Diff Legend

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