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.21 by root, Sat Jun 21 00:13:13 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); \
… …
310 X_LOCK (reqlock); 314 X_LOCK (reqlock);
311 X_LOCK (reslock); 315 X_LOCK (reslock);
312#if !HAVE_PREADWRITE 316#if !HAVE_PREADWRITE
313 X_LOCK (preadwritelock); 317 X_LOCK (preadwritelock);
314#endif 318#endif
315#if !HAVE_READDIR_R
316 X_LOCK (readdirlock);
317#endif
318} 319}
319 320
320static void etp_atfork_parent (void) 321static void etp_atfork_parent (void)
321{ 322{
322#if !HAVE_READDIR_R
323 X_UNLOCK (readdirlock);
324#endif
325#if !HAVE_PREADWRITE 323#if !HAVE_PREADWRITE
326 X_UNLOCK (preadwritelock); 324 X_UNLOCK (preadwritelock);
327#endif 325#endif
328 X_UNLOCK (reslock); 326 X_UNLOCK (reslock);
329 X_UNLOCK (reqlock); 327 X_UNLOCK (reqlock);
… …
332 330
333static void etp_atfork_child (void) 331static void etp_atfork_child (void)
334{ 332{
335 ETP_REQ *prv; 333 ETP_REQ *prv;
336 334
337 while (prv = reqq_shift (&req_queue)) 335 while ((prv = reqq_shift (&req_queue)))
338 ETP_DESTROY (prv); 336 ETP_DESTROY (prv);
339 337
340 while (prv = reqq_shift (&res_queue)) 338 while ((prv = reqq_shift (&res_queue)))
341 ETP_DESTROY (prv); 339 ETP_DESTROY (prv);
342 340
343 while (wrk_first.next != &wrk_first) 341 while (wrk_first.next != &wrk_first)
344 { 342 {
345 etp_worker *wrk = wrk_first.next; 343 etp_worker *wrk = wrk_first.next;
… …
373 371
374 pthread_once (&doinit, etp_once_init); 372 pthread_once (&doinit, etp_once_init);
375 373
376 want_poll_cb = want_poll; 374 want_poll_cb = want_poll;
377 done_poll_cb = done_poll; 375 done_poll_cb = done_poll;
376
377 return 0;
378} 378}
379 379
380X_THREAD_PROC (etp_proc); 380X_THREAD_PROC (etp_proc);
381 381
382static void etp_start_thread (void) 382static void etp_start_thread (void)
… …
777 777
778#if !HAVE_READAHEAD 778#if !HAVE_READAHEAD
779# define readahead(fd,offset,count) eio__readahead (fd, offset, count, self) 779# define readahead(fd,offset,count) eio__readahead (fd, offset, count, self)
780 780
781static ssize_t 781static ssize_t
782eio__readahead (int fd, off_t offset, size_t count, worker *self) 782eio__readahead (int fd, off_t offset, size_t count, etp_worker *self)
783{ 783{
784 size_t todo = count; 784 size_t todo = count;
785 dBUF; 785 dBUF;
786 786
787 while (todo > 0) 787 while (todo > 0)
… …
795 795
796 errno = 0; 796 errno = 0;
797 return count; 797 return count;
798} 798}
799 799
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 800#endif
832 801
833/* sendfile always needs emulation */ 802/* sendfile always needs emulation */
834static ssize_t 803static ssize_t
835eio__sendfile (int ofd, int ifd, off_t offset, size_t count, etp_worker *self) 804eio__sendfile (int ofd, int ifd, off_t offset, size_t count, etp_worker *self)
… …
927/* read a full directory */ 896/* read a full directory */
928static void 897static void
929eio__scandir (eio_req *req, etp_worker *self) 898eio__scandir (eio_req *req, etp_worker *self)
930{ 899{
931 DIR *dirp; 900 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; 901 EIO_STRUCT_DIRENT *entp;
938 char *name, *names; 902 char *name, *names;
939 int memlen = 4096; 903 int memlen = 4096;
940 int memofs = 0; 904 int memofs = 0;
941 int res = 0; 905 int res = 0;
942 906
943 X_LOCK (wrklock); 907 X_LOCK (wrklock);
908 /* the corresponding closedir is in ETP_WORKER_CLEAR */
944 self->dirp = dirp = opendir (req->ptr1); 909 self->dirp = dirp = opendir (req->ptr1);
945 self->dbuf = u = malloc (sizeof (*u));
946 req->flags |= EIO_FLAG_PTR2_FREE; 910 req->flags |= EIO_FLAG_PTR2_FREE;
947 req->ptr2 = names = malloc (memlen); 911 req->ptr2 = names = malloc (memlen);
948 X_UNLOCK (wrklock); 912 X_UNLOCK (wrklock);
949 913
950 if (dirp && u && names) 914 if (dirp && names)
951 for (;;) 915 for (;;)
952 { 916 {
953 errno = 0; 917 errno = 0;
954 readdir_r (dirp, &u->d, &entp); 918 entp = readdir (dirp);
955 919
956 if (!entp) 920 if (!entp)
957 break; 921 break;
958 922
959 name = entp->d_name; 923 name = entp->d_name;
… …
1047 1011
1048 --nready; 1012 --nready;
1049 1013
1050 X_UNLOCK (reqlock); 1014 X_UNLOCK (reqlock);
1051 1015
1052 errno = 0; /* strictly unnecessary */ 1016 if (req->type < 0)
1017 goto quit;
1053 1018
1054 if (!EIO_CANCELLED (req)) 1019 if (!EIO_CANCELLED (req))
1055 switch (req->type) 1020 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 1021
1156 X_LOCK (reslock); 1022 X_LOCK (reslock);
1157 1023
1158 ++npending; 1024 ++npending;
1159 1025
… …
1176 1042
1177/*****************************************************************************/ 1043/*****************************************************************************/
1178 1044
1179int eio_init (void (*want_poll)(void), void (*done_poll)(void)) 1045int eio_init (void (*want_poll)(void), void (*done_poll)(void))
1180{ 1046{
1181 etp_init (want_poll, done_poll); 1047 return etp_init (want_poll, done_poll);
1182} 1048}
1183 1049
1184static void eio_api_destroy (eio_req *req) 1050static void eio_api_destroy (eio_req *req)
1185{ 1051{
1186 free (req); 1052 free (req);
… …
1208 { \ 1074 { \
1209 eio_api_destroy (req); \ 1075 eio_api_destroy (req); \
1210 return 0; \ 1076 return 0; \
1211 } 1077 }
1212 1078
1079static void eio_execute (etp_worker *self, eio_req *req)
1080{
1081 errno = 0;
1082
1083 switch (req->type)
1084 {
1085 case EIO_READ: ALLOC (req->size);
1086 req->result = req->offs >= 0
1087 ? pread (req->int1, req->ptr2, req->size, req->offs)
1088 : read (req->int1, req->ptr2, req->size); break;
1089 case EIO_WRITE: req->result = req->offs >= 0
1090 ? pwrite (req->int1, req->ptr2, req->size, req->offs)
1091 : write (req->int1, req->ptr2, req->size); break;
1092
1093 case EIO_READAHEAD: req->result = readahead (req->int1, req->offs, req->size); break;
1094 case EIO_SENDFILE: req->result = eio__sendfile (req->int1, req->int2, req->offs, req->size, self); break;
1095
1096 case EIO_STAT: ALLOC (sizeof (EIO_STRUCT_STAT));
1097 req->result = stat (req->ptr1, (EIO_STRUCT_STAT *)req->ptr2); break;
1098 case EIO_LSTAT: ALLOC (sizeof (EIO_STRUCT_STAT));
1099 req->result = lstat (req->ptr1, (EIO_STRUCT_STAT *)req->ptr2); break;
1100 case EIO_FSTAT: ALLOC (sizeof (EIO_STRUCT_STAT));
1101 req->result = fstat (req->int1, (EIO_STRUCT_STAT *)req->ptr2); break;
1102
1103 case EIO_CHOWN: req->result = chown (req->ptr1, req->int2, req->int3); break;
1104 case EIO_FCHOWN: req->result = fchown (req->int1, req->int2, req->int3); break;
1105 case EIO_CHMOD: req->result = chmod (req->ptr1, (mode_t)req->int2); break;
1106 case EIO_FCHMOD: req->result = fchmod (req->int1, (mode_t)req->int2); break;
1107 case EIO_TRUNCATE: req->result = truncate (req->ptr1, req->offs); break;
1108 case EIO_FTRUNCATE: req->result = ftruncate (req->int1, req->offs); break;
1109
1110 case EIO_OPEN: req->result = open (req->ptr1, req->int1, (mode_t)req->int2); break;
1111 case EIO_CLOSE: req->result = close (req->int1); break;
1112 case EIO_DUP2: req->result = dup2 (req->int1, req->int2); break;
1113 case EIO_UNLINK: req->result = unlink (req->ptr1); break;
1114 case EIO_RMDIR: req->result = rmdir (req->ptr1); break;
1115 case EIO_MKDIR: req->result = mkdir (req->ptr1, (mode_t)req->int2); break;
1116 case EIO_RENAME: req->result = rename (req->ptr1, req->ptr2); break;
1117 case EIO_LINK: req->result = link (req->ptr1, req->ptr2); break;
1118 case EIO_SYMLINK: req->result = symlink (req->ptr1, req->ptr2); break;
1119 case EIO_MKNOD: req->result = mknod (req->ptr1, (mode_t)req->int2, (dev_t)req->int3); break;
1120
1121 case EIO_READLINK: ALLOC (NAME_MAX);
1122 req->result = readlink (req->ptr1, req->ptr2, NAME_MAX); break;
1123
1124 case EIO_SYNC: req->result = 0; sync (); break;
1125 case EIO_FSYNC: req->result = fsync (req->int1); break;
1126 case EIO_FDATASYNC: req->result = fdatasync (req->int1); break;
1127
1128 case EIO_READDIR: eio__scandir (req, self); break;
1129
1130 case EIO_BUSY:
1131#ifdef _WIN32
1132 Sleep (req->nv1 * 1000.);
1133#else
1134 {
1135 struct timeval tv;
1136
1137 tv.tv_sec = req->nv1;
1138 tv.tv_usec = (req->nv1 - tv.tv_sec) * 1000000.;
1139
1140 req->result = select (0, 0, 0, 0, &tv);
1141 }
1142#endif
1143 break;
1144
1145 case EIO_UTIME:
1146 case EIO_FUTIME:
1147 {
1148 struct timeval tv[2];
1149 struct timeval *times;
1150
1151 if (req->nv1 != -1. || req->nv2 != -1.)
1152 {
1153 tv[0].tv_sec = req->nv1;
1154 tv[0].tv_usec = (req->nv1 - tv[0].tv_sec) * 1000000.;
1155 tv[1].tv_sec = req->nv2;
1156 tv[1].tv_usec = (req->nv2 - tv[1].tv_sec) * 1000000.;
1157
1158 times = tv;
1159 }
1160 else
1161 times = 0;
1162
1163
1164 req->result = req->type == EIO_FUTIME
1165 ? futimes (req->int1, times)
1166 : utimes (req->ptr1, times);
1167 }
1168
1169 case EIO_GROUP:
1170 case EIO_NOP:
1171 req->result = 0;
1172 break;
1173
1174 case EIO_CUSTOM:
1175 req->feed (req);
1176 break;
1177
1178 default:
1179 req->result = -1;
1180 break;
1181 }
1182
1183 req->errorno = errno;
1184}
1185
1213#ifndef EIO_NO_WRAPPERS 1186#ifndef EIO_NO_WRAPPERS
1214 1187
1215eio_req *eio_nop (int pri, eio_cb cb, void *data) 1188eio_req *eio_nop (int pri, eio_cb cb, void *data)
1216{ 1189{
1217 REQ (EIO_NOP); SEND; 1190 REQ (EIO_NOP); SEND;
… …
1358 return eio__1path (EIO_READDIR, path, pri, cb, data); 1331 return eio__1path (EIO_READDIR, path, pri, cb, data);
1359} 1332}
1360 1333
1361eio_req *eio_mknod (const char *path, mode_t mode, dev_t dev, int pri, eio_cb cb, void *data) 1334eio_req *eio_mknod (const char *path, mode_t mode, dev_t dev, int pri, eio_cb cb, void *data)
1362{ 1335{
1363 REQ (EIO_MKNOD); PATH; req->int2 = (long)mode; req->int2 = (long)dev; SEND; 1336 REQ (EIO_MKNOD); PATH; req->int2 = (long)mode; req->int3 = (long)dev; SEND;
1364} 1337}
1365 1338
1366static eio_req * 1339static eio_req *
1367eio__2path (int type, const char *path, const char *new_path, int pri, eio_cb cb, void *data) 1340eio__2path (int type, const char *path, const char *new_path, int pri, eio_cb cb, void *data)
1368{ 1341{
… …
1392eio_req *eio_rename (const char *path, const char *new_path, int pri, eio_cb cb, void *data) 1365eio_req *eio_rename (const char *path, const char *new_path, int pri, eio_cb cb, void *data)
1393{ 1366{
1394 return eio__2path (EIO_RENAME, path, new_path, pri, cb, data); 1367 return eio__2path (EIO_RENAME, path, new_path, pri, cb, data);
1395} 1368}
1396 1369
1370eio_req *eio_custom (eio_cb execute, int pri, eio_cb cb, void *data)
1371{
1372 REQ (EIO_CUSTOM); req->feed = execute; SEND;
1373}
1374
1397#endif 1375#endif
1398 1376
1399eio_req *eio_grp (eio_cb cb, void *data) 1377eio_req *eio_grp (eio_cb cb, void *data)
1400{ 1378{
1401 const int pri = EIO_PRI_MAX; 1379 const int pri = EIO_PRI_MAX;

Diff Legend

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