ref: initramfs -> StartupVolume; /bin -> /System/CoreServices;

ref(Kernel/VM/Heap): malloc -> VMHeapAllocate; free -> VMHeapFree; realloc -> VMHeapResize

.tokeignore

@@ -6,3 +6,4 @@ kernel/data
 bootloader/
 bootloader/src/uefi
 initramfs/
+kernel/inc/Data

CMakeLists.txt

@@ -30,21 +30,25 @@ add_subdirectory(bootloader)
 add_subdirectory(kernel)
 add_subdirectory(userspace)
 
-if(MCOPY_EXE AND MKFS_EXE AND CPIO_EXE)
+set(SYSTEM_SERVICES
+    init
+    debug
+    termosh
+)
+
+set(VOLUME_ROOT "${CMAKE_BINARY_DIR}/StartupVolume")
+set(INITRAMFS_CPIO_FILE "${CMAKE_BINARY_DIR}/StartupVolume.cpio")
 set(IMG_FILE "${CMAKE_BINARY_DIR}/termOS.img")
 
-    set(INITRAMFS_SRC_DIR "${CMAKE_SOURCE_DIR}/initramfs")
+if(MCOPY_EXE AND MKFS_EXE AND CPIO_EXE)
-    set(INITRAMFS_CPIO_FILE "${CMAKE_BINARY_DIR}/initramfs.cpio")
-    file(GLOB_RECURSE INIT_FILES "${INITRAMFS_SRC_DIR}/*")
-
 add_custom_command(
         OUTPUT ${INITRAMFS_CPIO_FILE}
-        COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_BINARY_DIR}
+        COMMAND ${CMAKE_COMMAND} -E make_directory ${VOLUME_ROOT}
         COMMAND sh -c "find . -mindepth 1 ! -name '*.cpio' -print0 | ${CPIO_EXE} --null -ov -H newc > \"${INITRAMFS_CPIO_FILE}\""
-        WORKING_DIRECTORY ${INITRAMFS_SRC_DIR}
+        WORKING_DIRECTORY ${VOLUME_ROOT}
-        DEPENDS ${INIT_FILES} init debug termosh
+        DEPENDS ${SYSTEM_SERVICES}
         VERBATIM
