--- IO-AIO/AIO.pm	2016/05/21 04:43:31	1.261
+++ IO-AIO/AIO.pm	2018/01/06 01:04:42	1.279
@@ -1,6 +1,6 @@
 =head1 NAME
 
-IO::AIO - Asynchronous Input/Output
+IO::AIO - Asynchronous/Advanced Input/Output
 
 =head1 SYNOPSIS
 
@@ -60,6 +60,10 @@
 aio_write, so the remaining functionality would have to be implemented
 using threads anyway.
 
+In addition to asynchronous I/O, this module also exports some rather
+arcane interfaces, such as C<madvise> or linux's C<splice> system call,
+which is why the C<A> in C<AIO> can also mean I<advanced>.
+
 Although the module will work in the presence of other (Perl-) threads,
 it is currently not reentrant in any way, so use appropriate locking
 yourself, always call C<poll_cb> from within the same thread, or never
@@ -169,18 +173,19 @@
 use base 'Exporter';
 
 BEGIN {
-   our $VERSION = 4.34;
+   our $VERSION = 4.4;
 
    our @AIO_REQ = qw(aio_sendfile aio_seek aio_read aio_write aio_open aio_close
                      aio_stat aio_lstat aio_unlink aio_rmdir aio_readdir aio_readdirx
                      aio_scandir aio_symlink aio_readlink aio_realpath aio_fcntl aio_ioctl
                      aio_sync aio_fsync aio_syncfs aio_fdatasync aio_sync_file_range
                      aio_pathsync aio_readahead aio_fiemap aio_allocate
-                     aio_rename aio_link aio_move aio_copy aio_group
+                     aio_rename aio_rename2 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_msync aio_mtouch aio_mlock aio_mlockall
                      aio_statvfs
+                     aio_slurp
                      aio_wd);
 
    our @EXPORT = (@AIO_REQ, qw(aioreq_pri aioreq_nice));
@@ -231,6 +236,7 @@
    aio_readlink $pathname, $callback->($link)
    aio_realpath $pathname, $callback->($path)
    aio_rename $srcpath, $dstpath, $callback->($status)
+   aio_rename2 $srcpath, $dstpath, $flags, $callback->($status)
    aio_mkdir $pathname, $mode, $callback->($status)
    aio_rmdir $pathname, $callback->($status)
    aio_readdir $pathname, $callback->($entries)
@@ -250,7 +256,7 @@
    aio_fdatasync $fh, $callback->($status)
    aio_sync_file_range $fh, $offset, $nbytes, $flags, $callback->($status)
    aio_pathsync $pathname, $callback->($status)
-   aio_msync $scalar, $offset = 0, $length = undef, flags = 0, $callback->($status)
+   aio_msync $scalar, $offset = 0, $length = undef, flags = MS_SYNC, $callback->($status)
    aio_mtouch $scalar, $offset = 0, $length = undef, flags = 0, $callback->($status)
    aio_mlock $scalar, $offset = 0, $length = undef, $callback->($status)
    aio_mlockall $flags, $callback->($status)
@@ -274,6 +280,8 @@
    IO::AIO::nreqs
    IO::AIO::nready
    IO::AIO::npending
+   $nfd = IO::AIO::get_fdlimit [EXPERIMENTAL]
+   IO::AIO::min_fdlimit $nfd [EXPERIMENTAL]
 
    IO::AIO::sendfile $ofh, $ifh, $offset, $count
    IO::AIO::fadvise $fh, $offset, $len, $advice
@@ -443,8 +451,8 @@
 =item aio_write $fh,$offset,$length, $data,$dataoffset, $callback->($retval)
 
 Reads or writes C<$length> bytes from or to the specified C<$fh> and
-C<$offset> into the scalar given by C<$data> and offset C<$dataoffset>
-and calls the callback without the actual number of bytes read (or -1 on
+C<$offset> into the scalar given by C<$data> and offset C<$dataoffset> and
+calls the callback with the actual number of bytes transferred (or -1 on
 error, just like the syscall).
 
 C<aio_read> will, like C<sysread>, shrink or grow the C<$data> scalar to
@@ -512,7 +520,7 @@
 on many systems, this implementation tries to work around some known bugs
 in Linux and FreeBSD kernels (probably others, too), but that might fail,
 so you really really should check the return value of C<aio_sendfile> -
-fewre bytes than expected might have been transferred.
+fewer bytes than expected might have been transferred.
 
 
 =item aio_readahead $fh,$offset,$length, $callback->($retval)
@@ -737,11 +745,13 @@
 to deallocate a file range.
 
 IO::AIO also supports C<FALLOC_FL_COLLAPSE_RANGE>, to remove a range
-(without leaving a hole) and C<FALLOC_FL_ZERO_RANGE>, to zero a range (see
-your L<fallocate(2)> manpage).
+(without leaving a hole), C<FALLOC_FL_ZERO_RANGE>, to zero a range,
+C<FALLOC_FL_INSERT_RANGE> to insert a range and C<FALLOC_FL_UNSHARE_RANGE>
+to unshare shared blocks (see your L<fallocate(2)> manpage).
 
 The file system block size used by C<fallocate> is presumably the
-C<f_bsize> returned by C<statvfs>.
+C<f_bsize> returned by C<statvfs>, but different filesystems and filetypes
+can dictate other limitations.
 
 If C<fallocate> isn't available or cannot be emulated (currently no
 emulation will be attempted), passes C<-1> and sets C<$!> to C<ENOSYS>.
@@ -810,6 +820,22 @@
 of failing, C<rename> is called on the absolute path of C<$wd>.
 
 
+=item aio_rename2 $srcpath, $dstpath, $flags, $callback->($status)
+
+Basically a version of C<aio_rename> with an additional C<$flags>
+argument. Calling this with C<$flags=0> is the same as calling
+C<aio_rename>.
+
+Non-zero flags are currently only supported on GNU/Linux systems that
+support renameat2. Other systems fail with C<ENOSYS> in this case.
+
+The following constants are available (missing ones are, as usual C<0>),
+see renameat2(2) for details:
+
+C<IO::AIO::RENAME_NOREPLACE>, C<IO::AIO::RENAME_EXCHANGE>
+and C<IO::AIO::RENAME_WHITEOUT>.
+
+
 =item aio_mkdir $pathname, $mode, $callback->($status)
 
 Asynchronously mkdir (create) a directory and call the callback with
@@ -903,11 +929,42 @@
 =back
 
 
+=item aio_slurp $pathname, $offset, $length, $data, $callback->($status)
+
+Opens, reads and closes the given file. The data is put into C<$data>,
+which is resized as required.
+
+If C<$offset> is negative, then it is counted from the end of the file.
+
+If C<$length> is zero, then the remaining length of the file is
+used. Also, in this case, the same limitations to modifying C<$data> apply
+as when IO::AIO::mmap is used, i.e. it must only be modified in-place
+with C<substr>. If the size of the file is known, specifying a non-zero
+C<$length> results in a performance advantage.
+
+This request is similar to the older C<aio_load> request, but since it is
+a single request, it might be more efficient to use.
+
+Example: load F</etc/passwd> into C<$passwd>.
+
+   my $passwd;
+   aio_slurp "/etc/passwd", 0, 0, $passwd, sub {
+      $_[0] >= 0
+         or die "/etc/passwd: $!\n";
+
+      printf "/etc/passwd is %d bytes long, and contains:\n", length $passwd;
+      print $passwd;
+   };
+   IO::AIO::flush;
+
+
 =item aio_load $pathname, $data, $callback->($status)
 
 This is a composite request that tries to fully load the given file into
 memory. Status is the same as with aio_read.
 
+Using C<aio_slurp> might be more efficient, as it is a single request.
+
 =cut
 
 sub aio_load($$;$) {
@@ -937,6 +994,8 @@
 destination) from C<$srcpath> to C<$dstpath> and call the callback with
 a status of C<0> (ok) or C<-1> (error, see C<$!>).
 
+Existing destination files will be truncated.
+
 This is a composite request that creates the destination file with
 mode 0200 and copies the contents of the source file into it using
 C<aio_sendfile>, followed by restoring atime, mtime, access mode and
@@ -1055,7 +1114,7 @@
 names, directories you can recurse into (directories), and ones you cannot
 recurse into (everything else, including symlinks to directories).
 
-C<aio_scandir> is a composite request that creates of many sub requests_
+C<aio_scandir> is a composite request that generates many sub requests.
 C<$maxreq> specifies the maximum number of outstanding aio requests that
 this function generates. If it is C<< <= 0 >>, then a suitable default
 will be chosen (currently 4).
@@ -1250,6 +1309,31 @@
 other processes), although if you are careful and know what you are doing,
 you still can.
 
