--- IO-AIO/AIO.pm 2012/05/29 03:58:02 1.227 +++ IO-AIO/AIO.pm 2016/05/21 04:43:31 1.261 @@ -70,7 +70,6 @@ This is a simple example that uses the EV module and loads F asynchronously: - use Fcntl; use EV; use IO::AIO; @@ -97,7 +96,7 @@ print $contents; # exit event loop and program - EV::unloop; + EV::break; }; }; @@ -105,7 +104,7 @@ # check for sockets etc. etc. # process events as long as there are some: - EV::loop; + EV::run; =head1 REQUEST ANATOMY AND LIFETIME @@ -170,13 +169,13 @@ use base 'Exporter'; BEGIN { - our $VERSION = '4.15'; + our $VERSION = 4.34; 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_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_nop aio_mknod aio_load aio_rmtree aio_mkdir aio_chown aio_chmod aio_utime aio_truncate @@ -204,8 +203,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,12 +222,14 @@ 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_mkdir $pathname, $mode, $callback->($status) aio_rmdir $pathname, $callback->($status) @@ -241,6 +242,8 @@ 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) @@ -362,7 +365,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. @@ -395,7 +398,7 @@ C, C, C, C, C, C, C, C, C, C, C, -C, C and C. +C, C, C, C, and C. =item aio_close $fh, $callback->($status) @@ -523,8 +526,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) @@ -603,6 +606,90 @@ 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: + + 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) @@ -640,6 +727,26 @@ 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) and C, to zero a range (see +your L manpage). + +The file system block size used by C is presumably the +C returned by C. + +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. @@ -686,7 +793,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 @@ -698,6 +805,10 @@ 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_mkdir $pathname, $mode, $callback->($status) @@ -711,6 +822,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) @@ -1084,7 +1199,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. @@ -1116,6 +1231,25 @@ $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. + =item aio_sync $callback->($status) Asynchronously call sync and call the callback when finished. @@ -1214,10 +1348,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) @@ -1261,9 +1395,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 @@ -1276,9 +1410,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. @@ -1290,7 +1424,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, @@ -1299,6 +1433,11 @@ C, C or C. +At the time of this writing (Linux 3.2), this requets 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 large number of +extents. The code works around all these issues if C<$count> is undef. + =item aio_group $callback->(...) This is a very special aio request: Instead of doing something, it is a @@ -1391,9 +1530,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: @@ -1423,7 +1562,7 @@ older systems. Some functions (such as realpath) 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). @@ -1446,23 +1585,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 @@ -1650,16 +1795,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 @@ -1678,10 +1826,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