ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/IO-AIO/AIO.xs
(Generate patch)

Comparing IO-AIO/AIO.xs (file contents):
Revision 1.36 by root, Tue Aug 23 01:18:04 2005 UTC vs.
Revision 1.37 by root, Tue Aug 23 12:37:19 2005 UTC

… …
7 7
8#include "autoconf/config.h" 8#include "autoconf/config.h"
9 9
10#include <pthread.h> 10#include <pthread.h>
11 11
12#include <stddef.h>
12#include <sys/types.h> 13#include <sys/types.h>
13#include <sys/stat.h> 14#include <sys/stat.h>
14 15#include <limits.h>
15#include <unistd.h> 16#include <unistd.h>
16#include <fcntl.h> 17#include <fcntl.h>
17#include <signal.h> 18#include <signal.h>
18#include <sched.h> 19#include <sched.h>
19 20
… …
33#endif 34#endif
34 35
35#if __ia64 36#if __ia64
36# define STACKSIZE 65536 37# define STACKSIZE 65536
37#else 38#else
38# define STACKSIZE 4096 39# define STACKSIZE 8192
39#endif 40#endif
40 41
41enum { 42enum {
42 REQ_QUIT, 43 REQ_QUIT,
43 REQ_OPEN, REQ_CLOSE, 44 REQ_OPEN, REQ_CLOSE,
44 REQ_READ, REQ_WRITE, REQ_READAHEAD, 45 REQ_READ, REQ_WRITE, REQ_READAHEAD,
45 REQ_SENDFILE, 46 REQ_SENDFILE,
46 REQ_STAT, REQ_LSTAT, REQ_FSTAT, 47 REQ_STAT, REQ_LSTAT, REQ_FSTAT,
47 REQ_FSYNC, REQ_FDATASYNC, 48 REQ_FSYNC, REQ_FDATASYNC,
48 REQ_UNLINK, REQ_RMDIR, 49 REQ_UNLINK, REQ_RMDIR,
50 REQ_READDIR,
49 REQ_SYMLINK, 51 REQ_SYMLINK,
50}; 52};
51 53
52typedef struct aio_cb { 54typedef struct aio_cb {
53 struct aio_cb *volatile next; 55 struct aio_cb *volatile next;
54 56
55 int type; 57 int type;
56 58
59 /* should receive a cleanup, with unions */
57 int fd, fd2; 60 int fd, fd2;
58 off_t offset; 61 off_t offset;
59 size_t length; 62 size_t length;
60 ssize_t result; 63 ssize_t result;
61 mode_t mode; /* open */ 64 mode_t mode; /* open */
… …
97 Safefree (req->statdata); 100 Safefree (req->statdata);
98 101
99 if (req->callback) 102 if (req->callback)
100 SvREFCNT_dec (req->callback); 103 SvREFCNT_dec (req->callback);
101 104
105 if (req->type == REQ_READDIR && req->result >= 0)
106 free (req->data2ptr);
107
102 Safefree (req); 108 Safefree (req);
103} 109}
104 110
105static void 111static void
106poll_wait () 112poll_wait ()
… …
170 PL_statcache = *(req->statdata); 176 PL_statcache = *(req->statdata);
171 } 177 }
172 178
173 ENTER; 179 ENTER;
174 PUSHMARK (SP); 180 PUSHMARK (SP);
175 XPUSHs (sv_2mortal (newSViv (req->result)));
176 181
177 if (req->type == REQ_OPEN) 182 if (req->type == REQ_READDIR)
178 { 183 {
184 SV *rv = &PL_sv_undef;
185
186 if (req->result >= 0)
187 {
188 char *buf = req->data2ptr;
189 AV *av = newAV ();
190
191 while (req->result)
192 {
193 SV *sv = newSVpv (buf, 0);
194
195 av_push (av, sv);
196 buf += SvCUR (sv) + 1;
197 req->result--;
198 }
199
200 rv = sv_2mortal (newRV_noinc ((SV *)av));
201 }
202
203 XPUSHs (rv);
204 }
205 else
206 {
207 XPUSHs (sv_2mortal (newSViv (req->result)));
208
209 if (req->type == REQ_OPEN)
210 {
179 /* convert fd to fh */ 211 /* convert fd to fh */
180 SV *fh; 212 SV *fh;
181 213
182 PUTBACK; 214 PUTBACK;
183 call_pv ("IO::AIO::_fd2fh", G_SCALAR | G_EVAL); 215 call_pv ("IO::AIO::_fd2fh", G_SCALAR | G_EVAL);
184 SPAGAIN; 216 SPAGAIN;
185 217
186 fh = SvREFCNT_inc (POPs); 218 fh = SvREFCNT_inc (POPs);
187 219
188 PUSHMARK (SP); 220 PUSHMARK (SP);
189 XPUSHs (sv_2mortal (fh)); 221 XPUSHs (sv_2mortal (fh));
222 }
190 } 223 }
191 224
192 if (SvOK (req->callback)) 225 if (SvOK (req->callback))
193 { 226 {
194 PUTBACK; 227 PUTBACK;
… …
317 350
318 if (fcntl (respipe [1], F_SETFL, O_NONBLOCK)) 351 if (fcntl (respipe [1], F_SETFL, O_NONBLOCK))
319 croak ("cannot set result pipe to nonblocking mode"); 352 croak ("cannot set result pipe to nonblocking mode");
320} 353}
321 354
322static void atfork_prepare (void)
323{
324 pthread_mutex_lock (&reqlock);
325 pthread_mutex_lock (&reslock);
326}
327
328static void atfork_parent (void)
329{
330 pthread_mutex_unlock (&reslock);
331 pthread_mutex_unlock (&reqlock);
332}
333
334static void atfork_child (void)
335{
336 aio_req prv;
337
338 started = 0;
339
340 while (reqs)
341 {
342 prv = reqs;
343 reqs = prv->next;
344 free_req (prv);
345 }
346
347 reqs = reqe = 0;
348
349 while (ress)
350 {
351 prv = ress;
352 ress = prv->next;
353 free_req (prv);
354 }
355
356 ress = rese = 0;
357
358 close (respipe [0]);
359 close (respipe [1]);
360 create_pipe ();
361
362 atfork_parent ();
363}
364
365/*****************************************************************************/ 355/*****************************************************************************/
366/* work around various missing functions */ 356/* work around various missing functions */
367 357
368#if !HAVE_PREADWRITE 358#if !HAVE_PREADWRITE
369# define pread aio_pread 359# define pread aio_pread
… …
372/* 362/*
373 * make our pread/pwrite safe against themselves, but not against 363 * make our pread/pwrite safe against themselves, but not against
374 * normal read/write by using a mutex. slows down execution a lot, 364 * normal read/write by using a mutex. slows down execution a lot,
375 * but that's your problem, not mine. 365 * but that's your problem, not mine.
376 */ 366 */
377static pthread_mutex_t iolock = PTHREAD_MUTEX_INITIALIZER; 367static pthread_mutex_t preadwritelock = PTHREAD_MUTEX_INITIALIZER;
378 368
379static ssize_t 369static ssize_t
380pread (int fd, void *buf, size_t count, off_t offset) 370pread (int fd, void *buf, size_t count, off_t offset)
381{ 371{
382 ssize_t res; 372 ssize_t res;
383 off_t ooffset; 373 off_t ooffset;
384 374
385 pthread_mutex_lock (&iolock); 375 pthread_mutex_lock (&preadwritelock);
386 ooffset = lseek (fd, 0, SEEK_CUR); 376 ooffset = lseek (fd, 0, SEEK_CUR);
387 lseek (fd, offset, SEEK_SET); 377 lseek (fd, offset, SEEK_SET);
388 res = read (fd, buf, count); 378 res = read (fd, buf, count);
389 lseek (fd, ooffset, SEEK_SET); 379 lseek (fd, ooffset, SEEK_SET);
390 pthread_mutex_unlock (&iolock); 380 pthread_mutex_unlock (&preadwritelock);
391 381
392 return res; 382 return res;
393} 383}
394 384
395static ssize_t 385static ssize_t
396pwrite (int fd, void *buf, size_t count, off_t offset) 386pwrite (int fd, void *buf, size_t count, off_t offset)
397{ 387{
398 ssize_t res; 388 ssize_t res;
399 off_t ooffset; 389 off_t ooffset;
400 390
401 pthread_mutex_lock (&iolock); 391 pthread_mutex_lock (&preadwritelock);
402 ooffset = lseek (fd, 0, SEEK_CUR); 392 ooffset = lseek (fd, 0, SEEK_CUR);
403 lseek (fd, offset, SEEK_SET); 393 lseek (fd, offset, SEEK_SET);
404 res = write (fd, buf, count); 394 res = write (fd, buf, count);
405 lseek (fd, offset, SEEK_SET); 395 lseek (fd, offset, SEEK_SET);
406 pthread_mutex_unlock (&iolock); 396 pthread_mutex_unlock (&preadwritelock);
407 397
408 return res; 398 return res;
409} 399}
410#endif 400#endif
411 401
… …
414#endif 404#endif
415 405
416#if !HAVE_READAHEAD 406#if !HAVE_READAHEAD
417# define readahead aio_readahead 407# define readahead aio_readahead
418 408
419static char readahead_buf[4096];
420
421static ssize_t 409static ssize_t
422readahead (int fd, off_t offset, size_t count) 410readahead (int fd, off_t offset, size_t count)
423{ 411{
412 char readahead_buf[4096];
413
424 while (count > 0) 414 while (count > 0)
425 { 415 {
426 size_t len = count < sizeof (readahead_buf) ? count : sizeof (readahead_buf); 416 size_t len = count < sizeof (readahead_buf) ? count : sizeof (readahead_buf);
427 417
428 pread (fd, readahead_buf, len, offset); 418 pread (fd, readahead_buf, len, offset);
… …
432 422
433 errno = 0; 423 errno = 0;
434} 424}
435#endif 425#endif
436 426
427#if !HAVE_READDIR_R
428# define readdir_r aio_readdir_r
429
430static pthread_mutex_t readdirlock = PTHREAD_MUTEX_INITIALIZER;
431
432static int
433readdir_r (DIR *dirp, struct dirent *ent, struct dirent **res)
434{
435 struct dirent *e;
436 int errorno;
437
438 pthread_mutex_lock (&readdirlock);
439
440 e = readdir (dirp);
441 errorno = errno;
442
443 if (e)
444 {
445 *res = ent;
446 strcpy (ent->d_name, e->d_name);
447 }
448 else
449 *res = 0;
450
451 pthread_mutex_unlock (&readdirlock);
452
453 errno = errorno;
454 return e ? 0 : -1;
455}
456#endif
457
437/* sendfile always needs emulation */ 458/* sendfile always needs emulation */
438static ssize_t 459static ssize_t
439sendfile_ (int ofd, int ifd, off_t offset, size_t count) 460sendfile_ (int ofd, int ifd, off_t offset, size_t count)
440{ 461{
441 ssize_t res; 462 ssize_t res;
442 463
443 if (!count) 464 if (!count)
444 return 0; 465 return 0;
445 466
446#if HAVE_SENDFILE 467#if HAVE_SENDFILE
447# if __linux 468# if __linux
448 res = sendfile (ofd, ifd, &offset, count); 469 res = sendfile (ofd, ifd, &offset, count);
449 470
450# elif __freebsd 471# elif __freebsd
451 /* 472 /*
452 * Of course, the freebsd sendfile is a dire hack with no thoughts 473 * Of course, the freebsd sendfile is a dire hack with no thoughts
453 * wasted on making it similar to other I/O functions. 474 * wasted on making it similar to other I/O functions.
454 */ 475 */
455 { 476 {
456 off_t sbytes; 477 off_t sbytes;
457 res = sendfile (ifd, ofd, offset, count, 0, &sbytes, 0); 478 res = sendfile (ifd, ofd, offset, count, 0, &sbytes, 0);
458 479
459 if (res < 0 && sbytes) 480 if (res < 0 && sbytes)
460 /* maybe only on EAGAIN only: as usual, the manpage leaves you guessing */ 481 /* maybe only on EAGAIN only: as usual, the manpage leaves you guessing */
461 res = sbytes; 482 res = sbytes;
462 } 483 }
463 484
464# elif __hpux 485# elif __hpux
465 res = sendfile (ofd, ifd, offset, count, 0, 0); 486 res = sendfile (ofd, ifd, offset, count, 0, 0);
466 487
467# elif __solaris 488# elif __solaris
468 { 489 {
469 struct sendfilevec vec; 490 struct sendfilevec vec;
470 size_t sbytes; 491 size_t sbytes;
471 492
472 vec.sfv_fd = ifd; 493 vec.sfv_fd = ifd;
473 vec.sfv_flag = 0; 494 vec.sfv_flag = 0;
474 vec.sfv_off = offset; 495 vec.sfv_off = offset;
475 vec.sfv_len = count; 496 vec.sfv_len = count;
476 497
477 res = sendfilev (ofd, &vec, 1, &sbytes); 498 res = sendfilev (ofd, &vec, 1, &sbytes);
478 499
479 if (res < 0 && sbytes) 500 if (res < 0 && sbytes)
480 res = sbytes; 501 res = sbytes;
481 } 502 }
482 503
483# else 504# else
484 res = -1; 505 res = -1;
485 errno = ENOSYS; 506 errno = ENOSYS;
486# endif 507# endif
487#endif 508#endif
488 509
489 if (res < 0 510 if (res < 0
490 && (errno == ENOSYS || errno == EINVAL || errno == ENOTSOCK 511 && (errno == ENOSYS || errno == EINVAL || errno == ENOTSOCK
491#if __solaris 512#if __solaris
492 || errno == EAFNOSUPPORT || errno == EPROTOTYPE 513 || errno == EAFNOSUPPORT || errno == EPROTOTYPE
493#endif 514#endif
494 ) 515 )
495 ) 516 )
496 { 517 {
497 /* emulate sendfile. this is a major pain in the ass */ 518 /* emulate sendfile. this is a major pain in the ass */
498 char *buf = malloc (4096); 519 char buf[4096];
499 res = 0; 520 res = 0;
500 521
501 for (;;) 522 for (;;)
502 { 523 {
503 ssize_t cnt; 524 ssize_t cnt;
504 525
505 cnt = pread (ifd, buf, 4096, offset); 526 cnt = pread (ifd, buf, 4096, offset);
506 527
507 if (cnt <= 0) 528 if (cnt <= 0)
508 { 529 {
509 if (cnt && !res) res = -1; 530 if (cnt && !res) res = -1;
510 break; 531 break;
511 } 532 }
512 533
513 cnt = write (ofd, buf, cnt); 534 cnt = write (ofd, buf, cnt);
514 535
515 if (cnt <= 0) 536 if (cnt <= 0)
516 { 537 {
517 if (cnt && !res) res = -1; 538 if (cnt && !res) res = -1;
518 break; 539 break;
519 } 540 }
520 541
521 offset += cnt; 542 offset += cnt;
522 res += cnt; 543 res += cnt;
523 } 544 }
524
525 {
526 int errorno = errno;
527 free (buf);
528 errno = errorno;
529 }
530 } 545 }
531 546
532 return res; 547 return res;
548}
549
550/* read a full directory */
551static int
552scandir_ (const char *path, void **namesp)
553{
554 DIR *dirp = opendir (path);
555 union
556 {
557 struct dirent d;
558 char b [offsetof (struct dirent, d_name) + NAME_MAX + 1];
559 } u;
560 struct dirent *entp;
561 char *name, *names;
562 int memlen = 4096;
563 int memofs = 0;
564 int res = 0;
565 int errorno;
566
567 if (!dirp)
568 return -1;
569
570 names = malloc (memlen);
571
572 for (;;)
573 {
574 errno = 0, readdir_r (dirp, &u.d, &entp);
575
576 if (!entp)
577 break;
578
579 name = entp->d_name;
580
581 if (name [0] != '.' || (name [1] && (name [1] != '.' || name [2])))
582 {
583 int len = strlen (name) + 1;
584
585 res++;
586
587 while (memofs + len > memlen)
588 {
589 memlen *= 2;
590 names = realloc (names, memlen);
591 if (!names)
592 break;
593 }
594
595 memcpy (names + memofs, name, len);
596 memofs += len;
597 }
598 }
599
600 errorno = errno;
601 closedir (dirp);
602
603 if (errorno)
604 {
605 free (names);
606 errno = errorno;
607 res = -1;
608 }
609
610 *namesp = (void *)names;
611 return res;
533} 612}
534 613
535/*****************************************************************************/ 614/*****************************************************************************/
536 615
537static void * 616static void *
… …
584 case REQ_RMDIR: req->result = rmdir (req->dataptr); break; 663 case REQ_RMDIR: req->result = rmdir (req->dataptr); break;
585 case REQ_SYMLINK: req->result = symlink (req->data2ptr, req->dataptr); break; 664 case REQ_SYMLINK: req->result = symlink (req->data2ptr, req->dataptr); break;
586 665
587 case REQ_FDATASYNC: req->result = fdatasync (req->fd); break; 666 case REQ_FDATASYNC: req->result = fdatasync (req->fd); break;
588 case REQ_FSYNC: req->result = fsync (req->fd); break; 667 case REQ_FSYNC: req->result = fsync (req->fd); break;
668 case REQ_READDIR: req->result = scandir_ (req->dataptr, &req->data2ptr); break;
589 669
590 case REQ_QUIT: 670 case REQ_QUIT:
591 break; 671 break;
592 672
593 default: 673 default:
… …
617 pthread_mutex_unlock (&reslock); 697 pthread_mutex_unlock (&reslock);
618 } 698 }
619 while (type != REQ_QUIT); 699 while (type != REQ_QUIT);
620 700
621 return 0; 701 return 0;
702}
703
704/*****************************************************************************/
705
706static void atfork_prepare (void)
707{
708 pthread_mutex_lock (&reqlock);
709 pthread_mutex_lock (&reslock);
710#if !HAVE_PREADWRITE
711 pthread_mutex_lock (&preadwritelock);
712#endif
713#if !HAVE_READDIR_R
714 pthread_mutex_lock (&readdirlock);
715#endif
716}
717
718static void atfork_parent (void)
719{
720#if !HAVE_READDIR_R
721 pthread_mutex_unlock (&readdirlock);
722#endif
723#if !HAVE_PREADWRITE
724 pthread_mutex_unlock (&preadwritelock);
725#endif
726 pthread_mutex_unlock (&reslock);
727 pthread_mutex_unlock (&reqlock);
728}
729
730static void atfork_child (void)
731{
732 aio_req prv;
733
734 started = 0;
735
736 while (reqs)
737 {
738 prv = reqs;
739 reqs = prv->next;
740 free_req (prv);
741 }
742
743 reqs = reqe = 0;
744
745 while (ress)
746 {
747 prv = ress;
748 ress = prv->next;
749 free_req (prv);
750 }
751
752 ress = rese = 0;
753
754 close (respipe [0]);
755 close (respipe [1]);
756 create_pipe ();
757
758 atfork_parent ();
622} 759}
623 760
624#define dREQ \ 761#define dREQ \
625 aio_req req; \ 762 aio_req req; \
626 \ 763 \
… …
877 1014
878 send_req (req); 1015 send_req (req);
879} 1016}
880 1017
881void 1018void
1019aio_readdir(pathname,callback=&PL_sv_undef)
1020 SV * pathname
1021 SV * callback
1022 CODE:
1023{
1024 dREQ;
1025
1026 req->type = REQ_READDIR;
1027 req->data = newSVsv (pathname);
1028 req->dataptr = SvPVbyte_nolen (req->data);
1029
1030 send_req (req);
1031}
1032
1033void
882flush() 1034flush()
883 PROTOTYPE: 1035 PROTOTYPE:
884 CODE: 1036 CODE:
885 while (nreqs) 1037 while (nreqs)
886 { 1038 {

Diff Legend

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