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

Comparing libeio/eio.c (file contents):
Revision 1.99 by root, Tue Jul 26 11:07:08 2011 UTC vs.
Revision 1.121 by root, Sat Jun 2 20:13:26 2012 UTC

1/* 1/*
2 * libeio implementation 2 * libeio implementation
3 * 3 *
4 * Copyright (c) 2007,2008,2009,2010,2011 Marc Alexander Lehmann <libeio@schmorp.de> 4 * Copyright (c) 2007,2008,2009,2010,2011,2012 Marc Alexander Lehmann <libeio@schmorp.de>
5 * All rights reserved. 5 * All rights reserved.
6 * 6 *
7 * Redistribution and use in source and binary forms, with or without modifica- 7 * Redistribution and use in source and binary forms, with or without modifica-
8 * tion, are permitted provided that the following conditions are met: 8 * tion, are permitted provided that the following conditions are met:
9 * 9 *
… …
43 43
44#include "eio.h" 44#include "eio.h"
45#include "ecb.h" 45#include "ecb.h"
46 46
47#ifdef EIO_STACKSIZE 47#ifdef EIO_STACKSIZE
48# define XTHREAD_STACKSIZE EIO_STACKSIZE 48# define X_STACKSIZE EIO_STACKSIZE
49#endif 49#endif
50#include "xthread.h" 50#include "xthread.h"
51 51
52#include <errno.h> 52#include <errno.h>
53#include <stddef.h> 53#include <stddef.h>
… …
105#ifdef _WIN32 105#ifdef _WIN32
106 106
107 #undef PAGESIZE 107 #undef PAGESIZE
108 #define PAGESIZE 4096 /* GetSystemInfo? */ 108 #define PAGESIZE 4096 /* GetSystemInfo? */
109 109
110 /* TODO: look at how perl does stat (non-sloppy), unlink (ro-files), utime, link */
111
110 #ifdef EIO_STRUCT_STATI64 112 #ifdef EIO_STRUCT_STATI64
113 /* look at perl's non-sloppy stat */
111 #define stat(path,buf) _stati64 (path,buf) 114 #define stat(path,buf) _stati64 (path,buf)
112 #define fstat(fd,buf) _fstati64 (fd,buf) 115 #define fstat(fd,buf) _fstati64 (fd,buf)
113 #endif 116 #endif
114 #define lstat(path,buf) stat (path,buf) 117 #define lstat(path,buf) stat (path,buf)
115 #define fsync(fd) (FlushFileBuffers ((HANDLE)EIO_FD_TO_WIN32_HANDLE (fd)) ? 0 : EIO_ERRNO (EBADF, -1)) 118 #define fsync(fd) (FlushFileBuffers ((HANDLE)EIO_FD_TO_WIN32_HANDLE (fd)) ? 0 : EIO_ERRNO (EBADF, -1))
… …
205 #endif 208 #endif
206 209
207 #define D_NAME(entp) entp->d_name 210 #define D_NAME(entp) entp->d_name
208 211
209 /* POSIX_SOURCE is useless on bsd's, and XOPEN_SOURCE is unreliable there, too */ 212 /* POSIX_SOURCE is useless on bsd's, and XOPEN_SOURCE is unreliable there, too */
210 #if __FreeBSD__ || defined __NetBSD__ || defined __OpenBSD__ 213 #if __FreeBSD__ || __NetBSD__ || __OpenBSD__
211 #define _DIRENT_HAVE_D_TYPE /* sigh */ 214 #define _DIRENT_HAVE_D_TYPE /* sigh */
212 #define D_INO(de) (de)->d_fileno 215 #define D_INO(de) (de)->d_fileno
213 #define D_NAMLEN(de) (de)->d_namlen 216 #define D_NAMLEN(de) (de)->d_namlen
214 #elif __linux || defined d_ino || _XOPEN_SOURCE >= 600 217 #elif __linux || defined d_ino || _XOPEN_SOURCE >= 600
215 #define D_INO(de) (de)->d_ino 218 #define D_INO(de) (de)->d_ino
… …
289#define FUBd \ 292#define FUBd \
290 free (eio_buf) 293 free (eio_buf)
291 294
292#define EIO_TICKS ((1000000 + 1023) >> 10) 295#define EIO_TICKS ((1000000 + 1023) >> 10)
293 296
297/*****************************************************************************/
298
299struct tmpbuf
300{
301 void *ptr;
302 int len;
303};
304
305static void *
306tmpbuf_get (struct tmpbuf *buf, int len)
307{
308 if (buf->len < len)
309 {
310 free (buf->ptr);
311 buf->ptr = malloc (buf->len = len);
312 }
313
314 return buf->ptr;
315}
316
317struct tmpbuf;
318
319#if _POSIX_VERSION >= 200809L
320 #define HAVE_AT 1
321 #define WD2FD(wd) ((wd) ? (wd)->fd : AT_FDCWD)
322 #ifndef O_SEARCH
323 #define O_SEARCH O_RDONLY
324 #endif
325#else
326 #define HAVE_AT 0
327 static const char *wd_expand (struct tmpbuf *tmpbuf, eio_wd wd, const char *path);
328#endif
329
330struct eio_pwd
331{
332#if HAVE_AT
333 int fd;
334#endif
335 int len;
336 char str[1]; /* actually, a 0-terminated canonical path */
337};
338
339/*****************************************************************************/
340
294#define ETP_PRI_MIN EIO_PRI_MIN 341#define ETP_PRI_MIN EIO_PRI_MIN
295#define ETP_PRI_MAX EIO_PRI_MAX 342#define ETP_PRI_MAX EIO_PRI_MAX
296 343
297struct etp_worker; 344struct etp_worker;
298 345
… …
321static void (*done_poll_cb) (void); 368static void (*done_poll_cb) (void);
322 369
323static unsigned int max_poll_time; /* reslock */ 370static unsigned int max_poll_time; /* reslock */
324static unsigned int max_poll_reqs; /* reslock */ 371static unsigned int max_poll_reqs; /* reslock */
325 372
326static volatile unsigned int nreqs; /* reqlock */ 373static unsigned int nreqs; /* reqlock */
327static volatile unsigned int nready; /* reqlock */ 374static unsigned int nready; /* reqlock */
328static volatile unsigned int npending; /* reqlock */ 375static unsigned int npending; /* reqlock */
329static volatile unsigned int max_idle = 4; /* maximum number of threads that can idle indefinitely */ 376static unsigned int max_idle = 4; /* maximum number of threads that can idle indefinitely */
330static volatile unsigned int idle_timeout = 10; /* number of seconds after which an idle threads exit */ 377static unsigned int idle_timeout = 10; /* number of seconds after which an idle threads exit */
331 378
332static xmutex_t wrklock; 379static xmutex_t wrklock;
333static xmutex_t reslock; 380static xmutex_t reslock;
334static xmutex_t reqlock; 381static xmutex_t reqlock;
335static xcond_t reqwait; 382static xcond_t reqwait;
336 383
337#if !HAVE_PREADWRITE
338/*
339 * make our pread/pwrite emulation safe against themselves, but not against
340 * normal read/write by using a mutex. slows down execution a lot,
341 * but that's your problem, not mine.
342 */
343static xmutex_t preadwritelock;
344#endif
345
346typedef struct etp_worker 384typedef struct etp_worker
347{ 385{
386 struct tmpbuf tmpbuf;
387
348 /* locked by wrklock */ 388 /* locked by wrklock */
349 struct etp_worker *prev, *next; 389 struct etp_worker *prev, *next;
350 390
351 xthread_t tid; 391 xthread_t tid;
352 392
353 /* locked by reslock, reqlock or wrklock */
354 ETP_REQ *req; /* currently processed request */
355
356#ifdef ETP_WORKER_COMMON 393#ifdef ETP_WORKER_COMMON
357 ETP_WORKER_COMMON 394 ETP_WORKER_COMMON
358#endif 395#endif
359} etp_worker; 396} etp_worker;
360 397
… …
363#define ETP_WORKER_LOCK(wrk) X_LOCK (wrklock) 400#define ETP_WORKER_LOCK(wrk) X_LOCK (wrklock)
364#define ETP_WORKER_UNLOCK(wrk) X_UNLOCK (wrklock) 401#define ETP_WORKER_UNLOCK(wrk) X_UNLOCK (wrklock)
365 402
366/* worker threads management */ 403/* worker threads management */
367 404
368static void ecb_cold 405static void
369etp_worker_clear (etp_worker *wrk) 406etp_worker_clear (etp_worker *wrk)
370{ 407{
371} 408}
372 409
373static void ecb_cold 410static void ecb_cold
374etp_worker_free (etp_worker *wrk) 411etp_worker_free (etp_worker *wrk)
375{ 412{
413 free (wrk->tmpbuf.ptr);
414
376 wrk->next->prev = wrk->prev; 415 wrk->next->prev = wrk->prev;
377 wrk->prev->next = wrk->next; 416 wrk->prev->next = wrk->next;
378 417
379 free (wrk); 418 free (wrk);
380} 419}
… …
558} 597}
559 598
560static void ecb_cold 599static void ecb_cold
561etp_end_thread (void) 600etp_end_thread (void)
562{ 601{
563 eio_req *req = calloc (1, sizeof (eio_req)); 602 eio_req *req = calloc (1, sizeof (eio_req)); /* will be freed by worker */
564 603
565 req->type = -1; 604 req->type = -1;
566 req->pri = ETP_PRI_MAX - ETP_PRI_MIN; 605 req->pri = ETP_PRI_MAX - ETP_PRI_MIN;
567 606
568 X_LOCK (reqlock); 607 X_LOCK (reqlock);
… …
895} 934}
896 935
897/*****************************************************************************/ 936/*****************************************************************************/
898/* work around various missing functions */ 937/* work around various missing functions */
899 938
900#if !HAVE_PREADWRITE
901# undef pread
902# undef pwrite
903# define pread eio__pread
904# define pwrite eio__pwrite
905
906static eio_ssize_t
907eio__pread (int fd, void *buf, size_t count, off_t offset)
908{
909 eio_ssize_t res;
910 off_t ooffset;
911
912 X_LOCK (preadwritelock);
913 ooffset = lseek (fd, 0, SEEK_CUR);
914 lseek (fd, offset, SEEK_SET);
915 res = read (fd, buf, count);
916 lseek (fd, ooffset, SEEK_SET);
917 X_UNLOCK (preadwritelock);
918
919 return res;
920}
921
922static eio_ssize_t
923eio__pwrite (int fd, void *buf, size_t count, off_t offset)
924{
925 eio_ssize_t res;
926 off_t ooffset;
927
928 X_LOCK (preadwritelock);
929 ooffset = lseek (fd, 0, SEEK_CUR);
930 lseek (fd, offset, SEEK_SET);
931 res = write (fd, buf, count);
932 lseek (fd, ooffset, SEEK_SET);
933 X_UNLOCK (preadwritelock);
934
935 return res;
936}
937#endif
938
939#ifndef HAVE_UTIMES 939#ifndef HAVE_UTIMES
940 940
941# undef utimes 941# undef utimes
942# define utimes(path,times) eio__utimes (path, times) 942# define utimes(path,times) eio__utimes (path, times)
943 943
… …
984 int res; 984 int res;
985 985
986#if HAVE_SYS_SYNCFS 986#if HAVE_SYS_SYNCFS
987 res = (int)syscall (__NR_syncfs, (int)(fd)); 987 res = (int)syscall (__NR_syncfs, (int)(fd));
988#else 988#else
989 res = -1; 989 res = EIO_ENOSYS ();
990 errno = ENOSYS;
991#endif 990#endif
992 991
993 if (res < 0 && errno == ENOSYS && fd >= 0) 992 if (res < 0 && errno == ENOSYS && fd >= 0)
994 sync (); 993 sync ();
995 994
… …
1025} 1024}
1026 1025
1027static int 1026static int
1028eio__fallocate (int fd, int mode, off_t offset, size_t len) 1027eio__fallocate (int fd, int mode, off_t offset, size_t len)
1029{ 1028{
1030#if HAVE_FALLOCATE 1029#if HAVE_LINUX_FALLOCATE
1031 return fallocate (fd, mode, offset, len); 1030 return fallocate (fd, mode, offset, len);
1032#else 1031#else
1033 errno = ENOSYS; 1032 return EIO_ENOSYS ();
1034 return -1;
1035#endif 1033#endif
1036} 1034}
1037 1035
1038#if !HAVE_READAHEAD 1036#if !HAVE_READAHEAD
1039# undef readahead 1037# undef readahead
… …
1054 todo -= len; 1052 todo -= len;
1055 } 1053 }
1056 1054
1057 FUBd; 1055 FUBd;
1058 1056
1059 errno = 0; 1057 /* linux's readahead basically only fails for EBADF or EINVAL (not mmappable) */
1058 /* but not for e.g. EIO or eof, so we also never fail */
1060 return count; 1059 return 0;
1061} 1060}
1062 1061
1063#endif 1062#endif
1064 1063
1065/* sendfile always needs emulation */ 1064/* sendfile always needs emulation */
… …
1100 1099
1101 /* according to source inspection, this is correct, and useful behaviour */ 1100 /* according to source inspection, this is correct, and useful behaviour */
1102 if (sbytes) 1101 if (sbytes)
1103 res = sbytes; 1102 res = sbytes;
1104 1103
1105# elif defined (__APPLE__) 1104# elif defined __APPLE__
1106 off_t sbytes = count; 1105 off_t sbytes = count;
1107 res = sendfile (ifd, ofd, offset, &sbytes, 0, 0); 1106 res = sendfile (ifd, ofd, offset, &sbytes, 0, 0);
1108 1107
1109 /* according to the manpage, sbytes is always valid */ 1108 /* according to the manpage, sbytes is always valid */
1110 if (sbytes) 1109 if (sbytes)
… …
1137 HANDLE h = TO_SOCKET (ifd); 1136 HANDLE h = TO_SOCKET (ifd);
1138 SetFilePointer (h, offset, 0, FILE_BEGIN); 1137 SetFilePointer (h, offset, 0, FILE_BEGIN);
1139 res = TransmitFile (TO_SOCKET (ofd), h, count, 0, 0, 0, 0); 1138 res = TransmitFile (TO_SOCKET (ofd), h, count, 0, 0, 0, 0);
1140 1139
1141#else 1140#else
1142 res = -1; 1141 res = EIO_ENOSYS ();
1143 errno = ENOSYS;
1144#endif 1142#endif
1145 1143
1146 /* we assume sendfile can copy at least 128mb in one go */ 1144 /* we assume sendfile can copy at least 128mb in one go */
1147 if (res <= 128 * 1024 * 1024) 1145 if (res <= 128 * 1024 * 1024)
1148 { 1146 {
… …
1335 1333
1336/*****************************************************************************/ 1334/*****************************************************************************/
1337/* requests implemented outside eio_execute, because they are so large */ 1335/* requests implemented outside eio_execute, because they are so large */
1338 1336
1339static void 1337static void
1340eio__realpath (eio_req *req, etp_worker *self) 1338eio__lseek (eio_req *req)
1341{ 1339{
1342 char *rel = req->ptr1; 1340 /* this usually gets optimised away completely, or your compiler sucks, */
1341 /* or the whence constants really are not 0, 1, 2 */
1342 int whence = req->int2 == EIO_SEEK_SET ? SEEK_SET
1343 : req->int2 == EIO_SEEK_CUR ? SEEK_CUR
1344 : req->int2 == EIO_SEEK_END ? SEEK_END
1345 : req->int2;
1346
1347 req->offs = lseek (req->int1, req->offs, whence);
1348 req->result = req->offs == (off_t)-1 ? -1 : 0;
1349}
1350
1351/* result will always end up in tmpbuf, there is always space for adding a 0-byte */
1352static int
1353eio__realpath (struct tmpbuf *tmpbuf, eio_wd wd, const char *path)
1354{
1355 const char *rel = path;
1343 char *res; 1356 char *res;
1344 char *tmp1, *tmp2; 1357 char *tmp1, *tmp2;
1345#if SYMLOOP_MAX > 32 1358#if SYMLOOP_MAX > 32
1346 int symlinks = SYMLOOP_MAX; 1359 int symlinks = SYMLOOP_MAX;
1347#else 1360#else
1348 int symlinks = 32; 1361 int symlinks = 32;
1349#endif 1362#endif
1350 1363
1351 req->result = -1;
1352
1353 errno = EINVAL; 1364 errno = EINVAL;
1354 if (!rel) 1365 if (!rel)
1355 return; 1366 return -1;
1356 1367
1357 errno = ENOENT; 1368 errno = ENOENT;
1358 if (!*rel) 1369 if (!*rel)
1359 return; 1370 return -1;
1360 1371
1361 if (!req->ptr2) 1372 res = tmpbuf_get (tmpbuf, PATH_MAX * 3);
1362 {
1363 X_LOCK (wrklock);
1364 req->flags |= EIO_FLAG_PTR2_FREE;
1365 X_UNLOCK (wrklock);
1366 req->ptr2 = malloc (PATH_MAX * 3);
1367
1368 errno = ENOMEM;
1369 if (!req->ptr2)
1370 return;
1371 }
1372
1373 res = req->ptr2;
1374 tmp1 = res + PATH_MAX; 1373 tmp1 = res + PATH_MAX;
1375 tmp2 = tmp1 + PATH_MAX; 1374 tmp2 = tmp1 + PATH_MAX;
1376 1375
1377#if 0 /* disabled, the musl way to do things is just too racy */ 1376#if 0 /* disabled, the musl way to do things is just too racy */
1378#if __linux && defined(O_NONBLOCK) && defined(O_NOATIME) 1377#if __linux && defined(O_NONBLOCK) && defined(O_NOATIME)
… …
1397#endif 1396#endif
1398#endif 1397#endif
1399 1398
1400 if (*rel != '/') 1399 if (*rel != '/')
1401 { 1400 {
1401 int len;
1402
1403 errno = ENOENT;
1404 if (wd == EIO_INVALID_WD)
1405 return -1;
1406
1407 if (wd == EIO_CWD)
1408 {
1402 if (!getcwd (res, PATH_MAX)) 1409 if (!getcwd (res, PATH_MAX))
1403 return; 1410 return -1;
1411
1412 len = strlen (res);
1413 }
1414 else
1415 memcpy (res, wd->str, len = wd->len);
1404 1416
1405 if (res [1]) /* only use if not / */ 1417 if (res [1]) /* only use if not / */
1406 res += strlen (res); 1418 res += len;
1407 } 1419 }
1408 1420
1409 while (*rel) 1421 while (*rel)
1410 { 1422 {
1411 eio_ssize_t len, linklen; 1423 eio_ssize_t len, linklen;
1412 char *beg = rel; 1424 const char *beg = rel;
1413 1425
1414 while (*rel && *rel != '/') 1426 while (*rel && *rel != '/')
1415 ++rel; 1427 ++rel;
1416 1428
1417 len = rel - beg; 1429 len = rel - beg;
… …
1429 1441
1430 if (beg [1] == '.' && len == 2) 1442 if (beg [1] == '.' && len == 2)
1431 { 1443 {
1432 /* .. - back up one component, if possible */ 1444 /* .. - back up one component, if possible */
1433 1445
1434 while (res != req->ptr2) 1446 while (res != tmpbuf->ptr)
1435 if (*--res == '/') 1447 if (*--res == '/')
1436 break; 1448 break;
1437 1449
1438 continue; 1450 continue;
1439 } 1451 }
1440 } 1452 }
1441 1453
1442 errno = ENAMETOOLONG; 1454 errno = ENAMETOOLONG;
1443 if (res + 1 + len + 1 >= tmp1) 1455 if (res + 1 + len + 1 >= tmp1)
1444 return; 1456 return -1;
1445 1457
1446 /* copy one component */ 1458 /* copy one component */
1447 *res = '/'; 1459 *res = '/';
1448 memcpy (res + 1, beg, len); 1460 memcpy (res + 1, beg, len);
1449 1461
1450 /* zero-terminate, for readlink */ 1462 /* zero-terminate, for readlink */
1451 res [len + 1] = 0; 1463 res [len + 1] = 0;
1452 1464
1453 /* now check if it's a symlink */ 1465 /* now check if it's a symlink */
1454 linklen = readlink (req->ptr2, tmp1, PATH_MAX); 1466 linklen = readlink (tmpbuf->ptr, tmp1, PATH_MAX);
1455 1467
1456 if (linklen < 0) 1468 if (linklen < 0)
1457 { 1469 {
1458 if (errno != EINVAL) 1470 if (errno != EINVAL)
1459 return; 1471 return -1;
1460 1472
1461 /* it's a normal directory. hopefully */ 1473 /* it's a normal directory. hopefully */
1462 res += len + 1; 1474 res += len + 1;
1463 } 1475 }
1464 else 1476 else
… …
1466 /* yay, it was a symlink - build new path in tmp2 */ 1478 /* yay, it was a symlink - build new path in tmp2 */
1467 int rellen = strlen (rel); 1479 int rellen = strlen (rel);
1468 1480
1469 errno = ENAMETOOLONG; 1481 errno = ENAMETOOLONG;
1470 if (linklen + 1 + rellen >= PATH_MAX) 1482 if (linklen + 1 + rellen >= PATH_MAX)
1471 return; 1483 return -1;
1472 1484
1473 errno = ELOOP; 1485 errno = ELOOP;
1474 if (!--symlinks) 1486 if (!--symlinks)
1475 return; 1487 return -1;
1476 1488
1477 if (*tmp1 == '/') 1489 if (*tmp1 == '/')
1478 res = req->ptr2; /* symlink resolves to an absolute path */ 1490 res = tmpbuf->ptr; /* symlink resolves to an absolute path */
1479 1491
1480 /* we need to be careful, as rel might point into tmp2 already */ 1492 /* we need to be careful, as rel might point into tmp2 already */
1481 memmove (tmp2 + linklen + 1, rel, rellen + 1); 1493 memmove (tmp2 + linklen + 1, rel, rellen + 1);
1482 tmp2 [linklen] = '/'; 1494 tmp2 [linklen] = '/';
1483 memcpy (tmp2, tmp1, linklen); 1495 memcpy (tmp2, tmp1, linklen);
… …
1485 rel = tmp2; 1497 rel = tmp2;
1486 } 1498 }
1487 } 1499 }
1488 1500
1489 /* special case for the lone root path */ 1501 /* special case for the lone root path */
1490 if (res == req->ptr2) 1502 if (res == tmpbuf->ptr)
1491 *res++ = '/'; 1503 *res++ = '/';
1492 1504
1493 req->result = res - (char *)req->ptr2; 1505 return res - (char *)tmpbuf->ptr;
1494
1495done:
1496 req->ptr2 = realloc (req->ptr2, req->result); /* trade time for space savings */
1497} 1506}
1498 1507
1499static signed char 1508static signed char
1500eio_dent_cmp (const eio_dirent *a, const eio_dirent *b) 1509eio_dent_cmp (const eio_dirent *a, const eio_dirent *b)
1501{ 1510{
… …
1689#ifdef _WIN32 1698#ifdef _WIN32
1690 { 1699 {
1691 int len = strlen ((const char *)req->ptr1); 1700 int len = strlen ((const char *)req->ptr1);
1692 char *path = malloc (MAX_PATH); 1701 char *path = malloc (MAX_PATH);
1693 const char *fmt; 1702 const char *fmt;
1703 const char *reqpath = wd_expand (&self->tmpbuf, req->wd, req->ptr1);
1694 1704
1695 if (!len) 1705 if (!len)
1696 fmt = "./*"; 1706 fmt = "./*";
1697 else if (((const char *)req->ptr1)[len - 1] == '/' || ((const char *)req->ptr1)[len - 1] == '\\') 1707 else if (reqpath[len - 1] == '/' || reqpath[len - 1] == '\\')
1698 fmt = "%s*"; 1708 fmt = "%s*";
1699 else 1709 else
1700 fmt = "%s/*"; 1710 fmt = "%s/*";
1701 1711
1702 _snprintf (path, MAX_PATH, fmt, (const char *)req->ptr1); 1712 _snprintf (path, MAX_PATH, fmt, reqpath);
1703 dirp = FindFirstFile (path, &entp); 1713 dirp = FindFirstFile (path, &entp);
1704 free (path); 1714 free (path);
1705 1715
1706 if (dirp == INVALID_HANDLE_VALUE) 1716 if (dirp == INVALID_HANDLE_VALUE)
1707 { 1717 {
1708 dirp = 0;
1709
1710 /* should steal _dosmaperr */ 1718 /* should steal _dosmaperr */
1711 switch (GetLastError ()) 1719 switch (GetLastError ())
1712 { 1720 {
1713 case ERROR_FILE_NOT_FOUND: 1721 case ERROR_FILE_NOT_FOUND:
1714 req->result = 0; 1722 req->result = 0;
1715 break; 1723 break;
1716 1724
1717 case ERROR_INVALID_NAME: 1725 case ERROR_INVALID_NAME:
1718 case ERROR_PATH_NOT_FOUND: 1726 case ERROR_PATH_NOT_FOUND:
1719 case ERROR_NO_MORE_FILES: 1727 case ERROR_NO_MORE_FILES:
1720 errno = ENOENT; 1728 errno = ENOENT;
1721 break; 1729 break;
1722 1730
1723 case ERROR_NOT_ENOUGH_MEMORY: 1731 case ERROR_NOT_ENOUGH_MEMORY:
1724 errno = ENOMEM; 1732 errno = ENOMEM;
1725 break; 1733 break;
1726 1734
1727 default: 1735 default:
1728 errno = EINVAL; 1736 errno = EINVAL;
1729 break; 1737 break;
1730 } 1738 }
1739
1740 return;
1731 } 1741 }
1732 } 1742 }
1733#else 1743#else
1744 #if HAVE_AT
1745 if (req->wd)
1746 {
1747 int fd = openat (WD2FD (req->wd), req->ptr1, O_CLOEXEC | O_SEARCH | O_DIRECTORY);
1748
1749 if (fd < 0)
1750 return;
1751
1752 dirp = fdopendir (fd);
1753
1754 if (!dirp)
1755 close (fd);
1756 }
1757 else
1734 dirp = opendir (req->ptr1); 1758 dirp = opendir (req->ptr1);
1759 #else
1760 dirp = opendir (wd_expand (&self->tmpbuf, req->wd, req->ptr1));
1761 #endif
1762
1763 if (!dirp)
1764 return;
1735#endif 1765#endif
1736 1766
1737 if (req->flags & EIO_FLAG_PTR1_FREE) 1767 if (req->flags & EIO_FLAG_PTR1_FREE)
1738 free (req->ptr1); 1768 free (req->ptr1);
1739 1769
1740 req->flags |= EIO_FLAG_PTR1_FREE | EIO_FLAG_PTR2_FREE; 1770 req->flags |= EIO_FLAG_PTR1_FREE | EIO_FLAG_PTR2_FREE;
1741 req->ptr1 = dents = flags ? malloc (dentalloc * sizeof (eio_dirent)) : 0; 1771 req->ptr1 = dents = flags ? malloc (dentalloc * sizeof (eio_dirent)) : 0;
1742 req->ptr2 = names = malloc (namesalloc); 1772 req->ptr2 = names = malloc (namesalloc);
1743 1773
1744 if (dirp && names && (!flags || dents)) 1774 if (!names || (flags && !dents))
1775 return;
1776
1745 for (;;) 1777 for (;;)
1746 { 1778 {
1747 int done; 1779 int done;
1748 1780
1749#ifdef _WIN32 1781#ifdef _WIN32
1750 done = !dirp; 1782 done = !dirp;
1751#else 1783#else
1752 errno = 0; 1784 errno = 0;
1753 entp = readdir (dirp); 1785 entp = readdir (dirp);
1754 done = !entp; 1786 done = !entp;
1755#endif 1787#endif
1756 1788
1757 if (done) 1789 if (done)
1758 { 1790 {
1759#ifndef _WIN32 1791#ifndef _WIN32
1760 int old_errno = errno; 1792 int old_errno = errno;
1761 closedir (dirp); 1793 closedir (dirp);
1762 errno = old_errno; 1794 errno = old_errno;
1763 1795
1764 if (errno) 1796 if (errno)
1765 break; 1797 break;
1766#endif 1798#endif
1767 1799
1768 /* sort etc. */ 1800 /* sort etc. */
1769 req->int1 = flags; 1801 req->int1 = flags;
1770 req->result = dentoffs; 1802 req->result = dentoffs;
1771 1803
1772 if (flags & EIO_READDIR_STAT_ORDER) 1804 if (flags & EIO_READDIR_STAT_ORDER)
1773 eio_dent_sort (dents, dentoffs, flags & EIO_READDIR_DIRS_FIRST ? 7 : 0, inode_bits); 1805 eio_dent_sort (dents, dentoffs, flags & EIO_READDIR_DIRS_FIRST ? 7 : 0, inode_bits);
1774 else if (flags & EIO_READDIR_DIRS_FIRST) 1806 else if (flags & EIO_READDIR_DIRS_FIRST)
1775 if (flags & EIO_READDIR_FOUND_UNKNOWN) 1807 if (flags & EIO_READDIR_FOUND_UNKNOWN)
1776 eio_dent_sort (dents, dentoffs, 7, inode_bits); /* sort by score and inode */ 1808 eio_dent_sort (dents, dentoffs, 7, inode_bits); /* sort by score and inode */
1777 else 1809 else
1810 {
1811 /* in this case, all is known, and we just put dirs first and sort them */
1812 eio_dirent *oth = dents + dentoffs;
1813 eio_dirent *dir = dents;
1814
1815 /* now partition dirs to the front, and non-dirs to the back */
1816 /* by walking from both sides and swapping if necessary */
1817 while (oth > dir)
1818 {
1819 if (dir->type == EIO_DT_DIR)
1820 ++dir;
1821 else if ((--oth)->type == EIO_DT_DIR)
1822 {
1823 eio_dirent tmp = *dir; *dir = *oth; *oth = tmp;
1824
1825 ++dir;
1826 }
1827 }
1828
1829 /* now sort the dirs only (dirs all have the same score) */
1830 eio_dent_sort (dents, dir - dents, 0, inode_bits);
1831 }
1832
1833 break;
1834 }
1835
1836 /* now add the entry to our list(s) */
1837 name = D_NAME (entp);
1838
1839 /* skip . and .. entries */
1840 if (name [0] != '.' || (name [1] && (name [1] != '.' || name [2])))
1841 {
1842 int len = D_NAMLEN (entp) + 1;
1843
1844 while (ecb_expect_false (namesoffs + len > namesalloc))
1845 {
1846 namesalloc *= 2;
1847 req->ptr2 = names = realloc (names, namesalloc);
1848
1849 if (!names)
1850 break;
1851 }
1852
1853 memcpy (names + namesoffs, name, len);
1854
1855 if (dents)
1856 {
1857 struct eio_dirent *ent;
1858
1859 if (ecb_expect_false (dentoffs == dentalloc))
1778 { 1860 {
1779 /* in this case, all is known, and we just put dirs first and sort them */ 1861 dentalloc *= 2;
1862 req->ptr1 = dents = realloc (dents, dentalloc * sizeof (eio_dirent));
1863
1864 if (!dents)
1865 break;
1866 }
1867
1780 eio_dirent *oth = dents + dentoffs; 1868 ent = dents + dentoffs;
1781 eio_dirent *dir = dents;
1782 1869
1783 /* now partition dirs to the front, and non-dirs to the back */ 1870 ent->nameofs = namesoffs; /* rather dirtily we store the offset in the pointer */
1784 /* by walking from both sides and swapping if necessary */ 1871 ent->namelen = len - 1;
1785 while (oth > dir) 1872 ent->inode = D_INO (entp);
1873
1874 inode_bits |= ent->inode;
1875
1876 switch (D_TYPE (entp))
1877 {
1878 default:
1879 ent->type = EIO_DT_UNKNOWN;
1880 flags |= EIO_READDIR_FOUND_UNKNOWN;
1881 break;
1882
1883 #ifdef DT_FIFO
1884 case DT_FIFO: ent->type = EIO_DT_FIFO; break;
1885 #endif
1886 #ifdef DT_CHR
1887 case DT_CHR: ent->type = EIO_DT_CHR; break;
1888 #endif
1889 #ifdef DT_MPC
1890 case DT_MPC: ent->type = EIO_DT_MPC; break;
1891 #endif
1892 #ifdef DT_DIR
1893 case DT_DIR: ent->type = EIO_DT_DIR; break;
1894 #endif
1895 #ifdef DT_NAM
1896 case DT_NAM: ent->type = EIO_DT_NAM; break;
1897 #endif
1898 #ifdef DT_BLK
1899 case DT_BLK: ent->type = EIO_DT_BLK; break;
1900 #endif
1901 #ifdef DT_MPB
1902 case DT_MPB: ent->type = EIO_DT_MPB; break;
1903 #endif
1904 #ifdef DT_REG
1905 case DT_REG: ent->type = EIO_DT_REG; break;
1906 #endif
1907 #ifdef DT_NWK
1908 case DT_NWK: ent->type = EIO_DT_NWK; break;
1909 #endif
1910 #ifdef DT_CMP
1911 case DT_CMP: ent->type = EIO_DT_CMP; break;
1912 #endif
1913 #ifdef DT_LNK
1914 case DT_LNK: ent->type = EIO_DT_LNK; break;
1915 #endif
1916 #ifdef DT_SOCK
1917 case DT_SOCK: ent->type = EIO_DT_SOCK; break;
1918 #endif
1919 #ifdef DT_DOOR
1920 case DT_DOOR: ent->type = EIO_DT_DOOR; break;
1921 #endif
1922 #ifdef DT_WHT
1923 case DT_WHT: ent->type = EIO_DT_WHT; break;
1924 #endif
1925 }
1926
1927 ent->score = 7;
1928
1929 if (flags & EIO_READDIR_DIRS_FIRST)
1930 {
1931 if (ent->type == EIO_DT_UNKNOWN)
1786 { 1932 {
1787 if (dir->type == EIO_DT_DIR) 1933 if (*name == '.') /* leading dots are likely directories, and, in any case, rare */
1788 ++dir; 1934 ent->score = 1;
1789 else if ((--oth)->type == EIO_DT_DIR) 1935 else if (!strchr (name, '.')) /* absence of dots indicate likely dirs */
1790 { 1936 ent->score = len <= 2 ? 4 - len : len <= 4 ? 4 : len <= 7 ? 5 : 6; /* shorter == more likely dir, but avoid too many classes */
1791 eio_dirent tmp = *dir; *dir = *oth; *oth = tmp;
1792
1793 ++dir;
1794 }
1795 } 1937 }
1796 1938 else if (ent->type == EIO_DT_DIR)
1797 /* now sort the dirs only (dirs all have the same score) */ 1939 ent->score = 0;
1798 eio_dent_sort (dents, dir - dents, 0, inode_bits);
1799 } 1940 }
1800
1801 break;
1802 }
1803
1804 /* now add the entry to our list(s) */
1805 name = D_NAME (entp);
1806
1807 /* skip . and .. entries */
1808 if (name [0] != '.' || (name [1] && (name [1] != '.' || name [2])))
1809 {
1810 int len = D_NAMLEN (entp) + 1;
1811
1812 while (ecb_expect_false (namesoffs + len > namesalloc))
1813 {
1814 namesalloc *= 2;
1815 req->ptr2 = names = realloc (names, namesalloc);
1816
1817 if (!names)
1818 break;
1819 } 1941 }
1820 1942
1821 memcpy (names + namesoffs, name, len);
1822
1823 if (dents)
1824 {
1825 struct eio_dirent *ent;
1826
1827 if (ecb_expect_false (dentoffs == dentalloc))
1828 {
1829 dentalloc *= 2;
1830 req->ptr1 = dents = realloc (dents, dentalloc * sizeof (eio_dirent));
1831
1832 if (!dents)
1833 break;
1834 }
1835
1836 ent = dents + dentoffs;
1837
1838 ent->nameofs = namesoffs; /* rather dirtily we store the offset in the pointer */
1839 ent->namelen = len - 1;
1840 ent->inode = D_INO (entp);
1841
1842 inode_bits |= ent->inode;
1843
1844 switch (D_TYPE (entp))
1845 {
1846 default:
1847 ent->type = EIO_DT_UNKNOWN;
1848 flags |= EIO_READDIR_FOUND_UNKNOWN;
1849 break;
1850
1851 #ifdef DT_FIFO
1852 case DT_FIFO: ent->type = EIO_DT_FIFO; break;
1853 #endif
1854 #ifdef DT_CHR
1855 case DT_CHR: ent->type = EIO_DT_CHR; break;
1856 #endif
1857 #ifdef DT_MPC
1858 case DT_MPC: ent->type = EIO_DT_MPC; break;
1859 #endif
1860 #ifdef DT_DIR
1861 case DT_DIR: ent->type = EIO_DT_DIR; break;
1862 #endif
1863 #ifdef DT_NAM
1864 case DT_NAM: ent->type = EIO_DT_NAM; break;
1865 #endif
1866 #ifdef DT_BLK
1867 case DT_BLK: ent->type = EIO_DT_BLK; break;
1868 #endif
1869 #ifdef DT_MPB
1870 case DT_MPB: ent->type = EIO_DT_MPB; break;
1871 #endif
1872 #ifdef DT_REG
1873 case DT_REG: ent->type = EIO_DT_REG; break;
1874 #endif
1875 #ifdef DT_NWK
1876 case DT_NWK: ent->type = EIO_DT_NWK; break;
1877 #endif
1878 #ifdef DT_CMP
1879 case DT_CMP: ent->type = EIO_DT_CMP; break;
1880 #endif
1881 #ifdef DT_LNK
1882 case DT_LNK: ent->type = EIO_DT_LNK; break;
1883 #endif
1884 #ifdef DT_SOCK
1885 case DT_SOCK: ent->type = EIO_DT_SOCK; break;
1886 #endif
1887 #ifdef DT_DOOR
1888 case DT_DOOR: ent->type = EIO_DT_DOOR; break;
1889 #endif
1890 #ifdef DT_WHT
1891 case DT_WHT: ent->type = EIO_DT_WHT; break;
1892 #endif
1893 }
1894
1895 ent->score = 7;
1896
1897 if (flags & EIO_READDIR_DIRS_FIRST)
1898 {
1899 if (ent->type == EIO_DT_UNKNOWN)
1900 {
1901 if (*name == '.') /* leading dots are likely directories, and, in any case, rare */
1902 ent->score = 1;
1903 else if (!strchr (name, '.')) /* absense of dots indicate likely dirs */
1904 ent->score = len <= 2 ? 4 - len : len <= 4 ? 4 : len <= 7 ? 5 : 6; /* shorter == more likely dir, but avoid too many classes */
1905 }
1906 else if (ent->type == EIO_DT_DIR)
1907 ent->score = 0;
1908 }
1909 }
1910
1911 namesoffs += len; 1943 namesoffs += len;
1912 ++dentoffs; 1944 ++dentoffs;
1913 } 1945 }
1914 1946
1915 if (EIO_CANCELLED (req)) 1947 if (EIO_CANCELLED (req))
1916 { 1948 {
1917 errno = ECANCELED; 1949 errno = ECANCELED;
1918 break; 1950 break;
1919 } 1951 }
1920 1952
1921#ifdef _WIN32 1953#ifdef _WIN32
1922 if (!FindNextFile (dirp, &entp)) 1954 if (!FindNextFile (dirp, &entp))
1923 { 1955 {
1924 FindClose (dirp); 1956 FindClose (dirp);
1925 dirp = 0; 1957 dirp = 0;
1926 } 1958 }
1927#endif 1959#endif
1928 } 1960 }
1929} 1961}
1962
1963/*****************************************************************************/
1964/* working directory stuff */
1965/* various deficiencies in the posix 2008 api force us to */
1966/* keep the absolute path in string form at all times */
1967/* fuck yeah. */
1968
1969#if !HAVE_AT
1970
1971/* a bit like realpath, but usually faster because it doesn'T have to return */
1972/* an absolute or canonical path */
1973static const char *
1974wd_expand (struct tmpbuf *tmpbuf, eio_wd wd, const char *path)
1975{
1976 if (!wd || *path == '/')
1977 return path;
1978
1979 if (path [0] == '.' && !path [1])
1980 return wd->str;
1981
1982 {
1983 int l1 = wd->len;
1984 int l2 = strlen (path);
1985
1986 char *res = tmpbuf_get (tmpbuf, l1 + l2 + 2);
1987
1988 memcpy (res, wd->str, l1);
1989 res [l1] = '/';
1990 memcpy (res + l1 + 1, path, l2 + 1);
1991
1992 return res;
1993 }
1994}
1995
1996#endif
1997
1998static eio_wd
1999eio__wd_open_sync (struct tmpbuf *tmpbuf, eio_wd wd, const char *path)
2000{
2001 int fd;
2002 eio_wd res;
2003 int len = eio__realpath (tmpbuf, wd, path);
2004
2005 if (len < 0)
2006 return EIO_INVALID_WD;
2007
2008#if HAVE_AT
2009 fd = openat (WD2FD (wd), path, O_CLOEXEC | O_SEARCH | O_DIRECTORY);
2010
2011 if (fd < 0)
2012 return EIO_INVALID_WD;
2013#endif
2014
2015 res = malloc (sizeof (*res) + len); /* one extra 0-byte */
2016
2017#if HAVE_AT
2018 res->fd = fd;
2019#endif
2020
2021 res->len = len;
2022 memcpy (res->str, tmpbuf->ptr, len);
2023 res->str [len] = 0;
2024
2025 return res;
2026}
2027
2028eio_wd
2029eio_wd_open_sync (eio_wd wd, const char *path)
2030{
2031 struct tmpbuf tmpbuf = { 0 };
2032 wd = eio__wd_open_sync (&tmpbuf, wd, path);
2033 free (tmpbuf.ptr);
2034
2035 return wd;
2036}
2037
2038void
2039eio_wd_close_sync (eio_wd wd)
2040{
2041 if (wd != EIO_INVALID_WD && wd != EIO_CWD)
2042 {
2043 #if HAVE_AT
2044 close (wd->fd);
2045 #endif
2046 free (wd);
2047 }
2048}
2049
2050#if HAVE_AT
2051
2052/* they forgot these */
2053
2054static int
2055eio__truncateat (int dirfd, const char *path, off_t length)
2056{
2057 int fd = openat (dirfd, path, O_WRONLY | O_CLOEXEC);
2058 int res;
2059
2060 if (fd < 0)
2061 return fd;
2062
2063 res = ftruncate (fd, length);
2064 close (fd);
2065 return res;
2066}
2067
2068static int
2069eio__statvfsat (int dirfd, const char *path, struct statvfs *buf)
2070{
2071 int fd = openat (dirfd, path, O_SEARCH | O_CLOEXEC);
2072 int res;
2073
2074 if (fd < 0)
2075 return fd;
2076
2077 res = fstatvfs (fd, buf);
2078 close (fd);
2079 return res;
2080
2081}
2082
2083#endif
1930 2084
1931/*****************************************************************************/ 2085/*****************************************************************************/
1932 2086
1933#define ALLOC(len) \ 2087#define ALLOC(len) \
1934 if (!req->ptr2) \ 2088 if (!req->ptr2) \
… …
1943 req->result = -1; \ 2097 req->result = -1; \
1944 break; \ 2098 break; \
1945 } \ 2099 } \
1946 } 2100 }
1947 2101
2102static void ecb_noinline ecb_cold
2103etp_proc_init (void)
2104{
2105#if HAVE_PRCTL_SET_NAME
2106 /* provide a more sensible "thread name" */
2107 char name[16 + 1];
2108 const int namelen = sizeof (name) - 1;
2109 int len;
2110
2111 prctl (PR_GET_NAME, (unsigned long)name, 0, 0, 0);
2112 name [namelen] = 0;
2113 len = strlen (name);
2114 strcpy (name + (len <= namelen - 4 ? len : namelen - 4), "/eio");
2115 prctl (PR_SET_NAME, (unsigned long)name, 0, 0, 0);
2116#endif
2117}
2118
1948X_THREAD_PROC (etp_proc) 2119X_THREAD_PROC (etp_proc)
1949{ 2120{
1950 ETP_REQ *req; 2121 ETP_REQ *req;
1951 struct timespec ts; 2122 struct timespec ts;
1952 etp_worker *self = (etp_worker *)thr_arg; 2123 etp_worker *self = (etp_worker *)thr_arg;
1953 2124
1954#if HAVE_PRCTL_SET_NAME 2125 etp_proc_init ();
1955 prctl (PR_SET_NAME, (unsigned long)"eio_thread", 0, 0, 0);
1956#endif
1957 2126
1958 /* try to distribute timeouts somewhat evenly */ 2127 /* try to distribute timeouts somewhat evenly */
1959 ts.tv_nsec = ((unsigned long)self & 1023UL) * (1000000000UL / 1024UL); 2128 ts.tv_nsec = ((unsigned long)self & 1023UL) * (1000000000UL / 1024UL);
1960 2129
1961 for (;;) 2130 for (;;)
… …
1964 2133
1965 X_LOCK (reqlock); 2134 X_LOCK (reqlock);
1966 2135
1967 for (;;) 2136 for (;;)
1968 { 2137 {
1969 self->req = req = reqq_shift (&req_queue); 2138 req = reqq_shift (&req_queue);
1970 2139
1971 if (req) 2140 if (req)
1972 break; 2141 break;
1973 2142
1974 if (ts.tv_sec == 1) /* no request, but timeout detected, let's quit */ 2143 if (ts.tv_sec == 1) /* no request, but timeout detected, let's quit */
… …
2012 ++npending; 2181 ++npending;
2013 2182
2014 if (!reqq_push (&res_queue, req) && want_poll_cb) 2183 if (!reqq_push (&res_queue, req) && want_poll_cb)
2015 want_poll_cb (); 2184 want_poll_cb ();
2016 2185
2017 self->req = 0;
2018 etp_worker_clear (self); 2186 etp_worker_clear (self);
2019 2187
2020 X_UNLOCK (reslock); 2188 X_UNLOCK (reslock);
2021 } 2189 }
2022 2190
2023quit: 2191quit:
2192 free (req);
2193
2024 X_LOCK (wrklock); 2194 X_LOCK (wrklock);
2025 etp_worker_free (self); 2195 etp_worker_free (self);
2026 X_UNLOCK (wrklock); 2196 X_UNLOCK (wrklock);
2027
2028 return 0;
2029} 2197}
2030 2198
2031/*****************************************************************************/ 2199/*****************************************************************************/
2032 2200
2033int ecb_cold 2201int ecb_cold
2034eio_init (void (*want_poll)(void), void (*done_poll)(void)) 2202eio_init (void (*want_poll)(void), void (*done_poll)(void))
2035{ 2203{
2036#if !HAVE_PREADWRITE
2037 X_MUTEX_CREATE (preadwritelock);
2038#endif
2039
2040 return etp_init (want_poll, done_poll); 2204 return etp_init (want_poll, done_poll);
2041} 2205}
2042 2206
2043ecb_inline void 2207ecb_inline void
2044eio_api_destroy (eio_req *req) 2208eio_api_destroy (eio_req *req)
2045{ 2209{
2046 free (req); 2210 free (req);
2047} 2211}
2048 2212
2049#define REQ(rtype) \ 2213#define REQ(rtype) \
2050 eio_req *req; \ 2214 eio_req *req; \
2051 \ 2215 \
2052 req = (eio_req *)calloc (1, sizeof *req); \ 2216 req = (eio_req *)calloc (1, sizeof *req); \
2053 if (!req) \ 2217 if (!req) \
2054 return 0; \ 2218 return 0; \
… …
2071 } 2235 }
2072 2236
2073static void 2237static void
2074eio_execute (etp_worker *self, eio_req *req) 2238eio_execute (etp_worker *self, eio_req *req)
2075{ 2239{
2240#if HAVE_AT
2241 int dirfd;
2242#else
2243 const char *path;
2244#endif
2245
2076 if (ecb_expect_false (EIO_CANCELLED (req))) 2246 if (ecb_expect_false (EIO_CANCELLED (req)))
2077 { 2247 {
2078 req->result = -1; 2248 req->result = -1;
2079 req->errorno = ECANCELED; 2249 req->errorno = ECANCELED;
2080 return; 2250 return;
2081 } 2251 }
2082 2252
2253 if (ecb_expect_false (req->wd == EIO_INVALID_WD))
2254 {
2255 req->result = -1;
2256 req->errorno = ENOENT;
2257 return;
2258 }
2259
2260 if (req->type >= EIO_OPEN)
2261 {
2262 #if HAVE_AT
2263 dirfd = WD2FD (req->wd);
2264 #else
2265 path = wd_expand (&self->tmpbuf, req->wd, req->ptr1);
2266 #endif
2267 }
2268
2083 switch (req->type) 2269 switch (req->type)
2084 { 2270 {
2271 case EIO_WD_OPEN: req->wd = eio__wd_open_sync (&self->tmpbuf, req->wd, req->ptr1);
2272 req->result = req->wd == EIO_INVALID_WD ? -1 : 0;
2273 break;
2274 case EIO_WD_CLOSE: req->result = 0;
2275 eio_wd_close_sync (req->wd); break;
2276
2277 case EIO_SEEK: eio__lseek (req); break;
2085 case EIO_READ: ALLOC (req->size); 2278 case EIO_READ: ALLOC (req->size);
2086 req->result = req->offs >= 0 2279 req->result = req->offs >= 0
2087 ? pread (req->int1, req->ptr2, req->size, req->offs) 2280 ? pread (req->int1, req->ptr2, req->size, req->offs)
2088 : read (req->int1, req->ptr2, req->size); break; 2281 : read (req->int1, req->ptr2, req->size); break;
2089 case EIO_WRITE: req->result = req->offs >= 0 2282 case EIO_WRITE: req->result = req->offs >= 0
… …
2091 : write (req->int1, req->ptr2, req->size); break; 2284 : write (req->int1, req->ptr2, req->size); break;
2092 2285
2093 case EIO_READAHEAD: req->result = readahead (req->int1, req->offs, req->size); break; 2286 case EIO_READAHEAD: req->result = readahead (req->int1, req->offs, req->size); break;
2094 case EIO_SENDFILE: req->result = eio__sendfile (req->int1, req->int2, req->offs, req->size); break; 2287 case EIO_SENDFILE: req->result = eio__sendfile (req->int1, req->int2, req->offs, req->size); break;
2095 2288
2289#if HAVE_AT
2290
2096 case EIO_STAT: ALLOC (sizeof (EIO_STRUCT_STAT)); 2291 case EIO_STAT: ALLOC (sizeof (EIO_STRUCT_STAT));
2097 req->result = stat (req->ptr1, (EIO_STRUCT_STAT *)req->ptr2); break; 2292 req->result = fstatat (dirfd, req->ptr1, (EIO_STRUCT_STAT *)req->ptr2, 0); break;
2098 case EIO_LSTAT: ALLOC (sizeof (EIO_STRUCT_STAT)); 2293 case EIO_LSTAT: ALLOC (sizeof (EIO_STRUCT_STAT));
2294 req->result = fstatat (dirfd, req->ptr1, (EIO_STRUCT_STAT *)req->ptr2, AT_SYMLINK_NOFOLLOW); break;
2295 case EIO_CHOWN: req->result = fchownat (dirfd, req->ptr1, req->int2, req->int3, 0); break;
2296 case EIO_CHMOD: req->result = fchmodat (dirfd, req->ptr1, (mode_t)req->int2, 0); break;
2297 case EIO_TRUNCATE: req->result = eio__truncateat (dirfd, req->ptr1, req->offs); break;
2298 case EIO_OPEN: req->result = openat (dirfd, req->ptr1, req->int1, (mode_t)req->int2); break;
2299
2300 case EIO_UNLINK: req->result = unlinkat (dirfd, req->ptr1, 0); break;
2301 case EIO_RMDIR: req->result = unlinkat (dirfd, req->ptr1, AT_REMOVEDIR); break;
2302 case EIO_MKDIR: req->result = mkdirat (dirfd, req->ptr1, (mode_t)req->int2); break;
2303 case EIO_RENAME: req->result = renameat (dirfd, req->ptr1, WD2FD ((eio_wd)req->int3), req->ptr2); break;
2304 case EIO_LINK: req->result = linkat (dirfd, req->ptr1, WD2FD ((eio_wd)req->int3), req->ptr2, 0); break;
2305 case EIO_SYMLINK: req->result = symlinkat (req->ptr1, dirfd, req->ptr2); break;
2306 case EIO_MKNOD: req->result = mknodat (dirfd, req->ptr1, (mode_t)req->int2, (dev_t)req->offs); break;
2307 case EIO_READLINK: ALLOC (PATH_MAX);
2308 req->result = readlinkat (dirfd, req->ptr1, req->ptr2, PATH_MAX); break;
2309 case EIO_STATVFS: ALLOC (sizeof (EIO_STRUCT_STATVFS));
2310 req->result = eio__statvfsat (dirfd, req->ptr1, (EIO_STRUCT_STATVFS *)req->ptr2); break;
2311 case EIO_UTIME:
2312 case EIO_FUTIME:
2313 {
2314 struct timespec ts[2];
2315 struct timespec *times;
2316
2317 if (req->nv1 != -1. || req->nv2 != -1.)
2318 {
2319 ts[0].tv_sec = req->nv1;
2320 ts[0].tv_nsec = (req->nv1 - ts[0].tv_sec) * 1e9;
2321 ts[1].tv_sec = req->nv2;
2322 ts[1].tv_nsec = (req->nv2 - ts[1].tv_sec) * 1e9;
2323
2324 times = ts;
2325 }
2326 else
2327 times = 0;
2328
2329 req->result = req->type == EIO_FUTIME
2330 ? futimens (req->int1, times)
2331 : utimensat (dirfd, req->ptr1, times, 0);
2332 }
2333 break;
2334
2335#else
2336
2337 case EIO_STAT: ALLOC (sizeof (EIO_STRUCT_STAT));
2338 req->result = stat (path , (EIO_STRUCT_STAT *)req->ptr2); break;
2339 case EIO_LSTAT: ALLOC (sizeof (EIO_STRUCT_STAT));
2099 req->result = lstat (req->ptr1, (EIO_STRUCT_STAT *)req->ptr2); break; 2340 req->result = lstat (path , (EIO_STRUCT_STAT *)req->ptr2); break;
2341 case EIO_CHOWN: req->result = chown (path , req->int2, req->int3); break;
2342 case EIO_CHMOD: req->result = chmod (path , (mode_t)req->int2); break;
2343 case EIO_TRUNCATE: req->result = truncate (path , req->offs); break;
2344 case EIO_OPEN: req->result = open (path , req->int1, (mode_t)req->int2); break;
2345
2346 case EIO_UNLINK: req->result = unlink (path ); break;
2347 case EIO_RMDIR: req->result = rmdir (path ); break;
2348 case EIO_MKDIR: req->result = mkdir (path , (mode_t)req->int2); break;
2349 case EIO_RENAME: req->result = rename (path , req->ptr2); break;
2350 case EIO_LINK: req->result = link (path , req->ptr2); break;
2351 case EIO_SYMLINK: req->result = symlink (path , req->ptr2); break;
2352 case EIO_MKNOD: req->result = mknod (path , (mode_t)req->int2, (dev_t)req->offs); break;
2353 case EIO_READLINK: ALLOC (PATH_MAX);
2354 req->result = readlink (path, req->ptr2, PATH_MAX); break;
2355 case EIO_STATVFS: ALLOC (sizeof (EIO_STRUCT_STATVFS));
2356 req->result = statvfs (path , (EIO_STRUCT_STATVFS *)req->ptr2); break;
2357
2358 case EIO_UTIME:
2359 case EIO_FUTIME:
2360 {
2361 struct timeval tv[2];
2362 struct timeval *times;
2363
2364 if (req->nv1 != -1. || req->nv2 != -1.)
2365 {
2366 tv[0].tv_sec = req->nv1;
2367 tv[0].tv_usec = (req->nv1 - tv[0].tv_sec) * 1e6;
2368 tv[1].tv_sec = req->nv2;
2369 tv[1].tv_usec = (req->nv2 - tv[1].tv_sec) * 1e6;
2370
2371 times = tv;
2372 }
2373 else
2374 times = 0;
2375
2376 req->result = req->type == EIO_FUTIME
2377 ? futimes (req->int1, times)
2378 : utimes (req->ptr1, times);
2379 }
2380 break;
2381
2382#endif
2383
2384 case EIO_REALPATH: if (0 <= (req->result = eio__realpath (&self->tmpbuf, req->wd, req->ptr1)))
2385 {
2386 ALLOC (req->result);
2387 memcpy (req->ptr2, self->tmpbuf.ptr, req->result);
2388 }
2389 break;
2390
2100 case EIO_FSTAT: ALLOC (sizeof (EIO_STRUCT_STAT)); 2391 case EIO_FSTAT: ALLOC (sizeof (EIO_STRUCT_STAT));
2101 req->result = fstat (req->int1, (EIO_STRUCT_STAT *)req->ptr2); break; 2392 req->result = fstat (req->int1, (EIO_STRUCT_STAT *)req->ptr2); break;
2102 2393
2103 case EIO_STATVFS: ALLOC (sizeof (EIO_STRUCT_STATVFS));
2104 req->result = statvfs (req->ptr1, (EIO_STRUCT_STATVFS *)req->ptr2); break;
2105 case EIO_FSTATVFS: ALLOC (sizeof (EIO_STRUCT_STATVFS)); 2394 case EIO_FSTATVFS: ALLOC (sizeof (EIO_STRUCT_STATVFS));
2106 req->result = fstatvfs (req->int1, (EIO_STRUCT_STATVFS *)req->ptr2); break; 2395 req->result = fstatvfs (req->int1, (EIO_STRUCT_STATVFS *)req->ptr2); break;
2107 2396
2108 case EIO_CHOWN: req->result = chown (req->ptr1, req->int2, req->int3); break;
2109 case EIO_FCHOWN: req->result = fchown (req->int1, req->int2, req->int3); break; 2397 case EIO_FCHOWN: req->result = fchown (req->int1, req->int2, req->int3); break;
2110 case EIO_CHMOD: req->result = chmod (req->ptr1, (mode_t)req->int2); break;
2111 case EIO_FCHMOD: req->result = fchmod (req->int1, (mode_t)req->int2); break; 2398 case EIO_FCHMOD: req->result = fchmod (req->int1, (mode_t)req->int2); break;
2112 case EIO_TRUNCATE: req->result = truncate (req->ptr1, req->offs); break;
2113 case EIO_FTRUNCATE: req->result = ftruncate (req->int1, req->offs); break; 2399 case EIO_FTRUNCATE: req->result = ftruncate (req->int1, req->offs); break;
2114 2400
2115 case EIO_OPEN: req->result = open (req->ptr1, req->int1, (mode_t)req->int2); break;
2116 case EIO_CLOSE: req->result = close (req->int1); break; 2401 case EIO_CLOSE: req->result = close (req->int1); break;
2117 case EIO_DUP2: req->result = dup2 (req->int1, req->int2); break; 2402 case EIO_DUP2: req->result = dup2 (req->int1, req->int2); break;
2118 case EIO_UNLINK: req->result = unlink (req->ptr1); break;
2119 case EIO_RMDIR: req->result = rmdir (req->ptr1); break;
2120 case EIO_MKDIR: req->result = mkdir (req->ptr1, (mode_t)req->int2); break;
2121 case EIO_RENAME: req->result = rename (req->ptr1, req->ptr2); break;
2122 case EIO_LINK: req->result = link (req->ptr1, req->ptr2); break;
2123 case EIO_SYMLINK: req->result = symlink (req->ptr1, req->ptr2); break;
2124 case EIO_MKNOD: req->result = mknod (req->ptr1, (mode_t)req->int2, (dev_t)req->offs); break;
2125
2126 case EIO_REALPATH: eio__realpath (req, self); break;
2127
2128 case EIO_READLINK: ALLOC (PATH_MAX);
2129 req->result = readlink (req->ptr1, req->ptr2, PATH_MAX); break;
2130
2131 case EIO_SYNC: req->result = 0; sync (); break; 2403 case EIO_SYNC: req->result = 0; sync (); break;
2132 case EIO_FSYNC: req->result = fsync (req->int1); break; 2404 case EIO_FSYNC: req->result = fsync (req->int1); break;
2133 case EIO_FDATASYNC: req->result = fdatasync (req->int1); break; 2405 case EIO_FDATASYNC: req->result = fdatasync (req->int1); break;
2134 case EIO_SYNCFS: req->result = eio__syncfs (req->int1); break; 2406 case EIO_SYNCFS: req->result = eio__syncfs (req->int1); break;
2135 case EIO_SYNC_FILE_RANGE: req->result = eio__sync_file_range (req->int1, req->offs, req->size, req->int2); break; 2407 case EIO_SYNC_FILE_RANGE: req->result = eio__sync_file_range (req->int1, req->offs, req->size, req->int2); break;
… …
2154 req->result = select (0, 0, 0, 0, &tv); 2426 req->result = select (0, 0, 0, 0, &tv);
2155 } 2427 }
2156#endif 2428#endif
2157 break; 2429 break;
2158 2430
2159 case EIO_UTIME:
2160 case EIO_FUTIME:
2161 {
2162 struct timeval tv[2];
2163 struct timeval *times;
2164
2165 if (req->nv1 != -1. || req->nv2 != -1.)
2166 {
2167 tv[0].tv_sec = req->nv1;
2168 tv[0].tv_usec = (req->nv1 - tv[0].tv_sec) * 1000000.;
2169 tv[1].tv_sec = req->nv2;
2170 tv[1].tv_usec = (req->nv2 - tv[1].tv_sec) * 1000000.;
2171
2172 times = tv;
2173 }
2174 else
2175 times = 0;
2176
2177 req->result = req->type == EIO_FUTIME
2178 ? futimes (req->int1, times)
2179 : utimes (req->ptr1, times);
2180 }
2181 break;
2182
2183 case EIO_GROUP: 2431 case EIO_GROUP:
2184 abort (); /* handled in eio_request */ 2432 abort (); /* handled in eio_request */
2185 2433
2186 case EIO_NOP: 2434 case EIO_NOP:
2187 req->result = 0; 2435 req->result = 0;
… …
2190 case EIO_CUSTOM: 2438 case EIO_CUSTOM:
2191 req->feed (req); 2439 req->feed (req);
2192 break; 2440 break;
2193 2441
2194 default: 2442 default:
2195 errno = ENOSYS;
2196 req->result = -1; 2443 req->result = EIO_ENOSYS ();
2197 break; 2444 break;
2198 } 2445 }
2199 2446
2200 req->errorno = errno; 2447 req->errorno = errno;
2201} 2448}
2202 2449
2203#ifndef EIO_NO_WRAPPERS 2450#ifndef EIO_NO_WRAPPERS
2204 2451
2452eio_req *eio_wd_open (const char *path, int pri, eio_cb cb, void *data)
2453{
2454 REQ (EIO_WD_OPEN); PATH; SEND;
2455}
2456
2457eio_req *eio_wd_close (eio_wd wd, int pri, eio_cb cb, void *data)
2458{
2459 REQ (EIO_WD_CLOSE); req->wd = wd; SEND;
2460}
2461
2205eio_req *eio_nop (int pri, eio_cb cb, void *data) 2462eio_req *eio_nop (int pri, eio_cb cb, void *data)
2206{ 2463{
2207 REQ (EIO_NOP); SEND; 2464 REQ (EIO_NOP); SEND;
2208} 2465}
2209 2466
… …
2268} 2525}
2269 2526
2270eio_req *eio_readahead (int fd, off_t offset, size_t length, int pri, eio_cb cb, void *data) 2527eio_req *eio_readahead (int fd, off_t offset, size_t length, int pri, eio_cb cb, void *data)
2271{ 2528{
2272 REQ (EIO_READAHEAD); req->int1 = fd; req->offs = offset; req->size = length; SEND; 2529 REQ (EIO_READAHEAD); req->int1 = fd; req->offs = offset; req->size = length; SEND;
2530}
2531
2532eio_req *eio_seek (int fd, off_t offset, int whence, int pri, eio_cb cb, void *data)
2533{
2534 REQ (EIO_SEEK); req->int1 = fd; req->offs = offset; req->int2 = whence; SEND;
2273} 2535}
2274 2536
2275eio_req *eio_read (int fd, void *buf, size_t length, off_t offset, int pri, eio_cb cb, void *data) 2537eio_req *eio_read (int fd, void *buf, size_t length, off_t offset, int pri, eio_cb cb, void *data)
2276{ 2538{
2277 REQ (EIO_READ); req->int1 = fd; req->offs = offset; req->size = length; req->ptr2 = buf; SEND; 2539 REQ (EIO_READ); req->int1 = fd; req->offs = offset; req->size = length; req->ptr2 = buf; SEND;

Diff Legend

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