[PATCH 07/35] rt: Move generic implementation from sysdeps/pthread to rt
Florian Weimer
fweimer@redhat.com
Thu Jun 3 23:15:22 GMT 2021
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.
---
rt/Versions | 4 +
rt/aio_cancel.c | 129 +++-
rt/aio_error.c | 12 +-
rt/aio_fsync.c | 26 +-
rt/aio_misc.c | 699 ++++++++++++++++-
rt/aio_notify.c | 144 +++-
rt/aio_read.c | 18 +-
rt/aio_read64.c | 32 +-
rt/aio_suspend.c | 237 +++++-
rt/aio_write.c | 18 +-
rt/aio_write64.c | 32 +-
rt/lio_listio.c | 236 +++++-
rt/lio_listio64.c | 33 +-
rt/timer_create.c | 156 +++-
rt/timer_delete.c | 58 +-
rt/timer_getoverr.c | 33 +-
rt/timer_gettime.c | 64 +-
rt/timer_settime.c | 120 ++-
sysdeps/generic/aio_misc.h | 83 +-
sysdeps/{pthread => htl}/timer_routines.c | 0
sysdeps/pthread/Versions | 5 -
sysdeps/pthread/aio_cancel.c | 157 ----
sysdeps/pthread/aio_error.c | 48 --
sysdeps/pthread/aio_fsync.c | 57 --
sysdeps/pthread/aio_misc.c | 721 ------------------
sysdeps/pthread/aio_misc.h | 122 ---
sysdeps/pthread/aio_notify.c | 157 ----
sysdeps/pthread/aio_read.c | 30 -
sysdeps/pthread/aio_read64.c | 30 -
sysdeps/pthread/aio_suspend.c | 263 -------
sysdeps/pthread/aio_write.c | 30 -
sysdeps/pthread/aio_write64.c | 30 -
sysdeps/pthread/lio_listio.c | 248 ------
sysdeps/pthread/lio_listio64.c | 33 -
sysdeps/pthread/timer_create.c | 166 ----
sysdeps/pthread/timer_delete.c | 68 --
sysdeps/pthread/timer_getoverr.c | 43 --
sysdeps/pthread/timer_gettime.c | 74 --
sysdeps/pthread/timer_settime.c | 131 ----
sysdeps/unix/sysv/linux/alpha/aio_cancel.c | 4 +-
sysdeps/unix/sysv/linux/sparc/aio_cancel.c | 4 +-
.../unix/sysv/linux/wordsize-64/aio_read.c | 2 +-
.../unix/sysv/linux/wordsize-64/aio_write.c | 2 +-
.../unix/sysv/linux/wordsize-64/lio_listio.c | 2 +-
44 files changed, 2017 insertions(+), 2544 deletions(-)
rename sysdeps/{pthread => htl}/timer_routines.c (100%)
delete mode 100644 sysdeps/pthread/Versions
delete mode 100644 sysdeps/pthread/aio_cancel.c
delete mode 100644 sysdeps/pthread/aio_error.c
delete mode 100644 sysdeps/pthread/aio_fsync.c
delete mode 100644 sysdeps/pthread/aio_misc.c
delete mode 100644 sysdeps/pthread/aio_misc.h
delete mode 100644 sysdeps/pthread/aio_notify.c
delete mode 100644 sysdeps/pthread/aio_read.c
delete mode 100644 sysdeps/pthread/aio_read64.c
delete mode 100644 sysdeps/pthread/aio_suspend.c
delete mode 100644 sysdeps/pthread/aio_write.c
delete mode 100644 sysdeps/pthread/aio_write64.c
delete mode 100644 sysdeps/pthread/lio_listio.c
delete mode 100644 sysdeps/pthread/lio_listio64.c
delete mode 100644 sysdeps/pthread/timer_create.c
delete mode 100644 sysdeps/pthread/timer_delete.c
delete mode 100644 sysdeps/pthread/timer_getoverr.c
delete mode 100644 sysdeps/pthread/timer_gettime.c
delete mode 100644 sysdeps/pthread/timer_settime.c
diff --git a/rt/Versions b/rt/Versions
index 309486be1e..26c6d1ac63 100644
--- a/rt/Versions
+++ b/rt/Versions
@@ -47,6 +47,10 @@ librt {
mq_timedsend;
mq_unlink;
}
+ GLIBC_2.4 {
+ lio_listio;
+ lio_listio64;
+ }
GLIBC_2.7 {
__mq_open_2;
}
diff --git a/rt/aio_cancel.c b/rt/aio_cancel.c
index dba1e45044..63fd88f36c 100644
--- a/rt/aio_cancel.c
+++ b/rt/aio_cancel.c
@@ -1,6 +1,7 @@
-/* Cancel requests associated with given file descriptor. Stub version.
- Copyright (C) 2001-2021 Free Software Foundation, Inc.
+/* Cancel requests associated with given file descriptor.
+ 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
@@ -22,21 +23,135 @@
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. */
+#ifndef aio_cancel
#define aio_cancel64 XXX
#include <aio.h>
/* And undo the hack. */
#undef aio_cancel64
+#endif
+#include <assert.h>
#include <errno.h>
+#include <fcntl.h>
+
+#include <aio_misc.h>
+
int
aio_cancel (int fildes, struct aiocb *aiocbp)
{
- __set_errno (ENOSYS);
- return -1;
+ struct requestlist *req = NULL;
+ int result = AIO_ALLDONE;
+
+ /* If fildes is invalid, error. */
+ if (fcntl (fildes, F_GETFL) < 0)
+ {
+ __set_errno (EBADF);
+ return -1;
+ }
+
+ /* Request the mutex. */
+ pthread_mutex_lock (&__aio_requests_mutex);
+
+ /* We are asked to cancel a specific AIO request. */
+ if (aiocbp != NULL)
+ {
+ /* If the AIO request is not for this descriptor it has no value
+ to look for the request block. */
+ if (aiocbp->aio_fildes != fildes)
+ {
+ pthread_mutex_unlock (&__aio_requests_mutex);
+ __set_errno (EINVAL);
+ return -1;
+ }
+ else if (aiocbp->__error_code == EINPROGRESS)
+ {
+ struct requestlist *last = NULL;
+
+ req = __aio_find_req_fd (fildes);
+
+ if (req == NULL)
+ {
+ not_found:
+ pthread_mutex_unlock (&__aio_requests_mutex);
+ __set_errno (EINVAL);
+ return -1;
+ }
+
+ while (req->aiocbp != (aiocb_union *) aiocbp)
+ {
+ last = req;
+ req = req->next_prio;
+ if (req == NULL)
+ goto not_found;
+ }
+
+ /* Don't remove the entry if a thread is already working on it. */
+ if (req->running == allocated)
+ {
+ result = AIO_NOTCANCELED;
+ req = NULL;
+ }
+ else
+ {
+ /* We can remove the entry. */
+ __aio_remove_request (last, req, 0);
+
+ result = AIO_CANCELED;
+
+ req->next_prio = NULL;
+ }
+ }
+ }
+ else
+ {
+ /* Find the beginning of the list of all requests for this
+ desriptor. */
+ req = __aio_find_req_fd (fildes);
+
+ /* If any request is worked on by a thread it must be the first.
+ So either we can delete all requests or all but the first. */
+ if (req != NULL)
+ {
+ if (req->running == allocated)
+ {
+ struct requestlist *old = req;
+ req = req->next_prio;
+ old->next_prio = NULL;
+
+ result = AIO_NOTCANCELED;
+
+ if (req != NULL)
+ __aio_remove_request (old, req, 1);
+ }
+ else
+ {
+ result = AIO_CANCELED;
+
+ /* We can remove the entry. */
+ __aio_remove_request (NULL, req, 1);
+ }
+ }
+ }
+
+ /* Mark requests as canceled and send signal. */
+ while (req != NULL)
+ {
+ struct requestlist *old = req;
+ assert (req->running == yes || req->running == queued);
+ req->aiocbp->aiocb.__error_code = ECANCELED;
+ req->aiocbp->aiocb.__return_value = -1;
+ __aio_notify (req);
+ req = req->next_prio;
+ __aio_free_request (old);
+ }
+
+ /* Release the mutex. */
+ pthread_mutex_unlock (&__aio_requests_mutex);
+
+ return result;
}
+#ifndef aio_cancel
weak_alias (aio_cancel, aio_cancel64)
-
-stub_warning (aio_cancel)
-stub_warning (aio_cancel64)
+#endif
diff --git a/rt/aio_error.c b/rt/aio_error.c
index 730b64b5e9..ed664ae0ef 100644
--- a/rt/aio_error.c
+++ b/rt/aio_error.c
@@ -28,11 +28,21 @@
/* And undo the hack. */
#undef aio_error64
+#include <aio_misc.h>
+
int
aio_error (const struct aiocb *aiocbp)
{
- return aiocbp->__error_code;
+ int ret;
+
+ /* Acquire the mutex to make sure all operations for this request are
+ complete. */
+ pthread_mutex_lock(&__aio_requests_mutex);
+ ret = aiocbp->__error_code;
+ pthread_mutex_unlock(&__aio_requests_mutex);
+
+ return ret;
}
weak_alias (aio_error, aio_error64)
diff --git a/rt/aio_fsync.c b/rt/aio_fsync.c
index 86727246f8..5a52e2fec0 100644
--- a/rt/aio_fsync.c
+++ b/rt/aio_fsync.c
@@ -1,6 +1,7 @@
-/* Synchronize I/O in given file descriptor. Stub version.
- Copyright (C) 2001-2021 Free Software Foundation, Inc.
+/* Synchronize I/O in given file descriptor.
+ 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
@@ -26,24 +27,31 @@
#include <aio.h>
/* And undo the hack. */
#undef aio_fsync64
-
#include <errno.h>
#include <fcntl.h>
+#include <aio_misc.h>
+
+
int
aio_fsync (int op, struct aiocb *aiocbp)
{
- if (op != O_SYNC && op != O_DSYNC)
+ if (op != O_DSYNC && __builtin_expect (op != O_SYNC, 0))
{
__set_errno (EINVAL);
return -1;
}
- __set_errno (ENOSYS);
- return -1;
+ /* Verify that this is an open file descriptor. */
+ if (__glibc_unlikely (fcntl (aiocbp->aio_fildes, F_GETFL) == -1))
+ {
+ __set_errno (EBADF);
+ return -1;
+ }
+
+ return (__aio_enqueue_request ((aiocb_union *) aiocbp,
+ op == O_SYNC ? LIO_SYNC : LIO_DSYNC) == NULL
+ ? -1 : 0);
}
weak_alias (aio_fsync, aio_fsync64)
-
-stub_warning (aio_fsync)
-stub_warning (aio_fsync64)
diff --git a/rt/aio_misc.c b/rt/aio_misc.c
index 2332f3ed53..b95f07d9d3 100644
--- a/rt/aio_misc.c
+++ b/rt/aio_misc.c
@@ -1,6 +1,7 @@
-/* Handle general operations. Stub version.
- Copyright (C) 2001-2021 Free Software Foundation, Inc.
+/* Handle general operations.
+ 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
@@ -17,12 +18,704 @@
<https://www.gnu.org/licenses/>. */
#include <aio.h>
+#include <assert.h>
+#include <errno.h>
+#include <limits.h>
+#include <pthread.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/param.h>
+#include <sys/stat.h>
+#include <sys/time.h>
#include <aio_misc.h>
-/* This file is for internal code needed by the aio_* implementation. */
+#ifndef aio_create_helper_thread
+# define aio_create_helper_thread __aio_create_helper_thread
+extern inline int
+__aio_create_helper_thread (pthread_t *threadp, void *(*tf) (void *), void *arg)
+{
+ pthread_attr_t attr;
+
+ /* Make sure the thread is created detached. */
+ pthread_attr_init (&attr);
+ pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
+
+ int ret = pthread_create (threadp, &attr, tf, arg);
+
+ (void) pthread_attr_destroy (&attr);
+ return ret;
+}
+#endif
+
+static void add_request_to_runlist (struct requestlist *newrequest);
+
+/* Pool of request list entries. */
+static struct requestlist **pool;
+
+/* Number of total and allocated pool entries. */
+static size_t pool_max_size;
+static size_t pool_size;
+
+/* We implement a two dimensional array but allocate each row separately.
+ The macro below determines how many entries should be used per row.
+ It should better be a power of two. */
+#define ENTRIES_PER_ROW 32
+
+/* How many rows we allocate at once. */
+#define ROWS_STEP 8
+
+/* List of available entries. */
+static struct requestlist *freelist;
+
+/* List of request waiting to be processed. */
+static struct requestlist *runlist;
+
+/* Structure list of all currently processed requests. */
+static struct requestlist *requests;
+
+/* Number of threads currently running. */
+static int nthreads;
+
+/* Number of threads waiting for work to arrive. */
+static int idle_thread_count;
+
+
+/* These are the values used to optimize the use of AIO. The user can
+ overwrite them by using the `aio_init' function. */
+static struct aioinit optim =
+{
+ 20, /* int aio_threads; Maximal number of threads. */
+ 64, /* int aio_num; Number of expected simultaneous requests. */
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0
+};
+
+
+/* Since the list is global we need a mutex protecting it. */
+pthread_mutex_t __aio_requests_mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
+
+/* When you add a request to the list and there are idle threads present,
+ you signal this condition variable. When a thread finishes work, it waits
+ on this condition variable for a time before it actually exits. */
+pthread_cond_t __aio_new_request_notification = PTHREAD_COND_INITIALIZER;
+
+
+/* Functions to handle request list pool. */
+static struct requestlist *
+get_elem (void)
+{
+ struct requestlist *result;
+
+ if (freelist == NULL)
+ {
+ struct requestlist *new_row;
+ int cnt;
+
+ assert (sizeof (struct aiocb) == sizeof (struct aiocb64));
+
+ if (pool_size + 1 >= pool_max_size)
+ {
+ size_t new_max_size = pool_max_size + ROWS_STEP;
+ struct requestlist **new_tab;
+
+ new_tab = (struct requestlist **)
+ realloc (pool, new_max_size * sizeof (struct requestlist *));
+
+ if (new_tab == NULL)
+ return NULL;
+
+ pool_max_size = new_max_size;
+ pool = new_tab;
+ }
+
+ /* Allocate the new row. */
+ cnt = pool_size == 0 ? optim.aio_num : ENTRIES_PER_ROW;
+ new_row = (struct requestlist *) calloc (cnt,
+ sizeof (struct requestlist));
+ if (new_row == NULL)
+ return NULL;
+
+ pool[pool_size++] = new_row;
+
+ /* Put all the new entries in the freelist. */
+ do
+ {
+ new_row->next_prio = freelist;
+ freelist = new_row++;
+ }
+ while (--cnt > 0);
+ }
+
+ result = freelist;
+ freelist = freelist->next_prio;
+
+ return result;
+}
+
+
+void
+__aio_free_request (struct requestlist *elem)
+{
+ elem->running = no;
+ elem->next_prio = freelist;
+ freelist = elem;
+}
+
+
+struct requestlist *
+__aio_find_req (aiocb_union *elem)
+{
+ struct requestlist *runp = requests;
+ int fildes = elem->aiocb.aio_fildes;
+
+ while (runp != NULL && runp->aiocbp->aiocb.aio_fildes < fildes)
+ runp = runp->next_fd;
+
+ if (runp != NULL)
+ {
+ if (runp->aiocbp->aiocb.aio_fildes != fildes)
+ runp = NULL;
+ else
+ while (runp != NULL && runp->aiocbp != elem)
+ runp = runp->next_prio;
+ }
+
+ return runp;
+}
+
+
+struct requestlist *
+__aio_find_req_fd (int fildes)
+{
+ struct requestlist *runp = requests;
+
+ while (runp != NULL && runp->aiocbp->aiocb.aio_fildes < fildes)
+ runp = runp->next_fd;
+
+ return (runp != NULL && runp->aiocbp->aiocb.aio_fildes == fildes
+ ? runp : NULL);
+}
+
+
+void
+__aio_remove_request (struct requestlist *last, struct requestlist *req,
+ int all)
+{
+ assert (req->running == yes || req->running == queued
+ || req->running == done);
+
+ if (last != NULL)
+ last->next_prio = all ? NULL : req->next_prio;
+ else
+ {
+ if (all || req->next_prio == NULL)
+ {
+ if (req->last_fd != NULL)
+ req->last_fd->next_fd = req->next_fd;
+ else
+ requests = req->next_fd;
+ if (req->next_fd != NULL)
+ req->next_fd->last_fd = req->last_fd;
+ }
+ else
+ {
+ if (req->last_fd != NULL)
+ req->last_fd->next_fd = req->next_prio;
+ else
+ requests = req->next_prio;
+
+ if (req->next_fd != NULL)
+ req->next_fd->last_fd = req->next_prio;
+
+ req->next_prio->last_fd = req->last_fd;
+ req->next_prio->next_fd = req->next_fd;
+
+ /* Mark this entry as runnable. */
+ req->next_prio->running = yes;
+ }
+
+ if (req->running == yes)
+ {
+ struct requestlist *runp = runlist;
+
+ last = NULL;
+ while (runp != NULL)
+ {
+ if (runp == req)
+ {
+ if (last == NULL)
+ runlist = runp->next_run;
+ else
+ last->next_run = runp->next_run;
+ break;
+ }
+ last = runp;
+ runp = runp->next_run;
+ }
+ }
+ }
+}
+
+
+/* The thread handler. */
+static void *handle_fildes_io (void *arg);
+
+
+/* User optimization. */
void
__aio_init (const struct aioinit *init)
{
+ /* Get the mutex. */
+ pthread_mutex_lock (&__aio_requests_mutex);
+
+ /* Only allow writing new values if the table is not yet allocated. */
+ if (pool == NULL)
+ {
+ optim.aio_threads = init->aio_threads < 1 ? 1 : init->aio_threads;
+ assert (powerof2 (ENTRIES_PER_ROW));
+ optim.aio_num = (init->aio_num < ENTRIES_PER_ROW
+ ? ENTRIES_PER_ROW
+ : init->aio_num & ~(ENTRIES_PER_ROW - 1));
+ }
+
+ if (init->aio_idle_time != 0)
+ optim.aio_idle_time = init->aio_idle_time;
+
+ /* Release the mutex. */
+ pthread_mutex_unlock (&__aio_requests_mutex);
}
weak_alias (__aio_init, aio_init)
+
+
+/* The main function of the async I/O handling. It enqueues requests
+ and if necessary starts and handles threads. */
+struct requestlist *
+__aio_enqueue_request (aiocb_union *aiocbp, int operation)
+{
+ int result = 0;
+ int policy, prio;
+ struct sched_param param;
+ struct requestlist *last, *runp, *newp;
+ int running = no;
+
+ if (operation == LIO_SYNC || operation == LIO_DSYNC)
+ aiocbp->aiocb.aio_reqprio = 0;
+ else if (aiocbp->aiocb.aio_reqprio < 0
+#ifdef AIO_PRIO_DELTA_MAX
+ || aiocbp->aiocb.aio_reqprio > AIO_PRIO_DELTA_MAX
+#endif
+ )
+ {
+ /* Invalid priority value. */
+ __set_errno (EINVAL);
+ aiocbp->aiocb.__error_code = EINVAL;
+ aiocbp->aiocb.__return_value = -1;
+ return NULL;
+ }
+
+ /* Compute priority for this request. */
+ pthread_getschedparam (pthread_self (), &policy, ¶m);
+ prio = param.sched_priority - aiocbp->aiocb.aio_reqprio;
+
+ /* Get the mutex. */
+ pthread_mutex_lock (&__aio_requests_mutex);
+
+ last = NULL;
+ runp = requests;
+ /* First look whether the current file descriptor is currently
+ worked with. */
+ while (runp != NULL
+ && runp->aiocbp->aiocb.aio_fildes < aiocbp->aiocb.aio_fildes)
+ {
+ last = runp;
+ runp = runp->next_fd;
+ }
+
+ /* Get a new element for the waiting list. */
+ newp = get_elem ();
+ if (newp == NULL)
+ {
+ pthread_mutex_unlock (&__aio_requests_mutex);
+ __set_errno (EAGAIN);
+ return NULL;
+ }
+ newp->aiocbp = aiocbp;
+ newp->waiting = 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;
+
+ if (runp != NULL
+ && runp->aiocbp->aiocb.aio_fildes == aiocbp->aiocb.aio_fildes)
+ {
+ /* The current file descriptor is worked on. It makes no sense
+ to start another thread since this new thread would fight
+ with the running thread for the resources. But we also cannot
+ say that the thread processing this desriptor shall immediately
+ after finishing the current job process this request if there
+ are other threads in the running queue which have a higher
+ priority. */
+
+ /* Simply enqueue it after the running one according to the
+ priority. */
+ last = NULL;
+ while (runp->next_prio != NULL
+ && runp->next_prio->aiocbp->aiocb.__abs_prio >= prio)
+ {
+ last = runp;
+ runp = runp->next_prio;
+ }
+
+ newp->next_prio = runp->next_prio;
+ runp->next_prio = newp;
+
+ running = queued;
+ }
+ else
+ {
+ running = yes;
+ /* Enqueue this request for a new descriptor. */
+ if (last == NULL)
+ {
+ newp->last_fd = NULL;
+ newp->next_fd = requests;
+ if (requests != NULL)
+ requests->last_fd = newp;
+ requests = newp;
+ }
+ else
+ {
+ newp->next_fd = last->next_fd;
+ newp->last_fd = last;
+ last->next_fd = newp;
+ if (newp->next_fd != NULL)
+ newp->next_fd->last_fd = newp;
+ }
+
+ newp->next_prio = NULL;
+ last = NULL;
+ }
+
+ if (running == yes)
+ {
+ /* We try to 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.
+
+ If no new thread can be created or if the specified limit of
+ threads for AIO is reached we queue the request. */
+
+ /* See if we need to and are able to create a thread. */
+ if (nthreads < optim.aio_threads && idle_thread_count == 0)
+ {
+ pthread_t thid;
+
+ running = newp->running = allocated;
+
+ /* Now try to start a thread. */
+ result = aio_create_helper_thread (&thid, handle_fildes_io, newp);
+ if (result == 0)
+ /* We managed to enqueue the request. All errors which can
+ happen now can be recognized by calls to `aio_return' and
+ `aio_error'. */
+ ++nthreads;
+ else
+ {
+ /* Reset the running flag. The new request is not running. */
+ running = newp->running = yes;
+
+ if (nthreads == 0)
+ {
+ /* We cannot create a thread in the moment and there is
+ also no thread running. This is a problem. `errno' is
+ set to EAGAIN if this is only a temporary problem. */
+ __aio_remove_request (last, newp, 0);
+ }
+ else
+ result = 0;
+ }
+ }
+ }
+
+ /* Enqueue the request in the run queue if it is not yet running. */
+ if (running == yes && result == 0)
+ {
+ add_request_to_runlist (newp);
+
+ /* If there is a thread waiting for work, then let it know that we
+ have just given it something to do. */
+ if (idle_thread_count > 0)
+ pthread_cond_signal (&__aio_new_request_notification);
+ }
+
+ if (result == 0)
+ newp->running = running;
+ else
+ {
+ /* Something went wrong. */
+ __aio_free_request (newp);
+ aiocbp->aiocb.__error_code = result;
+ __set_errno (result);
+ newp = NULL;
+ }
+
+ /* Release the mutex. */
+ pthread_mutex_unlock (&__aio_requests_mutex);
+
+ return newp;
+}
+
+
+static void *
+handle_fildes_io (void *arg)
+{
+ pthread_t self = pthread_self ();
+ struct sched_param param;
+ struct requestlist *runp = (struct requestlist *) arg;
+ aiocb_union *aiocbp;
+ int policy;
+ int fildes;
+
+ pthread_getschedparam (self, &policy, ¶m);
+
+ do
+ {
+ /* If runp is NULL, then we were created to service the work queue
+ in general, not to handle any particular request. In that case we
+ skip the "do work" stuff on the first pass, and go directly to the
+ "get work off the work queue" part of this loop, which is near the
+ end. */
+ if (runp == NULL)
+ pthread_mutex_lock (&__aio_requests_mutex);
+ else
+ {
+ /* Hopefully this request is marked as running. */
+ assert (runp->running == allocated);
+
+ /* Update our variables. */
+ aiocbp = runp->aiocbp;
+ fildes = aiocbp->aiocb.aio_fildes;
+
+ /* Change the priority to the requested value (if necessary). */
+ if (aiocbp->aiocb.__abs_prio != param.sched_priority
+ || aiocbp->aiocb.__policy != policy)
+ {
+ param.sched_priority = aiocbp->aiocb.__abs_prio;
+ policy = aiocbp->aiocb.__policy;
+ pthread_setschedparam (self, policy, ¶m);
+ }
+
+ /* Process request pointed to by RUNP. We must not be disturbed
+ by signals. */
+ if ((aiocbp->aiocb.aio_lio_opcode & 127) == LIO_READ)
+ {
+ if (sizeof (off_t) != sizeof (off64_t)
+ && aiocbp->aiocb.aio_lio_opcode & 128)
+ aiocbp->aiocb.__return_value =
+ TEMP_FAILURE_RETRY (__pread64 (fildes, (void *)
+ aiocbp->aiocb64.aio_buf,
+ aiocbp->aiocb64.aio_nbytes,
+ aiocbp->aiocb64.aio_offset));
+ else
+ aiocbp->aiocb.__return_value =
+ TEMP_FAILURE_RETRY (__libc_pread (fildes,
+ (void *)
+ aiocbp->aiocb.aio_buf,
+ aiocbp->aiocb.aio_nbytes,
+ aiocbp->aiocb.aio_offset));
+
+ if (aiocbp->aiocb.__return_value == -1 && errno == ESPIPE)
+ /* The Linux kernel is different from others. It returns
+ ESPIPE if using pread on a socket. Other platforms
+ simply ignore the offset parameter and behave like
+ read. */
+ aiocbp->aiocb.__return_value =
+ TEMP_FAILURE_RETRY (read (fildes,
+ (void *) aiocbp->aiocb64.aio_buf,
+ aiocbp->aiocb64.aio_nbytes));
+ }
+ else if ((aiocbp->aiocb.aio_lio_opcode & 127) == LIO_WRITE)
+ {
+ if (sizeof (off_t) != sizeof (off64_t)
+ && aiocbp->aiocb.aio_lio_opcode & 128)
+ aiocbp->aiocb.__return_value =
+ TEMP_FAILURE_RETRY (__pwrite64 (fildes, (const void *)
+ aiocbp->aiocb64.aio_buf,
+ aiocbp->aiocb64.aio_nbytes,
+ aiocbp->aiocb64.aio_offset));
+ else
+ aiocbp->aiocb.__return_value =
+ TEMP_FAILURE_RETRY (__libc_pwrite (fildes, (const void *)
+ aiocbp->aiocb.aio_buf,
+ aiocbp->aiocb.aio_nbytes,
+ aiocbp->aiocb.aio_offset));
+
+ if (aiocbp->aiocb.__return_value == -1 && errno == ESPIPE)
+ /* The Linux kernel is different from others. It returns
+ ESPIPE if using pwrite on a socket. Other platforms
+ simply ignore the offset parameter and behave like
+ write. */
+ aiocbp->aiocb.__return_value =
+ TEMP_FAILURE_RETRY (write (fildes,
+ (void *) aiocbp->aiocb64.aio_buf,
+ aiocbp->aiocb64.aio_nbytes));
+ }
+ else if (aiocbp->aiocb.aio_lio_opcode == LIO_DSYNC)
+ aiocbp->aiocb.__return_value =
+ TEMP_FAILURE_RETRY (fdatasync (fildes));
+ else if (aiocbp->aiocb.aio_lio_opcode == LIO_SYNC)
+ aiocbp->aiocb.__return_value =
+ TEMP_FAILURE_RETRY (fsync (fildes));
+ else
+ {
+ /* This is an invalid opcode. */
+ aiocbp->aiocb.__return_value = -1;
+ __set_errno (EINVAL);
+ }
+
+ /* Get the mutex. */
+ pthread_mutex_lock (&__aio_requests_mutex);
+
+ if (aiocbp->aiocb.__return_value == -1)
+ aiocbp->aiocb.__error_code = errno;
+ else
+ aiocbp->aiocb.__error_code = 0;
+
+ /* Send the signal to notify about finished processing of the
+ request. */
+ __aio_notify (runp);
+
+ /* For debugging purposes we reset the running flag of the
+ finished request. */
+ assert (runp->running == allocated);
+ runp->running = done;
+
+ /* Now dequeue the current request. */
+ __aio_remove_request (NULL, runp, 0);
+ if (runp->next_prio != NULL)
+ add_request_to_runlist (runp->next_prio);
+
+ /* Free the old element. */
+ __aio_free_request (runp);
+ }
+
+ runp = runlist;
+
+ /* If the runlist is empty, then we sleep for a while, waiting for
+ something to arrive in it. */
+ if (runp == NULL && optim.aio_idle_time >= 0)
+ {
+ struct timespec now;
+ struct timespec wakeup_time;
+
+ ++idle_thread_count;
+ __clock_gettime (CLOCK_REALTIME, &now);
+ wakeup_time.tv_sec = now.tv_sec + optim.aio_idle_time;
+ wakeup_time.tv_nsec = now.tv_nsec;
+ if (wakeup_time.tv_nsec >= 1000000000)
+ {
+ wakeup_time.tv_nsec -= 1000000000;
+ ++wakeup_time.tv_sec;
+ }
+ pthread_cond_timedwait (&__aio_new_request_notification,
+ &__aio_requests_mutex,
+ &wakeup_time);
+ --idle_thread_count;
+ runp = runlist;
+ }
+
+ if (runp == NULL)
+ --nthreads;
+ else
+ {
+ assert (runp->running == yes);
+ runp->running = allocated;
+ runlist = runp->next_run;
+
+ /* If we have a request to process, and there's still another in
+ the run list, then we need to either wake up or create a new
+ thread to service the request that is still in the run list. */
+ if (runlist != NULL)
+ {
+ /* There are at least two items in the work queue to work on.
+ If there are other idle threads, then we should wake them
+ up for these other work elements; otherwise, we should try
+ to create a new thread. */
+ if (idle_thread_count > 0)
+ pthread_cond_signal (&__aio_new_request_notification);
+ else if (nthreads < optim.aio_threads)
+ {
+ pthread_t thid;
+ pthread_attr_t attr;
+
+ /* 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 we fail, no big deal,
+ because we know that there is at least one thread (us)
+ that is working on AIO operations. */
+ if (pthread_create (&thid, &attr, handle_fildes_io, NULL)
+ == 0)
+ ++nthreads;
+ }
+ }
+ }
+
+ /* Release the mutex. */
+ pthread_mutex_unlock (&__aio_requests_mutex);
+ }
+ while (runp != NULL);
+
+ return NULL;
+}
+
+
+/* Free allocated resources. */
+libc_freeres_fn (free_res)
+{
+ size_t row;
+
+ for (row = 0; row < pool_max_size; ++row)
+ free (pool[row]);
+
+ free (pool);
+}
+
+
+/* Add newrequest to the runlist. The __abs_prio flag of newrequest must
+ be correctly set to do this. Also, you had better set newrequest's
+ "running" flag to "yes" before you release your lock or you'll throw an
+ assertion. */
+static void
+add_request_to_runlist (struct requestlist *newrequest)
+{
+ int prio = newrequest->aiocbp->aiocb.__abs_prio;
+ struct requestlist *runp;
+
+ if (runlist == NULL || runlist->aiocbp->aiocb.__abs_prio < prio)
+ {
+ newrequest->next_run = runlist;
+ runlist = newrequest;
+ }
+ else
+ {
+ runp = runlist;
+
+ while (runp->next_run != NULL
+ && runp->next_run->aiocbp->aiocb.__abs_prio >= prio)
+ runp = runp->next_run;
+
+ newrequest->next_run = runp->next_run;
+ runp->next_run = newrequest;
+ }
+}
diff --git a/rt/aio_notify.c b/rt/aio_notify.c
index 9d51fd9c5e..a8d61503d8 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;
+ }
+}
diff --git a/rt/aio_read.c b/rt/aio_read.c
index fcd5acea8e..4698e48b1c 100644
--- a/rt/aio_read.c
+++ b/rt/aio_read.c
@@ -1,6 +1,7 @@
-/* Asynchronous read. Stub version.
- Copyright (C) 2001-2021 Free Software Foundation, Inc.
+/* Asynchronous read.
+ 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
@@ -17,18 +18,13 @@
<https://www.gnu.org/licenses/>. */
#include <aio.h>
-#include <errno.h>
-#ifdef BE_AIO64
-#define aiocb aiocb64
-#define aio_read aio_read64
-#endif
+#include <aio_misc.h>
+
int
aio_read (struct aiocb *aiocbp)
{
- __set_errno (ENOSYS);
- return -1;
+ return (__aio_enqueue_request ((aiocb_union *) aiocbp, LIO_READ) == NULL
+ ? -1 : 0);
}
-
-stub_warning (aio_read)
diff --git a/rt/aio_read64.c b/rt/aio_read64.c
index e9994aefcb..26b9b0b380 100644
--- a/rt/aio_read64.c
+++ b/rt/aio_read64.c
@@ -1,2 +1,30 @@
-#define BE_AIO64
-#include <aio_read.c>
+/* Asynchronous read, 64bit offset version.
+ 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
+ License as published by the Free Software Foundation; either
+ version 2.1 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, see
+ <https://www.gnu.org/licenses/>. */
+
+#include <aio.h>
+
+#include <aio_misc.h>
+
+
+int
+aio_read64 (struct aiocb64 *aiocbp)
+{
+ return (__aio_enqueue_request ((aiocb_union *) aiocbp, LIO_READ64) == NULL
+ ? -1 : 0);
+}
diff --git a/rt/aio_suspend.c b/rt/aio_suspend.c
index 32f5f7e742..6fd5b1bee2 100644
--- a/rt/aio_suspend.c
+++ b/rt/aio_suspend.c
@@ -1,6 +1,7 @@
-/* Suspend until termination of a requests. Stub version.
- Copyright (C) 2001-2021 Free Software Foundation, Inc.
+/* Suspend until termination of a requests.
+ 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
@@ -27,18 +28,236 @@
/* And undo the hack. */
#undef aio_suspend64
+#include <assert.h>
#include <errno.h>
+#include <stdbool.h>
+#include <stdlib.h>
#include <sys/time.h>
+#include <libc-lock.h>
+#include <aio_misc.h>
+
+
+struct clparam
+{
+ const struct aiocb *const *list;
+ struct waitlist *waitlist;
+ struct requestlist **requestlist;
+#ifndef DONT_NEED_AIO_MISC_COND
+ pthread_cond_t *cond;
+#endif
+ int nent;
+};
+
+
+static void
+cleanup (void *arg)
+{
+#ifdef DONT_NEED_AIO_MISC_COND
+ /* Acquire the mutex. If pthread_cond_*wait is used this would
+ happen implicitly. */
+ pthread_mutex_lock (&__aio_requests_mutex);
+#endif
+
+ const struct clparam *param = (const struct clparam *) arg;
+
+ /* Now remove the entry in the waiting list for all requests
+ which didn't terminate. */
+ int cnt = param->nent;
+ while (cnt-- > 0)
+ if (param->list[cnt] != NULL
+ && param->list[cnt]->__error_code == EINPROGRESS)
+ {
+ struct waitlist **listp;
+
+ assert (param->requestlist[cnt] != NULL);
+
+ /* There is the chance that we cannot find our entry anymore. This
+ could happen if the request terminated and restarted again. */
+ listp = ¶m->requestlist[cnt]->waiting;
+ while (*listp != NULL && *listp != ¶m->waitlist[cnt])
+ listp = &(*listp)->next;
+
+ if (*listp != NULL)
+ *listp = (*listp)->next;
+ }
+
+#ifndef DONT_NEED_AIO_MISC_COND
+ /* Release the conditional variable. */
+ (void) pthread_cond_destroy (param->cond);
+#endif
+
+ /* Release the mutex. */
+ pthread_mutex_unlock (&__aio_requests_mutex);
+}
+
+#ifdef DONT_NEED_AIO_MISC_COND
+static int
+__attribute__ ((noinline))
+do_aio_misc_wait (unsigned int *cntr, const struct __timespec64 *timeout)
+{
+ int result = 0;
+
+ AIO_MISC_WAIT (result, *cntr, timeout, 1);
+
+ return result;
+}
+#endif
int
-aio_suspend (const struct aiocb *const list[], int nent,
- const struct timespec *timeout)
+__aio_suspend_time64 (const struct aiocb *const list[], int nent,
+ const struct __timespec64 *timeout)
{
- __set_errno (ENOSYS);
- return -1;
+ if (__glibc_unlikely (nent < 0))
+ {
+ __set_errno (EINVAL);
+ return -1;
+ }
+
+ struct waitlist waitlist[nent];
+ struct requestlist *requestlist[nent];
+#ifndef DONT_NEED_AIO_MISC_COND
+ pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
+#endif
+ int cnt;
+ bool any = false;
+ int result = 0;
+ unsigned int cntr = 1;
+
+ /* Request the mutex. */
+ pthread_mutex_lock (&__aio_requests_mutex);
+
+ /* There is not yet a finished request. Signal the request that
+ we are working for it. */
+ for (cnt = 0; cnt < nent; ++cnt)
+ if (list[cnt] != NULL)
+ {
+ if (list[cnt]->__error_code == EINPROGRESS)
+ {
+ requestlist[cnt] = __aio_find_req ((aiocb_union *) list[cnt]);
+
+ if (requestlist[cnt] != NULL)
+ {
+#ifndef DONT_NEED_AIO_MISC_COND
+ waitlist[cnt].cond = &cond;
+#endif
+ waitlist[cnt].result = NULL;
+ waitlist[cnt].next = requestlist[cnt]->waiting;
+ waitlist[cnt].counterp = &cntr;
+ waitlist[cnt].sigevp = NULL;
+ requestlist[cnt]->waiting = &waitlist[cnt];
+ any = true;
+ }
+ else
+ /* We will never suspend. */
+ break;
+ }
+ else
+ /* We will never suspend. */
+ break;
+ }
+
+ struct __timespec64 ts;
+ if (timeout != NULL)
+ {
+ __clock_gettime64 (CLOCK_MONOTONIC, &ts);
+ ts.tv_sec += timeout->tv_sec;
+ ts.tv_nsec += timeout->tv_nsec;
+ if (ts.tv_nsec >= 1000000000)
+ {
+ ts.tv_nsec -= 1000000000;
+ ts.tv_sec++;
+ }
+ }
+
+ /* Only if none of the entries is NULL or finished to be wait. */
+ if (cnt == nent && any)
+ {
+ struct clparam clparam =
+ {
+ .list = list,
+ .waitlist = waitlist,
+ .requestlist = requestlist,
+#ifndef DONT_NEED_AIO_MISC_COND
+ .cond = &cond,
+#endif
+ .nent = nent
+ };
+
+ pthread_cleanup_push (cleanup, &clparam);
+
+#ifdef DONT_NEED_AIO_MISC_COND
+ result = do_aio_misc_wait (&cntr, timeout == NULL ? NULL : &ts);
+#else
+ struct timespec ts32 = valid_timespec64_to_timespec (ts);
+ result = pthread_cond_timedwait (&cond, &__aio_requests_mutex,
+ timeout == NULL ? NULL : &ts32);
+#endif
+
+ pthread_cleanup_pop (0);
+ }
+
+ /* Now remove the entry in the waiting list for all requests
+ which didn't terminate. */
+ while (cnt-- > 0)
+ if (list[cnt] != NULL && list[cnt]->__error_code == EINPROGRESS)
+ {
+ struct waitlist **listp;
+
+ assert (requestlist[cnt] != NULL);
+
+ /* There is the chance that we cannot find our entry anymore. This
+ could happen if the request terminated and restarted again. */
+ listp = &requestlist[cnt]->waiting;
+ while (*listp != NULL && *listp != &waitlist[cnt])
+ listp = &(*listp)->next;
+
+ if (*listp != NULL)
+ *listp = (*listp)->next;
+ }
+
+#ifndef DONT_NEED_AIO_MISC_COND
+ /* Release the conditional variable. */
+ if (__glibc_unlikely (pthread_cond_destroy (&cond) != 0))
+ /* This must never happen. */
+ abort ();
+#endif
+
+ if (result != 0)
+ {
+#ifndef DONT_NEED_AIO_MISC_COND
+ /* An error occurred. Possibly it's ETIMEDOUT. We have to translate
+ the timeout error report of `pthread_cond_timedwait' to the
+ form expected from `aio_suspend'. */
+ if (result == ETIMEDOUT)
+ __set_errno (EAGAIN);
+ else
+#endif
+ __set_errno (result);
+
+ result = -1;
+ }
+
+ /* Release the mutex. */
+ pthread_mutex_unlock (&__aio_requests_mutex);
+
+ return result;
}
-weak_alias (aio_suspend, aio_suspend64)
-stub_warning (aio_suspend)
-stub_warning (aio_suspend64)
+#if __TIMESIZE != 64
+librt_hidden_def (__aio_suspend_time64)
+
+int
+__aio_suspend (const struct aiocb *const list[], int nent,
+ const struct timespec *timeout)
+{
+ struct __timespec64 ts64;
+
+ if (timeout != NULL)
+ ts64 = valid_timespec_to_timespec64 (*timeout);
+
+ return __aio_suspend_time64 (list, nent, timeout != NULL ? &ts64 : NULL);
+}
+#endif
+weak_alias (__aio_suspend, aio_suspend)
+weak_alias (aio_suspend, aio_suspend64)
diff --git a/rt/aio_write.c b/rt/aio_write.c
index 18a338e094..ea55f0dbbc 100644
--- a/rt/aio_write.c
+++ b/rt/aio_write.c
@@ -1,6 +1,7 @@
-/* Asynchronous write. Stub version.
- Copyright (C) 2001-2021 Free Software Foundation, Inc.
+/* Asynchronous write.
+ 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
@@ -17,18 +18,13 @@
<https://www.gnu.org/licenses/>. */
#include <aio.h>
-#include <errno.h>
-#ifdef BE_AIO64
-#define aiocb aiocb64
-#define aio_write aio_write64
-#endif
+#include <aio_misc.h>
+
int
aio_write (struct aiocb *aiocbp)
{
- __set_errno (ENOSYS);
- return -1;
+ return (__aio_enqueue_request ((aiocb_union *) aiocbp, LIO_WRITE) == NULL
+ ? -1 : 0);
}
-
-stub_warning (aio_write)
diff --git a/rt/aio_write64.c b/rt/aio_write64.c
index 88d5c001ce..bd6dd316be 100644
--- a/rt/aio_write64.c
+++ b/rt/aio_write64.c
@@ -1,2 +1,30 @@
-#define BE_AIO64
-#include <aio_write.c>
+/* Asynchronous write, 64bit offset version.
+ 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
+ License as published by the Free Software Foundation; either
+ version 2.1 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, see
+ <https://www.gnu.org/licenses/>. */
+
+#include <aio.h>
+
+#include <aio_misc.h>
+
+
+int
+aio_write64 (struct aiocb64 *aiocbp)
+{
+ return (__aio_enqueue_request ((aiocb_union *) aiocbp, LIO_WRITE64) == NULL
+ ? -1 : 0);
+}
diff --git a/rt/lio_listio.c b/rt/lio_listio.c
index db4ce68afc..2cab3c2254 100644
--- a/rt/lio_listio.c
+++ b/rt/lio_listio.c
@@ -1,6 +1,7 @@
-/* Enqueue a list of read or write requests. Stub version.
- Copyright (C) 2001-2021 Free Software Foundation, Inc.
+/* Enqueue and list of read or write requests.
+ 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,25 +17,232 @@
License along with the GNU C Library; if not, see
<https://www.gnu.org/licenses/>. */
+#ifndef lio_listio
#include <aio.h>
+#include <assert.h>
#include <errno.h>
+#include <stdlib.h>
+#include <unistd.h>
-#ifdef BE_AIO64
-#define lio_listio lio_listio64
-#define aiocb aiocb64
-#define aio_read aio_read64
-#define aio_write aio_write64
-#define aio_suspend aio_suspend64
+#include <aio_misc.h>
+
+#define LIO_OPCODE_BASE 0
+#endif
+
+#include <shlib-compat.h>
+
+
+/* We need this special structure to handle asynchronous I/O. */
+struct async_waitlist
+ {
+ unsigned int counter;
+ struct sigevent sigev;
+ struct waitlist list[0];
+ };
+
+
+/* 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];
+ int cnt;
+ volatile unsigned int total = 0;
+ int result = 0;
+
+ if (sig == NULL)
+ {
+ defsigev.sigev_notify = SIGEV_NONE;
+ sig = &defsigev;
+ }
+
+ /* Request the mutex. */
+ pthread_mutex_lock (&__aio_requests_mutex);
+
+ /* Now we can enqueue all requests. Since we already acquired the
+ mutex 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 (NO_INDIVIDUAL_EVENT_P (mode))
+ list[cnt]->aio_sigevent.sigev_notify = SIGEV_NONE;
+
+ requests[cnt] = __aio_enqueue_request ((aiocb_union *) list[cnt],
+ (list[cnt]->aio_lio_opcode
+ | LIO_OPCODE_BASE));
+
+ if (requests[cnt] != NULL)
+ /* Successfully enqueued. */
+ ++total;
+ else
+ /* Signal that we've seen an error. `errno' and the error code
+ of the aiocb will tell more. */
+ result = -1;
+ }
+ else
+ requests[cnt] = NULL;
+
+ if (total == 0)
+ {
+ /* We don't have anything to do except signalling if we work
+ asynchronously. */
+
+ /* Release the mutex. We do this before raising a signal since the
+ signal handler might do a `siglongjmp' and then the mutex is
+ locked forever. */
+ pthread_mutex_unlock (&__aio_requests_mutex);
+
+ if (LIO_MODE (mode) == LIO_NOWAIT)
+ __aio_notify_only (sig);
+
+ return result;
+ }
+ else if (LIO_MODE (mode) == LIO_WAIT)
+ {
+#ifndef DONT_NEED_AIO_MISC_COND
+ pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
+ int oldstate;
+#endif
+ struct waitlist waitlist[nent];
+
+ total = 0;
+ for (cnt = 0; cnt < nent; ++cnt)
+ {
+ assert (requests[cnt] == NULL || list[cnt] != NULL);
+
+ if (requests[cnt] != NULL && list[cnt]->aio_lio_opcode != LIO_NOP)
+ {
+#ifndef DONT_NEED_AIO_MISC_COND
+ waitlist[cnt].cond = &cond;
#endif
+ waitlist[cnt].result = &result;
+ waitlist[cnt].next = requests[cnt]->waiting;
+ waitlist[cnt].counterp = &total;
+ waitlist[cnt].sigevp = NULL;
+ requests[cnt]->waiting = &waitlist[cnt];
+ ++total;
+ }
+ }
+#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 cancellation for now. */
+ pthread_setcancelstate (PTHREAD_CANCEL_DISABLE, &oldstate);
+ while (total > 0)
+ pthread_cond_wait (&cond, &__aio_requests_mutex);
+
+ /* 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 any of the I/O requests failed, return -1 and set errno. */
+ if (result != 0)
+ {
+ __set_errno (result == EINTR ? EINTR : EIO);
+ result = -1;
+ }
+ }
+ else
+ {
+ struct async_waitlist *waitlist;
+
+ waitlist = (struct async_waitlist *)
+ malloc (sizeof (struct async_waitlist)
+ + (nent * sizeof (struct waitlist)));
+
+ if (waitlist == NULL)
+ {
+ __set_errno (EAGAIN);
+ result = -1;
+ }
+ else
+ {
+ total = 0;
+
+ for (cnt = 0; cnt < nent; ++cnt)
+ {
+ assert (requests[cnt] == NULL || list[cnt] != NULL);
+
+ 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;
+ requests[cnt]->waiting = &waitlist->list[cnt];
+ ++total;
+ }
+ }
+
+ waitlist->counter = total;
+ waitlist->sigev = *sig;
+ }
+ }
+
+ /* Release the mutex. */
+ pthread_mutex_unlock (&__aio_requests_mutex);
+
+ return result;
+}
+
+
+#if SHLIB_COMPAT (librt, GLIBC_2_1, GLIBC_2_4)
int
-lio_listio (int mode,
- struct aiocb *const list[], int nent,
- struct sigevent *sig)
+attribute_compat_text_section
+__lio_listio_21 (int mode, struct aiocb *const list[], int nent,
+ struct sigevent *sig)
{
- __set_errno (ENOSYS);
- return -1;
+ /* 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
-stub_warning (lio_listio)
+
+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);
diff --git a/rt/lio_listio64.c b/rt/lio_listio64.c
index 35a571c685..111c883a2f 100644
--- a/rt/lio_listio64.c
+++ b/rt/lio_listio64.c
@@ -1,2 +1,33 @@
-#define BE_AIO64
+/* Enqueue and list of read or write requests, 64bit offset version.
+ 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
+ License as published by the Free Software Foundation; either
+ version 2.1 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, see
+ <https://www.gnu.org/licenses/>. */
+
+#include <aio.h>
+#include <assert.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include <aio_misc.h>
+
+#define lio_listio lio_listio64
+#define __lio_listio_21 __lio_listio64_21
+#define __lio_listio_item_notify __lio_listio64_item_notify
+#define aiocb aiocb64
+#define LIO_OPCODE_BASE 128
#include <lio_listio.c>
diff --git a/rt/timer_create.c b/rt/timer_create.c
index 79d4d18317..2808f5b32b 100644
--- a/rt/timer_create.c
+++ b/rt/timer_create.c
@@ -1,10 +1,11 @@
-/* Copyright (C) 1999-2021 Free Software Foundation, Inc.
+/* Copyright (C) 2000-2021 Free Software Foundation, Inc.
This file is part of the GNU C Library.
+ Contributed by Kaz Kylheku <kaz@ashi.footprints.net>.
The GNU C Library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
+ modify it under the terms of the GNU Lesser General Public License as
+ published by the Free Software Foundation; either version 2.1 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
@@ -12,17 +13,154 @@
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
- License along with the GNU C Library; if not, see
- <https://www.gnu.org/licenses/>. */
+ License along with the GNU C Library; see the file COPYING.LIB. If
+ not, see <https://www.gnu.org/licenses/>. */
#include <errno.h>
+#include <signal.h>
+#include <pthread.h>
#include <time.h>
+#include <unistd.h>
+
+#include "posix-timer.h"
+
/* Create new per-process timer using CLOCK. */
int
timer_create (clockid_t clock_id, struct sigevent *evp, timer_t *timerid)
{
- __set_errno (ENOSYS);
- return -1;
+ int retval = -1;
+ struct timer_node *newtimer = NULL;
+ struct thread_node *thread = NULL;
+
+ if (0
+#if defined _POSIX_CPUTIME && _POSIX_CPUTIME >= 0
+ || clock_id == CLOCK_PROCESS_CPUTIME_ID
+#endif
+#if defined _POSIX_THREAD_CPUTIME && _POSIX_THREAD_CPUTIME >= 0
+ || clock_id == CLOCK_THREAD_CPUTIME_ID
+#endif
+ )
+ {
+ /* We don't allow timers for CPU clocks. At least not in the
+ moment. */
+ __set_errno (ENOTSUP);
+ return -1;
+ }
+
+ if (clock_id != CLOCK_REALTIME)
+ {
+ __set_errno (EINVAL);
+ return -1;
+ }
+
+ pthread_once (&__timer_init_once_control, __timer_init_once);
+
+ if (__timer_init_failed)
+ {
+ __set_errno (ENOMEM);
+ return -1;
+ }
+
+ pthread_mutex_lock (&__timer_mutex);
+
+ newtimer = __timer_alloc ();
+ if (__glibc_unlikely (newtimer == NULL))
+ {
+ __set_errno (EAGAIN);
+ goto unlock_bail;
+ }
+
+ if (evp != NULL)
+ newtimer->event = *evp;
+ else
+ {
+ newtimer->event.sigev_notify = SIGEV_SIGNAL;
+ newtimer->event.sigev_signo = SIGALRM;
+ newtimer->event.sigev_value.sival_ptr = newtimer;
+ newtimer->event.sigev_notify_function = 0;
+ }
+
+ newtimer->event.sigev_notify_attributes = &newtimer->attr;
+ newtimer->creator_pid = getpid ();
+
+ switch (__builtin_expect (newtimer->event.sigev_notify, SIGEV_SIGNAL))
+ {
+ case SIGEV_NONE:
+ case SIGEV_SIGNAL:
+ /* We have a global thread for delivering timed signals.
+ If it is not running, try to start it up. */
+ thread = &__timer_signal_thread_rclk;
+ if (! thread->exists)
+ {
+ if (__builtin_expect (__timer_thread_start (thread),
+ 1) < 0)
+ {
+ __set_errno (EAGAIN);
+ goto unlock_bail;
+ }
+ }
+ break;
+
+ case SIGEV_THREAD:
+ /* Copy over thread attributes or set up default ones. */
+ if (evp->sigev_notify_attributes)
+ newtimer->attr = *(pthread_attr_t *) evp->sigev_notify_attributes;
+ else
+ pthread_attr_init (&newtimer->attr);
+
+ /* Ensure thread attributes call for deatched thread. */
+ pthread_attr_setdetachstate (&newtimer->attr, PTHREAD_CREATE_DETACHED);
+
+ /* Try to find existing thread having the right attributes. */
+ thread = __timer_thread_find_matching (&newtimer->attr, clock_id);
+
+ /* If no existing thread has these attributes, try to allocate one. */
+ if (thread == NULL)
+ thread = __timer_thread_alloc (&newtimer->attr, clock_id);
+
+ /* Out of luck; no threads are available. */
+ if (__glibc_unlikely (thread == NULL))
+ {
+ __set_errno (EAGAIN);
+ goto unlock_bail;
+ }
+
+ /* If the thread is not running already, try to start it. */
+ if (! thread->exists
+ && __builtin_expect (! __timer_thread_start (thread), 0))
+ {
+ __set_errno (EAGAIN);
+ goto unlock_bail;
+ }
+ break;
+
+ default:
+ __set_errno (EINVAL);
+ goto unlock_bail;
+ }
+
+ newtimer->clock = clock_id;
+ newtimer->abstime = 0;
+ newtimer->armed = 0;
+ newtimer->thread = thread;
+
+ *timerid = timer_ptr2id (newtimer);
+ retval = 0;
+
+ if (__builtin_expect (retval, 0) == -1)
+ {
+ unlock_bail:
+ if (thread != NULL)
+ __timer_thread_dealloc (thread);
+ if (newtimer != NULL)
+ {
+ timer_delref (newtimer);
+ __timer_dealloc (newtimer);
+ }
+ }
+
+ pthread_mutex_unlock (&__timer_mutex);
+
+ return retval;
}
-stub_warning (timer_create)
diff --git a/rt/timer_delete.c b/rt/timer_delete.c
index 71da429e8b..c6f6d9743d 100644
--- a/rt/timer_delete.c
+++ b/rt/timer_delete.c
@@ -1,10 +1,11 @@
-/* Copyright (C) 1999-2021 Free Software Foundation, Inc.
+/* Copyright (C) 2000-2021 Free Software Foundation, Inc.
This file is part of the GNU C Library.
+ Contributed by Kaz Kylheku <kaz@ashi.footprints.net>.
The GNU C Library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
+ modify it under the terms of the GNU Lesser General Public License as
+ published by the Free Software Foundation; either version 2.1 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
@@ -12,17 +13,56 @@
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
- License along with the GNU C Library; if not, see
- <https://www.gnu.org/licenses/>. */
+ License along with the GNU C Library; see the file COPYING.LIB. If
+ not, see <https://www.gnu.org/licenses/>. */
+#include <assert.h>
#include <errno.h>
+#include <pthread.h>
#include <time.h>
+#include "posix-timer.h"
+
+
/* Delete timer TIMERID. */
int
timer_delete (timer_t timerid)
{
- __set_errno (ENOSYS);
- return -1;
+ struct timer_node *timer;
+ int retval = -1;
+
+ pthread_mutex_lock (&__timer_mutex);
+
+ timer = timer_id2ptr (timerid);
+ if (! timer_valid (timer))
+ /* Invalid timer ID or the timer is not in use. */
+ __set_errno (EINVAL);
+ else
+ {
+ if (timer->armed && timer->thread != NULL)
+ {
+ struct thread_node *thread = timer->thread;
+ assert (thread != NULL);
+
+ /* If thread is cancelled while waiting for handler to terminate,
+ the mutex is unlocked and timer_delete is aborted. */
+ pthread_cleanup_push (__timer_mutex_cancel_handler, &__timer_mutex);
+
+ /* If timer is currently being serviced, wait for it to finish. */
+ while (thread->current_timer == timer)
+ pthread_cond_wait (&thread->cond, &__timer_mutex);
+
+ pthread_cleanup_pop (0);
+ }
+
+ /* Remove timer from whatever queue it may be on and deallocate it. */
+ timer->inuse = TIMER_DELETED;
+ list_unlink_ip (&timer->links);
+ timer_delref (timer);
+ retval = 0;
+ }
+
+ pthread_mutex_unlock (&__timer_mutex);
+
+ return retval;
}
-stub_warning (timer_delete)
diff --git a/rt/timer_getoverr.c b/rt/timer_getoverr.c
index 3680ba687f..c1952f80c6 100644
--- a/rt/timer_getoverr.c
+++ b/rt/timer_getoverr.c
@@ -1,10 +1,11 @@
-/* Copyright (C) 1999-2021 Free Software Foundation, Inc.
+/* Copyright (C) 2000-2021 Free Software Foundation, Inc.
This file is part of the GNU C Library.
+ Contributed by Kaz Kylheku <kaz@ashi.footprints.net>.
The GNU C Library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
+ modify it under the terms of the GNU Lesser General Public License as
+ published by the Free Software Foundation; either version 2.1 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
@@ -12,17 +13,31 @@
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
- License along with the GNU C Library; if not, see
- <https://www.gnu.org/licenses/>. */
+ License along with the GNU C Library; see the file COPYING.LIB. If
+ not, see <https://www.gnu.org/licenses/>. */
#include <errno.h>
+#include <pthread.h>
#include <time.h>
+#include "posix-timer.h"
+
+
/* Get expiration overrun for timer TIMERID. */
int
timer_getoverrun (timer_t timerid)
{
- __set_errno (ENOSYS);
- return -1;
+ struct timer_node *timer;
+ int retval = -1;
+
+ pthread_mutex_lock (&__timer_mutex);
+
+ if (! timer_valid (timer = timer_id2ptr (timerid)))
+ __set_errno (EINVAL);
+ else
+ retval = timer->overrun_count;
+
+ pthread_mutex_unlock (&__timer_mutex);
+
+ return retval;
}
-stub_warning (timer_getoverrun)
diff --git a/rt/timer_gettime.c b/rt/timer_gettime.c
index 7bd94386a4..dd3b4a6281 100644
--- a/rt/timer_gettime.c
+++ b/rt/timer_gettime.c
@@ -1,10 +1,11 @@
-/* Copyright (C) 1999-2021 Free Software Foundation, Inc.
+/* Copyright (C) 2000-2021 Free Software Foundation, Inc.
This file is part of the GNU C Library.
+ Contributed by Kaz Kylheku <kaz@ashi.footprints.net>.
The GNU C Library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
+ modify it under the terms of the GNU Lesser General Public License as
+ published by the Free Software Foundation; either version 2.1 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
@@ -12,17 +13,62 @@
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
- License along with the GNU C Library; if not, see
- <https://www.gnu.org/licenses/>. */
+ License along with the GNU C Library; see the file COPYING.LIB. If
+ not, see <https://www.gnu.org/licenses/>. */
#include <errno.h>
+#include <pthread.h>
#include <time.h>
+#include "posix-timer.h"
+
+
/* Get current value of timer TIMERID and store it in VLAUE. */
int
timer_gettime (timer_t timerid, struct itimerspec *value)
{
- __set_errno (ENOSYS);
- return -1;
+ struct timer_node *timer;
+ struct timespec now, expiry;
+ int retval = -1, armed = 0, valid;
+ clock_t clock = 0;
+
+ pthread_mutex_lock (&__timer_mutex);
+
+ timer = timer_id2ptr (timerid);
+ valid = timer_valid (timer);
+
+ if (valid) {
+ armed = timer->armed;
+ expiry = timer->expirytime;
+ clock = timer->clock;
+ value->it_interval = timer->value.it_interval;
+ }
+
+ pthread_mutex_unlock (&__timer_mutex);
+
+ if (valid)
+ {
+ if (armed)
+ {
+ __clock_gettime (clock, &now);
+ if (timespec_compare (&now, &expiry) < 0)
+ timespec_sub (&value->it_value, &expiry, &now);
+ else
+ {
+ value->it_value.tv_sec = 0;
+ value->it_value.tv_nsec = 0;
+ }
+ }
+ else
+ {
+ value->it_value.tv_sec = 0;
+ value->it_value.tv_nsec = 0;
+ }
+
+ retval = 0;
+ }
+ else
+ __set_errno (EINVAL);
+
+ return retval;
}
-stub_warning (timer_gettime)
diff --git a/rt/timer_settime.c b/rt/timer_settime.c
index cde0e742fc..c05adf166f 100644
--- a/rt/timer_settime.c
+++ b/rt/timer_settime.c
@@ -1,10 +1,11 @@
-/* Copyright (C) 1999-2021 Free Software Foundation, Inc.
+/* Copyright (C) 2000-2021 Free Software Foundation, Inc.
This file is part of the GNU C Library.
+ Contributed by Kaz Kylheku <kaz@ashi.footprints.net>.
The GNU C Library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
+ modify it under the terms of the GNU Lesser General Public License as
+ published by the Free Software Foundation; either version 2.1 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
@@ -12,18 +13,119 @@
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
- License along with the GNU C Library; if not, see
- <https://www.gnu.org/licenses/>. */
+ License along with the GNU C Library; see the file COPYING.LIB. If
+ not, see <https://www.gnu.org/licenses/>. */
#include <errno.h>
+#include <pthread.h>
#include <time.h>
+#include "posix-timer.h"
+
+
/* Set timer TIMERID to VALUE, returning old value in OVLAUE. */
int
timer_settime (timer_t timerid, int flags, const struct itimerspec *value,
struct itimerspec *ovalue)
{
- __set_errno (ENOSYS);
- return -1;
+ struct timer_node *timer;
+ struct thread_node *thread = NULL;
+ struct timespec now;
+ int have_now = 0, need_wakeup = 0;
+ int retval = -1;
+
+ timer = timer_id2ptr (timerid);
+ if (timer == NULL)
+ {
+ __set_errno (EINVAL);
+ goto bail;
+ }
+
+ if (! valid_nanoseconds (value->it_interval.tv_nsec)
+ || ! valid_nanoseconds (value->it_value.tv_nsec))
+ {
+ __set_errno (EINVAL);
+ goto bail;
+ }
+
+ /* Will need to know current time since this is a relative timer;
+ might as well make the system call outside of the lock now! */
+
+ if ((flags & TIMER_ABSTIME) == 0)
+ {
+ __clock_gettime (timer->clock, &now);
+ have_now = 1;
+ }
+
+ pthread_mutex_lock (&__timer_mutex);
+ timer_addref (timer);
+
+ /* One final check of timer validity; this one is possible only
+ until we have the mutex, because it accesses the inuse flag. */
+
+ if (! timer_valid(timer))
+ {
+ __set_errno (EINVAL);
+ goto unlock_bail;
+ }
+
+ if (ovalue != NULL)
+ {
+ ovalue->it_interval = timer->value.it_interval;
+
+ if (timer->armed)
+ {
+ if (! have_now)
+ {
+ pthread_mutex_unlock (&__timer_mutex);
+ __clock_gettime (timer->clock, &now);
+ have_now = 1;
+ pthread_mutex_lock (&__timer_mutex);
+ timer_addref (timer);
+ }
+
+ timespec_sub (&ovalue->it_value, &timer->expirytime, &now);
+ }
+ else
+ {
+ ovalue->it_value.tv_sec = 0;
+ ovalue->it_value.tv_nsec = 0;
+ }
+ }
+
+ timer->value = *value;
+
+ list_unlink_ip (&timer->links);
+ timer->armed = 0;
+
+ thread = timer->thread;
+
+ /* A value of { 0, 0 } causes the timer to be stopped. */
+ if (value->it_value.tv_sec != 0
+ || __builtin_expect (value->it_value.tv_nsec != 0, 1))
+ {
+ if ((flags & TIMER_ABSTIME) != 0)
+ /* The user specified the expiration time. */
+ timer->expirytime = value->it_value;
+ else
+ timespec_add (&timer->expirytime, &now, &value->it_value);
+
+ /* Only need to wake up the thread if timer is inserted
+ at the head of the queue. */
+ if (thread != NULL)
+ need_wakeup = __timer_thread_queue_timer (thread, timer);
+ timer->armed = 1;
+ }
+
+ retval = 0;
+
+unlock_bail:
+ timer_delref (timer);
+ pthread_mutex_unlock (&__timer_mutex);
+
+bail:
+ if (thread != NULL && need_wakeup)
+ __timer_thread_wakeup (thread);
+
+ return retval;
}
-stub_warning (timer_settime)
diff --git a/sysdeps/generic/aio_misc.h b/sysdeps/generic/aio_misc.h
index 1307d822a0..e23524cffe 100644
--- a/sysdeps/generic/aio_misc.h
+++ b/sysdeps/generic/aio_misc.h
@@ -1,5 +1,4 @@
-/* Internal declarations for <aio.h> functions implementation. Stub version.
- Copyright (C) 2001-2021 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2021 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
@@ -20,17 +19,19 @@
#define _AIO_MISC_H 1
#include <aio.h>
+#include <pthread.h>
/* Extend the operation enum. */
enum
{
- LIO_DSYNC = LIO_READ + 1,
+ LIO_DSYNC = LIO_NOP + 1,
LIO_SYNC,
LIO_READ64 = LIO_READ | 128,
LIO_WRITE64 = LIO_WRITE | 128
};
+
/* Union of the two request types. */
typedef union
{
@@ -39,9 +40,83 @@ typedef union
} aiocb_union;
+/* Used to synchronize. */
+struct waitlist
+ {
+ struct waitlist *next;
+
+ /* The next two fields is used in synchronous `lio_listio' operations. */
+#ifndef DONT_NEED_AIO_MISC_COND
+ pthread_cond_t *cond;
+#endif
+ int *result;
+
+ volatile unsigned int *counterp;
+ /* The next field is used in asynchronous `lio_listio' operations. */
+ struct sigevent *sigevp;
+ };
+
+
+/* Status of a request. */
+enum
+{
+ no,
+ queued,
+ yes,
+ allocated,
+ done
+};
+
+
+/* Used to queue requests.. */
+struct requestlist
+ {
+ int running;
+
+ struct requestlist *last_fd;
+ struct requestlist *next_fd;
+ struct requestlist *next_prio;
+ struct requestlist *next_run;
+
+ /* Pointer to the actual data. */
+ aiocb_union *aiocbp;
+
+ /* List of waiting processes. */
+ struct waitlist *waiting;
+ };
+
+
+/* Lock for global I/O list of requests. */
+extern pthread_mutex_t __aio_requests_mutex attribute_hidden;
+
+
+/* Enqueue request. */
+extern struct requestlist *__aio_enqueue_request (aiocb_union *aiocbp,
+ int operation)
+ attribute_hidden;
+
+/* Find request entry for given AIO control block. */
+extern struct requestlist *__aio_find_req (aiocb_union *elem) attribute_hidden;
+
+/* Find request entry for given file descriptor. */
+extern struct requestlist *__aio_find_req_fd (int fildes) attribute_hidden;
+
+/* Remove request from the list. */
+extern void __aio_remove_request (struct requestlist *last,
+ struct requestlist *req, int all)
+ attribute_hidden;
+
+/* Release the entry for the request. */
+extern void __aio_free_request (struct requestlist *req) attribute_hidden;
+
+/* Notify initiator of request and tell this everybody listening. */
+extern void __aio_notify (struct requestlist *req) attribute_hidden;
+
+/* Notify initiator of request. */
+extern int __aio_notify_only (struct sigevent *sigev) attribute_hidden;
+
/* Send the signal. */
extern int __aio_sigqueue (int sig, const union sigval val, pid_t caller_pid)
attribute_hidden;
-
#endif /* aio_misc.h */
diff --git a/sysdeps/pthread/timer_routines.c b/sysdeps/htl/timer_routines.c
similarity index 100%
rename from sysdeps/pthread/timer_routines.c
rename to sysdeps/htl/timer_routines.c
diff --git a/sysdeps/pthread/Versions b/sysdeps/pthread/Versions
deleted file mode 100644
index a71cffbed4..0000000000
--- a/sysdeps/pthread/Versions
+++ /dev/null
@@ -1,5 +0,0 @@
-librt {
- GLIBC_2.4 {
- lio_listio; lio_listio64;
- }
-}
diff --git a/sysdeps/pthread/aio_cancel.c b/sysdeps/pthread/aio_cancel.c
deleted file mode 100644
index 63fd88f36c..0000000000
--- a/sysdeps/pthread/aio_cancel.c
+++ /dev/null
@@ -1,157 +0,0 @@
-/* Cancel requests associated with given file descriptor.
- 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
- License as published by the Free Software Foundation; either
- version 2.1 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with the GNU C Library; if not, see
- <https://www.gnu.org/licenses/>. */
-
-
-/* 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. */
-#ifndef aio_cancel
-#define aio_cancel64 XXX
-#include <aio.h>
-/* And undo the hack. */
-#undef aio_cancel64
-#endif
-
-#include <assert.h>
-#include <errno.h>
-#include <fcntl.h>
-
-#include <aio_misc.h>
-
-
-int
-aio_cancel (int fildes, struct aiocb *aiocbp)
-{
- struct requestlist *req = NULL;
- int result = AIO_ALLDONE;
-
- /* If fildes is invalid, error. */
- if (fcntl (fildes, F_GETFL) < 0)
- {
- __set_errno (EBADF);
- return -1;
- }
-
- /* Request the mutex. */
- pthread_mutex_lock (&__aio_requests_mutex);
-
- /* We are asked to cancel a specific AIO request. */
- if (aiocbp != NULL)
- {
- /* If the AIO request is not for this descriptor it has no value
- to look for the request block. */
- if (aiocbp->aio_fildes != fildes)
- {
- pthread_mutex_unlock (&__aio_requests_mutex);
- __set_errno (EINVAL);
- return -1;
- }
- else if (aiocbp->__error_code == EINPROGRESS)
- {
- struct requestlist *last = NULL;
-
- req = __aio_find_req_fd (fildes);
-
- if (req == NULL)
- {
- not_found:
- pthread_mutex_unlock (&__aio_requests_mutex);
- __set_errno (EINVAL);
- return -1;
- }
-
- while (req->aiocbp != (aiocb_union *) aiocbp)
- {
- last = req;
- req = req->next_prio;
- if (req == NULL)
- goto not_found;
- }
-
- /* Don't remove the entry if a thread is already working on it. */
- if (req->running == allocated)
- {
- result = AIO_NOTCANCELED;
- req = NULL;
- }
- else
- {
- /* We can remove the entry. */
- __aio_remove_request (last, req, 0);
-
- result = AIO_CANCELED;
-
- req->next_prio = NULL;
- }
- }
- }
- else
- {
- /* Find the beginning of the list of all requests for this
- desriptor. */
- req = __aio_find_req_fd (fildes);
-
- /* If any request is worked on by a thread it must be the first.
- So either we can delete all requests or all but the first. */
- if (req != NULL)
- {
- if (req->running == allocated)
- {
- struct requestlist *old = req;
- req = req->next_prio;
- old->next_prio = NULL;
-
- result = AIO_NOTCANCELED;
-
- if (req != NULL)
- __aio_remove_request (old, req, 1);
- }
- else
- {
- result = AIO_CANCELED;
-
- /* We can remove the entry. */
- __aio_remove_request (NULL, req, 1);
- }
- }
- }
-
- /* Mark requests as canceled and send signal. */
- while (req != NULL)
- {
- struct requestlist *old = req;
- assert (req->running == yes || req->running == queued);
- req->aiocbp->aiocb.__error_code = ECANCELED;
- req->aiocbp->aiocb.__return_value = -1;
- __aio_notify (req);
- req = req->next_prio;
- __aio_free_request (old);
- }
-
- /* Release the mutex. */
- pthread_mutex_unlock (&__aio_requests_mutex);
-
- return result;
-}
-
-#ifndef aio_cancel
-weak_alias (aio_cancel, aio_cancel64)
-#endif
diff --git a/sysdeps/pthread/aio_error.c b/sysdeps/pthread/aio_error.c
deleted file mode 100644
index ed664ae0ef..0000000000
--- a/sysdeps/pthread/aio_error.c
+++ /dev/null
@@ -1,48 +0,0 @@
-/* Return error status of asynchronous I/O 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
- License as published by the Free Software Foundation; either
- version 2.1 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with the GNU C Library; if not, see
- <https://www.gnu.org/licenses/>. */
-
-
-/* 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
-
-#include <aio_misc.h>
-
-
-int
-aio_error (const struct aiocb *aiocbp)
-{
- int ret;
-
- /* Acquire the mutex to make sure all operations for this request are
- complete. */
- pthread_mutex_lock(&__aio_requests_mutex);
- ret = aiocbp->__error_code;
- pthread_mutex_unlock(&__aio_requests_mutex);
-
- return ret;
-}
-
-weak_alias (aio_error, aio_error64)
diff --git a/sysdeps/pthread/aio_fsync.c b/sysdeps/pthread/aio_fsync.c
deleted file mode 100644
index 5a52e2fec0..0000000000
--- a/sysdeps/pthread/aio_fsync.c
+++ /dev/null
@@ -1,57 +0,0 @@
-/* Synchronize I/O in given file descriptor.
- 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
- License as published by the Free Software Foundation; either
- version 2.1 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with the GNU C Library; if not, see
- <https://www.gnu.org/licenses/>. */
-
-
-/* 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 <errno.h>
-#include <fcntl.h>
-
-#include <aio_misc.h>
-
-
-int
-aio_fsync (int op, struct aiocb *aiocbp)
-{
- if (op != O_DSYNC && __builtin_expect (op != O_SYNC, 0))
- {
- __set_errno (EINVAL);
- return -1;
- }
-
- /* Verify that this is an open file descriptor. */
- if (__glibc_unlikely (fcntl (aiocbp->aio_fildes, F_GETFL) == -1))
- {
- __set_errno (EBADF);
- return -1;
- }
-
- return (__aio_enqueue_request ((aiocb_union *) aiocbp,
- op == O_SYNC ? LIO_SYNC : LIO_DSYNC) == NULL
- ? -1 : 0);
-}
-
-weak_alias (aio_fsync, aio_fsync64)
diff --git a/sysdeps/pthread/aio_misc.c b/sysdeps/pthread/aio_misc.c
deleted file mode 100644
index b95f07d9d3..0000000000
--- a/sysdeps/pthread/aio_misc.c
+++ /dev/null
@@ -1,721 +0,0 @@
-/* Handle general operations.
- 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
- License as published by the Free Software Foundation; either
- version 2.1 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with the GNU C Library; if not, see
- <https://www.gnu.org/licenses/>. */
-
-#include <aio.h>
-#include <assert.h>
-#include <errno.h>
-#include <limits.h>
-#include <pthread.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <sys/param.h>
-#include <sys/stat.h>
-#include <sys/time.h>
-#include <aio_misc.h>
-
-#ifndef aio_create_helper_thread
-# define aio_create_helper_thread __aio_create_helper_thread
-
-extern inline int
-__aio_create_helper_thread (pthread_t *threadp, void *(*tf) (void *), void *arg)
-{
- pthread_attr_t attr;
-
- /* Make sure the thread is created detached. */
- pthread_attr_init (&attr);
- pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
-
- int ret = pthread_create (threadp, &attr, tf, arg);
-
- (void) pthread_attr_destroy (&attr);
- return ret;
-}
-#endif
-
-static void add_request_to_runlist (struct requestlist *newrequest);
-
-/* Pool of request list entries. */
-static struct requestlist **pool;
-
-/* Number of total and allocated pool entries. */
-static size_t pool_max_size;
-static size_t pool_size;
-
-/* We implement a two dimensional array but allocate each row separately.
- The macro below determines how many entries should be used per row.
- It should better be a power of two. */
-#define ENTRIES_PER_ROW 32
-
-/* How many rows we allocate at once. */
-#define ROWS_STEP 8
-
-/* List of available entries. */
-static struct requestlist *freelist;
-
-/* List of request waiting to be processed. */
-static struct requestlist *runlist;
-
-/* Structure list of all currently processed requests. */
-static struct requestlist *requests;
-
-/* Number of threads currently running. */
-static int nthreads;
-
-/* Number of threads waiting for work to arrive. */
-static int idle_thread_count;
-
-
-/* These are the values used to optimize the use of AIO. The user can
- overwrite them by using the `aio_init' function. */
-static struct aioinit optim =
-{
- 20, /* int aio_threads; Maximal number of threads. */
- 64, /* int aio_num; Number of expected simultaneous requests. */
- 0,
- 0,
- 0,
- 0,
- 1,
- 0
-};
-
-
-/* Since the list is global we need a mutex protecting it. */
-pthread_mutex_t __aio_requests_mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
-
-/* When you add a request to the list and there are idle threads present,
- you signal this condition variable. When a thread finishes work, it waits
- on this condition variable for a time before it actually exits. */
-pthread_cond_t __aio_new_request_notification = PTHREAD_COND_INITIALIZER;
-
-
-/* Functions to handle request list pool. */
-static struct requestlist *
-get_elem (void)
-{
- struct requestlist *result;
-
- if (freelist == NULL)
- {
- struct requestlist *new_row;
- int cnt;
-
- assert (sizeof (struct aiocb) == sizeof (struct aiocb64));
-
- if (pool_size + 1 >= pool_max_size)
- {
- size_t new_max_size = pool_max_size + ROWS_STEP;
- struct requestlist **new_tab;
-
- new_tab = (struct requestlist **)
- realloc (pool, new_max_size * sizeof (struct requestlist *));
-
- if (new_tab == NULL)
- return NULL;
-
- pool_max_size = new_max_size;
- pool = new_tab;
- }
-
- /* Allocate the new row. */
- cnt = pool_size == 0 ? optim.aio_num : ENTRIES_PER_ROW;
- new_row = (struct requestlist *) calloc (cnt,
- sizeof (struct requestlist));
- if (new_row == NULL)
- return NULL;
-
- pool[pool_size++] = new_row;
-
- /* Put all the new entries in the freelist. */
- do
- {
- new_row->next_prio = freelist;
- freelist = new_row++;
- }
- while (--cnt > 0);
- }
-
- result = freelist;
- freelist = freelist->next_prio;
-
- return result;
-}
-
-
-void
-__aio_free_request (struct requestlist *elem)
-{
- elem->running = no;
- elem->next_prio = freelist;
- freelist = elem;
-}
-
-
-struct requestlist *
-__aio_find_req (aiocb_union *elem)
-{
- struct requestlist *runp = requests;
- int fildes = elem->aiocb.aio_fildes;
-
- while (runp != NULL && runp->aiocbp->aiocb.aio_fildes < fildes)
- runp = runp->next_fd;
-
- if (runp != NULL)
- {
- if (runp->aiocbp->aiocb.aio_fildes != fildes)
- runp = NULL;
- else
- while (runp != NULL && runp->aiocbp != elem)
- runp = runp->next_prio;
- }
-
- return runp;
-}
-
-
-struct requestlist *
-__aio_find_req_fd (int fildes)
-{
- struct requestlist *runp = requests;
-
- while (runp != NULL && runp->aiocbp->aiocb.aio_fildes < fildes)
- runp = runp->next_fd;
-
- return (runp != NULL && runp->aiocbp->aiocb.aio_fildes == fildes
- ? runp : NULL);
-}
-
-
-void
-__aio_remove_request (struct requestlist *last, struct requestlist *req,
- int all)
-{
- assert (req->running == yes || req->running == queued
- || req->running == done);
-
- if (last != NULL)
- last->next_prio = all ? NULL : req->next_prio;
- else
- {
- if (all || req->next_prio == NULL)
- {
- if (req->last_fd != NULL)
- req->last_fd->next_fd = req->next_fd;
- else
- requests = req->next_fd;
- if (req->next_fd != NULL)
- req->next_fd->last_fd = req->last_fd;
- }
- else
- {
- if (req->last_fd != NULL)
- req->last_fd->next_fd = req->next_prio;
- else
- requests = req->next_prio;
-
- if (req->next_fd != NULL)
- req->next_fd->last_fd = req->next_prio;
-
- req->next_prio->last_fd = req->last_fd;
- req->next_prio->next_fd = req->next_fd;
-
- /* Mark this entry as runnable. */
- req->next_prio->running = yes;
- }
-
- if (req->running == yes)
- {
- struct requestlist *runp = runlist;
-
- last = NULL;
- while (runp != NULL)
- {
- if (runp == req)
- {
- if (last == NULL)
- runlist = runp->next_run;
- else
- last->next_run = runp->next_run;
- break;
- }
- last = runp;
- runp = runp->next_run;
- }
- }
- }
-}
-
-
-/* The thread handler. */
-static void *handle_fildes_io (void *arg);
-
-
-/* User optimization. */
-void
-__aio_init (const struct aioinit *init)
-{
- /* Get the mutex. */
- pthread_mutex_lock (&__aio_requests_mutex);
-
- /* Only allow writing new values if the table is not yet allocated. */
- if (pool == NULL)
- {
- optim.aio_threads = init->aio_threads < 1 ? 1 : init->aio_threads;
- assert (powerof2 (ENTRIES_PER_ROW));
- optim.aio_num = (init->aio_num < ENTRIES_PER_ROW
- ? ENTRIES_PER_ROW
- : init->aio_num & ~(ENTRIES_PER_ROW - 1));
- }
-
- if (init->aio_idle_time != 0)
- optim.aio_idle_time = init->aio_idle_time;
-
- /* Release the mutex. */
- pthread_mutex_unlock (&__aio_requests_mutex);
-}
-weak_alias (__aio_init, aio_init)
-
-
-/* The main function of the async I/O handling. It enqueues requests
- and if necessary starts and handles threads. */
-struct requestlist *
-__aio_enqueue_request (aiocb_union *aiocbp, int operation)
-{
- int result = 0;
- int policy, prio;
- struct sched_param param;
- struct requestlist *last, *runp, *newp;
- int running = no;
-
- if (operation == LIO_SYNC || operation == LIO_DSYNC)
- aiocbp->aiocb.aio_reqprio = 0;
- else if (aiocbp->aiocb.aio_reqprio < 0
-#ifdef AIO_PRIO_DELTA_MAX
- || aiocbp->aiocb.aio_reqprio > AIO_PRIO_DELTA_MAX
-#endif
- )
- {
- /* Invalid priority value. */
- __set_errno (EINVAL);
- aiocbp->aiocb.__error_code = EINVAL;
- aiocbp->aiocb.__return_value = -1;
- return NULL;
- }
-
- /* Compute priority for this request. */
- pthread_getschedparam (pthread_self (), &policy, ¶m);
- prio = param.sched_priority - aiocbp->aiocb.aio_reqprio;
-
- /* Get the mutex. */
- pthread_mutex_lock (&__aio_requests_mutex);
-
- last = NULL;
- runp = requests;
- /* First look whether the current file descriptor is currently
- worked with. */
- while (runp != NULL
- && runp->aiocbp->aiocb.aio_fildes < aiocbp->aiocb.aio_fildes)
- {
- last = runp;
- runp = runp->next_fd;
- }
-
- /* Get a new element for the waiting list. */
- newp = get_elem ();
- if (newp == NULL)
- {
- pthread_mutex_unlock (&__aio_requests_mutex);
- __set_errno (EAGAIN);
- return NULL;
- }
- newp->aiocbp = aiocbp;
- newp->waiting = 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;
-
- if (runp != NULL
- && runp->aiocbp->aiocb.aio_fildes == aiocbp->aiocb.aio_fildes)
- {
- /* The current file descriptor is worked on. It makes no sense
- to start another thread since this new thread would fight
- with the running thread for the resources. But we also cannot
- say that the thread processing this desriptor shall immediately
- after finishing the current job process this request if there
- are other threads in the running queue which have a higher
- priority. */
-
- /* Simply enqueue it after the running one according to the
- priority. */
- last = NULL;
- while (runp->next_prio != NULL
- && runp->next_prio->aiocbp->aiocb.__abs_prio >= prio)
- {
- last = runp;
- runp = runp->next_prio;
- }
-
- newp->next_prio = runp->next_prio;
- runp->next_prio = newp;
-
- running = queued;
- }
- else
- {
- running = yes;
- /* Enqueue this request for a new descriptor. */
- if (last == NULL)
- {
- newp->last_fd = NULL;
- newp->next_fd = requests;
- if (requests != NULL)
- requests->last_fd = newp;
- requests = newp;
- }
- else
- {
- newp->next_fd = last->next_fd;
- newp->last_fd = last;
- last->next_fd = newp;
- if (newp->next_fd != NULL)
- newp->next_fd->last_fd = newp;
- }
-
- newp->next_prio = NULL;
- last = NULL;
- }
-
- if (running == yes)
- {
- /* We try to 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.
-
- If no new thread can be created or if the specified limit of
- threads for AIO is reached we queue the request. */
-
- /* See if we need to and are able to create a thread. */
- if (nthreads < optim.aio_threads && idle_thread_count == 0)
- {
- pthread_t thid;
-
- running = newp->running = allocated;
-
- /* Now try to start a thread. */
- result = aio_create_helper_thread (&thid, handle_fildes_io, newp);
- if (result == 0)
- /* We managed to enqueue the request. All errors which can
- happen now can be recognized by calls to `aio_return' and
- `aio_error'. */
- ++nthreads;
- else
- {
- /* Reset the running flag. The new request is not running. */
- running = newp->running = yes;
-
- if (nthreads == 0)
- {
- /* We cannot create a thread in the moment and there is
- also no thread running. This is a problem. `errno' is
- set to EAGAIN if this is only a temporary problem. */
- __aio_remove_request (last, newp, 0);
- }
- else
- result = 0;
- }
- }
- }
-
- /* Enqueue the request in the run queue if it is not yet running. */
- if (running == yes && result == 0)
- {
- add_request_to_runlist (newp);
-
- /* If there is a thread waiting for work, then let it know that we
- have just given it something to do. */
- if (idle_thread_count > 0)
- pthread_cond_signal (&__aio_new_request_notification);
- }
-
- if (result == 0)
- newp->running = running;
- else
- {
- /* Something went wrong. */
- __aio_free_request (newp);
- aiocbp->aiocb.__error_code = result;
- __set_errno (result);
- newp = NULL;
- }
-
- /* Release the mutex. */
- pthread_mutex_unlock (&__aio_requests_mutex);
-
- return newp;
-}
-
-
-static void *
-handle_fildes_io (void *arg)
-{
- pthread_t self = pthread_self ();
- struct sched_param param;
- struct requestlist *runp = (struct requestlist *) arg;
- aiocb_union *aiocbp;
- int policy;
- int fildes;
-
- pthread_getschedparam (self, &policy, ¶m);
-
- do
- {
- /* If runp is NULL, then we were created to service the work queue
- in general, not to handle any particular request. In that case we
- skip the "do work" stuff on the first pass, and go directly to the
- "get work off the work queue" part of this loop, which is near the
- end. */
- if (runp == NULL)
- pthread_mutex_lock (&__aio_requests_mutex);
- else
- {
- /* Hopefully this request is marked as running. */
- assert (runp->running == allocated);
-
- /* Update our variables. */
- aiocbp = runp->aiocbp;
- fildes = aiocbp->aiocb.aio_fildes;
-
- /* Change the priority to the requested value (if necessary). */
- if (aiocbp->aiocb.__abs_prio != param.sched_priority
- || aiocbp->aiocb.__policy != policy)
- {
- param.sched_priority = aiocbp->aiocb.__abs_prio;
- policy = aiocbp->aiocb.__policy;
- pthread_setschedparam (self, policy, ¶m);
- }
-
- /* Process request pointed to by RUNP. We must not be disturbed
- by signals. */
- if ((aiocbp->aiocb.aio_lio_opcode & 127) == LIO_READ)
- {
- if (sizeof (off_t) != sizeof (off64_t)
- && aiocbp->aiocb.aio_lio_opcode & 128)
- aiocbp->aiocb.__return_value =
- TEMP_FAILURE_RETRY (__pread64 (fildes, (void *)
- aiocbp->aiocb64.aio_buf,
- aiocbp->aiocb64.aio_nbytes,
- aiocbp->aiocb64.aio_offset));
- else
- aiocbp->aiocb.__return_value =
- TEMP_FAILURE_RETRY (__libc_pread (fildes,
- (void *)
- aiocbp->aiocb.aio_buf,
- aiocbp->aiocb.aio_nbytes,
- aiocbp->aiocb.aio_offset));
-
- if (aiocbp->aiocb.__return_value == -1 && errno == ESPIPE)
- /* The Linux kernel is different from others. It returns
- ESPIPE if using pread on a socket. Other platforms
- simply ignore the offset parameter and behave like
- read. */
- aiocbp->aiocb.__return_value =
- TEMP_FAILURE_RETRY (read (fildes,
- (void *) aiocbp->aiocb64.aio_buf,
- aiocbp->aiocb64.aio_nbytes));
- }
- else if ((aiocbp->aiocb.aio_lio_opcode & 127) == LIO_WRITE)
- {
- if (sizeof (off_t) != sizeof (off64_t)
- && aiocbp->aiocb.aio_lio_opcode & 128)
- aiocbp->aiocb.__return_value =
- TEMP_FAILURE_RETRY (__pwrite64 (fildes, (const void *)
- aiocbp->aiocb64.aio_buf,
- aiocbp->aiocb64.aio_nbytes,
- aiocbp->aiocb64.aio_offset));
- else
- aiocbp->aiocb.__return_value =
- TEMP_FAILURE_RETRY (__libc_pwrite (fildes, (const void *)
- aiocbp->aiocb.aio_buf,
- aiocbp->aiocb.aio_nbytes,
- aiocbp->aiocb.aio_offset));
-
- if (aiocbp->aiocb.__return_value == -1 && errno == ESPIPE)
- /* The Linux kernel is different from others. It returns
- ESPIPE if using pwrite on a socket. Other platforms
- simply ignore the offset parameter and behave like
- write. */
- aiocbp->aiocb.__return_value =
- TEMP_FAILURE_RETRY (write (fildes,
- (void *) aiocbp->aiocb64.aio_buf,
- aiocbp->aiocb64.aio_nbytes));
- }
- else if (aiocbp->aiocb.aio_lio_opcode == LIO_DSYNC)
- aiocbp->aiocb.__return_value =
- TEMP_FAILURE_RETRY (fdatasync (fildes));
- else if (aiocbp->aiocb.aio_lio_opcode == LIO_SYNC)
- aiocbp->aiocb.__return_value =
- TEMP_FAILURE_RETRY (fsync (fildes));
- else
- {
- /* This is an invalid opcode. */
- aiocbp->aiocb.__return_value = -1;
- __set_errno (EINVAL);
- }
-
- /* Get the mutex. */
- pthread_mutex_lock (&__aio_requests_mutex);
-
- if (aiocbp->aiocb.__return_value == -1)
- aiocbp->aiocb.__error_code = errno;
- else
- aiocbp->aiocb.__error_code = 0;
-
- /* Send the signal to notify about finished processing of the
- request. */
- __aio_notify (runp);
-
- /* For debugging purposes we reset the running flag of the
- finished request. */
- assert (runp->running == allocated);
- runp->running = done;
-
- /* Now dequeue the current request. */
- __aio_remove_request (NULL, runp, 0);
- if (runp->next_prio != NULL)
- add_request_to_runlist (runp->next_prio);
-
- /* Free the old element. */
- __aio_free_request (runp);
- }
-
- runp = runlist;
-
- /* If the runlist is empty, then we sleep for a while, waiting for
- something to arrive in it. */
- if (runp == NULL && optim.aio_idle_time >= 0)
- {
- struct timespec now;
- struct timespec wakeup_time;
-
- ++idle_thread_count;
- __clock_gettime (CLOCK_REALTIME, &now);
- wakeup_time.tv_sec = now.tv_sec + optim.aio_idle_time;
- wakeup_time.tv_nsec = now.tv_nsec;
- if (wakeup_time.tv_nsec >= 1000000000)
- {
- wakeup_time.tv_nsec -= 1000000000;
- ++wakeup_time.tv_sec;
- }
- pthread_cond_timedwait (&__aio_new_request_notification,
- &__aio_requests_mutex,
- &wakeup_time);
- --idle_thread_count;
- runp = runlist;
- }
-
- if (runp == NULL)
- --nthreads;
- else
- {
- assert (runp->running == yes);
- runp->running = allocated;
- runlist = runp->next_run;
-
- /* If we have a request to process, and there's still another in
- the run list, then we need to either wake up or create a new
- thread to service the request that is still in the run list. */
- if (runlist != NULL)
- {
- /* There are at least two items in the work queue to work on.
- If there are other idle threads, then we should wake them
- up for these other work elements; otherwise, we should try
- to create a new thread. */
- if (idle_thread_count > 0)
- pthread_cond_signal (&__aio_new_request_notification);
- else if (nthreads < optim.aio_threads)
- {
- pthread_t thid;
- pthread_attr_t attr;
-
- /* 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 we fail, no big deal,
- because we know that there is at least one thread (us)
- that is working on AIO operations. */
- if (pthread_create (&thid, &attr, handle_fildes_io, NULL)
- == 0)
- ++nthreads;
- }
- }
- }
-
- /* Release the mutex. */
- pthread_mutex_unlock (&__aio_requests_mutex);
- }
- while (runp != NULL);
-
- return NULL;
-}
-
-
-/* Free allocated resources. */
-libc_freeres_fn (free_res)
-{
- size_t row;
-
- for (row = 0; row < pool_max_size; ++row)
- free (pool[row]);
-
- free (pool);
-}
-
-
-/* Add newrequest to the runlist. The __abs_prio flag of newrequest must
- be correctly set to do this. Also, you had better set newrequest's
- "running" flag to "yes" before you release your lock or you'll throw an
- assertion. */
-static void
-add_request_to_runlist (struct requestlist *newrequest)
-{
- int prio = newrequest->aiocbp->aiocb.__abs_prio;
- struct requestlist *runp;
-
- if (runlist == NULL || runlist->aiocbp->aiocb.__abs_prio < prio)
- {
- newrequest->next_run = runlist;
- runlist = newrequest;
- }
- else
- {
- runp = runlist;
-
- while (runp->next_run != NULL
- && runp->next_run->aiocbp->aiocb.__abs_prio >= prio)
- runp = runp->next_run;
-
- newrequest->next_run = runp->next_run;
- runp->next_run = newrequest;
- }
-}
diff --git a/sysdeps/pthread/aio_misc.h b/sysdeps/pthread/aio_misc.h
deleted file mode 100644
index e23524cffe..0000000000
--- a/sysdeps/pthread/aio_misc.h
+++ /dev/null
@@ -1,122 +0,0 @@
-/* Copyright (C) 1997-2021 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 Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with the GNU C Library; if not, see
- <https://www.gnu.org/licenses/>. */
-
-#ifndef _AIO_MISC_H
-#define _AIO_MISC_H 1
-
-#include <aio.h>
-#include <pthread.h>
-
-
-/* Extend the operation enum. */
-enum
-{
- LIO_DSYNC = LIO_NOP + 1,
- LIO_SYNC,
- LIO_READ64 = LIO_READ | 128,
- LIO_WRITE64 = LIO_WRITE | 128
-};
-
-
-/* Union of the two request types. */
-typedef union
- {
- struct aiocb aiocb;
- struct aiocb64 aiocb64;
- } aiocb_union;
-
-
-/* Used to synchronize. */
-struct waitlist
- {
- struct waitlist *next;
-
- /* The next two fields is used in synchronous `lio_listio' operations. */
-#ifndef DONT_NEED_AIO_MISC_COND
- pthread_cond_t *cond;
-#endif
- int *result;
-
- volatile unsigned int *counterp;
- /* The next field is used in asynchronous `lio_listio' operations. */
- struct sigevent *sigevp;
- };
-
-
-/* Status of a request. */
-enum
-{
- no,
- queued,
- yes,
- allocated,
- done
-};
-
-
-/* Used to queue requests.. */
-struct requestlist
- {
- int running;
-
- struct requestlist *last_fd;
- struct requestlist *next_fd;
- struct requestlist *next_prio;
- struct requestlist *next_run;
-
- /* Pointer to the actual data. */
- aiocb_union *aiocbp;
-
- /* List of waiting processes. */
- struct waitlist *waiting;
- };
-
-
-/* Lock for global I/O list of requests. */
-extern pthread_mutex_t __aio_requests_mutex attribute_hidden;
-
-
-/* Enqueue request. */
-extern struct requestlist *__aio_enqueue_request (aiocb_union *aiocbp,
- int operation)
- attribute_hidden;
-
-/* Find request entry for given AIO control block. */
-extern struct requestlist *__aio_find_req (aiocb_union *elem) attribute_hidden;
-
-/* Find request entry for given file descriptor. */
-extern struct requestlist *__aio_find_req_fd (int fildes) attribute_hidden;
-
-/* Remove request from the list. */
-extern void __aio_remove_request (struct requestlist *last,
- struct requestlist *req, int all)
- attribute_hidden;
-
-/* Release the entry for the request. */
-extern void __aio_free_request (struct requestlist *req) attribute_hidden;
-
-/* Notify initiator of request and tell this everybody listening. */
-extern void __aio_notify (struct requestlist *req) attribute_hidden;
-
-/* Notify initiator of request. */
-extern int __aio_notify_only (struct sigevent *sigev) attribute_hidden;
-
-/* Send the signal. */
-extern int __aio_sigqueue (int sig, const union sigval val, pid_t caller_pid)
- attribute_hidden;
-
-#endif /* aio_misc.h */
diff --git a/sysdeps/pthread/aio_notify.c b/sysdeps/pthread/aio_notify.c
deleted file mode 100644
index a8d61503d8..0000000000
--- a/sysdeps/pthread/aio_notify.c
+++ /dev/null
@@ -1,157 +0,0 @@
-/* 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
- License as published by the Free Software Foundation; either
- version 2.1 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with the GNU C Library; if not, see
- <https://www.gnu.org/licenses/>. */
-
-#include <errno.h>
-#include <pthread.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <aio_misc.h>
-#include <signal.h>
-
-#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;
- }
-}
diff --git a/sysdeps/pthread/aio_read.c b/sysdeps/pthread/aio_read.c
deleted file mode 100644
index 4698e48b1c..0000000000
--- a/sysdeps/pthread/aio_read.c
+++ /dev/null
@@ -1,30 +0,0 @@
-/* Asynchronous read.
- 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
- License as published by the Free Software Foundation; either
- version 2.1 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with the GNU C Library; if not, see
- <https://www.gnu.org/licenses/>. */
-
-#include <aio.h>
-
-#include <aio_misc.h>
-
-
-int
-aio_read (struct aiocb *aiocbp)
-{
- return (__aio_enqueue_request ((aiocb_union *) aiocbp, LIO_READ) == NULL
- ? -1 : 0);
-}
diff --git a/sysdeps/pthread/aio_read64.c b/sysdeps/pthread/aio_read64.c
deleted file mode 100644
index 26b9b0b380..0000000000
--- a/sysdeps/pthread/aio_read64.c
+++ /dev/null
@@ -1,30 +0,0 @@
-/* Asynchronous read, 64bit offset version.
- 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
- License as published by the Free Software Foundation; either
- version 2.1 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with the GNU C Library; if not, see
- <https://www.gnu.org/licenses/>. */
-
-#include <aio.h>
-
-#include <aio_misc.h>
-
-
-int
-aio_read64 (struct aiocb64 *aiocbp)
-{
- return (__aio_enqueue_request ((aiocb_union *) aiocbp, LIO_READ64) == NULL
- ? -1 : 0);
-}
diff --git a/sysdeps/pthread/aio_suspend.c b/sysdeps/pthread/aio_suspend.c
deleted file mode 100644
index 6fd5b1bee2..0000000000
--- a/sysdeps/pthread/aio_suspend.c
+++ /dev/null
@@ -1,263 +0,0 @@
-/* Suspend until termination of a requests.
- 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
- License as published by the Free Software Foundation; either
- version 2.1 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with the GNU C Library; if not, see
- <https://www.gnu.org/licenses/>. */
-
-
-/* We use an UGLY hack to prevent gcc from finding us cheating. The
- implementations 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 <assert.h>
-#include <errno.h>
-#include <stdbool.h>
-#include <stdlib.h>
-#include <sys/time.h>
-
-#include <libc-lock.h>
-#include <aio_misc.h>
-
-
-struct clparam
-{
- const struct aiocb *const *list;
- struct waitlist *waitlist;
- struct requestlist **requestlist;
-#ifndef DONT_NEED_AIO_MISC_COND
- pthread_cond_t *cond;
-#endif
- int nent;
-};
-
-
-static void
-cleanup (void *arg)
-{
-#ifdef DONT_NEED_AIO_MISC_COND
- /* Acquire the mutex. If pthread_cond_*wait is used this would
- happen implicitly. */
- pthread_mutex_lock (&__aio_requests_mutex);
-#endif
-
- const struct clparam *param = (const struct clparam *) arg;
-
- /* Now remove the entry in the waiting list for all requests
- which didn't terminate. */
- int cnt = param->nent;
- while (cnt-- > 0)
- if (param->list[cnt] != NULL
- && param->list[cnt]->__error_code == EINPROGRESS)
- {
- struct waitlist **listp;
-
- assert (param->requestlist[cnt] != NULL);
-
- /* There is the chance that we cannot find our entry anymore. This
- could happen if the request terminated and restarted again. */
- listp = ¶m->requestlist[cnt]->waiting;
- while (*listp != NULL && *listp != ¶m->waitlist[cnt])
- listp = &(*listp)->next;
-
- if (*listp != NULL)
- *listp = (*listp)->next;
- }
-
-#ifndef DONT_NEED_AIO_MISC_COND
- /* Release the conditional variable. */
- (void) pthread_cond_destroy (param->cond);
-#endif
-
- /* Release the mutex. */
- pthread_mutex_unlock (&__aio_requests_mutex);
-}
-
-#ifdef DONT_NEED_AIO_MISC_COND
-static int
-__attribute__ ((noinline))
-do_aio_misc_wait (unsigned int *cntr, const struct __timespec64 *timeout)
-{
- int result = 0;
-
- AIO_MISC_WAIT (result, *cntr, timeout, 1);
-
- return result;
-}
-#endif
-
-int
-__aio_suspend_time64 (const struct aiocb *const list[], int nent,
- const struct __timespec64 *timeout)
-{
- if (__glibc_unlikely (nent < 0))
- {
- __set_errno (EINVAL);
- return -1;
- }
-
- struct waitlist waitlist[nent];
- struct requestlist *requestlist[nent];
-#ifndef DONT_NEED_AIO_MISC_COND
- pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
-#endif
- int cnt;
- bool any = false;
- int result = 0;
- unsigned int cntr = 1;
-
- /* Request the mutex. */
- pthread_mutex_lock (&__aio_requests_mutex);
-
- /* There is not yet a finished request. Signal the request that
- we are working for it. */
- for (cnt = 0; cnt < nent; ++cnt)
- if (list[cnt] != NULL)
- {
- if (list[cnt]->__error_code == EINPROGRESS)
- {
- requestlist[cnt] = __aio_find_req ((aiocb_union *) list[cnt]);
-
- if (requestlist[cnt] != NULL)
- {
-#ifndef DONT_NEED_AIO_MISC_COND
- waitlist[cnt].cond = &cond;
-#endif
- waitlist[cnt].result = NULL;
- waitlist[cnt].next = requestlist[cnt]->waiting;
- waitlist[cnt].counterp = &cntr;
- waitlist[cnt].sigevp = NULL;
- requestlist[cnt]->waiting = &waitlist[cnt];
- any = true;
- }
- else
- /* We will never suspend. */
- break;
- }
- else
- /* We will never suspend. */
- break;
- }
-
- struct __timespec64 ts;
- if (timeout != NULL)
- {
- __clock_gettime64 (CLOCK_MONOTONIC, &ts);
- ts.tv_sec += timeout->tv_sec;
- ts.tv_nsec += timeout->tv_nsec;
- if (ts.tv_nsec >= 1000000000)
- {
- ts.tv_nsec -= 1000000000;
- ts.tv_sec++;
- }
- }
-
- /* Only if none of the entries is NULL or finished to be wait. */
- if (cnt == nent && any)
- {
- struct clparam clparam =
- {
- .list = list,
- .waitlist = waitlist,
- .requestlist = requestlist,
-#ifndef DONT_NEED_AIO_MISC_COND
- .cond = &cond,
-#endif
- .nent = nent
- };
-
- pthread_cleanup_push (cleanup, &clparam);
-
-#ifdef DONT_NEED_AIO_MISC_COND
- result = do_aio_misc_wait (&cntr, timeout == NULL ? NULL : &ts);
-#else
- struct timespec ts32 = valid_timespec64_to_timespec (ts);
- result = pthread_cond_timedwait (&cond, &__aio_requests_mutex,
- timeout == NULL ? NULL : &ts32);
-#endif
-
- pthread_cleanup_pop (0);
- }
-
- /* Now remove the entry in the waiting list for all requests
- which didn't terminate. */
- while (cnt-- > 0)
- if (list[cnt] != NULL && list[cnt]->__error_code == EINPROGRESS)
- {
- struct waitlist **listp;
-
- assert (requestlist[cnt] != NULL);
-
- /* There is the chance that we cannot find our entry anymore. This
- could happen if the request terminated and restarted again. */
- listp = &requestlist[cnt]->waiting;
- while (*listp != NULL && *listp != &waitlist[cnt])
- listp = &(*listp)->next;
-
- if (*listp != NULL)
- *listp = (*listp)->next;
- }
-
-#ifndef DONT_NEED_AIO_MISC_COND
- /* Release the conditional variable. */
- if (__glibc_unlikely (pthread_cond_destroy (&cond) != 0))
- /* This must never happen. */
- abort ();
-#endif
-
- if (result != 0)
- {
-#ifndef DONT_NEED_AIO_MISC_COND
- /* An error occurred. Possibly it's ETIMEDOUT. We have to translate
- the timeout error report of `pthread_cond_timedwait' to the
- form expected from `aio_suspend'. */
- if (result == ETIMEDOUT)
- __set_errno (EAGAIN);
- else
-#endif
- __set_errno (result);
-
- result = -1;
- }
-
- /* Release the mutex. */
- pthread_mutex_unlock (&__aio_requests_mutex);
-
- return result;
-}
-
-#if __TIMESIZE != 64
-librt_hidden_def (__aio_suspend_time64)
-
-int
-__aio_suspend (const struct aiocb *const list[], int nent,
- const struct timespec *timeout)
-{
- struct __timespec64 ts64;
-
- if (timeout != NULL)
- ts64 = valid_timespec_to_timespec64 (*timeout);
-
- return __aio_suspend_time64 (list, nent, timeout != NULL ? &ts64 : NULL);
-}
-#endif
-weak_alias (__aio_suspend, aio_suspend)
-weak_alias (aio_suspend, aio_suspend64)
diff --git a/sysdeps/pthread/aio_write.c b/sysdeps/pthread/aio_write.c
deleted file mode 100644
index ea55f0dbbc..0000000000
--- a/sysdeps/pthread/aio_write.c
+++ /dev/null
@@ -1,30 +0,0 @@
-/* Asynchronous write.
- 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
- License as published by the Free Software Foundation; either
- version 2.1 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with the GNU C Library; if not, see
- <https://www.gnu.org/licenses/>. */
-
-#include <aio.h>
-
-#include <aio_misc.h>
-
-
-int
-aio_write (struct aiocb *aiocbp)
-{
- return (__aio_enqueue_request ((aiocb_union *) aiocbp, LIO_WRITE) == NULL
- ? -1 : 0);
-}
diff --git a/sysdeps/pthread/aio_write64.c b/sysdeps/pthread/aio_write64.c
deleted file mode 100644
index bd6dd316be..0000000000
--- a/sysdeps/pthread/aio_write64.c
+++ /dev/null
@@ -1,30 +0,0 @@
-/* Asynchronous write, 64bit offset version.
- 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
- License as published by the Free Software Foundation; either
- version 2.1 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with the GNU C Library; if not, see
- <https://www.gnu.org/licenses/>. */
-
-#include <aio.h>
-
-#include <aio_misc.h>
-
-
-int
-aio_write64 (struct aiocb64 *aiocbp)
-{
- return (__aio_enqueue_request ((aiocb_union *) aiocbp, LIO_WRITE64) == NULL
- ? -1 : 0);
-}
diff --git a/sysdeps/pthread/lio_listio.c b/sysdeps/pthread/lio_listio.c
deleted file mode 100644
index 2cab3c2254..0000000000
--- a/sysdeps/pthread/lio_listio.c
+++ /dev/null
@@ -1,248 +0,0 @@
-/* Enqueue and list of read or write requests.
- 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
- License as published by the Free Software Foundation; either
- version 2.1 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with the GNU C Library; if not, see
- <https://www.gnu.org/licenses/>. */
-
-#ifndef lio_listio
-#include <aio.h>
-#include <assert.h>
-#include <errno.h>
-#include <stdlib.h>
-#include <unistd.h>
-
-#include <aio_misc.h>
-
-#define LIO_OPCODE_BASE 0
-#endif
-
-#include <shlib-compat.h>
-
-
-/* We need this special structure to handle asynchronous I/O. */
-struct async_waitlist
- {
- unsigned int counter;
- struct sigevent sigev;
- struct waitlist list[0];
- };
-
-
-/* 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];
- int cnt;
- volatile unsigned int total = 0;
- int result = 0;
-
- if (sig == NULL)
- {
- defsigev.sigev_notify = SIGEV_NONE;
- sig = &defsigev;
- }
-
- /* Request the mutex. */
- pthread_mutex_lock (&__aio_requests_mutex);
-
- /* Now we can enqueue all requests. Since we already acquired the
- mutex 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 (NO_INDIVIDUAL_EVENT_P (mode))
- list[cnt]->aio_sigevent.sigev_notify = SIGEV_NONE;
-
- requests[cnt] = __aio_enqueue_request ((aiocb_union *) list[cnt],
- (list[cnt]->aio_lio_opcode
- | LIO_OPCODE_BASE));
-
- if (requests[cnt] != NULL)
- /* Successfully enqueued. */
- ++total;
- else
- /* Signal that we've seen an error. `errno' and the error code
- of the aiocb will tell more. */
- result = -1;
- }
- else
- requests[cnt] = NULL;
-
- if (total == 0)
- {
- /* We don't have anything to do except signalling if we work
- asynchronously. */
-
- /* Release the mutex. We do this before raising a signal since the
- signal handler might do a `siglongjmp' and then the mutex is
- locked forever. */
- pthread_mutex_unlock (&__aio_requests_mutex);
-
- if (LIO_MODE (mode) == LIO_NOWAIT)
- __aio_notify_only (sig);
-
- return result;
- }
- else if (LIO_MODE (mode) == LIO_WAIT)
- {
-#ifndef DONT_NEED_AIO_MISC_COND
- pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
- int oldstate;
-#endif
- struct waitlist waitlist[nent];
-
- total = 0;
- for (cnt = 0; cnt < nent; ++cnt)
- {
- assert (requests[cnt] == NULL || list[cnt] != NULL);
-
- if (requests[cnt] != NULL && list[cnt]->aio_lio_opcode != LIO_NOP)
- {
-#ifndef DONT_NEED_AIO_MISC_COND
- waitlist[cnt].cond = &cond;
-#endif
- waitlist[cnt].result = &result;
- waitlist[cnt].next = requests[cnt]->waiting;
- waitlist[cnt].counterp = &total;
- waitlist[cnt].sigevp = NULL;
- requests[cnt]->waiting = &waitlist[cnt];
- ++total;
- }
- }
-
-#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 cancellation for now. */
- pthread_setcancelstate (PTHREAD_CANCEL_DISABLE, &oldstate);
-
- while (total > 0)
- pthread_cond_wait (&cond, &__aio_requests_mutex);
-
- /* 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 any of the I/O requests failed, return -1 and set errno. */
- if (result != 0)
- {
- __set_errno (result == EINTR ? EINTR : EIO);
- result = -1;
- }
- }
- else
- {
- struct async_waitlist *waitlist;
-
- waitlist = (struct async_waitlist *)
- malloc (sizeof (struct async_waitlist)
- + (nent * sizeof (struct waitlist)));
-
- if (waitlist == NULL)
- {
- __set_errno (EAGAIN);
- result = -1;
- }
- else
- {
- total = 0;
-
- for (cnt = 0; cnt < nent; ++cnt)
- {
- assert (requests[cnt] == NULL || list[cnt] != NULL);
-
- 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;
- requests[cnt]->waiting = &waitlist->list[cnt];
- ++total;
- }
- }
-
- waitlist->counter = total;
- waitlist->sigev = *sig;
- }
- }
-
- /* Release the mutex. */
- pthread_mutex_unlock (&__aio_requests_mutex);
-
- 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);
diff --git a/sysdeps/pthread/lio_listio64.c b/sysdeps/pthread/lio_listio64.c
deleted file mode 100644
index 111c883a2f..0000000000
--- a/sysdeps/pthread/lio_listio64.c
+++ /dev/null
@@ -1,33 +0,0 @@
-/* Enqueue and list of read or write requests, 64bit offset version.
- 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
- License as published by the Free Software Foundation; either
- version 2.1 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with the GNU C Library; if not, see
- <https://www.gnu.org/licenses/>. */
-
-#include <aio.h>
-#include <assert.h>
-#include <errno.h>
-#include <stdlib.h>
-#include <unistd.h>
-
-#include <aio_misc.h>
-
-#define lio_listio lio_listio64
-#define __lio_listio_21 __lio_listio64_21
-#define __lio_listio_item_notify __lio_listio64_item_notify
-#define aiocb aiocb64
-#define LIO_OPCODE_BASE 128
-#include <lio_listio.c>
diff --git a/sysdeps/pthread/timer_create.c b/sysdeps/pthread/timer_create.c
deleted file mode 100644
index 2808f5b32b..0000000000
--- a/sysdeps/pthread/timer_create.c
+++ /dev/null
@@ -1,166 +0,0 @@
-/* Copyright (C) 2000-2021 Free Software Foundation, Inc.
- This file is part of the GNU C Library.
- Contributed by Kaz Kylheku <kaz@ashi.footprints.net>.
-
- The GNU C Library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public License as
- published by the Free Software Foundation; either version 2.1 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with the GNU C Library; see the file COPYING.LIB. If
- not, see <https://www.gnu.org/licenses/>. */
-
-#include <errno.h>
-#include <signal.h>
-#include <pthread.h>
-#include <time.h>
-#include <unistd.h>
-
-#include "posix-timer.h"
-
-
-/* Create new per-process timer using CLOCK. */
-int
-timer_create (clockid_t clock_id, struct sigevent *evp, timer_t *timerid)
-{
- int retval = -1;
- struct timer_node *newtimer = NULL;
- struct thread_node *thread = NULL;
-
- if (0
-#if defined _POSIX_CPUTIME && _POSIX_CPUTIME >= 0
- || clock_id == CLOCK_PROCESS_CPUTIME_ID
-#endif
-#if defined _POSIX_THREAD_CPUTIME && _POSIX_THREAD_CPUTIME >= 0
- || clock_id == CLOCK_THREAD_CPUTIME_ID
-#endif
- )
- {
- /* We don't allow timers for CPU clocks. At least not in the
- moment. */
- __set_errno (ENOTSUP);
- return -1;
- }
-
- if (clock_id != CLOCK_REALTIME)
- {
- __set_errno (EINVAL);
- return -1;
- }
-
- pthread_once (&__timer_init_once_control, __timer_init_once);
-
- if (__timer_init_failed)
- {
- __set_errno (ENOMEM);
- return -1;
- }
-
- pthread_mutex_lock (&__timer_mutex);
-
- newtimer = __timer_alloc ();
- if (__glibc_unlikely (newtimer == NULL))
- {
- __set_errno (EAGAIN);
- goto unlock_bail;
- }
-
- if (evp != NULL)
- newtimer->event = *evp;
- else
- {
- newtimer->event.sigev_notify = SIGEV_SIGNAL;
- newtimer->event.sigev_signo = SIGALRM;
- newtimer->event.sigev_value.sival_ptr = newtimer;
- newtimer->event.sigev_notify_function = 0;
- }
-
- newtimer->event.sigev_notify_attributes = &newtimer->attr;
- newtimer->creator_pid = getpid ();
-
- switch (__builtin_expect (newtimer->event.sigev_notify, SIGEV_SIGNAL))
- {
- case SIGEV_NONE:
- case SIGEV_SIGNAL:
- /* We have a global thread for delivering timed signals.
- If it is not running, try to start it up. */
- thread = &__timer_signal_thread_rclk;
- if (! thread->exists)
- {
- if (__builtin_expect (__timer_thread_start (thread),
- 1) < 0)
- {
- __set_errno (EAGAIN);
- goto unlock_bail;
- }
- }
- break;
-
- case SIGEV_THREAD:
- /* Copy over thread attributes or set up default ones. */
- if (evp->sigev_notify_attributes)
- newtimer->attr = *(pthread_attr_t *) evp->sigev_notify_attributes;
- else
- pthread_attr_init (&newtimer->attr);
-
- /* Ensure thread attributes call for deatched thread. */
- pthread_attr_setdetachstate (&newtimer->attr, PTHREAD_CREATE_DETACHED);
-
- /* Try to find existing thread having the right attributes. */
- thread = __timer_thread_find_matching (&newtimer->attr, clock_id);
-
- /* If no existing thread has these attributes, try to allocate one. */
- if (thread == NULL)
- thread = __timer_thread_alloc (&newtimer->attr, clock_id);
-
- /* Out of luck; no threads are available. */
- if (__glibc_unlikely (thread == NULL))
- {
- __set_errno (EAGAIN);
- goto unlock_bail;
- }
-
- /* If the thread is not running already, try to start it. */
- if (! thread->exists
- && __builtin_expect (! __timer_thread_start (thread), 0))
- {
- __set_errno (EAGAIN);
- goto unlock_bail;
- }
- break;
-
- default:
- __set_errno (EINVAL);
- goto unlock_bail;
- }
-
- newtimer->clock = clock_id;
- newtimer->abstime = 0;
- newtimer->armed = 0;
- newtimer->thread = thread;
-
- *timerid = timer_ptr2id (newtimer);
- retval = 0;
-
- if (__builtin_expect (retval, 0) == -1)
- {
- unlock_bail:
- if (thread != NULL)
- __timer_thread_dealloc (thread);
- if (newtimer != NULL)
- {
- timer_delref (newtimer);
- __timer_dealloc (newtimer);
- }
- }
-
- pthread_mutex_unlock (&__timer_mutex);
-
- return retval;
-}
diff --git a/sysdeps/pthread/timer_delete.c b/sysdeps/pthread/timer_delete.c
deleted file mode 100644
index c6f6d9743d..0000000000
--- a/sysdeps/pthread/timer_delete.c
+++ /dev/null
@@ -1,68 +0,0 @@
-/* Copyright (C) 2000-2021 Free Software Foundation, Inc.
- This file is part of the GNU C Library.
- Contributed by Kaz Kylheku <kaz@ashi.footprints.net>.
-
- The GNU C Library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public License as
- published by the Free Software Foundation; either version 2.1 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with the GNU C Library; see the file COPYING.LIB. If
- not, see <https://www.gnu.org/licenses/>. */
-
-#include <assert.h>
-#include <errno.h>
-#include <pthread.h>
-#include <time.h>
-
-#include "posix-timer.h"
-
-
-/* Delete timer TIMERID. */
-int
-timer_delete (timer_t timerid)
-{
- struct timer_node *timer;
- int retval = -1;
-
- pthread_mutex_lock (&__timer_mutex);
-
- timer = timer_id2ptr (timerid);
- if (! timer_valid (timer))
- /* Invalid timer ID or the timer is not in use. */
- __set_errno (EINVAL);
- else
- {
- if (timer->armed && timer->thread != NULL)
- {
- struct thread_node *thread = timer->thread;
- assert (thread != NULL);
-
- /* If thread is cancelled while waiting for handler to terminate,
- the mutex is unlocked and timer_delete is aborted. */
- pthread_cleanup_push (__timer_mutex_cancel_handler, &__timer_mutex);
-
- /* If timer is currently being serviced, wait for it to finish. */
- while (thread->current_timer == timer)
- pthread_cond_wait (&thread->cond, &__timer_mutex);
-
- pthread_cleanup_pop (0);
- }
-
- /* Remove timer from whatever queue it may be on and deallocate it. */
- timer->inuse = TIMER_DELETED;
- list_unlink_ip (&timer->links);
- timer_delref (timer);
- retval = 0;
- }
-
- pthread_mutex_unlock (&__timer_mutex);
-
- return retval;
-}
diff --git a/sysdeps/pthread/timer_getoverr.c b/sysdeps/pthread/timer_getoverr.c
deleted file mode 100644
index c1952f80c6..0000000000
--- a/sysdeps/pthread/timer_getoverr.c
+++ /dev/null
@@ -1,43 +0,0 @@
-/* Copyright (C) 2000-2021 Free Software Foundation, Inc.
- This file is part of the GNU C Library.
- Contributed by Kaz Kylheku <kaz@ashi.footprints.net>.
-
- The GNU C Library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public License as
- published by the Free Software Foundation; either version 2.1 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with the GNU C Library; see the file COPYING.LIB. If
- not, see <https://www.gnu.org/licenses/>. */
-
-#include <errno.h>
-#include <pthread.h>
-#include <time.h>
-
-#include "posix-timer.h"
-
-
-/* Get expiration overrun for timer TIMERID. */
-int
-timer_getoverrun (timer_t timerid)
-{
- struct timer_node *timer;
- int retval = -1;
-
- pthread_mutex_lock (&__timer_mutex);
-
- if (! timer_valid (timer = timer_id2ptr (timerid)))
- __set_errno (EINVAL);
- else
- retval = timer->overrun_count;
-
- pthread_mutex_unlock (&__timer_mutex);
-
- return retval;
-}
diff --git a/sysdeps/pthread/timer_gettime.c b/sysdeps/pthread/timer_gettime.c
deleted file mode 100644
index dd3b4a6281..0000000000
--- a/sysdeps/pthread/timer_gettime.c
+++ /dev/null
@@ -1,74 +0,0 @@
-/* Copyright (C) 2000-2021 Free Software Foundation, Inc.
- This file is part of the GNU C Library.
- Contributed by Kaz Kylheku <kaz@ashi.footprints.net>.
-
- The GNU C Library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public License as
- published by the Free Software Foundation; either version 2.1 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with the GNU C Library; see the file COPYING.LIB. If
- not, see <https://www.gnu.org/licenses/>. */
-
-#include <errno.h>
-#include <pthread.h>
-#include <time.h>
-
-#include "posix-timer.h"
-
-
-/* Get current value of timer TIMERID and store it in VLAUE. */
-int
-timer_gettime (timer_t timerid, struct itimerspec *value)
-{
- struct timer_node *timer;
- struct timespec now, expiry;
- int retval = -1, armed = 0, valid;
- clock_t clock = 0;
-
- pthread_mutex_lock (&__timer_mutex);
-
- timer = timer_id2ptr (timerid);
- valid = timer_valid (timer);
-
- if (valid) {
- armed = timer->armed;
- expiry = timer->expirytime;
- clock = timer->clock;
- value->it_interval = timer->value.it_interval;
- }
-
- pthread_mutex_unlock (&__timer_mutex);
-
- if (valid)
- {
- if (armed)
- {
- __clock_gettime (clock, &now);
- if (timespec_compare (&now, &expiry) < 0)
- timespec_sub (&value->it_value, &expiry, &now);
- else
- {
- value->it_value.tv_sec = 0;
- value->it_value.tv_nsec = 0;
- }
- }
- else
- {
- value->it_value.tv_sec = 0;
- value->it_value.tv_nsec = 0;
- }
-
- retval = 0;
- }
- else
- __set_errno (EINVAL);
-
- return retval;
-}
diff --git a/sysdeps/pthread/timer_settime.c b/sysdeps/pthread/timer_settime.c
deleted file mode 100644
index c05adf166f..0000000000
--- a/sysdeps/pthread/timer_settime.c
+++ /dev/null
@@ -1,131 +0,0 @@
-/* Copyright (C) 2000-2021 Free Software Foundation, Inc.
- This file is part of the GNU C Library.
- Contributed by Kaz Kylheku <kaz@ashi.footprints.net>.
-
- The GNU C Library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public License as
- published by the Free Software Foundation; either version 2.1 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with the GNU C Library; see the file COPYING.LIB. If
- not, see <https://www.gnu.org/licenses/>. */
-
-#include <errno.h>
-#include <pthread.h>
-#include <time.h>
-
-#include "posix-timer.h"
-
-
-/* Set timer TIMERID to VALUE, returning old value in OVLAUE. */
-int
-timer_settime (timer_t timerid, int flags, const struct itimerspec *value,
- struct itimerspec *ovalue)
-{
- struct timer_node *timer;
- struct thread_node *thread = NULL;
- struct timespec now;
- int have_now = 0, need_wakeup = 0;
- int retval = -1;
-
- timer = timer_id2ptr (timerid);
- if (timer == NULL)
- {
- __set_errno (EINVAL);
- goto bail;
- }
-
- if (! valid_nanoseconds (value->it_interval.tv_nsec)
- || ! valid_nanoseconds (value->it_value.tv_nsec))
- {
- __set_errno (EINVAL);
- goto bail;
- }
-
- /* Will need to know current time since this is a relative timer;
- might as well make the system call outside of the lock now! */
-
- if ((flags & TIMER_ABSTIME) == 0)
- {
- __clock_gettime (timer->clock, &now);
- have_now = 1;
- }
-
- pthread_mutex_lock (&__timer_mutex);
- timer_addref (timer);
-
- /* One final check of timer validity; this one is possible only
- until we have the mutex, because it accesses the inuse flag. */
-
- if (! timer_valid(timer))
- {
- __set_errno (EINVAL);
- goto unlock_bail;
- }
-
- if (ovalue != NULL)
- {
- ovalue->it_interval = timer->value.it_interval;
-
- if (timer->armed)
- {
- if (! have_now)
- {
- pthread_mutex_unlock (&__timer_mutex);
- __clock_gettime (timer->clock, &now);
- have_now = 1;
- pthread_mutex_lock (&__timer_mutex);
- timer_addref (timer);
- }
-
- timespec_sub (&ovalue->it_value, &timer->expirytime, &now);
- }
- else
- {
- ovalue->it_value.tv_sec = 0;
- ovalue->it_value.tv_nsec = 0;
- }
- }
-
- timer->value = *value;
-
- list_unlink_ip (&timer->links);
- timer->armed = 0;
-
- thread = timer->thread;
-
- /* A value of { 0, 0 } causes the timer to be stopped. */
- if (value->it_value.tv_sec != 0
- || __builtin_expect (value->it_value.tv_nsec != 0, 1))
- {
- if ((flags & TIMER_ABSTIME) != 0)
- /* The user specified the expiration time. */
- timer->expirytime = value->it_value;
- else
- timespec_add (&timer->expirytime, &now, &value->it_value);
-
- /* Only need to wake up the thread if timer is inserted
- at the head of the queue. */
- if (thread != NULL)
- need_wakeup = __timer_thread_queue_timer (thread, timer);
- timer->armed = 1;
- }
-
- retval = 0;
-
-unlock_bail:
- timer_delref (timer);
- pthread_mutex_unlock (&__timer_mutex);
-
-bail:
- if (thread != NULL && need_wakeup)
- __timer_thread_wakeup (thread);
-
- return retval;
-}
diff --git a/sysdeps/unix/sysv/linux/alpha/aio_cancel.c b/sysdeps/unix/sysv/linux/alpha/aio_cancel.c
index 0d6da82919..9f69b080ed 100644
--- a/sysdeps/unix/sysv/linux/alpha/aio_cancel.c
+++ b/sysdeps/unix/sysv/linux/alpha/aio_cancel.c
@@ -10,7 +10,7 @@ extern __typeof (aio_cancel) __old_aio_cancel;
#define aio_cancel __new_aio_cancel
-#include <sysdeps/pthread/aio_cancel.c>
+#include <rt/aio_cancel.c>
#undef aio_cancel
strong_alias (__new_aio_cancel, __new_aio_cancel64);
@@ -23,7 +23,7 @@ versioned_symbol (librt, __new_aio_cancel64, aio_cancel64, GLIBC_2_3);
#define aio_cancel __old_aio_cancel
#define ECANCELED 125
-#include <sysdeps/pthread/aio_cancel.c>
+#include <rt/aio_cancel.c>
#undef aio_cancel
strong_alias (__old_aio_cancel, __old_aio_cancel64);
diff --git a/sysdeps/unix/sysv/linux/sparc/aio_cancel.c b/sysdeps/unix/sysv/linux/sparc/aio_cancel.c
index 0d6da82919..9f69b080ed 100644
--- a/sysdeps/unix/sysv/linux/sparc/aio_cancel.c
+++ b/sysdeps/unix/sysv/linux/sparc/aio_cancel.c
@@ -10,7 +10,7 @@ extern __typeof (aio_cancel) __old_aio_cancel;
#define aio_cancel __new_aio_cancel
-#include <sysdeps/pthread/aio_cancel.c>
+#include <rt/aio_cancel.c>
#undef aio_cancel
strong_alias (__new_aio_cancel, __new_aio_cancel64);
@@ -23,7 +23,7 @@ versioned_symbol (librt, __new_aio_cancel64, aio_cancel64, GLIBC_2_3);
#define aio_cancel __old_aio_cancel
#define ECANCELED 125
-#include <sysdeps/pthread/aio_cancel.c>
+#include <rt/aio_cancel.c>
#undef aio_cancel
strong_alias (__old_aio_cancel, __old_aio_cancel64);
diff --git a/sysdeps/unix/sysv/linux/wordsize-64/aio_read.c b/sysdeps/unix/sysv/linux/wordsize-64/aio_read.c
index d10fc4320b..8310b484d0 100644
--- a/sysdeps/unix/sysv/linux/wordsize-64/aio_read.c
+++ b/sysdeps/unix/sysv/linux/wordsize-64/aio_read.c
@@ -1,6 +1,6 @@
#define aio_read64 __renamed_aio_read64
-#include "../../../../pthread/aio_read.c"
+#include <rt/aio_read.c>
#undef aio_read64
diff --git a/sysdeps/unix/sysv/linux/wordsize-64/aio_write.c b/sysdeps/unix/sysv/linux/wordsize-64/aio_write.c
index b0fb469cb2..60d242f88f 100644
--- a/sysdeps/unix/sysv/linux/wordsize-64/aio_write.c
+++ b/sysdeps/unix/sysv/linux/wordsize-64/aio_write.c
@@ -1,6 +1,6 @@
#define aio_write64 __renamed_aio_write64
-#include "../../../../pthread/aio_write.c"
+#include <rt/aio_write.c>
#undef aio_write64
diff --git a/sysdeps/unix/sysv/linux/wordsize-64/lio_listio.c b/sysdeps/unix/sysv/linux/wordsize-64/lio_listio.c
index 25ee5a3507..be9fe7a9c7 100644
--- a/sysdeps/unix/sysv/linux/wordsize-64/lio_listio.c
+++ b/sysdeps/unix/sysv/linux/wordsize-64/lio_listio.c
@@ -1,6 +1,6 @@
#define lio_listio64 __renamed_lio_listio64
-#include "../../../../pthread/lio_listio.c"
+#include <rt/lio_listio.c>
#undef lio_listio64
--
2.31.1
More information about the Libc-alpha
mailing list