--- IO-AIO/AIO.pm 2012/04/10 05:01:33 1.225 +++ IO-AIO/AIO.pm 2018/08/12 05:21:35 1.289 @@ -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 or linux's C system call, +which is why the C in C can also mean I. + 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 from within the same thread, or never @@ -70,7 +74,6 @@ This is a simple example that uses the EV module and loads F asynchronously: - use Fcntl; use EV; use IO::AIO; @@ -97,7 +100,7 @@ print $contents; # exit event loop and program - EV::unloop; + EV::break; }; }; @@ -105,7 +108,7 @@ # check for sockets etc. etc. # process events as long as there are some: - EV::loop; + EV::run; =head1 REQUEST ANATOMY AND LIFETIME @@ -170,18 +173,19 @@ use base 'Exporter'; BEGIN { - our $VERSION = '4.15'; + our $VERSION = 4.5; 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_sync - aio_fsync aio_syncfs aio_fdatasync aio_sync_file_range aio_fallocate - aio_pathsync aio_readahead aio_fiemap - aio_rename aio_link aio_move aio_copy aio_group + 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_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)); @@ -190,7 +194,7 @@ nreqs nready npending nthreads max_poll_time max_poll_reqs sendfile fadvise madvise - mmap munmap munlock munlockall); + mmap munmap mremap munlock munlockall); push @AIO_REQ, qw(aio_busy); # not exported @@ -204,8 +208,8 @@ =head2 QUICK OVERVIEW -This section simply lists the prototypes of the most important functions -for quick reference. See the following sections for function-by-function +This section simply lists the prototypes most of the functions for +quick reference. See the following sections for function-by-function documentation. aio_wd $pathname, $callback->($wd) @@ -223,13 +227,16 @@ aio_chown $fh_or_path, $uid, $gid, $callback->($status) aio_chmod $fh_or_path, $mode, $callback->($status) aio_truncate $fh_or_path, $offset, $callback->($status) + aio_allocate $fh, $mode, $offset, $len, $callback->($status) + aio_fiemap $fh, $start, $length, $flags, $count, $cb->(\@extents) aio_unlink $pathname, $callback->($status) aio_mknod $pathname, $mode, $dev, $callback->($status) aio_link $srcpath, $dstpath, $callback->($status) aio_symlink $srcpath, $dstpath, $callback->($status) aio_readlink $pathname, $callback->($link) - aio_realpath $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) @@ -241,13 +248,15 @@ aio_copy $srcpath, $dstpath, $callback->($status) aio_move $srcpath, $dstpath, $callback->($status) aio_rmtree $pathname, $callback->($status) + aio_fcntl $fh, $cmd, $arg, $callback->($status) + aio_ioctl $fh, $request, $buf, $callback->($status) aio_sync $callback->($status) aio_syncfs $fh, $callback->($status) aio_fsync $fh, $callback->($status) 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) @@ -271,9 +280,14 @@ 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 + IO::AIO::mremap $scalar, $new_length, $flags[, $new_address] IO::AIO::madvise $scalar, $offset, $length, $advice IO::AIO::mprotect $scalar, $offset, $length, $protect IO::AIO::munlock $scalar, $offset = 0, $length = undef @@ -360,7 +374,7 @@ =item aio_open $pathname, $flags, $mode, $callback->($fh) Asynchronously open or create a file and call the callback with a newly -created filehandle for the file. +created filehandle for the file (or C in case of an error). The pathname passed to C must be absolute. See API NOTES, above, for an explanation. @@ -393,7 +407,7 @@ C, C, C, C, C, C, C, C, C, C, C, -C, C and C. +C, C, C, C, C and C. =item aio_close $fh, $callback->($status) @@ -438,8 +452,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 will, like C, shrink or grow the C<$data> scalar to @@ -507,7 +521,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 - -fewre bytes than expected might have been transferred. +fewer bytes than expected might have been transferred. =item aio_readahead $fh,$offset,$length, $callback->($retval) @@ -521,8 +535,8 @@ (off-set+length). C 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. +If that syscall doesn't exist (likely if your kernel 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->($status) @@ -549,6 +563,9 @@ C, C, C, C, C, C. +To access higher resolution stat timestamps, see L. + Example: Print the length of F: aio_stat "/etc/passwd", sub { @@ -601,7 +618,6 @@ fsid => 1810 } - =item aio_utime $fh_or_path, $atime, $mtime, $callback->($status) Works like perl's C function (including the special case of $atime @@ -638,6 +654,28 @@ Works like truncate(2) or ftruncate(2). +=item aio_allocate $fh, $mode, $offset, $len, $callback->($status) + +Allocates or frees disk space according to the C<$mode> argument. See the +linux C documentation for details. + +C<$mode> is usually C<0> or C to allocate +space, or C, +to deallocate a file range. + +IO::AIO also supports C, to remove a range +(without leaving a hole), C, to zero a range, +C to insert a range and C +to unshare shared blocks (see your L manpage). + +The file system block size used by C is presumably the +C returned by C, but different filesystems and filetypes +can dictate other limitations. + +If C isn't available or cannot be emulated (currently no +emulation will be attempted), passes C<-1> and sets C<$!> to C. + + =item aio_chmod $fh_or_path, $mode, $callback->($status) Works like perl's C function. @@ -684,7 +722,7 @@ =item aio_realpath $pathname, $callback->($path) Asynchronously make the path absolute and resolve any symlinks in -C<$path>. The resulting path only consists of directories (Same as +C<$path>. The resulting path only consists of directories (same as L). This request can be used to get the absolute path of the current working @@ -696,6 +734,26 @@ Asynchronously rename the object at C<$srcpath> to C<$dstpath>, just as 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 is called on the absolute path of C<$wd>. + + +=item aio_rename2 $srcpath, $dstpath, $flags, $callback->($status) + +Basically a version of C with an additional C<$flags> +argument. Calling this with C<$flags=0> is the same as calling +C. + +Non-zero flags are currently only supported on GNU/Linux systems that +support renameat2. Other systems fail with C in this case. + +The following constants are available (missing ones are, as usual C<0>), +see renameat2(2) for details: + +C, C +and C. + =item aio_mkdir $pathname, $mode, $callback->($status) @@ -709,6 +767,10 @@ Asynchronously rmdir (delete) a directory and call the callback with the result code. +On systems that support the AIO::WD working directory abstraction +natively, the case C<[$wd, "."]> is specialcased - instead of failing, +C is called on the absolute path of C<$wd>. + =item aio_readdir $pathname, $callback->($entries) @@ -733,10 +795,10 @@ =item IO::AIO::READDIR_DENTS -When this flag is off, then the callback gets an arrayref consisting of -names only (as with C), otherwise it gets an arrayref with -C<[$name, $type, $inode]> arrayrefs, each describing a single directory -entry in more detail. +Normally the callback gets an arrayref consisting of names only (as +with C). If this flag is set, then the callback gets an +arrayref with C<[$name, $type, $inode]> arrayrefs, each describing a +single directory entry in more detail: C<$name> is the name of the entry. @@ -746,9 +808,9 @@ C, C, C, C, C. -C means just that: readdir does not know. If you need to -know, you have to run stat yourself. Also, for speed reasons, the C<$type> -scalars are read-only: you can not modify them. +C means just that: readdir does not know. If you need +to know, you have to run stat yourself. Also, for speed/memory reasons, +the C<$type> scalars are read-only: you must not modify them. C<$inode> is the inode number (which might not be exact on systems with 64 bit inode numbers and 32 bit perls). This field has unspecified content on @@ -769,12 +831,14 @@ =item IO::AIO::READDIR_STAT_ORDER When this flag is set, then the names will be returned in an order -suitable for stat()'ing each one. That is, when you plan to stat() -all files in the given directory, then the returned order will likely -be fastest. - -If both this flag and C are specified, then -the likely dirs come first, resulting in a less optimal stat order. +suitable for stat()'ing each one. That is, when you plan to stat() most or +all files in the given directory, then the returned order will likely be +faster. + +If both this flag and C are specified, +then the likely dirs come first, resulting in a less optimal stat order +for stat'ing all entries, but likely a more optimal order for finding +subdirectories. =item IO::AIO::READDIR_FOUND_UNKNOWN @@ -786,11 +850,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. 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 request, but since it is +a single request, it might be more efficient to use. + +Example: load F 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 might be more efficient, as it is a single request. + =cut sub aio_load($$;$) { @@ -820,6 +915,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, followed by restoring atime, mtime, access mode and @@ -938,7 +1035,7 @@ names, directories you can recurse into (directories), and ones you cannot recurse into (everything else, including symlinks to directories). -C is a composite request that creates of many sub requests_ +C 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). @@ -1082,7 +1179,7 @@ =item aio_rmtree $pathname, $callback->($status) Delete a directory tree starting (and including) C<$path>, return the -status of the final C only. This is a composite request that +status of the final C only. This is a composite request that uses C to recurse into and rmdir directories, and unlink everything else. @@ -1114,6 +1211,50 @@ $grp } +=item aio_fcntl $fh, $cmd, $arg, $callback->($status) + +=item aio_ioctl $fh, $request, $buf, $callback->($status) + +These work just like the C and C built-in functions, except +they execute asynchronously and pass the return value to the callback. + +Both calls can be used for a lot of things, some of which make more sense +to run asynchronously in their own thread, while some others make less +sense. For example, calls that block waiting for external events, such +as locking, will also lock down an I/O thread while it is waiting, which +can deadlock the whole I/O system. At the same time, there might be no +alternative to using a thread to wait. + +So in general, you should only use these calls for things that do +(filesystem) I/O, not for things that wait for other events (network, +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, + +C, C, C, + +C, C, C, C, C, C. + +C, C, C, C, +C. + +C, C, C, +C, C, C. + +C, C, C, C, C, +C, C, C, C, +C, C, C, C, +C, C, C, C, C, +C. + +C, C, C, C, +C, C, C, C, +C, C, C, C, +C, C, C, C, + =item aio_sync $callback->($status) Asynchronously call sync and call the callback when finished. @@ -1191,7 +1332,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 function, although it also works on data @@ -1203,8 +1344,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, then it goes till the end of the string. The flags can be -a combination of C, C and -C. +either C or C, plus an optional +C. =item aio_mtouch $scalar, $offset = 0, $length = undef, flags = 0, $callback->($status) @@ -1212,10 +1353,10 @@ scalars. It touches (reads or writes) all memory pages in the specified -range inside the scalar. All caveats and parameters are the same +range inside the scalar. All caveats and parameters are the same as for C, above, except for flags, which must be either C<0> (which reads all pages and ensures they are instantiated) or -C, which modifies the memory page s(by reading and +C, which modifies the memory pages (by reading and writing an octet from it, which dirties the page). =item aio_mlock $scalar, $offset = 0, $length = undef, $callback->($status) @@ -1259,9 +1400,9 @@ =item aio_fiemap $fh, $start, $length, $flags, $count, $cb->(\@extents) -Queries the extents of the given file (by calling the Linux FIEMAP ioctl, -see L for details). If the -C is not available on your OS, then this rquiest will fail with +Queries the extents of the given file (by calling the Linux C +ioctl, see L for details). If +the ioctl is not available on your OS, then this request will fail with C. C<$start> is the starting offset to query extents for, C<$length> is the @@ -1274,9 +1415,9 @@ the data portion. C<$count> is the maximum number of extent records to return. If it is -C, then IO::AIO queries all extents of the file. As a very special +C, then IO::AIO queries all extents of the range. As a very special case, if it is C<0>, then the callback receives the number of extents -instead of the extents themselves. +instead of the extents themselves (which is unreliable, see below). If an error occurs, the callback receives no arguments. The special C value C is available to test for flag errors. @@ -1288,7 +1429,7 @@ [$logical, $physical, $length, $flags] Flags is any combination of the following flag values (typically either C<0> -or C): +or C (1)): C, C, C, C, @@ -1297,6 +1438,12 @@ C, C or C. +At the time of this writing (Linux 3.2), this request is unreliable unless +C<$count> is C, as the kernel has all sorts of bugs preventing +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. + =item aio_group $callback->(...) This is a very special aio request: Instead of doing something, it is a @@ -1389,9 +1536,9 @@ }; }; -That C is a request and not a normal function shows that creating -an IO::AIO::WD object is itself a potentially blocking operation, which is -why it is done asynchronously. +The fact that C is a request and not a normal function shows that +creating an IO::AIO::WD object is itself a potentially blocking operation, +which is why it is done asynchronously. To stat the directory obtained with C above, one could write either of the following three request calls: @@ -1418,10 +1565,10 @@ 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) will always rely on +the string form of the pathname. -So this fucntionality is mainly useful to get some protection against +So this functionality is mainly useful to get some protection against C, 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). @@ -1444,23 +1591,29 @@ C callback, as future requests using the value will fail in the expected way. -If this call isn't available because your OS lacks it or it couldn't be -detected, it will be emulated by calling C instead. - =item IO::AIO::CWD This is a compiletime constant (object) that represents the process current working directory. -Specifying this object as working directory object for a pathname is as -if the pathname would be specified directly, without a directory object, -e.g., these calls are functionally identical: +Specifying this object as working directory object for a pathname is as if +the pathname would be specified directly, without a directory object. For +example, these calls are functionally identical: aio_stat "somefile", sub { ... }; aio_stat [IO::AIO::CWD, "somefile"], sub { ... }; =back +To recover the path associated with an IO::AIO::WD object, you can use +C: + + aio_realpath $wd, sub { + warn "path is $_[0]\n"; + }; + +Currently, C always, and C and C +sometimes, fall back to using an absolue path. =head2 IO::AIO::REQ CLASS @@ -1648,16 +1801,19 @@ =item IO::AIO::poll_cb -Process some outstanding events on the result pipe. You have to call -this regularly. Returns C<0> if all events could be processed (or there -were no events to process), or C<-1> if it returned earlier for whatever -reason. Returns immediately when no events are outstanding. The amount of -events processed depends on the settings of C and -C. - -If not all requests were processed for whatever reason, the filehandle -will still be ready when C returns, so normally you don't have to -do anything special to have it called later. +Process some requests that have reached the result phase (i.e. they have +been executed but the results are not yet reported). You have to call +this "regularly" to finish outstanding requests. + +Returns C<0> if all events could be processed (or there were no +events to process), or C<-1> if it returned earlier for whatever +reason. Returns immediately when no events are outstanding. The amount +of events processed depends on the settings of C, +C and C. + +If not all requests were processed for whatever reason, the poll file +descriptor will still be ready when C returns, so normally you +don't have to do anything special to have it called later. Apart from calling C when the event filehandle becomes ready, it can be beneficial to call this function from loops which submit @@ -1676,10 +1832,11 @@ =item IO::AIO::poll_wait -If there are any outstanding requests and none of them in the result -phase, wait till the result filehandle becomes ready for reading (simply -does a C