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.42 by root, Fri Jul 21 07:35:31 2006 UTC vs.
Revision 1.164 by root, Tue May 4 21:14:01 2010 UTC

1#define _REENTRANT 1 1#include "libeio/xthread.h"
2
2#include <errno.h> 3#include <errno.h>
3 4
4#include "EXTERN.h" 5#include "EXTERN.h"
5#include "perl.h" 6#include "perl.h"
6#include "XSUB.h" 7#include "XSUB.h"
7 8
8#include "autoconf/config.h" 9#include "schmorp.h"
9
10#include <pthread.h>
11 10
12#include <stddef.h> 11#include <stddef.h>
12#include <stdlib.h>
13#include <errno.h> 13#include <errno.h>
14#include <sys/types.h> 14#include <sys/types.h>
15#include <sys/stat.h> 15#include <sys/stat.h>
16#include <sys/statvfs.h>
16#include <limits.h> 17#include <limits.h>
17#include <unistd.h>
18#include <fcntl.h> 18#include <fcntl.h>
19#include <signal.h>
20#include <sched.h> 19#include <sched.h>
21 20
22#if HAVE_SENDFILE 21#if _POSIX_MEMLOCK || _POSIX_MAPPED_FILES
23# if __linux
24# include <sys/sendfile.h> 22# include <sys/mman.h>
25# elif __freebsd 23#endif
26# include <sys/socket.h> 24
25/* perl namespace pollution */
26#undef VERSION
27
28#ifdef _WIN32
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
66#else
67
27# include <sys/uio.h> 68# include <sys/time.h>
28# elif __hpux
29# include <sys/socket.h>
30# elif __solaris /* not yet */
31# include <sys/sendfile.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/eio.h"
124
125#ifndef POSIX_FADV_NORMAL
126# define POSIX_FADV_NORMAL 0
127# define NO_FADVISE 1
128#endif
129#ifndef POSIX_FADV_SEQUENTIAL
130# define POSIX_FADV_SEQUENTIAL 0
131#endif
132#ifndef POSIX_FADV_RANDOM
133# define POSIX_FADV_RANDOM 0
134#endif
135#ifndef POSIX_FADV_NOREUSE
136# define POSIX_FADV_NOREUSE 0
137#endif
138#ifndef POSIX_FADV_WILLNEED
139# define POSIX_FADV_WILLNEED 0
140#endif
141#ifndef POSIX_FADV_DONTNEED
142# define POSIX_FADV_DONTNEED 0
143#endif
144
145#ifndef ST_NODEV
146# define ST_NODEV 0
147#endif
148#ifndef ST_NOEXEC
149# define ST_NOEXEC 0
150#endif
151#ifndef ST_SYNCHRONOUS
152# define ST_SYNCHRONOUS 0
153#endif
154#ifndef ST_MANDLOCK
155# define ST_MANDLOCK 0
156#endif
157#ifndef ST_WRITE
158# define ST_WRITE 0
159#endif
160#ifndef ST_APPEND
161# define ST_APPEND 0
162#endif
163#ifndef ST_IMMUTABLE
164# define ST_IMMUTABLE 0
165#endif
166#ifndef ST_NOATIME
167# define ST_NOATIME 0
168#endif
169#ifndef ST_NODIRATIME
170# define ST_NODIRATIME 0
171#endif
172#ifndef ST_RELATIME
173# define ST_RELATIME 0
174#endif
175
176#ifndef MCL_CURRENT
177# define MCL_CURRENT 0
178#endif
179#ifndef MCL_FUTURE
180# define MCL_FUTURE 0
181#endif
182
183#ifndef MAP_ANONYMOUS
184# ifdef MAP_ANON
185# define MAP_ANONYMOUS MAP_ANON
32# else 186# else
33# error sendfile support requested but not available 187# define MAP_ANONYMOUS MAP_FIXED /* and hope this fails */
34# endif 188# endif
35#endif 189#endif
36 190#ifndef MAP_HUGETLB
37/* used for struct dirent, AIX doesn't provide it */ 191# define MAP_HUGETLB 0
38#ifndef NAME_MAX
39# define NAME_MAX 4096
40#endif 192#endif
41 193#ifndef MAP_LOCKED
42#if __ia64 194# define MAP_LOCKED 0
43# define STACKSIZE 65536
44#else
45# define STACKSIZE 8192
46#endif 195#endif
196#ifndef MAP_NORESERVE
197# define MAP_NORESERVE 0
198#endif
199#ifndef MAP_POPULATE
200# define MAP_POPULATE 0
201#endif
202#ifndef MAP_NONBLOCK
203# define MAP_NONBLOCK 0
204#endif
205
206#ifndef PAGESIZE
207# define PAGESIZE sysconf (_SC_PAGESIZE)
208#endif
209
210static int req_invoke (eio_req *req);
211#define EIO_FINISH(req) req_invoke (req)
212static void req_destroy (eio_req *grp);
213#define EIO_DESTROY(req) req_destroy (req)
47 214
48enum { 215enum {
49 REQ_QUIT, 216 FLAG_SV2_RO_OFF = 0x40, /* data was set readonly */
50 REQ_OPEN, REQ_CLOSE,
51 REQ_READ, REQ_WRITE, REQ_READAHEAD,
52 REQ_SENDFILE,
53 REQ_STAT, REQ_LSTAT, REQ_FSTAT,
54 REQ_FSYNC, REQ_FDATASYNC,
55 REQ_UNLINK, REQ_RMDIR, REQ_RENAME,
56 REQ_READDIR,
57 REQ_LINK, REQ_SYMLINK,
58}; 217};
59 218
60typedef struct aio_cb { 219#include "libeio/eio.c"
61 struct aio_cb *volatile next;
62 220
63 int type;
64
65 /* should receive a cleanup, with unions */
66 int fd, fd2;
67 off_t offset;
68 size_t length;
69 ssize_t result;
70 mode_t mode; /* open */
71 int errorno;
72 SV *data, *callback;
73 SV *fh, *fh2;
74 void *dataptr, *data2ptr;
75 STRLEN dataoffset;
76
77 Stat_t *statdata;
78} aio_cb;
79
80typedef aio_cb *aio_req; 221typedef eio_req *aio_req;
222typedef eio_req *aio_req_ornot;
81 223
82static int started, wanted; 224static SV *on_next_submit;
83static volatile int nreqs; 225static int next_pri = EIO_PRI_DEFAULT;
84static int max_outstanding = 1<<30; 226static int max_outstanding;
85static int respipe [2];
86 227
87static pthread_mutex_t reslock = PTHREAD_MUTEX_INITIALIZER; 228static s_epipe respipe;
88static pthread_mutex_t reqlock = PTHREAD_MUTEX_INITIALIZER;
89static pthread_cond_t reqwait = PTHREAD_COND_INITIALIZER;
90 229
91static volatile aio_req reqs, reqe; /* queue start, queue end */ 230static void req_destroy (aio_req req);
92static volatile aio_req ress, rese; /* queue start, queue end */
93
94static void free_req (aio_req req) 231static void req_cancel (aio_req req);
95{
96 if (req->data)
97 SvREFCNT_dec (req->data);
98 232
233static void want_poll (void)
234{
235 /* write a dummy byte to the pipe so fh becomes ready */
236 s_epipe_signal (&respipe);
237}
238
239static void done_poll (void)
240{
241 /* read any signals sent by the worker threads */
242 s_epipe_drain (&respipe);
243}
244
245/* must be called at most once */
246static SV *req_sv (aio_req req, HV *stash)
247{
248 if (!req->self)
249 {
250 req->self = (SV *)newHV ();
251 sv_magic (req->self, 0, PERL_MAGIC_ext, (char *)req, 0);
252 }
253
254 return sv_2mortal (sv_bless (newRV_inc (req->self), stash));
255}
256
257static aio_req SvAIO_REQ (SV *sv)
258{
259 MAGIC *mg;
260
261 if (!SvROK (sv)
262 || (SvSTASH (SvRV (sv)) != aio_grp_stash
263 && SvSTASH (SvRV (sv)) != aio_req_stash
264 && !sv_derived_from (sv, "IO::AIO::REQ")))
265 croak ("object of class IO::AIO::REQ expected");
266
267 mg = mg_find (SvRV (sv), PERL_MAGIC_ext);
268
269 return mg ? (aio_req)mg->mg_ptr : 0;
270}
271
272static void aio_grp_feed (aio_req grp)
273{
274 if (grp->sv2 && SvOK (grp->sv2))
275 {
276 dSP;
277
278 ENTER;
279 SAVETMPS;
280 PUSHMARK (SP);
281 XPUSHs (req_sv (grp, aio_grp_stash));
282 PUTBACK;
283 call_sv (grp->sv2, G_VOID | G_EVAL | G_KEEPERR);
284 SPAGAIN;
285 FREETMPS;
286 LEAVE;
287 }
288}
289
290static void req_submit (eio_req *req)
291{
292 eio_submit (req);
293
294 if (expect_false (on_next_submit))
295 {
296 dSP;
297 SV *cb = sv_2mortal (on_next_submit);
298
299 on_next_submit = 0;
300
301 PUSHMARK (SP);
302 PUTBACK;
303 call_sv (cb, G_DISCARD | G_EVAL);
304 }
305}
306
307static int req_invoke (eio_req *req)
308{
309 dSP;
310
311 if (req->flags & FLAG_SV2_RO_OFF)
312 SvREADONLY_off (req->sv2);
313
314 if (!EIO_CANCELLED (req) && req->callback)
315 {
316 ENTER;
317 SAVETMPS;
318 PUSHMARK (SP);
319 EXTEND (SP, 1);
320
321 switch (req->type)
322 {
323 case EIO_READDIR:
324 {
325 SV *rv = &PL_sv_undef;
326
327 if (req->result >= 0)
328 {
329 int i;
330 char *names = (char *)req->ptr2;
331 eio_dirent *ent = (eio_dirent *)req->ptr1; /* might be 0 */
332 AV *av = newAV ();
333
334 av_extend (av, req->result - 1);
335
336 for (i = 0; i < req->result; ++i)
337 {
338 if (req->int1 & EIO_READDIR_DENTS)
339 {
340 SV *namesv = newSVpvn (names + ent->nameofs, ent->namelen);
341
342 if (req->int1 & EIO_READDIR_CUSTOM2)
343 {
344 static SV *sv_type [EIO_DT_MAX + 1]; /* type sv cache */
345 AV *avent = newAV ();
346
347 av_extend (avent, 2);
348
349 if (!sv_type [ent->type])
350 {
351 sv_type [ent->type] = newSViv (ent->type);
352 SvREADONLY_on (sv_type [ent->type]);
353 }
354
355 av_store (avent, 0, namesv);
356 av_store (avent, 1, SvREFCNT_inc (sv_type [ent->type]));
357 av_store (avent, 2, IVSIZE >= 8 ? newSVuv (ent->inode) : newSVnv (ent->inode));
358
359 av_store (av, i, newRV_noinc ((SV *)avent));
360 }
361 else
362 av_store (av, i, namesv);
363
364 ++ent;
365 }
366 else
367 {
368 SV *name = newSVpv (names, 0);
369 av_store (av, i, name);
370 names += SvCUR (name) + 1;
371 }
372 }
373
374 rv = sv_2mortal (newRV_noinc ((SV *)av));
375 }
376
377 PUSHs (rv);
378
379 if (req->int1 & EIO_READDIR_CUSTOM1)
380 XPUSHs (sv_2mortal (newSViv (req->int1 & ~(EIO_READDIR_CUSTOM1 | EIO_READDIR_CUSTOM2))));
381 }
382 break;
383
384 case EIO_OPEN:
385 {
386 /* convert fd to fh */
387 SV *fh = &PL_sv_undef;
388
389 if (req->result >= 0)
390 {
391 GV *gv = (GV *)sv_newmortal ();
392 int flags = req->int1 & (O_RDONLY | O_WRONLY | O_RDWR);
393 char sym [64];
394 int symlen;
395
396 symlen = snprintf (sym, sizeof (sym), "fd#%d", (int)req->result);
397 gv_init (gv, aio_stash, sym, symlen, 0);
398
399 symlen = snprintf (
400 sym,
401 sizeof (sym),
402 "%s&=%d",
403 flags == O_RDONLY ? "<" : flags == O_WRONLY ? ">" : "+<",
404 (int)req->result
405 );
406
407 if (do_open (gv, sym, symlen, 0, 0, 0, 0))
408 fh = (SV *)gv;
409 }
410
411 PUSHs (fh);
412 }
413 break;
414
415 case EIO_STATVFS:
416 case EIO_FSTATVFS:
417 {
418 SV *rv = &PL_sv_undef;
419
420 if (req->result >= 0)
421 {
422 EIO_STRUCT_STATVFS *f = EIO_STATVFS_BUF (req);
423 HV *hv = newHV ();
424
425 rv = sv_2mortal (newRV_noinc ((SV *)hv));
426
427 hv_store (hv, "bsize" , sizeof ("bsize" ) - 1, newSVval64 (f->f_bsize ), 0);
428 hv_store (hv, "frsize" , sizeof ("frsize" ) - 1, newSVval64 (f->f_frsize ), 0);
429 hv_store (hv, "blocks" , sizeof ("blocks" ) - 1, newSVval64 (f->f_blocks ), 0);
430 hv_store (hv, "bfree" , sizeof ("bfree" ) - 1, newSVval64 (f->f_bfree ), 0);
431 hv_store (hv, "bavail" , sizeof ("bavail" ) - 1, newSVval64 (f->f_bavail ), 0);
432 hv_store (hv, "files" , sizeof ("files" ) - 1, newSVval64 (f->f_files ), 0);
433 hv_store (hv, "ffree" , sizeof ("ffree" ) - 1, newSVval64 (f->f_ffree ), 0);
434 hv_store (hv, "favail" , sizeof ("favail" ) - 1, newSVval64 (f->f_favail ), 0);
435 hv_store (hv, "fsid" , sizeof ("fsid" ) - 1, newSVval64 (f->f_fsid ), 0);
436 hv_store (hv, "flag" , sizeof ("flag" ) - 1, newSVval64 (f->f_flag ), 0);
437 hv_store (hv, "namemax", sizeof ("namemax") - 1, newSVval64 (f->f_namemax), 0);
438 }
439
440 PUSHs (rv);
441 }
442
443 break;
444
445 case EIO_GROUP:
446 req->int1 = 2; /* mark group as finished */
447
448 if (req->sv1)
449 {
450 int i;
451 AV *av = (AV *)req->sv1;
452
453 EXTEND (SP, AvFILL (av) + 1);
454 for (i = 0; i <= AvFILL (av); ++i)
455 PUSHs (*av_fetch (av, i, 0));
456 }
457 break;
458
459 case EIO_NOP:
460 case EIO_BUSY:
461 break;
462
463 case EIO_READLINK:
464 if (req->result > 0)
465 PUSHs (sv_2mortal (newSVpvn (req->ptr2, req->result)));
466 break;
467
468 case EIO_STAT:
469 case EIO_LSTAT:
470 case EIO_FSTAT:
471 PL_laststype = req->type == EIO_LSTAT ? OP_LSTAT : OP_STAT;
472 PL_laststatval = req->result;
473 PL_statcache = *(EIO_STRUCT_STAT *)(req->ptr2);
474 PUSHs (sv_2mortal (newSViv (req->result)));
475 break;
476
477 case EIO_READ:
478 {
479 SvCUR_set (req->sv2, req->stroffset + (req->result > 0 ? req->result : 0));
480 *SvEND (req->sv2) = 0;
481 SvPOK_only (req->sv2);
482 SvSETMAGIC (req->sv2);
483 PUSHs (sv_2mortal (newSViv (req->result)));
484 }
485 break;
486
487 case EIO_DUP2:
488 if (req->result > 0)
489 req->result = 0;
490 /* FALLTHROUGH */
491
492 default:
493 PUSHs (sv_2mortal (newSViv (req->result)));
494 break;
495 }
496
497 errno = req->errorno;
498
499 PUTBACK;
500 call_sv (req->callback, G_VOID | G_EVAL | G_DISCARD);
501 SPAGAIN;
502
503 FREETMPS;
504 LEAVE;
505
506 PUTBACK;
507 }
508
509 return !!SvTRUE (ERRSV);
510}
511
512static void req_destroy (aio_req req)
513{
99 if (req->fh) 514 if (req->self)
515 {
516 sv_unmagic (req->self, PERL_MAGIC_ext);
100 SvREFCNT_dec (req->fh); 517 SvREFCNT_dec (req->self);
518 }
101 519
102 if (req->fh2) 520 SvREFCNT_dec (req->sv1);
103 SvREFCNT_dec (req->fh2); 521 SvREFCNT_dec (req->sv2);
104
105 if (req->statdata)
106 Safefree (req->statdata);
107
108 if (req->callback)
109 SvREFCNT_dec (req->callback); 522 SvREFCNT_dec (req->callback);
110
111 if (req->type == REQ_READDIR && req->result >= 0)
112 free (req->data2ptr);
113 523
114 Safefree (req); 524 Safefree (req);
115} 525}
116 526
527static void req_cancel_subs (aio_req grp)
528{
529 aio_req sub;
530
531 if (grp->type != EIO_GROUP)
532 return;
533
534 SvREFCNT_dec (grp->sv2);
535 grp->sv2 = 0;
536
537 eio_grp_cancel (grp);
538}
539
117static void 540static void
118poll_wait () 541create_respipe (void)
119{ 542{
120 if (nreqs && !ress) 543 if (s_epipe_renew (&respipe))
544 croak ("IO::AIO: unable to initialize result pipe");
545}
546
547static void poll_wait (void)
548{
549 while (eio_nreqs ())
121 { 550 {
122 fd_set rfd; 551 int size;
123 FD_ZERO(&rfd);
124 FD_SET(respipe [0], &rfd);
125 552
126 select (respipe [0] + 1, &rfd, 0, 0, 0); 553 X_LOCK (reslock);
554 size = res_queue.size;
555 X_UNLOCK (reslock);
556
557 if (size)
558 return;
559
560 etp_maybe_start_thread ();
561
562 s_epipe_wait (&respipe);
127 } 563 }
128} 564}
129 565
130static int 566static int poll_cb (void)
131poll_cb ()
132{ 567{
133 dSP;
134 int count = 0;
135 int do_croak = 0;
136 aio_req req;
137
138 for (;;) 568 for (;;)
139 { 569 {
140 pthread_mutex_lock (&reslock); 570 int res = eio_poll ();
141 req = ress;
142 571
143 if (req) 572 if (res > 0)
144 {
145 ress = req->next;
146
147 if (!ress)
148 {
149 /* read any signals sent by the worker threads */
150 char buf [32];
151 while (read (respipe [0], buf, 32) == 32)
152 ;
153
154 rese = 0;
155 }
156 }
157
158 pthread_mutex_unlock (&reslock);
159
160 if (!req)
161 break;
162
163 nreqs--;
164
165 if (req->type == REQ_QUIT)
166 started--;
167 else
168 {
169 int errorno = errno;
170 errno = req->errorno;
171
172 if (req->type == REQ_READ)
173 SvCUR_set (req->data, req->dataoffset + (req->result > 0 ? req->result : 0));
174
175 if (req->data2ptr && (req->type == REQ_READ || req->type == REQ_WRITE))
176 SvREADONLY_off (req->data);
177
178 if (req->statdata)
179 {
180 PL_laststype = req->type == REQ_LSTAT ? OP_LSTAT : OP_STAT;
181 PL_laststatval = req->result;
182 PL_statcache = *(req->statdata);
183 }
184
185 ENTER;
186 PUSHMARK (SP);
187
188 if (req->type == REQ_READDIR)
189 {
190 SV *rv = &PL_sv_undef;
191
192 if (req->result >= 0)
193 {
194 char *buf = req->data2ptr;
195 AV *av = newAV ();
196
197 while (req->result)
198 {
199 SV *sv = newSVpv (buf, 0);
200
201 av_push (av, sv);
202 buf += SvCUR (sv) + 1;
203 req->result--;
204 }
205
206 rv = sv_2mortal (newRV_noinc ((SV *)av));
207 }
208
209 XPUSHs (rv);
210 }
211 else
212 {
213 XPUSHs (sv_2mortal (newSViv (req->result)));
214
215 if (req->type == REQ_OPEN)
216 {
217 /* convert fd to fh */
218 SV *fh;
219
220 PUTBACK;
221 call_pv ("IO::AIO::_fd2fh", G_SCALAR | G_EVAL);
222 SPAGAIN;
223
224 fh = SvREFCNT_inc (POPs);
225
226 PUSHMARK (SP);
227 XPUSHs (sv_2mortal (fh));
228 }
229 }
230
231 if (SvOK (req->callback))
232 {
233 PUTBACK;
234 call_sv (req->callback, G_VOID | G_EVAL);
235 SPAGAIN;
236
237 if (SvTRUE (ERRSV))
238 {
239 free_req (req);
240 croak (0); 573 croak (0);
241 }
242 }
243 574
244 LEAVE; 575 if (!max_outstanding || max_outstanding > eio_nreqs ())
576 return res;
245 577
246 errno = errorno; 578 poll_wait ();
247 count++;
248 }
249
250 free_req (req);
251 } 579 }
252
253 return count;
254} 580}
255 581
256static void *aio_proc(void *arg); 582static void atfork_child (void)
257
258static void
259start_thread (void)
260{ 583{
261 sigset_t fullsigset, oldsigset; 584 create_respipe ();
262 pthread_t tid;
263 pthread_attr_t attr;
264
265 pthread_attr_init (&attr);
266 pthread_attr_setstacksize (&attr, STACKSIZE);
267 pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
268
269 sigfillset (&fullsigset);
270 sigprocmask (SIG_SETMASK, &fullsigset, &oldsigset);
271
272 if (pthread_create (&tid, &attr, aio_proc, 0) == 0)
273 started++;
274
275 sigprocmask (SIG_SETMASK, &oldsigset, 0);
276}
277
278static void
279send_req (aio_req req)
280{
281 while (started < wanted && nreqs >= started)
282 start_thread ();
283
284 nreqs++;
285
286 pthread_mutex_lock (&reqlock);
287
288 req->next = 0;
289
290 if (reqe)
291 {
292 reqe->next = req;
293 reqe = req;
294 }
295 else
296 reqe = reqs = req;
297
298 pthread_cond_signal (&reqwait);
299 pthread_mutex_unlock (&reqlock);
300
301 if (nreqs > max_outstanding)
302 for (;;)
303 {
304 poll_cb ();
305
306 if (nreqs <= max_outstanding)
307 break;
308
309 poll_wait ();
310 }
311}
312
313static void
314end_thread (void)
315{
316 aio_req req;
317 Newz (0, req, 1, aio_cb);
318 req->type = REQ_QUIT;
319
320 send_req (req);
321}
322
323static void min_parallel (int nthreads)
324{
325 if (wanted < nthreads)
326 wanted = nthreads;
327}
328
329static void max_parallel (int nthreads)
330{
331 int cur = started;
332
333 if (wanted > nthreads)
334 wanted = nthreads;
335
336 while (cur > wanted)
337 {
338 end_thread ();
339 cur--;
340 }
341
342 while (started > wanted)
343 {
344 poll_wait ();
345 poll_cb ();
346 }
347}
348
349static void create_pipe ()
350{
351 if (pipe (respipe))
352 croak ("unable to initialize result pipe");
353
354 if (fcntl (respipe [0], F_SETFL, O_NONBLOCK))
355 croak ("cannot set result pipe to nonblocking mode");
356
357 if (fcntl (respipe [1], F_SETFL, O_NONBLOCK))
358 croak ("cannot set result pipe to nonblocking mode");
359} 585}
360 586
361/*****************************************************************************/ 587/*****************************************************************************/
362/* work around various missing functions */
363 588
364#if !HAVE_PREADWRITE 589#if !_POSIX_MAPPED_FILES
365# define pread aio_pread 590# define mmap(addr,length,prot,flags,fd,offs) (errno = ENOSYS, -1)
366# define pwrite aio_pwrite 591# define munmap(addr,length) (errno = ENOSYS, -1)
367
368/*
369 * make our pread/pwrite safe against themselves, but not against
370 * normal read/write by using a mutex. slows down execution a lot,
371 * but that's your problem, not mine.
372 */
373static pthread_mutex_t preadwritelock = PTHREAD_MUTEX_INITIALIZER;
374
375static ssize_t
376pread (int fd, void *buf, size_t count, off_t offset)
377{
378 ssize_t res;
379 off_t ooffset;
380
381 pthread_mutex_lock (&preadwritelock);
382 ooffset = lseek (fd, 0, SEEK_CUR);
383 lseek (fd, offset, SEEK_SET);
384 res = read (fd, buf, count);
385 lseek (fd, ooffset, SEEK_SET);
386 pthread_mutex_unlock (&preadwritelock);
387
388 return res;
389}
390
391static ssize_t
392pwrite (int fd, void *buf, size_t count, off_t offset)
393{
394 ssize_t res;
395 off_t ooffset;
396
397 pthread_mutex_lock (&preadwritelock);
398 ooffset = lseek (fd, 0, SEEK_CUR);
399 lseek (fd, offset, SEEK_SET);
400 res = write (fd, buf, count);
401 lseek (fd, offset, SEEK_SET);
402 pthread_mutex_unlock (&preadwritelock);
403
404 return res;
405}
406#endif 592#endif
407 593
408#if !HAVE_FDATASYNC 594#define MMAP_MAGIC PERL_MAGIC_ext
409# define fdatasync fsync
410#endif
411 595
412#if !HAVE_READAHEAD
413# define readahead aio_readahead
414
415static ssize_t
416readahead (int fd, off_t offset, size_t count)
417{
418 char readahead_buf[4096];
419
420 while (count > 0)
421 {
422 size_t len = count < sizeof (readahead_buf) ? count : sizeof (readahead_buf);
423
424 pread (fd, readahead_buf, len, offset);
425 offset += len;
426 count -= len;
427 }
428
429 errno = 0;
430}
431#endif
432
433#if !HAVE_READDIR_R
434# define readdir_r aio_readdir_r
435
436static pthread_mutex_t readdirlock = PTHREAD_MUTEX_INITIALIZER;
437
438static int 596static int
439readdir_r (DIR *dirp, struct dirent *ent, struct dirent **res) 597mmap_free (pTHX_ SV *sv, MAGIC *mg)
440{ 598{
441 struct dirent *e; 599 int old_errno = errno;
442 int errorno; 600 munmap (mg->mg_ptr, (size_t)mg->mg_obj);
443
444 pthread_mutex_lock (&readdirlock);
445
446 e = readdir (dirp);
447 errorno = errno; 601 errno = old_errno;
448 602
449 if (e) 603 mg->mg_obj = 0; /* just in case */
450 {
451 *res = ent;
452 strcpy (ent->d_name, e->d_name);
453 }
454 else
455 *res = 0;
456 604
457 pthread_mutex_unlock (&readdirlock); 605 SvREADONLY_off (sv);
606 SvCUR_set (sv, 0);
607 SvLEN_set (sv, 0);
608 SvPVX (sv) = 0;
609 SvOK_off (sv);
458 610
459 errno = errorno;
460 return e ? 0 : -1;
461}
462#endif
463
464/* sendfile always needs emulation */
465static ssize_t
466sendfile_ (int ofd, int ifd, off_t offset, size_t count)
467{
468 ssize_t res;
469
470 if (!count)
471 return 0; 611 return 0;
472
473#if HAVE_SENDFILE
474# if __linux
475 res = sendfile (ofd, ifd, &offset, count);
476
477# elif __freebsd
478 /*
479 * Of course, the freebsd sendfile is a dire hack with no thoughts
480 * wasted on making it similar to other I/O functions.
481 */
482 {
483 off_t sbytes;
484 res = sendfile (ifd, ofd, offset, count, 0, &sbytes, 0);
485
486 if (res < 0 && sbytes)
487 /* maybe only on EAGAIN only: as usual, the manpage leaves you guessing */
488 res = sbytes;
489 }
490
491# elif __hpux
492 res = sendfile (ofd, ifd, offset, count, 0, 0);
493
494# elif __solaris
495 {
496 struct sendfilevec vec;
497 size_t sbytes;
498
499 vec.sfv_fd = ifd;
500 vec.sfv_flag = 0;
501 vec.sfv_off = offset;
502 vec.sfv_len = count;
503
504 res = sendfilev (ofd, &vec, 1, &sbytes);
505
506 if (res < 0 && sbytes)
507 res = sbytes;
508 }
509
510# endif
511#else
512 res = -1;
513 errno = ENOSYS;
514#endif
515
516 if (res < 0
517 && (errno == ENOSYS || errno == EINVAL || errno == ENOTSOCK
518#if __solaris
519 || errno == EAFNOSUPPORT || errno == EPROTOTYPE
520#endif
521 )
522 )
523 {
524 /* emulate sendfile. this is a major pain in the ass */
525 char buf[4096];
526 res = 0;
527
528 while (count)
529 {
530 ssize_t cnt;
531
532 cnt = pread (ifd, buf, count > 4096 ? 4096 : count, offset);
533
534 if (cnt <= 0)
535 {
536 if (cnt && !res) res = -1;
537 break;
538 }
539
540 cnt = write (ofd, buf, cnt);
541
542 if (cnt <= 0)
543 {
544 if (cnt && !res) res = -1;
545 break;
546 }
547
548 offset += cnt;
549 res += cnt;
550 count -= cnt;
551 }
552 }
553
554 return res;
555} 612}
556 613
557/* read a full directory */ 614static MGVTBL mmap_vtbl = {
558static int 615 0, 0, 0, 0, mmap_free
559scandir_ (const char *path, void **namesp) 616};
560{
561 DIR *dirp = opendir (path);
562 union
563 {
564 struct dirent d;
565 char b [offsetof (struct dirent, d_name) + NAME_MAX + 1];
566 } u;
567 struct dirent *entp;
568 char *name, *names;
569 int memlen = 4096;
570 int memofs = 0;
571 int res = 0;
572 int errorno;
573
574 if (!dirp)
575 return -1;
576
577 names = malloc (memlen);
578
579 for (;;)
580 {
581 errno = 0, readdir_r (dirp, &u.d, &entp);
582
583 if (!entp)
584 break;
585
586 name = entp->d_name;
587
588 if (name [0] != '.' || (name [1] && (name [1] != '.' || name [2])))
589 {
590 int len = strlen (name) + 1;
591
592 res++;
593
594 while (memofs + len > memlen)
595 {
596 memlen *= 2;
597 names = realloc (names, memlen);
598 if (!names)
599 break;
600 }
601
602 memcpy (names + memofs, name, len);
603 memofs += len;
604 }
605 }
606
607 errorno = errno;
608 closedir (dirp);
609
610 if (errorno)
611 {
612 free (names);
613 errno = errorno;
614 res = -1;
615 }
616
617 *namesp = (void *)names;
618 return res;
619}
620 617
621/*****************************************************************************/ 618/*****************************************************************************/
622 619
623static void * 620static SV *
624aio_proc (void *thr_arg) 621get_cb (SV *cb_sv)
625{ 622{
626 aio_req req; 623 SvGETMAGIC (cb_sv);
627 int type; 624 return SvOK (cb_sv) ? s_get_cv_croak (cb_sv) : 0;
628
629 do
630 {
631 pthread_mutex_lock (&reqlock);
632
633 for (;;)
634 {
635 req = reqs;
636
637 if (reqs)
638 {
639 reqs = reqs->next;
640 if (!reqs) reqe = 0;
641 }
642
643 if (req)
644 break;
645
646 pthread_cond_wait (&reqwait, &reqlock);
647 }
648
649 pthread_mutex_unlock (&reqlock);
650
651 errno = 0; /* strictly unnecessary */
652
653 type = req->type;
654
655 switch (type)
656 {
657 case REQ_READ: req->result = pread (req->fd, req->dataptr, req->length, req->offset); break;
658 case REQ_WRITE: req->result = pwrite (req->fd, req->dataptr, req->length, req->offset); break;
659
660 case REQ_READAHEAD: req->result = readahead (req->fd, req->offset, req->length); break;
661 case REQ_SENDFILE: req->result = sendfile_ (req->fd, req->fd2, req->offset, req->length); break;
662
663 case REQ_STAT: req->result = stat (req->dataptr, req->statdata); break;
664 case REQ_LSTAT: req->result = lstat (req->dataptr, req->statdata); break;
665 case REQ_FSTAT: req->result = fstat (req->fd , req->statdata); break;
666
667 case REQ_OPEN: req->result = open (req->dataptr, req->fd, req->mode); break;
668 case REQ_CLOSE: req->result = close (req->fd); break;
669 case REQ_UNLINK: req->result = unlink (req->dataptr); break;
670 case REQ_RMDIR: req->result = rmdir (req->dataptr); break;
671 case REQ_RENAME: req->result = rename (req->data2ptr, req->dataptr); break;
672 case REQ_LINK: req->result = link (req->data2ptr, req->dataptr); break;
673 case REQ_SYMLINK: req->result = symlink (req->data2ptr, req->dataptr); break;
674
675 case REQ_FDATASYNC: req->result = fdatasync (req->fd); break;
676 case REQ_FSYNC: req->result = fsync (req->fd); break;
677 case REQ_READDIR: req->result = scandir_ (req->dataptr, &req->data2ptr); break;
678
679 case REQ_QUIT:
680 break;
681
682 default:
683 req->result = ENOSYS;
684 break;
685 }
686
687 req->errorno = errno;
688
689 pthread_mutex_lock (&reslock);
690
691 req->next = 0;
692
693 if (rese)
694 {
695 rese->next = req;
696 rese = req;
697 }
698 else
699 {
700 rese = ress = req;
701
702 /* write a dummy byte to the pipe so fh becomes ready */
703 write (respipe [1], &respipe, 1);
704 }
705
706 pthread_mutex_unlock (&reslock);
707 }
708 while (type != REQ_QUIT);
709
710 return 0;
711}
712
713/*****************************************************************************/
714
715static void atfork_prepare (void)
716{
717 pthread_mutex_lock (&reqlock);
718 pthread_mutex_lock (&reslock);
719#if !HAVE_PREADWRITE
720 pthread_mutex_lock (&preadwritelock);
721#endif
722#if !HAVE_READDIR_R
723 pthread_mutex_lock (&readdirlock);
724#endif
725}
726
727static void atfork_parent (void)
728{
729#if !HAVE_READDIR_R
730 pthread_mutex_unlock (&readdirlock);
731#endif
732#if !HAVE_PREADWRITE
733 pthread_mutex_unlock (&preadwritelock);
734#endif
735 pthread_mutex_unlock (&reslock);
736 pthread_mutex_unlock (&reqlock);
737}
738
739static void atfork_child (void)
740{
741 aio_req prv;
742
743 started = 0;
744
745 while (reqs)
746 {
747 prv = reqs;
748 reqs = prv->next;
749 free_req (prv);
750 }
751
752 reqs = reqe = 0;
753
754 while (ress)
755 {
756 prv = ress;
757 ress = prv->next;
758 free_req (prv);
759 }
760
761 ress = rese = 0;
762
763 close (respipe [0]);
764 close (respipe [1]);
765 create_pipe ();
766
767 atfork_parent ();
768} 625}
769 626
770#define dREQ \ 627#define dREQ \
628 SV *cb_cv; \
771 aio_req req; \ 629 aio_req req; \
630 int req_pri = next_pri; \
631 next_pri = EIO_PRI_DEFAULT; \
772 \ 632 \
773 if (SvOK (callback) && !SvROK (callback)) \ 633 cb_cv = get_cb (callback); \
774 croak ("clalback must be undef or of reference type"); \
775 \ 634 \
776 Newz (0, req, 1, aio_cb); \ 635 Newz (0, req, 1, eio_req); \
777 if (!req) \ 636 if (!req) \
778 croak ("out of memory during aio_req allocation"); \ 637 croak ("out of memory during eio_req allocation"); \
779 \ 638 \
780 req->callback = newSVsv (callback); 639 req->callback = SvREFCNT_inc (cb_cv); \
781 640 req->pri = req_pri
641
642#define REQ_SEND \
643 PUTBACK; \
644 req_submit (req); \
645 SPAGAIN; \
646 \
647 if (GIMME_V != G_VOID) \
648 XPUSHs (req_sv (req, aio_req_stash));
649
782MODULE = IO::AIO PACKAGE = IO::AIO 650MODULE = IO::AIO PACKAGE = IO::AIO
783 651
784PROTOTYPES: ENABLE 652PROTOTYPES: ENABLE
785 653
786BOOT: 654BOOT:
787{ 655{
656 static const struct {
657 const char *name;
658 IV iv;
659 } *civ, const_iv[] = {
660# define const_niv(name, value) { # name, (IV) value },
661# define const_iv(name) { # name, (IV) name },
662# define const_eio(name) { # name, (IV) EIO_ ## name },
663 const_iv (EXDEV)
664 const_iv (ENOSYS)
665 const_iv (O_RDONLY)
666 const_iv (O_WRONLY)
667 const_iv (O_RDWR)
668 const_iv (O_CREAT)
669 const_iv (O_TRUNC)
670 const_iv (O_EXCL)
671 const_iv (O_APPEND)
672#ifndef _WIN32
673 const_iv (S_IFIFO)
674#endif
675 const_niv (FADV_NORMAL , POSIX_FADV_NORMAL)
676 const_niv (FADV_SEQUENTIAL, POSIX_FADV_SEQUENTIAL)
677 const_niv (FADV_RANDOM , POSIX_FADV_RANDOM)
678 const_niv (FADV_NOREUSE , POSIX_FADV_NOREUSE)
679 const_niv (FADV_WILLNEED , POSIX_FADV_WILLNEED)
680 const_niv (FADV_DONTNEED , POSIX_FADV_DONTNEED)
681
682 const_iv (ST_RDONLY)
683 const_iv (ST_NOSUID)
684 const_iv (ST_NODEV)
685 const_iv (ST_NOEXEC)
686 const_iv (ST_SYNCHRONOUS)
687 const_iv (ST_MANDLOCK)
688 const_iv (ST_WRITE)
689 const_iv (ST_APPEND)
690 const_iv (ST_IMMUTABLE)
691 const_iv (ST_NOATIME)
692 const_iv (ST_NODIRATIME)
693 const_iv (ST_RELATIME)
694
695 const_iv (PROT_EXEC)
696 const_iv (PROT_NONE)
697 const_iv (PROT_READ)
698 const_iv (PROT_WRITE)
699
700 /*const_iv (MAP_FIXED)*/
701 const_iv (MAP_PRIVATE)
702 const_iv (MAP_SHARED)
703 const_iv (MAP_ANONYMOUS)
704
705 /* linuxish */
706 const_iv (MAP_HUGETLB)
707 const_iv (MAP_LOCKED)
708 const_iv (MAP_NORESERVE)
709 const_iv (MAP_POPULATE)
710 const_iv (MAP_NONBLOCK)
711
712 const_iv (MCL_FUTURE)
713 const_iv (MCL_CURRENT)
714
715 const_eio (MS_ASYNC)
716 const_eio (MS_INVALIDATE)
717 const_eio (MS_SYNC)
718
719 const_eio (MT_MODIFY)
720
721 const_eio (SYNC_FILE_RANGE_WAIT_BEFORE)
722 const_eio (SYNC_FILE_RANGE_WRITE)
723 const_eio (SYNC_FILE_RANGE_WAIT_AFTER)
724
725 const_eio (READDIR_DENTS)
726 const_eio (READDIR_DIRS_FIRST)
727 const_eio (READDIR_STAT_ORDER)
728 const_eio (READDIR_FOUND_UNKNOWN)
729
730 const_eio (DT_UNKNOWN)
731 const_eio (DT_FIFO)
732 const_eio (DT_CHR)
733 const_eio (DT_DIR)
734 const_eio (DT_BLK)
735 const_eio (DT_REG)
736 const_eio (DT_LNK)
737 const_eio (DT_SOCK)
738 const_eio (DT_WHT)
739 };
740
788 HV *stash = gv_stashpv ("IO::AIO", 1); 741 aio_stash = gv_stashpv ("IO::AIO" , 1);
789 newCONSTSUB (stash, "EXDEV", newSViv (EXDEV)); 742 aio_req_stash = gv_stashpv ("IO::AIO::REQ", 1);
790 newCONSTSUB (stash, "O_RDONLY", newSViv (O_RDONLY)); 743 aio_grp_stash = gv_stashpv ("IO::AIO::GRP", 1);
791 newCONSTSUB (stash, "O_WRONLY", newSViv (O_WRONLY));
792 744
745 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
746 newCONSTSUB (aio_stash, (char *)civ->name, newSViv (civ->iv));
747
748 newCONSTSUB (aio_stash, "PAGESIZE", newSViv (PAGESIZE));
749
793 create_pipe (); 750 create_respipe ();
794 pthread_atfork (atfork_prepare, atfork_parent, atfork_child);
795}
796 751
752 if (eio_init (want_poll, done_poll) < 0)
753 croak ("IO::AIO: unable to initialise eio library");
754
755 /* atfork child called in fifo order, so before eio's handler */
756 X_THREAD_ATFORK (0, 0, atfork_child);
757}
758
797void 759void
798min_parallel (nthreads) 760max_poll_reqs (int nreqs)
799 int nthreads
800 PROTOTYPE: $ 761 PROTOTYPE: $
762 CODE:
763 eio_set_max_poll_reqs (nreqs);
801 764
802void 765void
803max_parallel (nthreads) 766max_poll_time (double nseconds)
804 int nthreads
805 PROTOTYPE: $ 767 PROTOTYPE: $
806
807int
808max_outstanding (nreqs)
809 int nreqs
810 PROTOTYPE: $
811 CODE: 768 CODE:
812 RETVAL = max_outstanding; 769 eio_set_max_poll_time (nseconds);
770
771void
772min_parallel (int nthreads)
773 PROTOTYPE: $
774 CODE:
775 eio_set_min_parallel (nthreads);
776
777void
778max_parallel (int nthreads)
779 PROTOTYPE: $
780 CODE:
781 eio_set_max_parallel (nthreads);
782
783void
784max_idle (int nthreads)
785 PROTOTYPE: $
786 CODE:
787 eio_set_max_idle (nthreads);
788
789void
790max_outstanding (int maxreqs)
791 PROTOTYPE: $
792 CODE:
813 max_outstanding = nreqs; 793 max_outstanding = maxreqs;
814 794
815void 795void
816aio_open (pathname,flags,mode,callback=&PL_sv_undef) 796aio_open (SV8 *pathname, int flags, int mode, SV *callback=&PL_sv_undef)
817 SV * pathname
818 int flags
819 int mode
820 SV * callback
821 PROTOTYPE: $$$;$ 797 PROTOTYPE: $$$;$
822 CODE: 798 PPCODE:
823{ 799{
824 dREQ; 800 dREQ;
825 801
826 req->type = REQ_OPEN; 802 req->type = EIO_OPEN;
827 req->data = newSVsv (pathname); 803 req->sv1 = newSVsv (pathname);
828 req->dataptr = SvPVbyte_nolen (req->data); 804 req->ptr1 = SvPVbyte_nolen (req->sv1);
829 req->fd = flags; 805 req->int1 = flags;
830 req->mode = mode; 806 req->int2 = mode;
831 807
832 send_req (req); 808 REQ_SEND;
833} 809}
834 810
835void 811void
836aio_close (fh,callback=&PL_sv_undef) 812aio_fsync (SV *fh, SV *callback=&PL_sv_undef)
837 SV * fh
838 SV * callback
839 PROTOTYPE: $;$ 813 PROTOTYPE: $;$
840 ALIAS: 814 ALIAS:
841 aio_close = REQ_CLOSE
842 aio_fsync = REQ_FSYNC 815 aio_fsync = EIO_FSYNC
843 aio_fdatasync = REQ_FDATASYNC 816 aio_fdatasync = EIO_FDATASYNC
844 CODE: 817 PPCODE:
845{ 818{
819 int fd = s_fileno_croak (fh, 0);
846 dREQ; 820 dREQ;
847 821
848 req->type = ix; 822 req->type = ix;
849 req->fh = newSVsv (fh); 823 req->sv1 = newSVsv (fh);
850 req->fd = PerlIO_fileno (IoIFP (sv_2io (fh))); 824 req->int1 = fd;
851 825
852 send_req (req); 826 REQ_SEND (req);
853} 827}
854 828
855void 829void
830aio_sync_file_range (SV *fh, off_t offset, size_t nbytes, UV flags, SV *callback=&PL_sv_undef)
831 PROTOTYPE: $$$$;$
832 PPCODE:
833{
834 int fd = s_fileno_croak (fh, 0);
835 dREQ;
836
837 req->type = EIO_SYNC_FILE_RANGE;
838 req->sv1 = newSVsv (fh);
839 req->int1 = fd;
840 req->offs = offset;
841 req->size = nbytes;
842 req->int2 = flags;
843
844 REQ_SEND (req);
845}
846
847void
848aio_close (SV *fh, SV *callback=&PL_sv_undef)
849 PROTOTYPE: $;$
850 PPCODE:
851{
852 static int close_pipe = -1; /* dummy fd to close fds via dup2 */
853 int fd = s_fileno_croak (fh, 0);
854 dREQ;
855
856 if (close_pipe < 0)
857 {
858 int pipefd [2];
859
860 if (pipe (pipefd) < 0
861 || close (pipefd [1]) < 0
862 || fcntl (pipefd [0], F_SETFD, FD_CLOEXEC) < 0)
863 abort (); /*D*/
864
865 close_pipe = pipefd [0];
866 }
867
868 req->type = EIO_DUP2;
869 req->int1 = close_pipe;
870 req->sv2 = newSVsv (fh);
871 req->int2 = fd;
872
873 REQ_SEND (req);
874}
875
876void
856aio_read (fh,offset,length,data,dataoffset,callback=&PL_sv_undef) 877aio_read (SV *fh, SV *offset, SV *length, SV8 *data, IV dataoffset, SV *callback=&PL_sv_undef)
857 SV * fh
858 UV offset
859 UV length
860 SV * data
861 UV dataoffset
862 SV * callback
863 ALIAS: 878 ALIAS:
864 aio_read = REQ_READ 879 aio_read = EIO_READ
865 aio_write = REQ_WRITE 880 aio_write = EIO_WRITE
866 PROTOTYPE: $$$$$;$ 881 PROTOTYPE: $$$$$;$
867 CODE: 882 PPCODE:
868{ 883{
869 aio_req req;
870 STRLEN svlen; 884 STRLEN svlen;
885 int fd = s_fileno_croak (fh, ix == EIO_WRITE);
871 char *svptr = SvPVbyte (data, svlen); 886 char *svptr = SvPVbyte (data, svlen);
872 887 UV len = SvUV (length);
873 SvUPGRADE (data, SVt_PV);
874 SvPOK_on (data);
875 888
876 if (dataoffset < 0) 889 if (dataoffset < 0)
877 dataoffset += svlen; 890 dataoffset += svlen;
878 891
879 if (dataoffset < 0 || dataoffset > svlen) 892 if (dataoffset < 0 || dataoffset > svlen)
880 croak ("data offset outside of string"); 893 croak ("dataoffset outside of data scalar");
881 894
882 if (ix == REQ_WRITE) 895 if (ix == EIO_WRITE)
883 { 896 {
884 /* write: check length and adjust. */ 897 /* write: check length and adjust. */
885 if (length < 0 || length + dataoffset > svlen) 898 if (!SvOK (length) || len + dataoffset > svlen)
886 length = svlen - dataoffset; 899 len = svlen - dataoffset;
887 } 900 }
888 else 901 else
889 { 902 {
890 /* read: grow scalar as necessary */ 903 /* read: check type and grow scalar as necessary */
904 SvUPGRADE (data, SVt_PV);
891 svptr = SvGROW (data, length + dataoffset); 905 svptr = SvGROW (data, len + dataoffset + 1);
892 } 906 }
893
894 if (length < 0)
895 croak ("length must not be negative");
896 907
897 { 908 {
898 dREQ; 909 dREQ;
899 910
900 req->type = ix; 911 req->type = ix;
901 req->fh = newSVsv (fh); 912 req->sv1 = newSVsv (fh);
902 req->fd = PerlIO_fileno (ix == REQ_READ ? IoIFP (sv_2io (fh)) 913 req->int1 = fd;
903 : IoOFP (sv_2io (fh))); 914 req->offs = SvOK (offset) ? SvVAL64 (offset) : -1;
904 req->offset = offset; 915 req->size = len;
905 req->length = length;
906 req->data = SvREFCNT_inc (data); 916 req->sv2 = SvREFCNT_inc (data);
907 req->dataptr = (char *)svptr + dataoffset; 917 req->ptr2 = (char *)svptr + dataoffset;
918 req->stroffset = dataoffset;
908 919
909 if (!SvREADONLY (data)) 920 if (!SvREADONLY (data))
910 { 921 {
911 SvREADONLY_on (data); 922 SvREADONLY_on (data);
912 req->data2ptr = (void *)data; 923 req->flags |= FLAG_SV2_RO_OFF;
913 } 924 }
914 925
915 send_req (req); 926 REQ_SEND;
916 } 927 }
917} 928}
918 929
919void 930void
931aio_readlink (SV8 *path, SV *callback=&PL_sv_undef)
932 PROTOTYPE: $$;$
933 PPCODE:
934{
935 SV *data;
936 dREQ;
937
938 req->type = EIO_READLINK;
939 req->sv1 = newSVsv (path);
940 req->ptr1 = SvPVbyte_nolen (req->sv1);
941
942 REQ_SEND;
943}
944
945void
920aio_sendfile (out_fh,in_fh,in_offset,length,callback=&PL_sv_undef) 946aio_sendfile (SV *out_fh, SV *in_fh, off_t in_offset, size_t length, SV *callback=&PL_sv_undef)
921 SV * out_fh
922 SV * in_fh
923 UV in_offset
924 UV length
925 SV * callback
926 PROTOTYPE: $$$$;$ 947 PROTOTYPE: $$$$;$
927 CODE: 948 PPCODE:
928{ 949{
950 int ifd = s_fileno_croak (in_fh , 0);
951 int ofd = s_fileno_croak (out_fh, 1);
929 dREQ; 952 dREQ;
930 953
931 req->type = REQ_SENDFILE; 954 req->type = EIO_SENDFILE;
932 req->fh = newSVsv (out_fh); 955 req->sv1 = newSVsv (out_fh);
933 req->fd = PerlIO_fileno (IoIFP (sv_2io (out_fh))); 956 req->int1 = ofd;
934 req->fh2 = newSVsv (in_fh); 957 req->sv2 = newSVsv (in_fh);
935 req->fd2 = PerlIO_fileno (IoIFP (sv_2io (in_fh))); 958 req->int2 = ifd;
936 req->offset = in_offset; 959 req->offs = in_offset;
937 req->length = length; 960 req->size = length;
938 961
939 send_req (req); 962 REQ_SEND;
940} 963}
941 964
942void 965void
943aio_readahead (fh,offset,length,callback=&PL_sv_undef) 966aio_readahead (SV *fh, off_t offset, size_t length, SV *callback=&PL_sv_undef)
944 SV * fh
945 UV offset
946 IV length
947 SV * callback
948 PROTOTYPE: $$$;$ 967 PROTOTYPE: $$$;$
949 CODE: 968 PPCODE:
950{ 969{
970 int fd = s_fileno_croak (fh, 0);
951 dREQ; 971 dREQ;
952 972
953 req->type = REQ_READAHEAD; 973 req->type = EIO_READAHEAD;
954 req->fh = newSVsv (fh); 974 req->sv1 = newSVsv (fh);
955 req->fd = PerlIO_fileno (IoIFP (sv_2io (fh))); 975 req->int1 = fd;
956 req->offset = offset; 976 req->offs = offset;
957 req->length = length; 977 req->size = length;
958 978
959 send_req (req); 979 REQ_SEND;
960} 980}
961 981
962void 982void
963aio_stat (fh_or_path,callback=&PL_sv_undef) 983aio_stat (SV8 *fh_or_path, SV *callback=&PL_sv_undef)
964 SV * fh_or_path
965 SV * callback
966 ALIAS: 984 ALIAS:
967 aio_stat = REQ_STAT 985 aio_stat = EIO_STAT
968 aio_lstat = REQ_LSTAT 986 aio_lstat = EIO_LSTAT
987 aio_statvfs = EIO_STATVFS
969 CODE: 988 PPCODE:
970{ 989{
971 dREQ; 990 dREQ;
972 991
973 New (0, req->statdata, 1, Stat_t); 992 req->sv1 = newSVsv (fh_or_path);
974 if (!req->statdata)
975 {
976 free_req (req);
977 croak ("out of memory during aio_req->statdata allocation");
978 }
979 993
980 if (SvPOK (fh_or_path)) 994 if (SvPOK (req->sv1))
981 { 995 {
982 req->type = ix; 996 req->type = ix;
983 req->data = newSVsv (fh_or_path);
984 req->dataptr = SvPVbyte_nolen (req->data); 997 req->ptr1 = SvPVbyte_nolen (req->sv1);
985 } 998 }
986 else 999 else
987 { 1000 {
988 req->type = REQ_FSTAT; 1001 req->type = ix == EIO_STATVFS ? EIO_FSTATVFS : EIO_FSTAT;
989 req->fh = newSVsv (fh_or_path);
990 req->fd = PerlIO_fileno (IoIFP (sv_2io (fh_or_path))); 1002 req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
991 } 1003 }
992 1004
993 send_req (req); 1005 REQ_SEND;
994} 1006}
995 1007
996void 1008void
1009aio_utime (SV8 *fh_or_path, SV *atime, SV *mtime, SV *callback=&PL_sv_undef)
1010 PPCODE:
1011{
1012 dREQ;
1013
1014 req->nv1 = SvOK (atime) ? SvNV (atime) : -1.;
1015 req->nv2 = SvOK (mtime) ? SvNV (mtime) : -1.;
1016 req->sv1 = newSVsv (fh_or_path);
1017
1018 if (SvPOK (req->sv1))
1019 {
1020 req->type = EIO_UTIME;
1021 req->ptr1 = SvPVbyte_nolen (req->sv1);
1022 }
1023 else
1024 {
1025 req->type = EIO_FUTIME;
1026 req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
1027 }
1028
1029 REQ_SEND;
1030}
1031
1032void
1033aio_truncate (SV8 *fh_or_path, SV *offset, SV *callback=&PL_sv_undef)
1034 PPCODE:
1035{
1036 dREQ;
1037
1038 req->sv1 = newSVsv (fh_or_path);
1039 req->offs = SvOK (offset) ? SvVAL64 (offset) : -1;
1040
1041 if (SvPOK (req->sv1))
1042 {
1043 req->type = EIO_TRUNCATE;
1044 req->ptr1 = SvPVbyte_nolen (req->sv1);
1045 }
1046 else
1047 {
1048 req->type = EIO_FTRUNCATE;
1049 req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
1050 }
1051
1052 REQ_SEND;
1053}
1054
1055void
1056aio_chmod (SV8 *fh_or_path, int mode, SV *callback=&PL_sv_undef)
1057 ALIAS:
1058 aio_chmod = EIO_CHMOD
1059 aio_mkdir = EIO_MKDIR
1060 PPCODE:
1061{
1062 dREQ;
1063
1064 req->int2 = mode;
1065 req->sv1 = newSVsv (fh_or_path);
1066
1067 if (SvPOK (req->sv1))
1068 {
1069 req->type = ix;
1070 req->ptr1 = SvPVbyte_nolen (req->sv1);
1071 }
1072 else
1073 {
1074 req->type = EIO_FCHMOD;
1075 req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
1076 }
1077
1078 REQ_SEND;
1079}
1080
1081void
1082aio_chown (SV8 *fh_or_path, SV *uid, SV *gid, SV *callback=&PL_sv_undef)
1083 PPCODE:
1084{
1085 dREQ;
1086
1087 req->int2 = SvOK (uid) ? SvIV (uid) : -1;
1088 req->int3 = SvOK (gid) ? SvIV (gid) : -1;
1089 req->sv1 = newSVsv (fh_or_path);
1090
1091 if (SvPOK (req->sv1))
1092 {
1093 req->type = EIO_CHOWN;
1094 req->ptr1 = SvPVbyte_nolen (req->sv1);
1095 }
1096 else
1097 {
1098 req->type = EIO_FCHOWN;
1099 req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
1100 }
1101
1102 REQ_SEND;
1103}
1104
1105void
1106aio_readdirx (SV8 *pathname, IV flags, SV *callback=&PL_sv_undef)
1107 PPCODE:
1108{
1109 dREQ;
1110
1111 req->type = EIO_READDIR;
1112 req->sv1 = newSVsv (pathname);
1113 req->ptr1 = SvPVbyte_nolen (req->sv1);
1114 req->int1 = flags | EIO_READDIR_DENTS | EIO_READDIR_CUSTOM1;
1115
1116 if (flags & EIO_READDIR_DENTS)
1117 req->int1 |= EIO_READDIR_CUSTOM2;
1118
1119 REQ_SEND;
1120}
1121
1122void
997aio_unlink (pathname,callback=&PL_sv_undef) 1123aio_unlink (SV8 *pathname, SV *callback=&PL_sv_undef)
998 SV * pathname
999 SV * callback
1000 ALIAS: 1124 ALIAS:
1001 aio_unlink = REQ_UNLINK 1125 aio_unlink = EIO_UNLINK
1002 aio_rmdir = REQ_RMDIR 1126 aio_rmdir = EIO_RMDIR
1003 aio_readdir = REQ_READDIR 1127 aio_readdir = EIO_READDIR
1004 CODE: 1128 PPCODE:
1005{ 1129{
1006 dREQ; 1130 dREQ;
1007 1131
1008 req->type = ix; 1132 req->type = ix;
1009 req->data = newSVsv (pathname); 1133 req->sv1 = newSVsv (pathname);
1010 req->dataptr = SvPVbyte_nolen (req->data); 1134 req->ptr1 = SvPVbyte_nolen (req->sv1);
1011
1012 send_req (req);
1013}
1014 1135
1136 REQ_SEND;
1137}
1138
1015void 1139void
1016aio_link (oldpath,newpath,callback=&PL_sv_undef) 1140aio_link (SV8 *oldpath, SV8 *newpath, SV *callback=&PL_sv_undef)
1017 SV * oldpath
1018 SV * newpath
1019 SV * callback
1020 ALIAS: 1141 ALIAS:
1021 aio_link = REQ_LINK 1142 aio_link = EIO_LINK
1022 aio_symlink = REQ_SYMLINK 1143 aio_symlink = EIO_SYMLINK
1023 aio_rename = REQ_RENAME 1144 aio_rename = EIO_RENAME
1024 CODE: 1145 PPCODE:
1025{ 1146{
1026 dREQ; 1147 dREQ;
1027 1148
1028 req->type = ix; 1149 req->type = ix;
1029 req->fh = newSVsv (oldpath); 1150 req->sv1 = newSVsv (oldpath);
1030 req->data2ptr = SvPVbyte_nolen (req->fh); 1151 req->ptr1 = SvPVbyte_nolen (req->sv1);
1031 req->data = newSVsv (newpath); 1152 req->sv2 = newSVsv (newpath);
1032 req->dataptr = SvPVbyte_nolen (req->data); 1153 req->ptr2 = SvPVbyte_nolen (req->sv2);
1033 1154
1034 send_req (req); 1155 REQ_SEND;
1035} 1156}
1036 1157
1037#if 0
1038
1039# undocumented, because it does not cancel active requests
1040void 1158void
1041cancel_most_requests () 1159aio_mknod (SV8 *pathname, int mode, UV dev, SV *callback=&PL_sv_undef)
1160 PPCODE:
1161{
1162 dREQ;
1163
1164 req->type = EIO_MKNOD;
1165 req->sv1 = newSVsv (pathname);
1166 req->ptr1 = SvPVbyte_nolen (req->sv1);
1167 req->int2 = (mode_t)mode;
1168 req->offs = dev;
1169
1170 REQ_SEND;
1171}
1172
1173void
1174aio_mtouch (SV8 *data, IV offset = 0, SV *length = &PL_sv_undef, int flags = 0, SV *callback=&PL_sv_undef)
1175 ALIAS:
1176 aio_mtouch = EIO_MTOUCH
1177 aio_msync = EIO_MSYNC
1042 PROTOTYPE: 1178 PROTOTYPE: $$$$;$
1043 CODE: 1179 PPCODE:
1044{ 1180{
1045 aio_req *req; 1181 STRLEN svlen;
1182 UV len = SvUV (length);
1183 char *svptr = SvPVbyte (data, svlen);
1046 1184
1047 pthread_mutex_lock (&reqlock); 1185 if (offset < 0)
1048 for (req = reqs; req; req = req->next) 1186 offset += svlen;
1049 req->flags |= 1;
1050 pthread_mutex_unlock (&reqlock);
1051 1187
1052 pthread_mutex_lock (&reslock); 1188 if (offset < 0 || offset > svlen)
1053 for (req = ress; req; req = req->next) 1189 croak ("offset outside of scalar");
1054 req->flags |= 1;
1055 pthread_mutex_unlock (&reslock);
1056}
1057 1190
1058#endif 1191 if (!SvOK (length) || len + offset > svlen)
1192 len = svlen - offset;
1193
1194 {
1195 dREQ;
1196
1197 req->type = ix;
1198 req->size = len;
1199 req->sv2 = SvREFCNT_inc (data);
1200 req->ptr2 = (char *)svptr + offset;
1201 req->int1 = flags;
1202
1203 REQ_SEND;
1204 }
1205}
1206
1207void
1208aio_busy (double delay, SV *callback=&PL_sv_undef)
1209 PPCODE:
1210{
1211 dREQ;
1212
1213 req->type = EIO_BUSY;
1214 req->nv1 = delay < 0. ? 0. : delay;
1215
1216 REQ_SEND;
1217}
1218
1219void
1220aio_group (SV *callback=&PL_sv_undef)
1221 PROTOTYPE: ;$
1222 PPCODE:
1223{
1224 dREQ;
1225
1226 req->type = EIO_GROUP;
1227
1228 req_submit (req);
1229 XPUSHs (req_sv (req, aio_grp_stash));
1230}
1231
1232void
1233aio_nop (SV *callback=&PL_sv_undef)
1234 ALIAS:
1235 aio_nop = EIO_NOP
1236 aio_sync = EIO_SYNC
1237 PPCODE:
1238{
1239 dREQ;
1240
1241 req->type = ix;
1242
1243 REQ_SEND;
1244}
1245
1246int
1247aioreq_pri (int pri = 0)
1248 PROTOTYPE: ;$
1249 CODE:
1250 RETVAL = next_pri;
1251 if (items > 0)
1252 {
1253 if (pri < EIO_PRI_MIN) pri = EIO_PRI_MIN;
1254 if (pri > EIO_PRI_MAX) pri = EIO_PRI_MAX;
1255 next_pri = pri;
1256 }
1257 OUTPUT:
1258 RETVAL
1259
1260void
1261aioreq_nice (int nice = 0)
1262 CODE:
1263 nice = next_pri - nice;
1264 if (nice < EIO_PRI_MIN) nice = EIO_PRI_MIN;
1265 if (nice > EIO_PRI_MAX) nice = EIO_PRI_MAX;
1266 next_pri = nice;
1059 1267
1060void 1268void
1061flush () 1269flush ()
1062 PROTOTYPE: 1270 PROTOTYPE:
1063 CODE: 1271 CODE:
1064 while (nreqs) 1272 while (eio_nreqs ())
1065 { 1273 {
1066 poll_wait (); 1274 poll_wait ();
1067 poll_cb (); 1275 poll_cb ();
1068 } 1276 }
1069 1277
1070void 1278int
1071poll() 1279poll()
1072 PROTOTYPE: 1280 PROTOTYPE:
1073 CODE: 1281 CODE:
1074 if (nreqs)
1075 {
1076 poll_wait (); 1282 poll_wait ();
1077 poll_cb (); 1283 RETVAL = poll_cb ();
1078 } 1284 OUTPUT:
1285 RETVAL
1079 1286
1080int 1287int
1081poll_fileno() 1288poll_fileno()
1082 PROTOTYPE: 1289 PROTOTYPE:
1083 CODE: 1290 CODE:
1084 RETVAL = respipe [0]; 1291 RETVAL = s_epipe_fd (&respipe);
1085 OUTPUT: 1292 OUTPUT:
1086 RETVAL 1293 RETVAL
1087 1294
1088int 1295int
1089poll_cb(...) 1296poll_cb(...)
1095 1302
1096void 1303void
1097poll_wait() 1304poll_wait()
1098 PROTOTYPE: 1305 PROTOTYPE:
1099 CODE: 1306 CODE:
1100 if (nreqs)
1101 poll_wait (); 1307 poll_wait ();
1102 1308
1103int 1309int
1104nreqs() 1310nreqs()
1105 PROTOTYPE: 1311 PROTOTYPE:
1106 CODE: 1312 CODE:
1107 RETVAL = nreqs; 1313 RETVAL = eio_nreqs ();
1108 OUTPUT: 1314 OUTPUT:
1109 RETVAL 1315 RETVAL
1110 1316
1317int
1318nready()
1319 PROTOTYPE:
1320 CODE:
1321 RETVAL = eio_nready ();
1322 OUTPUT:
1323 RETVAL
1324
1325int
1326npending()
1327 PROTOTYPE:
1328 CODE:
1329 RETVAL = eio_npending ();
1330 OUTPUT:
1331 RETVAL
1332
1333int
1334nthreads()
1335 PROTOTYPE:
1336 CODE:
1337 RETVAL = eio_nthreads ();
1338 OUTPUT:
1339 RETVAL
1340
1341int
1342fadvise (aio_rfd fh, off_t offset, off_t length, IV advice)
1343 PROTOTYPE: $$$$
1344 CODE:
1345#if _XOPEN_SOURCE >= 600 && !NO_FADVISE
1346 RETVAL = posix_fadvise (fh, offset, length, advice);
1347#else
1348 RETVAL = errno = ENOSYS; /* yes, this is actually correct */
1349#endif
1350 OUTPUT:
1351 RETVAL
1352
1353ssize_t
1354sendfile (aio_wfd ofh, aio_rfd ifh, off_t offset, size_t count)
1355 PROTOTYPE: $$$$
1356 CODE:
1357 RETVAL = eio_sendfile_sync (ofh, ifh, offset, count);
1358 OUTPUT:
1359 RETVAL
1360
1361void
1362mmap (SV *scalar, size_t length, int prot, int flags, SV *fh, off_t offset = 0)
1363 PROTOTYPE: $$$$$;$
1364 PPCODE:
1365 sv_unmagic (scalar, MMAP_MAGIC);
1366{
1367 int fd = SvOK (fh) ? s_fileno_croak (fh, flags & PROT_WRITE) : -1;
1368 void *addr = (void *)mmap (0, length, prot, flags, fd, offset);
1369 if (addr == (void *)-1)
1370 XSRETURN_NO;
1371
1372 /* we store the length in mg_obj, as namlen is I32 :/ */
1373 sv_magicext (scalar, 0, MMAP_MAGIC, &mmap_vtbl, (char *)addr, 0)
1374 ->mg_obj = (SV *)length;
1375
1376 SvUPGRADE (scalar, SVt_PV); /* nop... */
1377 if (!(prot & PROT_WRITE))
1378 SvREADONLY_on (scalar);
1379
1380 SvPVX (scalar) = (char *)addr;
1381 SvCUR_set (scalar, length);
1382 SvLEN_set (scalar, 0);
1383 SvPOK_only (scalar);
1384
1385 XSRETURN_YES;
1386}
1387
1388void
1389munmap (SV *scalar)
1390 PROTOTYPE: $
1391 CODE:
1392 sv_unmagic (scalar, MMAP_MAGIC);
1393
1394int
1395mlockall (int flags)
1396 PROTOTYPE: $
1397 CODE:
1398#if _POSIX_MEMLOCK
1399#if __GLIBC__ == 2 && __GLIBC_MINOR__ <= 7
1400 extern int mallopt (int, int);
1401 mallopt (-6, 238); /* http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=473812 */
1402#endif
1403 mlockall (flags);
1404#else
1405 RETVAL = -1;
1406 errno = ENOSYS;
1407#endif
1408 OUTPUT:
1409 RETVAL
1410
1411int
1412munlockall ()
1413 PROTOTYPE:
1414 CODE:
1415#if _POSIX_MEMLOCK
1416 munlockall ();
1417#else
1418 RETVAL = -1;
1419 errno = ENOSYS;
1420#endif
1421 OUTPUT:
1422 RETVAL
1423
1424void _on_next_submit (SV *cb)
1425 CODE:
1426 SvREFCNT_dec (on_next_submit);
1427 on_next_submit = SvOK (cb) ? newSVsv (cb) : 0;
1428
1429PROTOTYPES: DISABLE
1430
1431MODULE = IO::AIO PACKAGE = IO::AIO::REQ
1432
1433void
1434cancel (aio_req_ornot req)
1435 CODE:
1436 eio_cancel (req);
1437
1438void
1439cb (aio_req_ornot req, SV *callback=&PL_sv_undef)
1440 PPCODE:
1441{
1442 if (GIMME_V != G_VOID)
1443 XPUSHs (req->callback ? sv_2mortal (newRV_inc (req->callback)) : &PL_sv_undef);
1444
1445 if (items > 1)
1446 {
1447 SV *cb_cv =get_cb (callback);
1448
1449 SvREFCNT_dec (req->callback);
1450 req->callback = SvREFCNT_inc (cb_cv);
1451 }
1452}
1453
1454MODULE = IO::AIO PACKAGE = IO::AIO::GRP
1455
1456void
1457add (aio_req grp, ...)
1458 PPCODE:
1459{
1460 int i;
1461
1462 if (grp->int1 == 2)
1463 croak ("cannot add requests to IO::AIO::GRP after the group finished");
1464
1465 for (i = 1; i < items; ++i )
1466 {
1467 aio_req req;
1468
1469 if (GIMME_V != G_VOID)
1470 XPUSHs (sv_2mortal (newSVsv (ST (i))));
1471
1472 req = SvAIO_REQ (ST (i));
1473
1474 if (req)
1475 eio_grp_add (grp, req);
1476 }
1477}
1478
1479void
1480cancel_subs (aio_req_ornot req)
1481 CODE:
1482 req_cancel_subs (req);
1483
1484void
1485result (aio_req grp, ...)
1486 CODE:
1487{
1488 int i;
1489 AV *av;
1490
1491 grp->errorno = errno;
1492
1493 av = newAV ();
1494 av_extend (av, items - 1);
1495
1496 for (i = 1; i < items; ++i )
1497 av_push (av, newSVsv (ST (i)));
1498
1499 SvREFCNT_dec (grp->sv1);
1500 grp->sv1 = (SV *)av;
1501}
1502
1503void
1504errno (aio_req grp, int errorno = errno)
1505 CODE:
1506 grp->errorno = errorno;
1507
1508void
1509limit (aio_req grp, int limit)
1510 CODE:
1511 eio_grp_limit (grp, limit);
1512
1513void
1514feed (aio_req grp, SV *callback=&PL_sv_undef)
1515 CODE:
1516{
1517 SvREFCNT_dec (grp->sv2);
1518 grp->sv2 = newSVsv (callback);
1519 grp->feed = aio_grp_feed;
1520
1521 if (grp->int2 <= 0)
1522 grp->int2 = 2;
1523
1524 eio_grp_limit (grp, grp->int2);
1525}
1526

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines