diff options
Diffstat (limited to 'rt')
| -rw-r--r-- | rt/Makefile | 42 | ||||
| -rw-r--r-- | rt/aio.h | 231 | ||||
| -rw-r--r-- | rt/aio_cancel.c | 172 | ||||
| -rw-r--r-- | rt/aio_error.c | 40 | ||||
| -rw-r--r-- | rt/aio_fsync.c | 42 | ||||
| -rw-r--r-- | rt/aio_misc.c | 306 | ||||
| -rw-r--r-- | rt/aio_misc.h | 45 | ||||
| -rw-r--r-- | rt/aio_read.c | 31 | ||||
| -rw-r--r-- | rt/aio_read64.c | 31 | ||||
| -rw-r--r-- | rt/aio_return.c | 40 | ||||
| -rw-r--r-- | rt/aio_suspend.c | 55 | ||||
| -rw-r--r-- | rt/aio_write.c | 31 | ||||
| -rw-r--r-- | rt/aio_write64.c | 31 | ||||
| -rw-r--r-- | rt/lio_listio.c | 68 | ||||
| -rw-r--r-- | rt/lio_listio64.c | 66 |
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, ¶m) < 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, ¶m); + + 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, ¶m); + } + + /* 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; +} |