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.225 by root, Sat Dec 29 09:35:39 2012 UTC vs.
Revision 1.256 by root, Tue Feb 20 06:54:46 2018 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"
10 8
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/types.h> 12#include <sys/types.h>
… …
19 17
20#if _POSIX_MEMLOCK || _POSIX_MEMLOCK_RANGE || _POSIX_MAPPED_FILES 18#if _POSIX_MEMLOCK || _POSIX_MEMLOCK_RANGE || _POSIX_MAPPED_FILES
21# include <sys/mman.h> 19# include <sys/mman.h>
22#endif 20#endif
23 21
24#if __linux__ 22/* the incompetent fool that created musl keeps __linux__, refuses
23 * to implement any linux standard apis, and also has no way to test
24 * for his broken iplementation. don't complain to me if this fails
25 * for you.
26 */
27#if __linux__ && (defined __GLIBC__ || defined __UCLIBC__)
25# include <linux/fs.h> 28# include <linux/fs.h>
26# ifdef FS_IOC_FIEMAP 29# ifdef FS_IOC_FIEMAP
27# include <linux/types.h> 30# include <linux/types.h>
28# include <linux/fiemap.h> 31# include <linux/fiemap.h>
29# define HAVE_FIEMAP 1 32# define HAVE_FIEMAP 1
… …
99#define expect_false(expr) expect ((expr) != 0, 0) 102#define expect_false(expr) expect ((expr) != 0, 0)
100#define expect_true(expr) expect ((expr) != 0, 1) 103#define expect_true(expr) expect ((expr) != 0, 1)
101 104
102/*****************************************************************************/ 105/*****************************************************************************/
103 106
107#include "libeio/config.h"
108
109#include "schmorp.h"
110
111#if HAVE_EVENTFD
112# include <sys/eventfd.h>
113#endif
114
115#if HAVE_TIMERFD
116# include <sys/timerfd.h>
117#endif
118
119#if HAVE_RLIMITS
120 #include <sys/time.h>
121 #include <sys/resource.h>
122#endif
123
104typedef SV SV8; /* byte-sv, used for argument-checking */ 124typedef SV SV8; /* byte-sv, used for argument-checking */
105typedef int aio_rfd; /* read file desriptor */ 125typedef int aio_rfd; /* read file desriptor */
106typedef int aio_wfd; /* write file descriptor */ 126typedef int aio_wfd; /* write file descriptor */
107 127
108static HV *aio_stash, *aio_req_stash, *aio_grp_stash, *aio_wd_stash; 128static HV *aio_stash, *aio_req_stash, *aio_grp_stash, *aio_wd_stash;
… …
114 STRLEN stroffset; \ 134 STRLEN stroffset; \
115 SV *self; 135 SV *self;
116 136
117#define EIO_NO_WRAPPERS 1 137#define EIO_NO_WRAPPERS 1
118 138
119#include "libeio/config.h"
120#include "libeio/eio.h" 139#include "libeio/eio.h"
121 140
122static int req_invoke (eio_req *req); 141static int req_invoke (eio_req *req);
123#define EIO_FINISH(req) req_invoke (req) 142#define EIO_FINISH(req) req_invoke (req)
124static void req_destroy (eio_req *grp); 143static void req_destroy (eio_req *grp);
… …
141# define MAP_ANONYMOUS MAP_FIXED /* and hope this fails */ 160# define MAP_ANONYMOUS MAP_FIXED /* and hope this fails */
142# endif 161# endif
143#endif 162#endif
144 163
145/* defines all sorts of constants to 0 unless they are already defined */ 164/* defines all sorts of constants to 0 unless they are already defined */
165/* also provides const_iv_ and const_niv_ macros for them */
146#include "def0.h" 166#include "def0.h"
147 167
148#ifndef makedev 168#ifndef makedev
149# define makedev(maj,min) (((maj) << 8) | (min)) 169# define makedev(maj,min) (((maj) << 8) | (min))
150#endif 170#endif
… …
156#endif 176#endif
157 177
158#if PAGESIZE <= 0 178#if PAGESIZE <= 0
159# define PAGESIZE sysconf (_SC_PAGESIZE) 179# define PAGESIZE sysconf (_SC_PAGESIZE)
160#endif 180#endif
181
182/*****************************************************************************/
183
184#if !_POSIX_MAPPED_FILES
185# define mmap(addr,length,prot,flags,fd,offs) EIO_ENOSYS ()
186# define munmap(addr,length) EIO_ENOSYS ()
187#endif
188
189#if !_POSIX_MEMORY_PROTECTION
190# define mprotect(addr,len,prot) EIO_ENOSYS ()
191#endif
192
193#define FOREIGN_MAGIC PERL_MAGIC_ext
194
195static int ecb_cold
196mmap_free (pTHX_ SV *sv, MAGIC *mg)
197{
198 int old_errno = errno;
199 munmap (mg->mg_ptr, (size_t)mg->mg_obj);
200 errno = old_errno;
201
202 mg->mg_obj = 0; /* just in case */
203
204 SvREADONLY_off (sv);
205
206 if (SvPVX (sv) != mg->mg_ptr)
207 croak ("ERROR: IO::AIO::mmap-mapped scalar changed location, detected");
208
209 SvCUR_set (sv, 0);
210 SvPVX (sv) = 0;
211 SvOK_off (sv);
212
213 return 0;
214}
215
216static MGVTBL mmap_vtbl = {
217 0, 0, 0, 0, mmap_free
218};
219
220static int ecb_cold
221sysfree_free (pTHX_ SV *sv, MAGIC *mg)
222{
223 free (mg->mg_ptr);
224 mg->mg_obj = 0; /* just in case */
225
226 SvREADONLY_off (sv);
227
228 if (SvPVX (sv) != mg->mg_ptr)
229 croak ("ERROR: IO::AIO mapped scalar changed location, detected");
230
231 SvCUR_set (sv, 0);
232 SvPVX (sv) = 0;
233 SvOK_off (sv);
234
235 return 0;
236}
237
238static MGVTBL sysfree_vtbl = {
239 0, 0, 0, 0, sysfree_free
240};
241
242/*****************************************************************************/
243
244/* helper: set scalar to foreign ptr with custom free */
245static void
246sv_set_foreign (SV *sv, const MGVTBL *const vtbl, void *addr, IV length)
247{
248 sv_force_normal (sv);
249
250 /* we store the length in mg_obj, as namlen is I32 :/ */
251 sv_magicext (sv, 0, FOREIGN_MAGIC, vtbl, (char *)addr, 0)
252 ->mg_obj = (SV *)length;
253
254 SvUPGRADE (sv, SVt_PV); /* nop... */
255
256 if (SvLEN (sv))
257 Safefree (SvPVX (sv));
258
259 SvPVX (sv) = (char *)addr;
260 SvCUR_set (sv, length);
261 SvLEN_set (sv, 0);
262 SvPOK_only (sv);
263}
264
265static void
266sv_clear_foreign (SV *sv)
267{
268 /* todo: iterate over magic and only free ours, but of course */
269 /* the perl5porters will call that (correct) behaviour buggy */
270 sv_unmagic (sv, FOREIGN_MAGIC);
271}
161 272
162/*****************************************************************************/ 273/*****************************************************************************/
163 274
164static void 275static void
165fiemap (eio_req *req) 276fiemap (eio_req *req)
… …
198 || !fiemap->fm_mapped_extents /* no more extents */ 309 || !fiemap->fm_mapped_extents /* no more extents */
199 || fiemap->fm_extents [fiemap->fm_mapped_extents - 1].fe_flags & FIEMAP_EXTENT_LAST /* hit eof */) 310 || fiemap->fm_extents [fiemap->fm_mapped_extents - 1].fe_flags & FIEMAP_EXTENT_LAST /* hit eof */)
200 goto done; 311 goto done;
201 312
202 /* else we have to loop - 313 /* else we have to loop -
203 * it would be tempting (atcually I tried that first) to just query the 314 * it would be tempting (actually I tried that first) to just query the
204 * number of extents needed, but linux often feels like not returning all 315 * number of extents needed, but linux often feels like not returning all
205 * extents, without telling us it left any out. this complicates 316 * extents, without telling us it left any out. this complicates
206 * this quite a bit. 317 * this quite a bit.
207 */ 318 */
208 319
… …
221 incmap->fm_extent_count = (sizeof (scratch) - sizeof (struct fiemap)) / sizeof (struct fiemap_extent); 332 incmap->fm_extent_count = (sizeof (scratch) - sizeof (struct fiemap)) / sizeof (struct fiemap_extent);
222 333
223 if (ioctl (req->int1, FS_IOC_FIEMAP, incmap) < 0) 334 if (ioctl (req->int1, FS_IOC_FIEMAP, incmap) < 0)
224 return; 335 return;
225 336
337 if (!incmap->fm_mapped_extents)
338 goto done;
339
226 count = fiemap->fm_mapped_extents + incmap->fm_mapped_extents; 340 count = fiemap->fm_mapped_extents + incmap->fm_mapped_extents;
227 fiemap = realloc (fiemap, sizeof (*fiemap) + sizeof (struct fiemap_extent) * count); 341 fiemap = realloc (fiemap, sizeof (*fiemap) + sizeof (struct fiemap_extent) * count);
228 errno = ENOMEM; 342 errno = ENOMEM;
229 if (!fiemap) 343 if (!fiemap)
230 return; 344 return;
… …
301} 415}
302 416
303static SV * 417static SV *
304newSVaio_wd (aio_wd wd) 418newSVaio_wd (aio_wd wd)
305{ 419{
306 return sv_bless (newRV_noinc (newSViv ((IV)wd)), aio_wd_stash); 420 return sv_bless (newRV_noinc (newSViv ((intptr_t)wd)), aio_wd_stash);
307} 421}
308 422
309static aio_req 423static aio_req
310SvAIO_REQ (SV *sv) 424SvAIO_REQ (SV *sv)
311{ 425{
… …
330 || SvTYPE (SvRV (sv)) != SVt_PVMG 444 || SvTYPE (SvRV (sv)) != SVt_PVMG
331 || SvSTASH (SvRV (sv)) != aio_wd_stash) 445 || SvSTASH (SvRV (sv)) != aio_wd_stash)
332 croak ("IO::AIO: expected a working directory object as returned by aio_wd"); 446 croak ("IO::AIO: expected a working directory object as returned by aio_wd");
333 447
334 return (aio_wd)(long)SvIVX (SvRV (sv)); 448 return (aio_wd)(long)SvIVX (SvRV (sv));
449}
450
451static SV *
452newmortalFH (int fd, int flags)
453{
454 if (fd < 0)
455 return &PL_sv_undef;
456
457 GV *gv = (GV *)sv_newmortal ();
458 char sym[64];
459 int symlen;
460
461 symlen = snprintf (sym, sizeof (sym), "fd#%d", fd);
462 gv_init (gv, aio_stash, sym, symlen, 0);
463
464 symlen = snprintf (
465 sym,
466 sizeof (sym),
467 "%s&=%d",
468 flags == O_RDONLY ? "<" : flags == O_WRONLY ? ">" : "+<",
469 fd
470 );
471
472 return do_open (gv, sym, symlen, 0, 0, 0, 0)
473 ? (SV *)gv : &PL_sv_undef;
335} 474}
336 475
337static void 476static void
338aio_grp_feed (aio_req grp) 477aio_grp_feed (aio_req grp)
339{ 478{
… …
467 XPUSHs (sv_2mortal (newSViv (req->int1 & ~(EIO_READDIR_CUSTOM1 | EIO_READDIR_CUSTOM2)))); 606 XPUSHs (sv_2mortal (newSViv (req->int1 & ~(EIO_READDIR_CUSTOM1 | EIO_READDIR_CUSTOM2))));
468 } 607 }
469 break; 608 break;
470 609
471 case EIO_OPEN: 610 case EIO_OPEN:
472 { 611 PUSHs (newmortalFH (req->result, req->int1 & (O_RDONLY | O_WRONLY | O_RDWR)));
473 /* convert fd to fh */
474 SV *fh = &PL_sv_undef;
475
476 if (req->result >= 0)
477 {
478 GV *gv = (GV *)sv_newmortal ();
479 int flags = req->int1 & (O_RDONLY | O_WRONLY | O_RDWR);
480 char sym [64];
481 int symlen;
482
483 symlen = snprintf (sym, sizeof (sym), "fd#%d", (int)req->result);
484 gv_init (gv, aio_stash, sym, symlen, 0);
485
486 symlen = snprintf (
487 sym,
488 sizeof (sym),
489 "%s&=%d",
490 flags == O_RDONLY ? "<" : flags == O_WRONLY ? ">" : "+<",
491 (int)req->result
492 );
493
494 if (do_open (gv, sym, symlen, 0, 0, 0, 0))
495 fh = (SV *)gv;
496 }
497
498 PUSHs (fh);
499 }
500 break; 612 break;
501 613
502 case EIO_STATVFS: 614 case EIO_STATVFS:
503 case EIO_FSTATVFS: 615 case EIO_FSTATVFS:
504 { 616 {
… …
584 SvSETMAGIC (req->sv2); 696 SvSETMAGIC (req->sv2);
585 PUSHs (sv_result); 697 PUSHs (sv_result);
586 } 698 }
587 break; 699 break;
588 700
701 case EIO_SLURP:
702 {
703 if (req->result >= 0)
704 {
705 /* if length was originally not known, we steal the malloc'ed memory */
706 if (req->flags & EIO_FLAG_PTR2_FREE)
707 {
708 req->flags &= ~EIO_FLAG_PTR2_FREE;
709 sv_set_foreign (req->sv2, &sysfree_vtbl, req->ptr2, req->result);
710 }
711 else
712 {
713 SvCUR_set (req->sv2, req->result);
714 *SvEND (req->sv2) = 0;
715 SvPOK_only (req->sv2);
716 }
717
718 SvSETMAGIC (req->sv2);
719 }
720
721 PUSHs (sv_result);
722 }
723 break;
724
589 case EIO_CUSTOM: 725 case EIO_CUSTOM:
590 if (req->feed == fiemap) 726 if (req->feed == fiemap)
591 { 727 {
592#if HAVE_FIEMAP 728#if HAVE_FIEMAP
593 if (!req->result) 729 if (!req->result)
… …
698{ 834{
699 while (eio_nreqs ()) 835 while (eio_nreqs ())
700 { 836 {
701 int size; 837 int size;
702 838
703 X_LOCK (reslock); 839 X_LOCK (EIO_POOL->reslock);
704 size = res_queue.size; 840 size = EIO_POOL->res_queue.size;
705 X_UNLOCK (reslock); 841 X_UNLOCK (EIO_POOL->reslock);
706 842
707 if (size) 843 if (size)
708 return; 844 return;
709 845
710 etp_maybe_start_thread (); 846 etp_maybe_start_thread (EIO_POOL);
711 847
712 s_epipe_wait (&respipe); 848 s_epipe_wait (&respipe);
713 } 849 }
714} 850}
715 851
… …
736 create_respipe (); 872 create_respipe ();
737 873
738 if (eio_init (want_poll, done_poll) < 0) 874 if (eio_init (want_poll, done_poll) < 0)
739 croak ("IO::AIO: unable to initialise eio library"); 875 croak ("IO::AIO: unable to initialise eio library");
740} 876}
741
742/*****************************************************************************/
743
744#if !_POSIX_MAPPED_FILES
745# define mmap(addr,length,prot,flags,fd,offs) EIO_ENOSYS ()
746# define munmap(addr,length) EIO_ENOSYS ()
747#endif
748
749#if !_POSIX_MEMORY_PROTECTION
750# define mprotect(addr,len,prot) EIO_ENOSYS ()
751# define PROT_NONE 0
752# define PROT_WRITE 0
753# define MAP_PRIVATE 0
754# define MAP_SHARED 0
755# define MAP_FIXED 0
756#endif
757
758#define MMAP_MAGIC PERL_MAGIC_ext
759
760static int ecb_cold
761mmap_free (pTHX_ SV *sv, MAGIC *mg)
762{
763 int old_errno = errno;
764 munmap (mg->mg_ptr, (size_t)mg->mg_obj);
765 errno = old_errno;
766
767 mg->mg_obj = 0; /* just in case */
768
769 SvREADONLY_off (sv);
770
771 if (SvPVX (sv) != mg->mg_ptr)
772 croak ("ERROR: IO::AIO::mmap-mapped scalar changed location, detected");
773
774 SvCUR_set (sv, 0);
775 SvPVX (sv) = 0;
776 SvOK_off (sv);
777
778 return 0;
779}
780
781static MGVTBL mmap_vtbl = {
782 0, 0, 0, 0, mmap_free
783};
784 877
785/*****************************************************************************/ 878/*****************************************************************************/
786 879
787static SV * 880static SV *
788get_cb (SV *cb_sv) 881get_cb (SV *cb_sv)
… …
884 req_set_path1 (req, fh_or_path); 977 req_set_path1 (req, fh_or_path);
885 break; 978 break;
886 } 979 }
887} 980}
888 981
982/*****************************************************************************/
983
984static void
985ts_set (struct timespec *ts, NV value)
986{
987 ts->tv_sec = value;
988 ts->tv_nsec = (value - ts->tv_sec) * 1e9;
989}
990
991static NV
992ts_get (const struct timespec *ts)
993{
994 return ts->tv_sec + ts->tv_nsec * 1e-9;
995}
996
997/*****************************************************************************/
998
889XS(boot_IO__AIO) ecb_cold; 999XS(boot_IO__AIO) ecb_cold;
890 1000
891MODULE = IO::AIO PACKAGE = IO::AIO 1001MODULE = IO::AIO PACKAGE = IO::AIO
892 1002
893PROTOTYPES: ENABLE 1003PROTOTYPES: ENABLE
… …
900 } *civ, const_iv[] = { 1010 } *civ, const_iv[] = {
901# define const_niv(name, value) { # name, (IV) value }, 1011# define const_niv(name, value) { # name, (IV) value },
902# define const_iv(name) { # name, (IV) name }, 1012# define const_iv(name) { # name, (IV) name },
903# define const_eio(name) { # name, (IV) EIO_ ## name }, 1013# define const_eio(name) { # name, (IV) EIO_ ## name },
904 1014
905 /* you have to re-run ./gendef0 after adding/Removing any constants here */ 1015 /* you have to re-run ./gendef0 after adding/removing any constants here */
906 1016 /* the first block can be undef if missing */
907 const_iv (ENOSYS) 1017 const_iv (ENOSYS)
908 const_iv (EXDEV) 1018 const_iv (EXDEV)
909 const_iv (EBADR) 1019 const_iv (EBADR)
910 1020
1021 /* for lseek */
1022 const_iv (SEEK_DATA)
1023 const_iv (SEEK_HOLE)
1024
1025 const_niv (FADV_NORMAL , POSIX_FADV_NORMAL)
1026 const_niv (FADV_SEQUENTIAL, POSIX_FADV_SEQUENTIAL)
1027 const_niv (FADV_RANDOM , POSIX_FADV_RANDOM)
1028 const_niv (FADV_NOREUSE , POSIX_FADV_NOREUSE)
1029 const_niv (FADV_WILLNEED , POSIX_FADV_WILLNEED)
1030 const_niv (FADV_DONTNEED , POSIX_FADV_DONTNEED)
1031
1032 const_niv (MADV_NORMAL , POSIX_MADV_NORMAL)
1033 const_niv (MADV_SEQUENTIAL, POSIX_MADV_SEQUENTIAL)
1034 const_niv (MADV_RANDOM , POSIX_MADV_RANDOM)
1035 const_niv (MADV_WILLNEED , POSIX_MADV_WILLNEED)
1036 const_niv (MADV_DONTNEED , POSIX_MADV_DONTNEED)
1037
1038 /* the second block will be 0 when missing */
911 const_iv (O_RDONLY) 1039 const_iv (O_RDONLY)
912 const_iv (O_WRONLY) 1040 const_iv (O_WRONLY)
913 const_iv (O_RDWR) 1041 const_iv (O_RDWR)
914 const_iv (O_CREAT) 1042 const_iv (O_CREAT)
915 const_iv (O_TRUNC) 1043 const_iv (O_TRUNC)
… …
928 const_iv (O_SEARCH) 1056 const_iv (O_SEARCH)
929 const_iv (O_DIRECTORY) 1057 const_iv (O_DIRECTORY)
930 const_iv (O_DSYNC) 1058 const_iv (O_DSYNC)
931 const_iv (O_RSYNC) 1059 const_iv (O_RSYNC)
932 const_iv (O_SYNC) 1060 const_iv (O_SYNC)
1061 const_iv (O_PATH)
1062 const_iv (O_TMPFILE)
933 const_iv (O_TTY_INIT) 1063 const_iv (O_TTY_INIT)
934 1064
935 const_iv (S_IFIFO) 1065 const_iv (S_IFIFO)
936 const_iv (S_IFCHR) 1066 const_iv (S_IFCHR)
937 const_iv (S_IFBLK) 1067 const_iv (S_IFBLK)
… …
939 const_iv (S_IFREG) 1069 const_iv (S_IFREG)
940 const_iv (S_IFDIR) 1070 const_iv (S_IFDIR)
941 const_iv (S_IFWHT) 1071 const_iv (S_IFWHT)
942 const_iv (S_IFSOCK) 1072 const_iv (S_IFSOCK)
943 const_iv (S_IFMT) 1073 const_iv (S_IFMT)
944
945 const_niv (FADV_NORMAL , POSIX_FADV_NORMAL)
946 const_niv (FADV_SEQUENTIAL, POSIX_FADV_SEQUENTIAL)
947 const_niv (FADV_RANDOM , POSIX_FADV_RANDOM)
948 const_niv (FADV_NOREUSE , POSIX_FADV_NOREUSE)
949 const_niv (FADV_WILLNEED , POSIX_FADV_WILLNEED)
950 const_niv (FADV_DONTNEED , POSIX_FADV_DONTNEED)
951
952 const_niv (MADV_NORMAL , POSIX_MADV_NORMAL)
953 const_niv (MADV_SEQUENTIAL, POSIX_MADV_SEQUENTIAL)
954 const_niv (MADV_RANDOM , POSIX_MADV_RANDOM)
955 const_niv (MADV_WILLNEED , POSIX_MADV_WILLNEED)
956 const_niv (MADV_DONTNEED , POSIX_MADV_DONTNEED)
957 1074
958 const_iv (ST_RDONLY) 1075 const_iv (ST_RDONLY)
959 const_iv (ST_NOSUID) 1076 const_iv (ST_NOSUID)
960 const_iv (ST_NODEV) 1077 const_iv (ST_NODEV)
961 const_iv (ST_NOEXEC) 1078 const_iv (ST_NOEXEC)
… …
971 const_iv (PROT_NONE) 1088 const_iv (PROT_NONE)
972 const_iv (PROT_EXEC) 1089 const_iv (PROT_EXEC)
973 const_iv (PROT_READ) 1090 const_iv (PROT_READ)
974 const_iv (PROT_WRITE) 1091 const_iv (PROT_WRITE)
975 1092
976 /*const_iv (MAP_FIXED)*/
977 const_iv (MAP_PRIVATE) 1093 const_iv (MAP_PRIVATE)
978 const_iv (MAP_SHARED) 1094 const_iv (MAP_SHARED)
1095 const_iv (MAP_FIXED)
979 const_iv (MAP_ANONYMOUS) 1096 const_iv (MAP_ANONYMOUS)
980 1097
981 /* linuxish */ 1098 /* linuxish */
982 const_iv (MAP_HUGETLB)
983 const_iv (MAP_LOCKED) 1099 const_iv (MAP_LOCKED)
984 const_iv (MAP_NORESERVE) 1100 const_iv (MAP_NORESERVE)
985 const_iv (MAP_POPULATE) 1101 const_iv (MAP_POPULATE)
986 const_iv (MAP_NONBLOCK) 1102 const_iv (MAP_NONBLOCK)
1103 const_iv (MAP_GROWSDOWN)
1104 const_iv (MAP_32BIT)
1105 const_iv (MAP_HUGETLB)
1106 const_iv (MAP_STACK)
1107
1108 const_iv (F_DUPFD_CLOEXEC)
1109
1110 const_iv (F_OFD_GETLK)
1111 const_iv (F_OFD_SETLK)
1112 const_iv (F_OFD_GETLKW)
1113
1114 const_iv (FIFREEZE)
1115 const_iv (FITHAW)
1116 const_iv (FITRIM)
1117 const_iv (FICLONE)
1118 const_iv (FICLONERANGE)
1119 const_iv (FIDEDUPERANGE)
1120
1121 const_iv (FS_IOC_GETFLAGS)
1122 const_iv (FS_IOC_SETFLAGS)
1123 const_iv (FS_IOC_GETVERSION)
1124 const_iv (FS_IOC_SETVERSION)
1125 const_iv (FS_IOC_FIEMAP)
1126 const_iv (FS_IOC_FSGETXATTR)
1127 const_iv (FS_IOC_FSSETXATTR)
1128 const_iv (FS_IOC_SET_ENCRYPTION_POLICY)
1129 const_iv (FS_IOC_GET_ENCRYPTION_PWSALT)
1130 const_iv (FS_IOC_GET_ENCRYPTION_POLICY)
1131
1132 const_iv (FS_KEY_DESCRIPTOR_SIZE)
1133
1134 const_iv (FS_SECRM_FL)
1135 const_iv (FS_UNRM_FL)
1136 const_iv (FS_COMPR_FL)
1137 const_iv (FS_SYNC_FL)
1138 const_iv (FS_IMMUTABLE_FL)
1139 const_iv (FS_APPEND_FL)
1140 const_iv (FS_NODUMP_FL)
1141 const_iv (FS_NOATIME_FL)
1142 const_iv (FS_DIRTY_FL)
1143 const_iv (FS_COMPRBLK_FL)
1144 const_iv (FS_NOCOMP_FL)
1145 const_iv (FS_ENCRYPT_FL)
1146 const_iv (FS_BTREE_FL)
1147 const_iv (FS_INDEX_FL)
1148 const_iv (FS_JOURNAL_DATA_FL)
1149 const_iv (FS_NOTAIL_FL)
1150 const_iv (FS_DIRSYNC_FL)
1151 const_iv (FS_TOPDIR_FL)
1152 const_iv (FS_FL_USER_MODIFIABLE)
1153
1154 const_iv (FS_XFLAG_REALTIME)
1155 const_iv (FS_XFLAG_PREALLOC)
1156 const_iv (FS_XFLAG_IMMUTABLE)
1157 const_iv (FS_XFLAG_APPEND)
1158 const_iv (FS_XFLAG_SYNC)
1159 const_iv (FS_XFLAG_NOATIME)
1160 const_iv (FS_XFLAG_NODUMP)
1161 const_iv (FS_XFLAG_RTINHERIT)
1162 const_iv (FS_XFLAG_PROJINHERIT)
1163 const_iv (FS_XFLAG_NOSYMLINKS)
1164 const_iv (FS_XFLAG_EXTSIZE)
1165 const_iv (FS_XFLAG_EXTSZINHERIT)
1166 const_iv (FS_XFLAG_NODEFRAG)
1167 const_iv (FS_XFLAG_FILESTREAM)
1168 const_iv (FS_XFLAG_DAX)
1169 const_iv (FS_XFLAG_HASATTR)
987 1170
988 const_iv (FIEMAP_FLAG_SYNC) 1171 const_iv (FIEMAP_FLAG_SYNC)
989 const_iv (FIEMAP_FLAG_XATTR) 1172 const_iv (FIEMAP_FLAG_XATTR)
990 const_iv (FIEMAP_FLAGS_COMPAT) 1173 const_iv (FIEMAP_FLAGS_COMPAT)
991 const_iv (FIEMAP_EXTENT_LAST) 1174 const_iv (FIEMAP_EXTENT_LAST)
… …
1003 const_iv (SPLICE_F_MOVE) 1186 const_iv (SPLICE_F_MOVE)
1004 const_iv (SPLICE_F_NONBLOCK) 1187 const_iv (SPLICE_F_NONBLOCK)
1005 const_iv (SPLICE_F_MORE) 1188 const_iv (SPLICE_F_MORE)
1006 const_iv (SPLICE_F_GIFT) 1189 const_iv (SPLICE_F_GIFT)
1007 1190
1008 const_iv (SEEK_DATA) 1191 const_iv (EFD_CLOEXEC)
1192 const_iv (EFD_NONBLOCK)
1009 const_iv (SEEK_HOLE) 1193 const_iv (EFD_SEMAPHORE)
1010 1194
1011 /* libeio constants */ 1195 const_iv (CLOCK_REALTIME)
1196 const_iv (CLOCK_MONOTONIC)
1197 const_iv (CLOCK_BOOTTIME)
1198 const_iv (CLOCK_REALTIME_ALARM)
1199 const_iv (CLOCK_BOOTTIME_ALARM)
1200
1201 const_iv (TFD_NONBLOCK)
1202 const_iv (TFD_CLOEXEC)
1203
1204 const_iv (TFD_TIMER_ABSTIME)
1205 const_iv (TFD_TIMER_CANCEL_ON_SET)
1206
1207 /* these are libeio constants, and are independent of gendef0 */
1012 const_eio (SEEK_SET) 1208 const_eio (SEEK_SET)
1013 const_eio (SEEK_CUR) 1209 const_eio (SEEK_CUR)
1014 const_eio (SEEK_END) 1210 const_eio (SEEK_END)
1015 1211
1016 const_eio (MCL_FUTURE) 1212 const_eio (MCL_FUTURE)
… …
1026 const_eio (SYNC_FILE_RANGE_WRITE) 1222 const_eio (SYNC_FILE_RANGE_WRITE)
1027 const_eio (SYNC_FILE_RANGE_WAIT_AFTER) 1223 const_eio (SYNC_FILE_RANGE_WAIT_AFTER)
1028 1224
1029 const_eio (FALLOC_FL_KEEP_SIZE) 1225 const_eio (FALLOC_FL_KEEP_SIZE)
1030 const_eio (FALLOC_FL_PUNCH_HOLE) 1226 const_eio (FALLOC_FL_PUNCH_HOLE)
1227 const_eio (FALLOC_FL_COLLAPSE_RANGE)
1228 const_eio (FALLOC_FL_ZERO_RANGE)
1229 const_eio (FALLOC_FL_INSERT_RANGE)
1230 const_eio (FALLOC_FL_UNSHARE_RANGE)
1231
1232 const_eio (RENAME_NOREPLACE)
1233 const_eio (RENAME_EXCHANGE)
1234 const_eio (RENAME_WHITEOUT)
1031 1235
1032 const_eio (READDIR_DENTS) 1236 const_eio (READDIR_DENTS)
1033 const_eio (READDIR_DIRS_FIRST) 1237 const_eio (READDIR_DIRS_FIRST)
1034 const_eio (READDIR_STAT_ORDER) 1238 const_eio (READDIR_STAT_ORDER)
1035 const_eio (READDIR_FOUND_UNKNOWN) 1239 const_eio (READDIR_FOUND_UNKNOWN)
… …
1103 PROTOTYPE: $ 1307 PROTOTYPE: $
1104 CODE: 1308 CODE:
1105 max_outstanding = maxreqs; 1309 max_outstanding = maxreqs;
1106 1310
1107void 1311void
1108aio_wd (SV8 *pathname, SV *callback=&PL_sv_undef) 1312aio_wd (SV8 *pathname, SV *callback = &PL_sv_undef)
1109 PPCODE: 1313 PPCODE:
1110{ 1314{
1111 dREQ; 1315 dREQ;
1112 1316
1113 req->type = EIO_WD_OPEN; 1317 req->type = EIO_WD_OPEN;
… …
1115 1319
1116 REQ_SEND; 1320 REQ_SEND;
1117} 1321}
1118 1322
1119void 1323void
1120aio_open (SV8 *pathname, int flags, int mode, SV *callback=&PL_sv_undef) 1324aio_open (SV8 *pathname, int flags, int mode, SV *callback = &PL_sv_undef)
1121 PPCODE: 1325 PPCODE:
1122{ 1326{
1123 dREQ; 1327 dREQ;
1124 1328
1125 req->type = EIO_OPEN; 1329 req->type = EIO_OPEN;
… …
1129 1333
1130 REQ_SEND; 1334 REQ_SEND;
1131} 1335}
1132 1336
1133void 1337void
1134aio_fsync (SV *fh, SV *callback=&PL_sv_undef) 1338aio_fsync (SV *fh, SV *callback = &PL_sv_undef)
1135 ALIAS: 1339 ALIAS:
1136 aio_fsync = EIO_FSYNC 1340 aio_fsync = EIO_FSYNC
1137 aio_fdatasync = EIO_FDATASYNC 1341 aio_fdatasync = EIO_FDATASYNC
1138 aio_syncfs = EIO_SYNCFS 1342 aio_syncfs = EIO_SYNCFS
1139 PPCODE: 1343 PPCODE:
… …
1147 1351
1148 REQ_SEND; 1352 REQ_SEND;
1149} 1353}
1150 1354
1151void 1355void
1152aio_sync_file_range (SV *fh, off_t offset, size_t nbytes, UV flags, SV *callback=&PL_sv_undef) 1356aio_sync_file_range (SV *fh, off_t offset, size_t nbytes, UV flags, SV *callback = &PL_sv_undef)
1153 PPCODE: 1357 PPCODE:
1154{ 1358{
1155 int fd = s_fileno_croak (fh, 0); 1359 int fd = s_fileno_croak (fh, 0);
1156 dREQ; 1360 dREQ;
1157 1361
… …
1164 1368
1165 REQ_SEND; 1369 REQ_SEND;
1166} 1370}
1167 1371
1168void 1372void
1169aio_allocate (SV *fh, int mode, off_t offset, size_t len, SV *callback=&PL_sv_undef) 1373aio_allocate (SV *fh, int mode, off_t offset, size_t len, SV *callback = &PL_sv_undef)
1170 PPCODE: 1374 PPCODE:
1171{ 1375{
1172 int fd = s_fileno_croak (fh, 0); 1376 int fd = s_fileno_croak (fh, 0);
1173 dREQ; 1377 dREQ;
1174 1378
… …
1181 1385
1182 REQ_SEND; 1386 REQ_SEND;
1183} 1387}
1184 1388
1185void 1389void
1186aio_close (SV *fh, SV *callback=&PL_sv_undef) 1390aio_close (SV *fh, SV *callback = &PL_sv_undef)
1187 PPCODE: 1391 PPCODE:
1188{ 1392{
1189 static int close_fd = -1; /* dummy fd to close fds via dup2 */ 1393 static int close_fd = -1; /* dummy fd to close fds via dup2 */
1190 int fd = s_fileno_croak (fh, 0); 1394 int fd = s_fileno_croak (fh, 0);
1191 dREQ; 1395 dREQ;
… …
1215 1419
1216 REQ_SEND; 1420 REQ_SEND;
1217} 1421}
1218 1422
1219void 1423void
1220aio_seek (SV *fh, SV *offset, int whence, SV *callback=&PL_sv_undef) 1424aio_seek (SV *fh, SV *offset, int whence, SV *callback = &PL_sv_undef)
1221 PPCODE: 1425 PPCODE:
1222{ 1426{
1223 int fd = s_fileno_croak (fh, 0); 1427 int fd = s_fileno_croak (fh, 0);
1224 dREQ; 1428 dREQ;
1225 1429
… …
1231 1435
1232 REQ_SEND; 1436 REQ_SEND;
1233} 1437}
1234 1438
1235void 1439void
1236aio_read (SV *fh, SV *offset, SV *length, SV8 *data, IV dataoffset, SV *callback=&PL_sv_undef) 1440aio_read (SV *fh, SV *offset, SV *length, SV8 *data, IV dataoffset, SV *callback = &PL_sv_undef)
1237 ALIAS: 1441 ALIAS:
1238 aio_read = EIO_READ 1442 aio_read = EIO_READ
1239 aio_write = EIO_WRITE 1443 aio_write = EIO_WRITE
1240 PPCODE: 1444 PPCODE:
1241{ 1445{
… …
1257 len = svlen - dataoffset; 1461 len = svlen - dataoffset;
1258 } 1462 }
1259 else 1463 else
1260 { 1464 {
1261 /* read: check type and grow scalar as necessary */ 1465 /* read: check type and grow scalar as necessary */
1262 SvUPGRADE (data, SVt_PV);
1263 if (SvLEN (data) >= SvCUR (data)) 1466 if (!SvPOK (data) || SvLEN (data) >= SvCUR (data))
1264 svptr = SvGROW (data, len + dataoffset + 1); 1467 svptr = sv_grow (data, len + dataoffset + 1);
1265 else if (SvCUR (data) < len + dataoffset) 1468 else if (SvCUR (data) < len + dataoffset)
1266 croak ("length + dataoffset outside of scalar, and cannot grow"); 1469 croak ("length + dataoffset outside of scalar, and cannot grow");
1267 } 1470 }
1268 1471
1269 { 1472 {
… …
1287 REQ_SEND; 1490 REQ_SEND;
1288 } 1491 }
1289} 1492}
1290 1493
1291void 1494void
1495aio_ioctl (SV *fh, unsigned long request, SV8 *arg, SV *callback = &PL_sv_undef)
1496 ALIAS:
1497 aio_ioctl = EIO_IOCTL
1498 aio_fcntl = EIO_FCNTL
1499 PPCODE:
1500{
1501 int fd = s_fileno_croak (fh, 0);
1502 char *svptr;
1503
1504 if (SvPOK (arg) || !SvNIOK (arg))
1505 {
1506 STRLEN svlen;
1507 /* perl uses IOCPARM_LEN for fcntl, so we do, too */
1508#ifdef IOCPARM_LEN
1509 STRLEN need = IOCPARM_LEN (request);
1510#else
1511 STRLEN need = 256;
1512#endif
1513
1514 if (svlen < need)
1515 svptr = SvGROW (arg, need);
1516 }
1517 else
1518 svptr = (char *)SvIV (arg);
1519
1520 {
1521 dREQ;
1522
1523 req->type = ix;
1524 req->sv1 = newSVsv (fh);
1525 req->int1 = fd;
1526 req->int2 = (long)request;
1527 req->sv2 = SvREFCNT_inc (arg);
1528 req->ptr2 = svptr;
1529
1530 REQ_SEND;
1531 }
1532}
1533
1534void
1292aio_readlink (SV8 *pathname, SV *callback=&PL_sv_undef) 1535aio_readlink (SV8 *pathname, SV *callback = &PL_sv_undef)
1293 ALIAS: 1536 ALIAS:
1294 aio_readlink = EIO_READLINK 1537 aio_readlink = EIO_READLINK
1295 aio_realpath = EIO_REALPATH 1538 aio_realpath = EIO_REALPATH
1296 PPCODE: 1539 PPCODE:
1297{ 1540{
… …
1302 1545
1303 REQ_SEND; 1546 REQ_SEND;
1304} 1547}
1305 1548
1306void 1549void
1307aio_sendfile (SV *out_fh, SV *in_fh, off_t in_offset, size_t length, SV *callback=&PL_sv_undef) 1550aio_sendfile (SV *out_fh, SV *in_fh, off_t in_offset, size_t length, SV *callback = &PL_sv_undef)
1308 PPCODE: 1551 PPCODE:
1309{ 1552{
1310 int ifd = s_fileno_croak (in_fh , 0); 1553 int ifd = s_fileno_croak (in_fh , 0);
1311 int ofd = s_fileno_croak (out_fh, 1); 1554 int ofd = s_fileno_croak (out_fh, 1);
1312 dREQ; 1555 dREQ;
… …
1321 1564
1322 REQ_SEND; 1565 REQ_SEND;
1323} 1566}
1324 1567
1325void 1568void
1326aio_readahead (SV *fh, off_t offset, size_t length, SV *callback=&PL_sv_undef) 1569aio_readahead (SV *fh, off_t offset, size_t length, SV *callback = &PL_sv_undef)
1327 PPCODE: 1570 PPCODE:
1328{ 1571{
1329 int fd = s_fileno_croak (fh, 0); 1572 int fd = s_fileno_croak (fh, 0);
1330 dREQ; 1573 dREQ;
1331 1574
… …
1337 1580
1338 REQ_SEND; 1581 REQ_SEND;
1339} 1582}
1340 1583
1341void 1584void
1342aio_stat (SV8 *fh_or_path, SV *callback=&PL_sv_undef) 1585aio_stat (SV8 *fh_or_path, SV *callback = &PL_sv_undef)
1343 ALIAS: 1586 ALIAS:
1344 aio_stat = EIO_STAT 1587 aio_stat = EIO_STAT
1345 aio_lstat = EIO_LSTAT 1588 aio_lstat = EIO_LSTAT
1346 aio_statvfs = EIO_STATVFS 1589 aio_statvfs = EIO_STATVFS
1347 PPCODE: 1590 PPCODE:
… …
1356UV 1599UV
1357major (UV dev) 1600major (UV dev)
1358 ALIAS: 1601 ALIAS:
1359 minor = 1 1602 minor = 1
1360 CODE: 1603 CODE:
1361 RETVAL = ix ? major (dev) : minor (dev); 1604 RETVAL = ix ? minor (dev) : major (dev);
1362 OUTPUT: 1605 OUTPUT:
1363 RETVAL 1606 RETVAL
1364 1607
1365UV 1608UV
1366makedev (UV maj, UV min) 1609makedev (UV maj, UV min)
… …
1368 RETVAL = makedev (maj, min); 1611 RETVAL = makedev (maj, min);
1369 OUTPUT: 1612 OUTPUT:
1370 RETVAL 1613 RETVAL
1371 1614
1372void 1615void
1373aio_utime (SV8 *fh_or_path, SV *atime, SV *mtime, SV *callback=&PL_sv_undef) 1616aio_utime (SV8 *fh_or_path, SV *atime, SV *mtime, SV *callback = &PL_sv_undef)
1374 PPCODE: 1617 PPCODE:
1375{ 1618{
1376 dREQ; 1619 dREQ;
1377 1620
1378 req->nv1 = SvOK (atime) ? SvNV (atime) : -1.; 1621 req->nv1 = SvOK (atime) ? SvNV (atime) : -1.;
… …
1381 1624
1382 REQ_SEND; 1625 REQ_SEND;
1383} 1626}
1384 1627
1385void 1628void
1386aio_truncate (SV8 *fh_or_path, SV *offset, SV *callback=&PL_sv_undef) 1629aio_truncate (SV8 *fh_or_path, SV *offset, SV *callback = &PL_sv_undef)
1387 PPCODE: 1630 PPCODE:
1388{ 1631{
1389 dREQ; 1632 dREQ;
1390 1633
1391 req->offs = SvOK (offset) ? SvVAL64 (offset) : -1; 1634 req->offs = SvOK (offset) ? SvVAL64 (offset) : -1;
… …
1393 1636
1394 REQ_SEND; 1637 REQ_SEND;
1395} 1638}
1396 1639
1397void 1640void
1398aio_chmod (SV8 *fh_or_path, int mode, SV *callback=&PL_sv_undef) 1641aio_chmod (SV8 *fh_or_path, int mode, SV *callback = &PL_sv_undef)
1399 PPCODE: 1642 PPCODE:
1400{ 1643{
1401 dREQ; 1644 dREQ;
1402 1645
1403 req->int2 = mode; 1646 req->int2 = mode;
… …
1405 1648
1406 REQ_SEND; 1649 REQ_SEND;
1407} 1650}
1408 1651
1409void 1652void
1410aio_chown (SV8 *fh_or_path, SV *uid, SV *gid, SV *callback=&PL_sv_undef) 1653aio_chown (SV8 *fh_or_path, SV *uid, SV *gid, SV *callback = &PL_sv_undef)
1411 PPCODE: 1654 PPCODE:
1412{ 1655{
1413 dREQ; 1656 dREQ;
1414 1657
1415 req->int2 = SvOK (uid) ? SvIV (uid) : -1; 1658 req->int2 = SvOK (uid) ? SvIV (uid) : -1;
… …
1418 1661
1419 REQ_SEND; 1662 REQ_SEND;
1420} 1663}
1421 1664
1422void 1665void
1423aio_readdirx (SV8 *pathname, IV flags, SV *callback=&PL_sv_undef) 1666aio_readdirx (SV8 *pathname, IV flags, SV *callback = &PL_sv_undef)
1424 PPCODE: 1667 PPCODE:
1425{ 1668{
1426 dREQ; 1669 dREQ;
1427 1670
1428 req->type = EIO_READDIR; 1671 req->type = EIO_READDIR;
… …
1435 1678
1436 REQ_SEND; 1679 REQ_SEND;
1437} 1680}
1438 1681
1439void 1682void
1440aio_mkdir (SV8 *pathname, int mode, SV *callback=&PL_sv_undef) 1683aio_mkdir (SV8 *pathname, int mode, SV *callback = &PL_sv_undef)
1441 PPCODE: 1684 PPCODE:
1442{ 1685{
1443 dREQ; 1686 dREQ;
1444 1687
1445 req->type = EIO_MKDIR; 1688 req->type = EIO_MKDIR;
… …
1448 1691
1449 REQ_SEND; 1692 REQ_SEND;
1450} 1693}
1451 1694
1452void 1695void
1453aio_unlink (SV8 *pathname, SV *callback=&PL_sv_undef) 1696aio_unlink (SV8 *pathname, SV *callback = &PL_sv_undef)
1454 ALIAS: 1697 ALIAS:
1455 aio_unlink = EIO_UNLINK 1698 aio_unlink = EIO_UNLINK
1456 aio_rmdir = EIO_RMDIR 1699 aio_rmdir = EIO_RMDIR
1457 aio_readdir = EIO_READDIR 1700 aio_readdir = EIO_READDIR
1458 PPCODE: 1701 PPCODE:
… …
1464 1707
1465 REQ_SEND; 1708 REQ_SEND;
1466} 1709}
1467 1710
1468void 1711void
1469aio_link (SV8 *oldpath, SV8 *newpath, SV *callback=&PL_sv_undef) 1712aio_link (SV8 *oldpath, SV8 *newpath, SV *callback = &PL_sv_undef)
1470 ALIAS: 1713 ALIAS:
1471 aio_link = EIO_LINK 1714 aio_link = EIO_LINK
1472 aio_symlink = EIO_SYMLINK 1715 aio_symlink = EIO_SYMLINK
1473 aio_rename = EIO_RENAME 1716 aio_rename = EIO_RENAME
1474 PPCODE: 1717 PPCODE:
… …
1483 1726
1484 REQ_SEND; 1727 REQ_SEND;
1485} 1728}
1486 1729
1487void 1730void
1731aio_rename2 (SV8 *oldpath, SV8 *newpath, int flags = 0, SV *callback = &PL_sv_undef)
1732 PPCODE:
1733{
1734 eio_wd wd2 = 0;
1735 dREQ;
1736
1737 req->type = EIO_RENAME;
1738 req_set_path1 (req, oldpath);
1739 req_set_path (req, newpath, &req->sv2, &req->sv4, &wd2, &req->ptr2);
1740 req->int2 = flags;
1741 req->int3 = (long)wd2;
1742
1743 REQ_SEND;
1744}
1745
1746void
1488aio_mknod (SV8 *pathname, int mode, UV dev, SV *callback=&PL_sv_undef) 1747aio_mknod (SV8 *pathname, int mode, UV dev, SV *callback = &PL_sv_undef)
1489 PPCODE: 1748 PPCODE:
1490{ 1749{
1491 dREQ; 1750 dREQ;
1492 1751
1493 req->type = EIO_MKNOD; 1752 req->type = EIO_MKNOD;
… …
1497 1756
1498 REQ_SEND; 1757 REQ_SEND;
1499} 1758}
1500 1759
1501void 1760void
1502aio_mtouch (SV8 *data, IV offset = 0, SV *length = &PL_sv_undef, int flags = 0, SV *callback=&PL_sv_undef) 1761aio_mtouch (SV8 *data, IV offset = 0, SV *length = &PL_sv_undef, int flags = -1, SV *callback = &PL_sv_undef)
1503 ALIAS: 1762 ALIAS:
1504 aio_mtouch = EIO_MTOUCH 1763 aio_mtouch = EIO_MTOUCH
1505 aio_msync = EIO_MSYNC 1764 aio_msync = EIO_MSYNC
1506 PPCODE: 1765 PPCODE:
1507{ 1766{
1508 STRLEN svlen; 1767 STRLEN svlen;
1509 char *svptr = SvPVbyte (data, svlen); 1768 char *svptr = SvPVbyte (data, svlen);
1510 UV len = SvUV (length); 1769 UV len = SvUV (length);
1770
1771 if (flags < 0)
1772 flags = ix == EIO_MSYNC ? EIO_MS_SYNC : 0;
1511 1773
1512 if (offset < 0) 1774 if (offset < 0)
1513 offset += svlen; 1775 offset += svlen;
1514 1776
1515 if (offset < 0 || offset > svlen) 1777 if (offset < 0 || offset > svlen)
… …
1530 REQ_SEND; 1792 REQ_SEND;
1531 } 1793 }
1532} 1794}
1533 1795
1534void 1796void
1535aio_mlock (SV8 *data, IV offset = 0, SV *length = &PL_sv_undef, SV *callback=&PL_sv_undef) 1797aio_mlock (SV8 *data, IV offset = 0, SV *length = &PL_sv_undef, SV *callback = &PL_sv_undef)
1536 PPCODE: 1798 PPCODE:
1537{ 1799{
1538 STRLEN svlen; 1800 STRLEN svlen;
1539 char *svptr = SvPVbyte (data, svlen); 1801 char *svptr = SvPVbyte (data, svlen);
1540 UV len = SvUV (length); 1802 UV len = SvUV (length);
… …
1559 REQ_SEND; 1821 REQ_SEND;
1560 } 1822 }
1561} 1823}
1562 1824
1563void 1825void
1564aio_mlockall (IV flags, SV *callback=&PL_sv_undef) 1826aio_mlockall (IV flags, SV *callback = &PL_sv_undef)
1565 PPCODE: 1827 PPCODE:
1566{ 1828{
1567 dREQ; 1829 dREQ;
1568 1830
1569 req->type = EIO_MLOCKALL; 1831 req->type = EIO_MLOCKALL;
… …
1571 1833
1572 REQ_SEND; 1834 REQ_SEND;
1573} 1835}
1574 1836
1575void 1837void
1576aio_fiemap (SV *fh, off_t start, SV *length, U32 flags, SV *count, SV *callback=&PL_sv_undef) 1838aio_fiemap (SV *fh, off_t start, SV *length, U32 flags, SV *count, SV *callback = &PL_sv_undef)
1577 PPCODE: 1839 PPCODE:
1578{ 1840{
1579 int fd = s_fileno_croak (fh, 0); 1841 int fd = s_fileno_croak (fh, 0);
1580 dREQ; 1842 dREQ;
1581 1843
… …
1594 1856
1595 REQ_SEND; 1857 REQ_SEND;
1596} 1858}
1597 1859
1598void 1860void
1861aio_slurp (SV *pathname, off_t offset, UV length, SV8 *data, SV *callback = &PL_sv_undef)
1862 PPCODE:
1863{
1864 char *svptr = 0;
1865
1866 sv_clear_foreign (data);
1867
1868 if (length) /* known length, directly read into scalar */
1869 {
1870 if (!SvPOK (data) || SvLEN (data) >= SvCUR (data))
1871 svptr = sv_grow (data, length + 1);
1872 else if (SvCUR (data) < length)
1873 croak ("length outside of scalar, and cannot grow");
1874 else
1875 svptr = SvPVbyte_nolen (data);
1876 }
1877
1878 {
1879 dREQ;
1880
1881 req->type = EIO_SLURP;
1882 req_set_path1 (req, pathname);
1883 req->offs = offset;
1884 req->size = length;
1885 req->sv2 = SvREFCNT_inc (data);
1886 req->ptr2 = svptr;
1887
1888 if (!SvREADONLY (data))
1889 {
1890 SvREADONLY_on (data);
1891 req->flags |= FLAG_SV2_RO_OFF;
1892 }
1893
1894 REQ_SEND;
1895 }
1896}
1897
1898void
1599aio_busy (double delay, SV *callback=&PL_sv_undef) 1899aio_busy (double delay, SV *callback = &PL_sv_undef)
1600 PPCODE: 1900 PPCODE:
1601{ 1901{
1602 dREQ; 1902 dREQ;
1603 1903
1604 req->type = EIO_BUSY; 1904 req->type = EIO_BUSY;
… …
1606 1906
1607 REQ_SEND; 1907 REQ_SEND;
1608} 1908}
1609 1909
1610void 1910void
1611aio_group (SV *callback=&PL_sv_undef) 1911aio_group (SV *callback = &PL_sv_undef)
1612 PPCODE: 1912 PPCODE:
1613{ 1913{
1614 dREQ; 1914 dREQ;
1615 1915
1616 req->type = EIO_GROUP; 1916 req->type = EIO_GROUP;
1617 1917
1918 PUTBACK;
1618 req_submit (req); 1919 req_submit (req);
1920 SPAGAIN;
1921
1619 XPUSHs (req_sv (req, aio_grp_stash)); 1922 XPUSHs (req_sv (req, aio_grp_stash));
1620} 1923}
1621 1924
1622void 1925void
1623aio_nop (SV *callback=&PL_sv_undef) 1926aio_nop (SV *callback = &PL_sv_undef)
1624 ALIAS: 1927 ALIAS:
1625 aio_nop = EIO_NOP 1928 aio_nop = EIO_NOP
1626 aio_sync = EIO_SYNC 1929 aio_sync = EIO_SYNC
1627 PPCODE: 1930 PPCODE:
1628{ 1931{
… …
1632 1935
1633 REQ_SEND; 1936 REQ_SEND;
1634} 1937}
1635 1938
1636int 1939int
1637aioreq_pri (int pri = 0) 1940aioreq_pri (int pri = NO_INIT)
1638 CODE: 1941 CODE:
1639 RETVAL = next_pri; 1942 RETVAL = next_pri;
1640 if (items > 0) 1943 if (items > 0)
1641 { 1944 {
1642 if (pri < EIO_PRI_MIN) pri = EIO_PRI_MIN; 1945 if (pri < EIO_PRI_MIN) pri = EIO_PRI_MIN;
… …
1732 RETVAL = eio_sendfile_sync (ofh, ifh, offset, count); 2035 RETVAL = eio_sendfile_sync (ofh, ifh, offset, count);
1733 OUTPUT: 2036 OUTPUT:
1734 RETVAL 2037 RETVAL
1735 2038
1736void 2039void
1737mmap (SV *scalar, size_t length, int prot, int flags, SV *fh = &PL_sv_undef, off_t offset = 0) 2040mmap (SV *scalar, STRLEN length, int prot, int flags, SV *fh = &PL_sv_undef, off_t offset = 0)
1738 PPCODE: 2041 PPCODE:
1739 sv_unmagic (scalar, MMAP_MAGIC); 2042 sv_clear_foreign (scalar);
1740{ 2043{
1741 int fd = SvOK (fh) ? s_fileno_croak (fh, flags & PROT_WRITE) : -1; 2044 int fd = SvOK (fh) ? s_fileno_croak (fh, flags & PROT_WRITE) : -1;
1742 void *addr = (void *)mmap (0, length, prot, flags, fd, offset); 2045 void *addr = (void *)mmap (0, length, prot, flags, fd, offset);
1743 if (addr == (void *)-1) 2046 if (addr == (void *)-1)
1744 XSRETURN_NO; 2047 XSRETURN_NO;
1745 2048
1746 sv_force_normal (scalar); 2049 sv_set_foreign (scalar, &mmap_vtbl, addr, length);
1747
1748 /* we store the length in mg_obj, as namlen is I32 :/ */
1749 sv_magicext (scalar, 0, MMAP_MAGIC, &mmap_vtbl, (char *)addr, 0)
1750 ->mg_obj = (SV *)length;
1751
1752 SvUPGRADE (scalar, SVt_PV); /* nop... */
1753 2050
1754 if (!(prot & PROT_WRITE)) 2051 if (!(prot & PROT_WRITE))
1755 SvREADONLY_on (scalar); 2052 SvREADONLY_on (scalar);
1756 2053
1757 if (SvLEN (scalar))
1758 Safefree (SvPVX (scalar));
1759
1760 SvPVX (scalar) = (char *)addr;
1761 SvCUR_set (scalar, length);
1762 SvLEN_set (scalar, 0);
1763 SvPOK_only (scalar);
1764
1765 XSRETURN_YES; 2054 XSRETURN_YES;
1766} 2055}
1767 2056
1768void 2057void
1769munmap (SV *scalar) 2058munmap (SV *scalar)
1770 CODE: 2059 CODE:
1771 sv_unmagic (scalar, MMAP_MAGIC); 2060 sv_clear_foreign (scalar);
1772 2061
1773int 2062int
1774madvise (SV *scalar, off_t offset = 0, SV *length = &PL_sv_undef, IV advice_or_prot) 2063madvise (SV *scalar, STRLEN offset = 0, SV *length = &PL_sv_undef, IV advice_or_prot)
1775 ALIAS: 2064 ALIAS:
1776 mprotect = 1 2065 mprotect = 1
1777 CODE: 2066 CODE:
1778{ 2067{
1779 STRLEN svlen; 2068 STRLEN svlen;
1780 void *addr = SvPVbyte (scalar, svlen); 2069 void *addr = SvPVbyte (scalar, svlen);
1781 size_t len = SvUV (length); 2070 STRLEN len = SvUV (length);
1782 2071
1783 if (offset < 0) 2072 if (offset < 0)
1784 offset += svlen; 2073 offset += svlen;
1785 2074
1786 if (offset < 0 || offset > svlen) 2075 if (offset < 0 || offset > svlen)
… …
1800} 2089}
1801 OUTPUT: 2090 OUTPUT:
1802 RETVAL 2091 RETVAL
1803 2092
1804int 2093int
1805munlock (SV *scalar, off_t offset = 0, SV *length = &PL_sv_undef) 2094munlock (SV *scalar, STRLEN offset = 0, SV *length = &PL_sv_undef)
1806 CODE: 2095 CODE:
1807{ 2096{
1808 STRLEN svlen; 2097 STRLEN svlen;
1809 void *addr = SvPVbyte (scalar, svlen); 2098 void *addr = SvPVbyte (scalar, svlen);
1810 size_t len = SvUV (length); 2099 size_t len = SvUV (length);
… …
1866#else 2155#else
1867 RETVAL = EIO_ENOSYS (); 2156 RETVAL = EIO_ENOSYS ();
1868#endif 2157#endif
1869 OUTPUT: 2158 OUTPUT:
1870 RETVAL 2159 RETVAL
2160
2161int
2162pipesize (aio_rfd rfh, int new_size = -1)
2163 PROTOTYPE: $;$
2164 CODE:
2165#if defined(F_SETPIPE_SZ) && defined(F_GETPIPE_SZ)
2166 if (new_size >= 0)
2167 RETVAL = fcntl (rfh, F_SETPIPE_SZ, new_size);
2168 else
2169 RETVAL = fcntl (rfh, F_GETPIPE_SZ);
2170#else
2171 errno = ENOSYS;
2172 RETVAL = -1;
2173#endif
2174 OUTPUT:
2175 RETVAL
2176
2177void
2178pipe2 (int flags = 0)
2179 PROTOTYPE: ;$
2180 PPCODE:
2181{
2182 int fd[2];
2183 int res;
2184
2185 if (flags)
2186#if HAVE_PIPE2
2187 res = pipe2 (fd, flags);
2188#else
2189 res = (errno = ENOSYS, -1);
2190#endif
2191 else
2192 res = pipe (fd);
2193
2194 if (!res)
2195 {
2196 EXTEND (SP, 2);
2197 PUSHs (newmortalFH (fd[0], O_RDONLY));
2198 PUSHs (newmortalFH (fd[1], O_WRONLY));
2199 }
2200}
2201
2202void
2203eventfd (unsigned int initval = 0, int flags = 0)
2204 PPCODE:
2205{
2206 int fd;
2207#if HAVE_EVENTFD
2208 fd = eventfd (initval, flags);
2209#else
2210 fd = (errno = ENOSYS, -1);
2211#endif
2212
2213 XPUSHs (newmortalFH (fd, O_RDWR));
2214}
2215
2216void
2217timerfd_create (int clockid, int flags = 0)
2218 PPCODE:
2219{
2220 int fd;
2221#if HAVE_TIMERFD
2222 fd = timerfd_create (clockid, flags);
2223#else
2224 fd = (errno = ENOSYS, -1);
2225#endif
2226
2227 XPUSHs (newmortalFH (fd, O_RDWR));
2228}
2229
2230void
2231timerfd_settime (SV *fh, int flags, NV interval, NV value)
2232 PPCODE:
2233{
2234 int fd = s_fileno_croak (fh, 0);
2235#if HAVE_TIMERFD
2236 int res;
2237 struct itimerspec its, ots;
2238
2239 ts_set (&its.it_interval, interval);
2240 ts_set (&its.it_value , value);
2241 res = timerfd_settime (fd, flags, &its, &ots);
2242
2243 if (!res)
2244 {
2245 EXTEND (SP, 2);
2246 PUSHs (newSVnv (ts_get (&ots.it_interval)));
2247 PUSHs (newSVnv (ts_get (&ots.it_value)));
2248 }
2249#else
2250 errno = ENOSYS;
2251#endif
2252}
2253
2254void
2255timerfd_gettime (SV *fh)
2256 PPCODE:
2257{
2258 int fd = s_fileno_croak (fh, 0);
2259#if HAVE_TIMERFD
2260 int res;
2261 struct itimerspec ots;
2262 res = timerfd_gettime (fd, &ots);
2263
2264 if (!res)
2265 {
2266 EXTEND (SP, 2);
2267 PUSHs (newSVnv (ts_get (&ots.it_interval)));
2268 PUSHs (newSVnv (ts_get (&ots.it_value)));
2269 }
2270#else
2271 errno = ENOSYS;
2272#endif
2273}
2274
2275UV
2276get_fdlimit ()
2277 CODE:
2278#if HAVE_RLIMITS
2279 struct rlimit rl;
2280 if (0 == getrlimit (RLIMIT_NOFILE, &rl))
2281 XSRETURN_UV (rl.rlim_cur == RLIM_INFINITY ? (UV)-1 : rl.rlim_cur);
2282#endif
2283 XSRETURN_UNDEF;
2284 OUTPUT:
2285 RETVAL
2286
2287void
2288min_fdlimit (UV limit = 0x7fffffffU)
2289 CODE:
2290{
2291#if HAVE_RLIMITS
2292 struct rlimit rl;
2293 rlim_t orig_rlim_max;
2294 UV bit;
2295
2296 if (0 != getrlimit (RLIMIT_NOFILE, &rl))
2297 goto fail;
2298
2299 if (rl.rlim_cur == RLIM_INFINITY)
2300 XSRETURN_YES;
2301
2302 orig_rlim_max = rl.rlim_max == RLIM_INFINITY ? ((rlim_t)0)-1 : rl.rlim_max;
2303
2304 if (rl.rlim_cur < limit)
2305 {
2306 rl.rlim_cur = limit;
2307
2308 if (rl.rlim_max < rl.rlim_cur && rl.rlim_max != RLIM_INFINITY)
2309 rl.rlim_max = rl.rlim_cur;
2310 }
2311
2312 if (0 == setrlimit (RLIMIT_NOFILE, &rl))
2313 XSRETURN_YES;
2314
2315 if (errno == EPERM)
2316 {
2317 /* setlimit failed with EPERM - maybe we can't raise the hardlimit, or maybe */
2318 /* our limit overflows a system-wide limit */
2319 /* try an adaptive algorithm, but do not lower the hardlimit */
2320 rl.rlim_max = 0;
2321 for (bit = 0x40000000U; bit; bit >>= 1)
2322 {
2323 rl.rlim_max |= bit;
2324 rl.rlim_cur = rl.rlim_max;
2325
2326 /* nevr decrease the hard limit */
2327 if (rl.rlim_max < orig_rlim_max)
2328 break;
2329
2330 if (0 != setrlimit (RLIMIT_NOFILE, &rl))
2331 rl.rlim_max &= ~bit; /* too high, remove bit again */
2332 }
2333
2334 /* now, raise the soft limit to the max permitted */
2335 if (0 == getrlimit (RLIMIT_NOFILE, &rl))
2336 {
2337 rl.rlim_cur = rl.rlim_max;
2338 if (0 == setrlimit (RLIMIT_NOFILE, &rl))
2339 errno = EPERM;
2340 }
2341 }
2342#endif
2343 fail:
2344 XSRETURN_UNDEF;
2345}
1871 2346
1872void _on_next_submit (SV *cb) 2347void _on_next_submit (SV *cb)
1873 CODE: 2348 CODE:
1874 SvREFCNT_dec (on_next_submit); 2349 SvREFCNT_dec (on_next_submit);
1875 on_next_submit = SvOK (cb) ? newSVsv (cb) : 0; 2350 on_next_submit = SvOK (cb) ? newSVsv (cb) : 0;
… …
1910cancel (aio_req_ornot req) 2385cancel (aio_req_ornot req)
1911 CODE: 2386 CODE:
1912 eio_cancel (req); 2387 eio_cancel (req);
1913 2388
1914void 2389void
1915cb (aio_req_ornot req, SV *callback=&PL_sv_undef) 2390cb (aio_req_ornot req, SV *callback = NO_INIT)
1916 PPCODE: 2391 PPCODE:
1917{ 2392{
1918 if (GIMME_V != G_VOID) 2393 if (GIMME_V != G_VOID)
1919 XPUSHs (req->callback ? sv_2mortal (newRV_inc (req->callback)) : &PL_sv_undef); 2394 XPUSHs (req->callback ? sv_2mortal (newRV_inc (req->callback)) : &PL_sv_undef);
1920 2395
1921 if (items > 1) 2396 if (items > 1)
1922 { 2397 {
1923 SV *cb_cv =get_cb (callback); 2398 SV *cb_cv = get_cb (callback);
1924 2399
1925 SvREFCNT_dec (req->callback); 2400 SvREFCNT_dec (req->callback);
1926 req->callback = SvREFCNT_inc (cb_cv); 2401 req->callback = SvREFCNT_inc (cb_cv);
1927 } 2402 }
1928} 2403}
… …
1985limit (aio_req grp, int limit) 2460limit (aio_req grp, int limit)
1986 CODE: 2461 CODE:
1987 eio_grp_limit (grp, limit); 2462 eio_grp_limit (grp, limit);
1988 2463
1989void 2464void
1990feed (aio_req grp, SV *callback=&PL_sv_undef) 2465feed (aio_req grp, SV *callback = &PL_sv_undef)
1991 CODE: 2466 CODE:
1992{ 2467{
1993 SvREFCNT_dec (grp->sv2); 2468 SvREFCNT_dec (grp->sv2);
1994 grp->sv2 = newSVsv (callback); 2469 grp->sv2 = newSVsv (callback);
1995 grp->feed = aio_grp_feed; 2470 grp->feed = aio_grp_feed;

Diff Legend

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