ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/IO-AIO/AIO.xs
(Generate patch)

Comparing IO-AIO/AIO.xs (file contents):
Revision 1.217 by root, Fri Jul 27 17:24:06 2012 UTC vs.
Revision 1.251 by root, Sat Jan 6 01:04:42 2018 UTC

… …
19 19
20#if _POSIX_MEMLOCK || _POSIX_MEMLOCK_RANGE || _POSIX_MAPPED_FILES 20#if _POSIX_MEMLOCK || _POSIX_MEMLOCK_RANGE || _POSIX_MAPPED_FILES
21# include <sys/mman.h> 21# include <sys/mman.h>
22#endif 22#endif
23 23
24#if __linux__ 24/* the incompetent fool that created musl keeps __linux__, refuses
25 * to implement any linux standard apis, and also has no way to test
26 * for his broken iplementation. don't complain to me if this fails
27 * for you.
28 */
29#if __linux__ && (defined __GLIBC__ || defined __UCLIBC__)
25# include <linux/fs.h> 30# include <linux/fs.h>
26# ifdef FS_IOC_FIEMAP 31# ifdef FS_IOC_FIEMAP
27# include <linux/types.h> 32# include <linux/types.h>
28# include <linux/fiemap.h> 33# include <linux/fiemap.h>
29# define HAVE_FIEMAP 1 34# define HAVE_FIEMAP 1
… …
99#define expect_false(expr) expect ((expr) != 0, 0) 104#define expect_false(expr) expect ((expr) != 0, 0)
100#define expect_true(expr) expect ((expr) != 0, 1) 105#define expect_true(expr) expect ((expr) != 0, 1)
101 106
102/*****************************************************************************/ 107/*****************************************************************************/
103 108
109#include "libeio/config.h"
110
111#if HAVE_RLIMITS
112 #include <sys/time.h>
113 #include <sys/resource.h>
114#endif
115
104typedef SV SV8; /* byte-sv, used for argument-checking */ 116typedef SV SV8; /* byte-sv, used for argument-checking */
105typedef int aio_rfd; /* read file desriptor */ 117typedef int aio_rfd; /* read file desriptor */
106typedef int aio_wfd; /* write file descriptor */ 118typedef int aio_wfd; /* write file descriptor */
107 119
108static HV *aio_stash, *aio_req_stash, *aio_grp_stash, *aio_wd_stash; 120static HV *aio_stash, *aio_req_stash, *aio_grp_stash, *aio_wd_stash;
… …
114 STRLEN stroffset; \ 126 STRLEN stroffset; \
115 SV *self; 127 SV *self;
116 128
117#define EIO_NO_WRAPPERS 1 129#define EIO_NO_WRAPPERS 1
118 130
119#include "libeio/config.h"
120#include "libeio/eio.h" 131#include "libeio/eio.h"
121 132
122static int req_invoke (eio_req *req); 133static int req_invoke (eio_req *req);
123#define EIO_FINISH(req) req_invoke (req) 134#define EIO_FINISH(req) req_invoke (req)
124static void req_destroy (eio_req *grp); 135static void req_destroy (eio_req *grp);
… …
141# define MAP_ANONYMOUS MAP_FIXED /* and hope this fails */ 152# define MAP_ANONYMOUS MAP_FIXED /* and hope this fails */
142# endif 153# endif
143#endif 154#endif
144 155
145/* defines all sorts of constants to 0 unless they are already defined */ 156/* defines all sorts of constants to 0 unless they are already defined */
157/* also provides const_iv_ and const_niv_ macros for them */
146#include "def0.h" 158#include "def0.h"
147 159
148#ifndef makedev 160#ifndef makedev
149# define makedev(maj,min) (((maj) << 8) | (min)) 161# define makedev(maj,min) (((maj) << 8) | (min))
150#endif 162#endif
… …
153#endif 165#endif
154#ifndef minor 166#ifndef minor
155# define minor(dev) ((dev) & 0xff) 167# define minor(dev) ((dev) & 0xff)
156#endif 168#endif
157 169
158#ifndef PAGESIZE 170#if PAGESIZE <= 0
159# define PAGESIZE sysconf (_SC_PAGESIZE) 171# define PAGESIZE sysconf (_SC_PAGESIZE)
160#endif 172#endif
173
174/*****************************************************************************/
175
176#if !_POSIX_MAPPED_FILES
177# define mmap(addr,length,prot,flags,fd,offs) EIO_ENOSYS ()
178# define munmap(addr,length) EIO_ENOSYS ()
179#endif
180
181#if !_POSIX_MEMORY_PROTECTION
182# define mprotect(addr,len,prot) EIO_ENOSYS ()
183#endif
184
185#define FOREIGN_MAGIC PERL_MAGIC_ext
186
187static int ecb_cold
188mmap_free (pTHX_ SV *sv, MAGIC *mg)
189{
190 int old_errno = errno;
191 munmap (mg->mg_ptr, (size_t)mg->mg_obj);
192 errno = old_errno;
193
194 mg->mg_obj = 0; /* just in case */
195
196 SvREADONLY_off (sv);
197
198 if (SvPVX (sv) != mg->mg_ptr)
199 croak ("ERROR: IO::AIO::mmap-mapped scalar changed location, detected");
200
201 SvCUR_set (sv, 0);
202 SvPVX (sv) = 0;
203 SvOK_off (sv);
204
205 return 0;
206}
207
208static MGVTBL mmap_vtbl = {
209 0, 0, 0, 0, mmap_free
210};
211
212static int ecb_cold
213sysfree_free (pTHX_ SV *sv, MAGIC *mg)
214{
215 free (mg->mg_ptr);
216 mg->mg_obj = 0; /* just in case */
217
218 SvREADONLY_off (sv);
219
220 if (SvPVX (sv) != mg->mg_ptr)
221 croak ("ERROR: IO::AIO mapped scalar changed location, detected");
222
223 SvCUR_set (sv, 0);
224 SvPVX (sv) = 0;
225 SvOK_off (sv);
226
227 return 0;
228}
229
230static MGVTBL sysfree_vtbl = {
231 0, 0, 0, 0, sysfree_free
232};
233
234/*****************************************************************************/
235
236/* helper: set scalar to foreign ptr with custom free */
237static void
238sv_set_foreign (SV *sv, const MGVTBL *const vtbl, void *addr, IV length)
239{
240 sv_force_normal (sv);
241
242 /* we store the length in mg_obj, as namlen is I32 :/ */
243 sv_magicext (sv, 0, FOREIGN_MAGIC, vtbl, (char *)addr, 0)
244 ->mg_obj = (SV *)length;
245
246 SvUPGRADE (sv, SVt_PV); /* nop... */
247
248 if (SvLEN (sv))
249 Safefree (SvPVX (sv));
250
251 SvPVX (sv) = (char *)addr;
252 SvCUR_set (sv, length);
253 SvLEN_set (sv, 0);
254 SvPOK_only (sv);
255}
256
257static void
258sv_clear_foreign (SV *sv)
259{
260 /* todo: iterate over magic and only free ours, but of course */
261 /* the perl5porters will call that (correct) behaviour buggy */
262 sv_unmagic (sv, FOREIGN_MAGIC);
263}
161 264
162/*****************************************************************************/ 265/*****************************************************************************/
163 266
164static void 267static void
165fiemap (eio_req *req) 268fiemap (eio_req *req)
166{ 269{
167 req->result = -1; 270 req->result = -1;
168 271
169#if HAVE_FIEMAP 272#if HAVE_FIEMAP
273 /* assume some c99 */
274 struct fiemap *fiemap = 0;
275 size_t end_offset;
170 int count = req->int3; 276 int count = req->int3;
171 277
172 /* heuristic: first try with 64 extents if we don't know how many, */ 278 req->flags |= EIO_FLAG_PTR1_FREE;
173 /* as most files have (hopefully) fewer than this many extents */ 279
174 /* in fact, most should have <= 2, so maybe the 72 below is probably overkill */ 280 /* heuristic: start with 512 bytes (8 extents), and if that isn't enough, */
281 /* increase in 3.5kb steps */
175 if (count < 0) 282 if (count < 0)
176 count = 72; /* for what it's worth, 72 extents fit nicely into 4kb */ 283 count = 8;
284
285 fiemap = malloc (sizeof (*fiemap) + sizeof (struct fiemap_extent) * count);
286 errno = ENOMEM;
287 if (!fiemap)
288 return;
289
290 req->ptr1 = fiemap;
291
292 fiemap->fm_start = req->offs;
293 fiemap->fm_length = req->size;
294 fiemap->fm_flags = req->int2;
295 fiemap->fm_extent_count = count;
296
297 if (ioctl (req->int1, FS_IOC_FIEMAP, fiemap) < 0)
298 return;
299
300 if (req->int3 >= 0 /* not autosizing */
301 || !fiemap->fm_mapped_extents /* no more extents */
302 || fiemap->fm_extents [fiemap->fm_mapped_extents - 1].fe_flags & FIEMAP_EXTENT_LAST /* hit eof */)
303 goto done;
304
305 /* else we have to loop -
306 * it would be tempting (actually I tried that first) to just query the
307 * number of extents needed, but linux often feels like not returning all
308 * extents, without telling us it left any out. this complicates
309 * this quite a bit.
310 */
311
312 end_offset = fiemap->fm_length + (fiemap->fm_length == FIEMAP_MAX_OFFSET ? 0 : fiemap->fm_start);
177 313
178 for (;;) 314 for (;;)
179 { 315 {
316 /* we go in 54 extent steps - 3kb, in the hope that this fits nicely on the eio stack (normally 16+ kb) */
317 char scratch[3072];
318 struct fiemap *incmap = (struct fiemap *)scratch;
319
320 incmap->fm_start = fiemap->fm_extents [fiemap->fm_mapped_extents - 1].fe_logical
321 + fiemap->fm_extents [fiemap->fm_mapped_extents - 1].fe_length;
322 incmap->fm_length = fiemap->fm_length - (incmap->fm_start - fiemap->fm_start);
323 incmap->fm_flags = fiemap->fm_flags;
324 incmap->fm_extent_count = (sizeof (scratch) - sizeof (struct fiemap)) / sizeof (struct fiemap_extent);
325
326 if (ioctl (req->int1, FS_IOC_FIEMAP, incmap) < 0)
327 return;
328
329 if (!incmap->fm_mapped_extents)
330 goto done;
331
332 count = fiemap->fm_mapped_extents + incmap->fm_mapped_extents;
180 struct fiemap *fiemap = malloc (sizeof (*fiemap) + sizeof (struct fiemap_extent) * count); 333 fiemap = realloc (fiemap, sizeof (*fiemap) + sizeof (struct fiemap_extent) * count);
181 errno = ENOMEM; 334 errno = ENOMEM;
182 if (!fiemap) 335 if (!fiemap)
183 return; 336 return;
184 337
185 req->ptr1 = fiemap; 338 req->ptr1 = fiemap;
186 req->flags |= EIO_FLAG_PTR1_FREE;
187 339
188 fiemap->fm_start = req->offs; 340 for (count = 0; count < incmap->fm_mapped_extents; ++count)
189 fiemap->fm_length = req->size; 341 {
190 fiemap->fm_flags = req->int2; 342 struct fiemap_extent *e = incmap->fm_extents + count;
191 fiemap->fm_extent_count = count;
192 343
193 if (ioctl (req->int1, FS_IOC_FIEMAP, fiemap)) 344 if (e->fe_logical + e->fe_length >= end_offset)
194 return; 345 goto done;
195 346
196 if (req->int3 >= 0) 347 fiemap->fm_extents [fiemap->fm_mapped_extents++] = *e;
197 break; /* when not autosizing we are done */
198 348
199 if (fiemap->fm_extents [fiemap->fm_mapped_extents - 1].fe_flags & FIEMAP_EXTENT_LAST) 349 if (e->fe_flags & FIEMAP_EXTENT_LAST)
200 break; /* autosizing successful, we are done */ 350 goto done;
201 351
202 fiemap->fm_flags = req->int2; 352 }
203 fiemap->fm_extent_count = 0;
204
205 if (ioctl (req->int1, FS_IOC_FIEMAP, fiemap))
206 return;
207
208 count = fiemap->fm_mapped_extents;
209
210 free (fiemap);
211 } 353 }
212 354
355done:
213 req->result = 0; 356 req->result = 0;
214 357
215#else 358#else
216 errno = ENOSYS; 359 errno = ENOSYS;
217#endif 360#endif
… …
264} 407}
265 408
266static SV * 409static SV *
267newSVaio_wd (aio_wd wd) 410newSVaio_wd (aio_wd wd)
268{ 411{
269 return sv_bless (newRV_noinc (newSViv ((IV)wd)), aio_wd_stash); 412 return sv_bless (newRV_noinc (newSViv ((intptr_t)wd)), aio_wd_stash);
270} 413}
271 414
272static aio_req 415static aio_req
273SvAIO_REQ (SV *sv) 416SvAIO_REQ (SV *sv)
274{ 417{
… …
293 || SvTYPE (SvRV (sv)) != SVt_PVMG 436 || SvTYPE (SvRV (sv)) != SVt_PVMG
294 || SvSTASH (SvRV (sv)) != aio_wd_stash) 437 || SvSTASH (SvRV (sv)) != aio_wd_stash)
295 croak ("IO::AIO: expected a working directory object as returned by aio_wd"); 438 croak ("IO::AIO: expected a working directory object as returned by aio_wd");
296 439
297 return (aio_wd)(long)SvIVX (SvRV (sv)); 440 return (aio_wd)(long)SvIVX (SvRV (sv));
441}
442
443static SV *
444newmortalFH (int fd, int flags)
445{
446 if (fd < 0)
447 return &PL_sv_undef;
448
449 GV *gv = (GV *)sv_newmortal ();
450 char sym[64];
451 int symlen;
452
453 symlen = snprintf (sym, sizeof (sym), "fd#%d", fd);
454 gv_init (gv, aio_stash, sym, symlen, 0);
455
456 symlen = snprintf (
457 sym,
458 sizeof (sym),
459 "%s&=%d",
460 flags == O_RDONLY ? "<" : flags == O_WRONLY ? ">" : "+<",
461 fd
462 );
463
464 return do_open (gv, sym, symlen, 0, 0, 0, 0)
465 ? (SV *)gv : &PL_sv_undef;
298} 466}
299 467
300static void 468static void
301aio_grp_feed (aio_req grp) 469aio_grp_feed (aio_req grp)
302{ 470{
… …
430 XPUSHs (sv_2mortal (newSViv (req->int1 & ~(EIO_READDIR_CUSTOM1 | EIO_READDIR_CUSTOM2)))); 598 XPUSHs (sv_2mortal (newSViv (req->int1 & ~(EIO_READDIR_CUSTOM1 | EIO_READDIR_CUSTOM2))));
431 } 599 }
432 break; 600 break;
433 601
434 case EIO_OPEN: 602 case EIO_OPEN:
435 { 603 PUSHs (newmortalFH (req->result, req->int1 & (O_RDONLY | O_WRONLY | O_RDWR)));
436 /* convert fd to fh */
437 SV *fh = &PL_sv_undef;
438
439 if (req->result >= 0)
440 {
441 GV *gv = (GV *)sv_newmortal ();
442 int flags = req->int1 & (O_RDONLY | O_WRONLY | O_RDWR);
443 char sym [64];
444 int symlen;
445
446 symlen = snprintf (sym, sizeof (sym), "fd#%d", (int)req->result);
447 gv_init (gv, aio_stash, sym, symlen, 0);
448
449 symlen = snprintf (
450 sym,
451 sizeof (sym),
452 "%s&=%d",
453 flags == O_RDONLY ? "<" : flags == O_WRONLY ? ">" : "+<",
454 (int)req->result
455 );
456
457 if (do_open (gv, sym, symlen, 0, 0, 0, 0))
458 fh = (SV *)gv;
459 }
460
461 PUSHs (fh);
462 }
463 break; 604 break;
464 605
465 case EIO_STATVFS: 606 case EIO_STATVFS:
466 case EIO_FSTATVFS: 607 case EIO_FSTATVFS:
467 { 608 {
… …
470#ifndef _WIN32 611#ifndef _WIN32
471 if (req->result >= 0) 612 if (req->result >= 0)
472 { 613 {
473 EIO_STRUCT_STATVFS *f = EIO_STATVFS_BUF (req); 614 EIO_STRUCT_STATVFS *f = EIO_STATVFS_BUF (req);
474 HV *hv = newHV (); 615 HV *hv = newHV ();
616 /* POSIX requires fsid to be unsigned long, but AIX in its infinite wisdom
617 * chooses to make it a struct.
618 */
619 unsigned long fsid = 0;
620 memcpy (&fsid, &f->f_fsid, sizeof (unsigned long) < sizeof (f->f_fsid) ? sizeof (unsigned long) : sizeof (f->f_fsid));
475 621
476 rv = sv_2mortal (newRV_noinc ((SV *)hv)); 622 rv = sv_2mortal (newRV_noinc ((SV *)hv));
477 623
478 hv_store (hv, "bsize" , sizeof ("bsize" ) - 1, newSVval64 (f->f_bsize ), 0); 624 hv_store (hv, "bsize" , sizeof ("bsize" ) - 1, newSVval64 (f->f_bsize ), 0);
479 hv_store (hv, "frsize" , sizeof ("frsize" ) - 1, newSVval64 (f->f_frsize ), 0); 625 hv_store (hv, "frsize" , sizeof ("frsize" ) - 1, newSVval64 (f->f_frsize ), 0);
… …
481 hv_store (hv, "bfree" , sizeof ("bfree" ) - 1, newSVval64 (f->f_bfree ), 0); 627 hv_store (hv, "bfree" , sizeof ("bfree" ) - 1, newSVval64 (f->f_bfree ), 0);
482 hv_store (hv, "bavail" , sizeof ("bavail" ) - 1, newSVval64 (f->f_bavail ), 0); 628 hv_store (hv, "bavail" , sizeof ("bavail" ) - 1, newSVval64 (f->f_bavail ), 0);
483 hv_store (hv, "files" , sizeof ("files" ) - 1, newSVval64 (f->f_files ), 0); 629 hv_store (hv, "files" , sizeof ("files" ) - 1, newSVval64 (f->f_files ), 0);
484 hv_store (hv, "ffree" , sizeof ("ffree" ) - 1, newSVval64 (f->f_ffree ), 0); 630 hv_store (hv, "ffree" , sizeof ("ffree" ) - 1, newSVval64 (f->f_ffree ), 0);
485 hv_store (hv, "favail" , sizeof ("favail" ) - 1, newSVval64 (f->f_favail ), 0); 631 hv_store (hv, "favail" , sizeof ("favail" ) - 1, newSVval64 (f->f_favail ), 0);
486 hv_store (hv, "fsid" , sizeof ("fsid" ) - 1, newSVval64 (f->f_fsid ), 0); 632 hv_store (hv, "fsid" , sizeof ("fsid" ) - 1, newSVval64 (fsid ), 0);
487 hv_store (hv, "flag" , sizeof ("flag" ) - 1, newSVval64 (f->f_flag ), 0); 633 hv_store (hv, "flag" , sizeof ("flag" ) - 1, newSVval64 (f->f_flag ), 0);
488 hv_store (hv, "namemax", sizeof ("namemax") - 1, newSVval64 (f->f_namemax), 0); 634 hv_store (hv, "namemax", sizeof ("namemax") - 1, newSVval64 (f->f_namemax), 0);
489 } 635 }
490#endif 636#endif
491 637
… …
542 SvSETMAGIC (req->sv2); 688 SvSETMAGIC (req->sv2);
543 PUSHs (sv_result); 689 PUSHs (sv_result);
544 } 690 }
545 break; 691 break;
546 692
693 case EIO_SLURP:
694 {
695 if (req->result >= 0)
696 {
697 /* if length was originally not known, we steal the malloc'ed memory */
698 if (req->flags & EIO_FLAG_PTR2_FREE)
699 {
700 req->flags &= ~EIO_FLAG_PTR2_FREE;
701 sv_set_foreign (req->sv2, &sysfree_vtbl, req->ptr2, req->result);
702 }
703 else
704 SvCUR_set (req->sv2, req->result);
705 }
706
707 PUSHs (sv_result);
708 }
709 break;
710
547 case EIO_CUSTOM: 711 case EIO_CUSTOM:
548 if (req->feed == fiemap) 712 if (req->feed == fiemap)
549 { 713 {
550#if HAVE_FIEMAP 714#if HAVE_FIEMAP
551 if (!req->result) 715 if (!req->result)
… …
656{ 820{
657 while (eio_nreqs ()) 821 while (eio_nreqs ())
658 { 822 {
659 int size; 823 int size;
660 824
661 X_LOCK (reslock); 825 X_LOCK (EIO_POOL->reslock);
662 size = res_queue.size; 826 size = EIO_POOL->res_queue.size;
663 X_UNLOCK (reslock); 827 X_UNLOCK (EIO_POOL->reslock);
664 828
665 if (size) 829 if (size)
666 return; 830 return;
667 831
668 etp_maybe_start_thread (); 832 etp_maybe_start_thread (EIO_POOL);
669 833
670 s_epipe_wait (&respipe); 834 s_epipe_wait (&respipe);
671 } 835 }
672} 836}
673 837
… …
694 create_respipe (); 858 create_respipe ();
695 859
696 if (eio_init (want_poll, done_poll) < 0) 860 if (eio_init (want_poll, done_poll) < 0)
697 croak ("IO::AIO: unable to initialise eio library"); 861 croak ("IO::AIO: unable to initialise eio library");
698} 862}
699
700/*****************************************************************************/
701
702#if !_POSIX_MAPPED_FILES
703# define mmap(addr,length,prot,flags,fd,offs) EIO_ENOSYS ()
704# define munmap(addr,length) EIO_ENOSYS ()
705#endif
706
707#if !_POSIX_MEMORY_PROTECTION
708# define mprotect(addr,len,prot) EIO_ENOSYS ()
709# define PROT_NONE 0
710# define PROT_WRITE 0
711# define MAP_PRIVATE 0
712# define MAP_SHARED 0
713# define MAP_FIXED 0
714#endif
715
716#define MMAP_MAGIC PERL_MAGIC_ext
717
718static int ecb_cold
719mmap_free (pTHX_ SV *sv, MAGIC *mg)
720{
721 int old_errno = errno;
722 munmap (mg->mg_ptr, (size_t)mg->mg_obj);
723 errno = old_errno;
724
725 mg->mg_obj = 0; /* just in case */
726
727 SvREADONLY_off (sv);
728
729 if (SvPVX (sv) != mg->mg_ptr)
730 croak ("ERROR: IO::AIO::mmap-mapped scalar changed location, detected");
731
732 SvCUR_set (sv, 0);
733 SvPVX (sv) = 0;
734 SvOK_off (sv);
735
736 return 0;
737}
738
739static MGVTBL mmap_vtbl = {
740 0, 0, 0, 0, mmap_free
741};
742 863
743/*****************************************************************************/ 864/*****************************************************************************/
744 865
745static SV * 866static SV *
746get_cb (SV *cb_sv) 867get_cb (SV *cb_sv)
… …
858 } *civ, const_iv[] = { 979 } *civ, const_iv[] = {
859# define const_niv(name, value) { # name, (IV) value }, 980# define const_niv(name, value) { # name, (IV) value },
860# define const_iv(name) { # name, (IV) name }, 981# define const_iv(name) { # name, (IV) name },
861# define const_eio(name) { # name, (IV) EIO_ ## name }, 982# define const_eio(name) { # name, (IV) EIO_ ## name },
862 983
863 /* you have to re-run ./gendef0 after adding/Removing any constants here */ 984 /* you have to re-run ./gendef0 after adding/removing any constants here */
864 985 /* the first block can be undef if missing */
865 const_iv (ENOSYS) 986 const_iv (ENOSYS)
866 const_iv (EXDEV) 987 const_iv (EXDEV)
867 const_iv (EBADR) 988 const_iv (EBADR)
868 989
990 /* for lseek */
991 const_iv (SEEK_DATA)
992 const_iv (SEEK_HOLE)
993
994 const_niv (FADV_NORMAL , POSIX_FADV_NORMAL)
995 const_niv (FADV_SEQUENTIAL, POSIX_FADV_SEQUENTIAL)
996 const_niv (FADV_RANDOM , POSIX_FADV_RANDOM)
997 const_niv (FADV_NOREUSE , POSIX_FADV_NOREUSE)
998 const_niv (FADV_WILLNEED , POSIX_FADV_WILLNEED)
999 const_niv (FADV_DONTNEED , POSIX_FADV_DONTNEED)
1000
1001 const_niv (MADV_NORMAL , POSIX_MADV_NORMAL)
1002 const_niv (MADV_SEQUENTIAL, POSIX_MADV_SEQUENTIAL)
1003 const_niv (MADV_RANDOM , POSIX_MADV_RANDOM)
1004 const_niv (MADV_WILLNEED , POSIX_MADV_WILLNEED)
1005 const_niv (MADV_DONTNEED , POSIX_MADV_DONTNEED)
1006
1007 /* the second block will be 0 when missing */
869 const_iv (O_RDONLY) 1008 const_iv (O_RDONLY)
870 const_iv (O_WRONLY) 1009 const_iv (O_WRONLY)
871 const_iv (O_RDWR) 1010 const_iv (O_RDWR)
872 const_iv (O_CREAT) 1011 const_iv (O_CREAT)
873 const_iv (O_TRUNC) 1012 const_iv (O_TRUNC)
… …
886 const_iv (O_SEARCH) 1025 const_iv (O_SEARCH)
887 const_iv (O_DIRECTORY) 1026 const_iv (O_DIRECTORY)
888 const_iv (O_DSYNC) 1027 const_iv (O_DSYNC)
889 const_iv (O_RSYNC) 1028 const_iv (O_RSYNC)
890 const_iv (O_SYNC) 1029 const_iv (O_SYNC)
1030 const_iv (O_PATH)
1031 const_iv (O_TMPFILE)
891 const_iv (O_TTY_INIT) 1032 const_iv (O_TTY_INIT)
892 1033
893 const_iv (S_IFIFO) 1034 const_iv (S_IFIFO)
894 const_iv (S_IFCHR) 1035 const_iv (S_IFCHR)
895 const_iv (S_IFBLK) 1036 const_iv (S_IFBLK)
… …
897 const_iv (S_IFREG) 1038 const_iv (S_IFREG)
898 const_iv (S_IFDIR) 1039 const_iv (S_IFDIR)
899 const_iv (S_IFWHT) 1040 const_iv (S_IFWHT)
900 const_iv (S_IFSOCK) 1041 const_iv (S_IFSOCK)
901 const_iv (S_IFMT) 1042 const_iv (S_IFMT)
902
903 const_niv (FADV_NORMAL , POSIX_FADV_NORMAL)
904 const_niv (FADV_SEQUENTIAL, POSIX_FADV_SEQUENTIAL)
905 const_niv (FADV_RANDOM , POSIX_FADV_RANDOM)
906 const_niv (FADV_NOREUSE , POSIX_FADV_NOREUSE)
907 const_niv (FADV_WILLNEED , POSIX_FADV_WILLNEED)
908 const_niv (FADV_DONTNEED , POSIX_FADV_DONTNEED)
909
910 const_niv (MADV_NORMAL , POSIX_MADV_NORMAL)
911 const_niv (MADV_SEQUENTIAL, POSIX_MADV_SEQUENTIAL)
912 const_niv (MADV_RANDOM , POSIX_MADV_RANDOM)
913 const_niv (MADV_WILLNEED , POSIX_MADV_WILLNEED)
914 const_niv (MADV_DONTNEED , POSIX_MADV_DONTNEED)
915 1043
916 const_iv (ST_RDONLY) 1044 const_iv (ST_RDONLY)
917 const_iv (ST_NOSUID) 1045 const_iv (ST_NOSUID)
918 const_iv (ST_NODEV) 1046 const_iv (ST_NODEV)
919 const_iv (ST_NOEXEC) 1047 const_iv (ST_NOEXEC)
… …
929 const_iv (PROT_NONE) 1057 const_iv (PROT_NONE)
930 const_iv (PROT_EXEC) 1058 const_iv (PROT_EXEC)
931 const_iv (PROT_READ) 1059 const_iv (PROT_READ)
932 const_iv (PROT_WRITE) 1060 const_iv (PROT_WRITE)
933 1061
934 /*const_iv (MAP_FIXED)*/
935 const_iv (MAP_PRIVATE) 1062 const_iv (MAP_PRIVATE)
936 const_iv (MAP_SHARED) 1063 const_iv (MAP_SHARED)
1064 const_iv (MAP_FIXED)
937 const_iv (MAP_ANONYMOUS) 1065 const_iv (MAP_ANONYMOUS)
938 1066
939 /* linuxish */ 1067 /* linuxish */
940 const_iv (MAP_HUGETLB)
941 const_iv (MAP_LOCKED) 1068 const_iv (MAP_LOCKED)
942 const_iv (MAP_NORESERVE) 1069 const_iv (MAP_NORESERVE)
943 const_iv (MAP_POPULATE) 1070 const_iv (MAP_POPULATE)
944 const_iv (MAP_NONBLOCK) 1071 const_iv (MAP_NONBLOCK)
1072 const_iv (MAP_GROWSDOWN)
1073 const_iv (MAP_32BIT)
1074 const_iv (MAP_HUGETLB)
1075 const_iv (MAP_STACK)
1076
1077 const_iv (F_DUPFD_CLOEXEC)
1078
1079 const_iv (F_OFD_GETLK)
1080 const_iv (F_OFD_SETLK)
1081 const_iv (F_OFD_GETLKW)
1082
1083 const_iv (FIFREEZE)
1084 const_iv (FITHAW)
1085 const_iv (FITRIM)
1086 const_iv (FICLONE)
1087 const_iv (FICLONERANGE)
1088 const_iv (FIDEDUPERANGE)
1089
1090 const_iv (FS_IOC_GETFLAGS)
1091 const_iv (FS_IOC_SETFLAGS)
1092 const_iv (FS_IOC_GETVERSION)
1093 const_iv (FS_IOC_SETVERSION)
1094 const_iv (FS_IOC_FIEMAP)
1095 const_iv (FS_IOC_FSGETXATTR)
1096 const_iv (FS_IOC_FSSETXATTR)
1097 const_iv (FS_IOC_SET_ENCRYPTION_POLICY)
1098 const_iv (FS_IOC_GET_ENCRYPTION_PWSALT)
1099 const_iv (FS_IOC_GET_ENCRYPTION_POLICY)
1100
1101 const_iv (FS_KEY_DESCRIPTOR_SIZE)
1102
1103 const_iv (FS_SECRM_FL)
1104 const_iv (FS_UNRM_FL)
1105 const_iv (FS_COMPR_FL)
1106 const_iv (FS_SYNC_FL)
1107 const_iv (FS_IMMUTABLE_FL)
1108 const_iv (FS_APPEND_FL)
1109 const_iv (FS_NODUMP_FL)
1110 const_iv (FS_NOATIME_FL)
1111 const_iv (FS_DIRTY_FL)
1112 const_iv (FS_COMPRBLK_FL)
1113 const_iv (FS_NOCOMP_FL)
1114 const_iv (FS_ENCRYPT_FL)
1115 const_iv (FS_BTREE_FL)
1116 const_iv (FS_INDEX_FL)
1117 const_iv (FS_JOURNAL_DATA_FL)
1118 const_iv (FS_NOTAIL_FL)
1119 const_iv (FS_DIRSYNC_FL)
1120 const_iv (FS_TOPDIR_FL)
1121 const_iv (FS_FL_USER_MODIFIABLE)
1122
1123 const_iv (FS_XFLAG_REALTIME)
1124 const_iv (FS_XFLAG_PREALLOC)
1125 const_iv (FS_XFLAG_IMMUTABLE)
1126 const_iv (FS_XFLAG_APPEND)
1127 const_iv (FS_XFLAG_SYNC)
1128 const_iv (FS_XFLAG_NOATIME)
1129 const_iv (FS_XFLAG_NODUMP)
1130 const_iv (FS_XFLAG_RTINHERIT)
1131 const_iv (FS_XFLAG_PROJINHERIT)
1132 const_iv (FS_XFLAG_NOSYMLINKS)
1133 const_iv (FS_XFLAG_EXTSIZE)
1134 const_iv (FS_XFLAG_EXTSZINHERIT)
1135 const_iv (FS_XFLAG_NODEFRAG)
1136 const_iv (FS_XFLAG_FILESTREAM)
1137 const_iv (FS_XFLAG_DAX)
1138 const_iv (FS_XFLAG_HASATTR)
945 1139
946 const_iv (FIEMAP_FLAG_SYNC) 1140 const_iv (FIEMAP_FLAG_SYNC)
947 const_iv (FIEMAP_FLAG_XATTR) 1141 const_iv (FIEMAP_FLAG_XATTR)
948 const_iv (FIEMAP_FLAGS_COMPAT) 1142 const_iv (FIEMAP_FLAGS_COMPAT)
949 const_iv (FIEMAP_EXTENT_LAST) 1143 const_iv (FIEMAP_EXTENT_LAST)
… …
961 const_iv (SPLICE_F_MOVE) 1155 const_iv (SPLICE_F_MOVE)
962 const_iv (SPLICE_F_NONBLOCK) 1156 const_iv (SPLICE_F_NONBLOCK)
963 const_iv (SPLICE_F_MORE) 1157 const_iv (SPLICE_F_MORE)
964 const_iv (SPLICE_F_GIFT) 1158 const_iv (SPLICE_F_GIFT)
965 1159
966 const_iv (SEEK_DATA) 1160 /* these are libeio constants, and are independent of gendef0 */
967 const_iv (SEEK_HOLE)
968
969 /* libeio constants */
970 const_eio (SEEK_SET) 1161 const_eio (SEEK_SET)
971 const_eio (SEEK_CUR) 1162 const_eio (SEEK_CUR)
972 const_eio (SEEK_END) 1163 const_eio (SEEK_END)
973 1164
974 const_eio (MCL_FUTURE) 1165 const_eio (MCL_FUTURE)
… …
984 const_eio (SYNC_FILE_RANGE_WRITE) 1175 const_eio (SYNC_FILE_RANGE_WRITE)
985 const_eio (SYNC_FILE_RANGE_WAIT_AFTER) 1176 const_eio (SYNC_FILE_RANGE_WAIT_AFTER)
986 1177
987 const_eio (FALLOC_FL_KEEP_SIZE) 1178 const_eio (FALLOC_FL_KEEP_SIZE)
988 const_eio (FALLOC_FL_PUNCH_HOLE) 1179 const_eio (FALLOC_FL_PUNCH_HOLE)
1180 const_eio (FALLOC_FL_COLLAPSE_RANGE)
1181 const_eio (FALLOC_FL_ZERO_RANGE)
1182 const_eio (FALLOC_FL_INSERT_RANGE)
1183 const_eio (FALLOC_FL_UNSHARE_RANGE)
1184
1185 const_eio (RENAME_NOREPLACE)
1186 const_eio (RENAME_EXCHANGE)
1187 const_eio (RENAME_WHITEOUT)
989 1188
990 const_eio (READDIR_DENTS) 1189 const_eio (READDIR_DENTS)
991 const_eio (READDIR_DIRS_FIRST) 1190 const_eio (READDIR_DIRS_FIRST)
992 const_eio (READDIR_STAT_ORDER) 1191 const_eio (READDIR_STAT_ORDER)
993 const_eio (READDIR_FOUND_UNKNOWN) 1192 const_eio (READDIR_FOUND_UNKNOWN)
… …
1061 PROTOTYPE: $ 1260 PROTOTYPE: $
1062 CODE: 1261 CODE:
1063 max_outstanding = maxreqs; 1262 max_outstanding = maxreqs;
1064 1263
1065void 1264void
1066aio_wd (SV8 *pathname, SV *callback=&PL_sv_undef) 1265aio_wd (SV8 *pathname, SV *callback = &PL_sv_undef)
1067 PPCODE: 1266 PPCODE:
1068{ 1267{
1069 dREQ; 1268 dREQ;
1070 1269
1071 req->type = EIO_WD_OPEN; 1270 req->type = EIO_WD_OPEN;
… …
1073 1272
1074 REQ_SEND; 1273 REQ_SEND;
1075} 1274}
1076 1275
1077void 1276void
1078aio_open (SV8 *pathname, int flags, int mode, SV *callback=&PL_sv_undef) 1277aio_open (SV8 *pathname, int flags, int mode, SV *callback = &PL_sv_undef)
1079 PPCODE: 1278 PPCODE:
1080{ 1279{
1081 dREQ; 1280 dREQ;
1082 1281
1083 req->type = EIO_OPEN; 1282 req->type = EIO_OPEN;
… …
1087 1286
1088 REQ_SEND; 1287 REQ_SEND;
1089} 1288}
1090 1289
1091void 1290void
1092aio_fsync (SV *fh, SV *callback=&PL_sv_undef) 1291aio_fsync (SV *fh, SV *callback = &PL_sv_undef)
1093 ALIAS: 1292 ALIAS:
1094 aio_fsync = EIO_FSYNC 1293 aio_fsync = EIO_FSYNC
1095 aio_fdatasync = EIO_FDATASYNC 1294 aio_fdatasync = EIO_FDATASYNC
1096 aio_syncfs = EIO_SYNCFS 1295 aio_syncfs = EIO_SYNCFS
1097 PPCODE: 1296 PPCODE:
1098{ 1297{
1099 int fd = s_fileno_croak (fh, 0); 1298 int fd = s_fileno_croak (fh, 0);
1100 dREQ; 1299 dREQ;
1101 1300
1102 req->type = ix; 1301 req->type = ix;
1103 req->sv1 = newSVsv (fh); 1302 req->sv1 = newSVsv (fh);
1104 req->int1 = fd; 1303 req->int1 = fd;
1105 1304
1106 REQ_SEND; 1305 REQ_SEND;
1107} 1306}
1108 1307
1109void 1308void
1110aio_sync_file_range (SV *fh, off_t offset, size_t nbytes, UV flags, SV *callback=&PL_sv_undef) 1309aio_sync_file_range (SV *fh, off_t offset, size_t nbytes, UV flags, SV *callback = &PL_sv_undef)
1111 PPCODE: 1310 PPCODE:
1112{ 1311{
1113 int fd = s_fileno_croak (fh, 0); 1312 int fd = s_fileno_croak (fh, 0);
1114 dREQ; 1313 dREQ;
1115 1314
1116 req->type = EIO_SYNC_FILE_RANGE; 1315 req->type = EIO_SYNC_FILE_RANGE;
1117 req->sv1 = newSVsv (fh); 1316 req->sv1 = newSVsv (fh);
1118 req->int1 = fd; 1317 req->int1 = fd;
… …
1122 1321
1123 REQ_SEND; 1322 REQ_SEND;
1124} 1323}
1125 1324
1126void 1325void
1127aio_fallocate (SV *fh, int mode, off_t offset, size_t len, SV *callback=&PL_sv_undef) 1326aio_allocate (SV *fh, int mode, off_t offset, size_t len, SV *callback = &PL_sv_undef)
1128 PPCODE: 1327 PPCODE:
1129{ 1328{
1130 int fd = s_fileno_croak (fh, 0); 1329 int fd = s_fileno_croak (fh, 0);
1131 dREQ; 1330 dREQ;
1132 1331
1133 req->type = EIO_FALLOCATE; 1332 req->type = EIO_FALLOCATE;
1134 req->sv1 = newSVsv (fh); 1333 req->sv1 = newSVsv (fh);
1135 req->int1 = fd; 1334 req->int1 = fd;
… …
1139 1338
1140 REQ_SEND; 1339 REQ_SEND;
1141} 1340}
1142 1341
1143void 1342void
1144aio_close (SV *fh, SV *callback=&PL_sv_undef) 1343aio_close (SV *fh, SV *callback = &PL_sv_undef)
1145 PPCODE: 1344 PPCODE:
1146{ 1345{
1147 static int close_fd = -1; /* dummy fd to close fds via dup2 */ 1346 static int close_fd = -1; /* dummy fd to close fds via dup2 */
1148 int fd = s_fileno_croak (fh, 0); 1347 int fd = s_fileno_croak (fh, 0);
1149 dREQ; 1348 dREQ;
1150 1349
1151 if (expect_false (close_fd < 0)) 1350 if (expect_false (close_fd < 0))
1152 { 1351 {
1153 int pipefd [2]; 1352 int pipefd [2];
… …
1173 1372
1174 REQ_SEND; 1373 REQ_SEND;
1175} 1374}
1176 1375
1177void 1376void
1178aio_seek (SV *fh, SV *offset, int whence, SV *callback=&PL_sv_undef) 1377aio_seek (SV *fh, SV *offset, int whence, SV *callback = &PL_sv_undef)
1179 PPCODE: 1378 PPCODE:
1180{ 1379{
1181 int fd = s_fileno_croak (fh, 0); 1380 int fd = s_fileno_croak (fh, 0);
1182 dREQ; 1381 dREQ;
1183 1382
… …
1189 1388
1190 REQ_SEND; 1389 REQ_SEND;
1191} 1390}
1192 1391
1193void 1392void
1194aio_read (SV *fh, SV *offset, SV *length, SV8 *data, IV dataoffset, SV *callback=&PL_sv_undef) 1393aio_read (SV *fh, SV *offset, SV *length, SV8 *data, IV dataoffset, SV *callback = &PL_sv_undef)
1195 ALIAS: 1394 ALIAS:
1196 aio_read = EIO_READ 1395 aio_read = EIO_READ
1197 aio_write = EIO_WRITE 1396 aio_write = EIO_WRITE
1198 PPCODE: 1397 PPCODE:
1199{ 1398{
… …
1215 len = svlen - dataoffset; 1414 len = svlen - dataoffset;
1216 } 1415 }
1217 else 1416 else
1218 { 1417 {
1219 /* read: check type and grow scalar as necessary */ 1418 /* read: check type and grow scalar as necessary */
1220 SvUPGRADE (data, SVt_PV);
1221 if (SvLEN (data) >= SvCUR (data)) 1419 if (!SvPOK (data) || SvLEN (data) >= SvCUR (data))
1222 svptr = SvGROW (data, len + dataoffset + 1); 1420 svptr = sv_grow (data, len + dataoffset);
1223 else if (SvCUR (data) < len + dataoffset) 1421 else if (SvCUR (data) < len + dataoffset)
1224 croak ("length + dataoffset outside of scalar, and cannot grow"); 1422 croak ("length + dataoffset outside of scalar, and cannot grow");
1225 } 1423 }
1226 1424
1227 { 1425 {
… …
1245 REQ_SEND; 1443 REQ_SEND;
1246 } 1444 }
1247} 1445}
1248 1446
1249void 1447void
1448aio_ioctl (SV *fh, unsigned long request, SV8 *arg, SV *callback = &PL_sv_undef)
1449 ALIAS:
1450 aio_ioctl = EIO_IOCTL
1451 aio_fcntl = EIO_FCNTL
1452 PPCODE:
1453{
1454 int fd = s_fileno_croak (fh, 0);
1455 char *svptr;
1456
1457 if (SvPOK (arg) || !SvNIOK (arg))
1458 {
1459 STRLEN svlen;
1460 /* perl uses IOCPARM_LEN for fcntl, so we do, too */
1461#ifdef IOCPARM_LEN
1462 STRLEN need = IOCPARM_LEN (request);
1463#else
1464 STRLEN need = 256;
1465#endif
1466
1467 if (svlen < need)
1468 svptr = SvGROW (arg, need);
1469 }
1470 else
1471 svptr = (char *)SvIV (arg);
1472
1473 {
1474 dREQ;
1475
1476 req->type = ix;
1477 req->sv1 = newSVsv (fh);
1478 req->int1 = fd;
1479 req->int2 = (long)request;
1480 req->sv2 = SvREFCNT_inc (arg);
1481 req->ptr2 = svptr;
1482
1483 REQ_SEND;
1484 }
1485}
1486
1487void
1250aio_readlink (SV8 *pathname, SV *callback=&PL_sv_undef) 1488aio_readlink (SV8 *pathname, SV *callback = &PL_sv_undef)
1251 ALIAS: 1489 ALIAS:
1252 aio_readlink = EIO_READLINK 1490 aio_readlink = EIO_READLINK
1253 aio_realpath = EIO_REALPATH 1491 aio_realpath = EIO_REALPATH
1254 PPCODE: 1492 PPCODE:
1255{ 1493{
… …
1260 1498
1261 REQ_SEND; 1499 REQ_SEND;
1262} 1500}
1263 1501
1264void 1502void
1265aio_sendfile (SV *out_fh, SV *in_fh, off_t in_offset, size_t length, SV *callback=&PL_sv_undef) 1503aio_sendfile (SV *out_fh, SV *in_fh, off_t in_offset, size_t length, SV *callback = &PL_sv_undef)
1266 PPCODE: 1504 PPCODE:
1267{ 1505{
1268 int ifd = s_fileno_croak (in_fh , 0); 1506 int ifd = s_fileno_croak (in_fh , 0);
1269 int ofd = s_fileno_croak (out_fh, 1); 1507 int ofd = s_fileno_croak (out_fh, 1);
1270 dREQ; 1508 dREQ;
1271 1509
1272 req->type = EIO_SENDFILE; 1510 req->type = EIO_SENDFILE;
1273 req->sv1 = newSVsv (out_fh); 1511 req->sv1 = newSVsv (out_fh);
1274 req->int1 = ofd; 1512 req->int1 = ofd;
… …
1279 1517
1280 REQ_SEND; 1518 REQ_SEND;
1281} 1519}
1282 1520
1283void 1521void
1284aio_readahead (SV *fh, off_t offset, size_t length, SV *callback=&PL_sv_undef) 1522aio_readahead (SV *fh, off_t offset, size_t length, SV *callback = &PL_sv_undef)
1285 PPCODE: 1523 PPCODE:
1286{ 1524{
1287 int fd = s_fileno_croak (fh, 0); 1525 int fd = s_fileno_croak (fh, 0);
1288 dREQ; 1526 dREQ;
1289 1527
1290 req->type = EIO_READAHEAD; 1528 req->type = EIO_READAHEAD;
1291 req->sv1 = newSVsv (fh); 1529 req->sv1 = newSVsv (fh);
1292 req->int1 = fd; 1530 req->int1 = fd;
… …
1295 1533
1296 REQ_SEND; 1534 REQ_SEND;
1297} 1535}
1298 1536
1299void 1537void
1300aio_stat (SV8 *fh_or_path, SV *callback=&PL_sv_undef) 1538aio_stat (SV8 *fh_or_path, SV *callback = &PL_sv_undef)
1301 ALIAS: 1539 ALIAS:
1302 aio_stat = EIO_STAT 1540 aio_stat = EIO_STAT
1303 aio_lstat = EIO_LSTAT 1541 aio_lstat = EIO_LSTAT
1304 aio_statvfs = EIO_STATVFS 1542 aio_statvfs = EIO_STATVFS
1305 PPCODE: 1543 PPCODE:
… …
1314UV 1552UV
1315major (UV dev) 1553major (UV dev)
1316 ALIAS: 1554 ALIAS:
1317 minor = 1 1555 minor = 1
1318 CODE: 1556 CODE:
1319 RETVAL = ix ? major (dev) : minor (dev); 1557 RETVAL = ix ? minor (dev) : major (dev);
1320 OUTPUT: 1558 OUTPUT:
1321 RETVAL 1559 RETVAL
1322 1560
1323UV 1561UV
1324makedev (UV maj, UV min) 1562makedev (UV maj, UV min)
… …
1326 RETVAL = makedev (maj, min); 1564 RETVAL = makedev (maj, min);
1327 OUTPUT: 1565 OUTPUT:
1328 RETVAL 1566 RETVAL
1329 1567
1330void 1568void
1331aio_utime (SV8 *fh_or_path, SV *atime, SV *mtime, SV *callback=&PL_sv_undef) 1569aio_utime (SV8 *fh_or_path, SV *atime, SV *mtime, SV *callback = &PL_sv_undef)
1332 PPCODE: 1570 PPCODE:
1333{ 1571{
1334 dREQ; 1572 dREQ;
1335 1573
1336 req->nv1 = SvOK (atime) ? SvNV (atime) : -1.; 1574 req->nv1 = SvOK (atime) ? SvNV (atime) : -1.;
… …
1339 1577
1340 REQ_SEND; 1578 REQ_SEND;
1341} 1579}
1342 1580
1343void 1581void
1344aio_truncate (SV8 *fh_or_path, SV *offset, SV *callback=&PL_sv_undef) 1582aio_truncate (SV8 *fh_or_path, SV *offset, SV *callback = &PL_sv_undef)
1345 PPCODE: 1583 PPCODE:
1346{ 1584{
1347 dREQ; 1585 dREQ;
1348 1586
1349 req->offs = SvOK (offset) ? SvVAL64 (offset) : -1; 1587 req->offs = SvOK (offset) ? SvVAL64 (offset) : -1;
… …
1351 1589
1352 REQ_SEND; 1590 REQ_SEND;
1353} 1591}
1354 1592
1355void 1593void
1356aio_chmod (SV8 *fh_or_path, int mode, SV *callback=&PL_sv_undef) 1594aio_chmod (SV8 *fh_or_path, int mode, SV *callback = &PL_sv_undef)
1357 PPCODE: 1595 PPCODE:
1358{ 1596{
1359 dREQ; 1597 dREQ;
1360 1598
1361 req->int2 = mode; 1599 req->int2 = mode;
… …
1363 1601
1364 REQ_SEND; 1602 REQ_SEND;
1365} 1603}
1366 1604
1367void 1605void
1368aio_chown (SV8 *fh_or_path, SV *uid, SV *gid, SV *callback=&PL_sv_undef) 1606aio_chown (SV8 *fh_or_path, SV *uid, SV *gid, SV *callback = &PL_sv_undef)
1369 PPCODE: 1607 PPCODE:
1370{ 1608{
1371 dREQ; 1609 dREQ;
1372 1610
1373 req->int2 = SvOK (uid) ? SvIV (uid) : -1; 1611 req->int2 = SvOK (uid) ? SvIV (uid) : -1;
… …
1376 1614
1377 REQ_SEND; 1615 REQ_SEND;
1378} 1616}
1379 1617
1380void 1618void
1381aio_readdirx (SV8 *pathname, IV flags, SV *callback=&PL_sv_undef) 1619aio_readdirx (SV8 *pathname, IV flags, SV *callback = &PL_sv_undef)
1382 PPCODE: 1620 PPCODE:
1383{ 1621{
1384 dREQ; 1622 dREQ;
1385 1623
1386 req->type = EIO_READDIR; 1624 req->type = EIO_READDIR;
… …
1393 1631
1394 REQ_SEND; 1632 REQ_SEND;
1395} 1633}
1396 1634
1397void 1635void
1398aio_mkdir (SV8 *pathname, int mode, SV *callback=&PL_sv_undef) 1636aio_mkdir (SV8 *pathname, int mode, SV *callback = &PL_sv_undef)
1399 PPCODE: 1637 PPCODE:
1400{ 1638{
1401 dREQ; 1639 dREQ;
1402 1640
1403 req->type = EIO_MKDIR; 1641 req->type = EIO_MKDIR;
… …
1406 1644
1407 REQ_SEND; 1645 REQ_SEND;
1408} 1646}
1409 1647
1410void 1648void
1411aio_unlink (SV8 *pathname, SV *callback=&PL_sv_undef) 1649aio_unlink (SV8 *pathname, SV *callback = &PL_sv_undef)
1412 ALIAS: 1650 ALIAS:
1413 aio_unlink = EIO_UNLINK 1651 aio_unlink = EIO_UNLINK
1414 aio_rmdir = EIO_RMDIR 1652 aio_rmdir = EIO_RMDIR
1415 aio_readdir = EIO_READDIR 1653 aio_readdir = EIO_READDIR
1416 PPCODE: 1654 PPCODE:
… …
1422 1660
1423 REQ_SEND; 1661 REQ_SEND;
1424} 1662}
1425 1663
1426void 1664void
1427aio_link (SV8 *oldpath, SV8 *newpath, SV *callback=&PL_sv_undef) 1665aio_link (SV8 *oldpath, SV8 *newpath, SV *callback = &PL_sv_undef)
1428 ALIAS: 1666 ALIAS:
1429 aio_link = EIO_LINK 1667 aio_link = EIO_LINK
1430 aio_symlink = EIO_SYMLINK 1668 aio_symlink = EIO_SYMLINK
1431 aio_rename = EIO_RENAME 1669 aio_rename = EIO_RENAME
1432 PPCODE: 1670 PPCODE:
… …
1441 1679
1442 REQ_SEND; 1680 REQ_SEND;
1443} 1681}
1444 1682
1445void 1683void
1684aio_rename2 (SV8 *oldpath, SV8 *newpath, int flags = 0, SV *callback = &PL_sv_undef)
1685 PPCODE:
1686{
1687 eio_wd wd2 = 0;
1688 dREQ;
1689
1690 req->type = EIO_RENAME;
1691 req_set_path1 (req, oldpath);
1692 req_set_path (req, newpath, &req->sv2, &req->sv4, &wd2, &req->ptr2);
1693 req->int2 = flags;
1694 req->int3 = (long)wd2;
1695
1696 REQ_SEND;
1697}
1698
1699void
1446aio_mknod (SV8 *pathname, int mode, UV dev, SV *callback=&PL_sv_undef) 1700aio_mknod (SV8 *pathname, int mode, UV dev, SV *callback = &PL_sv_undef)
1447 PPCODE: 1701 PPCODE:
1448{ 1702{
1449 dREQ; 1703 dREQ;
1450 1704
1451 req->type = EIO_MKNOD; 1705 req->type = EIO_MKNOD;
… …
1455 1709
1456 REQ_SEND; 1710 REQ_SEND;
1457} 1711}
1458 1712
1459void 1713void
1460aio_mtouch (SV8 *data, IV offset = 0, SV *length = &PL_sv_undef, int flags = 0, SV *callback=&PL_sv_undef) 1714aio_mtouch (SV8 *data, IV offset = 0, SV *length = &PL_sv_undef, int flags = -1, SV *callback = &PL_sv_undef)
1461 ALIAS: 1715 ALIAS:
1462 aio_mtouch = EIO_MTOUCH 1716 aio_mtouch = EIO_MTOUCH
1463 aio_msync = EIO_MSYNC 1717 aio_msync = EIO_MSYNC
1464 PPCODE: 1718 PPCODE:
1465{ 1719{
1466 STRLEN svlen; 1720 STRLEN svlen;
1467 char *svptr = SvPVbyte (data, svlen); 1721 char *svptr = SvPVbyte (data, svlen);
1468 UV len = SvUV (length); 1722 UV len = SvUV (length);
1723
1724 if (flags < 0)
1725 flags = ix == EIO_MSYNC ? EIO_MS_SYNC : 0;
1469 1726
1470 if (offset < 0) 1727 if (offset < 0)
1471 offset += svlen; 1728 offset += svlen;
1472 1729
1473 if (offset < 0 || offset > svlen) 1730 if (offset < 0 || offset > svlen)
… …
1488 REQ_SEND; 1745 REQ_SEND;
1489 } 1746 }
1490} 1747}
1491 1748
1492void 1749void
1493aio_mlock (SV8 *data, IV offset = 0, SV *length = &PL_sv_undef, SV *callback=&PL_sv_undef) 1750aio_mlock (SV8 *data, IV offset = 0, SV *length = &PL_sv_undef, SV *callback = &PL_sv_undef)
1494 PPCODE: 1751 PPCODE:
1495{ 1752{
1496 STRLEN svlen; 1753 STRLEN svlen;
1497 char *svptr = SvPVbyte (data, svlen); 1754 char *svptr = SvPVbyte (data, svlen);
1498 UV len = SvUV (length); 1755 UV len = SvUV (length);
… …
1517 REQ_SEND; 1774 REQ_SEND;
1518 } 1775 }
1519} 1776}
1520 1777
1521void 1778void
1522aio_mlockall (IV flags, SV *callback=&PL_sv_undef) 1779aio_mlockall (IV flags, SV *callback = &PL_sv_undef)
1523 PPCODE: 1780 PPCODE:
1524{ 1781{
1525 dREQ; 1782 dREQ;
1526 1783
1527 req->type = EIO_MLOCKALL; 1784 req->type = EIO_MLOCKALL;
… …
1529 1786
1530 REQ_SEND; 1787 REQ_SEND;
1531} 1788}
1532 1789
1533void 1790void
1534aio_fiemap (SV *fh, off_t start, SV *length, U32 flags, SV *count, SV *callback=&PL_sv_undef) 1791aio_fiemap (SV *fh, off_t start, SV *length, U32 flags, SV *count, SV *callback = &PL_sv_undef)
1535 PPCODE: 1792 PPCODE:
1536{ 1793{
1537 int fd = s_fileno_croak (fh, 0); 1794 int fd = s_fileno_croak (fh, 0);
1538 dREQ; 1795 dREQ;
1539 1796
… …
1552 1809
1553 REQ_SEND; 1810 REQ_SEND;
1554} 1811}
1555 1812
1556void 1813void
1814aio_slurp (SV *pathname, off_t offset, UV length, SV8 *data, SV *callback = &PL_sv_undef)
1815 PPCODE:
1816{
1817 char *svptr = 0;
1818
1819 sv_clear_foreign (data);
1820
1821 if (length) /* known length, directly read into scalar */
1822 {
1823 if (!SvPOK (data) || SvLEN (data) >= SvCUR (data))
1824 svptr = sv_grow (data, length);
1825 else if (SvCUR (data) < length)
1826 croak ("length outside of scalar, and cannot grow");
1827 else
1828 svptr = SvPVbyte_nolen (data);
1829 }
1830
1831 {
1832 dREQ;
1833
1834 req->type = EIO_SLURP;
1835 req_set_path1 (req, pathname);
1836 req->offs = offset;
1837 req->size = length;
1838 req->sv2 = SvREFCNT_inc (data);
1839 req->ptr2 = svptr;
1840
1841 if (!SvREADONLY (data))
1842 {
1843 SvREADONLY_on (data);
1844 req->flags |= FLAG_SV2_RO_OFF;
1845 }
1846
1847 REQ_SEND;
1848 }
1849}
1850
1851void
1557aio_busy (double delay, SV *callback=&PL_sv_undef) 1852aio_busy (double delay, SV *callback = &PL_sv_undef)
1558 PPCODE: 1853 PPCODE:
1559{ 1854{
1560 dREQ; 1855 dREQ;
1561 1856
1562 req->type = EIO_BUSY; 1857 req->type = EIO_BUSY;
… …
1564 1859
1565 REQ_SEND; 1860 REQ_SEND;
1566} 1861}
1567 1862
1568void 1863void
1569aio_group (SV *callback=&PL_sv_undef) 1864aio_group (SV *callback = &PL_sv_undef)
1570 PPCODE: 1865 PPCODE:
1571{ 1866{
1572 dREQ; 1867 dREQ;
1573 1868
1574 req->type = EIO_GROUP; 1869 req->type = EIO_GROUP;
1575 1870
1871 PUTBACK;
1576 req_submit (req); 1872 req_submit (req);
1873 SPAGAIN;
1874
1577 XPUSHs (req_sv (req, aio_grp_stash)); 1875 XPUSHs (req_sv (req, aio_grp_stash));
1578} 1876}
1579 1877
1580void 1878void
1581aio_nop (SV *callback=&PL_sv_undef) 1879aio_nop (SV *callback = &PL_sv_undef)
1582 ALIAS: 1880 ALIAS:
1583 aio_nop = EIO_NOP 1881 aio_nop = EIO_NOP
1584 aio_sync = EIO_SYNC 1882 aio_sync = EIO_SYNC
1585 PPCODE: 1883 PPCODE:
1586{ 1884{
… …
1590 1888
1591 REQ_SEND; 1889 REQ_SEND;
1592} 1890}
1593 1891
1594int 1892int
1595aioreq_pri (int pri = 0) 1893aioreq_pri (int pri = NO_INIT)
1596 CODE: 1894 CODE:
1597 RETVAL = next_pri; 1895 RETVAL = next_pri;
1598 if (items > 0) 1896 if (items > 0)
1599 { 1897 {
1600 if (pri < EIO_PRI_MIN) pri = EIO_PRI_MIN; 1898 if (pri < EIO_PRI_MIN) pri = EIO_PRI_MIN;
… …
1690 RETVAL = eio_sendfile_sync (ofh, ifh, offset, count); 1988 RETVAL = eio_sendfile_sync (ofh, ifh, offset, count);
1691 OUTPUT: 1989 OUTPUT:
1692 RETVAL 1990 RETVAL
1693 1991
1694void 1992void
1695mmap (SV *scalar, size_t length, int prot, int flags, SV *fh = &PL_sv_undef, off_t offset = 0) 1993mmap (SV *scalar, STRLEN length, int prot, int flags, SV *fh = &PL_sv_undef, off_t offset = 0)
1696 PPCODE: 1994 PPCODE:
1697 sv_unmagic (scalar, MMAP_MAGIC); 1995 sv_clear_foreign (scalar);
1698{ 1996{
1699 int fd = SvOK (fh) ? s_fileno_croak (fh, flags & PROT_WRITE) : -1; 1997 int fd = SvOK (fh) ? s_fileno_croak (fh, flags & PROT_WRITE) : -1;
1700 void *addr = (void *)mmap (0, length, prot, flags, fd, offset); 1998 void *addr = (void *)mmap (0, length, prot, flags, fd, offset);
1701 if (addr == (void *)-1) 1999 if (addr == (void *)-1)
1702 XSRETURN_NO; 2000 XSRETURN_NO;
1703 2001
1704 sv_force_normal (scalar); 2002 sv_set_foreign (scalar, &mmap_vtbl, addr, length);
1705
1706 /* we store the length in mg_obj, as namlen is I32 :/ */
1707 sv_magicext (scalar, 0, MMAP_MAGIC, &mmap_vtbl, (char *)addr, 0)
1708 ->mg_obj = (SV *)length;
1709
1710 SvUPGRADE (scalar, SVt_PV); /* nop... */
1711 2003
1712 if (!(prot & PROT_WRITE)) 2004 if (!(prot & PROT_WRITE))
1713 SvREADONLY_on (scalar); 2005 SvREADONLY_on (scalar);
1714 2006
1715 if (SvLEN (scalar))
1716 Safefree (SvPVX (scalar));
1717
1718 SvPVX (scalar) = (char *)addr;
1719 SvCUR_set (scalar, length);
1720 SvLEN_set (scalar, 0);
1721 SvPOK_only (scalar);
1722
1723 XSRETURN_YES; 2007 XSRETURN_YES;
1724} 2008}
1725 2009
1726void 2010void
1727munmap (SV *scalar) 2011munmap (SV *scalar)
1728 CODE: 2012 CODE:
1729 sv_unmagic (scalar, MMAP_MAGIC); 2013 sv_clear_foreign (scalar);
1730 2014
1731int 2015int
1732madvise (SV *scalar, off_t offset = 0, SV *length = &PL_sv_undef, IV advice_or_prot) 2016madvise (SV *scalar, STRLEN offset = 0, SV *length = &PL_sv_undef, IV advice_or_prot)
1733 ALIAS: 2017 ALIAS:
1734 mprotect = 1 2018 mprotect = 1
1735 CODE: 2019 CODE:
1736{ 2020{
1737 STRLEN svlen; 2021 STRLEN svlen;
1738 void *addr = SvPVbyte (scalar, svlen); 2022 void *addr = SvPVbyte (scalar, svlen);
1739 size_t len = SvUV (length); 2023 STRLEN len = SvUV (length);
1740 2024
1741 if (offset < 0) 2025 if (offset < 0)
1742 offset += svlen; 2026 offset += svlen;
1743 2027
1744 if (offset < 0 || offset > svlen) 2028 if (offset < 0 || offset > svlen)
… …
1758} 2042}
1759 OUTPUT: 2043 OUTPUT:
1760 RETVAL 2044 RETVAL
1761 2045
1762int 2046int
1763munlock (SV *scalar, off_t offset = 0, SV *length = &PL_sv_undef) 2047munlock (SV *scalar, STRLEN offset = 0, SV *length = &PL_sv_undef)
1764 CODE: 2048 CODE:
1765{ 2049{
1766 STRLEN svlen; 2050 STRLEN svlen;
1767 void *addr = SvPVbyte (scalar, svlen); 2051 void *addr = SvPVbyte (scalar, svlen);
1768 size_t len = SvUV (length); 2052 size_t len = SvUV (length);
1769 2053
1770 if (offset < 0) 2054 if (offset < 0)
1771 offset += svlen; 2055 offset += svlen;
1772 2056
… …
1824#else 2108#else
1825 RETVAL = EIO_ENOSYS (); 2109 RETVAL = EIO_ENOSYS ();
1826#endif 2110#endif
1827 OUTPUT: 2111 OUTPUT:
1828 RETVAL 2112 RETVAL
2113
2114int
2115pipesize (aio_rfd rfh, int new_size = -1)
2116 PROTOTYPE: $;$
2117 CODE:
2118#if defined(F_SETPIPE_SZ) && defined(F_GETPIPE_SZ)
2119 if (new_size >= 0)
2120 RETVAL = fcntl (rfh, F_SETPIPE_SZ, new_size);
2121 else
2122 RETVAL = fcntl (rfh, F_GETPIPE_SZ);
2123#else
2124 errno = ENOSYS;
2125 RETVAL = -1;
2126#endif
2127 OUTPUT:
2128 RETVAL
2129
2130void
2131pipe2 (int flags = 0)
2132 PROTOTYPE: ;$
2133 PPCODE:
2134{
2135 int fd[2];
2136 int res;
2137
2138 if (flags)
2139#if HAVE_PIPE2
2140 res = pipe2 (fd, flags);
2141#else
2142 res = (errno = ENOSYS, -1);
2143#endif
2144 else
2145 res = pipe (fd);
2146
2147 if (!res)
2148 {
2149 EXTEND (SP, 2);
2150 PUSHs (newmortalFH (fd[0], O_RDONLY));
2151 PUSHs (newmortalFH (fd[1], O_WRONLY));
2152 }
2153}
2154
2155UV
2156get_fdlimit ()
2157 CODE:
2158#if HAVE_RLIMITS
2159 struct rlimit rl;
2160 if (0 == getrlimit (RLIMIT_NOFILE, &rl))
2161 XSRETURN_UV (rl.rlim_cur == RLIM_INFINITY ? (UV)-1 : rl.rlim_cur);
2162#endif
2163 XSRETURN_UNDEF;
2164 OUTPUT:
2165 RETVAL
2166
2167void
2168min_fdlimit (UV limit = 0x7fffffffU)
2169 CODE:
2170{
2171#if HAVE_RLIMITS
2172 struct rlimit rl;
2173 rlim_t orig_rlim_max;
2174 UV bit;
2175
2176 if (0 != getrlimit (RLIMIT_NOFILE, &rl))
2177 goto fail;
2178
2179 if (rl.rlim_cur == RLIM_INFINITY)
2180 XSRETURN_YES;
2181
2182 orig_rlim_max = rl.rlim_max == RLIM_INFINITY ? ((rlim_t)0)-1 : rl.rlim_max;
2183
2184 if (rl.rlim_cur < limit)
2185 {
2186 rl.rlim_cur = limit;
2187
2188 if (rl.rlim_max < rl.rlim_cur && rl.rlim_max != RLIM_INFINITY)
2189 rl.rlim_max = rl.rlim_cur;
2190 }
2191
2192 if (0 == setrlimit (RLIMIT_NOFILE, &rl))
2193 XSRETURN_YES;
2194
2195 if (errno == EPERM)
2196 {
2197 /* setlimit failed with EPERM - maybe we can't raise the hardlimit, or maybe */
2198 /* our limit overflows a system-wide limit */
2199 /* try an adaptive algorithm, but do not lower the hardlimit */
2200 rl.rlim_max = 0;
2201 for (bit = 0x40000000U; bit; bit >>= 1)
2202 {
2203 rl.rlim_max |= bit;
2204 rl.rlim_cur = rl.rlim_max;
2205
2206 /* nevr decrease the hard limit */
2207 if (rl.rlim_max < orig_rlim_max)
2208 break;
2209
2210 if (0 != setrlimit (RLIMIT_NOFILE, &rl))
2211 rl.rlim_max &= ~bit; /* too high, remove bit again */
2212 }
2213
2214 /* now, raise the soft limit to the max permitted */
2215 if (0 == getrlimit (RLIMIT_NOFILE, &rl))
2216 {
2217 rl.rlim_cur = rl.rlim_max;
2218 if (0 == setrlimit (RLIMIT_NOFILE, &rl))
2219 errno = EPERM;
2220 }
2221 }
2222#endif
2223 fail:
2224 XSRETURN_UNDEF;
2225}
1829 2226
1830void _on_next_submit (SV *cb) 2227void _on_next_submit (SV *cb)
1831 CODE: 2228 CODE:
1832 SvREFCNT_dec (on_next_submit); 2229 SvREFCNT_dec (on_next_submit);
1833 on_next_submit = SvOK (cb) ? newSVsv (cb) : 0; 2230 on_next_submit = SvOK (cb) ? newSVsv (cb) : 0;
… …
1868cancel (aio_req_ornot req) 2265cancel (aio_req_ornot req)
1869 CODE: 2266 CODE:
1870 eio_cancel (req); 2267 eio_cancel (req);
1871 2268
1872void 2269void
1873cb (aio_req_ornot req, SV *callback=&PL_sv_undef) 2270cb (aio_req_ornot req, SV *callback = NO_INIT)
1874 PPCODE: 2271 PPCODE:
1875{ 2272{
1876 if (GIMME_V != G_VOID) 2273 if (GIMME_V != G_VOID)
1877 XPUSHs (req->callback ? sv_2mortal (newRV_inc (req->callback)) : &PL_sv_undef); 2274 XPUSHs (req->callback ? sv_2mortal (newRV_inc (req->callback)) : &PL_sv_undef);
1878 2275
1879 if (items > 1) 2276 if (items > 1)
1880 { 2277 {
1881 SV *cb_cv =get_cb (callback); 2278 SV *cb_cv = get_cb (callback);
1882 2279
1883 SvREFCNT_dec (req->callback); 2280 SvREFCNT_dec (req->callback);
1884 req->callback = SvREFCNT_inc (cb_cv); 2281 req->callback = SvREFCNT_inc (cb_cv);
1885 } 2282 }
1886} 2283}
… …
1943limit (aio_req grp, int limit) 2340limit (aio_req grp, int limit)
1944 CODE: 2341 CODE:
1945 eio_grp_limit (grp, limit); 2342 eio_grp_limit (grp, limit);
1946 2343
1947void 2344void
1948feed (aio_req grp, SV *callback=&PL_sv_undef) 2345feed (aio_req grp, SV *callback = &PL_sv_undef)
1949 CODE: 2346 CODE:
1950{ 2347{
1951 SvREFCNT_dec (grp->sv2); 2348 SvREFCNT_dec (grp->sv2);
1952 grp->sv2 = newSVsv (callback); 2349 grp->sv2 = newSVsv (callback);
1953 grp->feed = aio_grp_feed; 2350 grp->feed = aio_grp_feed;

Diff Legend

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