l4/pkg/uclibc/lib/contrib/uclibc/libpthread/linuxthreads.old/specific.c

   1 /* Linuxthreads - a simple clone()-based implementation of Posix        */
   2 /* threads for Linux.                                                   */
   3 /* Copyright (C) 1996 Xavier Leroy (Xavier.Leroy@inria.fr)              */
   4 /*                                                                      */
   5 /* This program is free software; you can redistribute it and/or        */
   6 /* modify it under the terms of the GNU Library General Public License  */
   7 /* as published by the Free Software Foundation; either version 2       */
   8 /* of the License, or (at your option) any later version.               */
   9 /*                                                                      */
  10 /* This program is distributed in the hope that it will be useful,      */
  11 /* but WITHOUT ANY WARRANTY; without even the implied warranty of       */
  12 /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        */
  13 /* GNU Library General Public License for more details.                 */
  14
  15 /* Thread-specific data */
  16
  17 #include <features.h>
  18 #include <errno.h>
  19 #include <stddef.h>
  20 #include <stdlib.h>
  21 #include "pthread.h"
  22 #include "internals.h"
  23 #include "spinlock.h"
  24 #include "restart.h"
  25
  26 /* Table of keys. */
  27
  28 static struct pthread_key_struct pthread_keys[PTHREAD_KEYS_MAX] =
  29   { { 0, NULL } };
  30
  31 /* For debugging purposes put the maximum number of keys in a variable.  */
  32 const int __linuxthreads_pthread_keys_max = PTHREAD_KEYS_MAX;
  33 const int __linuxthreads_pthread_key_2ndlevel_size = PTHREAD_KEY_2NDLEVEL_SIZE;
  34
  35 /* Mutex to protect access to pthread_keys */
  36
  37 static pthread_mutex_t pthread_keys_mutex = PTHREAD_MUTEX_INITIALIZER;
  38
  39 /* Create a new key */
  40
  41 int pthread_key_create(pthread_key_t * key, destr_function destr)
  42 {
  43   int i;
  44
  45   __pthread_mutex_lock(&pthread_keys_mutex);
  46   for (i = 0; i < PTHREAD_KEYS_MAX; i++) {
  47     if (! pthread_keys[i].in_use) {
  48       /* Mark key in use */
  49       pthread_keys[i].in_use = 1;
  50       pthread_keys[i].destr = destr;
  51       __pthread_mutex_unlock(&pthread_keys_mutex);
  52       *key = i;
  53       return 0;
  54     }
  55   }
  56   __pthread_mutex_unlock(&pthread_keys_mutex);
  57   return EAGAIN;
  58 }
  59
  60 /* Delete a key */
  61 int pthread_key_delete(pthread_key_t key)
  62 {
  63     pthread_descr self = thread_self();
  64
  65     __pthread_mutex_lock(&pthread_keys_mutex);
  66     if (key >= PTHREAD_KEYS_MAX || !pthread_keys[key].in_use) {
  67         __pthread_mutex_unlock(&pthread_keys_mutex);
  68         return EINVAL;
  69     }
  70     pthread_keys[key].in_use = 0;
  71     pthread_keys[key].destr = NULL;
  72
  73     /* Set the value of the key to NULL in all running threads, so
  74        that if the key is reallocated later by pthread_key_create, its
  75        associated values will be NULL in all threads.
  76        Do nothing if no threads have been created yet.  */
  77     if (__pthread_manager_request != -1)
  78     {
  79         pthread_descr th;
  80         unsigned int idx1st, idx2nd;
  81
  82         idx1st = key / PTHREAD_KEY_2NDLEVEL_SIZE;
  83         idx2nd = key % PTHREAD_KEY_2NDLEVEL_SIZE;
  84         th = self;
  85         do {
  86             /* If the thread already is terminated don't modify the memory.  */
  87             if (!th->p_terminated && th->p_specific[idx1st] != NULL)
  88                 th->p_specific[idx1st][idx2nd] = NULL;
  89             th = th->p_nextlive;
  90         } while (th != self);
  91     }
  92
  93     __pthread_mutex_unlock(&pthread_keys_mutex);
  94     return 0;
  95 }
  96
  97 /* Set the value of a key */
  98
  99 int pthread_setspecific(pthread_key_t key, const void * pointer)
 100 {
 101     pthread_descr self = thread_self();
 102     unsigned int idx1st, idx2nd;
 103
 104     if (key >= PTHREAD_KEYS_MAX || !pthread_keys[key].in_use)
 105         return EINVAL;
 106     idx1st = key / PTHREAD_KEY_2NDLEVEL_SIZE;
 107     idx2nd = key % PTHREAD_KEY_2NDLEVEL_SIZE;
 108     if (THREAD_GETMEM_NC(self, p_specific[idx1st]) == NULL) {
 109         void *newp = calloc(PTHREAD_KEY_2NDLEVEL_SIZE, sizeof (void *));
 110         if (newp == NULL)
 111             return ENOMEM;
 112         THREAD_SETMEM_NC(self, p_specific[idx1st], newp);
 113     }
 114     THREAD_GETMEM_NC(self, p_specific[idx1st])[idx2nd] = (void *) pointer;
 115     return 0;
 116 }
 117
 118 /* Get the value of a key */
 119
 120 void * pthread_getspecific(pthread_key_t key)
 121 {
 122     pthread_descr self = thread_self();
 123     unsigned int idx1st, idx2nd;
 124
 125     if (key >= PTHREAD_KEYS_MAX)
 126         return NULL;
 127     idx1st = key / PTHREAD_KEY_2NDLEVEL_SIZE;
 128     idx2nd = key % PTHREAD_KEY_2NDLEVEL_SIZE;
 129     if (THREAD_GETMEM_NC(self, p_specific[idx1st]) == NULL
 130             || !pthread_keys[key].in_use)
 131         return NULL;
 132     return THREAD_GETMEM_NC(self, p_specific[idx1st])[idx2nd];
 133 }
 134
 135 /* Call the destruction routines on all keys */
 136
 137 void __pthread_destroy_specifics(void)
 138 {
 139     pthread_descr self = thread_self();
 140     int i, j, round, found_nonzero;
 141     destr_function destr;
 142     void * data;
 143
 144     for (round = 0, found_nonzero = 1;
 145             found_nonzero && round < PTHREAD_DESTRUCTOR_ITERATIONS;
 146             round++) {
 147         found_nonzero = 0;
 148         for (i = 0; i < PTHREAD_KEY_1STLEVEL_SIZE; i++)
 149             if (THREAD_GETMEM_NC(self, p_specific[i]) != NULL)
 150                 for (j = 0; j < PTHREAD_KEY_2NDLEVEL_SIZE; j++) {
 151                     destr = pthread_keys[i * PTHREAD_KEY_2NDLEVEL_SIZE + j].destr;
 152                     data = THREAD_GETMEM_NC(self, p_specific[i])[j];
 153                     if (destr != NULL && data != NULL) {
 154                         THREAD_GETMEM_NC(self, p_specific[i])[j] = NULL;
 155                         destr(data);
 156                         found_nonzero = 1;
 157                     }
 158                 }
 159     }
 160     __pthread_lock(THREAD_GETMEM(self, p_lock), self);
 161     for (i = 0; i < PTHREAD_KEY_1STLEVEL_SIZE; i++) {
 162         if (THREAD_GETMEM_NC(self, p_specific[i]) != NULL) {
 163             free(THREAD_GETMEM_NC(self, p_specific[i]));
 164             THREAD_SETMEM_NC(self, p_specific[i], NULL);
 165         }
 166     }
 167     __pthread_unlock(THREAD_GETMEM(self, p_lock));
 168 }
 169
 170 #if !defined __UCLIBC_HAS_TLS__ && defined __UCLIBC_HAS_RPC__
 171
 172 /* Thread-specific data for libc. */
 173
 174 int
 175 __pthread_internal_tsd_set (int key, const void * pointer)
 176 {
 177   pthread_descr self = thread_self();
 178
 179   THREAD_SETMEM_NC(self, p_libc_specific[key], (void *) pointer);
 180   return 0;
 181 }
 182
 183 void *
 184 __pthread_internal_tsd_get (int key)
 185 {
 186   pthread_descr self = thread_self();
 187
 188   return THREAD_GETMEM_NC(self, p_libc_specific[key]);
 189 }
 190
 191 void ** __attribute__ ((__const__))
 192 __pthread_internal_tsd_address (int key)
 193 {
 194   pthread_descr self = thread_self();
 195   return &self->p_libc_specific[key];
 196 }
 197
 198 #endif