+The following constants are available (missing ones are, as usual C<0>):
+
+C<F_DUPFD_CLOEXEC>,
+
+C<F_OFD_GETLK>, C<F_OFD_SETLK>, C<F_OFD_GETLKW>,
+
+C<FIFREEZE>, C<FITHAW>, C<FITRIM>, C<FICLONE>, C<FICLONERANGE>, C<FIDEDUPERANGE>.
+
+C<FS_IOC_GETFLAGS>, C<FS_IOC_SETFLAGS>, C<FS_IOC_GETVERSION>, C<FS_IOC_SETVERSION>,
+C<FS_IOC_FIEMAP>.
+
+C<FS_IOC_FSGETXATTR>, C<FS_IOC_FSSETXATTR>, C<FS_IOC_SET_ENCRYPTION_POLICY>,
+C<FS_IOC_GET_ENCRYPTION_PWSALT>, C<FS_IOC_GET_ENCRYPTION_POLICY>, C<FS_KEY_DESCRIPTOR_SIZE>.
+
+C<FS_SECRM_FL>, C<FS_UNRM_FL>, C<FS_COMPR_FL>, C<FS_SYNC_FL>, C<FS_IMMUTABLE_FL>,
+C<FS_APPEND_FL>, C<FS_NODUMP_FL>, C<FS_NOATIME_FL>, C<FS_DIRTY_FL>,
+C<FS_COMPRBLK_FL>, C<FS_NOCOMP_FL>, C<FS_ENCRYPT_FL>, C<FS_BTREE_FL>,
+C<FS_INDEX_FL>, C<FS_JOURNAL_DATA_FL>, C<FS_NOTAIL_FL>, C<FS_DIRSYNC_FL>, C<FS_TOPDIR_FL>,
+C<FS_FL_USER_MODIFIABLE>.
+
+C<FS_XFLAG_REALTIME>, C<FS_XFLAG_PREALLOC>, C<FS_XFLAG_IMMUTABLE>, C<FS_XFLAG_APPEND>,
+C<FS_XFLAG_SYNC>, C<FS_XFLAG_NOATIME>, C<FS_XFLAG_NODUMP>, C<FS_XFLAG_RTINHERIT>,
+C<FS_XFLAG_PROJINHERIT>, C<FS_XFLAG_NOSYMLINKS>, C<FS_XFLAG_EXTSIZE>, C<FS_XFLAG_EXTSZINHERIT>,
+C<FS_XFLAG_NODEFRAG>, C<FS_XFLAG_FILESTREAM>, C<FS_XFLAG_DAX>, C<FS_XFLAG_HASATTR>,
+
 =item aio_sync $callback->($status)
 
 Asynchronously call sync and call the callback when finished.
