karina/termOS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
ref(Kernel/VM/Heap): malloc -> VMHeapAllocate; free -> VMHeapFree; realloc -> VMHeapResize
This commit is contained in:
Karina
2026-01-31 16:11:45 +04:00
parent c30d57d06e
commit ee67cef4f8
12 changed files with 58 additions and 77 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.tokeignore
+1
View File
@@ -6,3 +6,4 @@ kernel/data
bootloader/
bootloader/src/uefi
initramfs/
kernel/inc/Data
CMakeLists.txt
+16 -12
View File
@@ -30,21 +30,25 @@ add_subdirectory(bootloader)
add_subdirectory(kernel)
add_subdirectory(userspace)
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")
if(MCOPY_EXE AND MKFS_EXE AND CPIO_EXE)
set(IMG_FILE "${CMAKE_BINARY_DIR}/termOS.img")
set(INITRAMFS_SRC_DIR "${CMAKE_SOURCE_DIR}/initramfs")
set(INITRAMFS_CPIO_FILE "${CMAKE_BINARY_DIR}/initramfs.cpio")
file(GLOB_RECURSE INIT_FILES "${INITRAMFS_SRC_DIR}/*")
add_custom_command(
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}
DEPENDS ${INIT_FILES} init debug termosh
WORKING_DIRECTORY ${VOLUME_ROOT}
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
+2 -2
View File
@@ -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
-24
View File
@@ -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
+5 -7
View File
@@ -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 free(void* ptr);
void* realloc(void* ptr, UInt64 newSize);
void* VMHeapAllocate(UInt64 size);
void VMHeapFree(void* ptr);
void* VMHeapResize(void* ptr, UInt64 newSize);
kernel/src/FS/CPIO.c
+2 -2
View File
@@ -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
+8 -8
View File
@@ -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);
free(newProcess);
VMHeapFree(imageBuffer);
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
+3 -3
View File
@@ -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
+14 -14
View File
@@ -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->previous && current->previous->isFree) combine_forward(current->previous);
if (current->next && current->next->isFree) sVMHeapCombineForward(current);
if (current->previous && current->previous->isFree) sVMHeapCombineForward(current->previous);
}
void* realloc(void* pointer, UInt64 newSize) {
if (!pointer) return malloc(newSize);
void* VMHeapResize(void* pointer, UInt64 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
+1 -1
View File
@@ -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
+3 -1
View File
@@ -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
+1 -1
View File
@@ -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);
}
}