linuxthreads/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 <errno.h>
  18 #include <stddef.h>
  19 #include <stdlib.h>
  20 #include "pthread.h"
  21 #include "internals.h"
  22 #include "spinlock.h"
  23 #include <bits/libc-lock.h>
  24
  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 strong_alias (__pthread_key_create, pthread_key_create)
  60
  61 /* Delete a key */
  62
  63 int pthread_key_delete(pthread_key_t key)
  64 {
  65   pthread_descr self = thread_self();
  66   pthread_descr th;
  67   unsigned int idx1st, idx2nd;
  68
  69   pthread_mutex_lock(&pthread_keys_mutex);
  70   if (key >= PTHREAD_KEYS_MAX || !pthread_keys[key].in_use) {
  71     pthread_mutex_unlock(&pthread_keys_mutex);
  72     return EINVAL;
  73   }
  74   pthread_keys[key].in_use = 0;
  75   pthread_keys[key].destr = NULL;
  76   /* Set the value of the key to NULL in all running threads, so
  77      that if the key is reallocated later by pthread_key_create, its
  78      associated values will be NULL in all threads. */
  79   idx1st = key / PTHREAD_KEY_2NDLEVEL_SIZE;
  80   idx2nd = key % PTHREAD_KEY_2NDLEVEL_SIZE;
  81   th = self;
  82   do {
  83     /* If the thread already is terminated don't modify the memory.  */
  84     if (!th->p_terminated) {
  85       /* pthread_exit() may try to free th->p_specific[idx1st] concurrently. */
  86       __pthread_lock(THREAD_GETMEM(th, p_lock), self);
  87       if (th->p_specific[idx1st] != NULL)
  88         th->p_specific[idx1st][idx2nd] = NULL;
  89       __pthread_unlock(THREAD_GETMEM(th, p_lock));
  90     }
  91     th = th->p_nextlive;
  92   } while (th != self);
  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 strong_alias (__pthread_setspecific, pthread_setspecific)
 118
 119 /* Get the value of a key */
 120
 121 void * __pthread_getspecific(pthread_key_t key)
 122 {
 123   pthread_descr self = thread_self();
 124   unsigned int idx1st, idx2nd;
 125
 126   if (key >= PTHREAD_KEYS_MAX)
 127     return NULL;
 128   idx1st = key / PTHREAD_KEY_2NDLEVEL_SIZE;
 129   idx2nd = key % PTHREAD_KEY_2NDLEVEL_SIZE;
 130   if (THREAD_GETMEM_NC(self, p_specific[idx1st]) == NULL
 131       || !pthread_keys[key].in_use)
 132     return NULL;
 133   return THREAD_GETMEM_NC(self, p_specific[idx1st])[idx2nd];
 134 }
 135 strong_alias (__pthread_getspecific, pthread_getspecific)
 136
 137 /* Call the destruction routines on all keys */
 138
 139 void __pthread_destroy_specifics()
 140 {
 141   pthread_descr self = thread_self();
 142   int i, j, round, found_nonzero;
 143   destr_function destr;
 144   void * data;
 145
 146   for (round = 0, found_nonzero = 1;
 147        found_nonzero && round < PTHREAD_DESTRUCTOR_ITERATIONS;
 148        round++) {
 149     found_nonzero = 0;
 150     for (i = 0; i < PTHREAD_KEY_1STLEVEL_SIZE; i++)
 151       if (THREAD_GETMEM_NC(self, p_specific[i]) != NULL)
 152         for (j = 0; j < PTHREAD_KEY_2NDLEVEL_SIZE; j++) {
 153           destr = pthread_keys[i * PTHREAD_KEY_2NDLEVEL_SIZE + j].destr;
 154           data = THREAD_GETMEM_NC(self, p_specific[i])[j];
 155           if (destr != NULL && data != NULL) {
 156             THREAD_GETMEM_NC(self, p_specific[i])[j] = NULL;
 157             destr(data);
 158             found_nonzero = 1;
 159           }
 160         }
 161   }
 162   __pthread_lock(THREAD_GETMEM(self, p_lock), self);
 163   for (i = 0; i < PTHREAD_KEY_1STLEVEL_SIZE; i++) {
 164     if (THREAD_GETMEM_NC(self, p_specific[i]) != NULL) {
 165       free(THREAD_GETMEM_NC(self, p_specific[i]));
 166       THREAD_SETMEM_NC(self, p_specific[i], NULL);
 167     }
 168   }
 169   __pthread_unlock(THREAD_GETMEM(self, p_lock));
 170 }
 171
 172 /* Thread-specific data for libc. */
 173
 174 static int
 175 libc_internal_tsd_set(enum __libc_tsd_key_t 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 int (*__libc_internal_tsd_set)(enum __libc_tsd_key_t key, const void * pointer)
 183      = libc_internal_tsd_set;
 184
 185 static void *
 186 libc_internal_tsd_get(enum __libc_tsd_key_t key)
 187 {
 188   pthread_descr self = thread_self();
 189
 190   return THREAD_GETMEM_NC(self, p_libc_specific[key]);
 191 }
 192 void * (*__libc_internal_tsd_get)(enum __libc_tsd_key_t key)
 193      = libc_internal_tsd_get;