--- IO-AIO/AIO.pm	2009/08/05 11:53:16	1.163
+++ IO-AIO/AIO.pm	2010/01/07 20:25:57	1.173
@@ -193,7 +193,7 @@
 use base 'Exporter';
 
 BEGIN {
-   our $VERSION = '3.3';
+   our $VERSION = '3.5';
 
    our @AIO_REQ = qw(aio_sendfile aio_read aio_write aio_open aio_close
                      aio_stat aio_lstat aio_unlink aio_rmdir aio_readdir aio_readdirx
@@ -201,7 +201,8 @@
                      aio_fdatasync aio_sync_file_range aio_pathsync aio_readahead
                      aio_rename aio_link aio_move aio_copy aio_group
                      aio_nop aio_mknod aio_load aio_rmtree aio_mkdir aio_chown
-                     aio_chmod aio_utime aio_truncate);
+                     aio_chmod aio_utime aio_truncate
+                     aio_msync aio_mtouch aio_statvfs);
 
    our @EXPORT = (@AIO_REQ, qw(aioreq_pri aioreq_nice));
    our @EXPORT_OK = qw(poll_fileno poll_cb poll_wait flush
@@ -382,9 +383,10 @@
 zero-copy operation. For this to work, C<$out_fh> should refer to a
 socket, and C<$in_fh> should refer to mmap'able file.
 
-If the native sendfile call fails or is not implemented, it will be
-emulated, so you can call C<aio_sendfile> on any type of filehandle
-regardless of the limitations of the operating system.
+If a native sendfile cannot be found or it fails with C<ENOSYS>,
+C<ENOTSUP>, C<EOPNOTSUPP>, C<EAFNOSUPPORT>, C<EPROTOTYPE> or C<ENOTSOCK>,
+it will be emulated, so you can call C<aio_sendfile> on any type of
+filehandle regardless of the limitations of the operating system.
 
 Please note, however, that C<aio_sendfile> can read more bytes from
 C<$in_fh> than are written, and there is no way to find out how many
@@ -432,6 +434,51 @@
    };
 
 
+=item aio_statvfs  $fh_or_path, $callback->($statvfs)
+
+Works like the POSIX C<statvfs> or C<fstatvfs> syscalls, depending on
+whether a file handle or path was passed.
+
+On success, the callback is passed a hash reference with the following
+members: C<bsize>, C<frsize>, C<blocks>, C<bfree>, C<bavail>, C<files>,
+C<ffree>, C<favail>, C<fsid>, C<flag> and C<namemax>. On failure, C<undef>
+is passed.
+
+The following POSIX IO::AIO::ST_* constants are defined: C<ST_RDONLY> and
+C<ST_NOSUID>.
+
+The following non-POSIX IO::AIO::ST_* flag masks are defined to
+their correct value when available, or to C<0> on systems that do
+not support them:  C<ST_NODEV>, C<ST_NOEXEC>, C<ST_SYNCHRONOUS>,
+C<ST_MANDLOCK>, C<ST_WRITE>, C<ST_APPEND>, C<ST_IMMUTABLE>, C<ST_NOATIME>,
+C<ST_NODIRATIME> and C<ST_RELATIME>.
+
+Example: stat C</wd> and dump out the data if successful.
+
+   aio_statvfs "/wd", sub {
+      my $f = $_[0]
+         or die "statvfs: $!";
+
+      use Data::Dumper;
+      say Dumper $f;
+   };
+
+   # result:
+   {
+      bsize   => 1024,
+      bfree   => 4333064312,
+      blocks  => 10253828096,
+      files   => 2050765568,
+      flag    => 4096,
+      favail  => 2042092649,
+      bavail  => 4333064312,
+      ffree   => 2042092649,
+      namemax => 255,
+      frsize  => 1024,
+      fsid    => 1810
+   }
+
+
 =item aio_utime $fh_or_path, $atime, $mtime, $callback->($status)
 
 Works like perl's C<utime> function (including the special case of $atime
@@ -636,7 +683,7 @@
 
 Try to copy the I<file> (directories not supported as either source or
 destination) from C<$srcpath> to C<$dstpath> and call the callback with
-the C<0> (error) or C<-1> ok.
+a status of C<0> (ok) or C<-1> (error, see C<$!>).
 
 This is a composite request that creates the destination file with
 mode 0200 and copies the contents of the source file into it using
@@ -658,7 +705,7 @@
    aioreq_pri $pri;
    add $grp aio_open $src, O_RDONLY, 0, sub {
       if (my $src_fh = $_[0]) {
-         my @stat = stat $src_fh; # hmm, might bock over nfs?
+         my @stat = stat $src_fh; # hmm, might block over nfs?
 
          aioreq_pri $pri;
          add $grp aio_open $dst, O_CREAT | O_WRONLY | O_TRUNC, 0200, sub {
@@ -715,7 +762,7 @@
 
 Try to move the I<file> (directories not supported as either source or
 destination) from C<$srcpath> to C<$dstpath> and call the callback with
-the C<0> (error) or C<-1> ok.
+a status of C<0> (ok) or C<-1> (error, see C<$!>).
 
 This is a composite request that tries to rename(2) the file first; if
 rename fails with C<EXDEV>, it copies the file with C<aio_copy> and, if
@@ -991,6 +1038,32 @@
    $grp
 }
 
+=item aio_msync $scalar, $offset = 0, $length = undef, flags = 0, $callback->($status)
+
+This is a rather advanced IO::AIO call, which only works on mmap(2)ed
+scalars (see the L<Sys::Mmap> or L<Mmap> modules for details on this, note
+that the scalar must only be modified in-place while an aio operation is
+pending on it).
+
+It calls the C<msync> function of your OS, if available, with the memory
+area starting at C<$offset> in the string and ending C<$length> bytes
+later. If C<$length> is negative, counts from the end, and if C<$length>
+is C<undef>, then it goes till the end of the string. The flags can be
+a combination of C<IO::AIO::MS_ASYNC>, C<IO::AIO::MS_INVALIDATE> and
+C<IO::AIO::MS_SYNC>.
+
+=item aio_mtouch $scalar, $offset = 0, $length = undef, flags = 0, $callback->($status)
+
+This is a rather advanced IO::AIO call, which works best on mmap(2)ed
+scalars.
+
+It touches (reads or writes) all memory pages in the specified
+range inside the scalar.  All caveats and parameters are the same
+as for C<aio_msync>, above, except for flags, which must be either
+C<0> (which reads all pages and ensures they are instantiated) or
+C<IO::AIO::MT_MODIFY>, which modifies the memory page s(by reading and
+writing an octet from it, which dirties the page).
+
 =item aio_group $callback->(...)
 
 This is a very special aio request: Instead of doing something, it is a
@@ -1135,6 +1208,9 @@
 Cancel all subrequests and clears any feeder, but not the group request
 itself. Useful when you queued a lot of events but got a result early.
 
+The group request will finish normally (you cannot add requests to the
+group).
+
 =item $grp->result (...)
 
 Set the result value(s) that will be passed to the group callback when all