contrib/jemalloc/src/tsd.c

   1 #define JEMALLOC_TSD_C_
   2 #include "jemalloc/internal/jemalloc_internal.h"
   3
   4 /******************************************************************************/
   5 /* Data. */
   6
   7 static unsigned ncleanups;
   8 static malloc_tsd_cleanup_t cleanups[MALLOC_TSD_CLEANUPS_MAX];
   9
  10 malloc_tsd_data(, , tsd_t, TSD_INITIALIZER)
  11
  12 /******************************************************************************/
  13
  14 void *
  15 malloc_tsd_malloc(size_t size)
  16 {
  17
  18         return (a0malloc(CACHELINE_CEILING(size)));
  19 }
  20
  21 void
  22 malloc_tsd_dalloc(void *wrapper)
  23 {
  24
  25         a0dalloc(wrapper);
  26 }
  27
  28 void
  29 malloc_tsd_no_cleanup(void *arg)
  30 {
  31
  32         not_reached();
  33 }
  34
  35 #if defined(JEMALLOC_MALLOC_THREAD_CLEANUP) || defined(_WIN32)
  36 #ifndef _WIN32
  37 JEMALLOC_EXPORT
  38 #endif
  39 void
  40 _malloc_thread_cleanup(void)
  41 {
  42         bool pending[MALLOC_TSD_CLEANUPS_MAX], again;
  43         unsigned i;
  44
  45         for (i = 0; i < ncleanups; i++)
  46                 pending[i] = true;
  47
  48         do {
  49                 again = false;
  50                 for (i = 0; i < ncleanups; i++) {
  51                         if (pending[i]) {
  52                                 pending[i] = cleanups[i]();
  53                                 if (pending[i])
  54                                         again = true;
  55                         }
  56                 }
  57         } while (again);
  58 }
  59 #endif
  60
  61 void
  62 malloc_tsd_cleanup_register(bool (*f)(void))
  63 {
  64
  65         assert(ncleanups < MALLOC_TSD_CLEANUPS_MAX);
  66         cleanups[ncleanups] = f;
  67         ncleanups++;
  68 }
  69
  70 void
  71 tsd_cleanup(void *arg)
  72 {
  73         tsd_t *tsd = (tsd_t *)arg;
  74
  75         switch (tsd->state) {
  76         case tsd_state_uninitialized:
  77                 /* Do nothing. */
  78                 break;
  79         case tsd_state_nominal:
  80 #define O(n, t)                                                         \
  81                 n##_cleanup(tsd);
  82 MALLOC_TSD
  83 #undef O
  84                 tsd->state = tsd_state_purgatory;
  85                 tsd_set(tsd);
  86                 break;
  87         case tsd_state_purgatory:
  88                 /*
  89                  * The previous time this destructor was called, we set the
  90                  * state to tsd_state_purgatory so that other destructors
  91                  * wouldn't cause re-creation of the tsd.  This time, do
  92                  * nothing, and do not request another callback.
  93                  */
  94                 break;
  95         case tsd_state_reincarnated:
  96                 /*
  97                  * Another destructor deallocated memory after this destructor
  98                  * was called.  Reset state to tsd_state_purgatory and request
  99                  * another callback.
 100                  */
 101                 tsd->state = tsd_state_purgatory;
 102                 tsd_set(tsd);
 103                 break;
 104         default:
 105                 not_reached();
 106         }
 107 }
 108
 109 bool
 110 malloc_tsd_boot0(void)
 111 {
 112
 113         ncleanups = 0;
 114         if (tsd_boot0())
 115                 return (true);
 116         *tsd_arenas_tdata_bypassp_get(tsd_fetch()) = true;
 117         return (false);
 118 }
 119
 120 void
 121 malloc_tsd_boot1(void)
 122 {
 123
 124         tsd_boot1();
 125         *tsd_arenas_tdata_bypassp_get(tsd_fetch()) = false;
 126 }
 127
 128 #ifdef _WIN32
 129 static BOOL WINAPI
 130 _tls_callback(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
 131 {
 132
 133         switch (fdwReason) {
 134 #ifdef JEMALLOC_LAZY_LOCK
 135         case DLL_THREAD_ATTACH:
 136                 isthreaded = true;
 137                 break;
 138 #endif
 139         case DLL_THREAD_DETACH:
 140                 _malloc_thread_cleanup();
 141                 break;
 142         default:
 143                 break;
 144         }
 145         return (true);
 146 }
 147
 148 #ifdef _MSC_VER
 149 #  ifdef _M_IX86
 150 #    pragma comment(linker, "/INCLUDE:__tls_used")
 151 #    pragma comment(linker, "/INCLUDE:_tls_callback")
 152 #  else
 153 #    pragma comment(linker, "/INCLUDE:_tls_used")
 154 #    pragma comment(linker, "/INCLUDE:tls_callback")
 155 #  endif
 156 #  pragma section(".CRT$XLY",long,read)
 157 #endif
 158 JEMALLOC_SECTION(".CRT$XLY") JEMALLOC_ATTR(used)
 159 BOOL    (WINAPI *const tls_callback)(HINSTANCE hinstDLL,
 160     DWORD fdwReason, LPVOID lpvReserved) = _tls_callback;
 161 #endif
 162
 163 #if (!defined(JEMALLOC_MALLOC_THREAD_CLEANUP) && !defined(JEMALLOC_TLS) && \
 164     !defined(_WIN32))
 165 void *
 166 tsd_init_check_recursion(tsd_init_head_t *head, tsd_init_block_t *block)
 167 {
 168         pthread_t self = pthread_self();
 169         tsd_init_block_t *iter;
 170
 171         /* Check whether this thread has already inserted into the list. */
 172         malloc_mutex_lock(&head->lock);
 173         ql_foreach(iter, &head->blocks, link) {
 174                 if (iter->thread == self) {
 175                         malloc_mutex_unlock(&head->lock);
 176                         return (iter->data);
 177                 }
 178         }
 179         /* Insert block into list. */
 180         ql_elm_new(block, link);
 181         block->thread = self;
 182         ql_tail_insert(&head->blocks, block, link);
 183         malloc_mutex_unlock(&head->lock);
 184         return (NULL);
 185 }
 186
 187 void
 188 tsd_init_finish(tsd_init_head_t *head, tsd_init_block_t *block)
 189 {
 190
 191         malloc_mutex_lock(&head->lock);
 192         ql_remove(&head->blocks, block, link);
 193         malloc_mutex_unlock(&head->lock);
 194 }
 195 #endif