Squash commits for public release

boot/libboot/mem/alloc.c

@@ -0,0 +1,96 @@
+#include <libboot/log/log.h>
+#include <libboot/mem/alloc.h>
+
+void* _malloc_next_addr = NULL;
+void* _malloc_end_addr = NULL;
+
+void* _palloc_start_addr = NULL;
+void* _palloc_next_addr = NULL;
+void* _palloc_end_addr = NULL;
+
+int malloc_init(void* addr, size_t size)
+{
+    _malloc_next_addr = addr;
+    _malloc_end_addr = _malloc_next_addr + size;
+    return 0;
+}
+
+// Current implementation is a simple linear allocator.
+void* malloc(size_t size)
+{
+    if (!_malloc_next_addr) {
+        return NULL;
+    }
+    if (_malloc_next_addr >= _malloc_end_addr) {
+        return NULL;
+    }
+
+    void* res = _malloc_next_addr;
+
+    size = ROUND_CEIL(size, 0x10);
+    _malloc_next_addr += size;
+    return res;
+}
+
+// Current implementation is a simple linear allocator.
+void* malloc_aligned(size_t size, size_t alignment)
+{
+    if ((size_t)_malloc_next_addr % alignment) {
+        malloc(alignment - ((size_t)_malloc_next_addr % alignment));
+    }
+    return malloc(size);
+}
+
+void free(void* ptr)
+{
+    UNUSED(ptr);
+}
+
+// Preserve alloc
+
+int palloc_init(size_t size, size_t alignment)
+{
+    _palloc_start_addr = _palloc_next_addr = malloc_aligned(size, alignment);
+    if (!_palloc_next_addr) {
+        return -1;
+    }
+
+    _palloc_end_addr = (void*)((uintptr_t)_palloc_next_addr + size);
+    return 0;
+}
+
+void* palloc(size_t size)
+{
+    if (!_palloc_next_addr) {
+        log("palloc not init");
+        while (1) { };
+    }
+    if (_palloc_next_addr >= _palloc_end_addr) {
+        log("palloc out of mem");
+        while (1) { };
+    }
+
+    void* res = _palloc_next_addr;
+
+    size = ROUND_CEIL(size, 0x10);
+    _palloc_next_addr += size;
+    return res;
+}
+
+void* palloc_aligned(size_t size, size_t alignment)
+{
+    if ((size_t)_palloc_next_addr % alignment) {
+        palloc(alignment - ((size_t)_palloc_next_addr % alignment));
+    }
+    return palloc(size);
+}
+
+size_t palloc_total_size()
+{
+    return (size_t)_palloc_end_addr - (size_t)_palloc_start_addr;
+}
+
+size_t palloc_used_size()
+{
+    return (size_t)_palloc_next_addr - (size_t)_palloc_start_addr;
+}

boot/libboot/mem/alloc.h

@@ -0,0 +1,17 @@
+#ifndef _BOOT_LIBBOOT_MEM_MALLOC_H
+#define _BOOT_LIBBOOT_MEM_MALLOC_H
+
+#include <libboot/mem/mem.h>
+
+int malloc_init(void* addr, size_t size);
+void* malloc(size_t size);
+void* malloc_aligned(size_t size, size_t alignment);
+void free(void* ptr);
+
+int palloc_init(size_t size, size_t alignment);
+void* palloc(size_t size);
+void* palloc_aligned(size_t size, size_t alignment);
+size_t palloc_used_size();
+size_t palloc_total_size();
+
+#endif // _BOOT_LIBBOOT_MEM_MALLOC_H

boot/libboot/mem/mem.c

