[ViewVC] Diff of: cvs/IO-AIO/README

Comparing IO-AIO/README (file contents):
Revision 1.45 by root, Thu Dec 30 07:19:31 2010 UTC vs.
Revision 1.57 by root, Mon Jan 18 11:53:09 2016 UTC

…		…
64		64
65	EXAMPLE	65	EXAMPLE
66	This is a simple example that uses the EV module and loads /etc/passwd	66	This is a simple example that uses the EV module and loads /etc/passwd
67	asynchronously:	67	asynchronously:
68		68
69	use Fcntl;
70	use EV;	69	use EV;
71	use IO::AIO;	70	use IO::AIO;
72		71
73	# register the IO::AIO callback with EV	72	# register the IO::AIO callback with EV
74	my $aio_w = EV::io IO::AIO::poll_fileno, EV::READ, \&IO::AIO::poll_cb;	73	my $aio_w = EV::io IO::AIO::poll_fileno, EV::READ, \&IO::AIO::poll_cb;
…		…
91		90
92	# file contents now in $contents	91	# file contents now in $contents
93	print $contents;	92	print $contents;
94		93
95	# exit event loop and program	94	# exit event loop and program
96	EV::unloop;	95	EV::break;
97	};	96	};
98	};	97	};
99		98
100	# possibly queue up other requests, or open GUI windows,	99	# possibly queue up other requests, or open GUI windows,
101	# check for sockets etc. etc.	100	# check for sockets etc. etc.
102		101
103	# process events as long as there are some:	102	# process events as long as there are some:
104	EV::loop;	103	EV::run;
105		104
106	REQUEST ANATOMY AND LIFETIME	105	REQUEST ANATOMY AND LIFETIME
107	Every "aio_*" function creates a request. which is a C data structure	106	Every "aio_*" function creates a request. which is a C data structure
108	not directly visible to Perl.	107	not directly visible to Perl.
109		108
…		…
146	the actual aio request is severed and calling its methods will	145	the actual aio request is severed and calling its methods will
147	either do nothing or result in a runtime error).	146	either do nothing or result in a runtime error).
148		147
149	FUNCTIONS	148	FUNCTIONS
150	QUICK OVERVIEW	149	QUICK OVERVIEW
151	This section simply lists the prototypes of the most important functions	150	This section simply lists the prototypes most of the functions for quick
152	for quick reference. See the following sections for function-by-function	151	reference. See the following sections for function-by-function
153	documentation.	152	documentation.
154		153
		154	aio_wd $pathname, $callback->($wd)
155	aio_open $pathname, $flags, $mode, $callback->($fh)	155	aio_open $pathname, $flags, $mode, $callback->($fh)
156	aio_close $fh, $callback->($status)	156	aio_close $fh, $callback->($status)
		157	aio_seek $fh,$offset,$whence, $callback->($offs)
157	aio_read $fh,$offset,$length, $data,$dataoffset, $callback->($retval)	158	aio_read $fh,$offset,$length, $data,$dataoffset, $callback->($retval)
158	aio_write $fh,$offset,$length, $data,$dataoffset, $callback->($retval)	159	aio_write $fh,$offset,$length, $data,$dataoffset, $callback->($retval)
159	aio_sendfile $out_fh, $in_fh, $in_offset, $length, $callback->($retval)	160	aio_sendfile $out_fh, $in_fh, $in_offset, $length, $callback->($retval)
160	aio_readahead $fh,$offset,$length, $callback->($retval)	161	aio_readahead $fh,$offset,$length, $callback->($retval)
161	aio_stat $fh_or_path, $callback->($status)	162	aio_stat $fh_or_path, $callback->($status)
162	aio_lstat $fh, $callback->($status)	163	aio_lstat $fh, $callback->($status)
163	aio_statvfs $fh_or_path, $callback->($statvfs)	164	aio_statvfs $fh_or_path, $callback->($statvfs)
164	aio_utime $fh_or_path, $atime, $mtime, $callback->($status)	165	aio_utime $fh_or_path, $atime, $mtime, $callback->($status)
165	aio_chown $fh_or_path, $uid, $gid, $callback->($status)	166	aio_chown $fh_or_path, $uid, $gid, $callback->($status)
		167	aio_chmod $fh_or_path, $mode, $callback->($status)
166	aio_truncate $fh_or_path, $offset, $callback->($status)	168	aio_truncate $fh_or_path, $offset, $callback->($status)
167	aio_chmod $fh_or_path, $mode, $callback->($status)	169	aio_allocate $fh, $mode, $offset, $len, $callback->($status)
		170	aio_fiemap $fh, $start, $length, $flags, $count, $cb->(\@extents)
168	aio_unlink $pathname, $callback->($status)	171	aio_unlink $pathname, $callback->($status)
169	aio_mknod $path, $mode, $dev, $callback->($status)	172	aio_mknod $pathname, $mode, $dev, $callback->($status)
170	aio_link $srcpath, $dstpath, $callback->($status)	173	aio_link $srcpath, $dstpath, $callback->($status)
171	aio_symlink $srcpath, $dstpath, $callback->($status)	174	aio_symlink $srcpath, $dstpath, $callback->($status)
172	aio_readlink $path, $callback->($link)	175	aio_readlink $pathname, $callback->($link)
		176	aio_realpath $pathname, $callback->($path)
173	aio_rename $srcpath, $dstpath, $callback->($status)	177	aio_rename $srcpath, $dstpath, $callback->($status)
174	aio_mkdir $pathname, $mode, $callback->($status)	178	aio_mkdir $pathname, $mode, $callback->($status)
175	aio_rmdir $pathname, $callback->($status)	179	aio_rmdir $pathname, $callback->($status)
176	aio_readdir $pathname, $callback->($entries)	180	aio_readdir $pathname, $callback->($entries)
177	aio_readdirx $pathname, $flags, $callback->($entries, $flags)	181	aio_readdirx $pathname, $flags, $callback->($entries, $flags)
178	IO::AIO::READDIR_DENTS IO::AIO::READDIR_DIRS_FIRST	182	IO::AIO::READDIR_DENTS IO::AIO::READDIR_DIRS_FIRST
179	IO::AIO::READDIR_STAT_ORDER IO::AIO::READDIR_FOUND_UNKNOWN	183	IO::AIO::READDIR_STAT_ORDER IO::AIO::READDIR_FOUND_UNKNOWN
		184	aio_scandir $pathname, $maxreq, $callback->($dirs, $nondirs)
180	aio_load $path, $data, $callback->($status)	185	aio_load $pathname, $data, $callback->($status)
181	aio_copy $srcpath, $dstpath, $callback->($status)	186	aio_copy $srcpath, $dstpath, $callback->($status)
182	aio_move $srcpath, $dstpath, $callback->($status)	187	aio_move $srcpath, $dstpath, $callback->($status)
183	aio_scandir $path, $maxreq, $callback->($dirs, $nondirs)
184	aio_rmtree $path, $callback->($status)	188	aio_rmtree $pathname, $callback->($status)
185	aio_sync $callback->($status)	189	aio_sync $callback->($status)
		190	aio_syncfs $fh, $callback->($status)
186	aio_fsync $fh, $callback->($status)	191	aio_fsync $fh, $callback->($status)
187	aio_fdatasync $fh, $callback->($status)	192	aio_fdatasync $fh, $callback->($status)
188	aio_sync_file_range $fh, $offset, $nbytes, $flags, $callback->($status)	193	aio_sync_file_range $fh, $offset, $nbytes, $flags, $callback->($status)
189	aio_pathsync $path, $callback->($status)	194	aio_pathsync $pathname, $callback->($status)
190	aio_msync $scalar, $offset = 0, $length = undef, flags = 0, $callback->($status)	195	aio_msync $scalar, $offset = 0, $length = undef, flags = 0, $callback->($status)
191	aio_mtouch $scalar, $offset = 0, $length = undef, flags = 0, $callback->($status)	196	aio_mtouch $scalar, $offset = 0, $length = undef, flags = 0, $callback->($status)
192	aio_mlock $scalar, $offset = 0, $length = undef, $callback->($status)	197	aio_mlock $scalar, $offset = 0, $length = undef, $callback->($status)
193	aio_mlockall $flags, $callback->($status)	198	aio_mlockall $flags, $callback->($status)
194	aio_group $callback->(...)	199	aio_group $callback->(...)
…		…
204	IO::AIO::max_poll_reqs $nreqs	209	IO::AIO::max_poll_reqs $nreqs
205	IO::AIO::max_poll_time $seconds	210	IO::AIO::max_poll_time $seconds
206	IO::AIO::min_parallel $nthreads	211	IO::AIO::min_parallel $nthreads
207	IO::AIO::max_parallel $nthreads	212	IO::AIO::max_parallel $nthreads
208	IO::AIO::max_idle $nthreads	213	IO::AIO::max_idle $nthreads
		214	IO::AIO::idle_timeout $seconds
209	IO::AIO::max_outstanding $maxreqs	215	IO::AIO::max_outstanding $maxreqs
210	IO::AIO::nreqs	216	IO::AIO::nreqs
211	IO::AIO::nready	217	IO::AIO::nready
212	IO::AIO::npending	218	IO::AIO::npending
213		219
214	IO::AIO::sendfile $ofh, $ifh, $offset, $count	220	IO::AIO::sendfile $ofh, $ifh, $offset, $count
215	IO::AIO::fadvise $fh, $offset, $len, $advice	221	IO::AIO::fadvise $fh, $offset, $len, $advice
		222	IO::AIO::mmap $scalar, $length, $prot, $flags[, $fh[, $offset]]
		223	IO::AIO::munmap $scalar
