--- IO-AIO/AIO.pm	2006/10/28 23:32:29	1.86
+++ IO-AIO/AIO.pm	2006/10/30 23:30:29	1.91
@@ -63,11 +63,12 @@
 on a RAID volume or over NFS when you do a number of stat operations
 concurrently.
 
-While this works on all types of file descriptors (for example sockets),
-using these functions on file descriptors that support nonblocking
-operation (again, sockets, pipes etc.) is very inefficient. Use an event
-loop for that (such as the L<Event|Event> module): IO::AIO will naturally
-fit into such an event loop itself.
+While most of this works on all types of file descriptors (for example
+sockets), using these functions on file descriptors that support
+nonblocking operation (again, sockets, pipes etc.) is very inefficient or
+might not work (aio_read fails on sockets/pipes/fifos). Use an event loop
+for that (such as the L<Event|Event> module): IO::AIO will naturally fit
+into such an event loop itself.
 
 In this version, a number of threads are started that execute your
 requests and signal their completion. You don't need thread support
@@ -178,6 +179,8 @@
 aio request is severed and calling its methods will either do nothing or
 result in a runtime error).
 
+=back
+
 =cut
 
 package IO::AIO;
@@ -188,12 +191,12 @@
 use base 'Exporter';
 
 BEGIN {
-   our $VERSION = '2.1';
+   our $VERSION = '2.2';
 
    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_scandir aio_symlink
-                     aio_fsync aio_fdatasync aio_readahead aio_rename aio_link aio_move
-                     aio_copy aio_group aio_nop aio_mknod);
+                     aio_readlink aio_fsync aio_fdatasync aio_readahead aio_rename aio_link
+                     aio_move aio_copy aio_group aio_nop aio_mknod);
    our @EXPORT = (@AIO_REQ, qw(aioreq_pri aioreq_nice));
    our @EXPORT_OK = qw(poll_fileno poll_cb poll_wait flush
                        min_parallel max_parallel max_idle
@@ -208,7 +211,7 @@
 
 =head1 FUNCTIONS
 
-=head2 AIO FUNCTIONS
+=head2 AIO REQUEST FUNCTIONS
 
 All the C<aio_*> calls are more or less thin wrappers around the syscall
 with the same name (sans C<aio_>). The arguments are similar or identical,
@@ -221,21 +224,25 @@
 All functions expecting a filehandle keep a copy of the filehandle
 internally until the request has finished.
 
-All requests return objects of type L<IO::AIO::REQ> that allow further
-manipulation of those requests while they are in-flight.
+All functions return request objects of type L<IO::AIO::REQ> that allow
+further manipulation of those requests while they are in-flight.
 
 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
+encoded as octets. 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.
+current working directory anywhere in the program and then use relative
+paths.
 
-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
+To encode pathnames as octets, either make sure you either: a) always pass
+in filenames you got from outside (command line, readdir etc.) without
+tinkering, 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.
+use something else to ensure your scalar has the correct contents.
+
+This works, btw. independent of the internal UTF-8 bit, which IO::AIO
+handles correctly wether it is set or not.
 
 =over 4
 
@@ -268,7 +275,7 @@
 =item aioreq_nice $pri_adjust
 
 Similar to C<aioreq_pri>, but subtracts the given value from the current
-priority, so effects are cumulative.
+priority, so the effect is cumulative.
 
 =item aio_open $pathname, $flags, $mode, $callback->($fh)
 
@@ -413,6 +420,12 @@
 Asynchronously create a new symbolic link to the existing object at C<$srcpath> at
 the path C<$dstpath> and call the callback with the result code.
 
+=item aio_readlink $path, $callback->($link)
+
+Asynchronously read the symlink specified by C<$path> and pass it to
+the callback. If an error occurs, nothing or undef gets passed to the
+callback.
+
 =item aio_rename $srcpath, $dstpath, $callback->($status)
 
 Asynchronously rename the object at C<$srcpath> to C<$dstpath>, just as
@@ -935,6 +948,11 @@
 C<IO::AIO::poll_cb> to process requests (more correctly the mininum amount
 of time C<poll_cb> is allowed to use).
 
+Setting C<max_poll_time> to a non-zero value creates an overhead of one
+syscall per request processed, which is not normally a problem unless your
+callbacks are really really fast or your OS is really really slow (I am
+not mentioning Solaris here). Using C<max_poll_reqs> incurs no overhead.
+
 Setting these is useful if you want to ensure some level of
 interactiveness when perl is not fast enough to process all requests in
 time.
@@ -942,7 +960,7 @@
 For interactive programs, values such as C<0.01> to C<0.1> should be fine.
 
 Example: Install an Event watcher that automatically calls
-IO::AIO::poll_some with low priority, to ensure that other parts of the
+IO::AIO::poll_cb with low priority, to ensure that other parts of the
 program get the CPU sometimes even under high AIO load.
 
    # try not to spend much more than 0.1s in poll_cb