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.30 by root, Thu Aug 18 16:32:10 2005 UTC vs.
Revision 1.37 by root, Tue Aug 23 12:37:19 2005 UTC

… …
5#include "perl.h" 5#include "perl.h"
6#include "XSUB.h" 6#include "XSUB.h"
7 7
8#include "autoconf/config.h" 8#include "autoconf/config.h"
9 9
10#include <pthread.h>
11
12#include <stddef.h>
10#include <sys/types.h> 13#include <sys/types.h>
11#include <sys/stat.h> 14#include <sys/stat.h>
12 15#include <limits.h>
13#include <unistd.h> 16#include <unistd.h>
14#include <fcntl.h> 17#include <fcntl.h>
15#include <signal.h> 18#include <signal.h>
16#include <sched.h> 19#include <sched.h>
17 20
18#include <pthread.h> 21#if HAVE_SENDFILE
19 22# if __linux
20typedef void *InputStream; /* hack, but 5.6.1 is simply toooo old ;) */ 23# include <sys/sendfile.h>
21typedef void *OutputStream; /* hack, but 5.6.1 is simply toooo old ;) */ 24# elif __freebsd
22typedef void *InOutStream; /* hack, but 5.6.1 is simply toooo old ;) */ 25# include <sys/socket.h>
26# include <sys/uio.h>
27# elif __hpux
28# include <sys/socket.h>
29# elif __solaris /* not yet */
30# include <sys/sendfile.h>
31# else
32# error sendfile support requested but not available
33# endif
34#endif
23 35
24#if __ia64 36#if __ia64
25# define STACKSIZE 65536 37# define STACKSIZE 65536
26#else 38#else
27# define STACKSIZE 4096 39# define STACKSIZE 8192
28#endif 40#endif
29 41
30enum { 42enum {
31 REQ_QUIT, 43 REQ_QUIT,
32 REQ_OPEN, REQ_CLOSE, 44 REQ_OPEN, REQ_CLOSE,
33 REQ_READ, REQ_WRITE, REQ_READAHEAD, 45 REQ_READ, REQ_WRITE, REQ_READAHEAD,
46 REQ_SENDFILE,
34 REQ_STAT, REQ_LSTAT, REQ_FSTAT, 47 REQ_STAT, REQ_LSTAT, REQ_FSTAT,
35 REQ_FSYNC, REQ_FDATASYNC, 48 REQ_FSYNC, REQ_FDATASYNC,
36 REQ_UNLINK, REQ_RMDIR, 49 REQ_UNLINK, REQ_RMDIR,
50 REQ_READDIR,
37 REQ_SYMLINK, 51 REQ_SYMLINK,
38}; 52};
39 53
40typedef struct aio_cb { 54typedef struct aio_cb {
41 struct aio_cb *volatile next; 55 struct aio_cb *volatile next;
42 56
43 int type; 57 int type;
44 58
59 /* should receive a cleanup, with unions */
45 int fd; 60 int fd, fd2;
46 off_t offset; 61 off_t offset;
47 size_t length; 62 size_t length;
48 ssize_t result; 63 ssize_t result;
49 mode_t mode; /* open */ 64 mode_t mode; /* open */
50 int errorno; 65 int errorno;
51 SV *data, *callback, *fh; 66 SV *data, *callback;
67 SV *fh, *fh2;
52 void *dataptr, *data2ptr; 68 void *dataptr, *data2ptr;
53 STRLEN dataoffset; 69 STRLEN dataoffset;
54 70
55 Stat_t *statdata; 71 Stat_t *statdata;
56} aio_cb; 72} aio_cb;
… …
75 SvREFCNT_dec (req->data); 91 SvREFCNT_dec (req->data);
76 92
77 if (req->fh) 93 if (req->fh)
78 SvREFCNT_dec (req->fh); 94 SvREFCNT_dec (req->fh);
79 95
96 if (req->fh2)
97 SvREFCNT_dec (req->fh2);
98
80 if (req->statdata) 99 if (req->statdata)
81 Safefree (req->statdata); 100 Safefree (req->statdata);
82 101
83 if (req->callback) 102 if (req->callback)
84 SvREFCNT_dec (req->callback); 103 SvREFCNT_dec (req->callback);
104
105 if (req->type == REQ_READDIR && req->result >= 0)
106 free (req->data2ptr);
85 107
86 Safefree (req); 108 Safefree (req);
87} 109}
88 110
89static void 111static void
… …
154 PL_statcache = *(req->statdata); 176 PL_statcache = *(req->statdata);
155 } 177 }
156 178
157 ENTER; 179 ENTER;
158 PUSHMARK (SP); 180 PUSHMARK (SP);
159 XPUSHs (sv_2mortal (newSViv (req->result)));
160 181
161 if (req->type == REQ_OPEN) 182 if (req->type == REQ_READDIR)
162 { 183 {
184 SV *rv = &PL_sv_undef;
185
186 if (req->result >= 0)
187 {
188 char *buf = req->data2ptr;
189 AV *av = newAV ();
190
191 while (req->result)
192 {
193 SV *sv = newSVpv (buf, 0);
194
195 av_push (av, sv);
196 buf += SvCUR (sv) + 1;
197 req->result--;
198 }
199
200 rv = sv_2mortal (newRV_noinc ((SV *)av));
201 }
202
203 XPUSHs (rv);
204 }
205 else
206 {
207 XPUSHs (sv_2mortal (newSViv (req->result)));
208
209 if (req->type == REQ_OPEN)
210 {
163 /* convert fd to fh */ 211 /* convert fd to fh */
164 SV *fh; 212 SV *fh;
165 213
166 PUTBACK; 214 PUTBACK;
167 call_pv ("IO::AIO::_fd2fh", G_SCALAR | G_EVAL); 215 call_pv ("IO::AIO::_fd2fh", G_SCALAR | G_EVAL);
168 SPAGAIN; 216 SPAGAIN;
169 217
170 fh = SvREFCNT_inc (POPs); 218 fh = SvREFCNT_inc (POPs);
171 219
172 PUSHMARK (SP); 220 PUSHMARK (SP);
173 XPUSHs (sv_2mortal (fh)); 221 XPUSHs (sv_2mortal (fh));
222 }
174 } 223 }
175 224
176 if (SvOK (req->callback)) 225 if (SvOK (req->callback))
177 { 226 {
178 PUTBACK; 227 PUTBACK;
… …
207 pthread_t tid; 256 pthread_t tid;
208 pthread_attr_t attr; 257 pthread_attr_t attr;
209 258
210 pthread_attr_init (&attr); 259 pthread_attr_init (&attr);
211 pthread_attr_setstacksize (&attr, STACKSIZE); 260 pthread_attr_setstacksize (&attr, STACKSIZE);
212// pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED); 261 pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
213 262
214 sigfillset (&fullsigset); 263 sigfillset (&fullsigset);
215 sigprocmask (SIG_SETMASK, &fullsigset, &oldsigset); 264 sigprocmask (SIG_SETMASK, &fullsigset, &oldsigset);
216 265
217 if (pthread_create (&tid, &attr, aio_proc, 0) == 0) 266 if (pthread_create (&tid, &attr, aio_proc, 0) == 0)
… …
299 if (fcntl (respipe [0], F_SETFL, O_NONBLOCK)) 348 if (fcntl (respipe [0], F_SETFL, O_NONBLOCK))
300 croak ("cannot set result pipe to nonblocking mode"); 349 croak ("cannot set result pipe to nonblocking mode");
301 350
302 if (fcntl (respipe [1], F_SETFL, O_NONBLOCK)) 351 if (fcntl (respipe [1], F_SETFL, O_NONBLOCK))
303 croak ("cannot set result pipe to nonblocking mode"); 352 croak ("cannot set result pipe to nonblocking mode");
304}
305
306static void atfork_prepare (void)
307{
308 pthread_mutex_lock (&reqlock);
309 pthread_mutex_lock (&reslock);
310}
311
312static void atfork_parent (void)
313{
314 pthread_mutex_unlock (&reslock);
315 pthread_mutex_unlock (&reqlock);
316}
317
318static void atfork_child (void)
319{
320 aio_req prv;
321
322 started = 0;
323
324 while (reqs)
325 {
326 prv = reqs;
327 reqs = prv->next;
328 free_req (prv);
329 }
330
331 reqs = reqe = 0;
332
333 while (ress)
334 {
335 prv = ress;
336 ress = prv->next;
337 free_req (prv);
338 }
339
340 ress = rese = 0;
341
342 close (respipe [0]);
343 close (respipe [1]);
344 create_pipe ();
345
346 atfork_parent ();
347} 353}
348 354
349/*****************************************************************************/ 355/*****************************************************************************/
350/* work around various missing functions */ 356/* work around various missing functions */
351 357
… …
356/* 362/*
357 * make our pread/pwrite safe against themselves, but not against 363 * make our pread/pwrite safe against themselves, but not against
358 * normal read/write by using a mutex. slows down execution a lot, 364 * normal read/write by using a mutex. slows down execution a lot,
359 * but that's your problem, not mine. 365 * but that's your problem, not mine.
360 */ 366 */
361static pthread_mutex_t iolock = PTHREAD_MUTEX_INITIALIZER; 367static pthread_mutex_t preadwritelock = PTHREAD_MUTEX_INITIALIZER;
362 368
363static ssize_t 369static ssize_t
364pread (int fd, void *buf, size_t count, off_t offset) 370pread (int fd, void *buf, size_t count, off_t offset)
365{ 371{
366 ssize_t res; 372 ssize_t res;
367 off_t ooffset; 373 off_t ooffset;
368 374
369 pthread_mutex_lock (&iolock); 375 pthread_mutex_lock (&preadwritelock);
370 ooffset = lseek (fd, 0, SEEK_CUR); 376 ooffset = lseek (fd, 0, SEEK_CUR);
371 lseek (fd, offset, SEEK_SET); 377 lseek (fd, offset, SEEK_SET);
372 res = read (fd, buf, count); 378 res = read (fd, buf, count);
373 lseek (fd, ooffset, SEEK_SET); 379 lseek (fd, ooffset, SEEK_SET);
374 pthread_mutex_unlock (&iolock); 380 pthread_mutex_unlock (&preadwritelock);
375 381
376 return res; 382 return res;
377} 383}
378 384
379static ssize_t 385static ssize_t
380pwrite (int fd, void *buf, size_t count, off_t offset) 386pwrite (int fd, void *buf, size_t count, off_t offset)
381{ 387{
382 ssize_t res; 388 ssize_t res;
383 off_t ooffset; 389 off_t ooffset;
384 390
385 pthread_mutex_lock (&iolock); 391 pthread_mutex_lock (&preadwritelock);
386 ooffset = lseek (fd, 0, SEEK_CUR); 392 ooffset = lseek (fd, 0, SEEK_CUR);
387 lseek (fd, offset, SEEK_SET); 393 lseek (fd, offset, SEEK_SET);
388 res = write (fd, buf, count); 394 res = write (fd, buf, count);
389 lseek (fd, offset, SEEK_SET); 395 lseek (fd, offset, SEEK_SET);
390 pthread_mutex_unlock (&iolock); 396 pthread_mutex_unlock (&preadwritelock);
391 397
392 return res; 398 return res;
393} 399}
394#endif 400#endif
395 401
… …
398#endif 404#endif
399 405
400#if !HAVE_READAHEAD 406#if !HAVE_READAHEAD
401# define readahead aio_readahead 407# define readahead aio_readahead
402 408
403static char readahead_buf[4096];
404
405static ssize_t 409static ssize_t
406readahead (int fd, off_t offset, size_t count) 410readahead (int fd, off_t offset, size_t count)
407{ 411{
412 char readahead_buf[4096];
413
408 while (count > 0) 414 while (count > 0)
409 { 415 {
410 size_t len = count < sizeof (readahead_buf) ? count : sizeof (readahead_buf); 416 size_t len = count < sizeof (readahead_buf) ? count : sizeof (readahead_buf);
411 417
412 pread (fd, readahead_buf, len, offset); 418 pread (fd, readahead_buf, len, offset);
… …
415 } 421 }
416 422
417 errno = 0; 423 errno = 0;
418} 424}
419#endif 425#endif
426
427#if !HAVE_READDIR_R
428# define readdir_r aio_readdir_r
429
430static pthread_mutex_t readdirlock = PTHREAD_MUTEX_INITIALIZER;
431
432static int
433readdir_r (DIR *dirp, struct dirent *ent, struct dirent **res)
434{
435 struct dirent *e;
436 int errorno;
437
438 pthread_mutex_lock (&readdirlock);
439
440 e = readdir (dirp);
441 errorno = errno;
442
443 if (e)
444 {
445 *res = ent;
446 strcpy (ent->d_name, e->d_name);
447 }
448 else
449 *res = 0;
450
451 pthread_mutex_unlock (&readdirlock);
452
453 errno = errorno;
454 return e ? 0 : -1;
455}
456#endif
457
458/* sendfile always needs emulation */
459static ssize_t
460sendfile_ (int ofd, int ifd, off_t offset, size_t count)
461{
462 ssize_t res;
463
464 if (!count)
465 return 0;
466
467#if HAVE_SENDFILE
468# if __linux
469 res = sendfile (ofd, ifd, &offset, count);
470
471# elif __freebsd
472 /*
473 * Of course, the freebsd sendfile is a dire hack with no thoughts
474 * wasted on making it similar to other I/O functions.
475 */
476 {
477 off_t sbytes;
478 res = sendfile (ifd, ofd, offset, count, 0, &sbytes, 0);
479
480 if (res < 0 && sbytes)
481 /* maybe only on EAGAIN only: as usual, the manpage leaves you guessing */
482 res = sbytes;
483 }
484
485# elif __hpux
486 res = sendfile (ofd, ifd, offset, count, 0, 0);
487
488# elif __solaris
489 {
490 struct sendfilevec vec;
491 size_t sbytes;
492
493 vec.sfv_fd = ifd;
494 vec.sfv_flag = 0;
495 vec.sfv_off = offset;
496 vec.sfv_len = count;
497
498 res = sendfilev (ofd, &vec, 1, &sbytes);
499
500 if (res < 0 && sbytes)
501 res = sbytes;
502 }
503
504# else
505 res = -1;
506 errno = ENOSYS;
507# endif
508#endif
509
510 if (res < 0
511 && (errno == ENOSYS || errno == EINVAL || errno == ENOTSOCK
512#if __solaris
513 || errno == EAFNOSUPPORT || errno == EPROTOTYPE
514#endif
515 )
516 )
517 {
518 /* emulate sendfile. this is a major pain in the ass */
519 char buf[4096];
520 res = 0;
521
522 for (;;)
523 {
524 ssize_t cnt;
525
526 cnt = pread (ifd, buf, 4096, offset);
527
528 if (cnt <= 0)
529 {
530 if (cnt && !res) res = -1;
531 break;
532 }
533
534 cnt = write (ofd, buf, cnt);
535
536 if (cnt <= 0)
537 {
538 if (cnt && !res) res = -1;
539 break;
540 }
541
542 offset += cnt;
543 res += cnt;
544 }
545 }
546
547 return res;
548}
549
550/* read a full directory */
551static int
552scandir_ (const char *path, void **namesp)
553{
554 DIR *dirp = opendir (path);
555 union
556 {
557 struct dirent d;
558 char b [offsetof (struct dirent, d_name) + NAME_MAX + 1];
559 } u;
560 struct dirent *entp;
561 char *name, *names;
562 int memlen = 4096;
563 int memofs = 0;
564 int res = 0;
565 int errorno;
566
567 if (!dirp)
568 return -1;
569
570 names = malloc (memlen);
571
572 for (;;)
573 {
574 errno = 0, readdir_r (dirp, &u.d, &entp);
575
576 if (!entp)
577 break;
578
579 name = entp->d_name;
580
581 if (name [0] != '.' || (name [1] && (name [1] != '.' || name [2])))
582 {
583 int len = strlen (name) + 1;
584
585 res++;
586
587 while (memofs + len > memlen)
588 {
589 memlen *= 2;
590 names = realloc (names, memlen);
591 if (!names)
592 break;
593 }
594
595 memcpy (names + memofs, name, len);
596 memofs += len;
597 }
598 }
599
600 errorno = errno;
601 closedir (dirp);
602
603 if (errorno)
604 {
605 free (names);
606 errno = errorno;
607 res = -1;
608 }
609
610 *namesp = (void *)names;
611 return res;
612}
420 613
421/*****************************************************************************/ 614/*****************************************************************************/
422 615
423static void * 616static void *
424aio_proc (void *thr_arg) 617aio_proc (void *thr_arg)
… …
456 { 649 {
457 case REQ_READ: req->result = pread (req->fd, req->dataptr, req->length, req->offset); break; 650 case REQ_READ: req->result = pread (req->fd, req->dataptr, req->length, req->offset); break;
458 case REQ_WRITE: req->result = pwrite (req->fd, req->dataptr, req->length, req->offset); break; 651 case REQ_WRITE: req->result = pwrite (req->fd, req->dataptr, req->length, req->offset); break;
459 652
460 case REQ_READAHEAD: req->result = readahead (req->fd, req->offset, req->length); break; 653 case REQ_READAHEAD: req->result = readahead (req->fd, req->offset, req->length); break;
654 case REQ_SENDFILE: req->result = sendfile_ (req->fd, req->fd2, req->offset, req->length); break;
461 655
462 case REQ_STAT: req->result = stat (req->dataptr, req->statdata); break; 656 case REQ_STAT: req->result = stat (req->dataptr, req->statdata); break;
463 case REQ_LSTAT: req->result = lstat (req->dataptr, req->statdata); break; 657 case REQ_LSTAT: req->result = lstat (req->dataptr, req->statdata); break;
464 case REQ_FSTAT: req->result = fstat (req->fd , req->statdata); break; 658 case REQ_FSTAT: req->result = fstat (req->fd , req->statdata); break;
465 659
… …
469 case REQ_RMDIR: req->result = rmdir (req->dataptr); break; 663 case REQ_RMDIR: req->result = rmdir (req->dataptr); break;
470 case REQ_SYMLINK: req->result = symlink (req->data2ptr, req->dataptr); break; 664 case REQ_SYMLINK: req->result = symlink (req->data2ptr, req->dataptr); break;
471 665
472 case REQ_FDATASYNC: req->result = fdatasync (req->fd); break; 666 case REQ_FDATASYNC: req->result = fdatasync (req->fd); break;
473 case REQ_FSYNC: req->result = fsync (req->fd); break; 667 case REQ_FSYNC: req->result = fsync (req->fd); break;
668 case REQ_READDIR: req->result = scandir_ (req->dataptr, &req->data2ptr); break;
474 669
475 case REQ_QUIT: 670 case REQ_QUIT:
476 break; 671 break;
477 672
478 default: 673 default:
… …
502 pthread_mutex_unlock (&reslock); 697 pthread_mutex_unlock (&reslock);
503 } 698 }
504 while (type != REQ_QUIT); 699 while (type != REQ_QUIT);
505 700
506 return 0; 701 return 0;
702}
703
704/*****************************************************************************/
705
706static void atfork_prepare (void)
707{
708 pthread_mutex_lock (&reqlock);
709 pthread_mutex_lock (&reslock);
710#if !HAVE_PREADWRITE
711 pthread_mutex_lock (&preadwritelock);
712#endif
713#if !HAVE_READDIR_R
714 pthread_mutex_lock (&readdirlock);
715#endif
716}
717
718static void atfork_parent (void)
719{
720#if !HAVE_READDIR_R
721 pthread_mutex_unlock (&readdirlock);
722#endif
723#if !HAVE_PREADWRITE
724 pthread_mutex_unlock (&preadwritelock);
725#endif
726 pthread_mutex_unlock (&reslock);
727 pthread_mutex_unlock (&reqlock);
728}
729
730static void atfork_child (void)
731{
732 aio_req prv;
733
734 started = 0;
735
736 while (reqs)
737 {
738 prv = reqs;
739 reqs = prv->next;
740 free_req (prv);
741 }
742
743 reqs = reqe = 0;
744
745 while (ress)
746 {
747 prv = ress;
748 ress = prv->next;
749 free_req (prv);
750 }
751
752 ress = rese = 0;
753
754 close (respipe [0]);
755 close (respipe [1]);
756 create_pipe ();
757
758 atfork_parent ();
507} 759}
508 760
509#define dREQ \ 761#define dREQ \
510 aio_req req; \ 762 aio_req req; \
511 \ 763 \
… …
588 840
589void 841void
590aio_read(fh,offset,length,data,dataoffset,callback=&PL_sv_undef) 842aio_read(fh,offset,length,data,dataoffset,callback=&PL_sv_undef)
591 SV * fh 843 SV * fh
592 UV offset 844 UV offset
593 IV length 845 UV length
594 SV * data 846 SV * data
595 IV dataoffset 847 UV dataoffset
596 SV * callback 848 SV * callback
597 ALIAS: 849 ALIAS:
598 aio_read = REQ_READ 850 aio_read = REQ_READ
599 aio_write = REQ_WRITE 851 aio_write = REQ_WRITE
600 PROTOTYPE: $$$$$;$ 852 PROTOTYPE: $$$$$;$
… …
646 req->data2ptr = (void *)data; 898 req->data2ptr = (void *)data;
647 } 899 }
648 900
649 send_req (req); 901 send_req (req);
650 } 902 }
903}
904
905void
906aio_sendfile(out_fh,in_fh,in_offset,length,callback=&PL_sv_undef)
907 SV * out_fh
908 SV * in_fh
909 UV in_offset
910 UV length
911 SV * callback
912 PROTOTYPE: $$$$;$
913 CODE:
914{
915 dREQ;
916
917 req->type = REQ_SENDFILE;
918 req->fh = newSVsv (out_fh);
919 req->fd = PerlIO_fileno (IoIFP (sv_2io (out_fh)));
920 req->fh2 = newSVsv (in_fh);
921 req->fd2 = PerlIO_fileno (IoIFP (sv_2io (in_fh)));
922 req->offset = in_offset;
923 req->length = length;
924
925 send_req (req);
651} 926}
652 927
653void 928void
654aio_readahead(fh,offset,length,callback=&PL_sv_undef) 929aio_readahead(fh,offset,length,callback=&PL_sv_undef)
655 SV * fh 930 SV * fh
… …
739 1014
740 send_req (req); 1015 send_req (req);
741} 1016}
742 1017
743void 1018void
1019aio_readdir(pathname,callback=&PL_sv_undef)
1020 SV * pathname
1021 SV * callback
1022 CODE:
1023{
1024 dREQ;
1025
1026 req->type = REQ_READDIR;
1027 req->data = newSVsv (pathname);
1028 req->dataptr = SvPVbyte_nolen (req->data);
1029
1030 send_req (req);
1031}
1032
1033void
744flush() 1034flush()
745 PROTOTYPE: 1035 PROTOTYPE:
746 CODE: 1036 CODE:
747 while (nreqs) 1037 while (nreqs)
748 { 1038 {

Diff Legend

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