@@ -1327,7 +1411,7 @@
    $grp
 }
 
-=item aio_msync $scalar, $offset = 0, $length = undef, flags = 0, $callback->($status)
+=item aio_msync $scalar, $offset = 0, $length = undef, flags = MS_SYNC, $callback->($status)
 
 This is a rather advanced IO::AIO call, which only works on mmap(2)ed
 scalars (see the C<IO::AIO::mmap> function, although it also works on data
@@ -1339,8 +1423,8 @@
 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>.
+either C<IO::AIO::MS_ASYNC> or C<IO::AIO::MS_SYNC>, plus an optional
+C<IO::AIO::MS_INVALIDATE>.
 
 =item aio_mtouch $scalar, $offset = 0, $length = undef, flags = 0, $callback->($status)
 
@@ -1433,10 +1517,11 @@
 C<IO::AIO::FIEMAP_EXTENT_UNWRITTEN>, C<IO::AIO::FIEMAP_EXTENT_MERGED> or
 C<IO::AIO::FIEMAP_EXTENT_SHARED>.
 
-At the time of this writing (Linux 3.2), this requets is unreliable unless
+At the time of this writing (Linux 3.2), this request is unreliable unless
 C<$count> is C<undef>, as the kernel has all sorts of bugs preventing
-it to return all extents of a range for files with large number of
-extents. The code works around all these issues if C<$count> is undef.
+it to return all extents of a range for files with a large number of
+extents. The code (only) works around all these issues if C<$count> is
+C<undef>.
 
 =item aio_group $callback->(...)
 
@@ -1559,8 +1644,8 @@
 nowhere at all), while the directory fd, if available on the system,
 will still point to the original directory. Most functions accepting a
 pathname will use the directory fd on newer systems, and the string on
