Kmalloc

design/memory.md

@@ -171,7 +171,7 @@ any pages after the region end should be 0).
 
 ## Paging Allocator (`memory.h`)
 
-Paging allocator (aka `kmalloc` and `kfree`) is responsible for connecting the
+Paging allocator (aka `pmalloc` and `pfree`) is responsible for connecting the
 physical memory allocator (ram) and page tables (mmu). This allocator keeps a
 linked list of tables, 1022 entries each.
 

src/apps/demo/src/demo.c

@@ -11,7 +11,7 @@ int __start(size_t argc, char ** argv) {
     int store = 0;
     len += printf("The last part is pointers %8p\n", &store);
 
-    void * data = kmalloc(10);
+    void * data = pmalloc(10);
 
     printf("\nMalloc memory got pointer %p\n", data);
     printf("Float number %f or shorter %3f or digits %.4f or lead %.04f\n", 3.14, 31.45, 3.14, 3.14);

src/drivers/src/ata.c

@@ -4,6 +4,7 @@
 #include "cpu/ports.h"
 #include "debug.h"
 #include "drivers/rtc.h"
+#include "kernel.h"
 #include "libc/memory.h"
 #include "libc/proc.h"
 #include "libc/stdio.h"

src/drivers/src/disk.c

@@ -2,6 +2,7 @@
 
 #include "drivers/ata.h"
 #include "drivers/ramdisk.h"
+#include "kernel.h"
 #include "libc/memory.h"
 #include "libc/string.h"
 

src/drivers/src/ramdisk.c

@@ -1,5 +1,6 @@
 #include "drivers/ramdisk.h"
 
+#include "kernel.h"
 #include "libc/memory.h"
 #include "libc/proc.h"
 #include "libc/string.h"

src/drivers/src/tar.c

@@ -2,6 +2,7 @@
 
 #include <stdint.h>
 
+#include "kernel.h"
 #include "libc/memory.h"
 #include "libc/proc.h"
 #include "libc/stdio.h"

src/io/src/file.c

@@ -1,5 +1,6 @@
 #include "io/file.h"
 
+#include "kernel.h"
 #include "libc/memory.h"
 #include "libk/sys_call.h"
 

src/kernel/include/kernel.h

@@ -66,6 +66,10 @@ int kernel_call_as_proc(int pid, _proc_call_t fn, void * data);
 
 int kernel_switch_task(int next_pid);
 
+void * kmalloc(size_t size);
+void * krealloc(void * ptr, size_t size);
+void   kfree(void * ptr);
+
 #ifdef TESTING
 #define NO_RETURN
 #else

src/kernel/src/kernel.c

@@ -284,6 +284,18 @@ process_t * kernel_find_pid(int pid) {
     return pm_find_pid(&__kernel.pm, pid);
 }
 
+void * kmalloc(size_t size) {
+    return memory_alloc(&__kernel.kernel_memory, size);
+}
+
+void * krealloc(void * ptr, size_t size) {
+    return memory_realloc(&__kernel.kernel_memory, ptr, size);
+}
+
+void kfree(void * ptr) {
+    memory_free(&__kernel.kernel_memory, ptr);
+}
+
 static void cursor() {
     vga_cursor(3, 3);
 

src/kernel/src/term.c

@@ -340,9 +340,9 @@ static void exec_buff() {
 
     // Free parsed args
     for (size_t i = 0; i < argc; i++) {
-        kfree(argv[i]);
+        pfree(argv[i]);
     }
-    kfree(argv);
+    pfree(argv);
 }
 
 static bool is_ws(char c) {
@@ -412,7 +412,7 @@ static char ** parse_args(const char * line, size_t * out_len) {
     }
 
     *out_len      = len;
-    char ** args  = kmalloc(sizeof(char *) * len);
+    char ** args  = pmalloc(sizeof(char *) * len);
     size_t  arg_i = 0;
 
     while (*line) {
@@ -443,7 +443,7 @@ static char ** parse_args(const char * line, size_t * out_len) {
 
             line++;
 
-            args[arg_i] = kmalloc(sizeof(char) * next);
+            args[arg_i] = pmalloc(sizeof(char) * next);
             kmemcpy(args[arg_i], line, next - 1);
             args[arg_i][next - 1] = 0;
             arg_i++;
@@ -459,7 +459,7 @@ static char ** parse_args(const char * line, size_t * out_len) {
         }
 
         size_t word_len = line - start;
-        args[arg_i]     = kmalloc(sizeof(char) * word_len + 1);
+        args[arg_i]     = pmalloc(sizeof(char) * word_len + 1);
         kmemcpy(args[arg_i], start, word_len);
         args[arg_i][word_len] = 0;
         arg_i++;

src/libc/include/libc/memory.h

@@ -7,8 +7,8 @@
 #include "memory_alloc.h"
 
 void   init_malloc(memory_t * memory);
-void * kmalloc(size_t size);
-void * krealloc(void * ptr, size_t size);
-void   kfree(void * ptr);
+void * pmalloc(size_t size);
+void * prealloc(void * ptr, size_t size);
+void   pfree(void * ptr);
 
 #endif // LIBC_MEMORY_H

src/libc/src/array.c

@@ -11,7 +11,7 @@ int arr_create(arr_t * arr, size_t size, size_t elem_size) {
         return -1;
     }
 
-    arr->data = kmalloc(size * elem_size);
+    arr->data = pmalloc(size * elem_size);
     if (!arr->data) {
         return -1;
     }
@@ -25,7 +25,7 @@ int arr_create(arr_t * arr, size_t size, size_t elem_size) {
 
 void arr_free(arr_t * arr) {
     if (arr && arr->data) {
-        kfree(arr->data);
+        pfree(arr->data);
         arr->data = 0;
     }
 }
@@ -119,7 +119,7 @@ static void * arr_at_no_limit(const arr_t * arr, size_t i) {
 
 static int grow_array(arr_t * arr) {
     size_t new_size = arr->size + (arr->size / 2);
-    void * new_data = krealloc(arr->data, new_size);
+    void * new_data = prealloc(arr->data, new_size);
     if (!new_data) {
         return -1;
     }

src/libc/src/circular_buffer.c

@@ -11,7 +11,7 @@ int cb_create(cb_t * cb, size_t size, size_t elem_size) {
         return -1;
     }
 
-    cb->buff = kmalloc(size * elem_size);
+    cb->buff = pmalloc(size * elem_size);
     if (!cb->buff) {
         return -1;
     }
@@ -26,7 +26,7 @@ int cb_create(cb_t * cb, size_t size, size_t elem_size) {
 
 void cb_free(cb_t * cb) {
     if (cb && cb->buff) {
-        kfree(cb->buff);
+        pfree(cb->buff);
         cb->buff = 0;
     }
 }

src/libc/src/memory.c

@@ -9,14 +9,14 @@ void init_malloc(memory_t * memory) {
     __memory = memory;
 }
 
-void * kmalloc(size_t size) {
+void * pmalloc(size_t size) {
     return memory_alloc(__memory, size);
 }
 
-void * krealloc(void * ptr, size_t size) {
+void * prealloc(void * ptr, size_t size) {
     return memory_realloc(__memory, ptr, size);
 }
 
-void kfree(void * ptr) {
+void pfree(void * ptr) {
     memory_free(__memory, ptr);
 }

src/libc/src/signal.c

@@ -36,7 +36,7 @@ int register_signal(int sig_no, signal_handler callback) {
         sig = sig->next;
     }
 
-    sig = kmalloc(sizeof(signal_t));
+    sig = pmalloc(sizeof(signal_t));
     if (!sig) {
         return -1;
     }

tests/src/libc/test_array.cpp

@@ -19,8 +19,8 @@ class Array : public testing::Test {
         arr_create(&arr, 3, 1);
         arr_size(&arr);
 
-        RESET_FAKE(kmalloc);
-        kmalloc_fake.custom_fake = malloc;
+        RESET_FAKE(pmalloc);
+        pmalloc_fake.custom_fake = malloc;
     }
 
     void TearDown() override {
@@ -42,15 +42,15 @@ TEST_F(Array, arr_create) {
     EXPECT_NE(0, arr_create(0, 0, 1));
     EXPECT_NE(0, arr_create(&arr, 1, 0));
     EXPECT_NE(0, arr_create(&arr, 0, 1));
-    EXPECT_EQ(0, kmalloc_fake.call_count);
-    EXPECT_EQ(0, kfree_fake.call_count);
+    EXPECT_EQ(0, pmalloc_fake.call_count);
+    EXPECT_EQ(0, pfree_fake.call_count);
 
     // Good args
     EXPECT_EQ(0, arr_create(&arr, 4, 1));
     EXPECT_EQ(0, arr_size(&arr));
 
-    ASSERT_EQ(1, kmalloc_fake.call_count);
-    EXPECT_EQ(4, kmalloc_fake.arg0_val);
+    ASSERT_EQ(1, pmalloc_fake.call_count);
+    EXPECT_EQ(4, pmalloc_fake.arg0_val);
 
     arr_free(&arr);
 
@@ -60,31 +60,31 @@ TEST_F(Array, arr_create) {
     EXPECT_EQ(0, arr_create(&arr, 4, 2));
     EXPECT_EQ(0, arr_size(&arr));
 
-    ASSERT_EQ(1, kmalloc_fake.call_count);
-    EXPECT_EQ(8, kmalloc_fake.arg0_val);
+    ASSERT_EQ(1, pmalloc_fake.call_count);
+    EXPECT_EQ(8, pmalloc_fake.arg0_val);
 
     arr_free(&arr);
 
     SetUp();
 
-    kmalloc_fake.custom_fake = 0;
-    kmalloc_fake.return_val  = 0;
+    pmalloc_fake.custom_fake = 0;
+    pmalloc_fake.return_val  = 0;
 
     // First malloc fails
     EXPECT_NE(0, arr_create(&arr, 4, 1));
-    EXPECT_EQ(1, kmalloc_fake.call_count);
-    EXPECT_EQ(4, kmalloc_fake.arg0_val);
+    EXPECT_EQ(1, pmalloc_fake.call_count);
+    EXPECT_EQ(4, pmalloc_fake.arg0_val);
 }
 
 TEST_F(Array, arr_free) {
     // Invalid parameters
     arr_free(0);
-    EXPECT_EQ(0, kfree_fake.call_count);
+    EXPECT_EQ(0, pfree_fake.call_count);
 
     void * data = arr.data;
     arr_free(&arr);
-    EXPECT_EQ(1, kfree_fake.call_count);
-    EXPECT_EQ(data, kfree_fake.arg0_val);
+    EXPECT_EQ(1, pfree_fake.call_count);
+    EXPECT_EQ(data, pfree_fake.arg0_val);
     EXPECT_EQ(0, arr.data);
 }
 
@@ -114,9 +114,9 @@ TEST_F(Array, arr_size) {
     EXPECT_EQ(0, arr_insert(&arr, 3, &c));
     EXPECT_EQ(4, arr_size(&arr));
 
-    ASSERT_EQ(1, krealloc_fake.call_count);
-    EXPECT_EQ(old_data, krealloc_fake.arg0_val);
-    EXPECT_EQ(4, krealloc_fake.arg1_val);
+    ASSERT_EQ(1, prealloc_fake.call_count);
+    EXPECT_EQ(old_data, prealloc_fake.arg0_val);
+    EXPECT_EQ(4, prealloc_fake.arg1_val);
 }
 
 TEST_F(Array, arr_data) {
@@ -263,8 +263,8 @@ TEST_F(Array, arr_insert) {
 TEST_F(Array, array_insert_grow_fails) {
     fill_array();
 
-    krealloc_fake.custom_fake = 0;
-    krealloc_fake.return_val  = 0;
+    prealloc_fake.custom_fake = 0;
+    prealloc_fake.return_val  = 0;
 
     char c = '1';
     EXPECT_NE(0, arr_insert(&arr, 0, &c));

tests/src/libc/test_circular_buffer.cpp

@@ -18,8 +18,8 @@ class CircularBuffer : public testing::Test {
 
         cb_create(&cbuff, 3, 1);
 
-        RESET_FAKE(kmalloc);
-        kmalloc_fake.custom_fake = malloc;
+        RESET_FAKE(pmalloc);
+        pmalloc_fake.custom_fake = malloc;
     }
 
     void TearDown() override {
@@ -34,16 +34,16 @@ TEST_F(CircularBuffer, cb_create) {
     EXPECT_NE(0, cb_create(0, 0, 1));
     EXPECT_NE(0, cb_create(&cbuff, 1, 0));
     EXPECT_NE(0, cb_create(&cbuff, 0, 1));
-    EXPECT_EQ(0, kmalloc_fake.call_count);
-    EXPECT_EQ(0, kfree_fake.call_count);
+    EXPECT_EQ(0, pmalloc_fake.call_count);
+    EXPECT_EQ(0, pfree_fake.call_count);
 
     // Good args
     EXPECT_EQ(0, cb_create(&cbuff, 4, 1));
     EXPECT_EQ(0, cb_len(&cbuff));
     EXPECT_EQ(4, cb_buff_size(&cbuff));
 
-    ASSERT_EQ(1, kmalloc_fake.call_count);
-    EXPECT_EQ(4, kmalloc_fake.arg0_val);
+    ASSERT_EQ(1, pmalloc_fake.call_count);
+    EXPECT_EQ(4, pmalloc_fake.arg0_val);
 
     cb_free(&cbuff);
 
@@ -54,30 +54,30 @@ TEST_F(CircularBuffer, cb_create) {
     EXPECT_EQ(0, cb_len(&cbuff));
     EXPECT_EQ(4, cb_buff_size(&cbuff));
 
-    ASSERT_EQ(1, kmalloc_fake.call_count);
-    EXPECT_EQ(8, kmalloc_fake.arg0_val);
+    ASSERT_EQ(1, pmalloc_fake.call_count);
+    EXPECT_EQ(8, pmalloc_fake.arg0_val);
 
     cb_free(&cbuff);
 
     SetUp();
 
-    kmalloc_fake.custom_fake = 0;
-    kmalloc_fake.return_val  = 0;
+    pmalloc_fake.custom_fake = 0;
+    pmalloc_fake.return_val  = 0;
 
     // First malloc fails
     EXPECT_NE(0, cb_create(&cbuff, 4, 1));
-    EXPECT_EQ(1, kmalloc_fake.call_count);
-    EXPECT_EQ(4, kmalloc_fake.arg0_val);
+    EXPECT_EQ(1, pmalloc_fake.call_count);
+    EXPECT_EQ(4, pmalloc_fake.arg0_val);
 }
 
 TEST_F(CircularBuffer, cb_free) {
     cb_free(0);
-    EXPECT_EQ(0, kfree_fake.call_count);
+    EXPECT_EQ(0, pfree_fake.call_count);
 
     void * data = cbuff.buff;
     cb_free(&cbuff);
-    EXPECT_EQ(1, kfree_fake.call_count);
-    EXPECT_EQ(data, kfree_fake.arg0_val);
+    EXPECT_EQ(1, pfree_fake.call_count);
+    EXPECT_EQ(data, pfree_fake.arg0_val);
     EXPECT_EQ(0, cbuff.buff);
 }