malloc working in loader w/ init workaround

Author: Sharpiro

.clang-format

@@ -8,3 +8,5 @@ BinPackParameters: false
 BinPackArguments: false
 AllowAllParametersOfDeclarationOnNextLine: true
 PenaltyReturnTypeOnItsOwnLine: 1000000
+# ternary expressions
+AlignOperands: false

Makefile

@@ -49,9 +49,10 @@ loader: src/loader/loader_main.c src/tiny_c/tiny_c.c
 		-DARM32 \
 		-o loader \
 		src/loader/loader_main.c \
+		src/loader/loader_lib.c \
 		src/tiny_c/tinyc_sys.c \
 		src/tiny_c/tiny_c.c \
-		src/elf_tools.c
+		src/loader/elf_tools.c
 
 programs/linux/env:
 	@$(CC) $(CFLAGS) -g \

src/elf_tools.c renamed to src/loader/elf_tools.c

@@ -1,5 +1,6 @@
 #include "elf_tools.h"
-#include "tiny_c/tiny_c.h"
+#include "../tiny_c/tiny_c.h"
+#include "loader_lib.h"
 
 #define ELF_HEADER_LEN sizeof(ELF_HEADER)
 
@@ -12,7 +13,7 @@ const uint8_t ELF_MAGIC[] = {0x7f, 'E', 'L', 'F'};
 #define EXAMPLE2(fmt, ...) tiny_c_fprintf(STDERR, fmt, ##__VA_ARGS__)
 
 bool get_elf_data(int fd, struct ElfData *elf_data) {
-    ELF_HEADER *elf_header = tinyc_malloc(ELF_HEADER_LEN);
+    ELF_HEADER *elf_header = loader_malloc_arena(ELF_HEADER_LEN);
     ssize_t header_read_len = tiny_c_read(fd, elf_header, ELF_HEADER_LEN);
     if (header_read_len != ELF_HEADER_LEN) {
         tiny_c_fprintf(STDERR, "read failed\n");
@@ -29,14 +30,14 @@ bool get_elf_data(int fd, struct ElfData *elf_data) {
     }
 
     size_t program_headers_len = elf_header->e_phnum * elf_header->e_phentsize;
-    PROGRAM_HEADER *program_headers = tinyc_malloc(program_headers_len);
+    PROGRAM_HEADER *program_headers = loader_malloc_arena(program_headers_len);
     ssize_t ph_read_len = tiny_c_read(fd, program_headers, program_headers_len);
     if ((size_t)ph_read_len != program_headers_len) {
         BAIL("read failed\n")
     }
 
     struct MemoryRegion *memory_regions =
-        tinyc_malloc(sizeof(struct MemoryRegion) * elf_header->e_phnum);
+        loader_malloc_arena(sizeof(struct MemoryRegion) * elf_header->e_phnum);
 
     size_t j = 0;
     for (size_t i = 0; i < elf_header->e_phnum; i++) {
@@ -46,14 +47,13 @@ bool get_elf_data(int fd, struct ElfData *elf_data) {
         }
 
         uint32_t file_offset = program_header->p_offset /
-                               program_header->p_align *
-                               program_header->p_align;
+            program_header->p_align * program_header->p_align;
         uint32_t start = program_header->p_vaddr / program_header->p_align *
-                         program_header->p_align;
+            program_header->p_align;
         uint32_t end = start +
-                       program_header->p_memsz / program_header->p_align *
-                           program_header->p_align +
-                       program_header->p_align;
+            program_header->p_memsz / program_header->p_align *
+                program_header->p_align +
+            program_header->p_align;
 
         memory_regions[j++] = (struct MemoryRegion){
             .start = start,

src/elf_tools.h renamed to src/loader/elf_tools.h

@@ -0,0 +1,22 @@
+#include "loader_lib.h"
+
+#define LOADER_BUFFER_SIZE 1000
+
+static uint8_t loader_buffer[LOADER_BUFFER_SIZE] = {0};
+static size_t loader_heap_end = LOADER_BUFFER_SIZE;
+static size_t loader_heap_index = 0;
+
+void *loader_malloc_arena(size_t n) {
+    if (loader_heap_index + n > loader_heap_end) {
+        return NULL;
+    }
+
+    void *address = (void *)(loader_buffer + loader_heap_index);
+    loader_heap_index += n;
+
+    return address;
+}
+
+void loader_free_arena(void) {
+    loader_heap_index = 0;
+}

src/loader/loader_lib.c

@@ -0,0 +1,8 @@
+#pragma once
+
+#include <stdint.h>
+#include <stdlib.h>
+
+void *loader_malloc_arena(size_t n);
+
+void loader_free_arena(void);

src/loader/loader_lib.h

@@ -1,5 +1,5 @@
-#include "../elf_tools.h"
 #include "../tiny_c/tiny_c.h"
+#include "elf_tools.h"
 #include <fcntl.h>
 #include <stdint.h>
 #include <sys/mman.h>
@@ -117,8 +117,6 @@ int main(int32_t argc, char **argv) {
         return -1;
     }
 
-    // @todo: map data section
-
     struct ElfData elf_data;
     if (!get_elf_data(fd, &elf_data)) {
         tiny_c_fprintf(STDERR, "error parsing elf data\n");
@@ -133,7 +131,6 @@ int main(int32_t argc, char **argv) {
     for (size_t i = 0; i < elf_data.memory_regions_len; i++) {
         struct MemoryRegion *memory_region = &elf_data.memory_regions[i];
         size_t memory_region_len = memory_region->end - memory_region->start;
-        // @todo: mem region test?
         size_t prot_read = (memory_region->permissions & 4) >> 2;
         size_t prot_write = memory_region->permissions & 2;
         size_t prot_execute = (memory_region->permissions & 1) << 2;
@@ -167,6 +164,7 @@ int main(int32_t argc, char **argv) {
     tiny_c_fprintf(log_handle, "frame_pointer: %x\n", frame_pointer);
     tiny_c_fprintf(log_handle, "stack_start: %x\n", stack_start);
     tiny_c_fprintf(log_handle, "running program...\n");
+
     run_asm(
         (size_t)inferior_frame_pointer,
         (size_t)stack_start,

src/loader/loader_main.c

@@ -1,7 +1,12 @@
 #include "../../../tiny_c/tiny_c.h"
+#include <stddef.h>
 
 ARM32_START_FUNCTION
 
+extern size_t tinyc_heap_start;
+extern size_t tinyc_heap_end;
+extern size_t tinyc_heap_index;
+
 int main(void) {
     int32_t pid = tiny_c_get_pid();
     tiny_c_printf("pid: %x\n", pid);
@@ -10,18 +15,19 @@ int main(void) {
     const char *cwd = tiny_c_get_cwd(cwd_buffer, 100);
     tiny_c_printf("cwd: '%s'\n", cwd);
 
-    uint8_t *buffer = tinyc_malloc(128);
+    const int MALLOC_SIZE = 0x1001;
+    uint8_t *buffer = tinyc_malloc_arena(MALLOC_SIZE);
     tiny_c_printf("p: %x\n", buffer);
-    tiny_c_printf("n: %x\n", *buffer);
-    tinyc_free(buffer);
+    tiny_c_printf("f: %x\n", *buffer);
+    tiny_c_printf("l: %x\n", *(buffer + MALLOC_SIZE - 1));
 
-    buffer = tinyc_malloc(0x800);
+    buffer = tinyc_malloc_arena(0x800);
     tiny_c_printf("p: %x\n", buffer);
     tiny_c_printf("n: %x\n", *buffer);
-    tinyc_free(buffer);
 
-    buffer = tinyc_malloc(0x800);
+    buffer = tinyc_malloc_arena(0x800);
     tiny_c_printf("p: %x\n", buffer);
     tiny_c_printf("n: %x\n", *buffer);
-    tinyc_free(buffer);
+
+    tinyc_free_arena();
 }

src/programs/linux/tinyfetch/tinyfetch_main.c

@@ -11,7 +11,9 @@
 #include <sys/types.h>
 
 int32_t tinyc_errno = 0;
-size_t tinyc_heap_start = 0;
+
+// @todo: 0 initial value doesn't work
+size_t tinyc_heap_start = 42;
 size_t tinyc_heap_end = 0;
 size_t tinyc_heap_index = 0;
 
@@ -384,25 +386,27 @@ const char *tinyc_strerror(int32_t err_number) {
     }
 }
 
-void *tinyc_malloc(size_t n) {
-    const int HEAP_CHUNK_LEN = 0x1000;
+void *tinyc_malloc_arena(size_t n) {
+    const int PAGE_SIZE = 0x1000;
 
-    if (tinyc_heap_start == 0) {
+    if (tinyc_heap_start == 42) {
         tinyc_heap_start = tinyc_sys_brk(0);
         tinyc_heap_end = tinyc_heap_start;
         tinyc_heap_index = tinyc_heap_start;
     }
     if (tinyc_heap_index + n > tinyc_heap_end) {
-        tinyc_heap_end = tinyc_sys_brk((size_t)tinyc_heap_end + HEAP_CHUNK_LEN);
+        size_t extend_size = PAGE_SIZE * (n / PAGE_SIZE) + PAGE_SIZE;
+        tinyc_heap_end = tinyc_sys_brk(tinyc_heap_end + extend_size);
     }
 
     void *address = (void *)tinyc_heap_index;
     tinyc_heap_index += n;
+
     return address;
 }
 
-void tinyc_free(void *_) {
-    // @todo: free
+void tinyc_free_arena(void) {
+    tinyc_heap_index = tinyc_heap_start;
 }
 
 #ifdef ARM32

src/tiny_c/tiny_c.c

@@ -33,8 +33,8 @@ int32_t tiny_c_strcmp(const void *__s1, const void *__s2);
 int32_t tiny_c_get_pid(void);
 char *tiny_c_get_cwd(char *buffer, size_t size);
 const char *tinyc_strerror(int32_t err_number);
-void *tinyc_malloc(size_t n);
-void tinyc_free(void *_);
+void *tinyc_malloc_arena(size_t n);
+void tinyc_free_arena(void);
 
 #ifdef ARM32