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

Comparing libeio/eio.c (file contents):
Revision 1.93 by root, Mon Jul 18 01:27:03 2011 UTC vs.
Revision 1.136 by root, Thu Jun 25 17:05:07 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>
… …
71#endif 71#endif
72#ifndef ELOOP 72#ifndef ELOOP
73# define ELOOP EDOM 73# define ELOOP EDOM
74#endif 74#endif
75 75
76#if !defined(ENOTSOCK) && defined(WSAENOTSOCK)
77# define ENOTSOCK WSAENOTSOCK
78#endif
79
76static void eio_destroy (eio_req *req); 80static void eio_destroy (eio_req *req);
77 81
78#ifndef EIO_FINISH 82#ifndef EIO_FINISH
79# define EIO_FINISH(req) ((req)->finish) && !EIO_CANCELLED (req) ? (req)->finish (req) : 0 83# define EIO_FINISH(req) ((req)->finish) && !EIO_CANCELLED (req) ? (req)->finish (req) : 0
80#endif 84#endif
… …
101#ifdef _WIN32 105#ifdef _WIN32
102 106
103 #undef PAGESIZE 107 #undef PAGESIZE
104 #define PAGESIZE 4096 /* GetSystemInfo? */ 108 #define PAGESIZE 4096 /* GetSystemInfo? */
105 109
110 /* TODO: look at how perl does stat (non-sloppy), unlink (ro-files), utime, link */
111
106 #ifdef EIO_STRUCT_STATI64 112 #ifdef EIO_STRUCT_STATI64
113 /* look at perl's non-sloppy stat */
107 #define stat(path,buf) _stati64 (path,buf) 114 #define stat(path,buf) _stati64 (path,buf)
108 #define fstat(fd,buf) _fstati64 (path,buf) 115 #define fstat(fd,buf) _fstati64 (fd,buf)
109 #endif 116 #endif
110 #define lstat(path,buf) stat (path,buf) 117 #define lstat(path,buf) stat (path,buf)
111 #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))
112 #define mkdir(path,mode) _mkdir (path) 119 #define mkdir(path,mode) _mkdir (path)
113 #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))
114 121
115 #define chmod(path,mode) _chmod (path, mode) 122 #define chmod(path,mode) _chmod (path, mode)
116 #define dup(fd) _dup (fd) 123 #define dup(fd) _dup (fd)
117 #define dup2(fd1,fd2) _dup2 (fd1, fd2) 124 #define dup2(fd1,fd2) _dup2 (fd1, fd2)
125 #define pipe(fds) _pipe (fds, 4096, O_BINARY)
118 126
119 #define fchmod(fd,mode) EIO_ENOSYS () 127 #define fchmod(fd,mode) EIO_ENOSYS ()
120 #define chown(path,uid,gid) EIO_ENOSYS () 128 #define chown(path,uid,gid) EIO_ENOSYS ()
121 #define fchown(fd,uid,gid) EIO_ENOSYS () 129 #define fchown(fd,uid,gid) EIO_ENOSYS ()
122 #define truncate(path,offs) EIO_ENOSYS () /* far-miss: SetEndOfFile */ 130 #define truncate(path,offs) EIO_ENOSYS () /* far-miss: SetEndOfFile */
… …
125 #define sync() EIO_ENOSYS () 133 #define sync() EIO_ENOSYS ()
126 #define readlink(path,buf,s) EIO_ENOSYS () 134 #define readlink(path,buf,s) EIO_ENOSYS ()
127 #define statvfs(path,buf) EIO_ENOSYS () 135 #define statvfs(path,buf) EIO_ENOSYS ()
128 #define fstatvfs(fd,buf) EIO_ENOSYS () 136 #define fstatvfs(fd,buf) EIO_ENOSYS ()
129 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 }
172
173 /* rename() uses MoveFile, which fails to overwrite */
174 #define rename(old,neu) eio__rename (old, neu)
175
176 static int
177 eio__rename (const char *old, const char *neu)
178 {
179 if (MoveFileEx (old, neu, MOVEFILE_REPLACE_EXISTING))
180 return 0;
181
182 /* should steal _dosmaperr */
183 switch (GetLastError ())
184 {
185 case ERROR_FILE_NOT_FOUND:
186 case ERROR_PATH_NOT_FOUND:
187 case ERROR_INVALID_DRIVE:
188 case ERROR_NO_MORE_FILES:
189 case ERROR_BAD_NETPATH:
190 case ERROR_BAD_NET_NAME:
191 case ERROR_BAD_PATHNAME:
192 case ERROR_FILENAME_EXCED_RANGE:
193 errno = ENOENT;
194 break;
195
196 default:
197 errno = EACCES;
198 break;
199 }
200
201 return -1;
202 }
203
130 /* we could even stat and see if it exists */ 204 /* we could even stat and see if it exists */
131 static int 205 static int
132 symlink (const char *old, const char *neu) 206 symlink (const char *old, const char *neu)
133 { 207 {
134 #if WINVER >= 0x0600 208 #if WINVER >= 0x0600
… …
140 #endif 214 #endif
141 215
142 return EIO_ERRNO (ENOENT, -1); 216 return EIO_ERRNO (ENOENT, -1);
143 } 217 }
144 218
145 /* POSIX API only */ 219 /* POSIX API only, causing trouble for win32 apps */
146 #define CreateHardLink(neu,old,flags) 0 220 #define CreateHardLink(neu,old,flags) 0 /* not really creating hardlink, still using relative paths? */
147 #define CreateSymbolicLink(neu,old,flags) 0 221 #define CreateSymbolicLink(neu,old,flags) 0 /* vista+ only */
148 222
149 struct statvfs 223 struct statvfs
150 { 224 {
151 int dummy; 225 int dummy;
152 }; 226 };
… …
158 232
159#else 233#else
160 234
161 #include <sys/time.h> 235 #include <sys/time.h>
162 #include <sys/select.h> 236 #include <sys/select.h>
163 #include <sys/statvfs.h>
164 #include <unistd.h> 237 #include <unistd.h>
165 #include <utime.h>
166 #include <signal.h> 238 #include <signal.h>
167 #include <dirent.h> 239 #include <dirent.h>
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
168 249
169 #if _POSIX_MEMLOCK || _POSIX_MEMLOCK_RANGE || _POSIX_MAPPED_FILES 250 #if _POSIX_MEMLOCK || _POSIX_MEMLOCK_RANGE || _POSIX_MAPPED_FILES
170 #include <sys/mman.h> 251 #include <sys/mman.h>
171 #endif 252 #endif
172 253
173 #define D_NAME(entp) entp->d_name 254 #define D_NAME(entp) entp->d_name
174 255
175 /* 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 */
176 #if __FreeBSD__ || defined __NetBSD__ || defined __OpenBSD__ 257 #if __FreeBSD__ || __NetBSD__ || __OpenBSD__
177 #define _DIRENT_HAVE_D_TYPE /* sigh */ 258 #define _DIRENT_HAVE_D_TYPE /* sigh */
178 #define D_INO(de) (de)->d_fileno 259 #define D_INO(de) (de)->d_fileno
179 #define D_NAMLEN(de) (de)->d_namlen 260 #define D_NAMLEN(de) (de)->d_namlen
180 #elif __linux || defined d_ino || _XOPEN_SOURCE >= 600 261 #elif __linux || defined d_ino || _XOPEN_SOURCE >= 600
181 #define D_INO(de) (de)->d_ino 262 #define D_INO(de) (de)->d_ino
… …
192 273
193 #ifndef EIO_STRUCT_DIRENT 274 #ifndef EIO_STRUCT_DIRENT
194 #define EIO_STRUCT_DIRENT struct dirent 275 #define EIO_STRUCT_DIRENT struct dirent
195 #endif 276 #endif
196 277
278#endif
279
280#if HAVE_UTIMES
281# include <utime.h>
282#endif
283
284#if HAVE_SYS_SYSCALL_H
285# include <sys/syscall.h>
286#endif
287
288#if HAVE_SYS_PRCTL_H
289# include <sys/prctl.h>
197#endif 290#endif
198 291
199#if HAVE_SENDFILE 292#if HAVE_SENDFILE
200# if __linux 293# if __linux
201# include <sys/sendfile.h> 294# include <sys/sendfile.h>
… …
232#endif 325#endif
233 326
234/* buffer size for various temporary buffers */ 327/* buffer size for various temporary buffers */
235#define EIO_BUFSIZE 65536 328#define EIO_BUFSIZE 65536
236 329
237#define dBUF \ 330#define dBUF \
238 char *eio_buf; \
239 ETP_WORKER_LOCK (self); \
240 self->dbuf = eio_buf = malloc (EIO_BUFSIZE); \ 331 char *eio_buf = malloc (EIO_BUFSIZE); \
241 ETP_WORKER_UNLOCK (self); \
242 errno = ENOMEM; \ 332 errno = ENOMEM; \
243 if (!eio_buf) \ 333 if (!eio_buf) \
244 return -1; 334 return -1
245 335
246#define EIO_TICKS ((1000000 + 1023) >> 10) 336#define FUBd \
337 free (eio_buf)
338
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/*****************************************************************************/
247 364
248#define ETP_PRI_MIN EIO_PRI_MIN 365#define ETP_PRI_MIN EIO_PRI_MIN
249#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
250 370
251struct etp_worker; 371struct etp_worker;
252 372
253#define ETP_REQ eio_req 373#define ETP_REQ eio_req
254#define ETP_DESTROY(req) eio_destroy (req) 374#define ETP_DESTROY(req) eio_destroy (req)
255static int eio_finish (eio_req *req); 375static int eio_finish (eio_req *req);
256#define ETP_FINISH(req) eio_finish (req) 376#define ETP_FINISH(req) eio_finish (req)
257static void eio_execute (struct etp_worker *self, eio_req *req); 377static void eio_execute (struct etp_worker *self, eio_req *req);
258#define ETP_EXECUTE(wrk,req) eio_execute (wrk,req) 378#define ETP_EXECUTE(wrk,req) eio_execute (wrk, req)
259 379
260#define ETP_WORKER_CLEAR(req) \ 380#include "etp.c"
261 if (wrk->dbuf) \
262 { \
263 free (wrk->dbuf); \
264 wrk->dbuf = 0; \
265 }
266
267#define ETP_WORKER_COMMON \
268 void *dbuf;
269
270/*****************************************************************************/
271
272#define ETP_NUM_PRI (ETP_PRI_MAX - ETP_PRI_MIN + 1)
273
274/* calculate time difference in ~1/EIO_TICKS of a second */
275ecb_inline int
276tvdiff (struct timeval *tv1, struct timeval *tv2)
277{
278 return (tv2->tv_sec - tv1->tv_sec ) * EIO_TICKS
279 + ((tv2->tv_usec - tv1->tv_usec) >> 10);
280}
281
282static unsigned int started, idle, wanted = 4;
283
284static void (*want_poll_cb) (void);
285static void (*done_poll_cb) (void);
286
287static unsigned int max_poll_time; /* reslock */
288static unsigned int max_poll_reqs; /* reslock */
289
290static volatile unsigned int nreqs; /* reqlock */
291static volatile unsigned int nready; /* reqlock */
292static volatile unsigned int npending; /* reqlock */
293static volatile unsigned int max_idle = 4; /* maximum number of threads that can idle indefinitely */
294static volatile unsigned int idle_timeout = 10; /* number of seconds after which an idle threads exit */
295
296static xmutex_t wrklock;
297static xmutex_t reslock;
298static xmutex_t reqlock;
299static xcond_t reqwait;
300
301#if !HAVE_PREADWRITE
302/*
303 * make our pread/pwrite emulation safe against themselves, but not against
304 * normal read/write by using a mutex. slows down execution a lot,
305 * but that's your problem, not mine.
306 */
307static xmutex_t preadwritelock;
308#endif
309
310typedef struct etp_worker
311{
312 /* locked by wrklock */
313 struct etp_worker *prev, *next;
314
315 xthread_t tid;
316
317 /* locked by reslock, reqlock or wrklock */
318 ETP_REQ *req; /* currently processed request */
319
320 ETP_WORKER_COMMON
321} etp_worker;
322
323static etp_worker wrk_first; /* NOT etp */
324
325#define ETP_WORKER_LOCK(wrk) X_LOCK (wrklock)
326#define ETP_WORKER_UNLOCK(wrk) X_UNLOCK (wrklock)
327
328/* worker threads management */
329
330static void ecb_cold
331etp_worker_clear (etp_worker *wrk)
332{
333 ETP_WORKER_CLEAR (wrk);
334}
335
336static void ecb_cold
337etp_worker_free (etp_worker *wrk)
338{
339 wrk->next->prev = wrk->prev;
340 wrk->prev->next = wrk->next;
341
342 free (wrk);
343}
344
345static unsigned int
346etp_nreqs (void)
347{
348 int retval;
349 if (WORDACCESS_UNSAFE) X_LOCK (reqlock);
350 retval = nreqs;
351 if (WORDACCESS_UNSAFE) X_UNLOCK (reqlock);
352 return retval;
353}
354
355static unsigned int
356etp_nready (void)
357{
358 unsigned int retval;
359
360 if (WORDACCESS_UNSAFE) X_LOCK (reqlock);
361 retval = nready;
362 if (WORDACCESS_UNSAFE) X_UNLOCK (reqlock);
363
364 return retval;
365}
366
367static unsigned int
368etp_npending (void)
369{
370 unsigned int retval;
371
372 if (WORDACCESS_UNSAFE) X_LOCK (reqlock);
373 retval = npending;
374 if (WORDACCESS_UNSAFE) X_UNLOCK (reqlock);
375
376 return retval;
377}
378
379static unsigned int
380etp_nthreads (void)
381{
382 unsigned int retval;
383
384 if (WORDACCESS_UNSAFE) X_LOCK (reqlock);
385 retval = started;
386 if (WORDACCESS_UNSAFE) X_UNLOCK (reqlock);
387
388 return retval;
389}
390
391/*
392 * a somewhat faster data structure might be nice, but
393 * with 8 priorities this actually needs <20 insns
394 * per shift, the most expensive operation.
395 */
396typedef struct {
397 ETP_REQ *qs[ETP_NUM_PRI], *qe[ETP_NUM_PRI]; /* qstart, qend */
398 int size;
399} etp_reqq;
400
401static etp_reqq req_queue;
402static etp_reqq res_queue;
403
404static void ecb_noinline ecb_cold
405reqq_init (etp_reqq *q)
406{
407 int pri;
408
409 for (pri = 0; pri < ETP_NUM_PRI; ++pri)
410 q->qs[pri] = q->qe[pri] = 0;
411
412 q->size = 0;
413}
414
415static int ecb_noinline
416reqq_push (etp_reqq *q, ETP_REQ *req)
417{
418 int pri = req->pri;
419 req->next = 0;
420
421 if (q->qe[pri])
422 {
423 q->qe[pri]->next = req;
424 q->qe[pri] = req;
425 }
426 else
427 q->qe[pri] = q->qs[pri] = req;
428
429 return q->size++;
430}
431
432static ETP_REQ * ecb_noinline
433reqq_shift (etp_reqq *q)
434{
435 int pri;
436
437 if (!q->size)
438 return 0;
439
440 --q->size;
441
442 for (pri = ETP_NUM_PRI; pri--; )
443 {
444 eio_req *req = q->qs[pri];
445
446 if (req)
447 {
448 if (!(q->qs[pri] = (eio_req *)req->next))
449 q->qe[pri] = 0;
450
451 return req;
452 }
453 }
454
455 abort ();
456}
457
458static int ecb_cold
459etp_init (void (*want_poll)(void), void (*done_poll)(void))
460{
461 X_MUTEX_CREATE (wrklock);
462 X_MUTEX_CREATE (reslock);
463 X_MUTEX_CREATE (reqlock);
464 X_COND_CREATE (reqwait);
465
466 reqq_init (&req_queue);
467 reqq_init (&res_queue);
468
469 wrk_first.next =
470 wrk_first.prev = &wrk_first;
471
472 started = 0;
473 idle = 0;
474 nreqs = 0;
475 nready = 0;
476 npending = 0;
477
478 want_poll_cb = want_poll;
479 done_poll_cb = done_poll;
480
481 return 0;
482}
483
484X_THREAD_PROC (etp_proc);
485
486static void ecb_cold
487etp_start_thread (void)
488{
489 etp_worker *wrk = calloc (1, sizeof (etp_worker));
490
491 /*TODO*/
492 assert (("unable to allocate worker thread data", wrk));
493
494 X_LOCK (wrklock);
495
496 if (thread_create (&wrk->tid, etp_proc, (void *)wrk))
497 {
498 wrk->prev = &wrk_first;
499 wrk->next = wrk_first.next;
500 wrk_first.next->prev = wrk;
501 wrk_first.next = wrk;
502 ++started;
503 }
504 else
505 free (wrk);
506
507 X_UNLOCK (wrklock);
508}
509
510static void
511etp_maybe_start_thread (void)
512{
513 if (ecb_expect_true (etp_nthreads () >= wanted))
514 return;
515
516 /* todo: maybe use idle here, but might be less exact */
517 if (ecb_expect_true (0 <= (int)etp_nthreads () + (int)etp_npending () - (int)etp_nreqs ()))
518 return;
519
520 etp_start_thread ();
521}
522
523static void ecb_cold
524etp_end_thread (void)
525{
526 eio_req *req = calloc (1, sizeof (eio_req));
527
528 req->type = -1;
529 req->pri = ETP_PRI_MAX - ETP_PRI_MIN;
530
531 X_LOCK (reqlock);
532 reqq_push (&req_queue, req);
533 X_COND_SIGNAL (reqwait);
534 X_UNLOCK (reqlock);
535
536 X_LOCK (wrklock);
537 --started;
538 X_UNLOCK (wrklock);
539}
540
541static int
542etp_poll (void)
543{
544 unsigned int maxreqs;
545 unsigned int maxtime;
546 struct timeval tv_start, tv_now;
547
548 X_LOCK (reslock);
549 maxreqs = max_poll_reqs;
550 maxtime = max_poll_time;
551 X_UNLOCK (reslock);
552
553 if (maxtime)
554 gettimeofday (&tv_start, 0);
555
556 for (;;)
557 {
558 ETP_REQ *req;
559
560 etp_maybe_start_thread ();
561
562 X_LOCK (reslock);
563 req = reqq_shift (&res_queue);
564
565 if (req)
566 {
567 --npending;
568
569 if (!res_queue.size && done_poll_cb)
570 done_poll_cb ();
571 }
572
573 X_UNLOCK (reslock);
574
575 if (!req)
576 return 0;
577
578 X_LOCK (reqlock);
579 --nreqs;
580 X_UNLOCK (reqlock);
581
582 if (ecb_expect_false (req->type == EIO_GROUP && req->size))
583 {
584 req->int1 = 1; /* mark request as delayed */
585 continue;
586 }
587 else
588 {
589 int res = ETP_FINISH (req);
590 if (ecb_expect_false (res))
591 return res;
592 }
593
594 if (ecb_expect_false (maxreqs && !--maxreqs))
595 break;
596
597 if (maxtime)
598 {
599 gettimeofday (&tv_now, 0);
600
601 if (tvdiff (&tv_start, &tv_now) >= maxtime)
602 break;
603 }
604 }
605
606 errno = EAGAIN;
607 return -1;
608}
609
610static void
611etp_cancel (ETP_REQ *req)
612{
613 req->cancelled = 1;
614
615 eio_grp_cancel (req);
616}
617
618static void
619etp_submit (ETP_REQ *req)
620{
621 req->pri -= ETP_PRI_MIN;
622
623 if (ecb_expect_false (req->pri < ETP_PRI_MIN - ETP_PRI_MIN)) req->pri = ETP_PRI_MIN - ETP_PRI_MIN;
624 if (ecb_expect_false (req->pri > ETP_PRI_MAX - ETP_PRI_MIN)) req->pri = ETP_PRI_MAX - ETP_PRI_MIN;
625
626 if (ecb_expect_false (req->type == EIO_GROUP))
627 {
628 /* I hope this is worth it :/ */
629 X_LOCK (reqlock);
630 ++nreqs;
631 X_UNLOCK (reqlock);
632
633 X_LOCK (reslock);
634
635 ++npending;
636
637 if (!reqq_push (&res_queue, req) && want_poll_cb)
638 want_poll_cb ();
639
640 X_UNLOCK (reslock);
641 }
642 else
643 {
644 X_LOCK (reqlock);
645 ++nreqs;
646 ++nready;
647 reqq_push (&req_queue, req);
648 X_COND_SIGNAL (reqwait);
649 X_UNLOCK (reqlock);
650
651 etp_maybe_start_thread ();
652 }
653}
654
655static void ecb_cold
656etp_set_max_poll_time (double nseconds)
657{
658 if (WORDACCESS_UNSAFE) X_LOCK (reslock);
659 max_poll_time = nseconds * EIO_TICKS;
660 if (WORDACCESS_UNSAFE) X_UNLOCK (reslock);
661}
662
663static void ecb_cold
664etp_set_max_poll_reqs (unsigned int maxreqs)
665{
666 if (WORDACCESS_UNSAFE) X_LOCK (reslock);
667 max_poll_reqs = maxreqs;
668 if (WORDACCESS_UNSAFE) X_UNLOCK (reslock);
669}
670
671static void ecb_cold
672etp_set_max_idle (unsigned int nthreads)
673{
674 if (WORDACCESS_UNSAFE) X_LOCK (reqlock);
675 max_idle = nthreads;
676 if (WORDACCESS_UNSAFE) X_UNLOCK (reqlock);
677}
678
679static void ecb_cold
680etp_set_idle_timeout (unsigned int seconds)
681{
682 if (WORDACCESS_UNSAFE) X_LOCK (reqlock);
683 idle_timeout = seconds;
684 if (WORDACCESS_UNSAFE) X_UNLOCK (reqlock);
685}
686
687static void ecb_cold
688etp_set_min_parallel (unsigned int nthreads)
689{
690 if (wanted < nthreads)
691 wanted = nthreads;
692}
693
694static void ecb_cold
695etp_set_max_parallel (unsigned int nthreads)
696{
697 if (wanted > nthreads)
698 wanted = nthreads;
699
700 while (started > wanted)
701 etp_end_thread ();
702}
703 381
704/*****************************************************************************/ 382/*****************************************************************************/
705 383
706static void 384static void
707grp_try_feed (eio_req *grp) 385grp_try_feed (eio_req *grp)
708{ 386{
709 while (grp->size < grp->int2 && !EIO_CANCELLED (grp)) 387 while (grp->size < grp->int2 && !EIO_CANCELLED (grp))
710 { 388 {
711 grp->flags &= ~EIO_FLAG_GROUPADD; 389 grp->flags &= ~ETP_FLAG_GROUPADD;
712 390
713 EIO_FEED (grp); 391 EIO_FEED (grp);
714 392
715 /* stop if no progress has been made */ 393 /* stop if no progress has been made */
716 if (!(grp->flags & EIO_FLAG_GROUPADD)) 394 if (!(grp->flags & ETP_FLAG_GROUPADD))
717 { 395 {
718 grp->feed = 0; 396 grp->feed = 0;
719 break; 397 break;
720 } 398 }
721 } 399 }
… …
728 406
729 /* call feeder, if applicable */ 407 /* call feeder, if applicable */
730 grp_try_feed (grp); 408 grp_try_feed (grp);
731 409
732 /* finish, if done */ 410 /* finish, if done */
733 if (!grp->size && grp->int1) 411 if (!grp->size && grp->flags & ETP_FLAG_DELAYED)
734 return eio_finish (grp); 412 return eio_finish (grp);
735 else 413 else
736 return 0; 414 return 0;
737} 415}
738 416
… …
774} 452}
775 453
776void 454void
777eio_grp_cancel (eio_req *grp) 455eio_grp_cancel (eio_req *grp)
778{ 456{
779 for (grp = grp->grp_first; grp; grp = grp->grp_next)
780 eio_cancel (grp); 457 etp_grp_cancel (grp);
781} 458}
782 459
783void 460void
784eio_cancel (eio_req *req) 461eio_cancel (eio_req *req)
785{ 462{
… …
857 return etp_poll (); 534 return etp_poll ();
858} 535}
859 536
860/*****************************************************************************/ 537/*****************************************************************************/
861/* work around various missing functions */ 538/* work around various missing functions */
862
863#if !HAVE_PREADWRITE
864# undef pread
865# undef pwrite
866# define pread eio__pread
867# define pwrite eio__pwrite
868
869static eio_ssize_t
870eio__pread (int fd, void *buf, size_t count, off_t offset)
871{
872 eio_ssize_t res;
873 off_t ooffset;
874
875 X_LOCK (preadwritelock);
876 ooffset = lseek (fd, 0, SEEK_CUR);
877 lseek (fd, offset, SEEK_SET);
878 res = read (fd, buf, count);
879 lseek (fd, ooffset, SEEK_SET);
880 X_UNLOCK (preadwritelock);
881
882 return res;
883}
884
885static eio_ssize_t
886eio__pwrite (int fd, void *buf, size_t count, off_t offset)
887{
888 eio_ssize_t res;
889 off_t ooffset;
890
891 X_LOCK (preadwritelock);
892 ooffset = lseek (fd, 0, SEEK_CUR);
893 lseek (fd, offset, SEEK_SET);
894 res = write (fd, buf, count);
895 lseek (fd, ooffset, SEEK_SET);
896 X_UNLOCK (preadwritelock);
897
898 return res;
899}
900#endif
901 539
902#ifndef HAVE_UTIMES 540#ifndef HAVE_UTIMES
903 541
904# undef utimes 542# undef utimes
905# define utimes(path,times) eio__utimes (path, times) 543# define utimes(path,times) eio__utimes (path, times)
… …
938 576
939#if !HAVE_FDATASYNC 577#if !HAVE_FDATASYNC
940# undef fdatasync 578# undef fdatasync
941# define fdatasync(fd) fsync (fd) 579# define fdatasync(fd) fsync (fd)
942#endif 580#endif
581
582static int
583eio__syncfs (int fd)
584{
585 int res;
586
587#if HAVE_SYS_SYNCFS
588 res = (int)syscall (__NR_syncfs, (int)(fd));
589#else
590 res = EIO_ENOSYS ();
591#endif
592
593 if (res < 0 && errno == ENOSYS && fd >= 0)
594 sync ();
595
596 return res;
597}
943 598
944/* sync_file_range always needs emulation */ 599/* sync_file_range always needs emulation */
945static int 600static int
946eio__sync_file_range (int fd, off_t offset, size_t nbytes, unsigned int flags) 601eio__sync_file_range (int fd, off_t offset, size_t nbytes, unsigned int flags)
947{ 602{
… …
970} 625}
971 626
972static int 627static int
973eio__fallocate (int fd, int mode, off_t offset, size_t len) 628eio__fallocate (int fd, int mode, off_t offset, size_t len)
974{ 629{
975#if HAVE_FALLOCATE 630#if HAVE_LINUX_FALLOCATE
976 return fallocate (fd, mode, offset, len); 631 return fallocate (fd, mode, offset, len);
977#else 632#else
978 errno = ENOSYS; 633 return EIO_ENOSYS ();
979 return -1;
980#endif 634#endif
981} 635}
982 636
983#if !HAVE_READAHEAD 637#if !HAVE_READAHEAD
984# undef readahead 638# undef readahead
… …
997 pread (fd, eio_buf, len, offset); 651 pread (fd, eio_buf, len, offset);
998 offset += len; 652 offset += len;
999 todo -= len; 653 todo -= len;
1000 } 654 }
1001 655
1002 errno = 0; 656 FUBd;
657
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 */
1003 return count; 660 return 0;
1004} 661}
1005 662
1006#endif 663#endif
1007 664
1008/* sendfile always needs emulation */ 665/* sendfile always needs emulation */
1009static eio_ssize_t 666static eio_ssize_t
1010eio__sendfile (int ofd, int ifd, off_t offset, size_t count, etp_worker *self) 667eio__sendfile (int ofd, int ifd, off_t offset, size_t count)
1011{ 668{
1012 eio_ssize_t written = 0; 669 eio_ssize_t written = 0;
1013 eio_ssize_t res; 670 eio_ssize_t res;
1014 671
1015 if (!count) 672 if (!count)
… …
1043 700
1044 /* according to source inspection, this is correct, and useful behaviour */ 701 /* according to source inspection, this is correct, and useful behaviour */
1045 if (sbytes) 702 if (sbytes)
1046 res = sbytes; 703 res = sbytes;
1047 704
1048# elif defined (__APPLE__) 705# elif defined __APPLE__
1049 off_t sbytes = count; 706 off_t sbytes = count;
1050 res = sendfile (ifd, ofd, offset, &sbytes, 0, 0); 707 res = sendfile (ifd, ofd, offset, &sbytes, 0, 0);
1051 708
1052 /* according to the manpage, sbytes is always valid */ 709 /* according to the manpage, sbytes is always valid */
1053 if (sbytes) 710 if (sbytes)
… …
1080 HANDLE h = TO_SOCKET (ifd); 737 HANDLE h = TO_SOCKET (ifd);
1081 SetFilePointer (h, offset, 0, FILE_BEGIN); 738 SetFilePointer (h, offset, 0, FILE_BEGIN);
1082 res = TransmitFile (TO_SOCKET (ofd), h, count, 0, 0, 0, 0); 739 res = TransmitFile (TO_SOCKET (ofd), h, count, 0, 0, 0, 0);
1083 740
1084#else 741#else
1085 res = -1; 742 res = EIO_ENOSYS ();
1086 errno = ENOSYS;
1087#endif 743#endif
1088 744
1089 /* we assume sendfile can copy at least 128mb in one go */ 745 /* we assume sendfile can copy at least 128mb in one go */
1090 if (res <= 128 * 1024 * 1024) 746 if (res <= 128 * 1024 * 1024)
1091 { 747 {
… …
1151 807
1152 offset += cnt; 808 offset += cnt;
1153 res += cnt; 809 res += cnt;
1154 count -= cnt; 810 count -= cnt;
1155 } 811 }
812
813 FUBd;
1156 } 814 }
1157 815
1158 return res; 816 return res;
1159} 817}
1160 818
… …
1276 934
1277/*****************************************************************************/ 935/*****************************************************************************/
1278/* requests implemented outside eio_execute, because they are so large */ 936/* requests implemented outside eio_execute, because they are so large */
1279 937
1280static void 938static void
1281eio__realpath (eio_req *req, etp_worker *self) 939eio__lseek (eio_req *req)
1282{ 940{
1283 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{
1284 char *res; 956 char *res;
957 const char *rel = path;
1285 char *tmp1, *tmp2; 958 char *tmp1, *tmp2;
1286#if SYMLOOP_MAX > 32 959#if SYMLOOP_MAX > 32
1287 int symlinks = SYMLOOP_MAX; 960 int symlinks = SYMLOOP_MAX;
1288#else 961#else
1289 int symlinks = 32; 962 int symlinks = 32;
1290#endif 963#endif
1291 964
1292 req->result = -1;
1293
1294 errno = EINVAL; 965 errno = EINVAL;
1295 if (!rel) 966 if (!rel)
1296 return; 967 return -1;
1297 968
1298 errno = ENOENT; 969 errno = ENOENT;
1299 if (!*rel) 970 if (!*rel)
1300 return; 971 return -1;
1301 972
1302 if (!req->ptr2) 973 res = etp_tmpbuf_get (tmpbuf, PATH_MAX * 3);
1303 { 974#ifdef _WIN32
1304 X_LOCK (wrklock); 975 if (_access (rel, 4) != 0)
1305 req->flags |= EIO_FLAG_PTR2_FREE;
1306 X_UNLOCK (wrklock);
1307 req->ptr2 = malloc (PATH_MAX * 3);
1308
1309 errno = ENOMEM;
1310 if (!req->ptr2)
1311 return; 976 return -1;
1312 }
1313 977
1314 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
1315 tmp1 = res + PATH_MAX; 991 tmp1 = res + PATH_MAX;
1316 tmp2 = tmp1 + PATH_MAX; 992 tmp2 = tmp1 + PATH_MAX;
1317 993
1318#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 */
1319#if __linux && defined(O_NONBLOCK) && defined(O_NOATIME) 995#if __linux && defined(O_NONBLOCK) && defined(O_NOATIME)
… …
1323 999
1324 if (fd >= 0) 1000 if (fd >= 0)
1325 { 1001 {
1326 sprintf (tmp1, "/proc/self/fd/%d", fd); 1002 sprintf (tmp1, "/proc/self/fd/%d", fd);
1327 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 */
1328 close (fd); 1005 close (fd);
1329
1330 /* here we should probably stat the open file and the disk file, to make sure they still match */
1331 1006
1332 if (req->result > 0) 1007 if (req->result > 0)
1333 goto done; 1008 goto done;
1334 } 1009 }
1335 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)
1336 return; 1011 return -1;
1337 } 1012 }
1338#endif 1013#endif
1339#endif 1014#endif
1340 1015
1341 if (*rel != '/') 1016 if (*rel != '/')
1342 { 1017 {
1018 int len;
1019
1020 errno = ENOENT;
1021 if (wd == EIO_INVALID_WD)
1022 return -1;
1023
1024 if (wd == EIO_CWD)
1025 {
1343 if (!getcwd (res, PATH_MAX)) 1026 if (!getcwd (res, PATH_MAX))
1344 return; 1027 return -1;
1028
1029 len = strlen (res);
1030 }
1031 else
1032 memcpy (res, wd->str, len = wd->len);
1345 1033
1346 if (res [1]) /* only use if not / */ 1034 if (res [1]) /* only use if not / */
1347 res += strlen (res); 1035 res += len;
1348 } 1036 }
1349 1037
1350 while (*rel) 1038 while (*rel)
1351 { 1039 {
1352 eio_ssize_t len, linklen; 1040 eio_ssize_t len, linklen;
1353 char *beg = rel; 1041 const char *beg = rel;
1354 1042
1355 while (*rel && *rel != '/') 1043 while (*rel && *rel != '/')
1356 ++rel; 1044 ++rel;
1357 1045
1358 len = rel - beg; 1046 len = rel - beg;
… …
1370 1058
1371 if (beg [1] == '.' && len == 2) 1059 if (beg [1] == '.' && len == 2)
1372 { 1060 {
1373 /* .. - back up one component, if possible */ 1061 /* .. - back up one component, if possible */
1374 1062
1375 while (res != req->ptr2) 1063 while (res != tmpbuf->ptr)
1376 if (*--res == '/') 1064 if (*--res == '/')
1377 break; 1065 break;
1378 1066
1379 continue; 1067 continue;
1380 } 1068 }
1381 } 1069 }
1382 1070
1383 errno = ENAMETOOLONG; 1071 errno = ENAMETOOLONG;
1384 if (res + 1 + len + 1 >= tmp1) 1072 if (res + 1 + len + 1 >= tmp1)
1385 return; 1073 return -1;
1386 1074
1387 /* copy one component */ 1075 /* copy one component */
1388 *res = '/'; 1076 *res = '/';
1389 memcpy (res + 1, beg, len); 1077 memcpy (res + 1, beg, len);
1390 1078
1391 /* zero-terminate, for readlink */ 1079 /* zero-terminate, for readlink */
1392 res [len + 1] = 0; 1080 res [len + 1] = 0;
1393 1081
1394 /* now check if it's a symlink */ 1082 /* now check if it's a symlink */
1395 linklen = readlink (req->ptr2, tmp1, PATH_MAX); 1083 linklen = readlink (tmpbuf->ptr, tmp1, PATH_MAX);
1396 1084
1397 if (linklen < 0) 1085 if (linklen < 0)
1398 { 1086 {
1399 if (errno != EINVAL) 1087 if (errno != EINVAL)
1400 return; 1088 return -1;
1401 1089
1402 /* it's a normal directory. hopefully */ 1090 /* it's a normal directory. hopefully */
1403 res += len + 1; 1091 res += len + 1;
1404 } 1092 }
1405 else 1093 else
… …
1407 /* yay, it was a symlink - build new path in tmp2 */ 1095 /* yay, it was a symlink - build new path in tmp2 */
1408 int rellen = strlen (rel); 1096 int rellen = strlen (rel);
1409 1097
1410 errno = ENAMETOOLONG; 1098 errno = ENAMETOOLONG;
1411 if (linklen + 1 + rellen >= PATH_MAX) 1099 if (linklen + 1 + rellen >= PATH_MAX)
1412 return; 1100 return -1;
1413 1101
1414 errno = ELOOP; 1102 errno = ELOOP;
1415 if (!--symlinks) 1103 if (!--symlinks)
1416 return; 1104 return -1;
1417 1105
1418 if (*tmp1 == '/') 1106 if (*tmp1 == '/')
1419 res = req->ptr2; /* symlink resolves to an absolute path */ 1107 res = tmpbuf->ptr; /* symlink resolves to an absolute path */
1420 1108
1421 /* 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 */
1422 memmove (tmp2 + linklen + 1, rel, rellen + 1); 1110 memmove (tmp2 + linklen + 1, rel, rellen + 1);
1423 tmp2 [linklen] = '/'; 1111 tmp2 [linklen] = '/';
1424 memcpy (tmp2, tmp1, linklen); 1112 memcpy (tmp2, tmp1, linklen);
… …
1426 rel = tmp2; 1114 rel = tmp2;
1427 } 1115 }
1428 } 1116 }
1429 1117
1430 /* special case for the lone root path */ 1118 /* special case for the lone root path */
1431 if (res == req->ptr2) 1119 if (res == tmpbuf->ptr)
1432 *res++ = '/'; 1120 *res++ = '/';
1433 1121
1434 req->result = res - (char *)req->ptr2; 1122 return res - (char *)tmpbuf->ptr;
1435 1123#endif
1436done:
1437 req->ptr2 = realloc (req->ptr2, req->result); /* trade time for space savings */
1438} 1124}
1439 1125
1440static signed char 1126static signed char
1441eio_dent_cmp (const eio_dirent *a, const eio_dirent *b) 1127eio_dent_cmp (const eio_dirent *a, const eio_dirent *b)
1442{ 1128{
… …
1630#ifdef _WIN32 1316#ifdef _WIN32
1631 { 1317 {
1632 int len = strlen ((const char *)req->ptr1); 1318 int len = strlen ((const char *)req->ptr1);
1633 char *path = malloc (MAX_PATH); 1319 char *path = malloc (MAX_PATH);
1634 const char *fmt; 1320 const char *fmt;
1321 const char *reqpath = wd_expand (&self->tmpbuf, req->wd, req->ptr1);
1635 1322
1636 if (!len) 1323 if (!len)
1637 fmt = "./*"; 1324 fmt = "./*";
1638 else if (((const char *)req->ptr1)[len - 1] == '/' || ((const char *)req->ptr1)[len - 1] == '\\') 1325 else if (reqpath[len - 1] == '/' || reqpath[len - 1] == '\\')
1639 fmt = "%s*"; 1326 fmt = "%s*";
1640 else 1327 else
1641 fmt = "%s/*"; 1328 fmt = "%s/*";
1642 1329
1643 _snprintf (path, MAX_PATH, fmt, (const char *)req->ptr1); 1330 _snprintf (path, MAX_PATH, fmt, reqpath);
1644 dirp = FindFirstFile (path, &entp); 1331 dirp = FindFirstFile (path, &entp);
1645 free (path); 1332 free (path);
1646 1333
1647 if (dirp == INVALID_HANDLE_VALUE) 1334 if (dirp == INVALID_HANDLE_VALUE)
1648 { 1335 {
1649 dirp = 0; 1336 /* should steal _dosmaperr */
1650
1651 switch (GetLastError ()) 1337 switch (GetLastError ())
1652 { 1338 {
1653 case ERROR_FILE_NOT_FOUND: 1339 case ERROR_FILE_NOT_FOUND:
1654 req->result = 0; 1340 req->result = 0;
1655 break; 1341 break;
1656 1342
1657 case ERROR_INVALID_NAME: 1343 case ERROR_INVALID_NAME:
1658 case ERROR_PATH_NOT_FOUND: 1344 case ERROR_PATH_NOT_FOUND:
1659 case ERROR_NO_MORE_FILES: 1345 case ERROR_NO_MORE_FILES:
1660 errno = ENOENT; 1346 errno = ENOENT;
1661 break; 1347 break;
1662 1348
1663 case ERROR_NOT_ENOUGH_MEMORY: 1349 case ERROR_NOT_ENOUGH_MEMORY:
1664 errno = ENOMEM; 1350 errno = ENOMEM;
1665 break; 1351 break;
1666 1352
1667 default: 1353 default:
1668 errno = EINVAL; 1354 errno = EINVAL;
1669 break; 1355 break;
1670 } 1356 }
1357
1358 return;
1671 } 1359 }
1672 } 1360 }
1673#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
1674 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;
1675#endif 1383#endif
1676 1384
1677 if (req->flags & EIO_FLAG_PTR1_FREE) 1385 if (req->flags & EIO_FLAG_PTR1_FREE)
1678 free (req->ptr1); 1386 free (req->ptr1);
1679 1387
1680 req->flags |= EIO_FLAG_PTR1_FREE | EIO_FLAG_PTR2_FREE; 1388 req->flags |= EIO_FLAG_PTR1_FREE | EIO_FLAG_PTR2_FREE;
1681 req->ptr1 = dents = flags ? malloc (dentalloc * sizeof (eio_dirent)) : 0; 1389 req->ptr1 = dents = flags ? malloc (dentalloc * sizeof (eio_dirent)) : 0;
1682 req->ptr2 = names = malloc (namesalloc); 1390 req->ptr2 = names = malloc (namesalloc);
1683 1391
1684 if (dirp && names && (!flags || dents)) 1392 if (!names || (flags && !dents))
1393 return;
1394
1685 for (;;) 1395 for (;;)
1686 { 1396 {
1687 int done; 1397 int done;
1688 1398
1689#ifdef _WIN32 1399#ifdef _WIN32
1690 done = !dirp; 1400 done = !dirp;
1691#else 1401#else
1692 errno = 0; 1402 errno = 0;
1693 entp = readdir (dirp); 1403 entp = readdir (dirp);
1694 done = !entp; 1404 done = !entp;
1695#endif 1405#endif
1696 1406
1697 if (done) 1407 if (done)
1698 { 1408 {
1699#ifndef _WIN32 1409#ifndef _WIN32
1700 int old_errno = errno; 1410 int old_errno = errno;
1701 closedir (dirp); 1411 closedir (dirp);
1702 errno = old_errno; 1412 errno = old_errno;
1703 1413
1704 if (errno) 1414 if (errno)
1705 break; 1415 break;
1706#endif 1416#endif
1707 1417
1708 /* sort etc. */ 1418 /* sort etc. */
1709 req->int1 = flags; 1419 req->int1 = flags;
1710 req->result = dentoffs; 1420 req->result = dentoffs;
1711 1421
1712 if (flags & EIO_READDIR_STAT_ORDER) 1422 if (flags & EIO_READDIR_STAT_ORDER)
1713 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);
1714 else if (flags & EIO_READDIR_DIRS_FIRST) 1424 else if (flags & EIO_READDIR_DIRS_FIRST)
1715 if (flags & EIO_READDIR_FOUND_UNKNOWN) 1425 if (flags & EIO_READDIR_FOUND_UNKNOWN)
1716 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 */
1717 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))
1718 { 1478 {
1719 /* 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
1720 eio_dirent *oth = dents + dentoffs; 1486 ent = dents + dentoffs;
1721 eio_dirent *dir = dents;
1722 1487
1723 /* 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 */
1724 /* by walking from both sides and swapping if necessary */ 1489 ent->namelen = len - 1;
1725 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)
1726 { 1550 {
1727 if (dir->type == EIO_DT_DIR) 1551 if (*name == '.') /* leading dots are likely directories, and, in any case, rare */
1728 ++dir; 1552 ent->score = 1;
1729 else if ((--oth)->type == EIO_DT_DIR) 1553 else if (!strchr (name, '.')) /* absence of dots indicate likely dirs */
1730 { 1554 ent->score = len <= 2 ? 4 - len : len <= 4 ? 4 : len <= 7 ? 5 : 6; /* shorter == more likely dir, but avoid too many classes */
1731 eio_dirent tmp = *dir; *dir = *oth; *oth = tmp;
1732
1733 ++dir;
1734 }
1735 } 1555 }
1736 1556 else if (ent->type == EIO_DT_DIR)
1737 /* now sort the dirs only (dirs all have the same score) */ 1557 ent->score = 0;
1738 eio_dent_sort (dents, dir - dents, 0, inode_bits);
1739 } 1558 }
1740
1741 break;
1742 }
1743
1744 /* now add the entry to our list(s) */
1745 name = D_NAME (entp);
1746
1747 /* skip . and .. entries */
1748 if (name [0] != '.' || (name [1] && (name [1] != '.' || name [2])))
1749 {
1750 int len = D_NAMLEN (entp) + 1;
1751
1752 while (ecb_expect_false (namesoffs + len > namesalloc))
1753 {
1754 namesalloc *= 2;
1755 req->ptr2 = names = realloc (names, namesalloc);
1756
1757 if (!names)
1758 break;
1759 } 1559 }
1760 1560
1761 memcpy (names + namesoffs, name, len);
1762
1763 if (dents)
1764 {
1765 struct eio_dirent *ent;
1766
1767 if (ecb_expect_false (dentoffs == dentalloc))
1768 {
1769 dentalloc *= 2;
1770 req->ptr1 = dents = realloc (dents, dentalloc * sizeof (eio_dirent));
1771
1772 if (!dents)
1773 break;
1774 }
1775
1776 ent = dents + dentoffs;
1777
1778 ent->nameofs = namesoffs; /* rather dirtily we store the offset in the pointer */
1779 ent->namelen = len - 1;
1780 ent->inode = D_INO (entp);
1781
1782 inode_bits |= ent->inode;
1783
1784 switch (D_TYPE (entp))
1785 {
1786 default:
1787 ent->type = EIO_DT_UNKNOWN;
1788 flags |= EIO_READDIR_FOUND_UNKNOWN;
1789 break;
1790
1791 #ifdef DT_FIFO
1792 case DT_FIFO: ent->type = EIO_DT_FIFO; break;
1793 #endif
1794 #ifdef DT_CHR
1795 case DT_CHR: ent->type = EIO_DT_CHR; break;
1796 #endif
1797 #ifdef DT_MPC
1798 case DT_MPC: ent->type = EIO_DT_MPC; break;
1799 #endif
1800 #ifdef DT_DIR
1801 case DT_DIR: ent->type = EIO_DT_DIR; break;
1802 #endif
1803 #ifdef DT_NAM
1804 case DT_NAM: ent->type = EIO_DT_NAM; break;
1805 #endif
1806 #ifdef DT_BLK
1807 case DT_BLK: ent->type = EIO_DT_BLK; break;
1808 #endif
1809 #ifdef DT_MPB
1810 case DT_MPB: ent->type = EIO_DT_MPB; break;
1811 #endif
1812 #ifdef DT_REG
1813 case DT_REG: ent->type = EIO_DT_REG; break;
1814 #endif
1815 #ifdef DT_NWK
1816 case DT_NWK: ent->type = EIO_DT_NWK; break;
1817 #endif
1818 #ifdef DT_CMP
1819 case DT_CMP: ent->type = EIO_DT_CMP; break;
1820 #endif
1821 #ifdef DT_LNK
1822 case DT_LNK: ent->type = EIO_DT_LNK; break;
1823 #endif
1824 #ifdef DT_SOCK
1825 case DT_SOCK: ent->type = EIO_DT_SOCK; break;
1826 #endif
1827 #ifdef DT_DOOR
1828 case DT_DOOR: ent->type = EIO_DT_DOOR; break;
1829 #endif
1830 #ifdef DT_WHT
1831 case DT_WHT: ent->type = EIO_DT_WHT; break;
1832 #endif
1833 }
1834
1835 ent->score = 7;
1836
1837 if (flags & EIO_READDIR_DIRS_FIRST)
1838 {
1839 if (ent->type == EIO_DT_UNKNOWN)
1840 {
1841 if (*name == '.') /* leading dots are likely directories, and, in any case, rare */
1842 ent->score = 1;
1843 else if (!strchr (name, '.')) /* absense of dots indicate likely dirs */
1844 ent->score = len <= 2 ? 4 - len : len <= 4 ? 4 : len <= 7 ? 5 : 6; /* shorter == more likely dir, but avoid too many classes */
1845 }
1846 else if (ent->type == EIO_DT_DIR)
1847 ent->score = 0;
1848 }
1849 }
1850
1851 namesoffs += len; 1561 namesoffs += len;
1852 ++dentoffs; 1562 ++dentoffs;
1853 } 1563 }
1854 1564
1855 if (EIO_CANCELLED (req)) 1565 if (EIO_CANCELLED (req))
1856 { 1566 {
1857 errno = ECANCELED; 1567 errno = ECANCELED;
1858 break; 1568 break;
1859 } 1569 }
1860 1570
1861#ifdef _WIN32 1571#ifdef _WIN32
1862 if (!FindNextFile (dirp, &entp)) 1572 if (!FindNextFile (dirp, &entp))
1863 { 1573 {
1864 FindClose (dirp); 1574 FindClose (dirp);
1865 dirp = 0; 1575 dirp = 0;
1866 } 1576 }
1867#endif 1577#endif
1868 } 1578 }
1869} 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
1870 1702
1871/*****************************************************************************/ 1703/*****************************************************************************/
1872 1704
1873#define ALLOC(len) \ 1705#define ALLOC(len) \
1874 if (!req->ptr2) \ 1706 if (!req->ptr2) \
… …
1883 req->result = -1; \ 1715 req->result = -1; \
1884 break; \ 1716 break; \
1885 } \ 1717 } \
1886 } 1718 }
1887 1719
1888X_THREAD_PROC (etp_proc)
1889{
1890 ETP_REQ *req;
1891 struct timespec ts;
1892 etp_worker *self = (etp_worker *)thr_arg;
1893
1894 /* try to distribute timeouts somewhat evenly */
1895 ts.tv_nsec = ((unsigned long)self & 1023UL) * (1000000000UL / 1024UL);
1896
1897 for (;;)
1898 {
1899 ts.tv_sec = 0;
1900
1901 X_LOCK (reqlock);
1902
1903 for (;;)
1904 {
1905 self->req = req = reqq_shift (&req_queue);
1906
1907 if (req)
1908 break;
1909
1910 if (ts.tv_sec == 1) /* no request, but timeout detected, let's quit */
1911 {
1912 X_UNLOCK (reqlock);
1913 X_LOCK (wrklock);
1914 --started;
1915 X_UNLOCK (wrklock);
1916 goto quit;
1917 }
1918
1919 ++idle;
1920
1921 if (idle <= max_idle)
1922 /* we are allowed to idle, so do so without any timeout */
1923 X_COND_WAIT (reqwait, reqlock);
1924 else
1925 {
1926 /* initialise timeout once */
1927 if (!ts.tv_sec)
1928 ts.tv_sec = time (0) + idle_timeout;
1929
1930 if (X_COND_TIMEDWAIT (reqwait, reqlock, ts) == ETIMEDOUT)
1931 ts.tv_sec = 1; /* assuming this is not a value computed above.,.. */
1932 }
1933
1934 --idle;
1935 }
1936
1937 --nready;
1938
1939 X_UNLOCK (reqlock);
1940
1941 if (req->type < 0)
1942 goto quit;
1943
1944 ETP_EXECUTE (self, req);
1945
1946 X_LOCK (reslock);
1947
1948 ++npending;
1949
1950 if (!reqq_push (&res_queue, req) && want_poll_cb)
1951 want_poll_cb ();
1952
1953 self->req = 0;
1954 etp_worker_clear (self);
1955
1956 X_UNLOCK (reslock);
1957 }
1958
1959quit:
1960 X_LOCK (wrklock);
1961 etp_worker_free (self);
1962 X_UNLOCK (wrklock);
1963
1964 return 0;
1965}
1966
1967/*****************************************************************************/ 1720/*****************************************************************************/
1968 1721
1969int ecb_cold 1722int ecb_cold
1970eio_init (void (*want_poll)(void), void (*done_poll)(void)) 1723eio_init (void (*want_poll)(void), void (*done_poll)(void))
1971{ 1724{
1972#if !HAVE_PREADWRITE
1973 X_MUTEX_CREATE (preadwritelock);
1974#endif
1975
1976 return etp_init (want_poll, done_poll); 1725 return etp_init (want_poll, done_poll);
1977} 1726}
1978 1727
1979ecb_inline void 1728ecb_inline void
1980eio_api_destroy (eio_req *req) 1729eio_api_destroy (eio_req *req)
1981{ 1730{
1982 free (req); 1731 free (req);
1983} 1732}
1984 1733
1985#define REQ(rtype) \ 1734#define REQ(rtype) \
1986 eio_req *req; \ 1735 eio_req *req; \
1987 \ 1736 \
1988 req = (eio_req *)calloc (1, sizeof *req); \ 1737 req = (eio_req *)calloc (1, sizeof *req); \
1989 if (!req) \ 1738 if (!req) \
1990 return 0; \ 1739 return 0; \
… …
2004 { \ 1753 { \
2005 eio_api_destroy (req); \ 1754 eio_api_destroy (req); \
2006 return 0; \ 1755 return 0; \
2007 } 1756 }
2008 1757
1758#define SINGLEDOT(ptr) (0[(char *)(ptr)] == '.' && !1[(char *)(ptr)])
1759
2009static void 1760static void
2010eio_execute (etp_worker *self, eio_req *req) 1761eio_execute (etp_worker *self, eio_req *req)
2011{ 1762{
1763#if HAVE_AT
1764 int dirfd;
1765#else
1766 const char *path;
1767#endif
1768
2012 if (ecb_expect_false (EIO_CANCELLED (req))) 1769 if (ecb_expect_false (EIO_CANCELLED (req)))
2013 { 1770 {
2014 req->result = -1; 1771 req->result = -1;
2015 req->errorno = ECANCELED; 1772 req->errorno = ECANCELED;
2016 return; 1773 return;
2017 } 1774 }
2018 1775
1776 if (ecb_expect_false (req->wd == EIO_INVALID_WD))
1777 {
1778 req->result = -1;
1779 req->errorno = ENOENT;
1780 return;
1781 }
1782
1783 if (req->type >= EIO_OPEN)
1784 {
1785 #if HAVE_AT
1786 dirfd = WD2FD (req->wd);
1787 #else
1788 path = wd_expand (&self->tmpbuf, req->wd, req->ptr1);
1789 #endif
1790 }
1791
2019 switch (req->type) 1792 switch (req->type)
2020 { 1793 {
1794 case EIO_WD_OPEN: req->wd = eio__wd_open_sync (&self->tmpbuf, req->wd, req->ptr1);
1795 req->result = req->wd == EIO_INVALID_WD ? -1 : 0;
1796 break;
1797 case EIO_WD_CLOSE: req->result = 0;
1798 eio_wd_close_sync (req->wd); break;
1799
1800 case EIO_SEEK: eio__lseek (req); break;
2021 case EIO_READ: ALLOC (req->size); 1801 case EIO_READ: ALLOC (req->size);
2022 req->result = req->offs >= 0 1802 req->result = req->offs >= 0
2023 ? pread (req->int1, req->ptr2, req->size, req->offs) 1803 ? pread (req->int1, req->ptr2, req->size, req->offs)
2024 : read (req->int1, req->ptr2, req->size); break; 1804 : read (req->int1, req->ptr2, req->size); break;
2025 case EIO_WRITE: req->result = req->offs >= 0 1805 case EIO_WRITE: req->result = req->offs >= 0
2026 ? pwrite (req->int1, req->ptr2, req->size, req->offs) 1806 ? pwrite (req->int1, req->ptr2, req->size, req->offs)
2027 : write (req->int1, req->ptr2, req->size); break; 1807 : write (req->int1, req->ptr2, req->size); break;
2028 1808
2029 case EIO_READAHEAD: req->result = readahead (req->int1, req->offs, req->size); break; 1809 case EIO_READAHEAD: req->result = readahead (req->int1, req->offs, req->size); break;
2030 case EIO_SENDFILE: req->result = eio__sendfile (req->int1, req->int2, req->offs, req->size, self); break; 1810 case EIO_SENDFILE: req->result = eio__sendfile (req->int1, req->int2, req->offs, req->size); break;
1811
1812#if HAVE_AT
2031 1813
2032 case EIO_STAT: ALLOC (sizeof (EIO_STRUCT_STAT)); 1814 case EIO_STAT: ALLOC (sizeof (EIO_STRUCT_STAT));
2033 req->result = stat (req->ptr1, (EIO_STRUCT_STAT *)req->ptr2); break; 1815 req->result = fstatat (dirfd, req->ptr1, (EIO_STRUCT_STAT *)req->ptr2, 0); break;
2034 case EIO_LSTAT: ALLOC (sizeof (EIO_STRUCT_STAT)); 1816 case EIO_LSTAT: ALLOC (sizeof (EIO_STRUCT_STAT));
1817 req->result = fstatat (dirfd, req->ptr1, (EIO_STRUCT_STAT *)req->ptr2, AT_SYMLINK_NOFOLLOW); break;
1818 case EIO_CHOWN: req->result = fchownat (dirfd, req->ptr1, req->int2, req->int3, 0); break;
1819 case EIO_CHMOD: req->result = fchmodat (dirfd, req->ptr1, (mode_t)req->int2, 0); break;
1820 case EIO_TRUNCATE: req->result = eio__truncateat (dirfd, req->ptr1, req->offs); break;
1821 case EIO_OPEN: req->result = openat (dirfd, req->ptr1, req->int1, (mode_t)req->int2); break;
1822
1823 case EIO_UNLINK: req->result = unlinkat (dirfd, req->ptr1, 0); break;
1824 case EIO_RMDIR: /* complications arise because "." cannot be removed, so we might have to expand */
1825 req->result = req->wd && SINGLEDOT (req->ptr1)
1826 ? rmdir (req->wd->str)
1827 : unlinkat (dirfd, req->ptr1, AT_REMOVEDIR); break;
1828 case EIO_MKDIR: req->result = mkdirat (dirfd, req->ptr1, (mode_t)req->int2); break;
1829 case EIO_RENAME: /* complications arise because "." cannot be renamed, so we might have to expand */
1830 req->result = req->wd && SINGLEDOT (req->ptr1)
1831 ? rename (req->wd->str, req->ptr2)
1832 : renameat (dirfd, req->ptr1, WD2FD ((eio_wd)req->int3), req->ptr2); break;
1833 case EIO_LINK: req->result = linkat (dirfd, req->ptr1, WD2FD ((eio_wd)req->int3), req->ptr2, 0); break;
1834 case EIO_SYMLINK: req->result = symlinkat (req->ptr1, dirfd, req->ptr2); break;
1835 case EIO_MKNOD: req->result = mknodat (dirfd, req->ptr1, (mode_t)req->int2, (dev_t)req->offs); break;
1836 case EIO_READLINK: ALLOC (PATH_MAX);
1837 req->result = readlinkat (dirfd, req->ptr1, req->ptr2, PATH_MAX); break;
1838 case EIO_STATVFS: ALLOC (sizeof (EIO_STRUCT_STATVFS));
1839 req->result = eio__statvfsat (dirfd, req->ptr1, (EIO_STRUCT_STATVFS *)req->ptr2); break;
1840 case EIO_UTIME:
1841 case EIO_FUTIME:
1842 {
1843 struct timespec ts[2];
1844 struct timespec *times;
1845
1846 if (req->nv1 != -1. || req->nv2 != -1.)
1847 {
1848 ts[0].tv_sec = req->nv1;
1849 ts[0].tv_nsec = (req->nv1 - ts[0].tv_sec) * 1e9;
1850 ts[1].tv_sec = req->nv2;
1851 ts[1].tv_nsec = (req->nv2 - ts[1].tv_sec) * 1e9;
1852
1853 times = ts;
1854 }
1855 else
1856 times = 0;
1857
1858 req->result = req->type == EIO_FUTIME
1859 ? futimens (req->int1, times)
1860 : utimensat (dirfd, req->ptr1, times, 0);
1861 }
1862 break;
1863
1864#else
1865
1866 case EIO_STAT: ALLOC (sizeof (EIO_STRUCT_STAT));
1867 req->result = stat (path , (EIO_STRUCT_STAT *)req->ptr2); break;
1868 case EIO_LSTAT: ALLOC (sizeof (EIO_STRUCT_STAT));
2035 req->result = lstat (req->ptr1, (EIO_STRUCT_STAT *)req->ptr2); break; 1869 req->result = lstat (path , (EIO_STRUCT_STAT *)req->ptr2); break;
1870 case EIO_CHOWN: req->result = chown (path , req->int2, req->int3); break;
1871 case EIO_CHMOD: req->result = chmod (path , (mode_t)req->int2); break;
1872 case EIO_TRUNCATE: req->result = truncate (path , req->offs); break;
1873 case EIO_OPEN: req->result = open (path , req->int1, (mode_t)req->int2); break;
1874
1875 case EIO_UNLINK: req->result = unlink (path ); break;
1876 case EIO_RMDIR: req->result = rmdir (path ); break;
1877 case EIO_MKDIR: req->result = mkdir (path , (mode_t)req->int2); break;
1878 case EIO_RENAME: req->result = rename (path , req->ptr2); break;
1879 case EIO_LINK: req->result = link (path , req->ptr2); break;
1880 case EIO_SYMLINK: req->result = symlink (path , req->ptr2); break;
1881 case EIO_MKNOD: req->result = mknod (path , (mode_t)req->int2, (dev_t)req->offs); break;
1882 case EIO_READLINK: ALLOC (PATH_MAX);
1883 req->result = readlink (path, req->ptr2, PATH_MAX); break;
1884 case EIO_STATVFS: ALLOC (sizeof (EIO_STRUCT_STATVFS));
1885 req->result = statvfs (path , (EIO_STRUCT_STATVFS *)req->ptr2); break;
1886
1887 case EIO_UTIME:
1888 case EIO_FUTIME:
1889 {
1890 struct timeval tv[2];
1891 struct timeval *times;
1892
1893 if (req->nv1 != -1. || req->nv2 != -1.)
1894 {
1895 tv[0].tv_sec = req->nv1;
1896 tv[0].tv_usec = (req->nv1 - tv[0].tv_sec) * 1e6;
1897 tv[1].tv_sec = req->nv2;
1898 tv[1].tv_usec = (req->nv2 - tv[1].tv_sec) * 1e6;
1899
1900 times = tv;
1901 }
1902 else
1903 times = 0;
1904
1905 req->result = req->type == EIO_FUTIME
1906 ? futimes (req->int1, times)
1907 : utimes (req->ptr1, times);
1908 }
1909 break;
1910
1911#endif
1912
1913 case EIO_REALPATH: if (0 <= (req->result = eio__realpath (&self->tmpbuf, req->wd, req->ptr1)))
1914 {
1915 ALLOC (req->result);
1916 memcpy (req->ptr2, self->tmpbuf.ptr, req->result);
1917 }
1918 break;
1919
2036 case EIO_FSTAT: ALLOC (sizeof (EIO_STRUCT_STAT)); 1920 case EIO_FSTAT: ALLOC (sizeof (EIO_STRUCT_STAT));
2037 req->result = fstat (req->int1, (EIO_STRUCT_STAT *)req->ptr2); break; 1921 req->result = fstat (req->int1, (EIO_STRUCT_STAT *)req->ptr2); break;
2038 1922
2039 case EIO_STATVFS: ALLOC (sizeof (EIO_STRUCT_STATVFS));
2040 req->result = statvfs (req->ptr1, (EIO_STRUCT_STATVFS *)req->ptr2); break;
2041 case EIO_FSTATVFS: ALLOC (sizeof (EIO_STRUCT_STATVFS)); 1923 case EIO_FSTATVFS: ALLOC (sizeof (EIO_STRUCT_STATVFS));
2042 req->result = fstatvfs (req->int1, (EIO_STRUCT_STATVFS *)req->ptr2); break; 1924 req->result = fstatvfs (req->int1, (EIO_STRUCT_STATVFS *)req->ptr2); break;
2043 1925
2044 case EIO_CHOWN: req->result = chown (req->ptr1, req->int2, req->int3); break;
2045 case EIO_FCHOWN: req->result = fchown (req->int1, req->int2, req->int3); break; 1926 case EIO_FCHOWN: req->result = fchown (req->int1, req->int2, req->int3); break;
2046 case EIO_CHMOD: req->result = chmod (req->ptr1, (mode_t)req->int2); break;
2047 case EIO_FCHMOD: req->result = fchmod (req->int1, (mode_t)req->int2); break; 1927 case EIO_FCHMOD: req->result = fchmod (req->int1, (mode_t)req->int2); break;
2048 case EIO_TRUNCATE: req->result = truncate (req->ptr1, req->offs); break;
2049 case EIO_FTRUNCATE: req->result = ftruncate (req->int1, req->offs); break; 1928 case EIO_FTRUNCATE: req->result = ftruncate (req->int1, req->offs); break;
2050 1929
2051 case EIO_OPEN: req->result = open (req->ptr1, req->int1, (mode_t)req->int2); break;
2052 case EIO_CLOSE: req->result = close (req->int1); break; 1930 case EIO_CLOSE: req->result = close (req->int1); break;
2053 case EIO_DUP2: req->result = dup2 (req->int1, req->int2); break; 1931 case EIO_DUP2: req->result = dup2 (req->int1, req->int2); break;
2054 case EIO_UNLINK: req->result = unlink (req->ptr1); break;
2055 case EIO_RMDIR: req->result = rmdir (req->ptr1); break;
2056 case EIO_MKDIR: req->result = mkdir (req->ptr1, (mode_t)req->int2); break;
2057 case EIO_RENAME: req->result = rename (req->ptr1, req->ptr2); break;
2058 case EIO_LINK: req->result = link (req->ptr1, req->ptr2); break;
2059 case EIO_SYMLINK: req->result = symlink (req->ptr1, req->ptr2); break;
2060 case EIO_MKNOD: req->result = mknod (req->ptr1, (mode_t)req->int2, (dev_t)req->offs); break;
2061
2062 case EIO_REALPATH: eio__realpath (req, self); break;
2063
2064 case EIO_READLINK: ALLOC (PATH_MAX);
2065 req->result = readlink (req->ptr1, req->ptr2, PATH_MAX); break;
2066
2067 case EIO_SYNC: req->result = 0; sync (); break; 1932 case EIO_SYNC: req->result = 0; sync (); break;
2068 case EIO_FSYNC: req->result = fsync (req->int1); break; 1933 case EIO_FSYNC: req->result = fsync (req->int1); break;
2069 case EIO_FDATASYNC: req->result = fdatasync (req->int1); break; 1934 case EIO_FDATASYNC: req->result = fdatasync (req->int1); break;
1935 case EIO_SYNCFS: req->result = eio__syncfs (req->int1); break;
1936 case EIO_SYNC_FILE_RANGE: req->result = eio__sync_file_range (req->int1, req->offs, req->size, req->int2); break;
2070 case EIO_MSYNC: req->result = eio__msync (req->ptr2, req->size, req->int1); break; 1937 case EIO_MSYNC: req->result = eio__msync (req->ptr2, req->size, req->int1); break;
2071 case EIO_MTOUCH: req->result = eio__mtouch (req); break; 1938 case EIO_MTOUCH: req->result = eio__mtouch (req); break;
2072 case EIO_MLOCK: req->result = eio__mlock (req->ptr2, req->size); break; 1939 case EIO_MLOCK: req->result = eio__mlock (req->ptr2, req->size); break;
2073 case EIO_MLOCKALL: req->result = eio__mlockall (req->int1); break; 1940 case EIO_MLOCKALL: req->result = eio__mlockall (req->int1); break;
2074 case EIO_SYNC_FILE_RANGE: req->result = eio__sync_file_range (req->int1, req->offs, req->size, req->int2); break;
2075 case EIO_FALLOCATE: req->result = eio__fallocate (req->int1, req->int2, req->offs, req->size); break; 1941 case EIO_FALLOCATE: req->result = eio__fallocate (req->int1, req->int2, req->offs, req->size); break;
2076 1942
2077 case EIO_READDIR: eio__scandir (req, self); break; 1943 case EIO_READDIR: eio__scandir (req, self); break;
2078 1944
2079 case EIO_BUSY: 1945 case EIO_BUSY:
… …
2089 req->result = select (0, 0, 0, 0, &tv); 1955 req->result = select (0, 0, 0, 0, &tv);
2090 } 1956 }
2091#endif 1957#endif
2092 break; 1958 break;
2093 1959
2094 case EIO_UTIME: 1960#if 0
2095 case EIO_FUTIME:
2096 {
2097 struct timeval tv[2];
2098 struct timeval *times;
2099
2100 if (req->nv1 != -1. || req->nv2 != -1.)
2101 {
2102 tv[0].tv_sec = req->nv1;
2103 tv[0].tv_usec = (req->nv1 - tv[0].tv_sec) * 1000000.;
2104 tv[1].tv_sec = req->nv2;
2105 tv[1].tv_usec = (req->nv2 - tv[1].tv_sec) * 1000000.;
2106
2107 times = tv;
2108 }
2109 else
2110 times = 0;
2111
2112 req->result = req->type == EIO_FUTIME
2113 ? futimes (req->int1, times)
2114 : utimes (req->ptr1, times);
2115 }
2116 break;
2117
2118 case EIO_GROUP: 1961 case EIO_GROUP:
2119 abort (); /* handled in eio_request */ 1962 abort (); /* handled in eio_request */
1963#endif
2120 1964
2121 case EIO_NOP: 1965 case EIO_NOP:
2122 req->result = 0; 1966 req->result = 0;
2123 break; 1967 break;
2124 1968
2125 case EIO_CUSTOM: 1969 case EIO_CUSTOM:
2126 req->feed (req); 1970 req->feed (req);
2127 break; 1971 break;
2128 1972
2129 default: 1973 default:
2130 errno = ENOSYS;
2131 req->result = -1; 1974 req->result = EIO_ENOSYS ();
2132 break; 1975 break;
2133 } 1976 }
2134 1977
2135 req->errorno = errno; 1978 req->errorno = errno;
2136} 1979}
2137 1980
2138#ifndef EIO_NO_WRAPPERS 1981#ifndef EIO_NO_WRAPPERS
2139 1982
1983eio_req *eio_wd_open (const char *path, int pri, eio_cb cb, void *data)
1984{
1985 REQ (EIO_WD_OPEN); PATH; SEND;
1986}
1987
1988eio_req *eio_wd_close (eio_wd wd, int pri, eio_cb cb, void *data)
1989{
1990 REQ (EIO_WD_CLOSE); req->wd = wd; SEND;
1991}
1992
2140eio_req *eio_nop (int pri, eio_cb cb, void *data) 1993eio_req *eio_nop (int pri, eio_cb cb, void *data)
2141{ 1994{
2142 REQ (EIO_NOP); SEND; 1995 REQ (EIO_NOP); SEND;
2143} 1996}
2144 1997
… …
2160eio_req *eio_msync (void *addr, size_t length, int flags, int pri, eio_cb cb, void *data) 2013eio_req *eio_msync (void *addr, size_t length, int flags, int pri, eio_cb cb, void *data)
2161{ 2014{
2162 REQ (EIO_MSYNC); req->ptr2 = addr; req->size = length; req->int1 = flags; SEND; 2015 REQ (EIO_MSYNC); req->ptr2 = addr; req->size = length; req->int1 = flags; SEND;
2163} 2016}
2164 2017
2018eio_req *eio_fdatasync (int fd, int pri, eio_cb cb, void *data)
2019{
2020 REQ (EIO_FDATASYNC); req->int1 = fd; SEND;
2021}
2022
2023eio_req *eio_syncfs (int fd, int pri, eio_cb cb, void *data)
2024{
2025 REQ (EIO_SYNCFS); req->int1 = fd; SEND;
2026}
2027
2028eio_req *eio_sync_file_range (int fd, off_t offset, size_t nbytes, unsigned int flags, int pri, eio_cb cb, void *data)
2029{
2030 REQ (EIO_SYNC_FILE_RANGE); req->int1 = fd; req->offs = offset; req->size = nbytes; req->int2 = flags; SEND;
2031}
2032
2165eio_req *eio_mtouch (void *addr, size_t length, int flags, int pri, eio_cb cb, void *data) 2033eio_req *eio_mtouch (void *addr, size_t length, int flags, int pri, eio_cb cb, void *data)
2166{ 2034{
2167 REQ (EIO_MTOUCH); req->ptr2 = addr; req->size = length; req->int1 = flags; SEND; 2035 REQ (EIO_MTOUCH); req->ptr2 = addr; req->size = length; req->int1 = flags; SEND;
2168} 2036}
2169 2037
… …
2175eio_req *eio_mlockall (int flags, int pri, eio_cb cb, void *data) 2043eio_req *eio_mlockall (int flags, int pri, eio_cb cb, void *data)
2176{ 2044{
2177 REQ (EIO_MLOCKALL); req->int1 = flags; SEND; 2045 REQ (EIO_MLOCKALL); req->int1 = flags; SEND;
2178} 2046}
2179 2047
2180eio_req *eio_sync_file_range (int fd, off_t offset, size_t nbytes, unsigned int flags, int pri, eio_cb cb, void *data)
2181{
2182 REQ (EIO_SYNC_FILE_RANGE); req->int1 = fd; req->offs = offset; req->size = nbytes; req->int2 = flags; SEND;
2183}
2184
2185eio_req *eio_fallocate (int fd, int mode, off_t offset, size_t len, int pri, eio_cb cb, void *data) 2048eio_req *eio_fallocate (int fd, int mode, off_t offset, size_t len, int pri, eio_cb cb, void *data)
2186{ 2049{
2187 REQ (EIO_FALLOCATE); req->int1 = fd; req->int2 = mode; req->offs = offset; req->size = len; SEND; 2050 REQ (EIO_FALLOCATE); req->int1 = fd; req->int2 = mode; req->offs = offset; req->size = len; SEND;
2188} 2051}
2189 2052
2190eio_req *eio_fdatasync (int fd, int pri, eio_cb cb, void *data)
2191{
2192 REQ (EIO_FDATASYNC); req->int1 = fd; SEND;
2193}
2194
2195eio_req *eio_close (int fd, int pri, eio_cb cb, void *data) 2053eio_req *eio_close (int fd, int pri, eio_cb cb, void *data)
2196{ 2054{
2197 REQ (EIO_CLOSE); req->int1 = fd; SEND; 2055 REQ (EIO_CLOSE); req->int1 = fd; SEND;
2198} 2056}
2199 2057
2200eio_req *eio_readahead (int fd, off_t offset, size_t length, int pri, eio_cb cb, void *data) 2058eio_req *eio_readahead (int fd, off_t offset, size_t length, int pri, eio_cb cb, void *data)
2201{ 2059{
2202 REQ (EIO_READAHEAD); req->int1 = fd; req->offs = offset; req->size = length; SEND; 2060 REQ (EIO_READAHEAD); req->int1 = fd; req->offs = offset; req->size = length; SEND;
2061}
2062
2063eio_req *eio_seek (int fd, off_t offset, int whence, int pri, eio_cb cb, void *data)
2064{
2065 REQ (EIO_SEEK); req->int1 = fd; req->offs = offset; req->int2 = whence; SEND;
2203} 2066}
2204 2067
2205eio_req *eio_read (int fd, void *buf, size_t length, off_t offset, int pri, eio_cb cb, void *data) 2068eio_req *eio_read (int fd, void *buf, size_t length, off_t offset, int pri, eio_cb cb, void *data)
2206{ 2069{
2207 REQ (EIO_READ); req->int1 = fd; req->offs = offset; req->size = length; req->ptr2 = buf; SEND; 2070 REQ (EIO_READ); req->int1 = fd; req->offs = offset; req->size = length; req->ptr2 = buf; SEND;
… …
2405void 2268void
2406eio_grp_add (eio_req *grp, eio_req *req) 2269eio_grp_add (eio_req *grp, eio_req *req)
2407{ 2270{
2408 assert (("cannot add requests to IO::AIO::GRP after the group finished", grp->int1 != 2)); 2271 assert (("cannot add requests to IO::AIO::GRP after the group finished", grp->int1 != 2));
2409 2272
2410 grp->flags |= EIO_FLAG_GROUPADD; 2273 grp->flags |= ETP_FLAG_GROUPADD;
2411 2274
2412 ++grp->size; 2275 ++grp->size;
2413 req->grp = grp; 2276 req->grp = grp;
2414 2277
2415 req->grp_prev = 0; 2278 req->grp_prev = 0;
… …
2425/* misc garbage */ 2288/* misc garbage */
2426 2289
2427eio_ssize_t 2290eio_ssize_t
2428eio_sendfile_sync (int ofd, int ifd, off_t offset, size_t count) 2291eio_sendfile_sync (int ofd, int ifd, off_t offset, size_t count)
2429{ 2292{
2430 etp_worker wrk;
2431 eio_ssize_t ret;
2432
2433 wrk.dbuf = 0;
2434
2435 ret = eio__sendfile (ofd, ifd, offset, count, &wrk); 2293 return eio__sendfile (ofd, ifd, offset, count);
2436
2437 if (wrk.dbuf)
2438 free (wrk.dbuf);
2439
2440 return ret;
2441} 2294}
2442 2295

Diff Legend

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