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

Comparing libeio/eio.c (file contents):
Revision 1.103 by root, Thu Sep 15 13:20:54 2011 UTC vs.
Revision 1.104 by root, Mon Sep 26 16:54:25 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
317/*****************************************************************************/
318
297#define ETP_PRI_MIN EIO_PRI_MIN 319#define ETP_PRI_MIN EIO_PRI_MIN
298#define ETP_PRI_MAX EIO_PRI_MAX 320#define ETP_PRI_MAX EIO_PRI_MAX
299 321
300struct etp_worker; 322struct etp_worker;
301 323
… …
346static xmutex_t preadwritelock; 368static xmutex_t preadwritelock;
347#endif 369#endif
348 370
349typedef struct etp_worker 371typedef struct etp_worker
350{ 372{
373 struct tmpbuf tmpbuf;
374
351 /* locked by wrklock */ 375 /* locked by wrklock */
352 struct etp_worker *prev, *next; 376 struct etp_worker *prev, *next;
353 377
354 xthread_t tid; 378 xthread_t tid;
355 379
356 /* locked by reslock, reqlock or wrklock */
357 ETP_REQ *req; /* currently processed request */
358
359#ifdef ETP_WORKER_COMMON 380#ifdef ETP_WORKER_COMMON
360 ETP_WORKER_COMMON 381 ETP_WORKER_COMMON
361#endif 382#endif
362} etp_worker; 383} etp_worker;
363 384
… …
374} 395}
375 396
376static void ecb_cold 397static void ecb_cold
377etp_worker_free (etp_worker *wrk) 398etp_worker_free (etp_worker *wrk)
378{ 399{
400 free (wrk->tmpbuf.ptr);
401
379 wrk->next->prev = wrk->prev; 402 wrk->next->prev = wrk->prev;
380 wrk->prev->next = wrk->next; 403 wrk->prev->next = wrk->next;
381 404
382 free (wrk); 405 free (wrk);
383} 406}
… …
1337} 1360}
1338 1361
1339/*****************************************************************************/ 1362/*****************************************************************************/
1340/* requests implemented outside eio_execute, because they are so large */ 1363/* requests implemented outside eio_execute, because they are so large */
1341 1364
1365/* copies some absolute path to tmpbuf */
1366static char *
1367eio__getwd (struct tmpbuf *tmpbuf, eio_wd wd)
1368{
1369 if (wd == EIO_CWD)
1370 return getcwd (tmpbuf->ptr, PATH_MAX);
1371
1372#if HAVE_AT
1373 abort (); /*TODO*/
1374#else
1375 strcpy (tmpbuf->ptr, wd);
1376#endif
1377 return tmpbuf->ptr;
1378}
1379
1380/* result will always end up in tmpbuf, there is always space for adding a 0-byte */
1342static void 1381static int
1343eio__realpath (eio_req *req, etp_worker *self) 1382eio__realpath (struct tmpbuf *tmpbuf, eio_wd wd, const char *path)
1344{ 1383{
1345 char *rel = req->ptr1; 1384 const char *rel = path;
1346 char *res; 1385 char *res;
1347 char *tmp1, *tmp2; 1386 char *tmp1, *tmp2;
1348#if SYMLOOP_MAX > 32 1387#if SYMLOOP_MAX > 32
1349 int symlinks = SYMLOOP_MAX; 1388 int symlinks = SYMLOOP_MAX;
1350#else 1389#else
1351 int symlinks = 32; 1390 int symlinks = 32;
1352#endif 1391#endif
1353 1392
1354 req->result = -1; 1393 /*D*/ /*TODO: wd ignored */
1355 1394
1356 errno = EINVAL; 1395 errno = EINVAL;
1357 if (!rel) 1396 if (!rel)
1358 return; 1397 return -1;
1359 1398
1360 errno = ENOENT; 1399 errno = ENOENT;
1361 if (!*rel) 1400 if (!*rel)
1362 return; 1401 return -1;
1363 1402
1364 if (!req->ptr2) 1403 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; 1404 tmp1 = res + PATH_MAX;
1378 tmp2 = tmp1 + PATH_MAX; 1405 tmp2 = tmp1 + PATH_MAX;
1379 1406
1380#if 0 /* disabled, the musl way to do things is just too racy */ 1407#if 0 /* disabled, the musl way to do things is just too racy */
1381#if __linux && defined(O_NONBLOCK) && defined(O_NOATIME) 1408#if __linux && defined(O_NONBLOCK) && defined(O_NOATIME)
… …
1400#endif 1427#endif
1401#endif 1428#endif
1402 1429
1403 if (*rel != '/') 1430 if (*rel != '/')
1404 { 1431 {
1405 if (!getcwd (res, PATH_MAX)) 1432 if (!eio__getwd (tmpbuf, wd))
1406 return; 1433 return -1;
1407 1434
1408 if (res [1]) /* only use if not / */ 1435 if (res [1]) /* only use if not / */
1409 res += strlen (res); 1436 res += strlen (res);
1410 } 1437 }
1411 1438
1412 while (*rel) 1439 while (*rel)
1413 { 1440 {
1414 eio_ssize_t len, linklen; 1441 eio_ssize_t len, linklen;
1415 char *beg = rel; 1442 const char *beg = rel;
1416 1443
1417 while (*rel && *rel != '/') 1444 while (*rel && *rel != '/')
1418 ++rel; 1445 ++rel;
1419 1446
1420 len = rel - beg; 1447 len = rel - beg;
… …
1432 1459
1433 if (beg [1] == '.' && len == 2) 1460 if (beg [1] == '.' && len == 2)
1434 { 1461 {
1435 /* .. - back up one component, if possible */ 1462 /* .. - back up one component, if possible */
1436 1463
1437 while (res != req->ptr2) 1464 while (res != tmpbuf->ptr)
1438 if (*--res == '/') 1465 if (*--res == '/')
1439 break; 1466 break;
1440 1467
1441 continue; 1468 continue;
1442 } 1469 }
… …
1452 1479
1453 /* zero-terminate, for readlink */ 1480 /* zero-terminate, for readlink */
1454 res [len + 1] = 0; 1481 res [len + 1] = 0;
1455 1482
1456 /* now check if it's a symlink */ 1483 /* now check if it's a symlink */
1457 linklen = readlink (req->ptr2, tmp1, PATH_MAX); 1484 linklen = readlink (tmpbuf->ptr, tmp1, PATH_MAX);
1458 1485
1459 if (linklen < 0) 1486 if (linklen < 0)
1460 { 1487 {
1461 if (errno != EINVAL) 1488 if (errno != EINVAL)
1462 return; 1489 return -1;
1463 1490
1464 /* it's a normal directory. hopefully */ 1491 /* it's a normal directory. hopefully */
1465 res += len + 1; 1492 res += len + 1;
1466 } 1493 }
1467 else 1494 else
… …
1469 /* yay, it was a symlink - build new path in tmp2 */ 1496 /* yay, it was a symlink - build new path in tmp2 */
1470 int rellen = strlen (rel); 1497 int rellen = strlen (rel);
1471 1498
1472 errno = ENAMETOOLONG; 1499 errno = ENAMETOOLONG;
1473 if (linklen + 1 + rellen >= PATH_MAX) 1500 if (linklen + 1 + rellen >= PATH_MAX)
1474 return; 1501 return -1;
1475 1502
1476 errno = ELOOP; 1503 errno = ELOOP;
1477 if (!--symlinks) 1504 if (!--symlinks)
1478 return; 1505 return -1;
1479 1506
1480 if (*tmp1 == '/') 1507 if (*tmp1 == '/')
1481 res = req->ptr2; /* symlink resolves to an absolute path */ 1508 res = tmpbuf->ptr; /* symlink resolves to an absolute path */
1482 1509
1483 /* we need to be careful, as rel might point into tmp2 already */ 1510 /* we need to be careful, as rel might point into tmp2 already */
1484 memmove (tmp2 + linklen + 1, rel, rellen + 1); 1511 memmove (tmp2 + linklen + 1, rel, rellen + 1);
1485 tmp2 [linklen] = '/'; 1512 tmp2 [linklen] = '/';
1486 memcpy (tmp2, tmp1, linklen); 1513 memcpy (tmp2, tmp1, linklen);
… …
1488 rel = tmp2; 1515 rel = tmp2;
1489 } 1516 }
1490 } 1517 }
1491 1518
1492 /* special case for the lone root path */ 1519 /* special case for the lone root path */
1493 if (res == req->ptr2) 1520 if (res == tmpbuf->ptr)
1494 *res++ = '/'; 1521 *res++ = '/';
1495 1522
1496 req->result = res - (char *)req->ptr2; 1523 return res - (char *)tmpbuf->ptr;
1497
1498done:
1499 req->ptr2 = realloc (req->ptr2, req->result); /* trade time for space savings */
1500} 1524}
1501 1525
1502static signed char 1526static signed char
1503eio_dent_cmp (const eio_dirent *a, const eio_dirent *b) 1527eio_dent_cmp (const eio_dirent *a, const eio_dirent *b)
1504{ 1528{
… …
1664 eio_dent_insertion_sort (dents, size); 1688 eio_dent_insertion_sort (dents, size);
1665} 1689}
1666 1690
1667/* read a full directory */ 1691/* read a full directory */
1668static void 1692static void
1669eio__scandir (eio_req *req, etp_worker *self) 1693eio__scandir (eio_req *req)
1670{ 1694{
1671 char *name, *names; 1695 char *name, *names;
1672 int namesalloc = 4096 - sizeof (void *) * 4; 1696 int namesalloc = 4096 - sizeof (void *) * 4;
1673 int namesoffs = 0; 1697 int namesoffs = 0;
1674 int flags = req->int1; 1698 int flags = req->int1;
… …
1935#endif 1959#endif
1936 } 1960 }
1937} 1961}
1938 1962
1939/*****************************************************************************/ 1963/*****************************************************************************/
1964/* working directory stuff */
1965
1966#if HAVE_AT
1967
1968#define WD2FD(wd) (wd ? ((int)wd) - 1 : AT_FDCWD)
1969
1970eio_wd
1971eio_wd_open_sync (eio_wd wd, const char *path)
1972{
1973 int fd = openat (WD2FD (wd), path, O_CLOEXEC | O_SEARCH | O_DIRECTORY);
1974
1975 return fd >= 0 ? (eio_wd)(fd + 1) : EIO_INVALID_WD;
1976}
1977
1978void
1979eio_wd_close_sync (eio_wd wd)
1980{
1981 int fd = WD2FD (wd);
1982
1983 if (fd >= 0)
1984 close (fd);
1985}
1986
1987#else
1988
1989/* on legacy systems, we represent the working directories simply by their path strings */
1990
1991static const char *
1992wd_expand (struct tmpbuf *tmpbuf, eio_wd wd, const char *path)
1993{
1994 if (!wd || *path == '/')
1995 return path;
1996
1997 {
1998 int l1 = strlen ((const char *)wd);
1999 int l2 = strlen (path);
2000
2001 char *res = tmpbuf_get (tmpbuf, l1 + l2 + 2);
2002
2003 memcpy (res, wd, l1);
2004 res [l1] = '/';
2005 memcpy (res + l1 + 1, path, l2 + 1);
2006
2007 return res;
2008 }
2009}
2010
2011eio_wd
2012eio__wd_open_sync (struct tmpbuf *tmpbuf, eio_wd wd, const char *path)
2013{
2014 if (*path == '/') /* absolute paths ignore wd */
2015 path = strdup (path);
2016 else if (path [0] == '.' && !path [1]) /* special case '.', as it is common */
2017 return wd;
2018 else
2019 {
2020 int len = eio__realpath (tmpbuf, wd, path);
2021
2022 path = EIO_INVALID_WD;
2023
2024 if (len >= 0)
2025 {
2026 ((char *)tmpbuf->ptr)[len] = 0;
2027 path = strdup (tmpbuf->ptr);
2028 }
2029 }
2030
2031 if (!path)
2032 path = EIO_INVALID_WD;
2033
2034 return (eio_wd)path;
2035}
2036
2037eio_wd
2038eio_wd_open_sync (eio_wd wd, const char *path)
2039{
2040 struct tmpbuf tmpbuf = { 0 };
2041 wd = eio__wd_open_sync (&tmpbuf, wd, path);
2042 free (tmpbuf.ptr);
2043
2044 return wd;
2045}
2046
2047void
2048eio_wd_close_sync (eio_wd wd)
2049{
2050 if (wd != EIO_INVALID_WD)
2051 free (wd);
2052}
2053
2054#endif
2055
2056/*****************************************************************************/
1940 2057
1941#define ALLOC(len) \ 2058#define ALLOC(len) \
1942 if (!req->ptr2) \ 2059 if (!req->ptr2) \
1943 { \ 2060 { \
1944 X_LOCK (wrklock); \ 2061 X_LOCK (wrklock); \
… …
1972 2089
1973 X_LOCK (reqlock); 2090 X_LOCK (reqlock);
1974 2091
1975 for (;;) 2092 for (;;)
1976 { 2093 {
1977 self->req = req = reqq_shift (&req_queue); 2094 req = reqq_shift (&req_queue);
1978 2095
1979 if (req) 2096 if (req)
1980 break; 2097 break;
1981 2098
1982 if (ts.tv_sec == 1) /* no request, but timeout detected, let's quit */ 2099 if (ts.tv_sec == 1) /* no request, but timeout detected, let's quit */
… …
2020 ++npending; 2137 ++npending;
2021 2138
2022 if (!reqq_push (&res_queue, req) && want_poll_cb) 2139 if (!reqq_push (&res_queue, req) && want_poll_cb)
2023 want_poll_cb (); 2140 want_poll_cb ();
2024 2141
2025 self->req = 0;
2026 etp_worker_clear (self); 2142 etp_worker_clear (self);
2027 2143
2028 X_UNLOCK (reslock); 2144 X_UNLOCK (reslock);
2029 } 2145 }
2030 2146
2031quit: 2147quit:
2148 free (req);
2149
2032 X_LOCK (wrklock); 2150 X_LOCK (wrklock);
2033 etp_worker_free (self); 2151 etp_worker_free (self);
2034 X_UNLOCK (wrklock); 2152 X_UNLOCK (wrklock);
2035 2153
2036 return 0; 2154 return 0;
… …
2079 } 2197 }
2080 2198
2081static void 2199static void
2082eio_execute (etp_worker *self, eio_req *req) 2200eio_execute (etp_worker *self, eio_req *req)
2083{ 2201{
2202#if HAVE_AT
2203 int dirfd;
2204#else
2205 const char *path;
2206#endif
2207
2084 if (ecb_expect_false (EIO_CANCELLED (req))) 2208 if (ecb_expect_false (EIO_CANCELLED (req)))
2085 { 2209 {
2086 req->result = -1; 2210 req->result = -1;
2087 req->errorno = ECANCELED; 2211 req->errorno = ECANCELED;
2088 return; 2212 return;
2089 } 2213 }
2090 2214
2215 if (ecb_expect_false (req->wd == EIO_INVALID_WD))
2216 {
2217 req->result = -1;
2218 req->errorno = ENOENT;
2219 return;
2220 }
2221
2222 if (req->type >= EIO_OPEN)
2223 {
2224 #if HAVE_AT
2225 dirfd = WD2FD (req->wd);
2226 #else
2227 path = wd_expand (&self->tmpbuf, req->wd, req->ptr1);
2228 #endif
2229 }
2230
2091 switch (req->type) 2231 switch (req->type)
2092 { 2232 {
2233 case EIO_WD_OPEN: req->wd = eio__wd_open_sync (&self->tmpbuf, req->wd, req->ptr1);
2234 req->result = req->wd == EIO_INVALID_WD ? -1 : 0;
2235 break;
2236 case EIO_WD_CLOSE: eio_wd_close_sync (req->wd); break;
2237
2093 case EIO_READ: ALLOC (req->size); 2238 case EIO_READ: ALLOC (req->size);
2094 req->result = req->offs >= 0 2239 req->result = req->offs >= 0
2095 ? pread (req->int1, req->ptr2, req->size, req->offs) 2240 ? pread (req->int1, req->ptr2, req->size, req->offs)
2096 : read (req->int1, req->ptr2, req->size); break; 2241 : read (req->int1, req->ptr2, req->size); break;
2097 case EIO_WRITE: req->result = req->offs >= 0 2242 case EIO_WRITE: req->result = req->offs >= 0
… …
2099 : write (req->int1, req->ptr2, req->size); break; 2244 : write (req->int1, req->ptr2, req->size); break;
2100 2245
2101 case EIO_READAHEAD: req->result = readahead (req->int1, req->offs, req->size); break; 2246 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; 2247 case EIO_SENDFILE: req->result = eio__sendfile (req->int1, req->int2, req->offs, req->size); break;
2103 2248
2249#if HAVE_AT
2250 case EIO_GETPATH: abort ();
2104 case EIO_STAT: ALLOC (sizeof (EIO_STRUCT_STAT)); 2251 case EIO_STAT: ALLOC (sizeof (EIO_STRUCT_STAT));
2105 req->result = stat (req->ptr1, (EIO_STRUCT_STAT *)req->ptr2); break; 2252 req->result = fstatat (dirfd, path, (EIO_STRUCT_STAT *)req->ptr2); break;
2106 case EIO_LSTAT: ALLOC (sizeof (EIO_STRUCT_STAT)); 2253 case EIO_LSTAT: ALLOC (sizeof (EIO_STRUCT_STAT));
2107 req->result = lstat (req->ptr1, (EIO_STRUCT_STAT *)req->ptr2); break; 2254 req->result = lstat (dirfd, path, (EIO_STRUCT_STAT *)req->ptr2); break;
2255#if 0/*D*/
2256 case EIO_STATVFS: ALLOC (sizeof (EIO_STRUCT_STATVFS));
2257 req->result = statvfs (dirfd, path, (EIO_STRUCT_STATVFS *)req->ptr2); break;
2258#endif
2259 case EIO_CHOWN: req->result = chown (dirfd, path, req->int2, req->int3); break;
2260 case EIO_CHMOD: req->result = chmod (dirfd, path, (mode_t)req->int2); break;
2261 case EIO_TRUNCATE: req->result = truncate (dirfd, path, req->offs); break;
2262 case EIO_OPEN: req->result = open (dirfd, path, req->int1, (mode_t)req->int2); break;
2263
2264 case EIO_UNLINK: req->result = unlink (dirfd, path); break;
2265 case EIO_RMDIR: req->result = rmdir (dirfd, path); break;
2266 case EIO_MKDIR: req->result = mkdir (dirfd, path, (mode_t)req->int2); break;
2267 case EIO_RENAME: req->result = rename (dirfd, path, req->ptr2); break;
2268 case EIO_LINK: req->result = link (dirfd, path, req->ptr2); break;
2269 case EIO_SYMLINK: req->result = symlink (dirfd, path, req->ptr2); break;
2270 case EIO_MKNOD: req->result = mknod (dirfd, path, (mode_t)req->int2, (dev_t)req->offs); break;
2271#else
2272 case EIO_STAT: ALLOC (sizeof (EIO_STRUCT_STAT));
2273 req->result = stat (path , (EIO_STRUCT_STAT *)req->ptr2); break;
2274 case EIO_LSTAT: ALLOC (sizeof (EIO_STRUCT_STAT));
2275 req->result = lstat (path , (EIO_STRUCT_STAT *)req->ptr2); break;
2276 case EIO_CHOWN: req->result = chown (path , req->int2, req->int3); break;
2277 case EIO_CHMOD: req->result = chmod (path , (mode_t)req->int2); break;
2278 case EIO_TRUNCATE: req->result = truncate (path , req->offs); break;
2279 case EIO_OPEN: req->result = open (path , req->int1, (mode_t)req->int2); break;
2280
2281 case EIO_UNLINK: req->result = unlink (path ); break;
2282 case EIO_RMDIR: req->result = rmdir (path ); break;
2283 case EIO_MKDIR: req->result = mkdir (path , (mode_t)req->int2); break;
2284 case EIO_RENAME: req->result = rename (path , req->ptr2); break;
2285 case EIO_LINK: req->result = link (path , req->ptr2); break;
2286 case EIO_SYMLINK: req->result = symlink (path , req->ptr2); break;
2287 case EIO_MKNOD: req->result = mknod (path , (mode_t)req->int2, (dev_t)req->offs); break;
2288
2289 case EIO_READLINK: ALLOC (PATH_MAX);
2290 req->result = readlink (path, req->ptr2, PATH_MAX); break;
2291#endif
2292
2293 case EIO_REALPATH: if (0 <= (req->result = eio__realpath (&self->tmpbuf, req->wd, req->ptr1)))
2294 {
2295 ALLOC (req->result);
2296 memcpy (req->ptr2, self->tmpbuf.ptr, req->result);
2297 }
2298 break;
2299
2300 case EIO_STATVFS: ALLOC (sizeof (EIO_STRUCT_STATVFS)); /*D*/
2301 req->result = statvfs (path , (EIO_STRUCT_STATVFS *)req->ptr2); break;
2302
2108 case EIO_FSTAT: ALLOC (sizeof (EIO_STRUCT_STAT)); 2303 case EIO_FSTAT: ALLOC (sizeof (EIO_STRUCT_STAT));
2109 req->result = fstat (req->int1, (EIO_STRUCT_STAT *)req->ptr2); break; 2304 req->result = fstat (req->int1, (EIO_STRUCT_STAT *)req->ptr2); break;
2110 2305
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)); 2306 case EIO_FSTATVFS: ALLOC (sizeof (EIO_STRUCT_STATVFS));
2114 req->result = fstatvfs (req->int1, (EIO_STRUCT_STATVFS *)req->ptr2); break; 2307 req->result = fstatvfs (req->int1, (EIO_STRUCT_STATVFS *)req->ptr2); break;
2115 2308
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; 2309 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; 2310 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; 2311 case EIO_FTRUNCATE: req->result = ftruncate (req->int1, req->offs); break;
2122 2312
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; 2313 case EIO_CLOSE: req->result = close (req->int1); break;
2125 case EIO_DUP2: req->result = dup2 (req->int1, req->int2); break; 2314 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; 2315 case EIO_SYNC: req->result = 0; sync (); break;
2140 case EIO_FSYNC: req->result = fsync (req->int1); break; 2316 case EIO_FSYNC: req->result = fsync (req->int1); break;
2141 case EIO_FDATASYNC: req->result = fdatasync (req->int1); break; 2317 case EIO_FDATASYNC: req->result = fdatasync (req->int1); break;
2142 case EIO_SYNCFS: req->result = eio__syncfs (req->int1); break; 2318 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; 2319 case EIO_SYNC_FILE_RANGE: req->result = eio__sync_file_range (req->int1, req->offs, req->size, req->int2); break;
… …
2145 case EIO_MTOUCH: req->result = eio__mtouch (req); break; 2321 case EIO_MTOUCH: req->result = eio__mtouch (req); break;
2146 case EIO_MLOCK: req->result = eio__mlock (req->ptr2, req->size); break; 2322 case EIO_MLOCK: req->result = eio__mlock (req->ptr2, req->size); break;
2147 case EIO_MLOCKALL: req->result = eio__mlockall (req->int1); break; 2323 case EIO_MLOCKALL: req->result = eio__mlockall (req->int1); break;
2148 case EIO_FALLOCATE: req->result = eio__fallocate (req->int1, req->int2, req->offs, req->size); break; 2324 case EIO_FALLOCATE: req->result = eio__fallocate (req->int1, req->int2, req->offs, req->size); break;
2149 2325
2150 case EIO_READDIR: eio__scandir (req, self); break; 2326 case EIO_READDIR: eio__scandir (req); break;
2151 2327
2152 case EIO_BUSY: 2328 case EIO_BUSY:
2153#ifdef _WIN32 2329#ifdef _WIN32
2154 Sleep (req->nv1 * 1e3); 2330 Sleep (req->nv1 * 1e3);
2155#else 2331#else

Diff Legend

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