216	IO::AIO::madvise $scalar, $offset, $length, $advice	224	IO::AIO::madvise $scalar, $offset, $length, $advice
217	IO::AIO::mprotect $scalar, $offset, $length, $protect	225	IO::AIO::mprotect $scalar, $offset, $length, $protect
218	IO::AIO::munlock $scalar, $offset = 0, $length = undef	226	IO::AIO::munlock $scalar, $offset = 0, $length = undef
219	IO::AIO::munlockall	227	IO::AIO::munlockall
220		228
221	AIO REQUEST FUNCTIONS	229	API NOTES
222	All the "aio_*" calls are more or less thin wrappers around the syscall	230	All the "aio_*" calls are more or less thin wrappers around the syscall
223	with the same name (sans "aio_"). The arguments are similar or	231	with the same name (sans "aio_"). The arguments are similar or
224	identical, and they all accept an additional (and optional) $callback	232	identical, and they all accept an additional (and optional) $callback
225	argument which must be a code reference. This code reference will get	233	argument which must be a code reference. This code reference will be
226	called with the syscall return code (e.g. most syscalls return -1 on
227	error, unlike perl, which usually delivers "false") as its sole argument
228	after the given syscall has been executed asynchronously.	234	called after the syscall has been executed in an asynchronous fashion.
		235	The results of the request will be passed as arguments to the callback
		236	(and, if an error occured, in $!) - for most requests the syscall return
		237	code (e.g. most syscalls return -1 on error, unlike perl, which usually
		238	delivers "false").
		239
		240	Some requests (such as "aio_readdir") pass the actual results and
		241	communicate failures by passing "undef".
229		242
230	All functions expecting a filehandle keep a copy of the filehandle	243	All functions expecting a filehandle keep a copy of the filehandle
231	internally until the request has finished.	244	internally until the request has finished.
232		245
233	All functions return request objects of type IO::AIO::REQ that allow	246	All functions return request objects of type IO::AIO::REQ that allow
234	further manipulation of those requests while they are in-flight.	247	further manipulation of those requests while they are in-flight.
235		248
236	The pathnames you pass to these routines must be absolute and encoded	249	The pathnames you pass to these routines should be absolute. The
237	as octets. The reason for the former is that at the time the request is	250	reason for this is that at the time the request is being executed, the
238	being executed, the current working directory could have changed.	251	current working directory could have changed. Alternatively, you can
239	Alternatively, you can make sure that you never change the current	252	make sure that you never change the current working directory anywhere
240	working directory anywhere in the program and then use relative paths.	253	in the program and then use relative paths. You can also take advantage
		254	of IO::AIOs working directory abstraction, that lets you specify paths
		255	relative to some previously-opened "working directory object" - see the
		256	description of the "IO::AIO::WD" class later in this document.
241		257
242	To encode pathnames as octets, either make sure you either: a) always	258	To encode pathnames as octets, either make sure you either: a) always
243	pass in filenames you got from outside (command line, readdir etc.)	259	pass in filenames you got from outside (command line, readdir etc.)
244	without tinkering, b) are ASCII or ISO 8859-1, c) use the Encode module	260	without tinkering, b) are in your native filesystem encoding, c) use the
245	and encode your pathnames to the locale (or other) encoding in effect in	261	Encode module and encode your pathnames to the locale (or other)
246	the user environment, d) use Glib::filename_from_unicode on unicode	262	encoding in effect in the user environment, d) use
247	filenames or e) use something else to ensure your scalar has the correct	263	Glib::filename_from_unicode on unicode filenames or e) use something
248	contents.	264	else to ensure your scalar has the correct contents.
249		265
250	This works, btw. independent of the internal UTF-8 bit, which IO::AIO	266	This works, btw. independent of the internal UTF-8 bit, which IO::AIO
251	handles correctly whether it is set or not.	267	handles correctly whether it is set or not.
252		268
		269	AIO REQUEST FUNCTIONS
253	$prev_pri = aioreq_pri [$pri]	270	$prev_pri = aioreq_pri [$pri]
254	Returns the priority value that would be used for the next request	271	Returns the priority value that would be used for the next request
255	and, if $pri is given, sets the priority for the next aio request.	272	and, if $pri is given, sets the priority for the next aio request.
256		273
257	The default priority is 0, the minimum and maximum priorities are -4	274	The default priority is 0, the minimum and maximum priorities are -4
…		…
279	Similar to "aioreq_pri", but subtracts the given value from the	296	Similar to "aioreq_pri", but subtracts the given value from the
280	current priority, so the effect is cumulative.	297	current priority, so the effect is cumulative.
281		298
282	aio_open $pathname, $flags, $mode, $callback->($fh)	299	aio_open $pathname, $flags, $mode, $callback->($fh)
283	Asynchronously open or create a file and call the callback with a	300	Asynchronously open or create a file and call the callback with a
284	newly created filehandle for the file.	301	newly created filehandle for the file (or "undef" in case of an
		302	error).
285		303
286	The pathname passed to "aio_open" must be absolute. See API NOTES,	304	The pathname passed to "aio_open" must be absolute. See API NOTES,
287	above, for an explanation.	305	above, for an explanation.
288		306
289	The $flags argument is a bitmask. See the "Fcntl" module for a list.	307	The $flags argument is a bitmask. See the "Fcntl" module for a list.
…		…
305	} else {	323	} else {
306	die "open failed: $!\n";	324	die "open failed: $!\n";
307	}	325	}
308	};	326	};
309		327
		328	In addition to all the common open modes/flags ("O_RDONLY",
		329	"O_WRONLY", "O_RDWR", "O_CREAT", "O_TRUNC", "O_EXCL" and
		330	"O_APPEND"), the following POSIX and non-POSIX constants are
		331	available (missing ones on your system are, as usual, 0):
		332
		333	"O_ASYNC", "O_DIRECT", "O_NOATIME", "O_CLOEXEC", "O_NOCTTY",
		334	"O_NOFOLLOW", "O_NONBLOCK", "O_EXEC", "O_SEARCH", "O_DIRECTORY",
		335	"O_DSYNC", "O_RSYNC", "O_SYNC", "O_PATH", "O_TMPFILE", and
		336	"O_TTY_INIT".
		337
310	aio_close $fh, $callback->($status)	338	aio_close $fh, $callback->($status)
311	Asynchronously close a file and call the callback with the result	339	Asynchronously close a file and call the callback with the result
312	code.	340	code.
313		341
314	Unfortunately, you can't do this to perl. Perl insists very	342	Unfortunately, you can't do this to perl. Perl insists very
…		…
319	will use dup2 to overwrite the file descriptor with the write-end of	347	will use dup2 to overwrite the file descriptor with the write-end of
320	a pipe (the pipe fd will be created on demand and will be cached).	348	a pipe (the pipe fd will be created on demand and will be cached).
321		349
322	Or in other words: the file descriptor will be closed, but it will	350	Or in other words: the file descriptor will be closed, but it will
323	not be free for reuse until the perl filehandle is closed.	351	not be free for reuse until the perl filehandle is closed.
		352
		353	aio_seek $fh, $offset, $whence, $callback->($offs)
		354	Seeks the filehandle to the new $offset, similarly to perl's
		355	"sysseek". The $whence can use the traditional values (0 for
		356	"IO::AIO::SEEK_SET", 1 for "IO::AIO::SEEK_CUR" or 2 for
		357	"IO::AIO::SEEK_END").
		358
		359	The resulting absolute offset will be passed to the callback, or -1
		360	in case of an error.
		361
		362	In theory, the $whence constants could be different than the
		363	corresponding values from Fcntl, but perl guarantees they are the
		364	same, so don't panic.
		365
		366	As a GNU/Linux (and maybe Solaris) extension, also the constants
		367	"IO::AIO::SEEK_DATA" and "IO::AIO::SEEK_HOLE" are available, if they
		368	could be found. No guarantees about suitability for use in
		369	"aio_seek" or Perl's "sysseek" can be made though, although I would
		370	naively assume they "just work".
324		371
325	aio_read $fh,$offset,$length, $data,$dataoffset, $callback->($retval)	372	aio_read $fh,$offset,$length, $data,$dataoffset, $callback->($retval)
326	aio_write $fh,$offset,$length, $data,$dataoffset, $callback->($retval)	373	aio_write $fh,$offset,$length, $data,$dataoffset, $callback->($retval)
327	Reads or writes $length bytes from or to the specified $fh and	374	Reads or writes $length bytes from or to the specified $fh and
328	$offset into the scalar given by $data and offset $dataoffset and	375	$offset into the scalar given by $data and offset $dataoffset and
…		…
357	aio_sendfile $out_fh, $in_fh, $in_offset, $length, $callback->($retval)	404	aio_sendfile $out_fh, $in_fh, $in_offset, $length, $callback->($retval)
358	Tries to copy $length bytes from $in_fh to $out_fh. It starts	405	Tries to copy $length bytes from $in_fh to $out_fh. It starts
359	reading at byte offset $in_offset, and starts writing at the current	406	reading at byte offset $in_offset, and starts writing at the current
360	file offset of $out_fh. Because of that, it is not safe to issue	407	file offset of $out_fh. Because of that, it is not safe to issue
361	more than one "aio_sendfile" per $out_fh, as they will interfere	408	more than one "aio_sendfile" per $out_fh, as they will interfere
362	with each other.	409	with each other. The same $in_fh works fine though, as this function
		410	does not move or use the file offset of $in_fh.
363		411
364	Please note that "aio_sendfile" can read more bytes from $in_fh than	412	Please note that "aio_sendfile" can read more bytes from $in_fh than
365	are written, and there is no way to find out how many bytes have	413	are written, and there is no way to find out how many more bytes
366	been read from "aio_sendfile" alone, as "aio_sendfile" only provides	414	have been read from "aio_sendfile" alone, as "aio_sendfile" only
367	the number of bytes written to $out_fh. Only if the result value	415	provides the number of bytes written to $out_fh. Only if the result
368	equals $length one can assume that $length bytes have been read.	416	value equals $length one can assume that $length bytes have been
		417	read.
