--- IO-AIO/README 2018/02/20 06:54:47 1.59 +++ IO-AIO/README 2022/09/06 10:56:12 1.69 @@ -223,18 +223,53 @@ IO::AIO::nreqs IO::AIO::nready IO::AIO::npending - $nfd = IO::AIO::get_fdlimit [EXPERIMENTAL] - IO::AIO::min_fdlimit $nfd [EXPERIMENTAL] + IO::AIO::reinit + + $nfd = IO::AIO::get_fdlimit + IO::AIO::min_fdlimit $nfd IO::AIO::sendfile $ofh, $ifh, $offset, $count IO::AIO::fadvise $fh, $offset, $len, $advice + IO::AIO::fexecve $fh, $argv, $envp + 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 IO::AIO::munlockall + # stat extensions + $counter = IO::AIO::st_gen + $seconds = IO::AIO::st_atime, IO::AIO::st_mtime, IO::AIO::st_ctime, IO::AIO::st_btime + ($atime, $mtime, $ctime, $btime, ...) = IO::AIO::st_xtime + $nanoseconds = IO::AIO::st_atimensec, IO::AIO::st_mtimensec, IO::AIO::st_ctimensec, IO::AIO::st_btimensec + $seconds = IO::AIO::st_btimesec + ($atime, $mtime, $ctime, $btime, ...) = IO::AIO::st_xtimensec + + # very much unportable syscalls + IO::AIO::accept4 $r_fh, $sockaddr, $sockaddr_len, $flags + IO::AIO::splice $r_fh, $r_off, $w_fh, $w_off, $length, $flags + IO::AIO::tee $r_fh, $w_fh, $length, $flags + + $actual_size = IO::AIO::pipesize $r_fh[, $new_size] + ($rfh, $wfh) = IO::AIO::pipe2 [$flags] + + $fh = IO::AIO::eventfd [$initval, [$flags]] + $fh = IO::AIO::memfd_create $pathname[, $flags] + + $fh = IO::AIO::timerfd_create $clockid[, $flags] + ($cur_interval, $cur_value) = IO::AIO::timerfd_settime $fh, $flags, $new_interval, $nbw_value + ($cur_interval, $cur_value) = IO::AIO::timerfd_gettime $fh + + $fh = IO::AIO::pidfd_open $pid[, $flags] + $status = IO::AIO::pidfd_send_signal $pidfh, $signal[, $siginfo[, $flags]] + $fh = IO::AIO::pidfd_getfd $pidfh, $targetfd[, $flags] + + $retval = IO::AIO::mount $special, $path, $fstype, $flags = 0, $data = undef + $retval = IO::AIO::umount $path, $flags = 0 + API NOTES All the "aio_*" calls are more or less thin wrappers around the syscall with the same name (sans "aio_"). The arguments are similar or @@ -341,8 +376,8 @@ "O_ASYNC", "O_DIRECT", "O_NOATIME", "O_CLOEXEC", "O_NOCTTY", "O_NOFOLLOW", "O_NONBLOCK", "O_EXEC", "O_SEARCH", "O_DIRECTORY", - "O_DSYNC", "O_RSYNC", "O_SYNC", "O_PATH", "O_TMPFILE", and - "O_TTY_INIT". + "O_DSYNC", "O_RSYNC", "O_SYNC", "O_PATH", "O_TMPFILE", "O_TTY_INIT" + and "O_ACCMODE". aio_close $fh, $callback->($status) Asynchronously close a file and call the callback with the result @@ -470,9 +505,10 @@ aio_stat $fh_or_path, $callback->($status) aio_lstat $fh, $callback->($status) - Works like perl's "stat" or "lstat" in void context. The callback - will be called after the stat and the results will be available - using "stat _" or "-s _" etc... + Works almost exactly like perl's "stat" or "lstat" in void context. + The callback will be called after the stat and the results will be + available using "stat _" or "-s _" and other tests (with the + exception of "-B" and "-T"). The pathname passed to "aio_stat" must be absolute. See API NOTES, above, for an explanation. @@ -491,6 +527,9 @@ "S_IFDIR", "S_IFWHT", "S_IFSOCK", "IO::AIO::major $dev_t", "IO::AIO::minor $dev_t", "IO::AIO::makedev $major, $minor". + To access higher resolution stat timestamps, see "SUBSECOND STAT + TIME ACCESS". + Example: Print the length of /etc/passwd: aio_stat "/etc/passwd", sub { @@ -546,9 +585,10 @@ $atime and $mtime being undef). Fractional times are supported if the underlying syscalls support them. - When called with a pathname, uses utimes(2) if available, otherwise - utime(2). If called on a file descriptor, uses futimes(2) if - available, otherwise returns ENOSYS, so this is not portable. + When called with a pathname, uses utimensat(2) or utimes(2) if + available, otherwise utime(2). If called on a file descriptor, uses + futimens(2) or futimes(2) if available, otherwise returns ENOSYS, so + this is not portable. Examples: @@ -688,10 +728,10 @@ modified): IO::AIO::READDIR_DENTS - When this flag is off, then the callback gets an arrayref - consisting of names only (as with "aio_readdir"), otherwise it + Normally the callback gets an arrayref consisting of names only + (as with "aio_readdir"). If this flag is set, then the callback gets an arrayref with "[$name, $type, $inode]" arrayrefs, each - describing a single directory entry in more detail. + describing a single directory entry in more detail: $name is the name of the entry. @@ -702,9 +742,9 @@ "IO::AIO::DT_LNK", "IO::AIO::DT_SOCK", "IO::AIO::DT_WHT". "IO::AIO::DT_UNKNOWN" means just that: readdir does not know. If - you need to know, you have to run stat yourself. Also, for speed - reasons, the $type scalars are read-only: you can not modify - them. + you need to know, you have to run stat yourself. Also, for + speed/memory reasons, the $type scalars are read-only: you must + not modify them. $inode is the inode number (which might not be exact on systems with 64 bit inode numbers and 32 bit perls). This field has @@ -726,12 +766,13 @@ 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. + to stat() most or all files in the given directory, then the + returned order will likely be faster. If both this flag and "IO::AIO::READDIR_DIRS_FIRST" are specified, then the likely dirs come first, resulting in a less - optimal stat order. + optimal stat order for stat'ing all entries, but likely a more + optimal order for finding subdirectories. IO::AIO::READDIR_FOUND_UNKNOWN This flag should not be set when calling "aio_readdirx". @@ -882,8 +923,8 @@ (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 - 0): + The following constants are available and can be used for normal + "ioctl" and "fcntl" as well (missing ones are, as usual 0): "F_DUPFD_CLOEXEC", @@ -892,6 +933,9 @@ "FIFREEZE", "FITHAW", "FITRIM", "FICLONE", "FICLONERANGE", "FIDEDUPERANGE". + "F_ADD_SEALS", "F_GET_SEALS", "F_SEAL_SEAL", "F_SEAL_SHRINK", + "F_SEAL_GROW" and "F_SEAL_WRITE". + "FS_IOC_GETFLAGS", "FS_IOC_SETFLAGS", "FS_IOC_GETVERSION", "FS_IOC_SETVERSION", "FS_IOC_FIEMAP". @@ -912,6 +956,10 @@ "FS_XFLAG_NODEFRAG", "FS_XFLAG_FILESTREAM", "FS_XFLAG_DAX", "FS_XFLAG_HASATTR", + "BLKROSET", "BLKROGET", "BLKRRPART", "BLKGETSIZE", "BLKFLSBUF", + "BLKRASET", "BLKRAGET", "BLKFRASET", "BLKFRAGET", "BLKSECTSET", + "BLKSECTGET", "BLKSSZGET", "BLKBSZGET", "BLKBSZSET", "BLKGETSIZE64", + aio_sync $callback->($status) Asynchronously call sync and call the callback when finished. @@ -1011,10 +1059,13 @@ aio_mlockall $flags, $callback->($status) Calls the "mlockall" function with the given $flags (a combination - of "IO::AIO::MCL_CURRENT" and "IO::AIO::MCL_FUTURE"). + of "IO::AIO::MCL_CURRENT", "IO::AIO::MCL_FUTURE" and + "IO::AIO::MCL_ONFAULT"). On systems that do not implement "mlockall", this function returns - -1 and sets errno to "ENOSYS". + -1 and sets errno to "ENOSYS". Similarly, flag combinations not + supported by the system result in a return value of -1 with errno + being set to "EINVAL". Note that the corresponding "munlockall" is synchronous and is documented under "MISCELLANEOUS FUNCTIONS". @@ -1213,7 +1264,7 @@ value will fail in the expected way. IO::AIO::CWD - This is a compiletime constant (object) that represents the process + This is a compile time constant (object) that represents the process current working directory. Specifying this object as working directory object for a pathname is @@ -1448,6 +1499,17 @@ IO::AIO::poll_wait, IO::AIO::poll_cb while IO::AIO::nreqs; + This function can be useful at program aborts, to make sure + outstanding I/O has been done ("IO::AIO" uses an "END" block which + already calls this function on normal exits), or when you are merely + using "IO::AIO" for its more advanced functions, rather than for + async I/O, e.g.: + + my ($dirs, $nondirs); + IO::AIO::aio_scandir "/tmp", 0, sub { ($dirs, $nondirs) = @_ }; + IO::AIO::flush; + # $dirs, $nondirs are now set + IO::AIO::max_poll_reqs $nreqs IO::AIO::max_poll_time $seconds These set the maximum number of requests (default 0, meaning @@ -1546,9 +1608,11 @@ In other words, this setting does not enforce a queue limit, but can be used to make poll functions block if the limit is exceeded. - 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 "aio_group" together with a feed callback. + This is a bad function to use in interactive programs because it + blocks, and a bad way to reduce concurrency because it is inexact. + If you need to issue many requests without being able to call a poll + function on demand, it is better to use an "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 something like this: @@ -1563,10 +1627,11 @@ IO::AIO::flush; The call to "poll_cb" inside the loop will normally return - instantly, but as soon as more thna 32 reqeusts are in-flight, it - will block until some requests have been handled. This keeps the - loop from pushing a large number of "aio_stat" requests onto the - queue. + instantly, allowing the loop to progress, but as soon as more than + 32 requests are in-flight, it will block until some requests have + been handled. This keeps the loop from pushing a large number of + "aio_stat" requests onto the queue (which, with many paths to stat, + can use up a lot of memory). The default value for "max_outstanding" is very large, so there is no practical limit on the number of outstanding requests. @@ -1590,22 +1655,139 @@ Returns the number of requests currently in the pending state (executed, but not yet processed by poll_cb). + SUBSECOND STAT TIME ACCESS + Both "aio_stat"/"aio_lstat" and perl's "stat"/"lstat" functions can + generally find access/modification and change times with subsecond time + accuracy of the system supports it, but perl's built-in functions only + return the integer part. + + The following functions return the timestamps of the most recent stat + with subsecond precision on most systems and work both after + "aio_stat"/"aio_lstat" and perl's "stat"/"lstat" calls. Their return + value is only meaningful after a successful "stat"/"lstat" call, or + during/after a successful "aio_stat"/"aio_lstat" callback. + + This is similar to the Time::HiRes "stat" functions, but can return full + resolution without rounding and work with standard perl "stat", + alleviating the need to call the special "Time::HiRes" functions, which + do not act like their perl counterparts. + + On operating systems or file systems where subsecond time resolution is + not supported or could not be detected, a fractional part of 0 is + returned, so it is always safe to call these functions. + + $seconds = IO::AIO::st_atime, IO::AIO::st_mtime, IO::AIO::st_ctime, + IO::AIO::st_btime + Return the access, modication, change or birth time, respectively, + including fractional part. Due to the limited precision of floating + point, the accuracy on most platforms is only a bit better than + milliseconds for times around now - see the *nsec* function family, + below, for full accuracy. + + File birth time is only available when the OS and perl support it + (on FreeBSD and NetBSD at the time of this writing, although support + is adaptive, so if your OS/perl gains support, IO::AIO can take + advantage of it). On systems where it isn't available, 0 is + currently returned, but this might change to "undef" in a future + version. + + ($atime, $mtime, $ctime, $btime, ...) = IO::AIO::st_xtime + Returns access, modification, change and birth time all in one go, + and maybe more times in the future version. + + $nanoseconds = IO::AIO::st_atimensec, IO::AIO::st_mtimensec, + IO::AIO::st_ctimensec, IO::AIO::st_btimensec + Return the fractional access, modifcation, change or birth time, in + nanoseconds, as an integer in the range 0 to 999999999. + + Note that no accessors are provided for access, modification and + change times - you need to get those from "stat _" if required ("int + IO::AIO::st_atime" and so on will *not* generally give you the + correct value). + + $seconds = IO::AIO::st_btimesec + The (integral) seconds part of the file birth time, if available. + + ($atime, $mtime, $ctime, $btime, ...) = IO::AIO::st_xtimensec + Like the functions above, but returns all four times in one go (and + maybe more in future versions). + + $counter = IO::AIO::st_gen + Returns the generation counter (in practice this is just a random + number) of the file. This is only available on platforms which have + this member in their "struct stat" (most BSDs at the time of this + writing) and generally only to the root usert. If unsupported, 0 is + returned, but this might change to "undef" in a future version. + + Example: print the high resolution modification time of /etc, using + "stat", and "IO::AIO::aio_stat". + + if (stat "/etc") { + printf "stat(/etc) mtime: %f\n", IO::AIO::st_mtime; + } + + IO::AIO::aio_stat "/etc", sub { + $_[0] + and return; + + printf "aio_stat(/etc) mtime: %d.%09d\n", (stat _)[9], IO::AIO::st_mtimensec; + }; + + IO::AIO::flush; + + Output of the awbove on my system, showing reduced and full accuracy: + + stat(/etc) mtime: 1534043702.020808 + aio_stat(/etc) mtime: 1534043702.020807792 + MISCELLANEOUS FUNCTIONS IO::AIO implements some functions that are useful when you want to use some "Advanced I/O" function not available to in Perl, without going the "Asynchronous I/O" route. Many of these have an asynchronous "aio_*" counterpart. - $numfd = IO::AIO::get_fdlimit - This function is *EXPERIMENTAL* and subject to change. + $retval = IO::AIO::fexecve $fh, $argv, $envp + A more-or-less direct equivalent to the POSIX "fexecve" functions, + which allows you to specify the program to be executed via a file + descriptor (or handle). Returns -1 and sets errno to "ENOSYS" if not + available. + + $retval = IO::AIO::mount $special, $path, $fstype, $flags = 0, $data = + undef + Calls the GNU/Linux mount syscall with the given arguments. All + except $flags are strings, and if $data is "undef", a "NULL" will be + passed. + + The following values for $flags are available: + + "IO::AIO::MS_RDONLY", "IO::AIO::MS_NOSUID", "IO::AIO::MS_NODEV", + "IO::AIO::MS_NOEXEC", "IO::AIO::MS_SYNCHRONOUS", + "IO::AIO::MS_REMOUNT", "IO::AIO::MS_MANDLOCK", + "IO::AIO::MS_DIRSYNC", "IO::AIO::MS_NOATIME", + "IO::AIO::MS_NODIRATIME", "IO::AIO::MS_BIND", "IO::AIO::MS_MOVE", + "IO::AIO::MS_REC", "IO::AIO::MS_SILENT", "IO::AIO::MS_POSIXACL", + "IO::AIO::MS_UNBINDABLE", "IO::AIO::MS_PRIVATE", + "IO::AIO::MS_SLAVE", "IO::AIO::MS_SHARED", "IO::AIO::MS_RELATIME", + "IO::AIO::MS_KERNMOUNT", "IO::AIO::MS_I_VERSION", + "IO::AIO::MS_STRICTATIME", "IO::AIO::MS_LAZYTIME", + "IO::AIO::MS_ACTIVE", "IO::AIO::MS_NOUSER", "IO::AIO::MS_RMT_MASK", + "IO::AIO::MS_MGC_VAL" and "IO::AIO::MS_MGC_MSK". + + $retval = IO::AIO::umount $path, $flags = 0 + Invokes the GNU/Linux "umount" or "umount2" syscalls. Always calls + "umount" if $flags is 0, otherwqise always tries to call "umount2". + The following $flags are available: + + "IO::AIO::MNT_FORCE", "IO::AIO::MNT_DETACH", "IO::AIO::MNT_EXPIRE" + and "IO::AIO::UMOUNT_NOFOLLOW". + + $numfd = IO::AIO::get_fdlimit Tries to find the current file descriptor limit and returns it, or "undef" and sets $! in case of an error. The limit is one larger than the highest valid file descriptor number. IO::AIO::min_fdlimit [$numfd] - This function is *EXPERIMENTAL* and subject to change. - Try to increase the current file descriptor limit(s) to at least $numfd by changing the soft or hard file descriptor resource limit. If $numfd is missing, it will try to set a very high limit, although @@ -1702,8 +1884,9 @@ "IO::AIO::MAP_LOCKED", "IO::AIO::MAP_NORESERVE", "IO::AIO::MAP_POPULATE", "IO::AIO::MAP_NONBLOCK", "IO::AIO::MAP_FIXED", "IO::AIO::MAP_GROWSDOWN", - "IO::AIO::MAP_32BIT", "IO::AIO::MAP_HUGETLB" or - "IO::AIO::MAP_STACK". + "IO::AIO::MAP_32BIT", "IO::AIO::MAP_HUGETLB", "IO::AIO::MAP_STACK", + "IO::AIO::MAP_FIXED_NOREPLACE", "IO::AIO::MAP_SHARED_VALIDATE", + "IO::AIO::MAP_SYNC" or "IO::AIO::MAP_UNINITIALIZED". If $fh is "undef", then a file descriptor of -1 is passed. @@ -1726,6 +1909,34 @@ IO::AIO::munmap $scalar Removes a previous mmap and undefines the $scalar. + IO::AIO::mremap $scalar, $new_length, $flags = MREMAP_MAYMOVE[, + $new_address = 0] + Calls the Linux-specific mremap(2) system call. The $scalar must + have been mapped by "IO::AIO::mmap", and $flags must currently + either be 0 or "IO::AIO::MREMAP_MAYMOVE". + + Returns true if successful, and false otherwise. If the underlying + mmapped region has changed address, then the true value has the + numerical value 1, otherwise it has the numerical value 0: + + my $success = IO::AIO::mremap $mmapped, 8192, IO::AIO::MREMAP_MAYMOVE + or die "mremap: $!"; + + if ($success*1) { + warn "scalar has chanegd address in memory\n"; + } + + "IO::AIO::MREMAP_FIXED" and the $new_address argument are currently + implemented, but not supported and might go away in a future + version. + + On systems where this call is not supported or is not emulated, this + call returns falls and sets $! to "ENOSYS". + + IO::AIO::mlockall $flags + Calls the "eio_mlockall_sync" function, which is like + "aio_mlockall", but is blocking. + IO::AIO::munlock $scalar, $offset = 0, $length = undef Calls the "munlock" function, undoing the effects of a previous "aio_mlock" call (see its description for details). @@ -1736,6 +1947,26 @@ On systems that do not implement "munlockall", this function returns ENOSYS, otherwise the return value of "munlockall". + $fh = IO::AIO::accept4 $r_fh, $sockaddr, $sockaddr_maxlen, $flags + Uses the GNU/Linux accept4(2) syscall, if available, to accept a + socket and return the new file handle on success, or sets $! and + returns "undef" on error. + + The remote name of the new socket will be stored in $sockaddr, which + will be extended to allow for at least $sockaddr_maxlen octets. If + the socket name does not fit into $sockaddr_maxlen octets, this is + signaled by returning a longer string in $sockaddr, which might or + might not be truncated. + + To accept name-less sockets, use "undef" for $sockaddr and 0 for + $sockaddr_maxlen. + + The main reasons to use this syscall rather than portable accept(2) + are that you can specify "SOCK_NONBLOCK" and/or "SOCK_CLOEXEC" flags + and you can accept name-less sockets by specifying 0 for + $sockaddr_maxlen, which is sadly not possible with perl's interface + to "accept". + IO::AIO::splice $r_fh, $r_off, $w_fh, $w_off, $length, $flags Calls the GNU/Linux splice(2) syscall, if available. If $r_off or $w_off are "undef", then "NULL" is passed for these, otherwise they @@ -1785,6 +2016,82 @@ my ($rfh, $wfh) = IO::AIO::pipe2 IO::AIO::O_CLOEXEC or die "pipe2: $!\n"; + $fh = IO::AIO::memfd_create $pathname[, $flags] + This is a direct interface to the Linux memfd_create(2) system call. + The (unhelpful) default for $flags is 0, but your default should be + "IO::AIO::MFD_CLOEXEC". + + On success, the new memfd filehandle is returned, otherwise returns + "undef". If the memfd_create syscall is missing, fails with + "ENOSYS". + + Please refer to memfd_create(2) for more info on this call. + + The following $flags values are available: "IO::AIO::MFD_CLOEXEC", + "IO::AIO::MFD_ALLOW_SEALING", "IO::AIO::MFD_HUGETLB", + "IO::AIO::MFD_HUGETLB_2MB" and "IO::AIO::MFD_HUGETLB_1GB". + + Example: create a new memfd. + + my $fh = IO::AIO::memfd_create "somenameforprocfd", IO::AIO::MFD_CLOEXEC + or die "memfd_create: $!\n"; + + $fh = IO::AIO::pidfd_open $pid[, $flags] + This is an interface to the Linux pidfd_open(2) system call. The + default for $flags is 0. + + On success, a new pidfd filehandle is returned (that is already set + to close-on-exec), otherwise returns "undef". If the syscall is + missing, fails with "ENOSYS". + + Example: open pid 6341 as pidfd. + + my $fh = IO::AIO::pidfd_open 6341 + or die "pidfd_open: $!\n"; + + $status = IO::AIO::pidfd_send_signal $pidfh, $signal[, $siginfo[, + $flags]] + This is an interface to the Linux pidfd_send_signal system call. The + default for $siginfo is "undef" and the default for $flags is 0. + + Returns the system call status. If the syscall is missing, fails + with "ENOSYS". + + When specified, $siginfo must be a reference to a hash with one or + more of the following members: + + code - the "si_code" member + pid - the "si_pid" member + uid - the "si_uid" member + value_int - the "si_value.sival_int" member + value_ptr - the "si_value.sival_ptr" member, specified as an integer + + Example: send a SIGKILL to the specified process. + + my $status = IO::AIO::pidfd_send_signal $pidfh, 9, undef + and die "pidfd_send_signal: $!\n"; + + Example: send a SIGKILL to the specified process with extra data. + + my $status = IO::AIO::pidfd_send_signal $pidfh, 9, { code => -1, value_int => 7 } + and die "pidfd_send_signal: $!\n"; + + $fh = IO::AIO::pidfd_getfd $pidfh, $targetfd[, $flags] + This is an interface to the Linux pidfd_getfd system call. The + default for $flags is 0. + + On success, returns a dup'ed copy of the target file descriptor + (specified as an integer) returned (that is already set to + close-on-exec), otherwise returns "undef". If the syscall is + missing, fails with "ENOSYS". + + Example: get a copy of standard error of another process and print + soemthing to it. + + my $errfh = IO::AIO::pidfd_getfd $pidfh, 2 + or die "pidfd_getfd: $!\n"; + print $errfh "stderr\n"; + $fh = IO::AIO::eventfd [$initval, [$flags]] This is a direct interface to the Linux eventfd(2) system call. The (unhelpful) defaults for $initval and $flags are 0 for both. @@ -1801,16 +2108,17 @@ Example: create a new eventfd filehandle: - $fh = IO::AIO::eventfd 0, IO::AIO::O_CLOEXEC + $fh = IO::AIO::eventfd 0, IO::AIO::EFD_CLOEXEC or die "eventfd: $!\n"; $fh = IO::AIO::timerfd_create $clockid[, $flags] This is a direct interface to the Linux timerfd_create(2) system - call. The (unhelpful) default for $flags is 0. + call. The (unhelpful) default for $flags is 0, but your default + should be "IO::AIO::TFD_CLOEXEC". On success, the new timerfd filehandle is returned, otherwise - returns "undef". If the eventfd syscall is missing, fails with - "ENOSYS". + returns "undef". If the timerfd_create syscall is missing, fails + with "ENOSYS". Please refer to timerfd_create(2) for more info on this call. @@ -1963,7 +2271,7 @@ SEE ALSO AnyEvent::AIO for easy integration into event loops, Coro::AIO for a - more natural syntax. + more natural syntax and IO::FDPass for file descriptor passing. AUTHOR Marc Lehmann