-older systems. Some functions (such as realpath) will always rely on the
-string form of the pathname.
+older systems. Some functions (such as C<aio_realpath>) will always rely on
+the string form of the pathname.
 
 So this functionality is mainly useful to get some protection against
 C<chdir>, to easily get an absolute path out of a relative path for future
@@ -1962,7 +2047,7 @@
 use an C<aio_group> together with a feed callback.
 
 Its main use is in scripts without an event loop - when you want to stat
-a lot of files, you can write somehting like this:
+a lot of files, you can write something like this:
 
    IO::AIO::max_outstanding 32;
 
@@ -2018,6 +2103,31 @@
 
 =over 4
 
+=item $numfd = IO::AIO::get_fdlimit
+
+This function is I<EXPERIMENTAL> and subject to change.
+
+Tries to find the current file descriptor limit and returns it, or
+C<undef> and sets C<$!> in case of an error. The limit is one larger than
+the highest valid file descriptor number.
+
+=item IO::AIO::min_fdlimit [$numfd]
+
+This function is I<EXPERIMENTAL> and subject to change.
+
+Try to increase the current file descriptor limit(s) to at least C<$numfd>
+by changing the soft or hard file descriptor resource limit. If C<$numfd>
+is missing, it will try to set a very high limit, although this is not
+recommended when you know the actual minimum that you require.
+
+If the limit cannot be raised enough, the function makes a best-effort
+attempt to increase the limit as much as possible, using various
+tricks, while still failing. You can query the resulting limit using
+C<IO::AIO::get_fdlimit>.
+
+If an error occurs, returns C<undef> and sets C<$!>, otherwise returns
+true.
+
 =item IO::AIO::sendfile $ofh, $ifh, $offset, $count
 
 Calls the C<eio_sendfile_sync> function, which is like C<aio_sendfile>,
@@ -2043,7 +2153,12 @@
 Simply calls the C<posix_madvise> function (see its
 manpage for details). The following advice constants are
 available: C<IO::AIO::MADV_NORMAL>, C<IO::AIO::MADV_SEQUENTIAL>,
-C<IO::AIO::MADV_RANDOM>, C<IO::AIO::MADV_WILLNEED>, C<IO::AIO::MADV_DONTNEED>.
+C<IO::AIO::MADV_RANDOM>, C<IO::AIO::MADV_WILLNEED>,
+C<IO::AIO::MADV_DONTNEED>.
+
+If C<$offset> is negative, counts from the end. If C<$length> is negative,
+the remaining length of the C<$scalar> is used. If possible, C<$length>
+will be reduced to fit into the C<$scalar>.
 
 On systems that do not implement C<posix_madvise>, this function returns
 ENOSYS, otherwise the return value of C<posix_madvise>.
@@ -2055,6 +2170,10 @@
 constants are available: C<IO::AIO::PROT_NONE>, C<IO::AIO::PROT_READ>,
 C<IO::AIO::PROT_WRITE>, C<IO::AIO::PROT_EXEC>.
 
+If C<$offset> is negative, counts from the end. If C<$length> is negative,
+the remaining length of the C<$scalar> is used. If possible, C<$length>
+will be reduced to fit into the C<$scalar>.
+
 On systems that do not implement C<mprotect>, this function returns
 ENOSYS, otherwise the return value of C<mprotect>.
 
@@ -2064,15 +2183,19 @@
 given C<$scalar>, which will act like a string scalar. Returns true on
 success, and false otherwise.
 
-The only operations allowed on the scalar are C<substr>/C<vec> that don't
-change the string length, and most read-only operations such as copying it
-or searching it with regexes and so on.
+The scalar must exist, but its contents do not matter - this means you
+cannot use a nonexistant array or hash element. When in doubt, C<undef>
+the scalar first.
+
+The only operations allowed on the mmapped scalar are C<substr>/C<vec>,
+which don't change the string length, and most read-only operations such
+as copying it or searching it with regexes and so on.
 
 Anything else is unsafe and will, at best, result in memory leaks.
 
 The memory map associated with the C<$scalar> is automatically removed
-when the C<$scalar> is destroyed, or when the C<IO::AIO::mmap> or
-C<IO::AIO::munmap> functions are called.
+when the C<$scalar> is undef'd or destroyed, or when the C<IO::AIO::mmap>
+or C<IO::AIO::munmap> functions are called on it.
 
 This calls the C<mmap>(2) function internally. See your system's manual
 page for details on the C<$length>, C<$prot> and C<$flags> parameters.