ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/IO-AIO/AIO.xs
Revision: 1.183
Committed: Tue Jul 5 09:24:11 2011 UTC (12 years, 10 months ago) by root
Branch: MAIN
Changes since 1.182: +5 -1 lines
Log Message: 
realpath

File Contents

# User Rev Content
1 root 1.115 #include "libeio/xthread.h"
2 root 1.63
3 root 1.19 #include <errno.h>
4    
5 root 1.15 #include "EXTERN.h"
6 root 1.1 #include "perl.h"
7     #include "XSUB.h"
8    
9 root 1.151 #include "schmorp.h"
10    
11 root 1.37 #include <stddef.h>
12 root 1.94 #include <stdlib.h>
13 root 1.41 #include <errno.h>
14 root 1.1 #include <sys/types.h>
15     #include <sys/stat.h>
16 root 1.159 #include <sys/statvfs.h>
17 root 1.37 #include <limits.h>
18 root 1.1 #include <fcntl.h>
19     #include <sched.h>
20 root 1.103
21 root 1.178 #if _POSIX_MEMLOCK || _POSIX_MEMLOCK_RANGE || _POSIX_MAPPED_FILES
22 root 1.161 # include <sys/mman.h>
23     #endif
24    
25 root 1.118 /* perl namespace pollution */
26     #undef VERSION
27    
28 root 1.103 #ifdef _WIN32
29    
30 root 1.115 # define EIO_STRUCT_DIRENT Direntry_t
31     # undef malloc
32     # undef free
33 root 1.103
34     // perl overrides all those nice win32 functions
35     # undef open
36     # undef read
37     # undef write
38 root 1.104 # undef send
39     # undef recv
40 root 1.103 # undef stat
41     # undef fstat
42     # define lstat stat
43     # undef truncate
44     # undef ftruncate
45     # undef open
46     # undef close
47     # undef unlink
48     # undef rmdir
49     # undef rename
50     # undef lseek
51    
52     # define chown(a,b,c) (errno = ENOSYS, -1)
53     # define fchown(a,b,c) (errno = ENOSYS, -1)
54     # define fchmod(a,b) (errno = ENOSYS, -1)
55     # define symlink(a,b) (errno = ENOSYS, -1)
56     # define readlink(a,b,c) (errno = ENOSYS, -1)
57     # define mknod(a,b,c) (errno = ENOSYS, -1)
58     # define truncate(a,b) (errno = ENOSYS, -1)
59     # define ftruncate(fd,o) chsize ((fd), (o))
60     # define fsync(fd) _commit (fd)
61     # define opendir(fd) (errno = ENOSYS, 0)
62     # define readdir(fd) (errno = ENOSYS, -1)
63     # define closedir(fd) (errno = ENOSYS, -1)
64     # define mkdir(a,b) mkdir (a)
65    
66     #else
67    
68     # include <sys/time.h>
69     # include <sys/select.h>
70     # include <unistd.h>
71     # include <utime.h>
72     # include <signal.h>
73 root 1.115 # define EIO_STRUCT_DIRENT struct dirent
74 root 1.103
75     #endif
76 root 1.1
77 root 1.125 /* perl stupidly overrides readdir and maybe others */
78     /* with thread-unsafe versions, imagine that :( */
79     #undef readdir
80     #undef opendir
81     #undef closedir
82    
83 root 1.115 #define EIO_STRUCT_STAT Stat_t
84 root 1.65
85 root 1.101 /* use NV for 32 bit perls as it allows larger offsets */
86     #if IVSIZE >= 8
87 root 1.148 # define VAL64 IV
88 root 1.101 # define SvVAL64 SvIV
89 root 1.148 # define newSVval64 newSViv
90 root 1.101 #else
91 root 1.148 # define VAL64 NV
92 root 1.101 # define SvVAL64 SvNV
93 root 1.148 # define newSVval64 newSVnv
94 root 1.101 #endif
95    
96 root 1.127 /*****************************************************************************/
97    
98     #if __GNUC__ >= 3
99     # define expect(expr,value) __builtin_expect ((expr),(value))
100     #else
101     # define expect(expr,value) (expr)
102     #endif
103    
104     #define expect_false(expr) expect ((expr) != 0, 0)
105     #define expect_true(expr) expect ((expr) != 0, 1)
106    
107     /*****************************************************************************/
108    
109 root 1.90 typedef SV SV8; /* byte-sv, used for argument-checking */
110 root 1.148 typedef int aio_rfd; /* read file desriptor */
111     typedef int aio_wfd; /* write file descriptor */
112 root 1.90
113 root 1.156 static HV *aio_stash, *aio_req_stash, *aio_grp_stash;
114 root 1.43
115 root 1.121 #define EIO_REQ_MEMBERS \
116 root 1.115 SV *callback; \
117     SV *sv1, *sv2; \
118     STRLEN stroffset; \
119 root 1.121 SV *self;
120 root 1.115
121 root 1.122 #define EIO_NO_WRAPPERS 1
122    
123 root 1.176 #include "libeio/config.h"
124 root 1.115 #include "libeio/eio.h"
125    
126 root 1.182 /* Linux/others */
127     #ifndef O_ASYNC
128     # define O_ASYNC 0
129     #endif
130     #ifndef O_DIRECT
131     # define O_DIRECT 0
132     #endif
133     #ifndef O_NOATIME
134     # define O_NOATIME 0
135     #endif
136    
137     /* POSIX */
138     #ifndef O_CLOEXEC
139     # define O_CLOEXEC 0
140     #endif
141     #ifndef O_NOFOLLOW
142     # define O_NOFOLLOW 0
143     #endif
144     #ifndef O_NOCTTY
145     # define O_NOCTTY 0
146     #endif
147     #ifndef O_NONBLOCK
148     # define O_NONBLOCK 0
149     #endif
150     #ifndef O_EXEC
151     # define O_EXEC 0
152     #endif
153     #ifndef O_SEARCH
154     # define O_SEARCH 0
155     #endif
156     #ifndef O_DIRECTORY
157     # define O_DIRECTORY 0
158     #endif
159     #ifndef O_DSYNC
160     # define O_DSYNC 0
161     #endif
162     #ifndef O_RSYNC
163     # define O_RSYNC 0
164     #endif
165     #ifndef O_SYNC
166     # define O_SYNC 0
167     #endif
168     #ifndef O_TTY_INIT
169     # define O_TTY_INIT 0
170     #endif
171    
172 root 1.148 #ifndef POSIX_FADV_NORMAL
173     # define POSIX_FADV_NORMAL 0
174     #endif
175     #ifndef POSIX_FADV_SEQUENTIAL
176     # define POSIX_FADV_SEQUENTIAL 0
177     #endif
178     #ifndef POSIX_FADV_RANDOM
179     # define POSIX_FADV_RANDOM 0
180     #endif
181     #ifndef POSIX_FADV_NOREUSE
182     # define POSIX_FADV_NOREUSE 0
183     #endif
184     #ifndef POSIX_FADV_WILLNEED
185     # define POSIX_FADV_WILLNEED 0
186     #endif
187     #ifndef POSIX_FADV_DONTNEED
188     # define POSIX_FADV_DONTNEED 0
189     #endif
190    
191 root 1.175 #if !HAVE_POSIX_FADVISE
192 root 1.170 # define posix_fadvise(a,b,c,d) errno = ENOSYS /* also return ENOSYS */
193     #endif
194    
195 root 1.169 #ifndef POSIX_MADV_NORMAL
196     # define POSIX_MADV_NORMAL 0
197     #endif
198     #ifndef POSIX_MADV_SEQUENTIAL
199     # define POSIX_MADV_SEQUENTIAL 0
200     #endif
201     #ifndef POSIX_MADV_RANDOM
202     # define POSIX_MADV_RANDOM 0
203     #endif
204     #ifndef POSIX_MADV_WILLNEED
205     # define POSIX_MADV_WILLNEED 0
206     #endif
207     #ifndef POSIX_MADV_DONTNEED
208     # define POSIX_MADV_DONTNEED 0
209     #endif
210    
211 root 1.175 #if !HAVE_POSIX_MADVISE
212 root 1.170 # define posix_madvise(a,b,c) errno = ENOSYS /* also return ENOSYS */
213     #endif
214    
215 root 1.171 #ifndef PROT_NONE
216     # define PROT_NONE 0
217     #endif
218     #ifndef PROT_READ
219     # define PROT_READ 0
220     #endif
221     #ifndef PROT_WRITE
222     # define PROT_READ 0
223     #endif
224     #ifndef PROT_EXEC
225     # define PROT_EXEC 0
226     #endif
227    
228 root 1.159 #ifndef ST_NODEV
229     # define ST_NODEV 0
230     #endif
231     #ifndef ST_NOEXEC
232     # define ST_NOEXEC 0
233     #endif
234     #ifndef ST_SYNCHRONOUS
235     # define ST_SYNCHRONOUS 0
236     #endif
237     #ifndef ST_MANDLOCK
238     # define ST_MANDLOCK 0
239     #endif
240     #ifndef ST_WRITE
241     # define ST_WRITE 0
242     #endif
243     #ifndef ST_APPEND
244     # define ST_APPEND 0
245     #endif
246     #ifndef ST_IMMUTABLE
247     # define ST_IMMUTABLE 0
248     #endif
249     #ifndef ST_NOATIME
250     # define ST_NOATIME 0
251     #endif
252     #ifndef ST_NODIRATIME
253     # define ST_NODIRATIME 0
254     #endif
255     #ifndef ST_RELATIME
256     # define ST_RELATIME 0
257     #endif
258    
259 root 1.180 #ifndef S_IFIFO
260     # define S_IFIFO 0
261     #endif
262     #ifndef S_IFCHR
263     # define S_IFCHR 0
264     #endif
265     #ifndef S_IFBLK
266     # define S_IFBLK 0
267     #endif
268     #ifndef S_IFLNK
269     # define S_IFLNK 0
270     #endif
271     #ifndef S_IFREG
272     # define S_IFREG 0
273     #endif
274     #ifndef S_IFDIR
275     # define S_IFDIR 0
276     #endif
277     #ifndef S_IFWHT
278     # define S_IFWHT 0
279     #endif
280     #ifndef S_IFSOCK
281     # define S_IFSOCK 0
282     #endif
283    
284 root 1.162 #ifndef MAP_ANONYMOUS
285     # ifdef MAP_ANON
286     # define MAP_ANONYMOUS MAP_ANON
287     # else
288     # define MAP_ANONYMOUS MAP_FIXED /* and hope this fails */
289     # endif
290     #endif
291     #ifndef MAP_HUGETLB
292     # define MAP_HUGETLB 0
293     #endif
294     #ifndef MAP_LOCKED
295     # define MAP_LOCKED 0
296     #endif
297     #ifndef MAP_NORESERVE
298     # define MAP_NORESERVE 0
299     #endif
300     #ifndef MAP_POPULATE
301     # define MAP_POPULATE 0
302     #endif
303     #ifndef MAP_NONBLOCK
304     # define MAP_NONBLOCK 0
305     #endif
306    
307 root 1.180 #ifndef makedev
308     # define makedev(maj,min) (((maj) << 8) | (min))
309     #endif
310     #ifndef major
311     # define major(dev) ((dev) >> 8)
312     #endif
313     #ifndef minor
314     # define minor(dev) ((dev) & 0xff)
315     #endif
316    
317 root 1.162 #ifndef PAGESIZE
318     # define PAGESIZE sysconf (_SC_PAGESIZE)
319     #endif
320    
321 root 1.115 static int req_invoke (eio_req *req);
322     #define EIO_FINISH(req) req_invoke (req)
323     static void req_destroy (eio_req *grp);
324     #define EIO_DESTROY(req) req_destroy (req)
325 root 1.1
326 root 1.58 enum {
327 root 1.115 FLAG_SV2_RO_OFF = 0x40, /* data was set readonly */
328 root 1.58 };
329    
330 root 1.115 #include "libeio/eio.c"
331 root 1.1
332 root 1.115 typedef eio_req *aio_req;
333     typedef eio_req *aio_req_ornot;
334 root 1.60
335 root 1.117 static SV *on_next_submit;
336 root 1.121 static int next_pri = EIO_PRI_DEFAULT;
337 root 1.117 static int max_outstanding;
338 root 1.94
339 root 1.153 static s_epipe respipe;
340 root 1.80
341 root 1.115 static void req_destroy (aio_req req);
342     static void req_cancel (aio_req req);
343 root 1.80
344 root 1.115 static void want_poll (void)
345 root 1.80 {
346 root 1.115 /* write a dummy byte to the pipe so fh becomes ready */
347 root 1.153 s_epipe_signal (&respipe);
348 root 1.67 }
349    
350 root 1.115 static void done_poll (void)
351 root 1.67 {
352 root 1.115 /* read any signals sent by the worker threads */
353 root 1.153 s_epipe_drain (&respipe);
354 root 1.67 }
355 root 1.1
356 root 1.43 /* must be called at most once */
357 root 1.156 static SV *req_sv (aio_req req, HV *stash)
358 root 1.43 {
359 root 1.49 if (!req->self)
360     {
361     req->self = (SV *)newHV ();
362     sv_magic (req->self, 0, PERL_MAGIC_ext, (char *)req, 0);
363     }
364 root 1.43
365 root 1.156 return sv_2mortal (sv_bless (newRV_inc (req->self), stash));
366 root 1.43 }
367    
368 root 1.45 static aio_req SvAIO_REQ (SV *sv)
369 root 1.26 {
370 root 1.53 MAGIC *mg;
371    
372 root 1.156 if (!SvROK (sv)
373     || (SvSTASH (SvRV (sv)) != aio_grp_stash
374     && SvSTASH (SvRV (sv)) != aio_req_stash
375     && !sv_derived_from (sv, "IO::AIO::REQ")))
376     croak ("object of class IO::AIO::REQ expected");
377 root 1.43
378 root 1.53 mg = mg_find (SvRV (sv), PERL_MAGIC_ext);
379 root 1.43
380     return mg ? (aio_req)mg->mg_ptr : 0;
381     }
382    
383 root 1.49 static void aio_grp_feed (aio_req grp)
384     {
385 root 1.115 if (grp->sv2 && SvOK (grp->sv2))
386 root 1.49 {
387 root 1.115 dSP;
388 root 1.49
389 root 1.115 ENTER;
390     SAVETMPS;
391     PUSHMARK (SP);
392 root 1.156 XPUSHs (req_sv (grp, aio_grp_stash));
393 root 1.115 PUTBACK;
394     call_sv (grp->sv2, G_VOID | G_EVAL | G_KEEPERR);
395     SPAGAIN;
396     FREETMPS;
397     LEAVE;
398 root 1.50 }
399     }
400    
401 root 1.117 static void req_submit (eio_req *req)
402     {
403     eio_submit (req);
404    
405 root 1.127 if (expect_false (on_next_submit))
406 root 1.117 {
407     dSP;
408     SV *cb = sv_2mortal (on_next_submit);
409    
410     on_next_submit = 0;
411    
412     PUSHMARK (SP);
413     PUTBACK;
414     call_sv (cb, G_DISCARD | G_EVAL);
415     }
416     }
417    
418 root 1.115 static int req_invoke (eio_req *req)
419 root 1.45 {
420 root 1.100 if (req->flags & FLAG_SV2_RO_OFF)
421     SvREADONLY_off (req->sv2);
422 root 1.86
423 root 1.128 if (!EIO_CANCELLED (req) && req->callback)
424 root 1.67 {
425 root 1.166 dSP;
426 root 1.165 static SV *sv_result_cache; /* caches the result integer SV */
427     SV *sv_result;
428    
429 root 1.67 ENTER;
430     SAVETMPS;
431     PUSHMARK (SP);
432     EXTEND (SP, 1);
433 root 1.45
434 root 1.165 /* do not recreate the result IV from scratch each time */
435     if (expect_true (sv_result_cache))
436     {
437     sv_result = sv_result_cache; sv_result_cache = 0;
438     SvIV_set (sv_result, req->result);
439 root 1.177 SvIOK_only (sv_result);
440 root 1.165 }
441     else
442     {
443     sv_result = newSViv (req->result);
444     SvREADONLY_on (sv_result);
445     }
446    
447 root 1.67 switch (req->type)
448 root 1.45 {
449 root 1.115 case EIO_READDIR:
450 root 1.45 {
451 root 1.67 SV *rv = &PL_sv_undef;
452 root 1.45
453 root 1.67 if (req->result >= 0)
454 root 1.45 {
455 root 1.71 int i;
456 root 1.147 char *names = (char *)req->ptr2;
457     eio_dirent *ent = (eio_dirent *)req->ptr1; /* might be 0 */
458 root 1.67 AV *av = newAV ();
459    
460 root 1.71 av_extend (av, req->result - 1);
461    
462     for (i = 0; i < req->result; ++i)
463 root 1.67 {
464 root 1.141 if (req->int1 & EIO_READDIR_DENTS)
465     {
466 root 1.147 SV *namesv = newSVpvn (names + ent->nameofs, ent->namelen);
467 root 1.141
468     if (req->int1 & EIO_READDIR_CUSTOM2)
469     {
470     static SV *sv_type [EIO_DT_MAX + 1]; /* type sv cache */
471     AV *avent = newAV ();
472    
473     av_extend (avent, 2);
474    
475     if (!sv_type [ent->type])
476     {
477     sv_type [ent->type] = newSViv (ent->type);
478     SvREADONLY_on (sv_type [ent->type]);
479     }
480    
481     av_store (avent, 0, namesv);
482 root 1.143 av_store (avent, 1, SvREFCNT_inc (sv_type [ent->type]));
483     av_store (avent, 2, IVSIZE >= 8 ? newSVuv (ent->inode) : newSVnv (ent->inode));
484 root 1.141
485     av_store (av, i, newRV_noinc ((SV *)avent));
486     }
487     else
488     av_store (av, i, namesv);
489    
490 root 1.147 ++ent;
491 root 1.141 }
492     else
493     {
494 root 1.147 SV *name = newSVpv (names, 0);
495 root 1.141 av_store (av, i, name);
496 root 1.147 names += SvCUR (name) + 1;
497 root 1.141 }
498 root 1.67 }
499 root 1.45
500 root 1.67 rv = sv_2mortal (newRV_noinc ((SV *)av));
501 root 1.45 }
502    
503 root 1.67 PUSHs (rv);
504 root 1.141
505     if (req->int1 & EIO_READDIR_CUSTOM1)
506     XPUSHs (sv_2mortal (newSViv (req->int1 & ~(EIO_READDIR_CUSTOM1 | EIO_READDIR_CUSTOM2))));
507 root 1.45 }
508 root 1.67 break;
509 root 1.45
510 root 1.115 case EIO_OPEN:
511 root 1.67 {
512     /* convert fd to fh */
513 root 1.107 SV *fh = &PL_sv_undef;
514    
515     if (req->result >= 0)
516     {
517     GV *gv = (GV *)sv_newmortal ();
518     int flags = req->int1 & (O_RDONLY | O_WRONLY | O_RDWR);
519     char sym [64];
520     int symlen;
521    
522 root 1.146 symlen = snprintf (sym, sizeof (sym), "fd#%d", (int)req->result);
523 root 1.156 gv_init (gv, aio_stash, sym, symlen, 0);
524 root 1.107
525     symlen = snprintf (
526     sym,
527     sizeof (sym),
528 root 1.146 "%s&=%d",
529 root 1.107 flags == O_RDONLY ? "<" : flags == O_WRONLY ? ">" : "+<",
530 root 1.146 (int)req->result
531 root 1.107 );
532 root 1.45
533 root 1.107 if (do_open (gv, sym, symlen, 0, 0, 0, 0))
534 root 1.108 fh = (SV *)gv;
535 root 1.107 }
536 root 1.45
537 root 1.109 PUSHs (fh);
538 root 1.67 }
539     break;
540 root 1.45
541 root 1.159 case EIO_STATVFS:
542     case EIO_FSTATVFS:
543     {
544     SV *rv = &PL_sv_undef;
545    
546     if (req->result >= 0)
547     {
548     EIO_STRUCT_STATVFS *f = EIO_STATVFS_BUF (req);
549     HV *hv = newHV ();
550    
551 root 1.160 rv = sv_2mortal (newRV_noinc ((SV *)hv));
552 root 1.159
553     hv_store (hv, "bsize" , sizeof ("bsize" ) - 1, newSVval64 (f->f_bsize ), 0);
554     hv_store (hv, "frsize" , sizeof ("frsize" ) - 1, newSVval64 (f->f_frsize ), 0);
555     hv_store (hv, "blocks" , sizeof ("blocks" ) - 1, newSVval64 (f->f_blocks ), 0);
556     hv_store (hv, "bfree" , sizeof ("bfree" ) - 1, newSVval64 (f->f_bfree ), 0);
557     hv_store (hv, "bavail" , sizeof ("bavail" ) - 1, newSVval64 (f->f_bavail ), 0);
558     hv_store (hv, "files" , sizeof ("files" ) - 1, newSVval64 (f->f_files ), 0);
559     hv_store (hv, "ffree" , sizeof ("ffree" ) - 1, newSVval64 (f->f_ffree ), 0);
560     hv_store (hv, "favail" , sizeof ("favail" ) - 1, newSVval64 (f->f_favail ), 0);
561     hv_store (hv, "fsid" , sizeof ("fsid" ) - 1, newSVval64 (f->f_fsid ), 0);
562     hv_store (hv, "flag" , sizeof ("flag" ) - 1, newSVval64 (f->f_flag ), 0);
563     hv_store (hv, "namemax", sizeof ("namemax") - 1, newSVval64 (f->f_namemax), 0);
564     }
565    
566     PUSHs (rv);
567     }
568    
569     break;
570    
571 root 1.115 case EIO_GROUP:
572 root 1.86 req->int1 = 2; /* mark group as finished */
573 root 1.45
574 root 1.86 if (req->sv1)
575 root 1.67 {
576     int i;
577 root 1.86 AV *av = (AV *)req->sv1;
578 root 1.49
579 root 1.67 EXTEND (SP, AvFILL (av) + 1);
580     for (i = 0; i <= AvFILL (av); ++i)
581     PUSHs (*av_fetch (av, i, 0));
582     }
583     break;
584 root 1.48
585 root 1.115 case EIO_NOP:
586     case EIO_BUSY:
587 root 1.67 break;
588 root 1.48
589 root 1.115 case EIO_READLINK:
590 root 1.183 case EIO_REALPATH:
591 root 1.86 if (req->result > 0)
592 root 1.119 PUSHs (sv_2mortal (newSVpvn (req->ptr2, req->result)));
593 root 1.86 break;
594    
595 root 1.115 case EIO_STAT:
596     case EIO_LSTAT:
597     case EIO_FSTAT:
598     PL_laststype = req->type == EIO_LSTAT ? OP_LSTAT : OP_STAT;
599 root 1.87 PL_laststatval = req->result;
600 root 1.115 PL_statcache = *(EIO_STRUCT_STAT *)(req->ptr2);
601 root 1.165 PUSHs (sv_result);
602 root 1.87 break;
603    
604 root 1.115 case EIO_READ:
605 root 1.138 {
606     SvCUR_set (req->sv2, req->stroffset + (req->result > 0 ? req->result : 0));
607     *SvEND (req->sv2) = 0;
608     SvPOK_only (req->sv2);
609     SvSETMAGIC (req->sv2);
610 root 1.165 PUSHs (sv_result);
611 root 1.138 }
612 root 1.87 break;
613    
614 root 1.177 case EIO_DUP2: /* EIO_DUP2 actually means aio_close(), so fudge result value */
615 root 1.115 if (req->result > 0)
616 root 1.165 SvIV_set (sv_result, 0);
617 root 1.115 /* FALLTHROUGH */
618    
619 root 1.67 default:
620 root 1.165 PUSHs (sv_result);
621 root 1.67 break;
622     }
623 root 1.45
624 root 1.79 errno = req->errorno;
625 root 1.51
626 root 1.67 PUTBACK;
627 root 1.109 call_sv (req->callback, G_VOID | G_EVAL | G_DISCARD);
628 root 1.67 SPAGAIN;
629 root 1.51
630 root 1.165 if (expect_false (SvREFCNT (sv_result) != 1 || sv_result_cache))
631     SvREFCNT_dec (sv_result);
632     else
633     sv_result_cache = sv_result;
634    
635 root 1.67 FREETMPS;
636     LEAVE;
637 root 1.109
638     PUTBACK;
639 root 1.45 }
640    
641 root 1.115 return !!SvTRUE (ERRSV);
642 root 1.67 }
643    
644 root 1.101 static void req_destroy (aio_req req)
645 root 1.67 {
646 root 1.43 if (req->self)
647     {
648     sv_unmagic (req->self, PERL_MAGIC_ext);
649     SvREFCNT_dec (req->self);
650     }
651    
652 root 1.86 SvREFCNT_dec (req->sv1);
653     SvREFCNT_dec (req->sv2);
654 root 1.49 SvREFCNT_dec (req->callback);
655 root 1.26
656     Safefree (req);
657     }
658    
659 root 1.72 static void req_cancel_subs (aio_req grp)
660     {
661     aio_req sub;
662    
663 root 1.115 if (grp->type != EIO_GROUP)
664 root 1.72 return;
665    
666 root 1.86 SvREFCNT_dec (grp->sv2);
667     grp->sv2 = 0;
668 root 1.72
669 root 1.115 eio_grp_cancel (grp);
670 root 1.1 }
671    
672 root 1.104 static void
673 root 1.111 create_respipe (void)
674 root 1.104 {
675 root 1.153 if (s_epipe_renew (&respipe))
676 root 1.155 croak ("IO::AIO: unable to initialize result pipe");
677 root 1.104 }
678    
679 root 1.111 static void poll_wait (void)
680 root 1.80 {
681 root 1.115 while (eio_nreqs ())
682 root 1.30 {
683 root 1.80 int size;
684 root 1.115
685     X_LOCK (reslock);
686 root 1.80 size = res_queue.size;
687 root 1.115 X_UNLOCK (reslock);
688 root 1.80
689     if (size)
690     return;
691    
692 root 1.123 etp_maybe_start_thread ();
693 root 1.80
694 root 1.153 s_epipe_wait (&respipe);
695 root 1.22 }
696 root 1.80 }
697    
698 root 1.111 static int poll_cb (void)
699 root 1.80 {
700 root 1.124 for (;;)
701 root 1.116 {
702 root 1.124 int res = eio_poll ();
703 root 1.116
704     if (res > 0)
705     croak (0);
706 root 1.124
707     if (!max_outstanding || max_outstanding > eio_nreqs ())
708     return res;
709    
710     poll_wait ();
711 root 1.116 }
712 root 1.17 }
713 root 1.37
714 root 1.116 static void atfork_child (void)
715     {
716     create_respipe ();
717     }
718    
719 root 1.162 /*****************************************************************************/
720    
721 root 1.163 #if !_POSIX_MAPPED_FILES
722     # define mmap(addr,length,prot,flags,fd,offs) (errno = ENOSYS, -1)
723     # define munmap(addr,length) (errno = ENOSYS, -1)
724 root 1.179 #endif
725    
726     #if !_POSIX_MEMORY_PROTECTION
727 root 1.171 # define mprotect(addr,len,prot) (errno = ENOSYS, -1)
728 root 1.174 # define PROT_NONE 0
729     # define PROT_WRITE 0
730     # define MAP_PRIVATE 0
731     # define MAP_SHARED 0
732     # define MAP_FIXED 0
733 root 1.163 #endif
734    
735 root 1.162 #define MMAP_MAGIC PERL_MAGIC_ext
736    
737     static int
738     mmap_free (pTHX_ SV *sv, MAGIC *mg)
739     {
740     int old_errno = errno;
741     munmap (mg->mg_ptr, (size_t)mg->mg_obj);
742     errno = old_errno;
743    
744     mg->mg_obj = 0; /* just in case */
745    
746     SvREADONLY_off (sv);
747 root 1.168
748     if (SvPVX (sv) != mg->mg_ptr)
749     croak ("ERROR: IO::AIO::mmap-mapped scalar changed location, detected");
750    
751 root 1.162 SvCUR_set (sv, 0);
752     SvPVX (sv) = 0;
753     SvOK_off (sv);
754    
755     return 0;
756     }
757    
758     static MGVTBL mmap_vtbl = {
759     0, 0, 0, 0, mmap_free
760     };
761    
762     /*****************************************************************************/
763    
764 root 1.128 static SV *
765     get_cb (SV *cb_sv)
766     {
767 root 1.152 SvGETMAGIC (cb_sv);
768     return SvOK (cb_sv) ? s_get_cv_croak (cb_sv) : 0;
769 root 1.128 }
770    
771 root 1.22 #define dREQ \
772 root 1.128 SV *cb_cv; \
773 root 1.22 aio_req req; \
774 root 1.60 int req_pri = next_pri; \
775 root 1.121 next_pri = EIO_PRI_DEFAULT; \
776 root 1.22 \
777 root 1.128 cb_cv = get_cb (callback); \
778 root 1.22 \
779 root 1.115 Newz (0, req, 1, eio_req); \
780 root 1.22 if (!req) \
781 root 1.115 croak ("out of memory during eio_req allocation"); \
782 root 1.22 \
783 root 1.128 req->callback = SvREFCNT_inc (cb_cv); \
784 root 1.60 req->pri = req_pri
785 root 1.43
786     #define REQ_SEND \
787 root 1.126 PUTBACK; \
788 root 1.117 req_submit (req); \
789 root 1.126 SPAGAIN; \
790 root 1.43 \
791     if (GIMME_V != G_VOID) \
792 root 1.156 XPUSHs (req_sv (req, aio_req_stash));
793 root 1.136
794 root 1.1 MODULE = IO::AIO PACKAGE = IO::AIO
795    
796 root 1.8 PROTOTYPES: ENABLE
797    
798 root 1.1 BOOT:
799     {
800 root 1.141 static const struct {
801     const char *name;
802     IV iv;
803     } *civ, const_iv[] = {
804 root 1.162 # define const_niv(name, value) { # name, (IV) value },
805     # define const_iv(name) { # name, (IV) name },
806 root 1.141 # define const_eio(name) { # name, (IV) EIO_ ## name },
807 root 1.162 const_iv (EXDEV)
808     const_iv (ENOSYS)
809     const_iv (O_RDONLY)
810     const_iv (O_WRONLY)
811 root 1.164 const_iv (O_RDWR)
812 root 1.162 const_iv (O_CREAT)
813     const_iv (O_TRUNC)
814 root 1.164 const_iv (O_EXCL)
815     const_iv (O_APPEND)
816 root 1.180
817 root 1.182 const_iv (O_ASYNC)
818     const_iv (O_DIRECT)
819     const_iv (O_NOATIME)
820    
821     const_iv (O_CLOEXEC)
822     const_iv (O_NOCTTY)
823     const_iv (O_NOFOLLOW)
824     const_iv (O_NONBLOCK)
825     const_iv (O_EXEC)
826     const_iv (O_SEARCH)
827     const_iv (O_DIRECTORY)
828     const_iv (O_DSYNC)
829     const_iv (O_RSYNC)
830     const_iv (O_SYNC)
831     const_iv (O_TTY_INIT)
832    
833 root 1.162 const_iv (S_IFIFO)
834 root 1.180 const_iv (S_IFCHR)
835     const_iv (S_IFBLK)
836     const_iv (S_IFLNK)
837     const_iv (S_IFREG)
838     const_iv (S_IFDIR)
839     const_iv (S_IFWHT)
840     const_iv (S_IFSOCK)
841     const_iv (S_IFMT)
842    
843 root 1.162 const_niv (FADV_NORMAL , POSIX_FADV_NORMAL)
844     const_niv (FADV_SEQUENTIAL, POSIX_FADV_SEQUENTIAL)
845     const_niv (FADV_RANDOM , POSIX_FADV_RANDOM)
846     const_niv (FADV_NOREUSE , POSIX_FADV_NOREUSE)
847     const_niv (FADV_WILLNEED , POSIX_FADV_WILLNEED)
848     const_niv (FADV_DONTNEED , POSIX_FADV_DONTNEED)
849    
850 root 1.169 const_niv (MADV_NORMAL , POSIX_MADV_NORMAL)
851     const_niv (MADV_SEQUENTIAL, POSIX_MADV_SEQUENTIAL)
852     const_niv (MADV_RANDOM , POSIX_MADV_RANDOM)
853     const_niv (MADV_WILLNEED , POSIX_MADV_WILLNEED)
854     const_niv (MADV_DONTNEED , POSIX_MADV_DONTNEED)
855    
856 root 1.162 const_iv (ST_RDONLY)
857     const_iv (ST_NOSUID)
858     const_iv (ST_NODEV)
859     const_iv (ST_NOEXEC)
860     const_iv (ST_SYNCHRONOUS)
861     const_iv (ST_MANDLOCK)
862     const_iv (ST_WRITE)
863     const_iv (ST_APPEND)
864     const_iv (ST_IMMUTABLE)
865     const_iv (ST_NOATIME)
866     const_iv (ST_NODIRATIME)
867     const_iv (ST_RELATIME)
868    
869 root 1.171 const_iv (PROT_NONE)
870 root 1.162 const_iv (PROT_EXEC)
871     const_iv (PROT_READ)
872     const_iv (PROT_WRITE)
873    
874     /*const_iv (MAP_FIXED)*/
875     const_iv (MAP_PRIVATE)
876     const_iv (MAP_SHARED)
877     const_iv (MAP_ANONYMOUS)
878    
879     /* linuxish */
880     const_iv (MAP_HUGETLB)
881     const_iv (MAP_LOCKED)
882     const_iv (MAP_NORESERVE)
883     const_iv (MAP_POPULATE)
884     const_iv (MAP_NONBLOCK)
885 root 1.159
886 root 1.172 const_eio (MCL_FUTURE)
887     const_eio (MCL_CURRENT)
888 root 1.161
889 root 1.158 const_eio (MS_ASYNC)
890     const_eio (MS_INVALIDATE)
891     const_eio (MS_SYNC)
892    
893     const_eio (MT_MODIFY)
894    
895 root 1.141 const_eio (SYNC_FILE_RANGE_WAIT_BEFORE)
896     const_eio (SYNC_FILE_RANGE_WRITE)
897     const_eio (SYNC_FILE_RANGE_WAIT_AFTER)
898    
899     const_eio (READDIR_DENTS)
900     const_eio (READDIR_DIRS_FIRST)
901     const_eio (READDIR_STAT_ORDER)
902     const_eio (READDIR_FOUND_UNKNOWN)
903    
904     const_eio (DT_UNKNOWN)
905     const_eio (DT_FIFO)
906     const_eio (DT_CHR)
907     const_eio (DT_DIR)
908     const_eio (DT_BLK)
909     const_eio (DT_REG)
910     const_eio (DT_LNK)
911     const_eio (DT_SOCK)
912     const_eio (DT_WHT)
913     };
914 root 1.103
915 root 1.156 aio_stash = gv_stashpv ("IO::AIO" , 1);
916     aio_req_stash = gv_stashpv ("IO::AIO::REQ", 1);
917     aio_grp_stash = gv_stashpv ("IO::AIO::GRP", 1);
918 root 1.146
919 root 1.141 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
920 root 1.156 newCONSTSUB (aio_stash, (char *)civ->name, newSViv (civ->iv));
921 root 1.141
922 root 1.162 newCONSTSUB (aio_stash, "PAGESIZE", newSViv (PAGESIZE));
923    
924 root 1.141 create_respipe ();
925 root 1.41
926 root 1.141 if (eio_init (want_poll, done_poll) < 0)
927     croak ("IO::AIO: unable to initialise eio library");
928 root 1.116
929 root 1.141 /* atfork child called in fifo order, so before eio's handler */
930     X_THREAD_ATFORK (0, 0, atfork_child);
931 root 1.1 }
932    
933     void
934 root 1.181 max_poll_reqs (unsigned int nreqs)
935 root 1.85 PROTOTYPE: $
936     CODE:
937 root 1.115 eio_set_max_poll_reqs (nreqs);
938 root 1.85
939     void
940     max_poll_time (double nseconds)
941     PROTOTYPE: $
942     CODE:
943 root 1.115 eio_set_max_poll_time (nseconds);
944 root 1.85
945     void
946 root 1.181 min_parallel (unsigned int nthreads)
947 root 1.1 PROTOTYPE: $
948 root 1.115 CODE:
949     eio_set_min_parallel (nthreads);
950 root 1.1
951     void
952 root 1.181 max_parallel (unsigned int nthreads)
953 root 1.78 PROTOTYPE: $
954 root 1.115 CODE:
955     eio_set_max_parallel (nthreads);
956 root 1.78
957 root 1.85 void
958 root 1.181 max_idle (unsigned int nthreads)
959 root 1.85 PROTOTYPE: $
960     CODE:
961 root 1.115 eio_set_max_idle (nthreads);
962 root 1.85
963 root 1.115 void
964 root 1.181 idle_timeout (unsigned int seconds)
965     PROTOTYPE: $
966     CODE:
967     eio_set_idle_timeout (seconds);
968    
969     void
970     max_outstanding (unsigned int maxreqs)
971 root 1.1 PROTOTYPE: $
972 root 1.78 CODE:
973     max_outstanding = maxreqs;
974 root 1.1
975     void
976 root 1.99 aio_open (SV8 *pathname, int flags, int mode, SV *callback=&PL_sv_undef)
977 root 1.43 PPCODE:
978 root 1.1 {
979 root 1.22 dREQ;
980 root 1.1
981 root 1.115 req->type = EIO_OPEN;
982 root 1.86 req->sv1 = newSVsv (pathname);
983 root 1.89 req->ptr1 = SvPVbyte_nolen (req->sv1);
984 root 1.86 req->int1 = flags;
985 root 1.115 req->int2 = mode;
986 root 1.1
987 root 1.43 REQ_SEND;
988 root 1.1 }
989    
990     void
991 root 1.107 aio_fsync (SV *fh, SV *callback=&PL_sv_undef)
992 root 1.1 ALIAS:
993 root 1.115 aio_fsync = EIO_FSYNC
994     aio_fdatasync = EIO_FDATASYNC
995 root 1.43 PPCODE:
996 root 1.1 {
997 root 1.151 int fd = s_fileno_croak (fh, 0);
998 root 1.22 dREQ;
999 root 1.1
1000     req->type = ix;
1001 root 1.99 req->sv1 = newSVsv (fh);
1002 root 1.136 req->int1 = fd;
1003 root 1.1
1004 root 1.43 REQ_SEND (req);
1005 root 1.1 }
1006    
1007     void
1008 root 1.148 aio_sync_file_range (SV *fh, off_t offset, size_t nbytes, UV flags, SV *callback=&PL_sv_undef)
1009 root 1.133 PPCODE:
1010     {
1011 root 1.151 int fd = s_fileno_croak (fh, 0);
1012 root 1.133 dREQ;
1013    
1014     req->type = EIO_SYNC_FILE_RANGE;
1015     req->sv1 = newSVsv (fh);
1016 root 1.136 req->int1 = fd;
1017 root 1.148 req->offs = offset;
1018     req->size = nbytes;
1019 root 1.133 req->int2 = flags;
1020    
1021     REQ_SEND (req);
1022     }
1023    
1024     void
1025 root 1.113 aio_close (SV *fh, SV *callback=&PL_sv_undef)
1026 root 1.107 PPCODE:
1027     {
1028 root 1.115 static int close_pipe = -1; /* dummy fd to close fds via dup2 */
1029 root 1.151 int fd = s_fileno_croak (fh, 0);
1030 root 1.109 dREQ;
1031 root 1.107
1032 root 1.115 if (close_pipe < 0)
1033     {
1034     int pipefd [2];
1035    
1036     if (pipe (pipefd) < 0
1037     || close (pipefd [1]) < 0
1038     || fcntl (pipefd [0], F_SETFD, FD_CLOEXEC) < 0)
1039     abort (); /*D*/
1040    
1041     close_pipe = pipefd [0];
1042     }
1043    
1044     req->type = EIO_DUP2;
1045     req->int1 = close_pipe;
1046     req->sv2 = newSVsv (fh);
1047 root 1.136 req->int2 = fd;
1048 root 1.107
1049 root 1.109 REQ_SEND (req);
1050 root 1.107 }
1051    
1052     void
1053 root 1.102 aio_read (SV *fh, SV *offset, SV *length, SV8 *data, IV dataoffset, SV *callback=&PL_sv_undef)
1054 root 1.13 ALIAS:
1055 root 1.115 aio_read = EIO_READ
1056     aio_write = EIO_WRITE
1057 root 1.43 PPCODE:
1058 root 1.13 {
1059     STRLEN svlen;
1060 root 1.151 int fd = s_fileno_croak (fh, ix == EIO_WRITE);
1061 root 1.21 char *svptr = SvPVbyte (data, svlen);
1062 root 1.102 UV len = SvUV (length);
1063 root 1.134
1064 root 1.13 if (dataoffset < 0)
1065     dataoffset += svlen;
1066    
1067     if (dataoffset < 0 || dataoffset > svlen)
1068 root 1.102 croak ("dataoffset outside of data scalar");
1069 root 1.13
1070 root 1.115 if (ix == EIO_WRITE)
1071 root 1.13 {
1072     /* write: check length and adjust. */
1073 root 1.102 if (!SvOK (length) || len + dataoffset > svlen)
1074     len = svlen - dataoffset;
1075 root 1.13 }
1076     else
1077     {
1078 root 1.138 /* read: check type and grow scalar as necessary */
1079     SvUPGRADE (data, SVt_PV);
1080 root 1.102 svptr = SvGROW (data, len + dataoffset + 1);
1081 root 1.13 }
1082    
1083 root 1.22 {
1084     dREQ;
1085 root 1.13
1086 root 1.22 req->type = ix;
1087 root 1.99 req->sv1 = newSVsv (fh);
1088 root 1.135 req->int1 = fd;
1089 root 1.101 req->offs = SvOK (offset) ? SvVAL64 (offset) : -1;
1090 root 1.102 req->size = len;
1091 root 1.132 req->sv2 = SvREFCNT_inc (data);
1092 root 1.115 req->ptr2 = (char *)svptr + dataoffset;
1093 root 1.86 req->stroffset = dataoffset;
1094 root 1.13
1095 root 1.28 if (!SvREADONLY (data))
1096     {
1097     SvREADONLY_on (data);
1098 root 1.100 req->flags |= FLAG_SV2_RO_OFF;
1099 root 1.28 }
1100    
1101 root 1.43 REQ_SEND;
1102 root 1.22 }
1103 root 1.13 }
1104 root 1.1
1105     void
1106 root 1.99 aio_readlink (SV8 *path, SV *callback=&PL_sv_undef)
1107 root 1.183 ALIAS:
1108     aio_readlink = EIO_READLINK
1109     aio_realpath = EIO_REALPATH
1110 root 1.86 PPCODE:
1111     {
1112     SV *data;
1113     dREQ;
1114    
1115 root 1.183 req->type = ix;
1116 root 1.99 req->sv1 = newSVsv (path);
1117 root 1.115 req->ptr1 = SvPVbyte_nolen (req->sv1);
1118 root 1.86
1119     REQ_SEND;
1120     }
1121    
1122     void
1123 root 1.148 aio_sendfile (SV *out_fh, SV *in_fh, off_t in_offset, size_t length, SV *callback=&PL_sv_undef)
1124 root 1.43 PPCODE:
1125 root 1.32 {
1126 root 1.151 int ifd = s_fileno_croak (in_fh , 0);
1127     int ofd = s_fileno_croak (out_fh, 1);
1128 root 1.32 dREQ;
1129    
1130 root 1.115 req->type = EIO_SENDFILE;
1131 root 1.99 req->sv1 = newSVsv (out_fh);
1132 root 1.136 req->int1 = ofd;
1133 root 1.86 req->sv2 = newSVsv (in_fh);
1134 root 1.136 req->int2 = ifd;
1135 root 1.148 req->offs = in_offset;
1136 root 1.86 req->size = length;
1137 root 1.32
1138 root 1.43 REQ_SEND;
1139 root 1.32 }
1140    
1141     void
1142 root 1.148 aio_readahead (SV *fh, off_t offset, size_t length, SV *callback=&PL_sv_undef)
1143 root 1.43 PPCODE:
1144 root 1.1 {
1145 root 1.151 int fd = s_fileno_croak (fh, 0);
1146 root 1.22 dREQ;
1147 root 1.1
1148 root 1.115 req->type = EIO_READAHEAD;
1149 root 1.99 req->sv1 = newSVsv (fh);
1150 root 1.136 req->int1 = fd;
1151 root 1.148 req->offs = offset;
1152 root 1.86 req->size = length;
1153 root 1.1
1154 root 1.43 REQ_SEND;
1155 root 1.1 }
1156    
1157     void
1158 root 1.99 aio_stat (SV8 *fh_or_path, SV *callback=&PL_sv_undef)
1159 root 1.1 ALIAS:
1160 root 1.159 aio_stat = EIO_STAT
1161     aio_lstat = EIO_LSTAT
1162     aio_statvfs = EIO_STATVFS
1163 root 1.43 PPCODE:
1164 root 1.1 {
1165 root 1.22 dREQ;
1166 root 1.1
1167 root 1.99 req->sv1 = newSVsv (fh_or_path);
1168 root 1.87
1169 root 1.119 if (SvPOK (req->sv1))
1170 root 1.1 {
1171 root 1.8 req->type = ix;
1172 root 1.89 req->ptr1 = SvPVbyte_nolen (req->sv1);
1173 root 1.1 }
1174     else
1175     {
1176 root 1.159 req->type = ix == EIO_STATVFS ? EIO_FSTATVFS : EIO_FSTAT;
1177 root 1.86 req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
1178 root 1.1 }
1179    
1180 root 1.43 REQ_SEND;
1181 root 1.1 }
1182    
1183 root 1.180 UV
1184     major (UV dev)
1185     ALIAS:
1186     minor = 1
1187     CODE:
1188     RETVAL = ix ? major (dev) : minor (dev);
1189     OUTPUT:
1190     RETVAL
1191    
1192     UV
1193     makedev (UV maj, UV min)
1194     CODE:
1195     RETVAL = makedev (maj, min);
1196     OUTPUT:
1197     RETVAL
1198    
1199 root 1.1 void
1200 root 1.99 aio_utime (SV8 *fh_or_path, SV *atime, SV *mtime, SV *callback=&PL_sv_undef)
1201     PPCODE:
1202     {
1203     dREQ;
1204    
1205     req->nv1 = SvOK (atime) ? SvNV (atime) : -1.;
1206     req->nv2 = SvOK (mtime) ? SvNV (mtime) : -1.;
1207     req->sv1 = newSVsv (fh_or_path);
1208    
1209 root 1.119 if (SvPOK (req->sv1))
1210 root 1.99 {
1211 root 1.115 req->type = EIO_UTIME;
1212 root 1.99 req->ptr1 = SvPVbyte_nolen (req->sv1);
1213     }
1214     else
1215     {
1216 root 1.115 req->type = EIO_FUTIME;
1217 root 1.99 req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
1218     }
1219    
1220     REQ_SEND;
1221     }
1222    
1223     void
1224 root 1.103 aio_truncate (SV8 *fh_or_path, SV *offset, SV *callback=&PL_sv_undef)
1225     PPCODE:
1226     {
1227     dREQ;
1228    
1229     req->sv1 = newSVsv (fh_or_path);
1230     req->offs = SvOK (offset) ? SvVAL64 (offset) : -1;
1231    
1232 root 1.119 if (SvPOK (req->sv1))
1233 root 1.103 {
1234 root 1.115 req->type = EIO_TRUNCATE;
1235 root 1.103 req->ptr1 = SvPVbyte_nolen (req->sv1);
1236     }
1237     else
1238     {
1239 root 1.115 req->type = EIO_FTRUNCATE;
1240 root 1.103 req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
1241     }
1242    
1243     REQ_SEND;
1244     }
1245    
1246     void
1247 root 1.99 aio_chmod (SV8 *fh_or_path, int mode, SV *callback=&PL_sv_undef)
1248 root 1.115 ALIAS:
1249     aio_chmod = EIO_CHMOD
1250     aio_mkdir = EIO_MKDIR
1251 root 1.99 PPCODE:
1252     {
1253     dREQ;
1254    
1255 root 1.115 req->int2 = mode;
1256 root 1.99 req->sv1 = newSVsv (fh_or_path);
1257    
1258 root 1.119 if (SvPOK (req->sv1))
1259     {
1260 root 1.120 req->type = ix;
1261     req->ptr1 = SvPVbyte_nolen (req->sv1);
1262 root 1.119 }
1263 root 1.99 else
1264 root 1.119 {
1265 root 1.120 req->type = EIO_FCHMOD;
1266     req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
1267 root 1.119 }
1268 root 1.99
1269     REQ_SEND;
1270     }
1271    
1272     void
1273     aio_chown (SV8 *fh_or_path, SV *uid, SV *gid, SV *callback=&PL_sv_undef)
1274     PPCODE:
1275     {
1276     dREQ;
1277    
1278     req->int2 = SvOK (uid) ? SvIV (uid) : -1;
1279     req->int3 = SvOK (gid) ? SvIV (gid) : -1;
1280     req->sv1 = newSVsv (fh_or_path);
1281    
1282 root 1.119 if (SvPOK (req->sv1))
1283 root 1.99 {
1284 root 1.115 req->type = EIO_CHOWN;
1285 root 1.99 req->ptr1 = SvPVbyte_nolen (req->sv1);
1286     }
1287     else
1288     {
1289 root 1.115 req->type = EIO_FCHOWN;
1290 root 1.99 req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
1291     }
1292    
1293     REQ_SEND;
1294     }
1295    
1296     void
1297 root 1.141 aio_readdirx (SV8 *pathname, IV flags, SV *callback=&PL_sv_undef)
1298     PPCODE:
1299     {
1300     dREQ;
1301    
1302     req->type = EIO_READDIR;
1303     req->sv1 = newSVsv (pathname);
1304     req->ptr1 = SvPVbyte_nolen (req->sv1);
1305     req->int1 = flags | EIO_READDIR_DENTS | EIO_READDIR_CUSTOM1;
1306    
1307     if (flags & EIO_READDIR_DENTS)
1308 root 1.142 req->int1 |= EIO_READDIR_CUSTOM2;
1309 root 1.141
1310     REQ_SEND;
1311     }
1312    
1313     void
1314 root 1.99 aio_unlink (SV8 *pathname, SV *callback=&PL_sv_undef)
1315 root 1.22 ALIAS:
1316 root 1.115 aio_unlink = EIO_UNLINK
1317     aio_rmdir = EIO_RMDIR
1318     aio_readdir = EIO_READDIR
1319 root 1.43 PPCODE:
1320 root 1.1 {
1321 root 1.22 dREQ;
1322 root 1.1
1323 root 1.22 req->type = ix;
1324 root 1.86 req->sv1 = newSVsv (pathname);
1325 root 1.89 req->ptr1 = SvPVbyte_nolen (req->sv1);
1326 root 1.87
1327 root 1.43 REQ_SEND;
1328 root 1.22 }
1329    
1330     void
1331 root 1.99 aio_link (SV8 *oldpath, SV8 *newpath, SV *callback=&PL_sv_undef)
1332 root 1.40 ALIAS:
1333 root 1.115 aio_link = EIO_LINK
1334     aio_symlink = EIO_SYMLINK
1335     aio_rename = EIO_RENAME
1336 root 1.43 PPCODE:
1337 root 1.22 {
1338     dREQ;
1339 root 1.1
1340 root 1.40 req->type = ix;
1341 root 1.115 req->sv1 = newSVsv (oldpath);
1342     req->ptr1 = SvPVbyte_nolen (req->sv1);
1343     req->sv2 = newSVsv (newpath);
1344 root 1.99 req->ptr2 = SvPVbyte_nolen (req->sv2);
1345 root 1.1
1346 root 1.43 REQ_SEND;
1347 root 1.1 }
1348    
1349 root 1.42 void
1350 root 1.99 aio_mknod (SV8 *pathname, int mode, UV dev, SV *callback=&PL_sv_undef)
1351 root 1.81 PPCODE:
1352     {
1353     dREQ;
1354    
1355 root 1.115 req->type = EIO_MKNOD;
1356 root 1.86 req->sv1 = newSVsv (pathname);
1357 root 1.89 req->ptr1 = SvPVbyte_nolen (req->sv1);
1358 root 1.115 req->int2 = (mode_t)mode;
1359 root 1.86 req->offs = dev;
1360 root 1.81
1361     REQ_SEND;
1362     }
1363    
1364     void
1365 root 1.158 aio_mtouch (SV8 *data, IV offset = 0, SV *length = &PL_sv_undef, int flags = 0, SV *callback=&PL_sv_undef)
1366     ALIAS:
1367     aio_mtouch = EIO_MTOUCH
1368     aio_msync = EIO_MSYNC
1369     PPCODE:
1370     {
1371     STRLEN svlen;
1372 root 1.172 char *svptr = SvPVbyte (data, svlen);
1373 root 1.158 UV len = SvUV (length);
1374    
1375     if (offset < 0)
1376     offset += svlen;
1377    
1378     if (offset < 0 || offset > svlen)
1379     croak ("offset outside of scalar");
1380    
1381     if (!SvOK (length) || len + offset > svlen)
1382     len = svlen - offset;
1383    
1384     {
1385     dREQ;
1386    
1387     req->type = ix;
1388 root 1.172 req->sv2 = SvREFCNT_inc (data);
1389     req->ptr2 = (char *)svptr + offset;
1390 root 1.158 req->size = len;
1391 root 1.172 req->int1 = flags;
1392    
1393     REQ_SEND;
1394     }
1395     }
1396    
1397     void
1398     aio_mlock (SV8 *data, IV offset = 0, SV *length = &PL_sv_undef, SV *callback=&PL_sv_undef)
1399     PPCODE:
1400     {
1401     STRLEN svlen;
1402     char *svptr = SvPVbyte (data, svlen);
1403     UV len = SvUV (length);
1404    
1405     if (offset < 0)
1406     offset += svlen;
1407    
1408     if (offset < 0 || offset > svlen)
1409     croak ("offset outside of scalar");
1410    
1411     if (!SvOK (length) || len + offset > svlen)
1412     len = svlen - offset;
1413    
1414     {
1415     dREQ;
1416    
1417     req->type = EIO_MLOCK;
1418 root 1.158 req->sv2 = SvREFCNT_inc (data);
1419     req->ptr2 = (char *)svptr + offset;
1420 root 1.172 req->size = len;
1421 root 1.158
1422     REQ_SEND;
1423     }
1424     }
1425    
1426     void
1427 root 1.172 aio_mlockall (IV flags, SV *callback=&PL_sv_undef)
1428     PPCODE:
1429     {
1430     dREQ;
1431    
1432     req->type = EIO_MLOCKALL;
1433     req->int1 = flags;
1434    
1435     REQ_SEND;
1436     }
1437    
1438     void
1439 root 1.99 aio_busy (double delay, SV *callback=&PL_sv_undef)
1440 root 1.45 PPCODE:
1441     {
1442     dREQ;
1443    
1444 root 1.115 req->type = EIO_BUSY;
1445 root 1.99 req->nv1 = delay < 0. ? 0. : delay;
1446 root 1.45
1447     REQ_SEND;
1448     }
1449    
1450     void
1451 root 1.99 aio_group (SV *callback=&PL_sv_undef)
1452 root 1.44 PPCODE:
1453 root 1.42 {
1454 root 1.44 dREQ;
1455 root 1.60
1456 root 1.115 req->type = EIO_GROUP;
1457 root 1.86
1458 root 1.127 req_submit (req);
1459 root 1.156 XPUSHs (req_sv (req, aio_grp_stash));
1460 root 1.42 }
1461    
1462 root 1.6 void
1463 root 1.99 aio_nop (SV *callback=&PL_sv_undef)
1464 root 1.110 ALIAS:
1465 root 1.115 aio_nop = EIO_NOP
1466     aio_sync = EIO_SYNC
1467 root 1.54 PPCODE:
1468     {
1469     dREQ;
1470    
1471 root 1.110 req->type = ix;
1472 root 1.54
1473     REQ_SEND;
1474     }
1475    
1476 root 1.79 int
1477     aioreq_pri (int pri = 0)
1478     CODE:
1479 root 1.121 RETVAL = next_pri;
1480 root 1.79 if (items > 0)
1481     {
1482 root 1.115 if (pri < EIO_PRI_MIN) pri = EIO_PRI_MIN;
1483     if (pri > EIO_PRI_MAX) pri = EIO_PRI_MAX;
1484 root 1.121 next_pri = pri;
1485 root 1.79 }
1486     OUTPUT:
1487     RETVAL
1488 root 1.68
1489     void
1490     aioreq_nice (int nice = 0)
1491 root 1.79 CODE:
1492     nice = next_pri - nice;
1493 root 1.115 if (nice < EIO_PRI_MIN) nice = EIO_PRI_MIN;
1494     if (nice > EIO_PRI_MAX) nice = EIO_PRI_MAX;
1495 root 1.121 next_pri = nice;
1496 root 1.60
1497 root 1.54 void
1498 root 1.40 flush ()
1499 root 1.6 CODE:
1500 root 1.116 while (eio_nreqs ())
1501 root 1.6 {
1502     poll_wait ();
1503 root 1.91 poll_cb ();
1504 root 1.6 }
1505    
1506 root 1.91 int
1507 root 1.172 poll ()
1508 root 1.7 CODE:
1509 root 1.92 poll_wait ();
1510     RETVAL = poll_cb ();
1511 root 1.91 OUTPUT:
1512     RETVAL
1513 root 1.7
1514 root 1.1 int
1515 root 1.172 poll_fileno ()
1516 root 1.1 CODE:
1517 root 1.153 RETVAL = s_epipe_fd (&respipe);
1518 root 1.1 OUTPUT:
1519     RETVAL
1520    
1521     int
1522 root 1.172 poll_cb (...)
1523 root 1.1 PROTOTYPE:
1524     CODE:
1525 root 1.85 RETVAL = poll_cb ();
1526 root 1.1 OUTPUT:
1527     RETVAL
1528    
1529     void
1530 root 1.172 poll_wait ()
1531 root 1.1 CODE:
1532 root 1.92 poll_wait ();
1533 root 1.1
1534     int
1535 root 1.172 nreqs ()
1536 root 1.1 CODE:
1537 root 1.115 RETVAL = eio_nreqs ();
1538 root 1.1 OUTPUT:
1539     RETVAL
1540    
1541 root 1.79 int
1542 root 1.172 nready ()
1543 root 1.79 CODE:
1544 root 1.115 RETVAL = eio_nready ();
1545 root 1.79 OUTPUT:
1546     RETVAL
1547    
1548     int
1549 root 1.172 npending ()
1550 root 1.79 CODE:
1551 root 1.115 RETVAL = eio_npending ();
1552 root 1.79 OUTPUT:
1553     RETVAL
1554    
1555 root 1.85 int
1556 root 1.172 nthreads ()
1557 root 1.85 CODE:
1558 root 1.122 RETVAL = eio_nthreads ();
1559 root 1.85 OUTPUT:
1560     RETVAL
1561    
1562 root 1.148 int
1563     fadvise (aio_rfd fh, off_t offset, off_t length, IV advice)
1564     CODE:
1565     RETVAL = posix_fadvise (fh, offset, length, advice);
1566     OUTPUT:
1567     RETVAL
1568    
1569     ssize_t
1570     sendfile (aio_wfd ofh, aio_rfd ifh, off_t offset, size_t count)
1571     CODE:
1572 root 1.157 RETVAL = eio_sendfile_sync (ofh, ifh, offset, count);
1573     OUTPUT:
1574     RETVAL
1575 root 1.148
1576 root 1.162 void
1577     mmap (SV *scalar, size_t length, int prot, int flags, SV *fh, off_t offset = 0)
1578     PPCODE:
1579     sv_unmagic (scalar, MMAP_MAGIC);
1580     {
1581     int fd = SvOK (fh) ? s_fileno_croak (fh, flags & PROT_WRITE) : -1;
1582     void *addr = (void *)mmap (0, length, prot, flags, fd, offset);
1583     if (addr == (void *)-1)
1584     XSRETURN_NO;
1585    
1586 root 1.168 sv_force_normal (scalar);
1587    
1588 root 1.162 /* we store the length in mg_obj, as namlen is I32 :/ */
1589     sv_magicext (scalar, 0, MMAP_MAGIC, &mmap_vtbl, (char *)addr, 0)
1590     ->mg_obj = (SV *)length;
1591    
1592     SvUPGRADE (scalar, SVt_PV); /* nop... */
1593 root 1.168
1594 root 1.162 if (!(prot & PROT_WRITE))
1595     SvREADONLY_on (scalar);
1596    
1597 root 1.168 if (SvLEN (scalar))
1598     Safefree (SvPVX (scalar));
1599    
1600 root 1.162 SvPVX (scalar) = (char *)addr;
1601     SvCUR_set (scalar, length);
1602     SvLEN_set (scalar, 0);
1603     SvPOK_only (scalar);
1604    
1605     XSRETURN_YES;
1606     }
1607    
1608     void
1609     munmap (SV *scalar)
1610     CODE:
1611     sv_unmagic (scalar, MMAP_MAGIC);
1612    
1613 root 1.161 int
1614 root 1.172 madvise (SV *scalar, off_t offset = 0, SV *length = &PL_sv_undef, IV advice_or_prot)
1615 root 1.171 ALIAS:
1616     mprotect = 1
1617 root 1.169 CODE:
1618     {
1619 root 1.172 STRLEN svlen;
1620     void *addr = SvPVbyte (scalar, svlen);
1621     size_t len = SvUV (length);
1622    
1623     if (offset < 0)
1624     offset += svlen;
1625    
1626     if (offset < 0 || offset > svlen)
1627     croak ("offset outside of scalar");
1628    
1629     if (!SvOK (length) || len + offset > svlen)
1630     len = svlen - offset;
1631 root 1.169
1632 root 1.172 addr = (void *)(((intptr_t)addr) + offset);
1633     eio_page_align (&addr, &len);
1634    
1635     switch (ix)
1636 root 1.171 {
1637 root 1.172 case 0: RETVAL = posix_madvise (addr, len, advice_or_prot); break;
1638     case 1: RETVAL = mprotect (addr, len, advice_or_prot); break;
1639 root 1.171 }
1640 root 1.169 }
1641     OUTPUT:
1642     RETVAL
1643    
1644     int
1645 root 1.172 munlock (SV *scalar, off_t offset = 0, SV *length = &PL_sv_undef)
1646 root 1.161 CODE:
1647 root 1.172 {
1648     STRLEN svlen;
1649     void *addr = SvPVbyte (scalar, svlen);
1650     size_t len = SvUV (length);
1651    
1652     if (offset < 0)
1653     offset += svlen;
1654    
1655     if (offset < 0 || offset > svlen)
1656     croak ("offset outside of scalar");
1657    
1658     if (!SvOK (length) || len + offset > svlen)
1659     len = svlen - offset;
1660    
1661     addr = (void *)(((intptr_t)addr) + offset);
1662     eio_page_align (&addr, &len);
1663 root 1.178 #if _POSIX_MEMLOCK_RANGE
1664 root 1.172 RETVAL = munlock (addr, len);
1665 root 1.161 #else
1666 root 1.172 RETVAL = ((errno = ENOSYS), -1);
1667 root 1.161 #endif
1668 root 1.172 }
1669 root 1.161 OUTPUT:
1670     RETVAL
1671    
1672     int
1673     munlockall ()
1674     CODE:
1675     #if _POSIX_MEMLOCK
1676     munlockall ();
1677     #else
1678 root 1.162 RETVAL = -1;
1679 root 1.161 errno = ENOSYS;
1680     #endif
1681     OUTPUT:
1682     RETVAL
1683    
1684 root 1.117 void _on_next_submit (SV *cb)
1685     CODE:
1686     SvREFCNT_dec (on_next_submit);
1687     on_next_submit = SvOK (cb) ? newSVsv (cb) : 0;
1688    
1689 root 1.48 PROTOTYPES: DISABLE
1690    
1691 root 1.44 MODULE = IO::AIO PACKAGE = IO::AIO::REQ
1692 root 1.43
1693     void
1694     cancel (aio_req_ornot req)
1695     CODE:
1696 root 1.115 eio_cancel (req);
1697 root 1.45
1698 root 1.56 void
1699 root 1.59 cb (aio_req_ornot req, SV *callback=&PL_sv_undef)
1700 root 1.128 PPCODE:
1701     {
1702     if (GIMME_V != G_VOID)
1703     XPUSHs (req->callback ? sv_2mortal (newRV_inc (req->callback)) : &PL_sv_undef);
1704    
1705     if (items > 1)
1706     {
1707 root 1.152 SV *cb_cv =get_cb (callback);
1708 root 1.128
1709     SvREFCNT_dec (req->callback);
1710     req->callback = SvREFCNT_inc (cb_cv);
1711     }
1712     }
1713 root 1.56
1714 root 1.45 MODULE = IO::AIO PACKAGE = IO::AIO::GRP
1715    
1716     void
1717     add (aio_req grp, ...)
1718     PPCODE:
1719     {
1720     int i;
1721 root 1.94
1722 root 1.86 if (grp->int1 == 2)
1723 root 1.49 croak ("cannot add requests to IO::AIO::GRP after the group finished");
1724    
1725 root 1.45 for (i = 1; i < items; ++i )
1726     {
1727 root 1.115 aio_req req;
1728    
1729 root 1.46 if (GIMME_V != G_VOID)
1730     XPUSHs (sv_2mortal (newSVsv (ST (i))));
1731    
1732 root 1.53 req = SvAIO_REQ (ST (i));
1733 root 1.45
1734 root 1.46 if (req)
1735 root 1.115 eio_grp_add (grp, req);
1736 root 1.45 }
1737     }
1738 root 1.43
1739 root 1.48 void
1740 root 1.72 cancel_subs (aio_req_ornot req)
1741     CODE:
1742     req_cancel_subs (req);
1743    
1744     void
1745 root 1.51 result (aio_req grp, ...)
1746     CODE:
1747     {
1748     int i;
1749 root 1.79 AV *av;
1750    
1751     grp->errorno = errno;
1752    
1753     av = newAV ();
1754 root 1.141 av_extend (av, items - 1);
1755 root 1.51
1756     for (i = 1; i < items; ++i )
1757     av_push (av, newSVsv (ST (i)));
1758    
1759 root 1.86 SvREFCNT_dec (grp->sv1);
1760     grp->sv1 = (SV *)av;
1761 root 1.51 }
1762    
1763     void
1764 root 1.79 errno (aio_req grp, int errorno = errno)
1765     CODE:
1766     grp->errorno = errorno;
1767    
1768     void
1769 root 1.67 limit (aio_req grp, int limit)
1770 root 1.49 CODE:
1771 root 1.115 eio_grp_limit (grp, limit);
1772 root 1.49
1773     void
1774 root 1.56 feed (aio_req grp, SV *callback=&PL_sv_undef)
1775 root 1.49 CODE:
1776     {
1777 root 1.86 SvREFCNT_dec (grp->sv2);
1778 root 1.131 grp->sv2 = newSVsv (callback);
1779     grp->feed = aio_grp_feed;
1780 root 1.49
1781 root 1.86 if (grp->int2 <= 0)
1782     grp->int2 = 2;
1783 root 1.49
1784 root 1.115 eio_grp_limit (grp, grp->int2);
1785 root 1.49 }
1786