MFP4 (with some minor changes):

Implement the linux_io_* syscalls (AIO). They are only enabled if the native
AIO code is available (either compiled in to the kernel or as a module) at
the time the functions are used. If the AIO stuff is not available there
will be a ENOSYS.

From the submitter:
---snip---
DESIGN NOTES:

1. Linux permits a process to own multiple AIO queues (distinguished by
   "context"), but FreeBSD creates only one single AIO queue per process.
   My code maintains a request queue (STAILQ of queue(3)) per "context",
   and throws all AIO requests of all contexts owned by a process into
   the single FreeBSD per-process AIO queue.

   When the process calls io_destroy(2), io_getevents(2), io_submit(2) and
   io_cancel(2), my code can pick out requests owned by the specified context
   from the single FreeBSD per-process AIO queue according to the per-context
   request queues maintained by my code.

2. The request queue maintained by my code stores contrast information between
   Linux IO control blocks (struct linux_iocb) and FreeBSD IO control blocks
   (struct aiocb). FreeBSD IO control block actually exists in userland memory
   space, required by FreeBSD native aio_XXXXXX(2).

3. It is quite troubling that the function io_getevents() of libaio-0.3.105
   needs to use Linux-specific "struct aio_ring", which is a partial mirror
   of context in user space. I would rather take the address of context in
   kernel as the context ID, but the io_getevents() of libaio forces me to
   take the address of the "ring" in user space as the context ID.

   To my surprise, one comment line in the file "io_getevents.c" of
   libaio-0.3.105 reads:

             Ben will hate me for this

REFERENCE:

1. Linux kernel source code:   http://www.kernel.org/pub/linux/kernel/v2.6/
   (include/linux/aio_abi.h, fs/aio.c)

2. Linux manual pages:         http://www.kernel.org/pub/linux/docs/manpages/
   (io_setup(2), io_destroy(2), io_getevents(2), io_submit(2), io_cancel(2))

3. Linux Scalability Effort:   http://lse.sourceforge.net/io/aio.html
   The design notes:           http://lse.sourceforge.net/io/aionotes.txt

4. The package libaio, both source and binary:
       http://rpmfind.net/linux/rpm2html/search.php?query=libaio
   Simple transparent interface to Linux AIO system calls.

5. Libaio-oracle:              http://oss.oracle.com/projects/libaio-oracle/
   POSIX AIO implementation based on Linux AIO system calls (depending on
   libaio).
---snip---

Submitted by:	Li, Xiao <intron@intron.ac>

1 files changed, 98 insertions, 0 deletions

diff --git a/sys/compat/linux/linux_aio.h b/sys/compat/linux/linux_aio.h
new file mode 100644
index 0000000..96028a8
--- /dev/null
+++ b/sys/compat/linux/linux_aio.h
@@ -0,0 +1,98 @@
+/*-
+ * Copyright (c) 2006 Li, Xiao <intron@intron.ac>.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/*
+ * Linux Kernel Implementation of Asynchronous I/O
+ */
+
+#ifndef	_LINUX_AIO_H_
+#define	_LINUX_AIO_H_
+
+typedef unsigned long linux_aio_context_t;
+
+enum {
+	LINUX_IOCB_CMD_PREAD = 0,
+	LINUX_IOCB_CMD_PWRITE = 1,
+	LINUX_IOCB_CMD_FSYNC = 2,
+	LINUX_IOCB_CMD_FDSYNC = 3,
+#if 0
+	LINUX_IOCB_CMD_PREADX = 4,
+	LINUX_IOCB_CMD_POLL = 5,
+#endif
+	LINUX_IOCB_CMD_NOOP = 6,
+};
+
+struct linux_io_event {
+	uint64_t	data;
+	uint64_t	obj;
+	int64_t		res;
+	int64_t		res2;
+};
+
+#if _BYTE_ORDER == _LITTLE_ENDIAN
+#define LINUX_AIO_PADDED(x,y)	x,y
+#elif _BYTE_ORDER == _BIG_ENDIAN
+#define LINUX_AIO_PADDED(x,y)	y,x
+#else
+#error Unidentified byte order !!!
+#endif
+
+struct linux_iocb {
+	uint64_t	aio_data;
+	uint32_t	LINUX_AIO_PADDED(aio_key, aio_reserved1);
+
+	uint16_t	aio_lio_opcode;
+	int16_t		aio_reqprio;
+	uint32_t	aio_fildes;
+
+	uint64_t	aio_buf;
+	uint64_t	aio_nbytes;
+	int64_t		aio_offset;
+
+	uint64_t	aio_reserved2;	/* TODO: use this for a (struct sigevent *) */
+	uint64_t	aio_reserved3;
+
+};
+
+/* User space context information structure */
+struct linux_aio_ring {
+	l_uint	ring_id;
+	l_uint	ring_nr;
+	l_uint	ring_head;
+	l_uint	ring_tail;
+#define LINUX_AIO_RING_MAGIC			0xa10a10a1
+	l_uint	ring_magic;
+#define LINUX_AIO_RING_COMPAT_FEATURES		1
+	l_uint	ring_compat_features;
+#define LINUX_AIO_RING_INCOMPAT_FEATURES	0
+	l_uint	ring_incompat_features;
+	l_uint	ring_header_length; /* Size of this structure */
+
+	struct linux_io_event	ring_io_events[0];
+};
+
+#endif /* !_LINUX_AIO_H_ */