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.24 by root, Tue Sep 30 13:17:32 2008 UTC vs.
Revision 1.41 by root, Sun Jun 14 20:36:59 2009 UTC

1/* 1/*
2 * libeio implementation 2 * libeio implementation
3 * 3 *
4 * Copyright (c) 2007,2008 Marc Alexander Lehmann <libeio@schmorp.de> 4 * Copyright (c) 2007,2008,2009 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 *
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>
64#endif 68#endif
65 69
66#ifdef _WIN32 70#ifdef _WIN32
67 71
68 /*doh*/ 72 /*doh*/
69
70#else 73#else
71 74
72# include "config.h" 75# include "config.h"
73# include <sys/time.h> 76# include <sys/time.h>
74# include <sys/select.h> 77# include <sys/select.h>
78# include <sys/mman.h>
75# include <unistd.h> 79# include <unistd.h>
76# include <utime.h> 80# include <utime.h>
77# include <signal.h> 81# include <signal.h>
78# include <dirent.h> 82# include <dirent.h>
83
84/* POSIX_SOURCE is useless on bsd's, and XOPEN_SOURCE is unreliable there, too */
85# if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
86# define _DIRENT_HAVE_D_TYPE /* sigh */
87# define D_INO(de) (de)->d_fileno
88# define D_NAMLEN(de) (de)->d_namlen
89# elif defined(__linux) || defined(d_ino) || _XOPEN_SOURCE >= 600
90# define D_INO(de) (de)->d_ino
91# endif
92
93#ifdef _D_EXACT_NAMLEN
94# undef D_NAMLEN
95# define D_NAMLEN(de) _D_EXACT_NAMLEN (de)
96#endif
97
98# ifdef _DIRENT_HAVE_D_TYPE
99# define D_TYPE(de) (de)->d_type
100# endif
79 101
80# ifndef EIO_STRUCT_DIRENT 102# ifndef EIO_STRUCT_DIRENT
81# define EIO_STRUCT_DIRENT struct dirent 103# define EIO_STRUCT_DIRENT struct dirent
82# endif 104# endif
83 105
96# else 118# else
97# error sendfile support requested but not available 119# error sendfile support requested but not available
98# endif 120# endif
99#endif 121#endif
100 122
123#ifndef D_TYPE
124# define D_TYPE(de) 0
125#endif
126#ifndef D_INO
127# define D_INO(de) 0
128#endif
129#ifndef D_NAMLEN
130# define D_NAMLEN(de) strlen ((de)->d_name)
131#endif
132
101/* number of seconds after which an idle threads exit */ 133/* number of seconds after which an idle threads exit */
102#define IDLE_TIMEOUT 10 134#define IDLE_TIMEOUT 10
103 135
104/* used for struct dirent, AIX doesn't provide it */ 136/* used for struct dirent, AIX doesn't provide it */
105#ifndef NAME_MAX 137#ifndef NAME_MAX
155 if (wrk->dirp) \ 187 if (wrk->dirp) \
156 { \ 188 { \
157 closedir (wrk->dirp); \ 189 closedir (wrk->dirp); \
158 wrk->dirp = 0; \ 190 wrk->dirp = 0; \
159 } 191 }
192
160#define ETP_WORKER_COMMON \ 193#define ETP_WORKER_COMMON \
161 void *dbuf; \ 194 void *dbuf; \
162 DIR *dirp; 195 DIR *dirp;
163 196
164/*****************************************************************************/ 197/*****************************************************************************/
604 637
605static void grp_try_feed (eio_req *grp) 638static void grp_try_feed (eio_req *grp)
606{ 639{
607 while (grp->size < grp->int2 && !EIO_CANCELLED (grp)) 640 while (grp->size < grp->int2 && !EIO_CANCELLED (grp))
608 { 641 {
609 int old_len = grp->size; 642 grp->flags &= ~EIO_FLAG_GROUPADD;
610 643
611 EIO_FEED (grp); 644 EIO_FEED (grp);
612 645
613 /* stop if no progress has been made */ 646 /* stop if no progress has been made */
614 if (old_len == grp->size) 647 if (!(grp->flags & EIO_FLAG_GROUPADD))
615 { 648 {
616 grp->feed = 0; 649 grp->feed = 0;
617 break; 650 break;
618 } 651 }
619 } 652 }
736 769
737/*****************************************************************************/ 770/*****************************************************************************/
738/* work around various missing functions */ 771/* work around various missing functions */
739 772
740#if !HAVE_PREADWRITE 773#if !HAVE_PREADWRITE
774# undef pread
775# undef pwrite
741# define pread eio__pread 776# define pread eio__pread
742# define pwrite eio__pwrite 777# define pwrite eio__pwrite
743 778
744static ssize_t 779static ssize_t
745eio__pread (int fd, void *buf, size_t count, off_t offset) 780eio__pread (int fd, void *buf, size_t count, off_t offset)
765 800
766 X_LOCK (preadwritelock); 801 X_LOCK (preadwritelock);
767 ooffset = lseek (fd, 0, SEEK_CUR); 802 ooffset = lseek (fd, 0, SEEK_CUR);
768 lseek (fd, offset, SEEK_SET); 803 lseek (fd, offset, SEEK_SET);
769 res = write (fd, buf, count); 804 res = write (fd, buf, count);
770 lseek (fd, offset, SEEK_SET); 805 lseek (fd, ooffset, SEEK_SET);
771 X_UNLOCK (preadwritelock); 806 X_UNLOCK (preadwritelock);
772 807
773 return res; 808 return res;
774} 809}
775#endif 810#endif
776 811
777#ifndef HAVE_FUTIMES 812#ifndef HAVE_FUTIMES
778 813
814# undef utimes
815# undef futimes
779# define utimes(path,times) eio__utimes (path, times) 816# define utimes(path,times) eio__utimes (path, times)
780# define futimes(fd,times) eio__futimes (fd, times) 817# define futimes(fd,times) eio__futimes (fd, times)
781 818
782static int 819static int
783eio__utimes (const char *filename, const struct timeval times[2]) 820eio__utimes (const char *filename, const struct timeval times[2])
802} 839}
803 840
804#endif 841#endif
805 842
806#if !HAVE_FDATASYNC 843#if !HAVE_FDATASYNC
844# undef fdatasync
807# define fdatasync fsync 845# define fdatasync(fd) fsync (fd)
808#endif 846#endif
847
848/* sync_file_range always needs emulation */
849int
850eio__sync_file_range (int fd, off_t offset, size_t nbytes, unsigned int flags)
851{
852#if HAVE_SYNC_FILE_RANGE
853 int res;
854
855 if (EIO_SYNC_FILE_RANGE_WAIT_BEFORE != SYNC_FILE_RANGE_WAIT_BEFORE
856 || EIO_SYNC_FILE_RANGE_WRITE != SYNC_FILE_RANGE_WRITE
857 || EIO_SYNC_FILE_RANGE_WAIT_AFTER != SYNC_FILE_RANGE_WAIT_AFTER)
858 {
859 flags = 0
860 | (flags & EIO_SYNC_FILE_RANGE_WAIT_BEFORE ? SYNC_FILE_RANGE_WAIT_BEFORE : 0)
861 | (flags & EIO_SYNC_FILE_RANGE_WRITE ? SYNC_FILE_RANGE_WRITE : 0)
862 | (flags & EIO_SYNC_FILE_RANGE_WAIT_AFTER ? SYNC_FILE_RANGE_WAIT_AFTER : 0);
863 }
864
865 res = sync_file_range (fd, offset, nbytes, flags);
866
867 if (!res || errno != ENOSYS)
868 return res;
869#endif
870
871 /* even though we could play tricks with the flags, it's better to always
872 * call fdatasync, as thta matches the expectation of it's users best */
873 return fdatasync (fd);
874}
809 875
810#if !HAVE_READAHEAD 876#if !HAVE_READAHEAD
877# undef readahead
811# define readahead(fd,offset,count) eio__readahead (fd, offset, count, self) 878# define readahead(fd,offset,count) eio__readahead (fd, offset, count, self)
812 879
813static ssize_t 880static ssize_t
814eio__readahead (int fd, off_t offset, size_t count, etp_worker *self) 881eio__readahead (int fd, off_t offset, size_t count, etp_worker *self)
815{ 882{
923 } 990 }
924 991
925 return res; 992 return res;
926} 993}
927 994
995static signed char
996eio_dent_cmp (const eio_dirent *a, const eio_dirent *b)
997{
998 return b->score - a->score ? b->score - a->score /* works because our signed char is always 0..100 */
999 : a->inode < b->inode ? -1 : a->inode > b->inode ? 1 : 0;
1000}
1001
1002#define EIO_DENT_CMP(i,op,j) eio_dent_cmp (&i, &j) op 0
1003#define EIO_DENT_NUM_SCORES 9
1004
1005#define EIO_QSORT_CUTOFF 30 /* quite high, but performs well on many filesystems */
1006#define EIO_QSORT_SKIP 60 /* when to skip qsort completely */
1007
1008static void
1009eio_dent_sort (eio_dirent *dents, int size)
1010{
1011 if (size <= 1)
1012 return; /* our insertion sort relies on size > 0 */
1013
1014 if (size > EIO_QSORT_SKIP) /* skip quicksort for small directories */
1015 {
1016 /* first, use quicksort */
1017 /* should be good for 2**31 entries */
1018 int i;
1019 struct rng { eio_dirent *l, *r; } rng [32];
1020
1021 i = 0;
1022 rng[0].l = dents;
1023 rng[0].r = dents + size;
1024
1025 while (expect_true (i >= 0))
1026 {
1027 eio_dirent *L = rng [i].l;
1028 eio_dirent *R = rng [i].r - 1;
1029
1030 if (expect_false (L + EIO_QSORT_CUTOFF < R))
1031 {
1032 eio_dirent *mid = &dents [((L - dents) + (R - dents)) >> 1];
1033 eio_dirent piv = *mid; *mid = *L; *L = piv;
1034
1035 while (L < R)
1036 {
1037 while (EIO_DENT_CMP (*R, >=, piv) && L < R)
1038 --R;
1039
1040 if (L < R)
1041 *L++ = *R;
1042
1043 while (EIO_DENT_CMP (*L, <=, piv) && L < R)
1044 ++L;
1045
1046 if (L < R)
1047 *R-- = *L;
1048 }
1049
1050 *L = piv;
1051
1052 ++i;
1053 rng [i].l = L + 1;
1054 rng [i].r = rng [i - 1].r;
1055 rng [i - 1].r = L;
1056
1057 if (rng [i].r - rng [i].l > rng [i - 1].r - rng [i - 1].l)
1058 {
1059 struct rng t;
1060
1061 t = rng [i]; rng [i] = rng [i - 1]; rng [i - 1] = t;
1062 }
1063 }
1064 else
1065 --i;
1066 }
1067 }
1068
1069 /* use an insertion sort after qsort, or for small arrays */
1070 /* first move the smallest element to the front, to act as a sentinel */
1071 {
1072 int i;
1073 eio_dirent *min = dents;
1074
1075 for (i = size > EIO_QSORT_SKIP ? EIO_QSORT_CUTOFF + 1 : size; --i; )
1076 if (EIO_DENT_CMP (dents [i], <, *min))
1077 min = &dents [i];
1078
1079 /* swap elements 0 and j (minimum) */
1080 {
1081 eio_dirent tmp = *dents; *dents = *min; *min = tmp;
1082 }
1083 }
1084
1085 {
1086 /* then do standard insertion sort */
1087 eio_dirent *i, *j;
1088
1089 for (i = dents + 1; i < dents + size; ++i)
1090 {
1091 eio_dirent value = *i;
1092
1093 for (j = i - 1; EIO_DENT_CMP (*j, >, value); --j)
1094 j [1] = j [0];
1095
1096 j [1] = value;
1097 }
1098 }
1099}
1100
928/* read a full directory */ 1101/* read a full directory */
929static void 1102static void
930eio__scandir (eio_req *req, etp_worker *self) 1103eio__scandir (eio_req *req, etp_worker *self)
931{ 1104{
932 DIR *dirp; 1105 DIR *dirp;
933 EIO_STRUCT_DIRENT *entp; 1106 EIO_STRUCT_DIRENT *entp;
934 char *name, *names; 1107 char *name, *names;
935 int memlen = 4096; 1108 int namesalloc = 4096;
936 int memofs = 0; 1109 int namesoffs = 0;
1110 int flags = req->int1;
1111 eio_dirent *dents = 0;
1112 int dentalloc = 128;
937 int res = 0; 1113 int dentoffs = 0;
1114
1115 req->result = -1;
1116
1117 if (!(flags & EIO_READDIR_DENTS))
1118 flags &= ~(EIO_READDIR_DIRS_FIRST | EIO_READDIR_STAT_ORDER);
938 1119
939 X_LOCK (wrklock); 1120 X_LOCK (wrklock);
940 /* the corresponding closedir is in ETP_WORKER_CLEAR */ 1121 /* the corresponding closedir is in ETP_WORKER_CLEAR */
941 self->dirp = dirp = opendir (req->ptr1); 1122 self->dirp = dirp = opendir (req->ptr1);
942 req->flags |= EIO_FLAG_PTR2_FREE; 1123 req->flags |= EIO_FLAG_PTR1_FREE | EIO_FLAG_PTR2_FREE;
943 req->ptr2 = names = malloc (memlen); 1124 req->ptr1 = names = malloc (namesalloc);
1125 req->ptr2 = dents = flags ? malloc (dentalloc * sizeof (eio_dirent)) : 0;
944 X_UNLOCK (wrklock); 1126 X_UNLOCK (wrklock);
945 1127
946 if (dirp && names) 1128 if (dirp && names && (!flags || dents))
947 for (;;) 1129 for (;;)
948 { 1130 {
949 errno = 0; 1131 errno = 0;
950 entp = readdir (dirp); 1132 entp = readdir (dirp);
951 1133
952 if (!entp) 1134 if (!entp)
1135 {
1136 if (errno)
1137 break;
1138
1139 /* sort etc. */
1140 req->int1 = flags;
1141 req->result = dentoffs;
1142
1143 if (dents)
1144 {
1145 eio_dirent *ent = dents + dentoffs;
1146
1147 while (ent > dents)
1148 (--ent)->name = names + (size_t)ent->name;
1149 }
1150
1151 if (flags & EIO_READDIR_STAT_ORDER
1152 || !(~flags & (EIO_READDIR_DIRS_FIRST | EIO_READDIR_FOUND_UNKNOWN)))
1153 eio_dent_sort (dents, dentoffs); /* score depends of DIRS_FIRST */
1154 else if (flags & EIO_READDIR_DIRS_FIRST)
1155 {
1156 /* in this case, all is known, and we just put dirs first and sort them */
1157 eio_dirent *ent = dents + dentoffs;
1158 eio_dirent *dir = dents;
1159
1160 /* now move dirs to the front, and non-dirs to the back */
1161 /* by walking from both sides and swapping if necessary */
1162 while (ent > dir)
1163 {
1164 if (dir->type == DT_DIR)
1165 {
1166 dir->score = 0;
1167 ++dir;
1168 }
1169 else
1170 {
1171 --ent;
1172
1173 if (ent->type == DT_DIR)
1174 {
1175 eio_dirent tmp = *dir;
1176 *dir = *ent;
1177 *ent = tmp;
1178
1179 dir->score = 0;
1180 ++dir;
1181 }
1182 }
1183 }
1184
1185 /* now sort the dirs only */
1186 eio_dent_sort (dents, dir - dents);
1187 }
1188
1189 /* only provide the names array unless DENTS is specified */
1190 if (!(flags & EIO_READDIR_DENTS))
1191 {
1192 X_LOCK (wrklock);
1193 assert (!dents);
1194 req->ptr1 = 0;
1195 req->ptr2 = names;
1196 X_UNLOCK (wrklock);
1197 }
1198
953 break; 1199 break;
1200 }
954 1201
1202 /* now add the entry to our list(s) */
955 name = entp->d_name; 1203 name = entp->d_name;
956 1204
1205 /* skip . and .. entries */
957 if (name [0] != '.' || (name [1] && (name [1] != '.' || name [2]))) 1206 if (name [0] != '.' || (name [1] && (name [1] != '.' || name [2])))
958 { 1207 {
959 int len = strlen (name) + 1; 1208 int len = D_NAMLEN (entp) + 1;
960 1209
961 res++; 1210 while (expect_false (namesoffs + len > namesalloc))
962
963 while (memofs + len > memlen)
964 { 1211 {
965 memlen *= 2; 1212 namesalloc *= 2;
966 X_LOCK (wrklock); 1213 X_LOCK (wrklock);
967 req->ptr2 = names = realloc (names, memlen); 1214 req->ptr1 = names = realloc (names, namesalloc);
968 X_UNLOCK (wrklock); 1215 X_UNLOCK (wrklock);
969 1216
970 if (!names) 1217 if (!names)
971 break; 1218 break;
972 } 1219 }
973 1220
974 memcpy (names + memofs, name, len); 1221 memcpy (names + namesoffs, name, len);
1222
1223 if (dents)
1224 {
1225 struct eio_dirent *ent;
1226
1227 if (expect_false (dentoffs == dentalloc))
1228 {
1229 dentalloc *= 2;
1230 X_LOCK (wrklock);
1231 req->ptr2 = dents = realloc (dents, dentalloc * sizeof (eio_dirent));
1232 X_UNLOCK (wrklock);
1233
1234 if (!dents)
1235 break;
1236 }
1237
1238 ent = dents + dentoffs;
1239
1240 ent->name = (char *)(size_t)namesoffs; /* rather dirtily we store the offset in the pointer */
1241 ent->namelen = len - 1;
1242 ent->inode = D_INO (entp) ? D_INO (entp) : dentoffs;
1243
1244 switch (D_TYPE (entp))
1245 {
1246 default:
1247 ent->type = EIO_DT_UNKNOWN;
1248 flags |= EIO_READDIR_FOUND_UNKNOWN;
1249 break;
1250
1251 #ifdef DT_FIFO
1252 case DT_FIFO: ent->type = EIO_DT_FIFO; break;
1253 #endif
1254 #ifdef DT_CHR
1255 case DT_CHR: ent->type = EIO_DT_CHR; break;
1256 #endif
1257 #ifdef DT_MPC
1258 case DT_MPC: ent->type = EIO_DT_MPC; break;
1259 #endif
1260 #ifdef DT_DIR
1261 case DT_DIR: ent->type = EIO_DT_DIR; break;
1262 #endif
1263 #ifdef DT_NAM
1264 case DT_NAM: ent->type = EIO_DT_NAM; break;
1265 #endif
1266 #ifdef DT_BLK
1267 case DT_BLK: ent->type = EIO_DT_BLK; break;
1268 #endif
1269 #ifdef DT_MPB
1270 case DT_MPB: ent->type = EIO_DT_MPB; break;
1271 #endif
1272 #ifdef DT_REG
1273 case DT_REG: ent->type = EIO_DT_REG; break;
1274 #endif
1275 #ifdef DT_NWK
1276 case DT_NWK: ent->type = EIO_DT_NWK; break;
1277 #endif
1278 #ifdef DT_CMP
1279 case DT_CMP: ent->type = EIO_DT_CMP; break;
1280 #endif
1281 #ifdef DT_LNK
1282 case DT_LNK: ent->type = EIO_DT_LNK; break;
1283 #endif
1284 #ifdef DT_SOCK
1285 case DT_SOCK: ent->type = EIO_DT_SOCK; break;
1286 #endif
1287 #ifdef DT_DOOR
1288 case DT_DOOR: ent->type = EIO_DT_DOOR; break;
1289 #endif
1290 #ifdef DT_WHT
1291 case DT_WHT: ent->type = EIO_DT_WHT; break;
1292 #endif
1293 }
1294
1295 ent->score = 0;
1296
1297 if (flags & EIO_READDIR_DIRS_FIRST)
1298 {
1299 if (ent->type == EIO_DT_UNKNOWN)
1300 {
1301 if (*name == '.') /* leading dots are likely directories, and, in any case, rare */
1302 ent->score = 7;
1303 else if (!strchr (name, '.')) /* absense of dots indicate likely dirs */
1304 ent->score = len <= 2 ? len + 4 : len <= 4 ? 3 : len <= 7 ? 2 : 1; /* shorter == more likely dir, but avoid too many classes */
1305 }
1306 else if (ent->type == EIO_DT_DIR)
1307 ent->score = 8;
1308 }
1309 }
1310
975 memofs += len; 1311 namesoffs += len;
1312 ++dentoffs;
1313 }
1314
1315 if (EIO_CANCELLED (req))
1316 {
1317 errno = ECANCELED;
1318 break;
976 } 1319 }
977 } 1320 }
978
979 if (errno)
980 res = -1;
981
982 req->result = res;
983} 1321}
984 1322
985#if !(_POSIX_MAPPED_FILES && _POSIX_SYNCHRONIZED_IO) 1323#if !(_POSIX_MAPPED_FILES && _POSIX_SYNCHRONIZED_IO)
1324# undef msync
986# define msync(a,b,c) ENOSYS 1325# define msync(a,b,c) ((errno = ENOSYS), -1)
987#endif 1326#endif
988 1327
989int 1328int
990eio__mtouch (void *mem, size_t len, int flags) 1329eio__mtouch (void *mem, size_t len, int flags)
991{ 1330{
1185 case EIO_SYNC: req->result = 0; sync (); break; 1524 case EIO_SYNC: req->result = 0; sync (); break;
1186 case EIO_FSYNC: req->result = fsync (req->int1); break; 1525 case EIO_FSYNC: req->result = fsync (req->int1); break;
1187 case EIO_FDATASYNC: req->result = fdatasync (req->int1); break; 1526 case EIO_FDATASYNC: req->result = fdatasync (req->int1); break;
1188 case EIO_MSYNC: req->result = msync (req->ptr2, req->size, req->int1); break; 1527 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; 1528 case EIO_MTOUCH: req->result = eio__mtouch (req->ptr2, req->size, req->int1); break;
1529 case EIO_SYNC_FILE_RANGE: req->result = eio__sync_file_range (req->int1, req->offs, req->size, req->int2); break;
1190 1530
1191 case EIO_READDIR: eio__scandir (req, self); break; 1531 case EIO_READDIR: eio__scandir (req, self); break;
1192 1532
1193 case EIO_BUSY: 1533 case EIO_BUSY:
1194#ifdef _WIN32 1534#ifdef _WIN32
1226 1566
1227 req->result = req->type == EIO_FUTIME 1567 req->result = req->type == EIO_FUTIME
1228 ? futimes (req->int1, times) 1568 ? futimes (req->int1, times)
1229 : utimes (req->ptr1, times); 1569 : utimes (req->ptr1, times);
1230 } 1570 }
1571 break;
1231 1572
1232 case EIO_GROUP: 1573 case EIO_GROUP:
1233 abort (); /* handled in eio_request */ 1574 abort (); /* handled in eio_request */
1234 1575
1235 case EIO_NOP: 1576 case EIO_NOP:
1278eio_req *eio_mtouch (void *addr, size_t length, int flags, int pri, eio_cb cb, void *data) 1619eio_req *eio_mtouch (void *addr, size_t length, int flags, int pri, eio_cb cb, void *data)
1279{ 1620{
1280 REQ (EIO_MTOUCH); req->ptr2 = addr; req->size = length; req->int1 = flags; SEND; 1621 REQ (EIO_MTOUCH); req->ptr2 = addr; req->size = length; req->int1 = flags; SEND;
1281} 1622}
1282 1623
1624eio_req *eio_sync_file_range (int fd, off_t offset, size_t nbytes, unsigned int flags, int pri, eio_cb cb, void *data)
1625{
1626 REQ (EIO_SYNC_FILE_RANGE); req->int1 = fd; req->offs = offset; req->size = nbytes; req->int2 = flags; SEND;
1627}
1628
1283eio_req *eio_fdatasync (int fd, int pri, eio_cb cb, void *data) 1629eio_req *eio_fdatasync (int fd, int pri, eio_cb cb, void *data)
1284{ 1630{
1285 REQ (EIO_FDATASYNC); req->int1 = fd; SEND; 1631 REQ (EIO_FDATASYNC); req->int1 = fd; SEND;
1286} 1632}
1287 1633
1399eio_req *eio_rmdir (const char *path, int pri, eio_cb cb, void *data) 1745eio_req *eio_rmdir (const char *path, int pri, eio_cb cb, void *data)
1400{ 1746{
1401 return eio__1path (EIO_RMDIR, path, pri, cb, data); 1747 return eio__1path (EIO_RMDIR, path, pri, cb, data);
1402} 1748}
1403 1749
1404eio_req *eio_readdir (const char *path, int pri, eio_cb cb, void *data) 1750eio_req *eio_readdir (const char *path, int flags, int pri, eio_cb cb, void *data)
1405{ 1751{
1406 return eio__1path (EIO_READDIR, path, pri, cb, data); 1752 REQ (EIO_READDIR); PATH; req->int1 = flags; SEND;
1407} 1753}
1408 1754
1409eio_req *eio_mknod (const char *path, mode_t mode, dev_t dev, int pri, eio_cb cb, void *data) 1755eio_req *eio_mknod (const char *path, mode_t mode, dev_t dev, int pri, eio_cb cb, void *data)
1410{ 1756{
1411 REQ (EIO_MKNOD); PATH; req->int2 = (long)mode; req->int3 = (long)dev; SEND; 1757 REQ (EIO_MKNOD); PATH; req->int2 = (long)mode; req->int3 = (long)dev; SEND;
1480 1826
1481void eio_grp_add (eio_req *grp, eio_req *req) 1827void eio_grp_add (eio_req *grp, eio_req *req)
1482{ 1828{
1483 assert (("cannot add requests to IO::AIO::GRP after the group finished", grp->int1 != 2)); 1829 assert (("cannot add requests to IO::AIO::GRP after the group finished", grp->int1 != 2));
1484 1830
1831 grp->flags |= EIO_FLAG_GROUPADD;
1832
1485 ++grp->size; 1833 ++grp->size;
1486 req->grp = grp; 1834 req->grp = grp;
1487 1835
1488 req->grp_prev = 0; 1836 req->grp_prev = 0;
1489 req->grp_next = grp->grp_first; 1837 req->grp_next = grp->grp_first;
1498/* misc garbage */ 1846/* misc garbage */
1499 1847
1500ssize_t eio_sendfile_sync (int ofd, int ifd, off_t offset, size_t count) 1848ssize_t eio_sendfile_sync (int ofd, int ifd, off_t offset, size_t count)
1501{ 1849{
1502 etp_worker wrk; 1850 etp_worker wrk;
1851 ssize_t ret;
1503 1852
1504 wrk.dbuf = 0; 1853 wrk.dbuf = 0;
1505 1854
1506 eio__sendfile (ofd, ifd, offset, count, &wrk); 1855 ret = eio__sendfile (ofd, ifd, offset, count, &wrk);
1507 1856
1508 if (wrk.dbuf) 1857 if (wrk.dbuf)
1509 free (wrk.dbuf); 1858 free (wrk.dbuf);
1510}
1511 1859
1860 return ret;
1861}
1862

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines