1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #pragma ident "%Z%%M% %I% %E% SMI"
28
29 /*
30 * The structure of the sbrk backend:
31 *
32 * +-----------+
33 * | sbrk_top |
34 * +-----------+
35 * | (vmem_sbrk_alloc(), vmem_free())
36 * |
37 * +-----------+
38 * | sbrk_heap |
39 * +-----------+
40 * | | ... | (vmem_alloc(), vmem_free())
41 * <other arenas>
42 *
43 * The sbrk_top arena holds all controlled memory. vmem_sbrk_alloc() handles
44 * allocations from it, including growing the heap when we run low.
45 *
46 * Growing the heap is complicated by the fact that we have to extend the
47 * sbrk_top arena (using _vmem_extend_alloc()), and that can fail. Since
48 * other threads may be actively allocating, we can't return the memory.
49 *
50 * Instead, we put it on a doubly-linked list, sbrk_fails, which we search
51 * before calling sbrk().
52 */
53
54 #include <errno.h>
55 #include <limits.h>
56 #include <sys/sysmacros.h>
57 #include <sys/mman.h>
58 #include <unistd.h>
59
60 #include "vmem_base.h"
61
62 #include "misc.h"
63
64 size_t vmem_sbrk_pagesize = 0; /* the preferred page size of the heap */
65
66 #define VMEM_SBRK_MINALLOC (64 * 1024)
67 size_t vmem_sbrk_minalloc = VMEM_SBRK_MINALLOC; /* minimum allocation */
68
69 static size_t real_pagesize;
70 static vmem_t *sbrk_heap;
71
72 typedef struct sbrk_fail {
73 struct sbrk_fail *sf_next;
74 struct sbrk_fail *sf_prev;
75 void *sf_base; /* == the sbrk_fail's address */
76 size_t sf_size; /* the size of this buffer */
77 } sbrk_fail_t;
78
79 static sbrk_fail_t sbrk_fails = {
80 &sbrk_fails,
81 &sbrk_fails,
82 NULL,
83 0
84 };
85
86 static mutex_t sbrk_faillock = DEFAULTMUTEX;
87
88 /*
89 * Try to extend src with [pos, pos + size).
90 *
91 * If it fails, add the block to the sbrk_fails list.
92 */
93 static void *
vmem_sbrk_extend_alloc(vmem_t * src,void * pos,size_t size,size_t alloc,int vmflags)94 vmem_sbrk_extend_alloc(vmem_t *src, void *pos, size_t size, size_t alloc,
95 int vmflags)
96 {
97 sbrk_fail_t *fnext, *fprev, *fp;
98 void *ret;
99
100 ret = _vmem_extend_alloc(src, pos, size, alloc, vmflags);
101 if (ret != NULL)
102 return (ret);
103
104 fp = (sbrk_fail_t *)pos;
105
106 ASSERT(sizeof (sbrk_fail_t) <= size);
107
108 fp->sf_base = pos;
109 fp->sf_size = size;
110
111 (void) mutex_lock(&sbrk_faillock);
112 fp->sf_next = fnext = &sbrk_fails;
113 fp->sf_prev = fprev = sbrk_fails.sf_prev;
114 fnext->sf_prev = fp;
115 fprev->sf_next = fp;
116 (void) mutex_unlock(&sbrk_faillock);
117
118 return (NULL);
119 }
120
121 /*
122 * Try to add at least size bytes to src, using the sbrk_fails list
123 */
124 static void *
vmem_sbrk_tryfail(vmem_t * src,size_t size,int vmflags)125 vmem_sbrk_tryfail(vmem_t *src, size_t size, int vmflags)
126 {
127 sbrk_fail_t *fp;
128
129 (void) mutex_lock(&sbrk_faillock);
130 for (fp = sbrk_fails.sf_next; fp != &sbrk_fails; fp = fp->sf_next) {
131 if (fp->sf_size >= size) {
132 fp->sf_next->sf_prev = fp->sf_prev;
133 fp->sf_prev->sf_next = fp->sf_next;
134 fp->sf_next = fp->sf_prev = NULL;
135 break;
136 }
137 }
138 (void) mutex_unlock(&sbrk_faillock);
139
140 if (fp != &sbrk_fails) {
141 ASSERT(fp->sf_base == (void *)fp);
142 return (vmem_sbrk_extend_alloc(src, fp, fp->sf_size, size,
143 vmflags));
144 }
145 /*
146 * nothing of the right size on the freelist
147 */
148 return (NULL);
149 }
150
151 static void *
vmem_sbrk_alloc(vmem_t * src,size_t size,int vmflags)152 vmem_sbrk_alloc(vmem_t *src, size_t size, int vmflags)
153 {
154 extern void *_sbrk_grow_aligned(size_t min_size, size_t low_align,
155 size_t high_align, size_t *actual_size);
156
157 void *ret;
158 void *buf;
159 size_t buf_size;
160
161 int old_errno = errno;
162
163 ret = vmem_alloc(src, size, VM_NOSLEEP);
164 if (ret != NULL) {
165 errno = old_errno;
166 return (ret);
167 }
168
169 /*
170 * The allocation failed. We need to grow the heap.
171 *
172 * First, try to use any buffers which failed earlier.
173 */
174 if (sbrk_fails.sf_next != &sbrk_fails &&
175 (ret = vmem_sbrk_tryfail(src, size, vmflags)) != NULL)
176 return (ret);
177
178 buf_size = MAX(size, vmem_sbrk_minalloc);
179
180 /*
181 * buf_size gets overwritten with the actual allocated size
182 */
183 buf = _sbrk_grow_aligned(buf_size, real_pagesize, vmem_sbrk_pagesize,
184 &buf_size);
185
186 if (buf != MAP_FAILED) {
187 ret = vmem_sbrk_extend_alloc(src, buf, buf_size, size, vmflags);
188 if (ret != NULL) {
189 errno = old_errno;
190 return (ret);
191 }
192 }
193
194 /*
195 * Growing the heap failed. The vmem_alloc() above called umem_reap().
196 */
197 ASSERT((vmflags & VM_NOSLEEP) == VM_NOSLEEP);
198
199 errno = old_errno;
200 return (NULL);
201 }
202
203 /*
204 * fork1() support
205 */
206 void
vmem_sbrk_lockup(void)207 vmem_sbrk_lockup(void)
208 {
209 (void) mutex_lock(&sbrk_faillock);
210 }
211
212 void
vmem_sbrk_release(void)213 vmem_sbrk_release(void)
214 {
215 (void) mutex_unlock(&sbrk_faillock);
216 }
217
218 vmem_t *
vmem_sbrk_arena(vmem_alloc_t ** a_out,vmem_free_t ** f_out)219 vmem_sbrk_arena(vmem_alloc_t **a_out, vmem_free_t **f_out)
220 {
221 if (sbrk_heap == NULL) {
222 size_t heap_size;
223
224 real_pagesize = sysconf(_SC_PAGESIZE);
225
226 heap_size = vmem_sbrk_pagesize;
227
228 if (issetugid()) {
229 heap_size = 0;
230 } else if (heap_size != 0 && !ISP2(heap_size)) {
231 heap_size = 0;
232 log_message("ignoring bad pagesize: 0x%p\n", heap_size);
233 }
234 if (heap_size <= real_pagesize) {
235 heap_size = real_pagesize;
236 } else {
237 struct memcntl_mha mha;
238 mha.mha_cmd = MHA_MAPSIZE_BSSBRK;
239 mha.mha_flags = 0;
240 mha.mha_pagesize = heap_size;
241
242 if (memcntl(NULL, 0, MC_HAT_ADVISE, (char *)&mha, 0, 0)
243 == -1) {
244 log_message("unable to set MAPSIZE_BSSBRK to "
245 "0x%p\n", heap_size);
246 heap_size = real_pagesize;
247 }
248 }
249 vmem_sbrk_pagesize = heap_size;
250
251 /* validate vmem_sbrk_minalloc */
252 if (vmem_sbrk_minalloc < VMEM_SBRK_MINALLOC)
253 vmem_sbrk_minalloc = VMEM_SBRK_MINALLOC;
254 vmem_sbrk_minalloc = P2ROUNDUP(vmem_sbrk_minalloc, heap_size);
255
256 sbrk_heap = vmem_init("sbrk_top", real_pagesize,
257 vmem_sbrk_alloc, vmem_free,
258 "sbrk_heap", NULL, 0, real_pagesize,
259 vmem_alloc, vmem_free);
260 }
261
262 if (a_out != NULL)
263 *a_out = vmem_alloc;
264 if (f_out != NULL)
265 *f_out = vmem_free;
266
267 return (sbrk_heap);
268 }
269