1 /* mmap.c -- Memory allocation with mmap.
2 Copyright (C) 2012-2014 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor, Google.
5 Redistribution and use in source and binary forms, with or without
6 modification, are permitted provided that the following conditions are
9 (1) Redistributions of source code must retain the above copyright
10 notice, this list of conditions and the following disclaimer.
12 (2) Redistributions in binary form must reproduce the above copyright
13 notice, this list of conditions and the following disclaimer in
14 the documentation and/or other materials provided with the
17 (3) The name of the author may not be used to
18 endorse or promote products derived from this software without
19 specific prior written permission.
21 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
22 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
23 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
24 DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
25 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
26 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
27 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
29 STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
30 IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
31 POSSIBILITY OF SUCH DAMAGE. */
39 #include <sys/types.h>
42 #include "backtrace.h"
45 /* Memory allocation on systems that provide anonymous mmap. This
46 permits the backtrace functions to be invoked from a signal
47 handler, assuming that mmap is async-signal safe. */
50 #define MAP_ANONYMOUS MAP_ANON
53 /* A list of free memory blocks. */
55 struct backtrace_freelist_struct
58 struct backtrace_freelist_struct *next;
59 /* Size of this block, including this structure. */
63 /* Free memory allocated by backtrace_alloc. */
66 backtrace_free_locked (struct backtrace_state *state, void *addr, size_t size)
68 /* Just leak small blocks. We don't have to be perfect. */
69 if (size >= sizeof (struct backtrace_freelist_struct))
71 struct backtrace_freelist_struct *p;
73 p = (struct backtrace_freelist_struct *) addr;
74 p->next = state->freelist;
80 /* Allocate memory like malloc. */
83 backtrace_alloc (struct backtrace_state *state,
84 size_t size, backtrace_error_callback error_callback,
89 struct backtrace_freelist_struct **pp;
96 /* If we can acquire the lock, then see if there is space on the
97 free list. If we can't acquire the lock, drop straight into
98 using mmap. __sync_lock_test_and_set returns the old state of
99 the lock, so we have acquired it if it returns 0. */
101 if (!state->threaded)
104 locked = __sync_lock_test_and_set (&state->lock_alloc, 1) == 0;
108 for (pp = &state->freelist; *pp != NULL; pp = &(*pp)->next)
110 if ((*pp)->size >= size)
112 struct backtrace_freelist_struct *p;
117 /* Round for alignment; we assume that no type we care about
118 is more than 8 bytes. */
119 size = (size + 7) & ~ (size_t) 7;
121 backtrace_free_locked (state, (char *) p + size,
131 __sync_lock_release (&state->lock_alloc);
136 /* Allocate a new page. */
138 pagesize = getpagesize ();
139 asksize = (size + pagesize - 1) & ~ (pagesize - 1);
140 page = mmap (NULL, asksize, PROT_READ | PROT_WRITE,
141 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
143 error_callback (data, "mmap", errno);
146 size = (size + 7) & ~ (size_t) 7;
148 backtrace_free (state, (char *) page + size, asksize - size,
149 error_callback, data);
158 /* Allocate memory like strdup. */
161 backtrace_strdup (struct backtrace_state *state, const char *str,
162 backtrace_error_callback error_callback,
174 size = strlen(str) + 1;
175 mem = backtrace_alloc (state, size, error_callback, data);
178 memcpy(mem, str, size);
185 /* Free memory allocated by backtrace_alloc. */
188 backtrace_free (struct backtrace_state *state, void *addr, size_t size,
189 backtrace_error_callback error_callback ATTRIBUTE_UNUSED,
190 void *data ATTRIBUTE_UNUSED)
194 /* If we can acquire the lock, add the new space to the free list.
195 If we can't acquire the lock, just leak the memory.
196 __sync_lock_test_and_set returns the old state of the lock, so we
197 have acquired it if it returns 0. */
199 if (!state->threaded)
202 locked = __sync_lock_test_and_set (&state->lock_alloc, 1) == 0;
206 backtrace_free_locked (state, addr, size);
209 __sync_lock_release (&state->lock_alloc);
213 /* Grow VEC by SIZE bytes. */
216 backtrace_vector_grow (struct backtrace_state *state,size_t size,
217 backtrace_error_callback error_callback,
218 void *data, struct backtrace_vector *vec)
228 pagesize = getpagesize ();
229 alc = vec->size + size;
232 else if (alc < pagesize)
239 alc = (alc + pagesize - 1) & ~ (pagesize - 1);
240 base = backtrace_alloc (state, alc, error_callback, data);
243 if (vec->base != NULL)
245 memcpy (base, vec->base, vec->size);
246 backtrace_free (state, vec->base, vec->alc, error_callback, data);
249 vec->alc = alc - vec->size;
252 ret = (char *) vec->base + vec->size;
258 /* Finish the current allocation on VEC. */
261 backtrace_vector_finish (
262 struct backtrace_state *state ATTRIBUTE_UNUSED,
263 struct backtrace_vector *vec,
264 backtrace_error_callback error_callback ATTRIBUTE_UNUSED,
265 void *data ATTRIBUTE_UNUSED)
270 vec->base = (char *) vec->base + vec->size;
275 /* Release any extra space allocated for VEC. */
278 backtrace_vector_release (struct backtrace_state *state,
279 struct backtrace_vector *vec,
280 backtrace_error_callback error_callback,
287 /* Make sure that the block that we free is aligned on an 8-byte
291 aligned = (size + 7) & ~ (size_t) 7;
292 alc -= aligned - size;
294 backtrace_free (state, (char *) vec->base + aligned, alc,
295 error_callback, data);