diff options
author | Florian Weimer <fweimer@redhat.com> | 2021-06-22 09:50:27 +0200 |
---|---|---|
committer | Florian Weimer <fweimer@redhat.com> | 2021-06-22 09:50:45 +0200 |
commit | daa3fc9bff55c1f8368a464ec802ab620901344e (patch) | |
tree | 14c3a5a951a84aeff9d554ab5a77c13a4ec29521 /rt/aio_notify.c | |
parent | ae830b2d9f5238e1bee9820cd4d4df7f7b13ecff (diff) | |
download | glibc-daa3fc9bff55c1f8368a464ec802ab620901344e.zip glibc-daa3fc9bff55c1f8368a464ec802ab620901344e.tar.gz glibc-daa3fc9bff55c1f8368a464ec802ab620901344e.tar.bz2 |
rt: Move generic implementation from sysdeps/pthread to rt
The pthread-based implementation is the generic one. Replacing
the stubs makes it clear that they do not have to be adjusted for
the libpthread move.
Result of:
git mv -f sysdeps/pthread/aio_misc.h sysdeps/generic/
git mv sysdeps/pthread/timer_routines.c sysdeps/htl/
git mv -f sysdeps/pthread/{aio,lio,timer}_*.c rt/
Followed by manual adjustment of the #include paths in
sysdeps/unix/sysv/linux/wordsize-64, and a move of the version
definitions formerly in sysdeps/pthread/Versions.
Reviewed-by: Adhemerval Zanella <adhemerval.zanella@linaro.org>
Diffstat (limited to 'rt/aio_notify.c')
-rw-r--r-- | rt/aio_notify.c | 144 |
1 files changed, 139 insertions, 5 deletions
diff --git a/rt/aio_notify.c b/rt/aio_notify.c index 9d51fd9..a8d6150 100644 --- a/rt/aio_notify.c +++ b/rt/aio_notify.c @@ -1,6 +1,7 @@ -/* Notify initiator of AIO request. Stub version. - Copyright (C) 2001-2021 Free Software Foundation, Inc. +/* Notify initiator of AIO request. + Copyright (C) 1997-2021 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 Lesser General Public @@ -16,8 +17,141 @@ License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ -#include <aio.h> +#include <errno.h> +#include <pthread.h> +#include <stdlib.h> +#include <unistd.h> #include <aio_misc.h> +#include <signal.h> -/* This file contains only internal functions used by - the particular aio_* implementation code. */ +#ifndef aio_start_notify_thread +# define aio_start_notify_thread() do { } while (0) +#endif + +struct notify_func + { + void (*func) (sigval_t); + sigval_t value; + }; + +static void * +notify_func_wrapper (void *arg) +{ + aio_start_notify_thread (); + struct notify_func *const n = arg; + void (*func) (sigval_t) = n->func; + sigval_t value = n->value; + free (n); + (*func) (value); + return NULL; +} + + +int +__aio_notify_only (struct sigevent *sigev) +{ + int result = 0; + + /* Send the signal to notify about finished processing of the request. */ + if (__glibc_unlikely (sigev->sigev_notify == SIGEV_THREAD)) + { + /* We have to start a thread. */ + pthread_t tid; + pthread_attr_t attr, *pattr; + + pattr = (pthread_attr_t *) sigev->sigev_notify_attributes; + if (pattr == NULL) + { + pthread_attr_init (&attr); + pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED); + pattr = &attr; + } + + /* SIGEV may be freed as soon as we return, so we cannot let the + notification thread use that pointer. Even though a sigval_t is + only one word and the same size as a void *, we cannot just pass + the value through pthread_create as the argument and have the new + thread run the user's function directly, because on some machines + the calling convention for a union like sigval_t is different from + that for a pointer type like void *. */ + struct notify_func *nf = malloc (sizeof *nf); + if (nf == NULL) + result = -1; + else + { + nf->func = sigev->sigev_notify_function; + nf->value = sigev->sigev_value; + if (pthread_create (&tid, pattr, notify_func_wrapper, nf) < 0) + { + free (nf); + result = -1; + } + } + } + else if (sigev->sigev_notify == SIGEV_SIGNAL) + { + /* We have to send a signal. */ +#if _POSIX_REALTIME_SIGNALS > 0 + /* Note that the standard gives us the option of using a plain + non-queuing signal here when SA_SIGINFO is not set for the signal. */ + if (__aio_sigqueue (sigev->sigev_signo, sigev->sigev_value, getpid ()) + < 0) + result = -1; +#else + /* There are no queued signals on this system at all. */ + result = raise (sigev->sigev_signo); +#endif + } + + return result; +} + + +void +__aio_notify (struct requestlist *req) +{ + struct waitlist *waitlist; + struct aiocb *aiocbp = &req->aiocbp->aiocb; + + if (__aio_notify_only (&aiocbp->aio_sigevent) != 0) + { + /* XXX What shall we do if already an error is set by + read/write/fsync? */ + aiocbp->__error_code = errno; + aiocbp->__return_value = -1; + } + + /* Now also notify possibly waiting threads. */ + waitlist = req->waiting; + while (waitlist != NULL) + { + struct waitlist *next = waitlist->next; + + if (waitlist->sigevp == NULL) + { + if (waitlist->result != NULL && aiocbp->__return_value == -1) + *waitlist->result = -1; + +#ifdef DONT_NEED_AIO_MISC_COND + AIO_MISC_NOTIFY (waitlist); +#else + /* Decrement the counter. */ + --*waitlist->counterp; + + pthread_cond_signal (waitlist->cond); +#endif + } + else + /* This is part of an asynchronous `lio_listio' operation. If + this request is the last one, send the signal. */ + if (--*waitlist->counterp == 0) + { + __aio_notify_only (waitlist->sigevp); + /* This is tricky. See lio_listio.c for the reason why + this works. */ + free ((void *) waitlist->counterp); + } + + waitlist = next; + } +} |