369		418
370	Unlike with other "aio_" functions, it makes a lot of sense to use	419	Unlike with other "aio_" functions, it makes a lot of sense to use
371	"aio_sendfile" on non-blocking sockets, as long as one end	420	"aio_sendfile" on non-blocking sockets, as long as one end
372	(typically the $in_fh) is a file - the file I/O will then be	421	(typically the $in_fh) is a file - the file I/O will then be
373	asynchronous, while the socket I/O will be non-blocking. Note,	422	asynchronous, while the socket I/O will be non-blocking. Note,
374	however, that you can run into a trap where "aio_sendfile" reads	423	however, that you can run into a trap where "aio_sendfile" reads
375	some data with readahead, then fails to write all data, and when the	424	some data with readahead, then fails to write all data, and when the
376	socket is ready the next time, the data in the cache is already	425	socket is ready the next time, the data in the cache is already
377	lost, forcing "aio_sendfile" to again hit the disk. Explicit	426	lost, forcing "aio_sendfile" to again hit the disk. Explicit
378	"aio_read" + "aio_write" let's you control resource usage much	427	"aio_read" + "aio_write" let's you better control resource usage.
379	better.
380		428
381	This call tries to make use of a native "sendfile" syscall to	429	This call tries to make use of a native "sendfile"-like syscall to
382	provide zero-copy operation. For this to work, $out_fh should refer	430	provide zero-copy operation. For this to work, $out_fh should refer
383	to a socket, and $in_fh should refer to an mmap'able file.	431	to a socket, and $in_fh should refer to an mmap'able file.
384		432
385	If a native sendfile cannot be found or it fails with "ENOSYS",	433	If a native sendfile cannot be found or it fails with "ENOSYS",
386	"ENOTSUP", "EOPNOTSUPP", "EAFNOSUPPORT", "EPROTOTYPE" or "ENOTSOCK",	434	"EINVAL", "ENOTSUP", "EOPNOTSUPP", "EAFNOSUPPORT", "EPROTOTYPE" or
387	it will be emulated, so you can call "aio_sendfile" on any type of	435	"ENOTSOCK", it will be emulated, so you can call "aio_sendfile" on
388	filehandle regardless of the limitations of the operating system.	436	any type of filehandle regardless of the limitations of the
		437	operating system.
		438
		439	As native sendfile syscalls (as practically any non-POSIX interface
		440	hacked together in a hurry to improve benchmark numbers) tend to be
		441	rather buggy on many systems, this implementation tries to work
		442	around some known bugs in Linux and FreeBSD kernels (probably
		443	others, too), but that might fail, so you really really should check
		444	the return value of "aio_sendfile" - fewre bytes than expected might
		445	have been transferred.
389		446
390	aio_readahead $fh,$offset,$length, $callback->($retval)	447	aio_readahead $fh,$offset,$length, $callback->($retval)
391	"aio_readahead" populates the page cache with data from a file so	448	"aio_readahead" populates the page cache with data from a file so
392	that subsequent reads from that file will not block on disk I/O. The	449	that subsequent reads from that file will not block on disk I/O. The
393	$offset argument specifies the starting point from which data is to	450	$offset argument specifies the starting point from which data is to
…		…
413		470
414	Currently, the stats are always 64-bit-stats, i.e. instead of	471	Currently, the stats are always 64-bit-stats, i.e. instead of
415	returning an error when stat'ing a large file, the results will be	472	returning an error when stat'ing a large file, the results will be
416	silently truncated unless perl itself is compiled with large file	473	silently truncated unless perl itself is compiled with large file
417	support.	474	support.
		475
		476	To help interpret the mode and dev/rdev stat values, IO::AIO offers
		477	the following constants and functions (if not implemented, the
		478	constants will be 0 and the functions will either "croak" or fall
		479	back on traditional behaviour).
		480
		481	"S_IFMT", "S_IFIFO", "S_IFCHR", "S_IFBLK", "S_IFLNK", "S_IFREG",
		482	"S_IFDIR", "S_IFWHT", "S_IFSOCK", "IO::AIO::major $dev_t",
		483	"IO::AIO::minor $dev_t", "IO::AIO::makedev $major, $minor".
418		484
419	Example: Print the length of /etc/passwd:	485	Example: Print the length of /etc/passwd:
420		486
421	aio_stat "/etc/passwd", sub {	487	aio_stat "/etc/passwd", sub {
422	$_[0] and die "stat failed: $!";	488	$_[0] and die "stat failed: $!";
…		…
464	namemax => 255,	530	namemax => 255,
465	frsize => 1024,	531	frsize => 1024,
466	fsid => 1810	532	fsid => 1810
467	}	533	}
468		534
		535	Here is a (likely partial - send me updates!) list of fsid values
		536	used by Linux - it is safe to hardcode these when $^O is "linux":
		537
		538	0x0000adf5 adfs
		539	0x0000adff affs
		540	0x5346414f afs
		541	0x09041934 anon-inode filesystem
		542	0x00000187 autofs
		543	0x42465331 befs
		544	0x1badface bfs
		545	0x42494e4d binfmt_misc
		546	0x9123683e btrfs
		547	0x0027e0eb cgroupfs
		548	0xff534d42 cifs
		549	0x73757245 coda
		550	0x012ff7b7 coh
		551	0x28cd3d45 cramfs
		552	0x453dcd28 cramfs-wend (wrong endianness)
		553	0x64626720 debugfs
		554	0x00001373 devfs
		555	0x00001cd1 devpts
		556	0x0000f15f ecryptfs
		557	0x00414a53 efs
		558	0x0000137d ext
		559	0x0000ef53 ext2/ext3/ext4
		560	0x0000ef51 ext2
		561	0xf2f52010 f2fs
		562	0x00004006 fat
		563	0x65735546 fuseblk
		564	0x65735543 fusectl
		565	0x0bad1dea futexfs
		566	0x01161970 gfs2
		567	0x47504653 gpfs
		568	0x00004244 hfs
		569	0xf995e849 hpfs
		570	0x00c0ffee hostfs
		571	0x958458f6 hugetlbfs
		572	0x2bad1dea inotifyfs
		573	0x00009660 isofs
		574	0x000072b6 jffs2
		575	0x3153464a jfs
		576	0x6b414653 k-afs
		577	0x0bd00bd0 lustre
		578	0x0000137f minix
		579	0x0000138f minix 30 char names
		580	0x00002468 minix v2
		581	0x00002478 minix v2 30 char names
		582	0x00004d5a minix v3
		583	0x19800202 mqueue
		584	0x00004d44 msdos
		585	0x0000564c novell
		586	0x00006969 nfs
		587	0x6e667364 nfsd
		588	0x00003434 nilfs
		589	0x5346544e ntfs
		590	0x00009fa1 openprom
		591	0x7461636F ocfs2
		592	0x00009fa0 proc
		593	0x6165676c pstorefs
		594	0x0000002f qnx4
		595	0x68191122 qnx6
		596	0x858458f6 ramfs
		597	0x52654973 reiserfs
		598	0x00007275 romfs
		599	0x67596969 rpc_pipefs
		600	0x73636673 securityfs
		601	0xf97cff8c selinux
		602	0x0000517b smb
		603	0x534f434b sockfs
		604	0x73717368 squashfs
		605	0x62656572 sysfs
		606	0x012ff7b6 sysv2
		607	0x012ff7b5 sysv4
		608	0x01021994 tmpfs
		609	0x15013346 udf
		610	0x00011954 ufs
		611	0x54190100 ufs byteswapped
		612	0x00009fa2 usbdevfs
		613	0x01021997 v9fs
		614	0xa501fcf5 vxfs
		615	0xabba1974 xenfs
		616	0x012ff7b4 xenix
		617	0x58465342 xfs
		618	0x012fd16d xia
		619
469	aio_utime $fh_or_path, $atime, $mtime, $callback->($status)	620	aio_utime $fh_or_path, $atime, $mtime, $callback->($status)
470	Works like perl's "utime" function (including the special case of	621	Works like perl's "utime" function (including the special case of
471	$atime and $mtime being undef). Fractional times are supported if	622	$atime and $mtime being undef). Fractional times are supported if
472	the underlying syscalls support them.	623	the underlying syscalls support them.
473		624
…		…
495	aio_chown "path", 0, undef;	646	aio_chown "path", 0, undef;
496		647
497	aio_truncate $fh_or_path, $offset, $callback->($status)	648	aio_truncate $fh_or_path, $offset, $callback->($status)
498	Works like truncate(2) or ftruncate(2).	649	Works like truncate(2) or ftruncate(2).
499		650
		651	aio_allocate $fh, $mode, $offset, $len, $callback->($status)
		652	Allocates or frees disk space according to the $mode argument. See
		653	the linux "fallocate" documentation for details.
		654
		655	$mode is usually 0 or "IO::AIO::FALLOC_FL_KEEP_SIZE" to allocate
		656	space, or "IO::AIO::FALLOC_FL_PUNCH_HOLE \|
		657	IO::AIO::FALLOC_FL_KEEP_SIZE", to deallocate a file range.
		658
		659	IO::AIO also supports "FALLOC_FL_COLLAPSE_RANGE", to remove a range
		660	(without leaving a hole) and "FALLOC_FL_ZERO_RANGE", to zero a range
		661	(see your fallocate(2) manpage).
		662
		663	The file system block size used by "fallocate" is presumably the
		664	"f_bsize" returned by "statvfs".
		665
		666	If "fallocate" isn't available or cannot be emulated (currently no
		667	emulation will be attempted), passes -1 and sets $! to "ENOSYS".
		668
