--- /dev/null
+*.rej
+*.orig
+*~
+/*.patch
+
+*.o
+*.o[ls]
+
+/src/libaio.a
+/src/libaio.so*
includedir=$(prefix)/include
libdir=$(prefix)/lib
-pkgname := libaio
-ver := $(shell cat .version)
-
-version_dirty := $(strip $(shell git diff | lsdiff | grep ".version"))
-dirty := $(strip $(shell git whatchanged ${pkgname}-${ver}... 2>/dev/null))
-new_changes := $(strip $(shell git diff 2>/dev/null))
-tag_valid := $(strip $(shell git tag -l ${pkgname}-${ver}))
-
default: all
all:
@$(MAKE) -C src clean
@$(MAKE) -C harness clean
-tag: tag-checks
- git tag ${pkgname}-${ver}
+tag-archive:
+ @cvs -Q tag -F $(CVSTAG)
-archive: uptodate
- @echo "Creating archive from version ${pkgname}-${ver}:"
- git archive --format=tar --prefix=${pkgname}-${ver}/ \
- ${pkgname}-${ver} | gzip > ${pkgname}-${ver}.tar.gz
-tag-checks:
-ifneq (${version_dirty},)
- @echo "Error: .version is not committed to the repository."
- @exit 1
-endif
-ifneq (${new_changes},)
- @echo "Error: there are changes in this checkout that have not been"
- @echo "committed to the repository."
- @exit 1
-endif
+create-archive: tag-archive
+ @rm -rf /tmp/$(NAME)
+ @cd /tmp; cvs -Q -d $(CVSROOT) export -r$(CVSTAG) $(NAME) || echo GRRRrrrrr -- ignore [export aborted]
+ @mv /tmp/$(NAME) /tmp/$(NAME)-$(VERSION)
+ @cd /tmp; tar czSpf $(NAME)-$(VERSION).tar.gz $(NAME)-$(VERSION)
+ @rm -rf /tmp/$(NAME)-$(VERSION)
+ @cp /tmp/$(NAME)-$(VERSION).tar.gz .
+ @rm -f /tmp/$(NAME)-$(VERSION).tar.gz
+ @echo " "
+ @echo "The final archive is ./$(NAME)-$(VERSION).tar.gz."
-uptodate: tag-checks
-ifneq (${dirty},)
- @echo -n "Error: this branch contains changes that are not part of tag "
- @echo "${pkgname}-${ver}."
- @echo -n "Try running git-whatchanged ${pkgname}-${ver}... to see "
- @echo "the changes."
- @exit 1
-endif
-ifeq (${tag_valid},)
- @echo "Error: tag ${pkgname}-${ver} does not exist. Run 'make tag'"
- @echo "and try again."
- @exit 1
-endif
+archive: clean tag-archive create-archive
-srpm: archive
+srpm: create-archive
$(RPMBUILD) --define "_sourcedir `pwd`" --define "_srcrpmdir `pwd`" --nodeps -bs $(SPECFILE)
HARNESS_SRCS:=main.c
# io_queue.c
-CFLAGS=-Wall -Werror -I../src -g -O
+CFLAGS+=-Wall -Werror -I../src -g -O
#-lpthread -lrt
all: $(PROGS)
test_child();
res = waitpid(pid, &status, 0);
+ if (res < 0) {
+ printf("waitpid error\n");
+ return res;
+ }
if (WIFEXITED(status)) {
int failed = (WEXITSTATUS(status) != 0);
test_child();
res = waitpid(pid, &status, 0);
+ if (res < 0) {
+ printf("waitpid error\n");
+ return res;
+ }
if (WIFEXITED(status)) {
int failed = (WEXITSTATUS(status) != 0);
#define SYS_eventfd 318
#elif defined(__alpha__)
#define SYS_eventfd 478
+#elif defined(__aarch64__)
+/* arm64 does not implement eventfd, only eventfd2 */
+#define USE_EVENTFD2
+#ifndef SYS_eventfd2
+#define SYS_eventfd2 19
+#endif /* __aarch64__ */
#else
#error define SYS_eventfd for your arch!
#endif
struct timespec notime = { .tv_sec = 0, .tv_nsec = 0 };
buf = malloc(SIZE); assert(buf);
+#ifndef USE_EVENTFD2
efd = syscall(SYS_eventfd, 0);
+#else
+ efd = syscall(SYS_eventfd2, 0, 0);
+#endif
if (efd < 0) {
if (errno == ENOSYS) {
printf("No eventfd support. [SKIPPING]\n");
Name: libaio
-Version: 0.3.109
+Version: 0.3.110
Release: 1
Summary: Linux-native asynchronous I/O access library
License: LGPL
%attr(0644,root,root) %{_libdir}/libaio.a
%changelog
+* Fri Jul 5 2013 Jeff Moyer <jmoyer@redhat.com> - 0.3.110-1
+- Add suport for sparc and arm64 (Mike Frysinger and Jeff Moyer)
+- Add generic syscall fallbacks (Mike Frysinger)
+- Update man pages (Jeff Moyer and Cyril Hrubis)
+- Build system fixes (Mike Frysinger)
+
* Tue Jun 9 2009 Jeff Moyer <jmoyer@redhat.com> - 0.3.108-1
- add ARM architecture support (grabbed from Debian arches tree)
- replace check of __i386__ with __LP64__ in test harness (Jeff Moyer)
+++ /dev/null
-.TH aio 3 2002-09-12 "Linux 2.4" Linux AIO"
-.SH NAME
-aio \- Asynchronous IO
-.SH SYNOPSIS
-.nf
-.B #include <errno.h>
-.sp
-.br
-.B #include <aio.h>
-.sp
-.fi
-.SH DESCRIPTION
-The POSIX.1b standard defines a new set of I/O operations which can
-significantly reduce the time an application spends waiting at I/O. The
-new functions allow a program to initiate one or more I/O operations and
-then immediately resume normal work while the I/O operations are
-executed in parallel. This functionality is available if the
-.IR "unistd.h"
-file defines the symbol
-.B "_POSIX_ASYNCHRONOUS_IO"
-.
-
-These functions are part of the library with realtime functions named
-.IR "librt"
-. They are not actually part of the
-.IR "libc"
-binary.
-The implementation of these functions can be done using support in the
-kernel (if available) or using an implementation based on threads at
-userlevel. In the latter case it might be necessary to link applications
-with the thread library
-.IR "libpthread"
-in addition to
-.IR "librt"
-and
-.IR "libaio"
-.
-
-All AIO operations operate on files which were opened previously. There
-might be arbitrarily many operations running for one file. The
-asynchronous I/O operations are controlled using a data structure named
-.IR "struct aiocb"
-It is defined in
-.IR "aio.h"
- as follows.
-
-.nf
-struct aiocb
-{
- int aio_fildes; /* File desriptor. */
- int aio_lio_opcode; /* Operation to be performed. */
- int aio_reqprio; /* Request priority offset. */
- volatile void *aio_buf; /* Location of buffer. */
- size_t aio_nbytes; /* Length of transfer. */
- struct sigevent aio_sigevent; /* Signal number and value. */
-
- /* Internal members. */
- struct aiocb *__next_prio;
- int __abs_prio;
- int __policy;
- int __error_code;
- __ssize_t __return_value;
-
-#ifndef __USE_FILE_OFFSET64
- __off_t aio_offset; /* File offset. */
- char __pad[sizeof (__off64_t) - sizeof (__off_t)];
-#else
- __off64_t aio_offset; /* File offset. */
-#endif
- char __unused[32];
-};
-
-.fi
-The POSIX.1b standard mandates that the
-.IR "struct aiocb"
-structure
-contains at least the members described in the following table. There
-might be more elements which are used by the implementation, but
-depending upon these elements is not portable and is highly deprecated.
-
-.TP
-.IR "int aio_fildes"
-This element specifies the file descriptor to be used for the
-operation. It must be a legal descriptor, otherwise the operation will
-fail.
-
-The device on which the file is opened must allow the seek operation.
-I.e., it is not possible to use any of the AIO operations on devices
-like terminals where an
-.IR "lseek"
- call would lead to an error.
-.TP
-.IR "off_t aio_offset"
-This element specifies the offset in the file at which the operation (input
-or output) is performed. Since the operations are carried out in arbitrary
-order and more than one operation for one file descriptor can be
-started, one cannot expect a current read/write position of the file
-descriptor.
-.TP
-.IR "volatile void *aio_buf"
-This is a pointer to the buffer with the data to be written or the place
-where the read data is stored.
-.TP
-.IR "size_t aio_nbytes"
-This element specifies the length of the buffer pointed to by
-.IR "aio_buf"
-.
-.TP
-.IR "int aio_reqprio"
-If the platform has defined
-.B "_POSIX_PRIORITIZED_IO"
-and
-.B "_POSIX_PRIORITY_SCHEDULING"
-, the AIO requests are
-processed based on the current scheduling priority. The
-.IR "aio_reqprio"
-element can then be used to lower the priority of the
-AIO operation.
-.TP
-.IR "struct sigevent aio_sigevent"
-This element specifies how the calling process is notified once the
-operation terminates. If the
-.IR "sigev_notify"
-element is
-.B "SIGEV_NONE"
-, no notification is sent. If it is
-.B "SIGEV_SIGNAL"
-,
-the signal determined by
-.IR "sigev_signo"
-is sent. Otherwise,
-.IR "sigev_notify"
-must be
-.B "SIGEV_THREAD"
-. In this case, a thread
-is created which starts executing the function pointed to by
-.IR "sigev_notify_function"
-.
-.TP
-.IR "int aio_lio_opcode"
-This element is only used by the
-.IR "lio_listio"
- and
-.IR "lio_listio64"
- functions. Since these functions allow an
-arbitrary number of operations to start at once, and each operation can be
-input or output (or nothing), the information must be stored in the
-control block. The possible values are:
-.TP
-.B "LIO_READ"
-Start a read operation. Read from the file at position
-.IR "aio_offset"
- and store the next
-.IR "aio_nbytes"
- bytes in the
-buffer pointed to by
-.IR "aio_buf"
-.
-.TP
-.B "LIO_WRITE"
-Start a write operation. Write
-.IR "aio_nbytes"
-bytes starting at
-.IR "aio_buf"
-into the file starting at position
-.IR "aio_offset"
-.
-.TP
-.B "LIO_NOP"
-Do nothing for this control block. This value is useful sometimes when
-an array of
-.IR "struct aiocb"
-values contains holes, i.e., some of the
-values must not be handled although the whole array is presented to the
-.IR "lio_listio"
-function.
-
-When the sources are compiled using
-.B "_FILE_OFFSET_BITS == 64"
-on a
-32 bit machine, this type is in fact
-.IR "struct aiocb64"
-, since the LFS
-interface transparently replaces the
-.IR "struct aiocb"
-definition.
-.PP
-For use with the AIO functions defined in the LFS, there is a similar type
-defined which replaces the types of the appropriate members with larger
-types but otherwise is equivalent to
-.IR "struct aiocb"
-. Particularly,
-all member names are the same.
-
-.nf
-/* The same for the 64bit offsets. Please note that the members aio_fildes
- to __return_value have to be the same in aiocb and aiocb64. */
-#ifdef __USE_LARGEFILE64
-struct aiocb64
-{
- int aio_fildes; /* File desriptor. */
- int aio_lio_opcode; /* Operation to be performed. */
- int aio_reqprio; /* Request priority offset. */
- volatile void *aio_buf; /* Location of buffer. */
- size_t aio_nbytes; /* Length of transfer. */
- struct sigevent aio_sigevent; /* Signal number and value. */
-
- /* Internal members. */
- struct aiocb *__next_prio;
- int __abs_prio;
- int __policy;
- int __error_code;
- __ssize_t __return_value;
-
- __off64_t aio_offset; /* File offset. */
- char __unused[32];
-};
-
-.fi
-.TP
-.IR "int aio_fildes"
-This element specifies the file descriptor which is used for the
-operation. It must be a legal descriptor since otherwise the operation
-fails for obvious reasons.
-The device on which the file is opened must allow the seek operation.
-I.e., it is not possible to use any of the AIO operations on devices
-like terminals where an
-.IR "lseek"
- call would lead to an error.
-.TP
-.IR "off64_t aio_offset"
-This element specifies at which offset in the file the operation (input
-or output) is performed. Since the operation are carried in arbitrary
-order and more than one operation for one file descriptor can be
-started, one cannot expect a current read/write position of the file
-descriptor.
-.TP
-.IR "volatile void *aio_buf"
-This is a pointer to the buffer with the data to be written or the place
-where the read data is stored.
-.TP
-.IR "size_t aio_nbytes"
-This element specifies the length of the buffer pointed to by
-.IR "aio_buf"
-.
-.TP
-.IR "int aio_reqprio"
-If for the platform
-.B "_POSIX_PRIORITIZED_IO"
-and
-.B "_POSIX_PRIORITY_SCHEDULING"
-are defined the AIO requests are
-processed based on the current scheduling priority. The
-.IR "aio_reqprio"
-element can then be used to lower the priority of the
-AIO operation.
-.TP
-.IR "struct sigevent aio_sigevent"
-This element specifies how the calling process is notified once the
-operation terminates. If the
-.IR "sigev_notify"
-, element is
-.B "SIGEV_NONE"
-no notification is sent. If it is
-.B "SIGEV_SIGNAL"
-,
-the signal determined by
-.IR "sigev_signo"
-is sent. Otherwise,
-.IR "sigev_notify"
- must be
-.B "SIGEV_THREAD"
-in which case a thread
-which starts executing the function pointed to by
-.IR "sigev_notify_function"
-.
-.TP
-.IR "int aio_lio_opcode"
-This element is only used by the
-.IR "lio_listio"
-and
-.IR "lio_listio64"
-functions. Since these functions allow an
-arbitrary number of operations to start at once, and since each operation can be
-input or output (or nothing), the information must be stored in the
-control block. See the description of
-.IR "struct aiocb"
-for a description
-of the possible values.
-.PP
-When the sources are compiled using
-.B "_FILE_OFFSET_BITS == 64"
-on a
-32 bit machine, this type is available under the name
-.IR "struct aiocb64"
-, since the LFS transparently replaces the old interface.
-.SH "RETURN VALUES"
-.SH ERRORS
-.SH "SEE ALSO"
-.BR aio_cancel(3),
-.BR aio_cancel64(3),
-.BR aio_error(3),
-.BR aio_error64(3),
-.BR aio_fsync(3),
-.BR aio_fsync64(3),
-.BR aio_init(3),
-.BR aio_read(3),
-.BR aio_read64(3),
-.BR aio_return(3),
-.BR aio_return64(3),
-.BR aio_suspend(3),
-.BR aio_suspend64(3),
-.BR aio_write(3),
-.BR aio_write64(3),
-.BR errno(3),
+++ /dev/null
-.TH aio_cancel 3 2002-09-12 "Linux 2.4" Linux AIO"
-.SH NAME
-aio_cancel - Cancel asynchronous I/O requests
-.SH SYNOPSYS
-.nf
-.B #include <errno.h>
-.sp
-.br
-.B #include <aio.h>
-.sp
-.br
-.BI "int aio_cancel (int fildes " , struct aiocb *aiocbp " )"
-.fi
-.SH DESCRIPTION
-When one or more requests are asynchronously processed, it might be
-useful in some situations to cancel a selected operation, e.g., if it
-becomes obvious that the written data is no longer accurate and would
-have to be overwritten soon. As an example, assume an application, which
-writes data in files in a situation where new incoming data would have
-to be written in a file which will be updated by an enqueued request.
-The POSIX AIO implementation provides such a function, but this function
-is not capable of forcing the cancellation of the request. It is up to the
-implementation to decide whether it is possible to cancel the operation
-or not. Therefore using this function is merely a hint.
-.B "The libaio implementation does not implement the cancel operation in the"
-.B "POSIX libraries".
-.PP
-The
-.IR aio_cancel
-function can be used to cancel one or more
-outstanding requests. If the
-.IR aiocbp
-parameter is
-.IR NULL
-, the
-function tries to cancel all of the outstanding requests which would process
-the file descriptor
-.IR fildes
-(i.e., whose
-.IR aio_fildes
-member
-is
-.IR fildes
-). If
-.IR aiocbp is not
-.IR NULL
-,
-.IR aio_cancel
-attempts to cancel the specific request pointed to by
-.IR aiocbp.
-
-For requests which were successfully canceled, the normal notification
-about the termination of the request should take place. I.e., depending
-on the
-.IR "struct sigevent"
-object which controls this, nothing
-happens, a signal is sent or a thread is started. If the request cannot
-be canceled, it terminates the usual way after performing the operation.
-After a request is successfully canceled, a call to
-.IR aio_error
-with
-a reference to this request as the parameter will return
-.B ECANCELED
-and a call to
-.IR aio_return
-will return
-.IR -1.
-If the request wasn't canceled and is still running the error status is
-still
-.B EINPROGRESS.
-When the sources are compiled with
-.IR "_FILE_OFFSET_BITS == 64"
-, this
-function is in fact
-.IR aio_cancel64
-since the LFS interface
-transparently replaces the normal implementation.
-
-.SH "RETURN VALUES"
-.TP
-.B AIO_CANCELED
-If there were
-requests which haven't terminated and which were successfully canceled.
-.TP
-.B AIO_NOTCANCELED
-If there is one or more requests left which couldn't be canceled,
-. In this case
-.IR aio_error
-must be used to find out which of the, perhaps multiple, requests (in
-.IR aiocbp
-is
-.IR NULL
-) weren't successfully canceled.
-.TP
-.B AIO_ALLDONE
-If all
-requests already terminated at the time
-.IR aio_cancel
-is called the
-return value is
-.
-.SH ERRORS
-If an error occurred during the execution of
-.IR aio_cancel
-the
-function returns
-.IR -1
-and sets
-.IR errno
-to one of the following
-values.
-.TP
-.B EBADF
-The file descriptor
-.IR fildes
-is not valid.
-.TP
-.B ENOSYS
-.IR aio_cancel
-is not implemented.
-.SH "SEE ALSO"
-.BR aio(3),
-.BR aio_cancel64(3),
-.BR aio_error(3),
-.BR aio_error64(3),
-.BR aio_fsync(3),
-.BR aio_fsync64(3),
-.BR aio_init(3),
-.BR aio_read(3),
-.BR aio_read64(3),
-.BR aio_return(3),
-.BR aio_return64(3),
-.BR aio_suspend(3),
-.BR aio_suspend64(3),
-.BR aio_write(3),
-.BR aio_write64(3),
-.BR errno(3),
+++ /dev/null
-.TH aio_cancel64 3 2002-09-12 "Linux 2.4" Linux AIO"
-.SH NAME
-aio_cancel64 \- Cancel asynchronous I/O requests
-.SH SYNOPSYS
-.nf
-.B #include <errno.h>
-.sp
-.br
-.B #include <aio.h>
-.sp
-.br
-.BI "int aio_cancel64 (int fildes, struct aiocb64 *aiocbp)"
-.fi
-.SH DESCRIPTION
-This function is similar to
-.IR aio_cancel
-with the only difference
-that the argument is a reference to a variable of type
-.IR struct aiocb64
-.
-
-When the sources are compiled with
-.IR _FILE_OFFSET_BITS == 64
-, this
-function is available under the name
-.IR aio_cancel
-and so
-transparently replaces the interface for small files on 32 bit
-machines.
-.SH "RETURN VALUES"
-See aio_cancel(3).
-.SH ERRORS
-See aio_cancel(3).
-.SH "SEE ALSO"
-.BR aio(3),
-.BR aio_cancel(3),
-.BR aio_error(3),
-.BR aio_error64(3),
-.BR aio_fsync(3),
-.BR aio_fsync64(3),
-.BR aio_init(3),
-.BR aio_read(3),
-.BR aio_read64(3),
-.BR aio_return(3),
-.BR aio_return64(3),
-.BR aio_suspend(3),
-.BR aio_suspend64(3),
-.BR aio_write(3),
-.BR aio_write64(3),
-.BR errno(3),
+++ /dev/null
-.TH aio_error 3 2002-09-12 "Linux 2.4" Linux AIO"
-.SH NAME
-aio_error \- Getting the Status of AIO Operations
-.SH SYNOPSYS
-.nf
-.B #include <errno.h>
-.sp
-.br
-.B #include <aio.h>
-.sp
-.br
-.BI "int aio_error (const struct aiocb *aiocbp)"
-.fi
-.SH DESCRIPTION
-The function
-.IR aio_error
-determines the error state of the request described by the
-.IR "struct aiocb"
-variable pointed to by
-.I aiocbp
-.
-
-When the operation is performed truly asynchronously (as with
-.IR "aio_read"
-and
-.IR "aio_write"
-and with
-.IR "lio_listio"
-when the mode is
-.IR "LIO_NOWAIT"
-), one sometimes needs to know whether a
-specific request already terminated and if so, what the result was.
-When the sources are compiled with
-.IR "_FILE_OFFSET_BITS == 64"
-this function is in fact
-.IR "aio_error64"
-since the LFS interface transparently replaces the normal implementation.
-.SH "RETURN VALUES"
-If the request has not yet terminated the value returned is always
-.IR "EINPROGRESS"
-. Once the request has terminated the value
-.IR "aio_error"
-returns is either
-.I 0
-if the request completed successfully or it returns the value which would be stored in the
-.IR "errno"
-variable if the request would have been done using
-.IR "read"
-,
-.IR "write"
-, or
-.IR "fsync"
-.
-.SH ERRORS
-.TP
-.IR "ENOSYS"
-if it is not implemented. It
-could also return
-.TP
-.IR "EINVAL"
-if the
-.I aiocbp
-parameter does not
-refer to an asynchronous operation whose return status is not yet known.
-.SH "SEE ALSO"
-.BR aio(3),
-.BR aio_cancel(3),
-.BR aio_cancel64(3),
-.BR aio_error64(3),
-.BR aio_fsync(3),
-.BR aio_fsync64(3),
-.BR aio_init(3),
-.BR aio_read(3),
-.BR aio_read64(3),
-.BR aio_return(3),
-.BR aio_return64(3),
-.BR aio_suspend(3),
-.BR aio_suspend64(3),
-.BR aio_write(3),
-.BR aio_write64(3),
-.BR errno(3),
+++ /dev/null
-.TH aio_error64 3 2002-09-12 "Linux 2.4" Linux AIO"
-.SH NAME
-aio_error64 \- Return errors
-.SH SYNOPSYS
-.nf
-.B #include <errno.h>
-.sp
-.br
-.B #include <aio.h>
-.sp
-.br
-.BI "int aio_error64 (const struct aiocb64 *aiocbp)"
-.fi
-.SH DESCRIPTION
-This function is similar to
-.IR aio_error
-with the only difference
-that the argument is a reference to a variable of type
-.IR "struct aiocb64".
-.PP
-When the sources are compiled with
-.IR "_FILE_OFFSET_BITS == 64"
-this
-function is available under the name
-.IR aio_error
-and so
-transparently replaces the interface for small files on 32 bit
-machines.
-.SH "RETURN VALUES"
-If the request has not yet terminated the value returned is always
-.IR "EINPROGRESS"
-. Once the request has terminated the value
-.IR "aio_error"
-returns is either
-.I 0
-if the request completed successfully or it returns the value which would be stored in the
-.IR "errno"
-variable if the request would have been done using
-.IR "read"
-,
-.IR "write"
-, or
-.IR "fsync"
-.
-.SH ERRORS
-See
-.IR aio_error(3).
-.SH "SEE ALSO"
-.BR aio(3),
-.BR aio_cancel(3),
-.BR aio_cancel64(3),
-.BR aio_error(3),
-.BR aio_fsync(3),
-.BR aio_fsync64(3),
-.BR aio_init(3),
-.BR aio_read(3),
-.BR aio_read64(3),
-.BR aio_return(3),
-.BR aio_return64(3),
-.BR aio_suspend(3),
-.BR aio_suspend64(3),
-.BR aio_write(3),
-.BR aio_write64(3),
-.BR errno(3),
+++ /dev/null
-.TH aio_fsync 3 2002-09-12 "Linux 2.4" Linux AIO"
-.SH NAME
-aio_fsync \- Synchronize a file's complete in-core state with that on disk
-.SH SYNOPSYS
-.nf
-.B #include <errno.h>
-.sp
-.br
-.B #include <aio.h>
-.sp
-.br
-.BI "int aio_fsync (int op, struct aiocb aiocbp)"
-.fi
-.SH DESCRIPTION
-.PP
-When dealing with asynchronous operations it is sometimes necessary to
-get into a consistent state. This would mean for AIO that one wants to
-know whether a certain request or a group of request were processed.
-This could be done by waiting for the notification sent by the system
-after the operation terminated, but this sometimes would mean wasting
-resources (mainly computation time). Instead POSIX.1b defines two
-functions which will help with most kinds of consistency.
-.PP
-The
-.IR aio_fsync
-and
-.IR "aio_fsync64"
-functions are only available
-if the symbol
-.IR "_POSIX_SYNCHRONIZED_IO"
-is defined in
-.I unistd.h
-.
-
-Calling this function forces all I/O operations operating queued at the
-time of the function call operating on the file descriptor
-.IR "aiocbp->aio_fildes"
-into the synchronized I/O completion state . The
-.IR "aio_fsync"
-function returns
-immediately but the notification through the method described in
-.IR "aiocbp->aio_sigevent"
-will happen only after all requests for this
-file descriptor have terminated and the file is synchronized. This also
-means that requests for this very same file descriptor which are queued
-after the synchronization request are not affected.
-
-If
-.IR "op"
-is
-.IR "O_DSYNC"
-the synchronization happens as with a call
-to
-.IR "fdatasync"
-. Otherwise
-.IR "op"
-should be
-.IR "O_SYNC"
-and
-the synchronization happens as with
-.IR "fsync"
-.
-
-As long as the synchronization has not happened, a call to
-.IR "aio_error"
-with the reference to the object pointed to by
-.IR "aiocbp"
-returns
-.IR "EINPROGRESS"
-. Once the synchronization is
-done
-.IR "aio_error"
-return
-.IR 0
-if the synchronization was not
-successful. Otherwise the value returned is the value to which the
-.IR "fsync"
-or
-.IR "fdatasync"
-function would have set the
-.IR "errno"
-variable. In this case nothing can be assumed about the
-consistency for the data written to this file descriptor.
-
-.SH "RETURN VALUES"
-The return value of this function is
-.IR 0
-if the request was
-successfully enqueued. Otherwise the return value is
-.IR -1
-and
-.IR "errno".
-.SH ERRORS
-.TP
-.B EAGAIN
-The request could not be enqueued due to temporary lack of resources.
-.TP
-.B EBADF
-The file descriptor
-.IR "aiocbp->aio_fildes"
-is not valid or not open
-for writing.
-.TP
-.B EINVAL
-The implementation does not support I/O synchronization or the
-.IR "op"
-parameter is other than
-.IR "O_DSYNC"
-and
-.IR "O_SYNC"
-.
-.TP
-.B ENOSYS
-This function is not implemented.
-.PP
-When the sources are compiled with
-.IR "_FILE_OFFSET_BITS == 64"
- this
-function is in fact
-.IR "aio_return64"
-since the LFS interface
-transparently replaces the normal implementation.
-.SH "SEE ALSO"
-.BR aio(3),
-.BR aio_cancel(3),
-.BR aio_cancel64(3),
-.BR aio_error(3),
-.BR aio_error64(3),
-.BR aio_fsync64(3),
-.BR aio_init(3),
-.BR aio_read(3),
-.BR aio_read64(3),
-.BR aio_return(3),
-.BR aio_return64(3),
-.BR aio_suspend(3),
-.BR aio_suspend64(3),
-.BR aio_write(3),
-.BR aio_write64(3),
-.BR errno(3),
+++ /dev/null
-.TH aio_fsync64 3 2002-09-12 "Linux 2.4" Linux AIO"
-.SH NAME
-aio_fsync64 \- Synchronize a file's complete in-core state with that on disk
-.SH SYNOPSYS
-.nf
-.B #include <errno.h>
-.sp
-.br
-.B #include <aio.h>
-.sp
-.br
-.BI "int aio_fsync64 (int op, struct aiocb64 *aiocbp)"
-.fi
-.SH DESCRIPTION
-This function is similar to
-.IR aio_fsync
-with the only difference
-that the argument is a reference to a variable of type
-.IR "struct aiocb64".
-
-When the sources are compiled with
-.IR "_FILE_OFFSET_BITS == 64"
-this
-function is available under the name
-.IR aio_fsync
-and so
-transparently replaces the interface for small files on 32 bit
-machines.
-.SH "RETURN VALUES"
-See
-.IR aio_fsync.
-.SH ERRORS
-See
-.IR aio_fsync.
-.SH "SEE ALSO"
-.BR aio(3),
-.BR aio_cancel(3),
-.BR aio_cancel64(3),
-.BR aio_error(3),
-.BR aio_error64(3),
-.BR aio_fsync(3),
-.BR aio_init(3),
-.BR aio_read(3),
-.BR aio_read64(3),
-.BR aio_return(3),
-.BR aio_return64(3),
-.BR aio_suspend(3),
-.BR aio_suspend64(3),
-.BR aio_write(3),
-.BR aio_write64(3),
-.BR errno(3),
+++ /dev/null
-.TH aio_init 3 2002-09-12 "Linux 2.4" Linux AIO"
-.SH NAME
-aio_init \- How to optimize the AIO implementation
-.SH SYNOPSYS
-.nf
-.B #include <errno.h>
-.sp
-.br
-.B #include <aio.h>
-.sp
-.br
-.BI "void aio_init (const struct aioinit *init)"
-.fi
-.SH DESCRIPTION
-
-The POSIX standard does not specify how the AIO functions are
-implemented. They could be system calls, but it is also possible to
-emulate them at userlevel.
-
-At the point of this writing, the available implementation is a userlevel
-implementation which uses threads for handling the enqueued requests.
-While this implementation requires making some decisions about
-limitations, hard limitations are something which is best avoided
-in the GNU C library. Therefore, the GNU C library provides a means
-for tuning the AIO implementation according to the individual use.
-
-.BI "struct aioinit"
-.PP
-This data type is used to pass the configuration or tunable parameters
-to the implementation. The program has to initialize the members of
-this struct and pass it to the implementation using the
-.IR aio_init
-function.
-.TP
-.B "int aio_threads"
-This member specifies the maximal number of threads which may be used
-at any one time.
-.TP
-.B "int aio_num"
-This number provides an estimate on the maximal number of simultaneously
-enqueued requests.
-.TP
-.B "int aio_locks"
-Unused.
-.TP
-.B "int aio_usedba"
-Unused.
-.TP
-.B "int aio_debug"
-Unused.
-.TP
-.B "int aio_numusers"
-Unused.
-.TP
-.B "int aio_reserved[2]"
-Unused.
-.PP
-This function must be called before any other AIO function. Calling it
-is completely voluntary, as it is only meant to help the AIO
-implementation perform better.
-
-Before calling the
-.IR aio_init
-, function the members of a variable of
-type
-.IR "struct aioinit"
-must be initialized. Then a reference to
-this variable is passed as the parameter to
-.IR aio_init
-which itself
-may or may not pay attention to the hints.
-
-It is a extension which follows a proposal from the SGI implementation in
-.IR Irix 6
-. It is not covered by POSIX.1b or Unix98.
-.SH "RETURN VALUES"
-The function has no return value.
-.SH ERRORS
-The function has no error cases defined.
-.SH "SEE ALSO"
-.BR aio(3),
-.BR aio_cancel(3),
-.BR aio_cancel64(3),
-.BR aio_error(3),
-.BR aio_error64(3),
-.BR aio_fsync(3),
-.BR aio_fsync64(3),
-.BR aio_read(3),
-.BR aio_read64(3),
-.BR aio_return(3),
-.BR aio_return64(3),
-.BR aio_suspend(3),
-.BR aio_suspend64(3),
-.BR aio_write(3),
-.BR aio_write64(3),
-.BR errno(3),
+++ /dev/null
-.TH aio_read 3 2002-09-12 "Linux 2.4" Linux AIO"
-.SH NAME
-aio_read \- Initiate an asynchronous read operation
-.SH SYNOPSYS
-.nf
-.B #include <errno.h>
-.sp
-.br
-.B #include <aio.h>
-.sp
-.br
-.BI "int aio_read (struct aiocb *aiocbp)"
-.fi
-.SH DESCRIPTION
-This function initiates an asynchronous read operation. It
-immediately returns after the operation was enqueued or when an
-error was encountered.
-
-The first
-.IR "aiocbp->aio_nbytes"
-bytes of the file for which
-.IR "aiocbp->aio_fildes"
-is a descriptor are written to the buffer
-starting at
-.IR "aiocbp->aio_buf"
-. Reading starts at the absolute
-position
-.IR "aiocbp->aio_offset"
-in the file.
-
-If prioritized I/O is supported by the platform the
-.IR "aiocbp->aio_reqprio"
-value is used to adjust the priority before
-the request is actually enqueued.
-
-The calling process is notified about the termination of the read
-request according to the
-.IR "aiocbp->aio_sigevent"
-value.
-
-.SH "RETURN VALUES"
-When
-.IR "aio_read"
-returns, the return value is zero if no error
-occurred that can be found before the process is enqueued. If such an
-early error is found, the function returns
-.IR -1
-and sets
-.IR "errno".
-
-.PP
-If
-.IR "aio_read"
-returns zero, the current status of the request
-can be queried using
-.IR "aio_error"
-and
-.IR "aio_return"
-functions.
-As long as the value returned by
-.IR "aio_error"
-is
-.IR "EINPROGRESS"
-the operation has not yet completed. If
-.IR "aio_error"
-returns zero,
-the operation successfully terminated, otherwise the value is to be
-interpreted as an error code. If the function terminated, the result of
-the operation can be obtained using a call to
-.IR "aio_return"
-. The
-returned value is the same as an equivalent call to
-.IR "read"
-would
-have returned.
-When the sources are compiled with
-.IR "_FILE_OFFSET_BITS == 64"
-this
-function is in fact
-.IR "aio_read64"
-since the LFS interface transparently
-replaces the normal implementation.
-
-.SH ERRORS
-In the case of an early error:
-.TP
-.B EAGAIN
-The request was not enqueued due to (temporarily) exceeded resource
-limitations.
-.TP
-.B ENOSYS
-The
-.IR "aio_read"
-function is not implemented.
-.TP
-.B EBADF
-The
-.IR "aiocbp->aio_fildes"
-descriptor is not valid. This condition
-need not be recognized before enqueueing the request and so this error
-might also be signaled asynchronously.
-.TP
-.B EINVAL
-The
-.IR "aiocbp->aio_offset"
-or
-.IR "aiocbp->aio_reqpiro"
-value is
-invalid. This condition need not be recognized before enqueueing the
-request and so this error might also be signaled asynchronously.
-
-.PP
-In the case of a normal return, possible error codes returned by
-.IR "aio_error"
-are:
-.TP
-.B EBADF
-The
-.IR "aiocbp->aio_fildes"
-descriptor is not valid.
-.TP
-.B ECANCELED
-The operation was canceled before the operation was finished
-.TP
-.B EINVAL
-The
-.IR "aiocbp->aio_offset"
-value is invalid.
-.PP
-.SH "SEE ALSO"
-.BR aio(3),
-.BR aio_cancel(3),
-.BR aio_cancel64(3),
-.BR aio_error(3),
-.BR aio_error64(3),
-.BR aio_fsync(3),
-.BR aio_fsync64(3),
-.BR aio_init(3),
-.BR aio_read64(3),
-.BR aio_return(3),
-.BR aio_return64(3),
-.BR aio_suspend(3),
-.BR aio_suspend64(3),
-.BR aio_write(3),
-.BR aio_write64(3),
-.BR errno(3),
+++ /dev/null
-.TH aio_read64 3 2002-09-12 "Linux 2.4" Linux AIO"
-.SH NAME
-aio_read64 \- Initiate an asynchronous read operation
-.SH SYNOPSYS
-.nf
-.B #include <errno.h>
-.br
-.B #include <aio.h>
-.sp
-.br
-.BI "int aio_read64 (struct aiocb *aiocbp)"
-.fi
-.SH DESCRIPTION
-This function is similar to the
-.IR "aio_read"
-function. The only
-difference is that on
-.IR "32 bit"
-machines, the file descriptor should
-be opened in the large file mode. Internally,
-.IR "aio_read64"
-uses
-functionality equivalent to
-.IR "lseek64"
-to position the file descriptor correctly for the reading,
-as opposed to
-.IR "lseek"
-functionality used in
-.IR "aio_read".
-
-When the sources are compiled with
-.IR "_FILE_OFFSET_BITS == 64"
-, this
-function is available under the name
-.IR "aio_read"
-and so transparently
-replaces the interface for small files on 32 bit machines.
-.SH "RETURN VALUES"
-See
-.IR aio_read.
-.SH ERRORS
-See
-.IR aio_read.
-.SH "SEE ALSO"
-.BR aio(3),
-.BR aio_cancel(3),
-.BR aio_cancel64(3),
-.BR aio_error(3),
-.BR aio_error64(3),
-.BR aio_fsync(3),
-.BR aio_fsync64(3),
-.BR aio_init(3),
-.BR aio_read(3),
-.BR aio_return(3),
-.BR aio_return64(3),
-.BR aio_suspend(3),
-.BR aio_suspend64(3),
-.BR aio_write(3),
-.BR aio_write64(3),
-.BR errno(3),
+++ /dev/null
-.TH aio_return 3 2002-09-12 "Linux 2.4" Linux AIO"
-.SH NAME
-aio_return \- Retrieve status of asynchronous I/O operation
-.SH SYNOPSYS
-.nf
-.B #include <errno.h>
-.sp
-.br
-.B #include <aio.h>
-.sp
-.br
-.BI "ssize_t aio_return (const struct aiocb *aiocbp)"
-.fi
-.SH DESCRIPTION
-This function can be used to retrieve the return status of the operation
-carried out by the request described in the variable pointed to by
-.IR aiocbp
-. As long as the error status of this request as returned
-by
-.IR aio_error
-is
-.IR EINPROGRESS
-the return of this function is
-undefined.
-
-Once the request is finished this function can be used exactly once to
-retrieve the return value. Following calls might lead to undefined
-behavior.
-When the sources are compiled with
-.B "_FILE_OFFSET_BITS == 64"
-this function is in fact
-.IR aio_return64
-since the LFS interface
-transparently replaces the normal implementation.
-.SH "RETURN VALUES"
-The return value itself is the value which would have been
-returned by the
-.IR read
-,
-.IR write
-, or
-.IR fsync
-call.
-.SH ERRORS
-The function can return
-.TP
-.B ENOSYS
-if it is not implemented.
-.TP
-.B EINVAL
-if the
-.IR aiocbp
-parameter does not
-refer to an asynchronous operation whose return status is not yet known.
-.SH "SEE ALSO"
-.BR aio(3),
-.BR aio_cancel(3),
-.BR aio_cancel64(3),
-.BR aio_error(3),
-.BR aio_error64(3),
-.BR aio_fsync(3),
-.BR aio_fsync64(3),
-.BR aio_init(3),
-.BR aio_read(3),
-.BR aio_read64(3),
-.BR aio_return64(3),
-.BR aio_suspend(3),
-.BR aio_suspend64(3),
-.BR aio_write(3),
-.BR aio_write64(3),
-.BR errno(3),
+++ /dev/null
-.TH aio_read64 3 2002-09-12 "Linux 2.4" Linux AIO"
-.SH NAME
-aio_read64 \- Retrieve status of asynchronous I/O operation
-.SH SYNOPSYS
-.nf
-.B #include <errno.h>
-.sp
-.br
-.B #include <aio.h>
-.sp
-.br
-.BI "int aio_return64 (const struct aiocb64 *aiocbp)"
-.fi
-.SH DESCRIPTION
-This function is similar to
-.IR "aio_return"
-with the only difference
-that the argument is a reference to a variable of type
-.IR "struct aiocb64".
-
-When the sources are compiled with
-.IR "_FILE_OFFSET_BITS == 64"
-this
-function is available under the name
-.IR "aio_return"
-and so
-transparently replaces the interface for small files on 32 bit
-machines.
-.SH "RETURN VALUES"
-See
-.IR aio_return.
-.SH ERRORS
-See
-.IR aio_return.
-.SH "SEE ALSO"
-.BR aio(3),
-.BR aio_cancel(3),
-.BR aio_cancel64(3),
-.BR aio_error(3),
-.BR aio_error64(3),
-.BR aio_fsync(3),
-.BR aio_fsync64(3),
-.BR aio_init(3),
-.BR aio_read(3),
-.BR aio_read64(3),
-.BR aio_return(3),
-.BR aio_suspend(3),
-.BR aio_suspend64(3),
-.BR aio_write(3),
-.BR aio_write64(3),
-.BR errno(3),
+++ /dev/null
-.TH aio_suspend 3 2002-09-12 "Linux 2.4" Linux AIO"
-.SH NAME
-aio_suspend \- Wait until one or more requests of a specific set terminates.
-.SH SYNOPSYS
-.nf
-.B "#include <errno.h>"
-.sp
-.br
-.B "#include <aio.h>"
-.sp
-.br
-.BI "int aio_suspend (const struct aiocb *const list[], int nent, const struct timespec *timeout)"
-.fi
-.SH DESCRIPTION
-Another method of synchronization is to wait until one or more requests of a
-specific set terminated. This could be achieved by the
-.IR "aio_*"
-functions to notify the initiating process about the termination but in
-some situations this is not the ideal solution. In a program which
-constantly updates clients somehow connected to the server it is not
-always the best solution to go round robin since some connections might
-be slow. On the other hand letting the
-.IR "aio_*"
-function notify the
-caller might also be not the best solution since whenever the process
-works on preparing data for on client it makes no sense to be
-interrupted by a notification since the new client will not be handled
-before the current client is served. For situations like this
-.IR "aio_suspend"
-should be used.
-.PP
-When calling this function, the calling thread is suspended until at
-least one of the requests pointed to by the
-.IR "nent"
-elements of the
-array
-.IR "list"
-has completed. If any of the requests has already
-completed at the time
-.IR "aio_suspend"
-is called, the function returns
-immediately. Whether a request has terminated or not is determined by
-comparing the error status of the request with
-.IR "EINPROGRESS"
-. If
-an element of
-.IR "list"
-is
-.IR "NULL"
-, the entry is simply ignored.
-
-If no request has finished, the calling process is suspended. If
-.IR "timeout"
-is
-.IR "NULL"
-, the process is not woken until a request
-has finished. If
-.IR "timeout"
-is not
-.IR "NULL"
-, the process remains
-suspended at least as long as specified in
-.IR "timeout"
-. In this case,
-.IR "aio_suspend"
-returns with an error.
-.PP
-When the sources are compiled with
-.IR "_FILE_OFFSET_BITS == 64"
-this
-function is in fact
-.IR "aio_suspend64"
-since the LFS interface
-transparently replaces the normal implementation.
-.SH "RETURN VALUES"
-The return value of the function is
-.IR 0
-if one or more requests
-from the
-.IR "list"
-have terminated. Otherwise the function returns
-.IR -1
-and
-.IR "errno"
-is set.
-.SH ERRORS
-.TP
-.B EAGAIN
-None of the requests from the
-.IR "list"
-completed in the time specified
-by
-.IR "timeout"
-.
-.TP
-.B EINTR
-A signal interrupted the
-.IR "aio_suspend"
-function. This signal might
-also be sent by the AIO implementation while signalling the termination
-of one of the requests.
-.TP
-.B ENOSYS
-The
-.IR "aio_suspend"
-function is not implemented.
-.SH "SEE ALSO"
-.BR aio(3),
-.BR aio_cancel(3),
-.BR aio_cancel64(3),
-.BR aio_error(3),
-.BR aio_error64(3),
-.BR aio_fsync(3),
-.BR aio_fsync64(3),
-.BR aio_init(3),
-.BR aio_read(3),
-.BR aio_read64(3),
-.BR aio_return(3),
-.BR aio_return64(3),
-.BR aio_suspend64(3),
-.BR aio_write(3),
-.BR aio_write64(3),
-.BR errno(3),
+++ /dev/null
-.TH aio_suspend64 3 2002-09-12 "Linux 2.4" Linux AIO"
-.SH NAME
-aio_suspend64 \- Wait until one or more requests of a specific set terminates
-.SH SYNOPSYS
-.nf
-.B #include <errno.h>
-.sp
-.br
-.B #include <aio.h>
-.sp
-.br
-.BI "int aio_suspend64 (const struct aiocb64 *const list[], int nent, const struct timespec *timeout)"
-.fi
-.SH DESCRIPTION
-This function is similar to
-.IR "aio_suspend"
-with the only difference
-that the argument is a reference to a variable of type
-.IR "struct aiocb64".
-
-When the sources are compiled with
-.IR "_FILE_OFFSET_BITS == 64"
-this
-function is available under the name
-.IR "aio_suspend"
-and so
-transparently replaces the interface for small files on 32 bit
-machines.
-.SH "RETURN VALUES"
-See
-.IR aio_suspend.
-.SH ERRORS
-See
-.IR aio_suspend.
-.SH "SEE ALSO"
-.BR aio(3),
-.BR aio_cancel(3),
-.BR aio_cancel64(3),
-.BR aio_error(3),
-.BR aio_error64(3),
-.BR aio_fsync(3),
-.BR aio_fsync64(3),
-.BR aio_init(3),
-.BR aio_read(3),
-.BR aio_read64(3),
-.BR aio_return(3),
-.BR aio_return64(3),
-.BR aio_suspend(3),
-.BR aio_write(3),
-.BR aio_write64(3),
-.BR errno(3),
+++ /dev/null
-.TH aio_write 3 2002-09-12 "Linux 2.4" Linux AIO"
-.SH NAME
-aio_write \- Initiate an asynchronous write operation
-.SH SYNOPSYS
-.nf
-.B #include <errno.h>
-.sp
-.br
-.B #include <aio.h>
-.sp
-.br
-.BI "int aio_write (struct aiocb * aiocbp);"
-.fi
-.SH DESCRIPTION
-This function initiates an asynchronous write operation. The function
-call immediately returns after the operation was enqueued or if before
-this happens an error was encountered.
-
-The first
-.IR "aiocbp->aio_nbytes"
-bytes from the buffer starting at
-.IR "aiocbp->aio_buf"
-are written to the file for which
-.IR "aiocbp->aio_fildes"
-is an descriptor, starting at the absolute
-position
-.IR "aiocbp->aio_offset"
-in the file.
-
-If prioritized I/O is supported by the platform, the
-.IR "aiocbp->aio_reqprio "
-value is used to adjust the priority before
-the request is actually enqueued.
-
-The calling process is notified about the termination of the read
-request according to the
-.IR "aiocbp->aio_sigevent"
-value.
-
-When
-.IR "aio_write"
-returns, the return value is zero if no error
-occurred that can be found before the process is enqueued. If such an
-early error is found the function returns
-.IR -1
-and sets
-.IR "errno"
-to one of the following values.
-
-.TP
-.B EAGAIN
-The request was not enqueued due to (temporarily) exceeded resource
-limitations.
-.TP
-.B ENOSYS
-The
-.IR "aio_write"
-function is not implemented.
-.TP
-.B EBADF
-The
-.IR "aiocbp->aio_fildes"
-descriptor is not valid. This condition
-may not be recognized before enqueueing the request, and so this error
-might also be signaled asynchronously.
-.TP
-.B EINVAL
-The
-.IR "aiocbp->aio_offset"
-or
-.IR "aiocbp->aio_reqprio"
-value is
-invalid. This condition may not be recognized before enqueueing the
-request and so this error might also be signaled asynchronously.
-.PP
-
-In the case
-.IR "aio_write"
-returns zero, the current status of the
-request can be queried using
-.IR "aio_error"
-and
-.IR "aio_return"
-functions. As long as the value returned by
-.IR "aio_error"
-is
-.IR "EINPROGRESS"
-the operation has not yet completed. If
-.IR "aio_error"
-returns zero, the operation successfully terminated,
-otherwise the value is to be interpreted as an error code. If the
-function terminated, the result of the operation can be get using a call
-to
-.IR "aio_return"
-. The returned value is the same as an equivalent
-call to
-.IR "read"
-would have returned. Possible error codes returned
-by
-.IR "aio_error"
-are:
-
-.TP
-.B EBADF
-The
-.IR "aiocbp->aio_fildes"
-descriptor is not valid.
-.TP
-.B ECANCELED
-The operation was canceled before the operation was finished.
-.TP
-.B EINVAL
-The
-.IR "aiocbp->aio_offset"
-value is invalid.
-.PP
-When the sources are compiled with
-.IR "_FILE_OFFSET_BITS == 64"
-, this
-function is in fact
-.IR "aio_write64"
-since the LFS interface transparently
-replaces the normal implementation.
-.SH "RETURN VALUES"
-When
-.IR "aio_write"
-returns, the return value is zero if no error
-occurred that can be found before the process is enqueued. If such an
-early error is found the function returns
-.IR -1
-and sets
-.IR "errno"
-to one of the following values.
-.SH ERRORS
-.TP
-.B EAGAIN
-The request was not enqueued due to (temporarily) exceeded resource
-limitations.
-.TP
-.B ENOSYS
-The
-.IR "aio_write"
-function is not implemented.
-.TP
-.B EBADF
-The
-.IR "aiocbp->aio_fildes"
-descriptor is not valid. This condition
-may not be recognized before enqueueing the request, and so this error
-might also be signaled asynchronously.
-.TP
-.B EINVAL
-The
-.IR "aiocbp->aio_offset"
-or
-.IR "aiocbp->aio_reqprio"
-value is
-invalid. This condition may not be recognized before enqueueing the
-request and so this error might also be signaled asynchronously.
-.SH "SEE ALSO"
-.BR aio(3),
-.BR aio_cancel(3),
-.BR aio_cancel64(3),
-.BR aio_error(3),
-.BR aio_error64(3),
-.BR aio_fsync(3),
-.BR aio_fsync64(3),
-.BR aio_init(3),
-.BR aio_read(3),
-.BR aio_read64(3),
-.BR aio_return(3),
-.BR aio_return64(3),
-.BR aio_suspend(3),
-.BR aio_suspend64(3),
-.BR aio_write64(3),
-.BR errno(3),
+++ /dev/null
-.TH aio_write64 3 2002-09-12 "Linux 2.4" Linux AIO"
-.SH NAME
-aio_write64 \- Initiate an asynchronous write operation
-.SH SYNOPSYS
-.nf
-.B #include <errno.h>
-.sp
-.br
-.B #include <aio.h>
-.sp
-.br
-.BI "int aio_write64 (struct aiocb *aiocbp)"
-.fi
-.SH DESCRIPTION
-This function is similar to the
-.IR "aio_write"
-function. The only
-difference is that on
-.IR "32 bit"
-machines the file descriptor should
-be opened in the large file mode. Internally
-.IR "aio_write64"
-uses
-functionality equivalent to
-.IR "lseek64"
-to position the file descriptor correctly for the writing,
-as opposed to
-.IR "lseek"
-functionality used in
-.IR "aio_write".
-
-When the sources are compiled with
-.IR "_FILE_OFFSET_BITS == 64"
-, this
-function is available under the name
-.IR "aio_write"
-and so transparently
-replaces the interface for small files on 32 bit machines.
-.SH "RETURN VALUES"
-See
-.IR aio_write.
-.SH ERRORS
-See
-.IR aio_write.
-.SH "SEE ALSO"
-.BR aio(3),
-.BR aio_cancel(3),
-.BR aio_cancel64(3),
-.BR aio_error(3),
-.BR aio_error64(3),
-.BR aio_fsync(3),
-.BR aio_fsync64(3),
-.BR aio_init(3),
-.BR aio_read(3),
-.BR aio_read64(3),
-.BR aio_return(3),
-.BR aio_return64(3),
-.BR aio_suspend(3),
-.BR aio_suspend64(3),
-.BR aio_write(3),
-.BR errno(3),
+++ /dev/null
-.\"/* sys_io_cancel:
-.\" * Attempts to cancel an iocb previously passed to io_submit. If
-.\" * the operation is successfully cancelled, the resulting event is
-.\" * copied into the memory pointed to by result without being placed
-.\" * into the completion queue and 0 is returned. May fail with
-.\" * -EFAULT if any of the data structures pointed to are invalid.
-.\" * May fail with -EINVAL if aio_context specified by ctx_id is
-.\" * invalid. May fail with -EAGAIN if the iocb specified was not
-.\" * cancelled. Will fail with -ENOSYS if not implemented.
-.\" */
-.\"
-.TH io_cancel 2 2002-09-03 "Linux 2.4" "Linux AIO"
-.SH NAME
-io_cancel \- cancel io requests
-.SH SYNOPSIS
-.B #include <errno.h>
-.br
-.B #include <libaio.h>
-.LP
-.BI "int io_submit(io_context_t " ctx ", struct iocb *" iocb ", struct io_event *" result ");"
-
+++ /dev/null
-.\"/* sys_io_destroy:
-.\" * Destroy the aio_context specified. May cancel any outstanding
-.\" * AIOs and block on completion. Will fail with -ENOSYS if not
-.\" * implemented. May fail with -EFAULT if the context pointed to
-.\" * is invalid.
-.\" */
-.\" libaio provides this as io_queue_release.
-.TH io_destroy 2 2002-09-03 "Linux 2.4" "Linux AIO"
-.SH NAME
-io_destroy \- destroy an io context
-.SH SYNOPSIS
-.B #include <errno.h>
-.br
-.B #include <libaio.h>
-.LP
-.BI "int io_destroy(io_context_t " ctx ");"
-
+++ /dev/null
-./"/* io_getevents:
-./" * Attempts to read at least min_nr events and up to nr events from
-./" * the completion queue for the aio_context specified by ctx_id. May
-./" * fail with -EINVAL if ctx_id is invalid, if min_nr is out of range,
-./" * if nr is out of range, if when is out of range. May fail with
-./" * -EFAULT if any of the memory specified to is invalid. May return
-./" * 0 or < min_nr if no events are available and the timeout specified
-./" * by when has elapsed, where when == NULL specifies an infinite
-./" * timeout. Note that the timeout pointed to by when is relative and
-./" * will be updated if not NULL and the operation blocks. Will fail
-./" * with -ENOSYS if not implemented.
-./" */
-./"asmlinkage long sys_io_getevents(io_context_t ctx_id,
-./" long min_nr,
-./" long nr,
-./" struct io_event *events,
-./" struct timespec *timeout)
-./"
-.TH io_getevents 2 2002-09-03 "Linux 2.4" "Linux AIO"
-.SH NAME
-io_getevents \- read resulting events from io requests
-.SH SYNOPSIS
-.B #include <errno.h>
-.br
-.B #include <libaio.h>
-.sp
-.BI "int io_getevents(io_context_t " ctx ", long " min_nr ", long " nr ", struct io_events *" events "[], struct timespec *" timeout ");"
-
-
+++ /dev/null
-./"/* sys_io_setup:
-./" * Create an aio_context capable of receiving at least nr_events.
-./" * ctxp must not point to an aio_context that already exists, and
-./" * must be initialized to 0 prior to the call. On successful
-./" * creation of the aio_context, *ctxp is filled in with the resulting
-./" * handle. May fail with -EINVAL if *ctxp is not initialized,
-./" * if the specified nr_events exceeds internal limits. May fail
-./" * with -EAGAIN if the specified nr_events exceeds the user's limit
-./" * of available events. May fail with -ENOMEM if insufficient kernel
-./" * resources are available. May fail with -EFAULT if an invalid
-./" * pointer is passed for ctxp. Will fail with -ENOSYS if not
-./" * implemented.
-./" */
-./" -- note: libaio is actually providing io_queue_init and io_queue_grow
-./" as separate functions. For now io_setup is the same as io_queue_grow.
+++ /dev/null
-.TH io_submit 2 2002-09-02 "Linux 2.4" "Linux AIO"
-.SH NAME
-io_submit \- submit io requests
-.SH SYNOPSIS
-.B #include <errno.h>
-.br
-.B #include <libaio.h>
-.LP
-.BI "int io_submit(io_context_t " ctx ", long " nr ", struct iocb *" iocbs "[]);"
-.SH DESCRIPTION
-.B io_submit
-submits to the io_context
-.I ctx
-up to
-.I nr
-I/O requests pointed to by the vector
-.IR iocbs .
-
-The
-.B iocb
-structure is defined as something like
-.sp
-.RS
-.nf
-struct iocb {
- void *data;
-.\" unsigned key;
- short aio_lio_opcode;
- short aio_reqprio;
- int aio_fildes;
-};
-.fi
-.RE
-.sp
-.I data
-is a an opaque pointer which will upon completion be returned in the
-.B io_event
-structure by
-.BR io_getevents (2).
-.\" and io_wait(2)
-Callers will typically use this to point directly or indirectly to a
-callback function.
-.sp
-.I aio_lio_opcode
-is the I/O operation requested. Callers will typically set this and the
-arguments to the I/O operation calling the
-.BR io_prep_ (3)
-function corresponding to the operation.
-.sp
-.I aio_reqprio
-is the priority of the request. Higher values have more priority; the
-normal priority is 0.
-.sp
-.I aio_fildes
-is the file descriptor for the I/O operation.
-Callers will typically set this and the
-arguments to the I/O operation calling the
-.BR io_prep_ *(3)
-function corresponding to the operation.
-.sp
-The caller may not modify the contents or resubmit a submitted
-.B iocb
-structure until after the operation completes or is canceled.
-The implementation of
-.BR io_submit (2)
-is permitted to modify reserved fields of the
-.B iocb
-structure.
-.SH "RETURN VALUES"
-If able to submit at least one iocb,
-.B io_submit
-returns the number of iocbs submitted successfully. Otherwise,
-.RI - error
-is returned, where
-.I error
-is one of the Exxx values defined in the Errors section.
-.SH ERRORS
-.TP
-.B EFAULT
-.I iocbs
-referenced data outside of the program's accessible address space.
-.TP
-.B EINVAL
-.I nr
-is negative,
-.I ctx
-refers to an uninitialized aio context, the iocb pointed to by
-.IR iocbs [0]
-is improperly initialized or specifies an unsupported operation.
-.TP
-.B EBADF
-The iocb pointed to by
-.IR iocbs [0]
-contains a file descriptor that does not exist.
-.TP
-.B EAGAIN
-Insufficient resources were available to queue any operations.
-.SH "SEE ALSO"
-.BR io_setup (2),
-.BR io_destroy (2),
-.BR io_getevents (2),
-.\".BR io_wait (2),
-.BR io_prep_pread (3),
-.BR io_prep_pwrite (3),
-.BR io_prep_fsync (3),
-.BR io_prep_fdsync (3),
-.BR io_prep_noop (3),
-.BR io_cancel (2),
-.BR errno (3)
+++ /dev/null
-.TH lio_listio 3 2002-09-12 "Linux 2.4" Linux AIO"
-.SH NAME
-lio_listio - List directed I/O
-.SH SYNOPSYS
-.B #include <errno.h>
-.br
-.B #include <libaio.h>
-.LP
-.BI "int lio_listio (int mode, struct aiocb *const list[], int nent, struct sigevent *sig)"
-.nf
-.SH DESCRIPTION
-
-Besides these functions with the more or less traditional interface,
-POSIX.1b also defines a function which can initiate more than one
-operation at a time, and which can handle freely mixed read and write
-operations. It is therefore similar to a combination of
-.IR readv
-and
-.IR "writev"
-.
-
-The
-.IR "lio_listio"
-function can be used to enqueue an arbitrary
-number of read and write requests at one time. The requests can all be
-meant for the same file, all for different files or every solution in
-between.
-
-.IR "lio_listio"
-gets the
-.IR "nent"
-requests from the array pointed to
-by
-.IR "list"
-. The operation to be performed is determined by the
-.IR "aio_lio_opcode"
-member in each element of
-.IR "list"
-. If this
-field is
-.B "LIO_READ"
-a read operation is enqueued, similar to a call
-of
-.IR "aio_read"
-for this element of the array (except that the way
-the termination is signalled is different, as we will see below). If
-the
-.IR "aio_lio_opcode"
-member is
-.B "LIO_WRITE"
-a write operation
-is enqueued. Otherwise the
-.IR "aio_lio_opcode"
-must be
-.B "LIO_NOP"
-in which case this element of
-.IR "list"
-is simply ignored. This
-``operation'' is useful in situations where one has a fixed array of
-.IR "struct aiocb"
-elements from which only a few need to be handled at
-a time. Another situation is where the
-.IR "lio_listio"
-call was
-canceled before all requests are processed and the remaining requests have to be reissued.
-
-The other members of each element of the array pointed to by
-.IR "list"
-must have values suitable for the operation as described in
-the documentation for
-.IR "aio_read"
-and
-.IR "aio_write"
-above.
-
-The
-.IR "mode"
-argument determines how
-.IR "lio_listio"
-behaves after
-having enqueued all the requests. If
-.IR "mode"
-is
-.B "LIO_WAIT"
-it
-waits until all requests terminated. Otherwise
-.IR "mode"
-must be
-.B "LIO_NOWAIT"
-and in this case the function returns immediately after
-having enqueued all the requests. In this case the caller gets a
-notification of the termination of all requests according to the
-.IR "sig"
-parameter. If
-.IR "sig"
-is
-.B "NULL"
-no notification is
-send. Otherwise a signal is sent or a thread is started, just as
-described in the description for
-.IR "aio_read"
-or
-.IR "aio_write"
-.
-
-When the sources are compiled with
-.B "_FILE_OFFSET_BITS == 64"
-, this
-function is in fact
-.IR "lio_listio64"
-since the LFS interface
-transparently replaces the normal implementation.
-.SH "RETURN VALUES"
-If
-.IR "mode"
-is
-.B "LIO_WAIT"
-, the return value of
-.IR "lio_listio"
-is
-.IR 0
-when all requests completed successfully. Otherwise the
-function return
-.IR 1
-and
-.IR "errno"
-is set accordingly. To find
-out which request or requests failed one has to use the
-.IR "aio_error"
-function on all the elements of the array
-.IR "list"
-.
-
-In case
-.IR "mode"
-is
-.B "LIO_NOWAIT"
-, the function returns
-.IR 0
-if
-all requests were enqueued correctly. The current state of the requests
-can be found using
-.IR "aio_error"
-and
-.IR "aio_return"
-as described
-above. If
-.IR "lio_listio"
-returns
-.IR -1
-in this mode, the
-global variable
-.IR "errno"
-is set accordingly. If a request did not
-yet terminate, a call to
-.IR "aio_error"
-returns
-.B "EINPROGRESS"
-. If
-the value is different, the request is finished and the error value (or
-
-.IR 0
-) is returned and the result of the operation can be retrieved
-using
-.IR "aio_return"
-.
-.SH ERRORS
-Possible values for
-.IR "errno"
-are:
-
-.TP
-.B EAGAIN
-The resources necessary to queue all the requests are not available at
-the moment. The error status for each element of
-.IR "list"
-must be
-checked to determine which request failed.
-
-Another reason could be that the system wide limit of AIO requests is
-exceeded. This cannot be the case for the implementation on GNU systems
-since no arbitrary limits exist.
-.TP
-.B EINVAL
-The
-.IR "mode"
-parameter is invalid or
-.IR "nent"
-is larger than
-.B "AIO_LISTIO_MAX"
-.
-.TP
-.B EIO
-One or more of the request's I/O operations failed. The error status of
-each request should be checked to determine which one failed.
-.TP
-.B ENOSYS
-The
-.IR "lio_listio"
-function is not supported.
-.PP
-
-If the
-.IR "mode"
-parameter is
-.B "LIO_NOWAIT"
-and the caller cancels
-a request, the error status for this request returned by
-.IR "aio_error"
-is
-.B "ECANCELED"
-.
-.SH "SEE ALSO"
-.BR aio(3),
-.BR aio_cancel(3),
-.BR aio_cancel64(3),
-.BR aio_error(3),
-.BR aio_error64(3),
-.BR aio_fsync(3),
-.BR aio_fsync64(3),
-.BR aio_init(3),
-.BR aio_read(3),
-.BR aio_read64(3),
-.BR aio_return(3),
-.BR aio_return64(3),
-.BR aio_suspend(3),
-.BR aio_suspend64(3),
-.BR aio_write(3),
-.BR aio_write64(3)
+++ /dev/null
-.TH lio_listio64 3 2002-09-12 "Linux 2.4" Linux AIO"
-.SH NAME
-lio_listio64 \- List directed I/O
-.SH SYNOPSYS
-.B #include <errno.h>
-.br
-.B #include <libaio.h>
-.LP
-.BI "int lio_listio64 (int mode, struct aiocb *const list[], int nent, struct sigevent *sig)"
-.nf
-.SH DESCRIPTION
-This function is similar to the
-.IR "code{lio_listio"
-function. The only
-difference is that on
-.IR "32 bit"
-machines, the file descriptor should
-be opened in the large file mode. Internally,
-.IR "lio_listio64"
-uses
-functionality equivalent to
-.IR lseek64"
-to position the file descriptor correctly for the reading or
-writing, as opposed to
-.IR "lseek"
-functionality used in
-.IR "lio_listio".
-
-When the sources are compiled with
-.IR "_FILE_OFFSET_BITS == 64"
-, this
-function is available under the name
-.IR "lio_listio"
-and so
-transparently replaces the interface for small files on 32 bit
-machines.
-.SH "RETURN VALUES"
-.SH ERRORS
-.SH "SEE ALSO"
includedir=$(prefix)/include
libdir=$(prefix)/lib
-ARCH := $(shell uname -m | sed -e s/i.86/i386/)
-CFLAGS := -nostdlib -nostartfiles -Wall -I. -g -fomit-frame-pointer -O2 -fPIC
+CFLAGS ?= -g -fomit-frame-pointer -O2
+CFLAGS += -nostdlib -nostartfiles -Wall -I. -fPIC
SO_CFLAGS=-shared $(CFLAGS)
L_CFLAGS=$(CFLAGS)
LINK_FLAGS=
+LINK_FLAGS+=$(LDFLAGS)
soname=libaio.so.1
minor=0
%.ol: %.c
$(CC) $(L_CFLAGS) -c -o $@ $<
-
+AR ?= ar
+RANLIB ?= ranlib
libaio.a: $(libaio_objs)
rm -f libaio.a
- ar r libaio.a $^
- ranlib libaio.a
+ $(AR) r libaio.a $^
+ $(RANLIB) libaio.a
$(libname): $(libaio_sobjs) libaio.map
$(CC) $(SO_CFLAGS) -Wl,--version-script=libaio.map -Wl,-soname=$(soname) -o $@ $(libaio_sobjs) $(LINK_FLAGS)
IO_CMD_PWRITEV = 8,
} io_iocb_cmd_t;
-#if defined(__i386__) /* little endian, 32 bits */
+/* little endian, 32 bits */
+#if defined(__i386__) || (defined(__arm__) && !defined(__ARMEB__)) || \
+ defined(__sh__) || defined(__bfin__) || defined(__MIPSEL__) || \
+ defined(__cris__)
#define PADDED(x, y) x; unsigned y
#define PADDEDptr(x, y) x; unsigned y
#define PADDEDul(x, y) unsigned long x; unsigned y
-#elif defined(__ia64__) || defined(__x86_64__) || defined(__alpha__)
+
+/* little endian, 64 bits */
+#elif defined(__ia64__) || defined(__x86_64__) || defined(__alpha__) || \
+ (defined(__aarch64__) && defined(__AARCH64EL__))
#define PADDED(x, y) x, y
#define PADDEDptr(x, y) x
#define PADDEDul(x, y) unsigned long x
-#elif defined(__powerpc64__) /* big endian, 64 bits */
-#define PADDED(x, y) unsigned y; x
-#define PADDEDptr(x,y) x
-#define PADDEDul(x, y) unsigned long x
-#elif defined(__PPC__) /* big endian, 32 bits */
-#define PADDED(x, y) unsigned y; x
-#define PADDEDptr(x, y) unsigned y; x
-#define PADDEDul(x, y) unsigned y; unsigned long x
-#elif defined(__s390x__) /* big endian, 64 bits */
+
+/* big endian, 64 bits */
+#elif defined(__powerpc64__) || defined(__s390x__) || \
+ (defined(__sparc__) && defined(__arch64__)) || \
+ (defined(__aarch64__) && defined(__AARCH64EB__))
#define PADDED(x, y) unsigned y; x
#define PADDEDptr(x,y) x
#define PADDEDul(x, y) unsigned long x
-#elif defined(__s390__) /* big endian, 32 bits */
-#define PADDED(x, y) unsigned y; x
-#define PADDEDptr(x, y) unsigned y; x
-#define PADDEDul(x, y) unsigned y; unsigned long x
-#elif defined(__arm__)
-# if defined (__ARMEB__) /* big endian, 32 bits */
+
+/* big endian, 32 bits */
+#elif defined(__PPC__) || defined(__s390__) || \
+ (defined(__arm__) && defined(__ARMEB__)) || \
+ defined(__sparc__) || defined(__MIPSEB__) || defined(__m68k__) || \
+ defined(__hppa__) || defined(__frv__) || defined(__avr32__)
#define PADDED(x, y) unsigned y; x
#define PADDEDptr(x, y) unsigned y; x
#define PADDEDul(x, y) unsigned y; unsigned long x
-# else /* little endian, 32 bits */
-#define PADDED(x, y) x; unsigned y
-#define PADDEDptr(x, y) x; unsigned y
-#define PADDEDul(x, y) unsigned long x; unsigned y
-# endif
+
#else
#error endian?
#endif
--- /dev/null
+/*
+ * linux/include/asm-arm/unistd.h
+ *
+ * Copyright (C) 2001-2005 Russell King
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Please forward _all_ changes to this file to rmk@arm.linux.org.uk,
+ * no matter what the change is. Thanks!
+ */
+
+#define __NR_io_setup 0
+#define __NR_io_destroy 1
+#define __NR_io_submit 2
+#define __NR_io_cancel 3
+#define __NR_io_getevents 4
+
+#define __sys2(x) #x
+#define __sys1(x) __sys2(x)
+
+#define __SYS_REG(name) register long __sysreg __asm__("w8") = __NR_##name;
+#define __SYS_REG_LIST(regs...) "r" (__sysreg) , ##regs
+#define __syscall(name) "svc\t#0"
+
+#define io_syscall1(type,fname,sname,type1,arg1) \
+type fname(type1 arg1) { \
+ __SYS_REG(sname) \
+ register long __x0 __asm__("x0") = (long)arg1; \
+ register long __res_x0 __asm__("x0"); \
+ __asm__ __volatile__ ( \
+ __syscall(sname) \
+ : "=r" (__res_x0) \
+ : __SYS_REG_LIST( "0" (__x0) ) \
+ : "memory" ); \
+ return (type) __res_x0; \
+}
+
+#define io_syscall2(type,fname,sname,type1,arg1,type2,arg2) \
+type fname(type1 arg1,type2 arg2) { \
+ __SYS_REG(sname) \
+ register long __x0 __asm__("x0") = (long)arg1; \
+ register long __x1 __asm__("x1") = (long)arg2; \
+ register long __res_x0 __asm__("x0"); \
+ __asm__ __volatile__ ( \
+ __syscall(sname) \
+ : "=r" (__res_x0) \
+ : __SYS_REG_LIST( "0" (__x0), "r" (__x1) ) \
+ : "memory" ); \
+ return (type) __res_x0; \
+}
+
+#define io_syscall3(type,fname,sname,type1,arg1,type2,arg2,type3,arg3) \
+type fname(type1 arg1,type2 arg2,type3 arg3) { \
+ __SYS_REG(sname) \
+ register long __x0 __asm__("x0") = (long)arg1; \
+ register long __x1 __asm__("x1") = (long)arg2; \
+ register long __x2 __asm__("x2") = (long)arg3; \
+ register long __res_x0 __asm__("x0"); \
+ __asm__ __volatile__ ( \
+ __syscall(sname) \
+ : "=r" (__res_x0) \
+ : __SYS_REG_LIST( "0" (__x0), "r" (__x1), "r" (__x2) ) \
+ : "memory" ); \
+ return (type) __res_x0; \
+}
+
+#define io_syscall4(type,fname,sname,type1,arg1,type2,arg2,type3,arg3,type4,arg4)\
+type fname(type1 arg1, type2 arg2, type3 arg3, type4 arg4) { \
+ __SYS_REG(sname) \
+ register long __x0 __asm__("x0") = (long)arg1; \
+ register long __x1 __asm__("x1") = (long)arg2; \
+ register long __x2 __asm__("x2") = (long)arg3; \
+ register long __x3 __asm__("x3") = (long)arg4; \
+ register long __res_x0 __asm__("x0"); \
+ __asm__ __volatile__ ( \
+ __syscall(sname) \
+ : "=r" (__res_x0) \
+ : __SYS_REG_LIST( "0" (__x0), "r" (__x1), "r" (__x2), "r" (__x3) ) \
+ : "memory" ); \
+ return (type) __res_x0; \
+}
+
+#define io_syscall5(type,fname,sname,type1,arg1,type2,arg2,type3,arg3,type4,arg4,type5,arg5) \
+type fname(type1 arg1, type2 arg2, type3 arg3, type4 arg4, type5 arg5) {\
+ __SYS_REG(sname) \
+ register long __x0 __asm__("x0") = (long)arg1; \
+ register long __x1 __asm__("x1") = (long)arg2; \
+ register long __x2 __asm__("x2") = (long)arg3; \
+ register long __x3 __asm__("x3") = (long)arg4; \
+ register long __x4 __asm__("x4") = (long)arg5; \
+ register long __res_x0 __asm__("x0"); \
+ __asm__ __volatile__ ( \
+ __syscall(sname) \
+ : "=r" (__res_x0) \
+ : __SYS_REG_LIST( "0" (__x0), "r" (__x1), "r" (__x2), \
+ "r" (__x3), "r" (__x4) ) \
+ : "memory" ); \
+ return (type) __res_x0; \
+}
--- /dev/null
+#include <errno.h>
+#include <unistd.h>
+#include <sys/syscall.h>
+
+#define _body_io_syscall(sname, args...) \
+{ \
+ int ret = syscall(__NR_##sname, ## args); \
+ return ret < 0 ? -errno : ret; \
+}
+
+#define io_syscall1(type,fname,sname,type1,arg1) \
+type fname(type1 arg1) \
+_body_io_syscall(sname, (long)arg1)
+
+#define io_syscall2(type,fname,sname,type1,arg1,type2,arg2) \
+type fname(type1 arg1,type2 arg2) \
+_body_io_syscall(sname, (long)arg1, (long)arg2)
+
+#define io_syscall3(type,fname,sname,type1,arg1,type2,arg2,type3,arg3) \
+type fname(type1 arg1,type2 arg2,type3 arg3) \
+_body_io_syscall(sname, (long)arg1, (long)arg2, (long)arg3)
+
+#define io_syscall4(type,fname,sname,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \
+type fname (type1 arg1, type2 arg2, type3 arg3, type4 arg4) \
+_body_io_syscall(sname, (long)arg1, (long)arg2, (long)arg3, (long)arg4)
+
+#define io_syscall5(type,fname,sname,type1,arg1,type2,arg2,type3,arg3,type4,arg4, type5,arg5) \
+type fname (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5) \
+_body_io_syscall(sname, (long)arg1, (long)arg2, (long)arg3, (long)arg4, (long)arg5)
--- /dev/null
+#include <errno.h>
+
+#define __NR_io_setup 268
+#define __NR_io_destroy 269
+#define __NR_io_submit 270
+#define __NR_io_cancel 271
+#define __NR_io_getevents 272
+
+#define io_syscall1(type,fname,sname,type1,arg1) \
+type fname(type1 arg1) \
+{ \
+long __res; \
+register long __g1 __asm__ ("g1") = __NR_##sname; \
+register long __o0 __asm__ ("o0") = (long)(arg1); \
+__asm__ __volatile__ ("t 0x10\n\t" \
+ "bcc 1f\n\t" \
+ "mov %%o0, %0\n\t" \
+ "sub %%g0, %%o0, %0\n\t" \
+ "1:\n\t" \
+ : "=r" (__res), "=&r" (__o0) \
+ : "1" (__o0), "r" (__g1) \
+ : "cc"); \
+return (type) __res; \
+}
+
+#define io_syscall2(type,fname,sname,type1,arg1,type2,arg2) \
+type fname(type1 arg1,type2 arg2) \
+{ \
+long __res; \
+register long __g1 __asm__ ("g1") = __NR_##sname; \
+register long __o0 __asm__ ("o0") = (long)(arg1); \
+register long __o1 __asm__ ("o1") = (long)(arg2); \
+__asm__ __volatile__ ("t 0x10\n\t" \
+ "bcc 1f\n\t" \
+ "mov %%o0, %0\n\t" \
+ "sub %%g0, %%o0, %0\n\t" \
+ "1:\n\t" \
+ : "=r" (__res), "=&r" (__o0) \
+ : "1" (__o0), "r" (__o1), "r" (__g1) \
+ : "cc"); \
+return (type) __res; \
+}
+
+#define io_syscall3(type,fname,sname,type1,arg1,type2,arg2,type3,arg3) \
+type fname(type1 arg1,type2 arg2,type3 arg3) \
+{ \
+long __res; \
+register long __g1 __asm__ ("g1") = __NR_##sname; \
+register long __o0 __asm__ ("o0") = (long)(arg1); \
+register long __o1 __asm__ ("o1") = (long)(arg2); \
+register long __o2 __asm__ ("o2") = (long)(arg3); \
+__asm__ __volatile__ ("t 0x10\n\t" \
+ "bcc 1f\n\t" \
+ "mov %%o0, %0\n\t" \
+ "sub %%g0, %%o0, %0\n\t" \
+ "1:\n\t" \
+ : "=r" (__res), "=&r" (__o0) \
+ : "1" (__o0), "r" (__o1), "r" (__o2), "r" (__g1) \
+ : "cc"); \
+return (type) __res; \
+}
+
+#define io_syscall4(type,fname,sname,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \
+type fname (type1 arg1, type2 arg2, type3 arg3, type4 arg4) \
+{ \
+long __res; \
+register long __g1 __asm__ ("g1") = __NR_##sname; \
+register long __o0 __asm__ ("o0") = (long)(arg1); \
+register long __o1 __asm__ ("o1") = (long)(arg2); \
+register long __o2 __asm__ ("o2") = (long)(arg3); \
+register long __o3 __asm__ ("o3") = (long)(arg4); \
+__asm__ __volatile__ ("t 0x10\n\t" \
+ "bcc 1f\n\t" \
+ "mov %%o0, %0\n\t" \
+ "sub %%g0, %%o0, %0\n\t" \
+ "1:\n\t" \
+ : "=r" (__res), "=&r" (__o0) \
+ : "1" (__o0), "r" (__o1), "r" (__o2), "r" (__o3), "r" (__g1) \
+ : "cc"); \
+return (type) __res; \
+}
+
+#define io_syscall5(type,fname,sname,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
+ type5,arg5) \
+type fname (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5) \
+{ \
+long __res; \
+register long __g1 __asm__ ("g1") = __NR_##sname; \
+register long __o0 __asm__ ("o0") = (long)(arg1); \
+register long __o1 __asm__ ("o1") = (long)(arg2); \
+register long __o2 __asm__ ("o2") = (long)(arg3); \
+register long __o3 __asm__ ("o3") = (long)(arg4); \
+register long __o4 __asm__ ("o4") = (long)(arg5); \
+__asm__ __volatile__ ("t 0x10\n\t" \
+ "bcc 1f\n\t" \
+ "mov %%o0, %0\n\t" \
+ "sub %%g0, %%o0, %0\n\t" \
+ "1:\n\t" \
+ : "=r" (__res), "=&r" (__o0) \
+ : "1" (__o0), "r" (__o1), "r" (__o2), "r" (__o3), "r" (__o4), "r" (__g1) \
+ : "cc"); \
+return (type) __res; \
+}
#include "syscall-alpha.h"
#elif defined(__arm__)
#include "syscall-arm.h"
+#elif defined(__sparc__)
+#include "syscall-sparc.h"
+#elif defined(__aarch64__)
+#include "syscall-arm64.h"
#else
-#error "add syscall-arch.h"
+#warning "using generic syscall method"
+#include "syscall-generic.h"
#endif
projects / platform / upstream / libaio.git / commitdiff