AIO implementation for glibc.
authordrepper <drepper>
Wed, 3 Dec 1997 23:12:32 +0000 (23:12 +0000)
committerdrepper <drepper>
Wed, 3 Dec 1997 23:12:32 +0000 (23:12 +0000)
15 files changed:
rt/Makefile [new file with mode: 0644]
rt/aio.h [new file with mode: 0644]
rt/aio_cancel.c [new file with mode: 0644]
rt/aio_error.c [new file with mode: 0644]
rt/aio_fsync.c [new file with mode: 0644]
rt/aio_misc.c [new file with mode: 0644]
rt/aio_misc.h [new file with mode: 0644]
rt/aio_read.c [new file with mode: 0644]
rt/aio_read64.c [new file with mode: 0644]
rt/aio_return.c [new file with mode: 0644]
rt/aio_suspend.c [new file with mode: 0644]
rt/aio_write.c [new file with mode: 0644]
rt/aio_write64.c [new file with mode: 0644]
rt/lio_listio.c [new file with mode: 0644]
rt/lio_listio64.c [new file with mode: 0644]

diff --git a/rt/Makefile b/rt/Makefile
new file mode 100644 (file)
index 0000000..4eb9dfc
--- /dev/null
@@ -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 (file)
index 0000000..561776c
--- /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 (file)
index 0000000..f2d9389
--- /dev/null
@@ -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 (file)
index 0000000..a051e94
--- /dev/null
@@ -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 (file)
index 0000000..6daaca1
--- /dev/null
@@ -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 (file)
index 0000000..e4bb12c
--- /dev/null
@@ -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 (file)
index 0000000..c2eb9fc
--- /dev/null
@@ -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 (file)
index 0000000..8286ba9
--- /dev/null
@@ -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 (file)
index 0000000..bf808fb
--- /dev/null
@@ -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 (file)
index 0000000..304e1c9
--- /dev/null
@@ -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 (file)
index 0000000..75bf9ba
--- /dev/null
@@ -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 (file)
index 0000000..80b827c
--- /dev/null
@@ -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 (file)
index 0000000..477ce2c
--- /dev/null
@@ -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 (file)
index 0000000..73df5c2
--- /dev/null
@@ -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 (file)
index 0000000..b17e9ed
--- /dev/null
@@ -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;
+}