Merge branch 'master' into signal-dev

[lunaix-os.git] / lunaix-os / kernel / mm / kalloc.c

diff --git a/lunaix-os/kernel/mm/kalloc.c b/lunaix-os/kernel/mm/kalloc.c
index 675a51f4033fe0191a5fba16c46e0f558e22f40e..e970c1d5ac96ad399102a28b7deca8818cff939b 100644 (file)
--- a/lunaix-os/kernel/mm/kalloc.c
+++ b/lunaix-os/kernel/mm/kalloc.c
@@ -14,17 +14,15 @@
 #include <lunaix/mm/kalloc.h>
 #include <lunaix/mm/dmm.h>
 
-#include <lunaix/constants.h>
+#include <lunaix/common.h>
 #include <lunaix/spike.h>
 
-#include <libc/string.h>
+#include <klibc/string.h>
 
 #include <stdint.h>
 
 extern uint8_t __kernel_heap_start;
 
-heap_context_t __kalloc_kheap;
-
 void*
 lx_malloc_internal(heap_context_t* heap, size_t size);
 
@@ -59,36 +57,49 @@ lx_grow_heap(heap_context_t* heap, size_t sz);
     Note: the brk always point to the beginning of epilogue.
 */
 
+static heap_context_t kheap;
+
 int
 kalloc_init() {
-    __kalloc_kheap.start = &__kernel_heap_start;
-    __kalloc_kheap.brk = NULL;
-    __kalloc_kheap.max_addr = (void*)K_STACK_START;
+    kheap.start = &__kernel_heap_start;
+    kheap.brk = NULL;
+    kheap.max_addr = (void*)KSTACK_START;
 
-    if (!dmm_init(&__kalloc_kheap)) {
+    if (!dmm_init(&kheap)) {
         return 0;
     }
 
-    SW(__kalloc_kheap.start, PACK(4, M_ALLOCATED));
-    SW(__kalloc_kheap.start + WSIZE, PACK(0, M_ALLOCATED));
-    __kalloc_kheap.brk += WSIZE;
+    SW(kheap.start, PACK(4, M_ALLOCATED));
+    SW(kheap.start + WSIZE, PACK(0, M_ALLOCATED));
+    kheap.brk += WSIZE;
 
-    return lx_grow_heap(&__kalloc_kheap, HEAP_INIT_SIZE) != NULL;
+    return lx_grow_heap(&kheap, HEAP_INIT_SIZE) != NULL;
 }
 
 void*
 lxmalloc(size_t size) {
-    return lx_malloc_internal(&__kalloc_kheap, size);
+    mutex_lock(&kheap.lock);
+    void* r = lx_malloc_internal(&kheap, size);
+    mutex_unlock(&kheap.lock);
+
+    return r;
 }
 
 void*
-lxcalloc(size_t size) {
-    void* ptr = lxmalloc(size);
+lxcalloc(size_t n, size_t elem) {
+    size_t pd = n * elem;
+
+    // overflow detection
+    if (pd < elem || pd < n) {
+        return NULL;
+    }
+
+    void* ptr = lxmalloc(pd);
     if (!ptr) {
         return NULL;
     }
 
-    return memset(ptr, 0, size);
+    return memset(ptr, 0, pd);
 }
 
 void
@@ -96,6 +107,7 @@ lxfree(void* ptr) {
     if (!ptr) {
         return;
     }
+    mutex_lock(&kheap.lock);
 
     uint8_t* chunk_ptr = (uint8_t*)ptr - WSIZE;
     uint32_t hdr = LW(chunk_ptr);
@@ -116,6 +128,8 @@ lxfree(void* ptr) {
     SW(next_hdr, LW(next_hdr) | M_PREV_FREE);
     
     coalesce(chunk_ptr);
+
+    mutex_unlock(&kheap.lock);
 }
 
 
@@ -235,7 +249,7 @@ lx_grow_heap(heap_context_t* heap, size_t sz)
     void* start;
 
     // The "+ WSIZE" capture the overhead for epilogue marker
-    if (!(start = lxbrk(heap, sz + WSIZE))) {
+    if (!(start = lxsbrk(heap, sz + WSIZE))) {
         return NULL;
     }
     sz = ROUNDUP(sz, BOUNDARY);