500	aio_chmod $fh_or_path, $mode, $callback->($status)	669	aio_chmod $fh_or_path, $mode, $callback->($status)
501	Works like perl's "chmod" function.	670	Works like perl's "chmod" function.
502		671
503	aio_unlink $pathname, $callback->($status)	672	aio_unlink $pathname, $callback->($status)
504	Asynchronously unlink (delete) a file and call the callback with the	673	Asynchronously unlink (delete) a file and call the callback with the
505	result code.	674	result code.
506		675
507	aio_mknod $path, $mode, $dev, $callback->($status)	676	aio_mknod $pathname, $mode, $dev, $callback->($status)
508	[EXPERIMENTAL]	677	[EXPERIMENTAL]
509		678
510	Asynchronously create a device node (or fifo). See mknod(2).	679	Asynchronously create a device node (or fifo). See mknod(2).
511		680
512	The only (POSIX-) portable way of calling this function is:	681	The only (POSIX-) portable way of calling this function is:
513		682
514	aio_mknod $path, IO::AIO::S_IFIFO \| $mode, 0, sub { ...	683	aio_mknod $pathname, IO::AIO::S_IFIFO \| $mode, 0, sub { ...
		684
		685	See "aio_stat" for info about some potentially helpful extra
		686	constants and functions.
515		687
516	aio_link $srcpath, $dstpath, $callback->($status)	688	aio_link $srcpath, $dstpath, $callback->($status)
517	Asynchronously create a new link to the existing object at $srcpath	689	Asynchronously create a new link to the existing object at $srcpath
518	at the path $dstpath and call the callback with the result code.	690	at the path $dstpath and call the callback with the result code.
519		691
520	aio_symlink $srcpath, $dstpath, $callback->($status)	692	aio_symlink $srcpath, $dstpath, $callback->($status)
521	Asynchronously create a new symbolic link to the existing object at	693	Asynchronously create a new symbolic link to the existing object at
522	$srcpath at the path $dstpath and call the callback with the result	694	$srcpath at the path $dstpath and call the callback with the result
523	code.	695	code.
524		696
525	aio_readlink $path, $callback->($link)	697	aio_readlink $pathname, $callback->($link)
526	Asynchronously read the symlink specified by $path and pass it to	698	Asynchronously read the symlink specified by $path and pass it to
527	the callback. If an error occurs, nothing or undef gets passed to	699	the callback. If an error occurs, nothing or undef gets passed to
528	the callback.	700	the callback.
529		701
		702	aio_realpath $pathname, $callback->($path)
		703	Asynchronously make the path absolute and resolve any symlinks in
		704	$path. The resulting path only consists of directories (same as
		705	Cwd::realpath).
		706
		707	This request can be used to get the absolute path of the current
		708	working directory by passing it a path of . (a single dot).
		709
530	aio_rename $srcpath, $dstpath, $callback->($status)	710	aio_rename $srcpath, $dstpath, $callback->($status)
531	Asynchronously rename the object at $srcpath to $dstpath, just as	711	Asynchronously rename the object at $srcpath to $dstpath, just as
532	rename(2) and call the callback with the result code.	712	rename(2) and call the callback with the result code.
		713
		714	On systems that support the AIO::WD working directory abstraction
		715	natively, the case "[$wd, "."]" as $srcpath is specialcased -
		716	instead of failing, "rename" is called on the absolute path of $wd.
533		717
534	aio_mkdir $pathname, $mode, $callback->($status)	718	aio_mkdir $pathname, $mode, $callback->($status)
535	Asynchronously mkdir (create) a directory and call the callback with	719	Asynchronously mkdir (create) a directory and call the callback with
536	the result code. $mode will be modified by the umask at the time the	720	the result code. $mode will be modified by the umask at the time the
537	request is executed, so do not change your umask.	721	request is executed, so do not change your umask.
538		722
539	aio_rmdir $pathname, $callback->($status)	723	aio_rmdir $pathname, $callback->($status)
540	Asynchronously rmdir (delete) a directory and call the callback with	724	Asynchronously rmdir (delete) a directory and call the callback with
541	the result code.	725	the result code.
542		726
		727	On systems that support the AIO::WD working directory abstraction
		728	natively, the case "[$wd, "."]" is specialcased - instead of
		729	failing, "rmdir" is called on the absolute path of $wd.
		730
543	aio_readdir $pathname, $callback->($entries)	731	aio_readdir $pathname, $callback->($entries)
544	Unlike the POSIX call of the same name, "aio_readdir" reads an	732	Unlike the POSIX call of the same name, "aio_readdir" reads an
545	entire directory (i.e. opendir + readdir + closedir). The entries	733	entire directory (i.e. opendir + readdir + closedir). The entries
546	will not be sorted, and will NOT include the "." and ".." entries.	734	will not be sorted, and will NOT include the "." and ".." entries.
547		735
548	The callback is passed a single argument which is either "undef" or	736	The callback is passed a single argument which is either "undef" or
549	an array-ref with the filenames.	737	an array-ref with the filenames.
550		738
551	aio_readdirx $pathname, $flags, $callback->($entries, $flags)	739	aio_readdirx $pathname, $flags, $callback->($entries, $flags)
552	Quite similar to "aio_readdir", but the $flags argument allows to	740	Quite similar to "aio_readdir", but the $flags argument allows one
553	tune behaviour and output format. In case of an error, $entries will	741	to tune behaviour and output format. In case of an error, $entries
554	be "undef".	742	will be "undef".
555		743
556	The flags are a combination of the following constants, ORed	744	The flags are a combination of the following constants, ORed
557	together (the flags will also be passed to the callback, possibly	745	together (the flags will also be passed to the callback, possibly
558	modified):	746	modified):
559		747
560	IO::AIO::READDIR_DENTS	748	IO::AIO::READDIR_DENTS
561	When this flag is off, then the callback gets an arrayref with	749	When this flag is off, then the callback gets an arrayref
562	of names only (as with "aio_readdir"), otherwise it gets an	750	consisting of names only (as with "aio_readdir"), otherwise it
563	arrayref with "[$name, $type, $inode]" arrayrefs, each	751	gets an arrayref with "[$name, $type, $inode]" arrayrefs, each
564	describing a single directory entry in more detail.	752	describing a single directory entry in more detail.
565		753
566	$name is the name of the entry.	754	$name is the name of the entry.
567		755
568	$type is one of the "IO::AIO::DT_xxx" constants:	756	$type is one of the "IO::AIO::DT_xxx" constants:
…		…
581	unspecified content on systems that do not deliver the inode	769	unspecified content on systems that do not deliver the inode
582	information.	770	information.
583		771
584	IO::AIO::READDIR_DIRS_FIRST	772	IO::AIO::READDIR_DIRS_FIRST
585	When this flag is set, then the names will be returned in an	773	When this flag is set, then the names will be returned in an
586	order where likely directories come first. This is useful when	774	order where likely directories come first, in optimal stat
587	you need to quickly find directories, or you want to find all	775	order. This is useful when you need to quickly find directories,
588	directories while avoiding to stat() each entry.	776	or you want to find all directories while avoiding to stat()
		777	each entry.
589		778
590	If the system returns type information in readdir, then this is	779	If the system returns type information in readdir, then this is
591	used to find directories directly. Otherwise, likely directories	780	used to find directories directly. Otherwise, likely directories
592	are files beginning with ".", or otherwise files with no dots,	781	are names beginning with ".", or otherwise names with no dots,
593	of which files with short names are tried first.	782	of which names with short names are tried first.
594		783
595	IO::AIO::READDIR_STAT_ORDER	784	IO::AIO::READDIR_STAT_ORDER
596	When this flag is set, then the names will be returned in an	785	When this flag is set, then the names will be returned in an
597	order suitable for stat()'ing each one. That is, when you plan	786	order suitable for stat()'ing each one. That is, when you plan
598	to stat() all files in the given directory, then the returned	787	to stat() all files in the given directory, then the returned
…		…
603	optimal stat order.	792	optimal stat order.
604		793
605	IO::AIO::READDIR_FOUND_UNKNOWN	794	IO::AIO::READDIR_FOUND_UNKNOWN
606	This flag should not be set when calling "aio_readdirx".	795	This flag should not be set when calling "aio_readdirx".
607	Instead, it is being set by "aio_readdirx", when any of the	796	Instead, it is being set by "aio_readdirx", when any of the
608	$type's found were "IO::AIO::DT_UNKNOWN". The absense of this	797	$type's found were "IO::AIO::DT_UNKNOWN". The absence of this
609	flag therefore indicates that all $type's are known, which can	798	flag therefore indicates that all $type's are known, which can
610	be used to speed up some algorithms.	799	be used to speed up some algorithms.
611		800
612	aio_load $path, $data, $callback->($status)	801	aio_load $pathname, $data, $callback->($status)
613	This is a composite request that tries to fully load the given file	802	This is a composite request that tries to fully load the given file
614	into memory. Status is the same as with aio_read.	803	into memory. Status is the same as with aio_read.
615		804
616	aio_copy $srcpath, $dstpath, $callback->($status)	805	aio_copy $srcpath, $dstpath, $callback->($status)
617	Try to copy the file (directories not supported as either source	806	Try to copy the file (directories not supported as either source
…		…
634		823
635	This is a composite request that tries to rename(2) the file first;	824	This is a composite request that tries to rename(2) the file first;
636	if rename fails with "EXDEV", it copies the file with "aio_copy"	825	if rename fails with "EXDEV", it copies the file with "aio_copy"
637	and, if that is successful, unlinks the $srcpath.	826	and, if that is successful, unlinks the $srcpath.
638		827
639	aio_scandir $path, $maxreq, $callback->($dirs, $nondirs)	828	aio_scandir $pathname, $maxreq, $callback->($dirs, $nondirs)
640	Scans a directory (similar to "aio_readdir") but additionally tries	829	Scans a directory (similar to "aio_readdir") but additionally tries
641	to efficiently separate the entries of directory $path into two sets	830	to efficiently separate the entries of directory $path into two sets
642	of names, directories you can recurse into (directories), and ones	831	of names, directories you can recurse into (directories), and ones
643	you cannot recurse into (everything else, including symlinks to	832	you cannot recurse into (everything else, including symlinks to
644	directories).	833	directories).
…		…
677	Then entries will be sorted into likely directories a non-initial	866	Then entries will be sorted into likely directories a non-initial
678	dot currently) and likely non-directories (see "aio_readdirx"). Then	867	dot currently) and likely non-directories (see "aio_readdirx"). Then
679	every entry plus an appended "/." will be "stat"'ed, likely	868	every entry plus an appended "/." will be "stat"'ed, likely
680	directories first, in order of their inode numbers. If that	869	directories first, in order of their inode numbers. If that
681	succeeds, it assumes that the entry is a directory or a symlink to	870	succeeds, it assumes that the entry is a directory or a symlink to
682	directory (which will be checked seperately). This is often faster	871	directory (which will be checked separately). This is often faster
683	than stat'ing the entry itself because filesystems might detect the	872	than stat'ing the entry itself because filesystems might detect the
684	type of the entry without reading the inode data (e.g. ext2fs	873	type of the entry without reading the inode data (e.g. ext2fs
685	filetype feature), even on systems that cannot return the filetype	874	filetype feature), even on systems that cannot return the filetype
686	information on readdir.	875	information on readdir.
687		876
…		…
693		882
694	It will also likely work on non-POSIX filesystems with reduced	883	It will also likely work on non-POSIX filesystems with reduced
695	efficiency as those tend to return 0 or 1 as link counts, which	884	efficiency as those tend to return 0 or 1 as link counts, which
696	disables the directory counting heuristic.	885	disables the directory counting heuristic.
697		886
698	aio_rmtree $path, $callback->($status)	887	aio_rmtree $pathname, $callback->($status)
699	Delete a directory tree starting (and including) $path, return the	888	Delete a directory tree starting (and including) $path, return the
700	status of the final "rmdir" only. This is a composite request that	889	status of the final "rmdir" only. This is a composite request that
701	uses "aio_scandir" to recurse into and rmdir directories, and unlink	890	uses "aio_scandir" to recurse into and rmdir directories, and unlink
702	everything else.	891	everything else.
703		892
…		…
712	Asynchronously call fdatasync on the given filehandle and call the	901	Asynchronously call fdatasync on the given filehandle and call the
713	callback with the fdatasync result code.	902	callback with the fdatasync result code.
714		903
715	If this call isn't available because your OS lacks it or it couldn't	904	If this call isn't available because your OS lacks it or it couldn't
716	be detected, it will be emulated by calling "fsync" instead.	905	be detected, it will be emulated by calling "fsync" instead.
		906
		907	aio_syncfs $fh, $callback->($status)
		908	Asynchronously call the syncfs syscall to sync the filesystem
		909	associated to the given filehandle and call the callback with the
		910	syncfs result code. If syncfs is not available, calls sync(), but
		911	returns -1 and sets errno to "ENOSYS" nevertheless.
717		912
718	aio_sync_file_range $fh, $offset, $nbytes, $flags, $callback->($status)	913	aio_sync_file_range $fh, $offset, $nbytes, $flags, $callback->($status)
719	Sync the data portion of the file specified by $offset and $length	914	Sync the data portion of the file specified by $offset and $length
720	to disk (but NOT the metadata), by calling the Linux-specific	915	to disk (but NOT the metadata), by calling the Linux-specific
721	sync_file_range call. If sync_file_range is not available or it	916	sync_file_range call. If sync_file_range is not available or it
…		…
725	"IO::AIO::SYNC_FILE_RANGE_WAIT_BEFORE",	920	"IO::AIO::SYNC_FILE_RANGE_WAIT_BEFORE",
726	"IO::AIO::SYNC_FILE_RANGE_WRITE" and	921	"IO::AIO::SYNC_FILE_RANGE_WRITE" and
727	"IO::AIO::SYNC_FILE_RANGE_WAIT_AFTER": refer to the sync_file_range	922	"IO::AIO::SYNC_FILE_RANGE_WAIT_AFTER": refer to the sync_file_range
728	manpage for details.	923	manpage for details.
729		924
730	aio_pathsync $path, $callback->($status)	925	aio_pathsync $pathname, $callback->($status)
731	This request tries to open, fsync and close the given path. This is	926	This request tries to open, fsync and close the given path. This is
732	a composite request intended to sync directories after directory	927	a composite request intended to sync directories after directory
733	operations (E.g. rename). This might not work on all operating	928	operations (E.g. rename). This might not work on all operating
734	systems or have any specific effect, but usually it makes sure that	929	systems or have any specific effect, but usually it makes sure that
735	directory changes get written to disc. It works for anything that	930	directory changes get written to disc. It works for anything that
…		…
762		957
763	It touches (reads or writes) all memory pages in the specified range	958	It touches (reads or writes) all memory pages in the specified range
764	inside the scalar. All caveats and parameters are the same as for	959	inside the scalar. All caveats and parameters are the same as for
765	"aio_msync", above, except for flags, which must be either 0 (which	960	"aio_msync", above, except for flags, which must be either 0 (which
766	reads all pages and ensures they are instantiated) or	961	reads all pages and ensures they are instantiated) or
767	"IO::AIO::MT_MODIFY", which modifies the memory page s(by reading	962	"IO::AIO::MT_MODIFY", which modifies the memory pages (by reading
768	and writing an octet from it, which dirties the page).	963	and writing an octet from it, which dirties the page).
769		964
770	aio_mlock $scalar, $offset = 0, $length = undef, $callback->($status)	965	aio_mlock $scalar, $offset = 0, $length = undef, $callback->($status)
771	This is a rather advanced IO::AIO call, which works best on	966	This is a rather advanced IO::AIO call, which works best on
772	mmap(2)ed scalars.	967	mmap(2)ed scalars.
…		…
804		999
805	Example: asynchronously lock all current and future pages into	1000	Example: asynchronously lock all current and future pages into
806	memory.	1001	memory.
807		1002
808	aio_mlockall IO::AIO::MCL_FUTURE;	1003	aio_mlockall IO::AIO::MCL_FUTURE;
		1004
		1005	aio_fiemap $fh, $start, $length, $flags, $count, $cb->(\@extents)
		1006	Queries the extents of the given file (by calling the Linux "FIEMAP"
		1007	ioctl, see <http://cvs.schmorp.de/IO-AIO/doc/fiemap.txt> for
		1008	details). If the ioctl is not available on your OS, then this
		1009	request will fail with "ENOSYS".
		1010
		1011	$start is the starting offset to query extents for, $length is the
		1012	size of the range to query - if it is "undef", then the whole file
		1013	will be queried.
		1014
		1015	$flags is a combination of flags ("IO::AIO::FIEMAP_FLAG_SYNC" or
		1016	"IO::AIO::FIEMAP_FLAG_XATTR" - "IO::AIO::FIEMAP_FLAGS_COMPAT" is
		1017	also exported), and is normally 0 or "IO::AIO::FIEMAP_FLAG_SYNC" to
		1018	query the data portion.
		1019
		1020	$count is the maximum number of extent records to return. If it is
		1021	"undef", then IO::AIO queries all extents of the range. As a very
		1022	special case, if it is 0, then the callback receives the number of
		1023	extents instead of the extents themselves (which is unreliable, see
		1024	below).
		1025
		1026	If an error occurs, the callback receives no arguments. The special
		1027	"errno" value "IO::AIO::EBADR" is available to test for flag errors.
		1028
		1029	Otherwise, the callback receives an array reference with extent
		1030	structures. Each extent structure is an array reference itself, with
		1031	the following members:
		1032
		1033	[$logical, $physical, $length, $flags]
		1034
		1035	Flags is any combination of the following flag values (typically
		1036	either 0 or "IO::AIO::FIEMAP_EXTENT_LAST" (1)):
		1037
		1038	"IO::AIO::FIEMAP_EXTENT_LAST", "IO::AIO::FIEMAP_EXTENT_UNKNOWN",
		1039	"IO::AIO::FIEMAP_EXTENT_DELALLOC", "IO::AIO::FIEMAP_EXTENT_ENCODED",
		1040	"IO::AIO::FIEMAP_EXTENT_DATA_ENCRYPTED",
		1041	"IO::AIO::FIEMAP_EXTENT_NOT_ALIGNED",
		1042	"IO::AIO::FIEMAP_EXTENT_DATA_INLINE",
		1043	"IO::AIO::FIEMAP_EXTENT_DATA_TAIL",
		1044	"IO::AIO::FIEMAP_EXTENT_UNWRITTEN", "IO::AIO::FIEMAP_EXTENT_MERGED"
		1045	or "IO::AIO::FIEMAP_EXTENT_SHARED".
		1046
		1047	At the time of this writing (Linux 3.2), this requets is unreliable
		1048	unless $count is "undef", as the kernel has all sorts of bugs
		1049	preventing it to return all extents of a range for files with large
		1050	number of extents. The code works around all these issues if $count
		1051	is undef.
809		1052
810	aio_group $callback->(...)	1053	aio_group $callback->(...)
811	This is a very special aio request: Instead of doing something, it	1054	This is a very special aio request: Instead of doing something, it
812	is a container for other aio requests, which is useful if you want	1055	is a container for other aio requests, which is useful if you want
813	to bundle many requests into a single, composite, request with a	1056	to bundle many requests into a single, composite, request with a
…		…
847	While it is theoretically handy to have simple I/O scheduling	1090	While it is theoretically handy to have simple I/O scheduling
848	requests like sleep and file handle readable/writable, the overhead	1091	requests like sleep and file handle readable/writable, the overhead
849	this creates is immense (it blocks a thread for a long time) so do	1092	this creates is immense (it blocks a thread for a long time) so do
850	not use this function except to put your application under	1093	not use this function except to put your application under
851	artificial I/O pressure.	1094	artificial I/O pressure.
		1095
		1096	IO::AIO::WD - multiple working directories
		1097	Your process only has one current working directory, which is used by
		1098	all threads. This makes it hard to use relative paths (some other
		1099	component could call "chdir" at any time, and it is hard to control when
		1100	the path will be used by IO::AIO).
		1101
		1102	One solution for this is to always use absolute paths. This usually
		1103	works, but can be quite slow (the kernel has to walk the whole path on
		1104	every access), and can also be a hassle to implement.
		1105
		1106	Newer POSIX systems have a number of functions (openat, fdopendir,
		1107	futimensat and so on) that make it possible to specify working
		1108	directories per operation.
		1109
		1110	For portability, and because the clowns who "designed", or shall I
		1111	write, perpetrated this new interface were obviously half-drunk, this
		1112	abstraction cannot be perfect, though.
		1113
		1114	IO::AIO allows you to convert directory paths into a so-called
		1115	IO::AIO::WD object. This object stores the canonicalised, absolute
		1116	version of the path, and on systems that allow it, also a directory file
		1117	descriptor.
		1118
		1119	Everywhere where a pathname is accepted by IO::AIO (e.g. in "aio_stat"
		1120	or "aio_unlink"), one can specify an array reference with an IO::AIO::WD
		1121	object and a pathname instead (or the IO::AIO::WD object alone, which
		1122	gets interpreted as "[$wd, "."]"). If the pathname is absolute, the
		1123	IO::AIO::WD object is ignored, otherwise the pathname is resolved
		1124	relative to that IO::AIO::WD object.
		1125
		1126	For example, to get a wd object for /etc and then stat passwd inside,
		1127	you would write:
		1128
		1129	aio_wd "/etc", sub {
		1130	my $etcdir = shift;
		1131
		1132	# although $etcdir can be undef on error, there is generally no reason
		1133	# to check for errors here, as aio_stat will fail with ENOENT
		1134	# when $etcdir is undef.
		1135
		1136	aio_stat [$etcdir, "passwd"], sub {
		1137	# yay
		1138	};
		1139	};
		1140
		1141	The fact that "aio_wd" is a request and not a normal function shows that
		1142	creating an IO::AIO::WD object is itself a potentially blocking
		1143	operation, which is why it is done asynchronously.
		1144
		1145	To stat the directory obtained with "aio_wd" above, one could write
		1146	either of the following three request calls:
		1147
		1148	aio_lstat "/etc" , sub { ... # pathname as normal string
		1149	aio_lstat [$wd, "."], sub { ... # "." relative to $wd (i.e. $wd itself)
		1150	aio_lstat $wd , sub { ... # shorthand for the previous
		1151
		1152	As with normal pathnames, IO::AIO keeps a copy of the working directory
		1153	object and the pathname string, so you could write the following without
		1154	causing any issues due to $path getting reused:
		1155
		1156	my $path = [$wd, undef];
		1157
		1158	for my $name (qw(abc def ghi)) {
		1159	$path->[1] = $name;
		1160	aio_stat $path, sub {
		1161	# ...
		1162	};
		1163	}
		1164
		1165	There are some caveats: when directories get renamed (or deleted), the
		1166	pathname string doesn't change, so will point to the new directory (or
		1167	nowhere at all), while the directory fd, if available on the system,
		1168	will still point to the original directory. Most functions accepting a
		1169	pathname will use the directory fd on newer systems, and the string on
		1170	older systems. Some functions (such as realpath) will always rely on the
		1171	string form of the pathname.
		1172
		1173	So this functionality is mainly useful to get some protection against
		1174	"chdir", to easily get an absolute path out of a relative path for
		1175	future reference, and to speed up doing many operations in the same
		1176	directory (e.g. when stat'ing all files in a directory).
		1177
		1178	The following functions implement this working directory abstraction:
		1179
		1180	aio_wd $pathname, $callback->($wd)
		1181	Asynchonously canonicalise the given pathname and convert it to an
		1182	IO::AIO::WD object representing it. If possible and supported on the
		1183	system, also open a directory fd to speed up pathname resolution
		1184	relative to this working directory.
		1185
		1186	If something goes wrong, then "undef" is passwd to the callback
		1187	instead of a working directory object and $! is set appropriately.
		1188	Since passing "undef" as working directory component of a pathname
		1189	fails the request with "ENOENT", there is often no need for error
		1190	checking in the "aio_wd" callback, as future requests using the
		1191	value will fail in the expected way.
		1192
		1193	IO::AIO::CWD
		1194	This is a compiletime constant (object) that represents the process
		1195	current working directory.
		1196
		1197	Specifying this object as working directory object for a pathname is
		1198	as if the pathname would be specified directly, without a directory
		1199	object. For example, these calls are functionally identical:
		1200
		1201	aio_stat "somefile", sub { ... };
		1202	aio_stat [IO::AIO::CWD, "somefile"], sub { ... };
		1203
		1204	To recover the path associated with an IO::AIO::WD object, you can use
		1205	"aio_realpath":
		1206
		1207	aio_realpath $wd, sub {
		1208	warn "path is $_[0]\n";
		1209	};
		1210
		1211	Currently, "aio_statvfs" always, and "aio_rename" and "aio_rmdir"
		1212	sometimes, fall back to using an absolue path.
852		1213
853	IO::AIO::REQ CLASS	1214	IO::AIO::REQ CLASS
854	All non-aggregate "aio_*" functions return an object of this class when	1215	All non-aggregate "aio_*" functions return an object of this class when
855	called in non-void context.	1216	called in non-void context.
856		1217
…		…
956	Sets a feeder/generator on this group: every group can have an	1317	Sets a feeder/generator on this group: every group can have an
957	attached generator that generates requests if idle. The idea behind	1318	attached generator that generates requests if idle. The idea behind
958	this is that, although you could just queue as many requests as you	1319	this is that, although you could just queue as many requests as you
959	want in a group, this might starve other requests for a potentially	1320	want in a group, this might starve other requests for a potentially
960	long time. For example, "aio_scandir" might generate hundreds of	1321	long time. For example, "aio_scandir" might generate hundreds of
961	thousands "aio_stat" requests, delaying any later requests for a	1322	thousands of "aio_stat" requests, delaying any later requests for a
962	long time.	1323	long time.
963		1324
964	To avoid this, and allow incremental generation of requests, you can	1325	To avoid this, and allow incremental generation of requests, you can
965	instead a group and set a feeder on it that generates those	1326	instead a group and set a feeder on it that generates those
966	requests. The feed callback will be called whenever there are few	1327	requests. The feed callback will be called whenever there are few
…		…
1008	results.	1369	results.
1009		1370
1010	See "poll_cb" for an example.	1371	See "poll_cb" for an example.
1011		1372
1012	IO::AIO::poll_cb	1373	IO::AIO::poll_cb
1013	Process some outstanding events on the result pipe. You have to call	1374	Process some requests that have reached the result phase (i.e. they
1014	this regularly. Returns 0 if all events could be processed, or -1 if	1375	have been executed but the results are not yet reported). You have
1015	it returned earlier for whatever reason. Returns immediately when no	1376	to call this "regularly" to finish outstanding requests.
1016	events are outstanding. The amount of events processed depends on
1017	the settings of "IO::AIO::max_poll_req" and
1018	"IO::AIO::max_poll_time".
1019		1377
		1378	Returns 0 if all events could be processed (or there were no events
		1379	to process), or -1 if it returned earlier for whatever reason.
		1380	Returns immediately when no events are outstanding. The amount of
		1381	events processed depends on the settings of "IO::AIO::max_poll_req",
		1382	"IO::AIO::max_poll_time" and "IO::AIO::max_outstanding".
		1383
1020	If not all requests were processed for whatever reason, the	1384	If not all requests were processed for whatever reason, the poll
1021	filehandle will still be ready when "poll_cb" returns, so normally	1385	file descriptor will still be ready when "poll_cb" returns, so
1022	you don't have to do anything special to have it called later.	1386	normally you don't have to do anything special to have it called
		1387	later.
		1388
		1389	Apart from calling "IO::AIO::poll_cb" when the event filehandle
		1390	becomes ready, it can be beneficial to call this function from loops
		1391	which submit a lot of requests, to make sure the results get
		1392	processed when they become available and not just when the loop is
		1393	finished and the event loop takes over again. This function returns
		1394	very fast when there are no outstanding requests.
1023		1395
1024	Example: Install an Event watcher that automatically calls	1396	Example: Install an Event watcher that automatically calls
1025	IO::AIO::poll_cb with high priority (more examples can be found in	1397	IO::AIO::poll_cb with high priority (more examples can be found in
1026	the SYNOPSIS section, at the top of this document):	1398	the SYNOPSIS section, at the top of this document):
1027		1399
1028	Event->io (fd => IO::AIO::poll_fileno,	1400	Event->io (fd => IO::AIO::poll_fileno,
1029	poll => 'r', async => 1,	1401	poll => 'r', async => 1,
1030	cb => \&IO::AIO::poll_cb);	1402	cb => \&IO::AIO::poll_cb);
1031		1403
1032	IO::AIO::poll_wait	1404	IO::AIO::poll_wait
1033	If there are any outstanding requests and none of them in the result	1405	Wait until either at least one request is in the result phase or no
1034	phase, wait till the result filehandle becomes ready for reading	1406	requests are outstanding anymore.
1035	(simply does a "select" on the filehandle. This is useful if you	1407
1036	want to synchronously wait for some requests to finish).	1408	This is useful if you want to synchronously wait for some requests
		1409	to become ready, without actually handling them.
1037		1410
1038	See "nreqs" for an example.	1411	See "nreqs" for an example.
1039		1412
1040	IO::AIO::poll	1413	IO::AIO::poll
1041	Waits until some requests have been handled.	1414	Waits until some requests have been handled.
…		…
1121		1494
1122	Under normal circumstances you don't need to call this function.	1495	Under normal circumstances you don't need to call this function.
1123		1496
1124	IO::AIO::max_idle $nthreads	1497	IO::AIO::max_idle $nthreads
1125	Limit the number of threads (default: 4) that are allowed to idle	1498	Limit the number of threads (default: 4) that are allowed to idle
1126	(i.e., threads that did not get a request to process within 10	1499	(i.e., threads that did not get a request to process within the idle
1127	seconds). That means if a thread becomes idle while $nthreads other	1500	timeout (default: 10 seconds). That means if a thread becomes idle
1128	threads are also idle, it will free its resources and exit.	1501	while $nthreads other threads are also idle, it will free its
		1502	resources and exit.
1129		1503
1130	This is useful when you allow a large number of threads (e.g. 100 or	1504	This is useful when you allow a large number of threads (e.g. 100 or
1131	1000) to allow for extremely high load situations, but want to free	1505	1000) to allow for extremely high load situations, but want to free
1132	resources under normal circumstances (1000 threads can easily	1506	resources under normal circumstances (1000 threads can easily
1133	consume 30MB of RAM).	1507	consume 30MB of RAM).
1134		1508
1135	The default is probably ok in most situations, especially if thread	1509	The default is probably ok in most situations, especially if thread
1136	creation is fast. If thread creation is very slow on your system you	1510	creation is fast. If thread creation is very slow on your system you
1137	might want to use larger values.	1511	might want to use larger values.
1138		1512
		1513	IO::AIO::idle_timeout $seconds
		1514	Sets the minimum idle timeout (default 10) after which worker
		1515	threads are allowed to exit. SEe "IO::AIO::max_idle".
		1516
1139	IO::AIO::max_outstanding $maxreqs	1517	IO::AIO::max_outstanding $maxreqs
		1518	Sets the maximum number of outstanding requests to $nreqs. If you do
		1519	queue up more than this number of requests, the next call to
		1520	"IO::AIO::poll_cb" (and other functions calling "poll_cb", such as
		1521	"IO::AIO::flush" or "IO::AIO::poll") will block until the limit is
		1522	no longer exceeded.
		1523
		1524	In other words, this setting does not enforce a queue limit, but can
		1525	be used to make poll functions block if the limit is exceeded.
		1526
1140	This is a very bad function to use in interactive programs because	1527	This is a very bad function to use in interactive programs because
1141	it blocks, and a bad way to reduce concurrency because it is	1528	it blocks, and a bad way to reduce concurrency because it is
1142	inexact: Better use an "aio_group" together with a feed callback.	1529	inexact: Better use an "aio_group" together with a feed callback.
1143		1530
1144	Sets the maximum number of outstanding requests to $nreqs. If you do	1531	Its main use is in scripts without an event loop - when you want to
1145	queue up more than this number of requests, the next call to the	1532	stat a lot of files, you can write somehting like this:
1146	"poll_cb" (and "poll_some" and other functions calling "poll_cb")
1147	function will block until the limit is no longer exceeded.
1148		1533
1149	The default value is very large, so there is no practical limit on	1534	IO::AIO::max_outstanding 32;
		1535
		1536	for my $path (...) {
		1537	aio_stat $path , ...;
		1538	IO::AIO::poll_cb;
		1539	}
		1540
		1541	IO::AIO::flush;
		1542
		1543	The call to "poll_cb" inside the loop will normally return
		1544	instantly, but as soon as more thna 32 reqeusts are in-flight, it
		1545	will block until some requests have been handled. This keeps the
		1546	loop from pushing a large number of "aio_stat" requests onto the
		1547	queue.
		1548
		1549	The default value for "max_outstanding" is very large, so there is
1150	the number of outstanding requests.	1550	no practical limit on the number of outstanding requests.
1151
1152	You can still queue as many requests as you want. Therefore,
1153	"max_outstanding" is mainly useful in simple scripts (with low
1154	values) or as a stop gap to shield against fatal memory overflow
1155	(with large values).
1156		1551
1157	STATISTICAL INFORMATION	1552	STATISTICAL INFORMATION
1158	IO::AIO::nreqs	1553	IO::AIO::nreqs
1159	Returns the number of requests currently in the ready, execute or	1554	Returns the number of requests currently in the ready, execute or
1160	pending states (i.e. for which their callback has not been invoked	1555	pending states (i.e. for which their callback has not been invoked
…		…
1172	IO::AIO::npending	1567	IO::AIO::npending
1173	Returns the number of requests currently in the pending state	1568	Returns the number of requests currently in the pending state
1174	(executed, but not yet processed by poll_cb).	1569	(executed, but not yet processed by poll_cb).
1175		1570
1176	MISCELLANEOUS FUNCTIONS	1571	MISCELLANEOUS FUNCTIONS
1177	IO::AIO implements some functions that might be useful, but are not	1572	IO::AIO implements some functions that are useful when you want to use
1178	asynchronous.	1573	some "Advanced I/O" function not available to in Perl, without going the
		1574	"Asynchronous I/O" route. Many of these have an asynchronous "aio_*"
		1575	counterpart.
1179		1576
1180	IO::AIO::sendfile $ofh, $ifh, $offset, $count	1577	IO::AIO::sendfile $ofh, $ifh, $offset, $count
1181	Calls the "eio_sendfile_sync" function, which is like	1578	Calls the "eio_sendfile_sync" function, which is like
1182	"aio_sendfile", but is blocking (this makes most sense if you know	1579	"aio_sendfile", but is blocking (this makes most sense if you know
1183	the input data is likely cached already and the output filehandle is	1580	the input data is likely cached already and the output filehandle is
…		…
1185		1582
1186	Returns the number of bytes copied, or -1 on error.	1583	Returns the number of bytes copied, or -1 on error.
1187		1584
1188	IO::AIO::fadvise $fh, $offset, $len, $advice	1585	IO::AIO::fadvise $fh, $offset, $len, $advice
1189	Simply calls the "posix_fadvise" function (see its manpage for	1586	Simply calls the "posix_fadvise" function (see its manpage for
1190	details). The following advice constants are avaiable:	1587	details). The following advice constants are available:
1191	"IO::AIO::FADV_NORMAL", "IO::AIO::FADV_SEQUENTIAL",	1588	"IO::AIO::FADV_NORMAL", "IO::AIO::FADV_SEQUENTIAL",
1192	"IO::AIO::FADV_RANDOM", "IO::AIO::FADV_NOREUSE",	1589	"IO::AIO::FADV_RANDOM", "IO::AIO::FADV_NOREUSE",
1193	"IO::AIO::FADV_WILLNEED", "IO::AIO::FADV_DONTNEED".	1590	"IO::AIO::FADV_WILLNEED", "IO::AIO::FADV_DONTNEED".
1194		1591
1195	On systems that do not implement "posix_fadvise", this function	1592	On systems that do not implement "posix_fadvise", this function
1196	returns ENOSYS, otherwise the return value of "posix_fadvise".	1593	returns ENOSYS, otherwise the return value of "posix_fadvise".
1197		1594
1198	IO::AIO::madvise $scalar, $offset, $len, $advice	1595	IO::AIO::madvise $scalar, $offset, $len, $advice
1199	Simply calls the "posix_madvise" function (see its manpage for	1596	Simply calls the "posix_madvise" function (see its manpage for
1200	details). The following advice constants are avaiable:	1597	details). The following advice constants are available:
1201	"IO::AIO::MADV_NORMAL", "IO::AIO::MADV_SEQUENTIAL",	1598	"IO::AIO::MADV_NORMAL", "IO::AIO::MADV_SEQUENTIAL",
1202	"IO::AIO::MADV_RANDOM", "IO::AIO::MADV_WILLNEED",	1599	"IO::AIO::MADV_RANDOM", "IO::AIO::MADV_WILLNEED",
1203	"IO::AIO::MADV_DONTNEED".	1600	"IO::AIO::MADV_DONTNEED".
1204		1601
1205	On systems that do not implement "posix_madvise", this function	1602	On systems that do not implement "posix_madvise", this function
1206	returns ENOSYS, otherwise the return value of "posix_madvise".	1603	returns ENOSYS, otherwise the return value of "posix_madvise".
1207		1604
1208	IO::AIO::mprotect $scalar, $offset, $len, $protect	1605	IO::AIO::mprotect $scalar, $offset, $len, $protect
1209	Simply calls the "mprotect" function on the preferably AIO::mmap'ed	1606	Simply calls the "mprotect" function on the preferably AIO::mmap'ed
1210	$scalar (see its manpage for details). The following protect	1607	$scalar (see its manpage for details). The following protect
1211	constants are avaiable: "IO::AIO::PROT_NONE", "IO::AIO::PROT_READ",	1608	constants are available: "IO::AIO::PROT_NONE", "IO::AIO::PROT_READ",
1212	"IO::AIO::PROT_WRITE", "IO::AIO::PROT_EXEC".	1609	"IO::AIO::PROT_WRITE", "IO::AIO::PROT_EXEC".
1213		1610
1214	On systems that do not implement "mprotect", this function returns	1611	On systems that do not implement "mprotect", this function returns
1215	ENOSYS, otherwise the return value of "mprotect".	1612	ENOSYS, otherwise the return value of "mprotect".
1216		1613
1217	IO::AIO::mmap $scalar, $length, $prot, $flags, $fh[, $offset]	1614	IO::AIO::mmap $scalar, $length, $prot, $flags, $fh[, $offset]
1218	Memory-maps a file (or anonymous memory range) and attaches it to	1615	Memory-maps a file (or anonymous memory range) and attaches it to
1219	the given $scalar, which will act like a string scalar.	1616	the given $scalar, which will act like a string scalar. Returns true
		1617	on success, and false otherwise.
1220		1618
1221	The only operations allowed on the scalar are "substr"/"vec" that	1619	The only operations allowed on the scalar are "substr"/"vec" that
1222	don't change the string length, and most read-only operations such	1620	don't change the string length, and most read-only operations such
1223	as copying it or searching it with regexes and so on.	1621	as copying it or searching it with regexes and so on.
1224		1622
…		…
1238	"IO::AIO::PROT_EXEC", "IO::AIO::PROT_READ" and/or	1636	"IO::AIO::PROT_EXEC", "IO::AIO::PROT_READ" and/or
1239	"IO::AIO::PROT_WRITE",	1637	"IO::AIO::PROT_WRITE",
1240		1638
1241	$flags can be a combination of "IO::AIO::MAP_SHARED" or	1639	$flags can be a combination of "IO::AIO::MAP_SHARED" or
1242	"IO::AIO::MAP_PRIVATE", or a number of system-specific flags (when	1640	"IO::AIO::MAP_PRIVATE", or a number of system-specific flags (when
1243	not available, the are defined as 0): "IO::AIO::MAP_ANONYMOUS"	1641	not available, the are 0): "IO::AIO::MAP_ANONYMOUS" (which is set to
1244	(which is set to "MAP_ANON" if your system only provides this	1642	"MAP_ANON" if your system only provides this constant),
1245	constant), "IO::AIO::MAP_HUGETLB", "IO::AIO::MAP_LOCKED",	1643	"IO::AIO::MAP_HUGETLB", "IO::AIO::MAP_LOCKED",
1246	"IO::AIO::MAP_NORESERVE", "IO::AIO::MAP_POPULATE" or	1644	"IO::AIO::MAP_NORESERVE", "IO::AIO::MAP_POPULATE",
1247	"IO::AIO::MAP_NONBLOCK"	1645	"IO::AIO::MAP_NONBLOCK", "IO::AIO::MAP_FIXED",
		1646	"IO::AIO::MAP_GROWSDOWN", "IO::AIO::MAP_32BIT",
		1647	"IO::AIO::MAP_HUGETLB" or "IO::AIO::MAP_STACK".
1248		1648
1249	If $fh is "undef", then a file descriptor of -1 is passed.	1649	If $fh is "undef", then a file descriptor of -1 is passed.
1250		1650
1251	$offset is the offset from the start of the file - it generally must	1651	$offset is the offset from the start of the file - it generally must
1252	be a multiple of "IO::AIO::PAGESIZE" and defaults to 0.	1652	be a multiple of "IO::AIO::PAGESIZE" and defaults to 0.
…		…
1274	IO::AIO::munlockall	1674	IO::AIO::munlockall
1275	Calls the "munlockall" function.	1675	Calls the "munlockall" function.
1276		1676
1277	On systems that do not implement "munlockall", this function returns	1677	On systems that do not implement "munlockall", this function returns
1278	ENOSYS, otherwise the return value of "munlockall".	1678	ENOSYS, otherwise the return value of "munlockall".
		1679
		1680	IO::AIO::splice $r_fh, $r_off, $w_fh, $w_off, $length, $flags
		1681	Calls the GNU/Linux splice(2) syscall, if available. If $r_off or
		1682	$w_off are "undef", then "NULL" is passed for these, otherwise they
		1683	should be the file offset.
		1684
		1685	$r_fh and $w_fh should not refer to the same file, as splice might
		1686	silently corrupt the data in this case.
		1687
		1688	The following symbol flag values are available:
		1689	"IO::AIO::SPLICE_F_MOVE", "IO::AIO::SPLICE_F_NONBLOCK",
		1690	"IO::AIO::SPLICE_F_MORE" and "IO::AIO::SPLICE_F_GIFT".
		1691
		1692	See the splice(2) manpage for details.
		1693
		1694	IO::AIO::tee $r_fh, $w_fh, $length, $flags
		1695	Calls the GNU/Linux tee(2) syscall, see its manpage and the
		1696	description for "IO::AIO::splice" above for details.
		1697
		1698	$actual_size = IO::AIO::pipesize $r_fh[, $new_size]
		1699	Attempts to query or change the pipe buffer size. Obviously works
		1700	only on pipes, and currently works only on GNU/Linux systems, and
		1701	fails with -1/"ENOSYS" everywhere else. If anybody knows how to
		1702	influence pipe buffer size on other systems, drop me a note.
		1703
		1704	($rfh, $wfh) = IO::AIO::pipe2 [$flags]
		1705	This is a direct interface to the Linux pipe2(2) system call. If
		1706	$flags is missing or 0, then this should be the same as a call to
		1707	perl's built-in "pipe" function and create a new pipe, and works on
		1708	systems that lack the pipe2 syscall. On win32, this case invokes
		1709	"_pipe (..., 4096, O_BINARY)".
		1710
		1711	If $flags is non-zero, it tries to invoke the pipe2 system call with
		1712	the given flags (Linux 2.6.27, glibc 2.9).
		1713
		1714	On success, the read and write file handles are returned.
		1715
		1716	On error, nothing will be returned. If the pipe2 syscall is missing
		1717	and $flags is non-zero, fails with "ENOSYS".
		1718
		1719	Please refer to pipe2(2) for more info on the $flags, but at the
		1720	time of this writing, "IO::AIO::O_CLOEXEC", "IO::AIO::O_NONBLOCK"
		1721	and "IO::AIO::O_DIRECT" (Linux 3.4, for packet-based pipes) were
		1722	supported.
1279		1723
1280	EVENT LOOP INTEGRATION	1724	EVENT LOOP INTEGRATION
1281	It is recommended to use AnyEvent::AIO to integrate IO::AIO	1725	It is recommended to use AnyEvent::AIO to integrate IO::AIO
1282	automatically into many event loops:	1726	automatically into many event loops:
1283		1727
…		…
1306	# Danga::Socket integration	1750	# Danga::Socket integration
1307	Danga::Socket->AddOtherFds (IO::AIO::poll_fileno =>	1751	Danga::Socket->AddOtherFds (IO::AIO::poll_fileno =>
1308	\&IO::AIO::poll_cb);	1752	\&IO::AIO::poll_cb);
1309		1753
1310	FORK BEHAVIOUR	1754	FORK BEHAVIOUR
1311	This module should do "the right thing" when the process using it forks:	1755	Usage of pthreads in a program changes the semantics of fork
		1756	considerably. Specifically, only async-safe functions can be called
		1757	after fork. Perl doesn't know about this, so in general, you cannot call
		1758	fork with defined behaviour in perl if pthreads are involved. IO::AIO
		1759	uses pthreads, so this applies, but many other extensions and (for
		1760	inexplicable reasons) perl itself often is linked against pthreads, so
		1761	this limitation applies to quite a lot of perls.
1312		1762
1313	Before the fork, IO::AIO enters a quiescent state where no requests can	1763	This module no longer tries to fight your OS, or POSIX. That means
1314	be added in other threads and no results will be processed. After the	1764	IO::AIO only works in the process that loaded it. Forking is fully
1315	fork the parent simply leaves the quiescent state and continues	1765	supported, but using IO::AIO in the child is not.
1316	request/result processing, while the child frees the request/result
1317	queue (so that the requests started before the fork will only be handled
1318	in the parent). Threads will be started on demand until the limit set in
1319	the parent process has been reached again.
1320		1766
1321	In short: the parent will, after a short pause, continue as if fork had	1767	You might get around by not using IO::AIO before (or after) forking.
1322	not been called, while the child will act as if IO::AIO has not been	1768	You could also try to call the IO::AIO::reinit function in the child:
1323	used yet.	1769
		1770	IO::AIO::reinit
		1771	Abandons all current requests and I/O threads and simply
		1772	reinitialises all data structures. This is not an operation
		1773	supported by any standards, but happens to work on GNU/Linux and
		1774	some newer BSD systems.
		1775
		1776	The only reasonable use for this function is to call it after
		1777	forking, if "IO::AIO" was used in the parent. Calling it while
		1778	IO::AIO is active in the process will result in undefined behaviour.
		1779	Calling it at any time will also result in any undefined (by POSIX)
		1780	behaviour.
1324		1781
1325	MEMORY USAGE	1782	MEMORY USAGE
1326	Per-request usage:	1783	Per-request usage:
1327		1784
1328	Each aio request uses - depending on your architecture - around 100-200	1785	Each aio request uses - depending on your architecture - around 100-200

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing IO-AIO/README (file contents): Revision 1.45 by root, Thu Dec 30 07:19:31 2010 UTC vs. Revision 1.57 by root, Mon Jan 18 11:53:09 2016 UTC

Diff Legend

Comparing IO-AIO/README (file contents):
Revision 1.45 by root, Thu Dec 30 07:19:31 2010 UTC vs.
Revision 1.57 by root, Mon Jan 18 11:53:09 2016 UTC