src/system/libroot/posix/pthread/pthread_key.cpp

   1 /*
   2  * Copyright 2008, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
   3  * Distributed under the terms of the MIT License.
   4  */
   5
   6
   7 #include "pthread_private.h"
   8
   9 #include <limits.h>
  10 #include <stdlib.h>
  11
  12
  13 static pthread_key sKeyTable[PTHREAD_KEYS_MAX];
  14 static int32 sNextSequence = 1;
  15
  16
  17 /*!     Retrieves the destructor of a key locklessly.
  18         Returns the destructor's sequence in \a sequence.
  19 */
  20 static pthread_key_destructor
  21 get_key_destructor(uint32 key, int32& sequence)
  22 {
  23         pthread_key_destructor destructor = NULL;
  24
  25         do {
  26                 sequence = sKeyTable[key].sequence;
  27                 if (sequence == PTHREAD_UNUSED_SEQUENCE)
  28                         return NULL;
  29
  30                 destructor = sKeyTable[key].destructor;
  31         } while (sKeyTable[key].sequence != sequence);
  32
  33         return destructor;
  34 }
  35
  36
  37 /*!     Function to get the thread specific value of a key in a lockless
  38         way.
  39         \a sequence must be the sequence of the key table that this value
  40         has to fit to.
  41 */
  42 static void*
  43 get_key_value(pthread_thread* thread, uint32 key, int32 sequence)
  44 {
  45         pthread_key_data& keyData = thread->specific[key];
  46         int32 specificSequence;
  47         void* value;
  48
  49         do {
  50                 specificSequence = keyData.sequence;
  51                 if (specificSequence != sequence)
  52                         return NULL;
  53
  54                 value = keyData.value;
  55         } while (specificSequence != sequence);
  56
  57         return value;
  58 }
  59
  60
  61 void
  62 __pthread_key_call_destructors(pthread_thread* thread)
  63 {
  64         for (uint32 key = 0; key < PTHREAD_KEYS_MAX; key++) {
  65                 int32 sequence;
  66                 pthread_key_destructor destructor = get_key_destructor(key, sequence);
  67                 void* value = get_key_value(thread, key, sequence);
  68
  69                 if (value != NULL && destructor != NULL)
  70                         destructor(value);
  71         }
  72 }
  73
  74
  75 //      #pragma mark - public API
  76
  77
  78 int
  79 pthread_key_create(pthread_key_t* _key, void (*destructor)(void*))
  80 {
  81         int32 nextSequence = atomic_add(&sNextSequence, 1);
  82
  83         for (uint32 key = 0; key < PTHREAD_KEYS_MAX; key++) {
  84                 int32 sequence = sKeyTable[key].sequence;
  85                 if (sequence != PTHREAD_UNUSED_SEQUENCE)
  86                         continue;
  87
  88                 // try to acquire this slot
  89
  90                 if (atomic_test_and_set(&sKeyTable[key].sequence, nextSequence,
  91                                 sequence) != sequence)
  92                         continue;
  93
  94                 sKeyTable[key].destructor = destructor;
  95                 *_key = key;
  96                 return 0;
  97         }
  98
  99         return EAGAIN;
 100 }
 101
 102
 103 int
 104 pthread_key_delete(pthread_key_t key)
 105 {
 106         if (key < 0 || key >= PTHREAD_KEYS_MAX)
 107                 return EINVAL;
 108
 109         int32 sequence = atomic_get_and_set(&sKeyTable[key].sequence,
 110                 PTHREAD_UNUSED_SEQUENCE);
 111         if (sequence == PTHREAD_UNUSED_SEQUENCE)
 112                 return EINVAL;
 113
 114         return 0;
 115 }
 116
 117
 118 void*
 119 pthread_getspecific(pthread_key_t key)
 120 {
 121         pthread_thread* thread = pthread_self();
 122
 123         if (key < 0 || key >= PTHREAD_KEYS_MAX)
 124                 return NULL;
 125
 126         // check if this key is used, and our value belongs to its current meaning
 127         int32 sequence = atomic_get(&sKeyTable[key].sequence);
 128         if (sequence == PTHREAD_UNUSED_SEQUENCE
 129                 || thread->specific[key].sequence != sequence)
 130                 return NULL;
 131
 132         return thread->specific[key].value;
 133 }
 134
 135
 136 int
 137 pthread_setspecific(pthread_key_t key, const void* value)
 138 {
 139         if (key < 0 || key >= PTHREAD_KEYS_MAX)
 140                 return EINVAL;
 141
 142         int32 sequence = atomic_get(&sKeyTable[key].sequence);
 143         if (sequence == PTHREAD_UNUSED_SEQUENCE)
 144                 return EINVAL;
 145
 146         pthread_key_data& keyData = pthread_self()->specific[key];
 147         keyData.sequence = sequence;
 148         keyData.value = const_cast<void*>(value);
 149         return 0;
 150 }
 151