malloc.c 5.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181
  1. /*
  2. * libc/stdlib/malloc/malloc.c -- malloc function
  3. *
  4. * Copyright (C) 2002 NEC Corporation
  5. * Copyright (C) 2002 Miles Bader <miles@gnu.org>
  6. *
  7. * This file is subject to the terms and conditions of the GNU Lesser
  8. * General Public License. See the file COPYING.LIB in the main
  9. * directory of this archive for more details.
  10. *
  11. * Written by Miles Bader <miles@gnu.org>
  12. */
  13. #include <stdlib.h>
  14. #include <unistd.h>
  15. #include <sys/mman.h>
  16. #include "malloc.h"
  17. #include "heap.h"
  18. /* The malloc heap. We provide a bit of initial static space so that
  19. programs can do a little mallocing without mmaping in more space. */
  20. HEAP_DECLARE_STATIC_FREE_AREA (initial_fa, 256);
  21. struct heap __malloc_heap = HEAP_INIT_WITH_FA (initial_fa);
  22. #if defined(MALLOC_USE_LOCKING) && defined(MALLOC_USE_SBRK)
  23. /* A lock protecting our use of sbrk. */
  24. malloc_mutex_t __malloc_sbrk_lock;
  25. #endif /* MALLOC_USE_LOCKING && MALLOC_USE_SBRK */
  26. #ifdef MALLOC_DEBUGGING
  27. int __malloc_debug = 0;
  28. #endif
  29. #ifdef __UCLIBC_UCLINUX_BROKEN_MUNMAP__
  30. /* A list of all malloc_mmb structures describing blocsk that
  31. malloc has mmapped, ordered by the block address. */
  32. struct malloc_mmb *__malloc_mmapped_blocks = 0;
  33. /* A heap used for allocating malloc_mmb structures. We could allocate
  34. them from the main heap, but that tends to cause heap fragmentation in
  35. annoying ways. */
  36. HEAP_DECLARE_STATIC_FREE_AREA (initial_mmb_fa, 48); /* enough for 3 mmbs */
  37. struct heap __malloc_mmb_heap = HEAP_INIT_WITH_FA (initial_mmb_fa);
  38. # ifdef MALLOC_MMB_DEBUGGING
  39. int __malloc_mmb_debug = 0;
  40. # endif
  41. #endif /* __UCLIBC_UCLINUX_BROKEN_MUNMAP__ */
  42. static void *
  43. malloc_from_heap (size_t size, struct heap *heap)
  44. {
  45. void *mem;
  46. MALLOC_DEBUG ("malloc: %d bytes\n", size);
  47. /* Include extra space to record the size of the allocated block. */
  48. size += MALLOC_HEADER_SIZE;
  49. __heap_lock (heap);
  50. /* First try to get memory that's already in our heap. */
  51. mem = __heap_alloc (heap, &size);
  52. __heap_unlock (heap);
  53. if (unlikely (! mem))
  54. /* We couldn't allocate from the heap, so grab some more
  55. from the system, add it to the heap, and try again. */
  56. {
  57. /* If we're trying to allocate a block bigger than the default
  58. MALLOC_HEAP_EXTEND_SIZE, make sure we get enough to hold it. */
  59. void *block;
  60. size_t block_size
  61. = (size < MALLOC_HEAP_EXTEND_SIZE
  62. ? MALLOC_HEAP_EXTEND_SIZE
  63. : MALLOC_ROUND_UP_TO_PAGE_SIZE (size));
  64. /* Allocate the new heap block. */
  65. #ifdef MALLOC_USE_SBRK
  66. __malloc_lock_sbrk ();
  67. /* Use sbrk we can, as it's faster than mmap, and guarantees
  68. contiguous allocation. */
  69. block = sbrk (block_size);
  70. if (likely (block != (void *)-1))
  71. {
  72. /* Because sbrk can return results of arbitrary
  73. alignment, align the result to a MALLOC_ALIGNMENT boundary. */
  74. long aligned_block = MALLOC_ROUND_UP ((long)block, MALLOC_ALIGNMENT);
  75. if (block != (void *)aligned_block)
  76. /* Have to adjust. We should only have to actually do this
  77. the first time (after which we will have aligned the brk
  78. correctly). */
  79. {
  80. /* Move the brk to reflect the alignment; our next allocation
  81. should start on exactly the right alignment. */
  82. sbrk (aligned_block - (long)block);
  83. block = (void *)aligned_block;
  84. }
  85. }
  86. __malloc_unlock_sbrk ();
  87. #else /* !MALLOC_USE_SBRK */
  88. /* Otherwise, use mmap. */
  89. block = mmap (0, block_size, PROT_READ | PROT_WRITE,
  90. MAP_SHARED | MAP_ANONYMOUS, 0, 0);
  91. #endif /* MALLOC_USE_SBRK */
  92. if (likely (block != (void *)-1))
  93. {
  94. #if !defined(MALLOC_USE_SBRK) && defined(__UCLIBC_UCLINUX_BROKEN_MUNMAP__)
  95. struct malloc_mmb *mmb, *prev_mmb, *new_mmb;
  96. #endif
  97. MALLOC_DEBUG (" adding memory: 0x%lx - 0x%lx (%d bytes)\n",
  98. (long)block, (long)block + block_size, block_size);
  99. /* Get back the heap lock. */
  100. __heap_lock (heap);
  101. /* Put BLOCK into the heap. */
  102. __heap_free (heap, block, block_size);
  103. /* Try again to allocate. */
  104. mem = __heap_alloc (heap, &size);
  105. __heap_unlock (heap);
  106. #if !defined(MALLOC_USE_SBRK) && defined(__UCLIBC_UCLINUX_BROKEN_MUNMAP__)
  107. /* Insert a record of BLOCK in sorted order into the
  108. __malloc_mmapped_blocks list. */
  109. for (prev_mmb = 0, mmb = __malloc_mmapped_blocks;
  110. mmb;
  111. prev_mmb = mmb, mmb = mmb->next)
  112. if (block < mmb->mem)
  113. break;
  114. new_mmb = malloc_from_heap (sizeof *new_mmb, &__malloc_mmb_heap);
  115. new_mmb->next = mmb;
  116. new_mmb->mem = block;
  117. new_mmb->size = block_size;
  118. if (prev_mmb)
  119. prev_mmb->next = new_mmb;
  120. else
  121. __malloc_mmapped_blocks = new_mmb;
  122. MALLOC_MMB_DEBUG (" new mmb at 0x%x: 0x%x[%d]\n",
  123. (unsigned)new_mmb,
  124. (unsigned)new_mmb->mem, block_size);
  125. #endif /* !MALLOC_USE_SBRK && __UCLIBC_UCLINUX_BROKEN_MUNMAP__ */
  126. }
  127. }
  128. if (likely (mem))
  129. /* Record the size of the block and get the user address. */
  130. {
  131. mem = MALLOC_SETUP (mem, size);
  132. MALLOC_DEBUG (" malloc: returning 0x%lx (base:0x%lx, total_size:%d)\n",
  133. (long)mem, (long)MALLOC_BASE(mem), (long)MALLOC_SIZE(mem));
  134. }
  135. return mem;
  136. }
  137. void *
  138. malloc (size_t size)
  139. {
  140. return malloc_from_heap (size, &__malloc_heap);
  141. }