aboutsummaryrefslogtreecommitdiff
path: root/sysdeps/pthread
diff options
context:
space:
mode:
authorFlorian Weimer <fweimer@redhat.com>2021-06-22 09:50:27 +0200
committerFlorian Weimer <fweimer@redhat.com>2021-06-22 09:50:45 +0200
commitdaa3fc9bff55c1f8368a464ec802ab620901344e (patch)
tree14c3a5a951a84aeff9d554ab5a77c13a4ec29521 /sysdeps/pthread
parentae830b2d9f5238e1bee9820cd4d4df7f7b13ecff (diff)
downloadglibc-daa3fc9bff55c1f8368a464ec802ab620901344e.tar
glibc-daa3fc9bff55c1f8368a464ec802ab620901344e.tar.gz
glibc-daa3fc9bff55c1f8368a464ec802ab620901344e.tar.bz2
glibc-daa3fc9bff55c1f8368a464ec802ab620901344e.zip
rt: Move generic implementation from sysdeps/pthread to rt
The pthread-based implementation is the generic one. Replacing the stubs makes it clear that they do not have to be adjusted for the libpthread move. Result of: git mv -f sysdeps/pthread/aio_misc.h sysdeps/generic/ git mv sysdeps/pthread/timer_routines.c sysdeps/htl/ git mv -f sysdeps/pthread/{aio,lio,timer}_*.c rt/ Followed by manual adjustment of the #include paths in sysdeps/unix/sysv/linux/wordsize-64, and a move of the version definitions formerly in sysdeps/pthread/Versions. Reviewed-by: Adhemerval Zanella <adhemerval.zanella@linaro.org>
Diffstat (limited to 'sysdeps/pthread')
-rw-r--r--sysdeps/pthread/Versions5
-rw-r--r--sysdeps/pthread/aio_cancel.c157
-rw-r--r--sysdeps/pthread/aio_error.c48
-rw-r--r--sysdeps/pthread/aio_fsync.c57
-rw-r--r--sysdeps/pthread/aio_misc.c721
-rw-r--r--sysdeps/pthread/aio_misc.h122
-rw-r--r--sysdeps/pthread/aio_notify.c157
-rw-r--r--sysdeps/pthread/aio_read.c30
-rw-r--r--sysdeps/pthread/aio_read64.c30
-rw-r--r--sysdeps/pthread/aio_suspend.c263
-rw-r--r--sysdeps/pthread/aio_write.c30
-rw-r--r--sysdeps/pthread/aio_write64.c30
-rw-r--r--sysdeps/pthread/lio_listio.c248
-rw-r--r--sysdeps/pthread/lio_listio64.c33
-rw-r--r--sysdeps/pthread/timer_create.c166
-rw-r--r--sysdeps/pthread/timer_delete.c68
-rw-r--r--sysdeps/pthread/timer_getoverr.c43
-rw-r--r--sysdeps/pthread/timer_gettime.c74
-rw-r--r--sysdeps/pthread/timer_routines.c555
-rw-r--r--sysdeps/pthread/timer_settime.c131
20 files changed, 0 insertions, 2968 deletions
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, &param);
- 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, &param);
-
- 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, &param);
- }
-
- /* 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 = &param->requestlist[cnt]->waiting;
- while (*listp != NULL && *listp != &param->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_routines.c b/sysdeps/pthread/timer_routines.c
deleted file mode 100644
index 059ebef265..0000000000
--- a/sysdeps/pthread/timer_routines.c
+++ /dev/null
@@ -1,555 +0,0 @@
-/* Helper code for POSIX timer implementation on NPTL.
- 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 <stddef.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sysdep.h>
-#include <time.h>
-#include <unistd.h>
-#include <sys/syscall.h>
-
-#include "posix-timer.h"
-#include <timer_routines.h>
-
-#ifndef DELAYTIMER_MAX
-# define DELAYTIMER_MAX INT_MAX
-#endif
-
-/* Number of threads used. */
-#define THREAD_MAXNODES 16
-
-/* Array containing the descriptors for the used threads. */
-static struct thread_node thread_array[THREAD_MAXNODES];
-
-/* Static array with the structures for all the timers. */
-struct timer_node __timer_array[TIMER_MAX];
-
-/* Global lock to protect operation on the lists. */
-pthread_mutex_t __timer_mutex = PTHREAD_MUTEX_INITIALIZER;
-
-/* Variable to protext initialization. */
-pthread_once_t __timer_init_once_control = PTHREAD_ONCE_INIT;
-
-/* Nonzero if initialization of timer implementation failed. */
-int __timer_init_failed;
-
-/* Node for the thread used to deliver signals. */
-struct thread_node __timer_signal_thread_rclk;
-
-/* Lists to keep free and used timers and threads. */
-static struct list_head timer_free_list;
-static struct list_head thread_free_list;
-static struct list_head thread_active_list;
-
-
-#ifdef __NR_rt_sigqueueinfo
-extern int __syscall_rt_sigqueueinfo (int, int, siginfo_t *);
-#endif
-
-
-/* List handling functions. */
-static inline void
-list_append (struct list_head *list, struct list_head *newp)
-{
- newp->prev = list->prev;
- newp->next = list;
- list->prev->next = newp;
- list->prev = newp;
-}
-
-static inline void
-list_insbefore (struct list_head *list, struct list_head *newp)
-{
- list_append (list, newp);
-}
-
-/*
- * Like list_unlink_ip, except that calling it on a node that
- * is already unlinked is disastrous rather than a noop.
- */
-
-static inline void
-list_unlink (struct list_head *list)
-{
- struct list_head *lnext = list->next, *lprev = list->prev;
-
- lnext->prev = lprev;
- lprev->next = lnext;
-}
-
-static inline struct list_head *
-list_first (struct list_head *list)
-{
- return list->next;
-}
-
-static inline struct list_head *
-list_null (struct list_head *list)
-{
- return list;
-}
-
-static inline struct list_head *
-list_next (struct list_head *list)
-{
- return list->next;
-}
-
-static inline int
-list_isempty (struct list_head *list)
-{
- return list->next == list;
-}
-
-
-/* Functions build on top of the list functions. */
-static inline struct thread_node *
-thread_links2ptr (struct list_head *list)
-{
- return (struct thread_node *) ((char *) list
- - offsetof (struct thread_node, links));
-}
-
-static inline struct timer_node *
-timer_links2ptr (struct list_head *list)
-{
- return (struct timer_node *) ((char *) list
- - offsetof (struct timer_node, links));
-}
-
-
-/* Initialize a newly allocated thread structure. */
-static void
-thread_init (struct thread_node *thread, const pthread_attr_t *attr, clockid_t clock_id)
-{
- if (attr != NULL)
- thread->attr = *attr;
- else
- {
- pthread_attr_init (&thread->attr);
- pthread_attr_setdetachstate (&thread->attr, PTHREAD_CREATE_DETACHED);
- }
-
- thread->exists = 0;
- INIT_LIST_HEAD (&thread->timer_queue);
- pthread_cond_init (&thread->cond, 0);
- thread->current_timer = 0;
- thread->captured = pthread_self ();
- thread->clock_id = clock_id;
-}
-
-
-/* Initialize the global lists, and acquire global resources. Error
- reporting is done by storing a non-zero value to the global variable
- timer_init_failed. */
-static void
-init_module (void)
-{
- int i;
-
- INIT_LIST_HEAD (&timer_free_list);
- INIT_LIST_HEAD (&thread_free_list);
- INIT_LIST_HEAD (&thread_active_list);
-
- for (i = 0; i < TIMER_MAX; ++i)
- {
- list_append (&timer_free_list, &__timer_array[i].links);
- __timer_array[i].inuse = TIMER_FREE;
- }
-
- for (i = 0; i < THREAD_MAXNODES; ++i)
- list_append (&thread_free_list, &thread_array[i].links);
-
- thread_init (&__timer_signal_thread_rclk, 0, CLOCK_REALTIME);
-}
-
-
-/* This is a handler executed in a child process after a fork()
- occurs. It reinitializes the module, resetting all of the data
- structures to their initial state. The mutex is initialized in
- case it was locked in the parent process. */
-static void
-reinit_after_fork (void)
-{
- init_module ();
- pthread_mutex_init (&__timer_mutex, 0);
-}
-
-
-/* Called once form pthread_once in timer_init. This initializes the
- module and ensures that reinit_after_fork will be executed in any
- child process. */
-void
-__timer_init_once (void)
-{
- init_module ();
- pthread_atfork (0, 0, reinit_after_fork);
-}
-
-
-/* Deinitialize a thread that is about to be deallocated. */
-static void
-thread_deinit (struct thread_node *thread)
-{
- assert (list_isempty (&thread->timer_queue));
- pthread_cond_destroy (&thread->cond);
-}
-
-
-/* Allocate a thread structure from the global free list. Global
- mutex lock must be held by caller. The thread is moved to
- the active list. */
-struct thread_node *
-__timer_thread_alloc (const pthread_attr_t *desired_attr, clockid_t clock_id)
-{
- struct list_head *node = list_first (&thread_free_list);
-
- if (node != list_null (&thread_free_list))
- {
- struct thread_node *thread = thread_links2ptr (node);
- list_unlink (node);
- thread_init (thread, desired_attr, clock_id);
- list_append (&thread_active_list, node);
- return thread;
- }
-
- return 0;
-}
-
-
-/* Return a thread structure to the global free list. Global lock
- must be held by caller. */
-void
-__timer_thread_dealloc (struct thread_node *thread)
-{
- thread_deinit (thread);
- list_unlink (&thread->links);
- list_append (&thread_free_list, &thread->links);
-}
-
-
-/* Each of our threads which terminates executes this cleanup
- handler. We never terminate threads ourselves; if a thread gets here
- it means that the evil application has killed it. If the thread has
- timers, these require servicing and so we must hire a replacement
- thread right away. We must also unblock another thread that may
- have been waiting for this thread to finish servicing a timer (see
- timer_delete()). */
-
-static void
-thread_cleanup (void *val)
-{
- if (val != NULL)
- {
- struct thread_node *thread = val;
-
- /* How did the signal thread get killed? */
- assert (thread != &__timer_signal_thread_rclk);
-
- pthread_mutex_lock (&__timer_mutex);
-
- thread->exists = 0;
-
- /* We are no longer processing a timer event. */
- thread->current_timer = 0;
-
- if (list_isempty (&thread->timer_queue))
- __timer_thread_dealloc (thread);
- else
- (void) __timer_thread_start (thread);
-
- pthread_mutex_unlock (&__timer_mutex);
-
- /* Unblock potentially blocked timer_delete(). */
- pthread_cond_broadcast (&thread->cond);
- }
-}
-
-
-/* Handle a timer which is supposed to go off now. */
-static void
-thread_expire_timer (struct thread_node *self, struct timer_node *timer)
-{
- self->current_timer = timer; /* Lets timer_delete know timer is running. */
-
- pthread_mutex_unlock (&__timer_mutex);
-
- switch (__builtin_expect (timer->event.sigev_notify, SIGEV_SIGNAL))
- {
- case SIGEV_NONE:
- break;
-
- case SIGEV_SIGNAL:
-#ifdef __NR_rt_sigqueueinfo
- {
- siginfo_t info;
-
- /* First, clear the siginfo_t structure, so that we don't pass our
- stack content to other tasks. */
- memset (&info, 0, sizeof (siginfo_t));
- /* We must pass the information about the data in a siginfo_t
- value. */
- info.si_signo = timer->event.sigev_signo;
- info.si_code = SI_TIMER;
- info.si_pid = timer->creator_pid;
- info.si_uid = getuid ();
- info.si_value = timer->event.sigev_value;
-
- INLINE_SYSCALL (rt_sigqueueinfo, 3, info.si_pid, info.si_signo, &info);
- }
-#else
- if (pthread_kill (self->captured, timer->event.sigev_signo) != 0)
- {
- if (pthread_kill (self->id, timer->event.sigev_signo) != 0)
- abort ();
- }
-#endif
- break;
-
- case SIGEV_THREAD:
- timer->event.sigev_notify_function (timer->event.sigev_value);
- break;
-
- default:
- assert (! "unknown event");
- break;
- }
-
- pthread_mutex_lock (&__timer_mutex);
-
- self->current_timer = 0;
-
- pthread_cond_broadcast (&self->cond);
-}
-
-
-/* Thread function; executed by each timer thread. The job of this
- function is to wait on the thread's timer queue and expire the
- timers in chronological order as close to their scheduled time as
- possible. */
-static void
-__attribute__ ((noreturn))
-thread_func (void *arg)
-{
- struct thread_node *self = arg;
-
- /* Register cleanup handler, in case rogue application terminates
- this thread. (This cannot happen to __timer_signal_thread, which
- doesn't invoke application callbacks). */
-
- pthread_cleanup_push (thread_cleanup, self);
-
- pthread_mutex_lock (&__timer_mutex);
-
- while (1)
- {
- struct list_head *first;
- struct timer_node *timer = NULL;
-
- /* While the timer queue is not empty, inspect the first node. */
- first = list_first (&self->timer_queue);
- if (first != list_null (&self->timer_queue))
- {
- struct timespec now;
-
- timer = timer_links2ptr (first);
-
- /* This assumes that the elements of the list of one thread
- are all for the same clock. */
- __clock_gettime (timer->clock, &now);
-
- while (1)
- {
- /* If the timer is due or overdue, remove it from the queue.
- If it's a periodic timer, re-compute its new time and
- requeue it. Either way, perform the timer expiry. */
- if (timespec_compare (&now, &timer->expirytime) < 0)
- break;
-
- list_unlink_ip (first);
-
- if (__builtin_expect (timer->value.it_interval.tv_sec, 0) != 0
- || timer->value.it_interval.tv_nsec != 0)
- {
- timer->overrun_count = 0;
- timespec_add (&timer->expirytime, &timer->expirytime,
- &timer->value.it_interval);
- while (timespec_compare (&timer->expirytime, &now) < 0)
- {
- timespec_add (&timer->expirytime, &timer->expirytime,
- &timer->value.it_interval);
- if (timer->overrun_count < DELAYTIMER_MAX)
- ++timer->overrun_count;
- }
- __timer_thread_queue_timer (self, timer);
- }
-
- thread_expire_timer (self, timer);
-
- first = list_first (&self->timer_queue);
- if (first == list_null (&self->timer_queue))
- break;
-
- timer = timer_links2ptr (first);
- }
- }
-
- /* If the queue is not empty, wait until the expiry time of the
- first node. Otherwise wait indefinitely. Insertions at the
- head of the queue must wake up the thread by broadcasting
- this condition variable. */
- if (timer != NULL)
- pthread_cond_timedwait (&self->cond, &__timer_mutex,
- &timer->expirytime);
- else
- pthread_cond_wait (&self->cond, &__timer_mutex);
- }
- /* This macro will never be executed since the while loop loops
- forever - but we have to add it for proper nesting. */
- pthread_cleanup_pop (1);
-}
-
-
-/* Enqueue a timer in wakeup order in the thread's timer queue.
- Returns 1 if the timer was inserted at the head of the queue,
- causing the queue's next wakeup time to change. */
-
-int
-__timer_thread_queue_timer (struct thread_node *thread,
- struct timer_node *insert)
-{
- struct list_head *iter;
- int athead = 1;
-
- for (iter = list_first (&thread->timer_queue);
- iter != list_null (&thread->timer_queue);
- iter = list_next (iter))
- {
- struct timer_node *timer = timer_links2ptr (iter);
-
- if (timespec_compare (&insert->expirytime, &timer->expirytime) < 0)
- break;
- athead = 0;
- }
-
- list_insbefore (iter, &insert->links);
- return athead;
-}
-
-
-/* Start a thread and associate it with the given thread node. Global
- lock must be held by caller. */
-int
-__timer_thread_start (struct thread_node *thread)
-{
- int retval = 1;
- sigset_t set, oset;
-
- assert (!thread->exists);
- thread->exists = 1;
-
- sigfillset (&set);
- pthread_sigmask (SIG_SETMASK, &set, &oset);
-
- if (pthread_create (&thread->id, &thread->attr,
- (void *(*) (void *)) thread_func, thread) != 0)
- {
- thread->exists = 0;
- retval = -1;
- }
-
- pthread_sigmask (SIG_SETMASK, &oset, NULL);
-
- return retval;
-}
-
-
-void
-__timer_thread_wakeup (struct thread_node *thread)
-{
- pthread_cond_broadcast (&thread->cond);
-}
-
-
-
-/* Search the list of active threads and find one which has matching
- attributes. Global mutex lock must be held by caller. */
-struct thread_node *
-__timer_thread_find_matching (const pthread_attr_t *desired_attr,
- clockid_t desired_clock_id)
-{
- struct list_head *iter = list_first (&thread_active_list);
-
- while (iter != list_null (&thread_active_list))
- {
- struct thread_node *candidate = thread_links2ptr (iter);
-
- if (thread_attr_compare (desired_attr, &candidate->attr)
- && desired_clock_id == candidate->clock_id)
- return candidate;
-
- iter = list_next (iter);
- }
-
- return NULL;
-}
-
-
-/* Grab a free timer structure from the global free list. The global
- lock must be held by the caller. */
-struct timer_node *
-__timer_alloc (void)
-{
- struct list_head *node = list_first (&timer_free_list);
-
- if (node != list_null (&timer_free_list))
- {
- struct timer_node *timer = timer_links2ptr (node);
- list_unlink_ip (node);
- timer->inuse = TIMER_INUSE;
- timer->refcount = 1;
- return timer;
- }
-
- return NULL;
-}
-
-
-/* Return a timer structure to the global free list. The global lock
- must be held by the caller. */
-void
-__timer_dealloc (struct timer_node *timer)
-{
- assert (timer->refcount == 0);
- timer->thread = NULL; /* Break association between timer and thread. */
- timer->inuse = TIMER_FREE;
- list_append (&timer_free_list, &timer->links);
-}
-
-
-/* Thread cancellation handler which unlocks a mutex. */
-void
-__timer_mutex_cancel_handler (void *arg)
-{
- pthread_mutex_unlock (arg);
-}
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;
-}