[ViewVC] Diff of: cvs/IO-AIO/AIO.pm

Comparing IO-AIO/AIO.pm (file contents):
Revision 1.268 by root, Tue May 30 22:45:52 2017 UTC vs.
Revision 1.281 by root, Tue Feb 20 04:32:59 2018 UTC

 use common::sense;
 use base 'Exporter';
 BEGIN {
-   our $VERSION = 4.35;
+   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));
    our @EXPORT_OK = qw(poll_fileno poll_cb poll_wait flush
                        min_parallel max_parallel max_idle idle_timeout
    aio_link $srcpath, $dstpath, $callback->($status)
    aio_symlink $srcpath, $dstpath, $callback->($status)
    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)
    aio_readdirx $pathname, $flags, $callback->($entries, $flags)
       IO::AIO::READDIR_DENTS IO::AIO::READDIR_DIRS_FIRST
    IO::AIO::idle_timeout $seconds
    IO::AIO::max_outstanding $maxreqs
    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
    IO::AIO::mmap $scalar, $length, $prot, $flags[, $fh[, $offset]]
    IO::AIO::munmap $scalar
       namemax => 255,
       frsize  => 1024,
       fsid    => 1810
    }
-Here is a (likely partial - send me updates!) list of fsid values used by
-Linux - it is safe to hardcode these when C<$^O> is C<linux>:
-   0x0000adf5 adfs
-   0x0000adff affs
-   0x5346414f afs
-   0x09041934 anon-inode filesystem
-   0x00000187 autofs
-   0x42465331 befs
-   0x1badface bfs
-   0x42494e4d binfmt_misc
-   0x9123683e btrfs
-   0x0027e0eb cgroupfs
-   0xff534d42 cifs
-   0x73757245 coda
-   0x012ff7b7 coh
-   0x28cd3d45 cramfs
-   0x453dcd28 cramfs-wend (wrong endianness)
-   0x64626720 debugfs
-   0x00001373 devfs
-   0x00001cd1 devpts
-   0x0000f15f ecryptfs
-   0x00414a53 efs
-   0x0000137d ext
-   0x0000ef53 ext2/ext3/ext4
-   0x0000ef51 ext2
-   0xf2f52010 f2fs
-   0x00004006 fat
-   0x65735546 fuseblk
-   0x65735543 fusectl
-   0x0bad1dea futexfs
-   0x01161970 gfs2
-   0x47504653 gpfs
-   0x00004244 hfs
-   0xf995e849 hpfs
-   0x00c0ffee hostfs
-   0x958458f6 hugetlbfs
-   0x2bad1dea inotifyfs
-   0x00009660 isofs
-   0x000072b6 jffs2
-   0x3153464a jfs
-   0x6b414653 k-afs
-   0x0bd00bd0 lustre
-   0x0000137f minix
-   0x0000138f minix 30 char names
-   0x00002468 minix v2
-   0x00002478 minix v2 30 char names
-   0x00004d5a minix v3
-   0x19800202 mqueue
-   0x00004d44 msdos
-   0x0000564c novell
-   0x00006969 nfs
-   0x6e667364 nfsd
-   0x00003434 nilfs
-   0x5346544e ntfs
-   0x00009fa1 openprom
-   0x7461636F ocfs2
-   0x00009fa0 proc
-   0x6165676c pstorefs
-   0x0000002f qnx4
-   0x68191122 qnx6
-   0x858458f6 ramfs
-   0x52654973 reiserfs
-   0x00007275 romfs
-   0x67596969 rpc_pipefs
-   0x73636673 securityfs
-   0xf97cff8c selinux
-   0x0000517b smb
-   0x534f434b sockfs
-   0x73717368 squashfs
-   0x62656572 sysfs
-   0x012ff7b6 sysv2
-   0x012ff7b5 sysv4
-   0x01021994 tmpfs
-   0x15013346 udf
-   0x00011954 ufs
-   0x54190100 ufs byteswapped
-   0x00009fa2 usbdevfs
-   0x01021997 v9fs
-   0xa501fcf5 vxfs
-   0xabba1974 xenfs
-   0x012ff7b4 xenix
-   0x58465342 xfs
-   0x012fd16d xia
 =item aio_utime $fh_or_path, $atime, $mtime, $callback->($status)
 Works like perl's C<utime> function (including the special case of $atime
 and $mtime being undef). Fractional times are supported if the underlying
 syscalls support them.
 C<$mode> is usually C<0> or C<IO::AIO::FALLOC_FL_KEEP_SIZE> to allocate
 space, or C<IO::AIO::FALLOC_FL_PUNCH_HOLE | IO::AIO::FALLOC_FL_KEEP_SIZE>,
 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
