File Coverage

AIO.xs
Criterion Covered Total %
statement 336 900 37.3
branch 180 914 19.6
condition n/a
subroutine n/a
pod n/a
total 516 1814 28.4


line stmt bran cond sub pod time code
1             #include "libeio/xthread.h"
2              
3             #include
4              
5             #include "EXTERN.h"
6             #include "perl.h"
7             #include "XSUB.h"
8             #include "perliol.h"
9              
10             #if !defined mg_findext
11             # define mg_findext(sv,type,vtbl) mg_find (sv, type)
12             #endif
13              
14             #include
15             #include
16             #include
17             #include
18             #include
19             #include
20             #include
21             #include
22             #include
23              
24             /* perl namespace pollution */
25             #undef VERSION
26              
27             /* perl stupidly overrides readdir and maybe others */
28             /* with thread-unsafe versions, imagine that :( */
29             #undef readdir
30             #undef opendir
31             #undef closedir
32              
33             #ifdef _WIN32
34              
35             // perl overrides all those nice libc functions
36              
37             #undef malloc
38             #undef free
39             #undef open
40             #undef read
41             #undef write
42             #undef send
43             #undef recv
44             #undef stat
45             #undef lstat
46             #undef fstat
47             #undef truncate
48             #undef ftruncate
49             #undef open
50             #undef link
51             #undef close
52             #undef unlink
53             #undef mkdir
54             #undef rmdir
55             #undef rename
56             #undef lseek
57             #undef opendir
58             #undef readdir
59             #undef closedir
60             #undef chmod
61             #undef fchmod
62             #undef dup
63             #undef dup2
64             #undef abort
65             #undef pipe
66             #undef utime
67              
68             #define EIO_STRUCT_STAT struct _stati64
69             #define EIO_STRUCT_STATI64
70              
71             #else
72              
73             #include
74             #include
75             #include
76             #include
77             #include
78             #include
79              
80             #define EIO_STRUCT_STAT Stat_t
81              
82             #endif
83              
84             /*****************************************************************************/
85              
86             #if __GNUC__ >= 3
87             # define expect(expr,value) __builtin_expect ((expr),(value))
88             #else
89             # define expect(expr,value) (expr)
90             #endif
91              
92             #define expect_false(expr) expect ((expr) != 0, 0)
93             #define expect_true(expr) expect ((expr) != 0, 1)
94              
95             /*****************************************************************************/
96              
97             #include "config.h"
98              
99             #if HAVE_SYS_MKDEV_H
100             # include
101             #elif HAVE_SYS_SYSMACROS_H
102             # include
103             #endif
104              
105             #if _POSIX_MEMLOCK || _POSIX_MEMLOCK_RANGE || _POSIX_MAPPED_FILES
106             # include
107             #endif
108              
109             #if HAVE_SYS_UIO_H
110             # include
111             #endif
112              
113             /* MUST be included before linux/fs.h, as the latter includes
114             * linux/mount.h, which is incompatible to sys/mount.h
115             */
116             #if HAVE_SYS_MOUNT_H
117             # include
118             #endif
119              
120             /* the incompetent fool that created musl keeps __linux__, refuses
121             * to implement any linux standard apis, and also has no way to test
122             * for his broken implementation. don't complain to me if this fails
123             * for you.
124             */
125             #if __linux__ && (defined __GLIBC__ || defined __UCLIBC__)
126             # include /* MUST be included after sys/mount.h */
127             # ifdef FS_IOC_FIEMAP
128             # include
129             # include
130             # undef HAVE_FIEMAP
131             # define HAVE_FIEMAP 1
132             # endif
133             #endif
134              
135             #if HAVE_ST_XTIMENSEC
136             # define ATIMENSEC PL_statcache.st_atimensec
137             # define MTIMENSEC PL_statcache.st_mtimensec
138             # define CTIMENSEC PL_statcache.st_ctimensec
139             #elif HAVE_ST_XTIMESPEC
140             # define ATIMENSEC PL_statcache.st_atim.tv_nsec
141             # define MTIMENSEC PL_statcache.st_mtim.tv_nsec
142             # define CTIMENSEC PL_statcache.st_ctim.tv_nsec
143             #else
144             # define ATIMENSEC 0
145             # define MTIMENSEC 0
146             # define CTIMENSEC 0
147             #endif
148              
149             #if HAVE_ST_BIRTHTIMENSEC
150             # define BTIMESEC PL_statcache.st_birthtime
151             # define BTIMENSEC PL_statcache.st_birthtimensec
152             #elif HAVE_ST_BIRTHTIMESPEC
153             # define BTIMESEC PL_statcache.st_birthtim.tv_sec
154             # define BTIMENSEC PL_statcache.st_birthtim.tv_nsec
155             #else
156             # define BTIMESEC 0
157             # define BTIMENSEC 0
158             #endif
159              
160             #if HAVE_ST_GEN
161             # define ST_GEN PL_statcache.st_gen
162             #else
163             # define ST_GEN 0
164             #endif
165              
166             #include "schmorp.h"
167              
168             #if HAVE_EVENTFD
169             # include
170             #endif
171              
172             #if HAVE_TIMERFD
173             # include
174             #endif
175              
176             #if HAVE_RLIMITS
177             #include
178             #include
179             #endif
180              
181             typedef SV SV8; /* byte-sv, used for argument-checking */
182             typedef char *octet_string;
183             typedef char *octet_string_ornull;
184             typedef int aio_rfd; /* read file desriptor */
185             typedef int aio_wfd; /* write file descriptor */
186              
187             static HV *aio_stash, *aio_req_stash, *aio_grp_stash, *aio_wd_stash;
188              
189             #define EIO_REQ_MEMBERS \
190             SV *callback; \
191             SV *sv1, *sv2; \
192             SV *sv3, *sv4; \
193             STRLEN stroffset; \
194             SV *self;
195              
196             #define EIO_NO_WRAPPERS 1
197              
198             #include "libeio/eio.h"
199              
200             static int req_invoke (eio_req *req);
201             #define EIO_FINISH(req) req_invoke (req)
202             static void req_destroy (eio_req *grp);
203             #define EIO_DESTROY(req) req_destroy (req)
204              
205             #include "libeio/eio.c"
206              
207             #if !HAVE_POSIX_FADVISE
208             # define posix_fadvise(a,b,c,d) errno = ENOSYS /* also return ENOSYS */
209             #endif
210              
211             #if !HAVE_POSIX_MADVISE
212             # define posix_madvise(a,b,c) errno = ENOSYS /* also return ENOSYS */
213             #endif
214              
215             #ifndef MAP_ANONYMOUS
216             # ifdef MAP_ANON
217             # define MAP_ANONYMOUS MAP_ANON
218             # else
219             # define MAP_ANONYMOUS MAP_FIXED /* and hope this fails */
220             # endif
221             #endif
222              
223             #ifndef makedev
224             # define makedev(maj,min) (((maj) << 8) | (min))
225             #endif
226             #ifndef major
227             # define major(dev) ((dev) >> 8)
228             #endif
229             #ifndef minor
230             # define minor(dev) ((dev) & 0xff)
231             #endif
232              
233             /* solaris has a non-posix/unix compliant PAGESIZE that breaks compilation */
234             #ifdef __sun
235             # undef PAGESIZE
236             #endif
237              
238             #if PAGESIZE <= 0
239             # define PAGESIZE sysconf (_SC_PAGESIZE)
240             #endif
241              
242             /* solaris perl seems to declare a wrong syscall function that clashes with system includes */
243             #ifdef __sun
244             # undef HAVE_SYSCALL
245             #endif
246              
247             #if HAVE_SYSCALL
248             #include
249             #else
250             # define syscall(nr,...) (errno = ENOSYS, -1)
251             #endif
252              
253             /*****************************************************************************/
254              
255             #if !_POSIX_MAPPED_FILES
256             # define mmap(addr,length,prot,flags,fd,offs) (errno = ENOSYS, (void *)-1)
257             # define munmap(addr,length) EIO_ENOSYS ()
258             #endif
259              
260             #if !_POSIX_MEMORY_PROTECTION
261             # define mprotect(addr,len,prot) EIO_ENOSYS ()
262             #endif
263              
264             #if !MREMAP_MAYMOVE
265             # define mremap(old_address,old_size,new_size,flags,new_address) (errno = ENOSYS, (void *)-1)
266             #endif
267              
268             #define FOREIGN_MAGIC PERL_MAGIC_ext
269              
270             static int ecb_cold
271 0           mmap_free (pTHX_ SV *sv, MAGIC *mg)
272             {
273 0           int old_errno = errno;
274 0           munmap (mg->mg_ptr, (size_t)mg->mg_obj);
275 0           errno = old_errno;
276              
277 0           mg->mg_obj = 0; /* just in case */
278              
279 0           SvREADONLY_off (sv);
280              
281 0 0         if (SvPVX (sv) != mg->mg_ptr)
282 0           croak ("ERROR: IO::AIO::mmap-mapped scalar changed location, detected");
283              
284 0           SvCUR_set (sv, 0);
285 0           SvPVX (sv) = 0;
286 0 0         SvOK_off (sv);
287              
288 0           return 0;
289             }
290              
291             static MGVTBL mmap_vtbl = {
292             0, 0, 0, 0, mmap_free
293             };
294              
295             static int ecb_cold
296 0           sysfree_free (pTHX_ SV *sv, MAGIC *mg)
297             {
298 0           free (mg->mg_ptr);
299 0           mg->mg_obj = 0; /* just in case */
300              
301 0           SvREADONLY_off (sv);
302              
303 0 0         if (SvPVX (sv) != mg->mg_ptr)
304 0           croak ("ERROR: IO::AIO mapped scalar changed location, detected");
305              
306 0           SvCUR_set (sv, 0);
307 0           SvPVX (sv) = 0;
308 0 0         SvOK_off (sv);
309              
310 0           return 0;
311             }
312              
313             static MGVTBL sysfree_vtbl = {
314             0, 0, 0, 0, sysfree_free
315             };
316              
317             /*****************************************************************************/
318              
319             /* helper: set scalar to foreign ptr with custom free */
320             ecb_noinline
321             static void
322 0           sv_set_foreign (SV *sv, const MGVTBL *const vtbl, void *addr, IV length)
323             {
324 0           sv_force_normal (sv);
325              
326             /* we store the length in mg_obj, as namlen is I32 :/ */
327 0           sv_magicext (sv, 0, FOREIGN_MAGIC, vtbl, (char *)addr, 0)
328 0           ->mg_obj = (SV *)length;
329              
330 0 0         SvUPGRADE (sv, SVt_PV); /* nop... */
331              
332 0 0         if (SvLEN (sv))
333 0           Safefree (SvPVX (sv));
334              
335 0           SvPVX (sv) = (char *)addr;
336 0           SvCUR_set (sv, length);
337 0           SvLEN_set (sv, 0);
338 0           SvPOK_only (sv);
339 0           }
340              
341             static void
342 0           sv_clear_foreign (SV *sv)
343             {
344             /* todo: iterate over magic and only free ours, but of course */
345             /* the perl5porters will call that (correct) behaviour buggy */
346 0           sv_unmagic (sv, FOREIGN_MAGIC);
347 0           }
348              
349             /*****************************************************************************/
350              
351             /* defines all sorts of constants to 0 unless they are already defined */
352             /* also provides const_iv_ and const_niv_ macros for them */
353             #include "def0.h"
354              
355             /*****************************************************************************/
356              
357             static void
358 0           fiemap (eio_req *req)
359             {
360 0           req->result = -1;
361              
362             #if HAVE_FIEMAP
363             /* assume some c99 */
364 0           struct fiemap *fiemap = 0;
365             size_t end_offset;
366 0           int count = req->int3;
367              
368 0           req->flags |= EIO_FLAG_PTR1_FREE;
369              
370             /* heuristic: start with 512 bytes (8 extents), and if that isn't enough, */
371             /* increase in fixed steps */
372 0 0         if (count < 0)
373 0           count = 8;
374              
375 0           fiemap = malloc (sizeof (*fiemap) + sizeof (struct fiemap_extent) * count);
376 0           errno = ENOMEM;
377 0 0         if (!fiemap)
378 0           return;
379              
380 0           req->ptr1 = fiemap;
381              
382 0           fiemap->fm_start = req->offs;
383 0           fiemap->fm_length = req->size;
384 0           fiemap->fm_flags = req->int2;
385 0           fiemap->fm_extent_count = count;
386              
387 0 0         if (ioctl (req->int1, FS_IOC_FIEMAP, fiemap) < 0)
388 0           return;
389              
390 0 0         if (req->int3 >= 0 /* not autosizing */
391 0 0         || !fiemap->fm_mapped_extents /* no more extents */
392 0 0         || fiemap->fm_extents [fiemap->fm_mapped_extents - 1].fe_flags & FIEMAP_EXTENT_LAST /* hit eof */)
393             goto done;
394              
395             /* else we have to loop -
396             * it would be tempting (actually I tried that first) to just query the
397             * number of extents needed, but linux often feels like not returning all
398             * extents, without telling us it left any out. this complicates
399             * this quite a bit.
400             */
401              
402 0 0         end_offset = fiemap->fm_length + (fiemap->fm_length == FIEMAP_MAX_OFFSET ? 0 : fiemap->fm_start);
403              
404             for (;;)
405             {
406             /* we go in 54 extent steps - 3kb, in the hope that this fits nicely on the eio stack (normally 16+ kb) */
407             char scratch[3072];
408 0           struct fiemap *incmap = (struct fiemap *)scratch;
409              
410 0           incmap->fm_start = fiemap->fm_extents [fiemap->fm_mapped_extents - 1].fe_logical
411 0           + fiemap->fm_extents [fiemap->fm_mapped_extents - 1].fe_length;
412 0           incmap->fm_length = fiemap->fm_length - (incmap->fm_start - fiemap->fm_start);
413 0           incmap->fm_flags = fiemap->fm_flags;
414 0           incmap->fm_extent_count = (sizeof (scratch) - sizeof (struct fiemap)) / sizeof (struct fiemap_extent);
415              
416 0 0         if (ioctl (req->int1, FS_IOC_FIEMAP, incmap) < 0)
417 0           return;
418              
419 0 0         if (!incmap->fm_mapped_extents)
420 0           goto done;
421              
422 0           count = fiemap->fm_mapped_extents + incmap->fm_mapped_extents;
423 0           fiemap = realloc (fiemap, sizeof (*fiemap) + sizeof (struct fiemap_extent) * count);
424 0           errno = ENOMEM;
425 0 0         if (!fiemap)
426 0           return;
427              
428 0           req->ptr1 = fiemap;
429              
430 0 0         for (count = 0; count < incmap->fm_mapped_extents; ++count)
431             {
432 0           struct fiemap_extent *e = incmap->fm_extents + count;
433              
434 0           fiemap->fm_extents [fiemap->fm_mapped_extents++] = *e;
435              
436 0 0         if (e->fe_logical >= end_offset)
437 0           goto done;
438              
439 0 0         if (e->fe_flags & FIEMAP_EXTENT_LAST)
440 0           goto done;
441              
442             }
443 0           }
444              
445             done:
446 0           req->result = 0;
447              
448             #else
449             errno = ENOSYS;
450             #endif
451             }
452              
453             /*****************************************************************************/
454              
455             static int close_fd; /* dummy fd to close fds via dup2 */
456              
457             #if HAVE_STATX
458             static struct statx stx;
459             #define statx_offsetof(member) offsetof (struct statx, member)
460             #define eio__statx statx
461             #else
462             #define statx_offsetof(member) 0
463             #define eio__statx(dir,path,flags,mask,stx) EIO_ENOSYS()
464             #endif
465              
466             enum {
467             FLAG_SV2_RO_OFF = 0x40, /* data was set readonly */
468             };
469              
470             typedef eio_req *aio_req;
471             typedef eio_req *aio_req_ornot;
472             typedef eio_wd aio_wd;
473              
474             static SV *on_next_submit;
475             static int next_pri = EIO_PRI_DEFAULT;
476             static int max_outstanding;
477              
478             static s_epipe respipe;
479              
480             static void req_destroy (aio_req req);
481             static void req_cancel (aio_req req);
482              
483             static void
484 49           want_poll (void)
485             {
486             /* write a dummy byte to the pipe so fh becomes ready */
487 49           s_epipe_signal (&respipe);
488 49           }
489              
490             static void
491 40           done_poll (void)
492             {
493             /* read any signals sent by the worker threads */
494 40           s_epipe_drain (&respipe);
495 40           }
496              
497             /* must be called at most once */
498             ecb_noinline
499             static SV *
500 59           req_sv (aio_req req, HV *stash)
501             {
502 59 100         if (!req->self)
503             {
504 38           req->self = (SV *)newHV ();
505 38           sv_magic (req->self, 0, PERL_MAGIC_ext, (char *)req, 0);
506             }
507              
508 59           return sv_2mortal (sv_bless (newRV_inc (req->self), stash));
509             }
510              
511             static SV *
512 19           newSVaio_wd (aio_wd wd)
513             {
514 19           return sv_bless (newRV_noinc (newSViv ((intptr_t)wd)), aio_wd_stash);
515             }
516              
517             ecb_noinline
518             static aio_req
519 86           SvAIO_REQ (SV *sv)
520             {
521             MAGIC *mg;
522              
523 86 50         if (!SvROK (sv)
524             /* for speed reasons, we do not verify that SvROK actually has a stash ptr */
525 86 100         || (SvSTASH (SvRV (sv)) != aio_grp_stash
526 43 50         && SvSTASH (SvRV (sv)) != aio_req_stash
527 0 0         && !sv_derived_from (sv, "IO::AIO::REQ")))
528 0           croak ("object of class IO::AIO::REQ expected");
529              
530 86           mg = mg_find (SvRV (sv), PERL_MAGIC_ext);
531              
532 86 50         return mg ? (aio_req)mg->mg_ptr : 0;
533             }
534              
535             static aio_wd
536 37           SvAIO_WD (SV *sv)
537             {
538 37 50         if (!SvROK (sv)
539 37 50         || SvTYPE (SvRV (sv)) != SVt_PVMG
540 37 50         || SvSTASH (SvRV (sv)) != aio_wd_stash)
541 0           croak ("IO::AIO: expected a working directory object as returned by aio_wd");
542              
543 37           return (aio_wd)(long)SvIVX (SvRV (sv));
544             }
545              
546             static SV *
547 4           newmortalFH (int fd, int flags)
548             {
549 4 100         if (fd < 0)
550 1           return &PL_sv_undef;
551              
552 3           GV *gv = (GV *)sv_newmortal ();
553             char sym[64];
554             int symlen;
555            
556 3           symlen = snprintf (sym, sizeof (sym), "fd#%d", fd);
557 3           gv_init (gv, aio_stash, sym, symlen, 0);
558              
559 4 100         symlen = snprintf (
560             sym,
561             sizeof (sym),
562             "%s&=%d",
563 1 50         flags == O_RDONLY ? "<" : flags == O_WRONLY ? ">" : "+<",
564             fd
565             );
566              
567 7           return do_open (gv, sym, symlen, 0, 0, 0, 0)
568 3 50         ? (SV *)gv : &PL_sv_undef;
569             }
570              
571             static void
572 22           aio_grp_feed (aio_req grp)
573             {
574 22 50         if (grp->sv2 && SvOK (grp->sv2))
    100          
    50          
    50          
575             {
576 21           dSP;
577              
578 21           ENTER;
579 21           SAVETMPS;
580 21 50         PUSHMARK (SP);
581 21 50         XPUSHs (req_sv (grp, aio_grp_stash));
582 21           PUTBACK;
583 21           call_sv (grp->sv2, G_VOID | G_EVAL | G_KEEPERR);
584 21           SPAGAIN;
585 21 50         FREETMPS;
586 21           LEAVE;
587             }
588 22           }
589              
590             ecb_noinline
591             static void
592 82           req_submit (eio_req *req)
593             {
594 82           eio_submit (req);
595              
596 82 50         if (expect_false (on_next_submit))
597             {
598 0           dSP;
599 0           SV *cb = sv_2mortal (on_next_submit);
600              
601 0           on_next_submit = 0;
602              
603 0 0         PUSHMARK (SP);
604 0           PUTBACK;
605 0           call_sv (cb, G_DISCARD | G_EVAL);
606             }
607 82           }
608              
609             static int
610 62           req_invoke (eio_req *req)
611             {
612 62 100         if (req->flags & FLAG_SV2_RO_OFF)
613 1           SvREADONLY_off (req->sv2);
614              
615 62 100         if (!EIO_CANCELLED (req) && req->callback)
    100          
616             {
617 58           dSP;
618             static SV *sv_result_cache; /* caches the result integer SV */
619             SV *sv_result;
620              
621 58           ENTER;
622 58           SAVETMPS;
623 58 50         PUSHMARK (SP);
624 58 50         EXTEND (SP, 1);
625              
626             /* do not recreate the result IV from scratch each time */
627 58 100         if (expect_true (sv_result_cache))
628             {
629 50           sv_result = sv_result_cache; sv_result_cache = 0;
630 50           SvIV_set (sv_result, req->result);
631 50 50         SvIOK_only (sv_result);
632             }
633             else
634             {
635 8           sv_result = newSViv (req->result);
636 8           SvREADONLY_on (sv_result);
637             }
638              
639 58           switch (req->type)
640             {
641             case EIO_WD_OPEN:
642 1 50         PUSHs (req->result ? &PL_sv_undef : sv_2mortal (newSVaio_wd (req->wd)));
643 1           break;
644              
645             case EIO_READDIR:
646             {
647 4           SV *rv = &PL_sv_undef;
648              
649 4 50         if (req->result >= 0)
650             {
651             int i;
652 4           char *names = (char *)req->ptr2;
653 4           eio_dirent *ent = (eio_dirent *)req->ptr1; /* might be 0 */
654 4           AV *av = newAV ();
655              
656 4           av_extend (av, req->result - 1);
657              
658 144 100         for (i = 0; i < req->result; ++i)
659             {
660 140 100         if (req->int1 & EIO_READDIR_DENTS)
661             {
662 105           SV *namesv = newSVpvn (names + ent->nameofs, ent->namelen);
663              
664 105 100         if (req->int1 & EIO_READDIR_CUSTOM2)
665             {
666             static SV *sv_type [EIO_DT_MAX + 1]; /* type sv cache */
667 35           AV *avent = newAV ();
668              
669 35           av_extend (avent, 2);
670              
671 35 100         if (!sv_type [ent->type])
672             {
673 2           sv_type [ent->type] = newSViv (ent->type);
674 2           SvREADONLY_on (sv_type [ent->type]);
675             }
676              
677 35           av_store (avent, 0, namesv);
678 35           av_store (avent, 1, SvREFCNT_inc (sv_type [ent->type]));
679 35           av_store (avent, 2, IVSIZE >= 8 ? newSVuv (ent->inode) : newSVnv (ent->inode));
680              
681 35           av_store (av, i, newRV_noinc ((SV *)avent));
682             }
683             else
684 70           av_store (av, i, namesv);
685              
686 105           ++ent;
687             }
688             else
689             {
690 35           SV *name = newSVpv (names, 0);
691 35           av_store (av, i, name);
692 35           names += SvCUR (name) + 1;
693             }
694             }
695              
696 4           rv = sv_2mortal (newRV_noinc ((SV *)av));
697             }
698              
699 4           PUSHs (rv);
700              
701 4 100         if (req->int1 & EIO_READDIR_CUSTOM1)
702 3 50         XPUSHs (sv_2mortal (newSViv (req->int1 & ~(EIO_READDIR_CUSTOM1 | EIO_READDIR_CUSTOM2))));
703             }
704 4           break;
705              
706             case EIO_OPEN:
707 4           PUSHs (newmortalFH (req->result, req->int1 & (O_RDONLY | O_WRONLY | O_RDWR)));
708 4           break;
709              
710             case EIO_STATVFS:
711             case EIO_FSTATVFS:
712             {
713 0           SV *rv = &PL_sv_undef;
714            
715             #ifndef _WIN32
716 0 0         if (req->result >= 0)
717             {
718 0           EIO_STRUCT_STATVFS *f = EIO_STATVFS_BUF (req);
719 0           HV *hv = newHV ();
720             /* POSIX requires fsid to be unsigned long, but AIX in its infinite wisdom
721             * chooses to make it a struct.
722             */
723 0           unsigned long fsid = 0;
724 0           memcpy (&fsid, &f->f_fsid, sizeof (unsigned long) < sizeof (f->f_fsid) ? sizeof (unsigned long) : sizeof (f->f_fsid));
725              
726 0           rv = sv_2mortal (newRV_noinc ((SV *)hv));
727              
728 0           hv_store (hv, "bsize" , sizeof ("bsize" ) - 1, newSVval64 (f->f_bsize ), 0);
729 0           hv_store (hv, "frsize" , sizeof ("frsize" ) - 1, newSVval64 (f->f_frsize ), 0);
730 0           hv_store (hv, "blocks" , sizeof ("blocks" ) - 1, newSVval64 (f->f_blocks ), 0);
731 0           hv_store (hv, "bfree" , sizeof ("bfree" ) - 1, newSVval64 (f->f_bfree ), 0);
732 0           hv_store (hv, "bavail" , sizeof ("bavail" ) - 1, newSVval64 (f->f_bavail ), 0);
733 0           hv_store (hv, "files" , sizeof ("files" ) - 1, newSVval64 (f->f_files ), 0);
734 0           hv_store (hv, "ffree" , sizeof ("ffree" ) - 1, newSVval64 (f->f_ffree ), 0);
735 0           hv_store (hv, "favail" , sizeof ("favail" ) - 1, newSVval64 (f->f_favail ), 0);
736 0           hv_store (hv, "fsid" , sizeof ("fsid" ) - 1, newSVval64 (fsid ), 0);
737 0           hv_store (hv, "flag" , sizeof ("flag" ) - 1, newSVval64 (f->f_flag ), 0);
738 0           hv_store (hv, "namemax", sizeof ("namemax") - 1, newSVval64 (f->f_namemax), 0);
739             }
740             #endif
741              
742 0           PUSHs (rv);
743             }
744              
745 0           break;
746              
747             case EIO_GROUP:
748 5           req->int1 = 2; /* mark group as finished */
749              
750 5 100         if (req->sv1)
751             {
752             int i;
753 2           AV *av = (AV *)req->sv1;
754              
755 2 50         EXTEND (SP, AvFILL (av) + 1);
    50          
    50          
    50          
    0          
756 7 50         for (i = 0; i <= AvFILL (av); ++i)
    100          
757 5           PUSHs (*av_fetch (av, i, 0));
758             }
759 5           break;
760              
761             case EIO_NOP:
762             case EIO_BUSY:
763 14           break;
764              
765             case EIO_READLINK:
766             case EIO_REALPATH:
767 0 0         if (req->result > 0)
768 0           PUSHs (sv_2mortal (newSVpvn (req->ptr2, req->result)));
769 0           break;
770              
771             case EIO_STAT:
772             case EIO_LSTAT:
773             case EIO_FSTAT:
774 24 100         PL_laststype = req->type == EIO_LSTAT ? OP_LSTAT : OP_STAT;
775              
776 24 100         if (!(PL_laststatval = req->result))
777             /* if compilation fails here then perl's Stat_t is not struct _stati64 */
778 18           PL_statcache = *(EIO_STRUCT_STAT *)(req->ptr2);
779              
780 24           PUSHs (sv_result);
781 24           break;
782              
783             case EIO_SEEK:
784 0 0         PUSHs (req->result ? sv_result : sv_2mortal (newSVval64 (req->offs)));
785 0           break;
786              
787             case EIO_READ:
788             {
789 1           SvCUR_set (req->sv2, req->stroffset + (req->result > 0 ? req->result : 0));
790 1           *SvEND (req->sv2) = 0;
791 1           SvPOK_only (req->sv2);
792 1 50         SvSETMAGIC (req->sv2);
793 1           PUSHs (sv_result);
794             }
795 1           break;
796              
797             case EIO_SLURP:
798             {
799 0 0         if (req->result >= 0)
800             {
801             /* if length was originally not known, we steal the malloc'ed memory */
802 0 0         if (req->flags & EIO_FLAG_PTR2_FREE)
803             {
804 0           req->flags &= ~EIO_FLAG_PTR2_FREE;
805 0           sv_set_foreign (req->sv2, &sysfree_vtbl, req->ptr2, req->result);
806             }
807             else
808             {
809 0           SvCUR_set (req->sv2, req->result);
810 0           *SvEND (req->sv2) = 0;
811 0           SvPOK_only (req->sv2);
812             }
813              
814 0 0         SvSETMAGIC (req->sv2);
815             }
816              
817 0           PUSHs (sv_result);
818             }
819 0           break;
820              
821             case EIO_CUSTOM:
822 0 0         if (req->feed == fiemap)
823             {
824             #if HAVE_FIEMAP
825 0 0         if (!req->result)
826             {
827 0           struct fiemap *fiemap = (struct fiemap *)req->ptr1;
828              
829 0 0         if (fiemap->fm_extent_count)
830             {
831 0           AV *av = newAV ();
832             int i;
833              
834 0 0         while (fiemap->fm_mapped_extents)
835             {
836 0           struct fiemap_extent *extent = &fiemap->fm_extents [--fiemap->fm_mapped_extents];
837 0           AV *ext_av = newAV ();
838              
839 0           av_store (ext_av, 3, newSVuv (extent->fe_flags));
840 0           av_store (ext_av, 2, newSVval64 (extent->fe_length));
841 0           av_store (ext_av, 1, newSVval64 (extent->fe_physical));
842 0           av_store (ext_av, 0, newSVval64 (extent->fe_logical));
843              
844 0           av_store (av, fiemap->fm_mapped_extents, newRV_noinc ((SV *)ext_av));
845             }
846              
847 0           PUSHs (sv_2mortal (newRV_noinc ((SV *)av)));
848             }
849             else
850             {
851 0           SvIV_set (sv_result, fiemap->fm_mapped_extents);
852 0           PUSHs (sv_result);
853             }
854             }
855             #endif
856             }
857             else
858 0           PUSHs (sv_result);
859 0           break;
860              
861             #if 0
862             case EIO_CLOSE:
863             PerlIOUnix_refcnt_dec (req->int1);
864             break;
865             #endif
866              
867             case EIO_DUP2: /* EIO_DUP2 actually means aio_close(), so fudge result value */
868 1 50         if (req->result > 0)
869 1           SvIV_set (sv_result, 0);
870             /* FALLTHROUGH */
871              
872             default:
873 5           PUSHs (sv_result);
874 5           break;
875             }
876              
877 58           errno = req->errorno;
878              
879 58           PUTBACK;
880 58           call_sv (req->callback, G_VOID | G_EVAL | G_DISCARD);
881 58           SPAGAIN;
882              
883 58 50         if (expect_false (SvREFCNT (sv_result) != 1 || sv_result_cache))
    50          
    50          
884 0           SvREFCNT_dec (sv_result);
885             else
886 58           sv_result_cache = sv_result;
887              
888 58 100         FREETMPS;
889 58           LEAVE;
890              
891 58           PUTBACK;
892             }
893              
894 62 50         return !!SvTRUE (ERRSV);
    50          
    50          
    50          
    0          
    0          
    50          
    50          
    0          
    0          
    0          
    0          
    50          
    50          
    50          
    50          
    50          
    50          
    50          
    50          
    0          
    0          
    50          
    0          
    0          
    0          
    0          
    0          
    0          
    0          
    0          
    0          
    0          
    0          
    0          
    0          
895             }
896              
897             static void
898 62           req_destroy (aio_req req)
899             {
900 62 100         if (req->self)
901             {
902 38           sv_unmagic (req->self, PERL_MAGIC_ext);
903 38           SvREFCNT_dec (req->self);
904             }
905              
906 62           SvREFCNT_dec (req->sv1);
907 62           SvREFCNT_dec (req->sv2);
908 62           SvREFCNT_dec (req->sv3);
909 62           SvREFCNT_dec (req->sv4);
910 62           SvREFCNT_dec (req->callback);
911              
912 62           free (req);
913 62           }
914              
915             static void
916 0           req_cancel_subs (aio_req grp)
917             {
918 0 0         if (grp->type != EIO_GROUP)
919 0           return;
920              
921 0           SvREFCNT_dec (grp->sv2);
922 0           grp->sv2 = 0;
923              
924 0           eio_grp_cancel (grp);
925             }
926              
927             ecb_cold
928             static void
929 10           create_respipe (void)
930             {
931 10 50         if (s_epipe_renew (&respipe))
932 0           croak ("IO::AIO: unable to initialize result pipe");
933 10           }
934              
935             static void
936 24           poll_wait (void)
937             {
938 42 50         while (eio_nreqs ())
939             {
940             int size;
941              
942 42           X_LOCK (EIO_POOL->reslock);
943 42           size = EIO_POOL->res_queue.size;
944 42           X_UNLOCK (EIO_POOL->reslock);
945              
946 42 100         if (size)
947 24           return;
948              
949 18           etp_maybe_start_thread (EIO_POOL);
950              
951 18           s_epipe_wait (&respipe);
952             }
953             }
954              
955             static int
956 38           poll_cb (void)
957             {
958             for (;;)
959             {
960 38           int res = eio_poll ();
961              
962 38 50         if (res > 0)
963 0           croak (0);
964              
965 38 50         if (!max_outstanding || max_outstanding > eio_nreqs ())
    0          
966 38           return res;
967              
968 0           poll_wait ();
969 0           }
970             }
971              
972             ecb_cold
973             static void
974 10           reinit (void)
975             {
976 10           create_respipe ();
977              
978 10 50         if (eio_init (want_poll, done_poll) < 0)
979 0           croak ("IO::AIO: unable to initialise eio library");
980 10           }
981              
982             /*****************************************************************************/
983              
984             static SV *
985 92           get_cb (SV *cb_sv)
986             {
987 92 50         SvGETMAGIC (cb_sv);
    0          
988 92 100         return SvOK (cb_sv) ? s_get_cv_croak (cb_sv) : 0;
    50          
    50          
989             }
990              
991             ecb_noinline
992             static aio_req ecb_noinline
993 82           dreq (SV *callback)
994             {
995             SV *cb_cv;
996             aio_req req;
997 82           int req_pri = next_pri;
998 82           next_pri = EIO_PRI_DEFAULT;
999              
1000 82           cb_cv = get_cb (callback);
1001              
1002 82           req = calloc (sizeof (*req), 1);
1003 82 50         if (!req)
1004 0           croak ("out of memory during eio_req allocation");
1005              
1006 82           req->callback = SvREFCNT_inc (cb_cv);
1007 82           req->pri = req_pri;
1008              
1009 82           return req;
1010             }
1011              
1012             #define dREQ \
1013             aio_req req = dreq (callback); \
1014              
1015             #define REQ_SEND \
1016             PUTBACK; \
1017             req_submit (req); \
1018             SPAGAIN; \
1019             \
1020             if (GIMME_V != G_VOID) \
1021             XPUSHs (req_sv (req, aio_req_stash));
1022              
1023             /* *wdsv, *pathsv, *wd and *ptr must be 0-initialized */
1024             ecb_inline
1025             void
1026 39           req_set_path (SV *path, SV **wdsv, SV **pathsv, eio_wd *wd, void **ptr)
1027             {
1028 39 100         if (expect_false (SvROK (path)))
1029             {
1030 18           SV *rv = SvRV (path);
1031             SV *wdob;
1032              
1033 18 50         if (SvTYPE (rv) == SVt_PVAV && AvFILLp (rv) == 1)
    50          
1034             {
1035 18           path = AvARRAY (rv)[1];
1036 18           wdob = AvARRAY (rv)[0];
1037              
1038 36 50         if (SvOK (wdob))
    0          
    0          
1039             {
1040 18           *wd = SvAIO_WD (wdob);
1041 18           *wdsv = SvREFCNT_inc_NN (SvRV (wdob));
1042             }
1043             else
1044 0           *wd = EIO_INVALID_WD;
1045             }
1046 0 0         else if (SvTYPE (rv) == SVt_PVMG && SvSTASH (rv) == aio_wd_stash)
    0          
1047             {
1048 0           *wd = (aio_wd)(long)SvIVX (rv);
1049 0           *wdsv = SvREFCNT_inc_NN (rv);
1050 0           *ptr = ".";
1051 0           return; /* path set to "." */
1052             }
1053             else
1054 0           croak ("IO::AIO: pathname arguments must be specified as a string, an IO::AIO::WD object or a [IO::AIO::WD, path] pair");
1055             }
1056              
1057 39           *pathsv = newSVsv (path);
1058 39 50         *ptr = SvPVbyte_nolen (*pathsv);
1059             }
1060              
1061             ecb_noinline
1062             static void
1063 38           req_set_path1 (aio_req req, SV *path)
1064             {
1065 38           req_set_path (path, &req->sv1, &req->sv3, &req->wd, &req->ptr1);
1066 38           }
1067              
1068             ecb_noinline
1069             static void
1070 26           req_set_fh_or_path (aio_req req, int type_path, int type_fh, SV *fh_or_path)
1071             {
1072 26 100         SV *rv = SvROK (fh_or_path) ? SvRV (fh_or_path) : fh_or_path;
1073              
1074 26 100         switch (SvTYPE (rv))
1075             {
1076             case SVt_PVIO:
1077             case SVt_PVLV:
1078             case SVt_PVGV:
1079 1           req->type = type_fh;
1080 1           req->sv1 = newSVsv (fh_or_path);
1081 1           req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
1082 1           break;
1083              
1084             default:
1085 25           req->type = type_path;
1086 25           req_set_path1 (req, fh_or_path);
1087 25           break;
1088             }
1089 26           }
1090              
1091             /*****************************************************************************/
1092              
1093             static void
1094 0           ts_set (struct timespec *ts, NV value)
1095             {
1096 0           ts->tv_sec = value;
1097 0           ts->tv_nsec = (value - ts->tv_sec) * 1e9;
1098 0           }
1099              
1100             static NV
1101 0           ts_get (const struct timespec *ts)
1102             {
1103 0           return ts->tv_sec + ts->tv_nsec * 1e-9;
1104             }
1105              
1106             /*****************************************************************************/
1107              
1108             /* extract a ref-to-array of strings into a temporary c style string vector */
1109             static char **
1110 0           extract_stringvec (SV *sv, const char *croakmsg)
1111             {
1112 0 0         if (!SvROK (sv) || SvTYPE (SvRV (sv)) != SVt_PVAV)
    0          
1113 0           croak ("%s", croakmsg);
1114              
1115 0           AV *av = (AV *)SvRV (sv);
1116 0           int i, nelem = av_len (av) + 1;
1117 0           char **vecp = (char **)SvPVX (sv_2mortal (newSV (sizeof (char *) * (nelem + 1))));
1118              
1119 0 0         for (i = 0; i < nelem; ++i)
1120             {
1121 0           SV **e = av_fetch (av, i, 0);
1122              
1123 0 0         if (e && *e)
    0          
1124 0 0         vecp[i] = SvPVbyte_nolen (*e);
1125             else
1126 0           vecp[i] = "";
1127             }
1128              
1129 0           vecp[nelem] = 0;
1130              
1131 0           return vecp;
1132             }
1133              
1134             /*****************************************************************************/
1135              
1136             XS(boot_IO__AIO) ecb_cold;
1137              
1138             MODULE = IO::AIO PACKAGE = IO::AIO
1139              
1140             PROTOTYPES: ENABLE
1141              
1142             BOOT:
1143             {
1144             static const struct {
1145             const char *name;
1146             IV iv;
1147             } *civ, const_iv[] = {
1148             # define const_niv(name, value) { # name, (IV) value },
1149             # define const_iv(name) { # name, (IV) name },
1150             # define const_eio(name) { # name, (IV) EIO_ ## name },
1151              
1152             /* you have to re-run ./gendef0 after adding/removing any constants here */
1153             /* the first block can be undef if missing */
1154             const_iv (ENOSYS)
1155             const_iv (EXDEV)
1156             const_iv (EBADR)
1157              
1158             /* for lseek */
1159             const_iv (SEEK_DATA)
1160             const_iv (SEEK_HOLE)
1161              
1162             const_niv (FADV_NORMAL , POSIX_FADV_NORMAL)
1163             const_niv (FADV_SEQUENTIAL, POSIX_FADV_SEQUENTIAL)
1164             const_niv (FADV_RANDOM , POSIX_FADV_RANDOM)
1165             const_niv (FADV_NOREUSE , POSIX_FADV_NOREUSE)
1166             const_niv (FADV_WILLNEED , POSIX_FADV_WILLNEED)
1167             const_niv (FADV_DONTNEED , POSIX_FADV_DONTNEED)
1168              
1169             const_niv (MADV_NORMAL , POSIX_MADV_NORMAL)
1170             const_niv (MADV_SEQUENTIAL, POSIX_MADV_SEQUENTIAL)
1171             const_niv (MADV_RANDOM , POSIX_MADV_RANDOM)
1172             const_niv (MADV_WILLNEED , POSIX_MADV_WILLNEED)
1173             const_niv (MADV_DONTNEED , POSIX_MADV_DONTNEED)
1174              
1175             /* the second block will be 0 when missing */
1176             const_iv (O_ACCMODE)
1177              
1178             const_iv (O_RDONLY)
1179             const_iv (O_WRONLY)
1180             const_iv (O_RDWR)
1181             const_iv (O_CREAT)
1182             const_iv (O_TRUNC)
1183             const_iv (O_EXCL)
1184             const_iv (O_APPEND)
1185              
1186             const_iv (O_ASYNC)
1187             const_iv (O_DIRECT)
1188             const_iv (O_NOATIME)
1189              
1190             const_iv (O_CLOEXEC)
1191             const_iv (O_NOCTTY)
1192             const_iv (O_NOFOLLOW)
1193             const_iv (O_NONBLOCK)
1194             const_iv (O_EXEC)
1195             const_iv (O_SEARCH)
1196             const_iv (O_DIRECTORY)
1197             const_iv (O_DSYNC)
1198             const_iv (O_RSYNC)
1199             const_iv (O_SYNC)
1200             const_iv (O_PATH)
1201             const_iv (O_TMPFILE)
1202             const_iv (O_TTY_INIT)
1203              
1204             const_iv (S_IFIFO)
1205             const_iv (S_IFCHR)
1206             const_iv (S_IFBLK)
1207             const_iv (S_IFLNK)
1208             const_iv (S_IFREG)
1209             const_iv (S_IFDIR)
1210             const_iv (S_IFWHT)
1211             const_iv (S_IFSOCK)
1212             const_iv (S_IFMT)
1213              
1214             const_iv (ST_RDONLY)
1215             const_iv (ST_NOSUID)
1216             const_iv (ST_NODEV)
1217             const_iv (ST_NOEXEC)
1218             const_iv (ST_SYNCHRONOUS)
1219             const_iv (ST_MANDLOCK)
1220             const_iv (ST_WRITE)
1221             const_iv (ST_APPEND)
1222             const_iv (ST_IMMUTABLE)
1223             const_iv (ST_NOATIME)
1224             const_iv (ST_NODIRATIME)
1225             const_iv (ST_RELATIME)
1226              
1227             const_iv (PROT_NONE)
1228             const_iv (PROT_EXEC)
1229             const_iv (PROT_READ)
1230             const_iv (PROT_WRITE)
1231              
1232             const_iv (MAP_PRIVATE)
1233             const_iv (MAP_SHARED)
1234             const_iv (MAP_FIXED)
1235             const_iv (MAP_ANONYMOUS)
1236              
1237             /* linuxish */
1238             const_iv (MAP_LOCKED)
1239             const_iv (MAP_NORESERVE)
1240             const_iv (MAP_POPULATE)
1241             const_iv (MAP_NONBLOCK)
1242             const_iv (MAP_GROWSDOWN)
1243             const_iv (MAP_32BIT)
1244             const_iv (MAP_HUGETLB)
1245             const_iv (MAP_STACK)
1246             const_iv (MAP_FIXED_NOREPLACE)
1247             const_iv (MAP_SHARED_VALIDATE)
1248             const_iv (MAP_SYNC)
1249             const_iv (MAP_UNINITIALIZED)
1250              
1251             const_iv (MREMAP_MAYMOVE)
1252             const_iv (MREMAP_FIXED)
1253              
1254             const_iv (MSG_CMSG_CLOEXEC)
1255             const_iv (SOCK_CLOEXEC)
1256              
1257             const_iv (F_DUPFD_CLOEXEC)
1258              
1259             const_iv (F_ADD_SEALS)
1260             const_iv (F_GET_SEALS)
1261             const_iv (F_SEAL_SEAL)
1262             const_iv (F_SEAL_SHRINK)
1263             const_iv (F_SEAL_GROW)
1264             const_iv (F_SEAL_WRITE)
1265              
1266             const_iv (F_OFD_GETLK)
1267             const_iv (F_OFD_SETLK)
1268             const_iv (F_OFD_GETLKW)
1269              
1270             const_iv (FIFREEZE)
1271             const_iv (FITHAW)
1272             const_iv (FITRIM)
1273             const_iv (FICLONE)
1274             const_iv (FICLONERANGE)
1275             const_iv (FIDEDUPERANGE)
1276              
1277             const_iv (FS_IOC_GETFLAGS)
1278             const_iv (FS_IOC_SETFLAGS)
1279             const_iv (FS_IOC_GETVERSION)
1280             const_iv (FS_IOC_SETVERSION)
1281             const_iv (FS_IOC_FIEMAP)
1282             const_iv (FS_IOC_FSGETXATTR)
1283             const_iv (FS_IOC_FSSETXATTR)
1284             const_iv (FS_IOC_SET_ENCRYPTION_POLICY)
1285             const_iv (FS_IOC_GET_ENCRYPTION_PWSALT)
1286             const_iv (FS_IOC_GET_ENCRYPTION_POLICY)
1287              
1288             const_iv (FS_KEY_DESCRIPTOR_SIZE)
1289              
1290             const_iv (FS_SECRM_FL)
1291             const_iv (FS_UNRM_FL)
1292             const_iv (FS_COMPR_FL)
1293             const_iv (FS_SYNC_FL)
1294             const_iv (FS_IMMUTABLE_FL)
1295             const_iv (FS_APPEND_FL)
1296             const_iv (FS_NODUMP_FL)
1297             const_iv (FS_NOATIME_FL)
1298             const_iv (FS_DIRTY_FL)
1299             const_iv (FS_COMPRBLK_FL)
1300             const_iv (FS_NOCOMP_FL)
1301             const_iv (FS_ENCRYPT_FL)
1302             const_iv (FS_BTREE_FL)
1303             const_iv (FS_INDEX_FL)
1304             const_iv (FS_JOURNAL_DATA_FL)
1305             const_iv (FS_NOTAIL_FL)
1306             const_iv (FS_DIRSYNC_FL)
1307             const_iv (FS_TOPDIR_FL)
1308             const_iv (FS_FL_USER_MODIFIABLE)
1309              
1310             const_iv (FS_XFLAG_REALTIME)
1311             const_iv (FS_XFLAG_PREALLOC)
1312             const_iv (FS_XFLAG_IMMUTABLE)
1313             const_iv (FS_XFLAG_APPEND)
1314             const_iv (FS_XFLAG_SYNC)
1315             const_iv (FS_XFLAG_NOATIME)
1316             const_iv (FS_XFLAG_NODUMP)
1317             const_iv (FS_XFLAG_RTINHERIT)
1318             const_iv (FS_XFLAG_PROJINHERIT)
1319             const_iv (FS_XFLAG_NOSYMLINKS)
1320             const_iv (FS_XFLAG_EXTSIZE)
1321             const_iv (FS_XFLAG_EXTSZINHERIT)
1322             const_iv (FS_XFLAG_NODEFRAG)
1323             const_iv (FS_XFLAG_FILESTREAM)
1324             const_iv (FS_XFLAG_DAX)
1325             const_iv (FS_XFLAG_HASATTR)
1326              
1327             const_iv (FIEMAP_FLAG_SYNC)
1328             const_iv (FIEMAP_FLAG_XATTR)
1329             const_iv (FIEMAP_FLAGS_COMPAT)
1330             const_iv (FIEMAP_EXTENT_LAST)
1331             const_iv (FIEMAP_EXTENT_UNKNOWN)
1332             const_iv (FIEMAP_EXTENT_DELALLOC)
1333             const_iv (FIEMAP_EXTENT_ENCODED)
1334             const_iv (FIEMAP_EXTENT_DATA_ENCRYPTED)
1335             const_iv (FIEMAP_EXTENT_NOT_ALIGNED)
1336             const_iv (FIEMAP_EXTENT_DATA_INLINE)
1337             const_iv (FIEMAP_EXTENT_DATA_TAIL)
1338             const_iv (FIEMAP_EXTENT_UNWRITTEN)
1339             const_iv (FIEMAP_EXTENT_MERGED)
1340             const_iv (FIEMAP_EXTENT_SHARED)
1341              
1342             const_iv (SPLICE_F_MOVE)
1343             const_iv (SPLICE_F_NONBLOCK)
1344             const_iv (SPLICE_F_MORE)
1345             const_iv (SPLICE_F_GIFT)
1346              
1347             const_iv (EFD_CLOEXEC)
1348             const_iv (EFD_NONBLOCK)
1349             const_iv (EFD_SEMAPHORE)
1350              
1351             const_iv (MFD_CLOEXEC)
1352             const_iv (MFD_ALLOW_SEALING)
1353             const_iv (MFD_HUGETLB)
1354             const_iv (MFD_HUGETLB_2MB)
1355             const_iv (MFD_HUGETLB_1GB)
1356              
1357             const_iv (CLOCK_REALTIME)
1358             const_iv (CLOCK_MONOTONIC)
1359             const_iv (CLOCK_BOOTTIME)
1360             const_iv (CLOCK_REALTIME_ALARM)
1361             const_iv (CLOCK_BOOTTIME_ALARM)
1362              
1363             const_iv (TFD_NONBLOCK)
1364             const_iv (TFD_CLOEXEC)
1365              
1366             const_iv (TFD_TIMER_ABSTIME)
1367             const_iv (TFD_TIMER_CANCEL_ON_SET)
1368              
1369             const_iv (STATX_TYPE)
1370             const_iv (STATX_MODE)
1371             const_iv (STATX_NLINK)
1372             const_iv (STATX_UID)
1373             const_iv (STATX_GID)
1374             const_iv (STATX_ATIME)
1375             const_iv (STATX_MTIME)
1376             const_iv (STATX_CTIME)
1377             const_iv (STATX_INO)
1378             const_iv (STATX_SIZE)
1379             const_iv (STATX_BLOCKS)
1380             const_iv (STATX_BASIC_STATS)
1381             const_iv (STATX_ALL)
1382             const_iv (STATX_BTIME)
1383             const_iv (STATX_ATTR_COMPRESSED)
1384             const_iv (STATX_ATTR_IMMUTABLE)
1385             const_iv (STATX_ATTR_APPEND)
1386             const_iv (STATX_ATTR_NODUMP)
1387             const_iv (STATX_ATTR_ENCRYPTED)
1388             const_iv (STATX_ATTR_AUTOMOUNT)
1389              
1390             const_iv (AT_FDCWD)
1391             const_iv (AT_SYMLINK_NOFOLLOW)
1392             const_iv (AT_EACCESS)
1393             const_iv (AT_REMOVEDIR)
1394             const_iv (AT_SYMLINK_FOLLOW)
1395             const_iv (AT_NO_AUTOMOUNT)
1396             const_iv (AT_EMPTY_PATH)
1397             const_iv (AT_STATX_SYNC_TYPE)
1398             const_iv (AT_STATX_AS_STAT)
1399             const_iv (AT_STATX_FORCE_SYNC)
1400             const_iv (AT_STATX_DONT_SYNC)
1401             const_iv (AT_RECURSIVE)
1402              
1403             const_iv (OPEN_TREE_CLONE)
1404              
1405             const_iv (FSOPEN_CLOEXEC)
1406              
1407             const_iv (FSPICK_CLOEXEC)
1408             const_iv (FSPICK_SYMLINK_NOFOLLOW)
1409             const_iv (FSPICK_NO_AUTOMOUNT)
1410             const_iv (FSPICK_EMPTY_PATH)
1411              
1412             const_iv (MOVE_MOUNT_F_SYMLINKS)
1413             const_iv (MOVE_MOUNT_F_AUTOMOUNTS)
1414             const_iv (MOVE_MOUNT_F_EMPTY_PATH)
1415             const_iv (MOVE_MOUNT_T_SYMLINKS)
1416             const_iv (MOVE_MOUNT_T_AUTOMOUNTS)
1417             const_iv (MOVE_MOUNT_T_EMPTY_PATH)
1418              
1419             /* waitid */
1420             const_iv (P_PID)
1421             const_iv (P_PIDFD)
1422             const_iv (P_PGID)
1423             const_iv (P_ALL)
1424              
1425             const_iv (FSCONFIG_SET_FLAG)
1426             const_iv (FSCONFIG_SET_STRING)
1427             const_iv (FSCONFIG_SET_BINARY)
1428             const_iv (FSCONFIG_SET_PATH)
1429             const_iv (FSCONFIG_SET_PATH_EMPTY)
1430             const_iv (FSCONFIG_SET_FD)
1431             const_iv (FSCONFIG_CMD_CREATE)
1432             const_iv (FSCONFIG_CMD_RECONFIGURE)
1433              
1434             const_iv (MOUNT_ATTR_RDONLY)
1435             const_iv (MOUNT_ATTR_NOSUID)
1436             const_iv (MOUNT_ATTR_NODEV)
1437             const_iv (MOUNT_ATTR_NOEXEC)
1438             const_iv (MOUNT_ATTR__ATIME)
1439             const_iv (MOUNT_ATTR_RELATIME)
1440             const_iv (MOUNT_ATTR_NOATIME)
1441             const_iv (MOUNT_ATTR_STRICTATIME)
1442             const_iv (MOUNT_ATTR_NODIRATIME)
1443              
1444             /* sys/mount.h */
1445             const_iv (MS_RDONLY)
1446             const_iv (MS_NOSUID)
1447             const_iv (MS_NODEV)
1448             const_iv (MS_NOEXEC)
1449             const_iv (MS_SYNCHRONOUS)
1450             const_iv (MS_REMOUNT)
1451             const_iv (MS_MANDLOCK)
1452             const_iv (MS_DIRSYNC)
1453             const_iv (MS_NOATIME)
1454             const_iv (MS_NODIRATIME)
1455             const_iv (MS_BIND)
1456             const_iv (MS_MOVE)
1457             const_iv (MS_REC)
1458             const_iv (MS_SILENT)
1459             const_iv (MS_POSIXACL)
1460             const_iv (MS_UNBINDABLE)
1461             const_iv (MS_PRIVATE)
1462             const_iv (MS_SLAVE)
1463             const_iv (MS_SHARED)
1464             const_iv (MS_RELATIME)
1465             const_iv (MS_KERNMOUNT)
1466             const_iv (MS_I_VERSION)
1467             const_iv (MS_STRICTATIME)
1468             const_iv (MS_LAZYTIME)
1469             const_iv (MS_ACTIVE)
1470             const_iv (MS_NOUSER)
1471             const_iv (MS_RMT_MASK)
1472             const_iv (MS_MGC_VAL)
1473             const_iv (MS_MGC_MSK)
1474              
1475             const_iv (MNT_FORCE)
1476             const_iv (MNT_DETACH)
1477             const_iv (MNT_EXPIRE)
1478             const_iv (UMOUNT_NOFOLLOW)
1479              
1480             const_iv (BLKROSET)
1481             const_iv (BLKROGET)
1482             const_iv (BLKRRPART)
1483             const_iv (BLKGETSIZE)
1484             const_iv (BLKFLSBUF)
1485             const_iv (BLKRASET)
1486             const_iv (BLKRAGET)
1487             const_iv (BLKFRASET)
1488             const_iv (BLKFRAGET)
1489             const_iv (BLKSECTSET)
1490             const_iv (BLKSECTGET)
1491             const_iv (BLKSSZGET)
1492             const_iv (BLKBSZGET)
1493             const_iv (BLKBSZSET)
1494             const_iv (BLKGETSIZE64)
1495              
1496             /* these are libeio constants, and are independent of gendef0 */
1497             const_eio (SEEK_SET)
1498             const_eio (SEEK_CUR)
1499             const_eio (SEEK_END)
1500              
1501             const_eio (MCL_FUTURE)
1502             const_eio (MCL_CURRENT)
1503             const_eio (MCL_ONFAULT)
1504              
1505             const_eio (MS_ASYNC)
1506             const_eio (MS_INVALIDATE)
1507             const_eio (MS_SYNC)
1508              
1509             const_eio (MT_MODIFY)
1510              
1511             const_eio (SYNC_FILE_RANGE_WAIT_BEFORE)
1512             const_eio (SYNC_FILE_RANGE_WRITE)
1513             const_eio (SYNC_FILE_RANGE_WAIT_AFTER)
1514              
1515             const_eio (FALLOC_FL_KEEP_SIZE)
1516             const_eio (FALLOC_FL_PUNCH_HOLE)
1517             const_eio (FALLOC_FL_COLLAPSE_RANGE)
1518             const_eio (FALLOC_FL_ZERO_RANGE)
1519             const_eio (FALLOC_FL_INSERT_RANGE)
1520             const_eio (FALLOC_FL_UNSHARE_RANGE)
1521              
1522             const_eio (RENAME_NOREPLACE)
1523             const_eio (RENAME_EXCHANGE)
1524             const_eio (RENAME_WHITEOUT)
1525              
1526             const_eio (READDIR_DENTS)
1527             const_eio (READDIR_DIRS_FIRST)
1528             const_eio (READDIR_STAT_ORDER)
1529             const_eio (READDIR_FOUND_UNKNOWN)
1530              
1531             const_eio (DT_UNKNOWN)
1532             const_eio (DT_FIFO)
1533             const_eio (DT_CHR)
1534             const_eio (DT_DIR)
1535             const_eio (DT_BLK)
1536             const_eio (DT_REG)
1537             const_eio (DT_LNK)
1538             const_eio (DT_SOCK)
1539             const_eio (DT_WHT)
1540             };
1541              
1542 9           aio_stash = gv_stashpv ("IO::AIO" , 1);
1543 9           aio_req_stash = gv_stashpv ("IO::AIO::REQ", 1);
1544 9           aio_grp_stash = gv_stashpv ("IO::AIO::GRP", 1);
1545 9           aio_wd_stash = gv_stashpv ("IO::AIO::WD" , 1);
1546              
1547 2979 100         for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ > const_iv; civ--)
1548 2970           newCONSTSUB (aio_stash, (char *)civ[-1].name, newSViv (civ[-1].iv));
1549              
1550 9           newCONSTSUB (aio_stash, "PAGESIZE", newSViv (PAGESIZE));
1551              
1552             /* allocate dummy pipe fd for aio_close */
1553             {
1554             int pipefd [2];
1555              
1556 9 50         if (
1557             #ifdef _WIN32
1558             _pipe (pipefd, 1, _O_BINARY) < 0
1559             #else
1560 9           pipe (pipefd) < 0
1561 9 50         || fcntl (pipefd [0], F_SETFD, FD_CLOEXEC) < 0
1562             #endif
1563 9 50         || close (pipefd [1]) < 0
1564             )
1565 0           croak ("IO::AIO: unable to create dummy pipe for aio_close");
1566              
1567 9           close_fd = pipefd [0];
1568             }
1569              
1570 9           reinit ();
1571             }
1572              
1573             void
1574             reinit ()
1575             PROTOTYPE:
1576              
1577             void
1578             max_poll_reqs (unsigned int nreqs)
1579             PROTOTYPE: $
1580             CODE:
1581 0           eio_set_max_poll_reqs (nreqs);
1582              
1583             void
1584             max_poll_time (double nseconds)
1585             PROTOTYPE: $
1586             CODE:
1587 0           eio_set_max_poll_time (nseconds);
1588              
1589             void
1590             min_parallel (unsigned int nthreads)
1591             PROTOTYPE: $
1592             CODE:
1593 16           eio_set_min_parallel (nthreads);
1594              
1595             void
1596             max_parallel (unsigned int nthreads)
1597             PROTOTYPE: $
1598             CODE:
1599 1           eio_set_max_parallel (nthreads);
1600              
1601             void
1602             max_idle (unsigned int nthreads)
1603             PROTOTYPE: $
1604             CODE:
1605 0           eio_set_max_idle (nthreads);
1606              
1607             void
1608             idle_timeout (unsigned int seconds)
1609             PROTOTYPE: $
1610             CODE:
1611 0           eio_set_idle_timeout (seconds);
1612              
1613             void
1614             max_outstanding (unsigned int maxreqs)
1615             PROTOTYPE: $
1616             CODE:
1617 0           max_outstanding = maxreqs;
1618              
1619             void
1620             aio_wd (SV8 *pathname, SV *callback = &PL_sv_undef)
1621             PPCODE:
1622             {
1623 1           dREQ;
1624              
1625 1           req->type = EIO_WD_OPEN;
1626 1           req_set_path1 (req, pathname);
1627              
1628 1 50         REQ_SEND;
    50          
    50          
1629             }
1630              
1631             void
1632             aio_open (SV8 *pathname, int flags, int mode, SV *callback = &PL_sv_undef)
1633             PPCODE:
1634             {
1635 4           dREQ;
1636              
1637 4           req->type = EIO_OPEN;
1638 4           req_set_path1 (req, pathname);
1639 4           req->int1 = flags;
1640 4           req->int2 = mode;
1641              
1642 4 50         REQ_SEND;
    50          
    0          
1643             }
1644              
1645             void
1646             aio_fsync (SV *fh, SV *callback = &PL_sv_undef)
1647             ALIAS:
1648             aio_fsync = EIO_FSYNC
1649             aio_fdatasync = EIO_FDATASYNC
1650             aio_syncfs = EIO_SYNCFS
1651             PPCODE:
1652             {
1653 0           int fd = s_fileno_croak (fh, 0);
1654 0           dREQ;
1655              
1656 0           req->type = ix;
1657 0           req->sv1 = newSVsv (fh);
1658 0           req->int1 = fd;
1659              
1660 0 0         REQ_SEND;
    0          
    0          
1661             }
1662              
1663             void
1664             aio_sync_file_range (SV *fh, off_t offset, size_t nbytes, UV flags, SV *callback = &PL_sv_undef)
1665             PPCODE:
1666             {
1667 0           int fd = s_fileno_croak (fh, 0);
1668 0           dREQ;
1669              
1670 0           req->type = EIO_SYNC_FILE_RANGE;
1671 0           req->sv1 = newSVsv (fh);
1672 0           req->int1 = fd;
1673 0           req->offs = offset;
1674 0           req->size = nbytes;
1675 0           req->int2 = flags;
1676              
1677 0 0         REQ_SEND;
    0          
    0          
1678             }
1679              
1680             void
1681             aio_allocate (SV *fh, int mode, off_t offset, size_t len, SV *callback = &PL_sv_undef)
1682             PPCODE:
1683             {
1684 0           int fd = s_fileno_croak (fh, 0);
1685 0           dREQ;
1686              
1687 0           req->type = EIO_FALLOCATE;
1688 0           req->sv1 = newSVsv (fh);
1689 0           req->int1 = fd;
1690 0           req->int2 = mode;
1691 0           req->offs = offset;
1692 0           req->size = len;
1693              
1694 0 0         REQ_SEND;
    0          
    0          
1695             }
1696              
1697             void
1698             aio_close (SV *fh, SV *callback = &PL_sv_undef)
1699             PPCODE:
1700             {
1701 1           int fd = s_fileno_croak (fh, 0);
1702 1           dREQ;
1703             #if 0
1704             /* partially duplicate logic in s_fileno */
1705             SvGETMAGIC (fh);
1706              
1707             if (SvROK (fh))
1708             {
1709             fh = SvRV (fh);
1710             SvGETMAGIC (fh);
1711             }
1712              
1713             if (SvTYPE (fh) == SVt_PVGV)
1714             {
1715             /* perl filehandle */
1716             PerlIOUnix_refcnt_inc (fd);
1717             do_close ((GV *)fh, 1);
1718              
1719             req->type = EIO_CLOSE;
1720             req->int1 = fd;
1721             /*req->sv2 = newSVsv (fh);*/ /* since we stole the fd, no need to keep the fh */
1722             }
1723             else
1724             #endif
1725             {
1726             /* fd number */
1727 1           req->type = EIO_DUP2;
1728 1           req->int1 = close_fd;
1729 1           req->sv2 = newSVsv (fh);
1730 1           req->int2 = fd;
1731             }
1732              
1733 1 50         REQ_SEND;
    50          
    0          
1734             }
1735              
1736             void
1737             aio_seek (SV *fh, SV *offset, int whence, SV *callback = &PL_sv_undef)
1738             PPCODE:
1739             {
1740 0           int fd = s_fileno_croak (fh, 0);
1741 0           dREQ;
1742              
1743 0           req->type = EIO_SEEK;
1744 0           req->sv1 = newSVsv (fh);
1745 0           req->int1 = fd;
1746 0 0         req->offs = SvVAL64 (offset);
1747 0           req->int2 = whence;
1748              
1749 0 0         REQ_SEND;
    0          
    0          
1750             }
1751              
1752             void
1753             aio_read (SV *fh, SV *offset, SV *length, SV8 *data, IV dataoffset, SV *callback = &PL_sv_undef)
1754             ALIAS:
1755             aio_read = EIO_READ
1756             aio_write = EIO_WRITE
1757             PPCODE:
1758             {
1759             STRLEN svlen;
1760 2           int fd = s_fileno_croak (fh, ix == EIO_WRITE);
1761 1 50         char *svptr = SvPVbyte (data, svlen);
1762 1 50         UV len = SvUV (length);
1763              
1764 1 50         if (dataoffset < 0)
1765 0           dataoffset += svlen;
1766              
1767 1 50         if (dataoffset < 0 || dataoffset > svlen)
    50          
1768 0           croak ("dataoffset outside of data scalar");
1769              
1770 1 50         if (ix == EIO_WRITE)
1771             {
1772             /* write: check length and adjust. */
1773 0 0         if (!SvOK (length) || len + dataoffset > svlen)
    0          
    0          
    0          
1774 0           len = svlen - dataoffset;
1775             }
1776             else
1777             {
1778             /* read: check type and grow scalar as necessary */
1779 1 50         if (!SvPOK (data) || SvLEN (data) >= SvCUR (data))
    50          
1780 1           svptr = sv_grow (data, len + dataoffset + 1);
1781 0 0         else if (SvCUR (data) < len + dataoffset)
1782 0           croak ("length + dataoffset outside of scalar, and cannot grow");
1783             }
1784              
1785             {
1786 1           dREQ;
1787              
1788 1           req->type = ix;
1789 1           req->sv1 = newSVsv (fh);
1790 1           req->int1 = fd;
1791 1 50         req->offs = SvOK (offset) ? SvVAL64 (offset) : -1;
    0          
    0          
    50          
1792 1           req->size = len;
1793 1           req->sv2 = SvREFCNT_inc (data);
1794 1           req->ptr2 = (char *)svptr + dataoffset;
1795 1           req->stroffset = dataoffset;
1796              
1797 1 50         if (!SvREADONLY (data))
1798             {
1799 1           SvREADONLY_on (data);
1800 1           req->flags |= FLAG_SV2_RO_OFF;
1801             }
1802              
1803 1 50         REQ_SEND;
    50          
    0          
1804             }
1805             }
1806              
1807             void
1808             aio_ioctl (SV *fh, unsigned long request, SV8 *arg, SV *callback = &PL_sv_undef)
1809             ALIAS:
1810             aio_ioctl = EIO_IOCTL
1811             aio_fcntl = EIO_FCNTL
1812             PPCODE:
1813             {
1814 0           int fd = s_fileno_croak (fh, 0);
1815             char *svptr;
1816              
1817 0 0         if (SvPOK (arg) || !SvNIOK (arg))
    0          
1818 0           {
1819             STRLEN svlen;
1820             /* perl uses IOCPARM_LEN for fcntl, so we do, too */
1821             #ifdef IOCPARM_LEN
1822 0           STRLEN need = IOCPARM_LEN (request);
1823             #else
1824             STRLEN need = 256;
1825             #endif
1826              
1827 0 0         if (svlen < need)
1828 0 0         svptr = SvGROW (arg, need);
    0          
1829             }
1830             else
1831 0 0         svptr = (char *)SvIV (arg);
1832              
1833             {
1834 0           dREQ;
1835              
1836 0           req->type = ix;
1837 0           req->sv1 = newSVsv (fh);
1838 0           req->int1 = fd;
1839 0           req->int2 = (long)request;
1840 0           req->sv2 = SvREFCNT_inc (arg);
1841 0           req->ptr2 = svptr;
1842              
1843 0 0         REQ_SEND;
    0          
    0          
1844             }
1845             }
1846              
1847             void
1848             aio_readlink (SV8 *pathname, SV *callback = &PL_sv_undef)
1849             ALIAS:
1850             aio_readlink = EIO_READLINK
1851             aio_realpath = EIO_REALPATH
1852             PPCODE:
1853             {
1854 0           dREQ;
1855              
1856 0           req->type = ix;
1857 0           req_set_path1 (req, pathname);
1858              
1859 0 0         REQ_SEND;
    0          
    0          
1860             }
1861              
1862             void
1863             aio_sendfile (SV *out_fh, SV *in_fh, off_t in_offset, size_t length, SV *callback = &PL_sv_undef)
1864             PPCODE:
1865             {
1866 0           int ifd = s_fileno_croak (in_fh , 0);
1867 0           int ofd = s_fileno_croak (out_fh, 1);
1868 0           dREQ;
1869              
1870 0           req->type = EIO_SENDFILE;
1871 0           req->sv1 = newSVsv (out_fh);
1872 0           req->int1 = ofd;
1873 0           req->sv2 = newSVsv (in_fh);
1874 0           req->int2 = ifd;
1875 0           req->offs = in_offset;
1876 0           req->size = length;
1877              
1878 0 0         REQ_SEND;
    0          
    0          
1879             }
1880              
1881             void
1882             aio_readahead (SV *fh, off_t offset, size_t length, SV *callback = &PL_sv_undef)
1883             PPCODE:
1884             {
1885 0           int fd = s_fileno_croak (fh, 0);
1886 0           dREQ;
1887              
1888 0           req->type = EIO_READAHEAD;
1889 0           req->sv1 = newSVsv (fh);
1890 0           req->int1 = fd;
1891 0           req->offs = offset;
1892 0           req->size = length;
1893              
1894 0 0         REQ_SEND;
    0          
    0          
1895             }
1896              
1897             void
1898             aio_stat (SV8 *fh_or_path, SV *callback = &PL_sv_undef)
1899             ALIAS:
1900             aio_stat = EIO_STAT
1901             aio_lstat = EIO_LSTAT
1902             aio_statvfs = EIO_STATVFS
1903             PPCODE:
1904             {
1905 26           dREQ;
1906              
1907 26 50         req_set_fh_or_path (req, ix, ix == EIO_STATVFS ? EIO_FSTATVFS : EIO_FSTAT, fh_or_path);
1908              
1909 26 50         REQ_SEND;
    100          
    50          
1910             }
1911              
1912             void
1913             st_xtime ()
1914             ALIAS:
1915             st_atime = 0x01
1916             st_mtime = 0x02
1917             st_ctime = 0x04
1918             st_btime = 0x08
1919             st_xtime = 0x0f
1920             PPCODE:
1921 0 0         EXTEND (SP, 4);
1922 0 0         if (ix & 0x01) PUSHs (newSVnv (PL_statcache.st_atime + 1e-9 * ATIMENSEC));
1923 0 0         if (ix & 0x02) PUSHs (newSVnv (PL_statcache.st_mtime + 1e-9 * MTIMENSEC));
1924 0 0         if (ix & 0x04) PUSHs (newSVnv (PL_statcache.st_ctime + 1e-9 * CTIMENSEC));
1925 0 0         if (ix & 0x08) PUSHs (newSVnv (BTIMESEC + 1e-9 * BTIMENSEC));
1926              
1927             void
1928             st_xtimensec ()
1929             ALIAS:
1930             st_atimensec = 0x01
1931             st_mtimensec = 0x02
1932             st_ctimensec = 0x04
1933             st_btimensec = 0x08
1934             st_xtimensec = 0x0f
1935             st_btimesec = 0x10
1936             st_gen = 0x20
1937             PPCODE:
1938 0 0         EXTEND (SP, 4);
1939 0 0         if (ix & 0x01) PUSHs (newSViv (ATIMENSEC));
1940 0 0         if (ix & 0x02) PUSHs (newSViv (MTIMENSEC));
1941 0 0         if (ix & 0x04) PUSHs (newSViv (CTIMENSEC));
1942 0 0         if (ix & 0x08) PUSHs (newSViv (BTIMENSEC));
1943 0 0         if (ix & 0x10) PUSHs (newSVuv (BTIMESEC));
1944 0 0         if (ix & 0x20) PUSHs (newSVuv (ST_GEN));
1945              
1946             UV
1947             major (UV dev)
1948             ALIAS:
1949             minor = 1
1950             CODE:
1951 0 0         RETVAL = ix ? minor (dev) : major (dev);
1952             OUTPUT:
1953             RETVAL
1954              
1955             UV
1956             makedev (UV maj, UV min)
1957             CODE:
1958 0           RETVAL = makedev (maj, min);
1959             OUTPUT:
1960             RETVAL
1961              
1962             void
1963             aio_utime (SV8 *fh_or_path, SV *atime, SV *mtime, SV *callback = &PL_sv_undef)
1964             PPCODE:
1965             {
1966 0           dREQ;
1967              
1968 0 0         req->nv1 = SvOK (atime) ? SvNV (atime) : -1.;
    0          
    0          
    0          
1969 0 0         req->nv2 = SvOK (mtime) ? SvNV (mtime) : -1.;
    0          
    0          
    0          
1970 0           req_set_fh_or_path (req, EIO_UTIME, EIO_FUTIME, fh_or_path);
1971              
1972 0 0         REQ_SEND;
    0          
    0          
1973             }
1974              
1975             void
1976             aio_truncate (SV8 *fh_or_path, SV *offset, SV *callback = &PL_sv_undef)
1977             PPCODE:
1978             {
1979 0           dREQ;
1980              
1981 0 0         req->offs = SvOK (offset) ? SvVAL64 (offset) : -1;
    0          
    0          
    0          
1982 0           req_set_fh_or_path (req, EIO_TRUNCATE, EIO_FTRUNCATE, fh_or_path);
1983              
1984 0 0         REQ_SEND;
    0          
    0          
1985             }
1986              
1987             void
1988             aio_chmod (SV8 *fh_or_path, int mode, SV *callback = &PL_sv_undef)
1989             PPCODE:
1990             {
1991 0           dREQ;
1992              
1993 0           req->int2 = mode;
1994 0           req_set_fh_or_path (req, EIO_CHMOD, EIO_FCHMOD, fh_or_path);
1995              
1996 0 0         REQ_SEND;
    0          
    0          
1997             }
1998              
1999             void
2000             aio_chown (SV8 *fh_or_path, SV *uid, SV *gid, SV *callback = &PL_sv_undef)
2001             PPCODE:
2002             {
2003 0           dREQ;
2004              
2005 0 0         req->int2 = SvOK (uid) ? SvIV (uid) : -1;
    0          
    0          
    0          
2006 0 0         req->int3 = SvOK (gid) ? SvIV (gid) : -1;
    0          
    0          
    0          
2007 0           req_set_fh_or_path (req, EIO_CHOWN, EIO_FCHOWN, fh_or_path);
2008              
2009 0 0         REQ_SEND;
    0          
    0          
2010             }
2011              
2012             void
2013             aio_readdirx (SV8 *pathname, IV flags, SV *callback = &PL_sv_undef)
2014             PPCODE:
2015             {
2016 3           dREQ;
2017            
2018 3           req->type = EIO_READDIR;
2019 3           req->int1 = flags | EIO_READDIR_DENTS | EIO_READDIR_CUSTOM1;
2020              
2021 3 100         if (flags & EIO_READDIR_DENTS)
2022 1           req->int1 |= EIO_READDIR_CUSTOM2;
2023              
2024 3           req_set_path1 (req, pathname);
2025              
2026 3 50         REQ_SEND;
    100          
    50          
2027             }
2028              
2029             void
2030             aio_mkdir (SV8 *pathname, int mode, SV *callback = &PL_sv_undef)
2031             PPCODE:
2032             {
2033 0           dREQ;
2034              
2035 0           req->type = EIO_MKDIR;
2036 0           req->int2 = mode;
2037 0           req_set_path1 (req, pathname);
2038              
2039 0 0         REQ_SEND;
    0          
    0          
2040             }
2041              
2042             void
2043             aio_unlink (SV8 *pathname, SV *callback = &PL_sv_undef)
2044             ALIAS:
2045             aio_unlink = EIO_UNLINK
2046             aio_rmdir = EIO_RMDIR
2047             aio_readdir = EIO_READDIR
2048             PPCODE:
2049             {
2050 4           dREQ;
2051            
2052 4           req->type = ix;
2053 4           req_set_path1 (req, pathname);
2054              
2055 4 50         REQ_SEND;
    50          
    0          
2056             }
2057              
2058             void
2059             aio_link (SV8 *oldpath, SV8 *newpath, SV *callback = &PL_sv_undef)
2060             ALIAS:
2061             aio_link = EIO_LINK
2062             aio_symlink = EIO_SYMLINK
2063             aio_rename = EIO_RENAME
2064             PPCODE:
2065             {
2066 1           eio_wd wd2 = 0;
2067 1           dREQ;
2068            
2069 1           req->type = ix;
2070 1           req_set_path1 (req, oldpath);
2071 1           req_set_path (newpath, &req->sv2, &req->sv4, &wd2, &req->ptr2);
2072 1           req->int3 = (long)wd2;
2073            
2074 1 50         REQ_SEND;
    50          
    0          
2075             }
2076              
2077             void
2078             aio_rename2 (SV8 *oldpath, SV8 *newpath, int flags = 0, SV *callback = &PL_sv_undef)
2079             PPCODE:
2080             {
2081 0           eio_wd wd2 = 0;
2082 0           dREQ;
2083            
2084 0           req->type = EIO_RENAME;
2085 0           req_set_path1 (req, oldpath);
2086 0           req_set_path (newpath, &req->sv2, &req->sv4, &wd2, &req->ptr2);
2087 0           req->int2 = flags;
2088 0           req->int3 = (long)wd2;
2089            
2090 0 0         REQ_SEND;
    0          
    0          
2091             }
2092              
2093             void
2094             aio_mknod (SV8 *pathname, int mode, UV dev, SV *callback = &PL_sv_undef)
2095             PPCODE:
2096             {
2097 0           dREQ;
2098            
2099 0           req->type = EIO_MKNOD;
2100 0           req->int2 = (mode_t)mode;
2101 0           req->offs = dev;
2102 0           req_set_path1 (req, pathname);
2103            
2104 0 0         REQ_SEND;
    0          
    0          
2105             }
2106              
2107             void
2108             aio_mtouch (SV8 *data, IV offset = 0, SV *length = &PL_sv_undef, int flags = -1, SV *callback = &PL_sv_undef)
2109             ALIAS:
2110             aio_mtouch = EIO_MTOUCH
2111             aio_msync = EIO_MSYNC
2112             PPCODE:
2113             {
2114             STRLEN svlen;
2115 0 0         char *svptr = SvPVbyte (data, svlen);
2116 0 0         UV len = SvUV (length);
2117              
2118 0 0         if (flags < 0)
2119 0 0         flags = ix == EIO_MSYNC ? EIO_MS_SYNC : 0;
2120              
2121 0 0         if (offset < 0)
2122 0           offset += svlen;
2123              
2124 0 0         if (offset < 0 || offset > svlen)
    0          
2125 0           croak ("offset outside of scalar");
2126              
2127 0 0         if (!SvOK (length) || len + offset > svlen)
    0          
    0          
    0          
2128 0           len = svlen - offset;
2129              
2130             {
2131 0           dREQ;
2132              
2133 0           req->type = ix;
2134 0           req->sv2 = SvREFCNT_inc (data);
2135 0           req->ptr2 = (char *)svptr + offset;
2136 0           req->size = len;
2137 0           req->int1 = flags;
2138              
2139 0 0         REQ_SEND;
    0          
    0          
2140             }
2141             }
2142              
2143             void
2144             aio_mlock (SV8 *data, IV offset = 0, SV *length = &PL_sv_undef, SV *callback = &PL_sv_undef)
2145             PPCODE:
2146             {
2147             STRLEN svlen;
2148 0 0         char *svptr = SvPVbyte (data, svlen);
2149 0 0         UV len = SvUV (length);
2150              
2151 0 0         if (offset < 0)
2152 0           offset += svlen;
2153              
2154 0 0         if (offset < 0 || offset > svlen)
    0          
2155 0           croak ("offset outside of scalar");
2156              
2157 0 0         if (!SvOK (length) || len + offset > svlen)
    0          
    0          
    0          
2158 0           len = svlen - offset;
2159              
2160             {
2161 0           dREQ;
2162              
2163 0           req->type = EIO_MLOCK;
2164 0           req->sv2 = SvREFCNT_inc (data);
2165 0           req->ptr2 = (char *)svptr + offset;
2166 0           req->size = len;
2167              
2168 0 0         REQ_SEND;
    0          
    0          
2169             }
2170             }
2171              
2172             void
2173             aio_mlockall (IV flags, SV *callback = &PL_sv_undef)
2174             PPCODE:
2175             {
2176 0           dREQ;
2177              
2178 0           req->type = EIO_MLOCKALL;
2179 0           req->int1 = flags;
2180              
2181 0 0         REQ_SEND;
    0          
    0          
2182             }
2183              
2184             void
2185             aio_fiemap (SV *fh, off_t start, SV *length, U32 flags, SV *count, SV *callback = &PL_sv_undef)
2186             PPCODE:
2187             {
2188 0           int fd = s_fileno_croak (fh, 0);
2189 0           dREQ;
2190              
2191 0           req->type = EIO_CUSTOM;
2192 0           req->sv1 = newSVsv (fh);
2193 0           req->int1 = fd;
2194              
2195 0           req->feed = fiemap;
2196             #if HAVE_FIEMAP
2197             /* keep our fingers crossed that the next two types are 64 bit */
2198 0           req->offs = start;
2199 0 0         req->size = SvOK (length) ? SvVAL64 (length) : ~0ULL;
    0          
    0          
    0          
2200 0           req->int2 = flags;
2201 0 0         req->int3 = SvOK (count) ? SvIV (count) : -1;
    0          
    0          
    0          
2202             #endif
2203              
2204 0 0         REQ_SEND;
    0          
    0          
2205             }
2206              
2207             void
2208             aio_slurp (SV *pathname, off_t offset, UV length, SV8 *data, SV *callback = &PL_sv_undef)
2209             PPCODE:
2210             {
2211 0           char *svptr = 0;
2212              
2213 0           sv_clear_foreign (data);
2214              
2215 0 0         if (length) /* known length, directly read into scalar */
2216             {
2217 0 0         if (!SvPOK (data) || SvLEN (data) >= SvCUR (data))
    0          
2218 0           svptr = sv_grow (data, length + 1);
2219 0 0         else if (SvCUR (data) < length)
2220 0           croak ("length outside of scalar, and cannot grow");
2221             else
2222 0 0         svptr = SvPVbyte_nolen (data);
2223             }
2224              
2225             {
2226 0           dREQ;
2227              
2228 0           req->type = EIO_SLURP;
2229 0           req_set_path1 (req, pathname);
2230 0           req->offs = offset;
2231 0           req->size = length;
2232 0           req->sv2 = SvREFCNT_inc (data);
2233 0           req->ptr2 = svptr;
2234              
2235 0 0         if (!SvREADONLY (data))
2236             {
2237 0           SvREADONLY_on (data);
2238 0           req->flags |= FLAG_SV2_RO_OFF;
2239             }
2240              
2241 0 0         REQ_SEND;
    0          
    0          
2242             }
2243             }
2244              
2245             void
2246             aio_busy (double delay, SV *callback = &PL_sv_undef)
2247             PPCODE:
2248             {
2249 13           dREQ;
2250              
2251 13           req->type = EIO_BUSY;
2252 13 50         req->nv1 = delay < 0. ? 0. : delay;
2253              
2254 13 50         REQ_SEND;
    100          
    50          
2255             }
2256              
2257             void
2258             aio_group (SV *callback = &PL_sv_undef)
2259             PPCODE:
2260             {
2261 6           dREQ;
2262              
2263 6           req->type = EIO_GROUP;
2264              
2265 6           PUTBACK;
2266 6           req_submit (req);
2267 6           SPAGAIN;
2268              
2269 6 50         XPUSHs (req_sv (req, aio_grp_stash));
2270             }
2271              
2272             void
2273             aio_nop (SV *callback = &PL_sv_undef)
2274             ALIAS:
2275             aio_nop = EIO_NOP
2276             aio_sync = EIO_SYNC
2277             PPCODE:
2278             {
2279 3           dREQ;
2280              
2281 3           req->type = ix;
2282              
2283 3 50         REQ_SEND;
    50          
    0          
2284             }
2285              
2286             int
2287             aioreq_pri (int pri = NO_INIT)
2288             CODE:
2289 30           RETVAL = next_pri;
2290 30 100         if (items > 0)
2291             {
2292 29 50         if (pri < EIO_PRI_MIN) pri = EIO_PRI_MIN;
2293 29 100         if (pri > EIO_PRI_MAX) pri = EIO_PRI_MAX;
2294 29           next_pri = pri;
2295             }
2296             OUTPUT:
2297             RETVAL
2298              
2299             void
2300             aioreq_nice (int nice = 0)
2301             CODE:
2302 0           nice = next_pri - nice;
2303 0 0         if (nice < EIO_PRI_MIN) nice = EIO_PRI_MIN;
2304 0 0         if (nice > EIO_PRI_MAX) nice = EIO_PRI_MAX;
2305 0           next_pri = nice;
2306              
2307             void
2308             flush ()
2309             CODE:
2310 9 50         while (eio_nreqs ())
2311             {
2312 0           poll_wait ();
2313 0           poll_cb ();
2314             }
2315              
2316             int
2317             poll ()
2318             CODE:
2319 24           poll_wait ();
2320 24           RETVAL = poll_cb ();
2321             OUTPUT:
2322             RETVAL
2323              
2324             int
2325             poll_fileno ()
2326             CODE:
2327 14           RETVAL = s_epipe_fd (&respipe);
2328             OUTPUT:
2329             RETVAL
2330              
2331             int
2332             poll_cb (...)
2333             PROTOTYPE:
2334             CODE:
2335 14           RETVAL = poll_cb ();
2336             OUTPUT:
2337             RETVAL
2338              
2339             void
2340             poll_wait ()
2341             CODE:
2342 0           poll_wait ();
2343              
2344             int
2345             nreqs ()
2346             CODE:
2347 63           RETVAL = eio_nreqs ();
2348             OUTPUT:
2349             RETVAL
2350              
2351             int
2352             nready ()
2353             CODE:
2354 0           RETVAL = eio_nready ();
2355             OUTPUT:
2356             RETVAL
2357              
2358             int
2359             npending ()
2360             CODE:
2361 0           RETVAL = eio_npending ();
2362             OUTPUT:
2363             RETVAL
2364              
2365             int
2366             nthreads ()
2367             CODE:
2368 0           RETVAL = eio_nthreads ();
2369             OUTPUT:
2370             RETVAL
2371              
2372             int
2373             fadvise (aio_rfd fh, off_t offset, off_t length, IV advice)
2374             CODE:
2375 0           RETVAL = posix_fadvise (fh, offset, length, advice);
2376             OUTPUT:
2377             RETVAL
2378              
2379             IV
2380             sendfile (aio_wfd ofh, aio_rfd ifh, off_t offset, size_t count)
2381             CODE:
2382 0           RETVAL = eio_sendfile_sync (ofh, ifh, offset, count);
2383             OUTPUT:
2384             RETVAL
2385              
2386             void
2387             mmap (SV *scalar, STRLEN length, int prot, int flags, SV *fh = &PL_sv_undef, off_t offset = 0)
2388             PPCODE:
2389 0           sv_clear_foreign (scalar);
2390             {
2391 0 0         int fd = SvOK (fh) ? s_fileno_croak (fh, flags & PROT_WRITE) : -1;
    0          
    0          
2392 0           void *addr = (void *)mmap (0, length, prot, flags, fd, offset);
2393 0 0         if (addr == (void *)-1)
2394 0           XSRETURN_NO;
2395              
2396 0           sv_set_foreign (scalar, &mmap_vtbl, addr, length);
2397              
2398 0 0         if (!(prot & PROT_WRITE))
2399 0           SvREADONLY_on (scalar);
2400              
2401 0           XSRETURN_YES;
2402             }
2403              
2404             void
2405             munmap (SV *scalar)
2406             CODE:
2407 0           sv_clear_foreign (scalar);
2408              
2409             SV *
2410             mremap (SV *scalar, STRLEN new_length, int flags = MREMAP_MAYMOVE, IV new_address = 0)
2411             CODE:
2412             {
2413 0           MAGIC *mg = mg_findext (scalar, FOREIGN_MAGIC, &mmap_vtbl);
2414             void *new;
2415              
2416 0 0         if (!mg || SvPVX (scalar) != mg->mg_ptr)
    0          
2417 0           croak ("IO::AIO::mremap: scalar not mapped by IO::AIO::mmap or improperly modified");
2418              
2419 0           new = mremap (mg->mg_ptr, (size_t)mg->mg_obj, new_length, flags, (void *)new_address);
2420              
2421 0           RETVAL = &PL_sv_no;
2422              
2423 0 0         if (new != (void *)-1)
2424             {
2425 0           RETVAL = new == (void *)mg->mg_ptr
2426             ? newSVpvn ("0 but true", 10)
2427 0 0         : &PL_sv_yes;
2428              
2429 0           mg->mg_ptr = (char *)new;
2430 0           mg->mg_obj = (SV *)new_length;
2431              
2432 0           SvPVX (scalar) = mg->mg_ptr;
2433 0           SvCUR_set (scalar, new_length);
2434             }
2435             }
2436             OUTPUT:
2437             RETVAL
2438              
2439             int
2440             madvise (SV *scalar, IV offset = 0, SV *length = &PL_sv_undef, IV advice_or_prot)
2441             ALIAS:
2442             mprotect = 1
2443             CODE:
2444             {
2445             STRLEN svlen;
2446 0 0         void *addr = SvPVbyte (scalar, svlen);
2447 0 0         STRLEN len = SvUV (length);
2448              
2449 0 0         if (offset < 0)
2450 0           offset += svlen;
2451              
2452 0 0         if (offset < 0 || offset > svlen)
    0          
2453 0           croak ("offset outside of scalar");
2454              
2455 0 0         if (!SvOK (length) || len + offset > svlen)
    0          
    0          
    0          
2456 0           len = svlen - offset;
2457              
2458 0           addr = (void *)(((intptr_t)addr) + offset);
2459 0           eio_page_align (&addr, &len);
2460              
2461 0           switch (ix)
2462             {
2463 0           case 0: RETVAL = posix_madvise (addr, len, advice_or_prot); break;
2464 0           case 1: RETVAL = mprotect (addr, len, advice_or_prot); break;
2465             }
2466             }
2467             OUTPUT:
2468             RETVAL
2469              
2470             int
2471             munlock (SV *scalar, IV offset = 0, SV *length = &PL_sv_undef)
2472             CODE:
2473             {
2474             STRLEN svlen;
2475 0 0         void *addr = SvPVbyte (scalar, svlen);
2476 0 0         size_t len = SvUV (length);
2477              
2478 0 0         if (offset < 0)
2479 0           offset += svlen;
2480              
2481 0 0         if (offset < 0 || offset > svlen)
    0          
2482 0           croak ("offset outside of scalar");
2483              
2484 0 0         if (!SvOK (length) || len + offset > svlen)
    0          
    0          
    0          
2485 0           len = svlen - offset;
2486              
2487 0           addr = (void *)(((intptr_t)addr) + offset);
2488 0           eio_page_align (&addr, &len);
2489             #if _POSIX_MEMLOCK_RANGE
2490 0           RETVAL = munlock (addr, len);
2491             #else
2492             RETVAL = EIO_ENOSYS ();
2493             #endif
2494             }
2495             OUTPUT:
2496             RETVAL
2497              
2498             int
2499             mlockall (int flags)
2500             PROTOTYPE: $;
2501             CODE:
2502 0           RETVAL = eio_mlockall_sync (flags);
2503             OUTPUT:
2504             RETVAL
2505              
2506             int
2507             munlockall ()
2508             CODE:
2509             #if _POSIX_MEMLOCK
2510 0           munlockall ();
2511             #else
2512             RETVAL = EIO_ENOSYS ();
2513             #endif
2514             OUTPUT:
2515             RETVAL
2516              
2517             int
2518             statx (SV8 *pathname, int flags, UV mask)
2519             CODE:
2520             {
2521             /* undocumented, and might go away, and anyway, should use eio_statx */
2522 0           SV *wdsv = 0;
2523 0           SV *pathsv = 0;
2524 0           eio_wd wd = EIO_CWD;
2525             void *ptr;
2526             int res;
2527              
2528 0           req_set_path (pathname, &wdsv, &pathsv, &wd, &ptr);
2529 0           RETVAL = eio__statx (!wd || wd->fd == EIO_CWD ? AT_FDCWD : wd->fd, ptr, flags, mask & STATX_ALL, &stx);
2530              
2531 0           SvREFCNT_dec (pathsv);
2532 0           SvREFCNT_dec (wdsv);
2533             }
2534             OUTPUT:
2535             RETVAL
2536              
2537             U32
2538             stx_mode ()
2539             PROTOTYPE:
2540             CODE:
2541             #if HAVE_STATX
2542             RETVAL = stx.stx_mode;
2543             #else
2544 0           XSRETURN_UNDEF;
2545             #endif
2546             OUTPUT:
2547             RETVAL
2548              
2549             #define STATX_OFFSET_mask statx_offsetof (stx_mask)
2550             #define STATX_OFFSET_blksize statx_offsetof (stx_blksize)
2551             #define STATX_OFFSET_nlink statx_offsetof (stx_nlink)
2552             #define STATX_OFFSET_uid statx_offsetof (stx_uid)
2553             #define STATX_OFFSET_gid statx_offsetof (stx_gid)
2554             #define STATX_OFFSET_rdev_major statx_offsetof (stx_rdev_major)
2555             #define STATX_OFFSET_rdev_minor statx_offsetof (stx_rdev_minor)
2556             #define STATX_OFFSET_dev_major statx_offsetof (stx_dev_major)
2557             #define STATX_OFFSET_dev_minor statx_offsetof (stx_dev_minor)
2558             #define STATX_OFFSET_attributes statx_offsetof (stx_attributes)
2559             #define STATX_OFFSET_ino statx_offsetof (stx_ino)
2560             #define STATX_OFFSET_size statx_offsetof (stx_size)
2561             #define STATX_OFFSET_blocks statx_offsetof (stx_blocks)
2562             #define STATX_OFFSET_attributes_mask statx_offsetof (stx_attributes_mask)
2563             #define STATX_OFFSET_atime statx_offsetof (stx_atime)
2564             #define STATX_OFFSET_btime statx_offsetof (stx_btime)
2565             #define STATX_OFFSET_ctime statx_offsetof (stx_ctime)
2566             #define STATX_OFFSET_mtime statx_offsetof (stx_mtime)
2567              
2568             U32
2569             stx_mask ()
2570             PROTOTYPE:
2571             ALIAS:
2572             stx_mask = STATX_OFFSET_mask
2573             stx_blksize = STATX_OFFSET_blksize
2574             stx_nlink = STATX_OFFSET_nlink
2575             stx_uid = STATX_OFFSET_uid
2576             stx_gid = STATX_OFFSET_gid
2577             stx_rdev_major = STATX_OFFSET_rdev_major
2578             stx_rdev_minor = STATX_OFFSET_rdev_minor
2579             stx_dev_major = STATX_OFFSET_dev_major
2580             stx_dev_minor = STATX_OFFSET_dev_minor
2581             CODE:
2582             #if HAVE_STATX
2583             RETVAL = *(__u32 *)((char *)&stx + ix);
2584             #else
2585 0           XSRETURN_UNDEF;
2586             #endif
2587             OUTPUT:
2588             RETVAL
2589              
2590             VAL64
2591             stx_attributes ()
2592             PROTOTYPE:
2593             ALIAS:
2594             stx_attributes = STATX_OFFSET_attributes
2595             stx_ino = STATX_OFFSET_ino
2596             stx_size = STATX_OFFSET_size
2597             stx_blocks = STATX_OFFSET_blocks
2598             stx_attributes_mask = STATX_OFFSET_attributes_mask
2599             CODE:
2600             #if HAVE_STATX
2601             RETVAL = *(__u64 *)((char *)&stx + ix);
2602             #else
2603 0           XSRETURN_UNDEF;
2604             #endif
2605             OUTPUT:
2606             RETVAL
2607              
2608             NV
2609             stx_atime ()
2610             PROTOTYPE:
2611             ALIAS:
2612             stx_atime = STATX_OFFSET_atime
2613             stx_btime = STATX_OFFSET_btime
2614             stx_ctime = STATX_OFFSET_ctime
2615             stx_mtime = STATX_OFFSET_mtime
2616             CODE:
2617             #if HAVE_STATX
2618             struct statx_timestamp *ts = (struct statx_timestamp *)((char *)&stx + ix);
2619             RETVAL = ts->tv_sec + ts->tv_nsec * 1e-9;
2620             #else
2621 0           XSRETURN_UNDEF;
2622             #endif
2623             OUTPUT:
2624             RETVAL
2625              
2626             VAL64
2627             stx_atimesec ()
2628             PROTOTYPE:
2629             ALIAS:
2630             stx_atimesec = STATX_OFFSET_atime
2631             stx_btimesec = STATX_OFFSET_btime
2632             stx_ctimesec = STATX_OFFSET_ctime
2633             stx_mtimesec = STATX_OFFSET_mtime
2634             CODE:
2635             #if HAVE_STATX
2636             struct statx_timestamp *ts = (struct statx_timestamp *)((char *)&stx + ix);
2637             RETVAL = ts->tv_sec;
2638             #else
2639 0           XSRETURN_UNDEF;
2640             #endif
2641             OUTPUT:
2642             RETVAL
2643              
2644             U32
2645             stx_atimensec ()
2646             PROTOTYPE:
2647             ALIAS:
2648             stx_atimensec = STATX_OFFSET_atime
2649             stx_btimensec = STATX_OFFSET_btime
2650             stx_ctimensec = STATX_OFFSET_ctime
2651             stx_mtimensec = STATX_OFFSET_mtime
2652             CODE:
2653             #if HAVE_STATX
2654             struct statx_timestamp *ts = (struct statx_timestamp *)((char *)&stx + ix);
2655             RETVAL = ts->tv_nsec;
2656             #else
2657 0           RETVAL = 0;
2658             #endif
2659             OUTPUT:
2660             RETVAL
2661              
2662             void
2663             accept4 (aio_rfd rfh, SV *sockaddr, int salen, int flags)
2664             PPCODE:
2665             {
2666             SV *retval;
2667             #if HAVE_ACCEPT4
2668 0 0         socklen_t salen_ = salen ? salen + 1 : 0;
2669              
2670 0 0         if (salen)
2671             {
2672 0           sv_upgrade (sockaddr, SVt_PV);
2673 0           sv_grow (sockaddr, salen_);
2674             }
2675            
2676 0 0         int res = accept4 (rfh, salen ? (struct sockaddr *)SvPVX (sockaddr) : 0, salen ? &salen_ : 0, flags);
    0          
2677            
2678 0           retval = newmortalFH (res, O_RDWR);
2679              
2680 0 0         if (res >= 0 && salen > 0)
    0          
2681             {
2682 0 0         if (salen_ > salen + 1)
2683 0           salen_ = salen + 1;
2684              
2685 0           SvPOK_only (sockaddr);
2686 0           SvCUR_set (sockaddr, salen_);
2687             }
2688             #else
2689             errno = ENOSYS;
2690             retval = &PL_sv_undef;
2691             #endif
2692 0 0         XPUSHs (retval);
2693             }
2694              
2695             ssize_t
2696             splice (aio_rfd rfh, SV *off_in, aio_wfd wfh, SV *off_out, size_t length, unsigned int flags)
2697             CODE:
2698             {
2699             #if HAVE_LINUX_SPLICE
2700             loff_t off_in_, off_out_;
2701 0 0         RETVAL = splice (
    0          
2702 0 0         rfh, SvOK (off_in ) ? (off_in_ = SvVAL64 (off_in )), &off_in_ : 0,
    0          
    0          
2703 0 0         wfh, SvOK (off_out) ? (off_out_ = SvVAL64 (off_out)), &off_out_ : 0,
    0          
    0          
2704             length, flags
2705             );
2706             #else
2707             RETVAL = EIO_ENOSYS ();
2708             #endif
2709             }
2710             OUTPUT:
2711             RETVAL
2712              
2713             ssize_t
2714             tee (aio_rfd rfh, aio_wfd wfh, size_t length, unsigned int flags)
2715             CODE:
2716             #if HAVE_LINUX_SPLICE
2717 0           RETVAL = tee (rfh, wfh, length, flags);
2718             #else
2719             RETVAL = EIO_ENOSYS ();
2720             #endif
2721             OUTPUT:
2722             RETVAL
2723              
2724             int
2725             pipesize (aio_rfd rfh, int new_size = -1)
2726             PROTOTYPE: $;$
2727             CODE:
2728             #if defined(F_SETPIPE_SZ) && defined(F_GETPIPE_SZ)
2729 0 0         if (new_size >= 0)
2730 0           RETVAL = fcntl (rfh, F_SETPIPE_SZ, new_size);
2731             else
2732 0           RETVAL = fcntl (rfh, F_GETPIPE_SZ);
2733             #else
2734             errno = ENOSYS;
2735             RETVAL = -1;
2736             #endif
2737             OUTPUT:
2738             RETVAL
2739              
2740             void
2741             pipe2 (int flags = 0)
2742             PROTOTYPE: ;$
2743             PPCODE:
2744             {
2745             int fd[2];
2746             int res;
2747              
2748 0 0         if (flags)
2749             #if HAVE_PIPE2
2750 0           res = pipe2 (fd, flags);
2751             #else
2752             res = (errno = ENOSYS, -1);
2753             #endif
2754             else
2755 0           res = pipe (fd);
2756              
2757 0 0         if (!res)
2758             {
2759 0 0         EXTEND (SP, 2);
2760 0           PUSHs (newmortalFH (fd[0], O_RDONLY));
2761 0           PUSHs (newmortalFH (fd[1], O_WRONLY));
2762             }
2763             }
2764              
2765             void
2766             pidfd_open (int pid, unsigned int flags = 0)
2767             PPCODE:
2768             {
2769             /*GENDEF0_SYSCALL(pidfd_open,434)*/
2770 0           int fd = syscall (SYS_pidfd_open, pid, flags);
2771 0 0         XPUSHs (newmortalFH (fd, O_RDWR));
2772             }
2773              
2774             int
2775             pidfd_send_signal (SV *pidfh, int sig, SV *siginfo = &PL_sv_undef, unsigned int flags = 0)
2776             PPCODE:
2777             {
2778             int res;
2779             #if HAVE_SIGINFO_T
2780 0           siginfo_t si = { 0 };
2781              
2782 0 0         if (SvOK (siginfo))
    0          
    0          
2783             {
2784             HV *hv;
2785             SV **svp;
2786              
2787 0 0         if (!SvROK (siginfo) || SvTYPE (SvRV (siginfo)) != SVt_PVHV)
    0          
2788 0           croak ("siginfo argument must be a hashref with 'code', 'pid', 'uid' and 'value_int' or 'value_ptr' members, caught");
2789              
2790 0           hv = (HV *)SvRV (siginfo);
2791              
2792 0 0         if ((svp = hv_fetchs (hv, "code" , 0))) si.si_code = SvIV (*svp);
    0          
2793 0 0         if ((svp = hv_fetchs (hv, "pid" , 0))) si.si_pid = SvIV (*svp);
    0          
2794 0 0         if ((svp = hv_fetchs (hv, "uid" , 0))) si.si_uid = SvIV (*svp);
    0          
2795 0 0         if ((svp = hv_fetchs (hv, "value_int", 0))) si.si_value.sival_int = SvIV (*svp);
    0          
2796 0 0         if ((svp = hv_fetchs (hv, "value_ptr", 0))) si.si_value.sival_ptr = (void *)SvIV (*svp);
    0          
2797             }
2798              
2799             /*GENDEF0_SYSCALL(pidfd_send_signal,424)*/
2800 0 0         res = syscall (SYS_pidfd_send_signal, s_fileno_croak (pidfh, 0), sig, SvOK (siginfo) ? &si : 0, flags);
    0          
    0          
2801             #else
2802             res = (errno = ENOSYS, -1);
2803             #endif
2804              
2805 0 0         XPUSHs (sv_2mortal (newSViv (res)));
2806             }
2807              
2808             void
2809             pidfd_getfd (SV *pidfh, int targetfd, unsigned int flags = 0)
2810             PPCODE:
2811             {
2812             /*GENDEF0_SYSCALL(pidfd_getfd,438)*/
2813 0           int fd = syscall (SYS_pidfd_getfd, s_fileno_croak (pidfh, 0), targetfd, flags);
2814 0 0         XPUSHs (newmortalFH (fd, O_RDWR));
2815             }
2816              
2817             void
2818             eventfd (unsigned int initval = 0, int flags = 0)
2819             PPCODE:
2820             {
2821             int fd;
2822             #if HAVE_EVENTFD
2823 0           fd = eventfd (initval, flags);
2824             #else
2825             fd = (errno = ENOSYS, -1);
2826             #endif
2827            
2828 0 0         XPUSHs (newmortalFH (fd, O_RDWR));
2829             }
2830              
2831             void
2832             timerfd_create (int clockid, int flags = 0)
2833             PPCODE:
2834             {
2835             int fd;
2836             #if HAVE_TIMERFD
2837 0           fd = timerfd_create (clockid, flags);
2838             #else
2839             fd = (errno = ENOSYS, -1);
2840             #endif
2841            
2842 0 0         XPUSHs (newmortalFH (fd, O_RDWR));
2843             }
2844              
2845             void
2846             timerfd_settime (SV *fh, int flags, NV interval, NV value)
2847             PPCODE:
2848             {
2849 0           int fd = s_fileno_croak (fh, 0);
2850             #if HAVE_TIMERFD
2851             int res;
2852             struct itimerspec its, ots;
2853              
2854 0           ts_set (&its.it_interval, interval);
2855 0           ts_set (&its.it_value , value);
2856 0           res = timerfd_settime (fd, flags, &its, &ots);
2857              
2858 0 0         if (!res)
2859             {
2860 0 0         EXTEND (SP, 2);
2861 0           PUSHs (newSVnv (ts_get (&ots.it_interval)));
2862 0           PUSHs (newSVnv (ts_get (&ots.it_value)));
2863             }
2864             #else
2865             errno = ENOSYS;
2866             #endif
2867             }
2868              
2869             void
2870             timerfd_gettime (SV *fh)
2871             PPCODE:
2872             {
2873 0           int fd = s_fileno_croak (fh, 0);
2874             #if HAVE_TIMERFD
2875             int res;
2876             struct itimerspec ots;
2877 0           res = timerfd_gettime (fd, &ots);
2878              
2879 0 0         if (!res)
2880             {
2881 0 0         EXTEND (SP, 2);
2882 0           PUSHs (newSVnv (ts_get (&ots.it_interval)));
2883 0           PUSHs (newSVnv (ts_get (&ots.it_value)));
2884             }
2885             #else
2886             errno = ENOSYS;
2887             #endif
2888             }
2889              
2890             void
2891             memfd_create (octet_string pathname, int flags = 0)
2892             PPCODE:
2893             {
2894             int fd;
2895             #if HAVE_MEMFD_CREATE
2896             fd = memfd_create (pathname, flags);
2897             #else
2898 0           fd = (errno = ENOSYS, -1);
2899             #endif
2900            
2901 0 0         XPUSHs (newmortalFH (fd, O_RDWR));
2902             }
2903              
2904             int
2905             fexecve (SV *fh, SV *args, SV *envs = &PL_sv_undef)
2906             CODE:
2907             {
2908 0           int fd = PerlIO_fileno (IoIFP (sv_2io (fh)));
2909             char **envp, **argv;
2910 0           argv = extract_stringvec (args, "IO::AIO::fexecve: args must be an array of strings");
2911 0 0         if (!SvOK (envs))
    0          
    0          
2912 0           {
2913             extern char **environ;
2914 0           envp = environ;
2915             }
2916             else
2917 0           envp = extract_stringvec (envs, "IO::AIO::fexecve: envs must be an array of strings");
2918             #if _POSIX_VERSION >= 200809L
2919 0           RETVAL = fexecve (fd, argv, envp);
2920             #else
2921             RETVAL = (errno = ENOSYS, -1);
2922             #endif
2923             }
2924             OUTPUT: RETVAL
2925              
2926             int
2927             mount (octet_string special, octet_string path, octet_string fstype, UV flags = 0, octet_string_ornull data = 0)
2928             CODE:
2929             #if HAVE_MOUNT
2930 0           RETVAL = mount (special, path, fstype, flags, data);
2931             #else
2932             RETVAL = (errno = ENOSYS, -1);
2933             #endif
2934             OUTPUT: RETVAL
2935              
2936             int
2937             umount (octet_string path, int flags = 0)
2938             CODE:
2939 0 0         if (flags)
2940             #if HAVE_UMOUNT2
2941 0           RETVAL = umount2 (path, flags);
2942             #else
2943             RETVAL = (errno = ENOSYS, -1);
2944             #endif
2945             else
2946             #if HAVE_MOUNT
2947 0           RETVAL = umount (path);
2948             #else
2949             RETVAL = (errno = ENOSYS, -1);
2950             #endif
2951             OUTPUT: RETVAL
2952              
2953             UV
2954             get_fdlimit ()
2955             CODE:
2956             #if HAVE_RLIMITS
2957             struct rlimit rl;
2958 0 0         if (0 == getrlimit (RLIMIT_NOFILE, &rl))
2959 0           XSRETURN_UV (rl.rlim_cur == RLIM_INFINITY ? (UV)-1 : rl.rlim_cur);
2960             #endif
2961 0           XSRETURN_UNDEF;
2962             OUTPUT:
2963             RETVAL
2964              
2965             void
2966             min_fdlimit (UV limit = 0x7fffffffU)
2967             CODE:
2968             {
2969             #if HAVE_RLIMITS
2970             struct rlimit rl;
2971             rlim_t orig_rlim_max;
2972             UV bit;
2973              
2974 0 0         if (0 != getrlimit (RLIMIT_NOFILE, &rl))
2975 0           goto fail;
2976              
2977 0 0         if (rl.rlim_cur == RLIM_INFINITY)
2978 0           XSRETURN_YES;
2979              
2980 0           orig_rlim_max = rl.rlim_max == RLIM_INFINITY ? ((rlim_t)0)-1 : rl.rlim_max;
2981              
2982 0 0         if (rl.rlim_cur < limit)
2983             {
2984 0           rl.rlim_cur = limit;
2985              
2986 0 0         if (rl.rlim_max < rl.rlim_cur && rl.rlim_max != RLIM_INFINITY)
    0          
2987 0           rl.rlim_max = rl.rlim_cur;
2988             }
2989              
2990 0 0         if (0 == setrlimit (RLIMIT_NOFILE, &rl))
2991 0           XSRETURN_YES;
2992              
2993 0 0         if (errno == EPERM)
2994             {
2995             /* setrlimit failed with EPERM - maybe we can't raise the hardlimit, or maybe */
2996             /* our limit overflows a system-wide limit */
2997             /* try an adaptive algorithm, but do not lower the hardlimit */
2998 0           rl.rlim_max = 0;
2999 0 0         for (bit = 0x40000000U; bit; bit >>= 1)
3000             {
3001 0           rl.rlim_max |= bit;
3002 0           rl.rlim_cur = rl.rlim_max;
3003              
3004             /* never decrease the hard limit */
3005 0 0         if (rl.rlim_max < orig_rlim_max)
3006 0           break;
3007              
3008 0 0         if (0 != setrlimit (RLIMIT_NOFILE, &rl))
3009 0           rl.rlim_max &= ~bit; /* too high, remove bit again */
3010             }
3011              
3012             /* now, raise the soft limit to the max permitted */
3013 0 0         if (0 == getrlimit (RLIMIT_NOFILE, &rl))
3014             {
3015 0           rl.rlim_cur = rl.rlim_max;
3016 0 0         if (0 == setrlimit (RLIMIT_NOFILE, &rl))
3017 0           errno = EPERM;
3018             }
3019             }
3020             #endif
3021             fail:
3022 0           XSRETURN_UNDEF;
3023             }
3024              
3025             void _on_next_submit (SV *cb)
3026             CODE:
3027 0           SvREFCNT_dec (on_next_submit);
3028 0 0         on_next_submit = SvOK (cb) ? newSVsv (cb) : 0;
    0          
    0          