-        COMMENT "Packing initramfs to cpio..."
+        COMMENT "Packing StartupVolume to cpio..."
     )
     
     add_custom_command(
@@ -54,7 +58,7 @@ if(MCOPY_EXE AND MKFS_EXE AND CPIO_EXE)
         COMMAND mmd -i ${IMG_FILE} ::/EFI ::/EFI/BOOT
         COMMAND ${MCOPY_EXE} -i ${IMG_FILE} $<TARGET_FILE:BOOTX64> ::/EFI/BOOT/BOOTX64.EFI
         COMMAND ${MCOPY_EXE} -i ${IMG_FILE} ${CMAKE_BINARY_DIR}/bin/kernel.bin ::/kernel.bin
-        COMMAND ${MCOPY_EXE} -i ${IMG_FILE} ${INITRAMFS_CPIO_FILE} ::/initramfs.cpio
+        COMMAND ${MCOPY_EXE} -i ${IMG_FILE} ${INITRAMFS_CPIO_FILE} ::/StartupVolume.cpio
         DEPENDS BOOTX64 kernel ${INITRAMFS_CPIO_FILE}
         VERBATIM
         COMMENT "Generating bootable image: ${IMG_FILE}"

bootloader/src/main.c

@@ -78,10 +78,10 @@ int main()
     efi_file_handle_t* initramfs_file;
     uintn_t iinfo_size = 0;
     efi_file_info_t* ifile_info = nullptr;
-    status = root->Open(root, &initramfs_file, L"initramfs.cpio", EFI_FILE_MODE_READ, 0);
+    status = root->Open(root, &initramfs_file, L"StartupVolume.cpio", EFI_FILE_MODE_READ, 0);
     
     if (EFI_ERROR(status)) {
-        print_initramfs_warning(L"initramfs.cpio is missing");
+        print_initramfs_warning(L"StartupVolume.cpio is missing");
         boot_info->initramfs.address = nullptr;
         boot_info->initramfs.size = 0;
     } else {

kernel/inc/MM/Heap.h

@@ -1,24 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-// Copyright (c) 2026 0xKarinyash
-
-#pragma once
-#include <types.h>
-
-#define KERNEL_HEAP_START   0xFFFFFFFFC0000000
-#define PHYS_TO_HEAP(phys) ((phys) + KERNEL_HEAP_START)
-#define HEAP_TO_PHYS(phys) ((phys) - KERNEL_HEAP_START)
-
-#define HEADER_MAGIC 0x1CE
-
-typedef struct VMHeapBlockHeader {
-    UInt64 magic;
-    struct VMHeapBlockHeader* next;
-    struct VMHeapBlockHeader* previous;
-    UInt64 size;
-    bool isFree;
-} block_header;
-
-void VMHeapInitialize();
-void* malloc(UInt64 size);
-void free(void* ptr);
-void* realloc(void* ptr, UInt64 new_size);

kernel/inc/VM/Heap.h

@@ -6,14 +6,12 @@
 
 enum {
     kVMKernelHeapStart = 0xFFFFFFFFC0000000,
-    kVMHeapSizePages = 1024
+    kVMHeapSizePages = 1024,
+    kVMHeapBlockHeaderMagic = 0x1CE
 };
 
 #define PHYS_TO_HEAP(phys) ((phys) + KERNEL_HEAP_START)
 #define HEAP_TO_PHYS(phys) ((phys) - KERNEL_HEAP_START)
-
-#define HEADER_MAGIC 0x1CE
-
 typedef struct VMHeapBlockHeader {
     UInt64 magic;
     struct VMHeapBlockHeader* next;
@@ -23,6 +21,6 @@ typedef struct VMHeapBlockHeader {
 } VMHeapBlockHeader;
 
 void VMHeapInitialize();
-void* malloc(UInt64 size);
+void* VMHeapAllocate(UInt64 size);
-void free(void* ptr);
+void VMHeapFree(void* ptr);
-void* realloc(void* ptr, UInt64 newSize);
+void* VMHeapResize(void* ptr, UInt64 newSize);

kernel/src/FS/CPIO.c

@@ -59,7 +59,7 @@ FSVNode* FSCPIOMount(void* baseAddress, UInt64 totalSize) {
     UInt8* currentPointer = (UInt8*)baseAddress;
     UInt8* endPointer = currentPointer + totalSize;
 
-    FSVNode* rootNode = (FSVNode*)malloc(sizeof(FSVNode));
+    FSVNode* rootNode = (FSVNode*)VMHeapAllocate(sizeof(FSVNode));
     if (!rootNode) OSPanic("CPIO: Failed to allocate memory for root node");
     
     memset(rootNode, 0, sizeof(FSVNode));
@@ -86,7 +86,7 @@ FSVNode* FSCPIOMount(void* baseAddress, UInt64 totalSize) {
         UInt64 offsetToData = FSCPIO_ALIGN4(headerAndNameLength);
         void* fileContent = (void*)(currentPointer + offsetToData);
 
-        FSVNode* newNode = (FSVNode*)malloc(sizeof(FSVNode));
+        FSVNode* newNode = (FSVNode*)VMHeapAllocate(sizeof(FSVNode));
         if (!newNode) OSPanic("CPIO: Failed to allocate memory for new node");
         
         memset(newNode, 0, sizeof(FSVNode));

kernel/src/OS/Exec/OSLoader.c

@@ -31,7 +31,7 @@ Int32 OSLoaderProcessSpawn(const char* executablePath, const char* processName)
         return -1;
     }
 
-    OSProcess* newProcess = (OSProcess*)malloc(sizeof(OSProcess));
+    OSProcess* newProcess = (OSProcess*)VMHeapAllocate(sizeof(OSProcess));
     if (!newProcess) {
         return -2;
     }
@@ -44,9 +44,9 @@ Int32 OSLoaderProcessSpawn(const char* executablePath, const char* processName)
     newProcess->heapCurrentPointer = kOSHeapStart;
     strncpy(newProcess->name, processName, 31);
 
-    UInt8* imageBuffer = (UInt8*)malloc(executableFile->dataLength);
+    UInt8* imageBuffer = (UInt8*)VMHeapAllocate(executableFile->dataLength);
     if (!imageBuffer) {
-        free(newProcess);
+        VMHeapFree(newProcess);
         return -3;
     }
 
@@ -54,12 +54,12 @@ Int32 OSLoaderProcessSpawn(const char* executablePath, const char* processName)
 
     UInt64 entryPoint = HOTLoad(newProcess, imageBuffer);
     if (!entryPoint) {
-        free(imageBuffer);
+        VMHeapFree(imageBuffer);
-        free(newProcess);
+        VMHeapFree(newProcess);
         return -4;
     }
 
-    free(imageBuffer);
+    VMHeapFree(imageBuffer);
 
     VMVirtualMemorySetupUserStack((UInt64*)newProcess->physicalPML4);
     
@@ -69,9 +69,9 @@ Int32 OSLoaderProcessSpawn(const char* executablePath, const char* processName)
 }
 
 void init_task_entry() {
-    Int32 pid = OSLoaderProcessSpawn("/bin/init", "init");
+    Int32 pid = OSLoaderProcessSpawn("/System/CoreServices/init", "init");
     if (pid < 0) {
-        OSPanic("FATAL: Failed to spawn /bin/init");
+        OSPanic("FATAL: Failed to spawn /System/CoreServices/init");
     }
 
     while (1) { __asm__("sti; hlt"); }

kernel/src/OS/OSScheduler.c

@@ -29,7 +29,7 @@ void OSSchedulerInitialize() {
     sOSSchedulerKernelProcess.physicalPML4 = gVMKernelPML4Physical;
     strcpy(sOSSchedulerKernelProcess.name, "kernel");
 
-    OSTask* kernelTask = (OSTask*)malloc(sizeof(OSTask));
+    OSTask* kernelTask = (OSTask*)VMHeapAllocate(sizeof(OSTask));
     memset(kernelTask, 0, sizeof(OSTask));
     kernelTask->id = 0;
     kernelTask->process = &sOSSchedulerKernelProcess;
@@ -43,12 +43,12 @@ void OSSchedulerInitialize() {
 }
 
 OSTask* OSSchedulerSpawn(void(*entry)(), OSProcess* owner, Boolean isUser, UInt64 fixedUserStackPointer) {
-    OSTask* task = (OSTask*)malloc(sizeof(OSTask));
+    OSTask* task = (OSTask*)VMHeapAllocate(sizeof(OSTask));
     if (!task) return nullptr;
     if (!owner) owner = &sOSSchedulerKernelProcess;
 
     UInt64 stackSize = 16384;
-    UInt8* stackBaseAddress = (UInt8*)malloc(stackSize);
+    UInt8* stackBaseAddress = (UInt8*)VMHeapAllocate(stackSize);
     if (!stackBaseAddress) OSPanic("OOM for task stack");
     UInt64* rsp = (UInt64*)(stackBaseAddress + stackSize); 
 

kernel/src/VM/Heap.c

@@ -11,7 +11,7 @@
 extern UInt64* gVMKernelPML4;
 static VMHeapBlockHeader* sVMHeapListHead = nullptr;
 
-void combine_forward(VMHeapBlockHeader* current) {
+static void sVMHeapCombineForward(VMHeapBlockHeader* current) {
     if (!current->next || !current->next->isFree) return;
     current->size += sizeof(VMHeapBlockHeader) + current->next->size;
     current->next = current->next->next;
@@ -30,14 +30,14 @@ void VMHeapInitialize() {
     }
 
     sVMHeapListHead = (VMHeapBlockHeader*)heapStart;
-    sVMHeapListHead->magic = HEADER_MAGIC;
+    sVMHeapListHead->magic = kVMHeapBlockHeaderMagic;
     sVMHeapListHead->size = (kVMHeapSizePages * kVMPageSize) - sizeof(VMHeapBlockHeader);
     sVMHeapListHead->isFree = true;
     sVMHeapListHead->next = nullptr;
     sVMHeapListHead->previous = nullptr;
 }
 
-void* malloc(UInt64 size) {
+void* VMHeapAllocate(UInt64 size) {
     if (size == 0) return nullptr;
     UInt64 alignedSize = (size + 15) & ~15;
 
@@ -50,7 +50,7 @@ void* malloc(UInt64 size) {
                 new_block->isFree = true;
                 new_block->next = current->next;
                 new_block->previous = current;
-                new_block->magic = HEADER_MAGIC;
+                new_block->magic = kVMHeapBlockHeaderMagic;
                 
                 if (current->next) current->next->previous = new_block;
                 current->next = new_block;
@@ -65,21 +65,21 @@ void* malloc(UInt64 size) {
     return nullptr;
 }
 
-void free(void* pointer) {
+void VMHeapFree(void* pointer) {
     if (!pointer) return;
 
     VMHeapBlockHeader* current = (VMHeapBlockHeader*)((UInt64)pointer - sizeof(VMHeapBlockHeader));
-    if (current->magic != HEADER_MAGIC) return;
+    if (current->magic != kVMHeapBlockHeaderMagic) return;
     
     current->isFree = true;
-    if (current->next && current->next->isFree) combine_forward(current);
+    if (current->next && current->next->isFree) sVMHeapCombineForward(current);
-    if (current->previous && current->previous->isFree) combine_forward(current->previous);
+    if (current->previous && current->previous->isFree) sVMHeapCombineForward(current->previous);
 }
 
-void* realloc(void* pointer, UInt64 newSize) {
+void* VMHeapResize(void* pointer, UInt64 newSize) {
-    if (!pointer) return malloc(newSize);
+    if (!pointer) return VMHeapAllocate(newSize);
     if (newSize == 0) { 
-        free(pointer); 
+        VMHeapFree(pointer); 
         return nullptr; 
     }
 
@@ -89,15 +89,15 @@ void* realloc(void* pointer, UInt64 newSize) {
     if (current->next &&
         current->next->isFree &&
         (current->size + sizeof(VMHeapBlockHeader) + current->next->size) >= newSize) { // why ts so fucking unreadable
-            combine_forward(current);
+            sVMHeapCombineForward(current);
             return pointer;
     }
 
-    void* newPointer = malloc(newSize);
+    void* newPointer = VMHeapAllocate(newSize);
     if (!newPointer) return nullptr;
 
     memcpy(newPointer, pointer, current->size);
-    free(pointer);
+    VMHeapFree(pointer);
 
     return newPointer;
 }

userspace/init/src/main.c

@@ -7,7 +7,7 @@
 // TODO: read .cfg and spawn what stated there
 int main() {
     while (1) {
-        Int32 pid = spawn("/bin/termosh");
+        Int32 pid = spawn("/System/CoreServices/termosh");
         if (pid < 0) return pid;
         wait(pid);
     }

userspace/libterm/CMakeLists.txt

@@ -54,7 +54,9 @@ function(add_termos_executable NAME SOURCES)
     )
 
     set(ELF2HOT_DIR "${CMAKE_SOURCE_DIR}/tools/elf2hot")
-    set(FINAL_HOT_PATH "${CMAKE_SOURCE_DIR}/initramfs/bin/${NAME}")
+    set(STARTUP_VOLUME_DIR "${CMAKE_BINARY_DIR}/StartupVolume/System/CoreServices")
+    file(MAKE_DIRECTORY "${STARTUP_VOLUME_DIR}")
+    set(FINAL_HOT_PATH "${STARTUP_VOLUME_DIR}/${NAME}")
 
     add_custom_command(TARGET ${NAME} POST_BUILD
         COMMAND cargo run --release --quiet -- $<TARGET_FILE:${NAME}> ${FINAL_HOT_PATH}

userspace/termosh/src/main.c

@@ -25,7 +25,7 @@ int main() {
             case TOKEN_SPAWN: if (tokens_count >= 2) cmd_spawn(tokens[1]); break;
             default: {
                 char buff[256];
-                snprintf(buff, sizeof(buff), "/bin/%s", tokens[0]);
+                snprintf(buff, sizeof(buff), "/System/CoreServices/%s", tokens[0]);
                 cmd_spawn(buff);
             }
         }