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.134 by root, Thu Jun 25 15:59:57 2015 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,2013 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 *
10 * 1. Redistributions of source code must retain the above copyright notice, 10 * 1. Redistributions of source code must retain the above copyright notice,
11 * this list of conditions and the following disclaimer. 11 * this list of conditions and the following disclaimer.
12 * 12 *
13 * 2. Redistributions in binary form must reproduce the above copyright 13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the 14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution. 15 * documentation and/or other materials provided with the distribution.
16 * 16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
18 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER- 18 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
19 * CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO 19 * CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
20 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE- 20 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
21 * CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 21 * CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
… …
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))
… …
117 #define link(old,neu) (CreateHardLink (neu, old, 0) ? 0 : EIO_ERRNO (ENOENT, -1)) 120 #define link(old,neu) (CreateHardLink (neu, old, 0) ? 0 : EIO_ERRNO (ENOENT, -1))
118 121
119 #define chmod(path,mode) _chmod (path, mode) 122 #define chmod(path,mode) _chmod (path, mode)
120 #define dup(fd) _dup (fd) 123 #define dup(fd) _dup (fd)
121 #define dup2(fd1,fd2) _dup2 (fd1, fd2) 124 #define dup2(fd1,fd2) _dup2 (fd1, fd2)
125 #define pipe(fds) _pipe (fds, 4096, O_BINARY)
122 126
123 #define fchmod(fd,mode) EIO_ENOSYS () 127 #define fchmod(fd,mode) EIO_ENOSYS ()
124 #define chown(path,uid,gid) EIO_ENOSYS () 128 #define chown(path,uid,gid) EIO_ENOSYS ()
125 #define fchown(fd,uid,gid) EIO_ENOSYS () 129 #define fchown(fd,uid,gid) EIO_ENOSYS ()
126 #define truncate(path,offs) EIO_ENOSYS () /* far-miss: SetEndOfFile */ 130 #define truncate(path,offs) EIO_ENOSYS () /* far-miss: SetEndOfFile */
… …
128 #define mknod(path,mode,dev) EIO_ENOSYS () 132 #define mknod(path,mode,dev) EIO_ENOSYS ()
129 #define sync() EIO_ENOSYS () 133 #define sync() EIO_ENOSYS ()
130 #define readlink(path,buf,s) EIO_ENOSYS () 134 #define readlink(path,buf,s) EIO_ENOSYS ()
131 #define statvfs(path,buf) EIO_ENOSYS () 135 #define statvfs(path,buf) EIO_ENOSYS ()
132 #define fstatvfs(fd,buf) EIO_ENOSYS () 136 #define fstatvfs(fd,buf) EIO_ENOSYS ()
137
138 #define pread(fd,buf,count,offset) eio__pread (fd, buf, count, offset)
139 #define pwrite(fd,buf,count,offset) eio__pwrite (fd, buf, count, offset)
140
141 #if __GNUC__
142 typedef long long eio_off_t; /* signed for compatibility to msvc */
143 #else
144 typedef __int64 eio_off_t; /* unsigned not supported by msvc */
145 #endif
146
147 static eio_ssize_t
148 eio__pread (int fd, void *buf, eio_ssize_t count, eio_off_t offset)
149 {
150 OVERLAPPED o = { 0 };
151 DWORD got;
152
153 o.Offset = offset;
154 o.OffsetHigh = offset >> 32;
155
156 return ReadFile ((HANDLE)EIO_FD_TO_WIN32_HANDLE (fd), buf, count, &got, &o)
157 ? got : -1;
158 }
159
160 static eio_ssize_t
161 eio__pwrite (int fd, void *buf, eio_ssize_t count, eio_off_t offset)
162 {
163 OVERLAPPED o = { 0 };
164 DWORD got;
165
166 o.Offset = offset;
167 o.OffsetHigh = offset >> 32;
168
169 return WriteFile ((HANDLE)EIO_FD_TO_WIN32_HANDLE (fd), buf, count, &got, &o)
170 ? got : -1;
171 }
133 172
134 /* rename() uses MoveFile, which fails to overwrite */ 173 /* rename() uses MoveFile, which fails to overwrite */
135 #define rename(old,neu) eio__rename (old, neu) 174 #define rename(old,neu) eio__rename (old, neu)
136 175
137 static int 176 static int
… …
175 #endif 214 #endif
176 215
177 return EIO_ERRNO (ENOENT, -1); 216 return EIO_ERRNO (ENOENT, -1);
178 } 217 }
179 218
180 /* POSIX API only */ 219 /* POSIX API only, causing trouble for win32 apps */
181 #define CreateHardLink(neu,old,flags) 0 220 #define CreateHardLink(neu,old,flags) 0 /* not really creating hardlink, still using relative paths? */
182 #define CreateSymbolicLink(neu,old,flags) 0 221 #define CreateSymbolicLink(neu,old,flags) 0 /* vista+ only */
183 222
184 struct statvfs 223 struct statvfs
185 { 224 {
186 int dummy; 225 int dummy;
187 }; 226 };
… …
193 232
194#else 233#else
195 234
196 #include <sys/time.h> 235 #include <sys/time.h>
197 #include <sys/select.h> 236 #include <sys/select.h>
198 #include <sys/statvfs.h>
199 #include <unistd.h> 237 #include <unistd.h>
200 #include <signal.h> 238 #include <signal.h>
201 #include <dirent.h> 239 #include <dirent.h>
202 240
241 #ifdef ANDROID
242 #include <sys/vfs.h>
243 #define statvfs statfs
244 #define fstatvfs fstatfs
245 #include <asm/page.h> /* supposedly limits.h does #define PAGESIZE PAGESIZE */
246 #else
247 #include <sys/statvfs.h>
248 #endif
249
203 #if _POSIX_MEMLOCK || _POSIX_MEMLOCK_RANGE || _POSIX_MAPPED_FILES 250 #if _POSIX_MEMLOCK || _POSIX_MEMLOCK_RANGE || _POSIX_MAPPED_FILES
204 #include <sys/mman.h> 251 #include <sys/mman.h>
205 #endif 252 #endif
206 253
207 #define D_NAME(entp) entp->d_name 254 #define D_NAME(entp) entp->d_name
208 255
209 /* POSIX_SOURCE is useless on bsd's, and XOPEN_SOURCE is unreliable there, too */ 256 /* POSIX_SOURCE is useless on bsd's, and XOPEN_SOURCE is unreliable there, too */
210 #if __FreeBSD__ || defined __NetBSD__ || defined __OpenBSD__ 257 #if __FreeBSD__ || __NetBSD__ || __OpenBSD__
211 #define _DIRENT_HAVE_D_TYPE /* sigh */ 258 #define _DIRENT_HAVE_D_TYPE /* sigh */
212 #define D_INO(de) (de)->d_fileno 259 #define D_INO(de) (de)->d_fileno
213 #define D_NAMLEN(de) (de)->d_namlen 260 #define D_NAMLEN(de) (de)->d_namlen
214 #elif __linux || defined d_ino || _XOPEN_SOURCE >= 600 261 #elif __linux || defined d_ino || _XOPEN_SOURCE >= 600
215 #define D_INO(de) (de)->d_ino 262 #define D_INO(de) (de)->d_ino
… …
278#endif 325#endif
279 326
280/* buffer size for various temporary buffers */ 327/* buffer size for various temporary buffers */
281#define EIO_BUFSIZE 65536 328#define EIO_BUFSIZE 65536
282 329
283#define dBUF \ 330#define dBUF \
284 char *eio_buf = malloc (EIO_BUFSIZE); \ 331 char *eio_buf = malloc (EIO_BUFSIZE); \
285 errno = ENOMEM; \ 332 errno = ENOMEM; \
286 if (!eio_buf) \ 333 if (!eio_buf) \
287 return -1 334 return -1
288 335
289#define FUBd \ 336#define FUBd \
290 free (eio_buf) 337 free (eio_buf)
291 338
292#define EIO_TICKS ((1000000 + 1023) >> 10) 339/*****************************************************************************/
340
341struct etp_tmpbuf;
342
343#if _POSIX_VERSION >= 200809L
344 #define HAVE_AT 1
345 #define WD2FD(wd) ((wd) ? (wd)->fd : AT_FDCWD)
346 #ifndef O_SEARCH
347 #define O_SEARCH O_RDONLY
348 #endif
349#else
350 #define HAVE_AT 0
351 static const char *wd_expand (struct etp_tmpbuf *tmpbuf, eio_wd wd, const char *path);
352#endif
353
354struct eio_pwd
355{
356#if HAVE_AT
357 int fd;
358#endif
359 int len;
360 char str[1]; /* actually, a 0-terminated canonical path */
361};
362
363/*****************************************************************************/
293 364
294#define ETP_PRI_MIN EIO_PRI_MIN 365#define ETP_PRI_MIN EIO_PRI_MIN
295#define ETP_PRI_MAX EIO_PRI_MAX 366#define ETP_PRI_MAX EIO_PRI_MAX
367
368#define ETP_TYPE_QUIT -1
369#define ETP_TYPE_GROUP EIO_GROUP
296 370
297struct etp_worker; 371struct etp_worker;
298 372
299#define ETP_REQ eio_req 373#define ETP_REQ eio_req
300#define ETP_DESTROY(req) eio_destroy (req) 374#define ETP_DESTROY(req) eio_destroy (req)
301static int eio_finish (eio_req *req); 375static int eio_finish (eio_req *req);
302#define ETP_FINISH(req) eio_finish (req) 376#define ETP_FINISH(req) eio_finish (req)
303static void eio_execute (struct etp_worker *self, eio_req *req); 377static void eio_execute (struct etp_worker *self, eio_req *req);
304#define ETP_EXECUTE(wrk,req) eio_execute (wrk,req) 378#define ETP_EXECUTE(wrk,req) eio_execute (wrk, req)
305 379
306/*****************************************************************************/ 380#include "etp.c"
307
308#define ETP_NUM_PRI (ETP_PRI_MAX - ETP_PRI_MIN + 1)
309
310/* calculate time difference in ~1/EIO_TICKS of a second */
311ecb_inline int
312tvdiff (struct timeval *tv1, struct timeval *tv2)
313{
314 return (tv2->tv_sec - tv1->tv_sec ) * EIO_TICKS
315 + ((tv2->tv_usec - tv1->tv_usec) >> 10);
316}
317
318static unsigned int started, idle, wanted = 4;
319
320static void (*want_poll_cb) (void);
321static void (*done_poll_cb) (void);
322
323static unsigned int max_poll_time; /* reslock */
324static unsigned int max_poll_reqs; /* reslock */
325
326static volatile unsigned int nreqs; /* reqlock */
327static volatile unsigned int nready; /* reqlock */
328static volatile unsigned int npending; /* reqlock */
329static volatile 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 */
331
332static xmutex_t wrklock;
333static xmutex_t reslock;
334static xmutex_t reqlock;
335static xcond_t reqwait;
336
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
347{
348 /* locked by wrklock */
349 struct etp_worker *prev, *next;
350
351 xthread_t tid;
352
353 /* locked by reslock, reqlock or wrklock */
354 ETP_REQ *req; /* currently processed request */
355
356#ifdef ETP_WORKER_COMMON
357 ETP_WORKER_COMMON
358#endif
359} etp_worker;
360
361static etp_worker wrk_first; /* NOT etp */
362
363#define ETP_WORKER_LOCK(wrk) X_LOCK (wrklock)
364#define ETP_WORKER_UNLOCK(wrk) X_UNLOCK (wrklock)
365
366/* worker threads management */
367
368static void ecb_cold
369etp_worker_clear (etp_worker *wrk)
370{
371}
372
373static void ecb_cold
374etp_worker_free (etp_worker *wrk)
375{
376 wrk->next->prev = wrk->prev;
377 wrk->prev->next = wrk->next;
378
379 free (wrk);
380}
381
382static unsigned int
383etp_nreqs (void)
384{
385 int retval;
386 if (WORDACCESS_UNSAFE) X_LOCK (reqlock);
387 retval = nreqs;
388 if (WORDACCESS_UNSAFE) X_UNLOCK (reqlock);
389 return retval;
390}
391
392static unsigned int
393etp_nready (void)
394{
395 unsigned int retval;
396
397 if (WORDACCESS_UNSAFE) X_LOCK (reqlock);
398 retval = nready;
399 if (WORDACCESS_UNSAFE) X_UNLOCK (reqlock);
400
401 return retval;
402}
403
404static unsigned int
405etp_npending (void)
406{
407 unsigned int retval;
408
409 if (WORDACCESS_UNSAFE) X_LOCK (reqlock);
410 retval = npending;
411 if (WORDACCESS_UNSAFE) X_UNLOCK (reqlock);
412
413 return retval;
414}
415
416static unsigned int
417etp_nthreads (void)
418{
419 unsigned int retval;
420
421 if (WORDACCESS_UNSAFE) X_LOCK (reqlock);
422 retval = started;
423 if (WORDACCESS_UNSAFE) X_UNLOCK (reqlock);
424
425 return retval;
426}
427
428/*
429 * a somewhat faster data structure might be nice, but
430 * with 8 priorities this actually needs <20 insns
431 * per shift, the most expensive operation.
432 */
433typedef struct {
434 ETP_REQ *qs[ETP_NUM_PRI], *qe[ETP_NUM_PRI]; /* qstart, qend */
435 int size;
436} etp_reqq;
437
438static etp_reqq req_queue;
439static etp_reqq res_queue;
440
441static void ecb_noinline ecb_cold
442reqq_init (etp_reqq *q)
443{
444 int pri;
445
446 for (pri = 0; pri < ETP_NUM_PRI; ++pri)
447 q->qs[pri] = q->qe[pri] = 0;
448
449 q->size = 0;
450}
451
452static int ecb_noinline
453reqq_push (etp_reqq *q, ETP_REQ *req)
454{
455 int pri = req->pri;
456 req->next = 0;
457
458 if (q->qe[pri])
459 {
460 q->qe[pri]->next = req;
461 q->qe[pri] = req;
462 }
463 else
464 q->qe[pri] = q->qs[pri] = req;
465
466 return q->size++;
467}
468
469static ETP_REQ * ecb_noinline
470reqq_shift (etp_reqq *q)
471{
472 int pri;
473
474 if (!q->size)
475 return 0;
476
477 --q->size;
478
479 for (pri = ETP_NUM_PRI; pri--; )
480 {
481 eio_req *req = q->qs[pri];
482
483 if (req)
484 {
485 if (!(q->qs[pri] = (eio_req *)req->next))
486 q->qe[pri] = 0;
487
488 return req;
489 }
490 }
491
492 abort ();
493}
494
495static int ecb_cold
496etp_init (void (*want_poll)(void), void (*done_poll)(void))
497{
498 X_MUTEX_CREATE (wrklock);
499 X_MUTEX_CREATE (reslock);
500 X_MUTEX_CREATE (reqlock);
501 X_COND_CREATE (reqwait);
502
503 reqq_init (&req_queue);
504 reqq_init (&res_queue);
505
506 wrk_first.next =
507 wrk_first.prev = &wrk_first;
508
509 started = 0;
510 idle = 0;
511 nreqs = 0;
512 nready = 0;
513 npending = 0;
514
515 want_poll_cb = want_poll;
516 done_poll_cb = done_poll;
517
518 return 0;
519}
520
521X_THREAD_PROC (etp_proc);
522
523static void ecb_cold
524etp_start_thread (void)
525{
526 etp_worker *wrk = calloc (1, sizeof (etp_worker));
527
528 /*TODO*/
529 assert (("unable to allocate worker thread data", wrk));
530
531 X_LOCK (wrklock);
532
533 if (thread_create (&wrk->tid, etp_proc, (void *)wrk))
534 {
535 wrk->prev = &wrk_first;
536 wrk->next = wrk_first.next;
537 wrk_first.next->prev = wrk;
538 wrk_first.next = wrk;
539 ++started;
540 }
541 else
542 free (wrk);
543
544 X_UNLOCK (wrklock);
545}
546
547static void
548etp_maybe_start_thread (void)
549{
550 if (ecb_expect_true (etp_nthreads () >= wanted))
551 return;
552
553 /* todo: maybe use idle here, but might be less exact */
554 if (ecb_expect_true (0 <= (int)etp_nthreads () + (int)etp_npending () - (int)etp_nreqs ()))
555 return;
556
557 etp_start_thread ();
558}
559
560static void ecb_cold
561etp_end_thread (void)
562{
563 eio_req *req = calloc (1, sizeof (eio_req));
564
565 req->type = -1;
566 req->pri = ETP_PRI_MAX - ETP_PRI_MIN;
567
568 X_LOCK (reqlock);
569 reqq_push (&req_queue, req);
570 X_COND_SIGNAL (reqwait);
571 X_UNLOCK (reqlock);
572
573 X_LOCK (wrklock);
574 --started;
575 X_UNLOCK (wrklock);
576}
577
578static int
579etp_poll (void)
580{
581 unsigned int maxreqs;
582 unsigned int maxtime;
583 struct timeval tv_start, tv_now;
584
585 X_LOCK (reslock);
586 maxreqs = max_poll_reqs;
587 maxtime = max_poll_time;
588 X_UNLOCK (reslock);
589
590 if (maxtime)
591 gettimeofday (&tv_start, 0);
592
593 for (;;)
594 {
595 ETP_REQ *req;
596
597 etp_maybe_start_thread ();
598
599 X_LOCK (reslock);
600 req = reqq_shift (&res_queue);
601
602 if (req)
603 {
604 --npending;
605
606 if (!res_queue.size && done_poll_cb)
607 done_poll_cb ();
608 }
609
610 X_UNLOCK (reslock);
611
612 if (!req)
613 return 0;
614
615 X_LOCK (reqlock);
616 --nreqs;
617 X_UNLOCK (reqlock);
618
619 if (ecb_expect_false (req->type == EIO_GROUP && req->size))
620 {
621 req->int1 = 1; /* mark request as delayed */
622 continue;
623 }
624 else
625 {
626 int res = ETP_FINISH (req);
627 if (ecb_expect_false (res))
628 return res;
629 }
630
631 if (ecb_expect_false (maxreqs && !--maxreqs))
632 break;
633
634 if (maxtime)
635 {
636 gettimeofday (&tv_now, 0);
637
638 if (tvdiff (&tv_start, &tv_now) >= maxtime)
639 break;
640 }
641 }
642
643 errno = EAGAIN;
644 return -1;
645}
646
647static void
648etp_cancel (ETP_REQ *req)
649{
650 req->cancelled = 1;
651
652 eio_grp_cancel (req);
653}
654
655static void
656etp_submit (ETP_REQ *req)
657{
658 req->pri -= ETP_PRI_MIN;
659
660 if (ecb_expect_false (req->pri < ETP_PRI_MIN - ETP_PRI_MIN)) req->pri = ETP_PRI_MIN - ETP_PRI_MIN;
661 if (ecb_expect_false (req->pri > ETP_PRI_MAX - ETP_PRI_MIN)) req->pri = ETP_PRI_MAX - ETP_PRI_MIN;
662
663 if (ecb_expect_false (req->type == EIO_GROUP))
664 {
665 /* I hope this is worth it :/ */
666 X_LOCK (reqlock);
667 ++nreqs;
668 X_UNLOCK (reqlock);
669
670 X_LOCK (reslock);
671
672 ++npending;
673
674 if (!reqq_push (&res_queue, req) && want_poll_cb)
675 want_poll_cb ();
676
677 X_UNLOCK (reslock);
678 }
679 else
680 {
681 X_LOCK (reqlock);
682 ++nreqs;
683 ++nready;
684 reqq_push (&req_queue, req);
685 X_COND_SIGNAL (reqwait);
686 X_UNLOCK (reqlock);
687
688 etp_maybe_start_thread ();
689 }
690}
691
692static void ecb_cold
693etp_set_max_poll_time (double nseconds)
694{
695 if (WORDACCESS_UNSAFE) X_LOCK (reslock);
696 max_poll_time = nseconds * EIO_TICKS;
697 if (WORDACCESS_UNSAFE) X_UNLOCK (reslock);
698}
699
700static void ecb_cold
701etp_set_max_poll_reqs (unsigned int maxreqs)
702{
703 if (WORDACCESS_UNSAFE) X_LOCK (reslock);
704 max_poll_reqs = maxreqs;
705 if (WORDACCESS_UNSAFE) X_UNLOCK (reslock);
706}
707
708static void ecb_cold
709etp_set_max_idle (unsigned int nthreads)
710{
711 if (WORDACCESS_UNSAFE) X_LOCK (reqlock);
712 max_idle = nthreads;
713 if (WORDACCESS_UNSAFE) X_UNLOCK (reqlock);
714}
715
716static void ecb_cold
717etp_set_idle_timeout (unsigned int seconds)
718{
719 if (WORDACCESS_UNSAFE) X_LOCK (reqlock);
720 idle_timeout = seconds;
721 if (WORDACCESS_UNSAFE) X_UNLOCK (reqlock);
722}
723
724static void ecb_cold
725etp_set_min_parallel (unsigned int nthreads)
726{
727 if (wanted < nthreads)
728 wanted = nthreads;
729}
730
731static void ecb_cold
732etp_set_max_parallel (unsigned int nthreads)
733{
734 if (wanted > nthreads)
735 wanted = nthreads;
736
737 while (started > wanted)
738 etp_end_thread ();
739}
740 381
741/*****************************************************************************/ 382/*****************************************************************************/
742 383
743static void 384static void
744grp_try_feed (eio_req *grp) 385grp_try_feed (eio_req *grp)
… …
811} 452}
812 453
813void 454void
814eio_grp_cancel (eio_req *grp) 455eio_grp_cancel (eio_req *grp)
815{ 456{
816 for (grp = grp->grp_first; grp; grp = grp->grp_next)
817 eio_cancel (grp); 457 etp_grp_cancel (grp);
818} 458}
819 459
820void 460void
821eio_cancel (eio_req *req) 461eio_cancel (eio_req *req)
822{ 462{
… …
894 return etp_poll (); 534 return etp_poll ();
895} 535}
896 536
897/*****************************************************************************/ 537/*****************************************************************************/
898/* work around various missing functions */ 538/* work around various missing functions */
899
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 539
939#ifndef HAVE_UTIMES 540#ifndef HAVE_UTIMES
940 541
941# undef utimes 542# undef utimes
942# define utimes(path,times) eio__utimes (path, times) 543# define utimes(path,times) eio__utimes (path, times)
… …
984 int res; 585 int res;
985 586
986#if HAVE_SYS_SYNCFS 587#if HAVE_SYS_SYNCFS
987 res = (int)syscall (__NR_syncfs, (int)(fd)); 588 res = (int)syscall (__NR_syncfs, (int)(fd));
988#else 589#else
989 res = -1; 590 res = EIO_ENOSYS ();
990 errno = ENOSYS;
991#endif 591#endif
992 592
993 if (res < 0 && errno == ENOSYS && fd >= 0) 593 if (res < 0 && errno == ENOSYS && fd >= 0)
994 sync (); 594 sync ();
995 595
… …
1025} 625}
1026 626
1027static int 627static int
1028eio__fallocate (int fd, int mode, off_t offset, size_t len) 628eio__fallocate (int fd, int mode, off_t offset, size_t len)
1029{ 629{
1030#if HAVE_FALLOCATE 630#if HAVE_LINUX_FALLOCATE
1031 return fallocate (fd, mode, offset, len); 631 return fallocate (fd, mode, offset, len);
1032#else 632#else
1033 errno = ENOSYS; 633 return EIO_ENOSYS ();
1034 return -1;
1035#endif 634#endif
1036} 635}
1037 636
1038#if !HAVE_READAHEAD 637#if !HAVE_READAHEAD
1039# undef readahead 638# undef readahead
… …
1054 todo -= len; 653 todo -= len;
1055 } 654 }
1056 655
1057 FUBd; 656 FUBd;
1058 657
1059 errno = 0; 658 /* linux's readahead basically only fails for EBADF or EINVAL (not mmappable) */
659 /* but not for e.g. EIO or eof, so we also never fail */
1060 return count; 660 return 0;
1061} 661}
1062 662
1063#endif 663#endif
1064 664
1065/* sendfile always needs emulation */ 665/* sendfile always needs emulation */
… …
1100 700
1101 /* according to source inspection, this is correct, and useful behaviour */ 701 /* according to source inspection, this is correct, and useful behaviour */
1102 if (sbytes) 702 if (sbytes)
1103 res = sbytes; 703 res = sbytes;
1104 704
1105# elif defined (__APPLE__) 705# elif defined __APPLE__
1106 off_t sbytes = count; 706 off_t sbytes = count;
1107 res = sendfile (ifd, ofd, offset, &sbytes, 0, 0); 707 res = sendfile (ifd, ofd, offset, &sbytes, 0, 0);
1108 708
1109 /* according to the manpage, sbytes is always valid */ 709 /* according to the manpage, sbytes is always valid */
1110 if (sbytes) 710 if (sbytes)
… …
1137 HANDLE h = TO_SOCKET (ifd); 737 HANDLE h = TO_SOCKET (ifd);
1138 SetFilePointer (h, offset, 0, FILE_BEGIN); 738 SetFilePointer (h, offset, 0, FILE_BEGIN);
1139 res = TransmitFile (TO_SOCKET (ofd), h, count, 0, 0, 0, 0); 739 res = TransmitFile (TO_SOCKET (ofd), h, count, 0, 0, 0, 0);
1140 740
1141#else 741#else
1142 res = -1; 742 res = EIO_ENOSYS ();
1143 errno = ENOSYS;
1144#endif 743#endif
1145 744
1146 /* we assume sendfile can copy at least 128mb in one go */ 745 /* we assume sendfile can copy at least 128mb in one go */
1147 if (res <= 128 * 1024 * 1024) 746 if (res <= 128 * 1024 * 1024)
1148 { 747 {
… …
1335 934
1336/*****************************************************************************/ 935/*****************************************************************************/
1337/* requests implemented outside eio_execute, because they are so large */ 936/* requests implemented outside eio_execute, because they are so large */
1338 937
1339static void 938static void
1340eio__realpath (eio_req *req, etp_worker *self) 939eio__lseek (eio_req *req)
1341{ 940{
1342 char *rel = req->ptr1; 941 /* this usually gets optimised away completely, or your compiler sucks, */
942 /* or the whence constants really are not 0, 1, 2 */
943 int whence = req->int2 == EIO_SEEK_SET ? SEEK_SET
944 : req->int2 == EIO_SEEK_CUR ? SEEK_CUR
945 : req->int2 == EIO_SEEK_END ? SEEK_END
946 : req->int2;
947
948 req->offs = lseek (req->int1, req->offs, whence);
949 req->result = req->offs == (off_t)-1 ? -1 : 0;
950}
951
952/* result will always end up in tmpbuf, there is always space for adding a 0-byte */
953static int
954eio__realpath (struct etp_tmpbuf *tmpbuf, eio_wd wd, const char *path)
955{
1343 char *res; 956 char *res;
957 const char *rel = path;
1344 char *tmp1, *tmp2; 958 char *tmp1, *tmp2;
1345#if SYMLOOP_MAX > 32 959#if SYMLOOP_MAX > 32
1346 int symlinks = SYMLOOP_MAX; 960 int symlinks = SYMLOOP_MAX;
1347#else 961#else
1348 int symlinks = 32; 962 int symlinks = 32;
1349#endif 963#endif
1350 964
1351 req->result = -1;
1352
1353 errno = EINVAL; 965 errno = EINVAL;
1354 if (!rel) 966 if (!rel)
1355 return; 967 return -1;
1356 968
1357 errno = ENOENT; 969 errno = ENOENT;
1358 if (!*rel) 970 if (!*rel)
1359 return; 971 return -1;
1360 972
1361 if (!req->ptr2) 973 res = etp_tmpbuf_get (tmpbuf, PATH_MAX * 3);
1362 { 974#ifdef _WIN32
1363 X_LOCK (wrklock); 975 if (_access (rel, 4) != 0)
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; 976 return -1;
1371 }
1372 977
1373 res = req->ptr2; 978 symlinks = GetFullPathName (rel, PATH_MAX * 3, res, 0);
979
980 errno = ENAMETOOLONG;
981 if (symlinks >= PATH_MAX * 3)
982 return -1;
983
984 errno = EIO;
985 if (symlinks <= 0)
986 return -1;
987
988 return symlinks;
989
990#else
1374 tmp1 = res + PATH_MAX; 991 tmp1 = res + PATH_MAX;
1375 tmp2 = tmp1 + PATH_MAX; 992 tmp2 = tmp1 + PATH_MAX;
1376 993
1377#if 0 /* disabled, the musl way to do things is just too racy */ 994#if 0 /* disabled, the musl way to do things is just too racy */
1378#if __linux && defined(O_NONBLOCK) && defined(O_NOATIME) 995#if __linux && defined(O_NONBLOCK) && defined(O_NOATIME)
… …
1382 999
1383 if (fd >= 0) 1000 if (fd >= 0)
1384 { 1001 {
1385 sprintf (tmp1, "/proc/self/fd/%d", fd); 1002 sprintf (tmp1, "/proc/self/fd/%d", fd);
1386 req->result = readlink (tmp1, res, PATH_MAX); 1003 req->result = readlink (tmp1, res, PATH_MAX);
1004 /* here we should probably stat the open file and the disk file, to make sure they still match */
1387 close (fd); 1005 close (fd);
1388
1389 /* here we should probably stat the open file and the disk file, to make sure they still match */
1390 1006
1391 if (req->result > 0) 1007 if (req->result > 0)
1392 goto done; 1008 goto done;
1393 } 1009 }
1394 else if (errno == ELOOP || errno == ENAMETOOLONG || errno == ENOENT || errno == ENOTDIR || errno == EIO) 1010 else if (errno == ELOOP || errno == ENAMETOOLONG || errno == ENOENT || errno == ENOTDIR || errno == EIO)
1395 return; 1011 return -1;
1396 } 1012 }
1397#endif 1013#endif
1398#endif 1014#endif
1399 1015
1400 if (*rel != '/') 1016 if (*rel != '/')
1401 { 1017 {
1018 int len;
1019
1020 errno = ENOENT;
1021 if (wd == EIO_INVALID_WD)
1022 return -1;
1023
1024 if (wd == EIO_CWD)
1025 {
1402 if (!getcwd (res, PATH_MAX)) 1026 if (!getcwd (res, PATH_MAX))
1403 return; 1027 return -1;
1028
1029 len = strlen (res);
1030 }
1031 else
1032 memcpy (res, wd->str, len = wd->len);
1404 1033
1405 if (res [1]) /* only use if not / */ 1034 if (res [1]) /* only use if not / */
1406 res += strlen (res); 1035 res += len;
1407 } 1036 }
1408 1037
1409 while (*rel) 1038 while (*rel)
1410 { 1039 {
1411 eio_ssize_t len, linklen; 1040 eio_ssize_t len, linklen;
1412 char *beg = rel; 1041 const char *beg = rel;
1413 1042
1414 while (*rel && *rel != '/') 1043 while (*rel && *rel != '/')
1415 ++rel; 1044 ++rel;
1416 1045
1417 len = rel - beg; 1046 len = rel - beg;
… …
1429 1058
1430 if (beg [1] == '.' && len == 2) 1059 if (beg [1] == '.' && len == 2)
1431 { 1060 {
1432 /* .. - back up one component, if possible */ 1061 /* .. - back up one component, if possible */
1433 1062
1434 while (res != req->ptr2) 1063 while (res != tmpbuf->ptr)
1435 if (*--res == '/') 1064 if (*--res == '/')
1436 break; 1065 break;
1437 1066
1438 continue; 1067 continue;
1439 } 1068 }
1440 } 1069 }
1441 1070
1442 errno = ENAMETOOLONG; 1071 errno = ENAMETOOLONG;
1443 if (res + 1 + len + 1 >= tmp1) 1072 if (res + 1 + len + 1 >= tmp1)
1444 return; 1073 return -1;
1445 1074
1446 /* copy one component */ 1075 /* copy one component */
1447 *res = '/'; 1076 *res = '/';
1448 memcpy (res + 1, beg, len); 1077 memcpy (res + 1, beg, len);
1449 1078
1450 /* zero-terminate, for readlink */ 1079 /* zero-terminate, for readlink */
1451 res [len + 1] = 0; 1080 res [len + 1] = 0;
1452 1081
1453 /* now check if it's a symlink */ 1082 /* now check if it's a symlink */
1454 linklen = readlink (req->ptr2, tmp1, PATH_MAX); 1083 linklen = readlink (tmpbuf->ptr, tmp1, PATH_MAX);
1455 1084
1456 if (linklen < 0) 1085 if (linklen < 0)
1457 { 1086 {
1458 if (errno != EINVAL) 1087 if (errno != EINVAL)
1459 return; 1088 return -1;
1460 1089
1461 /* it's a normal directory. hopefully */ 1090 /* it's a normal directory. hopefully */
1462 res += len + 1; 1091 res += len + 1;
1463 } 1092 }
1464 else 1093 else
… …
1466 /* yay, it was a symlink - build new path in tmp2 */ 1095 /* yay, it was a symlink - build new path in tmp2 */
1467 int rellen = strlen (rel); 1096 int rellen = strlen (rel);
1468 1097
1469 errno = ENAMETOOLONG; 1098 errno = ENAMETOOLONG;
1470 if (linklen + 1 + rellen >= PATH_MAX) 1099 if (linklen + 1 + rellen >= PATH_MAX)
1471 return; 1100 return -1;
1472 1101
1473 errno = ELOOP; 1102 errno = ELOOP;
1474 if (!--symlinks) 1103 if (!--symlinks)
1475 return; 1104 return -1;
1476 1105
1477 if (*tmp1 == '/') 1106 if (*tmp1 == '/')
1478 res = req->ptr2; /* symlink resolves to an absolute path */ 1107 res = tmpbuf->ptr; /* symlink resolves to an absolute path */
1479 1108
1480 /* we need to be careful, as rel might point into tmp2 already */ 1109 /* we need to be careful, as rel might point into tmp2 already */
1481 memmove (tmp2 + linklen + 1, rel, rellen + 1); 1110 memmove (tmp2 + linklen + 1, rel, rellen + 1);
1482 tmp2 [linklen] = '/'; 1111 tmp2 [linklen] = '/';
1483 memcpy (tmp2, tmp1, linklen); 1112 memcpy (tmp2, tmp1, linklen);
… …
1485 rel = tmp2; 1114 rel = tmp2;
1486 } 1115 }
1487 } 1116 }
1488 1117
1489 /* special case for the lone root path */ 1118 /* special case for the lone root path */
1490 if (res == req->ptr2) 1119 if (res == tmpbuf->ptr)
1491 *res++ = '/'; 1120 *res++ = '/';
1492 1121
1493 req->result = res - (char *)req->ptr2; 1122 return res - (char *)tmpbuf->ptr;
1494 1123#endif
1495done:
1496 req->ptr2 = realloc (req->ptr2, req->result); /* trade time for space savings */
1497} 1124}
1498 1125
1499static signed char 1126static signed char
1500eio_dent_cmp (const eio_dirent *a, const eio_dirent *b) 1127eio_dent_cmp (const eio_dirent *a, const eio_dirent *b)
1501{ 1128{
… …
1689#ifdef _WIN32 1316#ifdef _WIN32
1690 { 1317 {
1691 int len = strlen ((const char *)req->ptr1); 1318 int len = strlen ((const char *)req->ptr1);
1692 char *path = malloc (MAX_PATH); 1319 char *path = malloc (MAX_PATH);
1693 const char *fmt; 1320 const char *fmt;
1321 const char *reqpath = wd_expand (&self->tmpbuf, req->wd, req->ptr1);
1694 1322
1695 if (!len) 1323 if (!len)
1696 fmt = "./*"; 1324 fmt = "./*";
1697 else if (((const char *)req->ptr1)[len - 1] == '/' || ((const char *)req->ptr1)[len - 1] == '\\') 1325 else if (reqpath[len - 1] == '/' || reqpath[len - 1] == '\\')
1698 fmt = "%s*"; 1326 fmt = "%s*";
1699 else 1327 else
1700 fmt = "%s/*"; 1328 fmt = "%s/*";
1701 1329
1702 _snprintf (path, MAX_PATH, fmt, (const char *)req->ptr1); 1330 _snprintf (path, MAX_PATH, fmt, reqpath);
1703 dirp = FindFirstFile (path, &entp); 1331 dirp = FindFirstFile (path, &entp);
1704 free (path); 1332 free (path);
1705 1333
1706 if (dirp == INVALID_HANDLE_VALUE) 1334 if (dirp == INVALID_HANDLE_VALUE)
1707 { 1335 {
1708 dirp = 0;
1709
1710 /* should steal _dosmaperr */ 1336 /* should steal _dosmaperr */
1711 switch (GetLastError ()) 1337 switch (GetLastError ())
1712 { 1338 {
1713 case ERROR_FILE_NOT_FOUND: 1339 case ERROR_FILE_NOT_FOUND:
1714 req->result = 0; 1340 req->result = 0;
1715 break; 1341 break;
1716 1342
1717 case ERROR_INVALID_NAME: 1343 case ERROR_INVALID_NAME:
1718 case ERROR_PATH_NOT_FOUND: 1344 case ERROR_PATH_NOT_FOUND:
1719 case ERROR_NO_MORE_FILES: 1345 case ERROR_NO_MORE_FILES:
1720 errno = ENOENT; 1346 errno = ENOENT;
1721 break; 1347 break;
1722 1348
1723 case ERROR_NOT_ENOUGH_MEMORY: 1349 case ERROR_NOT_ENOUGH_MEMORY:
1724 errno = ENOMEM; 1350 errno = ENOMEM;
1725 break; 1351 break;
1726 1352
1727 default: 1353 default:
1728 errno = EINVAL; 1354 errno = EINVAL;
1729 break; 1355 break;
1730 } 1356 }
1357
1358 return;
1731 } 1359 }
1732 } 1360 }
1733#else 1361#else
1362 #if HAVE_AT
1363 if (req->wd)
1364 {
1365 int fd = openat (WD2FD (req->wd), req->ptr1, O_CLOEXEC | O_SEARCH | O_DIRECTORY);
1366
1367 if (fd < 0)
1368 return;
1369
1370 dirp = fdopendir (fd);
1371
1372 if (!dirp)
1373 close (fd);
1374 }
1375 else
1734 dirp = opendir (req->ptr1); 1376 dirp = opendir (req->ptr1);
1377 #else
1378 dirp = opendir (wd_expand (&self->tmpbuf, req->wd, req->ptr1));
1379 #endif
1380
1381 if (!dirp)
1382 return;
1735#endif 1383#endif
1736 1384
1737 if (req->flags & EIO_FLAG_PTR1_FREE) 1385 if (req->flags & EIO_FLAG_PTR1_FREE)
1738 free (req->ptr1); 1386 free (req->ptr1);
1739 1387
1740 req->flags |= EIO_FLAG_PTR1_FREE | EIO_FLAG_PTR2_FREE; 1388 req->flags |= EIO_FLAG_PTR1_FREE | EIO_FLAG_PTR2_FREE;
1741 req->ptr1 = dents = flags ? malloc (dentalloc * sizeof (eio_dirent)) : 0; 1389 req->ptr1 = dents = flags ? malloc (dentalloc * sizeof (eio_dirent)) : 0;
1742 req->ptr2 = names = malloc (namesalloc); 1390 req->ptr2 = names = malloc (namesalloc);
1743 1391
1744 if (dirp && names && (!flags || dents)) 1392 if (!names || (flags && !dents))
1393 return;
1394
1745 for (;;) 1395 for (;;)
1746 { 1396 {
1747 int done; 1397 int done;
1748 1398
1749#ifdef _WIN32 1399#ifdef _WIN32
1750 done = !dirp; 1400 done = !dirp;
1751#else 1401#else
1752 errno = 0; 1402 errno = 0;
1753 entp = readdir (dirp); 1403 entp = readdir (dirp);
1754 done = !entp; 1404 done = !entp;
1755#endif 1405#endif
1756 1406
1757 if (done) 1407 if (done)
1758 { 1408 {
1759#ifndef _WIN32 1409#ifndef _WIN32
1760 int old_errno = errno; 1410 int old_errno = errno;
1761 closedir (dirp); 1411 closedir (dirp);
1762 errno = old_errno; 1412 errno = old_errno;
1763 1413
1764 if (errno) 1414 if (errno)
1765 break; 1415 break;
1766#endif 1416#endif
1767 1417
1768 /* sort etc. */ 1418 /* sort etc. */
1769 req->int1 = flags; 1419 req->int1 = flags;
1770 req->result = dentoffs; 1420 req->result = dentoffs;
1771 1421
1772 if (flags & EIO_READDIR_STAT_ORDER) 1422 if (flags & EIO_READDIR_STAT_ORDER)
1773 eio_dent_sort (dents, dentoffs, flags & EIO_READDIR_DIRS_FIRST ? 7 : 0, inode_bits); 1423 eio_dent_sort (dents, dentoffs, flags & EIO_READDIR_DIRS_FIRST ? 7 : 0, inode_bits);
1774 else if (flags & EIO_READDIR_DIRS_FIRST) 1424 else if (flags & EIO_READDIR_DIRS_FIRST)
1775 if (flags & EIO_READDIR_FOUND_UNKNOWN) 1425 if (flags & EIO_READDIR_FOUND_UNKNOWN)
1776 eio_dent_sort (dents, dentoffs, 7, inode_bits); /* sort by score and inode */ 1426 eio_dent_sort (dents, dentoffs, 7, inode_bits); /* sort by score and inode */
1777 else 1427 else
1428 {
1429 /* in this case, all is known, and we just put dirs first and sort them */
1430 eio_dirent *oth = dents + dentoffs;
1431 eio_dirent *dir = dents;
1432
1433 /* now partition dirs to the front, and non-dirs to the back */
1434 /* by walking from both sides and swapping if necessary */
1435 while (oth > dir)
1436 {
1437 if (dir->type == EIO_DT_DIR)
1438 ++dir;
1439 else if ((--oth)->type == EIO_DT_DIR)
1440 {
1441 eio_dirent tmp = *dir; *dir = *oth; *oth = tmp;
1442
1443 ++dir;
1444 }
1445 }
1446
1447 /* now sort the dirs only (dirs all have the same score) */
1448 eio_dent_sort (dents, dir - dents, 0, inode_bits);
1449 }
1450
1451 break;
1452 }
1453
1454 /* now add the entry to our list(s) */
1455 name = D_NAME (entp);
1456
1457 /* skip . and .. entries */
1458 if (name [0] != '.' || (name [1] && (name [1] != '.' || name [2])))
1459 {
1460 int len = D_NAMLEN (entp) + 1;
1461
1462 while (ecb_expect_false (namesoffs + len > namesalloc))
1463 {
1464 namesalloc *= 2;
1465 req->ptr2 = names = realloc (names, namesalloc);
1466
1467 if (!names)
1468 break;
1469 }
1470
1471 memcpy (names + namesoffs, name, len);
1472
1473 if (dents)
1474 {
1475 struct eio_dirent *ent;
1476
1477 if (ecb_expect_false (dentoffs == dentalloc))
1778 { 1478 {
1779 /* in this case, all is known, and we just put dirs first and sort them */ 1479 dentalloc *= 2;
1480 req->ptr1 = dents = realloc (dents, dentalloc * sizeof (eio_dirent));
1481
1482 if (!dents)
1483 break;
1484 }
1485
1780 eio_dirent *oth = dents + dentoffs; 1486 ent = dents + dentoffs;
1781 eio_dirent *dir = dents;
1782 1487
1783 /* now partition dirs to the front, and non-dirs to the back */ 1488 ent->nameofs = namesoffs; /* rather dirtily we store the offset in the pointer */
1784 /* by walking from both sides and swapping if necessary */ 1489 ent->namelen = len - 1;
1785 while (oth > dir) 1490 ent->inode = D_INO (entp);
1491
1492 inode_bits |= ent->inode;
1493
1494 switch (D_TYPE (entp))
1495 {
1496 default:
1497 ent->type = EIO_DT_UNKNOWN;
1498 flags |= EIO_READDIR_FOUND_UNKNOWN;
1499 break;
1500
1501 #ifdef DT_FIFO
1502 case DT_FIFO: ent->type = EIO_DT_FIFO; break;
1503 #endif
1504 #ifdef DT_CHR
1505 case DT_CHR: ent->type = EIO_DT_CHR; break;
1506 #endif
1507 #ifdef DT_MPC
1508 case DT_MPC: ent->type = EIO_DT_MPC; break;
1509 #endif
1510 #ifdef DT_DIR
1511 case DT_DIR: ent->type = EIO_DT_DIR; break;
1512 #endif
1513 #ifdef DT_NAM
1514 case DT_NAM: ent->type = EIO_DT_NAM; break;
1515 #endif
1516 #ifdef DT_BLK
1517 case DT_BLK: ent->type = EIO_DT_BLK; break;
1518 #endif
1519 #ifdef DT_MPB
1520 case DT_MPB: ent->type = EIO_DT_MPB; break;
1521 #endif
1522 #ifdef DT_REG
1523 case DT_REG: ent->type = EIO_DT_REG; break;
1524 #endif
1525 #ifdef DT_NWK
1526 case DT_NWK: ent->type = EIO_DT_NWK; break;
1527 #endif
1528 #ifdef DT_CMP
1529 case DT_CMP: ent->type = EIO_DT_CMP; break;
1530 #endif
1531 #ifdef DT_LNK
1532 case DT_LNK: ent->type = EIO_DT_LNK; break;
1533 #endif
1534 #ifdef DT_SOCK
1535 case DT_SOCK: ent->type = EIO_DT_SOCK; break;
1536 #endif
1537 #ifdef DT_DOOR
1538 case DT_DOOR: ent->type = EIO_DT_DOOR; break;
1539 #endif
1540 #ifdef DT_WHT
1541 case DT_WHT: ent->type = EIO_DT_WHT; break;
1542 #endif
1543 }
1544
1545 ent->score = 7;
1546
1547 if (flags & EIO_READDIR_DIRS_FIRST)
1548 {
1549 if (ent->type == EIO_DT_UNKNOWN)
1786 { 1550 {
1787 if (dir->type == EIO_DT_DIR) 1551 if (*name == '.') /* leading dots are likely directories, and, in any case, rare */
1788 ++dir; 1552 ent->score = 1;
1789 else if ((--oth)->type == EIO_DT_DIR) 1553 else if (!strchr (name, '.')) /* absence of dots indicate likely dirs */
1790 { 1554 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 } 1555 }
1796 1556 else if (ent->type == EIO_DT_DIR)
1797 /* now sort the dirs only (dirs all have the same score) */ 1557 ent->score = 0;
1798 eio_dent_sort (dents, dir - dents, 0, inode_bits);
1799 } 1558 }
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 } 1559 }
1820 1560
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; 1561 namesoffs += len;
1912 ++dentoffs; 1562 ++dentoffs;
1913 } 1563 }
1914 1564
1915 if (EIO_CANCELLED (req)) 1565 if (EIO_CANCELLED (req))
1916 { 1566 {
1917 errno = ECANCELED; 1567 errno = ECANCELED;
1918 break; 1568 break;
1919 } 1569 }
1920 1570
1921#ifdef _WIN32 1571#ifdef _WIN32
1922 if (!FindNextFile (dirp, &entp)) 1572 if (!FindNextFile (dirp, &entp))
1923 { 1573 {
1924 FindClose (dirp); 1574 FindClose (dirp);
1925 dirp = 0; 1575 dirp = 0;
1926 } 1576 }
1927#endif 1577#endif
1928 } 1578 }
1929} 1579}
1580
1581/*****************************************************************************/
1582/* working directory stuff */
1583/* various deficiencies in the posix 2008 api force us to */
1584/* keep the absolute path in string form at all times */
1585/* fuck yeah. */
1586
1587#if !HAVE_AT
1588
1589/* a bit like realpath, but usually faster because it doesn'T have to return */
1590/* an absolute or canonical path */
1591static const char *
1592wd_expand (struct etp_tmpbuf *tmpbuf, eio_wd wd, const char *path)
1593{
1594 if (!wd || *path == '/')
1595 return path;
1596
1597 if (path [0] == '.' && !path [1])
1598 return wd->str;
1599
1600 {
1601 int l1 = wd->len;
1602 int l2 = strlen (path);
1603
1604 char *res = etp_tmpbuf_get (tmpbuf, l1 + l2 + 2);
1605
1606 memcpy (res, wd->str, l1);
1607 res [l1] = '/';
1608 memcpy (res + l1 + 1, path, l2 + 1);
1609
1610 return res;
1611 }
1612}
1613
1614#endif
1615
1616static eio_wd
1617eio__wd_open_sync (struct etp_tmpbuf *tmpbuf, eio_wd wd, const char *path)
1618{
1619 int fd;
1620 eio_wd res;
1621 int len = eio__realpath (tmpbuf, wd, path);
1622
1623 if (len < 0)
1624 return EIO_INVALID_WD;
1625
1626#if HAVE_AT
1627 fd = openat (WD2FD (wd), path, O_CLOEXEC | O_SEARCH | O_DIRECTORY);
1628
1629 if (fd < 0)
1630 return EIO_INVALID_WD;
1631#endif
1632
1633 res = malloc (sizeof (*res) + len); /* one extra 0-byte */
1634
1635#if HAVE_AT
1636 res->fd = fd;
1637#endif
1638
1639 res->len = len;
1640 memcpy (res->str, tmpbuf->ptr, len);
1641 res->str [len] = 0;
1642
1643 return res;
1644}
1645
1646eio_wd
1647eio_wd_open_sync (eio_wd wd, const char *path)
1648{
1649 struct etp_tmpbuf tmpbuf = { };
1650 wd = eio__wd_open_sync (&tmpbuf, wd, path);
1651 free (tmpbuf.ptr);
1652
1653 return wd;
1654}
1655
1656void
1657eio_wd_close_sync (eio_wd wd)
1658{
1659 if (wd != EIO_INVALID_WD && wd != EIO_CWD)
1660 {
1661 #if HAVE_AT
1662 close (wd->fd);
1663 #endif
1664 free (wd);
1665 }
1666}
1667
1668#if HAVE_AT
1669
1670/* they forgot these */
1671
1672static int
1673eio__truncateat (int dirfd, const char *path, off_t length)
1674{
1675 int fd = openat (dirfd, path, O_WRONLY | O_CLOEXEC);
1676 int res;
1677
1678 if (fd < 0)
1679 return fd;
1680
1681 res = ftruncate (fd, length);
1682 close (fd);
1683 return res;
1684}
1685
1686static int
1687eio__statvfsat (int dirfd, const char *path, struct statvfs *buf)
1688{
1689 int fd = openat (dirfd, path, O_SEARCH | O_CLOEXEC);
1690 int res;
1691
1692 if (fd < 0)
1693 return fd;
1694
1695 res = fstatvfs (fd, buf);
1696 close (fd);
1697 return res;
1698
1699}
1700
1701#endif
1930 1702
1931/*****************************************************************************/ 1703/*****************************************************************************/
1932 1704
1933#define ALLOC(len) \ 1705#define ALLOC(len) \
1934 if (!req->ptr2) \ 1706 if (!req->ptr2) \
… …
1943 req->result = -1; \ 1715 req->result = -1; \
1944 break; \ 1716 break; \
1945 } \ 1717 } \
1946 } 1718 }
1947 1719
1720static void ecb_noinline ecb_cold
1721etp_proc_init (void)
1722{
1723#if HAVE_PRCTL_SET_NAME
1724 /* provide a more sensible "thread name" */
1725 char name[16 + 1];
1726 const int namelen = sizeof (name) - 1;
1727 int len;
1728
1729 prctl (PR_GET_NAME, (unsigned long)name, 0, 0, 0);
1730 name [namelen] = 0;
1731 len = strlen (name);
1732 strcpy (name + (len <= namelen - 4 ? len : namelen - 4), "/eio");
1733 prctl (PR_SET_NAME, (unsigned long)name, 0, 0, 0);
1734#endif
1735}
1736
1737/* TODO: move somehow to etp.c */
1948X_THREAD_PROC (etp_proc) 1738X_THREAD_PROC (etp_proc)
1949{ 1739{
1950 ETP_REQ *req; 1740 ETP_REQ *req;
1951 struct timespec ts; 1741 struct timespec ts;
1952 etp_worker *self = (etp_worker *)thr_arg; 1742 etp_worker *self = (etp_worker *)thr_arg;
1953 1743
1954#if HAVE_PRCTL_SET_NAME 1744 etp_proc_init ();
1955 prctl (PR_SET_NAME, (unsigned long)"eio_thread", 0, 0, 0);
1956#endif
1957 1745
1958 /* try to distribute timeouts somewhat evenly */ 1746 /* try to distribute timeouts somewhat evenly */
1959 ts.tv_nsec = ((unsigned long)self & 1023UL) * (1000000000UL / 1024UL); 1747 ts.tv_nsec = ((unsigned long)self & 1023UL) * (1000000000UL / 1024UL);
1960 1748
1961 for (;;) 1749 for (;;)
… …
1964 1752
1965 X_LOCK (reqlock); 1753 X_LOCK (reqlock);
1966 1754
1967 for (;;) 1755 for (;;)
1968 { 1756 {
1969 self->req = req = reqq_shift (&req_queue); 1757 req = reqq_shift (&req_queue);
1970 1758
1971 if (req) 1759 if (req)
1972 break; 1760 break;
1973 1761
1974 if (ts.tv_sec == 1) /* no request, but timeout detected, let's quit */ 1762 if (ts.tv_sec == 1) /* no request, but timeout detected, let's quit */
… …
2000 1788
2001 --nready; 1789 --nready;
2002 1790
2003 X_UNLOCK (reqlock); 1791 X_UNLOCK (reqlock);
2004 1792
2005 if (req->type < 0) 1793 if (req->type == ETP_TYPE_QUIT)
2006 goto quit; 1794 goto quit;
2007 1795
2008 ETP_EXECUTE (self, req); 1796 ETP_EXECUTE (self, req);
2009 1797
2010 X_LOCK (reslock); 1798 X_LOCK (reslock);
… …
2012 ++npending; 1800 ++npending;
2013 1801
2014 if (!reqq_push (&res_queue, req) && want_poll_cb) 1802 if (!reqq_push (&res_queue, req) && want_poll_cb)
2015 want_poll_cb (); 1803 want_poll_cb ();
2016 1804
2017 self->req = 0;
2018 etp_worker_clear (self); 1805 etp_worker_clear (self);
2019 1806
2020 X_UNLOCK (reslock); 1807 X_UNLOCK (reslock);
2021 } 1808 }
2022 1809
2023quit: 1810quit:
1811 free (req);
1812
2024 X_LOCK (wrklock); 1813 X_LOCK (wrklock);
2025 etp_worker_free (self); 1814 etp_worker_free (self);
2026 X_UNLOCK (wrklock); 1815 X_UNLOCK (wrklock);
2027 1816
2028 return 0; 1817 return 0;
… …
2031/*****************************************************************************/ 1820/*****************************************************************************/
2032 1821
2033int ecb_cold 1822int ecb_cold
2034eio_init (void (*want_poll)(void), void (*done_poll)(void)) 1823eio_init (void (*want_poll)(void), void (*done_poll)(void))
2035{ 1824{
2036#if !HAVE_PREADWRITE
2037 X_MUTEX_CREATE (preadwritelock);
2038#endif
2039
2040 return etp_init (want_poll, done_poll); 1825 return etp_init (want_poll, done_poll);
2041} 1826}
2042 1827
2043ecb_inline void 1828ecb_inline void
2044eio_api_destroy (eio_req *req) 1829eio_api_destroy (eio_req *req)
2045{ 1830{
2046 free (req); 1831 free (req);
2047} 1832}
2048 1833
2049#define REQ(rtype) \ 1834#define REQ(rtype) \
2050 eio_req *req; \ 1835 eio_req *req; \
2051 \ 1836 \
2052 req = (eio_req *)calloc (1, sizeof *req); \ 1837 req = (eio_req *)calloc (1, sizeof *req); \
2053 if (!req) \ 1838 if (!req) \
2054 return 0; \ 1839 return 0; \
… …
2068 { \ 1853 { \
2069 eio_api_destroy (req); \ 1854 eio_api_destroy (req); \
2070 return 0; \ 1855 return 0; \
2071 } 1856 }
2072 1857
1858#define SINGLEDOT(ptr) (0[(char *)(ptr)] == '.' && !1[(char *)(ptr)])
1859
2073static void 1860static void
2074eio_execute (etp_worker *self, eio_req *req) 1861eio_execute (etp_worker *self, eio_req *req)
2075{ 1862{
1863#if HAVE_AT
1864 int dirfd;
1865#else
1866 const char *path;
1867#endif
1868
2076 if (ecb_expect_false (EIO_CANCELLED (req))) 1869 if (ecb_expect_false (EIO_CANCELLED (req)))
2077 { 1870 {
2078 req->result = -1; 1871 req->result = -1;
2079 req->errorno = ECANCELED; 1872 req->errorno = ECANCELED;
2080 return; 1873 return;
2081 } 1874 }
2082 1875
1876 if (ecb_expect_false (req->wd == EIO_INVALID_WD))
1877 {
1878 req->result = -1;
1879 req->errorno = ENOENT;
1880 return;
1881 }
1882
1883 if (req->type >= EIO_OPEN)
1884 {
1885 #if HAVE_AT
1886 dirfd = WD2FD (req->wd);
1887 #else
1888 path = wd_expand (&self->tmpbuf, req->wd, req->ptr1);
1889 #endif
1890 }
1891
2083 switch (req->type) 1892 switch (req->type)
2084 { 1893 {
1894 case EIO_WD_OPEN: req->wd = eio__wd_open_sync (&self->tmpbuf, req->wd, req->ptr1);
1895 req->result = req->wd == EIO_INVALID_WD ? -1 : 0;
1896 break;
1897 case EIO_WD_CLOSE: req->result = 0;
1898 eio_wd_close_sync (req->wd); break;
1899
1900 case EIO_SEEK: eio__lseek (req); break;
2085 case EIO_READ: ALLOC (req->size); 1901 case EIO_READ: ALLOC (req->size);
2086 req->result = req->offs >= 0 1902 req->result = req->offs >= 0
2087 ? pread (req->int1, req->ptr2, req->size, req->offs) 1903 ? pread (req->int1, req->ptr2, req->size, req->offs)
2088 : read (req->int1, req->ptr2, req->size); break; 1904 : read (req->int1, req->ptr2, req->size); break;
2089 case EIO_WRITE: req->result = req->offs >= 0 1905 case EIO_WRITE: req->result = req->offs >= 0
… …
2091 : write (req->int1, req->ptr2, req->size); break; 1907 : write (req->int1, req->ptr2, req->size); break;
2092 1908
2093 case EIO_READAHEAD: req->result = readahead (req->int1, req->offs, req->size); break; 1909 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; 1910 case EIO_SENDFILE: req->result = eio__sendfile (req->int1, req->int2, req->offs, req->size); break;
2095 1911
1912#if HAVE_AT
1913
2096 case EIO_STAT: ALLOC (sizeof (EIO_STRUCT_STAT)); 1914 case EIO_STAT: ALLOC (sizeof (EIO_STRUCT_STAT));
2097 req->result = stat (req->ptr1, (EIO_STRUCT_STAT *)req->ptr2); break; 1915 req->result = fstatat (dirfd, req->ptr1, (EIO_STRUCT_STAT *)req->ptr2, 0); break;
2098 case EIO_LSTAT: ALLOC (sizeof (EIO_STRUCT_STAT)); 1916 case EIO_LSTAT: ALLOC (sizeof (EIO_STRUCT_STAT));
1917 req->result = fstatat (dirfd, req->ptr1, (EIO_STRUCT_STAT *)req->ptr2, AT_SYMLINK_NOFOLLOW); break;
1918 case EIO_CHOWN: req->result = fchownat (dirfd, req->ptr1, req->int2, req->int3, 0); break;
1919 case EIO_CHMOD: req->result = fchmodat (dirfd, req->ptr1, (mode_t)req->int2, 0); break;
1920 case EIO_TRUNCATE: req->result = eio__truncateat (dirfd, req->ptr1, req->offs); break;
1921 case EIO_OPEN: req->result = openat (dirfd, req->ptr1, req->int1, (mode_t)req->int2); break;
1922
1923 case EIO_UNLINK: req->result = unlinkat (dirfd, req->ptr1, 0); break;
1924 case EIO_RMDIR: /* complications arise because "." cannot be removed, so we might have to expand */
1925 req->result = req->wd && SINGLEDOT (req->ptr1)
1926 ? rmdir (req->wd->str)
1927 : unlinkat (dirfd, req->ptr1, AT_REMOVEDIR); break;
1928 case EIO_MKDIR: req->result = mkdirat (dirfd, req->ptr1, (mode_t)req->int2); break;
1929 case EIO_RENAME: /* complications arise because "." cannot be renamed, so we might have to expand */
1930 req->result = req->wd && SINGLEDOT (req->ptr1)
1931 ? rename (req->wd->str, req->ptr2)
1932 : renameat (dirfd, req->ptr1, WD2FD ((eio_wd)req->int3), req->ptr2); break;
1933 case EIO_LINK: req->result = linkat (dirfd, req->ptr1, WD2FD ((eio_wd)req->int3), req->ptr2, 0); break;
1934 case EIO_SYMLINK: req->result = symlinkat (req->ptr1, dirfd, req->ptr2); break;
1935 case EIO_MKNOD: req->result = mknodat (dirfd, req->ptr1, (mode_t)req->int2, (dev_t)req->offs); break;
1936 case EIO_READLINK: ALLOC (PATH_MAX);
1937 req->result = readlinkat (dirfd, req->ptr1, req->ptr2, PATH_MAX); break;
1938 case EIO_STATVFS: ALLOC (sizeof (EIO_STRUCT_STATVFS));
1939 req->result = eio__statvfsat (dirfd, req->ptr1, (EIO_STRUCT_STATVFS *)req->ptr2); break;
1940 case EIO_UTIME:
1941 case EIO_FUTIME:
1942 {
1943 struct timespec ts[2];
1944 struct timespec *times;
1945
1946 if (req->nv1 != -1. || req->nv2 != -1.)
1947 {
1948 ts[0].tv_sec = req->nv1;
1949 ts[0].tv_nsec = (req->nv1 - ts[0].tv_sec) * 1e9;
1950 ts[1].tv_sec = req->nv2;
1951 ts[1].tv_nsec = (req->nv2 - ts[1].tv_sec) * 1e9;
1952
1953 times = ts;
1954 }
1955 else
1956 times = 0;
1957
1958 req->result = req->type == EIO_FUTIME
1959 ? futimens (req->int1, times)
1960 : utimensat (dirfd, req->ptr1, times, 0);
1961 }
1962 break;
1963
1964#else
1965
1966 case EIO_STAT: ALLOC (sizeof (EIO_STRUCT_STAT));
1967 req->result = stat (path , (EIO_STRUCT_STAT *)req->ptr2); break;
1968 case EIO_LSTAT: ALLOC (sizeof (EIO_STRUCT_STAT));
2099 req->result = lstat (req->ptr1, (EIO_STRUCT_STAT *)req->ptr2); break; 1969 req->result = lstat (path , (EIO_STRUCT_STAT *)req->ptr2); break;
1970 case EIO_CHOWN: req->result = chown (path , req->int2, req->int3); break;
1971 case EIO_CHMOD: req->result = chmod (path , (mode_t)req->int2); break;
1972 case EIO_TRUNCATE: req->result = truncate (path , req->offs); break;
1973 case EIO_OPEN: req->result = open (path , req->int1, (mode_t)req->int2); break;
1974
1975 case EIO_UNLINK: req->result = unlink (path ); break;
1976 case EIO_RMDIR: req->result = rmdir (path ); break;
1977 case EIO_MKDIR: req->result = mkdir (path , (mode_t)req->int2); break;
1978 case EIO_RENAME: req->result = rename (path , req->ptr2); break;
1979 case EIO_LINK: req->result = link (path , req->ptr2); break;
1980 case EIO_SYMLINK: req->result = symlink (path , req->ptr2); break;
1981 case EIO_MKNOD: req->result = mknod (path , (mode_t)req->int2, (dev_t)req->offs); break;
1982 case EIO_READLINK: ALLOC (PATH_MAX);
1983 req->result = readlink (path, req->ptr2, PATH_MAX); break;
1984 case EIO_STATVFS: ALLOC (sizeof (EIO_STRUCT_STATVFS));
1985 req->result = statvfs (path , (EIO_STRUCT_STATVFS *)req->ptr2); break;
1986
1987 case EIO_UTIME:
1988 case EIO_FUTIME:
1989 {
1990 struct timeval tv[2];
1991 struct timeval *times;
1992
1993 if (req->nv1 != -1. || req->nv2 != -1.)
1994 {
1995 tv[0].tv_sec = req->nv1;
1996 tv[0].tv_usec = (req->nv1 - tv[0].tv_sec) * 1e6;
1997 tv[1].tv_sec = req->nv2;
1998 tv[1].tv_usec = (req->nv2 - tv[1].tv_sec) * 1e6;
1999
2000 times = tv;
2001 }
2002 else
2003 times = 0;
2004
2005 req->result = req->type == EIO_FUTIME
2006 ? futimes (req->int1, times)
2007 : utimes (req->ptr1, times);
2008 }
2009 break;
2010
2011#endif
2012
2013 case EIO_REALPATH: if (0 <= (req->result = eio__realpath (&self->tmpbuf, req->wd, req->ptr1)))
2014 {
2015 ALLOC (req->result);
2016 memcpy (req->ptr2, self->tmpbuf.ptr, req->result);
2017 }
2018 break;
2019
2100 case EIO_FSTAT: ALLOC (sizeof (EIO_STRUCT_STAT)); 2020 case EIO_FSTAT: ALLOC (sizeof (EIO_STRUCT_STAT));
2101 req->result = fstat (req->int1, (EIO_STRUCT_STAT *)req->ptr2); break; 2021 req->result = fstat (req->int1, (EIO_STRUCT_STAT *)req->ptr2); break;
2102 2022
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)); 2023 case EIO_FSTATVFS: ALLOC (sizeof (EIO_STRUCT_STATVFS));
2106 req->result = fstatvfs (req->int1, (EIO_STRUCT_STATVFS *)req->ptr2); break; 2024 req->result = fstatvfs (req->int1, (EIO_STRUCT_STATVFS *)req->ptr2); break;
2107 2025
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; 2026 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; 2027 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; 2028 case EIO_FTRUNCATE: req->result = ftruncate (req->int1, req->offs); break;
2114 2029
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; 2030 case EIO_CLOSE: req->result = close (req->int1); break;
2117 case EIO_DUP2: req->result = dup2 (req->int1, req->int2); break; 2031 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; 2032 case EIO_SYNC: req->result = 0; sync (); break;
2132 case EIO_FSYNC: req->result = fsync (req->int1); break; 2033 case EIO_FSYNC: req->result = fsync (req->int1); break;
2133 case EIO_FDATASYNC: req->result = fdatasync (req->int1); break; 2034 case EIO_FDATASYNC: req->result = fdatasync (req->int1); break;
2134 case EIO_SYNCFS: req->result = eio__syncfs (req->int1); break; 2035 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; 2036 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); 2055 req->result = select (0, 0, 0, 0, &tv);
2155 } 2056 }
2156#endif 2057#endif
2157 break; 2058 break;
2158 2059
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: 2060 case EIO_GROUP:
2184 abort (); /* handled in eio_request */ 2061 abort (); /* handled in eio_request */
2185 2062
2186 case EIO_NOP: 2063 case EIO_NOP:
2187 req->result = 0; 2064 req->result = 0;
… …
2190 case EIO_CUSTOM: 2067 case EIO_CUSTOM:
2191 req->feed (req); 2068 req->feed (req);
2192 break; 2069 break;
2193 2070
2194 default: 2071 default:
2195 errno = ENOSYS;
2196 req->result = -1; 2072 req->result = EIO_ENOSYS ();
2197 break; 2073 break;
2198 } 2074 }
2199 2075
2200 req->errorno = errno; 2076 req->errorno = errno;
2201} 2077}
2202 2078
2203#ifndef EIO_NO_WRAPPERS 2079#ifndef EIO_NO_WRAPPERS
2204 2080
2081eio_req *eio_wd_open (const char *path, int pri, eio_cb cb, void *data)
2082{
2083 REQ (EIO_WD_OPEN); PATH; SEND;
2084}
2085
2086eio_req *eio_wd_close (eio_wd wd, int pri, eio_cb cb, void *data)
2087{
2088 REQ (EIO_WD_CLOSE); req->wd = wd; SEND;
2089}
2090
2205eio_req *eio_nop (int pri, eio_cb cb, void *data) 2091eio_req *eio_nop (int pri, eio_cb cb, void *data)
2206{ 2092{
2207 REQ (EIO_NOP); SEND; 2093 REQ (EIO_NOP); SEND;
2208} 2094}
2209 2095
… …
2268} 2154}
2269 2155
2270eio_req *eio_readahead (int fd, off_t offset, size_t length, int pri, eio_cb cb, void *data) 2156eio_req *eio_readahead (int fd, off_t offset, size_t length, int pri, eio_cb cb, void *data)
2271{ 2157{
2272 REQ (EIO_READAHEAD); req->int1 = fd; req->offs = offset; req->size = length; SEND; 2158 REQ (EIO_READAHEAD); req->int1 = fd; req->offs = offset; req->size = length; SEND;
2159}
2160
2161eio_req *eio_seek (int fd, off_t offset, int whence, int pri, eio_cb cb, void *data)
2162{
2163 REQ (EIO_SEEK); req->int1 = fd; req->offs = offset; req->int2 = whence; SEND;
2273} 2164}
2274 2165
2275eio_req *eio_read (int fd, void *buf, size_t length, off_t offset, int pri, eio_cb cb, void *data) 2166eio_req *eio_read (int fd, void *buf, size_t length, off_t offset, int pri, eio_cb cb, void *data)
2276{ 2167{
2277 REQ (EIO_READ); req->int1 = fd; req->offs = offset; req->size = length; req->ptr2 = buf; SEND; 2168 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