1 files changed, 62 insertions, 62 deletions

diff --git a/src/kern/mem.c b/src/kern/mem.c
index 5234fff..edef8f4 100644
--- a/src/kern/mem.c
+++ b/src/kern/mem.c
@@ -24,67 +24,67 @@ void* memset(void* dest, int c, size_t n);
 
 #endif
 
-typedef uint16_t halloc_off_t;
+typedef uint16_t kalloc_off_t;
 
 #define CANARY 0x5a
 
 // The sizes will count the number of WORDS allocated.
 // Since there's a max size of 16k, only 12 bits will be
 // needed for this.
-typedef struct HALLOC_NODE {
+typedef struct KALLOC_NODE {
   union {
     uint32_t header;
     struct {
-      /* Is this memory block currently in use (hasn't been hfree'd) */
+      /* Is this memory block currently in use (hasn't been kfree'd) */
       uint8_t     used:1;
       /* Number of words allocated. Does not include the header. */
       uint16_t size:12;
       /* The location of the previous block (in WORDS from offest) */
-      halloc_off_t prev:12;
+      kalloc_off_t prev:12;
       uint8_t canary:7;
     } PACKED;
   };
 
   uint8_t mem[]; /* The memory to use. */
-} halloc_node_t;
+} kalloc_node_t;
 
-static_assert(offsetof(halloc_node_t, mem) == 4, "Offset check failed.");
+static_assert(offsetof(kalloc_node_t, mem) == 4, "Offset check failed.");
 
-halloc_node_t* halloc_start;
+kalloc_node_t* kalloc_start;
 
-#define halloc_node_out_of_range(node) \
+#define kalloc_node_out_of_range(node) \
    ((uint8_t*) (node) == ((uint8_t*)&DATA_SEGMENT_STOP) + MAX_HEAP_SIZE)
 
-#define halloc_node_next(cur) \
-  ((halloc_node_t*)(((uint8_t*)(cur)) + (((cur)->size + 1) * 4)))
+#define kalloc_node_next(cur) \
+  ((kalloc_node_t*)(((uint8_t*)(cur)) + (((cur)->size + 1) * 4)))
 
-#define halloc_node_prev(cur) halloc_node_at_off(cur->prev)
+#define kalloc_node_prev(cur) kalloc_node_at_off(cur->prev)
 
-#define halloc_node_at_off(offset) \
-  ((halloc_node_t*)(((uint8_t*) halloc_start) + (offset) * 4))
+#define kalloc_node_at_off(offset) \
+  ((kalloc_node_t*)(((uint8_t*) kalloc_start) + (offset) * 4))
 
-#define halloc_node_get_off(node) \
-  (((uint32_t)(((uint8_t*)(node)) - ((uint8_t*)(halloc_start)))) / 4)
+#define kalloc_node_get_off(node) \
+  (((uint32_t)(((uint8_t*)(node)) - ((uint8_t*)(kalloc_start)))) / 4)
 
-#define get_halloc_node(mem) \
-  ((halloc_node_t*)(((uint8_t*)mem) - 4))
+#define get_kalloc_node(mem) \
+  ((kalloc_node_t*)(((uint8_t*)mem) - 4))
 
 #define size_for(n) \
   (((n) / 4) + ((n) % 4 != 0))
 