3029              
3030             PROTOTYPES: DISABLE
3031              
3032             MODULE = IO::AIO PACKAGE = IO::AIO::WD
3033              
3034             BOOT:
3035             {
3036 9           newCONSTSUB (aio_stash, "CWD" , newSVaio_wd (EIO_CWD ));
3037 9           newCONSTSUB (aio_stash, "INVALID_WD", newSVaio_wd (EIO_INVALID_WD));
3038             }
3039              
3040             void
3041             DESTROY (SV *self)
3042             CODE:
3043             {
3044 19           aio_wd wd = SvAIO_WD (self);
3045             #if HAVE_AT
3046             {
3047 19           SV *callback = &PL_sv_undef;
3048 19           dREQ; /* clobbers next_pri :/ */
3049 19           next_pri = req->pri; /* restore next_pri */
3050 19           req->pri = EIO_PRI_MAX; /* better use max. priority to conserve fds */
3051 19           req->type = EIO_WD_CLOSE;
3052 19           req->wd = wd;
3053 19 50         REQ_SEND;
    50          
    0          
3054             }
3055             #else
3056             eio_wd_close_sync (wd);
3057             #endif
3058             }
3059              
3060             MODULE = IO::AIO PACKAGE = IO::AIO::REQ
3061              
3062             void
3063             cancel (aio_req_ornot req)
3064             CODE:
3065 2           eio_cancel (req);
3066              
3067             void
3068             cb (aio_req_ornot req, SV *callback = NO_INIT)
3069             PPCODE:
3070             {
3071 10 50         if (GIMME_V != G_VOID)
    50          
3072 0 0         XPUSHs (req->callback ? sv_2mortal (newRV_inc (req->callback)) : &PL_sv_undef);
    0          
3073              
3074 10 50         if (items > 1)
3075             {
3076 10           SV *cb_cv = get_cb (callback);
3077              
3078 10           SvREFCNT_dec (req->callback);
3079 10           req->callback = SvREFCNT_inc (cb_cv);
3080             }
3081             }
3082              
3083             MODULE = IO::AIO PACKAGE = IO::AIO::GRP
3084              
3085             void
3086             add (aio_req grp, ...)
3087             PPCODE:
3088             {
3089             int i;
3090              
3091 32 50         if (grp->int1 == 2)
3092 0           croak ("cannot add requests to IO::AIO::GRP after the group finished");
3093              
3094 65 100         for (i = 1; i < items; ++i )
3095             {
3096             aio_req req;
3097              
3098 33 100         if (GIMME_V != G_VOID)
    100          
3099 13 50         XPUSHs (sv_2mortal (newSVsv (ST (i))));
3100              
3101 33           req = SvAIO_REQ (ST (i));
3102              
3103 33 50         if (req)
3104 33           eio_grp_add (grp, req);
3105             }
3106             }
3107              
3108             void
3109             cancel_subs (aio_req_ornot req)
3110             CODE:
3111 0           req_cancel_subs (req);
3112              
3113             void
3114             result (aio_req grp, ...)
3115             CODE:
3116             {
3117             int i;
3118             AV *av;
3119              
3120 4           grp->errorno = errno;
3121              
3122 4           av = newAV ();
3123 4           av_extend (av, items - 1);
3124              
3125 12 100         for (i = 1; i < items; ++i )
3126 8           av_push (av, newSVsv (ST (i)));
3127              
3128 4           SvREFCNT_dec (grp->sv1);
3129 4           grp->sv1 = (SV *)av;
3130             }
3131              
3132             void
3133             errno (aio_req grp, int errorno = errno)
3134             CODE:
3135 0           grp->errorno = errorno;
3136              
3137             void
3138             limit (aio_req grp, int limit)
3139             CODE:
3140 2           eio_grp_limit (grp, limit);
3141              
3142             void
3143             feed (aio_req grp, SV *callback = &PL_sv_undef)
3144             CODE:
3145             {
3146 3           SvREFCNT_dec (grp->sv2);
3147 3           grp->sv2 = newSVsv (callback);
3148 3           grp->feed = aio_grp_feed;
3149              
3150 3 50         if (grp->int2 <= 0)
3151 0           grp->int2 = 2;
3152              
3153 3           eio_grp_limit (grp, grp->int2);
3154             }
3155