--- IO-AIO/AIO.xs	2011/07/19 05:00:11	1.191
+++ IO-AIO/AIO.xs	2011/09/27 02:16:49	1.198
@@ -104,11 +104,12 @@
 typedef int aio_rfd; /* read file desriptor */
 typedef int aio_wfd; /* write file descriptor */
 
-static HV *aio_stash, *aio_req_stash, *aio_grp_stash;
+static HV *aio_stash, *aio_req_stash, *aio_grp_stash, *aio_wd_stash;
 
 #define EIO_REQ_MEMBERS	\
   SV *callback;		\
   SV *sv1, *sv2;	\
+  SV *sv3, *sv4;	\
   STRLEN stroffset;	\
   SV *self;
 
@@ -331,6 +332,7 @@
 
 typedef eio_req *aio_req;
 typedef eio_req *aio_req_ornot;
+typedef eio_wd   aio_wd;
 
 static SV *on_next_submit;
 static int next_pri = EIO_PRI_DEFAULT;
@@ -365,6 +367,12 @@
   return sv_2mortal (sv_bless (newRV_inc (req->self), stash));
 }
 
+static SV *
+newSVaio_wd (aio_wd wd)
+{
+  return sv_bless (newRV_noinc (newSViv ((long)wd)), aio_wd_stash);
+}
+
 static aio_req SvAIO_REQ (SV *sv)
 {
   MAGIC *mg;
@@ -380,6 +388,16 @@
   return mg ? (aio_req)mg->mg_ptr : 0;
 }
 
