--- IO-AIO/AIO.pm	2005/07/20 21:55:27	1.22
+++ IO-AIO/AIO.pm	2005/08/17 05:06:59	1.31
@@ -58,15 +58,17 @@
 
 package IO::AIO;
 
+no warnings;
+
 use base 'Exporter';
 
 use Fcntl ();
 
 BEGIN {
-   $VERSION = 0.9;
+   $VERSION = 1.2;
 
    @EXPORT = qw(aio_read aio_write aio_open aio_close aio_stat aio_lstat aio_unlink
-                aio_fsync aio_fdatasync aio_readahead);
+                aio_rmdir aio_symlink aio_fsync aio_fdatasync aio_readahead);
    @EXPORT_OK = qw(poll_fileno poll_cb min_parallel max_parallel max_outstanding nreqs);
 
    require XSLoader;
@@ -85,12 +87,21 @@
 perl, which usually delivers "false") as it's sole argument when the given
 syscall has been executed asynchronously.
 
-All functions that expect a filehandle will also accept a file descriptor.
+All functions expecting a filehandle keep a copy of the filehandle
+internally until the request has finished.
 
-The filenames you pass to these routines I<must> be absolute. The reason
-for this is that at the time the request is being executed, the current
-working directory could have changed. Alternatively, you can make sure
-that you never change the current working directory.
+The pathnames you pass to these routines I<must> be absolute and
+encoded in byte form. The reason for the former is that at the time the
+request is being executed, the current working directory could have
+changed. Alternatively, you can make sure that you never change the
+current working directory.
+
+To encode pathnames to byte form, either make sure you either: a)
+always pass in filenames you got from outside (command line, readdir
+etc.), b) are ASCII or ISO 8859-1, c) use the Encode module and encode
+your pathnames to the locale (or other) encoding in effect in the user
+environment, d) use Glib::filename_from_unicode on unicode filenames or e)
+use something else.
 
 =over 4
 
@@ -141,6 +152,10 @@
 callback without the actual number of bytes read (or -1 on error, just
 like the syscall).
 
+The C<$data> scalar I<MUST NOT> be modified in any way while the request
+is outstanding. Modifying it can result in segfaults or WW3 (if the
+necessary/optional hardware is installed).
+
 Example: Read 15 bytes at offset 7 into scalar C<$buffer>, starting at
 offset C<0> within the scalar:
 
@@ -151,10 +166,6 @@
 
 =item aio_readahead $fh,$offset,$length, $callback
 
-Asynchronously reads the specified byte range into the page cache, using
-the C<readahead> syscall. If that syscall doesn't exist (likely if your OS
-isn't Linux) the status will be C<-1> and C<$!> is set to C<ENOSYS>.
-
 C<aio_readahead> populates the page cache with data from a file so that
 subsequent reads from that file will not block on disk I/O. The C<$offset>
 argument specifies the starting point from which data is to be read and
@@ -164,6 +175,9 @@
 (off-set+length). C<aio_readahead> does not read beyond the end of the
 file. The current file offset of the file is left unchanged.
 
+If that syscall doesn't exist (likely if your OS isn't Linux) it will be
+emulated by simply reading the data, which would have a similar effect.
+
 =item aio_stat  $fh_or_path, $callback
 
 =item aio_lstat $fh, $callback
@@ -191,6 +205,11 @@
 Asynchronously unlink (delete) a file and call the callback with the
 result code.
 
+=item aio_rmdir $pathname, $callback
+
+Asynchronously rmdir (delete) a directory and call the callback with the
+result code.
+
 =item aio_fsync $fh, $callback
 
 Asynchronously call fsync on the given filehandle and call the callback
@@ -199,8 +218,10 @@
 =item aio_fdatasync $fh, $callback
 
 Asynchronously call fdatasync on the given filehandle and call the
-callback with the fdatasync result code. Might set C<$!> to C<ENOSYS> if
-C<fdatasync> is not available.
+callback with the fdatasync result code.
+
+If this call isn't available because your OS lacks it or it couldn't be
+detected, it will be emulated by calling C<fsync> instead.
 
 =back
 
@@ -312,12 +333,16 @@
 sub _fd2fh {
    return undef if $_[0] < 0;
 
-   # try to be perl5.6-compatible
-   local *AIO_FH;
-   open AIO_FH, "+<&=$_[0]"
+   # try to generate nice filehandles
+   my $sym = "IO::AIO::fd#$_[0]";
+   local *$sym;
+
+   open *$sym, "+<&=$_[0]"      # usually works under any unix
+      or open *$sym, "<&=$_[0]" # cygwin needs this
+      or open *$sym, ">&=$_[0]" # or this
       or return undef;
 
-   *AIO_FH
+   *$sym
 }
 
 min_parallel 4;
@@ -328,6 +353,14 @@
 
 1;
 
+=head2 FORK BEHAVIOUR
+
+Before the fork IO::AIO enters a quiescent state where no requests can be
+added in other threads and no results will be processed. After the fork
+the parent simply leaves the quiescent state and continues request/result
+processing, while the child clears the request/result queue and starts the
+same number of threads as were in use by the parent.
+
 =head1 SEE ALSO
 
 L<Coro>, L<Linux::AIO>.