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.87 by root, Mon Oct 30 23:42:27 2006 UTC vs.
Revision 1.91 by root, Wed Nov 8 01:57:43 2006 UTC

… …
87 self->dbuf = aio_buf = malloc (AIO_BUFSIZE); \ 87 self->dbuf = aio_buf = malloc (AIO_BUFSIZE); \
88 UNLOCK (wrklock); \ 88 UNLOCK (wrklock); \
89 if (!aio_buf) \ 89 if (!aio_buf) \
90 return -1; 90 return -1;
91 91
92typedef SV SV8; /* byte-sv, used for argument-checking */
93
92enum { 94enum {
93 REQ_QUIT, 95 REQ_QUIT,
94 REQ_OPEN, REQ_CLOSE, 96 REQ_OPEN, REQ_CLOSE,
95 REQ_READ, REQ_WRITE, REQ_READAHEAD, 97 REQ_READ, REQ_WRITE, REQ_READAHEAD,
96 REQ_SENDFILE, 98 REQ_SENDFILE,
… …
129 SV *self; /* the perl counterpart of this request, if any */ 131 SV *self; /* the perl counterpart of this request, if any */
130 struct aio_cb *grp, *grp_prev, *grp_next, *grp_first; 132 struct aio_cb *grp, *grp_prev, *grp_next, *grp_first;
131} aio_cb; 133} aio_cb;
132 134
133enum { 135enum {
134 FLAG_CANCELLED = 0x01, 136 FLAG_CANCELLED = 0x01, /* request was cancelled */
135 FLAG_SV1_RO_OFF = 0x40, /* data was set readonly */ 137 FLAG_SV1_RO_OFF = 0x40, /* data was set readonly */
136 FLAG_PTR2_FREE = 0x80, /* need free(ptr2) */ 138 FLAG_PTR2_FREE = 0x80, /* need to free(ptr2) */
137}; 139};
138 140
139typedef aio_cb *aio_req; 141typedef aio_cb *aio_req;
140typedef aio_cb *aio_req_ornot; 142typedef aio_cb *aio_req_ornot;
141 143
… …
1309 OUTPUT: 1311 OUTPUT:
1310 RETVAL 1312 RETVAL
1311 1313
1312void 1314void
1313aio_open (pathname,flags,mode,callback=&PL_sv_undef) 1315aio_open (pathname,flags,mode,callback=&PL_sv_undef)
1314 SV * pathname 1316 SV8 * pathname
1315 int flags 1317 int flags
1316 int mode 1318 int mode
1317 SV * callback 1319 SV * callback
1318 PROTOTYPE: $$$;$ 1320 PROTOTYPE: $$$;$
1319 PPCODE: 1321 PPCODE:
1320{ 1322{
1321 dREQ; 1323 dREQ;
1322 1324
1323 req->type = REQ_OPEN; 1325 req->type = REQ_OPEN;
1324 req->sv1 = newSVsv (pathname); 1326 req->sv1 = newSVsv (pathname);
1325 req->ptr1 = SvPVbyte_nolen (pathname); 1327 req->ptr1 = SvPVbyte_nolen (req->sv1);
1326 req->int1 = flags; 1328 req->int1 = flags;
1327 req->mode = mode; 1329 req->mode = mode;
1328 1330
1329 REQ_SEND; 1331 REQ_SEND;
1330} 1332}
… …
1352void 1354void
1353aio_read (fh,offset,length,data,dataoffset,callback=&PL_sv_undef) 1355aio_read (fh,offset,length,data,dataoffset,callback=&PL_sv_undef)
1354 SV * fh 1356 SV * fh
1355 UV offset 1357 UV offset
1356 UV length 1358 UV length
1357 SV * data 1359 SV8 * data
1358 UV dataoffset 1360 UV dataoffset
1359 SV * callback 1361 SV * callback
1360 ALIAS: 1362 ALIAS:
1361 aio_read = REQ_READ 1363 aio_read = REQ_READ
1362 aio_write = REQ_WRITE 1364 aio_write = REQ_WRITE
… …
1413 } 1415 }
1414} 1416}
1415 1417
1416void 1418void
1417aio_readlink (path,callback=&PL_sv_undef) 1419aio_readlink (path,callback=&PL_sv_undef)
1418 SV * path 1420 SV8 * path
1419 SV * callback 1421 SV * callback
1420 PROTOTYPE: $$;$ 1422 PROTOTYPE: $$;$
1421 PPCODE: 1423 PPCODE:
1422{ 1424{
1423 SV *data; 1425 SV *data;
… …
1426 data = newSV (NAME_MAX); 1428 data = newSV (NAME_MAX);
1427 SvPOK_on (data); 1429 SvPOK_on (data);
1428 1430
1429 req->type = REQ_READLINK; 1431 req->type = REQ_READLINK;
1430 req->fh = newSVsv (path); 1432 req->fh = newSVsv (path);
1431 req->ptr2 = SvPVbyte_nolen (path); 1433 req->ptr2 = SvPVbyte_nolen (req->fh);
1432 req->sv1 = data; 1434 req->sv1 = data;
1433 req->ptr1 = SvPVbyte_nolen (data); 1435 req->ptr1 = SvPVbyte_nolen (data);
1434 1436
1435 REQ_SEND; 1437 REQ_SEND;
1436} 1438}
… …
1478 REQ_SEND; 1480 REQ_SEND;
1479} 1481}
1480 1482
1481void 1483void
1482aio_stat (fh_or_path,callback=&PL_sv_undef) 1484aio_stat (fh_or_path,callback=&PL_sv_undef)
1483 SV * fh_or_path 1485 SV8 * fh_or_path
1484 SV * callback 1486 SV * callback
1485 ALIAS: 1487 ALIAS:
1486 aio_stat = REQ_STAT 1488 aio_stat = REQ_STAT
1487 aio_lstat = REQ_LSTAT 1489 aio_lstat = REQ_LSTAT
1488 PPCODE: 1490 PPCODE:
… …
1491 1493
1492 req->ptr2 = malloc (sizeof (Stat_t)); 1494 req->ptr2 = malloc (sizeof (Stat_t));
1493 if (!req->ptr2) 1495 if (!req->ptr2)
1494 { 1496 {
1495 req_free (req); 1497 req_free (req);
1496 croak ("out of memory during aio_req statdata allocation"); 1498 croak ("out of memory during aio_stat statdata allocation");
1497 } 1499 }
1498 1500
1499 req->flags |= FLAG_PTR2_FREE; 1501 req->flags |= FLAG_PTR2_FREE;
1500 1502
1501 if (SvPOK (fh_or_path)) 1503 if (SvPOK (fh_or_path))
1502 { 1504 {
1503 req->type = ix; 1505 req->type = ix;
1504 req->sv1 = newSVsv (fh_or_path); 1506 req->sv1 = newSVsv (fh_or_path);
1505 req->ptr1 = SvPVbyte_nolen (fh_or_path); 1507 req->ptr1 = SvPVbyte_nolen (req->sv1);
1506 } 1508 }
1507 else 1509 else
1508 { 1510 {
1509 req->type = REQ_FSTAT; 1511 req->type = REQ_FSTAT;
1510 req->fh = newSVsv (fh_or_path); 1512 req->fh = newSVsv (fh_or_path);
… …
1514 REQ_SEND; 1516 REQ_SEND;
1515} 1517}
1516 1518
1517void 1519void
1518aio_unlink (pathname,callback=&PL_sv_undef) 1520aio_unlink (pathname,callback=&PL_sv_undef)
1519 SV * pathname 1521 SV8 * pathname
1520 SV * callback 1522 SV * callback
1521 ALIAS: 1523 ALIAS:
1522 aio_unlink = REQ_UNLINK 1524 aio_unlink = REQ_UNLINK
1523 aio_rmdir = REQ_RMDIR 1525 aio_rmdir = REQ_RMDIR
1524 aio_readdir = REQ_READDIR 1526 aio_readdir = REQ_READDIR
… …
1526{ 1528{
1527 dREQ; 1529 dREQ;
1528 1530
1529 req->type = ix; 1531 req->type = ix;
1530 req->sv1 = newSVsv (pathname); 1532 req->sv1 = newSVsv (pathname);
1531 req->ptr1 = SvPVbyte_nolen (pathname); 1533 req->ptr1 = SvPVbyte_nolen (req->sv1);
1532 1534
1533 REQ_SEND; 1535 REQ_SEND;
1534} 1536}
1535 1537
1536void 1538void
1537aio_link (oldpath,newpath,callback=&PL_sv_undef) 1539aio_link (oldpath,newpath,callback=&PL_sv_undef)
1538 SV * oldpath 1540 SV8 * oldpath
1539 SV * newpath 1541 SV8 * newpath
1540 SV * callback 1542 SV * callback
1541 ALIAS: 1543 ALIAS:
1542 aio_link = REQ_LINK 1544 aio_link = REQ_LINK
1543 aio_symlink = REQ_SYMLINK 1545 aio_symlink = REQ_SYMLINK
1544 aio_rename = REQ_RENAME 1546 aio_rename = REQ_RENAME
… …
1548 1550
1549 req->type = ix; 1551 req->type = ix;
1550 req->fh = newSVsv (oldpath); 1552 req->fh = newSVsv (oldpath);
1551 req->ptr2 = SvPVbyte_nolen (req->fh); 1553 req->ptr2 = SvPVbyte_nolen (req->fh);
1552 req->sv1 = newSVsv (newpath); 1554 req->sv1 = newSVsv (newpath);
1553 req->ptr1 = SvPVbyte_nolen (newpath); 1555 req->ptr1 = SvPVbyte_nolen (req->sv1);
1554 1556
1555 REQ_SEND; 1557 REQ_SEND;
1556} 1558}
1557 1559
1558void 1560void
1559aio_mknod (pathname,mode,dev,callback=&PL_sv_undef) 1561aio_mknod (pathname,mode,dev,callback=&PL_sv_undef)
1560 SV * pathname 1562 SV8 * pathname
1561 SV * callback 1563 SV * callback
1562 UV mode 1564 UV mode
1563 UV dev 1565 UV dev
1564 PPCODE: 1566 PPCODE:
1565{ 1567{
1566 dREQ; 1568 dREQ;
1567 1569
1568 req->type = REQ_MKNOD; 1570 req->type = REQ_MKNOD;
1569 req->sv1 = newSVsv (pathname); 1571 req->sv1 = newSVsv (pathname);
1570 req->ptr1 = SvPVbyte_nolen (pathname); 1572 req->ptr1 = SvPVbyte_nolen (req->sv1);
1571 req->mode = (mode_t)mode; 1573 req->mode = (mode_t)mode;
1572 req->offs = dev; 1574 req->offs = dev;
1573 1575
1574 REQ_SEND; 1576 REQ_SEND;
1575} 1577}
… …
1642 PROTOTYPE: 1644 PROTOTYPE:
1643 CODE: 1645 CODE:
1644 while (nreqs) 1646 while (nreqs)
1645 { 1647 {
1646 poll_wait (); 1648 poll_wait ();
1647 poll_cb (0); 1649 poll_cb ();
1648 } 1650 }
1649 1651
1650void 1652int
1651poll() 1653poll()
1652 PROTOTYPE: 1654 PROTOTYPE:
1653 CODE: 1655 CODE:
1654 if (nreqs) 1656 if (nreqs)
1655 { 1657 {
1656 poll_wait (); 1658 poll_wait ();
1657 poll_cb (0); 1659 RETVAL = poll_cb ();
1658 } 1660 }
1661 else
1662 RETVAL = 0;
1663 OUTPUT:
1664 RETVAL
1659 1665
1660int 1666int
1661poll_fileno() 1667poll_fileno()
1662 PROTOTYPE: 1668 PROTOTYPE:
1663 CODE: 1669 CODE:

Diff Legend

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