Merge pull request #1 from cesanta/improvements

Improve heap layout, and some refactoring.

test/Makefile

@@ -0,0 +1,33 @@
+
+all: test test_poison test_integrity test_poison_integrity
+
+INCDIRS = -I.. -I.
+
+test:
+	@echo NORMAL
+	gcc --std=c99 $(CFLAGS) $(INCDIRS) -g3 -m32 \
+	  ../umm_malloc.c umm_malloc_test.c \
+		-o test_umm
+	./test_umm
+
+test_poison:
+	@echo POISON
+	gcc --std=c99 $(CFLAGS) $(INCDIRS) -DUMM_POISON -g3 -m32 \
+	  ../umm_malloc.c umm_malloc_test.c \
+		-o test_umm
+	./test_umm
+
+test_integrity:
+	@echo INTEGRITY
+	gcc --std=c99 $(CFLAGS) $(INCDIRS) -DUMM_INTEGRITY_CHECK -g3 -m32 \
+	  ../umm_malloc.c umm_malloc_test.c \
+		-o test_umm
+	./test_umm
+
+test_poison_integrity:
+	@echo POISON + INTEGRITY
+	gcc --std=c99 $(CFLAGS) $(INCDIRS) -DUMM_POISON -DUMM_INTEGRITY_CHECK -g3 -m32 \
+	  ../umm_malloc.c umm_malloc_test.c \
+		-o test_umm
+	./test_umm
+

test/umm_malloc_cfg.h

@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) 2016 Cesanta Software Limited
+ * All rights reserved
+ */
+
+/*
+ * Smartjs-specific configuration for umm_malloc
+ */
+
+#ifndef _UMM_MALLOC_CFG_H
+#define _UMM_MALLOC_CFG_H
+
+/*
+ * There are a number of defines you can set at compile time that affect how
+ * the memory allocator will operate.
+ * You can set them in your config file umm_malloc_cfg.h.
+ * In GNU C, you also can set these compile time defines like this:
+ *
+ * -D UMM_TEST_MAIN
+ *
+ * Set this if you want to compile in the test suite at the end of this file.
+ *
+ * If you leave this define unset, then you might want to set another one:
+ *
+ * -D UMM_REDEFINE_MEM_FUNCTIONS
+ *
+ * If you leave this define unset, then the function names are left alone as
+ * umm_malloc() umm_free() and umm_realloc() so that they cannot be confused
+ * with the C runtime functions malloc() free() and realloc()
+ *
+ * If you do set this define, then the function names become malloc()
+ * free() and realloc() so that they can be used as the C runtime functions
+ * in an embedded environment.
+ *
+ * -D UMM_BEST_FIT (defualt)
+ *
+ * Set this if you want to use a best-fit algorithm for allocating new
+ * blocks
+ *
+ * -D UMM_FIRST_FIT
+ *
+ * Set this if you want to use a first-fit algorithm for allocating new
+ * blocks
+ *
+ * -D UMM_DBG_LOG_LEVEL=n
+ *
+ * Set n to a value from 0 to 6 depending on how verbose you want the debug
+ * log to be
+ *
+ * ----------------------------------------------------------------------------
+ *
+ * Support for this library in a multitasking environment is provided when
+ * you add bodies to the UMM_CRITICAL_ENTRY and UMM_CRITICAL_EXIT macros
+ * (see below)
+ *
+ * ----------------------------------------------------------------------------
+ */
+
+extern char test_umm_heap[];
+extern void umm_corruption(void);
+
+/* Start and end addresses of the heap */
+#define UMM_MALLOC_CFG__HEAP_ADDR (test_umm_heap)
+#define UMM_MALLOC_CFG__HEAP_SIZE 0x10000
+
+/* A couple of macros to make packing structures less compiler dependent */
+
+#define UMM_H_ATTPACKPRE
+#define UMM_H_ATTPACKSUF __attribute__((__packed__))
+
+/*
+ * Callback that is called whenever a heap corruption is detected
+ */
+#define UMM_HEAP_CORRUPTION_CB() umm_corruption();
+
+/*
+ * A couple of macros to make it easier to protect the memory allocator
+ * in a multitasking system. You should set these macros up to use whatever
+ * your system uses for this purpose. You can disable interrupts entirely, or
+ * just disable task switching - it's up to you
+ *
+ * NOTE WELL that these macros MUST be allowed to nest, because umm_free() is
+ * called from within umm_malloc()
+ */
+
+#define UMM_CRITICAL_ENTRY()
+#define UMM_CRITICAL_EXIT()
+
+/*
+ * -D UMM_INTEGRITY_CHECK :
+ *
+ * Enables heap integrity check before any heap operation. It affects
+ * performance, but does NOT consume extra memory.
+ *
+ * If integrity violation is detected, the message is printed and user-provided
+ * callback is called: `UMM_HEAP_CORRUPTION_CB()`
+ *
+ * Note that not all buffer overruns are detected: each buffer is aligned by
+ * 4 bytes, so there might be some trailing "extra" bytes which are not checked
+ * for corruption.
+ */
+/*
+#define UMM_INTEGRITY_CHECK
+*/
+
+/*
+ * -D UMM_POISON :
+ *
+ * Enables heap poisoning: add predefined value (poison) before and after each
+ * allocation, and check before each heap operation that no poison is
+ * corrupted.
+ *
+ * Other than the poison itself, we need to store exact user-requested length
+ * for each buffer, so that overrun by just 1 byte will be always noticed.
+ *
+ * Customizations:
+ *
+ *    UMM_POISON_SIZE_BEFORE:
+ *      Number of poison bytes before each block, e.g. 2
+ *    UMM_POISON_SIZE_AFTER:
+ *      Number of poison bytes after each block e.g. 2
+ *    UMM_POISONED_BLOCK_LEN_TYPE
+ *      Type of the exact buffer length, e.g. `short`
+ *
+ * NOTE: each allocated buffer is aligned by 4 bytes. But when poisoning is
+ * enabled, actual pointer returned to user is shifted by
+ * `(sizeof(UMM_POISONED_BLOCK_LEN_TYPE) + UMM_POISON_SIZE_BEFORE)`.
+ * It's your responsibility to make resulting pointers aligned appropriately.
+ *
+ * If poison corruption is detected, the message is printed and user-provided
+ * callback is called: `UMM_HEAP_CORRUPTION_CB()`
+ */
+/*
+#define UMM_POISON
+*/
+#define UMM_POISON_SIZE_BEFORE 4
+#define UMM_POISON_SIZE_AFTER 4
+#define UMM_POISONED_BLOCK_LEN_TYPE short
+
+#endif /* _UMM_MALLOC_CFG_H */