+(without leaving a hole), C<FALLOC_FL_ZERO_RANGE>, to zero a range,
-your L<fallocate(2)> manpage).
+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>.
 rename(2) and call the callback with the result code.
 On systems that support the AIO::WD working directory abstraction
 natively, the case C<[$wd, "."]> as C<$srcpath> is specialcased - instead
 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
 C<$type>'s are known, which can be used to speed up some algorithms.
 =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($$;$) {
    my ($path, undef, $cb) = @_;
 =item aio_copy $srcpath, $dstpath, $callback->($status)
 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
 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
 uid/gid, in that order.
 Scans a directory (similar to C<aio_readdir>) but additionally tries to
 efficiently separate the entries of directory C<$path> into two sets of
 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).
 On error, the callback is called without arguments, otherwise it receives
 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<IO::AIO::FIEMAP_EXTENT_DATA_ENCRYPTED>, C<IO::AIO::FIEMAP_EXTENT_NOT_ALIGNED>,
 C<IO::AIO::FIEMAP_EXTENT_DATA_INLINE>, C<IO::AIO::FIEMAP_EXTENT_DATA_TAIL>,
 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
+it to return all extents of a range for files with a large number of
-extents. The code works around all these issues if C<$count> is undef.
+extents. The code (only) works around all these issues if C<$count> is
+C<undef>.
 =item aio_group $callback->(...)
 This is a very special aio request: Instead of doing something, it is a
 container for other aio requests, which is useful if you want to bundle
 There are some caveats: when directories get renamed (or deleted), the
 pathname string doesn't change, so will point to the new directory (or
 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
+older systems. Some functions (such as C<aio_realpath>) will always rely on
-string form of the pathname.
+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
 reference, and to speed up doing many operations in the same directory
 (e.g. when stat'ing all files in a directory).
 This is a very bad function to use in interactive programs because it
 blocks, and a bad way to reduce concurrency because it is inexact: Better
 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;
    for my $path (...) {
       aio_stat $path , ...;
 some "Advanced I/O" function not available to in Perl, without going the
 "Asynchronous I/O" route. Many of these have an asynchronous C<aio_*>
 counterpart.
 =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>,
 but is blocking (this makes most sense if you know the input data is
 =item IO::AIO::madvise $scalar, $offset, $len, $advice
 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_FREE>.
+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>.
 =item IO::AIO::mprotect $scalar, $offset, $len, $protect
 Simply calls the C<mprotect> function on the preferably AIO::mmap'ed
 $scalar (see its manpage for details). The following protect
 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>.
 =item IO::AIO::mmap $scalar, $length, $prot, $flags, $fh[, $offset]
 Please refer to L<pipe2(2)> for more info on the C<$flags>, but at the
 time of this writing, C<IO::AIO::O_CLOEXEC>, C<IO::AIO::O_NONBLOCK> and
 C<IO::AIO::O_DIRECT> (Linux 3.4, for packet-based pipes) were supported.
+Example: create a pipe race-free w.r.t. threads and fork:
+   my ($rfh, $wfh) = IO::AIO::pipe2 IO::AIO::O_CLOEXEC
+      or die "pipe2: $!\n";
+=item $fh = IO::AIO::eventfd ([$initval, [$flags]])
+This is a direct interface to the Linux L<eventfd(2)> system call. The
+(unhelpful) defaults for C<$initval> and C<$flags> are C<0> for both.
+On success, the new eventfd filehandle is returned, otherwise returns
+C<undef>. If the eventfd syscall is missing, fails with C<ENOSYS>.
+Please refer to L<eventfd(2)> for more info on this call.
+The following symbol flag values are available: C<IO::AIO::EFD_CLOEXEC>,
+C<IO::AIO::EFD_NONBLOCK> and C<IO::AIO::EFD_SEMAPHORE> (Linux 2.6.30).
 =back
 =cut
 min_parallel 8;

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing IO-AIO/AIO.pm (file contents): Revision 1.268 by root, Tue May 30 22:45:52 2017 UTC vs. Revision 1.281 by root, Tue Feb 20 04:32:59 2018 UTC

Diff Legend

Comparing IO-AIO/AIO.pm (file contents):
Revision 1.268 by root, Tue May 30 22:45:52 2017 UTC vs.
Revision 1.281 by root, Tue Feb 20 04:32:59 2018 UTC