--- IO-AIO/AIO.pm 2011/09/29 22:42:15 1.212 +++ IO-AIO/AIO.pm 2012/12/13 02:26:28 1.239 @@ -170,13 +170,13 @@ use base 'Exporter'; BEGIN { - our $VERSION = '4.0'; + our $VERSION = '4.18'; - 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 +204,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 +221,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 +238,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,12 +276,14 @@ 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, @@ -319,6 +324,8 @@ 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] @@ -357,7 +364,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. @@ -410,6 +417,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) @@ -578,6 +605,87 @@ fsid => 1810 } +Here is a (likely partial) list of fsid values used by Linux - it is safe +to hardcode these when the $^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) @@ -615,6 +723,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. @@ -661,7 +785,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 @@ -1059,7 +1183,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. @@ -1189,10 +1313,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) @@ -1234,6 +1358,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 @@ -1306,8 +1475,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 @@ -1325,8 +1495,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 @@ -1349,7 +1527,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). @@ -1380,15 +1558,22 @@ 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"; + }; + =head2 IO::AIO::REQ CLASS @@ -1836,7 +2021,8 @@ =item IO::AIO::mmap $scalar, $length, $prot, $flags, $fh[, $offset] Memory-maps a file (or anonymous memory range) and attaches it to the -given C<$scalar>, which will act like a string scalar. +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/C that don't change the string length, and most read-only operations such as copying it @@ -1899,6 +2085,26 @@ On systems that do not implement C, this function returns ENOSYS, otherwise the return value of C. +=item IO::AIO::splice $r_fh, $r_off, $w_fh, $w_off, $length, $flags + +Calls the GNU/Linux C syscall, if available. If C<$r_off> or +C<$w_off> are C, then C is passed for these, otherwise they +should be the file offset. + +C<$r_fh> and C<$w_fh> should not refer to the same file, as splice might +silently corrupt the data in this case. + +The following symbol flag values are available: C, +C, C and +C. + +See the C manpage for details. + +=item IO::AIO::tee $r_fh, $w_fh, $length, $flags + +Calls the GNU/Linux C syscall, see it's manpage and the +description for C above for details. + =back =cut