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.232 by root, Sat Jun 13 00:06:13 2015 UTC vs.
Revision 1.266 by root, Tue Aug 14 14:03:14 2018 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 "schmorp.h" 9#if !defined mg_findext
10# define mg_findext(sv,type,vtbl) mg_find (sv, type)
11#endif
10 12
11#include <stddef.h> 13#include <stddef.h>
12#include <stdlib.h> 14#include <stdlib.h>
13#include <errno.h> 15#include <errno.h>
14#include <sys/types.h> 16#include <sys/types.h>
17#include <sys/socket.h>
15#include <sys/stat.h> 18#include <sys/stat.h>
16#include <limits.h> 19#include <limits.h>
17#include <fcntl.h> 20#include <fcntl.h>
18#include <sched.h> 21#include <sched.h>
19 22
23#if HAVE_SYS_MKDEV_H
24# include <sys/mkdev.h>
25#elif HAVE_SYS_SYSMACROS_H
26# include <sys/sysmacros.h>
27#endif
28
20#if _POSIX_MEMLOCK || _POSIX_MEMLOCK_RANGE || _POSIX_MAPPED_FILES 29#if _POSIX_MEMLOCK || _POSIX_MEMLOCK_RANGE || _POSIX_MAPPED_FILES
21# include <sys/mman.h> 30# include <sys/mman.h>
22#endif 31#endif
23 32
24/* the incompetent fool that created musl keeps __linux__, refuses 33/* the incompetent fool that created musl keeps __linux__, refuses
25 * to implement any linux standard apis, and also has no way to test 34 * to implement any linux standard apis, and also has no way to test
26 * for his broken iplementation. on't complain if this fails for you. 35 * for his broken iplementation. don't complain to me if this fails
36 * for you.
27 */ 37 */
28#if __linux__ && (defined __GLIBC__ || defined __UCLIBC__) 38#if __linux__ && (defined __GLIBC__ || defined __UCLIBC__)
29# include <linux/fs.h> 39# include <linux/fs.h>
30# ifdef FS_IOC_FIEMAP 40# ifdef FS_IOC_FIEMAP
31# include <linux/types.h> 41# include <linux/types.h>
… …
103#define expect_false(expr) expect ((expr) != 0, 0) 113#define expect_false(expr) expect ((expr) != 0, 0)
104#define expect_true(expr) expect ((expr) != 0, 1) 114#define expect_true(expr) expect ((expr) != 0, 1)
105 115
106/*****************************************************************************/ 116/*****************************************************************************/
107 117
118#include "config.h"
119
120#if HAVE_ST_XTIMENSEC
121# define ATIMENSEC PL_statcache.st_atimensec
122# define MTIMENSEC PL_statcache.st_mtimensec
123# define CTIMENSEC PL_statcache.st_ctimensec
124#elif HAVE_ST_XTIMESPEC
125# define ATIMENSEC PL_statcache.st_atim.tv_nsec
126# define MTIMENSEC PL_statcache.st_mtim.tv_nsec
127# define CTIMENSEC PL_statcache.st_ctim.tv_nsec
128#else
129# define ATIMENSEC 0
130# define MTIMENSEC 0
131# define CTIMENSEC 0
132#endif
133
134#include "schmorp.h"
135
136#if HAVE_EVENTFD
137# include <sys/eventfd.h>
138#endif
139
140#if HAVE_TIMERFD
141# include <sys/timerfd.h>
142#endif
143
144#if HAVE_RLIMITS
145 #include <sys/time.h>
146 #include <sys/resource.h>
147#endif
148
108typedef SV SV8; /* byte-sv, used for argument-checking */ 149typedef SV SV8; /* byte-sv, used for argument-checking */
109typedef int aio_rfd; /* read file desriptor */ 150typedef int aio_rfd; /* read file desriptor */
110typedef int aio_wfd; /* write file descriptor */ 151typedef int aio_wfd; /* write file descriptor */
111 152
112static HV *aio_stash, *aio_req_stash, *aio_grp_stash, *aio_wd_stash; 153static HV *aio_stash, *aio_req_stash, *aio_grp_stash, *aio_wd_stash;
… …
118 STRLEN stroffset; \ 159 STRLEN stroffset; \
119 SV *self; 160 SV *self;
120 161
121#define EIO_NO_WRAPPERS 1 162#define EIO_NO_WRAPPERS 1
122 163
123#include "libeio/config.h"
124#include "libeio/eio.h" 164#include "libeio/eio.h"
125 165
126static int req_invoke (eio_req *req); 166static int req_invoke (eio_req *req);
127#define EIO_FINISH(req) req_invoke (req) 167#define EIO_FINISH(req) req_invoke (req)
128static void req_destroy (eio_req *grp); 168static void req_destroy (eio_req *grp);
… …
144# else 184# else
145# define MAP_ANONYMOUS MAP_FIXED /* and hope this fails */ 185# define MAP_ANONYMOUS MAP_FIXED /* and hope this fails */
146# endif 186# endif
147#endif 187#endif
148 188
149/* defines all sorts of constants to 0 unless they are already defined */
150#include "def0.h"
151
152#ifndef makedev 189#ifndef makedev
153# define makedev(maj,min) (((maj) << 8) | (min)) 190# define makedev(maj,min) (((maj) << 8) | (min))
154#endif 191#endif
155#ifndef major 192#ifndef major
156# define major(dev) ((dev) >> 8) 193# define major(dev) ((dev) >> 8)
157#endif 194#endif
158#ifndef minor 195#ifndef minor
159# define minor(dev) ((dev) & 0xff) 196# define minor(dev) ((dev) & 0xff)
160#endif 197#endif
161 198
199/* solaris has a non-posix/unix compliant PAGESIZE that breaks compilation */
200#ifdef __sun
201# undef PAGESIZE
202#endif
203
162#if PAGESIZE <= 0 204#if PAGESIZE <= 0
163# define PAGESIZE sysconf (_SC_PAGESIZE) 205# define PAGESIZE sysconf (_SC_PAGESIZE)
164#endif 206#endif
207
208/*****************************************************************************/
209
210#if !_POSIX_MAPPED_FILES
211# define mmap(addr,length,prot,flags,fd,offs) (errno = ENOSYS, (void *)-1)
212# define munmap(addr,length) EIO_ENOSYS ()
213#endif
214
215#if !_POSIX_MEMORY_PROTECTION
216# define mprotect(addr,len,prot) EIO_ENOSYS ()
217#endif
218
219#if !MREMAP_MAYMOVE
220# define mremap(old_address,old_size,new_size,flags,new_address) (errno = ENOSYS, (void *)-1)
221#endif
222
223#define FOREIGN_MAGIC PERL_MAGIC_ext
224
225static int ecb_cold
226mmap_free (pTHX_ SV *sv, MAGIC *mg)
227{
228 int old_errno = errno;
229 munmap (mg->mg_ptr, (size_t)mg->mg_obj);
230 errno = old_errno;
231
232 mg->mg_obj = 0; /* just in case */
233
234 SvREADONLY_off (sv);
235
236 if (SvPVX (sv) != mg->mg_ptr)
237 croak ("ERROR: IO::AIO::mmap-mapped scalar changed location, detected");
238
239 SvCUR_set (sv, 0);
240 SvPVX (sv) = 0;
241 SvOK_off (sv);
242
243 return 0;
244}
245
246static MGVTBL mmap_vtbl = {
247 0, 0, 0, 0, mmap_free
248};
249
250static int ecb_cold
251sysfree_free (pTHX_ SV *sv, MAGIC *mg)
252{
253 free (mg->mg_ptr);
254 mg->mg_obj = 0; /* just in case */
255
256 SvREADONLY_off (sv);
257
258 if (SvPVX (sv) != mg->mg_ptr)
259 croak ("ERROR: IO::AIO mapped scalar changed location, detected");
260
261 SvCUR_set (sv, 0);
262 SvPVX (sv) = 0;
263 SvOK_off (sv);
264
265 return 0;
266}
267
268static MGVTBL sysfree_vtbl = {
269 0, 0, 0, 0, sysfree_free
270};
271
272/*****************************************************************************/
273
274/* helper: set scalar to foreign ptr with custom free */
275static void
276sv_set_foreign (SV *sv, const MGVTBL *const vtbl, void *addr, IV length)
277{
278 sv_force_normal (sv);
279
280 /* we store the length in mg_obj, as namlen is I32 :/ */
281 sv_magicext (sv, 0, FOREIGN_MAGIC, vtbl, (char *)addr, 0)
282 ->mg_obj = (SV *)length;
283
284 SvUPGRADE (sv, SVt_PV); /* nop... */
285
286 if (SvLEN (sv))
287 Safefree (SvPVX (sv));
288
289 SvPVX (sv) = (char *)addr;
290 SvCUR_set (sv, length);
291 SvLEN_set (sv, 0);
292 SvPOK_only (sv);
293}
294
295static void
296sv_clear_foreign (SV *sv)
297{
298 /* todo: iterate over magic and only free ours, but of course */
299 /* the perl5porters will call that (correct) behaviour buggy */
300 sv_unmagic (sv, FOREIGN_MAGIC);
301}
302
303/*****************************************************************************/
304
305/* defines all sorts of constants to 0 unless they are already defined */
306/* also provides const_iv_ and const_niv_ macros for them */
307#include "def0.h"
165 308
166/*****************************************************************************/ 309/*****************************************************************************/
167 310
168static void 311static void
169fiemap (eio_req *req) 312fiemap (eio_req *req)
… …
337 || SvTYPE (SvRV (sv)) != SVt_PVMG 480 || SvTYPE (SvRV (sv)) != SVt_PVMG
338 || SvSTASH (SvRV (sv)) != aio_wd_stash) 481 || SvSTASH (SvRV (sv)) != aio_wd_stash)
339 croak ("IO::AIO: expected a working directory object as returned by aio_wd"); 482 croak ("IO::AIO: expected a working directory object as returned by aio_wd");
340 483
341 return (aio_wd)(long)SvIVX (SvRV (sv)); 484 return (aio_wd)(long)SvIVX (SvRV (sv));
485}
486
487static SV *
488newmortalFH (int fd, int flags)
489{
490 if (fd < 0)
491 return &PL_sv_undef;
492
493 GV *gv = (GV *)sv_newmortal ();
494 char sym[64];
495 int symlen;
496
497 symlen = snprintf (sym, sizeof (sym), "fd#%d", fd);
498 gv_init (gv, aio_stash, sym, symlen, 0);
499
500 symlen = snprintf (
501 sym,
502 sizeof (sym),
503 "%s&=%d",
504 flags == O_RDONLY ? "<" : flags == O_WRONLY ? ">" : "+<",
505 fd
506 );
507
508 return do_open (gv, sym, symlen, 0, 0, 0, 0)
509 ? (SV *)gv : &PL_sv_undef;
342} 510}
343 511
344static void 512static void
345aio_grp_feed (aio_req grp) 513aio_grp_feed (aio_req grp)
346{ 514{
… …
474 XPUSHs (sv_2mortal (newSViv (req->int1 & ~(EIO_READDIR_CUSTOM1 | EIO_READDIR_CUSTOM2)))); 642 XPUSHs (sv_2mortal (newSViv (req->int1 & ~(EIO_READDIR_CUSTOM1 | EIO_READDIR_CUSTOM2))));
475 } 643 }
476 break; 644 break;
477 645
478 case EIO_OPEN: 646 case EIO_OPEN:
479 { 647 PUSHs (newmortalFH (req->result, req->int1 & (O_RDONLY | O_WRONLY | O_RDWR)));
480 /* convert fd to fh */
481 SV *fh = &PL_sv_undef;
482
483 if (req->result >= 0)
484 {
485 GV *gv = (GV *)sv_newmortal ();
486 int flags = req->int1 & (O_RDONLY | O_WRONLY | O_RDWR);
487 char sym [64];
488 int symlen;
489
490 symlen = snprintf (sym, sizeof (sym), "fd#%d", (int)req->result);
491 gv_init (gv, aio_stash, sym, symlen, 0);
492
493 symlen = snprintf (
494 sym,
495 sizeof (sym),
496 "%s&=%d",
497 flags == O_RDONLY ? "<" : flags == O_WRONLY ? ">" : "+<",
498 (int)req->result
499 );
500
501 if (do_open (gv, sym, symlen, 0, 0, 0, 0))
502 fh = (SV *)gv;
503 }
504
505 PUSHs (fh);
506 }
507 break; 648 break;
508 649
509 case EIO_STATVFS: 650 case EIO_STATVFS:
510 case EIO_FSTATVFS: 651 case EIO_FSTATVFS:
511 { 652 {
… …
591 SvSETMAGIC (req->sv2); 732 SvSETMAGIC (req->sv2);
592 PUSHs (sv_result); 733 PUSHs (sv_result);
593 } 734 }
594 break; 735 break;
595 736
737 case EIO_SLURP:
738 {
739 if (req->result >= 0)
740 {
741 /* if length was originally not known, we steal the malloc'ed memory */
742 if (req->flags & EIO_FLAG_PTR2_FREE)
743 {
744 req->flags &= ~EIO_FLAG_PTR2_FREE;
745 sv_set_foreign (req->sv2, &sysfree_vtbl, req->ptr2, req->result);
746 }
747 else
748 {
749 SvCUR_set (req->sv2, req->result);
750 *SvEND (req->sv2) = 0;
751 SvPOK_only (req->sv2);
752 }
753
754 SvSETMAGIC (req->sv2);
755 }
756
757 PUSHs (sv_result);
758 }
759 break;
760
596 case EIO_CUSTOM: 761 case EIO_CUSTOM:
597 if (req->feed == fiemap) 762 if (req->feed == fiemap)
598 { 763 {
599#if HAVE_FIEMAP 764#if HAVE_FIEMAP
600 if (!req->result) 765 if (!req->result)
… …
705{ 870{
706 while (eio_nreqs ()) 871 while (eio_nreqs ())
707 { 872 {
708 int size; 873 int size;
709 874
710 X_LOCK (reslock); 875 X_LOCK (EIO_POOL->reslock);
711 size = res_queue.size; 876 size = EIO_POOL->res_queue.size;
712 X_UNLOCK (reslock); 877 X_UNLOCK (EIO_POOL->reslock);
713 878
714 if (size) 879 if (size)
715 return; 880 return;
716 881
717 etp_maybe_start_thread (); 882 etp_maybe_start_thread (EIO_POOL);
718 883
719 s_epipe_wait (&respipe); 884 s_epipe_wait (&respipe);
720 } 885 }
721} 886}
722 887
… …
743 create_respipe (); 908 create_respipe ();
744 909
745 if (eio_init (want_poll, done_poll) < 0) 910 if (eio_init (want_poll, done_poll) < 0)
746 croak ("IO::AIO: unable to initialise eio library"); 911 croak ("IO::AIO: unable to initialise eio library");
747} 912}
748
749/*****************************************************************************/
750
751#if !_POSIX_MAPPED_FILES
752# define mmap(addr,length,prot,flags,fd,offs) EIO_ENOSYS ()
753# define munmap(addr,length) EIO_ENOSYS ()
754#endif
755
756#if !_POSIX_MEMORY_PROTECTION
757# define mprotect(addr,len,prot) EIO_ENOSYS ()
758# define PROT_NONE 0
759# define PROT_WRITE 0
760# define MAP_PRIVATE 0
761# define MAP_SHARED 0
762# define MAP_FIXED 0
763#endif
764
765#define MMAP_MAGIC PERL_MAGIC_ext
766
767static int ecb_cold
768mmap_free (pTHX_ SV *sv, MAGIC *mg)
769{
770 int old_errno = errno;
771 munmap (mg->mg_ptr, (size_t)mg->mg_obj);
772 errno = old_errno;
773
774 mg->mg_obj = 0; /* just in case */
775
776 SvREADONLY_off (sv);
777
778 if (SvPVX (sv) != mg->mg_ptr)
779 croak ("ERROR: IO::AIO::mmap-mapped scalar changed location, detected");
780
781 SvCUR_set (sv, 0);
782 SvPVX (sv) = 0;
783 SvOK_off (sv);
784
785 return 0;
786}
787
788static MGVTBL mmap_vtbl = {
789 0, 0, 0, 0, mmap_free
790};
791 913
792/*****************************************************************************/ 914/*****************************************************************************/
793 915
794static SV * 916static SV *
795get_cb (SV *cb_sv) 917get_cb (SV *cb_sv)
… …
891 req_set_path1 (req, fh_or_path); 1013 req_set_path1 (req, fh_or_path);
892 break; 1014 break;
893 } 1015 }
894} 1016}
895 1017
1018/*****************************************************************************/
1019
1020static void
1021ts_set (struct timespec *ts, NV value)
1022{
1023 ts->tv_sec = value;
1024 ts->tv_nsec = (value - ts->tv_sec) * 1e9;
1025}
1026
1027static NV
1028ts_get (const struct timespec *ts)
1029{
1030 return ts->tv_sec + ts->tv_nsec * 1e-9;
1031}
1032
1033/*****************************************************************************/
1034
896XS(boot_IO__AIO) ecb_cold; 1035XS(boot_IO__AIO) ecb_cold;
897 1036
898MODULE = IO::AIO PACKAGE = IO::AIO 1037MODULE = IO::AIO PACKAGE = IO::AIO
899 1038
900PROTOTYPES: ENABLE 1039PROTOTYPES: ENABLE
… …
907 } *civ, const_iv[] = { 1046 } *civ, const_iv[] = {
908# define const_niv(name, value) { # name, (IV) value }, 1047# define const_niv(name, value) { # name, (IV) value },
909# define const_iv(name) { # name, (IV) name }, 1048# define const_iv(name) { # name, (IV) name },
910# define const_eio(name) { # name, (IV) EIO_ ## name }, 1049# define const_eio(name) { # name, (IV) EIO_ ## name },
911 1050
912 /* you have to re-run ./gendef0 after adding/Removing any constants here */ 1051 /* you have to re-run ./gendef0 after adding/removing any constants here */
913 1052 /* the first block can be undef if missing */
914 const_iv (ENOSYS) 1053 const_iv (ENOSYS)
915 const_iv (EXDEV) 1054 const_iv (EXDEV)
916 const_iv (EBADR) 1055 const_iv (EBADR)
1056
1057 /* for lseek */
1058 const_iv (SEEK_DATA)
1059 const_iv (SEEK_HOLE)
1060
1061 const_niv (FADV_NORMAL , POSIX_FADV_NORMAL)
1062 const_niv (FADV_SEQUENTIAL, POSIX_FADV_SEQUENTIAL)
1063 const_niv (FADV_RANDOM , POSIX_FADV_RANDOM)
1064 const_niv (FADV_NOREUSE , POSIX_FADV_NOREUSE)
1065 const_niv (FADV_WILLNEED , POSIX_FADV_WILLNEED)
1066 const_niv (FADV_DONTNEED , POSIX_FADV_DONTNEED)
1067
1068 const_niv (MADV_NORMAL , POSIX_MADV_NORMAL)
1069 const_niv (MADV_SEQUENTIAL, POSIX_MADV_SEQUENTIAL)
1070 const_niv (MADV_RANDOM , POSIX_MADV_RANDOM)
1071 const_niv (MADV_WILLNEED , POSIX_MADV_WILLNEED)
1072 const_niv (MADV_DONTNEED , POSIX_MADV_DONTNEED)
1073
1074 /* the second block will be 0 when missing */
1075 const_iv (O_ACCMODE)
917 1076
918 const_iv (O_RDONLY) 1077 const_iv (O_RDONLY)
919 const_iv (O_WRONLY) 1078 const_iv (O_WRONLY)
920 const_iv (O_RDWR) 1079 const_iv (O_RDWR)
921 const_iv (O_CREAT) 1080 const_iv (O_CREAT)
… …
935 const_iv (O_SEARCH) 1094 const_iv (O_SEARCH)
936 const_iv (O_DIRECTORY) 1095 const_iv (O_DIRECTORY)
937 const_iv (O_DSYNC) 1096 const_iv (O_DSYNC)
938 const_iv (O_RSYNC) 1097 const_iv (O_RSYNC)
939 const_iv (O_SYNC) 1098 const_iv (O_SYNC)
1099 const_iv (O_PATH)
1100 const_iv (O_TMPFILE)
940 const_iv (O_TTY_INIT) 1101 const_iv (O_TTY_INIT)
941 1102
942 const_iv (S_IFIFO) 1103 const_iv (S_IFIFO)
943 const_iv (S_IFCHR) 1104 const_iv (S_IFCHR)
944 const_iv (S_IFBLK) 1105 const_iv (S_IFBLK)
… …
946 const_iv (S_IFREG) 1107 const_iv (S_IFREG)
947 const_iv (S_IFDIR) 1108 const_iv (S_IFDIR)
948 const_iv (S_IFWHT) 1109 const_iv (S_IFWHT)
949 const_iv (S_IFSOCK) 1110 const_iv (S_IFSOCK)
950 const_iv (S_IFMT) 1111 const_iv (S_IFMT)
951
952 const_niv (FADV_NORMAL , POSIX_FADV_NORMAL)
953 const_niv (FADV_SEQUENTIAL, POSIX_FADV_SEQUENTIAL)
954 const_niv (FADV_RANDOM , POSIX_FADV_RANDOM)
955 const_niv (FADV_NOREUSE , POSIX_FADV_NOREUSE)
956 const_niv (FADV_WILLNEED , POSIX_FADV_WILLNEED)
957 const_niv (FADV_DONTNEED , POSIX_FADV_DONTNEED)
958
959 const_niv (MADV_NORMAL , POSIX_MADV_NORMAL)
960 const_niv (MADV_SEQUENTIAL, POSIX_MADV_SEQUENTIAL)
961 const_niv (MADV_RANDOM , POSIX_MADV_RANDOM)
962 const_niv (MADV_WILLNEED , POSIX_MADV_WILLNEED)
963 const_niv (MADV_DONTNEED , POSIX_MADV_DONTNEED)
964 1112
965 const_iv (ST_RDONLY) 1113 const_iv (ST_RDONLY)
966 const_iv (ST_NOSUID) 1114 const_iv (ST_NOSUID)
967 const_iv (ST_NODEV) 1115 const_iv (ST_NODEV)
968 const_iv (ST_NOEXEC) 1116 const_iv (ST_NOEXEC)
… …
978 const_iv (PROT_NONE) 1126 const_iv (PROT_NONE)
979 const_iv (PROT_EXEC) 1127 const_iv (PROT_EXEC)
980 const_iv (PROT_READ) 1128 const_iv (PROT_READ)
981 const_iv (PROT_WRITE) 1129 const_iv (PROT_WRITE)
982 1130
983 /*const_iv (MAP_FIXED)*/
984 const_iv (MAP_PRIVATE) 1131 const_iv (MAP_PRIVATE)
985 const_iv (MAP_SHARED) 1132 const_iv (MAP_SHARED)
1133 const_iv (MAP_FIXED)
986 const_iv (MAP_ANONYMOUS) 1134 const_iv (MAP_ANONYMOUS)
987 1135
988 /* linuxish */ 1136 /* linuxish */
989 const_iv (MAP_HUGETLB)
990 const_iv (MAP_LOCKED) 1137 const_iv (MAP_LOCKED)
991 const_iv (MAP_NORESERVE) 1138 const_iv (MAP_NORESERVE)
992 const_iv (MAP_POPULATE) 1139 const_iv (MAP_POPULATE)
993 const_iv (MAP_NONBLOCK) 1140 const_iv (MAP_NONBLOCK)
1141 const_iv (MAP_GROWSDOWN)
1142 const_iv (MAP_32BIT)
1143 const_iv (MAP_HUGETLB)
1144 const_iv (MAP_STACK)
1145
1146 const_iv (MREMAP_MAYMOVE)
1147 const_iv (MREMAP_FIXED)
1148
1149 const_iv (F_DUPFD_CLOEXEC)
1150
1151 const_iv (MSG_CMSG_CLOEXEC)
1152 const_iv (SOCK_CLOEXEC)
1153
1154 const_iv (F_OFD_GETLK)
1155 const_iv (F_OFD_SETLK)
1156 const_iv (F_OFD_GETLKW)
1157
1158 const_iv (FIFREEZE)
1159 const_iv (FITHAW)
1160 const_iv (FITRIM)
1161 const_iv (FICLONE)
1162 const_iv (FICLONERANGE)
1163 const_iv (FIDEDUPERANGE)
1164
1165 const_iv (FS_IOC_GETFLAGS)
1166 const_iv (FS_IOC_SETFLAGS)
1167 const_iv (FS_IOC_GETVERSION)
1168 const_iv (FS_IOC_SETVERSION)
1169 const_iv (FS_IOC_FIEMAP)
1170 const_iv (FS_IOC_FSGETXATTR)
1171 const_iv (FS_IOC_FSSETXATTR)
1172 const_iv (FS_IOC_SET_ENCRYPTION_POLICY)
1173 const_iv (FS_IOC_GET_ENCRYPTION_PWSALT)
1174 const_iv (FS_IOC_GET_ENCRYPTION_POLICY)
1175
1176 const_iv (FS_KEY_DESCRIPTOR_SIZE)
1177
1178 const_iv (FS_SECRM_FL)
1179 const_iv (FS_UNRM_FL)
1180 const_iv (FS_COMPR_FL)
1181 const_iv (FS_SYNC_FL)
1182 const_iv (FS_IMMUTABLE_FL)
1183 const_iv (FS_APPEND_FL)
1184 const_iv (FS_NODUMP_FL)
1185 const_iv (FS_NOATIME_FL)
1186 const_iv (FS_DIRTY_FL)
1187 const_iv (FS_COMPRBLK_FL)
1188 const_iv (FS_NOCOMP_FL)
1189 const_iv (FS_ENCRYPT_FL)
1190 const_iv (FS_BTREE_FL)
1191 const_iv (FS_INDEX_FL)
1192 const_iv (FS_JOURNAL_DATA_FL)
1193 const_iv (FS_NOTAIL_FL)
1194 const_iv (FS_DIRSYNC_FL)
1195 const_iv (FS_TOPDIR_FL)
1196 const_iv (FS_FL_USER_MODIFIABLE)
1197
1198 const_iv (FS_XFLAG_REALTIME)
1199 const_iv (FS_XFLAG_PREALLOC)
1200 const_iv (FS_XFLAG_IMMUTABLE)
1201 const_iv (FS_XFLAG_APPEND)
1202 const_iv (FS_XFLAG_SYNC)
1203 const_iv (FS_XFLAG_NOATIME)
1204 const_iv (FS_XFLAG_NODUMP)
1205 const_iv (FS_XFLAG_RTINHERIT)
1206 const_iv (FS_XFLAG_PROJINHERIT)
1207 const_iv (FS_XFLAG_NOSYMLINKS)
1208 const_iv (FS_XFLAG_EXTSIZE)
1209 const_iv (FS_XFLAG_EXTSZINHERIT)
1210 const_iv (FS_XFLAG_NODEFRAG)
1211 const_iv (FS_XFLAG_FILESTREAM)
1212 const_iv (FS_XFLAG_DAX)
1213 const_iv (FS_XFLAG_HASATTR)
994 1214
995 const_iv (FIEMAP_FLAG_SYNC) 1215 const_iv (FIEMAP_FLAG_SYNC)
996 const_iv (FIEMAP_FLAG_XATTR) 1216 const_iv (FIEMAP_FLAG_XATTR)
997 const_iv (FIEMAP_FLAGS_COMPAT) 1217 const_iv (FIEMAP_FLAGS_COMPAT)
998 const_iv (FIEMAP_EXTENT_LAST) 1218 const_iv (FIEMAP_EXTENT_LAST)
… …
1010 const_iv (SPLICE_F_MOVE) 1230 const_iv (SPLICE_F_MOVE)
1011 const_iv (SPLICE_F_NONBLOCK) 1231 const_iv (SPLICE_F_NONBLOCK)
1012 const_iv (SPLICE_F_MORE) 1232 const_iv (SPLICE_F_MORE)
1013 const_iv (SPLICE_F_GIFT) 1233 const_iv (SPLICE_F_GIFT)
1014 1234
1015 const_iv (SEEK_DATA) 1235 const_iv (EFD_CLOEXEC)
1236 const_iv (EFD_NONBLOCK)
1016 const_iv (SEEK_HOLE) 1237 const_iv (EFD_SEMAPHORE)
1017 1238
1018 /* libeio constants */ 1239 const_iv (CLOCK_REALTIME)
1240 const_iv (CLOCK_MONOTONIC)
1241 const_iv (CLOCK_BOOTTIME)
1242 const_iv (CLOCK_REALTIME_ALARM)
1243 const_iv (CLOCK_BOOTTIME_ALARM)
1244
1245 const_iv (TFD_NONBLOCK)
1246 const_iv (TFD_CLOEXEC)
1247
1248 const_iv (TFD_TIMER_ABSTIME)
1249 const_iv (TFD_TIMER_CANCEL_ON_SET)
1250
1251 /* these are libeio constants, and are independent of gendef0 */
1019 const_eio (SEEK_SET) 1252 const_eio (SEEK_SET)
1020 const_eio (SEEK_CUR) 1253 const_eio (SEEK_CUR)
1021 const_eio (SEEK_END) 1254 const_eio (SEEK_END)
1022 1255
1023 const_eio (MCL_FUTURE) 1256 const_eio (MCL_FUTURE)
… …
1035 1268
1036 const_eio (FALLOC_FL_KEEP_SIZE) 1269 const_eio (FALLOC_FL_KEEP_SIZE)
1037 const_eio (FALLOC_FL_PUNCH_HOLE) 1270 const_eio (FALLOC_FL_PUNCH_HOLE)
1038 const_eio (FALLOC_FL_COLLAPSE_RANGE) 1271 const_eio (FALLOC_FL_COLLAPSE_RANGE)
1039 const_eio (FALLOC_FL_ZERO_RANGE) 1272 const_eio (FALLOC_FL_ZERO_RANGE)
1273 const_eio (FALLOC_FL_INSERT_RANGE)
1274 const_eio (FALLOC_FL_UNSHARE_RANGE)
1275
1276 const_eio (RENAME_NOREPLACE)
1277 const_eio (RENAME_EXCHANGE)
1278 const_eio (RENAME_WHITEOUT)
1040 1279
1041 const_eio (READDIR_DENTS) 1280 const_eio (READDIR_DENTS)
1042 const_eio (READDIR_DIRS_FIRST) 1281 const_eio (READDIR_DIRS_FIRST)
1043 const_eio (READDIR_STAT_ORDER) 1282 const_eio (READDIR_STAT_ORDER)
1044 const_eio (READDIR_FOUND_UNKNOWN) 1283 const_eio (READDIR_FOUND_UNKNOWN)
… …
1295 REQ_SEND; 1534 REQ_SEND;
1296 } 1535 }
1297} 1536}
1298 1537
1299void 1538void
1539aio_ioctl (SV *fh, unsigned long request, SV8 *arg, SV *callback = &PL_sv_undef)
1540 ALIAS:
1541 aio_ioctl = EIO_IOCTL
1542 aio_fcntl = EIO_FCNTL
1543 PPCODE:
1544{
1545 int fd = s_fileno_croak (fh, 0);
1546 char *svptr;
1547
1548 if (SvPOK (arg) || !SvNIOK (arg))
1549 {
1550 STRLEN svlen;
1551 /* perl uses IOCPARM_LEN for fcntl, so we do, too */
1552#ifdef IOCPARM_LEN
1553 STRLEN need = IOCPARM_LEN (request);
1554#else
1555 STRLEN need = 256;
1556#endif
1557
1558 if (svlen < need)
1559 svptr = SvGROW (arg, need);
1560 }
1561 else
1562 svptr = (char *)SvIV (arg);
1563
1564 {
1565 dREQ;
1566
1567 req->type = ix;
1568 req->sv1 = newSVsv (fh);
1569 req->int1 = fd;
1570 req->int2 = (long)request;
1571 req->sv2 = SvREFCNT_inc (arg);
1572 req->ptr2 = svptr;
1573
1574 REQ_SEND;
1575 }
1576}
1577
1578void
1300aio_readlink (SV8 *pathname, SV *callback = &PL_sv_undef) 1579aio_readlink (SV8 *pathname, SV *callback = &PL_sv_undef)
1301 ALIAS: 1580 ALIAS:
1302 aio_readlink = EIO_READLINK 1581 aio_readlink = EIO_READLINK
1303 aio_realpath = EIO_REALPATH 1582 aio_realpath = EIO_REALPATH
1304 PPCODE: 1583 PPCODE:
… …
1359 req_set_fh_or_path (req, ix, ix == EIO_STATVFS ? EIO_FSTATVFS : EIO_FSTAT, fh_or_path); 1638 req_set_fh_or_path (req, ix, ix == EIO_STATVFS ? EIO_FSTATVFS : EIO_FSTAT, fh_or_path);
1360 1639
1361 REQ_SEND; 1640 REQ_SEND;
1362} 1641}
1363 1642
1643void
1644st_xtime ()
1645 ALIAS:
1646 st_atime = 1
1647 st_mtime = 2
1648 st_ctime = 4
1649 st_xtime = 7
1650 PPCODE:
1651 EXTEND (SP, 3);
1652 if (ix & 1) PUSHs (newSVnv (PL_statcache.st_atime + 1e-9 * ATIMENSEC));
1653 if (ix & 2) PUSHs (newSVnv (PL_statcache.st_mtime + 1e-9 * MTIMENSEC));
1654 if (ix & 4) PUSHs (newSVnv (PL_statcache.st_ctime + 1e-9 * CTIMENSEC));
1655
1656void
1657st_xtimensec ()
1658 ALIAS:
1659 st_atimensec = 1
1660 st_mtimensec = 2
1661 st_ctimensec = 4
1662 st_xtimensec = 7
1663 PPCODE:
1664 EXTEND (SP, 3);
1665 if (ix & 1) PUSHs (newSViv (ATIMENSEC));
1666 if (ix & 2) PUSHs (newSViv (MTIMENSEC));
1667 if (ix & 4) PUSHs (newSViv (CTIMENSEC));
1668
1364UV 1669UV
1365major (UV dev) 1670major (UV dev)
1366 ALIAS: 1671 ALIAS:
1367 minor = 1 1672 minor = 1
1368 CODE: 1673 CODE:
1369 RETVAL = ix ? major (dev) : minor (dev); 1674 RETVAL = ix ? minor (dev) : major (dev);
1370 OUTPUT: 1675 OUTPUT:
1371 RETVAL 1676 RETVAL
1372 1677
1373UV 1678UV
1374makedev (UV maj, UV min) 1679makedev (UV maj, UV min)
… …
1491 1796
1492 REQ_SEND; 1797 REQ_SEND;
1493} 1798}
1494 1799
1495void 1800void
1801aio_rename2 (SV8 *oldpath, SV8 *newpath, int flags = 0, SV *callback = &PL_sv_undef)
1802 PPCODE:
1803{
1804 eio_wd wd2 = 0;
1805 dREQ;
1806
1807 req->type = EIO_RENAME;
1808 req_set_path1 (req, oldpath);
1809 req_set_path (req, newpath, &req->sv2, &req->sv4, &wd2, &req->ptr2);
1810 req->int2 = flags;
1811 req->int3 = (long)wd2;
1812
1813 REQ_SEND;
1814}
1815
1816void
1496aio_mknod (SV8 *pathname, int mode, UV dev, SV *callback = &PL_sv_undef) 1817aio_mknod (SV8 *pathname, int mode, UV dev, SV *callback = &PL_sv_undef)
1497 PPCODE: 1818 PPCODE:
1498{ 1819{
1499 dREQ; 1820 dREQ;
1500 1821
… …
1505 1826
1506 REQ_SEND; 1827 REQ_SEND;
1507} 1828}
1508 1829
1509void 1830void
1510aio_mtouch (SV8 *data, IV offset = 0, SV *length = &PL_sv_undef, int flags = 0, SV *callback = &PL_sv_undef) 1831aio_mtouch (SV8 *data, IV offset = 0, SV *length = &PL_sv_undef, int flags = -1, SV *callback = &PL_sv_undef)
1511 ALIAS: 1832 ALIAS:
1512 aio_mtouch = EIO_MTOUCH 1833 aio_mtouch = EIO_MTOUCH
1513 aio_msync = EIO_MSYNC 1834 aio_msync = EIO_MSYNC
1514 PPCODE: 1835 PPCODE:
1515{ 1836{
1516 STRLEN svlen; 1837 STRLEN svlen;
1517 char *svptr = SvPVbyte (data, svlen); 1838 char *svptr = SvPVbyte (data, svlen);
1518 UV len = SvUV (length); 1839 UV len = SvUV (length);
1840
1841 if (flags < 0)
1842 flags = ix == EIO_MSYNC ? EIO_MS_SYNC : 0;
1519 1843
1520 if (offset < 0) 1844 if (offset < 0)
1521 offset += svlen; 1845 offset += svlen;
1522 1846
1523 if (offset < 0 || offset > svlen) 1847 if (offset < 0 || offset > svlen)
… …
1599 req->int2 = flags; 1923 req->int2 = flags;
1600 req->int3 = SvOK (count) ? SvIV (count) : -1; 1924 req->int3 = SvOK (count) ? SvIV (count) : -1;
1601#endif 1925#endif
1602 1926
1603 REQ_SEND; 1927 REQ_SEND;
1928}
1929
1930void
1931aio_slurp (SV *pathname, off_t offset, UV length, SV8 *data, SV *callback = &PL_sv_undef)
1932 PPCODE:
1933{
1934 char *svptr = 0;
1935
1936 sv_clear_foreign (data);
1937
1938 if (length) /* known length, directly read into scalar */
1939 {
1940 if (!SvPOK (data) || SvLEN (data) >= SvCUR (data))
1941 svptr = sv_grow (data, length + 1);
1942 else if (SvCUR (data) < length)
1943 croak ("length outside of scalar, and cannot grow");
1944 else
1945 svptr = SvPVbyte_nolen (data);
1946 }
1947
1948 {
1949 dREQ;
1950
1951 req->type = EIO_SLURP;
1952 req_set_path1 (req, pathname);
1953 req->offs = offset;
1954 req->size = length;
1955 req->sv2 = SvREFCNT_inc (data);
1956 req->ptr2 = svptr;
1957
1958 if (!SvREADONLY (data))
1959 {
1960 SvREADONLY_on (data);
1961 req->flags |= FLAG_SV2_RO_OFF;
1962 }
1963
1964 REQ_SEND;
1965 }
1604} 1966}
1605 1967
1606void 1968void
1607aio_busy (double delay, SV *callback = &PL_sv_undef) 1969aio_busy (double delay, SV *callback = &PL_sv_undef)
1608 PPCODE: 1970 PPCODE:
… …
1745 RETVAL 2107 RETVAL
1746 2108
1747void 2109void
1748mmap (SV *scalar, STRLEN length, int prot, int flags, SV *fh = &PL_sv_undef, off_t offset = 0) 2110mmap (SV *scalar, STRLEN length, int prot, int flags, SV *fh = &PL_sv_undef, off_t offset = 0)
1749 PPCODE: 2111 PPCODE:
1750 sv_unmagic (scalar, MMAP_MAGIC); 2112 sv_clear_foreign (scalar);
1751{ 2113{
1752 int fd = SvOK (fh) ? s_fileno_croak (fh, flags & PROT_WRITE) : -1; 2114 int fd = SvOK (fh) ? s_fileno_croak (fh, flags & PROT_WRITE) : -1;
1753 void *addr = (void *)mmap (0, length, prot, flags, fd, offset); 2115 void *addr = (void *)mmap (0, length, prot, flags, fd, offset);
1754 if (addr == (void *)-1) 2116 if (addr == (void *)-1)
1755 XSRETURN_NO; 2117 XSRETURN_NO;
1756 2118
1757 sv_force_normal (scalar); 2119 sv_set_foreign (scalar, &mmap_vtbl, addr, length);
1758
1759 /* we store the length in mg_obj, as namlen is I32 :/ */
1760 sv_magicext (scalar, 0, MMAP_MAGIC, &mmap_vtbl, (char *)addr, 0)
1761 ->mg_obj = (SV *)length;
1762
1763 SvUPGRADE (scalar, SVt_PV); /* nop... */
1764 2120
1765 if (!(prot & PROT_WRITE)) 2121 if (!(prot & PROT_WRITE))
1766 SvREADONLY_on (scalar); 2122 SvREADONLY_on (scalar);
1767 2123
1768 if (SvLEN (scalar))
1769 Safefree (SvPVX (scalar));
1770
1771 SvPVX (scalar) = (char *)addr;
1772 SvCUR_set (scalar, length);
1773 SvLEN_set (scalar, 0);
1774 SvPOK_only (scalar);
1775
1776 XSRETURN_YES; 2124 XSRETURN_YES;
1777} 2125}
1778 2126
1779void 2127void
1780munmap (SV *scalar) 2128munmap (SV *scalar)
1781 CODE: 2129 CODE:
1782 sv_unmagic (scalar, MMAP_MAGIC); 2130 sv_clear_foreign (scalar);
2131
2132SV *
2133mremap (SV *scalar, STRLEN new_length, int flags = MREMAP_MAYMOVE, IV new_address = 0)
2134 CODE:
2135{
2136 MAGIC *mg = mg_findext (scalar, FOREIGN_MAGIC, &mmap_vtbl);
2137 void *new;
2138
2139 if (!mg || SvPVX (scalar) != mg->mg_ptr)
2140 croak ("IO::AIO::mremap: scalar not mapped by IO::AIO::mmap or improperly modified");
2141
2142 new = mremap (mg->mg_ptr, (size_t)mg->mg_obj, new_length, flags, (void *)new_address);
2143
2144 RETVAL = &PL_sv_no;
2145
2146 if (new != (void *)-1)
2147 {
2148 RETVAL = new == (void *)mg->mg_ptr
2149 ? newSVpvn ("0 but true", 10)
2150 : &PL_sv_yes;
2151
2152 mg->mg_ptr = (char *)new;
2153 mg->mg_obj = (SV *)new_length;
2154
2155 SvPVX (scalar) = mg->mg_ptr;
2156 SvCUR_set (scalar, new_length);
2157 }
2158}
2159 OUTPUT:
2160 RETVAL
1783 2161
1784int 2162int
1785madvise (SV *scalar, STRLEN offset = 0, SV *length = &PL_sv_undef, IV advice_or_prot) 2163madvise (SV *scalar, STRLEN offset = 0, SV *length = &PL_sv_undef, IV advice_or_prot)
1786 ALIAS: 2164 ALIAS:
1787 mprotect = 1 2165 mprotect = 1
… …
1893 errno = ENOSYS; 2271 errno = ENOSYS;
1894 RETVAL = -1; 2272 RETVAL = -1;
1895#endif 2273#endif
1896 OUTPUT: 2274 OUTPUT:
1897 RETVAL 2275 RETVAL
2276
2277void
2278pipe2 (int flags = 0)
2279 PROTOTYPE: ;$
2280 PPCODE:
2281{
2282 int fd[2];
2283 int res;
2284
2285 if (flags)
2286#if HAVE_PIPE2
2287 res = pipe2 (fd, flags);
2288#else
2289 res = (errno = ENOSYS, -1);
2290#endif
2291 else
2292 res = pipe (fd);
2293
2294 if (!res)
2295 {
2296 EXTEND (SP, 2);
2297 PUSHs (newmortalFH (fd[0], O_RDONLY));
2298 PUSHs (newmortalFH (fd[1], O_WRONLY));
2299 }
2300}
2301
2302void
2303eventfd (unsigned int initval = 0, int flags = 0)
2304 PPCODE:
2305{
2306 int fd;
2307#if HAVE_EVENTFD
2308 fd = eventfd (initval, flags);
2309#else
2310 fd = (errno = ENOSYS, -1);
2311#endif
2312
2313 XPUSHs (newmortalFH (fd, O_RDWR));
2314}
2315
2316void
2317timerfd_create (int clockid, int flags = 0)
2318 PPCODE:
2319{
2320 int fd;
2321#if HAVE_TIMERFD
2322 fd = timerfd_create (clockid, flags);
2323#else
2324 fd = (errno = ENOSYS, -1);
2325#endif
2326
2327 XPUSHs (newmortalFH (fd, O_RDWR));
2328}
2329
2330void
2331timerfd_settime (SV *fh, int flags, NV interval, NV value)
2332 PPCODE:
2333{
2334 int fd = s_fileno_croak (fh, 0);
2335#if HAVE_TIMERFD
2336 int res;
2337 struct itimerspec its, ots;
2338
2339 ts_set (&its.it_interval, interval);
2340 ts_set (&its.it_value , value);
2341 res = timerfd_settime (fd, flags, &its, &ots);
2342
2343 if (!res)
2344 {
2345 EXTEND (SP, 2);
2346 PUSHs (newSVnv (ts_get (&ots.it_interval)));
2347 PUSHs (newSVnv (ts_get (&ots.it_value)));
2348 }
2349#else
2350 errno = ENOSYS;
2351#endif
2352}
2353
2354void
2355timerfd_gettime (SV *fh)
2356 PPCODE:
2357{
2358 int fd = s_fileno_croak (fh, 0);
2359#if HAVE_TIMERFD
2360 int res;
2361 struct itimerspec ots;
2362 res = timerfd_gettime (fd, &ots);
2363
2364 if (!res)
2365 {
2366 EXTEND (SP, 2);
2367 PUSHs (newSVnv (ts_get (&ots.it_interval)));
2368 PUSHs (newSVnv (ts_get (&ots.it_value)));
2369 }
2370#else
2371 errno = ENOSYS;
2372#endif
2373}
2374
2375UV
2376get_fdlimit ()
2377 CODE:
2378#if HAVE_RLIMITS
2379 struct rlimit rl;
2380 if (0 == getrlimit (RLIMIT_NOFILE, &rl))
2381 XSRETURN_UV (rl.rlim_cur == RLIM_INFINITY ? (UV)-1 : rl.rlim_cur);
2382#endif
2383 XSRETURN_UNDEF;
2384 OUTPUT:
2385 RETVAL
2386
2387void
2388min_fdlimit (UV limit = 0x7fffffffU)
2389 CODE:
2390{
2391#if HAVE_RLIMITS
2392 struct rlimit rl;
2393 rlim_t orig_rlim_max;
2394 UV bit;
2395
2396 if (0 != getrlimit (RLIMIT_NOFILE, &rl))
2397 goto fail;
2398
2399 if (rl.rlim_cur == RLIM_INFINITY)
2400 XSRETURN_YES;
2401
2402 orig_rlim_max = rl.rlim_max == RLIM_INFINITY ? ((rlim_t)0)-1 : rl.rlim_max;
2403
2404 if (rl.rlim_cur < limit)
2405 {
2406 rl.rlim_cur = limit;
2407
2408 if (rl.rlim_max < rl.rlim_cur && rl.rlim_max != RLIM_INFINITY)
2409 rl.rlim_max = rl.rlim_cur;
2410 }
2411
2412 if (0 == setrlimit (RLIMIT_NOFILE, &rl))
2413 XSRETURN_YES;
2414
2415 if (errno == EPERM)
2416 {
2417 /* setlimit failed with EPERM - maybe we can't raise the hardlimit, or maybe */
2418 /* our limit overflows a system-wide limit */
2419 /* try an adaptive algorithm, but do not lower the hardlimit */
2420 rl.rlim_max = 0;
2421 for (bit = 0x40000000U; bit; bit >>= 1)
2422 {
2423 rl.rlim_max |= bit;
2424 rl.rlim_cur = rl.rlim_max;
2425
2426 /* nevr decrease the hard limit */
2427 if (rl.rlim_max < orig_rlim_max)
2428 break;
2429
2430 if (0 != setrlimit (RLIMIT_NOFILE, &rl))
2431 rl.rlim_max &= ~bit; /* too high, remove bit again */
2432 }
2433
2434 /* now, raise the soft limit to the max permitted */
2435 if (0 == getrlimit (RLIMIT_NOFILE, &rl))
2436 {
2437 rl.rlim_cur = rl.rlim_max;
2438 if (0 == setrlimit (RLIMIT_NOFILE, &rl))
2439 errno = EPERM;
2440 }
2441 }
2442#endif
2443 fail:
2444 XSRETURN_UNDEF;
2445}
1898 2446
1899void _on_next_submit (SV *cb) 2447void _on_next_submit (SV *cb)
1900 CODE: 2448 CODE:
1901 SvREFCNT_dec (on_next_submit); 2449 SvREFCNT_dec (on_next_submit);
1902 on_next_submit = SvOK (cb) ? newSVsv (cb) : 0; 2450 on_next_submit = SvOK (cb) ? newSVsv (cb) : 0;

Diff Legend

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