diff options
| -rw-r--r-- | nptl/ChangeLog | 7 | ||||
| -rw-r--r-- | nptl/Makefile | 1 | ||||
| -rw-r--r-- | nptl/allocatestack.c | 3 | ||||
| -rw-r--r-- | nptl/sysdeps/unix/sysv/linux/i386/i486/pthread_cond_timedwait.S | 63 | ||||
| -rw-r--r-- | nptl/sysdeps/unix/sysv/linux/i386/i486/pthread_cond_wait.S | 67 | ||||
| -rw-r--r-- | nptl/tst-cond8.c | 275 | ||||
| -rw-r--r-- | nptl/tst-cond9.c | 150 |
7 files changed, 533 insertions, 33 deletions
diff --git a/nptl/ChangeLog b/nptl/ChangeLog index 0bcd27e189..c7d442148c 100644 --- a/nptl/ChangeLog +++ b/nptl/ChangeLog @@ -1,5 +1,12 @@ 2003-02-13 Ulrich Drepper <drepper@redhat.com> + * sysdeps/unix/sysv/linux/i386/i486/pthread_cond_wait.S: Fix + handling of cancellation and failung pthread_mutex_unlock call. + * sysdeps/unix/sysv/linux/i386/i486/pthread_cond_timedwait.S: Likewise. + * Makefile (tests): Add tst-cond8 and tst-cond9. + * tst-cond8.c: New file. + * tst-cond9.c: New file. + * tst-cond7.c (do_test): Unlock the mutex before canceling the thread. * sysdeps/pthread/pthread.h: Add missing initializers. Protect diff --git a/nptl/Makefile b/nptl/Makefile index ba5ab61a9b..35d77c2361 100644 --- a/nptl/Makefile +++ b/nptl/Makefile @@ -129,6 +129,7 @@ tests = tst-attr1 tst-attr2 \ tst-mutex7 \ tst-spin1 tst-spin2 tst-spin3 \ tst-cond1 tst-cond2 tst-cond3 tst-cond4 tst-cond5 tst-cond6 tst-cond7 \ + tst-cond8 tst-cond9 \ tst-rwlock1 tst-rwlock2 tst-rwlock3 tst-rwlock4 tst-rwlock5 \ tst-rwlock6 tst-rwlock7 \ tst-once1 tst-once2 tst-once3 tst-once4 \ diff --git a/nptl/allocatestack.c b/nptl/allocatestack.c index 94d4525ff0..1a4bf44367 100644 --- a/nptl/allocatestack.c +++ b/nptl/allocatestack.c @@ -465,8 +465,7 @@ allocate_stack (const struct pthread_attr *attr, struct pthread **pdp, 0)) { /* The old guard area is too large. */ - if (mprotect ((char *) mem + guardsize, - pd->guardsize - guardsize, + if (mprotect ((char *) mem + guardsize, pd->guardsize - guardsize, PROT_READ | PROT_WRITE | PROT_EXEC) != 0) goto mprot_error; diff --git a/nptl/sysdeps/unix/sysv/linux/i386/i486/pthread_cond_timedwait.S b/nptl/sysdeps/unix/sysv/linux/i386/i486/pthread_cond_timedwait.S index c520f287d9..b13ad19408 100644 --- a/nptl/sysdeps/unix/sysv/linux/i386/i486/pthread_cond_timedwait.S +++ b/nptl/sysdeps/unix/sysv/linux/i386/i486/pthread_cond_timedwait.S @@ -67,6 +67,9 @@ __pthread_cond_timedwait: 2: pushl 24(%esp) call __pthread_mutex_unlock_internal + testl %eax, %eax + jne 16f + addl $1, total_seq(%ebx) adcl $0, total_seq+4(%ebx) @@ -78,18 +81,23 @@ __pthread_cond_timedwait: #else leal __condvar_cleanup, %eax #endif - subl $32, %esp - leal 16(%esp), %edx - movl %ebx, 8(%esp) + subl $40, %esp + leal 28(%esp), %edx + movl %esp, 8(%esp) movl %eax, 4(%esp) movl %edx, (%esp) call __pthread_cleanup_push + /* Address of the mutex. */ + movl 68(%esp), %ecx /* Get and store current wakeup_seq value. */ movl wakeup_seq(%ebx), %edi movl wakeup_seq+4(%ebx), %edx - movl %edi, 12(%esp) - movl %edx, 16(%esp) + movl %edi, 20(%esp) + movl %edx, 24(%esp) + /* Prepare structure passed to cancellation handler. */ + movl %ebx, 4(%esp) + movl %ecx, 8(%esp) /* Unlock. */ 8: LOCK @@ -105,19 +113,19 @@ __pthread_cond_timedwait: /* Get the current time. */ movl %ebx, %edx - leal 4(%esp), %ebx + leal 12(%esp), %ebx xorl %ecx, %ecx movl $SYS_gettimeofday, %eax ENTER_KERNEL movl %edx, %ebx /* Compute relative timeout. */ - movl 8(%esp), %eax + movl 16(%esp), %eax movl $1000, %edx mul %edx /* Milli seconds to nano seconds. */ movl (%ebp), %ecx movl 4(%ebp), %edx - subl 4(%esp), %ecx + subl 12(%esp), %ecx subl %eax, %edx jns 12f addl $1000000000, %edx @@ -126,9 +134,9 @@ __pthread_cond_timedwait: js 13f /* Store relative timeout. */ - movl %ecx, 4(%esp) - movl %edx, 8(%esp) - leal 4(%esp), %esi + movl %ecx, 12(%esp) + movl %edx, 16(%esp) + leal 12(%esp), %esi xorl %ecx, %ecx /* movl $FUTEX_WAIT, %ecx */ movl %edi, %edx addl $wakeup_seq, %ebx @@ -156,10 +164,10 @@ __pthread_cond_timedwait: movl wakeup_seq(%ebx), %edi movl wakeup_seq+4(%ebx), %edx - cmpl 16(%esp), %ecx + cmpl 24(%esp), %ecx ja 7f jb 15f - cmpl 12(%esp), %eax + cmpl 20(%esp), %eax jb 15f 7: cmpl %ecx, %edx @@ -189,19 +197,19 @@ __pthread_cond_timedwait: jne 10f /* Remove cancellation handler. */ -11: leal 20(%esp), %edx +11: leal 28(%esp), %edx movl $0, 4(%esp) movl %edx, (%esp) call __pthread_cleanup_pop - movl 60(%esp), %ecx - movl %ecx, (%esp) + /* Trick ahead: 8(%esp) contains the address of the mutex. */ + addl $8, %esp call __pthread_mutex_lock_internal addl $36, %esp movl %esi, %eax - popl %ebx +18: popl %ebx popl %esi popl %edi popl %ebp @@ -248,6 +256,27 @@ __pthread_cond_timedwait: #endif call __lll_mutex_unlock_wake jmp 11b + + /* The initial unlocking of the mutex failed. */ +16: movl %eax, (%esp) + LOCK +#if cond_lock == 0 + decl (%ebx) +#else + decl cond_lock(%ebx) +#endif + jne 17f + +#if cond_lock == 0 + movl %ebx, %eax +#else + leal cond_lock(%ebx), %eax +#endif + call __lll_mutex_unlock_wake + +17: popl %eax + jmp 18b + .size __pthread_cond_wait, .-__pthread_cond_wait .size __pthread_cond_timedwait, .-__pthread_cond_timedwait versioned_symbol (libpthread, __pthread_cond_timedwait, pthread_cond_timedwait, GLIBC_2_3_2) diff --git a/nptl/sysdeps/unix/sysv/linux/i386/i486/pthread_cond_wait.S b/nptl/sysdeps/unix/sysv/linux/i386/i486/pthread_cond_wait.S index e43bcbac82..da0483ab1b 100644 --- a/nptl/sysdeps/unix/sysv/linux/i386/i486/pthread_cond_wait.S +++ b/nptl/sysdeps/unix/sysv/linux/i386/i486/pthread_cond_wait.S @@ -20,6 +20,7 @@ #include <sysdep.h> #include <shlib-compat.h> #include <lowlevelcond.h> +#include <tcb-offsets.h> #ifdef UP # define LOCK @@ -40,9 +41,11 @@ .hidden __condvar_cleanup __condvar_cleanup: pushl %ebx - movl 8(%esp), %ebx + pushl %esi + movl 12(%esp), %esi /* Get internal lock. */ + movl 4(%esi), %ebx movl $1, %eax LOCK #if cond_lock == 0 @@ -80,7 +83,16 @@ __condvar_cleanup: #endif call __lll_mutex_unlock_wake -2: popl %ebx + /* Lock the mutex unless asnychronous cancellation is in effect. */ +2: testl $2, (%esi) + jne 3f + + pushl 8(%esi) + call __pthread_mutex_lock_internal + popl %eax + +3: popl %esi + popl %ebx ret .size __condvar_cleanup, .-__condvar_cleanup @@ -113,6 +125,9 @@ __pthread_cond_wait: 2: pushl 20(%esp) call __pthread_mutex_unlock_internal + testl %eax, %eax + jne 12f + addl $1, total_seq(%ebx) adcl $0, total_seq+4(%ebx) @@ -124,18 +139,22 @@ __pthread_cond_wait: #else leal __condvar_cleanup, %eax #endif - subl $24, %esp - leal 12(%esp), %edx - movl %ebx, 8(%esp) + subl $32, %esp + leal 20(%esp), %edx + movl %esp, 8(%esp) movl %eax, 4(%esp) movl %edx, (%esp) call __pthread_cleanup_push /* Get and store current wakeup_seq value. */ + movl 56(%esp), %ecx movl wakeup_seq(%ebx), %edi movl wakeup_seq+4(%ebx), %edx - movl %edi, 4(%esp) - movl %edx, 8(%esp) + movl %edi, 12(%esp) + movl %edx, 16(%esp) + /* Prepare structure passed to cancellation handler. */ + movl %ebx, 4(%esp) + movl %ecx, 8(%esp) /* Unlock. */ 8: LOCK @@ -175,10 +194,10 @@ __pthread_cond_wait: movl wakeup_seq(%ebx), %edi movl wakeup_seq+4(%ebx), %edx - cmpl 8(%esp), %ecx + cmpl 16(%esp), %ecx ja 7f jb 8b - cmpl 4(%esp), %eax + cmpl 12(%esp), %eax jb 8b 7: cmpl %ecx, %edx @@ -199,17 +218,17 @@ __pthread_cond_wait: jne 10f /* Remove cancellation handler. */ -11: leal 12(%esp), %edx +11: leal 20(%esp), %edx movl $0, 4(%esp) movl %edx, (%esp) call __pthread_cleanup_pop - movl 48(%esp), %eax - movl %eax, (%esp) + /* Trick ahead: 8(%esp) contains the address of the mutex. */ + addl $8, %esp call __pthread_mutex_lock_internal addl $28, %esp - popl %ebx +14: popl %ebx popl %esi popl %edi @@ -246,7 +265,7 @@ __pthread_cond_wait: call __lll_mutex_lock_wait jmp 6b - /* Unlock after loop requires waekup. */ + /* Unlock after loop requires wakeup. */ 10: #if cond_lock == 0 movl %ebx, %eax @@ -255,6 +274,26 @@ __pthread_cond_wait: #endif call __lll_mutex_unlock_wake jmp 11b + + /* The initial unlocking of the mutex failed. */ +12: movl %eax, (%esp) + LOCK +#if cond_lock == 0 + decl (%ebx) +#else + decl cond_lock(%ebx) +#endif + jne 13f + +#if cond_lock == 0 + movl %ebx, %eax +#else + leal cond_lock(%ebx), %eax +#endif + call __lll_mutex_unlock_wake + +13: popl %eax + jmp 14b .size __pthread_cond_wait, .-__pthread_cond_wait versioned_symbol (libpthread, __pthread_cond_wait, pthread_cond_wait, GLIBC_2_3_2) diff --git a/nptl/tst-cond8.c b/nptl/tst-cond8.c new file mode 100644 index 0000000000..48451e7813 --- /dev/null +++ b/nptl/tst-cond8.c @@ -0,0 +1,275 @@ +/* Copyright (C) 2003 Free Software Foundation, Inc. + This file is part of the GNU C Library. + Contributed by Ulrich Drepper <drepper@redhat.com>, 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 <errno.h> +#include <pthread.h> +#include <stdio.h> +#include <stdlib.h> +#include <time.h> +#include <sys/time.h> + + +static pthread_cond_t cond = PTHREAD_COND_INITIALIZER; +static pthread_mutex_t mut = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP; + +static pthread_barrier_t bar; + + +static void +ch (void *arg) +{ + int e = pthread_mutex_lock (&mut); + if (e == 0) + { + puts ("mutex not locked at all by cond_wait"); + exit (1); + } + + if (e != EDEADLK) + { + puts ("no deadlock error signaled"); + exit (1); + } + + if (pthread_mutex_unlock (&mut) != 0) + { + puts ("ch: cannot unlock mutex"); + exit (1); + } +} + + +static void * +tf1 (void *p) +{ + int err; + + if (pthread_setcancelstate (PTHREAD_CANCEL_ENABLE, NULL) != 0 + || pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED, NULL) != 0) + { + puts ("cannot set cancellation options"); + exit (1); + } + + err = pthread_mutex_lock (&mut); + if (err != 0) + { + puts ("child: cannot get mutex"); + exit (1); + } + + err = pthread_barrier_wait (&bar); + if (err != 0 && err != PTHREAD_BARRIER_SERIAL_THREAD) + { + printf ("barrier_wait returned %d\n", err); + exit (1); + } + + puts ("child: got mutex; waiting"); + + pthread_cleanup_push (ch, NULL); + + pthread_cond_wait (&cond, &mut); + + pthread_cleanup_pop (0); + + puts ("child: cond_wait should not have returned"); + + return NULL; +} + + +static void * +tf2 (void *p) +{ + int err; + + if (pthread_setcancelstate (PTHREAD_CANCEL_ENABLE, NULL) != 0 + || pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED, NULL) != 0) + { + puts ("cannot set cancellation options"); + exit (1); + } + + err = pthread_mutex_lock (&mut); + if (err != 0) + { + puts ("child: cannot get mutex"); + exit (1); + } + + err = pthread_barrier_wait (&bar); + if (err != 0 && err != PTHREAD_BARRIER_SERIAL_THREAD) + { + printf ("barrier_wait returned %d\n", err); + exit (1); + } + + puts ("child: got mutex; waiting"); + + pthread_cleanup_push (ch, NULL); + + /* Current time. */ + struct timeval tv; + (void) gettimeofday (&tv, NULL); + /* +1000 seconds in correct format. */ + struct timespec ts; + TIMEVAL_TO_TIMESPEC (&tv, &ts); + ts.tv_sec += 1000; + + pthread_cond_timedwait (&cond, &mut, &ts); + + pthread_cleanup_pop (0); + + puts ("child: cond_wait should not have returned"); + + return NULL; +} + + +static int +do_test (void) +{ + pthread_t th; + int err; + + printf ("&cond = %p\n&mut = %p\n", &cond, &mut); + + puts ("parent: get mutex"); + + err = pthread_barrier_init (&bar, NULL, 2); + if (err != 0) + { + puts ("parent: cannot init barrier"); + exit (1); + } + + puts ("parent: create child"); + + err = pthread_create (&th, NULL, tf1, NULL); + if (err != 0) + { + puts ("parent: cannot create thread"); + exit (1); + } + + puts ("parent: wait for child to lock mutex"); + + err = pthread_barrier_wait (&bar); + if (err != 0 && err != PTHREAD_BARRIER_SERIAL_THREAD) + { + puts ("parent: cannot wait for barrier"); + exit (1); + } + + err = pthread_mutex_lock (&mut); + if (err != 0) + { + puts ("parent: mutex_lock failed"); + exit (1); + } + + err = pthread_mutex_unlock (&mut); + if (err != 0) + { + puts ("parent: mutex_unlock failed"); + exit (1); + } + + if (pthread_cancel (th) != 0) + { + puts ("cannot cancel thread"); + exit (1); + } + + void *r; + err = pthread_join (th, &r); + if (err != 0) + { + puts ("parent: failed to join"); + exit (1); + } + + if (r != PTHREAD_CANCELED) + { + puts ("child hasn't been canceled"); + exit (1); + } + + + + puts ("parent: create 2nd child"); + + err = pthread_create (&th, NULL, tf2, NULL); + if (err != 0) + { + puts ("parent: cannot create thread"); + exit (1); + } + + puts ("parent: wait for child to lock mutex"); + + err = pthread_barrier_wait (&bar); + if (err != 0 && err != PTHREAD_BARRIER_SERIAL_THREAD) + { + puts ("parent: cannot wait for barrier"); + exit (1); + } + + err = pthread_mutex_lock (&mut); + if (err != 0) + { + puts ("parent: mutex_lock failed"); + exit (1); + } + + err = pthread_mutex_unlock (&mut); + if (err != 0) + { + puts ("parent: mutex_unlock failed"); + exit (1); + } + + if (pthread_cancel (th) != 0) + { + puts ("cannot cancel thread"); + exit (1); + } + + err = pthread_join (th, &r); + if (err != 0) + { + puts ("parent: failed to join"); + exit (1); + } + + if (r != PTHREAD_CANCELED) + { + puts ("child hasn't been canceled"); + exit (1); + } + + puts ("done"); + + return 0; +} + + +#define TEST_FUNCTION do_test () +#include "../test-skeleton.c" diff --git a/nptl/tst-cond9.c b/nptl/tst-cond9.c new file mode 100644 index 0000000000..2a8477dd8b --- /dev/null +++ b/nptl/tst-cond9.c @@ -0,0 +1,150 @@ +/* Copyright (C) 2003 Free Software Foundation, Inc. + This file is part of the GNU C Library. + Contributed by Ulrich Drepper <drepper@redhat.com>, 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 <errno.h> +#include <pthread.h> +#include <stdio.h> +#include <stdlib.h> +#include <time.h> +#include <sys/time.h> + + +static pthread_cond_t cond = PTHREAD_COND_INITIALIZER; +static pthread_mutex_t mut = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP; + + +static void * +tf (void *arg) +{ + int err = pthread_cond_wait (&cond, &mut); + if (err == 0) + { + puts ("cond_wait did not fail"); + exit (1); + } + + if (err != EPERM) + { + printf ("cond_wait didn't return EPERM but %d\n", err); + exit (1); + } + + + /* Current time. */ + struct timeval tv; + (void) gettimeofday (&tv, NULL); + /* +1000 seconds in correct format. */ + struct timespec ts; + TIMEVAL_TO_TIMESPEC (&tv, &ts); + ts.tv_sec += 1000; + + err = pthread_cond_timedwait (&cond, &mut, &ts); + if (err == 0) + { + puts ("cond_timedwait did not fail"); + exit (1); + } + + if (err != EPERM) + { + printf ("cond_timedwait didn't return EPERM but %d\n", err); + exit (1); + } + + return (void *) 1l; +} + + +static int +do_test (void) +{ + pthread_t th; + int err; + + printf ("&cond = %p\n&mut = %p\n", &cond, &mut); + + err = pthread_cond_wait (&cond, &mut); + if (err == 0) + { + puts ("cond_wait did not fail"); + exit (1); + } + + if (err != EPERM) + { + printf ("cond_wait didn't return EPERM but %d\n", err); + exit (1); + } + + + /* Current time. */ + struct timeval tv; + (void) gettimeofday (&tv, NULL); + /* +1000 seconds in correct format. */ + struct timespec ts; + TIMEVAL_TO_TIMESPEC (&tv, &ts); + ts.tv_sec += 1000; + + err = pthread_cond_timedwait (&cond, &mut, &ts); + if (err == 0) + { + puts ("cond_timedwait did not fail"); + exit (1); + } + + if (err != EPERM) + { + printf ("cond_timedwait didn't return EPERM but %d\n", err); + exit (1); + } + + if (pthread_mutex_lock (&mut) != 0) + { + puts ("parent: mutex_lock failed"); + exit (1); + } + + puts ("creating thread"); + + if (pthread_create (&th, NULL, tf, NULL) != 0) + { + puts ("create failed"); + exit (1); + } + + void *r; + if (pthread_join (th, &r) != 0) + { + puts ("join failed"); + exit (1); + } + if (r != (void *) 1l) + { + puts ("thread has wrong return value"); + exit (1); + } + + puts ("done"); + + return 0; +} + + +#define TEST_FUNCTION do_test () +#include "../test-skeleton.c" |