+static aio_wd SvAIO_WD (SV *sv)
+{
+  if (!SvROK (sv)
+      || SvSTASH (SvRV (sv)) != aio_wd_stash
+      || SvTYPE (SvRV (sv)) != SVt_PVMG)
+    croak ("IO::AIO: expected a working directory object as returned by aio_wd");
+
+  return (aio_wd)(long)SvIVX (SvRV (sv));
+}
+
 static void aio_grp_feed (aio_req grp)
 {
   if (grp->sv2 && SvOK (grp->sv2))
@@ -446,6 +464,10 @@
 
       switch (req->type)
         {
+          case EIO_WD_OPEN:
+            PUSHs (sv_2mortal (newSVaio_wd (req->wd)));
+            break;
+
           case EIO_READDIR:
             {
               SV *rv = &PL_sv_undef;
@@ -597,10 +619,12 @@
           case EIO_STAT:
           case EIO_LSTAT:
           case EIO_FSTAT:
-            PL_laststype   = req->type == EIO_LSTAT ? OP_LSTAT : OP_STAT;
-            PL_laststatval = req->result;
-            /* if compilation fails here then perl's Stat_t is not struct _stati64 */
-            PL_statcache   = *(EIO_STRUCT_STAT *)(req->ptr2);
+            PL_laststype = req->type == EIO_LSTAT ? OP_LSTAT : OP_STAT;
+
+            if (!(PL_laststatval = req->result))
+              /* if compilation fails here then perl's Stat_t is not struct _stati64 */
+              PL_statcache = *(EIO_STRUCT_STAT *)(req->ptr2);
+
             PUSHs (sv_result);
             break;
 
@@ -654,6 +678,8 @@
 
   SvREFCNT_dec (req->sv1);
   SvREFCNT_dec (req->sv2);
+  SvREFCNT_dec (req->sv3);
+  SvREFCNT_dec (req->sv4);
   SvREFCNT_dec (req->callback);
 
   Safefree (req);
@@ -793,6 +819,62 @@
   if (GIMME_V != G_VOID)					\
     XPUSHs (req_sv (req, aio_req_stash));
 
+static void
+req_set_path (aio_req req, SV *path, SV **wdsv, SV **pathsv, eio_wd *wd, void **ptr)
+{
+  if (expect_false (SvROK (path)))
+    {
+      AV *av = (AV *)SvRV (path);
+      SV *wdob;
+
+      if (SvTYPE (av) != SVt_PVAV || AvFILLp (av) != 1)
+        croak ("IO::AIO: pathname arguments must be specified as strings or [wd, path] arrayrefs");
+
+      path = AvARRAY (av)[1];
+      wdob = AvARRAY (av)[0];
+
+      if (SvOK (wdob))
+        {
+          *wd = SvAIO_WD (wdob);
+          *wdsv = SvREFCNT_inc_NN (SvRV (wdob));
+        }
+      else
+        *wd = EIO_INVALID_WD;
+    }
+
+  *pathsv = newSVsv (path);
+  *ptr = SvPVbyte_nolen (*pathsv);
+}
+
+static void
+req_set_path1 (aio_req req, SV *path)
+{
+  req_set_path (req, path, &req->sv1, &req->sv3, &req->wd, &req->ptr1);
+}
+
+static void
+req_set_fh_or_path (aio_req req, int type_path, int type_fh, SV *fh_or_path)
+{
+  SV *rv = SvROK (fh_or_path) ? SvRV (fh_or_path) : fh_or_path;
+
+  switch (SvTYPE (rv))
+    {
+      case SVt_PVIO:
+      case SVt_PVLV:
+      case SVt_PVGV:
+        req->type = type_fh;
+        req->sv1  = newSVsv (fh_or_path);
+        req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
+        break;
+
+      default:
+        req->type = type_path;
+        req_set_path1 (req, fh_or_path);
+        break;
+    }
+
+}
+
 MODULE = IO::AIO                PACKAGE = IO::AIO
 
 PROTOTYPES: ENABLE
@@ -919,9 +1001,10 @@
   aio_stash     = gv_stashpv ("IO::AIO"     , 1);
   aio_req_stash = gv_stashpv ("IO::AIO::REQ", 1);
   aio_grp_stash = gv_stashpv ("IO::AIO::GRP", 1);
+  aio_wd_stash  = gv_stashpv ("IO::AIO::WD" , 1);
 
-  for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
-    newCONSTSUB (aio_stash, (char *)civ->name, newSViv (civ->iv));
+  for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ > const_iv; civ--)
+    newCONSTSUB (aio_stash, (char *)civ[-1].name, newSViv (civ[-1].iv));
 
   newCONSTSUB (aio_stash, "PAGESIZE", newSViv (PAGESIZE));
 
@@ -931,8 +1014,6 @@
 void
 reinit ()
 	PROTOTYPE:
-	CODE:
-	reinit ();
 
 void
 max_poll_reqs (unsigned int nreqs)
@@ -977,14 +1058,25 @@
         max_outstanding = maxreqs;
 
 void
+aio_wd (SV8 *pathname, SV *callback=&PL_sv_undef)
+	PPCODE:
+{
+        dREQ;
+
+        req->type = EIO_WD_OPEN;
+        req_set_path1 (req, pathname);
+
+        REQ_SEND;
+}
+
+void
 aio_open (SV8 *pathname, int flags, int mode, SV *callback=&PL_sv_undef)
 	PPCODE:
 {
         dREQ;
 
         req->type = EIO_OPEN;
-        req->sv1  = newSVsv (pathname);
-        req->ptr1 = SvPVbyte_nolen (req->sv1);
+        req_set_path1 (req, pathname);
         req->int1 = flags;
         req->int2 = mode;
 
@@ -996,6 +1088,7 @@
         ALIAS:
            aio_fsync     = EIO_FSYNC
            aio_fdatasync = EIO_FDATASYNC
+           aio_syncfs    = EIO_SYNCFS
 	PPCODE:
 {
   	int fd = s_fileno_croak (fh, 0);
@@ -1130,7 +1223,7 @@
 }
 
 void
-aio_readlink (SV8 *path, SV *callback=&PL_sv_undef)
+aio_readlink (SV8 *pathname, SV *callback=&PL_sv_undef)
         ALIAS:
            aio_readlink = EIO_READLINK
            aio_realpath = EIO_REALPATH
@@ -1139,8 +1232,7 @@
         dREQ;
 
         req->type = ix;
-        req->sv1  = newSVsv (path);
-        req->ptr1 = SvPVbyte_nolen (req->sv1);
+        req_set_path1 (req, pathname);
 
         REQ_SEND;
 }
@@ -1191,18 +1283,7 @@
 	dREQ;
 
         req->sv1 = newSVsv (fh_or_path);
-
-        if (SvPOK (req->sv1))
-          {
-            req->type = ix;
-            req->ptr1 = SvPVbyte_nolen (req->sv1);
-          }
-        else
-          {
-            req->type = ix == EIO_STATVFS ? EIO_FSTATVFS : EIO_FSTAT;
-            req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
-          }
-
+        req_set_fh_or_path (req, ix, ix == EIO_STATVFS ? EIO_FSTATVFS : EIO_FSTAT, fh_or_path);
         REQ_SEND;
 }
 
@@ -1230,18 +1311,7 @@
 
         req->nv1 = SvOK (atime) ? SvNV (atime) : -1.;
         req->nv2 = SvOK (mtime) ? SvNV (mtime) : -1.;
-        req->sv1 = newSVsv (fh_or_path);
-
-        if (SvPOK (req->sv1))
-          {
-            req->type = EIO_UTIME;
-            req->ptr1 = SvPVbyte_nolen (req->sv1);
-          }
-        else
-          {
-            req->type = EIO_FUTIME;
-            req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
-          }
+        req_set_fh_or_path (req, EIO_UTIME, EIO_FUTIME, fh_or_path);
 
         REQ_SEND;
 }
