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.98 by root, Wed May 9 06:45:12 2007 UTC vs.
Revision 1.99 by root, Fri Jun 1 05:51:21 2007 UTC

… …
18#include <limits.h> 18#include <limits.h>
19#include <unistd.h> 19#include <unistd.h>
20#include <fcntl.h> 20#include <fcntl.h>
21#include <signal.h> 21#include <signal.h>
22#include <sched.h> 22#include <sched.h>
23#include <utime.h>
23 24
24#if HAVE_SENDFILE 25#if HAVE_SENDFILE
25# if __linux 26# if __linux
26# include <sys/sendfile.h> 27# include <sys/sendfile.h>
27# elif __freebsd 28# elif __freebsd
… …
61 REQ_QUIT, 62 REQ_QUIT,
62 REQ_OPEN, REQ_CLOSE, 63 REQ_OPEN, REQ_CLOSE,
63 REQ_READ, REQ_WRITE, REQ_READAHEAD, 64 REQ_READ, REQ_WRITE, REQ_READAHEAD,
64 REQ_SENDFILE, 65 REQ_SENDFILE,
65 REQ_STAT, REQ_LSTAT, REQ_FSTAT, 66 REQ_STAT, REQ_LSTAT, REQ_FSTAT,
67 REQ_UTIME, REQ_FUTIME, /* must be consecutive */
68 REQ_CHMOD, REQ_FCHMOD, /* must be consecutive */
69 REQ_CHOWN, REQ_FCHOWN, /* must be consecutive */
66 REQ_FSYNC, REQ_FDATASYNC, 70 REQ_FSYNC, REQ_FDATASYNC,
67 REQ_UNLINK, REQ_RMDIR, REQ_MKDIR, REQ_RENAME, 71 REQ_UNLINK, REQ_RMDIR, REQ_MKDIR, REQ_RENAME,
68 REQ_MKNOD, REQ_READDIR, 72 REQ_MKNOD, REQ_READDIR,
69 REQ_LINK, REQ_SYMLINK, REQ_READLINK, 73 REQ_LINK, REQ_SYMLINK, REQ_READLINK,
70 REQ_GROUP, REQ_NOP, 74 REQ_GROUP, REQ_NOP,
… …
76 80
77typedef struct aio_cb 81typedef struct aio_cb
78{ 82{
79 struct aio_cb *volatile next; 83 struct aio_cb *volatile next;
80 84
81 SV *callback, *fh; 85 SV *callback;
82 SV *sv1, *sv2; 86 SV *sv1, *sv2;
83 void *ptr1, *ptr2; 87 void *ptr1, *ptr2;
84 off_t offs; 88 off_t offs;
85 size_t size; 89 size_t size;
86 ssize_t result; 90 ssize_t result;
91 double nv1, nv2;
87 92
88 STRLEN stroffset; 93 STRLEN stroffset;
89 int type; 94 int type;
90 int int1, int2; 95 int int1, int2, int3;
91 int errorno; 96 int errorno;
92 mode_t mode; /* open */ 97 mode_t mode; /* open */
93 98
94 unsigned char flags; 99 unsigned char flags;
95 unsigned char pri; 100 unsigned char pri;
… …
478 break; 483 break;
479 484
480 case REQ_READLINK: 485 case REQ_READLINK:
481 if (req->result > 0) 486 if (req->result > 0)
482 { 487 {
483 SvCUR_set (req->sv1, req->result); 488 SvCUR_set (req->sv2, req->result);
484 *SvEND (req->sv1) = 0; 489 *SvEND (req->sv2) = 0;
485 PUSHs (req->sv1); 490 PUSHs (req->sv2);
486 } 491 }
487 break; 492 break;
488 493
489 case REQ_STAT: 494 case REQ_STAT:
490 case REQ_LSTAT: 495 case REQ_LSTAT:
… …
494 PL_statcache = *(Stat_t *)(req->ptr2); 499 PL_statcache = *(Stat_t *)(req->ptr2);
495 PUSHs (sv_2mortal (newSViv (req->result))); 500 PUSHs (sv_2mortal (newSViv (req->result)));
496 break; 501 break;
497 502
498 case REQ_READ: 503 case REQ_READ:
499 SvCUR_set (req->sv1, req->stroffset + (req->result > 0 ? req->result : 0)); 504 SvCUR_set (req->sv2, req->stroffset + (req->result > 0 ? req->result : 0));
500 *SvEND (req->sv1) = 0; 505 *SvEND (req->sv2) = 0;
501 PUSHs (sv_2mortal (newSViv (req->result))); 506 PUSHs (sv_2mortal (newSViv (req->result)));
502 break; 507 break;
503 508
504 default: 509 default:
505 PUSHs (sv_2mortal (newSViv (req->result))); 510 PUSHs (sv_2mortal (newSViv (req->result)));
… …
539 { 544 {
540 sv_unmagic (req->self, PERL_MAGIC_ext); 545 sv_unmagic (req->self, PERL_MAGIC_ext);
541 SvREFCNT_dec (req->self); 546 SvREFCNT_dec (req->self);
542 } 547 }
543 548
544 SvREFCNT_dec (req->fh);
545 SvREFCNT_dec (req->sv1); 549 SvREFCNT_dec (req->sv1);
546 SvREFCNT_dec (req->sv2); 550 SvREFCNT_dec (req->sv2);
547 SvREFCNT_dec (req->callback); 551 SvREFCNT_dec (req->callback);
548 552
549 if (req->flags & FLAG_PTR2_FREE) 553 if (req->flags & FLAG_PTR2_FREE)
… …
832 836
833 return res; 837 return res;
834} 838}
835#endif 839#endif
836 840
841#ifndef HAVE_FUTIMES
842
843# define utimes(path,times) aio_utimes (path, times)
844# define futimes(fd,times) aio_futimes (fd, times)
845
846int aio_utimes (const char *filename, const struct timeval times[2])
847{
848 if (times)
849 {
850 struct utimbuf buf;
851
852 buf.actime = times[0].tv_sec;
853 buf.modtime = times[1].tv_sec;
854
855 return utime (filename, &buf);
856 }
857 else
858 return utime (filename, 0);
859}
860
861int aio_futimes (int fd, const struct timeval tv[2])
862{
863 errno = ENOSYS;
864 return -1;
865}
866
867#endif
868
837#if !HAVE_FDATASYNC 869#if !HAVE_FDATASYNC
838# define fdatasync fsync 870# define fdatasync fsync
839#endif 871#endif
840 872
841#if !HAVE_READAHEAD 873#if !HAVE_READAHEAD
… …
1109 1141
1110 case REQ_STAT: req->result = stat (req->ptr1, (Stat_t *)req->ptr2); break; 1142 case REQ_STAT: req->result = stat (req->ptr1, (Stat_t *)req->ptr2); break;
1111 case REQ_LSTAT: req->result = lstat (req->ptr1, (Stat_t *)req->ptr2); break; 1143 case REQ_LSTAT: req->result = lstat (req->ptr1, (Stat_t *)req->ptr2); break;
1112 case REQ_FSTAT: req->result = fstat (req->int1, (Stat_t *)req->ptr2); break; 1144 case REQ_FSTAT: req->result = fstat (req->int1, (Stat_t *)req->ptr2); break;
1113 1145
1146 case REQ_CHOWN: req->result = chown (req->ptr1, req->int2, req->int3); break;
1147 case REQ_FCHOWN: req->result = fchown (req->int1, req->int2, req->int3); break;
1148 case REQ_CHMOD: req->result = chmod (req->ptr1, req->mode); break;
1149 case REQ_FCHMOD: req->result = fchmod (req->int1, req->mode); break;
1150
1114 case REQ_OPEN: req->result = open (req->ptr1, req->int1, req->mode); break; 1151 case REQ_OPEN: req->result = open (req->ptr1, req->int1, req->mode); break;
1115 case REQ_CLOSE: req->result = close (req->int1); break; 1152 case REQ_CLOSE: req->result = close (req->int1); break;
1116 case REQ_UNLINK: req->result = unlink (req->ptr1); break; 1153 case REQ_UNLINK: req->result = unlink (req->ptr1); break;
1117 case REQ_RMDIR: req->result = rmdir (req->ptr1); break; 1154 case REQ_RMDIR: req->result = rmdir (req->ptr1); break;
1118 case REQ_MKDIR: req->result = mkdir (req->ptr1, req->mode); break; 1155 case REQ_MKDIR: req->result = mkdir (req->ptr1, req->mode); break;
… …
1128 1165
1129 case REQ_BUSY: 1166 case REQ_BUSY:
1130 { 1167 {
1131 struct timeval tv; 1168 struct timeval tv;
1132 1169
1133 tv.tv_sec = req->int1; 1170 tv.tv_sec = req->nv1;
1134 tv.tv_usec = req->int2; 1171 tv.tv_usec = (req->nv1 - tv.tv_usec) * 1000000.;
1135 1172
1136 req->result = select (0, 0, 0, 0, &tv); 1173 req->result = select (0, 0, 0, 0, &tv);
1174 }
1175
1176 case REQ_UTIME:
1177 case REQ_FUTIME:
1178 {
1179 struct timeval tv[2];
1180 struct timeval *times;
1181
1182 if (req->nv1 != -1. || req->nv2 != -1.)
1183 {
1184 tv[0].tv_sec = req->nv1;
1185 tv[0].tv_usec = (req->nv1 - tv[0].tv_sec) * 1000000.;
1186 tv[1].tv_sec = req->nv2;
1187 tv[1].tv_usec = (req->nv2 - tv[1].tv_sec) * 1000000.;
1188
1189 times = tv;
1190 }
1191 else
1192 times = 0;
1193
1194
1195 req->result = req->type == REQ_FUTIME
1196 ? futimes (req->int1, times)
1197 : utimes (req->ptr1, times);
1137 } 1198 }
1138 1199
1139 case REQ_GROUP: 1200 case REQ_GROUP:
1140 case REQ_NOP: 1201 case REQ_NOP:
1141 break; 1202 break;
1142 1203
1143 case REQ_QUIT: 1204 case REQ_QUIT:
1144 goto quit; 1205 goto quit;
1145 1206
1146 default: 1207 default:
1147 req->result = ENOSYS; 1208 req->result = -1;
1148 break; 1209 break;
1149 } 1210 }
1150 1211
1151 req->errorno = errno; 1212 req->errorno = errno;
1152 1213
… …
1315 max_outstanding = maxreqs; 1376 max_outstanding = maxreqs;
1316 OUTPUT: 1377 OUTPUT:
1317 RETVAL 1378 RETVAL
1318 1379
1319void 1380void
1320aio_open (pathname,flags,mode,callback=&PL_sv_undef) 1381aio_open (SV8 *pathname, int flags, int mode, SV *callback=&PL_sv_undef)
1321 SV8 * pathname
1322 int flags
1323 int mode
1324 SV * callback
1325 PROTOTYPE: $$$;$ 1382 PROTOTYPE: $$$;$
1326 PPCODE: 1383 PPCODE:
1327{ 1384{
1328 dREQ; 1385 dREQ;
1329 1386
… …
1335 1392
1336 REQ_SEND; 1393 REQ_SEND;
1337} 1394}
1338 1395
1339void 1396void
1340aio_close (fh,callback=&PL_sv_undef) 1397aio_close (SV *fh, SV *callback=&PL_sv_undef)
1341 SV * fh
1342 SV * callback
1343 PROTOTYPE: $;$ 1398 PROTOTYPE: $;$
1344 ALIAS: 1399 ALIAS:
1345 aio_close = REQ_CLOSE 1400 aio_close = REQ_CLOSE
1346 aio_fsync = REQ_FSYNC 1401 aio_fsync = REQ_FSYNC
1347 aio_fdatasync = REQ_FDATASYNC 1402 aio_fdatasync = REQ_FDATASYNC
1348 PPCODE: 1403 PPCODE:
1349{ 1404{
1350 dREQ; 1405 dREQ;
1351 1406
1352 req->type = ix; 1407 req->type = ix;
1353 req->fh = newSVsv (fh); 1408 req->sv1 = newSVsv (fh);
1354 req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh))); 1409 req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh)));
1355 1410
1356 REQ_SEND (req); 1411 REQ_SEND (req);
1357} 1412}
1358 1413
1359void 1414void
1360aio_read (fh,offset,length,data,dataoffset,callback=&PL_sv_undef) 1415aio_read (SV *fh, UV offset, UV length, SV8 *data, UV dataoffset, SV *callback=&PL_sv_undef)
1361 SV * fh
1362 UV offset
1363 UV length
1364 SV8 * data
1365 UV dataoffset
1366 SV * callback
1367 ALIAS: 1416 ALIAS:
1368 aio_read = REQ_READ 1417 aio_read = REQ_READ
1369 aio_write = REQ_WRITE 1418 aio_write = REQ_WRITE
1370 PROTOTYPE: $$$$$;$ 1419 PROTOTYPE: $$$$$;$
1371 PPCODE: 1420 PPCODE:
… …
1399 1448
1400 { 1449 {
1401 dREQ; 1450 dREQ;
1402 1451
1403 req->type = ix; 1452 req->type = ix;
1404 req->fh = newSVsv (fh); 1453 req->sv1 = newSVsv (fh);
1405 req->int1 = PerlIO_fileno (ix == REQ_READ ? IoIFP (sv_2io (fh)) 1454 req->int1 = PerlIO_fileno (ix == REQ_READ ? IoIFP (sv_2io (fh))
1406 : IoOFP (sv_2io (fh))); 1455 : IoOFP (sv_2io (fh)));
1407 req->offs = offset; 1456 req->offs = offset;
1408 req->size = length; 1457 req->size = length;
1409 req->sv1 = SvREFCNT_inc (data); 1458 req->sv2 = SvREFCNT_inc (data);
1410 req->ptr1 = (char *)svptr + dataoffset; 1459 req->ptr1 = (char *)svptr + dataoffset;
1411 req->stroffset = dataoffset; 1460 req->stroffset = dataoffset;
1412 1461
1413 if (!SvREADONLY (data)) 1462 if (!SvREADONLY (data))
1414 { 1463 {
… …
1419 REQ_SEND; 1468 REQ_SEND;
1420 } 1469 }
1421} 1470}
1422 1471
1423void 1472void
1424aio_readlink (path,callback=&PL_sv_undef) 1473aio_readlink (SV8 *path, SV *callback=&PL_sv_undef)
1425 SV8 * path
1426 SV * callback
1427 PROTOTYPE: $$;$ 1474 PROTOTYPE: $$;$
1428 PPCODE: 1475 PPCODE:
1429{ 1476{
1430 SV *data; 1477 SV *data;
1431 dREQ; 1478 dREQ;
1432 1479
1433 data = newSV (NAME_MAX); 1480 data = newSV (NAME_MAX);
1434 SvPOK_on (data); 1481 SvPOK_on (data);
1435 1482
1436 req->type = REQ_READLINK; 1483 req->type = REQ_READLINK;
1437 req->fh = newSVsv (path); 1484 req->sv1 = newSVsv (path);
1438 req->ptr2 = SvPVbyte_nolen (req->fh); 1485 req->ptr2 = SvPVbyte_nolen (req->sv1);
1439 req->sv1 = data; 1486 req->sv2 = data;
1440 req->ptr1 = SvPVbyte_nolen (data); 1487 req->ptr1 = SvPVbyte_nolen (data);
1441 1488
1442 REQ_SEND; 1489 REQ_SEND;
1443} 1490}
1444 1491
1445void 1492void
1446aio_sendfile (out_fh,in_fh,in_offset,length,callback=&PL_sv_undef) 1493aio_sendfile (SV *out_fh, SV *in_fh, UV in_offset, UV length, SV *callback=&PL_sv_undef)
1447 SV * out_fh
1448 SV * in_fh
1449 UV in_offset
1450 UV length
1451 SV * callback
1452 PROTOTYPE: $$$$;$ 1494 PROTOTYPE: $$$$;$
1453 PPCODE: 1495 PPCODE:
1454{ 1496{
1455 dREQ; 1497 dREQ;
1456 1498
1457 req->type = REQ_SENDFILE; 1499 req->type = REQ_SENDFILE;
1458 req->fh = newSVsv (out_fh); 1500 req->sv1 = newSVsv (out_fh);
1459 req->int1 = PerlIO_fileno (IoIFP (sv_2io (out_fh))); 1501 req->int1 = PerlIO_fileno (IoIFP (sv_2io (out_fh)));
1460 req->sv2 = newSVsv (in_fh); 1502 req->sv2 = newSVsv (in_fh);
1461 req->int2 = PerlIO_fileno (IoIFP (sv_2io (in_fh))); 1503 req->int2 = PerlIO_fileno (IoIFP (sv_2io (in_fh)));
1462 req->offs = in_offset; 1504 req->offs = in_offset;
1463 req->size = length; 1505 req->size = length;
1464 1506
1465 REQ_SEND; 1507 REQ_SEND;
1466} 1508}
1467 1509
1468void 1510void
1469aio_readahead (fh,offset,length,callback=&PL_sv_undef) 1511aio_readahead (SV *fh, UV offset, IV length, SV *callback=&PL_sv_undef)
1470 SV * fh
1471 UV offset
1472 IV length
1473 SV * callback
1474 PROTOTYPE: $$$;$ 1512 PROTOTYPE: $$$;$
1475 PPCODE: 1513 PPCODE:
1476{ 1514{
1477 dREQ; 1515 dREQ;
1478 1516
1479 req->type = REQ_READAHEAD; 1517 req->type = REQ_READAHEAD;
1480 req->fh = newSVsv (fh); 1518 req->sv1 = newSVsv (fh);
1481 req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh))); 1519 req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh)));
1482 req->offs = offset; 1520 req->offs = offset;
1483 req->size = length; 1521 req->size = length;
1484 1522
1485 REQ_SEND; 1523 REQ_SEND;
1486} 1524}
1487 1525
1488void 1526void
1489aio_stat (fh_or_path,callback=&PL_sv_undef) 1527aio_stat (SV8 *fh_or_path, SV *callback=&PL_sv_undef)
1490 SV8 * fh_or_path
1491 SV * callback
1492 ALIAS: 1528 ALIAS:
1493 aio_stat = REQ_STAT 1529 aio_stat = REQ_STAT
1494 aio_lstat = REQ_LSTAT 1530 aio_lstat = REQ_LSTAT
1495 PPCODE: 1531 PPCODE:
1496{ 1532{
… …
1502 req_free (req); 1538 req_free (req);
1503 croak ("out of memory during aio_stat statdata allocation"); 1539 croak ("out of memory during aio_stat statdata allocation");
1504 } 1540 }
1505 1541
1506 req->flags |= FLAG_PTR2_FREE; 1542 req->flags |= FLAG_PTR2_FREE;
1543 req->sv1 = newSVsv (fh_or_path);
1507 1544
1508 if (SvPOK (fh_or_path)) 1545 if (SvPOK (fh_or_path))
1509 { 1546 {
1510 req->type = ix; 1547 req->type = ix;
1511 req->sv1 = newSVsv (fh_or_path);
1512 req->ptr1 = SvPVbyte_nolen (req->sv1); 1548 req->ptr1 = SvPVbyte_nolen (req->sv1);
1513 } 1549 }
1514 else 1550 else
1515 { 1551 {
1516 req->type = REQ_FSTAT; 1552 req->type = REQ_FSTAT;
1517 req->fh = newSVsv (fh_or_path);
1518 req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path))); 1553 req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
1519 } 1554 }
1520 1555
1521 REQ_SEND; 1556 REQ_SEND;
1522} 1557}
1523 1558
1524void 1559void
1560aio_utime (SV8 *fh_or_path, SV *atime, SV *mtime, SV *callback=&PL_sv_undef)
1561 PPCODE:
1562{
1563 dREQ;
1564
1565 req->nv1 = SvOK (atime) ? SvNV (atime) : -1.;
1566 req->nv2 = SvOK (mtime) ? SvNV (mtime) : -1.;
1567 req->sv1 = newSVsv (fh_or_path);
1568
1569 if (SvPOK (fh_or_path))
1570 {
1571 req->type = REQ_UTIME;
1572 req->ptr1 = SvPVbyte_nolen (req->sv1);
1573 }
1574 else
1575 {
1576 req->type = REQ_FUTIME;
1577 req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
1578 }
1579
1580 REQ_SEND;
1581}
1582
1583void
1584aio_chmod (SV8 *fh_or_path, int mode, SV *callback=&PL_sv_undef)
1585 PPCODE:
1586{
1587 dREQ;
1588
1589 req->mode = mode;
1590 req->sv1 = newSVsv (fh_or_path);
1591
1592 if (SvPOK (fh_or_path))
1593 {
1594 req->type = REQ_CHMOD;
1595 req->ptr1 = SvPVbyte_nolen (req->sv1);
1596 }
1597 else
1598 {
1599 req->type = REQ_FCHMOD;
1600 req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
1601 }
1602
1603 REQ_SEND;
1604}
1605
1606void
1607aio_chown (SV8 *fh_or_path, SV *uid, SV *gid, SV *callback=&PL_sv_undef)
1608 PPCODE:
1609{
1610 dREQ;
1611
1612 req->int2 = SvOK (uid) ? SvIV (uid) : -1;
1613 req->int3 = SvOK (gid) ? SvIV (gid) : -1;
1614 req->sv1 = newSVsv (fh_or_path);
1615
1616 if (SvPOK (fh_or_path))
1617 {
1618 req->type = REQ_CHOWN;
1619 req->ptr1 = SvPVbyte_nolen (req->sv1);
1620 }
1621 else
1622 {
1623 req->type = REQ_FCHOWN;
1624 req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
1625 }
1626
1627 REQ_SEND;
1628}
1629
1630void
1525aio_unlink (pathname,callback=&PL_sv_undef) 1631aio_unlink (SV8 *pathname, SV *callback=&PL_sv_undef)
1526 SV8 * pathname
1527 SV * callback
1528 ALIAS: 1632 ALIAS:
1529 aio_unlink = REQ_UNLINK 1633 aio_unlink = REQ_UNLINK
1530 aio_rmdir = REQ_RMDIR 1634 aio_rmdir = REQ_RMDIR
1531 aio_readdir = REQ_READDIR 1635 aio_readdir = REQ_READDIR
1532 PPCODE: 1636 PPCODE:
… …
1539 1643
1540 REQ_SEND; 1644 REQ_SEND;
1541} 1645}
1542 1646
1543void 1647void
1544aio_mkdir (pathname,mode,callback=&PL_sv_undef) 1648aio_mkdir (SV8 *pathname, int mode, SV *callback=&PL_sv_undef)
1545 SV8 * pathname
1546 UV mode
1547 SV * callback
1548 PPCODE: 1649 PPCODE:
1549{ 1650{
1550 dREQ; 1651 dREQ;
1551 1652
1552 req->type = REQ_MKDIR; 1653 req->type = REQ_MKDIR;
… …
1556 1657
1557 REQ_SEND; 1658 REQ_SEND;
1558} 1659}
1559 1660
1560void 1661void
1561aio_link (oldpath,newpath,callback=&PL_sv_undef) 1662aio_link (SV8 *oldpath, SV8 *newpath, SV *callback=&PL_sv_undef)
1562 SV8 * oldpath
1563 SV8 * newpath
1564 SV * callback
1565 ALIAS: 1663 ALIAS:
1566 aio_link = REQ_LINK 1664 aio_link = REQ_LINK
1567 aio_symlink = REQ_SYMLINK 1665 aio_symlink = REQ_SYMLINK
1568 aio_rename = REQ_RENAME 1666 aio_rename = REQ_RENAME
1569 PPCODE: 1667 PPCODE:
1570{ 1668{
1571 dREQ; 1669 dREQ;
1572 1670
1573 req->type = ix; 1671 req->type = ix;
1574 req->fh = newSVsv (oldpath); 1672 req->sv2 = newSVsv (oldpath);
1575 req->ptr2 = SvPVbyte_nolen (req->fh); 1673 req->ptr2 = SvPVbyte_nolen (req->sv2);
1576 req->sv1 = newSVsv (newpath); 1674 req->sv1 = newSVsv (newpath);
1577 req->ptr1 = SvPVbyte_nolen (req->sv1); 1675 req->ptr1 = SvPVbyte_nolen (req->sv1);
1578 1676
1579 REQ_SEND; 1677 REQ_SEND;
1580} 1678}
1581 1679
1582void 1680void
1583aio_mknod (pathname,mode,dev,callback=&PL_sv_undef) 1681aio_mknod (SV8 *pathname, int mode, UV dev, SV *callback=&PL_sv_undef)
1584 SV8 * pathname
1585 UV mode
1586 UV dev
1587 SV * callback
1588 PPCODE: 1682 PPCODE:
1589{ 1683{
1590 dREQ; 1684 dREQ;
1591 1685
1592 req->type = REQ_MKNOD; 1686 req->type = REQ_MKNOD;
… …
1597 1691
1598 REQ_SEND; 1692 REQ_SEND;
1599} 1693}
1600 1694
1601void 1695void
1602aio_busy (delay,callback=&PL_sv_undef) 1696aio_busy (double delay, SV *callback=&PL_sv_undef)
1603 double delay
1604 SV * callback
1605 PPCODE: 1697 PPCODE:
1606{ 1698{
1607 dREQ; 1699 dREQ;
1608 1700
1609 req->type = REQ_BUSY; 1701 req->type = REQ_BUSY;
1610 req->int1 = delay < 0. ? 0 : delay; 1702 req->nv1 = delay < 0. ? 0. : delay;
1611 req->int2 = delay < 0. ? 0 : 1000. * (delay - req->int1);
1612 1703
1613 REQ_SEND; 1704 REQ_SEND;
1614} 1705}
1615 1706
1616void 1707void
1617aio_group (callback=&PL_sv_undef) 1708aio_group (SV *callback=&PL_sv_undef)
1618 SV * callback
1619 PROTOTYPE: ;$ 1709 PROTOTYPE: ;$
1620 PPCODE: 1710 PPCODE:
1621{ 1711{
1622 dREQ; 1712 dREQ;
1623 1713
… …
1626 req_send (req); 1716 req_send (req);
1627 XPUSHs (req_sv (req, AIO_GRP_KLASS)); 1717 XPUSHs (req_sv (req, AIO_GRP_KLASS));
1628} 1718}
1629 1719
1630void 1720void
1631aio_nop (callback=&PL_sv_undef) 1721aio_nop (SV *callback=&PL_sv_undef)
1632 SV * callback
1633 PPCODE: 1722 PPCODE:
1634{ 1723{
1635 dREQ; 1724 dREQ;
1636 1725
1637 req->type = REQ_NOP; 1726 req->type = REQ_NOP;

Diff Legend

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