@@ -0,0 +1,110 @@
+#include <libboot/mem/mem.h>
+
+int strcmp(const char* a, const char* b)
+{
+    while (*a == *b && *a != 0 && *b != 0) {
+        a++;
+        b++;
+    }
+
+    if (*a < *b) {
+        return -1;
+    }
+    if (*a > *b) {
+        return 1;
+    }
+    return 0;
+}
+
+int strncmp(const char* a, const char* b, uint32_t num)
+{
+    while (*a == *b && *a != 0 && *b != 0 && num) {
+        a++;
+        b++;
+        num--;
+    }
+
+    if (!num) {
+        return 0;
+    }
+
+    if (*a < *b) {
+        return -1;
+    }
+    if (*a > *b) {
+        return 1;
+    }
+    return 0;
+}
+
+size_t strlen(const char* s)
+{
+    size_t i = 0;
+    while (s[i] != '\0')
+        ++i;
+    return i;
+}
+
+size_t strnlen(const char* s, size_t maxlen)
+{
+    size_t i = 0;
+    while (s[i] != '\0' && maxlen) {
+        i++;
+        maxlen--;
+    }
+    return i;
+}
+
+void* memset(void* dest, uint8_t fll, uint32_t nbytes)
+{
+    for (int i = 0; i < nbytes; ++i) {
+        *((uint8_t*)dest + i) = fll;
+    }
+    return dest;
+}
+
+void* memcpy(void* dest, const void* src, uint32_t nbytes)
+{
+    for (int i = 0; i < nbytes; ++i) {
+        *(char*)(dest + i) = *(char*)(src + i);
+    }
+    return dest;
+}
+
+void* memmove(void* dest, const void* src, uint32_t nbytes)
+{
+    if (src > dest) {
+        for (int i = 0; i < nbytes; ++i) {
+            *((uint8_t*)dest + i) = *((uint8_t*)src + i);
+        }
+    } else {
+        for (int i = nbytes - 1; i >= 0; --i) {
+            *((uint8_t*)dest + i) = *((uint8_t*)src + i);
+        }
+    }
+    return dest;
+}
+
+void* memccpy(void* dest, const void* src, uint8_t stop, uint32_t nbytes)
+{
+    for (int i = 0; i < nbytes; ++i) {
+        *((uint8_t*)dest + i) = *((uint8_t*)src + i);
+        if (*((uint8_t*)src + i) == stop) {
+            return ((uint8_t*)dest + i + 1);
+        }
+    }
+    return NULL;
+}
+
+int memcmp(const void* src1, const void* src2, uint32_t nbytes)
+{
+    for (int i = 0; i < nbytes; ++i) {
+        if (*(uint8_t*)(src1 + i) < *((uint8_t*)src2 + i)) {
+            return -1;
+        }
+        if (*(uint8_t*)(src1 + i) > *(uint8_t*)(src2 + i)) {
+            return 1;
+        }
+    }
+    return 0;
+}

boot/libboot/mem/mem.h

@@ -0,0 +1,37 @@
+#ifndef _BOOT_LIBBOOT_MEM_MEM_H
+#define _BOOT_LIBBOOT_MEM_MEM_H
+
+#include <libboot/types.h>
+
+int strcmp(const char* a, const char* b);
+int strncmp(const char* a, const char* b, uint32_t num);
+size_t strlen(const char* s);
+size_t strnlen(const char* s, size_t maxlen);
+void* memset(void* dest, uint8_t fll, uint32_t nbytes);
+void* memcpy(void* dest, const void* src, uint32_t nbytes);
+void* memccpy(void* dest, const void* src, uint8_t stop, uint32_t nbytes);
+void* memmove(void* dest, const void* src, uint32_t nbytes);
+int memcmp(const void* src1, const void* src2, uint32_t nbytes);
+
+static size_t align_size(size_t size, size_t align)
+{
+    if (size % align) {
+        size += align - (size % align);
+    }
+    return size;
+}
+
+static inline void* copy_after_kernel(size_t kbase, void* from, size_t size, size_t* kernel_size, size_t align)
+{
+    void* pp = (void*)(kbase + *kernel_size);
+    memcpy(pp, from, size);
+    *kernel_size += align_size(size, align);
+    return pp;
+}
+
+static inline void* paddr_to_vaddr(void* ptr, size_t pbase, size_t vbase)
+{
+    return (void*)((size_t)ptr - pbase + vbase);
+}
+
+#endif // _BOOT_LIBBOOT_MEM_MEM_H