@@ -1252,19 +1322,8 @@
 {
 	dREQ;
 
-        req->sv1  = newSVsv (fh_or_path);
         req->offs = SvOK (offset) ? SvVAL64 (offset) : -1;
-
-        if (SvPOK (req->sv1))
-          {
-            req->type = EIO_TRUNCATE;
-            req->ptr1 = SvPVbyte_nolen (req->sv1);
-          }
-        else
-          {
-            req->type = EIO_FTRUNCATE;
-            req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
-          }
+        req_set_fh_or_path (req, EIO_TRUNCATE, EIO_FTRUNCATE, fh_or_path);
 
         REQ_SEND;
 }
@@ -1279,18 +1338,7 @@
 	dREQ;
 
         req->int2 = mode;
-        req->sv1  = newSVsv (fh_or_path);
-
-        if (SvPOK (req->sv1))
-          {
-            req->type = ix;
-            req->ptr1 = SvPVbyte_nolen (req->sv1);
-          }
-        else
-          {
-            req->type = EIO_FCHMOD;
-            req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
-          }
+        req_set_fh_or_path (req, EIO_CHMOD, EIO_FCHMOD, fh_or_path);
 
         REQ_SEND;
 }
@@ -1303,18 +1351,7 @@
 
         req->int2 = SvOK (uid) ? SvIV (uid) : -1;
         req->int3 = SvOK (gid) ? SvIV (gid) : -1;
-        req->sv1  = newSVsv (fh_or_path);
-
-        if (SvPOK (req->sv1))
-          {
-            req->type = EIO_CHOWN;
-            req->ptr1 = SvPVbyte_nolen (req->sv1);
-          }
-        else
-          {
-            req->type = EIO_FCHOWN;
-            req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
-          }
+        req_set_fh_or_path (req, EIO_CHOWN, EIO_FCHOWN, fh_or_path);
 
         REQ_SEND;
 }
@@ -1326,13 +1363,13 @@
 	dREQ;
 	
         req->type = EIO_READDIR;
-	req->sv1  = newSVsv (pathname);
-	req->ptr1 = SvPVbyte_nolen (req->sv1);
         req->int1 = flags | EIO_READDIR_DENTS | EIO_READDIR_CUSTOM1;
 
         if (flags & EIO_READDIR_DENTS)
           req->int1 |= EIO_READDIR_CUSTOM2;
 
+        req_set_path1 (req, pathname);
+
 	REQ_SEND;
 }
 
@@ -1347,8 +1384,7 @@
 	dREQ;
 	
         req->type = ix;
-	req->sv1  = newSVsv (pathname);
-	req->ptr1 = SvPVbyte_nolen (req->sv1);
+        req_set_path1 (req, pathname);
 
 	REQ_SEND;
 }
@@ -1362,12 +1398,12 @@
 	PPCODE:
 {
 	dREQ;
+        eio_wd wd2;
 	
         req->type = ix;
-	req->sv1  = newSVsv (oldpath);
-	req->ptr1 = SvPVbyte_nolen (req->sv1);
-	req->sv2  = newSVsv (newpath);
-	req->ptr2 = SvPVbyte_nolen (req->sv2);
+        req_set_path1 (req, oldpath);
+        req_set_path (req, newpath, &req->sv2, &req->sv4, &wd2, &req->ptr2);
+        req->int3 = (long)wd2;
 	
 	REQ_SEND;
 }
@@ -1379,10 +1415,9 @@
 	dREQ;
 	
         req->type = EIO_MKNOD;
-	req->sv1  = newSVsv (pathname);
-	req->ptr1 = SvPVbyte_nolen (req->sv1);
         req->int2 = (mode_t)mode;
         req->offs = dev;
+        req_set_path1 (req, pathname);
 	
 	REQ_SEND;
 }
@@ -1714,6 +1749,30 @@
 
 PROTOTYPES: DISABLE
 
+MODULE = IO::AIO                PACKAGE = IO::AIO::WD
+
+BOOT:
+{
+  newCONSTSUB (aio_stash, "CWD"       , newSVaio_wd (EIO_CWD       ));
+  newCONSTSUB (aio_stash, "INVALID_WD", newSVaio_wd (EIO_INVALID_WD));
+}
+
+void
+DESTROY (SV *self)
+	CODE:
+{
+	aio_wd wd = SvAIO_WD (self);
+#if HAVE_AT
+        SV *callback = &PL_sv_undef;
+        dREQ; /* clobbers next_pri :/ */
+        req->type = EIO_WD_CLOSE;
+        req->wd = wd;
+        REQ_SEND;
+#else
+        eio_wd_close_sync (wd);
+#endif
+}
+
 MODULE = IO::AIO                PACKAGE = IO::AIO::REQ
 
 void