diff --git a/ChangeLog b/ChangeLog index addd53ad3a..5c90512318 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,5 +1,12 @@ 2003-06-17 Ulrich Drepper + * sysdeps/unix/clock_nanosleep.c (clock_nanosleep): nanosleep + takes care of enabling cancellation. + + * sysdeps/pthread/aio_suspend.c (aio_suspend): Make aio_suspend + cancelable. It's not correct to disable cancellation. Instead of + a cleanup handler. + * sysdeps/unix/sysv/linux/sigtimedwait.c: If SIGCANCEL is defined and part of the incoming set, create a temporary set without this signal. diff --git a/nptl/Makefile b/nptl/Makefile index 74a2f7e3e4..47717e7a37 100644 --- a/nptl/Makefile +++ b/nptl/Makefile @@ -212,7 +212,7 @@ tests = tst-attr1 tst-attr2 \ tst-cancel1 tst-cancel2 tst-cancel3 tst-cancel4 tst-cancel5 \ tst-cancel6 tst-cancel7 tst-cancel8 tst-cancel9 tst-cancel10 \ tst-cancel11 tst-cancel12 tst-cancel13 tst-cancel14 tst-cancel15 \ - tst-cancel16 \ + tst-cancel16 tst-cancel17 \ tst-cleanup0 tst-cleanup1 tst-cleanup2 tst-cleanup3 \ tst-flock1 tst-flock2 \ tst-signal1 tst-signal2 tst-signal3 tst-signal4 tst-signal5 \ @@ -243,7 +243,7 @@ ifeq ($(have-forced-unwind),yes) tests += tst-cancelx2 tst-cancelx3 tst-cancelx4 tst-cancelx5 \ tst-cancelx6 tst-cancelx7 tst-cancelx8 tst-cancelx9 tst-cancelx10 \ tst-cancelx11 tst-cancelx12 tst-cancelx13 tst-cancelx14 tst-cancelx15\ - tst-cancelx16 \ + tst-cancelx16 tst-cancelx17 \ tst-cleanupx0 tst-cleanupx1 tst-cleanupx2 tst-cleanupx3 endif ifeq ($(build-shared),yes) @@ -363,6 +363,7 @@ CFLAGS-tst-cancelx13.c += -fexceptions CFLAGS-tst-cancelx14.c += -fexceptions CFLAGS-tst-cancelx15.c += -fexceptions CFLAGS-tst-cancelx16.c += -fexceptions +CFLAGS-tst-cancelx17.c += -fexceptions CFLAGS-tst-cleanupx0.c += -fexceptions -fasynchronous-unwind-tables CFLAGS-tst-cleanupx1.c += -fexceptions -fasynchronous-unwind-tables CFLAGS-tst-cleanupx2.c += -fexceptions @@ -385,8 +386,12 @@ $(objpfx)tst-dlsym1: $(libdl) $(shared-thread-library) ifeq (yes,$(build-shared)) $(objpfx)tst-cond11: $(common-objpfx)rt/librt.so +$(objpfx)tst-cancel17: $(common-objpfx)rt/librt.so +$(objpfx)tst-cancelx17: $(common-objpfx)rt/librt.so else $(objpfx)tst-cond11: $(common-objpfx)rt/librt.a +$(objpfx)tst-cancel17: $(common-objpfx)rt/librt.a +$(objpfx)tst-cancelx17: $(common-objpfx)rt/librt.a endif extra-B-pthread.so = -B$(common-objpfx)nptl/ diff --git a/nptl/sysdeps/unix/sysv/linux/sigtimedwait.c b/nptl/sysdeps/unix/sysv/linux/sigtimedwait.c new file mode 100644 index 0000000000..8560e8b40a --- /dev/null +++ b/nptl/sysdeps/unix/sysv/linux/sigtimedwait.c @@ -0,0 +1,2 @@ +#include +#include "../../../../../sysdeps/unix/sysv/linux/sigtimedwait.c" diff --git a/nptl/sysdeps/unix/sysv/linux/sigwait.c b/nptl/sysdeps/unix/sysv/linux/sigwait.c new file mode 100644 index 0000000000..c358bfbeed --- /dev/null +++ b/nptl/sysdeps/unix/sysv/linux/sigwait.c @@ -0,0 +1,2 @@ +#include +#include "../../../../../sysdeps/unix/sysv/linux/sigwait.c" diff --git a/nptl/sysdeps/unix/sysv/linux/sigwaitinfo.c b/nptl/sysdeps/unix/sysv/linux/sigwaitinfo.c new file mode 100644 index 0000000000..a4f9fe8f5f --- /dev/null +++ b/nptl/sysdeps/unix/sysv/linux/sigwaitinfo.c @@ -0,0 +1,2 @@ +#include +#include "../../../../../sysdeps/unix/sysv/linux/sigwaitinfo.c" diff --git a/nptl/tst-cancel17.c b/nptl/tst-cancel17.c new file mode 100644 index 0000000000..65b8c73ef8 --- /dev/null +++ b/nptl/tst-cancel17.c @@ -0,0 +1,205 @@ +/* Copyright (C) 2003 Free Software Foundation, Inc. + This file is part of the GNU C Library. + Contributed by Ulrich Drepper , 2003. + + 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, write to the Free + Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA + 02111-1307 USA. */ + +#include +#include +#include +#include +#include +#include + + +static pthread_barrier_t b; + + +/* Cleanup handling test. */ +static int cl_called; + +static void +cl (void *arg) +{ + ++cl_called; +} + + +static void * +tf (void *arg) +{ + int r = pthread_barrier_wait (&b); + if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD) + { + puts ("barrier_wait failed"); + exit (1); + } + + pthread_cleanup_push (cl, NULL); + + const struct aiocb *l[1] = { arg }; + + aio_suspend (l, 1, NULL); + + pthread_cleanup_pop (0); + + puts ("aio_suspend returned"); + + exit (1); +} + + +static int +do_test (void) +{ + int fds[2]; + if (pipe (fds) != 0) + { + puts ("pipe failed"); + return 1; + } + + struct aiocb a; + char mem[1]; + memset (&a, '\0', sizeof (a)); + a.aio_fildes = fds[0]; + a.aio_buf = mem; + a.aio_nbytes = sizeof (mem); + if (aio_read (&a) != 0) + { + puts ("aio_read failed"); + return 1; + } + + if (pthread_barrier_init (&b, NULL, 2) != 0) + { + puts ("barrier_init failed"); + return 1; + } + + pthread_t th; + if (pthread_create (&th, NULL, tf, &a) != 0) + { + puts ("1st create failed"); + return 1; + } + + int r = pthread_barrier_wait (&b); + if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD) + { + puts ("barrier_wait failed"); + exit (1); + } + + struct timespec ts = { .tv_sec = 0, .tv_nsec = 100000000 }; + while (nanosleep (&ts, &ts) != 0) + continue; + + puts ("going to cancel in-time"); + if (pthread_cancel (th) != 0) + { + puts ("1st cancel failed"); + return 1; + } + + void *status; + if (pthread_join (th, &status) != 0) + { + puts ("1st join failed"); + return 1; + } + if (status != PTHREAD_CANCELED) + { + puts ("1st thread not canceled"); + return 1; + } + + if (cl_called == 0) + { + puts ("cleanup handler not called"); + return 1; + } + if (cl_called > 1) + { + puts ("cleanup handler called more than once"); + return 1; + } + + puts ("in-time cancellation succeeded"); + aio_cancel (fds[0], &a); + + + cl_called = 0; + + memset (&a, '\0', sizeof (a)); + a.aio_fildes = fds[1]; + a.aio_buf = mem; + a.aio_nbytes = sizeof (mem); + if (aio_write (&a) != 0) + { + puts ("aio_write failed"); + return 1; + } + + if (pthread_create (&th, NULL, tf, &a) != 0) + { + puts ("2nd create failed"); + return 1; + } + + puts ("going to cancel early"); + if (pthread_cancel (th) != 0) + { + puts ("2nd cancel failed"); + return 1; + } + + r = pthread_barrier_wait (&b); + if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD) + { + puts ("barrier_wait failed"); + exit (1); + } + + if (pthread_join (th, &status) != 0) + { + puts ("2nd join failed"); + return 1; + } + if (status != PTHREAD_CANCELED) + { + puts ("2nd thread not canceled"); + return 1; + } + + if (cl_called == 0) + { + printf ("cleanup handler not called\n"); + return 1; + } + if (cl_called > 1) + { + printf ("cleanup handler called more than once\n"); + return 1; + } + + puts ("early cancellation succeeded"); + + return 0; +} + +#define TEST_FUNCTION do_test () +#include "../test-skeleton.c" diff --git a/nptl/tst-cancelx17.c b/nptl/tst-cancelx17.c new file mode 100644 index 0000000000..c6c833b60c --- /dev/null +++ b/nptl/tst-cancelx17.c @@ -0,0 +1 @@ +#include "tst-cancel17.c" diff --git a/sysdeps/pthread/aio_suspend.c b/sysdeps/pthread/aio_suspend.c index ffc1c64703..1b09aef028 100644 --- a/sysdeps/pthread/aio_suspend.c +++ b/sysdeps/pthread/aio_suspend.c @@ -35,9 +35,54 @@ #include #include +#include #include "aio_misc.h" +struct clparam +{ + const struct aiocb *const *list; + struct waitlist *waitlist; + struct requestlist **requestlist; + pthread_cond_t *cond; + int nent; +}; + + +static void +cleanup (void *arg) +{ + 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; + } + + /* Release the conditional variable. */ + (void) pthread_cond_destroy (param->cond); + + /* Release the mutex. */ + pthread_mutex_unlock (&__aio_requests_mutex); +} + + int aio_suspend (list, nent, timeout) const struct aiocb *const list[]; @@ -87,12 +132,16 @@ aio_suspend (list, nent, timeout) /* Only if none of the entries is NULL or finished to be wait. */ if (cnt == nent && any) { - int oldstate; + struct clparam clparam = + { + .list = list, + .waitlist = waitlist, + .requestlist = requestlist, + .cond = &cond, + .nent = nent + }; - /* Since `pthread_cond_wait'/`pthread_cond_timedwait' are cancelation - points we must be careful. We added entries to the waiting lists - which we must remove. So defer cancelation for now. */ - pthread_setcancelstate (PTHREAD_CANCEL_DISABLE, &oldstate); + __libc_cleanup_region_start (1, cleanup, &clparam); if (timeout == NULL) result = pthread_cond_wait (&cond, &__aio_requests_mutex); @@ -116,8 +165,7 @@ aio_suspend (list, nent, timeout) &abstime); } - /* Now it's time to restore the cancellation state. */ - pthread_setcancelstate (oldstate, NULL); + __libc_cleanup_region_end (0); } /* Now remove the entry in the waiting list for all requests diff --git a/sysdeps/unix/clock_nanosleep.c b/sysdeps/unix/clock_nanosleep.c index 34bbc2dae6..7662d1704e 100644 --- a/sysdeps/unix/clock_nanosleep.c +++ b/sysdeps/unix/clock_nanosleep.c @@ -94,15 +94,5 @@ clock_nanosleep (clockid_t clock_id, int flags, const struct timespec *req, /* Not supported. */ return ENOTSUP; - if (SINGLE_THREAD_P) - return __builtin_expect (nanosleep (req, rem), 0) ? errno : 0; - - /* More than one thread running, enable cancellation. */ - int oldstate = LIBC_CANCEL_ASYNC (); - - int result = __builtin_expect (nanosleep (req, rem), 0) ? errno : 0; - - LIBC_CANCEL_RESET (oldstate); - - return result; + return __builtin_expect (nanosleep (req, rem), 0) ? errno : 0; }