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

Comparing libeio/eio.c (file contents):
Revision 1.15 by root, Sat May 17 12:26:57 2008 UTC vs.
Revision 1.30 by root, Wed Jun 3 12:24:49 2009 UTC

… …
36 * provisions above, a recipient may use your version of this file under 36 * provisions above, a recipient may use your version of this file under
37 * either the BSD or the GPL. 37 * either the BSD or the GPL.
38 */ 38 */
39 39
40#include "eio.h" 40#include "eio.h"
41
42#ifdef EIO_STACKSIZE
43# define XTHREAD_STACKSIZE EIO_STACKSIZE
44#endif
41#include "xthread.h" 45#include "xthread.h"
42 46
43#include <errno.h> 47#include <errno.h>
44#include <stddef.h> 48#include <stddef.h>
45#include <stdlib.h> 49#include <stdlib.h>
… …
120 124
121#define EIO_TICKS ((1000000 + 1023) >> 10) 125#define EIO_TICKS ((1000000 + 1023) >> 10)
122 126
123/*****************************************************************************/ 127/*****************************************************************************/
124 128
129#if __GNUC__ >= 3
130# define expect(expr,value) __builtin_expect ((expr),(value))
131#else
132# define expect(expr,value) (expr)
133#endif
134
135#define expect_false(expr) expect ((expr) != 0, 0)
136#define expect_true(expr) expect ((expr) != 0, 1)
137
138/*****************************************************************************/
139
125#define ETP_PRI_MIN EIO_PRI_MIN 140#define ETP_PRI_MIN EIO_PRI_MIN
126#define ETP_PRI_MAX EIO_PRI_MAX 141#define ETP_PRI_MAX EIO_PRI_MAX
127 142
128struct etp_worker; 143struct etp_worker;
129 144
… …
177static mutex_t wrklock = X_MUTEX_INIT; 192static mutex_t wrklock = X_MUTEX_INIT;
178static mutex_t reslock = X_MUTEX_INIT; 193static mutex_t reslock = X_MUTEX_INIT;
179static mutex_t reqlock = X_MUTEX_INIT; 194static mutex_t reqlock = X_MUTEX_INIT;
180static cond_t reqwait = X_COND_INIT; 195static cond_t reqwait = X_COND_INIT;
181 196
197#if !HAVE_PREADWRITE
198/*
199 * make our pread/pwrite emulation safe against themselves, but not against
200 * normal read/write by using a mutex. slows down execution a lot,
201 * but that's your problem, not mine.
202 */
203static mutex_t preadwritelock = X_MUTEX_INIT;
204#endif
205
182typedef struct etp_worker 206typedef struct etp_worker
183{ 207{
184 /* locked by wrklock */ 208 /* locked by wrklock */
185 struct etp_worker *prev, *next; 209 struct etp_worker *prev, *next;
186 210
… …
314 X_LOCK (reqlock); 338 X_LOCK (reqlock);
315 X_LOCK (reslock); 339 X_LOCK (reslock);
316#if !HAVE_PREADWRITE 340#if !HAVE_PREADWRITE
317 X_LOCK (preadwritelock); 341 X_LOCK (preadwritelock);
318#endif 342#endif
319#if !HAVE_READDIR_R
320 X_LOCK (readdirlock);
321#endif
322} 343}
323 344
324static void etp_atfork_parent (void) 345static void etp_atfork_parent (void)
325{ 346{
326#if !HAVE_READDIR_R
327 X_UNLOCK (readdirlock);
328#endif
329#if !HAVE_PREADWRITE 347#if !HAVE_PREADWRITE
330 X_UNLOCK (preadwritelock); 348 X_UNLOCK (preadwritelock);
331#endif 349#endif
332 X_UNLOCK (reslock); 350 X_UNLOCK (reslock);
333 X_UNLOCK (reqlock); 351 X_UNLOCK (reqlock);
… …
336 354
337static void etp_atfork_child (void) 355static void etp_atfork_child (void)
338{ 356{
339 ETP_REQ *prv; 357 ETP_REQ *prv;
340 358
341 while (prv = reqq_shift (&req_queue)) 359 while ((prv = reqq_shift (&req_queue)))
342 ETP_DESTROY (prv); 360 ETP_DESTROY (prv);
343 361
344 while (prv = reqq_shift (&res_queue)) 362 while ((prv = reqq_shift (&res_queue)))
345 ETP_DESTROY (prv); 363 ETP_DESTROY (prv);
346 364
347 while (wrk_first.next != &wrk_first) 365 while (wrk_first.next != &wrk_first)
348 { 366 {
349 etp_worker *wrk = wrk_first.next; 367 etp_worker *wrk = wrk_first.next;
… …
377 395
378 pthread_once (&doinit, etp_once_init); 396 pthread_once (&doinit, etp_once_init);
379 397
380 want_poll_cb = want_poll; 398 want_poll_cb = want_poll;
381 done_poll_cb = done_poll; 399 done_poll_cb = done_poll;
400
401 return 0;
382} 402}
383 403
384X_THREAD_PROC (etp_proc); 404X_THREAD_PROC (etp_proc);
385 405
386static void etp_start_thread (void) 406static void etp_start_thread (void)
… …
406 X_UNLOCK (wrklock); 426 X_UNLOCK (wrklock);
407} 427}
408 428
409static void etp_maybe_start_thread (void) 429static void etp_maybe_start_thread (void)
410{ 430{
411 if (etp_nthreads () >= wanted) 431 if (expect_true (etp_nthreads () >= wanted))
412 return; 432 return;
413 433
414 /* todo: maybe use idle here, but might be less exact */ 434 /* todo: maybe use idle here, but might be less exact */
415 if (0 <= (int)etp_nthreads () + (int)etp_npending () - (int)etp_nreqs ()) 435 if (expect_true (0 <= (int)etp_nthreads () + (int)etp_npending () - (int)etp_nreqs ()))
416 return; 436 return;
417 437
418 etp_start_thread (); 438 etp_start_thread ();
419} 439}
420 440
… …
473 493
474 X_LOCK (reqlock); 494 X_LOCK (reqlock);
475 --nreqs; 495 --nreqs;
476 X_UNLOCK (reqlock); 496 X_UNLOCK (reqlock);
477 497
478 if (req->type == EIO_GROUP && req->size) 498 if (expect_false (req->type == EIO_GROUP && req->size))
479 { 499 {
480 req->int1 = 1; /* mark request as delayed */ 500 req->int1 = 1; /* mark request as delayed */
481 continue; 501 continue;
482 } 502 }
483 else 503 else
484 { 504 {
485 int res = ETP_FINISH (req); 505 int res = ETP_FINISH (req);
486 if (res) 506 if (expect_false (res))
487 return res; 507 return res;
488 } 508 }
489 509
490 if (maxreqs && !--maxreqs) 510 if (expect_false (maxreqs && !--maxreqs))
491 break; 511 break;
492 512
493 if (maxtime) 513 if (maxtime)
494 { 514 {
495 gettimeofday (&tv_now, 0); 515 gettimeofday (&tv_now, 0);
… …
514 534
515static void etp_submit (ETP_REQ *req) 535static void etp_submit (ETP_REQ *req)
516{ 536{
517 req->pri -= ETP_PRI_MIN; 537 req->pri -= ETP_PRI_MIN;
518 538
519 if (req->pri < ETP_PRI_MIN - ETP_PRI_MIN) req->pri = ETP_PRI_MIN - ETP_PRI_MIN; 539 if (expect_false (req->pri < ETP_PRI_MIN - ETP_PRI_MIN)) req->pri = ETP_PRI_MIN - ETP_PRI_MIN;
520 if (req->pri > ETP_PRI_MAX - ETP_PRI_MIN) req->pri = ETP_PRI_MAX - ETP_PRI_MIN; 540 if (expect_false (req->pri > ETP_PRI_MAX - ETP_PRI_MIN)) req->pri = ETP_PRI_MAX - ETP_PRI_MIN;
521 541
542 if (expect_false (req->type == EIO_GROUP))
543 {
544 /* I hope this is worth it :/ */
522 X_LOCK (reqlock); 545 X_LOCK (reqlock);
523 ++nreqs; 546 ++nreqs;
547 X_UNLOCK (reqlock);
548
549 X_LOCK (reslock);
550
551 ++npending;
552
553 if (!reqq_push (&res_queue, req) && want_poll_cb)
554 want_poll_cb ();
555
556 X_UNLOCK (reslock);
557 }
558 else
559 {
560 X_LOCK (reqlock);
561 ++nreqs;
524 ++nready; 562 ++nready;
525 reqq_push (&req_queue, req); 563 reqq_push (&req_queue, req);
526 X_COND_SIGNAL (reqwait); 564 X_COND_SIGNAL (reqwait);
527 X_UNLOCK (reqlock); 565 X_UNLOCK (reqlock);
528 566
529 etp_maybe_start_thread (); 567 etp_maybe_start_thread ();
568 }
530} 569}
531 570
532static void etp_set_max_poll_time (double nseconds) 571static void etp_set_max_poll_time (double nseconds)
533{ 572{
534 if (WORDACCESS_UNSAFE) X_LOCK (reslock); 573 if (WORDACCESS_UNSAFE) X_LOCK (reslock);
… …
569 608
570static void grp_try_feed (eio_req *grp) 609static void grp_try_feed (eio_req *grp)
571{ 610{
572 while (grp->size < grp->int2 && !EIO_CANCELLED (grp)) 611 while (grp->size < grp->int2 && !EIO_CANCELLED (grp))
573 { 612 {
574 int old_len = grp->size; 613 grp->flags &= ~EIO_FLAG_GROUPADD;
575 614
576 EIO_FEED (grp); 615 EIO_FEED (grp);
577 616
578 /* stop if no progress has been made */ 617 /* stop if no progress has been made */
579 if (old_len == grp->size) 618 if (!(grp->flags & EIO_FLAG_GROUPADD))
580 { 619 {
581 grp->feed = 0; 620 grp->feed = 0;
582 break; 621 break;
583 } 622 }
584 } 623 }
… …
701 740
702/*****************************************************************************/ 741/*****************************************************************************/
703/* work around various missing functions */ 742/* work around various missing functions */
704 743
705#if !HAVE_PREADWRITE 744#if !HAVE_PREADWRITE
745# undef pread
746# undef pwrite
706# define pread eio__pread 747# define pread eio__pread
707# define pwrite eio__pwrite 748# define pwrite eio__pwrite
708
709/*
710 * make our pread/pwrite safe against themselves, but not against
711 * normal read/write by using a mutex. slows down execution a lot,
712 * but that's your problem, not mine.
713 */
714static mutex_t preadwritelock = X_MUTEX_INIT;
715 749
716static ssize_t 750static ssize_t
717eio__pread (int fd, void *buf, size_t count, off_t offset) 751eio__pread (int fd, void *buf, size_t count, off_t offset)
718{ 752{
719 ssize_t res; 753 ssize_t res;
… …
737 771
738 X_LOCK (preadwritelock); 772 X_LOCK (preadwritelock);
739 ooffset = lseek (fd, 0, SEEK_CUR); 773 ooffset = lseek (fd, 0, SEEK_CUR);
740 lseek (fd, offset, SEEK_SET); 774 lseek (fd, offset, SEEK_SET);
741 res = write (fd, buf, count); 775 res = write (fd, buf, count);
742 lseek (fd, offset, SEEK_SET); 776 lseek (fd, ooffset, SEEK_SET);
743 X_UNLOCK (preadwritelock); 777 X_UNLOCK (preadwritelock);
744 778
745 return res; 779 return res;
746} 780}
747#endif 781#endif
748 782
749#ifndef HAVE_FUTIMES 783#ifndef HAVE_FUTIMES
750 784
785# undef utimes
786# undef futimes
751# define utimes(path,times) eio__utimes (path, times) 787# define utimes(path,times) eio__utimes (path, times)
752# define futimes(fd,times) eio__futimes (fd, times) 788# define futimes(fd,times) eio__futimes (fd, times)
753 789
754static int 790static int
755eio__utimes (const char *filename, const struct timeval times[2]) 791eio__utimes (const char *filename, const struct timeval times[2])
… …
774} 810}
775 811
776#endif 812#endif
777 813
778#if !HAVE_FDATASYNC 814#if !HAVE_FDATASYNC
815# undef fdatasync
779# define fdatasync fsync 816# define fdatasync(fd) fsync (fd)
780#endif 817#endif
818
819/* sync_file_range always needs emulation */
820int
821eio__sync_file_range (int fd, off_t offset, size_t nbytes, unsigned int flags)
822{
823#if HAVE_SYNC_FILE_RANGE
824 int res;
825
826 if (EIO_SYNC_FILE_RANGE_WAIT_BEFORE != SYNC_FILE_RANGE_WAIT_BEFORE
827 || EIO_SYNC_FILE_RANGE_WRITE != SYNC_FILE_RANGE_WRITE
828 || EIO_SYNC_FILE_RANGE_WAIT_AFTER != SYNC_FILE_RANGE_WAIT_AFTER)
829 {
830 flags = 0
831 | (flags & EIO_SYNC_FILE_RANGE_WAIT_BEFORE ? SYNC_FILE_RANGE_WAIT_BEFORE : 0)
832 | (flags & EIO_SYNC_FILE_RANGE_WRITE ? SYNC_FILE_RANGE_WRITE : 0)
833 | (flags & EIO_SYNC_FILE_RANGE_WAIT_AFTER ? SYNC_FILE_RANGE_WAIT_AFTER : 0);
834 }
835
836 res = sync_file_range (fd, offset, nbytes, flags);
837
838 if (!res || errno != ENOSYS)
839 return res;
840#endif
841
842 /* even though we could play tricks with the flags, it's better to always
843 * call fdatasync, as thta matches the expectation of it's users best */
844 return fdatasync (fd);
845}
781 846
782#if !HAVE_READAHEAD 847#if !HAVE_READAHEAD
848# undef readahead
783# define readahead(fd,offset,count) eio__readahead (fd, offset, count, self) 849# define readahead(fd,offset,count) eio__readahead (fd, offset, count, self)
784 850
785static ssize_t 851static ssize_t
786eio__readahead (int fd, off_t offset, size_t count, worker *self) 852eio__readahead (int fd, off_t offset, size_t count, etp_worker *self)
787{ 853{
788 size_t todo = count; 854 size_t todo = count;
789 dBUF; 855 dBUF;
790 856
791 while (todo > 0) 857 while (todo > 0)
… …
799 865
800 errno = 0; 866 errno = 0;
801 return count; 867 return count;
802} 868}
803 869
804#endif
805
806#if !HAVE_READDIR_R
807# define readdir_r eio__readdir_r
808
809static mutex_t readdirlock = X_MUTEX_INIT;
810
811static int
812eio__readdir_r (DIR *dirp, EIO_STRUCT_DIRENT *ent, EIO_STRUCT_DIRENT **res)
813{
814 EIO_STRUCT_DIRENT *e;
815 int errorno;
816
817 X_LOCK (readdirlock);
818
819 e = readdir (dirp);
820 errorno = errno;
821
822 if (e)
823 {
824 *res = ent;
825 strcpy (ent->d_name, e->d_name);
826 }
827 else
828 *res = 0;
829
830 X_UNLOCK (readdirlock);
831
832 errno = errorno;
833 return e ? 0 : -1;
834}
835#endif 870#endif
836 871
837/* sendfile always needs emulation */ 872/* sendfile always needs emulation */
838static ssize_t 873static ssize_t
839eio__sendfile (int ofd, int ifd, off_t offset, size_t count, etp_worker *self) 874eio__sendfile (int ofd, int ifd, off_t offset, size_t count, etp_worker *self)
… …
931/* read a full directory */ 966/* read a full directory */
932static void 967static void
933eio__scandir (eio_req *req, etp_worker *self) 968eio__scandir (eio_req *req, etp_worker *self)
934{ 969{
935 DIR *dirp; 970 DIR *dirp;
936 union
937 {
938 EIO_STRUCT_DIRENT d;
939 char b [offsetof (EIO_STRUCT_DIRENT, d_name) + NAME_MAX + 1];
940 } *u;
941 EIO_STRUCT_DIRENT *entp; 971 EIO_STRUCT_DIRENT *entp;
942 char *name, *names; 972 char *name, *names;
943 int memlen = 4096; 973 int memlen = 4096;
944 int memofs = 0; 974 int memofs = 0;
945 int res = 0; 975 int res = 0;
946 976
947 X_LOCK (wrklock); 977 X_LOCK (wrklock);
978 /* the corresponding closedir is in ETP_WORKER_CLEAR */
948 self->dirp = dirp = opendir (req->ptr1); 979 self->dirp = dirp = opendir (req->ptr1);
949 self->dbuf = u = malloc (sizeof (*u));
950 req->flags |= EIO_FLAG_PTR2_FREE; 980 req->flags |= EIO_FLAG_PTR2_FREE;
951 req->ptr2 = names = malloc (memlen); 981 req->ptr2 = names = malloc (memlen);
952 X_UNLOCK (wrklock); 982 X_UNLOCK (wrklock);
953 983
954 if (dirp && u && names) 984 if (dirp && names)
955 for (;;) 985 for (;;)
956 { 986 {
957 errno = 0; 987 errno = 0;
958 readdir_r (dirp, &u->d, &entp); 988 entp = readdir (dirp);
959 989
960 if (!entp) 990 if (!entp)
961 break; 991 break;
962 992
963 name = entp->d_name; 993 name = entp->d_name;
… …
986 1016
987 if (errno) 1017 if (errno)
988 res = -1; 1018 res = -1;
989 1019
990 req->result = res; 1020 req->result = res;
1021}
1022
1023#if !(_POSIX_MAPPED_FILES && _POSIX_SYNCHRONIZED_IO)
1024# undef msync
1025# define msync(a,b,c) ((errno = ENOSYS), -1)
1026#endif
1027
1028int
1029eio__mtouch (void *mem, size_t len, int flags)
1030{
1031 intptr_t addr = (intptr_t)mem;
1032 intptr_t end = addr + len;
1033#ifdef PAGESIZE
1034 const intptr_t page = PAGESIZE;
1035#else
1036 static intptr_t page;
1037
1038 if (!page)
1039 page = sysconf (_SC_PAGESIZE);
1040#endif
1041
1042 addr &= ~(page - 1); /* assume page size is always a power of two */
1043
1044 if (addr < end)
1045 if (flags) /* modify */
1046 do { *((volatile sig_atomic_t *)addr) |= 0; } while ((addr += page) < len);
1047 else
1048 do { *((volatile sig_atomic_t *)addr) ; } while ((addr += page) < len);
1049
1050 return 0;
991} 1051}
992 1052
993/*****************************************************************************/ 1053/*****************************************************************************/
994 1054
995#define ALLOC(len) \ 1055#define ALLOC(len) \
… …
1082 1142
1083/*****************************************************************************/ 1143/*****************************************************************************/
1084 1144
1085int eio_init (void (*want_poll)(void), void (*done_poll)(void)) 1145int eio_init (void (*want_poll)(void), void (*done_poll)(void))
1086{ 1146{
1087 etp_init (want_poll, done_poll); 1147 return etp_init (want_poll, done_poll);
1088} 1148}
1089 1149
1090static void eio_api_destroy (eio_req *req) 1150static void eio_api_destroy (eio_req *req)
1091{ 1151{
1092 free (req); 1152 free (req);
… …
1154 case EIO_RMDIR: req->result = rmdir (req->ptr1); break; 1214 case EIO_RMDIR: req->result = rmdir (req->ptr1); break;
1155 case EIO_MKDIR: req->result = mkdir (req->ptr1, (mode_t)req->int2); break; 1215 case EIO_MKDIR: req->result = mkdir (req->ptr1, (mode_t)req->int2); break;
1156 case EIO_RENAME: req->result = rename (req->ptr1, req->ptr2); break; 1216 case EIO_RENAME: req->result = rename (req->ptr1, req->ptr2); break;
1157 case EIO_LINK: req->result = link (req->ptr1, req->ptr2); break; 1217 case EIO_LINK: req->result = link (req->ptr1, req->ptr2); break;
1158 case EIO_SYMLINK: req->result = symlink (req->ptr1, req->ptr2); break; 1218 case EIO_SYMLINK: req->result = symlink (req->ptr1, req->ptr2); break;
1159 case EIO_MKNOD: req->result = mknod (req->ptr1, (mode_t)req->int2, (dev_t)req->offs); break; 1219 case EIO_MKNOD: req->result = mknod (req->ptr1, (mode_t)req->int2, (dev_t)req->int3); break;
1160 1220
1161 case EIO_READLINK: ALLOC (NAME_MAX); 1221 case EIO_READLINK: ALLOC (NAME_MAX);
1162 req->result = readlink (req->ptr1, req->ptr2, NAME_MAX); break; 1222 req->result = readlink (req->ptr1, req->ptr2, NAME_MAX); break;
1163 1223
1164 case EIO_SYNC: req->result = 0; sync (); break; 1224 case EIO_SYNC: req->result = 0; sync (); break;
1165 case EIO_FSYNC: req->result = fsync (req->int1); break; 1225 case EIO_FSYNC: req->result = fsync (req->int1); break;
1166 case EIO_FDATASYNC: req->result = fdatasync (req->int1); break; 1226 case EIO_FDATASYNC: req->result = fdatasync (req->int1); break;
1227 case EIO_MSYNC: req->result = msync (req->ptr2, req->size, req->int1); break;
1228 case EIO_MTOUCH: req->result = eio__mtouch (req->ptr2, req->size, req->int1); break;
1229 case EIO_SYNC_FILE_RANGE: req->result = eio__sync_file_range (req->int1, req->offs, req->size, req->int2); break;
1167 1230
1168 case EIO_READDIR: eio__scandir (req, self); break; 1231 case EIO_READDIR: eio__scandir (req, self); break;
1169 1232
1170 case EIO_BUSY: 1233 case EIO_BUSY:
1171#ifdef _WIN32 1234#ifdef _WIN32
… …
1203 1266
1204 req->result = req->type == EIO_FUTIME 1267 req->result = req->type == EIO_FUTIME
1205 ? futimes (req->int1, times) 1268 ? futimes (req->int1, times)
1206 : utimes (req->ptr1, times); 1269 : utimes (req->ptr1, times);
1207 } 1270 }
1271 break;
1208 1272
1209 case EIO_GROUP: 1273 case EIO_GROUP:
1274 abort (); /* handled in eio_request */
1275
1210 case EIO_NOP: 1276 case EIO_NOP:
1211 req->result = 0; 1277 req->result = 0;
1212 break; 1278 break;
1213 1279
1214 case EIO_CUSTOM: 1280 case EIO_CUSTOM:
1215 req->feed (req); 1281 ((void (*)(eio_req *))req->feed) (req);
1216 break; 1282 break;
1217 1283
1218 default: 1284 default:
1219 req->result = -1; 1285 req->result = -1;
1220 break; 1286 break;
… …
1243eio_req *eio_fsync (int fd, int pri, eio_cb cb, void *data) 1309eio_req *eio_fsync (int fd, int pri, eio_cb cb, void *data)
1244{ 1310{
1245 REQ (EIO_FSYNC); req->int1 = fd; SEND; 1311 REQ (EIO_FSYNC); req->int1 = fd; SEND;
1246} 1312}
1247 1313
1314eio_req *eio_msync (void *addr, size_t length, int flags, int pri, eio_cb cb, void *data)
1315{
1316 REQ (EIO_MSYNC); req->ptr2 = addr; req->size = length; req->int1 = flags; SEND;
1317}
1318
1319eio_req *eio_mtouch (void *addr, size_t length, int flags, int pri, eio_cb cb, void *data)
1320{
1321 REQ (EIO_MTOUCH); req->ptr2 = addr; req->size = length; req->int1 = flags; SEND;
1322}
1323
1324eio_req *eio_sync_file_range (int fd, off_t offset, size_t nbytes, unsigned int flags, int pri, eio_cb cb, void *data)
1325{
1326 REQ (EIO_SYNC_FILE_RANGE); req->int1 = fd; req->offs = offset; req->size = nbytes; req->int2 = flags; SEND;
1327}
1328
1248eio_req *eio_fdatasync (int fd, int pri, eio_cb cb, void *data) 1329eio_req *eio_fdatasync (int fd, int pri, eio_cb cb, void *data)
1249{ 1330{
1250 REQ (EIO_FDATASYNC); req->int1 = fd; SEND; 1331 REQ (EIO_FDATASYNC); req->int1 = fd; SEND;
1251} 1332}
1252 1333
… …
1371 return eio__1path (EIO_READDIR, path, pri, cb, data); 1452 return eio__1path (EIO_READDIR, path, pri, cb, data);
1372} 1453}
1373 1454
1374eio_req *eio_mknod (const char *path, mode_t mode, dev_t dev, int pri, eio_cb cb, void *data) 1455eio_req *eio_mknod (const char *path, mode_t mode, dev_t dev, int pri, eio_cb cb, void *data)
1375{ 1456{
1376 REQ (EIO_MKNOD); PATH; req->int2 = (long)mode; req->int2 = (long)dev; SEND; 1457 REQ (EIO_MKNOD); PATH; req->int2 = (long)mode; req->int3 = (long)dev; SEND;
1377} 1458}
1378 1459
1379static eio_req * 1460static eio_req *
1380eio__2path (int type, const char *path, const char *new_path, int pri, eio_cb cb, void *data) 1461eio__2path (int type, const char *path, const char *new_path, int pri, eio_cb cb, void *data)
1381{ 1462{
… …
1407 return eio__2path (EIO_RENAME, path, new_path, pri, cb, data); 1488 return eio__2path (EIO_RENAME, path, new_path, pri, cb, data);
1408} 1489}
1409 1490
1410eio_req *eio_custom (eio_cb execute, int pri, eio_cb cb, void *data) 1491eio_req *eio_custom (eio_cb execute, int pri, eio_cb cb, void *data)
1411{ 1492{
1412 REQ (EIO_CUSTOM); req->feed = execute; SEND; 1493 REQ (EIO_CUSTOM); req->feed = (void (*)(eio_req *))execute; SEND;
1413} 1494}
1414 1495
1415#endif 1496#endif
1416 1497
1417eio_req *eio_grp (eio_cb cb, void *data) 1498eio_req *eio_grp (eio_cb cb, void *data)
… …
1445 1526
1446void eio_grp_add (eio_req *grp, eio_req *req) 1527void eio_grp_add (eio_req *grp, eio_req *req)
1447{ 1528{
1448 assert (("cannot add requests to IO::AIO::GRP after the group finished", grp->int1 != 2)); 1529 assert (("cannot add requests to IO::AIO::GRP after the group finished", grp->int1 != 2));
1449 1530
1531 grp->flags |= EIO_FLAG_GROUPADD;
1532
1450 ++grp->size; 1533 ++grp->size;
1451 req->grp = grp; 1534 req->grp = grp;
1452 1535
1453 req->grp_prev = 0; 1536 req->grp_prev = 0;
1454 req->grp_next = grp->grp_first; 1537 req->grp_next = grp->grp_first;

Diff Legend

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