summaryrefslogtreecommitdiff
path: root/rt
diff options
context:
space:
mode:
Diffstat (limited to 'rt')
-rw-r--r--rt/Makefile42
-rw-r--r--rt/aio.h231
-rw-r--r--rt/aio_cancel.c172
-rw-r--r--rt/aio_error.c40
-rw-r--r--rt/aio_fsync.c42
-rw-r--r--rt/aio_misc.c306
-rw-r--r--rt/aio_misc.h45
-rw-r--r--rt/aio_read.c31
-rw-r--r--rt/aio_read64.c31
-rw-r--r--rt/aio_return.c40
-rw-r--r--rt/aio_suspend.c55
-rw-r--r--rt/aio_write.c31
-rw-r--r--rt/aio_write64.c31
-rw-r--r--rt/lio_listio.c68
-rw-r--r--rt/lio_listio64.c66
15 files changed, 1231 insertions, 0 deletions
diff --git a/rt/Makefile b/rt/Makefile
new file mode 100644
index 0000000000..4eb9dfcb7a
--- /dev/null
+++ b/rt/Makefile
@@ -0,0 +1,42 @@
+# Copyright (C) 1997 Free Software Foundation, Inc.
+# This file is part of the GNU C Library.
+
+# The GNU C Library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Library General Public License as
+# published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version.
+
+# The GNU C Library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Library General Public License for more details.
+
+# You should have received a copy of the GNU Library General Public
+# License along with the GNU C Library; see the file COPYING.LIB. If not,
+# write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.
+
+#
+# Sub-makefile for real-time portion of the library.
+#
+subdir := rt
+
+headers := aio.h
+
+extra-libs := librt
+extra-libs-others := $(extra-libs)
+
+librt-routines := aio_cancel aio_error aio_fsync aio_misc aio_read \
+ aio_read64 aio_return aio_suspend aio_write \
+ aio_write64 lio_listio lio_listio64 aio_sigqueue
+
+librt-map := librt.map
+
+distribute := aio_misc.h
+
+include ../Rules
+
+# Depend on libc.so so a DT_NEEDED is generated in the shared objects.
+# This ensures they will load libc.so for needed symbols if loaded by
+# a statically-linked program that hasn't already loaded it.
+$(objpfx)librt.so: $(common-objpfx)libc.so $(shared-thread-library)
diff --git a/rt/aio.h b/rt/aio.h
new file mode 100644
index 0000000000..561776c2d3
--- /dev/null
+++ b/rt/aio.h
@@ -0,0 +1,231 @@
+/* Copyright (C) 1996, 1997 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 of the
+ License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with the GNU C Library; see the file COPYING.LIB. If not,
+ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
+
+/*
+ * ISO/IEC 9945-1:1996 6.7: Asynchronous Input and Output
+ */
+
+#ifndef _AIO_H
+#define _AIO_H 1
+
+#include <features.h>
+#include <fcntl.h>
+#include <signal.h>
+#define __need_timespec
+#include <time.h>
+#include <sys/types.h>
+
+__BEGIN_DECLS
+
+/* Asynchronous I/O control block. */
+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 *__last_fd;
+ struct aiocb *__next_fd;
+ 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. */
+#else
+ __off64_t aio_offset; /* File offset. */
+#endif
+ int __unused[32];
+};
+
+/* The same for the 64bit offsets. */
+#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 aiocb64 *__last_fd;
+ struct aiocb64 *__next_fd;
+ struct aiocb64 *__next_prio;
+ int __abs_prio;
+ int __policy;
+ int __error_code;
+ __ssize_t __return_value;
+
+ __off64_t aio_offset; /* File offset. */
+ int __unused[32];
+};
+#endif
+
+
+/* Return values of cancelation function. */
+enum
+{
+ AIO_CANCELED,
+#define AIO_CANCELED AIO_CANCELED
+ AIO_NOTCANCELED,
+#define AIO_NOTCANCELED AIO_NOTCANCELED
+ AIO_ALLDONE
+#define AIO_ALLDONE AIO_ALLDONE
+};
+
+
+/* Operation codes for `aio_lio_opcode'. */
+enum
+{
+ LIO_READ,
+#define LIO_READ LIO_READ
+ LIO_WRITE,
+#define LIO_WRITE LIO_WRITE
+ LIO_NOP,
+#define LIO_NOP LIO_NOP
+ __LIO_DSYNC,
+ __LIO_SYNC,
+ __LIO_READ64 = LIO_READ | 128,
+ __LIO_WRITE64 = LIO_WRITE | 128
+};
+
+
+/* Synchronization options for `lio_listio' function. */
+enum
+{
+ LIO_WAIT,
+#define LIO_WAIT LIO_WAIT
+ LIO_NOWAIT
+#define LIO_NOWAIT LIO_NOWAIT
+};
+
+
+/* Enqueue read request for given number of bytes and the given priority. */
+#ifndef __USE_FILE_OFFSET64
+extern int aio_read __P ((struct aiocb *__aiocbp));
+#else
+extern int aio_read __P ((struct aiocb *__aiocbp)) __asm__ ("aio_read64");
+#endif
+#ifdef __USE_LARGEFILE64
+extern int aio_read64 __P ((struct aiocb64 *__aiocbp));
+#endif
+
+/* Enqueue write request for given number of bytes and the given priority. */
+#ifndef __USE_FILE_OFFSET64
+extern int aio_write __P ((struct aiocb *__aiocbp));
+#else
+extern int aio_write __P ((struct aiocb *__aiocbp)) __asm__ ("aio_write64");
+#endif
+#ifdef __USE_LARGEFILE64
+extern int aio_write64 __P ((struct aiocb64 *__aiocbp));
+#endif
+
+
+/* Initiate list of I/O requests. */
+#ifndef __USE_FILE_OFFSET64
+extern int lio_listio __P ((int __mode, struct aiocb *__const __list[],
+ int __nent, struct sigevent *__sig));
+#else
+extern int lio_listio __P ((int __mode, struct aiocb *__const __list[],
+ int __nent, struct sigevent *__sig))
+ __asm__ ("lio_listio64");
+#endif
+#ifdef __USE_LARGEFILE64
+extern int lio_listio64 __P ((int __mode, struct aiocb64 *__const __list[],
+ int __nent, struct sigevent *__sig));
+#endif
+
+
+/* Retrieve error status associated with AIOCBP. */
+#ifndef __USE_FILE_OFFSET64
+extern int aio_error __P ((__const struct aiocb *__aiocbp));
+#else
+extern int aio_error __P ((__const struct aiocb *__aiocbp))
+ __asm__ ("aio_error64");;
+#endif
+#ifdef __USE_LARGEFILE64
+extern int aio_error64 __P ((__const struct aiocb64 *__aiocbp));
+#endif
+
+
+/* Return status associated with AIOCBP. */
+#ifndef __USE_FILE_OFFSET64
+extern __ssize_t aio_return __P ((struct aiocb *__aiocbp));
+#else
+extern __ssize_t aio_return __P ((struct aiocb *__aiocbp))
+ __asm__ ("aio_return64");
+#endif
+#ifdef __USE_LARGEFILE64
+extern __ssize_t aio_return64 __P ((struct aiocb64 *__aiocbp));
+#endif
+
+
+/* Try to cancel asynchronous I/O requests outstanding against file
+ descriptot FILDES. */
+#ifndef __USE_FILE_OFFSET64
+extern int aio_cancel __P ((int __fildes, struct aiocb *__aiocbp));
+#else
+extern int aio_cancel __P ((int __fildes, struct aiocb *__aiocbp))
+ __asm__ ("aio_cancel64");
+#endif
+#ifdef __USE_LARGEFILE64
+extern int aio_cancel64 __P ((int __fildes, struct aiocb64 *__aiocbp));
+#endif
+
+
+/* Suspend calling thread until at least one of the asynchronous I/O
+ operations referenced by LIST has completed. */
+#ifndef __USE_FILE_OFFSET64
+extern int aio_suspend __P ((__const struct aiocb *__const __list[],
+ int __nent, __const struct timespec *__timeout));
+#else
+extern int aio_suspend __P ((__const struct aiocb *__const __list[],
+ int __nent, __const struct timespec *__timeout))
+ __asm__ ("aio_suspend64");
+#endif
+#ifdef __USE_LARGEFILE64
+extern int aio_suspend64 __P ((__const struct aiocb64 *__const __list[],
+ int __nent,
+ __const struct timespec *__timeout));
+#endif
+
+
+/* Force all operations associated with file desriptor described by
+ `aio_fildes' member of AIOCBP. */
+#ifndef __USE_FILE_OFFSET64
+extern int aio_fsync __P ((int __op, struct aiocb *__aiocbp));
+#else
+extern int aio_fsync __P ((int __op, struct aiocb *__aiocbp))
+ __asm__ ("aio_fsync64");
+#endif
+#ifdef __USE_LARGEFILE64
+extern int aio_fsync64 __P ((int __op, struct aiocb64 *__aiocbp));
+#endif
+
+
+__END_DECLS
+
+#endif /* aio.h */
diff --git a/rt/aio_cancel.c b/rt/aio_cancel.c
new file mode 100644
index 0000000000..f2d9389650
--- /dev/null
+++ b/rt/aio_cancel.c
@@ -0,0 +1,172 @@
+/* Cancel requests associated with given file descriptor.
+ Copyright (C) 1997 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 of the
+ License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with the GNU C Library; see the file COPYING.LIB. If not,
+ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
+
+
+/* We use an UGLY hack to prevent gcc from finding us cheating. The
+ implementation of aio_cancel and aio_cancel64 are identical and so
+ we want to avoid code duplication by using aliases. But gcc sees
+ the different parameter lists and prints a warning. We define here
+ a function so that aio_cancel64 has no prototype. */
+#define aio_cancel64 XXX
+#include <aio.h>
+/* And undo the hack. */
+#undef aio_cancel64
+
+#include <errno.h>
+#include <pthread.h>
+
+#include "aio_misc.h"
+
+
+/* Argh, so far there is no ECANCELED. */
+#define ECANCELED 125
+
+int
+aio_cancel (fildes, aiocbp)
+ int fildes;
+ struct aiocb *aiocbp;
+{
+ struct aiocb *firstp;
+ int result = AIO_ALLDONE;
+
+ /* Request the semaphore. */
+ sem_wait (&__aio_requests_sema);
+
+ /* Search for the list of requests associated with the given file
+ descriptor. */
+ for (firstp = (struct aiocb *) __aio_requests; firstp != NULL;
+ firstp = firstp->__next_fd)
+ if (firstp->aio_fildes == fildes)
+ break;
+
+ /* If the file descriptor is not found all work seems to done
+ already. Otherwise try to cancel the request(s). */
+ if (firstp != NULL)
+ {
+ if (aiocbp != NULL)
+ {
+ /* Locate the entry corresponding to the AIOCBP parameter. */
+ if (aiocbp == firstp)
+ /* The requests is currently handled, therefore don't
+ cancel it and signal this to the user. */
+ result = AIO_NOTCANCELED;
+ else
+ {
+ while (firstp->__next_prio != NULL
+ && aiocbp != firstp->__next_prio)
+ firstp = firstp->__next_prio;
+
+ if (firstp->__next_prio != NULL)
+ {
+ /* The request the user wants to cancel is in the
+ queue. Simply remove it. */
+ firstp->__next_prio = aiocbp->__next_prio;
+
+ /* Mark as canceled. */
+ aiocbp->__error_code = ECANCELED;
+ aiocbp->__return_value = -1;
+
+ /* Send the signal to notify about canceled
+ processing of the request. */
+ if (aiocbp->aio_sigevent.sigev_notify == SIGEV_THREAD)
+ {
+ /* We have to start a thread. */
+ pthread_t tid;
+ pthread_attr_t attr, *pattr;
+
+ pattr = (pthread_attr_t *)
+ aiocbp->aio_sigevent.sigev_notify_attributes;
+ if (pattr == NULL)
+ {
+ pthread_attr_init (&attr);
+ pthread_attr_setdetachstate (&attr,
+ PTHREAD_CREATE_DETACHED);
+ pattr = &attr;
+ }
+
+ pthread_create (&tid, pattr,
+ (void *(*) (void *))
+ aiocbp->aio_sigevent.sigev_notify_function,
+ aiocbp->aio_sigevent.sigev_value.sival_ptr);
+ }
+ else if (aiocbp->aio_sigevent.sigev_notify == SIGEV_SIGNAL)
+ /* We have to send a signal. */
+ __aio_sigqueue (aiocbp->aio_sigevent.sigev_signo,
+ aiocbp->aio_sigevent.sigev_value);
+
+ result = AIO_CANCELED;
+ }
+ }
+ }
+ else
+ {
+ /* First dequeue all waiting requests. */
+ aiocbp = firstp;
+
+ while ((firstp = firstp->__next_prio) != NULL)
+ {
+ firstp->__error_code = ECANCELED;
+ firstp->__return_value = -1;
+
+
+ /* Send the signal to notify about canceled processing
+ of the request. */
+ if (firstp->aio_sigevent.sigev_notify == SIGEV_THREAD)
+ {
+ /* We have to start a thread. */
+ pthread_t tid;
+ pthread_attr_t attr, *pattr;
+
+ pattr = (pthread_attr_t *)
+ aiocbp->aio_sigevent.sigev_notify_attributes;
+ if (pattr == NULL)
+ {
+ pthread_attr_init (&attr);
+ pthread_attr_setdetachstate (&attr,
+ PTHREAD_CREATE_DETACHED);
+ pattr = &attr;
+ }
+
+ pthread_create (&tid, pattr,
+ (void *(*) (void *))
+ firstp->aio_sigevent.sigev_notify_function,
+ firstp->aio_sigevent.sigev_value.sival_ptr);
+ }
+ else if (firstp->aio_sigevent.sigev_notify == SIGEV_SIGNAL)
+ /* We have to send a signal. */
+ __aio_sigqueue (firstp->aio_sigevent.sigev_signo,
+ firstp->aio_sigevent.sigev_value);
+ }
+
+ /* We have to signal that not all requests could be canceled
+ since the first requests is currently processed. */
+ result = AIO_NOTCANCELED;
+
+ aiocbp->__next_prio = NULL;
+ }
+ }
+
+ /* Release the semaphore. */
+ sem_post (&__aio_requests_sema);
+
+ return result;
+}
+
+weak_alias (aio_cancel, aio_cancel64)
diff --git a/rt/aio_error.c b/rt/aio_error.c
new file mode 100644
index 0000000000..a051e94af5
--- /dev/null
+++ b/rt/aio_error.c
@@ -0,0 +1,40 @@
+/* Return error status of asynchronous I/O request.
+ Copyright (C) 1997 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 of the
+ License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with the GNU C Library; see the file COPYING.LIB. If not,
+ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
+
+
+/* We use an UGLY hack to prevent gcc from finding us cheating. The
+ implementation of aio_error and aio_error64 are identical and so
+ we want to avoid code duplication by using aliases. But gcc sees
+ the different parameter lists and prints a warning. We define here
+ a function so that aio_error64 has no prototype. */
+#define aio_error64 XXX
+#include <aio.h>
+/* And undo the hack. */
+#undef aio_error64
+
+
+int
+aio_error (aiocbp)
+ const struct aiocb *aiocbp;
+{
+ return aiocbp->__error_code;
+}
+
+weak_alias (aio_error, aio_error64)
diff --git a/rt/aio_fsync.c b/rt/aio_fsync.c
new file mode 100644
index 0000000000..6daaca1e97
--- /dev/null
+++ b/rt/aio_fsync.c
@@ -0,0 +1,42 @@
+/* Synchronize I/O in given file descriptor.
+ Copyright (C) 1997 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 of the
+ License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with the GNU C Library; see the file COPYING.LIB. If not,
+ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
+
+
+/* We use an UGLY hack to prevent gcc from finding us cheating. The
+ implementation of aio_fsync and aio_fsync64 are identical and so
+ we want to avoid code duplication by using aliases. But gcc sees
+ the different parameter lists and prints a warning. We define here
+ a function so that aio_fsync64 has no prototype. */
+#define aio_fsync64 XXX
+#include <aio.h>
+/* And undo the hack. */
+#undef aio_fsync64
+
+#include "aio_misc.h"
+
+
+int
+aio_fsync (int op, struct aiocb *aiocbp)
+{
+ return __aio_enqueue_request ((aiocb_union *) aiocbp,
+ op == O_SYNC ? __LIO_SYNC : __LIO_DSYNC, 1);
+}
+
+weak_alias (aio_fsync, aio_fsync64)
diff --git a/rt/aio_misc.c b/rt/aio_misc.c
new file mode 100644
index 0000000000..e4bb12c500
--- /dev/null
+++ b/rt/aio_misc.c
@@ -0,0 +1,306 @@
+/* Handle general operations.
+ Copyright (C) 1997 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 of the
+ License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with the GNU C Library; see the file COPYING.LIB. If not,
+ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
+
+#include <aio.h>
+#include <errno.h>
+#include <pthread.h>
+#include <semaphore.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/stat.h>
+
+#include "aio_misc.h"
+
+
+/* We need a list of pending operations. This is sorted according to
+ the priority given in the aio_reqprio member. */
+aiocb_union *__aio_requests;
+
+/* Since the list is global we need a semaphore protecting it. */
+sem_t __aio_requests_sema;
+
+
+/* The initialization function. It gets automatically called if any
+ aio_* function is used in the program. */
+static void
+__attribute__ ((unused))
+aio_initialize (void)
+{
+ /* Initialize the semaphore. We allow exactly one user at a time. */
+ sem_init (&__aio_requests_sema, 0, 1);
+}
+
+text_set_element (__libc_subinit, aio_initialize);
+
+
+/* The thread handler. */
+static void *handle_fildes_io (void *arg);
+
+
+/* The main function of the async I/O handling. It enqueues requests
+ and if necessary starts and handles threads. */
+int
+__aio_enqueue_request (aiocb_union *aiocbp, int operation, int require_lock)
+{
+ int result;
+ int policy, prio;
+ struct sched_param param;
+ aiocb_union *runp;
+
+ if (aiocbp->aiocb.aio_reqprio < 0
+ || aiocbp->aiocb.aio_reqprio > AIO_PRIO_DELTA_MAX)
+ {
+ /* Invalid priority value. */
+ __set_errno (EINVAL);
+ aiocbp->aiocb.__error_code = EINVAL;
+ aiocbp->aiocb.__return_value = -1;
+ return -1;
+ }
+
+ if (pthread_getschedparam (pthread_self (), &policy, &param) < 0)
+ {
+ /* Something went wrong. */
+ aiocbp->aiocb.__error_code = errno;
+ aiocbp->aiocb.__return_value = -1;
+ return -1;
+ }
+
+ /* Compute priority for this request. */
+ prio = param.sched_priority - aiocbp->aiocb.aio_reqprio;
+
+
+ /* Get the semaphore. */
+ if (require_lock)
+ sem_wait (&__aio_requests_sema);
+
+ runp = __aio_requests;
+ /* First look whether the current file descriptor is currently
+ worked with. */
+ while (runp != NULL && runp->aiocb.aio_fildes < aiocbp->aiocb.aio_fildes)
+ runp = (aiocb_union *) runp->aiocb.__next_fd;
+
+ if (runp != NULL)
+ {
+ /* The current file descriptor is worked on. It makes no sense
+ to start another thread since this new thread would have to
+ wait for the previous one to terminate. Simply enqueue it
+ after the running one according to the priority. */
+ while (runp->aiocb.__next_prio != NULL
+ && runp->aiocb.__next_prio->__abs_prio >= prio)
+ runp = (aiocb_union *) runp->aiocb.__next_prio;
+
+ aiocbp->aiocb.__next_prio = runp->aiocb.__next_prio;
+ aiocbp->aiocb.__abs_prio = prio;
+ aiocbp->aiocb.__policy = policy;
+ aiocbp->aiocb.aio_lio_opcode = operation;
+ aiocbp->aiocb.__error_code = EINPROGRESS;
+ aiocbp->aiocb.__return_value = 0;
+ runp->aiocb.__next_prio = (struct aiocb *) aiocbp;
+
+ result = 0;
+ }
+ else
+ {
+ /* We create a new thread for this file descriptor. The
+ function which gets called will handle all available requests
+ for this descriptor and when all are processed it will
+ terminate. */
+ pthread_t thid;
+ pthread_attr_t attr;
+
+ /* First enqueue the request (the list is empty). */
+ aiocbp->aiocb.__next_fd = NULL;
+ aiocbp->aiocb.__last_fd = NULL;
+
+ aiocbp->aiocb.__next_prio = NULL;
+ aiocbp->aiocb.__abs_prio = prio;
+ aiocbp->aiocb.__policy = policy;
+ aiocbp->aiocb.aio_lio_opcode = operation;
+ aiocbp->aiocb.__error_code = EINPROGRESS;
+ aiocbp->aiocb.__return_value = 0;
+
+ /* Make sure the thread is created detached. */
+ pthread_attr_init (&attr);
+ pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
+
+ /* Now try to start a thread. */
+ if (pthread_create (&thid, &attr, handle_fildes_io, aiocbp) < 0)
+ {
+ result = -1;
+ aiocbp->aiocb.__error_code = errno;
+ aiocbp->aiocb.__return_value = -1;
+ }
+ else
+ /* We managed to enqueue the request. All errors which can
+ happen now can be recognized by calls to `aio_return' and
+ `aio_error'. */
+ result = 0;
+ }
+
+ /* Release the semaphore. */
+ if (require_lock)
+ sem_post (&__aio_requests_sema);
+
+ return result;
+}
+
+
+static void *
+handle_fildes_io (void *arg)
+{
+ pthread_t self = pthread_self ();
+ struct sched_param param;
+ aiocb_union *runp = (aiocb_union *) arg;
+ int policy;
+ int fildes = runp->aiocb.aio_fildes; /* This is always the same. */
+
+ pthread_getschedparam (self, &policy, &param);
+
+ do
+ {
+ /* Change the priority to the requested value (if necessary). */
+ if (runp->aiocb.__abs_prio != param.sched_priority
+ || runp->aiocb.__policy != policy)
+ {
+ param.sched_priority = runp->aiocb.__abs_prio;
+ policy = runp->aiocb.__policy;
+ pthread_setschedparam (self, policy, &param);
+ }
+
+ /* Process request pointed to by RUNP. We must not be disturbed
+ by signals. */
+ if ((runp->aiocb.aio_lio_opcode & 127) == LIO_READ)
+ {
+ if (runp->aiocb.aio_lio_opcode & 128)
+ runp->aiocb.__return_value =
+ TEMP_FAILURE_RETRY (__pread64 (fildes,
+ (void *) runp->aiocb64.aio_buf,
+ runp->aiocb64.aio_nbytes,
+ runp->aiocb64.aio_offset));
+ else
+ runp->aiocb.__return_value =
+ TEMP_FAILURE_RETRY (__pread (fildes,
+ (void *) runp->aiocb.aio_buf,
+ runp->aiocb.aio_nbytes,
+ runp->aiocb.aio_offset));
+ }
+ else if ((runp->aiocb.aio_lio_opcode & 127) == LIO_WRITE)
+ {
+ if (runp->aiocb.aio_lio_opcode & 128)
+ runp->aiocb.__return_value =
+ TEMP_FAILURE_RETRY (__pwrite64 (fildes,
+ (const void *) runp->aiocb64.aio_buf,
+ runp->aiocb64.aio_nbytes,
+ runp->aiocb64.aio_offset));
+ else
+ runp->aiocb.__return_value =
+ TEMP_FAILURE_RETRY (__pwrite (fildes,
+ (const void *) runp->aiocb.aio_buf,
+ runp->aiocb.aio_nbytes,
+ runp->aiocb.aio_offset));
+ }
+ else if (runp->aiocb.aio_lio_opcode == __LIO_DSYNC)
+ runp->aiocb.__return_value = TEMP_FAILURE_RETRY (fdatasync (fildes));
+ else if (runp->aiocb.aio_lio_opcode == __LIO_SYNC)
+ runp->aiocb.__return_value = TEMP_FAILURE_RETRY (fsync (fildes));
+ else
+ {
+ /* This is an invalid opcode. */
+ runp->aiocb.__return_value = -1;
+ __set_errno (EINVAL);
+ }
+
+ if (runp->aiocb.__return_value == -1)
+ runp->aiocb.__error_code = errno;
+ else
+ runp->aiocb.__error_code = 0;
+
+ /* Send the signal to notify about finished processing of the
+ request. */
+ if (runp->aiocb.aio_sigevent.sigev_notify == SIGEV_THREAD)
+ {
+ /* We have to start a thread. */
+ pthread_t tid;
+ pthread_attr_t attr, *pattr;
+
+ pattr = (pthread_attr_t *)
+ runp->aiocb.aio_sigevent.sigev_notify_attributes;
+ if (pattr == NULL)
+ {
+ pthread_attr_init (&attr);
+ pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
+ pattr = &attr;
+ }
+
+ if (pthread_create (&tid,
+ (pthread_attr_t *)
+ runp->aiocb.aio_sigevent.sigev_notify_attributes,
+ (void *(*) (void *))
+ runp->aiocb.aio_sigevent.sigev_notify_function,
+ runp->aiocb.aio_sigevent.sigev_value.sival_ptr)
+ < 0)
+ {
+ /* XXX What shall we do if already an error is set by
+ read/write/fsync? */
+ runp->aiocb.__error_code = errno;
+ runp->aiocb.__return_value = -1;
+ }
+ }
+ else if (runp->aiocb.aio_sigevent.sigev_notify == SIGEV_SIGNAL)
+ /* We have to send a signal. */
+ if (__aio_sigqueue (runp->aiocb.aio_sigevent.sigev_signo,
+ runp->aiocb.aio_sigevent.sigev_value) < 0)
+ {
+ /* XXX What shall we do if already an error is set by
+ read/write/fsync? */
+ runp->aiocb.__error_code = errno;
+ runp->aiocb.__return_value = -1;
+ }
+
+ /* Get the semaphore. */
+ sem_wait (&__aio_requests_sema);
+
+ /* Now dequeue the current request. */
+ if (runp->aiocb.__next_prio == NULL)
+ {
+ if (runp->aiocb.__next_fd != NULL)
+ runp->aiocb.__next_fd->__last_fd = runp->aiocb.__last_fd;
+ if (runp->aiocb.__last_fd != NULL)
+ runp->aiocb.__last_fd->__next_fd = runp->aiocb.__next_fd;
+ runp = NULL;
+ }
+ else
+ {
+ runp->aiocb.__next_prio->__last_fd = runp->aiocb.__last_fd;
+ runp->aiocb.__next_prio->__next_fd = runp->aiocb.__next_fd;
+ if (runp->aiocb.__next_fd != NULL)
+ runp->aiocb.__next_fd->__last_fd = runp->aiocb.__next_prio;
+ if (runp->aiocb.__last_fd != NULL)
+ runp->aiocb.__last_fd->__next_fd = runp->aiocb.__next_prio;
+ runp = (aiocb_union *) runp->aiocb.__next_prio;
+ }
+
+ /* Release the semaphore. */
+ sem_post (&__aio_requests_sema);
+ }
+ while (runp != NULL);
+
+ pthread_exit (NULL);
+}
diff --git a/rt/aio_misc.h b/rt/aio_misc.h
new file mode 100644
index 0000000000..c2eb9fcea1
--- /dev/null
+++ b/rt/aio_misc.h
@@ -0,0 +1,45 @@
+/* Copyright (C) 1997 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 of the
+ License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with the GNU C Library; see the file COPYING.LIB. If not,
+ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
+
+#ifndef _AIO_MISC_H
+#define _AIO_MISC_H 1
+
+#include <semaphore.h>
+
+/* Union of the two request types. */
+typedef union
+ {
+ struct aiocb aiocb;
+ struct aiocb64 aiocb64;
+ } aiocb_union;
+
+/* List of enqueued requests. */
+extern aiocb_union *__aio_requests;
+
+/* Lock for global I/O list of requests. */
+extern sem_t __aio_requests_sema;
+
+
+/* Enqueue request. */
+extern int __aio_enqueue_request (aiocb_union *aiocbp, int operation,
+ int require_lock);
+
+/* Send the signal. */
+extern int __aio_sigqueue (int sig, const union sigval val);
+
+#endif /* aio_misc.h */
diff --git a/rt/aio_read.c b/rt/aio_read.c
new file mode 100644
index 0000000000..8286ba9334
--- /dev/null
+++ b/rt/aio_read.c
@@ -0,0 +1,31 @@
+/* Asynchronous read.
+ Copyright (C) 1997 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 of the
+ License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with the GNU C Library; see the file COPYING.LIB. If not,
+ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
+
+#include <aio.h>
+
+#include "aio_misc.h"
+
+
+int
+aio_read (aiocbp)
+ struct aiocb *aiocbp;
+{
+ return __aio_enqueue_request ((aiocb_union *) aiocbp, LIO_READ, 1);
+}
diff --git a/rt/aio_read64.c b/rt/aio_read64.c
new file mode 100644
index 0000000000..bf808fb3da
--- /dev/null
+++ b/rt/aio_read64.c
@@ -0,0 +1,31 @@
+/* Asynchronous read, 64bit offset version.
+ Copyright (C) 1997 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 of the
+ License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with the GNU C Library; see the file COPYING.LIB. If not,
+ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
+
+#include <aio.h>
+
+#include "aio_misc.h"
+
+
+int
+aio_read64 (aiocbp)
+ struct aiocb64 *aiocbp;
+{
+ return __aio_enqueue_request ((aiocb_union *) aiocbp, __LIO_READ64, 1);
+}
diff --git a/rt/aio_return.c b/rt/aio_return.c
new file mode 100644
index 0000000000..304e1c98d2
--- /dev/null
+++ b/rt/aio_return.c
@@ -0,0 +1,40 @@
+/* Return exit value of asynchronous I/O request.
+ Copyright (C) 1997 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 of the
+ License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with the GNU C Library; see the file COPYING.LIB. If not,
+ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
+
+
+/* We use an UGLY hack to prevent gcc from finding us cheating. The
+ implementation of aio_return and aio_return64 are identical and so
+ we want to avoid code duplication by using aliases. But gcc sees
+ the different parameter lists and prints a warning. We define here
+ a function so that aio_return64 has no prototype. */
+#define aio_return64 XXX
+#include <aio.h>
+/* And undo the hack. */
+#undef aio_return64
+
+
+ssize_t
+aio_return (aiocbp)
+ struct aiocb *aiocbp;
+{
+ return aiocbp->__return_value;
+}
+
+weak_alias (aio_return, aio_return64)
diff --git a/rt/aio_suspend.c b/rt/aio_suspend.c
new file mode 100644
index 0000000000..75bf9ba94b
--- /dev/null
+++ b/rt/aio_suspend.c
@@ -0,0 +1,55 @@
+/* Suspend until termination of a requests.
+ Copyright (C) 1997 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 of the
+ License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with the GNU C Library; see the file COPYING.LIB. If not,
+ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
+
+
+/* We use an UGLY hack to prevent gcc from finding us cheating. The
+ implementation of aio_suspend and aio_suspend64 are identical and so
+ we want to avoid code duplication by using aliases. But gcc sees
+ the different parameter lists and prints a warning. We define here
+ a function so that aio_suspend64 has no prototype. */
+#define aio_suspend64 XXX
+#include <aio.h>
+/* And undo the hack. */
+#undef aio_suspend64
+
+#include <errno.h>
+
+#include "aio_misc.h"
+
+
+int
+aio_suspend (list, nent, timeout)
+ const struct aiocb *const list[];
+ int nent;
+ const struct timespec *timeout;
+{
+ int cnt;
+
+ /* First look whether there is already a terminated request. */
+ for (cnt = 0; cnt < nent; ++cnt)
+ if (list[cnt] != NULL && list[cnt]->__error_code != EINPROGRESS)
+ return 0;
+
+ /* XXX We have to write code which waits. */
+
+ return -1;
+}
+
+weak_alias (aio_suspend, aio_suspend64)
diff --git a/rt/aio_write.c b/rt/aio_write.c
new file mode 100644
index 0000000000..80b827c1aa
--- /dev/null
+++ b/rt/aio_write.c
@@ -0,0 +1,31 @@
+/* Asynchronous write.
+ Copyright (C) 1997 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 of the
+ License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with the GNU C Library; see the file COPYING.LIB. If not,
+ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
+
+#include <aio.h>
+
+#include "aio_misc.h"
+
+
+int
+aio_write (aiocbp)
+ struct aiocb *aiocbp;
+{
+ return __aio_enqueue_request ((aiocb_union *) aiocbp, LIO_WRITE, 1);
+}
diff --git a/rt/aio_write64.c b/rt/aio_write64.c
new file mode 100644
index 0000000000..477ce2cbe4
--- /dev/null
+++ b/rt/aio_write64.c
@@ -0,0 +1,31 @@
+/* Asynchronous write, 64bit offset version.
+ Copyright (C) 1997 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 of the
+ License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with the GNU C Library; see the file COPYING.LIB. If not,
+ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
+
+#include <aio.h>
+
+#include "aio_misc.h"
+
+
+int
+aio_write64 (aiocbp)
+ struct aiocb64 *aiocbp;
+{
+ return __aio_enqueue_request ((aiocb_union *) aiocbp, __LIO_WRITE64, 1);
+}
diff --git a/rt/lio_listio.c b/rt/lio_listio.c
new file mode 100644
index 0000000000..73df5c2f5c
--- /dev/null
+++ b/rt/lio_listio.c
@@ -0,0 +1,68 @@
+/* Enqueue and list of read or write requests.
+ Copyright (C) 1997 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 of the
+ License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with the GNU C Library; see the file COPYING.LIB. If not,
+ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
+
+#include <aio.h>
+#include <errno.h>
+#include <semaphore.h>
+
+#include "aio_misc.h"
+
+
+int
+lio_listio (mode, list, nent, sig)
+ int mode;
+ struct aiocb *const list[];
+ int nent;
+ struct sigevent *sig;
+{
+ int cnt;
+ int total = 0;
+ int result = 0;
+
+ /* Check arguments. */
+ if (mode != LIO_WAIT && mode != LIO_NOWAIT)
+ {
+ __set_errno (EINVAL);
+ return -1;
+ }
+
+ /* Request the semaphore. */
+ sem_wait (&__aio_requests_sema);
+
+ /* Now we can enqueue all requests. Since we already acquired the
+ semaphore the enqueue function need not do this. */
+ for (cnt = 0; cnt < nent; ++cnt)
+ if (list[cnt] != NULL && list[cnt]->aio_lio_opcode != LIO_NOP)
+ if (__aio_enqueue_request ((aiocb_union *) list[cnt],
+ list[cnt]->aio_lio_opcode, 0) >= 0)
+ /* Successfully enqueued. */
+ ++total;
+ else
+ /* Signal that we've seen an error. `errno' and the error code
+ of the aiocb will tell more. */
+ result = -1;
+
+
+
+ /* Release the semaphore. */
+ sem_post (&__aio_requests_sema);
+
+ return result;
+}
diff --git a/rt/lio_listio64.c b/rt/lio_listio64.c
new file mode 100644
index 0000000000..b17e9edae2
--- /dev/null
+++ b/rt/lio_listio64.c
@@ -0,0 +1,66 @@
+/* Enqueue and list of read or write requests, 64bit offset version.
+ Copyright (C) 1997 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 of the
+ License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with the GNU C Library; see the file COPYING.LIB. If not,
+ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
+
+#include <aio.h>
+#include <errno.h>
+#include <semaphore.h>
+
+#include "aio_misc.h"
+
+
+int
+lio_listio64 (mode, list, nent, sig)
+ int mode;
+ struct aiocb64 *const list[];
+ int nent;
+ struct sigevent *sig;
+{
+ int cnt;
+ int total = 0;
+ int result = 0;
+
+ /* Check arguments. */
+ if (mode != LIO_WAIT && mode != LIO_NOWAIT)
+ {
+ __set_errno (EINVAL);
+ return -1;
+ }
+
+ /* Request the semaphore. */
+ sem_wait (&__aio_requests_sema);
+
+ /* Now we can enqueue all requests. Since we already acquired the
+ semaphore the enqueue function need not do this. */
+ for (cnt = 0; cnt < nent; ++cnt)
+ if (list[cnt] != NULL && list[cnt]->aio_lio_opcode != LIO_NOP)
+ if (__aio_enqueue_request ((aiocb_union *) list[cnt],
+ list[cnt]->aio_lio_opcode | 128, 0) >= 0)
+ /* Successfully enqueued. */
+ ++total;
+ else
+ /* Signal that we've seen an error. `errno' and the error code
+ of the aiocb will tell more. */
+ result = -1;
+
+ /* Release the semaphore. */
+ sem_post (&__aio_requests_sema);
+
+ return result;
+}