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.137 by root, Sun Apr 19 13:19:57 2009 UTC vs.
Revision 1.151 by root, Tue Jul 14 00:13:36 2009 UTC

… …
3#include <errno.h> 3#include <errno.h>
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
9#include "schmorp.h"
8 10
9#include <stddef.h> 11#include <stddef.h>
10#include <stdlib.h> 12#include <stdlib.h>
11#include <errno.h> 13#include <errno.h>
12#include <sys/types.h> 14#include <sys/types.h>
… …
75 77
76#define EIO_STRUCT_STAT Stat_t 78#define EIO_STRUCT_STAT Stat_t
77 79
78/* use NV for 32 bit perls as it allows larger offsets */ 80/* use NV for 32 bit perls as it allows larger offsets */
79#if IVSIZE >= 8 81#if IVSIZE >= 8
82# define VAL64 IV
80# define SvVAL64 SvIV 83# define SvVAL64 SvIV
84# define newSVval64 newSViv
81#else 85#else
86# define VAL64 NV
82# define SvVAL64 SvNV 87# define SvVAL64 SvNV
88# define newSVval64 newSVnv
83#endif 89#endif
84 90
85/*****************************************************************************/ 91/*****************************************************************************/
86 92
87#if __GNUC__ >= 3 93#if __GNUC__ >= 3
… …
95 101
96/*****************************************************************************/ 102/*****************************************************************************/
97 103
98static HV *stash; 104static HV *stash;
99typedef SV SV8; /* byte-sv, used for argument-checking */ 105typedef SV SV8; /* byte-sv, used for argument-checking */
106typedef int aio_rfd; /* read file desriptor */
107typedef int aio_wfd; /* write file descriptor */
100 108
101#define AIO_REQ_KLASS "IO::AIO::REQ" 109#define AIO_REQ_KLASS "IO::AIO::REQ"
102#define AIO_GRP_KLASS "IO::AIO::GRP" 110#define AIO_GRP_KLASS "IO::AIO::GRP"
103 111
104#define EIO_REQ_MEMBERS \ 112#define EIO_REQ_MEMBERS \
… …
108 SV *self; 116 SV *self;
109 117
110#define EIO_NO_WRAPPERS 1 118#define EIO_NO_WRAPPERS 1
111 119
112#include "libeio/eio.h" 120#include "libeio/eio.h"
121
122#ifndef POSIX_FADV_NORMAL
123# define POSIX_FADV_NORMAL 0
124# define NO_FADVISE 1
125#endif
126
127#ifndef POSIX_FADV_SEQUENTIAL
128# define POSIX_FADV_SEQUENTIAL 0
129#endif
130
131#ifndef POSIX_FADV_RANDOM
132# define POSIX_FADV_RANDOM 0
133#endif
134
135#ifndef POSIX_FADV_NOREUSE
136# define POSIX_FADV_NOREUSE 0
137#endif
138
139#ifndef POSIX_FADV_WILLNEED
140# define POSIX_FADV_WILLNEED 0
141#endif
142
143#ifndef POSIX_FADV_DONTNEED
144# define POSIX_FADV_DONTNEED 0
145#endif
113 146
114static int req_invoke (eio_req *req); 147static int req_invoke (eio_req *req);
115#define EIO_FINISH(req) req_invoke (req) 148#define EIO_FINISH(req) req_invoke (req)
116static void req_destroy (eio_req *grp); 149static void req_destroy (eio_req *grp);
117#define EIO_DESTROY(req) req_destroy (req) 150#define EIO_DESTROY(req) req_destroy (req)
… …
228 SV *rv = &PL_sv_undef; 261 SV *rv = &PL_sv_undef;
229 262
230 if (req->result >= 0) 263 if (req->result >= 0)
231 { 264 {
232 int i; 265 int i;
233 char *buf = req->ptr2; 266 char *names = (char *)req->ptr2;
267 eio_dirent *ent = (eio_dirent *)req->ptr1; /* might be 0 */
234 AV *av = newAV (); 268 AV *av = newAV ();
235 269
236 av_extend (av, req->result - 1); 270 av_extend (av, req->result - 1);
237 271
238 for (i = 0; i < req->result; ++i) 272 for (i = 0; i < req->result; ++i)
239 { 273 {
240 SV *sv = newSVpv (buf, 0); 274 if (req->int1 & EIO_READDIR_DENTS)
275 {
276 SV *namesv = newSVpvn (names + ent->nameofs, ent->namelen);
241 277
278 if (req->int1 & EIO_READDIR_CUSTOM2)
279 {
280 static SV *sv_type [EIO_DT_MAX + 1]; /* type sv cache */
281 AV *avent = newAV ();
282
283 av_extend (avent, 2);
284
285 if (!sv_type [ent->type])
286 {
287 sv_type [ent->type] = newSViv (ent->type);
288 SvREADONLY_on (sv_type [ent->type]);
289 }
290
291 av_store (avent, 0, namesv);
292 av_store (avent, 1, SvREFCNT_inc (sv_type [ent->type]));
293 av_store (avent, 2, IVSIZE >= 8 ? newSVuv (ent->inode) : newSVnv (ent->inode));
294
295 av_store (av, i, newRV_noinc ((SV *)avent));
296 }
297 else
242 av_store (av, i, sv); 298 av_store (av, i, namesv);
299
300 ++ent;
301 }
302 else
303 {
304 SV *name = newSVpv (names, 0);
305 av_store (av, i, name);
243 buf += SvCUR (sv) + 1; 306 names += SvCUR (name) + 1;
307 }
244 } 308 }
245 309
246 rv = sv_2mortal (newRV_noinc ((SV *)av)); 310 rv = sv_2mortal (newRV_noinc ((SV *)av));
247 } 311 }
248 312
249 PUSHs (rv); 313 PUSHs (rv);
314
315 if (req->int1 & EIO_READDIR_CUSTOM1)
316 XPUSHs (sv_2mortal (newSViv (req->int1 & ~(EIO_READDIR_CUSTOM1 | EIO_READDIR_CUSTOM2))));
250 } 317 }
251 break; 318 break;
252 319
253 case EIO_OPEN: 320 case EIO_OPEN:
254 { 321 {
… …
260 GV *gv = (GV *)sv_newmortal (); 327 GV *gv = (GV *)sv_newmortal ();
261 int flags = req->int1 & (O_RDONLY | O_WRONLY | O_RDWR); 328 int flags = req->int1 & (O_RDONLY | O_WRONLY | O_RDWR);
262 char sym [64]; 329 char sym [64];
263 int symlen; 330 int symlen;
264 331
265 symlen = snprintf (sym, sizeof (sym), "fd#%d", req->result); 332 symlen = snprintf (sym, sizeof (sym), "fd#%d", (int)req->result);
266 gv_init (gv, stash, sym, symlen, 0); 333 gv_init (gv, stash, sym, symlen, 0);
267 334
268 symlen = snprintf ( 335 symlen = snprintf (
269 sym, 336 sym,
270 sizeof (sym), 337 sizeof (sym),
271 "%s&=%d", 338 "%s&=%d",
272 flags == O_RDONLY ? "<" : flags == O_WRONLY ? ">" : "+<", 339 flags == O_RDONLY ? "<" : flags == O_WRONLY ? ">" : "+<",
273 req->result 340 (int)req->result
274 ); 341 );
275 342
276 if (do_open (gv, sym, symlen, 0, 0, 0, 0)) 343 if (do_open (gv, sym, symlen, 0, 0, 0, 0))
277 fh = (SV *)gv; 344 fh = (SV *)gv;
278 } 345 }
… …
312 PL_statcache = *(EIO_STRUCT_STAT *)(req->ptr2); 379 PL_statcache = *(EIO_STRUCT_STAT *)(req->ptr2);
313 PUSHs (sv_2mortal (newSViv (req->result))); 380 PUSHs (sv_2mortal (newSViv (req->result)));
314 break; 381 break;
315 382
316 case EIO_READ: 383 case EIO_READ:
384 {
317 SvCUR_set (req->sv2, req->stroffset + (req->result > 0 ? req->result : 0)); 385 SvCUR_set (req->sv2, req->stroffset + (req->result > 0 ? req->result : 0));
318 *SvEND (req->sv2) = 0; 386 *SvEND (req->sv2) = 0;
387 SvPOK_only (req->sv2);
388 SvSETMAGIC (req->sv2);
319 PUSHs (sv_2mortal (newSViv (req->result))); 389 PUSHs (sv_2mortal (newSViv (req->result)));
390 }
320 break; 391 break;
321 392
322 case EIO_DUP2: 393 case EIO_DUP2:
323 if (req->result > 0) 394 if (req->result > 0)
324 req->result = 0; 395 req->result = 0;
… …
500 SPAGAIN; \ 571 SPAGAIN; \
501 \ 572 \
502 if (GIMME_V != G_VOID) \ 573 if (GIMME_V != G_VOID) \
503 XPUSHs (req_sv (req, AIO_REQ_KLASS)); 574 XPUSHs (req_sv (req, AIO_REQ_KLASS));
504 575
505static int
506extract_fd (SV *fh, int wr)
507{
508 int fd = PerlIO_fileno (wr ? IoOFP (sv_2io (fh)) : IoIFP (sv_2io (fh)));
509
510 if (fd < 0)
511 croak ("illegal fh argument, either not an OS file or read/write mode mismatch");
512
513 return fd;
514}
515
516MODULE = IO::AIO PACKAGE = IO::AIO 576MODULE = IO::AIO PACKAGE = IO::AIO
517 577
518PROTOTYPES: ENABLE 578PROTOTYPES: ENABLE
519 579
520BOOT: 580BOOT:
521{ 581{
522 stash = gv_stashpv ("IO::AIO", 1); 582 static const struct {
523 583 const char *name;
524 newCONSTSUB (stash, "EXDEV", newSViv (EXDEV)); 584 IV iv;
525 newCONSTSUB (stash, "O_RDONLY", newSViv (O_RDONLY)); 585 } *civ, const_iv[] = {
526 newCONSTSUB (stash, "O_WRONLY", newSViv (O_WRONLY)); 586# define const_iv(name, value) { # name, (IV) value },
527 newCONSTSUB (stash, "O_CREAT", newSViv (O_CREAT)); 587# define const_eio(name) { # name, (IV) EIO_ ## name },
528 newCONSTSUB (stash, "O_TRUNC", newSViv (O_TRUNC)); 588 const_iv (EXDEV , EXDEV)
589 const_iv (ENOSYS , ENOSYS)
590 const_iv (O_RDONLY, O_RDONLY)
591 const_iv (O_WRONLY, O_WRONLY)
592 const_iv (O_CREAT , O_CREAT)
593 const_iv (O_TRUNC , O_TRUNC)
529#ifndef _WIN32 594#ifndef _WIN32
530 newCONSTSUB (stash, "S_IFIFO", newSViv (S_IFIFO)); 595 const_iv (S_IFIFO , S_IFIFO)
531#endif 596#endif
532 newCONSTSUB (stash, "S_IFIFO", newSViv (S_IFIFO)); 597 const_iv (FADV_NORMAL , POSIX_FADV_NORMAL)
533 newCONSTSUB (stash, "SYNC_FILE_RANGE_WAIT_BEFORE", newSViv (EIO_SYNC_FILE_RANGE_WAIT_BEFORE)); 598 const_iv (FADV_SEQUENTIAL, POSIX_FADV_SEQUENTIAL)
534 newCONSTSUB (stash, "SYNC_FILE_RANGE_WRITE" , newSViv (EIO_SYNC_FILE_RANGE_WRITE)); 599 const_iv (FADV_RANDOM , POSIX_FADV_RANDOM)
535 newCONSTSUB (stash, "SYNC_FILE_RANGE_WAIT_AFTER" , newSViv (EIO_SYNC_FILE_RANGE_WAIT_AFTER)); 600 const_iv (FADV_NOREUSE , POSIX_FADV_NOREUSE)
601 const_iv (FADV_WILLNEED , POSIX_FADV_WILLNEED)
602 const_iv (FADV_DONTNEED , POSIX_FADV_DONTNEED)
536 603
604 const_eio (SYNC_FILE_RANGE_WAIT_BEFORE)
605 const_eio (SYNC_FILE_RANGE_WRITE)
606 const_eio (SYNC_FILE_RANGE_WAIT_AFTER)
607
608 const_eio (READDIR_DENTS)
609 const_eio (READDIR_DIRS_FIRST)
610 const_eio (READDIR_STAT_ORDER)
611 const_eio (READDIR_FOUND_UNKNOWN)
612
613 const_eio (DT_UNKNOWN)
614 const_eio (DT_FIFO)
615 const_eio (DT_CHR)
616 const_eio (DT_DIR)
617 const_eio (DT_BLK)
618 const_eio (DT_REG)
619 const_eio (DT_LNK)
620 const_eio (DT_SOCK)
621 const_eio (DT_WHT)
622 };
623
624 stash = gv_stashpv ("IO::AIO", 1);
625
626 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
627 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
628
537 create_respipe (); 629 create_respipe ();
538 630
539 if (eio_init (want_poll, done_poll) < 0) 631 if (eio_init (want_poll, done_poll) < 0)
540 croak ("IO::AIO: unable to initialise eio library"); 632 croak ("IO::AIO: unable to initialise eio library");
541 633
542 /* atfork child called in fifo order, so before eio's handler */ 634 /* atfork child called in fifo order, so before eio's handler */
543 X_THREAD_ATFORK (0, 0, atfork_child); 635 X_THREAD_ATFORK (0, 0, atfork_child);
544} 636}
545 637
546void 638void
547max_poll_reqs (int nreqs) 639max_poll_reqs (int nreqs)
548 PROTOTYPE: $ 640 PROTOTYPE: $
… …
601 ALIAS: 693 ALIAS:
602 aio_fsync = EIO_FSYNC 694 aio_fsync = EIO_FSYNC
603 aio_fdatasync = EIO_FDATASYNC 695 aio_fdatasync = EIO_FDATASYNC
604 PPCODE: 696 PPCODE:
605{ 697{
606 int fd = extract_fd (fh, 0); 698 int fd = s_fileno_croak (fh, 0);
607 dREQ; 699 dREQ;
608 700
609 req->type = ix; 701 req->type = ix;
610 req->sv1 = newSVsv (fh); 702 req->sv1 = newSVsv (fh);
611 req->int1 = fd; 703 req->int1 = fd;
612 704
613 REQ_SEND (req); 705 REQ_SEND (req);
614} 706}
615 707
616void 708void
617aio_sync_file_range (SV *fh, SV *offset, SV *nbytes, IV flags, SV *callback=&PL_sv_undef) 709aio_sync_file_range (SV *fh, off_t offset, size_t nbytes, UV flags, SV *callback=&PL_sv_undef)
618 PROTOTYPE: $$$$;$ 710 PROTOTYPE: $$$$;$
619 PPCODE: 711 PPCODE:
620{ 712{
621 int fd = extract_fd (fh, 0); 713 int fd = s_fileno_croak (fh, 0);
622 dREQ; 714 dREQ;
623 715
624 req->type = EIO_SYNC_FILE_RANGE; 716 req->type = EIO_SYNC_FILE_RANGE;
625 req->sv1 = newSVsv (fh); 717 req->sv1 = newSVsv (fh);
626 req->int1 = fd; 718 req->int1 = fd;
627 req->offs = SvVAL64 (offset); 719 req->offs = offset;
628 req->size = SvVAL64 (nbytes); 720 req->size = nbytes;
629 req->int2 = flags; 721 req->int2 = flags;
630 722
631 REQ_SEND (req); 723 REQ_SEND (req);
632} 724}
633 725
… …
635aio_close (SV *fh, SV *callback=&PL_sv_undef) 727aio_close (SV *fh, SV *callback=&PL_sv_undef)
636 PROTOTYPE: $;$ 728 PROTOTYPE: $;$
637 PPCODE: 729 PPCODE:
638{ 730{
639 static int close_pipe = -1; /* dummy fd to close fds via dup2 */ 731 static int close_pipe = -1; /* dummy fd to close fds via dup2 */
640 int fd = extract_fd (fh, 0); 732 int fd = s_fileno_croak (fh, 0);
641 dREQ; 733 dREQ;
642 734
643 if (close_pipe < 0) 735 if (close_pipe < 0)
644 { 736 {
645 int pipefd [2]; 737 int pipefd [2];
… …
667 aio_write = EIO_WRITE 759 aio_write = EIO_WRITE
668 PROTOTYPE: $$$$$;$ 760 PROTOTYPE: $$$$$;$
669 PPCODE: 761 PPCODE:
670{ 762{
671 STRLEN svlen; 763 STRLEN svlen;
672 int fd = extract_fd (fh, ix == EIO_WRITE); 764 int fd = s_fileno_croak (fh, ix == EIO_WRITE);
673 char *svptr = SvPVbyte (data, svlen); 765 char *svptr = SvPVbyte (data, svlen);
674 UV len = SvUV (length); 766 UV len = SvUV (length);
675
676 if (SvTYPE (data) > SVt_PVMG || SvROK (data))
677 croak ("illegal data argument '%s', must be plain scalar string", SvPV_nolen (data));
678
679 SvUPGRADE (data, SVt_PV);
680 SvPOK_only (data);
681 767
682 if (dataoffset < 0) 768 if (dataoffset < 0)
683 dataoffset += svlen; 769 dataoffset += svlen;
684 770
685 if (dataoffset < 0 || dataoffset > svlen) 771 if (dataoffset < 0 || dataoffset > svlen)
… …
691 if (!SvOK (length) || len + dataoffset > svlen) 777 if (!SvOK (length) || len + dataoffset > svlen)
692 len = svlen - dataoffset; 778 len = svlen - dataoffset;
693 } 779 }
694 else 780 else
695 { 781 {
696 /* read: grow scalar as necessary */ 782 /* read: check type and grow scalar as necessary */
783 SvUPGRADE (data, SVt_PV);
697 svptr = SvGROW (data, len + dataoffset + 1); 784 svptr = SvGROW (data, len + dataoffset + 1);
698 } 785 }
699
700 if (len < 0)
701 croak ("length must not be negative");
702 786
703 { 787 {
704 dREQ; 788 dREQ;
705 789
706 req->type = ix; 790 req->type = ix;
… …
736 820
737 REQ_SEND; 821 REQ_SEND;
738} 822}
739 823
740void 824void
741aio_sendfile (SV *out_fh, SV *in_fh, SV *in_offset, UV length, SV *callback=&PL_sv_undef) 825aio_sendfile (SV *out_fh, SV *in_fh, off_t in_offset, size_t length, SV *callback=&PL_sv_undef)
742 PROTOTYPE: $$$$;$ 826 PROTOTYPE: $$$$;$
743 PPCODE: 827 PPCODE:
744{ 828{
745 int ifd = extract_fd (in_fh , 0); 829 int ifd = s_fileno_croak (in_fh , 0);
746 int ofd = extract_fd (out_fh, 0); 830 int ofd = s_fileno_croak (out_fh, 1);
747 dREQ; 831 dREQ;
748 832
749 req->type = EIO_SENDFILE; 833 req->type = EIO_SENDFILE;
750 req->sv1 = newSVsv (out_fh); 834 req->sv1 = newSVsv (out_fh);
751 req->int1 = ofd; 835 req->int1 = ofd;
752 req->sv2 = newSVsv (in_fh); 836 req->sv2 = newSVsv (in_fh);
753 req->int2 = ifd; 837 req->int2 = ifd;
754 req->offs = SvVAL64 (in_offset); 838 req->offs = in_offset;
755 req->size = length; 839 req->size = length;
756 840
757 REQ_SEND; 841 REQ_SEND;
758} 842}
759 843
760void 844void
761aio_readahead (SV *fh, SV *offset, IV length, SV *callback=&PL_sv_undef) 845aio_readahead (SV *fh, off_t offset, size_t length, SV *callback=&PL_sv_undef)
762 PROTOTYPE: $$$;$ 846 PROTOTYPE: $$$;$
763 PPCODE: 847 PPCODE:
764{ 848{
765 int fd = extract_fd (fh, 0); 849 int fd = s_fileno_croak (fh, 0);
766 dREQ; 850 dREQ;
767 851
768 req->type = EIO_READAHEAD; 852 req->type = EIO_READAHEAD;
769 req->sv1 = newSVsv (fh); 853 req->sv1 = newSVsv (fh);
770 req->int1 = fd; 854 req->int1 = fd;
771 req->offs = SvVAL64 (offset); 855 req->offs = offset;
772 req->size = length; 856 req->size = length;
773 857
774 REQ_SEND; 858 REQ_SEND;
775} 859}
776 860
… …
892 req->type = EIO_FCHOWN; 976 req->type = EIO_FCHOWN;
893 req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path))); 977 req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
894 } 978 }
895 979
896 REQ_SEND; 980 REQ_SEND;
981}
982
983void
984aio_readdirx (SV8 *pathname, IV flags, SV *callback=&PL_sv_undef)
985 PPCODE:
986{
987 dREQ;
988
989 req->type = EIO_READDIR;
990 req->sv1 = newSVsv (pathname);
991 req->ptr1 = SvPVbyte_nolen (req->sv1);
992 req->int1 = flags | EIO_READDIR_DENTS | EIO_READDIR_CUSTOM1;
993
994 if (flags & EIO_READDIR_DENTS)
995 req->int1 |= EIO_READDIR_CUSTOM2;
996
997 REQ_SEND;
897} 998}
898 999
899void 1000void
900aio_unlink (SV8 *pathname, SV *callback=&PL_sv_undef) 1001aio_unlink (SV8 *pathname, SV *callback=&PL_sv_undef)
901 ALIAS: 1002 ALIAS:
… …
1079 CODE: 1180 CODE:
1080 RETVAL = eio_nthreads (); 1181 RETVAL = eio_nthreads ();
1081 OUTPUT: 1182 OUTPUT:
1082 RETVAL 1183 RETVAL
1083 1184
1185int
1186fadvise (aio_rfd fh, off_t offset, off_t length, IV advice)
1187 PROTOTYPE: $$$$
1188 CODE:
1189#if _XOPEN_SOURCE >= 600 && !NO_FADVISE
1190 RETVAL = posix_fadvise (fh, offset, length, advice);
1191#else
1192 RETVAL = errno = ENOSYS;
1193#endif
1194 OUTPUT:
1195 RETVAL
1196
1197ssize_t
1198sendfile (aio_wfd ofh, aio_rfd ifh, off_t offset, size_t count)
1199 PROTOTYPE: $$$$
1200 CODE:
1201 eio_sendfile_sync (ofh, ifh, offset, count);
1202
1084void _on_next_submit (SV *cb) 1203void _on_next_submit (SV *cb)
1085 CODE: 1204 CODE:
1086 SvREFCNT_dec (on_next_submit); 1205 SvREFCNT_dec (on_next_submit);
1087 on_next_submit = SvOK (cb) ? newSVsv (cb) : 0; 1206 on_next_submit = SvOK (cb) ? newSVsv (cb) : 0;
1088 1207
… …
1149 AV *av; 1268 AV *av;
1150 1269
1151 grp->errorno = errno; 1270 grp->errorno = errno;
1152 1271
1153 av = newAV (); 1272 av = newAV ();
1273 av_extend (av, items - 1);
1154 1274
1155 for (i = 1; i < items; ++i ) 1275 for (i = 1; i < items; ++i )
1156 av_push (av, newSVsv (ST (i))); 1276 av_push (av, newSVsv (ST (i)));
1157 1277
1158 SvREFCNT_dec (grp->sv1); 1278 SvREFCNT_dec (grp->sv1);

Diff Legend

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