diff options
Diffstat (limited to 'rtkaio/sysdeps/unix/sysv/linux/klio_listio.c')
-rw-r--r-- | rtkaio/sysdeps/unix/sysv/linux/klio_listio.c | 123 |
1 files changed, 93 insertions, 30 deletions
diff --git a/rtkaio/sysdeps/unix/sysv/linux/klio_listio.c b/rtkaio/sysdeps/unix/sysv/linux/klio_listio.c index 73cb0d547b..b7676c9f03 100644 --- a/rtkaio/sysdeps/unix/sysv/linux/klio_listio.c +++ b/rtkaio/sysdeps/unix/sysv/linux/klio_listio.c @@ -1,5 +1,5 @@ /* Enqueue and list of read or write requests. - Copyright (C) 1997,1998,1999,2000,2001,2002,2003 + Copyright (C) 1997,1998,1999,2000,2001,2002,2003,2005,2006 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997. @@ -25,16 +25,19 @@ #include <lio_listio.c> #else +#ifndef lio_listio #include <aio.h> #include <assert.h> #include <errno.h> #include <stdlib.h> #include <unistd.h> -#ifndef lio_listio #define LIO_OPCODE_BASE 0 #endif +#include <shlib-compat.h> + + /* We need this special structure to handle asynchronous I/O. */ struct async_waitlist { @@ -43,12 +46,23 @@ struct async_waitlist struct waitlist list[0]; }; -int -lio_listio (mode, list, nent, sig) - int mode; - struct aiocb *const list[]; - int nent; - struct sigevent *sig; + +/* The code in glibc 2.1 to glibc 2.4 issued only one event when all + requests submitted with lio_listio finished. The existing practice + is to issue events for the individual requests as well. This is + what the new code does. */ +#if SHLIB_COMPAT (librt, GLIBC_2_1, GLIBC_2_4) +# define LIO_MODE(mode) ((mode) & 127) +# define NO_INDIVIDUAL_EVENT_P(mode) ((mode) & 128) +#else +# define LIO_MODE(mode) mode +# define NO_INDIVIDUAL_EVENT_P(mode) 0 +#endif + + +static int +lio_listio_internal (int mode, struct aiocb *const list[], int nent, + struct sigevent *sig) { struct sigevent defsigev; struct requestlist *requests[nent]; @@ -57,13 +71,6 @@ lio_listio (mode, list, nent, sig) int result = 0, op = 0; kctx_t kctx = KCTX_NONE; - /* Check arguments. */ - if (mode != LIO_WAIT && mode != LIO_NOWAIT) - { - __set_errno (EINVAL); - return -1; - } - if (sig == NULL) { defsigev.sigev_notify = SIGEV_NONE; @@ -73,7 +80,7 @@ lio_listio (mode, list, nent, sig) /* Request the mutex. */ pthread_mutex_lock (&__aio_requests_mutex); - if (mode == LIO_WAIT && ! __have_no_kernel_aio && nent > 0) + if (LIO_MODE (mode) == LIO_WAIT && ! __have_no_kernel_aio && nent > 0) { int res; INTERNAL_SYSCALL_DECL (err); @@ -90,7 +97,7 @@ lio_listio (mode, list, nent, sig) __have_no_kernel_aio = 1; } } - else if (mode == LIO_NOWAIT) + else if (LIO_MODE (mode) == LIO_NOWAIT) { op = LIO_KTHREAD; if (sig->sigev_notify != SIGEV_NONE) @@ -103,7 +110,8 @@ lio_listio (mode, list, nent, sig) for (cnt = 0; cnt < nent; ++cnt) if (list[cnt] != NULL && list[cnt]->aio_lio_opcode != LIO_NOP) { - list[cnt]->aio_sigevent.sigev_notify = SIGEV_NONE; + if (NO_INDIVIDUAL_EVENT_P (mode)) + list[cnt]->aio_sigevent.sigev_notify = SIGEV_NONE; requests[cnt] = __aio_enqueue_request_ctx ((aiocb_union *) list[cnt], list[cnt]->aio_lio_opcode | op, @@ -136,7 +144,7 @@ lio_listio (mode, list, nent, sig) locked forever. */ pthread_mutex_unlock (&__aio_requests_mutex); - if (mode == LIO_NOWAIT) + if (LIO_MODE (mode) == LIO_NOWAIT) { #ifdef BROKEN_THREAD_SIGNALS __aio_notify_only (sig, @@ -148,11 +156,13 @@ lio_listio (mode, list, nent, sig) return result; } - else if (mode == LIO_WAIT) + else if (LIO_MODE (mode) == LIO_WAIT) { +#ifndef DONT_NEED_AIO_MISC_COND pthread_cond_t cond = PTHREAD_COND_INITIALIZER; - struct waitlist waitlist[nent]; int oldstate; +#endif + struct waitlist waitlist[nent]; volatile int ktotal = 0; total = 0; @@ -173,7 +183,10 @@ lio_listio (mode, list, nent, sig) waitlist[cnt].counterp = &total; ++total; } +#ifndef DONT_NEED_AIO_MISC_COND waitlist[cnt].cond = &cond; +#endif + waitlist[cnt].result = &result; waitlist[cnt].next = requests[cnt]->waiting; waitlist[cnt].sigevp = NULL; #ifdef BROKEN_THREAD_SIGNALS @@ -183,29 +196,40 @@ lio_listio (mode, list, nent, sig) } } - /* Since `pthread_cond_wait'/`pthread_cond_timedwait' are cancelation + while (ktotal > 0) + __aio_wait_for_events (kctx, NULL); +#ifdef DONT_NEED_AIO_MISC_COND + AIO_MISC_WAIT (result, total, NULL, 0); +#else + /* Since `pthread_cond_wait'/`pthread_cond_timedwait' are cancellation points we must be careful. We added entries to the waiting lists - which we must remove. So defer cancelation for now. */ + which we must remove. So defer cancellation for now. */ pthread_setcancelstate (PTHREAD_CANCEL_DISABLE, &oldstate); - while (ktotal > 0) - __aio_wait_for_events (kctx, NULL); while (total > 0) pthread_cond_wait (&cond, &__aio_requests_mutex); - /* Now it's time to restore the cancelation state. */ + /* Now it's time to restore the cancellation state. */ pthread_setcancelstate (oldstate, NULL); + /* Release the conditional variable. */ + if (pthread_cond_destroy (&cond) != 0) + /* This must never happen. */ + abort (); +#endif + if (kctx != KCTX_NONE) { INTERNAL_SYSCALL_DECL (err); INTERNAL_SYSCALL (io_destroy, err, 1, kctx); } - /* Release the conditional variable. */ - if (pthread_cond_destroy (&cond) != 0) - /* This must never happen. */ - abort (); + /* If any of the I/O requests failed, return -1 and set errno. */ + if (result != 0) + { + __set_errno (result == EINTR ? EINTR : EIO); + result = -1; + } } else if (sig->sigev_notify != SIGEV_NONE) { @@ -234,7 +258,10 @@ lio_listio (mode, list, nent, sig) if (requests[cnt] != NULL && list[cnt]->aio_lio_opcode != LIO_NOP) { +#ifndef DONT_NEED_AIO_MISC_COND waitlist->list[cnt].cond = NULL; +#endif + waitlist->list[cnt].result = NULL; waitlist->list[cnt].next = requests[cnt]->waiting; waitlist->list[cnt].counterp = &waitlist->counter; waitlist->list[cnt].sigevp = &waitlist->sigev; @@ -256,4 +283,40 @@ lio_listio (mode, list, nent, sig) return result; } + + +#if SHLIB_COMPAT (librt, GLIBC_2_1, GLIBC_2_4) +int +attribute_compat_text_section +__lio_listio_21 (int mode, struct aiocb *const list[], int nent, + struct sigevent *sig) +{ + /* Check arguments. */ + if (mode != LIO_WAIT && mode != LIO_NOWAIT) + { + __set_errno (EINVAL); + return -1; + } + + return lio_listio_internal (mode | LIO_NO_INDIVIDUAL_EVENT, list, nent, sig); +} +compat_symbol (librt, __lio_listio_21, lio_listio, GLIBC_2_1); +#endif + + +int +__lio_listio_item_notify (int mode, struct aiocb *const list[], int nent, + struct sigevent *sig) +{ + /* Check arguments. */ + if (mode != LIO_WAIT && mode != LIO_NOWAIT) + { + __set_errno (EINVAL); + return -1; + } + + return lio_listio_internal (mode, list, nent, sig); +} +versioned_symbol (librt, __lio_listio_item_notify, lio_listio, GLIBC_2_4); + #endif |