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

Comparing cvsroot/libeio/eio.c (file contents):
Revision 1.103 by root, Thu Sep 15 13:20:54 2011 UTC vs.
Revision 1.114 by root, Fri Dec 30 07:38:00 2011 UTC

… …
292#define FUBd \ 292#define FUBd \
293 free (eio_buf) 293 free (eio_buf)
294 294
295#define EIO_TICKS ((1000000 + 1023) >> 10) 295#define EIO_TICKS ((1000000 + 1023) >> 10)
296 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
297#define ETP_PRI_MIN EIO_PRI_MIN 341#define ETP_PRI_MIN EIO_PRI_MIN
298#define ETP_PRI_MAX EIO_PRI_MAX 342#define ETP_PRI_MAX EIO_PRI_MAX
299 343
300struct etp_worker; 344struct etp_worker;
301 345
… …
346static xmutex_t preadwritelock; 390static xmutex_t preadwritelock;
347#endif 391#endif
348 392
349typedef struct etp_worker 393typedef struct etp_worker
350{ 394{
395 struct tmpbuf tmpbuf;
396
351 /* locked by wrklock */ 397 /* locked by wrklock */
352 struct etp_worker *prev, *next; 398 struct etp_worker *prev, *next;
353 399
354 xthread_t tid; 400 xthread_t tid;
355 401
356 /* locked by reslock, reqlock or wrklock */
357 ETP_REQ *req; /* currently processed request */
358
359#ifdef ETP_WORKER_COMMON 402#ifdef ETP_WORKER_COMMON
360 ETP_WORKER_COMMON 403 ETP_WORKER_COMMON
361#endif 404#endif
362} etp_worker; 405} etp_worker;
363 406
… …
366#define ETP_WORKER_LOCK(wrk) X_LOCK (wrklock) 409#define ETP_WORKER_LOCK(wrk) X_LOCK (wrklock)
367#define ETP_WORKER_UNLOCK(wrk) X_UNLOCK (wrklock) 410#define ETP_WORKER_UNLOCK(wrk) X_UNLOCK (wrklock)
368 411
369/* worker threads management */ 412/* worker threads management */
370 413
371static void ecb_cold 414static void
372etp_worker_clear (etp_worker *wrk) 415etp_worker_clear (etp_worker *wrk)
373{ 416{
374} 417}
375 418
376static void ecb_cold 419static void ecb_cold
377etp_worker_free (etp_worker *wrk) 420etp_worker_free (etp_worker *wrk)
378{ 421{
422 free (wrk->tmpbuf.ptr);
423
379 wrk->next->prev = wrk->prev; 424 wrk->next->prev = wrk->prev;
380 wrk->prev->next = wrk->next; 425 wrk->prev->next = wrk->next;
381 426
382 free (wrk); 427 free (wrk);
383} 428}
… …
561} 606}
562 607
563static void ecb_cold 608static void ecb_cold
564etp_end_thread (void) 609etp_end_thread (void)
565{ 610{
566 eio_req *req = calloc (1, sizeof (eio_req)); 611 eio_req *req = calloc (1, sizeof (eio_req)); /* will be freed by worker */
567 612
568 req->type = -1; 613 req->type = -1;
569 req->pri = ETP_PRI_MAX - ETP_PRI_MIN; 614 req->pri = ETP_PRI_MAX - ETP_PRI_MIN;
570 615
571 X_LOCK (reqlock); 616 X_LOCK (reqlock);
… …
1337} 1382}
1338 1383
1339/*****************************************************************************/ 1384/*****************************************************************************/
1340/* requests implemented outside eio_execute, because they are so large */ 1385/* requests implemented outside eio_execute, because they are so large */
1341 1386
1387/* result will always end up in tmpbuf, there is always space for adding a 0-byte */
1342static void 1388static int
1343eio__realpath (eio_req *req, etp_worker *self) 1389eio__realpath (struct tmpbuf *tmpbuf, eio_wd wd, const char *path)
1344{ 1390{
1345 char *rel = req->ptr1; 1391 const char *rel = path;
1346 char *res; 1392 char *res;
1347 char *tmp1, *tmp2; 1393 char *tmp1, *tmp2;
1348#if SYMLOOP_MAX > 32 1394#if SYMLOOP_MAX > 32
1349 int symlinks = SYMLOOP_MAX; 1395 int symlinks = SYMLOOP_MAX;
1350#else 1396#else
1351 int symlinks = 32; 1397 int symlinks = 32;
1352#endif 1398#endif
1353 1399
1354 req->result = -1;
1355
1356 errno = EINVAL; 1400 errno = EINVAL;
1357 if (!rel) 1401 if (!rel)
1358 return; 1402 return -1;
1359 1403
1360 errno = ENOENT; 1404 errno = ENOENT;
1361 if (!*rel) 1405 if (!*rel)
1362 return; 1406 return -1;
1363 1407
1364 if (!req->ptr2) 1408 res = tmpbuf_get (tmpbuf, PATH_MAX * 3);
1365 {
1366 X_LOCK (wrklock);
1367 req->flags |= EIO_FLAG_PTR2_FREE;
1368 X_UNLOCK (wrklock);
1369 req->ptr2 = malloc (PATH_MAX * 3);
1370
1371 errno = ENOMEM;
1372 if (!req->ptr2)
1373 return;
1374 }
1375
1376 res = req->ptr2;
1377 tmp1 = res + PATH_MAX; 1409 tmp1 = res + PATH_MAX;
1378 tmp2 = tmp1 + PATH_MAX; 1410 tmp2 = tmp1 + PATH_MAX;
1379 1411
1380#if 0 /* disabled, the musl way to do things is just too racy */ 1412#if 0 /* disabled, the musl way to do things is just too racy */
1381#if __linux && defined(O_NONBLOCK) && defined(O_NOATIME) 1413#if __linux && defined(O_NONBLOCK) && defined(O_NOATIME)
… …
1400#endif 1432#endif
1401#endif 1433#endif
1402 1434
1403 if (*rel != '/') 1435 if (*rel != '/')
1404 { 1436 {
1437 int len;
1438
1439 errno = ENOENT;
1440 if (wd == EIO_INVALID_WD)
1441 return -1;
1442
1443 if (wd == EIO_CWD)
1444 {
1405 if (!getcwd (res, PATH_MAX)) 1445 if (!getcwd (res, PATH_MAX))
1406 return; 1446 return -1;
1447
1448 len = strlen (res);
1449 }
1450 else
1451 memcpy (res, wd->str, len = wd->len);
1407 1452
1408 if (res [1]) /* only use if not / */ 1453 if (res [1]) /* only use if not / */
1409 res += strlen (res); 1454 res += len;
1410 } 1455 }
1411 1456
1412 while (*rel) 1457 while (*rel)
1413 { 1458 {
1414 eio_ssize_t len, linklen; 1459 eio_ssize_t len, linklen;
1415 char *beg = rel; 1460 const char *beg = rel;
1416 1461
1417 while (*rel && *rel != '/') 1462 while (*rel && *rel != '/')
1418 ++rel; 1463 ++rel;
1419 1464
1420 len = rel - beg; 1465 len = rel - beg;
… …
1432 1477
1433 if (beg [1] == '.' && len == 2) 1478 if (beg [1] == '.' && len == 2)
1434 { 1479 {
1435 /* .. - back up one component, if possible */ 1480 /* .. - back up one component, if possible */
1436 1481
1437 while (res != req->ptr2) 1482 while (res != tmpbuf->ptr)
1438 if (*--res == '/') 1483 if (*--res == '/')
1439 break; 1484 break;
1440 1485
1441 continue; 1486 continue;
1442 } 1487 }
1443 } 1488 }
1444 1489
1445 errno = ENAMETOOLONG; 1490 errno = ENAMETOOLONG;
1446 if (res + 1 + len + 1 >= tmp1) 1491 if (res + 1 + len + 1 >= tmp1)
1447 return; 1492 return -1;
1448 1493
1449 /* copy one component */ 1494 /* copy one component */
1450 *res = '/'; 1495 *res = '/';
1451 memcpy (res + 1, beg, len); 1496 memcpy (res + 1, beg, len);
1452 1497
1453 /* zero-terminate, for readlink */ 1498 /* zero-terminate, for readlink */
1454 res [len + 1] = 0; 1499 res [len + 1] = 0;
1455 1500
1456 /* now check if it's a symlink */ 1501 /* now check if it's a symlink */
1457 linklen = readlink (req->ptr2, tmp1, PATH_MAX); 1502 linklen = readlink (tmpbuf->ptr, tmp1, PATH_MAX);
1458 1503
1459 if (linklen < 0) 1504 if (linklen < 0)
1460 { 1505 {
1461 if (errno != EINVAL) 1506 if (errno != EINVAL)
1462 return; 1507 return -1;
1463 1508
1464 /* it's a normal directory. hopefully */ 1509 /* it's a normal directory. hopefully */
1465 res += len + 1; 1510 res += len + 1;
1466 } 1511 }
1467 else 1512 else
… …
1469 /* yay, it was a symlink - build new path in tmp2 */ 1514 /* yay, it was a symlink - build new path in tmp2 */
1470 int rellen = strlen (rel); 1515 int rellen = strlen (rel);
1471 1516
1472 errno = ENAMETOOLONG; 1517 errno = ENAMETOOLONG;
1473 if (linklen + 1 + rellen >= PATH_MAX) 1518 if (linklen + 1 + rellen >= PATH_MAX)
1474 return; 1519 return -1;
1475 1520
1476 errno = ELOOP; 1521 errno = ELOOP;
1477 if (!--symlinks) 1522 if (!--symlinks)
1478 return; 1523 return -1;
1479 1524
1480 if (*tmp1 == '/') 1525 if (*tmp1 == '/')
1481 res = req->ptr2; /* symlink resolves to an absolute path */ 1526 res = tmpbuf->ptr; /* symlink resolves to an absolute path */
1482 1527
1483 /* we need to be careful, as rel might point into tmp2 already */ 1528 /* we need to be careful, as rel might point into tmp2 already */
1484 memmove (tmp2 + linklen + 1, rel, rellen + 1); 1529 memmove (tmp2 + linklen + 1, rel, rellen + 1);
1485 tmp2 [linklen] = '/'; 1530 tmp2 [linklen] = '/';
1486 memcpy (tmp2, tmp1, linklen); 1531 memcpy (tmp2, tmp1, linklen);
… …
1488 rel = tmp2; 1533 rel = tmp2;
1489 } 1534 }
1490 } 1535 }
1491 1536
1492 /* special case for the lone root path */ 1537 /* special case for the lone root path */
1493 if (res == req->ptr2) 1538 if (res == tmpbuf->ptr)
1494 *res++ = '/'; 1539 *res++ = '/';
1495 1540
1496 req->result = res - (char *)req->ptr2; 1541 return res - (char *)tmpbuf->ptr;
1497
1498done:
1499 req->ptr2 = realloc (req->ptr2, req->result); /* trade time for space savings */
1500} 1542}
1501 1543
1502static signed char 1544static signed char
1503eio_dent_cmp (const eio_dirent *a, const eio_dirent *b) 1545eio_dent_cmp (const eio_dirent *a, const eio_dirent *b)
1504{ 1546{
… …
1692#ifdef _WIN32 1734#ifdef _WIN32
1693 { 1735 {
1694 int len = strlen ((const char *)req->ptr1); 1736 int len = strlen ((const char *)req->ptr1);
1695 char *path = malloc (MAX_PATH); 1737 char *path = malloc (MAX_PATH);
1696 const char *fmt; 1738 const char *fmt;
1739 const char *reqpath = wd_expand (&self->tmpbuf, req->wd, req->ptr1);
1697 1740
1698 if (!len) 1741 if (!len)
1699 fmt = "./*"; 1742 fmt = "./*";
1700 else if (((const char *)req->ptr1)[len - 1] == '/' || ((const char *)req->ptr1)[len - 1] == '\\') 1743 else if (reqpath[len - 1] == '/' || reqpath[len - 1] == '\\')
1701 fmt = "%s*"; 1744 fmt = "%s*";
1702 else 1745 else
1703 fmt = "%s/*"; 1746 fmt = "%s/*";
1704 1747
1705 _snprintf (path, MAX_PATH, fmt, (const char *)req->ptr1); 1748 _snprintf (path, MAX_PATH, fmt, reqpath);
1706 dirp = FindFirstFile (path, &entp); 1749 dirp = FindFirstFile (path, &entp);
1707 free (path); 1750 free (path);
1708 1751
1709 if (dirp == INVALID_HANDLE_VALUE) 1752 if (dirp == INVALID_HANDLE_VALUE)
1710 { 1753 {
… …
1732 1775
1733 return; 1776 return;
1734 } 1777 }
1735 } 1778 }
1736#else 1779#else
1780 #if HAVE_AT
1781 if (req->wd)
1782 {
1783 int fd = openat (WD2FD (req->wd), req->ptr1, O_CLOEXEC | O_SEARCH | O_DIRECTORY);
1784
1785 if (fd < 0)
1786 return;
1787
1788 dirp = fdopendir (fd);
1789
1790 if (!dirp)
1791 close (fd);
1792 }
1793 else
1737 dirp = opendir (req->ptr1); 1794 dirp = opendir (req->ptr1);
1795 #else
1796 dirp = opendir (wd_expand (&self->tmpbuf, req->wd, req->ptr1));
1797 #endif
1738 1798
1739 if (!dirp) 1799 if (!dirp)
1740 return; 1800 return;
1741#endif 1801#endif
1742 1802
… …
1906 { 1966 {
1907 if (ent->type == EIO_DT_UNKNOWN) 1967 if (ent->type == EIO_DT_UNKNOWN)
1908 { 1968 {
1909 if (*name == '.') /* leading dots are likely directories, and, in any case, rare */ 1969 if (*name == '.') /* leading dots are likely directories, and, in any case, rare */
1910 ent->score = 1; 1970 ent->score = 1;
1911 else if (!strchr (name, '.')) /* absense of dots indicate likely dirs */ 1971 else if (!strchr (name, '.')) /* absence of dots indicate likely dirs */
1912 ent->score = len <= 2 ? 4 - len : len <= 4 ? 4 : len <= 7 ? 5 : 6; /* shorter == more likely dir, but avoid too many classes */ 1972 ent->score = len <= 2 ? 4 - len : len <= 4 ? 4 : len <= 7 ? 5 : 6; /* shorter == more likely dir, but avoid too many classes */
1913 } 1973 }
1914 else if (ent->type == EIO_DT_DIR) 1974 else if (ent->type == EIO_DT_DIR)
1915 ent->score = 0; 1975 ent->score = 0;
1916 } 1976 }
… …
1933 dirp = 0; 1993 dirp = 0;
1934 } 1994 }
1935#endif 1995#endif
1936 } 1996 }
1937} 1997}
1998
1999/*****************************************************************************/
2000/* working directory stuff */
2001/* various deficiencies in the posix 2008 api force us to */
2002/* keep the absolute path in string form at all times */
2003/* fuck yeah. */
2004
2005#if !HAVE_AT
2006
2007/* a bit like realpath, but usually faster because it doesn'T have to return */
2008/* an absolute or canonical path */
2009static const char *
2010wd_expand (struct tmpbuf *tmpbuf, eio_wd wd, const char *path)
2011{
2012 if (!wd || *path == '/')
2013 return path;
2014
2015 if (path [0] == '.' && !path [1])
2016 return wd->str;
2017
2018 {
2019 int l1 = wd->len;
2020 int l2 = strlen (path);
2021
2022 char *res = tmpbuf_get (tmpbuf, l1 + l2 + 2);
2023
2024 memcpy (res, wd->str, l1);
2025 res [l1] = '/';
2026 memcpy (res + l1 + 1, path, l2 + 1);
2027
2028 return res;
2029 }
2030}
2031
2032#endif
2033
2034static eio_wd
2035eio__wd_open_sync (struct tmpbuf *tmpbuf, eio_wd wd, const char *path)
2036{
2037 int fd;
2038 eio_wd res;
2039 int len = eio__realpath (tmpbuf, wd, path);
2040
2041 if (len < 0)
2042 return EIO_INVALID_WD;
2043
2044#if HAVE_AT
2045 fd = openat (WD2FD (wd), path, O_CLOEXEC | O_SEARCH | O_DIRECTORY);
2046
2047 if (fd < 0)
2048 return EIO_INVALID_WD;
2049#endif
2050
2051 res = malloc (sizeof (*res) + len); /* one extra 0-byte */
2052
2053#if HAVE_AT
2054 res->fd = fd;
2055#endif
2056
2057 res->len = len;
2058 memcpy (res->str, tmpbuf->ptr, len);
2059 res->str [len] = 0;
2060
2061 return res;
2062}
2063
2064eio_wd
2065eio_wd_open_sync (eio_wd wd, const char *path)
2066{
2067 struct tmpbuf tmpbuf = { 0 };
2068 wd = eio__wd_open_sync (&tmpbuf, wd, path);
2069 free (tmpbuf.ptr);
2070
2071 return wd;
2072}
2073
2074void
2075eio_wd_close_sync (eio_wd wd)
2076{
2077 if (wd != EIO_INVALID_WD && wd != EIO_CWD)
2078 {
2079 #if HAVE_AT
2080 close (wd->fd);
2081 #endif
2082 free (wd);
2083 }
2084}
2085
2086#if HAVE_AT
2087
2088/* they forgot these */
2089
2090static int
2091eio__truncateat (int dirfd, const char *path, off_t length)
2092{
2093 int fd = openat (dirfd, path, O_WRONLY | O_CLOEXEC);
2094 int res;
2095
2096 if (fd < 0)
2097 return fd;
2098
2099 res = ftruncate (fd, length);
2100 close (fd);
2101 return res;
2102}
2103
2104static int
2105eio__statvfsat (int dirfd, const char *path, struct statvfs *buf)
2106{
2107 int fd = openat (dirfd, path, O_SEARCH | O_CLOEXEC);
2108 int res;
2109
2110 if (fd < 0)
2111 return fd;
2112
2113 res = fstatvfs (fd, buf);
2114 close (fd);
2115 return res;
2116
2117}
2118
2119#endif
1938 2120
1939/*****************************************************************************/ 2121/*****************************************************************************/
1940 2122
1941#define ALLOC(len) \ 2123#define ALLOC(len) \
1942 if (!req->ptr2) \ 2124 if (!req->ptr2) \
… …
1951 req->result = -1; \ 2133 req->result = -1; \
1952 break; \ 2134 break; \
1953 } \ 2135 } \
1954 } 2136 }
1955 2137
2138static void ecb_noinline ecb_cold
2139etp_proc_init (void)
2140{
2141#if HAVE_PRCTL_SET_NAME
2142 /* provide a more sensible "thread name" */
2143 char name[16 + 1];
2144 const int namelen = sizeof (name) - 1;
2145 int len;
2146
2147 prctl (PR_GET_NAME, (unsigned long)name, 0, 0, 0);
2148 name [namelen] = 0;
2149 len = strlen (name);
2150 strcpy (name + (len <= namelen - 4 ? len : namelen - 4), "/eio");
2151 prctl (PR_SET_NAME, (unsigned long)name, 0, 0, 0);
2152#endif
2153}
2154
1956X_THREAD_PROC (etp_proc) 2155X_THREAD_PROC (etp_proc)
1957{ 2156{
1958 ETP_REQ *req; 2157 ETP_REQ *req;
1959 struct timespec ts; 2158 struct timespec ts;
1960 etp_worker *self = (etp_worker *)thr_arg; 2159 etp_worker *self = (etp_worker *)thr_arg;
1961 2160
1962#if HAVE_PRCTL_SET_NAME 2161 etp_proc_init ();
1963 prctl (PR_SET_NAME, (unsigned long)"eio_thread", 0, 0, 0);
1964#endif
1965 2162
1966 /* try to distribute timeouts somewhat evenly */ 2163 /* try to distribute timeouts somewhat evenly */
1967 ts.tv_nsec = ((unsigned long)self & 1023UL) * (1000000000UL / 1024UL); 2164 ts.tv_nsec = ((unsigned long)self & 1023UL) * (1000000000UL / 1024UL);
1968 2165
1969 for (;;) 2166 for (;;)
… …
1972 2169
1973 X_LOCK (reqlock); 2170 X_LOCK (reqlock);
1974 2171
1975 for (;;) 2172 for (;;)
1976 { 2173 {
1977 self->req = req = reqq_shift (&req_queue); 2174 req = reqq_shift (&req_queue);
1978 2175
1979 if (req) 2176 if (req)
1980 break; 2177 break;
1981 2178
1982 if (ts.tv_sec == 1) /* no request, but timeout detected, let's quit */ 2179 if (ts.tv_sec == 1) /* no request, but timeout detected, let's quit */
… …
2020 ++npending; 2217 ++npending;
2021 2218
2022 if (!reqq_push (&res_queue, req) && want_poll_cb) 2219 if (!reqq_push (&res_queue, req) && want_poll_cb)
2023 want_poll_cb (); 2220 want_poll_cb ();
2024 2221
2025 self->req = 0;
2026 etp_worker_clear (self); 2222 etp_worker_clear (self);
2027 2223
2028 X_UNLOCK (reslock); 2224 X_UNLOCK (reslock);
2029 } 2225 }
2030 2226
2031quit: 2227quit:
2228 free (req);
2229
2032 X_LOCK (wrklock); 2230 X_LOCK (wrklock);
2033 etp_worker_free (self); 2231 etp_worker_free (self);
2034 X_UNLOCK (wrklock); 2232 X_UNLOCK (wrklock);
2035 2233
2036 return 0; 2234 return 0;
… …
2079 } 2277 }
2080 2278
2081static void 2279static void
2082eio_execute (etp_worker *self, eio_req *req) 2280eio_execute (etp_worker *self, eio_req *req)
2083{ 2281{
2282#if HAVE_AT
2283 int dirfd;
2284#else
2285 const char *path;
2286#endif
2287
2084 if (ecb_expect_false (EIO_CANCELLED (req))) 2288 if (ecb_expect_false (EIO_CANCELLED (req)))
2085 { 2289 {
2086 req->result = -1; 2290 req->result = -1;
2087 req->errorno = ECANCELED; 2291 req->errorno = ECANCELED;
2088 return; 2292 return;
2089 } 2293 }
2090 2294
2295 if (ecb_expect_false (req->wd == EIO_INVALID_WD))
2296 {
2297 req->result = -1;
2298 req->errorno = ENOENT;
2299 return;
2300 }
2301
2302 if (req->type >= EIO_OPEN)
2303 {
2304 #if HAVE_AT
2305 dirfd = WD2FD (req->wd);
2306 #else
2307 path = wd_expand (&self->tmpbuf, req->wd, req->ptr1);
2308 #endif
2309 }
2310
2091 switch (req->type) 2311 switch (req->type)
2092 { 2312 {
2313 case EIO_WD_OPEN: req->wd = eio__wd_open_sync (&self->tmpbuf, req->wd, req->ptr1);
2314 req->result = req->wd == EIO_INVALID_WD ? -1 : 0;
2315 break;
2316 case EIO_WD_CLOSE: req->result = 0;
2317 eio_wd_close_sync (req->wd); break;
2318
2093 case EIO_READ: ALLOC (req->size); 2319 case EIO_READ: ALLOC (req->size);
2094 req->result = req->offs >= 0 2320 req->result = req->offs >= 0
2095 ? pread (req->int1, req->ptr2, req->size, req->offs) 2321 ? pread (req->int1, req->ptr2, req->size, req->offs)
2096 : read (req->int1, req->ptr2, req->size); break; 2322 : read (req->int1, req->ptr2, req->size); break;
2097 case EIO_WRITE: req->result = req->offs >= 0 2323 case EIO_WRITE: req->result = req->offs >= 0
… …
2099 : write (req->int1, req->ptr2, req->size); break; 2325 : write (req->int1, req->ptr2, req->size); break;
2100 2326
2101 case EIO_READAHEAD: req->result = readahead (req->int1, req->offs, req->size); break; 2327 case EIO_READAHEAD: req->result = readahead (req->int1, req->offs, req->size); break;
2102 case EIO_SENDFILE: req->result = eio__sendfile (req->int1, req->int2, req->offs, req->size); break; 2328 case EIO_SENDFILE: req->result = eio__sendfile (req->int1, req->int2, req->offs, req->size); break;
2103 2329
2330#if HAVE_AT
2331
2104 case EIO_STAT: ALLOC (sizeof (EIO_STRUCT_STAT)); 2332 case EIO_STAT: ALLOC (sizeof (EIO_STRUCT_STAT));
2105 req->result = stat (req->ptr1, (EIO_STRUCT_STAT *)req->ptr2); break; 2333 req->result = fstatat (dirfd, req->ptr1, (EIO_STRUCT_STAT *)req->ptr2, 0); break;
2106 case EIO_LSTAT: ALLOC (sizeof (EIO_STRUCT_STAT)); 2334 case EIO_LSTAT: ALLOC (sizeof (EIO_STRUCT_STAT));
2335 req->result = fstatat (dirfd, req->ptr1, (EIO_STRUCT_STAT *)req->ptr2, AT_SYMLINK_NOFOLLOW); break;
2336 case EIO_CHOWN: req->result = fchownat (dirfd, req->ptr1, req->int2, req->int3, 0); break;
2337 case EIO_CHMOD: req->result = fchmodat (dirfd, req->ptr1, (mode_t)req->int2, 0); break;
2338 case EIO_TRUNCATE: req->result = eio__truncateat (dirfd, req->ptr1, req->offs); break;
2339 case EIO_OPEN: req->result = openat (dirfd, req->ptr1, req->int1, (mode_t)req->int2); break;
2340
2341 case EIO_UNLINK: req->result = unlinkat (dirfd, req->ptr1, 0); break;
2342 case EIO_RMDIR: req->result = unlinkat (dirfd, req->ptr1, AT_REMOVEDIR); break;
2343 case EIO_MKDIR: req->result = mkdirat (dirfd, req->ptr1, (mode_t)req->int2); break;
2344 case EIO_RENAME: req->result = renameat (dirfd, req->ptr1, WD2FD ((eio_wd)req->int3), req->ptr2); break;
2345 case EIO_LINK: req->result = linkat (dirfd, req->ptr1, WD2FD ((eio_wd)req->int3), req->ptr2, 0); break;
2346 case EIO_SYMLINK: req->result = symlinkat (req->ptr1, dirfd, req->ptr2); break;
2347 case EIO_MKNOD: req->result = mknodat (dirfd, req->ptr1, (mode_t)req->int2, (dev_t)req->offs); break;
2348 case EIO_READLINK: ALLOC (PATH_MAX);
2349 req->result = readlinkat (dirfd, req->ptr1, req->ptr2, PATH_MAX); break;
2350 case EIO_STATVFS: ALLOC (sizeof (EIO_STRUCT_STATVFS));
2351 req->result = eio__statvfsat (dirfd, req->ptr1, (EIO_STRUCT_STATVFS *)req->ptr2); break;
2352 case EIO_UTIME:
2353 case EIO_FUTIME:
2354 {
2355 struct timespec ts[2];
2356 struct timespec *times;
2357
2358 if (req->nv1 != -1. || req->nv2 != -1.)
2359 {
2360 ts[0].tv_sec = req->nv1;
2361 ts[0].tv_nsec = (req->nv1 - ts[0].tv_sec) * 1e9;
2362 ts[1].tv_sec = req->nv2;
2363 ts[1].tv_nsec = (req->nv2 - ts[1].tv_sec) * 1e9;
2364
2365 times = ts;
2366 }
2367 else
2368 times = 0;
2369
2370 req->result = req->type == EIO_FUTIME
2371 ? futimens (req->int1, times)
2372 : utimensat (dirfd, req->ptr1, times, 0);
2373 }
2374 break;
2375
2376#else
2377
2378 case EIO_STAT: ALLOC (sizeof (EIO_STRUCT_STAT));
2379 req->result = stat (path , (EIO_STRUCT_STAT *)req->ptr2); break;
2380 case EIO_LSTAT: ALLOC (sizeof (EIO_STRUCT_STAT));
2107 req->result = lstat (req->ptr1, (EIO_STRUCT_STAT *)req->ptr2); break; 2381 req->result = lstat (path , (EIO_STRUCT_STAT *)req->ptr2); break;
2382 case EIO_CHOWN: req->result = chown (path , req->int2, req->int3); break;
2383 case EIO_CHMOD: req->result = chmod (path , (mode_t)req->int2); break;
2384 case EIO_TRUNCATE: req->result = truncate (path , req->offs); break;
2385 case EIO_OPEN: req->result = open (path , req->int1, (mode_t)req->int2); break;
2386
2387 case EIO_UNLINK: req->result = unlink (path ); break;
2388 case EIO_RMDIR: req->result = rmdir (path ); break;
2389 case EIO_MKDIR: req->result = mkdir (path , (mode_t)req->int2); break;
2390 case EIO_RENAME: req->result = rename (path , req->ptr2); break;
2391 case EIO_LINK: req->result = link (path , req->ptr2); break;
2392 case EIO_SYMLINK: req->result = symlink (path , req->ptr2); break;
2393 case EIO_MKNOD: req->result = mknod (path , (mode_t)req->int2, (dev_t)req->offs); break;
2394 case EIO_READLINK: ALLOC (PATH_MAX);
2395 req->result = readlink (path, req->ptr2, PATH_MAX); break;
2396 case EIO_STATVFS: ALLOC (sizeof (EIO_STRUCT_STATVFS));
2397 req->result = statvfs (path , (EIO_STRUCT_STATVFS *)req->ptr2); break;
2398
2399 case EIO_UTIME:
2400 case EIO_FUTIME:
2401 {
2402 struct timeval tv[2];
2403 struct timeval *times;
2404
2405 if (req->nv1 != -1. || req->nv2 != -1.)
2406 {
2407 tv[0].tv_sec = req->nv1;
2408 tv[0].tv_usec = (req->nv1 - tv[0].tv_sec) * 1e6;
2409 tv[1].tv_sec = req->nv2;
2410 tv[1].tv_usec = (req->nv2 - tv[1].tv_sec) * 1e6;
2411
2412 times = tv;
2413 }
2414 else
2415 times = 0;
2416
2417 req->result = req->type == EIO_FUTIME
2418 ? futimes (req->int1, times)
2419 : utimes (req->ptr1, times);
2420 }
2421 break;
2422
2423#endif
2424
2425 case EIO_REALPATH: if (0 <= (req->result = eio__realpath (&self->tmpbuf, req->wd, req->ptr1)))
2426 {
2427 ALLOC (req->result);
2428 memcpy (req->ptr2, self->tmpbuf.ptr, req->result);
2429 }
2430 break;
2431
2108 case EIO_FSTAT: ALLOC (sizeof (EIO_STRUCT_STAT)); 2432 case EIO_FSTAT: ALLOC (sizeof (EIO_STRUCT_STAT));
2109 req->result = fstat (req->int1, (EIO_STRUCT_STAT *)req->ptr2); break; 2433 req->result = fstat (req->int1, (EIO_STRUCT_STAT *)req->ptr2); break;
2110 2434
2111 case EIO_STATVFS: ALLOC (sizeof (EIO_STRUCT_STATVFS));
2112 req->result = statvfs (req->ptr1, (EIO_STRUCT_STATVFS *)req->ptr2); break;
2113 case EIO_FSTATVFS: ALLOC (sizeof (EIO_STRUCT_STATVFS)); 2435 case EIO_FSTATVFS: ALLOC (sizeof (EIO_STRUCT_STATVFS));
2114 req->result = fstatvfs (req->int1, (EIO_STRUCT_STATVFS *)req->ptr2); break; 2436 req->result = fstatvfs (req->int1, (EIO_STRUCT_STATVFS *)req->ptr2); break;
2115 2437
2116 case EIO_CHOWN: req->result = chown (req->ptr1, req->int2, req->int3); break;
2117 case EIO_FCHOWN: req->result = fchown (req->int1, req->int2, req->int3); break; 2438 case EIO_FCHOWN: req->result = fchown (req->int1, req->int2, req->int3); break;
2118 case EIO_CHMOD: req->result = chmod (req->ptr1, (mode_t)req->int2); break;
2119 case EIO_FCHMOD: req->result = fchmod (req->int1, (mode_t)req->int2); break; 2439 case EIO_FCHMOD: req->result = fchmod (req->int1, (mode_t)req->int2); break;
2120 case EIO_TRUNCATE: req->result = truncate (req->ptr1, req->offs); break;
2121 case EIO_FTRUNCATE: req->result = ftruncate (req->int1, req->offs); break; 2440 case EIO_FTRUNCATE: req->result = ftruncate (req->int1, req->offs); break;
2122 2441
2123 case EIO_OPEN: req->result = open (req->ptr1, req->int1, (mode_t)req->int2); break;
2124 case EIO_CLOSE: req->result = close (req->int1); break; 2442 case EIO_CLOSE: req->result = close (req->int1); break;
2125 case EIO_DUP2: req->result = dup2 (req->int1, req->int2); break; 2443 case EIO_DUP2: req->result = dup2 (req->int1, req->int2); break;
2126 case EIO_UNLINK: req->result = unlink (req->ptr1); break;
2127 case EIO_RMDIR: req->result = rmdir (req->ptr1); break;
2128 case EIO_MKDIR: req->result = mkdir (req->ptr1, (mode_t)req->int2); break;
2129 case EIO_RENAME: req->result = rename (req->ptr1, req->ptr2); break;
2130 case EIO_LINK: req->result = link (req->ptr1, req->ptr2); break;
2131 case EIO_SYMLINK: req->result = symlink (req->ptr1, req->ptr2); break;
2132 case EIO_MKNOD: req->result = mknod (req->ptr1, (mode_t)req->int2, (dev_t)req->offs); break;
2133
2134 case EIO_REALPATH: eio__realpath (req, self); break;
2135
2136 case EIO_READLINK: ALLOC (PATH_MAX);
2137 req->result = readlink (req->ptr1, req->ptr2, PATH_MAX); break;
2138
2139 case EIO_SYNC: req->result = 0; sync (); break; 2444 case EIO_SYNC: req->result = 0; sync (); break;
2140 case EIO_FSYNC: req->result = fsync (req->int1); break; 2445 case EIO_FSYNC: req->result = fsync (req->int1); break;
2141 case EIO_FDATASYNC: req->result = fdatasync (req->int1); break; 2446 case EIO_FDATASYNC: req->result = fdatasync (req->int1); break;
2142 case EIO_SYNCFS: req->result = eio__syncfs (req->int1); break; 2447 case EIO_SYNCFS: req->result = eio__syncfs (req->int1); break;
2143 case EIO_SYNC_FILE_RANGE: req->result = eio__sync_file_range (req->int1, req->offs, req->size, req->int2); break; 2448 case EIO_SYNC_FILE_RANGE: req->result = eio__sync_file_range (req->int1, req->offs, req->size, req->int2); break;
… …
2162 req->result = select (0, 0, 0, 0, &tv); 2467 req->result = select (0, 0, 0, 0, &tv);
2163 } 2468 }
2164#endif 2469#endif
2165 break; 2470 break;
2166 2471
2167 case EIO_UTIME:
2168 case EIO_FUTIME:
2169 {
2170 struct timeval tv[2];
2171 struct timeval *times;
2172
2173 if (req->nv1 != -1. || req->nv2 != -1.)
2174 {
2175 tv[0].tv_sec = req->nv1;
2176 tv[0].tv_usec = (req->nv1 - tv[0].tv_sec) * 1000000.;
2177 tv[1].tv_sec = req->nv2;
2178 tv[1].tv_usec = (req->nv2 - tv[1].tv_sec) * 1000000.;
2179
2180 times = tv;
2181 }
2182 else
2183 times = 0;
2184
2185 req->result = req->type == EIO_FUTIME
2186 ? futimes (req->int1, times)
2187 : utimes (req->ptr1, times);
2188 }
2189 break;
2190
2191 case EIO_GROUP: 2472 case EIO_GROUP:
2192 abort (); /* handled in eio_request */ 2473 abort (); /* handled in eio_request */
2193 2474
2194 case EIO_NOP: 2475 case EIO_NOP:
2195 req->result = 0; 2476 req->result = 0;
… …
2207 2488
2208 req->errorno = errno; 2489 req->errorno = errno;
2209} 2490}
2210 2491
2211#ifndef EIO_NO_WRAPPERS 2492#ifndef EIO_NO_WRAPPERS
2493
2494eio_req *eio_wd_open (const char *path, int pri, eio_cb cb, void *data)
2495{
2496 REQ (EIO_WD_OPEN); PATH; SEND;
2497}
2498
2499eio_req *eio_wd_close (eio_wd wd, int pri, eio_cb cb, void *data)
2500{
2501 REQ (EIO_WD_CLOSE); req->wd = wd; SEND;
2502}
2212 2503
2213eio_req *eio_nop (int pri, eio_cb cb, void *data) 2504eio_req *eio_nop (int pri, eio_cb cb, void *data)
2214{ 2505{
2215 REQ (EIO_NOP); SEND; 2506 REQ (EIO_NOP); SEND;
2216} 2507}

Diff Legend

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