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 * malloc_tsd_malloc(size_t size)15 malloc_tsd_malloc(size_t size) 16 { 17 18 return (a0malloc(CACHELINE_CEILING(size))); 19 } 20 21 void malloc_tsd_dalloc(void * wrapper)22 malloc_tsd_dalloc(void *wrapper) 23 { 24 25 a0dalloc(wrapper); 26 } 27 28 void malloc_tsd_no_cleanup(void * arg)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 _malloc_thread_cleanup(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 malloc_tsd_cleanup_register(bool (* f)(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 tsd_cleanup(void * arg)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 malloc_tsd_boot0(void)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 malloc_tsd_boot1(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 _tls_callback(HINSTANCE hinstDLL,DWORD fdwReason,LPVOID lpvReserved)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 * tsd_init_check_recursion(tsd_init_head_t * head,tsd_init_block_t * block)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 tsd_init_finish(tsd_init_head_t * head,tsd_init_block_t * block)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 196