Trying whatever i can to run busybox 😭

Author: pradosh-arduino

source/kernel/C/executables/elf.c

@@ -10,7 +10,6 @@
  */
 #include <executables/elf.h>
 #include <fdlfcn.h>
-#include <graphics.h>
 #include <memory.h>
 #include <stdint.h>
 #include <heap.h>
@@ -131,6 +130,132 @@ static int elf_load_tls_template_from_vfs(const char* path, elf_image_info_t* in
     return 0;
 }
 
+typedef uint64_t (*elf_ifunc_resolver_t)(void);
+
+static int elf_apply_relocation_entries(const Elf64_Rela* relocs, uint64_t reloc_count)
+{
+    if (!relocs || reloc_count == 0)
+        return 0;
+
+    for (uint64_t i = 0; i < reloc_count; ++i) {
+        const Elf64_Rela* reloc = &relocs[i];
+        uint32_t reloc_type = ELF64_R_TYPE(reloc->r_info);
+        uint64_t* target = (uint64_t*)reloc->r_offset;
+
+        if (!target) {
+            eprintf("elf: invalid relocation target");
+            return -1;
+        }
+
+        switch (reloc_type) {
+            case R_X86_64_RELATIVE:
+                *target = (uint64_t)reloc->r_addend;
+                break;
+
+            case R_X86_64_IRELATIVE: {
+                elf_ifunc_resolver_t resolver = (elf_ifunc_resolver_t)(uint64_t)reloc->r_addend;
+                *target = resolver ? resolver() : 0;
+                break;
+            }
+
+            default:
+                break;
+        }
+    }
+
+    return 0;
+}
+
+static int elf_apply_relocations_from_memory(void* file_base_address, uint64_t file_size, const Elf64_Ehdr* header)
+{
+    if (!file_base_address || !header || header->e_shoff == 0 || header->e_shnum == 0)
+        return 0;
+
+    uint64_t shdr_bytes = (uint64_t)header->e_shnum * header->e_shentsize;
+    if (header->e_shentsize != sizeof(Elf64_Shdr) || header->e_shoff + shdr_bytes > file_size) {
+        eprintf("elf: invalid section header table");
+        return -1;
+    }
+
+    Elf64_Shdr* shdrs = (Elf64_Shdr*)((uint8_t*)file_base_address + header->e_shoff);
+    for (uint16_t i = 0; i < header->e_shnum; ++i) {
+        Elf64_Shdr* sh = &shdrs[i];
+        if (sh->sh_type != SHT_RELA || sh->sh_size == 0)
+            continue;
+
+        if (sh->sh_offset + sh->sh_size > file_size || (sh->sh_size % sizeof(Elf64_Rela)) != 0) {
+            eprintf("elf: invalid SHT_RELA bounds");
+            return -1;
+        }
+
+        if (elf_apply_relocation_entries((Elf64_Rela*)((uint8_t*)file_base_address + sh->sh_offset),
+                                         sh->sh_size / sizeof(Elf64_Rela)) != 0)
+            return -1;
+    }
+
+    return 0;
+}
+
+static int elf_apply_relocations_from_vfs(const char* path, uint32_t file_size, const Elf64_Ehdr* header)
+{
+    if (!path || !header || header->e_shoff == 0 || header->e_shnum == 0)
+        return 0;
+
+    uint64_t shdr_bytes = (uint64_t)header->e_shnum * header->e_shentsize;
+    if (header->e_shentsize != sizeof(Elf64_Shdr) || header->e_shoff + shdr_bytes > file_size) {
+        eprintf("elf: invalid section header table");
+        return -1;
+    }
+
+    Elf64_Shdr* shdrs = kmalloc(shdr_bytes);
+    if (!shdrs) {
+        eprintf("elf: failed to allocate section headers");
+        return -1;
+    }
+
+    if (elf_vfs_read_exact_path(path, (uint32_t)header->e_shoff, shdrs, (uint32_t)shdr_bytes) != 0) {
+        eprintf("elf: failed to read section headers");
+        kfree(shdrs);
+        return -1;
+    }
+
+    for (uint16_t i = 0; i < header->e_shnum; ++i) {
+        Elf64_Shdr* sh = &shdrs[i];
+        if (sh->sh_type != SHT_RELA || sh->sh_size == 0)
+            continue;
+
+        if (sh->sh_offset + sh->sh_size > file_size || (sh->sh_size % sizeof(Elf64_Rela)) != 0) {
+            eprintf("elf: invalid SHT_RELA bounds");
+            kfree(shdrs);
+            return -1;
+        }
+
+        Elf64_Rela* relocs = kmalloc(sh->sh_size);
+        if (!relocs) {
+            eprintf("elf: failed to allocate relocations");
+            kfree(shdrs);
+            return -1;
+        }
+
+        if (elf_vfs_read_exact_path(path, (uint32_t)sh->sh_offset, relocs, (uint32_t)sh->sh_size) != 0) {
+            eprintf("elf: failed to read relocations");
+            kfree(relocs);
+            kfree(shdrs);
+            return -1;
+        }
+
+        int rc = elf_apply_relocation_entries(relocs, sh->sh_size / sizeof(Elf64_Rela));
+        kfree(relocs);
+        if (rc != 0) {
+            kfree(shdrs);
+            return -1;
+        }
+    }
+
+    kfree(shdrs);
+    return 0;
+}
+
 static uint64_t elf_runtime_addr_for_offset(Elf64_Phdr* headers, uint16_t phnum, uint64_t file_offset)
 {
     for (uint16_t i = 0; i < phnum; ++i) {
@@ -170,6 +295,7 @@ static void elf_log_load_progress(uint16_t current, uint16_t total, Elf64_Phdr*
            ph ? ph->p_offset : 0);
 }
 
+
 static uint64_t elf_stage_phdrs_for_user(Elf64_Phdr* headers, uint64_t phdr_bytes)
 {
     if (!headers || phdr_bytes == 0)
@@ -365,6 +491,9 @@ void* elf_load_from_memory_ex(void* file_base_address, uint64_t file_size, elf_i
             return NULL;
     }
 
+    if (elf_apply_relocations_from_memory(file_base_address, file_size, &header) != 0)
+        return NULL;
+
     return (void*)header.e_entry;
 }
 
@@ -467,6 +596,11 @@ void* elf_load_from_vfs_ex(const char* path, elf_image_info_t* info)
         }
     }
 
