--- IO-AIO/AIO.pm 2011/09/27 00:41:51 1.209 +++ IO-AIO/AIO.pm 2014/01/24 23:46:16 1.244 @@ -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; @@ -170,13 +169,13 @@ use base 'Exporter'; BEGIN { - our $VERSION = '4.0'; + our $VERSION = '4.19'; - our @AIO_REQ = qw(aio_sendfile aio_read aio_write aio_open aio_close + 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_fsync aio_syncfs aio_fdatasync aio_sync_file_range aio_allocate + aio_pathsync aio_readahead aio_fiemap 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,13 +203,14 @@ =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) aio_open $pathname, $flags, $mode, $callback->($fh) aio_close $fh, $callback->($status) + aio_seek $fh,$offset,$whence, $callback->($offs) aio_read $fh,$offset,$length, $data,$dataoffset, $callback->($retval) aio_write $fh,$offset,$length, $data,$dataoffset, $callback->($retval) aio_sendfile $out_fh, $in_fh, $in_offset, $length, $callback->($retval) @@ -220,8 +220,10 @@ aio_statvfs $fh_or_path, $callback->($statvfs) aio_utime $fh_or_path, $atime, $mtime, $callback->($status) aio_chown $fh_or_path, $uid, $gid, $callback->($status) - aio_truncate $fh_or_path, $offset, $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) @@ -235,10 +237,10 @@ aio_readdirx $pathname, $flags, $callback->($entries, $flags) IO::AIO::READDIR_DENTS IO::AIO::READDIR_DIRS_FIRST IO::AIO::READDIR_STAT_ORDER IO::AIO::READDIR_FOUND_UNKNOWN + aio_scandir $pathname, $maxreq, $callback->($dirs, $nondirs) aio_load $pathname, $data, $callback->($status) aio_copy $srcpath, $dstpath, $callback->($status) aio_move $srcpath, $dstpath, $callback->($status) - aio_scandir $pathname, $maxreq, $callback->($dirs, $nondirs) aio_rmtree $pathname, $callback->($status) aio_sync $callback->($status) aio_syncfs $fh, $callback->($status) @@ -273,20 +275,27 @@ 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::madvise $scalar, $offset, $length, $advice IO::AIO::mprotect $scalar, $offset, $length, $protect IO::AIO::munlock $scalar, $offset = 0, $length = undef IO::AIO::munlockall -=head2 AIO REQUEST FUNCTIONS +=head2 API NOTES All the C calls are more or less thin wrappers around the syscall with the same name (sans C). The arguments are similar or identical, and they all accept an additional (and optional) C<$callback> argument -which must be a code reference. This code reference will get called with -the syscall return code (e.g. most syscalls return C<-1> on error, unlike -perl, which usually delivers "false") as its sole argument after the given -syscall has been executed asynchronously. +which must be a code reference. This code reference will be called after +the syscall has been executed in an asynchronous fashion. The results +of the request will be passed as arguments to the callback (and, if an +error occured, in C<$!>) - for most requests the syscall return code (e.g. +most syscalls return C<-1> on error, unlike perl, which usually delivers +"false"). + +Some requests (such as C) pass the actual results and +communicate failures by passing C. All functions expecting a filehandle keep a copy of the filehandle internally until the request has finished. @@ -296,22 +305,26 @@ The pathnames you pass to these routines I be absolute. The reason for this 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 anywhere in -the program and then use relative paths. Lastly, you can take advantage -of IO::AIOs working directory abstraction - see the description of the -C class later in this document. +current working directory could have changed. Alternatively, you can +make sure that you never change the current working directory anywhere +in the program and then use relative paths. You can also take advantage +of IO::AIOs working directory abstraction, that lets you specify paths +relative to some previously-opened "working directory object" - see the +description of the C class later in this document. 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 to ensure your scalar has the correct contents. +tinkering, b) are in your native filesystem encoding, 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 to ensure your scalar has the +correct contents. This works, btw. independent of the internal UTF-8 bit, which IO::AIO handles correctly whether it is set or not. +=head2 AIO REQUEST FUNCTIONS + =over 4 =item $prev_pri = aioreq_pri [$pri] @@ -350,7 +363,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. @@ -403,6 +416,26 @@ =cut +=item aio_seek $fh, $offset, $whence, $callback->($offs) + +Seeks the filehandle to the new C<$offset>, similarly to perl's +C. The C<$whence> can use the traditional values (C<0> for +C, C<1> for C or C<2> for +C). + +The resulting absolute offset will be passed to the callback, or C<-1> in +case of an error. + +In theory, the C<$whence> constants could be different than the +corresponding values from L, but perl guarantees they are the same, +so don't panic. + +As a GNU/Linux (and maybe Solaris) extension, also the constants +C and C are available, if they +could be found. No guarantees about suitability for use in C or +Perl's C can be made though, although I would naively assume they +"just work". + =item aio_read $fh,$offset,$length, $data,$dataoffset, $callback->($retval) =item aio_write $fh,$offset,$length, $data,$dataoffset, $callback->($retval) @@ -571,6 +604,87 @@ 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 + 0x0000ef51 ext2 + 0x00004006 fat + 0x65735546 fuseblk + 0x65735543 fusectl + 0x0bad1dea futexfs + 0x01161970 gfs2 + 0x47504653 gpfs + 0x00004244 hfs + 0xf995e849 hpfs + 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 + 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) @@ -608,6 +722,22 @@ Works like truncate(2) or ftruncate(2). +=item aio_allocate $fh, $mode, $offset, $len, $callback->($status) + +Allocates or freed disk space according to the C<$mode> argument. See the +linux C docuemntation for details. + +C<$mode> can currently be C<0> or C +to allocate space, or C, to deallocate a file range. + +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. @@ -654,7 +784,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 @@ -666,6 +796,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) @@ -679,6 +813,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) @@ -968,67 +1106,78 @@ $maxreq = 4 if $maxreq <= 0; - # stat once + # get a wd object aioreq_pri $pri; - add $grp aio_stat $path, sub { - return $grp->result () if $_[0]; - my $now = time; - my $hash1 = join ":", (stat _)[0,1,3,7,9]; + add $grp aio_wd $path, sub { + $_[0] + or return $grp->result (); + + my $wd = [shift, "."]; - # read the directory entries + # stat once aioreq_pri $pri; - add $grp aio_readdirx $path, READDIR_DIRS_FIRST, sub { - my $entries = shift - or return $grp->result (); + add $grp aio_stat $wd, sub { + return $grp->result () if $_[0]; + my $now = time; + my $hash1 = join ":", (stat _)[0,1,3,7,9]; - # stat the dir another time + # read the directory entries aioreq_pri $pri; - add $grp aio_stat $path, sub { - my $hash2 = join ":", (stat _)[0,1,3,7,9]; + add $grp aio_readdirx $wd, READDIR_DIRS_FIRST, sub { + my $entries = shift + or return $grp->result (); - my $ndirs; + # stat the dir another time + aioreq_pri $pri; + add $grp aio_stat $wd, sub { + my $hash2 = join ":", (stat _)[0,1,3,7,9]; - # take the slow route if anything looks fishy - if ($hash1 ne $hash2 or (stat _)[9] == $now) { - $ndirs = -1; - } else { - # if nlink == 2, we are finished - # for non-posix-fs's, we rely on nlink < 2 - $ndirs = (stat _)[3] - 2 - or return $grp->result ([], $entries); - } + my $ndirs; - my (@dirs, @nondirs); + # take the slow route if anything looks fishy + if ($hash1 ne $hash2 or (stat _)[9] == $now) { + $ndirs = -1; + } else { + # if nlink == 2, we are finished + # for non-posix-fs's, we rely on nlink < 2 + $ndirs = (stat _)[3] - 2 + or return $grp->result ([], $entries); + } - my $statgrp = add $grp aio_group sub { - $grp->result (\@dirs, \@nondirs); - }; + my (@dirs, @nondirs); - limit $statgrp $maxreq; - feed $statgrp sub { - return unless @$entries; - my $entry = shift @$entries; + my $statgrp = add $grp aio_group sub { + $grp->result (\@dirs, \@nondirs); + }; - aioreq_pri $pri; - add $statgrp aio_stat "$path/$entry/.", sub { - if ($_[0] < 0) { - push @nondirs, $entry; - } else { - # need to check for real directory - aioreq_pri $pri; - add $statgrp aio_lstat "$path/$entry", sub { - if (-d _) { - push @dirs, $entry; - - unless (--$ndirs) { - push @nondirs, @$entries; - feed $statgrp; + limit $statgrp $maxreq; + feed $statgrp sub { + return unless @$entries; + my $entry = shift @$entries; + + aioreq_pri $pri; + $wd->[1] = "$entry/."; + add $statgrp aio_stat $wd, sub { + if ($_[0] < 0) { + push @nondirs, $entry; + } else { + # need to check for real directory + aioreq_pri $pri; + $wd->[1] = $entry; + add $statgrp aio_lstat $wd, sub { + if (-d _) { + push @dirs, $entry; + + unless (--$ndirs) { + push @nondirs, @$entries; + feed $statgrp; + } + } else { + push @nondirs, $entry; } - } else { - push @nondirs, $entry; } } - } + }; }; }; }; @@ -1041,7 +1190,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. @@ -1171,10 +1320,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) @@ -1216,6 +1365,51 @@ aio_mlockall IO::AIO::MCL_FUTURE; +=item aio_fiemap $fh, $start, $length, $flags, $count, $cb->(\@extents) + +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 +size of the range to query - if it is C, then the whole file will +be queried. + +C<$flags> is a combination of flags (C or +C - C is also +exported), and is normally C<0> or C to query +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 range. As a very special +case, if it is C<0>, then the callback receives the number of extents +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. + +Otherwise, the callback receives an array reference with extent +structures. Each extent structure is an array reference itself, with the +following members: + + [$logical, $physical, $length, $flags] + +Flags is any combination of the following flag values (typically either C<0> +or C (1)): + +C, C, +C, C, +C, C, +C, C, +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 @@ -1288,8 +1482,9 @@ Everywhere where a pathname is accepted by IO::AIO (e.g. in C or C), one can specify an array reference with an IO::AIO::WD -object and a pathname instead. If the pathname is absolute, the -IO::AIO::WD objetc is ignored, otherwise the pathname is resolved relative +object and a pathname instead (or the IO::AIO::WD object alone, which +gets interpreted as C<[$wd, "."]>). If the pathname is absolute, the +IO::AIO::WD object is ignored, otherwise the pathname is resolved relative to that IO::AIO::WD object. For example, to get a wd object for F and then stat F @@ -1307,8 +1502,16 @@ }; }; -This shows that creating an IO::AIO::WD object is itself a potentially -blocking operation, which is why it is done asynchronously. +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: + + aio_lstat "/etc" , sub { ... # pathname as normal string + aio_lstat [$wd, "."], sub { ... # "." relative to $wd (i.e. $wd itself) + aio_lstat $wd , sub { ... # shorthand for the previous As with normal pathnames, IO::AIO keeps a copy of the working directory object and the pathname string, so you could write the following without @@ -1331,7 +1534,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). @@ -1362,15 +1565,24 @@ 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 @@ -1498,8 +1710,8 @@ generator that generates requests if idle. The idea behind this is that, although you could just queue as many requests as you want in a group, this might starve other requests for a potentially long time. For example, -C might generate hundreds of thousands C requests, -delaying any later requests for a long time. +C might generate hundreds of thousands of C +requests, delaying any later requests for a long time. To avoid this, and allow incremental generation of requests, you can instead a group and set a feeder on it that generates those requests. The @@ -1558,16 +1770,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 @@ -1586,10 +1801,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