-void* halloc(size_t size)
+void* kalloc(size_t size)
 {
-  if (!halloc_start) {
-    halloc_start = (halloc_node_t*) DATA_SEGMENT_STOP_ADDR;
-    memset(halloc_start, 0, sizeof(halloc_node_t));
-    halloc_start->size = (MAX_HEAP_SIZE / 4) - 1;
-    halloc_start->canary = CANARY;
+  if (!kalloc_start) {
+    kalloc_start = (kalloc_node_t*) DATA_SEGMENT_STOP_ADDR;
+    memset(kalloc_start, 0, sizeof(kalloc_node_t));
+    kalloc_start->size = (MAX_HEAP_SIZE / 4) - 1;
+    kalloc_start->canary = CANARY;
   }
 
   size_t realsz = size_for(size); /* Clip the size to the nearest word. */
-  halloc_off_t offset = 0; 
+  kalloc_off_t offset = 0; 
   while (offset < (MAX_HEAP_SIZE / 4)) {
-    halloc_node_t* cur = halloc_node_at_off(offset);
+    kalloc_node_t* cur = kalloc_node_at_off(offset);
 
     if (!cur->used && (cur->size >= realsz)) {
       cur->used = true;
@@ -92,23 +92,23 @@ void* halloc(size_t size)
       cur->size = realsz;
       
       if (orig_size > realsz) {
-        /* This halloc node needs to split into two blocks. */
-        halloc_node_t* next = halloc_node_next(cur);
+        /* This kalloc node needs to split into two blocks. */
+        kalloc_node_t* next = kalloc_node_next(cur);
         next->used = 0;
-        next->size = orig_size - realsz - sizeof(halloc_node_t) / 4;
+        next->size = orig_size - realsz - sizeof(kalloc_node_t) / 4;
         next->prev = offset;
         next->canary = CANARY;
 
-        halloc_node_t* nextnext = halloc_node_next(next);
-        if (halloc_node_get_off(nextnext) < (MAX_HEAP_SIZE / 4)) {
-          nextnext->prev = halloc_node_get_off(next);
+        kalloc_node_t* nextnext = kalloc_node_next(next);
+        if (kalloc_node_get_off(nextnext) < (MAX_HEAP_SIZE / 4)) {
+          nextnext->prev = kalloc_node_get_off(next);
         }
       }
 
       return (void*) cur->mem;
     }
 
-    offset += (sizeof(halloc_node_t) / 4) + cur->size;
+    offset += (sizeof(kalloc_node_t) / 4) + cur->size;
   }
 
   return NULL;
@@ -116,33 +116,33 @@ void* halloc(size_t size)
 
 
 /* Joins this node with the previous and next nodes if they're free. */
-static void coalesce(halloc_node_t* cur)
+static void coalesce(kalloc_node_t* cur)
 {
-  halloc_node_t* orig = cur;
-  halloc_node_t* last_freed;
-  halloc_node_t* next_used;
+  kalloc_node_t* orig = cur;
+  kalloc_node_t* last_freed;
+  kalloc_node_t* next_used;
 
   /* Find the earliest contiguous free'd block. */
-  while (!cur->used && cur != halloc_start) {
-    cur = halloc_node_prev(cur);
+  while (!cur->used && cur != kalloc_start) {
+    cur = kalloc_node_prev(cur);
   }
 
-  if (cur == halloc_start && !cur->used) {
+  if (cur == kalloc_start && !cur->used) {
     last_freed = cur;
   } else {
-    last_freed = halloc_node_next(cur);
+    last_freed = kalloc_node_next(cur);
   }
 
   /* Find the next used block. */
   cur = orig;
-  while (!cur->used && !halloc_node_out_of_range(cur)) {
-    cur = halloc_node_next(cur);
+  while (!cur->used && !kalloc_node_out_of_range(cur)) {
+    cur = kalloc_node_next(cur);
   }
 
   next_used = cur;
 
-  if (!halloc_node_out_of_range(next_used)) {
-    next_used->prev = halloc_node_get_off(last_freed);
+  if (!kalloc_node_out_of_range(next_used)) {
+    next_used->prev = kalloc_node_get_off(last_freed);
   }
 
   last_freed->size = ((uint8_t*) next_used - (last_freed->mem)) / 4;
@@ -163,12 +163,12 @@ void panic(const char* x)
 }
 #endif
 
-void hfree(void* mem)
+void kfree(void* mem)
 {
   /* Like normal free(), do nothing on free'ing NULL */
   if (!mem) return;
 
-  halloc_node_t* header = get_halloc_node(mem);
+  kalloc_node_t* header = get_kalloc_node(mem);
   if (!header->used) {
     panic("Heap double free or corruption!\n");
     return;
@@ -182,18 +182,18 @@ void hfree(void* mem)
 
 #include <stdio.h>
 
-void* debug_halloc_get_next_ptr(void* ptr)
+void* debug_kalloc_get_next_ptr(void* ptr)
 {
-  halloc_node_t* node = ptr - sizeof(halloc_node_t);
-  halloc_node_t* next = halloc_node_next(node);
+  kalloc_node_t* node = ptr - sizeof(kalloc_node_t);
+  kalloc_node_t* next = kalloc_node_next(node);
   
   return next->mem;
 }
 
-void* debug_halloc_get_prev_ptr(void* ptr)
+void* debug_kalloc_get_prev_ptr(void* ptr)
 {
-  halloc_node_t* node = ptr - sizeof(halloc_node_t);
-  halloc_node_t* prev = halloc_node_prev(node);
+  kalloc_node_t* node = ptr - sizeof(kalloc_node_t);
+  kalloc_node_t* prev = kalloc_node_prev(node);
   
   return prev->mem;
 }
@@ -201,20 +201,20 @@ void* debug_halloc_get_prev_ptr(void* ptr)
 void debug_print_blocks()
 {
   printf("------ Print Blocks -------\n");
-  halloc_node_t* cur = halloc_node_at_off(0);
+  kalloc_node_t* cur = kalloc_node_at_off(0);
 
-  while (!halloc_node_out_of_range(cur)) {
+  while (!kalloc_node_out_of_range(cur)) {
     printf("header (%04x) {used=%d, size=%5d, prev=%04x, canary=%02x}\n",
-        halloc_node_get_off(cur), cur->used, cur->size, cur->prev, cur->canary);
-    cur = halloc_node_next(cur);
+        kalloc_node_get_off(cur), cur->used, cur->size, cur->prev, cur->canary);
+    cur = kalloc_node_next(cur);
   }
 }
 
 /* Tests that we can walk up and down the allocated blocks and that they
  * are properly aligned. */
-int debug_halloc_assert_consistency(char* error, size_t len)
+int debug_kalloc_assert_consistency(char* error, size_t len)
 {
-  halloc_node_t* cur = halloc_node_at_off(0);
+  kalloc_node_t* cur = kalloc_node_at_off(0);
   size_t total_size = 0;
   size_t loop_check = 0;
   size_t n_blocks = 1;
@@ -229,7 +229,7 @@ int debug_halloc_assert_consistency(char* error, size_t len)
 
     total_size += cur->size + 1;
 
-    halloc_node_t* next = halloc_node_next(cur);
+    kalloc_node_t* next = kalloc_node_next(cur);
     if ((uint8_t*) next == ((uint8_t*)&DATA_SEGMENT_STOP) + MAX_HEAP_SIZE) {
       break;
     } else if ((uint8_t*) next > (uint8_t*)DATA_SEGMENT_STOP_ADDR + MAX_HEAP_SIZE){
@@ -251,15 +251,15 @@ int debug_halloc_assert_consistency(char* error, size_t len)
     return 1;
   }
 
-  if (cur == halloc_start) {
+  if (cur == kalloc_start) {
     return 0;
   }
 
   while (loop_check < 10000) {
-    halloc_node_t* prev = halloc_node_prev(cur);
+    kalloc_node_t* prev = kalloc_node_prev(cur);
     ++ n_blocks_back;
 
-    if (prev == halloc_start)  {
+    if (prev == kalloc_start)  {
       if (n_blocks != n_blocks_back) {
         snprintf(
             error, len, "Different number of blocks found on the way back. Found %lu on the way back vs %lu up.\n",