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.1 by root, Sun Jul 10 17:07:44 2005 UTC vs.
Revision 1.56 by root, Mon Oct 23 14:49:51 2006 UTC

1#define PERL_NO_GET_CONTEXT 1#define _REENTRANT 1
2#include <errno.h>
2 3
3#include "EXTERN.h" 4#include "EXTERN.h"
4#include "perl.h" 5#include "perl.h"
5#include "XSUB.h" 6#include "XSUB.h"
6 7
8#include "autoconf/config.h"
9
10#include <pthread.h>
11
12#include <stddef.h>
13#include <errno.h>
14#include <sys/time.h>
15#include <sys/select.h>
7#include <sys/types.h> 16#include <sys/types.h>
8#include <sys/stat.h> 17#include <sys/stat.h>
18#include <limits.h>
9#include <unistd.h> 19#include <unistd.h>
10#include <fcntl.h> 20#include <fcntl.h>
11#include <signal.h> 21#include <signal.h>
12#include <sched.h> 22#include <sched.h>
13#include <endian.h>
14 23
15#include <pthread.h> 24#if HAVE_SENDFILE
25# if __linux
26# include <sys/sendfile.h>
27# elif __freebsd
16#include <sys/syscall.h> 28# include <sys/socket.h>
29# include <sys/uio.h>
30# elif __hpux
31# include <sys/socket.h>
32# elif __solaris /* not yet */
33# include <sys/sendfile.h>
34# else
35# error sendfile support requested but not available
36# endif
37#endif
17 38
18typedef void *InputStream; /* hack, but 5.6.1 is simply toooo old ;) */ 39/* used for struct dirent, AIX doesn't provide it */
19typedef void *OutputStream; /* hack, but 5.6.1 is simply toooo old ;) */ 40#ifndef NAME_MAX
20typedef void *InOutStream; /* hack, but 5.6.1 is simply toooo old ;) */ 41# define NAME_MAX 4096
42#endif
21 43
22#if __i386 || __amd64
23# define STACKSIZE ( 256 * sizeof (long))
24#elif __ia64 44#if __ia64
25# define STACKSIZE (8192 * sizeof (long)) 45# define STACKSIZE 65536
26#else 46#else
27# define STACKSIZE ( 512 * sizeof (long)) 47# define STACKSIZE 8192
28#endif 48#endif
29 49
30enum { 50enum {
31 REQ_QUIT, 51 REQ_QUIT,
32 REQ_OPEN, REQ_CLOSE, 52 REQ_OPEN, REQ_CLOSE,
33 REQ_READ, REQ_WRITE, REQ_READAHEAD, 53 REQ_READ, REQ_WRITE, REQ_READAHEAD,
54 REQ_SENDFILE,
34 REQ_STAT, REQ_LSTAT, REQ_FSTAT, REQ_UNLINK, 55 REQ_STAT, REQ_LSTAT, REQ_FSTAT,
35 REQ_FSYNC, REQ_FDATASYNC, 56 REQ_FSYNC, REQ_FDATASYNC,
57 REQ_UNLINK, REQ_RMDIR, REQ_RENAME,
58 REQ_READDIR,
59 REQ_LINK, REQ_SYMLINK,
60 REQ_GROUP, REQ_NOP,
61 REQ_SLEEP,
36}; 62};
37 63
64#define AIO_REQ_KLASS "IO::AIO::REQ"
65#define AIO_GRP_KLASS "IO::AIO::GRP"
66
38typedef struct aio_cb { 67typedef struct aio_cb
68{
39 struct aio_cb *next; 69 struct aio_cb *volatile next;
40 70
41 int type; 71 struct aio_cb *grp, *grp_prev, *grp_next, *grp_first;
42 72
43 int fd; 73 SV *self; /* the perl counterpart of this request, if any */
74
75 SV *data, *callback;
76 SV *fh, *fh2;
77 void *dataptr, *data2ptr;
78 Stat_t *statdata;
44 off_t offset; 79 off_t offset;
45 size_t length; 80 size_t length;
46 ssize_t result; 81 ssize_t result;
82
83 int type;
84 int fd, fd2;
85 int errorno;
86 STRLEN dataoffset;
47 mode_t mode; /* open */ 87 mode_t mode; /* open */
48 int errorno; 88 unsigned char cancelled;
49 SV *data, *callback;
50 void *dataptr;
51 STRLEN dataoffset;
52
53 Stat_t *statdata;
54} aio_cb; 89} aio_cb;
55 90
56typedef aio_cb *aio_req; 91typedef aio_cb *aio_req;
92typedef aio_cb *aio_req_ornot;
57 93
58static int started; 94static int started, wanted;
59static int nreqs; 95static volatile int nreqs;
96static int max_outstanding = 1<<30;
60static int reqpipe[2], respipe[2]; 97static int respipe [2];
61 98
99static pthread_mutex_t reslock = PTHREAD_MUTEX_INITIALIZER;
100static pthread_mutex_t reqlock = PTHREAD_MUTEX_INITIALIZER;
101static pthread_cond_t reqwait = PTHREAD_COND_INITIALIZER;
102
62static aio_req qs, qe; /* queue start, queue end */ 103static volatile aio_req reqs, reqe; /* queue start, queue end */
104static volatile aio_req ress, rese; /* queue start, queue end */
63 105
64static void *aio_proc(void *arg); 106static void req_invoke (aio_req req);
107static void req_free (aio_req req);
65 108
66static void 109/* must be called at most once */
67start_thread (void) 110static SV *req_sv (aio_req req, const char *klass)
68{ 111{
69 sigset_t fullsigset, oldsigset; 112 if (!req->self)
70 pthread_t tid;
71 pthread_attr_t attr;
72
73 pthread_attr_init (&attr);
74 pthread_attr_setstacksize (&attr, STACKSIZE);
75 pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
76
77 sigfillset (&fullsigset);
78 sigprocmask (SIG_SETMASK, &fullsigset, &oldsigset);
79
80 if (pthread_create (&tid, &attr, aio_proc, 0) == 0)
81 started++;
82
83 sigprocmask (SIG_SETMASK, &oldsigset, 0);
84}
85
86static void
87send_reqs (void)
88{
89 /* this write is atomic */
90 while (qs && write (reqpipe[1], &qs, sizeof qs) == sizeof qs)
91 { 113 {
92 qs = qs->next; 114 req->self = (SV *)newHV ();
93 if (!qs) qe = 0; 115 sv_magic (req->self, 0, PERL_MAGIC_ext, (char *)req, 0);
94 } 116 }
95}
96 117
97static void 118 return sv_2mortal (sv_bless (newRV_inc (req->self), gv_stashpv (klass, 1)));
98send_req (aio_req req) 119}
99{
100 nreqs++;
101 req->next = 0;
102 120
103 if (qe) 121static aio_req SvAIO_REQ (SV *sv)
104 { 122{
105 qe->next = req; 123 MAGIC *mg;
106 qe = req; 124
125 if (!sv_derived_from (sv, AIO_REQ_KLASS) || !SvROK (sv))
126 croak ("object of class " AIO_REQ_KLASS " expected");
127
128 mg = mg_find (SvRV (sv), PERL_MAGIC_ext);
129
130 return mg ? (aio_req)mg->mg_ptr : 0;
131}
132
133static void aio_grp_feed (aio_req grp)
134{
135 while (grp->length < grp->fd2)
107 } 136 {
108 else 137 int old_len = grp->length;
109 qe = qs = req;
110 138
111 send_reqs (); 139 if (grp->fh2 && SvOK (grp->fh2))
112} 140 {
141 dSP;
113 142
114static void 143 ENTER;
115end_thread (void) 144 SAVETMPS;
116{ 145 PUSHMARK (SP);
117 aio_req req; 146 XPUSHs (req_sv (grp, AIO_GRP_KLASS));
118 New (0, req, 1, aio_cb); 147 PUTBACK;
119 req->type = REQ_QUIT; 148 call_sv (grp->fh2, G_VOID | G_EVAL);
149 SPAGAIN;
150 FREETMPS;
151 LEAVE;
152 }
120 153
121 send_req (req); 154 /* stop if no progress has been made */
122} 155 if (old_len == grp->length)
123 156 {
124static void 157 SvREFCNT_dec (grp->fh2);
125read_write (pTHX_ 158 grp->fh2 = 0;
126 int dowrite, int fd, off_t offset, size_t length, 159 break;
127 SV *data, STRLEN dataoffset, SV *callback) 160 }
128{
129 aio_req req;
130 STRLEN svlen;
131 char *svptr = SvPV (data, svlen);
132
133 SvUPGRADE (data, SVt_PV);
134 SvPOK_on (data);
135
136 if (dataoffset < 0)
137 dataoffset += svlen;
138
139 if (dataoffset < 0 || dataoffset > svlen)
140 croak ("data offset outside of string");
141
142 if (dowrite)
143 { 161 }
144 /* write: check length and adjust. */ 162}
145 if (length < 0 || length + dataoffset > svlen) 163
146 length = svlen - dataoffset; 164static void aio_grp_dec (aio_req grp)
165{
166 --grp->length;
167
168 /* call feeder, if applicable */
169 aio_grp_feed (grp);
170
171 /* finish, if done */
172 if (!grp->length && grp->fd)
147 } 173 {
148 else 174 req_invoke (grp);
175 req_free (grp);
149 { 176 }
150 /* read: grow scalar as necessary */ 177}
151 svptr = SvGROW (data, length + dataoffset); 178
179static void poll_wait ()
180{
181 if (nreqs && !ress)
152 } 182 {
153
154 if (length < 0)
155 croak ("length must not be negative");
156
157 Newz (0, req, 1, aio_cb);
158
159 if (!req)
160 croak ("out of memory during aio_req allocation");
161
162 req->type = dowrite ? REQ_WRITE : REQ_READ;
163 req->fd = fd;
164 req->offset = offset;
165 req->length = length;
166 req->data = SvREFCNT_inc (data);
167 req->dataptr = (char *)svptr + dataoffset;
168 req->callback = SvREFCNT_inc (callback);
169
170 send_req (req);
171}
172
173static void
174poll_wait ()
175{
176 fd_set rfd; 183 fd_set rfd;
177 FD_ZERO(&rfd); 184 FD_ZERO(&rfd);
178 FD_SET(respipe[0], &rfd); 185 FD_SET(respipe [0], &rfd);
179 186
180 select (respipe[0] + 1, &rfd, 0, 0, 0); 187 select (respipe [0] + 1, &rfd, 0, 0, 0);
188 }
181} 189}
182 190
183static int 191static void req_invoke (aio_req req)
184poll_cb (pTHX) 192{
193 dSP;
194 int errorno = errno;
195
196 if (req->cancelled || !SvOK (req->callback))
197 return;
198
199 errno = req->errorno;
200
201 ENTER;
202 SAVETMPS;
203 PUSHMARK (SP);
204 EXTEND (SP, 1);
205
206 switch (req->type)
207 {
208 case REQ_READDIR:
209 {
210 SV *rv = &PL_sv_undef;
211
212 if (req->result >= 0)
213 {
214 char *buf = req->data2ptr;
215 AV *av = newAV ();
216
217 while (req->result)
218 {
219 SV *sv = newSVpv (buf, 0);
220
221 av_push (av, sv);
222 buf += SvCUR (sv) + 1;
223 req->result--;
224 }
225
226 rv = sv_2mortal (newRV_noinc ((SV *)av));
227 }
228
229 PUSHs (rv);
230 }
231 break;
232
233 case REQ_OPEN:
234 {
235 /* convert fd to fh */
236 SV *fh;
237
238 PUSHs (sv_2mortal (newSViv (req->result)));
239 PUTBACK;
240 call_pv ("IO::AIO::_fd2fh", G_SCALAR | G_EVAL);
241 SPAGAIN;
242
243 fh = SvREFCNT_inc (POPs);
244
245 PUSHMARK (SP);
246 XPUSHs (sv_2mortal (fh));
247 }
248 break;
249
250 case REQ_GROUP:
251 req->fd = 2; /* mark group as finished */
252
253 if (req->data)
254 {
255 int i;
256 AV *av = (AV *)req->data;
257
258 EXTEND (SP, AvFILL (av) + 1);
259 for (i = 0; i <= AvFILL (av); ++i)
260 PUSHs (*av_fetch (av, i, 0));
261 }
262 break;
263
264 case REQ_NOP:
265 case REQ_SLEEP:
266 break;
267
268 default:
269 PUSHs (sv_2mortal (newSViv (req->result)));
270 break;
271 }
272
273
274 PUTBACK;
275 call_sv (req->callback, G_VOID | G_EVAL);
276 SPAGAIN;
277
278 FREETMPS;
279 LEAVE;
280
281 errno = errorno;
282
283 if (SvTRUE (ERRSV))
284 {
285 req_free (req);
286 croak (0);
287 }
288}
289
290static void req_free (aio_req req)
291{
292 if (req->grp)
293 {
294 aio_req grp = req->grp;
295
296 /* unlink request */
297 if (req->grp_next) req->grp_next->grp_prev = req->grp_prev;
298 if (req->grp_prev) req->grp_prev->grp_next = req->grp_next;
299
300 if (grp->grp_first == req)
301 grp->grp_first = req->grp_next;
302
303 aio_grp_dec (grp);
304 }
305
306 if (req->self)
307 {
308 sv_unmagic (req->self, PERL_MAGIC_ext);
309 SvREFCNT_dec (req->self);
310 }
311
312 SvREFCNT_dec (req->data);
313 SvREFCNT_dec (req->fh);
314 SvREFCNT_dec (req->fh2);
315 SvREFCNT_dec (req->callback);
316 Safefree (req->statdata);
317
318 if (req->type == REQ_READDIR && req->result >= 0)
319 free (req->data2ptr);
320
321 Safefree (req);
322}
323
324static void req_cancel (aio_req req)
325{
326 req->cancelled = 1;
327
328 if (req->type == REQ_GROUP)
329 {
330 aio_req sub;
331
332 for (sub = req->grp_first; sub; sub = sub->grp_next)
333 req_cancel (sub);
334 }
335}
336
337static int poll_cb ()
185{ 338{
186 dSP; 339 dSP;
187 int count = 0; 340 int count = 0;
341 int do_croak = 0;
188 aio_req req; 342 aio_req req;
189 343
190 while (read (respipe[0], (void *)&req, sizeof (req)) == sizeof (req)) 344 for (;;)
191 { 345 {
346 pthread_mutex_lock (&reslock);
347 req = ress;
348
349 if (req)
350 {
351 ress = req->next;
352
353 if (!ress)
354 {
355 /* read any signals sent by the worker threads */
356 char buf [32];
357 while (read (respipe [0], buf, 32) == 32)
358 ;
359
360 rese = 0;
361 }
362 }
363
364 pthread_mutex_unlock (&reslock);
365
366 if (!req)
367 break;
368
192 nreqs--; 369 --nreqs;
193 370
194 if (req->type == REQ_QUIT) 371 if (req->type == REQ_QUIT)
195 started--; 372 started--;
373 else if (req->type == REQ_GROUP && req->length)
374 {
375 req->fd = 1; /* mark request as delayed */
376 continue;
377 }
196 else 378 else
197 { 379 {
198 int errorno = errno;
199 errno = req->errorno;
200
201 if (req->type == REQ_READ) 380 if (req->type == REQ_READ)
202 SvCUR_set (req->data, req->dataoffset 381 SvCUR_set (req->data, req->dataoffset + (req->result > 0 ? req->result : 0));
203 + req->result > 0 ? req->result : 0);
204 382
383 if (req->data2ptr && (req->type == REQ_READ || req->type == REQ_WRITE))
384 SvREADONLY_off (req->data);
385
205 if (req->data) 386 if (req->statdata)
206 SvREFCNT_dec (req->data);
207
208 if (req->type == REQ_STAT || req->type == REQ_LSTAT || req->type == REQ_FSTAT)
209 { 387 {
210 PL_laststype = req->type == REQ_LSTAT ? OP_LSTAT : OP_STAT; 388 PL_laststype = req->type == REQ_LSTAT ? OP_LSTAT : OP_STAT;
211 PL_laststatval = req->result; 389 PL_laststatval = req->result;
212 PL_statcache = *(req->statdata); 390 PL_statcache = *(req->statdata);
213
214 Safefree (req->statdata);
215 } 391 }
216 392
217 PUSHMARK (SP); 393 req_invoke (req);
218 XPUSHs (sv_2mortal (newSViv (req->result)));
219 PUTBACK;
220 call_sv (req->callback, G_VOID);
221 SPAGAIN;
222
223 if (req->callback)
224 SvREFCNT_dec (req->callback);
225 394
226 errno = errorno;
227 count++; 395 count++;
228 } 396 }
229 397
230 Safefree (req); 398 req_free (req);
231 } 399 }
232
233 if (qs)
234 send_reqs ();
235 400
236 return count; 401 return count;
237} 402}
238 403
239static void * 404static void *aio_proc(void *arg);
240aio_proc (void *thr_arg) 405
406static void start_thread (void)
407{
408 sigset_t fullsigset, oldsigset;
409 pthread_t tid;
410 pthread_attr_t attr;
411
412 pthread_attr_init (&attr);
413 pthread_attr_setstacksize (&attr, STACKSIZE);
414 pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
415
416 sigfillset (&fullsigset);
417 sigprocmask (SIG_SETMASK, &fullsigset, &oldsigset);
418
419 if (pthread_create (&tid, &attr, aio_proc, 0) == 0)
420 started++;
421
422 sigprocmask (SIG_SETMASK, &oldsigset, 0);
423}
424
425static void req_send (aio_req req)
426{
427 while (started < wanted && nreqs >= started)
428 start_thread ();
429
430 ++nreqs;
431
432 pthread_mutex_lock (&reqlock);
433
434 req->next = 0;
435
436 if (reqe)
437 {
438 reqe->next = req;
439 reqe = req;
440 }
441 else
442 reqe = reqs = req;
443
444 pthread_cond_signal (&reqwait);
445 pthread_mutex_unlock (&reqlock);
446
447 if (nreqs > max_outstanding)
448 for (;;)
449 {
450 poll_cb ();
451
452 if (nreqs <= max_outstanding)
453 break;
454
455 poll_wait ();
456 }
457}
458
459static void end_thread (void)
241{ 460{
242 aio_req req; 461 aio_req req;
462 Newz (0, req, 1, aio_cb);
463 req->type = REQ_QUIT;
243 464
244 /* then loop */ 465 req_send (req);
245 while (read (reqpipe[0], (void *)&req, sizeof (req)) == sizeof (req)) 466}
467
468static void min_parallel (int nthreads)
469{
470 if (wanted < nthreads)
471 wanted = nthreads;
472}
473
474static void max_parallel (int nthreads)
475{
476 int cur = started;
477
478 if (wanted > nthreads)
479 wanted = nthreads;
480
481 while (cur > wanted)
482 {
483 end_thread ();
484 cur--;
246 { 485 }
486
487 while (started > wanted)
488 {
489 poll_wait ();
490 poll_cb ();
491 }
492}
493
494static void create_pipe ()
495{
496 if (pipe (respipe))
497 croak ("unable to initialize result pipe");
498
499 if (fcntl (respipe [0], F_SETFL, O_NONBLOCK))
500 croak ("cannot set result pipe to nonblocking mode");
501
502 if (fcntl (respipe [1], F_SETFL, O_NONBLOCK))
503 croak ("cannot set result pipe to nonblocking mode");
504}
505
506/*****************************************************************************/
507/* work around various missing functions */
508
509#if !HAVE_PREADWRITE
510# define pread aio_pread
511# define pwrite aio_pwrite
512
513/*
514 * make our pread/pwrite safe against themselves, but not against
515 * normal read/write by using a mutex. slows down execution a lot,
516 * but that's your problem, not mine.
517 */
518static pthread_mutex_t preadwritelock = PTHREAD_MUTEX_INITIALIZER;
519
520static ssize_t pread (int fd, void *buf, size_t count, off_t offset)
521{
522 ssize_t res;
523 off_t ooffset;
524
525 pthread_mutex_lock (&preadwritelock);
526 ooffset = lseek (fd, 0, SEEK_CUR);
527 lseek (fd, offset, SEEK_SET);
528 res = read (fd, buf, count);
529 lseek (fd, ooffset, SEEK_SET);
530 pthread_mutex_unlock (&preadwritelock);
531
532 return res;
533}
534
535static ssize_t pwrite (int fd, void *buf, size_t count, off_t offset)
536{
537 ssize_t res;
538 off_t ooffset;
539
540 pthread_mutex_lock (&preadwritelock);
541 ooffset = lseek (fd, 0, SEEK_CUR);
542 lseek (fd, offset, SEEK_SET);
543 res = write (fd, buf, count);
544 lseek (fd, offset, SEEK_SET);
545 pthread_mutex_unlock (&preadwritelock);
546
547 return res;
548}
549#endif
550
551#if !HAVE_FDATASYNC
552# define fdatasync fsync
553#endif
554
555#if !HAVE_READAHEAD
556# define readahead aio_readahead
557
558static ssize_t readahead (int fd, off_t offset, size_t count)
559{
560 char readahead_buf[4096];
561
562 while (count > 0)
563 {
564 size_t len = count < sizeof (readahead_buf) ? count : sizeof (readahead_buf);
565
566 pread (fd, readahead_buf, len, offset);
567 offset += len;
568 count -= len;
569 }
570
571 errno = 0;
572}
573#endif
574
575#if !HAVE_READDIR_R
576# define readdir_r aio_readdir_r
577
578static pthread_mutex_t readdirlock = PTHREAD_MUTEX_INITIALIZER;
579
580static int readdir_r (DIR *dirp, struct dirent *ent, struct dirent **res)
581{
582 struct dirent *e;
583 int errorno;
584
585 pthread_mutex_lock (&readdirlock);
586
587 e = readdir (dirp);
588 errorno = errno;
589
590 if (e)
591 {
592 *res = ent;
593 strcpy (ent->d_name, e->d_name);
594 }
595 else
596 *res = 0;
597
598 pthread_mutex_unlock (&readdirlock);
599
600 errno = errorno;
601 return e ? 0 : -1;
602}
603#endif
604
605/* sendfile always needs emulation */
606static ssize_t sendfile_ (int ofd, int ifd, off_t offset, size_t count)
607{
608 ssize_t res;
609
610 if (!count)
611 return 0;
612
613#if HAVE_SENDFILE
614# if __linux
615 res = sendfile (ofd, ifd, &offset, count);
616
617# elif __freebsd
618 /*
619 * Of course, the freebsd sendfile is a dire hack with no thoughts
620 * wasted on making it similar to other I/O functions.
621 */
622 {
623 off_t sbytes;
624 res = sendfile (ifd, ofd, offset, count, 0, &sbytes, 0);
625
626 if (res < 0 && sbytes)
627 /* maybe only on EAGAIN only: as usual, the manpage leaves you guessing */
628 res = sbytes;
629 }
630
631# elif __hpux
632 res = sendfile (ofd, ifd, offset, count, 0, 0);
633
634# elif __solaris
635 {
636 struct sendfilevec vec;
637 size_t sbytes;
638
639 vec.sfv_fd = ifd;
640 vec.sfv_flag = 0;
641 vec.sfv_off = offset;
642 vec.sfv_len = count;
643
644 res = sendfilev (ofd, &vec, 1, &sbytes);
645
646 if (res < 0 && sbytes)
647 res = sbytes;
648 }
649
650# endif
651#else
652 res = -1;
653 errno = ENOSYS;
654#endif
655
656 if (res < 0
657 && (errno == ENOSYS || errno == EINVAL || errno == ENOTSOCK
658#if __solaris
659 || errno == EAFNOSUPPORT || errno == EPROTOTYPE
660#endif
661 )
662 )
663 {
664 /* emulate sendfile. this is a major pain in the ass */
665 char buf[4096];
666 res = 0;
667
668 while (count)
669 {
670 ssize_t cnt;
671
672 cnt = pread (ifd, buf, count > 4096 ? 4096 : count, offset);
673
674 if (cnt <= 0)
675 {
676 if (cnt && !res) res = -1;
677 break;
678 }
679
680 cnt = write (ofd, buf, cnt);
681
682 if (cnt <= 0)
683 {
684 if (cnt && !res) res = -1;
685 break;
686 }
687
688 offset += cnt;
689 res += cnt;
690 count -= cnt;
691 }
692 }
693
694 return res;
695}
696
697/* read a full directory */
698static int scandir_ (const char *path, void **namesp)
699{
700 DIR *dirp = opendir (path);
701 union
702 {
703 struct dirent d;
704 char b [offsetof (struct dirent, d_name) + NAME_MAX + 1];
705 } u;
706 struct dirent *entp;
707 char *name, *names;
708 int memlen = 4096;
709 int memofs = 0;
710 int res = 0;
711 int errorno;
712
713 if (!dirp)
714 return -1;
715
716 names = malloc (memlen);
717
718 for (;;)
719 {
720 errno = 0, readdir_r (dirp, &u.d, &entp);
721
722 if (!entp)
723 break;
724
725 name = entp->d_name;
726
727 if (name [0] != '.' || (name [1] && (name [1] != '.' || name [2])))
728 {
729 int len = strlen (name) + 1;
730
731 res++;
732
733 while (memofs + len > memlen)
734 {
735 memlen *= 2;
736 names = realloc (names, memlen);
737 if (!names)
738 break;
739 }
740
741 memcpy (names + memofs, name, len);
742 memofs += len;
743 }
744 }
745
746 errorno = errno;
747 closedir (dirp);
748
749 if (errorno)
750 {
751 free (names);
752 errno = errorno;
753 res = -1;
754 }
755
756 *namesp = (void *)names;
757 return res;
758}
759
760/*****************************************************************************/
761
762static void *aio_proc (void *thr_arg)
763{
764 aio_req req;
765 int type;
766
767 do
768 {
769 pthread_mutex_lock (&reqlock);
770
771 for (;;)
772 {
773 req = reqs;
774
775 if (reqs)
776 {
777 reqs = reqs->next;
778 if (!reqs) reqe = 0;
779 }
780
781 if (req)
782 break;
783
784 pthread_cond_wait (&reqwait, &reqlock);
785 }
786
787 pthread_mutex_unlock (&reqlock);
788
247 errno = 0; /* strictly unnecessary */ 789 errno = 0; /* strictly unnecessary */
248 790
249 switch (req->type) 791 if (!req->cancelled)
792 switch (type = req->type) /* remember type for QUIT check */
793 {
794 case REQ_READ: req->result = pread (req->fd, req->dataptr, req->length, req->offset); break;
795 case REQ_WRITE: req->result = pwrite (req->fd, req->dataptr, req->length, req->offset); break;
796
797 case REQ_READAHEAD: req->result = readahead (req->fd, req->offset, req->length); break;
798 case REQ_SENDFILE: req->result = sendfile_ (req->fd, req->fd2, req->offset, req->length); break;
799
800 case REQ_STAT: req->result = stat (req->dataptr, req->statdata); break;
801 case REQ_LSTAT: req->result = lstat (req->dataptr, req->statdata); break;
802 case REQ_FSTAT: req->result = fstat (req->fd , req->statdata); break;
803
804 case REQ_OPEN: req->result = open (req->dataptr, req->fd, req->mode); break;
805 case REQ_CLOSE: req->result = close (req->fd); break;
806 case REQ_UNLINK: req->result = unlink (req->dataptr); break;
807 case REQ_RMDIR: req->result = rmdir (req->dataptr); break;
808 case REQ_RENAME: req->result = rename (req->data2ptr, req->dataptr); break;
809 case REQ_LINK: req->result = link (req->data2ptr, req->dataptr); break;
810 case REQ_SYMLINK: req->result = symlink (req->data2ptr, req->dataptr); break;
811
812 case REQ_FDATASYNC: req->result = fdatasync (req->fd); break;
813 case REQ_FSYNC: req->result = fsync (req->fd); break;
814 case REQ_READDIR: req->result = scandir_ (req->dataptr, &req->data2ptr); break;
815
816 case REQ_SLEEP:
817 {
818 struct timeval tv;
819
820 tv.tv_sec = req->fd;
821 tv.tv_usec = req->fd2;
822
823 req->result = select (0, 0, 0, 0, &tv);
824 }
825
826 case REQ_GROUP:
827 case REQ_NOP:
828 case REQ_QUIT:
829 break;
830
831 default:
832 req->result = ENOSYS;
833 break;
834 }
835
836 req->errorno = errno;
837
838 pthread_mutex_lock (&reslock);
839
840 req->next = 0;
841
842 if (rese)
250 { 843 {
251 case REQ_READ: req->result = pread64 (req->fd, req->dataptr, req->length, req->offset); break; 844 rese->next = req;
252 case REQ_WRITE: req->result = pwrite64 (req->fd, req->dataptr, req->length, req->offset); break; 845 rese = req;
253#if SYS_readahead 846 }
254 case REQ_READAHEAD: req->result = readahead (req->fd, req->offset, req->length); break; 847 else
255#else 848 {
256 case REQ_READAHEAD: req->result = -1; errno = ENOSYS; break; 849 rese = ress = req;
850
851 /* write a dummy byte to the pipe so fh becomes ready */
852 write (respipe [1], &respipe, 1);
853 }
854
855 pthread_mutex_unlock (&reslock);
856 }
857 while (type != REQ_QUIT);
858
859 return 0;
860}
861
862/*****************************************************************************/
863
864static void atfork_prepare (void)
865{
866 pthread_mutex_lock (&reqlock);
867 pthread_mutex_lock (&reslock);
868#if !HAVE_PREADWRITE
869 pthread_mutex_lock (&preadwritelock);
257#endif 870#endif
871#if !HAVE_READDIR_R
872 pthread_mutex_lock (&readdirlock);
873#endif
874}
258 875
259 case REQ_STAT: req->result = stat (req->dataptr, req->statdata); break; 876static void atfork_parent (void)
260 case REQ_LSTAT: req->result = lstat (req->dataptr, req->statdata); break; 877{
261 case REQ_FSTAT: req->result = fstat (req->fd , req->statdata); break; 878#if !HAVE_READDIR_R
879 pthread_mutex_unlock (&readdirlock);
880#endif
881#if !HAVE_PREADWRITE
882 pthread_mutex_unlock (&preadwritelock);
883#endif
884 pthread_mutex_unlock (&reslock);
885 pthread_mutex_unlock (&reqlock);
886}
262 887
263 case REQ_OPEN: req->result = open (req->dataptr, req->fd, req->mode); break; 888static void atfork_child (void)
264 case REQ_CLOSE: req->result = close (req->fd); break; 889{
265 case REQ_UNLINK: req->result = unlink (req->dataptr); break; 890 aio_req prv;
266 891
267 case REQ_FSYNC: req->result = fsync (req->fd); break; 892 started = 0;
268 case REQ_FDATASYNC: req->result = fdatasync (req->fd); break;
269 893
270 case REQ_QUIT: 894 while (reqs)
271 write (respipe[1], (void *)&req, sizeof (req));
272 return 0;
273
274 default:
275 req->result = ENOSYS;
276 break;
277 }
278
279 req->errorno = errno;
280 write (respipe[1], (void *)&req, sizeof (req));
281 } 895 {
896 prv = reqs;
897 reqs = prv->next;
898 req_free (prv);
899 }
282 900
283 return 0; 901 reqs = reqe = 0;
284} 902
903 while (ress)
904 {
905 prv = ress;
906 ress = prv->next;
907 req_free (prv);
908 }
909
910 ress = rese = 0;
285 911
912 close (respipe [0]);
913 close (respipe [1]);
914 create_pipe ();
915
916 atfork_parent ();
917}
918
919#define dREQ \
920 aio_req req; \
921 \
922 if (SvOK (callback) && !SvROK (callback)) \
923 croak ("callback must be undef or of reference type"); \
924 \
925 Newz (0, req, 1, aio_cb); \
926 if (!req) \
927 croak ("out of memory during aio_req allocation"); \
928 \
929 req->callback = newSVsv (callback)
930
931#define REQ_SEND \
932 req_send (req); \
933 \
934 if (GIMME_V != G_VOID) \
935 XPUSHs (req_sv (req, AIO_REQ_KLASS));
936
286MODULE = IO::AIO PACKAGE = IO::AIO 937MODULE = IO::AIO PACKAGE = IO::AIO
287 938
939PROTOTYPES: ENABLE
940
288BOOT: 941BOOT:
289{ 942{
290 if (pipe (reqpipe) || pipe (respipe)) 943 HV *stash = gv_stashpv ("IO::AIO", 1);
291 croak ("unable to initialize request or result pipe"); 944 newCONSTSUB (stash, "EXDEV", newSViv (EXDEV));
945 newCONSTSUB (stash, "O_RDONLY", newSViv (O_RDONLY));
946 newCONSTSUB (stash, "O_WRONLY", newSViv (O_WRONLY));
292 947
293 if (fcntl (reqpipe[1], F_SETFL, O_NONBLOCK)) 948 create_pipe ();
294 croak ("cannot set result pipe to nonblocking mode"); 949 pthread_atfork (atfork_prepare, atfork_parent, atfork_child);
295
296 if (fcntl (respipe[0], F_SETFL, O_NONBLOCK))
297 croak ("cannot set result pipe to nonblocking mode");
298} 950}
299 951
300void 952void
301min_parallel(nthreads) 953min_parallel (nthreads)
302 int nthreads 954 int nthreads
303 PROTOTYPE: $ 955 PROTOTYPE: $
304 CODE:
305 while (nthreads > started)
306 start_thread ();
307 956
308void 957void
309max_parallel(nthreads) 958max_parallel (nthreads)
310 int nthreads 959 int nthreads
311 PROTOTYPE: $ 960 PROTOTYPE: $
961
962int
963max_outstanding (nreqs)
964 int nreqs
965 PROTOTYPE: $
312 CODE: 966 CODE:
313{ 967 RETVAL = max_outstanding;
314 int cur = started; 968 max_outstanding = nreqs;
315 while (cur > nthreads)
316 {
317 end_thread ();
318 cur--;
319 }
320 969
321 while (started > nthreads)
322 {
323 poll_wait ();
324 poll_cb (aTHX);
325 }
326}
327
328void 970void
329aio_open(pathname,flags,mode,callback) 971aio_open (pathname,flags,mode,callback=&PL_sv_undef)
330 SV * pathname 972 SV * pathname
331 int flags 973 int flags
332 int mode 974 int mode
333 SV * callback 975 SV * callback
334 PROTOTYPE: $$$$ 976 PROTOTYPE: $$$;$
335 CODE: 977 PPCODE:
336{ 978{
337 aio_req req; 979 dREQ;
338
339 Newz (0, req, 1, aio_cb);
340
341 if (!req)
342 croak ("out of memory during aio_req allocation");
343 980
344 req->type = REQ_OPEN; 981 req->type = REQ_OPEN;
345 req->data = newSVsv (pathname); 982 req->data = newSVsv (pathname);
346 req->dataptr = SvPV_nolen (req->data); 983 req->dataptr = SvPVbyte_nolen (req->data);
347 req->fd = flags; 984 req->fd = flags;
348 req->mode = mode; 985 req->mode = mode;
349 req->callback = SvREFCNT_inc (callback);
350 986
351 send_req (req); 987 REQ_SEND;
352} 988}
353 989
354void 990void
355aio_close(fh,callback) 991aio_close (fh,callback=&PL_sv_undef)
356 InputStream fh 992 SV * fh
357 SV * callback 993 SV * callback
358 PROTOTYPE: $$ 994 PROTOTYPE: $;$
359 ALIAS: 995 ALIAS:
360 aio_close = REQ_CLOSE 996 aio_close = REQ_CLOSE
361 aio_fsync = REQ_FSYNC 997 aio_fsync = REQ_FSYNC
362 aio_fdatasync = REQ_FDATASYNC 998 aio_fdatasync = REQ_FDATASYNC
363 CODE: 999 PPCODE:
1000{
1001 dREQ;
1002
1003 req->type = ix;
1004 req->fh = newSVsv (fh);
1005 req->fd = PerlIO_fileno (IoIFP (sv_2io (fh)));
1006
1007 REQ_SEND (req);
1008}
1009
1010void
1011aio_read (fh,offset,length,data,dataoffset,callback=&PL_sv_undef)
1012 SV * fh
1013 UV offset
1014 UV length
1015 SV * data
1016 UV dataoffset
1017 SV * callback
1018 ALIAS:
1019 aio_read = REQ_READ
1020 aio_write = REQ_WRITE
1021 PROTOTYPE: $$$$$;$
1022 PPCODE:
364{ 1023{
365 aio_req req; 1024 aio_req req;
1025 STRLEN svlen;
1026 char *svptr = SvPVbyte (data, svlen);
366 1027
367 Newz (0, req, 1, aio_cb); 1028 SvUPGRADE (data, SVt_PV);
1029 SvPOK_on (data);
368 1030
369 if (!req) 1031 if (dataoffset < 0)
370 croak ("out of memory during aio_req allocation"); 1032 dataoffset += svlen;
371 1033
372 req->type = ix; 1034 if (dataoffset < 0 || dataoffset > svlen)
373 req->fd = PerlIO_fileno (fh); 1035 croak ("data offset outside of string");
374 req->callback = SvREFCNT_inc (callback);
375 1036
376 send_req (req); 1037 if (ix == REQ_WRITE)
377} 1038 {
378 1039 /* write: check length and adjust. */
379void 1040 if (length < 0 || length + dataoffset > svlen)
380aio_read(fh,offset,length,data,dataoffset,callback) 1041 length = svlen - dataoffset;
381 InputStream fh 1042 }
382 UV offset 1043 else
383 IV length 1044 {
384 SV * data 1045 /* read: grow scalar as necessary */
385 IV dataoffset 1046 svptr = SvGROW (data, length + dataoffset);
386 SV * callback 1047 }
387 PROTOTYPE: $$$$$$
388 CODE:
389 read_write (aTHX_ 0, PerlIO_fileno (fh), offset, length, data, dataoffset, callback);
390
391void
392aio_write(fh,offset,length,data,dataoffset,callback)
393 OutputStream fh
394 UV offset
395 IV length
396 SV * data
397 IV dataoffset
398 SV * callback
399 PROTOTYPE: $$$$$$
400 CODE:
401 read_write (aTHX_ 1, PerlIO_fileno (fh), offset, length, data, dataoffset, callback);
402
403void
404aio_readahead(fh,offset,length,callback)
405 InputStream fh
406 UV offset
407 IV length
408 SV * callback
409 PROTOTYPE: $$$$
410 CODE:
411{
412 aio_req req;
413 1048
414 if (length < 0) 1049 if (length < 0)
415 croak ("length must not be negative"); 1050 croak ("length must not be negative");
416 1051
417 Newz (0, req, 1, aio_cb); 1052 {
1053 dREQ;
418 1054
419 if (!req) 1055 req->type = ix;
420 croak ("out of memory during aio_req allocation"); 1056 req->fh = newSVsv (fh);
1057 req->fd = PerlIO_fileno (ix == REQ_READ ? IoIFP (sv_2io (fh))
1058 : IoOFP (sv_2io (fh)));
1059 req->offset = offset;
1060 req->length = length;
1061 req->data = SvREFCNT_inc (data);
1062 req->dataptr = (char *)svptr + dataoffset;
1063
1064 if (!SvREADONLY (data))
1065 {
1066 SvREADONLY_on (data);
1067 req->data2ptr = (void *)data;
1068 }
1069
1070 REQ_SEND;
1071 }
1072}
1073
1074void
1075aio_sendfile (out_fh,in_fh,in_offset,length,callback=&PL_sv_undef)
1076 SV * out_fh
1077 SV * in_fh
1078 UV in_offset
1079 UV length
1080 SV * callback
1081 PROTOTYPE: $$$$;$
1082 PPCODE:
1083{
1084 dREQ;
1085
1086 req->type = REQ_SENDFILE;
1087 req->fh = newSVsv (out_fh);
1088 req->fd = PerlIO_fileno (IoIFP (sv_2io (out_fh)));
1089 req->fh2 = newSVsv (in_fh);
1090 req->fd2 = PerlIO_fileno (IoIFP (sv_2io (in_fh)));
1091 req->offset = in_offset;
1092 req->length = length;
1093
1094 REQ_SEND;
1095}
1096
1097void
1098aio_readahead (fh,offset,length,callback=&PL_sv_undef)
1099 SV * fh
1100 UV offset
1101 IV length
1102 SV * callback
1103 PROTOTYPE: $$$;$
1104 PPCODE:
1105{
1106 dREQ;
421 1107
422 req->type = REQ_READAHEAD; 1108 req->type = REQ_READAHEAD;
1109 req->fh = newSVsv (fh);
423 req->fd = PerlIO_fileno (fh); 1110 req->fd = PerlIO_fileno (IoIFP (sv_2io (fh)));
424 req->offset = offset; 1111 req->offset = offset;
425 req->length = length; 1112 req->length = length;
426 req->callback = SvREFCNT_inc (callback);
427 1113
428 send_req (req); 1114 REQ_SEND;
429} 1115}
430 1116
431void 1117void
432aio_stat(fh_or_path,callback) 1118aio_stat (fh_or_path,callback=&PL_sv_undef)
433 SV * fh_or_path 1119 SV * fh_or_path
434 SV * callback 1120 SV * callback
435 PROTOTYPE: $$
436 ALIAS: 1121 ALIAS:
1122 aio_stat = REQ_STAT
437 aio_lstat = 1 1123 aio_lstat = REQ_LSTAT
438 CODE: 1124 PPCODE:
439{ 1125{
440 aio_req req; 1126 dREQ;
441
442 Newz (0, req, 1, aio_cb);
443
444 if (!req)
445 croak ("out of memory during aio_req allocation");
446 1127
447 New (0, req->statdata, 1, Stat_t); 1128 New (0, req->statdata, 1, Stat_t);
448
449 if (!req->statdata) 1129 if (!req->statdata)
1130 {
1131 req_free (req);
450 croak ("out of memory during aio_req->statdata allocation"); 1132 croak ("out of memory during aio_req->statdata allocation");
1133 }
451 1134
452 if (SvPOK (fh_or_path)) 1135 if (SvPOK (fh_or_path))
453 { 1136 {
454 req->type = ix ? REQ_LSTAT : REQ_STAT; 1137 req->type = ix;
455 req->data = newSVsv (fh_or_path); 1138 req->data = newSVsv (fh_or_path);
456 req->dataptr = SvPV_nolen (req->data); 1139 req->dataptr = SvPVbyte_nolen (req->data);
457 } 1140 }
458 else 1141 else
459 { 1142 {
460 req->type = REQ_FSTAT; 1143 req->type = REQ_FSTAT;
1144 req->fh = newSVsv (fh_or_path);
461 req->fd = PerlIO_fileno (IoIFP (sv_2io (fh_or_path))); 1145 req->fd = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
462 } 1146 }
463 1147
464 req->callback = SvREFCNT_inc (callback); 1148 REQ_SEND;
465
466 send_req (req);
467} 1149}
468 1150
469void 1151void
470aio_unlink(pathname,callback) 1152aio_unlink (pathname,callback=&PL_sv_undef)
471 SV * pathname 1153 SV * pathname
472 SV * callback 1154 SV * callback
1155 ALIAS:
1156 aio_unlink = REQ_UNLINK
1157 aio_rmdir = REQ_RMDIR
1158 aio_readdir = REQ_READDIR
1159 PPCODE:
1160{
1161 dREQ;
1162
1163 req->type = ix;
1164 req->data = newSVsv (pathname);
1165 req->dataptr = SvPVbyte_nolen (req->data);
1166
1167 REQ_SEND;
1168}
1169
1170void
1171aio_link (oldpath,newpath,callback=&PL_sv_undef)
1172 SV * oldpath
1173 SV * newpath
1174 SV * callback
1175 ALIAS:
1176 aio_link = REQ_LINK
1177 aio_symlink = REQ_SYMLINK
1178 aio_rename = REQ_RENAME
1179 PPCODE:
1180{
1181 dREQ;
1182
1183 req->type = ix;
1184 req->fh = newSVsv (oldpath);
1185 req->data2ptr = SvPVbyte_nolen (req->fh);
1186 req->data = newSVsv (newpath);
1187 req->dataptr = SvPVbyte_nolen (req->data);
1188
1189 REQ_SEND;
1190}
1191
1192void
1193aio_sleep (delay,callback=&PL_sv_undef)
1194 double delay
1195 SV * callback
1196 PPCODE:
1197{
1198 dREQ;
1199
1200 req->type = REQ_SLEEP;
1201 req->fd = delay < 0. ? 0 : delay;
1202 req->fd2 = delay < 0. ? 0 : 1000. * (delay - req->fd);
1203
1204 REQ_SEND;
1205}
1206
1207void
1208aio_group (callback=&PL_sv_undef)
1209 SV * callback
473 PROTOTYPE: $$ 1210 PROTOTYPE: ;$
1211 PPCODE:
1212{
1213 dREQ;
1214 req->type = REQ_GROUP;
1215 req_send (req);
1216 XPUSHs (req_sv (req, AIO_GRP_KLASS));
1217}
1218
1219void
1220aio_nop (callback=&PL_sv_undef)
1221 SV * callback
1222 PPCODE:
1223{
1224 dREQ;
1225
1226 req->type = REQ_NOP;
1227
1228 REQ_SEND;
1229}
1230
1231void
1232flush ()
1233 PROTOTYPE:
474 CODE: 1234 CODE:
475{ 1235 while (nreqs)
476 aio_req req; 1236 {
477 1237 poll_wait ();
478 Newz (0, req, 1, aio_cb); 1238 poll_cb ();
479 1239 }
480 if (!req) 1240
481 croak ("out of memory during aio_req allocation"); 1241void
482 1242poll()
483 req->type = REQ_UNLINK; 1243 PROTOTYPE:
484 req->data = newSVsv (pathname); 1244 CODE:
485 req->dataptr = SvPV_nolen (req->data); 1245 if (nreqs)
486 req->callback = SvREFCNT_inc (callback); 1246 {
487 1247 poll_wait ();
488 send_req (req); 1248 poll_cb ();
489} 1249 }
490 1250
491int 1251int
492poll_fileno() 1252poll_fileno()
493 PROTOTYPE: 1253 PROTOTYPE:
494 CODE: 1254 CODE:
495 RETVAL = respipe[0]; 1255 RETVAL = respipe [0];
496 OUTPUT: 1256 OUTPUT:
497 RETVAL 1257 RETVAL
498 1258
499int 1259int
500poll_cb(...) 1260poll_cb(...)
501 PROTOTYPE: 1261 PROTOTYPE:
502 CODE: 1262 CODE:
503 RETVAL = poll_cb (aTHX); 1263 RETVAL = poll_cb ();
504 OUTPUT: 1264 OUTPUT:
505 RETVAL 1265 RETVAL
506 1266
507void 1267void
508poll_wait() 1268poll_wait()
509 PROTOTYPE: 1269 PROTOTYPE:
510 CODE: 1270 CODE:
1271 if (nreqs)
511 poll_wait (); 1272 poll_wait ();
512 1273
513int 1274int
514nreqs() 1275nreqs()
515 PROTOTYPE: 1276 PROTOTYPE:
516 CODE: 1277 CODE:
517 RETVAL = nreqs; 1278 RETVAL = nreqs;
518 OUTPUT: 1279 OUTPUT:
519 RETVAL 1280 RETVAL
520 1281
1282PROTOTYPES: DISABLE
1283
1284MODULE = IO::AIO PACKAGE = IO::AIO::REQ
1285
1286void
1287cancel (aio_req_ornot req)
1288 PROTOTYPE:
1289 CODE:
1290 req_cancel (req);
1291
1292void
1293cb (aio_req req, SV *callback=&PL_sv_undef)
1294 CODE:
1295 SvREFCNT_dec (req->callback);
1296 req->callback = newSVsv (callback);
1297
1298MODULE = IO::AIO PACKAGE = IO::AIO::GRP
1299
1300void
1301add (aio_req grp, ...)
1302 PPCODE:
1303{
1304 int i;
1305 aio_req req;
1306
1307 if (grp->fd == 2)
1308 croak ("cannot add requests to IO::AIO::GRP after the group finished");
1309
1310 for (i = 1; i < items; ++i )
1311 {
1312 if (GIMME_V != G_VOID)
1313 XPUSHs (sv_2mortal (newSVsv (ST (i))));
1314
1315 req = SvAIO_REQ (ST (i));
1316
1317 if (req)
1318 {
1319 ++grp->length;
1320 req->grp = grp;
1321
1322 req->grp_prev = 0;
1323 req->grp_next = grp->grp_first;
1324
1325 if (grp->grp_first)
1326 grp->grp_first->grp_prev = req;
1327
1328 grp->grp_first = req;
1329 }
1330 }
1331}
1332
1333void
1334result (aio_req grp, ...)
1335 CODE:
1336{
1337 int i;
1338 AV *av = newAV ();
1339
1340 for (i = 1; i < items; ++i )
1341 av_push (av, newSVsv (ST (i)));
1342
1343 SvREFCNT_dec (grp->data);
1344 grp->data = (SV *)av;
1345}
1346
1347void
1348feed_limit (aio_req grp, int limit)
1349 CODE:
1350 grp->fd2 = limit;
1351 aio_grp_feed (grp);
1352
1353void
1354feed (aio_req grp, SV *callback=&PL_sv_undef)
1355 CODE:
1356{
1357 SvREFCNT_dec (grp->fh2);
1358 grp->fh2 = newSVsv (callback);
1359
1360 if (grp->fd2 <= 0)
1361 grp->fd2 = 2;
1362
1363 aio_grp_feed (grp);
1364}
1365

Diff Legend

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