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