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.93 by root, Wed Nov 8 02:01:02 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
… …
445 PUSHs (sv_2mortal (newSViv (req->result))); 447 PUSHs (sv_2mortal (newSViv (req->result)));
446 PUTBACK; 448 PUTBACK;
447 call_pv ("IO::AIO::_fd2fh", G_SCALAR | G_EVAL); 449 call_pv ("IO::AIO::_fd2fh", G_SCALAR | G_EVAL);
448 SPAGAIN; 450 SPAGAIN;
449 451
450 fh = SvREFCNT_inc (POPs); 452 fh = POPs;
451
452 PUSHMARK (SP); 453 PUSHMARK (SP);
453 XPUSHs (sv_2mortal (fh)); 454 XPUSHs (fh);
454 } 455 }
455 break; 456 break;
456 457
457 case REQ_GROUP: 458 case REQ_GROUP:
458 req->int1 = 2; /* mark group as finished */ 459 req->int1 = 2; /* mark group as finished */
… …
1309 OUTPUT: 1310 OUTPUT:
1310 RETVAL 1311 RETVAL
1311 1312
1312void 1313void
1313aio_open (pathname,flags,mode,callback=&PL_sv_undef) 1314aio_open (pathname,flags,mode,callback=&PL_sv_undef)
1314 SV * pathname 1315 SV8 * pathname
1315 int flags 1316 int flags
1316 int mode 1317 int mode
1317 SV * callback 1318 SV * callback
1318 PROTOTYPE: $$$;$ 1319 PROTOTYPE: $$$;$
1319 PPCODE: 1320 PPCODE:
1320{ 1321{
1321 dREQ; 1322 dREQ;
1322 1323
1323 req->type = REQ_OPEN; 1324 req->type = REQ_OPEN;
1324 req->sv1 = newSVsv (pathname); 1325 req->sv1 = newSVsv (pathname);
1325 req->ptr1 = SvPVbyte_nolen (pathname); 1326 req->ptr1 = SvPVbyte_nolen (req->sv1);
1326 req->int1 = flags; 1327 req->int1 = flags;
1327 req->mode = mode; 1328 req->mode = mode;
1328 1329
1329 REQ_SEND; 1330 REQ_SEND;
1330} 1331}
… …
1352void 1353void
1353aio_read (fh,offset,length,data,dataoffset,callback=&PL_sv_undef) 1354aio_read (fh,offset,length,data,dataoffset,callback=&PL_sv_undef)
1354 SV * fh 1355 SV * fh
1355 UV offset 1356 UV offset
1356 UV length 1357 UV length
1357 SV * data 1358 SV8 * data
1358 UV dataoffset 1359 UV dataoffset
1359 SV * callback 1360 SV * callback
1360 ALIAS: 1361 ALIAS:
1361 aio_read = REQ_READ 1362 aio_read = REQ_READ
1362 aio_write = REQ_WRITE 1363 aio_write = REQ_WRITE
… …
1413 } 1414 }
1414} 1415}
1415 1416
1416void 1417void
1417aio_readlink (path,callback=&PL_sv_undef) 1418aio_readlink (path,callback=&PL_sv_undef)
1418 SV * path 1419 SV8 * path
1419 SV * callback 1420 SV * callback
1420 PROTOTYPE: $$;$ 1421 PROTOTYPE: $$;$
1421 PPCODE: 1422 PPCODE:
1422{ 1423{
1423 SV *data; 1424 SV *data;
… …
1426 data = newSV (NAME_MAX); 1427 data = newSV (NAME_MAX);
1427 SvPOK_on (data); 1428 SvPOK_on (data);
1428 1429
1429 req->type = REQ_READLINK; 1430 req->type = REQ_READLINK;
1430 req->fh = newSVsv (path); 1431 req->fh = newSVsv (path);
1431 req->ptr2 = SvPVbyte_nolen (path); 1432 req->ptr2 = SvPVbyte_nolen (req->fh);
1432 req->sv1 = data; 1433 req->sv1 = data;
1433 req->ptr1 = SvPVbyte_nolen (data); 1434 req->ptr1 = SvPVbyte_nolen (data);
1434 1435
1435 REQ_SEND; 1436 REQ_SEND;
1436} 1437}
… …
1478 REQ_SEND; 1479 REQ_SEND;
1479} 1480}
1480 1481
1481void 1482void
1482aio_stat (fh_or_path,callback=&PL_sv_undef) 1483aio_stat (fh_or_path,callback=&PL_sv_undef)
1483 SV * fh_or_path 1484 SV8 * fh_or_path
1484 SV * callback 1485 SV * callback
1485 ALIAS: 1486 ALIAS:
1486 aio_stat = REQ_STAT 1487 aio_stat = REQ_STAT
1487 aio_lstat = REQ_LSTAT 1488 aio_lstat = REQ_LSTAT
1488 PPCODE: 1489 PPCODE:
… …
1491 1492
1492 req->ptr2 = malloc (sizeof (Stat_t)); 1493 req->ptr2 = malloc (sizeof (Stat_t));
1493 if (!req->ptr2) 1494 if (!req->ptr2)
1494 { 1495 {
1495 req_free (req); 1496 req_free (req);
1496 croak ("out of memory during aio_req statdata allocation"); 1497 croak ("out of memory during aio_stat statdata allocation");
1497 } 1498 }
1498 1499
1499 req->flags |= FLAG_PTR2_FREE; 1500 req->flags |= FLAG_PTR2_FREE;
1500 1501
1501 if (SvPOK (fh_or_path)) 1502 if (SvPOK (fh_or_path))
1502 { 1503 {
1503 req->type = ix; 1504 req->type = ix;
1504 req->sv1 = newSVsv (fh_or_path); 1505 req->sv1 = newSVsv (fh_or_path);
1505 req->ptr1 = SvPVbyte_nolen (fh_or_path); 1506 req->ptr1 = SvPVbyte_nolen (req->sv1);
1506 } 1507 }
1507 else 1508 else
1508 { 1509 {
1509 req->type = REQ_FSTAT; 1510 req->type = REQ_FSTAT;
1510 req->fh = newSVsv (fh_or_path); 1511 req->fh = newSVsv (fh_or_path);
… …
1514 REQ_SEND; 1515 REQ_SEND;
1515} 1516}
1516 1517
1517void 1518void
1518aio_unlink (pathname,callback=&PL_sv_undef) 1519aio_unlink (pathname,callback=&PL_sv_undef)
1519 SV * pathname 1520 SV8 * pathname
1520 SV * callback 1521 SV * callback
1521 ALIAS: 1522 ALIAS:
1522 aio_unlink = REQ_UNLINK 1523 aio_unlink = REQ_UNLINK
1523 aio_rmdir = REQ_RMDIR 1524 aio_rmdir = REQ_RMDIR
1524 aio_readdir = REQ_READDIR 1525 aio_readdir = REQ_READDIR
… …
1526{ 1527{
1527 dREQ; 1528 dREQ;
1528 1529
1529 req->type = ix; 1530 req->type = ix;
1530 req->sv1 = newSVsv (pathname); 1531 req->sv1 = newSVsv (pathname);
1531 req->ptr1 = SvPVbyte_nolen (pathname); 1532 req->ptr1 = SvPVbyte_nolen (req->sv1);
1532 1533
1533 REQ_SEND; 1534 REQ_SEND;
1534} 1535}
1535 1536
1536void 1537void
1537aio_link (oldpath,newpath,callback=&PL_sv_undef) 1538aio_link (oldpath,newpath,callback=&PL_sv_undef)
1538 SV * oldpath 1539 SV8 * oldpath
1539 SV * newpath 1540 SV8 * newpath
1540 SV * callback 1541 SV * callback
1541 ALIAS: 1542 ALIAS:
1542 aio_link = REQ_LINK 1543 aio_link = REQ_LINK
1543 aio_symlink = REQ_SYMLINK 1544 aio_symlink = REQ_SYMLINK
1544 aio_rename = REQ_RENAME 1545 aio_rename = REQ_RENAME
… …
1548 1549
1549 req->type = ix; 1550 req->type = ix;
1550 req->fh = newSVsv (oldpath); 1551 req->fh = newSVsv (oldpath);
1551 req->ptr2 = SvPVbyte_nolen (req->fh); 1552 req->ptr2 = SvPVbyte_nolen (req->fh);
1552 req->sv1 = newSVsv (newpath); 1553 req->sv1 = newSVsv (newpath);
1553 req->ptr1 = SvPVbyte_nolen (newpath); 1554 req->ptr1 = SvPVbyte_nolen (req->sv1);
1554 1555
1555 REQ_SEND; 1556 REQ_SEND;
1556} 1557}
1557 1558
1558void 1559void
1559aio_mknod (pathname,mode,dev,callback=&PL_sv_undef) 1560aio_mknod (pathname,mode,dev,callback=&PL_sv_undef)
1560 SV * pathname 1561 SV8 * pathname
1561 SV * callback 1562 SV * callback
1562 UV mode 1563 UV mode
1563 UV dev 1564 UV dev
1564 PPCODE: 1565 PPCODE:
1565{ 1566{
1566 dREQ; 1567 dREQ;
1567 1568
1568 req->type = REQ_MKNOD; 1569 req->type = REQ_MKNOD;
1569 req->sv1 = newSVsv (pathname); 1570 req->sv1 = newSVsv (pathname);
1570 req->ptr1 = SvPVbyte_nolen (pathname); 1571 req->ptr1 = SvPVbyte_nolen (req->sv1);
1571 req->mode = (mode_t)mode; 1572 req->mode = (mode_t)mode;
1572 req->offs = dev; 1573 req->offs = dev;
1573 1574
1574 REQ_SEND; 1575 REQ_SEND;
1575} 1576}
… …
1642 PROTOTYPE: 1643 PROTOTYPE:
1643 CODE: 1644 CODE:
1644 while (nreqs) 1645 while (nreqs)
1645 { 1646 {
1646 poll_wait (); 1647 poll_wait ();
1647 poll_cb (0); 1648 poll_cb ();
1648 } 1649 }
1649 1650
1650void 1651int
1651poll() 1652poll()
1652 PROTOTYPE: 1653 PROTOTYPE:
1653 CODE: 1654 CODE:
1654 if (nreqs)
1655 {
1656 poll_wait (); 1655 poll_wait ();
1657 poll_cb (0); 1656 RETVAL = poll_cb ();
1658 } 1657 OUTPUT:
1658 RETVAL
1659 1659
1660int 1660int
1661poll_fileno() 1661poll_fileno()
1662 PROTOTYPE: 1662 PROTOTYPE:
1663 CODE: 1663 CODE:
… …
1675 1675
1676void 1676void
1677poll_wait() 1677poll_wait()
1678 PROTOTYPE: 1678 PROTOTYPE:
1679 CODE: 1679 CODE:
1680 if (nreqs)
1681 poll_wait (); 1680 poll_wait ();
1682 1681
1683int 1682int
1684nreqs() 1683nreqs()
1685 PROTOTYPE: 1684 PROTOTYPE:
1686 CODE: 1685 CODE:

Diff Legend

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