lib/libmthread/key.c

   1 #include <minix/mthread.h>
   2 #include <string.h>
   3 #include "global.h"
   4 #include "proto.h"
   5
   6 static int keys_used = 0;
   7 static struct {
   8   int used;
   9   int nvalues;
  10   void *mvalue;
  11   void **value;
  12   void (*destr)(void *);
  13 } keys[MTHREAD_KEYS_MAX];
  14
  15 /*===========================================================================*
  16  *                              mthread_init_keys                            *
  17  *===========================================================================*/
  18 void mthread_init_keys(void)
  19 {
  20 /* Initialize the table of key entries.
  21  */
  22   mthread_key_t k;
  23
  24   for (k = 0; k < MTHREAD_KEYS_MAX; k++)
  25         keys[k].used = FALSE;
  26 }
  27
  28 /*===========================================================================*
  29  *                              mthread_key_create                           *
  30  *===========================================================================*/
  31 int mthread_key_create(mthread_key_t *key, void (*destructor)(void *))
  32 {
  33 /* Allocate a key.
  34  */
  35   mthread_key_t k;
  36
  37   MTHREAD_CHECK_INIT(); /* Make sure libmthread is initialized */
  38   keys_used = 1;
  39
  40   /* We do not yet allocate storage space for the values here, because we can
  41    * not estimate how many threads will be created in the common case that the
  42    * application creates keys before spawning threads.
  43    */
  44   for (k = 0; k < MTHREAD_KEYS_MAX; k++) {
  45         if (!keys[k].used) {
  46                 keys[k].used = TRUE;
  47                 keys[k].nvalues = 0;
  48                 keys[k].mvalue = NULL;
  49                 keys[k].value = NULL;
  50                 keys[k].destr = destructor;
  51                 *key = k;
  52
  53                 return(0);
  54         }
  55   }
  56
  57   return(EAGAIN);
  58 }
  59
  60 /*===========================================================================*
  61  *                              mthread_key_delete                           *
  62  *===========================================================================*/
  63 int mthread_key_delete(mthread_key_t key)
  64 {
  65 /* Free up a key, as well as any associated storage space.
  66  */
  67
  68   MTHREAD_CHECK_INIT(); /* Make sure libmthread is initialized */
  69
  70   if (key < 0 || key >= MTHREAD_KEYS_MAX || !keys[key].used)
  71         return(EINVAL);
  72
  73   free(keys[key].value);
  74
  75   keys[key].used = FALSE;
  76
  77   return(0);
  78 }
  79
  80 /*===========================================================================*
  81  *                              mthread_getspecific                          *
  82  *===========================================================================*/
  83 void *mthread_getspecific(mthread_key_t key)
  84 {
  85 /* Get this thread's local value for the given key. The default is NULL.
  86  */
  87
  88   MTHREAD_CHECK_INIT(); /* Make sure libmthread is initialized */
  89
  90   if (key < 0 || key >= MTHREAD_KEYS_MAX || !keys[key].used)
  91         return(NULL);
  92
  93   if (current_thread == MAIN_THREAD)
  94         return keys[key].mvalue;
  95
  96   if (current_thread < keys[key].nvalues)
  97         return(keys[key].value[current_thread]);
  98
  99   return(NULL);
 100 }
 101
 102 /*===========================================================================*
 103  *                              mthread_setspecific                          *
 104  *===========================================================================*/
 105 int mthread_setspecific(mthread_key_t key, void *value)
 106 {
 107 /* Set this thread's value for the given key. Allocate more resources as
 108  * necessary.
 109  */
 110   void **p;
 111
 112   MTHREAD_CHECK_INIT(); /* Make sure libmthread is initialized */
 113
 114   if (key < 0 || key >= MTHREAD_KEYS_MAX || !keys[key].used)
 115         return(EINVAL);
 116
 117   if (current_thread == MAIN_THREAD) {
 118         keys[key].mvalue = value;
 119
 120         return(0);
 121   }
 122
 123   if (current_thread >= keys[key].nvalues) {
 124         if (current_thread >= no_threads)
 125                 mthread_panic("Library state corrupt");
 126
 127         if ((p = (void **) realloc(keys[key].value,
 128                         sizeof(void*) * no_threads)) == NULL)
 129                 return(ENOMEM);
 130
 131         memset(&p[keys[key].nvalues], 0,
 132                 sizeof(void*) * (no_threads - keys[key].nvalues));
 133
 134         keys[key].nvalues = no_threads;
 135         keys[key].value = p;
 136   }
 137
 138   keys[key].value[current_thread] = value;
 139
 140   return(0);
 141 }
 142
 143 /*===========================================================================*
 144  *                              mthread_cleanup_values                       *
 145  *===========================================================================*/
 146 void mthread_cleanup_values(void)
 147 {
 148 /* Clean up all the values associated with an exiting thread, calling keys'
 149  * destruction procedures as appropriate.
 150  */
 151   mthread_key_t k;
 152   void *value;
 153   int found;
 154
 155   if (!keys_used) return;       /* Only clean up if we used any keys at all */
 156
 157   /* Any of the destructors may set a new value on any key, so we may have to
 158    * loop over the table of keys multiple times. This implementation has no
 159    * protection against infinite loops in this case.
 160    */
 161   do {
 162         found = FALSE;
 163
 164         for (k = 0; k < MTHREAD_KEYS_MAX; k++) {
 165                 if (!keys[k].used) continue;
 166                 if (keys[k].destr == NULL) continue;
 167
 168                 if (current_thread == MAIN_THREAD) {
 169                         value = keys[k].mvalue;
 170
 171                         keys[k].mvalue = NULL;
 172                 } else {
 173                         if (current_thread >= keys[k].nvalues) continue;
 174
 175                         value = keys[k].value[current_thread];
 176
 177                         keys[k].value[current_thread] = NULL;
 178                 }
 179
 180                 if (value != NULL) {
 181                         /* Note: calling mthread_exit() from a destructor
 182                          * causes undefined behavior.
 183                          */
 184                         keys[k].destr(value);
 185
 186                         found = TRUE;
 187                 }
 188         }
 189   } while (found);
 190 }