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.128 by root, Tue Sep 30 14:07:59 2008 UTC vs.
Revision 1.161 by root, Sun Jan 10 20:28:43 2010 UTC

… …
3#include <errno.h> 3#include <errno.h>
4 4
5#include "EXTERN.h" 5#include "EXTERN.h"
6#include "perl.h" 6#include "perl.h"
7#include "XSUB.h" 7#include "XSUB.h"
8
9#include "schmorp.h"
8 10
9#include <stddef.h> 11#include <stddef.h>
10#include <stdlib.h> 12#include <stdlib.h>
11#include <errno.h> 13#include <errno.h>
12#include <sys/types.h> 14#include <sys/types.h>
13#include <sys/stat.h> 15#include <sys/stat.h>
16#include <sys/statvfs.h>
14#include <limits.h> 17#include <limits.h>
15#include <fcntl.h> 18#include <fcntl.h>
16#include <sched.h> 19#include <sched.h>
20
21#if _POSIX_MEMLOCK
22# include <sys/mman.h>
23#endif
17 24
18/* perl namespace pollution */ 25/* perl namespace pollution */
19#undef VERSION 26#undef VERSION
20 27
21#ifdef _WIN32 28#ifdef _WIN32
… …
75 82
76#define EIO_STRUCT_STAT Stat_t 83#define EIO_STRUCT_STAT Stat_t
77 84
78/* use NV for 32 bit perls as it allows larger offsets */ 85/* use NV for 32 bit perls as it allows larger offsets */
79#if IVSIZE >= 8 86#if IVSIZE >= 8
87# define VAL64 IV
80# define SvVAL64 SvIV 88# define SvVAL64 SvIV
89# define newSVval64 newSViv
81#else 90#else
91# define VAL64 NV
82# define SvVAL64 SvNV 92# define SvVAL64 SvNV
93# define newSVval64 newSVnv
83#endif 94#endif
84 95
85/*****************************************************************************/ 96/*****************************************************************************/
86 97
87#if __GNUC__ >= 3 98#if __GNUC__ >= 3
… …
93#define expect_false(expr) expect ((expr) != 0, 0) 104#define expect_false(expr) expect ((expr) != 0, 0)
94#define expect_true(expr) expect ((expr) != 0, 1) 105#define expect_true(expr) expect ((expr) != 0, 1)
95 106
96/*****************************************************************************/ 107/*****************************************************************************/
97 108
98static HV *stash;
99typedef SV SV8; /* byte-sv, used for argument-checking */ 109typedef SV SV8; /* byte-sv, used for argument-checking */
110typedef int aio_rfd; /* read file desriptor */
111typedef int aio_wfd; /* write file descriptor */
100 112
101#define AIO_REQ_KLASS "IO::AIO::REQ" 113static HV *aio_stash, *aio_req_stash, *aio_grp_stash;
102#define AIO_GRP_KLASS "IO::AIO::GRP"
103 114
104#define EIO_REQ_MEMBERS \ 115#define EIO_REQ_MEMBERS \
105 SV *callback; \ 116 SV *callback; \
106 SV *sv1, *sv2; \ 117 SV *sv1, *sv2; \
107 STRLEN stroffset; \ 118 STRLEN stroffset; \
… …
109 120
110#define EIO_NO_WRAPPERS 1 121#define EIO_NO_WRAPPERS 1
111 122
112#include "libeio/eio.h" 123#include "libeio/eio.h"
113 124
125#ifndef POSIX_FADV_NORMAL
126# define POSIX_FADV_NORMAL 0
127# define NO_FADVISE 1
128#endif
129#ifndef POSIX_FADV_SEQUENTIAL
130# define POSIX_FADV_SEQUENTIAL 0
131#endif
132#ifndef POSIX_FADV_RANDOM
133# define POSIX_FADV_RANDOM 0
134#endif
135#ifndef POSIX_FADV_NOREUSE
136# define POSIX_FADV_NOREUSE 0
137#endif
138#ifndef POSIX_FADV_WILLNEED
139# define POSIX_FADV_WILLNEED 0
140#endif
141#ifndef POSIX_FADV_DONTNEED
142# define POSIX_FADV_DONTNEED 0
143#endif
144
145#ifndef ST_NODEV
146# define ST_NODEV 0
147#endif
148#ifndef ST_NOEXEC
149# define ST_NOEXEC 0
150#endif
151#ifndef ST_SYNCHRONOUS
152# define ST_SYNCHRONOUS 0
153#endif
154#ifndef ST_MANDLOCK
155# define ST_MANDLOCK 0
156#endif
157#ifndef ST_WRITE
158# define ST_WRITE 0
159#endif
160#ifndef ST_APPEND
161# define ST_APPEND 0
162#endif
163#ifndef ST_IMMUTABLE
164# define ST_IMMUTABLE 0
165#endif
166#ifndef ST_NOATIME
167# define ST_NOATIME 0
168#endif
169#ifndef ST_NODIRATIME
170# define ST_NODIRATIME 0
171#endif
172#ifndef ST_RELATIME
173# define ST_RELATIME 0
174#endif
175
176#ifndef MCL_CURRENT
177# define MCL_CURRENT 0
178#endif
179#ifndef MCL_FUTURE
180# define MCL_FUTURE 0
181#endif
182
114static int req_invoke (eio_req *req); 183static int req_invoke (eio_req *req);
115#define EIO_FINISH(req) req_invoke (req) 184#define EIO_FINISH(req) req_invoke (req)
116static void aio_grp_feed (eio_req *grp);
117#define EIO_FEED(req) aio_grp_feed (req)
118static void req_destroy (eio_req *grp); 185static void req_destroy (eio_req *grp);
119#define EIO_DESTROY(req) req_destroy (req) 186#define EIO_DESTROY(req) req_destroy (req)
120 187
121enum { 188enum {
122 FLAG_SV2_RO_OFF = 0x40, /* data was set readonly */ 189 FLAG_SV2_RO_OFF = 0x40, /* data was set readonly */
… …
129 196
130static SV *on_next_submit; 197static SV *on_next_submit;
131static int next_pri = EIO_PRI_DEFAULT; 198static int next_pri = EIO_PRI_DEFAULT;
132static int max_outstanding; 199static int max_outstanding;
133 200
134static int respipe_osf [2], respipe [2] = { -1, -1 }; 201static s_epipe respipe;
135 202
136static void req_destroy (aio_req req); 203static void req_destroy (aio_req req);
137static void req_cancel (aio_req req); 204static void req_cancel (aio_req req);
138 205
139static void want_poll (void) 206static void want_poll (void)
140{ 207{
141 /* write a dummy byte to the pipe so fh becomes ready */ 208 /* write a dummy byte to the pipe so fh becomes ready */
142 respipe_write (respipe_osf [1], (const void *)&respipe_osf, 1); 209 s_epipe_signal (&respipe);
143} 210}
144 211
145static void done_poll (void) 212static void done_poll (void)
146{ 213{
147 /* read any signals sent by the worker threads */ 214 /* read any signals sent by the worker threads */
148 char buf [4]; 215 s_epipe_drain (&respipe);
149 while (respipe_read (respipe [0], buf, 4) == 4)
150 ;
151} 216}
152 217
153/* must be called at most once */ 218/* must be called at most once */
154static SV *req_sv (aio_req req, const char *klass) 219static SV *req_sv (aio_req req, HV *stash)
155{ 220{
156 if (!req->self) 221 if (!req->self)
157 { 222 {
158 req->self = (SV *)newHV (); 223 req->self = (SV *)newHV ();
159 sv_magic (req->self, 0, PERL_MAGIC_ext, (char *)req, 0); 224 sv_magic (req->self, 0, PERL_MAGIC_ext, (char *)req, 0);
160 } 225 }
161 226
162 return sv_2mortal (sv_bless (newRV_inc (req->self), gv_stashpv (klass, 1))); 227 return sv_2mortal (sv_bless (newRV_inc (req->self), stash));
163} 228}
164 229
165static aio_req SvAIO_REQ (SV *sv) 230static aio_req SvAIO_REQ (SV *sv)
166{ 231{
167 MAGIC *mg; 232 MAGIC *mg;
168 233
169 if (!sv_derived_from (sv, AIO_REQ_KLASS) || !SvROK (sv)) 234 if (!SvROK (sv)
235 || (SvSTASH (SvRV (sv)) != aio_grp_stash
236 && SvSTASH (SvRV (sv)) != aio_req_stash
237 && !sv_derived_from (sv, "IO::AIO::REQ")))
170 croak ("object of class " AIO_REQ_KLASS " expected"); 238 croak ("object of class IO::AIO::REQ expected");
171 239
172 mg = mg_find (SvRV (sv), PERL_MAGIC_ext); 240 mg = mg_find (SvRV (sv), PERL_MAGIC_ext);
173 241
174 return mg ? (aio_req)mg->mg_ptr : 0; 242 return mg ? (aio_req)mg->mg_ptr : 0;
175} 243}
… …
181 dSP; 249 dSP;
182 250
183 ENTER; 251 ENTER;
184 SAVETMPS; 252 SAVETMPS;
185 PUSHMARK (SP); 253 PUSHMARK (SP);
186 XPUSHs (req_sv (grp, AIO_GRP_KLASS)); 254 XPUSHs (req_sv (grp, aio_grp_stash));
187 PUTBACK; 255 PUTBACK;
188 call_sv (grp->sv2, G_VOID | G_EVAL | G_KEEPERR); 256 call_sv (grp->sv2, G_VOID | G_EVAL | G_KEEPERR);
189 SPAGAIN; 257 SPAGAIN;
190 FREETMPS; 258 FREETMPS;
191 LEAVE; 259 LEAVE;
… …
230 SV *rv = &PL_sv_undef; 298 SV *rv = &PL_sv_undef;
231 299
232 if (req->result >= 0) 300 if (req->result >= 0)
233 { 301 {
234 int i; 302 int i;
235 char *buf = req->ptr2; 303 char *names = (char *)req->ptr2;
304 eio_dirent *ent = (eio_dirent *)req->ptr1; /* might be 0 */
236 AV *av = newAV (); 305 AV *av = newAV ();
237 306
238 av_extend (av, req->result - 1); 307 av_extend (av, req->result - 1);
239 308
240 for (i = 0; i < req->result; ++i) 309 for (i = 0; i < req->result; ++i)
241 { 310 {
242 SV *sv = newSVpv (buf, 0); 311 if (req->int1 & EIO_READDIR_DENTS)
312 {
313 SV *namesv = newSVpvn (names + ent->nameofs, ent->namelen);
243 314
315 if (req->int1 & EIO_READDIR_CUSTOM2)
316 {
317 static SV *sv_type [EIO_DT_MAX + 1]; /* type sv cache */
318 AV *avent = newAV ();
319
320 av_extend (avent, 2);
321
322 if (!sv_type [ent->type])
323 {
324 sv_type [ent->type] = newSViv (ent->type);
325 SvREADONLY_on (sv_type [ent->type]);
326 }
327
328 av_store (avent, 0, namesv);
329 av_store (avent, 1, SvREFCNT_inc (sv_type [ent->type]));
330 av_store (avent, 2, IVSIZE >= 8 ? newSVuv (ent->inode) : newSVnv (ent->inode));
331
332 av_store (av, i, newRV_noinc ((SV *)avent));
333 }
334 else
244 av_store (av, i, sv); 335 av_store (av, i, namesv);
336
337 ++ent;
338 }
339 else
340 {
341 SV *name = newSVpv (names, 0);
342 av_store (av, i, name);
245 buf += SvCUR (sv) + 1; 343 names += SvCUR (name) + 1;
344 }
246 } 345 }
247 346
248 rv = sv_2mortal (newRV_noinc ((SV *)av)); 347 rv = sv_2mortal (newRV_noinc ((SV *)av));
249 } 348 }
250 349
251 PUSHs (rv); 350 PUSHs (rv);
351
352 if (req->int1 & EIO_READDIR_CUSTOM1)
353 XPUSHs (sv_2mortal (newSViv (req->int1 & ~(EIO_READDIR_CUSTOM1 | EIO_READDIR_CUSTOM2))));
252 } 354 }
253 break; 355 break;
254 356
255 case EIO_OPEN: 357 case EIO_OPEN:
256 { 358 {
… …
262 GV *gv = (GV *)sv_newmortal (); 364 GV *gv = (GV *)sv_newmortal ();
263 int flags = req->int1 & (O_RDONLY | O_WRONLY | O_RDWR); 365 int flags = req->int1 & (O_RDONLY | O_WRONLY | O_RDWR);
264 char sym [64]; 366 char sym [64];
265 int symlen; 367 int symlen;
266 368
267 symlen = snprintf (sym, sizeof (sym), "fd#%d", req->result); 369 symlen = snprintf (sym, sizeof (sym), "fd#%d", (int)req->result);
268 gv_init (gv, stash, sym, symlen, 0); 370 gv_init (gv, aio_stash, sym, symlen, 0);
269 371
270 symlen = snprintf ( 372 symlen = snprintf (
271 sym, 373 sym,
272 sizeof (sym), 374 sizeof (sym),
273 "%s&=%d", 375 "%s&=%d",
274 flags == O_RDONLY ? "<" : flags == O_WRONLY ? ">" : "+<", 376 flags == O_RDONLY ? "<" : flags == O_WRONLY ? ">" : "+<",
275 req->result 377 (int)req->result
276 ); 378 );
277 379
278 if (do_open (gv, sym, symlen, 0, 0, 0, 0)) 380 if (do_open (gv, sym, symlen, 0, 0, 0, 0))
279 fh = (SV *)gv; 381 fh = (SV *)gv;
280 } 382 }
281 383
282 PUSHs (fh); 384 PUSHs (fh);
283 } 385 }
386 break;
387
388 case EIO_STATVFS:
389 case EIO_FSTATVFS:
390 {
391 SV *rv = &PL_sv_undef;
392
393 if (req->result >= 0)
394 {
395 EIO_STRUCT_STATVFS *f = EIO_STATVFS_BUF (req);
396 HV *hv = newHV ();
397
398 rv = sv_2mortal (newRV_noinc ((SV *)hv));
399
400 hv_store (hv, "bsize" , sizeof ("bsize" ) - 1, newSVval64 (f->f_bsize ), 0);
401 hv_store (hv, "frsize" , sizeof ("frsize" ) - 1, newSVval64 (f->f_frsize ), 0);
402 hv_store (hv, "blocks" , sizeof ("blocks" ) - 1, newSVval64 (f->f_blocks ), 0);
403 hv_store (hv, "bfree" , sizeof ("bfree" ) - 1, newSVval64 (f->f_bfree ), 0);
404 hv_store (hv, "bavail" , sizeof ("bavail" ) - 1, newSVval64 (f->f_bavail ), 0);
405 hv_store (hv, "files" , sizeof ("files" ) - 1, newSVval64 (f->f_files ), 0);
406 hv_store (hv, "ffree" , sizeof ("ffree" ) - 1, newSVval64 (f->f_ffree ), 0);
407 hv_store (hv, "favail" , sizeof ("favail" ) - 1, newSVval64 (f->f_favail ), 0);
408 hv_store (hv, "fsid" , sizeof ("fsid" ) - 1, newSVval64 (f->f_fsid ), 0);
409 hv_store (hv, "flag" , sizeof ("flag" ) - 1, newSVval64 (f->f_flag ), 0);
410 hv_store (hv, "namemax", sizeof ("namemax") - 1, newSVval64 (f->f_namemax), 0);
411 }
412
413 PUSHs (rv);
414 }
415
284 break; 416 break;
285 417
286 case EIO_GROUP: 418 case EIO_GROUP:
287 req->int1 = 2; /* mark group as finished */ 419 req->int1 = 2; /* mark group as finished */
288 420
… …
314 PL_statcache = *(EIO_STRUCT_STAT *)(req->ptr2); 446 PL_statcache = *(EIO_STRUCT_STAT *)(req->ptr2);
315 PUSHs (sv_2mortal (newSViv (req->result))); 447 PUSHs (sv_2mortal (newSViv (req->result)));
316 break; 448 break;
317 449
318 case EIO_READ: 450 case EIO_READ:
451 {
319 SvCUR_set (req->sv2, req->stroffset + (req->result > 0 ? req->result : 0)); 452 SvCUR_set (req->sv2, req->stroffset + (req->result > 0 ? req->result : 0));
320 *SvEND (req->sv2) = 0; 453 *SvEND (req->sv2) = 0;
454 SvPOK_only (req->sv2);
455 SvSETMAGIC (req->sv2);
321 PUSHs (sv_2mortal (newSViv (req->result))); 456 PUSHs (sv_2mortal (newSViv (req->result)));
457 }
322 break; 458 break;
323 459
324 case EIO_DUP2: 460 case EIO_DUP2:
325 if (req->result > 0) 461 if (req->result > 0)
326 req->result = 0; 462 req->result = 0;
… …
372 grp->sv2 = 0; 508 grp->sv2 = 0;
373 509
374 eio_grp_cancel (grp); 510 eio_grp_cancel (grp);
375} 511}
376 512
377#ifdef USE_SOCKETS_AS_HANDLES
378# define TO_SOCKET(x) (win32_get_osfhandle (x))
379#else
380# define TO_SOCKET(x) (x)
381#endif
382
383static void 513static void
384create_respipe (void) 514create_respipe (void)
385{ 515{
386 int old_readfd = respipe [0];
387
388 if (respipe [1] >= 0)
389 respipe_close (TO_SOCKET (respipe [1]));
390
391#ifdef _WIN32
392 if (PerlSock_socketpair (AF_UNIX, SOCK_STREAM, 0, respipe))
393#else
394 if (pipe (respipe)) 516 if (s_epipe_renew (&respipe))
395#endif
396 croak ("unable to initialize result pipe"); 517 croak ("IO::AIO: unable to initialize result pipe");
397
398 if (old_readfd >= 0)
399 {
400 if (dup2 (TO_SOCKET (respipe [0]), TO_SOCKET (old_readfd)) < 0)
401 croak ("unable to initialize result pipe(2)");
402
403 respipe_close (respipe [0]);
404 respipe [0] = old_readfd;
405 }
406
407#ifdef _WIN32
408 int arg = 1;
409 if (ioctlsocket (TO_SOCKET (respipe [0]), FIONBIO, &arg)
410 || ioctlsocket (TO_SOCKET (respipe [1]), FIONBIO, &arg))
411#else
412 if (fcntl (respipe [0], F_SETFL, O_NONBLOCK)
413 || fcntl (respipe [1], F_SETFL, O_NONBLOCK))
414#endif
415 croak ("unable to initialize result pipe(3)");
416
417 respipe_osf [0] = TO_SOCKET (respipe [0]);
418 respipe_osf [1] = TO_SOCKET (respipe [1]);
419} 518}
420 519
421static void poll_wait (void) 520static void poll_wait (void)
422{ 521{
423 fd_set rfd;
424
425 while (eio_nreqs ()) 522 while (eio_nreqs ())
426 { 523 {
427 int size; 524 int size;
428 525
429 X_LOCK (reslock); 526 X_LOCK (reslock);
… …
433 if (size) 530 if (size)
434 return; 531 return;
435 532
436 etp_maybe_start_thread (); 533 etp_maybe_start_thread ();
437 534
438 FD_ZERO (&rfd); 535 s_epipe_wait (&respipe);
439 FD_SET (respipe [0], &rfd);
440
441 PerlSock_select (respipe [0] + 1, &rfd, 0, 0, 0);
442 } 536 }
443} 537}
444 538
445static int poll_cb (void) 539static int poll_cb (void)
446{ 540{
… …
464} 558}
465 559
466static SV * 560static SV *
467get_cb (SV *cb_sv) 561get_cb (SV *cb_sv)
468{ 562{
469 HV *st; 563 SvGETMAGIC (cb_sv);
470 GV *gvp; 564 return SvOK (cb_sv) ? s_get_cv_croak (cb_sv) : 0;
471 CV *cv;
472
473 if (!SvOK (cb_sv))
474 return 0;
475
476 cv = sv_2cv (cb_sv, &st, &gvp, 0);
477
478 if (!cv)
479 croak ("IO::AIO watcher callback must be undef or a CODE reference");
480
481 return (SV *)cv;
482} 565}
483 566
484#define dREQ \ 567#define dREQ \
485 SV *cb_cv; \ 568 SV *cb_cv; \
486 aio_req req; \ 569 aio_req req; \
… …
500 PUTBACK; \ 583 PUTBACK; \
501 req_submit (req); \ 584 req_submit (req); \
502 SPAGAIN; \ 585 SPAGAIN; \
503 \ 586 \
504 if (GIMME_V != G_VOID) \ 587 if (GIMME_V != G_VOID) \
505 XPUSHs (req_sv (req, AIO_REQ_KLASS)); 588 XPUSHs (req_sv (req, aio_req_stash));
506 589
507MODULE = IO::AIO PACKAGE = IO::AIO 590MODULE = IO::AIO PACKAGE = IO::AIO
508 591
509PROTOTYPES: ENABLE 592PROTOTYPES: ENABLE
510 593
511BOOT: 594BOOT:
512{ 595{
513 stash = gv_stashpv ("IO::AIO", 1); 596 static const struct {
514 597 const char *name;
515 newCONSTSUB (stash, "EXDEV", newSViv (EXDEV)); 598 IV iv;
516 newCONSTSUB (stash, "O_RDONLY", newSViv (O_RDONLY)); 599 } *civ, const_iv[] = {
517 newCONSTSUB (stash, "O_WRONLY", newSViv (O_WRONLY)); 600# define const_iv(name, value) { # name, (IV) value },
518 newCONSTSUB (stash, "O_CREAT", newSViv (O_CREAT)); 601# define const_eio(name) { # name, (IV) EIO_ ## name },
519 newCONSTSUB (stash, "O_TRUNC", newSViv (O_TRUNC)); 602 const_iv (EXDEV , EXDEV)
603 const_iv (ENOSYS , ENOSYS)
604 const_iv (O_RDONLY, O_RDONLY)
605 const_iv (O_WRONLY, O_WRONLY)
606 const_iv (O_CREAT , O_CREAT)
607 const_iv (O_TRUNC , O_TRUNC)
520#ifndef _WIN32 608#ifndef _WIN32
521 newCONSTSUB (stash, "S_IFIFO", newSViv (S_IFIFO)); 609 const_iv (S_IFIFO , S_IFIFO)
522#endif 610#endif
611 const_iv (FADV_NORMAL , POSIX_FADV_NORMAL)
612 const_iv (FADV_SEQUENTIAL, POSIX_FADV_SEQUENTIAL)
613 const_iv (FADV_RANDOM , POSIX_FADV_RANDOM)
614 const_iv (FADV_NOREUSE , POSIX_FADV_NOREUSE)
615 const_iv (FADV_WILLNEED , POSIX_FADV_WILLNEED)
616 const_iv (FADV_DONTNEED , POSIX_FADV_DONTNEED)
523 617
618 const_iv (ST_RDONLY , ST_RDONLY)
619 const_iv (ST_NOSUID , ST_NOSUID)
620 const_iv (ST_NODEV , ST_NODEV)
621 const_iv (ST_NOEXEC , ST_NOEXEC)
622 const_iv (ST_SYNCHRONOUS , ST_SYNCHRONOUS)
623 const_iv (ST_MANDLOCK , ST_MANDLOCK)
624 const_iv (ST_WRITE , ST_WRITE)
625 const_iv (ST_APPEND , ST_APPEND)
626 const_iv (ST_IMMUTABLE , ST_IMMUTABLE)
627 const_iv (ST_NOATIME , ST_NOATIME)
628 const_iv (ST_NODIRATIME , ST_NODIRATIME)
629 const_iv (ST_RELATIME , ST_RELATIME)
630
631 const_iv (MCL_FUTURE , MCL_FUTURE)
632 const_iv (MCL_CURRENT , MCL_CURRENT)
633
634 const_eio (MS_ASYNC)
635 const_eio (MS_INVALIDATE)
636 const_eio (MS_SYNC)
637
638 const_eio (MT_MODIFY)
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
524 create_respipe (); 667 create_respipe ();
525 668
526 if (eio_init (want_poll, done_poll) < 0) 669 if (eio_init (want_poll, done_poll) < 0)
527 croak ("IO::AIO: unable to initialise eio library"); 670 croak ("IO::AIO: unable to initialise eio library");
528 671
529 /* atfork child called in fifo order, so before eio's handler */ 672 /* atfork child called in fifo order, so before eio's handler */
530 X_THREAD_ATFORK (0, 0, atfork_child); 673 X_THREAD_ATFORK (0, 0, atfork_child);
531} 674}
532 675
533void 676void
534max_poll_reqs (int nreqs) 677max_poll_reqs (int nreqs)
535 PROTOTYPE: $ 678 PROTOTYPE: $
… …
588 ALIAS: 731 ALIAS:
589 aio_fsync = EIO_FSYNC 732 aio_fsync = EIO_FSYNC
590 aio_fdatasync = EIO_FDATASYNC 733 aio_fdatasync = EIO_FDATASYNC
591 PPCODE: 734 PPCODE:
592{ 735{
736 int fd = s_fileno_croak (fh, 0);
593 dREQ; 737 dREQ;
594 738
595 req->type = ix; 739 req->type = ix;
596 req->sv1 = newSVsv (fh); 740 req->sv1 = newSVsv (fh);
597 req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh))); 741 req->int1 = fd;
742
743 REQ_SEND (req);
744}
745
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;
598 760
599 REQ_SEND (req); 761 REQ_SEND (req);
600} 762}
601 763
602void 764void
603aio_close (SV *fh, SV *callback=&PL_sv_undef) 765aio_close (SV *fh, SV *callback=&PL_sv_undef)
604 PROTOTYPE: $;$ 766 PROTOTYPE: $;$
605 PPCODE: 767 PPCODE:
606{ 768{
607 static int close_pipe = -1; /* dummy fd to close fds via dup2 */ 769 static int close_pipe = -1; /* dummy fd to close fds via dup2 */
770 int fd = s_fileno_croak (fh, 0);
608 dREQ; 771 dREQ;
609 772
610 if (close_pipe < 0) 773 if (close_pipe < 0)
611 { 774 {
612 int pipefd [2]; 775 int pipefd [2];
… …
620 } 783 }
621 784
622 req->type = EIO_DUP2; 785 req->type = EIO_DUP2;
623 req->int1 = close_pipe; 786 req->int1 = close_pipe;
624 req->sv2 = newSVsv (fh); 787 req->sv2 = newSVsv (fh);
625 req->int2 = PerlIO_fileno (IoIFP (sv_2io (fh))); 788 req->int2 = fd;
626 789
627 REQ_SEND (req); 790 REQ_SEND (req);
628} 791}
629 792
630void 793void
… …
634 aio_write = EIO_WRITE 797 aio_write = EIO_WRITE
635 PROTOTYPE: $$$$$;$ 798 PROTOTYPE: $$$$$;$
636 PPCODE: 799 PPCODE:
637{ 800{
638 STRLEN svlen; 801 STRLEN svlen;
802 int fd = s_fileno_croak (fh, ix == EIO_WRITE);
639 char *svptr = SvPVbyte (data, svlen); 803 char *svptr = SvPVbyte (data, svlen);
640 UV len = SvUV (length); 804 UV len = SvUV (length);
641
642 SvUPGRADE (data, SVt_PV);
643 SvPOK_on (data);
644 805
645 if (dataoffset < 0) 806 if (dataoffset < 0)
646 dataoffset += svlen; 807 dataoffset += svlen;
647 808
648 if (dataoffset < 0 || dataoffset > svlen) 809 if (dataoffset < 0 || dataoffset > svlen)
… …
654 if (!SvOK (length) || len + dataoffset > svlen) 815 if (!SvOK (length) || len + dataoffset > svlen)
655 len = svlen - dataoffset; 816 len = svlen - dataoffset;
656 } 817 }
657 else 818 else
658 { 819 {
659 /* read: grow scalar as necessary */ 820 /* read: check type and grow scalar as necessary */
821 SvUPGRADE (data, SVt_PV);
660 svptr = SvGROW (data, len + dataoffset + 1); 822 svptr = SvGROW (data, len + dataoffset + 1);
661 } 823 }
662
663 if (len < 0)
664 croak ("length must not be negative");
665 824
666 { 825 {
667 dREQ; 826 dREQ;
668 827
669 req->type = ix; 828 req->type = ix;
670 req->sv1 = newSVsv (fh); 829 req->sv1 = newSVsv (fh);
671 req->int1 = PerlIO_fileno (ix == EIO_READ ? IoIFP (sv_2io (fh)) 830 req->int1 = fd;
672 : IoOFP (sv_2io (fh)));
673 req->offs = SvOK (offset) ? SvVAL64 (offset) : -1; 831 req->offs = SvOK (offset) ? SvVAL64 (offset) : -1;
674 req->size = len; 832 req->size = len;
675 req->sv2 = SvREFCNT_inc (data); 833 req->sv2 = SvREFCNT_inc (data);
676 req->ptr2 = (char *)svptr + dataoffset; 834 req->ptr2 = (char *)svptr + dataoffset;
677 req->stroffset = dataoffset; 835 req->stroffset = dataoffset;
… …
700 858
701 REQ_SEND; 859 REQ_SEND;
702} 860}
703 861
704void 862void
705aio_sendfile (SV *out_fh, SV *in_fh, SV *in_offset, UV length, SV *callback=&PL_sv_undef) 863aio_sendfile (SV *out_fh, SV *in_fh, off_t in_offset, size_t length, SV *callback=&PL_sv_undef)
706 PROTOTYPE: $$$$;$ 864 PROTOTYPE: $$$$;$
707 PPCODE: 865 PPCODE:
708{ 866{
867 int ifd = s_fileno_croak (in_fh , 0);
868 int ofd = s_fileno_croak (out_fh, 1);
709 dREQ; 869 dREQ;
710 870
711 req->type = EIO_SENDFILE; 871 req->type = EIO_SENDFILE;
712 req->sv1 = newSVsv (out_fh); 872 req->sv1 = newSVsv (out_fh);
713 req->int1 = PerlIO_fileno (IoIFP (sv_2io (out_fh))); 873 req->int1 = ofd;
714 req->sv2 = newSVsv (in_fh); 874 req->sv2 = newSVsv (in_fh);
715 req->int2 = PerlIO_fileno (IoIFP (sv_2io (in_fh))); 875 req->int2 = ifd;
716 req->offs = SvVAL64 (in_offset); 876 req->offs = in_offset;
717 req->size = length; 877 req->size = length;
718 878
719 REQ_SEND; 879 REQ_SEND;
720} 880}
721 881
722void 882void
723aio_readahead (SV *fh, SV *offset, IV length, SV *callback=&PL_sv_undef) 883aio_readahead (SV *fh, off_t offset, size_t length, SV *callback=&PL_sv_undef)
724 PROTOTYPE: $$$;$ 884 PROTOTYPE: $$$;$
725 PPCODE: 885 PPCODE:
726{ 886{
887 int fd = s_fileno_croak (fh, 0);
727 dREQ; 888 dREQ;
728 889
729 req->type = EIO_READAHEAD; 890 req->type = EIO_READAHEAD;
730 req->sv1 = newSVsv (fh); 891 req->sv1 = newSVsv (fh);
731 req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh))); 892 req->int1 = fd;
732 req->offs = SvVAL64 (offset); 893 req->offs = offset;
733 req->size = length; 894 req->size = length;
734 895
735 REQ_SEND; 896 REQ_SEND;
736} 897}
737 898
738void 899void
739aio_stat (SV8 *fh_or_path, SV *callback=&PL_sv_undef) 900aio_stat (SV8 *fh_or_path, SV *callback=&PL_sv_undef)
740 ALIAS: 901 ALIAS:
741 aio_stat = EIO_STAT 902 aio_stat = EIO_STAT
742 aio_lstat = EIO_LSTAT 903 aio_lstat = EIO_LSTAT
904 aio_statvfs = EIO_STATVFS
743 PPCODE: 905 PPCODE:
744{ 906{
745 dREQ; 907 dREQ;
746 908
747 req->sv1 = newSVsv (fh_or_path); 909 req->sv1 = newSVsv (fh_or_path);
… …
751 req->type = ix; 913 req->type = ix;
752 req->ptr1 = SvPVbyte_nolen (req->sv1); 914 req->ptr1 = SvPVbyte_nolen (req->sv1);
753 } 915 }
754 else 916 else
755 { 917 {
756 req->type = EIO_FSTAT; 918 req->type = ix == EIO_STATVFS ? EIO_FSTATVFS : EIO_FSTAT;
757 req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path))); 919 req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
758 } 920 }
759 921
760 REQ_SEND; 922 REQ_SEND;
761} 923}
… …
853 req->type = EIO_FCHOWN; 1015 req->type = EIO_FCHOWN;
854 req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path))); 1016 req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
855 } 1017 }
856 1018
857 REQ_SEND; 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;
858} 1037}
859 1038
860void 1039void
861aio_unlink (SV8 *pathname, SV *callback=&PL_sv_undef) 1040aio_unlink (SV8 *pathname, SV *callback=&PL_sv_undef)
862 ALIAS: 1041 ALIAS:
… …
907 1086
908 REQ_SEND; 1087 REQ_SEND;
909} 1088}
910 1089
911void 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
912aio_busy (double delay, SV *callback=&PL_sv_undef) 1125aio_busy (double delay, SV *callback=&PL_sv_undef)
913 PPCODE: 1126 PPCODE:
914{ 1127{
915 dREQ; 1128 dREQ;
916 1129
… …
928 dREQ; 1141 dREQ;
929 1142
930 req->type = EIO_GROUP; 1143 req->type = EIO_GROUP;
931 1144
932 req_submit (req); 1145 req_submit (req);
933 XPUSHs (req_sv (req, AIO_GRP_KLASS)); 1146 XPUSHs (req_sv (req, aio_grp_stash));
934} 1147}
935 1148
936void 1149void
937aio_nop (SV *callback=&PL_sv_undef) 1150aio_nop (SV *callback=&PL_sv_undef)
938 ALIAS: 1151 ALIAS:
… …
990 1203
991int 1204int
992poll_fileno() 1205poll_fileno()
993 PROTOTYPE: 1206 PROTOTYPE:
994 CODE: 1207 CODE:
995 RETVAL = respipe [0]; 1208 RETVAL = s_epipe_fd (&respipe);
996 OUTPUT: 1209 OUTPUT:
997 RETVAL 1210 RETVAL
998 1211
999int 1212int
1000poll_cb(...) 1213poll_cb(...)
… …
1040 CODE: 1253 CODE:
1041 RETVAL = eio_nthreads (); 1254 RETVAL = eio_nthreads ();
1042 OUTPUT: 1255 OUTPUT:
1043 RETVAL 1256 RETVAL
1044 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
1278int
1279mlockall (int flags)
1280 PROTOTYPE: $
1281 CODE:
1282#if _POSIX_MEMLOCK
1283#if __GLIBC__ == 2 && __GLIBC_MINOR__ <= 7
1284 extern int mallopt (int, int);
1285 mallopt (-6, 238); /* http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=473812 */
1286#endif
1287 mlockall (flags);
1288#else
1289 RETVAL ＝-1;
1290 errno = ENOSYS;
1291#endif
1292 OUTPUT:
1293 RETVAL
1294
1295int
1296munlockall ()
1297 PROTOTYPE:
1298 CODE:
1299#if _POSIX_MEMLOCK
1300 munlockall ();
1301#else
1302 RETVAL ＝-1;
1303 errno = ENOSYS;
1304#endif
1305 OUTPUT:
1306 RETVAL
1307
1045void _on_next_submit (SV *cb) 1308void _on_next_submit (SV *cb)
1046 CODE: 1309 CODE:
1047 SvREFCNT_dec (on_next_submit); 1310 SvREFCNT_dec (on_next_submit);
1048 on_next_submit = SvOK (cb) ? newSVsv (cb) : 0; 1311 on_next_submit = SvOK (cb) ? newSVsv (cb) : 0;
1049 1312
… …
1063 if (GIMME_V != G_VOID) 1326 if (GIMME_V != G_VOID)
1064 XPUSHs (req->callback ? sv_2mortal (newRV_inc (req->callback)) : &PL_sv_undef); 1327 XPUSHs (req->callback ? sv_2mortal (newRV_inc (req->callback)) : &PL_sv_undef);
1065 1328
1066 if (items > 1) 1329 if (items > 1)
1067 { 1330 {
1068 SV *cb_cv = get_cb (callback); 1331 SV *cb_cv =get_cb (callback);
1069 1332
1070 SvREFCNT_dec (req->callback); 1333 SvREFCNT_dec (req->callback);
1071 req->callback = SvREFCNT_inc (cb_cv); 1334 req->callback = SvREFCNT_inc (cb_cv);
1072 } 1335 }
1073} 1336}
… …
1110 AV *av; 1373 AV *av;
1111 1374
1112 grp->errorno = errno; 1375 grp->errorno = errno;
1113 1376
1114 av = newAV (); 1377 av = newAV ();
1378 av_extend (av, items - 1);
1115 1379
1116 for (i = 1; i < items; ++i ) 1380 for (i = 1; i < items; ++i )
1117 av_push (av, newSVsv (ST (i))); 1381 av_push (av, newSVsv (ST (i)));
1118 1382
1119 SvREFCNT_dec (grp->sv1); 1383 SvREFCNT_dec (grp->sv1);
… …
1133void 1397void
1134feed (aio_req grp, SV *callback=&PL_sv_undef) 1398feed (aio_req grp, SV *callback=&PL_sv_undef)
1135 CODE: 1399 CODE:
1136{ 1400{
1137 SvREFCNT_dec (grp->sv2); 1401 SvREFCNT_dec (grp->sv2);
1138 grp->sv2 = newSVsv (callback); 1402 grp->sv2 = newSVsv (callback);
1403 grp->feed = aio_grp_feed;
1139 1404
1140 if (grp->int2 <= 0) 1405 if (grp->int2 <= 0)
1141 grp->int2 = 2; 1406 grp->int2 = 2;
1142 1407
1143 eio_grp_limit (grp, grp->int2); 1408 eio_grp_limit (grp, grp->int2);

Diff Legend

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