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.4 by root, Sun Jul 10 20:57:00 2005 UTC vs.
Revision 1.169 by root, Wed Aug 4 16:06:54 2010 UTC

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

Diff Legend

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