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

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines