1 #define JEMALLOC_CHUNK_DSS_C_
2 #include "jemalloc/internal/jemalloc_internal.h"
3 /******************************************************************************/
4 /* Data. */
5
6 const char *dss_prec_names[] = {
7 "disabled",
8 "primary",
9 "secondary",
10 "N/A"
11 };
12
13 /* Current dss precedence default, used when creating new arenas. */
14 static dss_prec_t dss_prec_default = DSS_PREC_DEFAULT;
15
16 /*
17 * Protects sbrk() calls. This avoids malloc races among threads, though it
18 * does not protect against races with threads that call sbrk() directly.
19 */
20 static malloc_mutex_t dss_mtx;
21
22 /* Base address of the DSS. */
23 static void *dss_base;
24 /* Current end of the DSS, or ((void *)-1) if the DSS is exhausted. */
25 static void *dss_prev;
26 /* Current upper limit on DSS addresses. */
27 static void *dss_max;
28
29 /******************************************************************************/
30
31 static void *
chunk_dss_sbrk(intptr_t increment)32 chunk_dss_sbrk(intptr_t increment)
33 {
34
35 #ifdef JEMALLOC_HAVE_SBRK
36 return (sbrk(increment));
37 #else
38 not_implemented();
39 return (NULL);
40 #endif
41 }
42
43 dss_prec_t
chunk_dss_prec_get(void)44 chunk_dss_prec_get(void)
45 {
46 dss_prec_t ret;
47
48 if (config_dss == false)
49 return (dss_prec_disabled);
50 malloc_mutex_lock(&dss_mtx);
51 ret = dss_prec_default;
52 malloc_mutex_unlock(&dss_mtx);
53 return (ret);
54 }
55
56 bool
chunk_dss_prec_set(dss_prec_t dss_prec)57 chunk_dss_prec_set(dss_prec_t dss_prec)
58 {
59
60 if (config_dss == false)
61 return (true);
62 malloc_mutex_lock(&dss_mtx);
63 dss_prec_default = dss_prec;
64 malloc_mutex_unlock(&dss_mtx);
65 return (false);
66 }
67
68 void *
chunk_alloc_dss(size_t size,size_t alignment,bool * zero)69 chunk_alloc_dss(size_t size, size_t alignment, bool *zero)
70 {
71 void *ret;
72
73 cassert(config_dss);
74 assert(size > 0 && (size & chunksize_mask) == 0);
75 assert(alignment > 0 && (alignment & chunksize_mask) == 0);
76
77 /*
78 * sbrk() uses a signed increment argument, so take care not to
79 * interpret a huge allocation request as a negative increment.
80 */
81 if ((intptr_t)size < 0)
82 return (NULL);
83
84 malloc_mutex_lock(&dss_mtx);
85 if (dss_prev != (void *)-1) {
86 size_t gap_size, cpad_size;
87 void *cpad, *dss_next;
88 intptr_t incr;
89
90 /*
91 * The loop is necessary to recover from races with other
92 * threads that are using the DSS for something other than
93 * malloc.
94 */
95 do {
96 /* Get the current end of the DSS. */
97 dss_max = chunk_dss_sbrk(0);
98 /*
99 * Calculate how much padding is necessary to
100 * chunk-align the end of the DSS.
101 */
102 gap_size = (chunksize - CHUNK_ADDR2OFFSET(dss_max)) &
103 chunksize_mask;
104 /*
105 * Compute how much chunk-aligned pad space (if any) is
106 * necessary to satisfy alignment. This space can be
107 * recycled for later use.
108 */
109 cpad = (void *)((uintptr_t)dss_max + gap_size);
110 ret = (void *)ALIGNMENT_CEILING((uintptr_t)dss_max,
111 alignment);
112 cpad_size = (uintptr_t)ret - (uintptr_t)cpad;
113 dss_next = (void *)((uintptr_t)ret + size);
114 if ((uintptr_t)ret < (uintptr_t)dss_max ||
115 (uintptr_t)dss_next < (uintptr_t)dss_max) {
116 /* Wrap-around. */
117 malloc_mutex_unlock(&dss_mtx);
118 return (NULL);
119 }
120 incr = gap_size + cpad_size + size;
121 dss_prev = chunk_dss_sbrk(incr);
122 if (dss_prev == dss_max) {
123 /* Success. */
124 dss_max = dss_next;
125 malloc_mutex_unlock(&dss_mtx);
126 if (cpad_size != 0)
127 chunk_unmap(cpad, cpad_size);
128 if (*zero) {
129 VALGRIND_MAKE_MEM_UNDEFINED(ret, size);
130 memset(ret, 0, size);
131 }
132 return (ret);
133 }
134 } while (dss_prev != (void *)-1);
135 }
136 malloc_mutex_unlock(&dss_mtx);
137
138 return (NULL);
139 }
140
141 bool
chunk_in_dss(void * chunk)142 chunk_in_dss(void *chunk)
143 {
144 bool ret;
145
146 cassert(config_dss);
147
148 malloc_mutex_lock(&dss_mtx);
149 if ((uintptr_t)chunk >= (uintptr_t)dss_base
150 && (uintptr_t)chunk < (uintptr_t)dss_max)
151 ret = true;
152 else
153 ret = false;
154 malloc_mutex_unlock(&dss_mtx);
155
156 return (ret);
157 }
158
159 bool
chunk_dss_boot(void)160 chunk_dss_boot(void)
161 {
162
163 cassert(config_dss);
164
165 if (malloc_mutex_init(&dss_mtx))
166 return (true);
167 dss_base = chunk_dss_sbrk(0);
168 dss_prev = dss_base;
169 dss_max = dss_base;
170
171 return (false);
172 }
173
174 void
chunk_dss_prefork(void)175 chunk_dss_prefork(void)
176 {
177
178 if (config_dss)
179 malloc_mutex_prefork(&dss_mtx);
180 }
181
182 void
chunk_dss_postfork_parent(void)183 chunk_dss_postfork_parent(void)
184 {
185
186 if (config_dss)
187 malloc_mutex_postfork_parent(&dss_mtx);
188 }
189
190 void
chunk_dss_postfork_child(void)191 chunk_dss_postfork_child(void)
192 {
193
194 if (config_dss)
195 malloc_mutex_postfork_child(&dss_mtx);
196 }
197
198 /******************************************************************************/
199