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

Diff Legend

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