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.15 by root, Sat May 17 12:26:57 2008 UTC vs.
Revision 1.22 by root, Fri Jul 11 10:54:50 2008 UTC

… …
177static mutex_t wrklock = X_MUTEX_INIT; 177static mutex_t wrklock = X_MUTEX_INIT;
178static mutex_t reslock = X_MUTEX_INIT; 178static mutex_t reslock = X_MUTEX_INIT;
179static mutex_t reqlock = X_MUTEX_INIT; 179static mutex_t reqlock = X_MUTEX_INIT;
180static cond_t reqwait = X_COND_INIT; 180static cond_t reqwait = X_COND_INIT;
181 181
182#if !HAVE_PREADWRITE
183/*
184 * make our pread/pwrite emulation safe against themselves, but not against
185 * normal read/write by using a mutex. slows down execution a lot,
186 * but that's your problem, not mine.
187 */
188static mutex_t preadwritelock = X_MUTEX_INIT;
189#endif
190
182typedef struct etp_worker 191typedef struct etp_worker
183{ 192{
184 /* locked by wrklock */ 193 /* locked by wrklock */
185 struct etp_worker *prev, *next; 194 struct etp_worker *prev, *next;
186 195
… …
314 X_LOCK (reqlock); 323 X_LOCK (reqlock);
315 X_LOCK (reslock); 324 X_LOCK (reslock);
316#if !HAVE_PREADWRITE 325#if !HAVE_PREADWRITE
317 X_LOCK (preadwritelock); 326 X_LOCK (preadwritelock);
318#endif 327#endif
319#if !HAVE_READDIR_R
320 X_LOCK (readdirlock);
321#endif
322} 328}
323 329
324static void etp_atfork_parent (void) 330static void etp_atfork_parent (void)
325{ 331{
326#if !HAVE_READDIR_R
327 X_UNLOCK (readdirlock);
328#endif
329#if !HAVE_PREADWRITE 332#if !HAVE_PREADWRITE
330 X_UNLOCK (preadwritelock); 333 X_UNLOCK (preadwritelock);
331#endif 334#endif
332 X_UNLOCK (reslock); 335 X_UNLOCK (reslock);
333 X_UNLOCK (reqlock); 336 X_UNLOCK (reqlock);
… …
336 339
337static void etp_atfork_child (void) 340static void etp_atfork_child (void)
338{ 341{
339 ETP_REQ *prv; 342 ETP_REQ *prv;
340 343
341 while (prv = reqq_shift (&req_queue)) 344 while ((prv = reqq_shift (&req_queue)))
342 ETP_DESTROY (prv); 345 ETP_DESTROY (prv);
343 346
344 while (prv = reqq_shift (&res_queue)) 347 while ((prv = reqq_shift (&res_queue)))
345 ETP_DESTROY (prv); 348 ETP_DESTROY (prv);
346 349
347 while (wrk_first.next != &wrk_first) 350 while (wrk_first.next != &wrk_first)
348 { 351 {
349 etp_worker *wrk = wrk_first.next; 352 etp_worker *wrk = wrk_first.next;
… …
377 380
378 pthread_once (&doinit, etp_once_init); 381 pthread_once (&doinit, etp_once_init);
379 382
380 want_poll_cb = want_poll; 383 want_poll_cb = want_poll;
381 done_poll_cb = done_poll; 384 done_poll_cb = done_poll;
385
386 return 0;
382} 387}
383 388
384X_THREAD_PROC (etp_proc); 389X_THREAD_PROC (etp_proc);
385 390
386static void etp_start_thread (void) 391static void etp_start_thread (void)
… …
704 709
705#if !HAVE_PREADWRITE 710#if !HAVE_PREADWRITE
706# define pread eio__pread 711# define pread eio__pread
707# define pwrite eio__pwrite 712# define pwrite eio__pwrite
708 713
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
716static ssize_t 714static ssize_t
717eio__pread (int fd, void *buf, size_t count, off_t offset) 715eio__pread (int fd, void *buf, size_t count, off_t offset)
718{ 716{
719 ssize_t res; 717 ssize_t res;
720 off_t ooffset; 718 off_t ooffset;
… …
781 779
782#if !HAVE_READAHEAD 780#if !HAVE_READAHEAD
783# define readahead(fd,offset,count) eio__readahead (fd, offset, count, self) 781# define readahead(fd,offset,count) eio__readahead (fd, offset, count, self)
784 782
785static ssize_t 783static ssize_t
786eio__readahead (int fd, off_t offset, size_t count, worker *self) 784eio__readahead (int fd, off_t offset, size_t count, etp_worker *self)
787{ 785{
788 size_t todo = count; 786 size_t todo = count;
789 dBUF; 787 dBUF;
790 788
791 while (todo > 0) 789 while (todo > 0)
… …
799 797
800 errno = 0; 798 errno = 0;
801 return count; 799 return count;
802} 800}
803 801
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 802#endif
836 803
837/* sendfile always needs emulation */ 804/* sendfile always needs emulation */
838static ssize_t 805static ssize_t
839eio__sendfile (int ofd, int ifd, off_t offset, size_t count, etp_worker *self) 806eio__sendfile (int ofd, int ifd, off_t offset, size_t count, etp_worker *self)
… …
931/* read a full directory */ 898/* read a full directory */
932static void 899static void
933eio__scandir (eio_req *req, etp_worker *self) 900eio__scandir (eio_req *req, etp_worker *self)
934{ 901{
935 DIR *dirp; 902 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; 903 EIO_STRUCT_DIRENT *entp;
942 char *name, *names; 904 char *name, *names;
943 int memlen = 4096; 905 int memlen = 4096;
944 int memofs = 0; 906 int memofs = 0;
945 int res = 0; 907 int res = 0;
946 908
947 X_LOCK (wrklock); 909 X_LOCK (wrklock);
910 /* the corresponding closedir is in ETP_WORKER_CLEAR */
948 self->dirp = dirp = opendir (req->ptr1); 911 self->dirp = dirp = opendir (req->ptr1);
949 self->dbuf = u = malloc (sizeof (*u));
950 req->flags |= EIO_FLAG_PTR2_FREE; 912 req->flags |= EIO_FLAG_PTR2_FREE;
951 req->ptr2 = names = malloc (memlen); 913 req->ptr2 = names = malloc (memlen);
952 X_UNLOCK (wrklock); 914 X_UNLOCK (wrklock);
953 915
954 if (dirp && u && names) 916 if (dirp && names)
955 for (;;) 917 for (;;)
956 { 918 {
957 errno = 0; 919 errno = 0;
958 readdir_r (dirp, &u->d, &entp); 920 entp = readdir (dirp);
959 921
960 if (!entp) 922 if (!entp)
961 break; 923 break;
962 924
963 name = entp->d_name; 925 name = entp->d_name;
… …
1082 1044
1083/*****************************************************************************/ 1045/*****************************************************************************/
1084 1046
1085int eio_init (void (*want_poll)(void), void (*done_poll)(void)) 1047int eio_init (void (*want_poll)(void), void (*done_poll)(void))
1086{ 1048{
1087 etp_init (want_poll, done_poll); 1049 return etp_init (want_poll, done_poll);
1088} 1050}
1089 1051
1090static void eio_api_destroy (eio_req *req) 1052static void eio_api_destroy (eio_req *req)
1091{ 1053{
1092 free (req); 1054 free (req);
… …
1154 case EIO_RMDIR: req->result = rmdir (req->ptr1); break; 1116 case EIO_RMDIR: req->result = rmdir (req->ptr1); break;
1155 case EIO_MKDIR: req->result = mkdir (req->ptr1, (mode_t)req->int2); break; 1117 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; 1118 case EIO_RENAME: req->result = rename (req->ptr1, req->ptr2); break;
1157 case EIO_LINK: req->result = link (req->ptr1, req->ptr2); break; 1119 case EIO_LINK: req->result = link (req->ptr1, req->ptr2); break;
1158 case EIO_SYMLINK: req->result = symlink (req->ptr1, req->ptr2); break; 1120 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; 1121 case EIO_MKNOD: req->result = mknod (req->ptr1, (mode_t)req->int2, (dev_t)req->int3); break;
1160 1122
1161 case EIO_READLINK: ALLOC (NAME_MAX); 1123 case EIO_READLINK: ALLOC (NAME_MAX);
1162 req->result = readlink (req->ptr1, req->ptr2, NAME_MAX); break; 1124 req->result = readlink (req->ptr1, req->ptr2, NAME_MAX); break;
1163 1125
1164 case EIO_SYNC: req->result = 0; sync (); break; 1126 case EIO_SYNC: req->result = 0; sync (); break;
… …
1371 return eio__1path (EIO_READDIR, path, pri, cb, data); 1333 return eio__1path (EIO_READDIR, path, pri, cb, data);
1372} 1334}
1373 1335
1374eio_req *eio_mknod (const char *path, mode_t mode, dev_t dev, int pri, eio_cb cb, void *data) 1336eio_req *eio_mknod (const char *path, mode_t mode, dev_t dev, int pri, eio_cb cb, void *data)
1375{ 1337{
1376 REQ (EIO_MKNOD); PATH; req->int2 = (long)mode; req->int2 = (long)dev; SEND; 1338 REQ (EIO_MKNOD); PATH; req->int2 = (long)mode; req->int3 = (long)dev; SEND;
1377} 1339}
1378 1340
1379static eio_req * 1341static eio_req *
1380eio__2path (int type, const char *path, const char *new_path, int pri, eio_cb cb, void *data) 1342eio__2path (int type, const char *path, const char *new_path, int pri, eio_cb cb, void *data)
1381{ 1343{

Diff Legend

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