to debug the uClibc shared library loader early initialization,
answer Y. Mere mortals answer N.
+config UCLIBC_MALLOC_DEBUGGING
+ bool "Build malloc with debugging support"
+ depends MALLOC
+ default n
+ help
+ Answer Y here to compile extra debugging support code into malloc.
+ Malloc debugging output may then be enabled at runtime using
+ the MALLOC_DEBUG environment variable. Because this increases
+ the size of malloc appreciably (due to strings etc), you
+ should say N unless you need to debug a malloc problem.
+
endmenu
# calloc.c can be found at uClibc/libc/stdlib/calloc.c
CSRC = malloc.c free.c realloc.c memalign.c \
heap_alloc.c heap_alloc_at.c heap_free.c
+
+# Turn on malloc debugging if requested
+ifeq ($(UCLIBC_MALLOC_DEBUGGING),y)
+CSRC += malloc_debug.c heap_debug.c
+CFLAGS += -DMALLOC_DEBUGGING -DHEAP_DEBUGGING
+ifeq ($(UCLIBC_UCLINUX_BROKEN_MUNMAP),y)
+CFLAGS += -DMALLOC_MMB_DEBUGGING
+endif
+endif
+
COBJS=$(patsubst %.c,%.o, $(CSRC))
OBJS=$(COBJS)
ar-target: $(OBJS)
$(AR) $(ARFLAGS) $(LIBC) $(OBJS)
-$(COBJS): %.o : %.c
+# Depend on uClinux_config.h to cache changes in __UCLIBC_MALLOC_DEBUGGING__
+$(COBJS): %.o : %.c ../../../include/bits/uClibc_config.h
$(CC) $(CFLAGS) -c $< -o $@
$(STRIPTOOL) -x -R .note -R .comment $*.o
clean:
rm -f *.[oa] *~ core
-
/* Normal free. */
- MALLOC_DEBUG ("free: 0x%lx (base = 0x%lx, total_size = %d)\n",
+ MALLOC_DEBUG (1, "free: 0x%lx (base = 0x%lx, total_size = %d)",
(long)mem, (long)MALLOC_BASE (mem), MALLOC_SIZE (mem));
size = MALLOC_SIZE (mem);
reasonably cheap. */
if ((void *)end != sbrk (0))
{
- MALLOC_DEBUG (" not unmapping: 0x%lx - 0x%lx (%ld bytes)\n",
+ MALLOC_DEBUG (-1, "not unmapping: 0x%lx - 0x%lx (%ld bytes)",
start, end, end - start);
__malloc_unlock_sbrk ();
__heap_unlock (heap);
}
#endif
- MALLOC_DEBUG (" unmapping: 0x%lx - 0x%lx (%ld bytes)\n",
+ MALLOC_DEBUG (0, "unmapping: 0x%lx - 0x%lx (%ld bytes)",
start, end, end - start);
/* Remove FA from the heap. */
exactly as we got them from mmap, so scan through our list of
mmapped blocks, and return them in order. */
- MALLOC_MMB_DEBUG (" walking mmb list for region 0x%x[%d]...\n", start, end - start);
+ MALLOC_MMB_DEBUG (1, "walking mmb list for region 0x%x[%d]...",
+ start, end - start);
prev_mmb = 0;
mmb = __malloc_mmapped_blocks;
&& ((mmb_end = (mmb_start = (unsigned long)mmb->mem) + mmb->size)
<= end))
{
- MALLOC_MMB_DEBUG (" considering mmb at 0x%x: 0x%x[%d]\n",
+ MALLOC_MMB_DEBUG (1, "considering mmb at 0x%x: 0x%x[%d]",
(unsigned)mmb, mmb_start, mmb_end - mmb_start);
if (mmb_start >= start
this block, so give up. */
break;
- MALLOC_MMB_DEBUG (" unmapping mmb at 0x%x: 0x%x[%d]\n",
+ MALLOC_MMB_DEBUG (1, "unmapping mmb at 0x%x: 0x%x[%d]",
(unsigned)mmb, mmb_start, mmb_end - mmb_start);
if (mmb_start != start)
/* We're going to unmap a part of the heap that begins after
start, so put the intervening region back into the heap. */
{
- MALLOC_MMB_DEBUG (" putting intervening region back into heap: 0x%x[%d]\n",
+ MALLOC_MMB_DEBUG (0, "putting intervening region back into heap: 0x%x[%d]",
start, mmb_start - start);
__heap_free (heap, (void *)start, mmb_start - start);
}
+ MALLOC_MMB_DEBUG_INDENT (-1);
+
/* Unlink MMB from the list. */
if (prev_mmb)
prev_mmb->next = next_mmb;
prev_mmb = mmb;
mmb = mmb->next;
}
+
+ MALLOC_MMB_DEBUG_INDENT (-1);
}
if (start != end)
/* Hmm, well there's something we couldn't unmap, so put it back
into the heap. */
{
- MALLOC_MMB_DEBUG (" putting tail region back into heap: 0x%x[%d]\n",
+ MALLOC_MMB_DEBUG (0, "putting tail region back into heap: 0x%x[%d]",
start, end - start);
__heap_free (heap, (void *)start, end - start);
}
+ MALLOC_MMB_DEBUG_INDENT (-1);
+
# else /* !__UCLIBC_UCLINUX_BROKEN_MUNMAP__ */
/* MEM/LEN may not be page-aligned, so we have to page-align them,
#endif /* MALLOC_USE_SBRK */
}
+
+ MALLOC_DEBUG_INDENT (-1);
}
void
#include <stdarg.h>
#include <string.h>
+#include "malloc.h"
#include "heap.h"
{
struct heap_free_area *fa;
for (fa = heap->free_areas; fa; fa = fa->next)
- fprintf (stderr,
- " 0x%lx: 0x%lx - 0x%lx (%d)\tP=0x%lx, N=0x%lx\n",
- (long)fa,
- (long)HEAP_FREE_AREA_START (fa),
- (long)HEAP_FREE_AREA_END (fa),
- fa->size,
- (long)fa->prev,
- (long)fa->next);
+ __malloc_debug_printf (0,
+ "0x%lx: 0x%lx - 0x%lx (%d)\tP=0x%lx, N=0x%lx",
+ (long)fa,
+ (long)HEAP_FREE_AREA_START (fa),
+ (long)HEAP_FREE_AREA_END (fa),
+ fa->size,
+ (long)fa->prev,
+ (long)fa->next);
}
/* Output a text representation of HEAP to stderr, labelling it with STR. */
recursed = 1;
- fprintf (stderr, " %s: heap @0x%lx:\n", str, (long)heap);
+ __malloc_debug_printf (1, "%s: heap @0x%lx:", str, (long)heap);
__heap_dump_freelist (heap);
+ __malloc_debug_indent (-1);
recursed = 0;
}
vfprintf (stderr, fmt, val);
va_end (val);
- fprintf (stderr, "\nheap dump:\n");
+ putc ('\n', stderr);
+
+ __malloc_debug_set_indent (0);
+ __malloc_debug_printf (1, "heap dump:");
__heap_dump_freelist (heap);
exit (22);
malloc_mutex_t __malloc_sbrk_lock;
#endif /* MALLOC_USE_LOCKING && MALLOC_USE_SBRK */
-#ifdef MALLOC_DEBUGGING
-int __malloc_debug = 0;
-#endif
-
#ifdef __UCLIBC_UCLINUX_BROKEN_MUNMAP__
/* A list of all malloc_mmb structures describing blocsk that
annoying ways. */
HEAP_DECLARE_STATIC_FREE_AREA (initial_mmb_fa, 48); /* enough for 3 mmbs */
struct heap __malloc_mmb_heap = HEAP_INIT_WITH_FA (initial_mmb_fa);
-
-# ifdef MALLOC_MMB_DEBUGGING
-int __malloc_mmb_debug = 0;
-# endif
#endif /* __UCLIBC_UCLINUX_BROKEN_MUNMAP__ */
{
void *mem;
- MALLOC_DEBUG ("malloc: %d bytes\n", size);
+ MALLOC_DEBUG (1, "malloc: %d bytes", size);
/* Include extra space to record the size of the allocated block. */
size += MALLOC_HEADER_SIZE;
struct malloc_mmb *mmb, *prev_mmb, *new_mmb;
#endif
- MALLOC_DEBUG (" adding memory: 0x%lx - 0x%lx (%d bytes)\n",
+ MALLOC_DEBUG (1, "adding system memroy to heap: 0x%lx - 0x%lx (%d bytes)",
(long)block, (long)block + block_size, block_size);
/* Get back the heap lock. */
/* Put BLOCK into the heap. */
__heap_free (heap, block, block_size);
+ MALLOC_DEBUG_INDENT (-1);
+
/* Try again to allocate. */
mem = __heap_alloc (heap, &size);
else
__malloc_mmapped_blocks = new_mmb;
- MALLOC_MMB_DEBUG (" new mmb at 0x%x: 0x%x[%d]\n",
+ MALLOC_MMB_DEBUG (0, "new mmb at 0x%x: 0x%x[%d]",
(unsigned)new_mmb,
(unsigned)new_mmb->mem, block_size);
#endif /* !MALLOC_USE_SBRK && __UCLIBC_UCLINUX_BROKEN_MUNMAP__ */
{
mem = MALLOC_SETUP (mem, size);
- MALLOC_DEBUG (" malloc: returning 0x%lx (base:0x%lx, total_size:%d)\n",
+ MALLOC_DEBUG (-1, "malloc: returning 0x%lx (base:0x%lx, total_size:%ld)",
(long)mem, (long)MALLOC_BASE(mem), (long)MALLOC_SIZE(mem));
}
+ else
+ MALLOC_DEBUG (-1, "malloc: returning 0");
return mem;
}
void *
malloc (size_t size)
{
+#ifdef MALLOC_DEBUGGING
+ static int debugging_initialized = 0;
+ if (! debugging_initialized)
+ {
+ debugging_initialized = 1;
+ __malloc_debug_init ();
+ }
+ if (__malloc_check)
+ __heap_check (&__malloc_heap, "malloc");
+#endif
+
return malloc_from_heap (size, &__malloc_heap);
}
about mmap block allocation/freeing by the `uclinux broken munmap' code
to stderr, when the variable __malloc_mmb_debug is set to true. */
#ifdef MALLOC_MMB_DEBUGGING
-#include <stdio.h>
+# include <stdio.h>
extern int __malloc_mmb_debug;
-#define MALLOC_MMB_DEBUG(fmt, args...) \
- (__malloc_mmb_debug ? fprintf (stderr, fmt , ##args) : 0)
+# define MALLOC_MMB_DEBUG(indent, fmt, args...) \
+ (__malloc_mmb_debug ? __malloc_debug_printf (indent, fmt , ##args) : 0)
+# define MALLOC_MMB_DEBUG_INDENT(indent) \
+ (__malloc_mmb_debug ? __malloc_debug_indent (indent) : 0)
+# ifndef MALLOC_DEBUGGING
+# define MALLOC_DEBUGGING
+# endif
#else /* !MALLOC_MMB_DEBUGGING */
-#define MALLOC_MMB_DEBUG(fmt, args...) (void)0
+# define MALLOC_MMB_DEBUG(fmt, args...) (void)0
+# define MALLOC_MMB_DEBUG_INDENT(indent) (void)0
#endif /* MALLOC_MMB_DEBUGGING */
#endif /* __UCLIBC_UCLINUX_BROKEN_MUNMAP__ */
/* Define MALLOC_DEBUGGING to cause malloc to emit debugging info to stderr
when the variable __malloc_debug is set to true. */
#ifdef MALLOC_DEBUGGING
-#include <stdio.h>
-extern int __malloc_debug;
-#define MALLOC_DEBUG(fmt, args...) \
- (__malloc_debug ? fprintf (stderr, fmt , ##args) : 0)
-#else
-#define MALLOC_DEBUG(fmt, args...) (void)0
-#endif
+
+extern int __malloc_debug, __malloc_check;
+
+# define MALLOC_DEBUG(indent, fmt, args...) \
+ (__malloc_debug ? __malloc_debug_printf (indent, fmt , ##args) : 0)
+# define MALLOC_DEBUG_INDENT(indent) \
+ (__malloc_debug ? __malloc_debug_indent (indent) : 0)
+
+extern int __malloc_debug_cur_indent;
+
+/* Print FMT and args indented at the current debug print level, followed
+ by a newline, and change the level by INDENT. */
+extern void __malloc_debug_printf (int indent, const char *fmt, ...);
+
+/* Change the current debug print level by INDENT. */
+#define __malloc_debug_indent(indent) (__malloc_debug_cur_indent += indent)
+
+/* Set the current debug print level to LEVEL. */
+#define __malloc_debug_set_indent(level) (__malloc_debug_cur_indent = level)
+
+#else /* !MALLOC_DEBUGGING */
+# define MALLOC_DEBUG(fmt, args...) (void)0
+# define MALLOC_DEBUG_INDENT(indent) (void)0
+#endif /* MALLOC_DEBUGGING */
/* Return SZ rounded down to POWER_OF_2_SIZE (which must be power of 2). */
--- /dev/null
+/*
+ * libc/stdlib/malloc/malloc_debug.c -- malloc debugging support
+ *
+ * Copyright (C) 2002 NEC Corporation
+ * Copyright (C) 2002 Miles Bader <miles@gnu.org>
+ *
+ * This file is subject to the terms and conditions of the GNU Lesser
+ * General Public License. See the file COPYING.LIB in the main
+ * directory of this archive for more details.
+ *
+ * Written by Miles Bader <miles@gnu.org>
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdarg.h>
+
+#include "malloc.h"
+#include "heap.h"
+
+#ifdef MALLOC_DEBUGGING
+int __malloc_debug = 0, __malloc_check = 0;
+#endif
+
+#ifdef MALLOC_MMB_DEBUGGING
+int __malloc_mmb_debug = 0;
+#endif
+
+/* Debugging output is indented this may levels. */
+int __malloc_debug_cur_indent = 0;
+
+
+/* Print FMT and args indented at the current debug print level, followed
+ by a newline, and change the level by INDENT. */
+void
+__malloc_debug_printf (int indent, const char *fmt, ...)
+{
+ int i;
+ va_list val;
+
+ for (i = 0; i < __malloc_debug_cur_indent; i++)
+ fputs (" ", stderr);
+
+ va_start (val, fmt);
+ vfprintf (stderr, fmt, val);
+ va_end (val);
+
+ putc ('\n', stderr);
+
+ __malloc_debug_indent (indent);
+}
+
+void
+__malloc_debug_init (void)
+{
+ char *ev = getenv ("MALLOC_DEBUG");
+ if (ev)
+ {
+ int val = atoi (ev);
+ if (val & 1)
+ __malloc_check = 1;
+
+#ifdef MALLOC_DEBUGGING
+ if (val & 2)
+ __malloc_debug = 1;
+#endif
+#ifdef MALLOC_MMB_DEBUGGING
+ if (val & 4)
+ __malloc_mmb_debug = 1;
+#endif
+
+#ifdef HEAP_DEBUGGING
+ if (val & 8)
+ __heap_debug = 1;
+#endif
+
+ if (val)
+ __malloc_debug_printf
+ (0, "malloc_debug: initialized to %d (check = %d, dump = %d, dump_mmb = %d, dump_heap = %d)",
+ val,
+ !!(val & 1), !!(val & 2),
+ !!(val & 4), !!(val & 8));
+ }
+}
allocation unit (SIZE is already guaranteed to be so).*/
new_size = HEAP_ADJUST_SIZE (new_size + MALLOC_HEADER_SIZE);
- MALLOC_DEBUG ("realloc: 0x%lx, %d (base = 0x%lx, total_size = %d)\n",
+ MALLOC_DEBUG (1, "realloc: 0x%lx, %d (base = 0x%lx, total_size = %d)",
(long)mem, new_size, (long)base_mem, size);
if (new_size > size)
}
if (mem)
- MALLOC_DEBUG (" realloc: returning 0x%lx"
- " (base:0x%lx, total_size:%d)\n",
+ MALLOC_DEBUG (-1, "realloc: returning 0x%lx (base:0x%lx, total_size:%d)",
(long)mem, (long)MALLOC_BASE(mem), (long)MALLOC_SIZE(mem));
+ else
+ MALLOC_DEBUG (-1, "realloc: returning 0");
return mem;
}
OSDN Git Service
