1#define JEMALLOC_TSD_C_ 2#include "jemalloc/internal/jemalloc_internal.h" 3 4/******************************************************************************/ 5/* Data. */ 6 7static unsigned ncleanups; 8static malloc_tsd_cleanup_t cleanups[MALLOC_TSD_CLEANUPS_MAX]; 9 10malloc_tsd_data(, , tsd_t, TSD_INITIALIZER) 11 12/******************************************************************************/ 13 14void * 15malloc_tsd_malloc(size_t size) 16{ 17 18 return (a0malloc(CACHELINE_CEILING(size))); 19} 20 21void 22malloc_tsd_dalloc(void *wrapper) 23{ 24 25 a0dalloc(wrapper); 26} 27 28void 29malloc_tsd_no_cleanup(void *arg) 30{ 31 32 not_reached(); 33} 34 35#if defined(JEMALLOC_MALLOC_THREAD_CLEANUP) || defined(_WIN32) 36#ifndef _WIN32 37JEMALLOC_EXPORT 38#endif 39void 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 61void 62malloc_tsd_cleanup_register(bool (*f)(void)) 63{ 64 65 assert(ncleanups < MALLOC_TSD_CLEANUPS_MAX); 66 cleanups[ncleanups] = f; 67 ncleanups++; 68} 69 70void 71tsd_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); 82MALLOC_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 109tsd_t * 110malloc_tsd_boot0(void) 111{ 112 tsd_t *tsd; 113 114 ncleanups = 0; 115 if (tsd_boot0()) 116 return (NULL); 117 tsd = tsd_fetch(); 118 *tsd_arenas_tdata_bypassp_get(tsd) = true; 119 return (tsd); 120} 121 122void 123malloc_tsd_boot1(void) 124{ 125 126 tsd_boot1(); 127 *tsd_arenas_tdata_bypassp_get(tsd_fetch()) = false; 128} 129 130#ifdef _WIN32 131static BOOL WINAPI 132_tls_callback(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) 133{ 134 135 switch (fdwReason) { 136#ifdef JEMALLOC_LAZY_LOCK 137 case DLL_THREAD_ATTACH: 138 isthreaded = true; 139 break; 140#endif 141 case DLL_THREAD_DETACH: 142 _malloc_thread_cleanup(); 143 break; 144 default: 145 break; 146 } 147 return (true); 148} 149 150#ifdef _MSC_VER 151# ifdef _M_IX86 152# pragma comment(linker, "/INCLUDE:__tls_used") 153# pragma comment(linker, "/INCLUDE:_tls_callback") 154# else 155# pragma comment(linker, "/INCLUDE:_tls_used") 156# pragma comment(linker, "/INCLUDE:tls_callback") 157# endif 158# pragma section(".CRT$XLY",long,read) 159#endif 160JEMALLOC_SECTION(".CRT$XLY") JEMALLOC_ATTR(used) 161BOOL (WINAPI *const tls_callback)(HINSTANCE hinstDLL, 162 DWORD fdwReason, LPVOID lpvReserved) = _tls_callback; 163#endif 164 165#if (!defined(JEMALLOC_MALLOC_THREAD_CLEANUP) && !defined(JEMALLOC_TLS) && \ 166 !defined(_WIN32)) 167void * 168tsd_init_check_recursion(tsd_init_head_t *head, tsd_init_block_t *block) 169{ 170 pthread_t self = pthread_self(); 171 tsd_init_block_t *iter; 172 173 /* Check whether this thread has already inserted into the list. */ 174 malloc_mutex_lock(NULL, &head->lock); 175 ql_foreach(iter, &head->blocks, link) { 176 if (iter->thread == self) { 177 malloc_mutex_unlock(NULL, &head->lock); 178 return (iter->data); 179 } 180 } 181 /* Insert block into list. */ 182 ql_elm_new(block, link); 183 block->thread = self; 184 ql_tail_insert(&head->blocks, block, link); 185 malloc_mutex_unlock(NULL, &head->lock); 186 return (NULL); 187} 188 189void 190tsd_init_finish(tsd_init_head_t *head, tsd_init_block_t *block) 191{ 192 193 malloc_mutex_lock(NULL, &head->lock); 194 ql_remove(&head->blocks, block, link); 195 malloc_mutex_unlock(NULL, &head->lock); 196} 197#endif 198