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.195 by root, Mon Sep 26 20:19:08 2011 UTC vs.
Revision 1.209 by root, Sun Apr 1 17:46:02 2012 UTC

… …
62 #undef dup 62 #undef dup
63 #undef dup2 63 #undef dup2
64 #undef abort 64 #undef abort
65 #undef pipe 65 #undef pipe
66 66
67 #define EIO_STRUCT_STAT struct _stati64
68 #define EIO_STRUCT_STATI64
69
67#else 70#else
68 71
69 #include <sys/time.h> 72 #include <sys/time.h>
70 #include <sys/select.h> 73 #include <sys/select.h>
71 #include <unistd.h> 74 #include <unistd.h>
72 #include <utime.h> 75 #include <utime.h>
73 #include <signal.h> 76 #include <signal.h>
74 77
75#endif
76
77#define EIO_STRUCT_STAT Stat_t 78 #define EIO_STRUCT_STAT Stat_t
79
80#endif
78 81
79/* use NV for 32 bit perls as it allows larger offsets */ 82/* use NV for 32 bit perls as it allows larger offsets */
80#if IVSIZE >= 8 83#if IVSIZE >= 8
81# define VAL64 IV 84# define VAL64 IV
82# define SvVAL64 SvIV 85# define SvVAL64 SvIV
… …
330 FLAG_SV2_RO_OFF = 0x40, /* data was set readonly */ 333 FLAG_SV2_RO_OFF = 0x40, /* data was set readonly */
331}; 334};
332 335
333typedef eio_req *aio_req; 336typedef eio_req *aio_req;
334typedef eio_req *aio_req_ornot; 337typedef eio_req *aio_req_ornot;
335typedef eio_wd *aio_wd; 338typedef eio_wd aio_wd;
336 339
337static SV *on_next_submit; 340static SV *on_next_submit;
338static int next_pri = EIO_PRI_DEFAULT; 341static int next_pri = EIO_PRI_DEFAULT;
339static int max_outstanding; 342static int max_outstanding;
340 343
341static s_epipe respipe; 344static s_epipe respipe;
342 345
343static void req_destroy (aio_req req); 346static void req_destroy (aio_req req);
344static void req_cancel (aio_req req); 347static void req_cancel (aio_req req);
345 348
346static void want_poll (void) 349static void
350want_poll (void)
347{ 351{
348 /* write a dummy byte to the pipe so fh becomes ready */ 352 /* write a dummy byte to the pipe so fh becomes ready */
349 s_epipe_signal (&respipe); 353 s_epipe_signal (&respipe);
350} 354}
351 355
352static void done_poll (void) 356static void
357done_poll (void)
353{ 358{
354 /* read any signals sent by the worker threads */ 359 /* read any signals sent by the worker threads */
355 s_epipe_drain (&respipe); 360 s_epipe_drain (&respipe);
356} 361}
357 362
358/* must be called at most once */ 363/* must be called at most once */
364static SV *
359static SV *req_sv (aio_req req, HV *stash) 365req_sv (aio_req req, HV *stash)
360{ 366{
361 if (!req->self) 367 if (!req->self)
362 { 368 {
363 req->self = (SV *)newHV (); 369 req->self = (SV *)newHV ();
364 sv_magic (req->self, 0, PERL_MAGIC_ext, (char *)req, 0); 370 sv_magic (req->self, 0, PERL_MAGIC_ext, (char *)req, 0);
365 } 371 }
366 372
367 return sv_2mortal (sv_bless (newRV_inc (req->self), stash)); 373 return sv_2mortal (sv_bless (newRV_inc (req->self), stash));
368} 374}
369 375
370static aio_req SvAIO_REQ (SV *sv) 376static SV *
377newSVaio_wd (aio_wd wd)
378{
379 return sv_bless (newRV_noinc (newSViv ((IV)wd)), aio_wd_stash);
380}
381
382static aio_req
383SvAIO_REQ (SV *sv)
371{ 384{
372 MAGIC *mg; 385 MAGIC *mg;
373 386
374 if (!SvROK (sv) 387 if (!SvROK (sv)
388 /* for speed reasons, we do not verify that SvROK actually has a stash ptr */
375 || (SvSTASH (SvRV (sv)) != aio_grp_stash 389 || (SvSTASH (SvRV (sv)) != aio_grp_stash
376 && SvSTASH (SvRV (sv)) != aio_req_stash 390 && SvSTASH (SvRV (sv)) != aio_req_stash
377 && !sv_derived_from (sv, "IO::AIO::REQ"))) 391 && !sv_derived_from (sv, "IO::AIO::REQ")))
378 croak ("object of class IO::AIO::REQ expected"); 392 croak ("object of class IO::AIO::REQ expected");
379 393
380 mg = mg_find (SvRV (sv), PERL_MAGIC_ext); 394 mg = mg_find (SvRV (sv), PERL_MAGIC_ext);
381 395
382 return mg ? (aio_req)mg->mg_ptr : 0; 396 return mg ? (aio_req)mg->mg_ptr : 0;
383} 397}
384 398
385static aio_wd SvAIO_WD (SV *sv) 399static aio_wd
400SvAIO_WD (SV *sv)
386{ 401{
387 if (!SvROK (sv) 402 if (!SvROK (sv)
403 || SvTYPE (SvRV (sv)) != SVt_PVMG
388 || SvSTASH (SvRV (sv)) != aio_wd_stash 404 || SvSTASH (SvRV (sv)) != aio_wd_stash)
389 || SvTYPE (SvRV (sv)) != SVt_PVMG)
390 croak ("IO::AIO: expected a working directory object as returned by aio_wd"); 405 croak ("IO::AIO: expected a working directory object as returned by aio_wd");
391 406
392 return (aio_wd)(long)SvIVX (SvRV (sv)); 407 return (aio_wd)(long)SvIVX (SvRV (sv));
393} 408}
394 409
410static void
395static void aio_grp_feed (aio_req grp) 411aio_grp_feed (aio_req grp)
396{ 412{
397 if (grp->sv2 && SvOK (grp->sv2)) 413 if (grp->sv2 && SvOK (grp->sv2))
398 { 414 {
399 dSP; 415 dSP;
400 416
… …
408 FREETMPS; 424 FREETMPS;
409 LEAVE; 425 LEAVE;
410 } 426 }
411} 427}
412 428
429static void
413static void req_submit (eio_req *req) 430req_submit (eio_req *req)
414{ 431{
415 eio_submit (req); 432 eio_submit (req);
416 433
417 if (expect_false (on_next_submit)) 434 if (expect_false (on_next_submit))
418 { 435 {
… …
425 PUTBACK; 442 PUTBACK;
426 call_sv (cb, G_DISCARD | G_EVAL); 443 call_sv (cb, G_DISCARD | G_EVAL);
427 } 444 }
428} 445}
429 446
447static int
430static int req_invoke (eio_req *req) 448req_invoke (eio_req *req)
431{ 449{
432 if (req->flags & FLAG_SV2_RO_OFF) 450 if (req->flags & FLAG_SV2_RO_OFF)
433 SvREADONLY_off (req->sv2); 451 SvREADONLY_off (req->sv2);
434 452
435 if (!EIO_CANCELLED (req) && req->callback) 453 if (!EIO_CANCELLED (req) && req->callback)
… …
457 } 475 }
458 476
459 switch (req->type) 477 switch (req->type)
460 { 478 {
461 case EIO_WD_OPEN: 479 case EIO_WD_OPEN:
462 PUSHs (sv_2mortal (sv_bless (newRV_noinc (newSViv (((long)req->wd))), aio_wd_stash))); 480 PUSHs (req->result ? &PL_sv_undef : sv_2mortal (newSVaio_wd (req->wd)));
463 break; 481 break;
464 482
465 case EIO_READDIR: 483 case EIO_READDIR:
466 { 484 {
467 SV *rv = &PL_sv_undef; 485 SV *rv = &PL_sv_undef;
… …
611 break; 629 break;
612 630
613 case EIO_STAT: 631 case EIO_STAT:
614 case EIO_LSTAT: 632 case EIO_LSTAT:
615 case EIO_FSTAT: 633 case EIO_FSTAT:
616 PL_laststype = req->type == EIO_LSTAT ? OP_LSTAT : OP_STAT; 634 PL_laststype = req->type == EIO_LSTAT ? OP_LSTAT : OP_STAT;
635
617 PL_laststatval = req->result; 636 if (!(PL_laststatval = req->result))
618 /* if compilation fails here then perl's Stat_t is not struct _stati64 */ 637 /* if compilation fails here then perl's Stat_t is not struct _stati64 */
619 PL_statcache = *(EIO_STRUCT_STAT *)(req->ptr2); 638 PL_statcache = *(EIO_STRUCT_STAT *)(req->ptr2);
639
620 PUSHs (sv_result); 640 PUSHs (sv_result);
641 break;
642
643 case EIO_SEEK:
644 PUSHs (req->result ? sv_result : sv_2mortal (newSVval64 (req->offs)));
621 break; 645 break;
622 646
623 case EIO_READ: 647 case EIO_READ:
624 { 648 {
625 SvCUR_set (req->sv2, req->stroffset + (req->result > 0 ? req->result : 0)); 649 SvCUR_set (req->sv2, req->stroffset + (req->result > 0 ? req->result : 0));
… …
658 } 682 }
659 683
660 return !!SvTRUE (ERRSV); 684 return !!SvTRUE (ERRSV);
661} 685}
662 686
687static void
663static void req_destroy (aio_req req) 688req_destroy (aio_req req)
664{ 689{
665 if (req->self) 690 if (req->self)
666 { 691 {
667 sv_unmagic (req->self, PERL_MAGIC_ext); 692 sv_unmagic (req->self, PERL_MAGIC_ext);
668 SvREFCNT_dec (req->self); 693 SvREFCNT_dec (req->self);
… …
672 SvREFCNT_dec (req->sv2); 697 SvREFCNT_dec (req->sv2);
673 SvREFCNT_dec (req->sv3); 698 SvREFCNT_dec (req->sv3);
674 SvREFCNT_dec (req->sv4); 699 SvREFCNT_dec (req->sv4);
675 SvREFCNT_dec (req->callback); 700 SvREFCNT_dec (req->callback);
676 701
677 Safefree (req); 702 free (req);
678} 703}
679 704
705static void
680static void req_cancel_subs (aio_req grp) 706req_cancel_subs (aio_req grp)
681{ 707{
682 if (grp->type != EIO_GROUP) 708 if (grp->type != EIO_GROUP)
683 return; 709 return;
684 710
685 SvREFCNT_dec (grp->sv2); 711 SvREFCNT_dec (grp->sv2);
686 grp->sv2 = 0; 712 grp->sv2 = 0;
687 713
688 eio_grp_cancel (grp); 714 eio_grp_cancel (grp);
689} 715}
690 716
717static void ecb_cold
691static void create_respipe (void) 718create_respipe (void)
692{ 719{
693 if (s_epipe_renew (&respipe)) 720 if (s_epipe_renew (&respipe))
694 croak ("IO::AIO: unable to initialize result pipe"); 721 croak ("IO::AIO: unable to initialize result pipe");
695} 722}
696 723
697static void poll_wait (void) 724static void
725poll_wait (void)
698{ 726{
699 while (eio_nreqs ()) 727 while (eio_nreqs ())
700 { 728 {
701 int size; 729 int size;
702 730
… …
711 739
712 s_epipe_wait (&respipe); 740 s_epipe_wait (&respipe);
713 } 741 }
714} 742}
715 743
716static int poll_cb (void) 744static int
745poll_cb (void)
717{ 746{
718 for (;;) 747 for (;;)
719 { 748 {
720 int res = eio_poll (); 749 int res = eio_poll ();
721 750
… …
754# define MAP_FIXED 0 783# define MAP_FIXED 0
755#endif 784#endif
756 785
757#define MMAP_MAGIC PERL_MAGIC_ext 786#define MMAP_MAGIC PERL_MAGIC_ext
758 787
788static int ecb_cold
759static int mmap_free (pTHX_ SV *sv, MAGIC *mg) 789mmap_free (pTHX_ SV *sv, MAGIC *mg)
760{ 790{
761 int old_errno = errno; 791 int old_errno = errno;
762 munmap (mg->mg_ptr, (size_t)mg->mg_obj); 792 munmap (mg->mg_ptr, (size_t)mg->mg_obj);
763 errno = old_errno; 793 errno = old_errno;
764 794
… …
780 0, 0, 0, 0, mmap_free 810 0, 0, 0, 0, mmap_free
781}; 811};
782 812
783/*****************************************************************************/ 813/*****************************************************************************/
784 814
815static SV *
785static SV * get_cb (SV *cb_sv) 816get_cb (SV *cb_sv)
786{ 817{
787 SvGETMAGIC (cb_sv); 818 SvGETMAGIC (cb_sv);
788 return SvOK (cb_sv) ? s_get_cv_croak (cb_sv) : 0; 819 return SvOK (cb_sv) ? s_get_cv_croak (cb_sv) : 0;
789} 820}
790 821
822static aio_req ecb_noinline
823dreq (SV *callback)
824{
825 SV *cb_cv;
826 aio_req req;
827 int req_pri = next_pri;
828 next_pri = EIO_PRI_DEFAULT;
829
830 cb_cv = get_cb (callback);
831
832 req = calloc (sizeof (*req), 1);
833 if (!req)
834 croak ("out of memory during eio_req allocation");
835
836 req->callback = SvREFCNT_inc (cb_cv);
837 req->pri = req_pri;
838
839 return req;
840}
841
791#define dREQ \ 842#define dREQ \
792 SV *cb_cv; \ 843 aio_req req = dreq (callback); \
793 aio_req req; \
794 int req_pri = next_pri; \
795 next_pri = EIO_PRI_DEFAULT; \
796 \
797 cb_cv = get_cb (callback); \
798 \
799 Newz (0, req, 1, eio_req); \
800 if (!req) \
801 croak ("out of memory during eio_req allocation"); \
802 \
803 req->callback = SvREFCNT_inc (cb_cv); \
804 req->pri = req_pri
805 844
806#define REQ_SEND \ 845#define REQ_SEND \
807 PUTBACK; \ 846 PUTBACK; \
808 req_submit (req); \ 847 req_submit (req); \
809 SPAGAIN; \ 848 SPAGAIN; \
810 \ 849 \
811 if (GIMME_V != G_VOID) \ 850 if (GIMME_V != G_VOID) \
812 XPUSHs (req_sv (req, aio_req_stash)); 851 XPUSHs (req_sv (req, aio_req_stash));
813 852
814static void 853ecb_inline void
815req_set_path (aio_req req, SV *path, SV **wdsv, SV **pathsv, eio_wd *wd, void **ptr) 854req_set_path (aio_req req, SV *path, SV **wdsv, SV **pathsv, eio_wd *wd, void **ptr)
816{ 855{
817 if (SvROK (path)) 856 if (expect_false (SvROK (path)))
818 { 857 {
819 AV *av = (AV *)SvRV (path); 858 SV *rv = SvRV (path);
820 SV *wdob; 859 SV *wdob;
821 860
822 if (SvTYPE (av) != SVt_PVAV || AvFILLp (av) != 1) 861 if (SvTYPE (rv) == SVt_PVAV && AvFILLp (rv) == 1)
823 croak ("IO::AIO: pathname arguments must be specified as strings or [wd, path] arrayrefs"); 862 {
824
825 path = AvARRAY (av)[1]; 863 path = AvARRAY (rv)[1];
826 wdob = AvARRAY (av)[0]; 864 wdob = AvARRAY (rv)[0];
827 865
866 if (SvOK (wdob))
867 {
828 *wd = SvAIO_WD (wdob); 868 *wd = SvAIO_WD (wdob);
829 *wdsv = SvREFCNT_inc_NN (SvRV (wdob)); 869 *wdsv = SvREFCNT_inc_NN (SvRV (wdob));
870 }
871 else
872 *wd = EIO_INVALID_WD;
873 }
874 else if (SvTYPE (rv) == SVt_PVMG && SvSTASH (rv) == aio_wd_stash)
875 {
876 *wd = (aio_wd)(long)SvIVX (rv);
877 *wdsv = SvREFCNT_inc_NN (rv);
878 *ptr = ".";
879 return; /* path set to "." */
880 }
881 else
882 croak ("IO::AIO: pathname arguments must be specified as a string, an IO::AIO::WD object or a [IO::AIO::WD, path] pair");
830 } 883 }
831 884
832 *pathsv = newSVsv (path); 885 *pathsv = newSVsv (path);
833 *ptr = SvPVbyte_nolen (*pathsv); 886 *ptr = SvPVbyte_nolen (*pathsv);
834} 887}
835 888
836static void 889static void ecb_noinline
837req_set_path1 (aio_req req, SV *path) 890req_set_path1 (aio_req req, SV *path)
838{ 891{
839 req_set_path (req, path, &req->sv1, &req->sv3, &req->wd, &req->ptr1); 892 req_set_path (req, path, &req->sv1, &req->sv3, &req->wd, &req->ptr1);
840} 893}
841 894
842static void 895static void ecb_noinline
843req_set_fh_or_path (aio_req req, int type_path, int type_fh, SV *fh_or_path) 896req_set_fh_or_path (aio_req req, int type_path, int type_fh, SV *fh_or_path)
844{ 897{
845 SV *rv = SvROK (fh_or_path) ? SvRV (fh_or_path) : fh_or_path; 898 SV *rv = SvROK (fh_or_path) ? SvRV (fh_or_path) : fh_or_path;
846 899
847 switch (SvTYPE (rv)) 900 switch (SvTYPE (rv))
… …
857 default: 910 default:
858 req->type = type_path; 911 req->type = type_path;
859 req_set_path1 (req, fh_or_path); 912 req_set_path1 (req, fh_or_path);
860 break; 913 break;
861 } 914 }
862
863} 915}
916
917XS(boot_IO__AIO) ecb_cold;
864 918
865MODULE = IO::AIO PACKAGE = IO::AIO 919MODULE = IO::AIO PACKAGE = IO::AIO
866 920
867PROTOTYPES: ENABLE 921PROTOTYPES: ENABLE
868 922
… …
952 const_iv (MAP_LOCKED) 1006 const_iv (MAP_LOCKED)
953 const_iv (MAP_NORESERVE) 1007 const_iv (MAP_NORESERVE)
954 const_iv (MAP_POPULATE) 1008 const_iv (MAP_POPULATE)
955 const_iv (MAP_NONBLOCK) 1009 const_iv (MAP_NONBLOCK)
956 1010
1011 const_eio (SEEK_SET)
1012 const_eio (SEEK_CUR)
1013 const_eio (SEEK_END)
1014
957 const_eio (MCL_FUTURE) 1015 const_eio (MCL_FUTURE)
958 const_eio (MCL_CURRENT) 1016 const_eio (MCL_CURRENT)
959 1017
960 const_eio (MS_ASYNC) 1018 const_eio (MS_ASYNC)
961 const_eio (MS_INVALIDATE) 1019 const_eio (MS_INVALIDATE)
… …
1083 1141
1084 req->type = ix; 1142 req->type = ix;
1085 req->sv1 = newSVsv (fh); 1143 req->sv1 = newSVsv (fh);
1086 req->int1 = fd; 1144 req->int1 = fd;
1087 1145
1088 REQ_SEND (req); 1146 REQ_SEND;
1089} 1147}
1090 1148
1091void 1149void
1092aio_sync_file_range (SV *fh, off_t offset, size_t nbytes, UV flags, SV *callback=&PL_sv_undef) 1150aio_sync_file_range (SV *fh, off_t offset, size_t nbytes, UV flags, SV *callback=&PL_sv_undef)
1093 PPCODE: 1151 PPCODE:
… …
1100 req->int1 = fd; 1158 req->int1 = fd;
1101 req->offs = offset; 1159 req->offs = offset;
1102 req->size = nbytes; 1160 req->size = nbytes;
1103 req->int2 = flags; 1161 req->int2 = flags;
1104 1162
1105 REQ_SEND (req); 1163 REQ_SEND;
1106} 1164}
1107 1165
1108void 1166void
1109aio_fallocate (SV *fh, int mode, off_t offset, size_t len, SV *callback=&PL_sv_undef) 1167aio_fallocate (SV *fh, int mode, off_t offset, size_t len, SV *callback=&PL_sv_undef)
1110 PPCODE: 1168 PPCODE:
… …
1117 req->int1 = fd; 1175 req->int1 = fd;
1118 req->int2 = mode; 1176 req->int2 = mode;
1119 req->offs = offset; 1177 req->offs = offset;
1120 req->size = len; 1178 req->size = len;
1121 1179
1122 REQ_SEND (req); 1180 REQ_SEND;
1123} 1181}
1124 1182
1125void 1183void
1126aio_close (SV *fh, SV *callback=&PL_sv_undef) 1184aio_close (SV *fh, SV *callback=&PL_sv_undef)
1127 PPCODE: 1185 PPCODE:
… …
1151 req->type = EIO_DUP2; 1209 req->type = EIO_DUP2;
1152 req->int1 = close_fd; 1210 req->int1 = close_fd;
1153 req->sv2 = newSVsv (fh); 1211 req->sv2 = newSVsv (fh);
1154 req->int2 = fd; 1212 req->int2 = fd;
1155 1213
1156 REQ_SEND (req); 1214 REQ_SEND;
1215}
1216
1217void
1218aio_seek (SV *fh, SV *offset, int whence, SV *callback=&PL_sv_undef)
1219 PPCODE:
1220{
1221 STRLEN svlen;
1222 int fd = s_fileno_croak (fh, 0);
1223 dREQ;
1224
1225 req->type = EIO_SEEK;
1226 req->sv1 = newSVsv (fh);
1227 req->int1 = fd;
1228 req->offs = SvVAL64 (offset);
1229 req->int2 = whence;
1230
1231 REQ_SEND;
1157} 1232}
1158 1233
1159void 1234void
1160aio_read (SV *fh, SV *offset, SV *length, SV8 *data, IV dataoffset, SV *callback=&PL_sv_undef) 1235aio_read (SV *fh, SV *offset, SV *length, SV8 *data, IV dataoffset, SV *callback=&PL_sv_undef)
1161 ALIAS: 1236 ALIAS:
… …
1267 aio_statvfs = EIO_STATVFS 1342 aio_statvfs = EIO_STATVFS
1268 PPCODE: 1343 PPCODE:
1269{ 1344{
1270 dREQ; 1345 dREQ;
1271 1346
1272 req->sv1 = newSVsv (fh_or_path);
1273 req_set_fh_or_path (req, ix, ix == EIO_STATVFS ? EIO_FSTATVFS : EIO_FSTAT, fh_or_path); 1347 req_set_fh_or_path (req, ix, ix == EIO_STATVFS ? EIO_FSTATVFS : EIO_FSTAT, fh_or_path);
1348
1274 REQ_SEND; 1349 REQ_SEND;
1275} 1350}
1276 1351
1277UV 1352UV
1278major (UV dev) 1353major (UV dev)
… …
1315 REQ_SEND; 1390 REQ_SEND;
1316} 1391}
1317 1392
1318void 1393void
1319aio_chmod (SV8 *fh_or_path, int mode, SV *callback=&PL_sv_undef) 1394aio_chmod (SV8 *fh_or_path, int mode, SV *callback=&PL_sv_undef)
1320 ALIAS:
1321 aio_chmod = EIO_CHMOD
1322 aio_mkdir = EIO_MKDIR
1323 PPCODE: 1395 PPCODE:
1324{ 1396{
1325 dREQ; 1397 dREQ;
1326 1398
1327 req->int2 = mode; 1399 req->int2 = mode;
… …
1348 PPCODE: 1420 PPCODE:
1349{ 1421{
1350 dREQ; 1422 dREQ;
1351 1423
1352 req->type = EIO_READDIR; 1424 req->type = EIO_READDIR;
1353 req->sv1 = newSVsv (pathname);
1354 req->ptr1 = SvPVbyte_nolen (req->sv1);
1355 req->int1 = flags | EIO_READDIR_DENTS | EIO_READDIR_CUSTOM1; 1425 req->int1 = flags | EIO_READDIR_DENTS | EIO_READDIR_CUSTOM1;
1356 1426
1357 if (flags & EIO_READDIR_DENTS) 1427 if (flags & EIO_READDIR_DENTS)
1358 req->int1 |= EIO_READDIR_CUSTOM2; 1428 req->int1 |= EIO_READDIR_CUSTOM2;
1359 1429
1430 req_set_path1 (req, pathname);
1431
1360 REQ_SEND; 1432 REQ_SEND;
1433}
1434
1435void
1436aio_mkdir (SV8 *pathname, int mode, SV *callback=&PL_sv_undef)
1437 PPCODE:
1438{
1439 dREQ;
1440
1441 req->type = EIO_MKDIR;
1442 req->int2 = mode;
1443 req_set_path1 (req, pathname);
1444
1445 REQ_SEND;
1361} 1446}
1362 1447
1363void 1448void
1364aio_unlink (SV8 *pathname, SV *callback=&PL_sv_undef) 1449aio_unlink (SV8 *pathname, SV *callback=&PL_sv_undef)
1365 ALIAS: 1450 ALIAS:
… …
1382 aio_link = EIO_LINK 1467 aio_link = EIO_LINK
1383 aio_symlink = EIO_SYMLINK 1468 aio_symlink = EIO_SYMLINK
1384 aio_rename = EIO_RENAME 1469 aio_rename = EIO_RENAME
1385 PPCODE: 1470 PPCODE:
1386{ 1471{
1472 eio_wd wd2 = 0;
1387 dREQ; 1473 dREQ;
1388 eio_wd wd2;
1389 1474
1390 req->type = ix; 1475 req->type = ix;
1391 req_set_path1 (req, oldpath); 1476 req_set_path1 (req, oldpath);
1392 req_set_path (req, newpath, &req->sv2, &req->sv4, &wd2, &req->ptr2); 1477 req_set_path (req, newpath, &req->sv2, &req->sv4, &wd2, &req->ptr2);
1393 req->int3 = (long)wd2; 1478 req->int3 = (long)wd2;
… …
1736 1821
1737PROTOTYPES: DISABLE 1822PROTOTYPES: DISABLE
1738 1823
1739MODULE = IO::AIO PACKAGE = IO::AIO::WD 1824MODULE = IO::AIO PACKAGE = IO::AIO::WD
1740 1825
1826BOOT:
1827{
1828 newCONSTSUB (aio_stash, "CWD" , newSVaio_wd (EIO_CWD ));
1829 newCONSTSUB (aio_stash, "INVALID_WD", newSVaio_wd (EIO_INVALID_WD));
1830}
1831
1741void 1832void
1742DESTROY (SV *self) 1833DESTROY (SV *self)
1743 CODE: 1834 CODE:
1744{ 1835{
1745 aio_wd wd = SvAIO_WD (self); 1836 aio_wd wd = SvAIO_WD (self);
1746#if HAVE_AT 1837#if HAVE_AT
1838 {
1747 SV *callback = &PL_sv_undef; 1839 SV *callback = &PL_sv_undef;
1748 dREQ; /* clobbers next_pri :/ */ 1840 dREQ; /* clobbers next_pri :/ */
1841 next_pri = req->pri; /* restore next_pri */
1842 req->pri = EIO_PRI_MAX; /* better use max. priority to conserve fds */
1749 req->type = EIO_WD_CLOSE; 1843 req->type = EIO_WD_CLOSE;
1750 req->wd = wd; 1844 req->wd = wd;
1751 REQ_SEND; 1845 REQ_SEND;
1846 }
1752#else 1847#else
1753 eio_wd_close_sync (wd); 1848 eio_wd_close_sync (wd);
1754#endif 1849#endif
1755} 1850}
1756 1851

Diff Legend

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