aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/kern/mem.c124
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",
generated by cgit (git 2.34.1) at 2025-07-03 23:42:56 +0000