diff options
| -rw-r--r-- | nptl/ChangeLog | 12 | ||||
| -rw-r--r-- | nptl/Makefile | 2 | ||||
| -rw-r--r-- | nptl/pthread_create.c | 117 | ||||
| -rw-r--r-- | nptl/pthread_setspecific.c | 10 | ||||
| -rw-r--r-- | nptl/tst-tsd3.c | 129 |
5 files changed, 213 insertions, 57 deletions
diff --git a/nptl/ChangeLog b/nptl/ChangeLog index 04a474e509..9587f9cbb2 100644 --- a/nptl/ChangeLog +++ b/nptl/ChangeLog @@ -1,3 +1,15 @@ +2003-04-01 Ulrich Drepper <drepper@redhat.com> + + * pthread_create.c (deallocate_tsd): Clear/free memory after the last + round, not the first. Use specific_used flag instead of local + found_nonzero variable. Use THREAD_[SG]ETMEM where possible. + (__free_tcb): Don't call deallocate_tsd here. + (start_thread): Call deallocate_tsd here. + * pthread_setspecific.c: Set specific_used flag really only when + needed. + * Makefile (tests): Add tst-tsd3.c + * tst-tsd3.c: New file. + 2003-03-31 Ulrich Drepper <drepper@redhat.com> * sysdeps/unix/sysv/linux/ia64/lowlevellock.h (__lll_mutex_lock): diff --git a/nptl/Makefile b/nptl/Makefile index c352216421..96320cf686 100644 --- a/nptl/Makefile +++ b/nptl/Makefile @@ -145,7 +145,7 @@ tests = tst-attr1 tst-attr2 \ tst-kill1 tst-kill2 tst-kill3 tst-kill4 tst-kill5 tst-kill6 \ tst-join1 tst-join2 tst-join3 tst-join4 tst-join5 \ tst-eintr1 \ - tst-tsd1 tst-tsd2 \ + tst-tsd1 tst-tsd2 tst-tsd3 \ tst-tls1 tst-tls2 \ tst-fork1 tst-fork2 tst-fork3 tst-fork4 \ tst-atfork1 \ diff --git a/nptl/pthread_create.c b/nptl/pthread_create.c index 8598e4c763..748cb93686 100644 --- a/nptl/pthread_create.c +++ b/nptl/pthread_create.c @@ -112,67 +112,78 @@ deallocate_tsd (struct pthread *pd) { /* Maybe no data was ever allocated. This happens often so we have a flag for this. */ - if (pd->specific_used) + if (THREAD_GETMEM (pd, specific_used)) { size_t round; - bool found_nonzero; + size_t cnt; - for (round = 0, found_nonzero = true; - found_nonzero && round < PTHREAD_DESTRUCTOR_ITERATIONS; - ++round) + round = 0; + do { - size_t cnt; size_t idx; /* So far no new nonzero data entry. */ - found_nonzero = false; + THREAD_SETMEM (pd, specific_used, false); for (cnt = idx = 0; cnt < PTHREAD_KEY_1STLEVEL_SIZE; ++cnt) - if (pd->specific[cnt] != NULL) - { - size_t inner; - - for (inner = 0; inner < PTHREAD_KEY_2NDLEVEL_SIZE; - ++inner, ++idx) - { - void *data = pd->specific[cnt][inner].data; - - if (data != NULL - /* Make sure the data corresponds to a valid - key. This test fails if the key was - deallocated and also if it was - re-allocated. It is the user's - responsibility to free the memory in this - case. */ - && (pd->specific[cnt][inner].seq - == __pthread_keys[idx].seq) - /* It is not necessary to register a destructor - function. */ - && __pthread_keys[idx].destr != NULL) - { - pd->specific[cnt][inner].data = NULL; - __pthread_keys[idx].destr (data); - found_nonzero = true; - } - } - - if (cnt != 0) - { - /* The first block is allocated as part of the thread - descriptor. */ - free (pd->specific[cnt]); - pd->specific[cnt] = NULL; - } - else - /* Clear the memory of the first block for reuse. */ - memset (&pd->specific_1stblock, '\0', - sizeof (pd->specific_1stblock)); - } - else - idx += PTHREAD_KEY_1STLEVEL_SIZE; + { + struct pthread_key_data *level2; + + level2 = THREAD_GETMEM_NC (pd, specific, cnt); + + if (level2 != NULL) + { + size_t inner; + + for (inner = 0; inner < PTHREAD_KEY_2NDLEVEL_SIZE; + ++inner, ++idx) + { + void *data = level2[inner].data; + + if (data != NULL + /* Make sure the data corresponds to a valid + key. This test fails if the key was + deallocated and also if it was + re-allocated. It is the user's + responsibility to free the memory in this + case. */ + && (level2[inner].seq + == __pthread_keys[idx].seq) + /* It is not necessary to register a destructor + function. */ + && __pthread_keys[idx].destr != NULL) + { + level2[inner].data = NULL; + __pthread_keys[idx].destr (data); + } + } + } + else + idx += PTHREAD_KEY_1STLEVEL_SIZE; + } } + while (THREAD_GETMEM (pd, specific_used) + && ++round < PTHREAD_DESTRUCTOR_ITERATIONS); + + /* Clear the memory of the first block for reuse. */ + memset (&pd->specific_1stblock, '\0', sizeof (pd->specific_1stblock)); - pd->specific_used = false; + /* Free the memory for the other blocks. */ + for (cnt = 1; cnt < PTHREAD_KEY_1STLEVEL_SIZE; ++cnt) + { + struct pthread_key_data *level2; + + level2 = THREAD_GETMEM_NC (pd, specific, cnt); + if (level2 != NULL) + { + /* The first block is allocated as part of the thread + descriptor. */ + free (level2); + THREAD_SETMEM_NC (pd, specific, cnt, NULL); + } + } + + THREAD_SETMEM (pd, specific_used, false); } } @@ -193,9 +204,6 @@ __free_tcb (struct pthread *pd) running thread is gone. */ abort (); - /* Run the destructor for the thread-local data. */ - deallocate_tsd (pd); - /* Queue the stack memory block for reuse and exit the process. The kernel will signal via writing to the address returned by QUEUE-STACK when the stack is available. */ @@ -232,6 +240,9 @@ start_thread (void *arg) #endif } + /* Run the destructor for the thread-local data. */ + deallocate_tsd (pd); + /* Clean up any state libc stored in thread-local variables. */ __libc_thread_freeres (); diff --git a/nptl/pthread_setspecific.c b/nptl/pthread_setspecific.c index baca804adb..b6e66b5f22 100644 --- a/nptl/pthread_setspecific.c +++ b/nptl/pthread_setspecific.c @@ -45,6 +45,10 @@ __pthread_setspecific (key, value) return EINVAL; level2 = &self->specific_1stblock[key]; + + /* Remember that we stored at least one set of data. */ + if (value != NULL) + THREAD_SETMEM (self, specific_used, true); } else { @@ -76,6 +80,9 @@ __pthread_setspecific (key, value) /* Pointer to the right array element. */ level2 = &level2[idx2nd]; + + /* Remember that we stored at least one set of data. */ + THREAD_SETMEM (self, specific_used, true); } /* Store the data and the sequence number so that we can recognize @@ -83,9 +90,6 @@ __pthread_setspecific (key, value) level2->seq = seq; level2->data = (void *) value; - /* Remember that we stored at least one set of data. */ - THREAD_SETMEM (self, specific_used, true); - return 0; } strong_alias (__pthread_setspecific, pthread_setspecific) diff --git a/nptl/tst-tsd3.c b/nptl/tst-tsd3.c new file mode 100644 index 0000000000..6cdf749914 --- /dev/null +++ b/nptl/tst-tsd3.c @@ -0,0 +1,129 @@ +/* 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 <limits.h> +#include <pthread.h> +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> + + +static pthread_key_t key1; +static pthread_key_t key2; + + +static int left; + + +static void +destr1 (void *arg) +{ + if (--left > 0) + { + puts ("set key2"); + + if (pthread_setspecific (key2, (void *) 1l) != 0) + { + puts ("destr1: setspecific failed"); + exit (1); + } + } +} + + +static void +destr2 (void *arg) +{ + if (--left > 0) + { + puts ("set key1"); + + if (pthread_setspecific (key1, (void *) 1l) != 0) + { + puts ("destr2: setspecific failed"); + exit (1); + } + } +} + + +static void * +tf (void *arg) +{ + /* Let the destructors work. */ + left = 7; + + if (pthread_setspecific (key1, (void *) 1l) != 0 + || pthread_setspecific (key2, (void *) 1l) != 0) + { + puts ("tf: setspecific failed"); + exit (1); + } + + return NULL; +} + + +static int +do_test (void) +{ + /* Allocate two keys, both with destructors. */ + if (pthread_key_create (&key1, destr1) != 0 + || pthread_key_create (&key2, destr2) != 0) + { + puts ("key_create failed"); + return 1; + } + + pthread_t th; + if (pthread_create (&th, NULL, tf, NULL) != 0) + { + puts ("create failed"); + return 1; + } + + if (pthread_join (th, NULL) != 0) + { + puts ("join failed"); + return 1; + } + + if (left != 0) + { + printf ("left == %d\n", left); + return 1; + } + + if (pthread_getspecific (key1) != NULL) + { + puts ("key1 data != NULL"); + return 1; + } + if (pthread_getspecific (key2) != NULL) + { + puts ("key2 data != NULL"); + return 1; + } + + return 0; +} + + +#define TEST_FUNCTION do_test () +#include "../test-skeleton.c" |