+    if (elf_apply_relocations_from_vfs(path, size, &header) != 0) {
+        kfree(program_headers);
+        return NULL;
+    }
+
     kfree(program_headers);
     void* entry = (void*)header.e_entry;
     return entry;

source/kernel/C/interrupts/isr.c

@@ -14,6 +14,7 @@
 #include <memory.h>
 #include <drivers/rtl8139.h>
 #include <syscalls.h>
+#include <debugger.h>
 
 irq_handler interrupt_handlers[256];
 
@@ -53,6 +54,27 @@ static void log_page_fault_details(InterruptFrame* frame) {
             (int)((err >> 4) & 0x1));
 }
 
+static int emulate_syscall_instruction_if_present(InterruptFrame* frame) {
+    if (!frame)
+        return 0;
+
+    if ((frame->cs & 0x3) != 0x3)
+        return 0;
+
+    uint8_t* ip = (uint8_t*)frame->rip;
+    if (!ip)
+        return 0;
+
+    if (ip[0] == 0x0F && ip[1] == 0x05) {
+        debug_printf("isr: emulating SYSCALL as int 0x80 at rip=%u nr=%u\n", frame->rip, frame->rax);
+        syscalls_handler(frame);
+        frame->rip += 2;
+        return 1;
+    }
+
+    return 0;
+}
+
 void exceptionHandler(InterruptFrame* frame) {
     enable_logging = false; // disables logger as fast as it can to get the last instance of panic.
     log_page_fault_details(frame);
@@ -67,6 +89,9 @@ void exceptionHandler(InterruptFrame* frame) {
         case 6:
             if (skip_endbr64_if_present(frame))
                 return;
+            if(emulate_syscall_instruction_if_present(frame))
+                return;
+
             meltdown_screen("Invalid opcode detected!", __FILE__, __LINE__, frame->err_code, getCR2(), frame->int_no, frame);
 			break;
         case 8:

source/kernel/C/syscalls.c

@@ -1320,6 +1320,7 @@ void syscalls_handler(InterruptFrame* frame){
             break;
         default:
             warn(linux_syscalls_prefix "Unknown, returning -ENOSYS", __FILE__);
+            debug_printf(linux_syscalls_prefix "Unknown : requested %u\n", frame->rax);
             frame->rax = -LINUX_ENOSYS;
             break;
     }