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.5 by root, Sun Jul 10 23:45:16 2005 UTC vs.
Revision 1.182 by root, Thu May 19 22:57:04 2011 UTC

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

Diff Legend

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