ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/Linux-AIO/AIO.xs
(Generate patch)

Comparing Linux-AIO/AIO.xs (file contents):
Revision 1.3 by root, Tue Aug 14 04:33:50 2001 UTC vs.
Revision 1.21 by root, Fri Aug 6 17:18:08 2004 UTC

1#define PERL_NO_GET_CONTEXT
2
1#include "EXTERN.h" 3#include "EXTERN.h"
2#include "perl.h" 4#include "perl.h"
3#include "XSUB.h" 5#include "XSUB.h"
4 6
5#include <sys/types.h> 7#include <sys/types.h>
8#include <sys/stat.h>
6#include <unistd.h> 9#include <unistd.h>
10#include <fcntl.h>
11#include <signal.h>
7#include <sched.h> 12#include <sched.h>
8 13
14typedef void *InputStream; /* hack, but 5.6.1 is simply toooo old ;) */
15typedef void *OutputStream; /* hack, but 5.6.1 is simply toooo old ;) */
16typedef void *InOutStream; /* hack, but 5.6.1 is simply toooo old ;) */
17
9#define STACKSIZE 128 /* yeah */ 18#define STACKSIZE 1024 /* yeah */
10 19
11#define REQ_QUIT 0 20enum {
12#define REQ_READ 1 21 REQ_QUIT,
13#define REQ_WRITE 2 22 REQ_OPEN, REQ_CLOSE, REQ_READ, REQ_WRITE,
23 REQ_STAT, REQ_LSTAT, REQ_FSTAT, REQ_UNLINK
24};
14 25
15typedef struct { 26typedef struct {
16 char stack[STACKSIZE]; 27 char stack[STACKSIZE];
17} aio_thread; 28} aio_thread;
18 29
19typedef struct { 30typedef struct aio_cb {
31 struct aio_cb *next;
32
20 int type; 33 int type;
21 aio_thread *thread; 34 aio_thread *thread;
22 35
23/* read/write */
24 int fd; 36 int fd;
25 off_t offset; 37 off_t offset;
26 size_t length; 38 size_t length;
27 ssize_t result; 39 ssize_t result;
40 mode_t mode; /* open */
28 int errorno; 41 int errorno;
29 42 SV *data, *callback;
30 SV *data;
31 void *dataptr; 43 void *dataptr;
32 STRLEN dataoffset; 44 STRLEN dataoffset;
45
46 Stat_t *statdata;
33} aio_cb; 47} aio_cb;
34 48
35typedef aio_cb *aio_req; 49typedef aio_cb *aio_req;
36 50
37static int started; 51static int started;
52static int nreqs;
38static int reqpipe[2], respipe[2]; 53static int reqpipe[2], respipe[2];
39 54
55static aio_req qs, qe; /* queue start, queue end */
56
40static int aio_proc(void *arg); 57static int aio_proc(void *arg);
41 58
42static void 59static void
43start_thread(void) 60start_thread (void)
44{ 61{
45 aio_thread *thr; 62 aio_thread *thr;
46 63
47 New (0, thr, 1, aio_thread); 64 New (0, thr, 1, aio_thread);
48 65
49 if (clone (aio_proc, 66 if (clone (aio_proc,
50 &(thr->stack[STACKSIZE]), 67 &(thr->stack[STACKSIZE]),
51 CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND, 68 CLONE_VM|CLONE_FS|CLONE_FILES,
52 thr) >= 0) 69 thr) >= 0)
53 started++; 70 started++;
54 else 71 else
55 Safefree (thr); 72 Safefree (thr);
56} 73}
57 74
58static void 75static void
59end_thread(void) 76send_reqs (void)
60{ 77{
61 aio_req req = 0; 78 /* this write is atomic */
62 write (reqpipe[1], &req, sizeof (aio_req)); 79 while (qs && write (reqpipe[1], &qs, sizeof qs) == sizeof qs)
63 started--; 80 {
81 qs = qs->next;
82 if (!qs) qe = 0;
83 }
64} 84}
65 85
66static void 86static void
67set_errno(int errorno) 87send_req (aio_req req)
68{ 88{
89 nreqs++;
90 req->next = 0;
91
92 if (qe)
93 qe->next = req;
94 else
95 qe = qs = req;
96
97 send_reqs ();
98}
99
100static void
101end_thread (void)
102{
103 aio_req req;
104 New (0, req, 1, aio_cb);
105 req->type = REQ_QUIT;
106
107 send_req (req);
108}
109
110static void
111read_write (pTHX_
112 int dowrite, int fd, off_t offset, size_t length,
113 SV *data, STRLEN dataoffset, SV *callback)
114{
115 aio_req req;
116 STRLEN svlen;
117 char *svptr = SvPV (data, svlen);
118
119 SvUPGRADE (data, SVt_PV);
120 SvPOK_on (data);
121
122 if (dataoffset < 0)
123 dataoffset += svlen;
124
125 if (dataoffset < 0 || dataoffset > svlen)
126 croak ("data offset outside of string");
127
128 if (dowrite)
129 {
130 /* write: check length and adjust. */
131 if (length < 0 || length + dataoffset > svlen)
132 length = svlen - dataoffset;
133 }
134 else
135 {
136 /* read: grow scalar as necessary */
137 svptr = SvGROW (data, length + dataoffset);
138 }
139
140 if (length < 0)
141 croak ("length must not be negative");
142
143 Newz (0, req, 1, aio_cb);
144
145 if (!req)
146 croak ("out of memory during aio_req allocation");
147
148 req->type = dowrite ? REQ_WRITE : REQ_READ;
149 req->fd = fd;
150 req->offset = offset;
151 req->length = length;
152 req->data = SvREFCNT_inc (data);
153 req->dataptr = (char *)svptr + dataoffset;
154 req->callback = SvREFCNT_inc (callback);
155
156 send_req (req);
157}
158
159static int
160poll_cb (pTHX)
161{
162 dSP;
163 int count = 0;
164 aio_req req;
165
166 while (read (respipe[0], (void *)&req, sizeof (req)) == sizeof (req))
167 {
168 if (req->type == REQ_QUIT)
169 {
170 Safefree (req->thread);
171 started--;
172 }
173 else
174 {
175 int errorno = errno;
176 errno = req->errorno;
177
178 if (req->type == REQ_READ)
179 SvCUR_set (req->data, req->dataoffset
180 + req->result > 0 ? req->result : 0);
181
182 if (req->data)
183 SvREFCNT_dec (req->data);
184
185 if (req->type == REQ_STAT || req->type == REQ_LSTAT || req->type == REQ_FSTAT)
186 {
187 PL_laststype = req->type == REQ_LSTAT ? OP_LSTAT : OP_STAT;
188 PL_laststatval = req->result;
189 PL_statcache = *(req->statdata);
190
191 Safefree (req->statdata);
192 }
193
194 PUSHMARK (SP);
195 XPUSHs (sv_2mortal (newSViv (req->result)));
196 PUTBACK;
197 call_sv (req->callback, G_VOID);
198 SPAGAIN;
199
200 if (req->callback)
201 SvREFCNT_dec (req->callback);
202
69 errno = errorno; 203 errno = errorno;
204 nreqs--;
205 count++;
206 }
207
208 Safefree (req);
209 }
210
211 if (qs)
212 send_reqs ();
213
214 return count;
70} 215}
216
217static sigset_t fullsigset;
71 218
72#undef errno 219#undef errno
73#include <asm/unistd.h> 220#include <asm/unistd.h>
221#include <sys/prctl.h>
222
223#define COPY_STATDATA \
224 req->statdata->st_dev = statdata.st_dev; \
225 req->statdata->st_ino = statdata.st_ino; \
226 req->statdata->st_mode = statdata.st_mode; \
227 req->statdata->st_nlink = statdata.st_nlink; \
228 req->statdata->st_uid = statdata.st_uid; \
229 req->statdata->st_gid = statdata.st_gid; \
230 req->statdata->st_rdev = statdata.st_rdev; \
231 req->statdata->st_size = statdata.st_size; \
232 req->statdata->st_atime = statdata.st_atime; \
233 req->statdata->st_mtime = statdata.st_mtime; \
234 req->statdata->st_ctime = statdata.st_ctime; \
235 req->statdata->st_blksize = statdata.st_blksize; \
236 req->statdata->st_blocks = statdata.st_blocks; \
74 237
75static int 238static int
76aio_proc(void *thr_arg) 239aio_proc (void *thr_arg)
77{ 240{
78 aio_thread *thr = thr_arg; 241 aio_thread *thr = thr_arg;
79 int sig; 242 aio_req req;
80 int errno; 243 int errno;
81 aio_req req;
82 244
245 /* this is very much kernel-specific :(:(:( */
83 /* we rely on gcc's ability to create closures. */ 246 /* we rely on gcc's ability to create closures. */
84 _syscall3(int,lseek,int,fd,off_t,offset,int,whence);
85 _syscall3(int,read,int,fd,char *,buf,off_t,count); 247 _syscall3(int,read,int,fd,char *,buf,size_t,count)
86 _syscall3(int,write,int,fd,char *,buf,off_t,count); 248 _syscall3(int,write,int,fd,char *,buf,size_t,count)
87 249
88 /* first get rid of any signals */ 250 _syscall3(int,open,char *,pathname,int,flags,mode_t,mode)
89 for (sig = 1; sig < _NSIG; sig++) 251 _syscall1(int,close,int,fd)
90 if (sig != SIGTERM) 252
91 signal (sig, SIG_IGN); 253#ifdef __NR_pread64
92 254 _syscall5(int,pread64,int,fd,char *,buf,size_t,count,unsigned int,offset_lo,unsigned int,offset_hi)
255 _syscall5(int,pwrite64,int,fd,char *,buf,size_t,count,unsigned int,offset_lo,unsigned int,offset_hi)
256#elif __NR_pread
257 _syscall4(int,pread,int,fd,char *,buf,size_t,count,offset_t,offset)
258 _syscall4(int,pwrite,int,fd,char *,buf,size_t,count,offset_t,offset)
259#else
260# error "neither pread nor pread64 defined"
261#endif
262
263
264#ifdef __NR_stat64
265 _syscall2(int,stat64, const char *, filename, struct stat64 *, buf)
266 _syscall2(int,lstat64, const char *, filename, struct stat64 *, buf)
267 _syscall2(int,fstat64, int, fd, struct stat64 *, buf)
268#elif __NR_stat
269 _syscall2(int,stat, const char *, filename, struct stat *, buf)
270 _syscall2(int,lstat, const char *, filename, struct stat *, buf)
271 _syscall2(int,fstat, int, fd, struct stat *, buf)
272#else
273# error "neither stat64 nor stat defined"
274#endif
275
276 _syscall1(int,unlink, char *, filename);
277
278 sigprocmask (SIG_SETMASK, &fullsigset, 0);
279 prctl (PR_SET_PDEATHSIG, SIGKILL);
280
93 /* then loop */ 281 /* then loop */
94 while (read (reqpipe[0], (void *)&req, sizeof (req)) == sizeof (req)) 282 while (read (reqpipe[0], (void *)&req, sizeof (req)) == sizeof (req))
95 { 283 {
96 req->thread = thr; 284 req->thread = thr;
285 errno = 0; /* strictly unnecessary */
97 286
98 if (req->type == REQ_READ || req->type == REQ_WRITE) 287 switch (req->type)
99 { 288 {
289#ifdef __NR_pread64
290 case REQ_READ: req->result = pread64 (req->fd, req->dataptr, req->length, req->offset & 0xffffffff, req->offset >> 32); break;
291 case REQ_WRITE: req->result = pwrite64(req->fd, req->dataptr, req->length, req->offset & 0xffffffff, req->offset >> 32); break;
292#else
293 case REQ_READ: req->result = pread (req->fd, req->dataptr, req->length, req->offset); break;
294 case REQ_WRITE: req->result = pwrite (req->fd, req->dataptr, req->length, req->offset); break;
295#endif
296#ifdef __NR_stat64
297 struct stat64 statdata;
298 case REQ_STAT: req->result = stat64 (req->dataptr, &statdata); COPY_STATDATA; break;
299 case REQ_LSTAT: req->result = lstat64 (req->dataptr, &statdata); COPY_STATDATA; break;
300 case REQ_FSTAT: req->result = fstat64 (req->fd, &statdata); COPY_STATDATA; break;
301#else
302 struct stat statdata;
303 case REQ_STAT: req->result = stat (req->dataptr, &statdata); COPY_STATDATA; break;
304 case REQ_LSTAT: req->result = lstat (req->dataptr, &statdata); COPY_STATDATA; break;
305 case REQ_FSTAT: req->result = fstat (req->fd, &statdata); COPY_STATDATA; break;
306#endif
307 case REQ_OPEN: req->result = open (req->dataptr, req->fd, req->mode); break;
308 case REQ_CLOSE: req->result = close (req->fd); break;
309 case REQ_UNLINK: req->result = unlink (req->dataptr); break;
310
311 case REQ_QUIT:
312 default:
313 write (respipe[1], (void *)&req, sizeof (req));
100 errno = 0; 314 return 0;
101
102 if (lseek (req->fd, req->offset, SEEK_SET) == req->offset)
103 {
104 if (req->type == REQ_READ)
105 req->result = read (req->fd, req->dataptr, req->length);
106 else
107 req->result = write(req->fd, req->dataptr, req->length);
108 }
109
110 req->errorno = errno;
111 } 315 }
112 else
113 {
114 write (respipe[1], (void *)&req, sizeof (req));
115 break;
116 }
117 316
317 req->errorno = errno;
118 write (respipe[1], (void *)&req, sizeof (req)); 318 write (respipe[1], (void *)&req, sizeof (req));
119 } 319 }
120 320
121 return 0; 321 return 0;
122} 322}
123 323
124MODULE = Linux::AIO PACKAGE = Linux::AIO 324MODULE = Linux::AIO PACKAGE = Linux::AIO
125 325
126BOOT: 326BOOT:
127{ 327{
328 sigfillset (&fullsigset);
329 sigdelset (&fullsigset, SIGTERM);
330 sigdelset (&fullsigset, SIGQUIT);
331 sigdelset (&fullsigset, SIGABRT);
332 sigdelset (&fullsigset, SIGINT);
333
128 if (pipe (reqpipe) || pipe (respipe)) 334 if (pipe (reqpipe) || pipe (respipe))
129 croak ("unable to initialize request or result pipe"); 335 croak ("unable to initialize request or result pipe");
336
337 if (fcntl (reqpipe[1], F_SETFL, O_NONBLOCK))
338 croak ("cannot set result pipe to nonblocking mode");
339
340 if (fcntl (respipe[0], F_SETFL, O_NONBLOCK))
341 croak ("cannot set result pipe to nonblocking mode");
130} 342}
131 343
132void 344void
133min_parallel(nthreads) 345min_parallel(nthreads)
134 int nthreads 346 int nthreads
347 PROTOTYPE: $
135 CODE: 348 CODE:
136 while (nthreads > started) 349 while (nthreads > started)
137 start_thread (); 350 start_thread ();
138 351
139void 352void
140max_parallel(nthreads) 353max_parallel(nthreads)
141 int nthreads 354 int nthreads
355 PROTOTYPE: $
142 CODE: 356 CODE:
357 int cur = started;
358 while (cur > nthreads)
359 {
360 end_thread ();
361 cur--;
362 }
363
143 while (started > nthreads) 364 while (started > nthreads)
365 {
366 fd_set rfd;
367 FD_ZERO(&rfd);
368 FD_SET(respipe[0], &rfd);
369
370 select (respipe[0] + 1, &rfd, 0, 0, 0);
371 poll_cb (aTHX);
372 }
373
374void
375aio_open(pathname,flags,mode,callback)
376 SV * pathname
377 int flags
378 int mode
379 SV * callback
380 PROTOTYPE: $$$$
381 CODE:
382 aio_req req;
383
384 Newz (0, req, 1, aio_cb);
385
386 if (!req)
387 croak ("out of memory during aio_req allocation");
388
389 req->type = REQ_OPEN;
390 req->data = newSVsv (pathname);
391 req->dataptr = SvPV_nolen (req->data);
392 req->fd = flags;
393 req->mode = mode;
394 req->callback = SvREFCNT_inc (callback);
395
144 end_thread (); 396 send_req (req);
145 397
146void 398void
399aio_close(fh,callback)
400 InputStream fh
401 SV * callback
402 PROTOTYPE: $$
403 CODE:
404 aio_req req;
405
406 Newz (0, req, 1, aio_cb);
407
408 if (!req)
409 croak ("out of memory during aio_req allocation");
410
411 req->type = REQ_CLOSE;
412 req->fd = PerlIO_fileno (fh);
413 req->callback = SvREFCNT_inc (callback);
414
415 send_req (req);
416
417void
147read(fh,offset,length,data,dataoffset,callback) 418aio_read(fh,offset,length,data,dataoffset,callback)
148 ALIAS: 419 InputStream fh
149 write = 1 420 UV offset
421 IV length
422 SV * data
423 IV dataoffset
424 SV * callback
425 PROTOTYPE: $$$$$$
426 CODE:
427 read_write (aTHX_ 0, PerlIO_fileno (fh), offset, length, data, dataoffset, callback);
428
429void
430aio_write(fh,offset,length,data,dataoffset,callback)
431 OutputStream fh
432 UV offset
433 IV length
434 SV * data
435 IV dataoffset
436 SV * callback
437 PROTOTYPE: $$$$$$
438 CODE:
439 read_write (aTHX_ 1, PerlIO_fileno (fh), offset, length, data, dataoffset, callback);
440
441void
442aio_stat(fh_or_path,callback)
443 SV * fh_or_path
444 SV * callback
445 PROTOTYPE: $$
446 ALIAS:
447 aio_lstat = 1
150 CODE: 448 CODE:
449 aio_req req;
450
451 Newz (0, req, 1, aio_cb);
452
453 if (!req)
454 croak ("out of memory during aio_req allocation");
455
456 New (0, req->statdata, 1, Stat_t);
457
458 if (!req->statdata)
459 croak ("out of memory during aio_req->statdata allocation");
460
461 if (SvPOK (fh_or_path))
462 {
463 req->type = ix ? REQ_LSTAT : REQ_STAT;
464 req->data = newSVsv (fh_or_path);
465 req->dataptr = SvPV_nolen (req->data);
466 }
467 else
468 {
469 req->type = REQ_FSTAT;
470 req->fd = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
471 }
472
473 req->callback = SvREFCNT_inc (callback);
474
475 send_req (req);
476
477void
478aio_unlink(pathname,callback)
479 SV * pathname
480 SV * callback
481 PROTOTYPE: $$
482 CODE:
483 aio_req req;
484
485 Newz (0, req, 1, aio_cb);
486
487 if (!req)
488 croak ("out of memory during aio_req allocation");
489
490 req->type = REQ_UNLINK;
491 req->data = newSVsv (pathname);
492 req->dataptr = SvPV_nolen (req->data);
493 req->callback = SvREFCNT_inc (callback);
494
495 send_req (req);
496
497int
498poll_fileno()
499 PROTOTYPE:
500 CODE:
501 RETVAL = respipe[0];
502 OUTPUT:
503 RETVAL
504
505int
506poll_cb(...)
507 PROTOTYPE:
508 CODE:
509 RETVAL = poll_cb (aTHX);
510 OUTPUT:
511 RETVAL
512
513int
514nreqs()
515 PROTOTYPE:
516 CODE:
517 RETVAL = nreqs;
518 OUTPUT:
519 RETVAL
520

Diff Legend

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