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.98 by root, Wed May 9 06:45:12 2007 UTC vs.
Revision 1.106 by root, Mon Sep 24 18:14:00 2007 UTC

… …
4 4
5#include "EXTERN.h" 5#include "EXTERN.h"
6#include "perl.h" 6#include "perl.h"
7#include "XSUB.h" 7#include "XSUB.h"
8 8
9#include "autoconf/config.h"
10
11#include <stddef.h> 9#include <stddef.h>
12#include <stdlib.h> 10#include <stdlib.h>
13#include <errno.h> 11#include <errno.h>
14#include <sys/time.h>
15#include <sys/select.h>
16#include <sys/types.h> 12#include <sys/types.h>
17#include <sys/stat.h> 13#include <sys/stat.h>
18#include <limits.h> 14#include <limits.h>
19#include <unistd.h>
20#include <fcntl.h> 15#include <fcntl.h>
21#include <signal.h>
22#include <sched.h> 16#include <sched.h>
17
18#ifdef _WIN32
19
20# define SIGIO 0
21 typedef Direntry_t X_DIRENT;
22#undef malloc
23#undef free
24
25// perl overrides all those nice win32 functions
26# undef open
27# undef read
28# undef write
29# undef send
30# undef recv
31# undef stat
32# undef fstat
33# define lstat stat
34# undef truncate
35# undef ftruncate
36# undef open
37# undef close
38# undef unlink
39# undef rmdir
40# undef rename
41# undef lseek
42
43# define chown(a,b,c) (errno = ENOSYS, -1)
44# define fchown(a,b,c) (errno = ENOSYS, -1)
45# define fchmod(a,b) (errno = ENOSYS, -1)
46# define symlink(a,b) (errno = ENOSYS, -1)
47# define readlink(a,b,c) (errno = ENOSYS, -1)
48# define mknod(a,b,c) (errno = ENOSYS, -1)
49# define truncate(a,b) (errno = ENOSYS, -1)
50# define ftruncate(fd,o) chsize ((fd), (o))
51# define fsync(fd) _commit (fd)
52# define opendir(fd) (errno = ENOSYS, 0)
53# define readdir(fd) (errno = ENOSYS, -1)
54# define closedir(fd) (errno = ENOSYS, -1)
55# define mkdir(a,b) mkdir (a)
56
57#else
58
59# include "autoconf/config.h"
60# include <sys/time.h>
61# include <sys/select.h>
62# include <unistd.h>
63# include <utime.h>
64# include <signal.h>
65 typedef struct dirent X_DIRENT;
66
67#endif
23 68
24#if HAVE_SENDFILE 69#if HAVE_SENDFILE
25# if __linux 70# if __linux
26# include <sys/sendfile.h> 71# include <sys/sendfile.h>
27# elif __freebsd 72# elif __freebsd
… …
45#endif 90#endif
46 91
47/* buffer size for various temporary buffers */ 92/* buffer size for various temporary buffers */
48#define AIO_BUFSIZE 65536 93#define AIO_BUFSIZE 65536
49 94
95/* use NV for 32 bit perls as it allows larger offsets */
96#if IVSIZE >= 8
97# define SvVAL64 SvIV
98#else
99# define SvVAL64 SvNV
100#endif
101
50#define dBUF \ 102#define dBUF \
51 char *aio_buf; \ 103 char *aio_buf; \
52 LOCK (wrklock); \ 104 X_LOCK (wrklock); \
53 self->dbuf = aio_buf = malloc (AIO_BUFSIZE); \ 105 self->dbuf = aio_buf = malloc (AIO_BUFSIZE); \
54 UNLOCK (wrklock); \ 106 X_UNLOCK (wrklock); \
55 if (!aio_buf) \ 107 if (!aio_buf) \
56 return -1; 108 return -1;
57 109
58typedef SV SV8; /* byte-sv, used for argument-checking */ 110typedef SV SV8; /* byte-sv, used for argument-checking */
59 111
60enum { 112enum {
61 REQ_QUIT, 113 REQ_QUIT,
62 REQ_OPEN, REQ_CLOSE, 114 REQ_OPEN, REQ_CLOSE,
63 REQ_READ, REQ_WRITE, REQ_READAHEAD, 115 REQ_READ, REQ_WRITE,
64 REQ_SENDFILE, 116 REQ_READAHEAD, REQ_SENDFILE,
65 REQ_STAT, REQ_LSTAT, REQ_FSTAT, 117 REQ_STAT, REQ_LSTAT, REQ_FSTAT,
118 REQ_TRUNCATE, REQ_FTRUNCATE,
119 REQ_UTIME, REQ_FUTIME,
120 REQ_CHMOD, REQ_FCHMOD,
121 REQ_CHOWN, REQ_FCHOWN,
66 REQ_FSYNC, REQ_FDATASYNC, 122 REQ_FSYNC, REQ_FDATASYNC,
67 REQ_UNLINK, REQ_RMDIR, REQ_MKDIR, REQ_RENAME, 123 REQ_UNLINK, REQ_RMDIR, REQ_MKDIR, REQ_RENAME,
68 REQ_MKNOD, REQ_READDIR, 124 REQ_MKNOD, REQ_READDIR,
69 REQ_LINK, REQ_SYMLINK, REQ_READLINK, 125 REQ_LINK, REQ_SYMLINK, REQ_READLINK,
70 REQ_GROUP, REQ_NOP, 126 REQ_GROUP, REQ_NOP,
… …
76 132
77typedef struct aio_cb 133typedef struct aio_cb
78{ 134{
79 struct aio_cb *volatile next; 135 struct aio_cb *volatile next;
80 136
81 SV *callback, *fh; 137 SV *callback;
82 SV *sv1, *sv2; 138 SV *sv1, *sv2;
83 void *ptr1, *ptr2; 139 void *ptr1, *ptr2;
84 off_t offs; 140 off_t offs;
85 size_t size; 141 size_t size;
86 ssize_t result; 142 ssize_t result;
143 double nv1, nv2;
87 144
88 STRLEN stroffset; 145 STRLEN stroffset;
89 int type; 146 int type;
90 int int1, int2; 147 int int1, int2, int3;
91 int errorno; 148 int errorno;
92 mode_t mode; /* open */ 149 mode_t mode; /* open */
93 150
94 unsigned char flags; 151 unsigned char flags;
95 unsigned char pri; 152 unsigned char pri;
… …
98 struct aio_cb *grp, *grp_prev, *grp_next, *grp_first; 155 struct aio_cb *grp, *grp_prev, *grp_next, *grp_first;
99} aio_cb; 156} aio_cb;
100 157
101enum { 158enum {
102 FLAG_CANCELLED = 0x01, /* request was cancelled */ 159 FLAG_CANCELLED = 0x01, /* request was cancelled */
103 FLAG_SV1_RO_OFF = 0x40, /* data was set readonly */ 160 FLAG_SV2_RO_OFF = 0x40, /* data was set readonly */
104 FLAG_PTR2_FREE = 0x80, /* need to free(ptr2) */ 161 FLAG_PTR2_FREE = 0x80, /* need to free(ptr2) */
105}; 162};
106 163
107typedef aio_cb *aio_req; 164typedef aio_cb *aio_req;
108typedef aio_cb *aio_req_ornot; 165typedef aio_cb *aio_req_ornot;
… …
165static int next_pri = DEFAULT_PRI + PRI_BIAS; 222static int next_pri = DEFAULT_PRI + PRI_BIAS;
166 223
167static unsigned int started, idle, wanted; 224static unsigned int started, idle, wanted;
168 225
169/* worker threads management */ 226/* worker threads management */
170static mutex_t wrklock = MUTEX_INIT; 227static mutex_t wrklock = X_MUTEX_INIT;
171 228
172typedef struct worker { 229typedef struct worker {
173 /* locked by wrklock */ 230 /* locked by wrklock */
174 struct worker *prev, *next; 231 struct worker *prev, *next;
175 232
… …
207} 264}
208 265
209static volatile unsigned int nreqs, nready, npending; 266static volatile unsigned int nreqs, nready, npending;
210static volatile unsigned int max_idle = 4; 267static volatile unsigned int max_idle = 4;
211static volatile unsigned int max_outstanding = 0xffffffff; 268static volatile unsigned int max_outstanding = 0xffffffff;
212static int respipe [2]; 269static int respipe_osf [2], respipe [2] = { -1, -1 };
213 270
214static mutex_t reslock = MUTEX_INIT; 271static mutex_t reslock = X_MUTEX_INIT;
215static mutex_t reqlock = MUTEX_INIT; 272static mutex_t reqlock = X_MUTEX_INIT;
216static cond_t reqwait = COND_INIT; 273static cond_t reqwait = X_COND_INIT;
217 274
218#if WORDACCESS_UNSAFE 275#if WORDACCESS_UNSAFE
219 276
220static unsigned int get_nready () 277static unsigned int get_nready ()
221{ 278{
222 unsigned int retval; 279 unsigned int retval;
223 280
224 LOCK (reqlock); 281 X_LOCK (reqlock);
225 retval = nready; 282 retval = nready;
226 UNLOCK (reqlock); 283 X_UNLOCK (reqlock);
227 284
228 return retval; 285 return retval;
229} 286}
230 287
231static unsigned int get_npending () 288static unsigned int get_npending ()
232{ 289{
233 unsigned int retval; 290 unsigned int retval;
234 291
235 LOCK (reslock); 292 X_LOCK (reslock);
236 retval = npending; 293 retval = npending;
237 UNLOCK (reslock); 294 X_UNLOCK (reslock);
238 295
239 return retval; 296 return retval;
240} 297}
241 298
242static unsigned int get_nthreads () 299static unsigned int get_nthreads ()
243{ 300{
244 unsigned int retval; 301 unsigned int retval;
245 302
246 LOCK (wrklock); 303 X_LOCK (wrklock);
247 retval = started; 304 retval = started;
248 UNLOCK (wrklock); 305 X_UNLOCK (wrklock);
249 306
250 return retval; 307 return retval;
251} 308}
252 309
253#else 310#else
… …
312 abort (); 369 abort ();
313} 370}
314 371
315static int poll_cb (); 372static int poll_cb ();
316static int req_invoke (aio_req req); 373static int req_invoke (aio_req req);
317static void req_free (aio_req req); 374static void req_destroy (aio_req req);
318static void req_cancel (aio_req req); 375static void req_cancel (aio_req req);
319 376
320/* must be called at most once */ 377/* must be called at most once */
321static SV *req_sv (aio_req req, const char *klass) 378static SV *req_sv (aio_req req, const char *klass)
322{ 379{
… …
388 { 445 {
389 block_sig (); 446 block_sig ();
390 447
391 if (!req_invoke (grp)) 448 if (!req_invoke (grp))
392 { 449 {
393 req_free (grp); 450 req_destroy (grp);
394 unblock_sig (); 451 unblock_sig ();
395 croak (0); 452 croak (0);
396 } 453 }
397 454
398 req_free (grp); 455 req_destroy (grp);
399 unblock_sig (); 456 unblock_sig ();
400 } 457 }
401} 458}
402 459
403static int req_invoke (aio_req req) 460static int req_invoke (aio_req req)
404{ 461{
405 dSP; 462 dSP;
406 463
407 if (req->flags & FLAG_SV1_RO_OFF) 464 if (req->flags & FLAG_SV2_RO_OFF)
408 SvREADONLY_off (req->sv1); 465 SvREADONLY_off (req->sv2);
409 466
410 if (!(req->flags & FLAG_CANCELLED) && SvOK (req->callback)) 467 if (!(req->flags & FLAG_CANCELLED) && SvOK (req->callback))
411 { 468 {
412 ENTER; 469 ENTER;
413 SAVETMPS; 470 SAVETMPS;
… …
478 break; 535 break;
479 536
480 case REQ_READLINK: 537 case REQ_READLINK:
481 if (req->result > 0) 538 if (req->result > 0)
482 { 539 {
483 SvCUR_set (req->sv1, req->result); 540 SvCUR_set (req->sv2, req->result);
484 *SvEND (req->sv1) = 0; 541 *SvEND (req->sv2) = 0;
485 PUSHs (req->sv1); 542 PUSHs (req->sv2);
486 } 543 }
487 break; 544 break;
488 545
489 case REQ_STAT: 546 case REQ_STAT:
490 case REQ_LSTAT: 547 case REQ_LSTAT:
… …
494 PL_statcache = *(Stat_t *)(req->ptr2); 551 PL_statcache = *(Stat_t *)(req->ptr2);
495 PUSHs (sv_2mortal (newSViv (req->result))); 552 PUSHs (sv_2mortal (newSViv (req->result)));
496 break; 553 break;
497 554
498 case REQ_READ: 555 case REQ_READ:
499 SvCUR_set (req->sv1, req->stroffset + (req->result > 0 ? req->result : 0)); 556 SvCUR_set (req->sv2, req->stroffset + (req->result > 0 ? req->result : 0));
500 *SvEND (req->sv1) = 0; 557 *SvEND (req->sv2) = 0;
501 PUSHs (sv_2mortal (newSViv (req->result))); 558 PUSHs (sv_2mortal (newSViv (req->result)));
502 break; 559 break;
503 560
504 default: 561 default:
505 PUSHs (sv_2mortal (newSViv (req->result))); 562 PUSHs (sv_2mortal (newSViv (req->result)));
… …
531 } 588 }
532 589
533 return !SvTRUE (ERRSV); 590 return !SvTRUE (ERRSV);
534} 591}
535 592
536static void req_free (aio_req req) 593static void req_destroy (aio_req req)
537{ 594{
538 if (req->self) 595 if (req->self)
539 { 596 {
540 sv_unmagic (req->self, PERL_MAGIC_ext); 597 sv_unmagic (req->self, PERL_MAGIC_ext);
541 SvREFCNT_dec (req->self); 598 SvREFCNT_dec (req->self);
542 } 599 }
543 600
544 SvREFCNT_dec (req->fh);
545 SvREFCNT_dec (req->sv1); 601 SvREFCNT_dec (req->sv1);
546 SvREFCNT_dec (req->sv2); 602 SvREFCNT_dec (req->sv2);
547 SvREFCNT_dec (req->callback); 603 SvREFCNT_dec (req->callback);
548 604
549 if (req->flags & FLAG_PTR2_FREE) 605 if (req->flags & FLAG_PTR2_FREE)
… …
571 req->flags |= FLAG_CANCELLED; 627 req->flags |= FLAG_CANCELLED;
572 628
573 req_cancel_subs (req); 629 req_cancel_subs (req);
574} 630}
575 631
576static void *aio_proc(void *arg); 632#ifdef USE_SOCKETS_AS_HANDLES
633# define TO_SOCKET(x) (win32_get_osfhandle (x))
634#else
635# define TO_SOCKET(x) (x)
636#endif
637
638static void
639create_respipe ()
640{
641 int old_readfd = respipe [0];
642
643 if (respipe [1] >= 0)
644 respipe_close (TO_SOCKET (respipe [1]));
645
646#ifdef _WIN32
647 if (PerlSock_socketpair (AF_UNIX, SOCK_STREAM, 0, respipe))
648#else
649 if (pipe (respipe))
650#endif
651 croak ("unable to initialize result pipe");
652
653 if (old_readfd >= 0)
654 {
655 if (dup2 (TO_SOCKET (respipe [0]), TO_SOCKET (old_readfd)) < 0)
656 croak ("unable to initialize result pipe(2)");
657
658 respipe_close (respipe [0]);
659 respipe [0] = old_readfd;
660 }
661
662#ifdef _WIN32
663 int arg = 1;
664 if (ioctlsocket (TO_SOCKET (respipe [0]), FIONBIO, &arg)
665 || ioctlsocket (TO_SOCKET (respipe [1]), FIONBIO, &arg))
666#else
667 if (fcntl (respipe [0], F_SETFL, O_NONBLOCK)
668 || fcntl (respipe [1], F_SETFL, O_NONBLOCK))
669#endif
670 croak ("unable to initialize result pipe(3)");
671
672 respipe_osf [0] = TO_SOCKET (respipe [0]);
673 respipe_osf [1] = TO_SOCKET (respipe [1]);
674}
675
676X_THREAD_PROC (aio_proc);
577 677
578static void start_thread (void) 678static void start_thread (void)
579{ 679{
580 worker *wrk = calloc (1, sizeof (worker)); 680 worker *wrk = calloc (1, sizeof (worker));
581 681
582 if (!wrk) 682 if (!wrk)
583 croak ("unable to allocate worker thread data"); 683 croak ("unable to allocate worker thread data");
584 684
585 LOCK (wrklock); 685 X_LOCK (wrklock);
586 686
587 if (thread_create (&wrk->tid, aio_proc, (void *)wrk)) 687 if (thread_create (&wrk->tid, aio_proc, (void *)wrk))
588 { 688 {
589 wrk->prev = &wrk_first; 689 wrk->prev = &wrk_first;
590 wrk->next = wrk_first.next; 690 wrk->next = wrk_first.next;
… …
593 ++started; 693 ++started;
594 } 694 }
595 else 695 else
596 free (wrk); 696 free (wrk);
597 697
598 UNLOCK (wrklock); 698 X_UNLOCK (wrklock);
599} 699}
600 700
601static void maybe_start_thread () 701static void maybe_start_thread ()
602{ 702{
603 if (get_nthreads () >= wanted) 703 if (get_nthreads () >= wanted)
… …
614{ 714{
615 block_sig (); 715 block_sig ();
616 716
617 ++nreqs; 717 ++nreqs;
618 718
619 LOCK (reqlock); 719 X_LOCK (reqlock);
620 ++nready; 720 ++nready;
621 reqq_push (&req_queue, req); 721 reqq_push (&req_queue, req);
622 COND_SIGNAL (reqwait); 722 X_COND_SIGNAL (reqwait);
623 UNLOCK (reqlock); 723 X_UNLOCK (reqlock);
624 724
625 unblock_sig (); 725 unblock_sig ();
626 726
627 maybe_start_thread (); 727 maybe_start_thread ();
628} 728}
… …
634 Newz (0, req, 1, aio_cb); 734 Newz (0, req, 1, aio_cb);
635 735
636 req->type = REQ_QUIT; 736 req->type = REQ_QUIT;
637 req->pri = PRI_MAX + PRI_BIAS; 737 req->pri = PRI_MAX + PRI_BIAS;
638 738
639 LOCK (reqlock); 739 X_LOCK (reqlock);
640 reqq_push (&req_queue, req); 740 reqq_push (&req_queue, req);
641 COND_SIGNAL (reqwait); 741 X_COND_SIGNAL (reqwait);
642 UNLOCK (reqlock); 742 X_UNLOCK (reqlock);
643 743
644 LOCK (wrklock); 744 X_LOCK (wrklock);
645 --started; 745 --started;
646 UNLOCK (wrklock); 746 X_UNLOCK (wrklock);
647} 747}
648 748
649static void set_max_idle (int nthreads) 749static void set_max_idle (int nthreads)
650{ 750{
651 if (WORDACCESS_UNSAFE) LOCK (reqlock); 751 if (WORDACCESS_UNSAFE) X_LOCK (reqlock);
652 max_idle = nthreads <= 0 ? 1 : nthreads; 752 max_idle = nthreads <= 0 ? 1 : nthreads;
653 if (WORDACCESS_UNSAFE) UNLOCK (reqlock); 753 if (WORDACCESS_UNSAFE) X_UNLOCK (reqlock);
654} 754}
655 755
656static void min_parallel (int nthreads) 756static void min_parallel (int nthreads)
657{ 757{
658 if (wanted < nthreads) 758 if (wanted < nthreads)
… …
673 fd_set rfd; 773 fd_set rfd;
674 774
675 while (nreqs) 775 while (nreqs)
676 { 776 {
677 int size; 777 int size;
678 if (WORDACCESS_UNSAFE) LOCK (reslock); 778 if (WORDACCESS_UNSAFE) X_LOCK (reslock);
679 size = res_queue.size; 779 size = res_queue.size;
680 if (WORDACCESS_UNSAFE) UNLOCK (reslock); 780 if (WORDACCESS_UNSAFE) X_UNLOCK (reslock);
681 781
682 if (size) 782 if (size)
683 return; 783 return;
684 784
685 maybe_start_thread (); 785 maybe_start_thread ();
686 786
687 FD_ZERO(&rfd); 787 FD_ZERO (&rfd);
688 FD_SET(respipe [0], &rfd); 788 FD_SET (respipe [0], &rfd);
689 789
690 select (respipe [0] + 1, &rfd, 0, 0, 0); 790 PerlSock_select (respipe [0] + 1, &rfd, 0, 0, 0);
691 } 791 }
692} 792}
693 793
694static int poll_cb () 794static int poll_cb ()
695{ 795{
… …
709 { 809 {
710 for (;;) 810 for (;;)
711 { 811 {
712 maybe_start_thread (); 812 maybe_start_thread ();
713 813
714 LOCK (reslock); 814 X_LOCK (reslock);
715 req = reqq_shift (&res_queue); 815 req = reqq_shift (&res_queue);
716 816
717 if (req) 817 if (req)
718 { 818 {
719 --npending; 819 --npending;
720 820
721 if (!res_queue.size) 821 if (!res_queue.size)
722 { 822 {
723 /* read any signals sent by the worker threads */ 823 /* read any signals sent by the worker threads */
724 char buf [4]; 824 char buf [4];
725 while (read (respipe [0], buf, 4) == 4) 825 while (respipe_read (respipe [0], buf, 4) == 4)
726 ; 826 ;
727 } 827 }
728 } 828 }
729 829
730 UNLOCK (reslock); 830 X_UNLOCK (reslock);
731 831
732 if (!req) 832 if (!req)
733 break; 833 break;
734 834
735 --nreqs; 835 --nreqs;
… …
741 } 841 }
742 else 842 else
743 { 843 {
744 if (!req_invoke (req)) 844 if (!req_invoke (req))
745 { 845 {
746 req_free (req); 846 req_destroy (req);
747 unblock_sig (); 847 unblock_sig ();
748 croak (0); 848 croak (0);
749 } 849 }
750 850
751 count++; 851 count++;
752 } 852 }
753 853
754 req_free (req); 854 req_destroy (req);
755 855
756 if (maxreqs && !--maxreqs) 856 if (maxreqs && !--maxreqs)
757 break; 857 break;
758 858
759 if (max_poll_time) 859 if (max_poll_time)
… …
773 ++maxreqs; 873 ++maxreqs;
774 } 874 }
775 875
776 unblock_sig (); 876 unblock_sig ();
777 return count; 877 return count;
778}
779
780static void create_pipe ()
781{
782 if (pipe (respipe))
783 croak ("unable to initialize result pipe");
784
785 if (fcntl (respipe [0], F_SETFL, O_NONBLOCK))
786 croak ("cannot set result pipe to nonblocking mode");
787
788 if (fcntl (respipe [1], F_SETFL, O_NONBLOCK))
789 croak ("cannot set result pipe to nonblocking mode");
790} 878}
791 879
792/*****************************************************************************/ 880/*****************************************************************************/
793/* work around various missing functions */ 881/* work around various missing functions */
794 882
… …
799/* 887/*
800 * make our pread/pwrite safe against themselves, but not against 888 * make our pread/pwrite safe against themselves, but not against
801 * normal read/write by using a mutex. slows down execution a lot, 889 * normal read/write by using a mutex. slows down execution a lot,
802 * but that's your problem, not mine. 890 * but that's your problem, not mine.
803 */ 891 */
804static mutex_t preadwritelock = MUTEX_INIT; 892static mutex_t preadwritelock = X_MUTEX_INIT;
805 893
806static ssize_t pread (int fd, void *buf, size_t count, off_t offset) 894static ssize_t pread (int fd, void *buf, size_t count, off_t offset)
807{ 895{
808 ssize_t res; 896 ssize_t res;
809 off_t ooffset; 897 off_t ooffset;
810 898
811 LOCK (preadwritelock); 899 X_LOCK (preadwritelock);
812 ooffset = lseek (fd, 0, SEEK_CUR); 900 ooffset = lseek (fd, 0, SEEK_CUR);
813 lseek (fd, offset, SEEK_SET); 901 lseek (fd, offset, SEEK_SET);
814 res = read (fd, buf, count); 902 res = read (fd, buf, count);
815 lseek (fd, ooffset, SEEK_SET); 903 lseek (fd, ooffset, SEEK_SET);
816 UNLOCK (preadwritelock); 904 X_UNLOCK (preadwritelock);
817 905
818 return res; 906 return res;
819} 907}
820 908
821static ssize_t pwrite (int fd, void *buf, size_t count, off_t offset) 909static ssize_t pwrite (int fd, void *buf, size_t count, off_t offset)
822{ 910{
823 ssize_t res; 911 ssize_t res;
824 off_t ooffset; 912 off_t ooffset;
825 913
826 LOCK (preadwritelock); 914 X_LOCK (preadwritelock);
827 ooffset = lseek (fd, 0, SEEK_CUR); 915 ooffset = lseek (fd, 0, SEEK_CUR);
828 lseek (fd, offset, SEEK_SET); 916 lseek (fd, offset, SEEK_SET);
829 res = write (fd, buf, count); 917 res = write (fd, buf, count);
830 lseek (fd, offset, SEEK_SET); 918 lseek (fd, offset, SEEK_SET);
831 UNLOCK (preadwritelock); 919 X_UNLOCK (preadwritelock);
832 920
833 return res; 921 return res;
834} 922}
923#endif
924
925#ifndef HAVE_FUTIMES
926
927# define utimes(path,times) aio_utimes (path, times)
928# define futimes(fd,times) aio_futimes (fd, times)
929
930int aio_utimes (const char *filename, const struct timeval times[2])
931{
932 if (times)
933 {
934 struct utimbuf buf;
935
936 buf.actime = times[0].tv_sec;
937 buf.modtime = times[1].tv_sec;
938
939 return utime (filename, &buf);
940 }
941 else
942 return utime (filename, 0);
943}
944
945int aio_futimes (int fd, const struct timeval tv[2])
946{
947 errno = ENOSYS;
948 return -1;
949}
950
835#endif 951#endif
836 952
837#if !HAVE_FDATASYNC 953#if !HAVE_FDATASYNC
838# define fdatasync fsync 954# define fdatasync fsync
839#endif 955#endif
… …
841#if !HAVE_READAHEAD 957#if !HAVE_READAHEAD
842# define readahead(fd,offset,count) aio_readahead (fd, offset, count, self) 958# define readahead(fd,offset,count) aio_readahead (fd, offset, count, self)
843 959
844static ssize_t aio_readahead (int fd, off_t offset, size_t count, worker *self) 960static ssize_t aio_readahead (int fd, off_t offset, size_t count, worker *self)
845{ 961{
962 size_t todo = count;
846 dBUF; 963 dBUF;
847 964
848 while (count > 0) 965 while (todo > 0)
849 { 966 {
850 size_t len = count < AIO_BUFSIZE ? count : AIO_BUFSIZE; 967 size_t len = todo < AIO_BUFSIZE ? todo : AIO_BUFSIZE;
851 968
852 pread (fd, aio_buf, len, offset); 969 pread (fd, aio_buf, len, offset);
853 offset += len; 970 offset += len;
854 count -= len; 971 todo -= len;
855 } 972 }
856 973
857 errno = 0; 974 errno = 0;
975 return count;
858} 976}
859 977
860#endif 978#endif
861 979
862#if !HAVE_READDIR_R 980#if !HAVE_READDIR_R
863# define readdir_r aio_readdir_r 981# define readdir_r aio_readdir_r
864 982
865static mutex_t readdirlock = MUTEX_INIT; 983static mutex_t readdirlock = X_MUTEX_INIT;
866 984
867static int readdir_r (DIR *dirp, struct dirent *ent, struct dirent **res) 985static int readdir_r (DIR *dirp, X_DIRENT *ent, X_DIRENT **res)
868{ 986{
869 struct dirent *e; 987 X_DIRENT *e;
870 int errorno; 988 int errorno;
871 989
872 LOCK (readdirlock); 990 X_LOCK (readdirlock);
873 991
874 e = readdir (dirp); 992 e = readdir (dirp);
875 errorno = errno; 993 errorno = errno;
876 994
877 if (e) 995 if (e)
… …
880 strcpy (ent->d_name, e->d_name); 998 strcpy (ent->d_name, e->d_name);
881 } 999 }
882 else 1000 else
883 *res = 0; 1001 *res = 0;
884 1002
885 UNLOCK (readdirlock); 1003 X_UNLOCK (readdirlock);
886 1004
887 errno = errorno; 1005 errno = errorno;
888 return e ? 0 : -1; 1006 return e ? 0 : -1;
889} 1007}
890#endif 1008#endif
… …
986static void scandir_ (aio_req req, worker *self) 1104static void scandir_ (aio_req req, worker *self)
987{ 1105{
988 DIR *dirp; 1106 DIR *dirp;
989 union 1107 union
990 { 1108 {
991 struct dirent d; 1109 X_DIRENT d;
992 char b [offsetof (struct dirent, d_name) + NAME_MAX + 1]; 1110 char b [offsetof (X_DIRENT, d_name) + NAME_MAX + 1];
993 } *u; 1111 } *u;
994 struct dirent *entp; 1112 X_DIRENT *entp;
995 char *name, *names; 1113 char *name, *names;
996 int memlen = 4096; 1114 int memlen = 4096;
997 int memofs = 0; 1115 int memofs = 0;
998 int res = 0; 1116 int res = 0;
999 int errorno;
1000 1117
1001 LOCK (wrklock); 1118 X_LOCK (wrklock);
1002 self->dirp = dirp = opendir (req->ptr1); 1119 self->dirp = dirp = opendir (req->ptr1);
1003 self->dbuf = u = malloc (sizeof (*u)); 1120 self->dbuf = u = malloc (sizeof (*u));
1004 req->flags |= FLAG_PTR2_FREE; 1121 req->flags |= FLAG_PTR2_FREE;
1005 req->ptr2 = names = malloc (memlen); 1122 req->ptr2 = names = malloc (memlen);
1006 UNLOCK (wrklock); 1123 X_UNLOCK (wrklock);
1007 1124
1008 if (dirp && u && names) 1125 if (dirp && u && names)
1009 for (;;) 1126 for (;;)
1010 { 1127 {
1011 errno = 0; 1128 errno = 0;
… …
1023 res++; 1140 res++;
1024 1141
1025 while (memofs + len > memlen) 1142 while (memofs + len > memlen)
1026 { 1143 {
1027 memlen *= 2; 1144 memlen *= 2;
1028 LOCK (wrklock); 1145 X_LOCK (wrklock);
1029 req->ptr2 = names = realloc (names, memlen); 1146 req->ptr2 = names = realloc (names, memlen);
1030 UNLOCK (wrklock); 1147 X_UNLOCK (wrklock);
1031 1148
1032 if (!names) 1149 if (!names)
1033 break; 1150 break;
1034 } 1151 }
1035 1152
… …
1044 req->result = res; 1161 req->result = res;
1045} 1162}
1046 1163
1047/*****************************************************************************/ 1164/*****************************************************************************/
1048 1165
1049static void *aio_proc (void *thr_arg) 1166X_THREAD_PROC (aio_proc)
1050{ 1167{
1168 {//D
1051 aio_req req; 1169 aio_req req;
1052 struct timespec ts; 1170 struct timespec ts;
1053 worker *self = (worker *)thr_arg; 1171 worker *self = (worker *)thr_arg;
1054 1172
1055 /* try to distribute timeouts somewhat evenly */ 1173 /* try to distribute timeouts somewhat randomly */
1056 ts.tv_nsec = (((unsigned long)self + (unsigned long)ts.tv_sec) & 1023UL) 1174 ts.tv_nsec = ((unsigned long)self & 1023UL) * (1000000000UL / 1024UL);
1057 * (1000000000UL / 1024UL);
1058 1175
1059 for (;;) 1176 for (;;)
1060 { 1177 {
1061 ts.tv_sec = time (0) + IDLE_TIMEOUT; 1178 ts.tv_sec = time (0) + IDLE_TIMEOUT;
1062 1179
1063 LOCK (reqlock); 1180 X_LOCK (reqlock);
1064 1181
1065 for (;;) 1182 for (;;)
1066 { 1183 {
1067 self->req = req = reqq_shift (&req_queue); 1184 self->req = req = reqq_shift (&req_queue);
1068 1185
1069 if (req) 1186 if (req)
1070 break; 1187 break;
1071 1188
1072 ++idle; 1189 ++idle;
1073 1190
1074 if (COND_TIMEDWAIT (reqwait, reqlock, ts) 1191 if (X_COND_TIMEDWAIT (reqwait, reqlock, ts)
1075 == ETIMEDOUT) 1192 == ETIMEDOUT)
1076 { 1193 {
1077 if (idle > max_idle) 1194 if (idle > max_idle)
1078 { 1195 {
1079 --idle; 1196 --idle;
1080 UNLOCK (reqlock); 1197 X_UNLOCK (reqlock);
1081 LOCK (wrklock); 1198 X_LOCK (wrklock);
1082 --started; 1199 --started;
1083 UNLOCK (wrklock); 1200 X_UNLOCK (wrklock);
1084 goto quit; 1201 goto quit;
1085 } 1202 }
1086 1203
1087 /* we are allowed to idle, so do so without any timeout */ 1204 /* we are allowed to idle, so do so without any timeout */
1088 COND_WAIT (reqwait, reqlock); 1205 X_COND_WAIT (reqwait, reqlock);
1089 ts.tv_sec = time (0) + IDLE_TIMEOUT; 1206 ts.tv_sec = time (0) + IDLE_TIMEOUT;
1090 } 1207 }
1091 1208
1092 --idle; 1209 --idle;
1093 } 1210 }
1094 1211
1095 --nready; 1212 --nready;
1096 1213
1097 UNLOCK (reqlock); 1214 X_UNLOCK (reqlock);
1098 1215
1099 errno = 0; /* strictly unnecessary */ 1216 errno = 0; /* strictly unnecessary */
1100 1217
1101 if (!(req->flags & FLAG_CANCELLED)) 1218 if (!(req->flags & FLAG_CANCELLED))
1102 switch (req->type) 1219 switch (req->type)
1103 { 1220 {
1104 case REQ_READ: req->result = pread (req->int1, req->ptr1, req->size, req->offs); break; 1221 case REQ_READ: req->result = req->offs >= 0
1105 case REQ_WRITE: req->result = pwrite (req->int1, req->ptr1, req->size, req->offs); break; 1222 ? pread (req->int1, req->ptr1, req->size, req->offs)
1223 : read (req->int1, req->ptr1, req->size); break;
1224 case REQ_WRITE: req->result = req->offs >= 0
1225 ? pwrite (req->int1, req->ptr1, req->size, req->offs)
1226 : write (req->int1, req->ptr1, req->size); break;
1106 1227
1107 case REQ_READAHEAD: req->result = readahead (req->int1, req->offs, req->size); break; 1228 case REQ_READAHEAD: req->result = readahead (req->int1, req->offs, req->size); break;
1108 case REQ_SENDFILE: req->result = sendfile_ (req->int1, req->int2, req->offs, req->size, self); break; 1229 case REQ_SENDFILE: req->result = sendfile_ (req->int1, req->int2, req->offs, req->size, self); break;
1109 1230
1110 case REQ_STAT: req->result = stat (req->ptr1, (Stat_t *)req->ptr2); break; 1231 case REQ_STAT: req->result = stat (req->ptr1, (Stat_t *)req->ptr2); break;
1111 case REQ_LSTAT: req->result = lstat (req->ptr1, (Stat_t *)req->ptr2); break; 1232 case REQ_LSTAT: req->result = lstat (req->ptr1, (Stat_t *)req->ptr2); break;
1112 case REQ_FSTAT: req->result = fstat (req->int1, (Stat_t *)req->ptr2); break; 1233 case REQ_FSTAT: req->result = fstat (req->int1, (Stat_t *)req->ptr2); break;
1234
1235 case REQ_CHOWN: req->result = chown (req->ptr1, req->int2, req->int3); break;
1236 case REQ_FCHOWN: req->result = fchown (req->int1, req->int2, req->int3); break;
1237 case REQ_CHMOD: req->result = chmod (req->ptr1, req->mode); break;
1238 case REQ_FCHMOD: req->result = fchmod (req->int1, req->mode); break;
1239 case REQ_TRUNCATE: req->result = truncate (req->ptr1, req->offs); break;
1240 case REQ_FTRUNCATE: req->result = ftruncate (req->int1, req->offs); break;
1113 1241
1114 case REQ_OPEN: req->result = open (req->ptr1, req->int1, req->mode); break; 1242 case REQ_OPEN: req->result = open (req->ptr1, req->int1, req->mode); break;
1115 case REQ_CLOSE: req->result = close (req->int1); break; 1243 case REQ_CLOSE: req->result = close (req->int1); break;
1116 case REQ_UNLINK: req->result = unlink (req->ptr1); break; 1244 case REQ_UNLINK: req->result = unlink (req->ptr1); break;
1117 case REQ_RMDIR: req->result = rmdir (req->ptr1); break; 1245 case REQ_RMDIR: req->result = rmdir (req->ptr1); break;
… …
1125 case REQ_FDATASYNC: req->result = fdatasync (req->int1); break; 1253 case REQ_FDATASYNC: req->result = fdatasync (req->int1); break;
1126 case REQ_FSYNC: req->result = fsync (req->int1); break; 1254 case REQ_FSYNC: req->result = fsync (req->int1); break;
1127 case REQ_READDIR: scandir_ (req, self); break; 1255 case REQ_READDIR: scandir_ (req, self); break;
1128 1256
1129 case REQ_BUSY: 1257 case REQ_BUSY:
1258#ifdef _WIN32
1259 Sleep (req->nv1 * 1000.);
1260#else
1130 { 1261 {
1131 struct timeval tv; 1262 struct timeval tv;
1132 1263
1133 tv.tv_sec = req->int1; 1264 tv.tv_sec = req->nv1;
1134 tv.tv_usec = req->int2; 1265 tv.tv_usec = (req->nv1 - tv.tv_sec) * 1000000.;
1135 1266
1136 req->result = select (0, 0, 0, 0, &tv); 1267 req->result = select (0, 0, 0, 0, &tv);
1268 }
1269#endif
1270 break;
1271
1272 case REQ_UTIME:
1273 case REQ_FUTIME:
1274 {
1275 struct timeval tv[2];
1276 struct timeval *times;
1277
1278 if (req->nv1 != -1. || req->nv2 != -1.)
1279 {
1280 tv[0].tv_sec = req->nv1;
1281 tv[0].tv_usec = (req->nv1 - tv[0].tv_sec) * 1000000.;
1282 tv[1].tv_sec = req->nv2;
1283 tv[1].tv_usec = (req->nv2 - tv[1].tv_sec) * 1000000.;
1284
1285 times = tv;
1286 }
1287 else
1288 times = 0;
1289
1290
1291 req->result = req->type == REQ_FUTIME
1292 ? futimes (req->int1, times)
1293 : utimes (req->ptr1, times);
1137 } 1294 }
1138 1295
1139 case REQ_GROUP: 1296 case REQ_GROUP:
1140 case REQ_NOP: 1297 case REQ_NOP:
1141 break; 1298 break;
1142 1299
1143 case REQ_QUIT: 1300 case REQ_QUIT:
1144 goto quit; 1301 goto quit;
1145 1302
1146 default: 1303 default:
1147 req->result = ENOSYS; 1304 req->result = -1;
1148 break; 1305 break;
1149 } 1306 }
1150 1307
1151 req->errorno = errno; 1308 req->errorno = errno;
1152 1309
1153 LOCK (reslock); 1310 X_LOCK (reslock);
1154 1311
1155 ++npending; 1312 ++npending;
1156 1313
1157 if (!reqq_push (&res_queue, req)) 1314 if (!reqq_push (&res_queue, req))
1158 { 1315 {
1159 /* write a dummy byte to the pipe so fh becomes ready */ 1316 /* write a dummy byte to the pipe so fh becomes ready */
1160 write (respipe [1], &respipe, 1); 1317 respipe_write (respipe_osf [1], (const void *)&respipe_osf, 1);
1161 1318
1162 /* optionally signal the main thread asynchronously */ 1319 /* optionally signal the main thread asynchronously */
1163 if (main_sig) 1320 if (main_sig)
1164 pthread_kill (main_tid, main_sig); 1321 pthread_kill (main_tid, main_sig);
1165 } 1322 }
1166 1323
1167 self->req = 0; 1324 self->req = 0;
1168 worker_clear (self); 1325 worker_clear (self);
1169 1326
1170 UNLOCK (reslock); 1327 X_UNLOCK (reslock);
1171 } 1328 }
1172 1329
1173quit: 1330quit:
1174 LOCK (wrklock); 1331 X_LOCK (wrklock);
1175 worker_free (self); 1332 worker_free (self);
1176 UNLOCK (wrklock); 1333 X_UNLOCK (wrklock);
1177 1334
1178 return 0; 1335 return 0;
1336 }//D
1179} 1337}
1180 1338
1181/*****************************************************************************/ 1339/*****************************************************************************/
1182 1340
1183static void atfork_prepare (void) 1341static void atfork_prepare (void)
1184{ 1342{
1185 LOCK (wrklock); 1343 X_LOCK (wrklock);
1186 LOCK (reqlock); 1344 X_LOCK (reqlock);
1187 LOCK (reslock); 1345 X_LOCK (reslock);
1188#if !HAVE_PREADWRITE 1346#if !HAVE_PREADWRITE
1189 LOCK (preadwritelock); 1347 X_LOCK (preadwritelock);
1190#endif 1348#endif
1191#if !HAVE_READDIR_R 1349#if !HAVE_READDIR_R
1192 LOCK (readdirlock); 1350 X_LOCK (readdirlock);
1193#endif 1351#endif
1194} 1352}
1195 1353
1196static void atfork_parent (void) 1354static void atfork_parent (void)
1197{ 1355{
1198#if !HAVE_READDIR_R 1356#if !HAVE_READDIR_R
1199 UNLOCK (readdirlock); 1357 X_UNLOCK (readdirlock);
1200#endif 1358#endif
1201#if !HAVE_PREADWRITE 1359#if !HAVE_PREADWRITE
1202 UNLOCK (preadwritelock); 1360 X_UNLOCK (preadwritelock);
1203#endif 1361#endif
1204 UNLOCK (reslock); 1362 X_UNLOCK (reslock);
1205 UNLOCK (reqlock); 1363 X_UNLOCK (reqlock);
1206 UNLOCK (wrklock); 1364 X_UNLOCK (wrklock);
1207} 1365}
1208 1366
1209static void atfork_child (void) 1367static void atfork_child (void)
1210{ 1368{
1211 aio_req prv; 1369 aio_req prv;
1212 1370
1213 while (prv = reqq_shift (&req_queue)) 1371 while (prv = reqq_shift (&req_queue))
1214 req_free (prv); 1372 req_destroy (prv);
1215 1373
1216 while (prv = reqq_shift (&res_queue)) 1374 while (prv = reqq_shift (&res_queue))
1217 req_free (prv); 1375 req_destroy (prv);
1218 1376
1219 while (wrk_first.next != &wrk_first) 1377 while (wrk_first.next != &wrk_first)
1220 { 1378 {
1221 worker *wrk = wrk_first.next; 1379 worker *wrk = wrk_first.next;
1222 1380
1223 if (wrk->req) 1381 if (wrk->req)
1224 req_free (wrk->req); 1382 req_destroy (wrk->req);
1225 1383
1226 worker_clear (wrk); 1384 worker_clear (wrk);
1227 worker_free (wrk); 1385 worker_free (wrk);
1228 } 1386 }
1229 1387
… …
1231 idle = 0; 1389 idle = 0;
1232 nreqs = 0; 1390 nreqs = 0;
1233 nready = 0; 1391 nready = 0;
1234 npending = 0; 1392 npending = 0;
1235 1393
1236 close (respipe [0]);
1237 close (respipe [1]);
1238 create_pipe (); 1394 create_respipe ();
1239 1395
1240 atfork_parent (); 1396 atfork_parent ();
1241} 1397}
1242 1398
1243#define dREQ \ 1399#define dREQ \
… …
1272 newCONSTSUB (stash, "EXDEV", newSViv (EXDEV)); 1428 newCONSTSUB (stash, "EXDEV", newSViv (EXDEV));
1273 newCONSTSUB (stash, "O_RDONLY", newSViv (O_RDONLY)); 1429 newCONSTSUB (stash, "O_RDONLY", newSViv (O_RDONLY));
1274 newCONSTSUB (stash, "O_WRONLY", newSViv (O_WRONLY)); 1430 newCONSTSUB (stash, "O_WRONLY", newSViv (O_WRONLY));
1275 newCONSTSUB (stash, "O_CREAT", newSViv (O_CREAT)); 1431 newCONSTSUB (stash, "O_CREAT", newSViv (O_CREAT));
1276 newCONSTSUB (stash, "O_TRUNC", newSViv (O_TRUNC)); 1432 newCONSTSUB (stash, "O_TRUNC", newSViv (O_TRUNC));
1433#ifdef _WIN32
1434 X_MUTEX_CHECK (wrklock);
1435 X_MUTEX_CHECK (reslock);
1436 X_MUTEX_CHECK (reqlock);
1437 X_MUTEX_CHECK (reqwait);
1438 X_MUTEX_CHECK (preadwritelock);
1439 X_MUTEX_CHECK (readdirlock);
1440
1441 X_COND_CHECK (reqwait);
1442#else
1277 newCONSTSUB (stash, "S_IFIFO", newSViv (S_IFIFO)); 1443 newCONSTSUB (stash, "S_IFIFO", newSViv (S_IFIFO));
1278 newCONSTSUB (stash, "SIGIO", newSViv (SIGIO)); 1444 newCONSTSUB (stash, "SIGIO", newSViv (SIGIO));
1445#endif
1279 1446
1280 create_pipe (); 1447 create_respipe ();
1448
1281 ATFORK (atfork_prepare, atfork_parent, atfork_child); 1449 X_THREAD_ATFORK (atfork_prepare, atfork_parent, atfork_child);
1282} 1450}
1283 1451
1284void 1452void
1285max_poll_reqs (int nreqs) 1453max_poll_reqs (int nreqs)
1286 PROTOTYPE: $ 1454 PROTOTYPE: $
… …
1315 max_outstanding = maxreqs; 1483 max_outstanding = maxreqs;
1316 OUTPUT: 1484 OUTPUT:
1317 RETVAL 1485 RETVAL
1318 1486
1319void 1487void
1320aio_open (pathname,flags,mode,callback=&PL_sv_undef) 1488aio_open (SV8 *pathname, int flags, int mode, SV *callback=&PL_sv_undef)
1321 SV8 * pathname
1322 int flags
1323 int mode
1324 SV * callback
1325 PROTOTYPE: $$$;$ 1489 PROTOTYPE: $$$;$
1326 PPCODE: 1490 PPCODE:
1327{ 1491{
1328 dREQ; 1492 dREQ;
1329 1493
… …
1335 1499
1336 REQ_SEND; 1500 REQ_SEND;
1337} 1501}
1338 1502
1339void 1503void
1340aio_close (fh,callback=&PL_sv_undef) 1504aio_close (SV *fh, SV *callback=&PL_sv_undef)
1341 SV * fh
1342 SV * callback
1343 PROTOTYPE: $;$ 1505 PROTOTYPE: $;$
1344 ALIAS: 1506 ALIAS:
1345 aio_close = REQ_CLOSE 1507 aio_close = REQ_CLOSE
1346 aio_fsync = REQ_FSYNC 1508 aio_fsync = REQ_FSYNC
1347 aio_fdatasync = REQ_FDATASYNC 1509 aio_fdatasync = REQ_FDATASYNC
1348 PPCODE: 1510 PPCODE:
1349{ 1511{
1350 dREQ; 1512 dREQ;
1351 1513
1352 req->type = ix; 1514 req->type = ix;
1353 req->fh = newSVsv (fh); 1515 req->sv1 = newSVsv (fh);
1354 req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh))); 1516 req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh)));
1355 1517
1356 REQ_SEND (req); 1518 REQ_SEND (req);
1357} 1519}
1358 1520
1359void 1521void
1360aio_read (fh,offset,length,data,dataoffset,callback=&PL_sv_undef) 1522aio_read (SV *fh, SV *offset, SV *length, SV8 *data, IV dataoffset, SV *callback=&PL_sv_undef)
1361 SV * fh
1362 UV offset
1363 UV length
1364 SV8 * data
1365 UV dataoffset
1366 SV * callback
1367 ALIAS: 1523 ALIAS:
1368 aio_read = REQ_READ 1524 aio_read = REQ_READ
1369 aio_write = REQ_WRITE 1525 aio_write = REQ_WRITE
1370 PROTOTYPE: $$$$$;$ 1526 PROTOTYPE: $$$$$;$
1371 PPCODE: 1527 PPCODE:
1372{ 1528{
1373 STRLEN svlen; 1529 STRLEN svlen;
1374 char *svptr = SvPVbyte (data, svlen); 1530 char *svptr = SvPVbyte (data, svlen);
1531 UV len = SvUV (length);
1375 1532
1376 SvUPGRADE (data, SVt_PV); 1533 SvUPGRADE (data, SVt_PV);
1377 SvPOK_on (data); 1534 SvPOK_on (data);
1378 1535
1379 if (dataoffset < 0) 1536 if (dataoffset < 0)
1380 dataoffset += svlen; 1537 dataoffset += svlen;
1381 1538
1382 if (dataoffset < 0 || dataoffset > svlen) 1539 if (dataoffset < 0 || dataoffset > svlen)
1383 croak ("data offset outside of string"); 1540 croak ("dataoffset outside of data scalar");
1384 1541
1385 if (ix == REQ_WRITE) 1542 if (ix == REQ_WRITE)
1386 { 1543 {
1387 /* write: check length and adjust. */ 1544 /* write: check length and adjust. */
1388 if (length < 0 || length + dataoffset > svlen) 1545 if (!SvOK (length) || len + dataoffset > svlen)
1389 length = svlen - dataoffset; 1546 len = svlen - dataoffset;
1390 } 1547 }
1391 else 1548 else
1392 { 1549 {
1393 /* read: grow scalar as necessary */ 1550 /* read: grow scalar as necessary */
1394 svptr = SvGROW (data, length + dataoffset + 1); 1551 svptr = SvGROW (data, len + dataoffset + 1);
1395 } 1552 }
1396 1553
1397 if (length < 0) 1554 if (len < 0)
1398 croak ("length must not be negative"); 1555 croak ("length must not be negative");
1399 1556
1400 { 1557 {
1401 dREQ; 1558 dREQ;
1402 1559
1403 req->type = ix; 1560 req->type = ix;
1404 req->fh = newSVsv (fh); 1561 req->sv1 = newSVsv (fh);
1405 req->int1 = PerlIO_fileno (ix == REQ_READ ? IoIFP (sv_2io (fh)) 1562 req->int1 = PerlIO_fileno (ix == REQ_READ ? IoIFP (sv_2io (fh))
1406 : IoOFP (sv_2io (fh))); 1563 : IoOFP (sv_2io (fh)));
1407 req->offs = offset; 1564 req->offs = SvOK (offset) ? SvVAL64 (offset) : -1;
1408 req->size = length; 1565 req->size = len;
1409 req->sv1 = SvREFCNT_inc (data); 1566 req->sv2 = SvREFCNT_inc (data);
1410 req->ptr1 = (char *)svptr + dataoffset; 1567 req->ptr1 = (char *)svptr + dataoffset;
1411 req->stroffset = dataoffset; 1568 req->stroffset = dataoffset;
1412 1569
1413 if (!SvREADONLY (data)) 1570 if (!SvREADONLY (data))
1414 { 1571 {
1415 SvREADONLY_on (data); 1572 SvREADONLY_on (data);
1416 req->flags |= FLAG_SV1_RO_OFF; 1573 req->flags |= FLAG_SV2_RO_OFF;
1417 } 1574 }
1418 1575
1419 REQ_SEND; 1576 REQ_SEND;
1420 } 1577 }
1421} 1578}
1422 1579
1423void 1580void
1424aio_readlink (path,callback=&PL_sv_undef) 1581aio_readlink (SV8 *path, SV *callback=&PL_sv_undef)
1425 SV8 * path
1426 SV * callback
1427 PROTOTYPE: $$;$ 1582 PROTOTYPE: $$;$
1428 PPCODE: 1583 PPCODE:
1429{ 1584{
1430 SV *data; 1585 SV *data;
1431 dREQ; 1586 dREQ;
1432 1587
1433 data = newSV (NAME_MAX); 1588 data = newSV (NAME_MAX);
1434 SvPOK_on (data); 1589 SvPOK_on (data);
1435 1590
1436 req->type = REQ_READLINK; 1591 req->type = REQ_READLINK;
1437 req->fh = newSVsv (path); 1592 req->sv1 = newSVsv (path);
1438 req->ptr2 = SvPVbyte_nolen (req->fh); 1593 req->ptr2 = SvPVbyte_nolen (req->sv1);
1439 req->sv1 = data; 1594 req->sv2 = data;
1440 req->ptr1 = SvPVbyte_nolen (data); 1595 req->ptr1 = SvPVbyte_nolen (data);
1441 1596
1442 REQ_SEND; 1597 REQ_SEND;
1443} 1598}
1444 1599
1445void 1600void
1446aio_sendfile (out_fh,in_fh,in_offset,length,callback=&PL_sv_undef) 1601aio_sendfile (SV *out_fh, SV *in_fh, SV *in_offset, UV length, SV *callback=&PL_sv_undef)
1447 SV * out_fh
1448 SV * in_fh
1449 UV in_offset
1450 UV length
1451 SV * callback
1452 PROTOTYPE: $$$$;$ 1602 PROTOTYPE: $$$$;$
1453 PPCODE: 1603 PPCODE:
1454{ 1604{
1455 dREQ; 1605 dREQ;
1456 1606
1457 req->type = REQ_SENDFILE; 1607 req->type = REQ_SENDFILE;
1458 req->fh = newSVsv (out_fh); 1608 req->sv1 = newSVsv (out_fh);
1459 req->int1 = PerlIO_fileno (IoIFP (sv_2io (out_fh))); 1609 req->int1 = PerlIO_fileno (IoIFP (sv_2io (out_fh)));
1460 req->sv2 = newSVsv (in_fh); 1610 req->sv2 = newSVsv (in_fh);
1461 req->int2 = PerlIO_fileno (IoIFP (sv_2io (in_fh))); 1611 req->int2 = PerlIO_fileno (IoIFP (sv_2io (in_fh)));
1462 req->offs = in_offset; 1612 req->offs = SvVAL64 (in_offset);
1463 req->size = length; 1613 req->size = length;
1464 1614
1465 REQ_SEND; 1615 REQ_SEND;
1466} 1616}
1467 1617
1468void 1618void
1469aio_readahead (fh,offset,length,callback=&PL_sv_undef) 1619aio_readahead (SV *fh, SV *offset, IV length, SV *callback=&PL_sv_undef)
1470 SV * fh
1471 UV offset
1472 IV length
1473 SV * callback
1474 PROTOTYPE: $$$;$ 1620 PROTOTYPE: $$$;$
1475 PPCODE: 1621 PPCODE:
1476{ 1622{
1477 dREQ; 1623 dREQ;
1478 1624
1479 req->type = REQ_READAHEAD; 1625 req->type = REQ_READAHEAD;
1480 req->fh = newSVsv (fh); 1626 req->sv1 = newSVsv (fh);
1481 req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh))); 1627 req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh)));
1482 req->offs = offset; 1628 req->offs = SvVAL64 (offset);
1483 req->size = length; 1629 req->size = length;
1484 1630
1485 REQ_SEND; 1631 REQ_SEND;
1486} 1632}
1487 1633
1488void 1634void
1489aio_stat (fh_or_path,callback=&PL_sv_undef) 1635aio_stat (SV8 *fh_or_path, SV *callback=&PL_sv_undef)
1490 SV8 * fh_or_path
1491 SV * callback
1492 ALIAS: 1636 ALIAS:
1493 aio_stat = REQ_STAT 1637 aio_stat = REQ_STAT
1494 aio_lstat = REQ_LSTAT 1638 aio_lstat = REQ_LSTAT
1495 PPCODE: 1639 PPCODE:
1496{ 1640{
1497 dREQ; 1641 dREQ;
1498 1642
1499 req->ptr2 = malloc (sizeof (Stat_t)); 1643 req->ptr2 = malloc (sizeof (Stat_t));
1500 if (!req->ptr2) 1644 if (!req->ptr2)
1501 { 1645 {
1502 req_free (req); 1646 req_destroy (req);
1503 croak ("out of memory during aio_stat statdata allocation"); 1647 croak ("out of memory during aio_stat statdata allocation");
1504 } 1648 }
1505 1649
1506 req->flags |= FLAG_PTR2_FREE; 1650 req->flags |= FLAG_PTR2_FREE;
1651 req->sv1 = newSVsv (fh_or_path);
1507 1652
1508 if (SvPOK (fh_or_path)) 1653 if (SvPOK (fh_or_path))
1509 { 1654 {
1510 req->type = ix; 1655 req->type = ix;
1511 req->sv1 = newSVsv (fh_or_path);
1512 req->ptr1 = SvPVbyte_nolen (req->sv1); 1656 req->ptr1 = SvPVbyte_nolen (req->sv1);
1513 } 1657 }
1514 else 1658 else
1515 { 1659 {
1516 req->type = REQ_FSTAT; 1660 req->type = REQ_FSTAT;
1517 req->fh = newSVsv (fh_or_path);
1518 req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path))); 1661 req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
1519 } 1662 }
1520 1663
1521 REQ_SEND; 1664 REQ_SEND;
1522} 1665}
1523 1666
1524void 1667void
1668aio_utime (SV8 *fh_or_path, SV *atime, SV *mtime, SV *callback=&PL_sv_undef)
1669 PPCODE:
1670{
1671 dREQ;
1672
1673 req->nv1 = SvOK (atime) ? SvNV (atime) : -1.;
1674 req->nv2 = SvOK (mtime) ? SvNV (mtime) : -1.;
1675 req->sv1 = newSVsv (fh_or_path);
1676
1677 if (SvPOK (fh_or_path))
1678 {
1679 req->type = REQ_UTIME;
1680 req->ptr1 = SvPVbyte_nolen (req->sv1);
1681 }
1682 else
1683 {
1684 req->type = REQ_FUTIME;
1685 req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
1686 }
1687
1688 REQ_SEND;
1689}
1690
1691void
1692aio_truncate (SV8 *fh_or_path, SV *offset, SV *callback=&PL_sv_undef)
1693 PPCODE:
1694{
1695 dREQ;
1696
1697 req->sv1 = newSVsv (fh_or_path);
1698 req->offs = SvOK (offset) ? SvVAL64 (offset) : -1;
1699
1700 if (SvPOK (fh_or_path))
1701 {
1702 req->type = REQ_TRUNCATE;
1703 req->ptr1 = SvPVbyte_nolen (req->sv1);
1704 }
1705 else
1706 {
1707 req->type = REQ_FTRUNCATE;
1708 req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
1709 }
1710
1711 REQ_SEND;
1712}
1713
1714void
1715aio_chmod (SV8 *fh_or_path, int mode, SV *callback=&PL_sv_undef)
1716 PPCODE:
1717{
1718 dREQ;
1719
1720 req->mode = mode;
1721 req->sv1 = newSVsv (fh_or_path);
1722
1723 if (SvPOK (fh_or_path))
1724 {
1725 req->type = REQ_CHMOD;
1726 req->ptr1 = SvPVbyte_nolen (req->sv1);
1727 }
1728 else
1729 {
1730 req->type = REQ_FCHMOD;
1731 req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
1732 }
1733
1734 REQ_SEND;
1735}
1736
1737void
1738aio_chown (SV8 *fh_or_path, SV *uid, SV *gid, SV *callback=&PL_sv_undef)
1739 PPCODE:
1740{
1741 dREQ;
1742
1743 req->int2 = SvOK (uid) ? SvIV (uid) : -1;
1744 req->int3 = SvOK (gid) ? SvIV (gid) : -1;
1745 req->sv1 = newSVsv (fh_or_path);
1746
1747 if (SvPOK (fh_or_path))
1748 {
1749 req->type = REQ_CHOWN;
1750 req->ptr1 = SvPVbyte_nolen (req->sv1);
1751 }
1752 else
1753 {
1754 req->type = REQ_FCHOWN;
1755 req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
1756 }
1757
1758 REQ_SEND;
1759}
1760
1761void
1525aio_unlink (pathname,callback=&PL_sv_undef) 1762aio_unlink (SV8 *pathname, SV *callback=&PL_sv_undef)
1526 SV8 * pathname
1527 SV * callback
1528 ALIAS: 1763 ALIAS:
1529 aio_unlink = REQ_UNLINK 1764 aio_unlink = REQ_UNLINK
1530 aio_rmdir = REQ_RMDIR 1765 aio_rmdir = REQ_RMDIR
1531 aio_readdir = REQ_READDIR 1766 aio_readdir = REQ_READDIR
1532 PPCODE: 1767 PPCODE:
… …
1539 1774
1540 REQ_SEND; 1775 REQ_SEND;
1541} 1776}
1542 1777
1543void 1778void
1544aio_mkdir (pathname,mode,callback=&PL_sv_undef) 1779aio_mkdir (SV8 *pathname, int mode, SV *callback=&PL_sv_undef)
1545 SV8 * pathname
1546 UV mode
1547 SV * callback
1548 PPCODE: 1780 PPCODE:
1549{ 1781{
1550 dREQ; 1782 dREQ;
1551 1783
1552 req->type = REQ_MKDIR; 1784 req->type = REQ_MKDIR;
… …
1556 1788
1557 REQ_SEND; 1789 REQ_SEND;
1558} 1790}
1559 1791
1560void 1792void
1561aio_link (oldpath,newpath,callback=&PL_sv_undef) 1793aio_link (SV8 *oldpath, SV8 *newpath, SV *callback=&PL_sv_undef)
1562 SV8 * oldpath
1563 SV8 * newpath
1564 SV * callback
1565 ALIAS: 1794 ALIAS:
1566 aio_link = REQ_LINK 1795 aio_link = REQ_LINK
1567 aio_symlink = REQ_SYMLINK 1796 aio_symlink = REQ_SYMLINK
1568 aio_rename = REQ_RENAME 1797 aio_rename = REQ_RENAME
1569 PPCODE: 1798 PPCODE:
1570{ 1799{
1571 dREQ; 1800 dREQ;
1572 1801
1573 req->type = ix; 1802 req->type = ix;
1574 req->fh = newSVsv (oldpath); 1803 req->sv2 = newSVsv (oldpath);
1575 req->ptr2 = SvPVbyte_nolen (req->fh); 1804 req->ptr2 = SvPVbyte_nolen (req->sv2);
1576 req->sv1 = newSVsv (newpath); 1805 req->sv1 = newSVsv (newpath);
1577 req->ptr1 = SvPVbyte_nolen (req->sv1); 1806 req->ptr1 = SvPVbyte_nolen (req->sv1);
1578 1807
1579 REQ_SEND; 1808 REQ_SEND;
1580} 1809}
1581 1810
1582void 1811void
1583aio_mknod (pathname,mode,dev,callback=&PL_sv_undef) 1812aio_mknod (SV8 *pathname, int mode, UV dev, SV *callback=&PL_sv_undef)
1584 SV8 * pathname
1585 UV mode
1586 UV dev
1587 SV * callback
1588 PPCODE: 1813 PPCODE:
1589{ 1814{
1590 dREQ; 1815 dREQ;
1591 1816
1592 req->type = REQ_MKNOD; 1817 req->type = REQ_MKNOD;
… …
1597 1822
1598 REQ_SEND; 1823 REQ_SEND;
1599} 1824}
1600 1825
1601void 1826void
1602aio_busy (delay,callback=&PL_sv_undef) 1827aio_busy (double delay, SV *callback=&PL_sv_undef)
1603 double delay
1604 SV * callback
1605 PPCODE: 1828 PPCODE:
1606{ 1829{
1607 dREQ; 1830 dREQ;
1608 1831
1609 req->type = REQ_BUSY; 1832 req->type = REQ_BUSY;
1610 req->int1 = delay < 0. ? 0 : delay; 1833 req->nv1 = delay < 0. ? 0. : delay;
1611 req->int2 = delay < 0. ? 0 : 1000. * (delay - req->int1);
1612 1834
1613 REQ_SEND; 1835 REQ_SEND;
1614} 1836}
1615 1837
1616void 1838void
1617aio_group (callback=&PL_sv_undef) 1839aio_group (SV *callback=&PL_sv_undef)
1618 SV * callback
1619 PROTOTYPE: ;$ 1840 PROTOTYPE: ;$
1620 PPCODE: 1841 PPCODE:
1621{ 1842{
1622 dREQ; 1843 dREQ;
1623 1844
… …
1626 req_send (req); 1847 req_send (req);
1627 XPUSHs (req_sv (req, AIO_GRP_KLASS)); 1848 XPUSHs (req_sv (req, AIO_GRP_KLASS));
1628} 1849}
1629 1850
1630void 1851void
1631aio_nop (callback=&PL_sv_undef) 1852aio_nop (SV *callback=&PL_sv_undef)
1632 SV * callback
1633 PPCODE: 1853 PPCODE:
1634{ 1854{
1635 dREQ; 1855 dREQ;
1636 1856
1637 req->type = REQ_NOP; 1857 req->type = REQ_NOP;
… …
1708 CODE: 1928 CODE:
1709{ 1929{
1710 if (block_sig_level) 1930 if (block_sig_level)
1711 croak ("cannot call IO::AIO::setsig from within aio_block/callback"); 1931 croak ("cannot call IO::AIO::setsig from within aio_block/callback");
1712 1932
1713 LOCK (reslock); 1933 X_LOCK (reslock);
1714 main_tid = pthread_self (); 1934 main_tid = pthread_self ();
1715 main_sig = signum; 1935 main_sig = signum;
1716 UNLOCK (reslock); 1936 X_UNLOCK (reslock);
1717 1937
1718 if (main_sig && npending) 1938 if (main_sig && npending)
1719 pthread_kill (main_tid, main_sig); 1939 pthread_kill (main_tid, main_sig);
1720} 1940}
1721 1941
… …
1765 1985
1766int 1986int
1767nthreads() 1987nthreads()
1768 PROTOTYPE: 1988 PROTOTYPE:
1769 CODE: 1989 CODE:
1770 if (WORDACCESS_UNSAFE) LOCK (wrklock); 1990 if (WORDACCESS_UNSAFE) X_LOCK (wrklock);
1771 RETVAL = started; 1991 RETVAL = started;
1772 if (WORDACCESS_UNSAFE) UNLOCK (wrklock); 1992 if (WORDACCESS_UNSAFE) X_UNLOCK (wrklock);
1773 OUTPUT: 1993 OUTPUT:
1774 RETVAL 1994 RETVAL
1775 1995
1776PROTOTYPES: DISABLE 1996PROTOTYPES: DISABLE
1777 1997

Diff Legend

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