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

Comparing cvsroot/libeio/eio.c (file contents):
Revision 1.14 by root, Sat May 17 12:17:25 2008 UTC vs.
Revision 1.25 by root, Tue Sep 30 17:23:24 2008 UTC

… …
120 120
121#define EIO_TICKS ((1000000 + 1023) >> 10) 121#define EIO_TICKS ((1000000 + 1023) >> 10)
122 122
123/*****************************************************************************/ 123/*****************************************************************************/
124 124
125#if __GNUC__ >= 3
126# define expect(expr,value) __builtin_expect ((expr),(value))
127#else
128# define expect(expr,value) (expr)
129#endif
130
131#define expect_false(expr) expect ((expr) != 0, 0)
132#define expect_true(expr) expect ((expr) != 0, 1)
133
134/*****************************************************************************/
135
125#define ETP_PRI_MIN EIO_PRI_MIN 136#define ETP_PRI_MIN EIO_PRI_MIN
126#define ETP_PRI_MAX EIO_PRI_MAX 137#define ETP_PRI_MAX EIO_PRI_MAX
138
139struct etp_worker;
127 140
128#define ETP_REQ eio_req 141#define ETP_REQ eio_req
129#define ETP_DESTROY(req) eio_destroy (req) 142#define ETP_DESTROY(req) eio_destroy (req)
130static int eio_finish (eio_req *req); 143static int eio_finish (eio_req *req);
131#define ETP_FINISH(req) eio_finish (req) 144#define ETP_FINISH(req) eio_finish (req)
145static void eio_execute (struct etp_worker *self, eio_req *req);
146#define ETP_EXECUTE(wrk,req) eio_execute (wrk,req)
132 147
133#define ETP_WORKER_CLEAR(req) \ 148#define ETP_WORKER_CLEAR(req) \
134 if (wrk->dbuf) \ 149 if (wrk->dbuf) \
135 { \ 150 { \
136 free (wrk->dbuf); \ 151 free (wrk->dbuf); \
… …
173static mutex_t wrklock = X_MUTEX_INIT; 188static mutex_t wrklock = X_MUTEX_INIT;
174static mutex_t reslock = X_MUTEX_INIT; 189static mutex_t reslock = X_MUTEX_INIT;
175static mutex_t reqlock = X_MUTEX_INIT; 190static mutex_t reqlock = X_MUTEX_INIT;
176static cond_t reqwait = X_COND_INIT; 191static cond_t reqwait = X_COND_INIT;
177 192
193#if !HAVE_PREADWRITE
194/*
195 * make our pread/pwrite emulation safe against themselves, but not against
196 * normal read/write by using a mutex. slows down execution a lot,
197 * but that's your problem, not mine.
198 */
199static mutex_t preadwritelock = X_MUTEX_INIT;
200#endif
201
178typedef struct etp_worker 202typedef struct etp_worker
179{ 203{
180 /* locked by wrklock */ 204 /* locked by wrklock */
181 struct etp_worker *prev, *next; 205 struct etp_worker *prev, *next;
182 206
… …
310 X_LOCK (reqlock); 334 X_LOCK (reqlock);
311 X_LOCK (reslock); 335 X_LOCK (reslock);
312#if !HAVE_PREADWRITE 336#if !HAVE_PREADWRITE
313 X_LOCK (preadwritelock); 337 X_LOCK (preadwritelock);
314#endif 338#endif
315#if !HAVE_READDIR_R
316 X_LOCK (readdirlock);
317#endif
318} 339}
319 340
320static void etp_atfork_parent (void) 341static void etp_atfork_parent (void)
321{ 342{
322#if !HAVE_READDIR_R
323 X_UNLOCK (readdirlock);
324#endif
325#if !HAVE_PREADWRITE 343#if !HAVE_PREADWRITE
326 X_UNLOCK (preadwritelock); 344 X_UNLOCK (preadwritelock);
327#endif 345#endif
328 X_UNLOCK (reslock); 346 X_UNLOCK (reslock);
329 X_UNLOCK (reqlock); 347 X_UNLOCK (reqlock);
… …
332 350
333static void etp_atfork_child (void) 351static void etp_atfork_child (void)
334{ 352{
335 ETP_REQ *prv; 353 ETP_REQ *prv;
336 354
337 while (prv = reqq_shift (&req_queue)) 355 while ((prv = reqq_shift (&req_queue)))
338 ETP_DESTROY (prv); 356 ETP_DESTROY (prv);
339 357
340 while (prv = reqq_shift (&res_queue)) 358 while ((prv = reqq_shift (&res_queue)))
341 ETP_DESTROY (prv); 359 ETP_DESTROY (prv);
342 360
343 while (wrk_first.next != &wrk_first) 361 while (wrk_first.next != &wrk_first)
344 { 362 {
345 etp_worker *wrk = wrk_first.next; 363 etp_worker *wrk = wrk_first.next;
… …
373 391
374 pthread_once (&doinit, etp_once_init); 392 pthread_once (&doinit, etp_once_init);
375 393
376 want_poll_cb = want_poll; 394 want_poll_cb = want_poll;
377 done_poll_cb = done_poll; 395 done_poll_cb = done_poll;
396
397 return 0;
378} 398}
379 399
380X_THREAD_PROC (etp_proc); 400X_THREAD_PROC (etp_proc);
381 401
382static void etp_start_thread (void) 402static void etp_start_thread (void)
… …
402 X_UNLOCK (wrklock); 422 X_UNLOCK (wrklock);
403} 423}
404 424
405static void etp_maybe_start_thread (void) 425static void etp_maybe_start_thread (void)
406{ 426{
407 if (etp_nthreads () >= wanted) 427 if (expect_true (etp_nthreads () >= wanted))
408 return; 428 return;
409 429
410 /* todo: maybe use idle here, but might be less exact */ 430 /* todo: maybe use idle here, but might be less exact */
411 if (0 <= (int)etp_nthreads () + (int)etp_npending () - (int)etp_nreqs ()) 431 if (expect_true (0 <= (int)etp_nthreads () + (int)etp_npending () - (int)etp_nreqs ()))
412 return; 432 return;
413 433
414 etp_start_thread (); 434 etp_start_thread ();
415} 435}
416 436
… …
469 489
470 X_LOCK (reqlock); 490 X_LOCK (reqlock);
471 --nreqs; 491 --nreqs;
472 X_UNLOCK (reqlock); 492 X_UNLOCK (reqlock);
473 493
474 if (req->type == EIO_GROUP && req->size) 494 if (expect_false (req->type == EIO_GROUP && req->size))
475 { 495 {
476 req->int1 = 1; /* mark request as delayed */ 496 req->int1 = 1; /* mark request as delayed */
477 continue; 497 continue;
478 } 498 }
479 else 499 else
480 { 500 {
481 int res = ETP_FINISH (req); 501 int res = ETP_FINISH (req);
482 if (res) 502 if (expect_false (res))
483 return res; 503 return res;
484 } 504 }
485 505
486 if (maxreqs && !--maxreqs) 506 if (expect_false (maxreqs && !--maxreqs))
487 break; 507 break;
488 508
489 if (maxtime) 509 if (maxtime)
490 { 510 {
491 gettimeofday (&tv_now, 0); 511 gettimeofday (&tv_now, 0);
… …
510 530
511static void etp_submit (ETP_REQ *req) 531static void etp_submit (ETP_REQ *req)
512{ 532{
513 req->pri -= ETP_PRI_MIN; 533 req->pri -= ETP_PRI_MIN;
514 534
515 if (req->pri < ETP_PRI_MIN - ETP_PRI_MIN) req->pri = ETP_PRI_MIN - ETP_PRI_MIN; 535 if (expect_false (req->pri < ETP_PRI_MIN - ETP_PRI_MIN)) req->pri = ETP_PRI_MIN - ETP_PRI_MIN;
516 if (req->pri > ETP_PRI_MAX - ETP_PRI_MIN) req->pri = ETP_PRI_MAX - ETP_PRI_MIN; 536 if (expect_false (req->pri > ETP_PRI_MAX - ETP_PRI_MIN)) req->pri = ETP_PRI_MAX - ETP_PRI_MIN;
517 537
538 if (expect_false (req->type == EIO_GROUP))
539 {
540 /* I hope this is worth it :/ */
518 X_LOCK (reqlock); 541 X_LOCK (reqlock);
519 ++nreqs; 542 ++nreqs;
543 X_UNLOCK (reqlock);
544
545 X_LOCK (reslock);
546
547 ++npending;
548
549 if (!reqq_push (&res_queue, req) && want_poll_cb)
550 want_poll_cb ();
551
552 X_UNLOCK (reslock);
553 }
554 else
555 {
556 X_LOCK (reqlock);
557 ++nreqs;
520 ++nready; 558 ++nready;
521 reqq_push (&req_queue, req); 559 reqq_push (&req_queue, req);
522 X_COND_SIGNAL (reqwait); 560 X_COND_SIGNAL (reqwait);
523 X_UNLOCK (reqlock); 561 X_UNLOCK (reqlock);
524 562
525 etp_maybe_start_thread (); 563 etp_maybe_start_thread ();
564 }
526} 565}
527 566
528static void etp_set_max_poll_time (double nseconds) 567static void etp_set_max_poll_time (double nseconds)
529{ 568{
530 if (WORDACCESS_UNSAFE) X_LOCK (reslock); 569 if (WORDACCESS_UNSAFE) X_LOCK (reslock);
… …
700 739
701#if !HAVE_PREADWRITE 740#if !HAVE_PREADWRITE
702# define pread eio__pread 741# define pread eio__pread
703# define pwrite eio__pwrite 742# define pwrite eio__pwrite
704 743
705/*
706 * make our pread/pwrite safe against themselves, but not against
707 * normal read/write by using a mutex. slows down execution a lot,
708 * but that's your problem, not mine.
709 */
710static mutex_t preadwritelock = X_MUTEX_INIT;
711
712static ssize_t 744static ssize_t
713eio__pread (int fd, void *buf, size_t count, off_t offset) 745eio__pread (int fd, void *buf, size_t count, off_t offset)
714{ 746{
715 ssize_t res; 747 ssize_t res;
716 off_t ooffset; 748 off_t ooffset;
… …
777 809
778#if !HAVE_READAHEAD 810#if !HAVE_READAHEAD
779# define readahead(fd,offset,count) eio__readahead (fd, offset, count, self) 811# define readahead(fd,offset,count) eio__readahead (fd, offset, count, self)
780 812
781static ssize_t 813static ssize_t
782eio__readahead (int fd, off_t offset, size_t count, worker *self) 814eio__readahead (int fd, off_t offset, size_t count, etp_worker *self)
783{ 815{
784 size_t todo = count; 816 size_t todo = count;
785 dBUF; 817 dBUF;
786 818
787 while (todo > 0) 819 while (todo > 0)
… …
795 827
796 errno = 0; 828 errno = 0;
797 return count; 829 return count;
798} 830}
799 831
800#endif
801
802#if !HAVE_READDIR_R
803# define readdir_r eio__readdir_r
804
805static mutex_t readdirlock = X_MUTEX_INIT;
806
807static int
808eio__readdir_r (DIR *dirp, EIO_STRUCT_DIRENT *ent, EIO_STRUCT_DIRENT **res)
809{
810 EIO_STRUCT_DIRENT *e;
811 int errorno;
812
813 X_LOCK (readdirlock);
814
815 e = readdir (dirp);
816 errorno = errno;
817
818 if (e)
819 {
820 *res = ent;
821 strcpy (ent->d_name, e->d_name);
822 }
823 else
824 *res = 0;
825
826 X_UNLOCK (readdirlock);
827
828 errno = errorno;
829 return e ? 0 : -1;
830}
831#endif 832#endif
832 833
833/* sendfile always needs emulation */ 834/* sendfile always needs emulation */
834static ssize_t 835static ssize_t
835eio__sendfile (int ofd, int ifd, off_t offset, size_t count, etp_worker *self) 836eio__sendfile (int ofd, int ifd, off_t offset, size_t count, etp_worker *self)
… …
927/* read a full directory */ 928/* read a full directory */
928static void 929static void
929eio__scandir (eio_req *req, etp_worker *self) 930eio__scandir (eio_req *req, etp_worker *self)
930{ 931{
931 DIR *dirp; 932 DIR *dirp;
932 union
933 {
934 EIO_STRUCT_DIRENT d;
935 char b [offsetof (EIO_STRUCT_DIRENT, d_name) + NAME_MAX + 1];
936 } *u;
937 EIO_STRUCT_DIRENT *entp; 933 EIO_STRUCT_DIRENT *entp;
938 char *name, *names; 934 char *name, *names;
939 int memlen = 4096; 935 int memlen = 4096;
940 int memofs = 0; 936 int memofs = 0;
941 int res = 0; 937 int res = 0;
942 938
943 X_LOCK (wrklock); 939 X_LOCK (wrklock);
940 /* the corresponding closedir is in ETP_WORKER_CLEAR */
944 self->dirp = dirp = opendir (req->ptr1); 941 self->dirp = dirp = opendir (req->ptr1);
945 self->dbuf = u = malloc (sizeof (*u));
946 req->flags |= EIO_FLAG_PTR2_FREE; 942 req->flags |= EIO_FLAG_PTR2_FREE;
947 req->ptr2 = names = malloc (memlen); 943 req->ptr2 = names = malloc (memlen);
948 X_UNLOCK (wrklock); 944 X_UNLOCK (wrklock);
949 945
950 if (dirp && u && names) 946 if (dirp && names)
951 for (;;) 947 for (;;)
952 { 948 {
953 errno = 0; 949 errno = 0;
954 readdir_r (dirp, &u->d, &entp); 950 entp = readdir (dirp);
955 951
956 if (!entp) 952 if (!entp)
957 break; 953 break;
958 954
959 name = entp->d_name; 955 name = entp->d_name;
… …
982 978
983 if (errno) 979 if (errno)
984 res = -1; 980 res = -1;
985 981
986 req->result = res; 982 req->result = res;
983}
984
985#if !(_POSIX_MAPPED_FILES && _POSIX_SYNCHRONIZED_IO)
986# define msync(a,b,c) ENOSYS
987#endif
988
989int
990eio__mtouch (void *mem, size_t len, int flags)
991{
992 intptr_t addr = (intptr_t)mem;
993 intptr_t end = addr + len;
994#ifdef PAGESIZE
995 const intptr_t page = PAGESIZE;
996#else
997 static intptr_t page;
998
999 if (!page)
1000 page = sysconf (_SC_PAGESIZE);
1001#endif
1002
1003 addr &= ~(page - 1); /* assume page size is always a power of two */
1004
1005 if (addr < end)
1006 if (flags) /* modify */
1007 do { *((volatile sig_atomic_t *)addr) |= 0; } while ((addr += page) < len);
1008 else
1009 do { *((volatile sig_atomic_t *)addr) ; } while ((addr += page) < len);
1010
1011 return 0;
987} 1012}
988 1013
989/*****************************************************************************/ 1014/*****************************************************************************/
990 1015
991#define ALLOC(len) \ 1016#define ALLOC(len) \
… …
1047 1072
1048 --nready; 1073 --nready;
1049 1074
1050 X_UNLOCK (reqlock); 1075 X_UNLOCK (reqlock);
1051 1076
1052 errno = 0; /* strictly unnecessary */ 1077 if (req->type < 0)
1078 goto quit;
1053 1079
1054 if (!EIO_CANCELLED (req)) 1080 if (!EIO_CANCELLED (req))
1055 switch (req->type) 1081 ETP_EXECUTE (self, req);
1056 {
1057 case EIO_READ: ALLOC (req->size);
1058 req->result = req->offs >= 0
1059 ? pread (req->int1, req->ptr2, req->size, req->offs)
1060 : read (req->int1, req->ptr2, req->size); break;
1061 case EIO_WRITE: req->result = req->offs >= 0
1062 ? pwrite (req->int1, req->ptr2, req->size, req->offs)
1063 : write (req->int1, req->ptr2, req->size); break;
1064
1065 case EIO_READAHEAD: req->result = readahead (req->int1, req->offs, req->size); break;
1066 case EIO_SENDFILE: req->result = eio__sendfile (req->int1, req->int2, req->offs, req->size, self); break;
1067
1068 case EIO_STAT: ALLOC (sizeof (EIO_STRUCT_STAT));
1069 req->result = stat (req->ptr1, (EIO_STRUCT_STAT *)req->ptr2); break;
1070 case EIO_LSTAT: ALLOC (sizeof (EIO_STRUCT_STAT));
1071 req->result = lstat (req->ptr1, (EIO_STRUCT_STAT *)req->ptr2); break;
1072 case EIO_FSTAT: ALLOC (sizeof (EIO_STRUCT_STAT));
1073 req->result = fstat (req->int1, (EIO_STRUCT_STAT *)req->ptr2); break;
1074
1075 case EIO_CHOWN: req->result = chown (req->ptr1, req->int2, req->int3); break;
1076 case EIO_FCHOWN: req->result = fchown (req->int1, req->int2, req->int3); break;
1077 case EIO_CHMOD: req->result = chmod (req->ptr1, (mode_t)req->int2); break;
1078 case EIO_FCHMOD: req->result = fchmod (req->int1, (mode_t)req->int2); break;
1079 case EIO_TRUNCATE: req->result = truncate (req->ptr1, req->offs); break;
1080 case EIO_FTRUNCATE: req->result = ftruncate (req->int1, req->offs); break;
1081
1082 case EIO_OPEN: req->result = open (req->ptr1, req->int1, (mode_t)req->int2); break;
1083 case EIO_CLOSE: req->result = close (req->int1); break;
1084 case EIO_DUP2: req->result = dup2 (req->int1, req->int2); break;
1085 case EIO_UNLINK: req->result = unlink (req->ptr1); break;
1086 case EIO_RMDIR: req->result = rmdir (req->ptr1); break;
1087 case EIO_MKDIR: req->result = mkdir (req->ptr1, (mode_t)req->int2); break;
1088 case EIO_RENAME: req->result = rename (req->ptr1, req->ptr2); break;
1089 case EIO_LINK: req->result = link (req->ptr1, req->ptr2); break;
1090 case EIO_SYMLINK: req->result = symlink (req->ptr1, req->ptr2); break;
1091 case EIO_MKNOD: req->result = mknod (req->ptr1, (mode_t)req->int2, (dev_t)req->offs); break;
1092
1093 case EIO_READLINK: ALLOC (NAME_MAX);
1094 req->result = readlink (req->ptr1, req->ptr2, NAME_MAX); break;
1095
1096 case EIO_SYNC: req->result = 0; sync (); break;
1097 case EIO_FSYNC: req->result = fsync (req->int1); break;
1098 case EIO_FDATASYNC: req->result = fdatasync (req->int1); break;
1099
1100 case EIO_READDIR: eio__scandir (req, self); break;
1101
1102 case EIO_BUSY:
1103#ifdef _WIN32
1104 Sleep (req->nv1 * 1000.);
1105#else
1106 {
1107 struct timeval tv;
1108
1109 tv.tv_sec = req->nv1;
1110 tv.tv_usec = (req->nv1 - tv.tv_sec) * 1000000.;
1111
1112 req->result = select (0, 0, 0, 0, &tv);
1113 }
1114#endif
1115 break;
1116
1117 case EIO_UTIME:
1118 case EIO_FUTIME:
1119 {
1120 struct timeval tv[2];
1121 struct timeval *times;
1122
1123 if (req->nv1 != -1. || req->nv2 != -1.)
1124 {
1125 tv[0].tv_sec = req->nv1;
1126 tv[0].tv_usec = (req->nv1 - tv[0].tv_sec) * 1000000.;
1127 tv[1].tv_sec = req->nv2;
1128 tv[1].tv_usec = (req->nv2 - tv[1].tv_sec) * 1000000.;
1129
1130 times = tv;
1131 }
1132 else
1133 times = 0;
1134
1135
1136 req->result = req->type == EIO_FUTIME
1137 ? futimes (req->int1, times)
1138 : utimes (req->ptr1, times);
1139 }
1140
1141 case EIO_GROUP:
1142 case EIO_NOP:
1143 req->result = 0;
1144 break;
1145
1146 case -1:
1147 goto quit;
1148
1149 default:
1150 req->result = -1;
1151 break;
1152 }
1153
1154 req->errorno = errno;
1155 1082
1156 X_LOCK (reslock); 1083 X_LOCK (reslock);
1157 1084
1158 ++npending; 1085 ++npending;
1159 1086
… …
1176 1103
1177/*****************************************************************************/ 1104/*****************************************************************************/
1178 1105
1179int eio_init (void (*want_poll)(void), void (*done_poll)(void)) 1106int eio_init (void (*want_poll)(void), void (*done_poll)(void))
1180{ 1107{
1181 etp_init (want_poll, done_poll); 1108 return etp_init (want_poll, done_poll);
1182} 1109}
1183 1110
1184static void eio_api_destroy (eio_req *req) 1111static void eio_api_destroy (eio_req *req)
1185{ 1112{
1186 free (req); 1113 free (req);
… …
1208 { \ 1135 { \
1209 eio_api_destroy (req); \ 1136 eio_api_destroy (req); \
1210 return 0; \ 1137 return 0; \
1211 } 1138 }
1212 1139
1140static void eio_execute (etp_worker *self, eio_req *req)
1141{
1142 errno = 0;
1143
1144 switch (req->type)
1145 {
1146 case EIO_READ: ALLOC (req->size);
1147 req->result = req->offs >= 0
1148 ? pread (req->int1, req->ptr2, req->size, req->offs)
1149 : read (req->int1, req->ptr2, req->size); break;
1150 case EIO_WRITE: req->result = req->offs >= 0
1151 ? pwrite (req->int1, req->ptr2, req->size, req->offs)
1152 : write (req->int1, req->ptr2, req->size); break;
1153
1154 case EIO_READAHEAD: req->result = readahead (req->int1, req->offs, req->size); break;
1155 case EIO_SENDFILE: req->result = eio__sendfile (req->int1, req->int2, req->offs, req->size, self); break;
1156
1157 case EIO_STAT: ALLOC (sizeof (EIO_STRUCT_STAT));
1158 req->result = stat (req->ptr1, (EIO_STRUCT_STAT *)req->ptr2); break;
1159 case EIO_LSTAT: ALLOC (sizeof (EIO_STRUCT_STAT));
1160 req->result = lstat (req->ptr1, (EIO_STRUCT_STAT *)req->ptr2); break;
1161 case EIO_FSTAT: ALLOC (sizeof (EIO_STRUCT_STAT));
1162 req->result = fstat (req->int1, (EIO_STRUCT_STAT *)req->ptr2); break;
1163
1164 case EIO_CHOWN: req->result = chown (req->ptr1, req->int2, req->int3); break;
1165 case EIO_FCHOWN: req->result = fchown (req->int1, req->int2, req->int3); break;
1166 case EIO_CHMOD: req->result = chmod (req->ptr1, (mode_t)req->int2); break;
1167 case EIO_FCHMOD: req->result = fchmod (req->int1, (mode_t)req->int2); break;
1168 case EIO_TRUNCATE: req->result = truncate (req->ptr1, req->offs); break;
1169 case EIO_FTRUNCATE: req->result = ftruncate (req->int1, req->offs); break;
1170
1171 case EIO_OPEN: req->result = open (req->ptr1, req->int1, (mode_t)req->int2); break;
1172 case EIO_CLOSE: req->result = close (req->int1); break;
1173 case EIO_DUP2: req->result = dup2 (req->int1, req->int2); break;
1174 case EIO_UNLINK: req->result = unlink (req->ptr1); break;
1175 case EIO_RMDIR: req->result = rmdir (req->ptr1); break;
1176 case EIO_MKDIR: req->result = mkdir (req->ptr1, (mode_t)req->int2); break;
1177 case EIO_RENAME: req->result = rename (req->ptr1, req->ptr2); break;
1178 case EIO_LINK: req->result = link (req->ptr1, req->ptr2); break;
1179 case EIO_SYMLINK: req->result = symlink (req->ptr1, req->ptr2); break;
1180 case EIO_MKNOD: req->result = mknod (req->ptr1, (mode_t)req->int2, (dev_t)req->int3); break;
1181
1182 case EIO_READLINK: ALLOC (NAME_MAX);
1183 req->result = readlink (req->ptr1, req->ptr2, NAME_MAX); break;
1184
1185 case EIO_SYNC: req->result = 0; sync (); break;
1186 case EIO_FSYNC: req->result = fsync (req->int1); break;
1187 case EIO_FDATASYNC: req->result = fdatasync (req->int1); break;
1188 case EIO_MSYNC: req->result = msync (req->ptr2, req->size, req->int1); break;
1189 case EIO_MTOUCH: req->result = eio__mtouch (req->ptr2, req->size, req->int1); break;
1190
1191 case EIO_READDIR: eio__scandir (req, self); break;
1192
1193 case EIO_BUSY:
1194#ifdef _WIN32
1195 Sleep (req->nv1 * 1000.);
1196#else
1197 {
1198 struct timeval tv;
1199
1200 tv.tv_sec = req->nv1;
1201 tv.tv_usec = (req->nv1 - tv.tv_sec) * 1000000.;
1202
1203 req->result = select (0, 0, 0, 0, &tv);
1204 }
1205#endif
1206 break;
1207
1208 case EIO_UTIME:
1209 case EIO_FUTIME:
1210 {
1211 struct timeval tv[2];
1212 struct timeval *times;
1213
1214 if (req->nv1 != -1. || req->nv2 != -1.)
1215 {
1216 tv[0].tv_sec = req->nv1;
1217 tv[0].tv_usec = (req->nv1 - tv[0].tv_sec) * 1000000.;
1218 tv[1].tv_sec = req->nv2;
1219 tv[1].tv_usec = (req->nv2 - tv[1].tv_sec) * 1000000.;
1220
1221 times = tv;
1222 }
1223 else
1224 times = 0;
1225
1226
1227 req->result = req->type == EIO_FUTIME
1228 ? futimes (req->int1, times)
1229 : utimes (req->ptr1, times);
1230 }
1231 break;
1232
1233 case EIO_GROUP:
1234 abort (); /* handled in eio_request */
1235
1236 case EIO_NOP:
1237 req->result = 0;
1238 break;
1239
1240 case EIO_CUSTOM:
1241 ((void (*)(eio_req *))req->feed) (req);
1242 break;
1243
1244 default:
1245 req->result = -1;
1246 break;
1247 }
1248
1249 req->errorno = errno;
1250}
1251
1213#ifndef EIO_NO_WRAPPERS 1252#ifndef EIO_NO_WRAPPERS
1214 1253
1215eio_req *eio_nop (int pri, eio_cb cb, void *data) 1254eio_req *eio_nop (int pri, eio_cb cb, void *data)
1216{ 1255{
1217 REQ (EIO_NOP); SEND; 1256 REQ (EIO_NOP); SEND;
… …
1228} 1267}
1229 1268
1230eio_req *eio_fsync (int fd, int pri, eio_cb cb, void *data) 1269eio_req *eio_fsync (int fd, int pri, eio_cb cb, void *data)
1231{ 1270{
1232 REQ (EIO_FSYNC); req->int1 = fd; SEND; 1271 REQ (EIO_FSYNC); req->int1 = fd; SEND;
1272}
1273
1274eio_req *eio_msync (void *addr, size_t length, int flags, int pri, eio_cb cb, void *data)
1275{
1276 REQ (EIO_MSYNC); req->ptr2 = addr; req->size = length; req->int1 = flags; SEND;
1277}
1278
1279eio_req *eio_mtouch (void *addr, size_t length, int flags, int pri, eio_cb cb, void *data)
1280{
1281 REQ (EIO_MTOUCH); req->ptr2 = addr; req->size = length; req->int1 = flags; SEND;
1233} 1282}
1234 1283
1235eio_req *eio_fdatasync (int fd, int pri, eio_cb cb, void *data) 1284eio_req *eio_fdatasync (int fd, int pri, eio_cb cb, void *data)
1236{ 1285{
1237 REQ (EIO_FDATASYNC); req->int1 = fd; SEND; 1286 REQ (EIO_FDATASYNC); req->int1 = fd; SEND;
… …
1358 return eio__1path (EIO_READDIR, path, pri, cb, data); 1407 return eio__1path (EIO_READDIR, path, pri, cb, data);
1359} 1408}
1360 1409
1361eio_req *eio_mknod (const char *path, mode_t mode, dev_t dev, int pri, eio_cb cb, void *data) 1410eio_req *eio_mknod (const char *path, mode_t mode, dev_t dev, int pri, eio_cb cb, void *data)
1362{ 1411{
1363 REQ (EIO_MKNOD); PATH; req->int2 = (long)mode; req->int2 = (long)dev; SEND; 1412 REQ (EIO_MKNOD); PATH; req->int2 = (long)mode; req->int3 = (long)dev; SEND;
1364} 1413}
1365 1414
1366static eio_req * 1415static eio_req *
1367eio__2path (int type, const char *path, const char *new_path, int pri, eio_cb cb, void *data) 1416eio__2path (int type, const char *path, const char *new_path, int pri, eio_cb cb, void *data)
1368{ 1417{
… …
1392eio_req *eio_rename (const char *path, const char *new_path, int pri, eio_cb cb, void *data) 1441eio_req *eio_rename (const char *path, const char *new_path, int pri, eio_cb cb, void *data)
1393{ 1442{
1394 return eio__2path (EIO_RENAME, path, new_path, pri, cb, data); 1443 return eio__2path (EIO_RENAME, path, new_path, pri, cb, data);
1395} 1444}
1396 1445
1446eio_req *eio_custom (eio_cb execute, int pri, eio_cb cb, void *data)
1447{
1448 REQ (EIO_CUSTOM); req->feed = (void (*)(eio_req *))execute; SEND;
1449}
1450
1397#endif 1451#endif
1398 1452
1399eio_req *eio_grp (eio_cb cb, void *data) 1453eio_req *eio_grp (eio_cb cb, void *data)
1400{ 1454{
1401 const int pri = EIO_PRI_MAX; 1455 const int pri = EIO_PRI_MAX;

Diff Legend

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