1 /* Malloc implementation for multiple threads without lock contention.
2 Copyright (C) 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Wolfram Gloger <wg@malloc.de>, 2001.
6 The GNU C Library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Lesser General Public License as
8 published by the Free Software Foundation; either version 2.1 of the
9 License, or (at your option) any later version.
11 The GNU C Library is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public
17 License along with the GNU C Library; see the file COPYING.LIB. If not,
18 write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
23 /* Compile-time constants. */
25 #define HEAP_MIN_SIZE (32*1024)
27 #define HEAP_MAX_SIZE (1024*1024) /* must be a power of two */
30 /* HEAP_MIN_SIZE and HEAP_MAX_SIZE limit the size of mmap()ed heaps
31 that are dynamically created for multi-threaded programs. The
32 maximum size must be a power of two, for fast determination of
33 which heap belongs to a chunk. It should be much larger than the
34 mmap threshold, so that requests with a size just below that
35 threshold can be fulfilled without creating too many heaps. */
39 #define THREAD_STATS 0
42 /* If THREAD_STATS is non-zero, some statistics on mutex locking are
45 /***************************************************************************/
47 #define top(ar_ptr) ((ar_ptr)->top)
49 /* A heap is a single contiguous memory region holding (coalesceable)
50 malloc_chunks. It is allocated with mmap() and always starts at an
51 address aligned to HEAP_MAX_SIZE. Not used unless compiling with
54 typedef struct _heap_info
{
55 mstate ar_ptr
; /* Arena for this heap. */
56 struct _heap_info
*prev
; /* Previous heap. */
57 size_t size
; /* Current size in bytes. */
58 size_t pad
; /* Make sure the following data is properly aligned. */
61 /* Thread specific data */
63 static tsd_key_t arena_key
;
64 static mutex_t list_lock
;
67 static int stat_n_heaps
;
68 #define THREAD_STAT(x) x
70 #define THREAD_STAT(x) do ; while(0)
73 /* Mapped memory in non-main arenas (reliable only for NO_THREADS). */
74 static unsigned long arena_mem
;
76 /* Already initialized? */
77 int __malloc_initialized
= -1;
79 /**************************************************************************/
83 /* arena_get() acquires an arena and locks the corresponding mutex.
84 First, try the one last locked successfully by this thread. (This
85 is the common case and handled with a macro for speed.) Then, loop
86 once over the circularly linked list of arenas. If no arena is
87 readily available, create a new one. In this latter case, `size'
88 is just a hint as to how much memory will be required immediately
91 #define arena_get(ptr, size) do { \
92 Void_t *vptr = NULL; \
93 ptr = (mstate)tsd_getspecific(arena_key, vptr); \
94 if(ptr && !mutex_trylock(&ptr->mutex)) { \
95 THREAD_STAT(++(ptr->stat_lock_direct)); \
97 ptr = arena_get2(ptr, (size)); \
100 /* find the heap and corresponding arena for a given ptr */
102 #define heap_for_ptr(ptr) \
103 ((heap_info *)((unsigned long)(ptr) & ~(HEAP_MAX_SIZE-1)))
104 #define arena_for_chunk(ptr) \
105 (chunk_non_main_arena(ptr) ? heap_for_ptr(ptr)->ar_ptr : &main_arena)
107 #else /* !USE_ARENAS */
109 /* There is only one arena, main_arena. */
112 #define arena_get(ar_ptr, sz) do { \
113 ar_ptr = &main_arena; \
114 if(!mutex_trylock(&ar_ptr->mutex)) \
115 ++(ar_ptr->stat_lock_direct); \
117 (void)mutex_lock(&ar_ptr->mutex); \
118 ++(ar_ptr->stat_lock_wait); \
122 #define arena_get(ar_ptr, sz) do { \
123 ar_ptr = &main_arena; \
124 (void)mutex_lock(&ar_ptr->mutex); \
127 #define arena_for_chunk(ptr) (&main_arena)
129 #endif /* USE_ARENAS */
131 /**************************************************************************/
135 /* atfork support. */
137 static __malloc_ptr_t (*save_malloc_hook
) (size_t __size
,
138 __const __malloc_ptr_t
);
139 # if !defined _LIBC || !defined USE_TLS || (defined SHARED && !USE___THREAD)
140 static __malloc_ptr_t (*save_memalign_hook
) (size_t __align
, size_t __size
,
141 __const __malloc_ptr_t
);
143 static void (*save_free_hook
) (__malloc_ptr_t __ptr
,
144 __const __malloc_ptr_t
);
145 static Void_t
* save_arena
;
147 /* Magic value for the thread-specific arena pointer when
148 malloc_atfork() is in use. */
150 #define ATFORK_ARENA_PTR ((Void_t*)-1)
152 /* The following hooks are used while the `atfork' handling mechanism
156 malloc_atfork(size_t sz
, const Void_t
*caller
)
161 tsd_getspecific(arena_key
, vptr
);
162 if(vptr
== ATFORK_ARENA_PTR
) {
163 /* We are the only thread that may allocate at all. */
164 if(save_malloc_hook
!= malloc_check
) {
165 return _int_malloc(&main_arena
, sz
);
169 victim
= _int_malloc(&main_arena
, sz
+1);
170 return mem2mem_check(victim
, sz
);
173 /* Suspend the thread until the `atfork' handlers have completed.
174 By that time, the hooks will have been reset as well, so that
175 mALLOc() can be used again. */
176 (void)mutex_lock(&list_lock
);
177 (void)mutex_unlock(&list_lock
);
178 return public_mALLOc(sz
);
183 free_atfork(Void_t
* mem
, const Void_t
*caller
)
187 mchunkptr p
; /* chunk corresponding to mem */
189 if (mem
== 0) /* free(0) has no effect */
192 p
= mem2chunk(mem
); /* do not bother to replicate free_check here */
195 if (chunk_is_mmapped(p
)) /* release mmapped memory. */
202 ar_ptr
= arena_for_chunk(p
);
203 tsd_getspecific(arena_key
, vptr
);
204 if(vptr
!= ATFORK_ARENA_PTR
)
205 (void)mutex_lock(&ar_ptr
->mutex
);
206 _int_free(ar_ptr
, mem
);
207 if(vptr
!= ATFORK_ARENA_PTR
)
208 (void)mutex_unlock(&ar_ptr
->mutex
);
211 /* The following two functions are registered via thread_atfork() to
212 make sure that the mutexes remain in a consistent state in the
213 fork()ed version of a thread. Also adapt the malloc and free hooks
214 temporarily, because the `atfork' handler mechanism may use
215 malloc/free internally (e.g. in LinuxThreads). */
218 ptmalloc_lock_all (void)
222 if(__malloc_initialized
< 1)
224 (void)mutex_lock(&list_lock
);
225 for(ar_ptr
= &main_arena
;;) {
226 (void)mutex_lock(&ar_ptr
->mutex
);
227 ar_ptr
= ar_ptr
->next
;
228 if(ar_ptr
== &main_arena
) break;
230 save_malloc_hook
= __malloc_hook
;
231 save_free_hook
= __free_hook
;
232 __malloc_hook
= malloc_atfork
;
233 __free_hook
= free_atfork
;
234 /* Only the current thread may perform malloc/free calls now. */
235 tsd_getspecific(arena_key
, save_arena
);
236 tsd_setspecific(arena_key
, ATFORK_ARENA_PTR
);
240 ptmalloc_unlock_all (void)
244 if(__malloc_initialized
< 1)
246 tsd_setspecific(arena_key
, save_arena
);
247 __malloc_hook
= save_malloc_hook
;
248 __free_hook
= save_free_hook
;
249 for(ar_ptr
= &main_arena
;;) {
250 (void)mutex_unlock(&ar_ptr
->mutex
);
251 ar_ptr
= ar_ptr
->next
;
252 if(ar_ptr
== &main_arena
) break;
254 (void)mutex_unlock(&list_lock
);
259 /* In LinuxThreads, unlocking a mutex in the child process after a
260 fork() is currently unsafe, whereas re-initializing it is safe and
261 does not leak resources. Therefore, a special atfork handler is
262 installed for the child. */
265 ptmalloc_unlock_all2 (void)
269 if(__malloc_initialized
< 1)
271 #if defined _LIBC || defined MALLOC_HOOKS
272 tsd_setspecific(arena_key
, save_arena
);
273 __malloc_hook
= save_malloc_hook
;
274 __free_hook
= save_free_hook
;
276 for(ar_ptr
= &main_arena
;;) {
277 mutex_init(&ar_ptr
->mutex
);
278 ar_ptr
= ar_ptr
->next
;
279 if(ar_ptr
== &main_arena
) break;
281 mutex_init(&list_lock
);
286 #define ptmalloc_unlock_all2 ptmalloc_unlock_all
290 #endif /* !defined NO_THREADS */
292 /* Initialization routine. */
295 extern char **_environ
;
299 next_env_entry (char ***position
)
301 char **current
= *position
;
304 while (*current
!= NULL
)
306 if (__builtin_expect ((*current
)[0] == 'M', 0)
307 && (*current
)[1] == 'A'
308 && (*current
)[2] == 'L'
309 && (*current
)[3] == 'L'
310 && (*current
)[4] == 'O'
311 && (*current
)[5] == 'C'
312 && (*current
)[6] == '_')
314 result
= &(*current
)[7];
316 /* Save current position for next visit. */
317 *position
= ++current
;
329 /* Set up basic state so that _int_malloc et al can work. */
331 ptmalloc_init_minimal (void)
333 #if DEFAULT_TOP_PAD != 0
334 mp_
.top_pad
= DEFAULT_TOP_PAD
;
336 mp_
.n_mmaps_max
= DEFAULT_MMAP_MAX
;
337 mp_
.mmap_threshold
= DEFAULT_MMAP_THRESHOLD
;
338 mp_
.trim_threshold
= DEFAULT_TRIM_THRESHOLD
;
339 mp_
.pagesize
= malloc_getpagesize
;
346 __failing_morecore (ptrdiff_t d
)
348 return (void *) MORECORE_FAILURE
;
352 # if defined SHARED && defined USE_TLS && !USE___THREAD
353 # include <stdbool.h>
355 /* This is called by __pthread_initialize_minimal when it needs to use
356 malloc to set up the TLS state. We cannot do the full work of
357 ptmalloc_init (below) until __pthread_initialize_minimal has finished,
358 so it has to switch to using the special startup-time hooks while doing
359 those allocations. */
361 __libc_malloc_pthread_startup (bool first_time
)
365 ptmalloc_init_minimal ();
366 save_malloc_hook
= __malloc_hook
;
367 save_memalign_hook
= __memalign_hook
;
368 save_free_hook
= __free_hook
;
369 __malloc_hook
= malloc_starter
;
370 __memalign_hook
= memalign_starter
;
371 __free_hook
= free_starter
;
375 __malloc_hook
= save_malloc_hook
;
376 __memalign_hook
= save_memalign_hook
;
377 __free_hook
= save_free_hook
;
393 if(__malloc_initialized
>= 0) return;
394 __malloc_initialized
= 0;
397 # if defined SHARED && defined USE_TLS && !USE___THREAD
398 /* ptmalloc_init_minimal may already have been called via
399 __libc_malloc_pthread_startup, above. */
400 if (mp_
.pagesize
== 0)
403 ptmalloc_init_minimal();
406 # if defined _LIBC && defined USE_TLS
407 /* We know __pthread_initialize_minimal has already been called,
408 and that is enough. */
412 /* With some threads implementations, creating thread-specific data
413 or initializing a mutex may call malloc() itself. Provide a
414 simple starter version (realloc() won't work). */
415 save_malloc_hook
= __malloc_hook
;
416 save_memalign_hook
= __memalign_hook
;
417 save_free_hook
= __free_hook
;
418 __malloc_hook
= malloc_starter
;
419 __memalign_hook
= memalign_starter
;
420 __free_hook
= free_starter
;
422 /* Initialize the pthreads interface. */
423 if (__pthread_initialize
!= NULL
)
424 __pthread_initialize();
425 # endif /* !defined _LIBC */
426 # endif /* !defined NO_STARTER */
427 #endif /* !defined NO_THREADS */
428 mutex_init(&main_arena
.mutex
);
429 main_arena
.next
= &main_arena
;
431 #if defined _LIBC && defined SHARED
432 /* In case this libc copy is in a non-default namespace, never use brk. */
435 if (_dl_addr (ptmalloc_init
, &di
, &l
, NULL
) != 0 && l
->l_ns
!= LM_ID_BASE
)
436 __morecore
= __failing_morecore
;
439 mutex_init(&list_lock
);
440 tsd_key_create(&arena_key
, NULL
);
441 tsd_setspecific(arena_key
, (Void_t
*)&main_arena
);
442 thread_atfork(ptmalloc_lock_all
, ptmalloc_unlock_all
, ptmalloc_unlock_all2
);
445 __malloc_hook
= save_malloc_hook
;
446 __memalign_hook
= save_memalign_hook
;
447 __free_hook
= save_free_hook
;
453 secure
= __libc_enable_secure
;
455 if (__builtin_expect (_environ
!= NULL
, 1))
457 char **runp
= _environ
;
460 while (__builtin_expect ((envline
= next_env_entry (&runp
)) != NULL
,
463 size_t len
= strcspn (envline
, "=");
465 if (envline
[len
] != '=')
466 /* This is a "MALLOC_" variable at the end of the string
467 without a '=' character. Ignore it since otherwise we
468 will access invalid memory below. */
474 if (memcmp (envline
, "CHECK_", 6) == 0)
478 if (! secure
&& memcmp (envline
, "TOP_PAD_", 8) == 0)
479 mALLOPt(M_TOP_PAD
, atoi(&envline
[9]));
482 if (! secure
&& memcmp (envline
, "MMAP_MAX_", 9) == 0)
483 mALLOPt(M_MMAP_MAX
, atoi(&envline
[10]));
488 if (memcmp (envline
, "TRIM_THRESHOLD_", 15) == 0)
489 mALLOPt(M_TRIM_THRESHOLD
, atoi(&envline
[16]));
490 else if (memcmp (envline
, "MMAP_THRESHOLD_", 15) == 0)
491 mALLOPt(M_MMAP_THRESHOLD
, atoi(&envline
[16]));
502 if((s
= getenv("MALLOC_TRIM_THRESHOLD_")))
503 mALLOPt(M_TRIM_THRESHOLD
, atoi(s
));
504 if((s
= getenv("MALLOC_TOP_PAD_")))
505 mALLOPt(M_TOP_PAD
, atoi(s
));
506 if((s
= getenv("MALLOC_MMAP_THRESHOLD_")))
507 mALLOPt(M_MMAP_THRESHOLD
, atoi(s
));
508 if((s
= getenv("MALLOC_MMAP_MAX_")))
509 mALLOPt(M_MMAP_MAX
, atoi(s
));
511 s
= getenv("MALLOC_CHECK_");
514 if(s
[0]) mALLOPt(M_CHECK_ACTION
, (int)(s
[0] - '0'));
515 if (check_action
!= 0)
516 __malloc_check_init();
518 if(__malloc_initialize_hook
!= NULL
)
519 (*__malloc_initialize_hook
)();
520 __malloc_initialized
= 1;
523 /* There are platforms (e.g. Hurd) with a link-time hook mechanism. */
524 #ifdef thread_atfork_static
525 thread_atfork_static(ptmalloc_lock_all
, ptmalloc_unlock_all
, \
526 ptmalloc_unlock_all2
)
531 /* Managing heaps and arenas (for concurrent threads) */
537 /* Print the complete contents of a single heap to stderr. */
541 dump_heap(heap_info
*heap
)
543 dump_heap(heap
) heap_info
*heap
;
549 fprintf(stderr
, "Heap %p, size %10lx:\n", heap
, (long)heap
->size
);
550 ptr
= (heap
->ar_ptr
!= (mstate
)(heap
+1)) ?
551 (char*)(heap
+ 1) : (char*)(heap
+ 1) + sizeof(struct malloc_state
);
552 p
= (mchunkptr
)(((unsigned long)ptr
+ MALLOC_ALIGN_MASK
) &
555 fprintf(stderr
, "chunk %p size %10lx", p
, (long)p
->size
);
556 if(p
== top(heap
->ar_ptr
)) {
557 fprintf(stderr
, " (top)\n");
559 } else if(p
->size
== (0|PREV_INUSE
)) {
560 fprintf(stderr
, " (fence)\n");
563 fprintf(stderr
, "\n");
568 #endif /* MALLOC_DEBUG > 1 */
570 /* If consecutive mmap (0, HEAP_MAX_SIZE << 1, ...) calls return decreasing
571 addresses as opposed to increasing, new_heap would badly fragment the
572 address space. In that case remember the second HEAP_MAX_SIZE part
573 aligned to HEAP_MAX_SIZE from last mmap (0, HEAP_MAX_SIZE << 1, ...)
574 call (if it is already aligned) and try to reuse it next time. We need
575 no locking for it, as kernel ensures the atomicity for us - worst case
576 we'll call mmap (addr, HEAP_MAX_SIZE, ...) for some value of addr in
577 multiple threads, but only one will succeed. */
578 static char *aligned_heap_area
;
580 /* Create a new heap. size is automatically rounded up to a multiple
586 new_heap(size_t size
, size_t top_pad
)
588 new_heap(size
, top_pad
) size_t size
, top_pad
;
591 size_t page_mask
= malloc_getpagesize
- 1;
596 if(size
+top_pad
< HEAP_MIN_SIZE
)
597 size
= HEAP_MIN_SIZE
;
598 else if(size
+top_pad
<= HEAP_MAX_SIZE
)
600 else if(size
> HEAP_MAX_SIZE
)
603 size
= HEAP_MAX_SIZE
;
604 size
= (size
+ page_mask
) & ~page_mask
;
606 /* A memory region aligned to a multiple of HEAP_MAX_SIZE is needed.
607 No swap space needs to be reserved for the following large
608 mapping (on Linux, this is the case for all non-writable mappings
611 if(aligned_heap_area
) {
612 p2
= (char *)MMAP(aligned_heap_area
, HEAP_MAX_SIZE
, PROT_NONE
,
613 MAP_PRIVATE
|MAP_NORESERVE
);
614 aligned_heap_area
= NULL
;
615 if (p2
!= MAP_FAILED
&& ((unsigned long)p2
& (HEAP_MAX_SIZE
-1))) {
616 munmap(p2
, HEAP_MAX_SIZE
);
620 if(p2
== MAP_FAILED
) {
621 p1
= (char *)MMAP(0, HEAP_MAX_SIZE
<<1, PROT_NONE
,
622 MAP_PRIVATE
|MAP_NORESERVE
);
623 if(p1
!= MAP_FAILED
) {
624 p2
= (char *)(((unsigned long)p1
+ (HEAP_MAX_SIZE
-1))
625 & ~(HEAP_MAX_SIZE
-1));
630 aligned_heap_area
= p2
+ HEAP_MAX_SIZE
;
631 munmap(p2
+ HEAP_MAX_SIZE
, HEAP_MAX_SIZE
- ul
);
633 /* Try to take the chance that an allocation of only HEAP_MAX_SIZE
634 is already aligned. */
635 p2
= (char *)MMAP(0, HEAP_MAX_SIZE
, PROT_NONE
, MAP_PRIVATE
|MAP_NORESERVE
);
638 if((unsigned long)p2
& (HEAP_MAX_SIZE
-1)) {
639 munmap(p2
, HEAP_MAX_SIZE
);
644 if(mprotect(p2
, size
, PROT_READ
|PROT_WRITE
) != 0) {
645 munmap(p2
, HEAP_MAX_SIZE
);
650 THREAD_STAT(stat_n_heaps
++);
654 /* Grow or shrink a heap. size is automatically rounded up to a
655 multiple of the page size if it is positive. */
659 grow_heap(heap_info
*h
, long diff
)
661 grow_heap(h
, diff
) heap_info
*h
; long diff
;
664 size_t page_mask
= malloc_getpagesize
- 1;
668 diff
= (diff
+ page_mask
) & ~page_mask
;
669 new_size
= (long)h
->size
+ diff
;
670 if(new_size
> HEAP_MAX_SIZE
)
672 if(mprotect((char *)h
+ h
->size
, diff
, PROT_READ
|PROT_WRITE
) != 0)
675 new_size
= (long)h
->size
+ diff
;
676 if(new_size
< (long)sizeof(*h
))
678 /* Try to re-map the extra heap space freshly to save memory, and
679 make it inaccessible. */
680 if((char *)MMAP((char *)h
+ new_size
, -diff
, PROT_NONE
,
681 MAP_PRIVATE
|MAP_FIXED
) == (char *) MAP_FAILED
)
683 /*fprintf(stderr, "shrink %p %08lx\n", h, new_size);*/
691 #define delete_heap(heap) \
693 if ((char *)(heap) + HEAP_MAX_SIZE == aligned_heap_area) \
694 aligned_heap_area = NULL; \
695 munmap((char*)(heap), HEAP_MAX_SIZE); \
701 heap_trim(heap_info
*heap
, size_t pad
)
703 heap_trim(heap
, pad
) heap_info
*heap
; size_t pad
;
706 mstate ar_ptr
= heap
->ar_ptr
;
707 unsigned long pagesz
= mp_
.pagesize
;
708 mchunkptr top_chunk
= top(ar_ptr
), p
, bck
, fwd
;
709 heap_info
*prev_heap
;
710 long new_size
, top_size
, extra
;
712 /* Can this heap go away completely? */
713 while(top_chunk
== chunk_at_offset(heap
, sizeof(*heap
))) {
714 prev_heap
= heap
->prev
;
715 p
= chunk_at_offset(prev_heap
, prev_heap
->size
- (MINSIZE
-2*SIZE_SZ
));
716 assert(p
->size
== (0|PREV_INUSE
)); /* must be fencepost */
718 new_size
= chunksize(p
) + (MINSIZE
-2*SIZE_SZ
);
719 assert(new_size
>0 && new_size
<(long)(2*MINSIZE
));
721 new_size
+= p
->prev_size
;
722 assert(new_size
>0 && new_size
<HEAP_MAX_SIZE
);
723 if(new_size
+ (HEAP_MAX_SIZE
- prev_heap
->size
) < pad
+ MINSIZE
+ pagesz
)
725 ar_ptr
->system_mem
-= heap
->size
;
726 arena_mem
-= heap
->size
;
729 if(!prev_inuse(p
)) { /* consolidate backward */
733 assert(((unsigned long)((char*)p
+ new_size
) & (pagesz
-1)) == 0);
734 assert( ((char*)p
+ new_size
) == ((char*)heap
+ heap
->size
) );
735 top(ar_ptr
) = top_chunk
= p
;
736 set_head(top_chunk
, new_size
| PREV_INUSE
);
737 /*check_chunk(ar_ptr, top_chunk);*/
739 top_size
= chunksize(top_chunk
);
740 extra
= ((top_size
- pad
- MINSIZE
+ (pagesz
-1))/pagesz
- 1) * pagesz
;
741 if(extra
< (long)pagesz
)
744 if(grow_heap(heap
, -extra
) != 0)
746 ar_ptr
->system_mem
-= extra
;
749 /* Success. Adjust top accordingly. */
750 set_head(top_chunk
, (top_size
- extra
) | PREV_INUSE
);
751 /*check_chunk(ar_ptr, top_chunk);*/
758 arena_get2(mstate a_tsd
, size_t size
)
760 arena_get2(a_tsd
, size
) mstate a_tsd
; size_t size
;
766 a
= a_tsd
= &main_arena
;
770 /* This can only happen while initializing the new arena. */
771 (void)mutex_lock(&main_arena
.mutex
);
772 THREAD_STAT(++(main_arena
.stat_lock_wait
));
777 /* Check the global, circularly linked list for available arenas. */
780 if(!mutex_trylock(&a
->mutex
)) {
781 THREAD_STAT(++(a
->stat_lock_loop
));
782 tsd_setspecific(arena_key
, (Void_t
*)a
);
788 /* If not even the list_lock can be obtained, try again. This can
789 happen during `atfork', or for example on systems where thread
790 creation makes it temporarily impossible to obtain _any_
792 if(mutex_trylock(&list_lock
)) {
796 (void)mutex_unlock(&list_lock
);
798 /* Nothing immediately available, so generate a new arena. */
799 a
= _int_new_arena(size
);
803 tsd_setspecific(arena_key
, (Void_t
*)a
);
804 mutex_init(&a
->mutex
);
805 mutex_lock(&a
->mutex
); /* remember result */
807 /* Add the new arena to the global list. */
808 (void)mutex_lock(&list_lock
);
809 a
->next
= main_arena
.next
;
810 atomic_write_barrier ();
812 (void)mutex_unlock(&list_lock
);
814 THREAD_STAT(++(a
->stat_lock_loop
));
818 /* Create a new arena with initial size "size". */
821 _int_new_arena(size_t size
)
826 unsigned long misalign
;
828 h
= new_heap(size
+ (sizeof(*h
) + sizeof(*a
) + MALLOC_ALIGNMENT
),
831 /* Maybe size is too large to fit in a single heap. So, just try
832 to create a minimally-sized arena and let _int_malloc() attempt
833 to deal with the large request via mmap_chunk(). */
834 h
= new_heap(sizeof(*h
) + sizeof(*a
) + MALLOC_ALIGNMENT
, mp_
.top_pad
);
838 a
= h
->ar_ptr
= (mstate
)(h
+1);
839 malloc_init_state(a
);
841 a
->system_mem
= a
->max_system_mem
= h
->size
;
842 arena_mem
+= h
->size
;
844 if((unsigned long)(mp_
.mmapped_mem
+ arena_mem
+ main_arena
.system_mem
) >
846 mp_
.max_total_mem
= mp_
.mmapped_mem
+ arena_mem
+ main_arena
.system_mem
;
849 /* Set up the top chunk, with proper alignment. */
850 ptr
= (char *)(a
+ 1);
851 misalign
= (unsigned long)chunk2mem(ptr
) & MALLOC_ALIGN_MASK
;
853 ptr
+= MALLOC_ALIGNMENT
- misalign
;
854 top(a
) = (mchunkptr
)ptr
;
855 set_head(top(a
), (((char*)h
+ h
->size
) - ptr
) | PREV_INUSE
);
860 #endif /* USE_ARENAS */