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

Comparing libeio/eio.c (file contents):
Revision 1.14 by root, Sat May 17 12:17:25 2008 UTC vs.
Revision 1.15 by root, Sat May 17 12:26:57 2008 UTC

… …
123/*****************************************************************************/ 123/*****************************************************************************/
124 124
125#define ETP_PRI_MIN EIO_PRI_MIN 125#define ETP_PRI_MIN EIO_PRI_MIN
126#define ETP_PRI_MAX EIO_PRI_MAX 126#define ETP_PRI_MAX EIO_PRI_MAX
127 127
128struct etp_worker;
129
128#define ETP_REQ eio_req 130#define ETP_REQ eio_req
129#define ETP_DESTROY(req) eio_destroy (req) 131#define ETP_DESTROY(req) eio_destroy (req)
130static int eio_finish (eio_req *req); 132static int eio_finish (eio_req *req);
131#define ETP_FINISH(req) eio_finish (req) 133#define ETP_FINISH(req) eio_finish (req)
134static void eio_execute (struct etp_worker *self, eio_req *req);
135#define ETP_EXECUTE(wrk,req) eio_execute (wrk,req)
132 136
133#define ETP_WORKER_CLEAR(req) \ 137#define ETP_WORKER_CLEAR(req) \
134 if (wrk->dbuf) \ 138 if (wrk->dbuf) \
135 { \ 139 { \
136 free (wrk->dbuf); \ 140 free (wrk->dbuf); \
… …
1047 1051
1048 --nready; 1052 --nready;
1049 1053
1050 X_UNLOCK (reqlock); 1054 X_UNLOCK (reqlock);
1051 1055
1052 errno = 0; /* strictly unnecessary */ 1056 if (req->type < 0)
1057 goto quit;
1053 1058
1054 if (!EIO_CANCELLED (req)) 1059 if (!EIO_CANCELLED (req))
1055 switch (req->type) 1060 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 1061
1156 X_LOCK (reslock); 1062 X_LOCK (reslock);
1157 1063
1158 ++npending; 1064 ++npending;
1159 1065
… …
1208 { \ 1114 { \
1209 eio_api_destroy (req); \ 1115 eio_api_destroy (req); \
1210 return 0; \ 1116 return 0; \
1211 } 1117 }
1212 1118
1119static void eio_execute (etp_worker *self, eio_req *req)
1120{
1121 errno = 0;
1122
1123 switch (req->type)
1124 {
1125 case EIO_READ: ALLOC (req->size);
1126 req->result = req->offs >= 0
1127 ? pread (req->int1, req->ptr2, req->size, req->offs)
1128 : read (req->int1, req->ptr2, req->size); break;
1129 case EIO_WRITE: req->result = req->offs >= 0
1130 ? pwrite (req->int1, req->ptr2, req->size, req->offs)
1131 : write (req->int1, req->ptr2, req->size); break;
1132
1133 case EIO_READAHEAD: req->result = readahead (req->int1, req->offs, req->size); break;
1134 case EIO_SENDFILE: req->result = eio__sendfile (req->int1, req->int2, req->offs, req->size, self); break;
1135
1136 case EIO_STAT: ALLOC (sizeof (EIO_STRUCT_STAT));
1137 req->result = stat (req->ptr1, (EIO_STRUCT_STAT *)req->ptr2); break;
1138 case EIO_LSTAT: ALLOC (sizeof (EIO_STRUCT_STAT));
1139 req->result = lstat (req->ptr1, (EIO_STRUCT_STAT *)req->ptr2); break;
1140 case EIO_FSTAT: ALLOC (sizeof (EIO_STRUCT_STAT));
1141 req->result = fstat (req->int1, (EIO_STRUCT_STAT *)req->ptr2); break;
1142
1143 case EIO_CHOWN: req->result = chown (req->ptr1, req->int2, req->int3); break;
1144 case EIO_FCHOWN: req->result = fchown (req->int1, req->int2, req->int3); break;
1145 case EIO_CHMOD: req->result = chmod (req->ptr1, (mode_t)req->int2); break;
1146 case EIO_FCHMOD: req->result = fchmod (req->int1, (mode_t)req->int2); break;
1147 case EIO_TRUNCATE: req->result = truncate (req->ptr1, req->offs); break;
1148 case EIO_FTRUNCATE: req->result = ftruncate (req->int1, req->offs); break;
1149
1150 case EIO_OPEN: req->result = open (req->ptr1, req->int1, (mode_t)req->int2); break;
1151 case EIO_CLOSE: req->result = close (req->int1); break;
1152 case EIO_DUP2: req->result = dup2 (req->int1, req->int2); break;
1153 case EIO_UNLINK: req->result = unlink (req->ptr1); break;
1154 case EIO_RMDIR: req->result = rmdir (req->ptr1); break;
1155 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;
1157 case EIO_LINK: req->result = link (req->ptr1, req->ptr2); break;
1158 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;
1160
1161 case EIO_READLINK: ALLOC (NAME_MAX);
1162 req->result = readlink (req->ptr1, req->ptr2, NAME_MAX); break;
1163
1164 case EIO_SYNC: req->result = 0; sync (); break;
1165 case EIO_FSYNC: req->result = fsync (req->int1); break;
1166 case EIO_FDATASYNC: req->result = fdatasync (req->int1); break;
1167
1168 case EIO_READDIR: eio__scandir (req, self); break;
1169
1170 case EIO_BUSY:
1171#ifdef _WIN32
1172 Sleep (req->nv1 * 1000.);
1173#else
1174 {
1175 struct timeval tv;
1176
1177 tv.tv_sec = req->nv1;
1178 tv.tv_usec = (req->nv1 - tv.tv_sec) * 1000000.;
1179
1180 req->result = select (0, 0, 0, 0, &tv);
1181 }
1182#endif
1183 break;
1184
1185 case EIO_UTIME:
1186 case EIO_FUTIME:
1187 {
1188 struct timeval tv[2];
1189 struct timeval *times;
1190
1191 if (req->nv1 != -1. || req->nv2 != -1.)
1192 {
1193 tv[0].tv_sec = req->nv1;
1194 tv[0].tv_usec = (req->nv1 - tv[0].tv_sec) * 1000000.;
1195 tv[1].tv_sec = req->nv2;
1196 tv[1].tv_usec = (req->nv2 - tv[1].tv_sec) * 1000000.;
1197
1198 times = tv;
1199 }
1200 else
1201 times = 0;
1202
1203
1204 req->result = req->type == EIO_FUTIME
1205 ? futimes (req->int1, times)
1206 : utimes (req->ptr1, times);
1207 }
1208
1209 case EIO_GROUP:
1210 case EIO_NOP:
1211 req->result = 0;
1212 break;
1213
1214 case EIO_CUSTOM:
1215 req->feed (req);
1216 break;
1217
1218 default:
1219 req->result = -1;
1220 break;
1221 }
1222
1223 req->errorno = errno;
1224}
1225
1213#ifndef EIO_NO_WRAPPERS 1226#ifndef EIO_NO_WRAPPERS
1214 1227
1215eio_req *eio_nop (int pri, eio_cb cb, void *data) 1228eio_req *eio_nop (int pri, eio_cb cb, void *data)
1216{ 1229{
1217 REQ (EIO_NOP); SEND; 1230 REQ (EIO_NOP); SEND;
… …
1392eio_req *eio_rename (const char *path, const char *new_path, int pri, eio_cb cb, void *data) 1405eio_req *eio_rename (const char *path, const char *new_path, int pri, eio_cb cb, void *data)
1393{ 1406{
1394 return eio__2path (EIO_RENAME, path, new_path, pri, cb, data); 1407 return eio__2path (EIO_RENAME, path, new_path, pri, cb, data);
1395} 1408}
1396 1409
1410eio_req *eio_custom (eio_cb execute, int pri, eio_cb cb, void *data)
1411{
1412 REQ (EIO_CUSTOM); req->feed = execute; SEND;
1413}
1414
1397#endif 1415#endif
1398 1416
1399eio_req *eio_grp (eio_cb cb, void *data) 1417eio_req *eio_grp (eio_cb cb, void *data)
1400{ 1418{
1401 const int pri = EIO_PRI_MAX; 1419 const int pri = EIO_PRI_MAX;

Diff Legend

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