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
  23 /* Table of keys. */
  24
  25 static struct pthread_key_struct pthread_keys[PTHREAD_KEYS_MAX] =
  26   { { 0, NULL } };
  27
  28 /* For debugging purposes put the maximum number of keys in a variable.  */
  29 const int __linuxthreads_pthread_keys_max = PTHREAD_KEYS_MAX;
  30 const int __linuxthreads_pthread_key_2ndlevel_size = PTHREAD_KEY_2NDLEVEL_SIZE;
  31
  32 /* Mutex to protect access to pthread_keys */
  33
  34 static pthread_mutex_t pthread_keys_mutex = PTHREAD_MUTEX_INITIALIZER;
  35
  36 /* Create a new key */
  37
  38 int __pthread_key_create(pthread_key_t * key, destr_function destr)
  39 {
  40   int i;
  41
  42   pthread_mutex_lock(&pthread_keys_mutex);
  43   for (i = 0; i < PTHREAD_KEYS_MAX; i++) {
  44     if (! pthread_keys[i].in_use) {
  45       /* Mark key in use */
  46       pthread_keys[i].in_use = 1;
  47       pthread_keys[i].destr = destr;
  48       pthread_mutex_unlock(&pthread_keys_mutex);
  49       *key = i;
  50       return 0;
  51     }
  52   }
  53   pthread_mutex_unlock(&pthread_keys_mutex);
  54   return EAGAIN;
  55 }
  56 strong_alias (__pthread_key_create, pthread_key_create)
  57
  58 /* Delete a key */
  59
  60 int pthread_key_delete(pthread_key_t key)
  61 {
  62   pthread_descr self = thread_self();
  63   pthread_descr th;
  64   unsigned int idx1st, idx2nd;
  65
  66   pthread_mutex_lock(&pthread_keys_mutex);
  67   if (key >= PTHREAD_KEYS_MAX || !pthread_keys[key].in_use) {
  68     pthread_mutex_unlock(&pthread_keys_mutex);
  69     return EINVAL;
  70   }
  71   pthread_keys[key].in_use = 0;
  72   pthread_keys[key].destr = NULL;
  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   idx1st = key / PTHREAD_KEY_2NDLEVEL_SIZE;
  77   idx2nd = key % PTHREAD_KEY_2NDLEVEL_SIZE;
  78   th = self;
  79   do {
  80     /* If the thread already is terminated don't modify the memory.  */
  81     if (!th->p_terminated && th->p_specific[idx1st] != NULL)
  82       th->p_specific[idx1st][idx2nd] = NULL;
  83     th = th->p_nextlive;
  84   } while (th != self);
  85   pthread_mutex_unlock(&pthread_keys_mutex);
  86   return 0;
  87 }
  88
  89 /* Set the value of a key */
  90
  91 int __pthread_setspecific(pthread_key_t key, const void * pointer)
  92 {
  93   pthread_descr self = thread_self();
  94   unsigned int idx1st, idx2nd;
  95
  96   if (key >= PTHREAD_KEYS_MAX || !pthread_keys[key].in_use)
  97     return EINVAL;
  98   idx1st = key / PTHREAD_KEY_2NDLEVEL_SIZE;
  99   idx2nd = key % PTHREAD_KEY_2NDLEVEL_SIZE;
 100   if (THREAD_GETMEM_NC(self, p_specific[idx1st]) == NULL) {
 101     void *newp = calloc(PTHREAD_KEY_2NDLEVEL_SIZE, sizeof (void *));
 102     if (newp == NULL)
 103       return ENOMEM;
 104     THREAD_SETMEM_NC(self, p_specific[idx1st], newp);
 105   }
 106   THREAD_GETMEM_NC(self, p_specific[idx1st])[idx2nd] = (void *) pointer;
 107   return 0;
 108 }
 109 strong_alias (__pthread_setspecific, pthread_setspecific)
 110
 111 /* Get the value of a key */
 112
 113 void * __pthread_getspecific(pthread_key_t key)
 114 {
 115   pthread_descr self = thread_self();
 116   unsigned int idx1st, idx2nd;
 117
 118   if (key >= PTHREAD_KEYS_MAX)
 119     return NULL;
 120   idx1st = key / PTHREAD_KEY_2NDLEVEL_SIZE;
 121   idx2nd = key % PTHREAD_KEY_2NDLEVEL_SIZE;
 122   if (THREAD_GETMEM_NC(self, p_specific[idx1st]) == NULL
 123       || !pthread_keys[key].in_use)
 124     return NULL;
 125   return THREAD_GETMEM_NC(self, p_specific[idx1st])[idx2nd];
 126 }
 127 strong_alias (__pthread_getspecific, pthread_getspecific)
 128
 129 /* Call the destruction routines on all keys */
 130
 131 void __pthread_destroy_specifics()
 132 {
 133   pthread_descr self = thread_self();
 134   int i, j, round, found_nonzero;
 135   destr_function destr;
 136   void * data;
 137
 138   for (round = 0, found_nonzero = 1;
 139        found_nonzero && round < PTHREAD_DESTRUCTOR_ITERATIONS;
 140        round++) {
 141     found_nonzero = 0;
 142     for (i = 0; i < PTHREAD_KEY_1STLEVEL_SIZE; i++)
 143       if (THREAD_GETMEM_NC(self, p_specific[i]) != NULL)
 144         for (j = 0; j < PTHREAD_KEY_2NDLEVEL_SIZE; j++) {
 145           destr = pthread_keys[i * PTHREAD_KEY_2NDLEVEL_SIZE + j].destr;
 146           data = THREAD_GETMEM_NC(self, p_specific[i])[j];
 147           if (destr != NULL && data != NULL) {
 148             THREAD_GETMEM_NC(self, p_specific[i])[j] = NULL;
 149             destr(data);
 150             found_nonzero = 1;
 151           }
 152         }
 153   }
 154   for (i = 0; i < PTHREAD_KEY_1STLEVEL_SIZE; i++) {
 155     if (THREAD_GETMEM_NC(self, p_specific[i]) != NULL)
 156       free(THREAD_GETMEM_NC(self, p_specific[i]));
 157   }
 158 }
 159
 160 /* Thread-specific data for libc. */
 161
 162 static int
 163 libc_internal_tsd_set(enum __libc_tsd_key_t key, const void * pointer)
 164 {
 165   pthread_descr self = thread_self();
 166
 167   THREAD_SETMEM_NC(self, p_libc_specific[key], (void *) pointer);
 168   return 0;
 169 }
 170 int (*__libc_internal_tsd_set)(enum __libc_tsd_key_t key, const void * pointer)
 171      = libc_internal_tsd_set;
 172
 173 static void *
 174 libc_internal_tsd_get(enum __libc_tsd_key_t key)
 175 {
 176   pthread_descr self = thread_self();
 177
 178   return THREAD_GETMEM_NC(self, p_libc_specific[key]);
 179 }
 180 void * (*__libc_internal_tsd_get)(enum __libc_tsd_key_t key)
 181      = libc_internal_tsd_get;