Working on elf loading

makefile

@@ -1,7 +1,7 @@
 CC := gcc
 AS := nasm
 CFLAGS:=-g -c -m32 -fno-pie -mno-sse -O3 -D __bits__=32 -Wno-int-to-pointer-cast -Wno-pointer-to-int-cast -Wno-incompatible-pointer-types -Wno-address-of-packed-member -Wno-discarded-qualifiers -fno-stack-protector -mno-red-zone -mno-sse -mno-sse2 -ffreestanding -nostdlib -mno-mmx
-CFLAGS_MODULE:=-g -c -m32 -fpie -mno-sse -O3 -D __bits__=32 -Wno-int-to-pointer-cast -Wno-pointer-to-int-cast -Wno-incompatible-pointer-types -Wno-address-of-packed-member -Wno-discarded-qualifiers -fno-stack-protector -mno-red-zone -mno-sse -mno-sse2 -ffreestanding -nostdlib -mno-mmx
+CFLAGS_MODULE:=-g -c -m32 -fpie -pie -mno-sse -O3 -D __bits__=32 -Wno-int-to-pointer-cast -Wno-pointer-to-int-cast -Wno-incompatible-pointer-types -Wno-address-of-packed-member -Wno-discarded-qualifiers -fno-stack-protector -mno-red-zone -mno-sse -mno-sse2 -ffreestanding -nostdlib -mno-mmx
 BL_ASFLAGS := -f bin
 SRCS := $(wildcard src/kernel/*/*.c)
 OBJS := $(patsubst src/kernel/%.c, bin/kernel/%.o, $(SRCS))
@@ -26,9 +26,9 @@ kernel:
 	sh c_build_helper.sh
 	nasm src/kernel/arch_i386/idt.s -o bin/kernel/idt.o -felf32
 	# ld -T linker.ld bin/kernel/entry.o bin/kernel/*.o -melf_i386
-	ld -T linker.ld bin/kernel/*.o -melf_i386 -o kernel.elf
+	ld -T linker.ld bin/kernel/*.o -melf_i386 -o kernel.elf -static
 	ld -T linker.ld -o kernel_interface.elf -r -R kernel.elf -melf_i386
-	ld -pic bin/modules/disk_driver.o kernel_interface.elf -o idm.elf -melf_i386
+	ld -pie bin/modules/disk_driver.o kernel_interface.elf -o idm.elf -melf_i386 -e main --no-dynamic-linker -static -nostdlib
 # %.o: $(SRCS)
 # 	mkdir -p bin/kernel/$(shell dirname $@)
 # 	$(CC) $(CFLAGS) $< -o $@

src/kernel/arch_i386/memory.c

@@ -141,7 +141,7 @@ void *get_new_page(uint32_t flags){
 }
 void *kmalloc(uint32_t size_pgs){
     // static uint8_t fake = 0;
-    uint32_t i = 1 << 10; //4mb/4096 (start search at 1mb line)
+    uint32_t i = 0xc0000000 >> 12; //4mb/4096 (start search at 1mb line)
     while(i < (1 << 22)){
         uint8_t found = 1;
         for(uint32_t j = 0; j < size_pgs; j++){

src/kernel/kmain.c

@@ -32,6 +32,7 @@ extern void kmain(kernel_info_t *kernel_info){
     mlog("KERNEL", "Initializing Scheduler & starting PID 1\n", MLOG_PRINT);
     boot_info = kernel_info;
     init_scheduler();
+    //scheduler doesn't work if there is no PID0, and I don't know why.
     thread_start(pid0);
     thread_start(sysinit);
     enable_interrupts();

src/kernel/shared/kstdlib.c

@@ -2,9 +2,9 @@
 #include <stdarg.h>
 
 char* log_info_types[] = {
-    "",
+    "\b",
     "| DEBUG",
-    "",
+    "\b",
     "| WARNING",
     "| ERROR"
 };

src/kernel/shared/memory.h

@@ -71,6 +71,7 @@ uint32_t get_paddr(void *addr);
 uint32_t pm_alloc();
 void pm_reserve(uint32_t addr);
 void pm_free(uint32_t addr);
+
 inline void set_cr3(void *cr3){
     asm volatile("mov %0, %%eax; mov %%eax, %%cr3":: "r"(cr3));
 }

src/kernel/system/elf.c

@@ -1,5 +1,64 @@
 #include "elf.h"
 #include "../shared/kstdlib.h"
-void *load_elf(void *file_data){
+#include "../shared/memory.h"
+
+#define MODULE_NAME "ELFLOAD"
+
+char *type[] = {"", "reloc", "exec", "shared", "core"};
+char *flags[] = {"---", "X--", "-W-", "XW-", "--R", "X-R", "-WR", "XWR"};
+
+void *load_segment(program_entry_t entry, void *file_data, void *base_segment, uint32_t map_flags){
+    // mlog("ELFLOAD", "p_addr: %d\n", MLOG_DEBUG, entry.paddr);
+    printf("Type: %x, Flags: %s, Vaddr: %x, Offset: %x, Size: %x, Align: %x\n", entry.type, flags[entry.flags], entry.vaddr, entry.data_offset, entry.msize, entry.alignment);
+    uint32_t *segment;
+    uint32_t data_offset = ((elf_header_t *)file_data)->entry_offset;
+    printf("Base: %x\n", base_segment);
+    if(entry.type == 1){
+        if(((elf_header_t *)(file_data))->type == ELF_TYPE_SHARED){
+            if(base_segment == 0){
+                segment = kmalloc(entry.msize/4096 + 1);
+                base_segment = segment;
+            }
+            else{
+                segment = base_segment + (entry.vaddr & 0xfffff000);
+                map(segment, (void *)pm_alloc(), PT_PRESENT | map_flags);
+            }
+            for(uint32_t i = 0; i < entry.fsize/sizeof(uint32_t) + 1; i++){
+                (segment)[i] = ((uint32_t *)(file_data))[i + entry.data_offset];
+                // printf("Writing to %x\n", (uint32_t)base_segment+i+entry.vaddr);
+            }
+        }
+    }
+    printf("dSegment: %x\n", data_offset);
+    return base_segment;
+}
+
+void *load_elf(void *file_data, uint32_t map_flags){
+    elf_header_t *header = file_data;
+    if(header->magic != 0x464c457f || header->type == ELF_TYPE_CORE){
+        return 0;
+    }
+    program_entry_t *program_header = file_data + header->program_header_offset;
+    uint32_t program_header_count = header->program_entry_count;
+    mlog(MODULE_NAME, "PROGRAM ENTRIES: %d\n", MLOG_PRINT, program_header_count);
+    void *base_segment = 0;
+    void *entry_offet = 0;
+    for(uint32_t i = 0; i < program_header_count; i++){
+        // mlog("ELFLOAD", "Type: %x, Flags: %s, ALIGN: %x\n", MLOG_DEBUG, program_header[i].type, flags[program_header[i].flags], program_header[i].alignment);
+        // void *segment_ptr = 0;
+        // if(header->type == ELF_TYPE_SHARED){
+        //     segment_ptr = kmalloc(1 + (program_header[i].msize/4096));
+        // }
+        // else{
+        //     for(uint32_t j = 0; j < program_header[i].msize/4096; j++){
+        //         map(program_header[i].vaddr, get_paddr(file_data + program_header[i].data_offset), );
+        //     }
+        // }
+        base_segment = load_segment(program_header[i], file_data, base_segment, map_flags);
         
     }
+    // void (*vt)(void) = base_segment;
+    uint32_t* vt = base_segment;
+    printf("%x", *vt);
+    // (*vt)();
+}

src/kernel/system/elf.h

@@ -34,4 +34,24 @@ typedef struct{
     uint16_t section_strtab_index;
 }__attribute__((packed)) elf_header_t;
 
-void *load_elf(void *file_data);
+typedef struct{
+    uint32_t type;
+    uint32_t data_offset;
+    uint32_t vaddr;
+    uint32_t paddr;
+    uint32_t fsize;//size in file
+    uint32_t msize;//size in memory
+    uint32_t flags;
+    uint32_t alignment;
+}__attribute__((packed))program_entry_t;
+
+#define PROG_ENT_FLAGS_EXE 1
+#define PROG_ENT_FLAGS_WRITE 2
+#define PROG_END_FLAGS_READ 4
+
+#define ELF_TYPE_RELOC 1
+#define ELF_TYPE_EXE 2
+#define ELF_TYPE_SHARED 3
+#define ELF_TYPE_CORE 4
+
+void *load_elf(void *file_data, uint32_t map_flags);

src/kernel/system/modules.c

@@ -1,13 +1,22 @@
 #include "modules.h"
 #include "../shared/kstdlib.h"
 #include "elf.h"
+#include "../shared/memory.h"
+
+#define MODULE_NAME "MLOADER"
 
 void init_modules(kernel_info_t *kernel_info){
-    mlog("Module Loader", "Initializing Boot-Time Modules", MLOG_PRINT);
+    mlog(MODULE_NAME, "Initializing Boot-Time Modules\n", MLOG_PRINT);
     kernel_module_t *module = kernel_info->loaded_modules;
     while(module){
+        if(!module->ptr){
+            continue;
+        }
         // printf("Module Type: %x, Module Size (Bytes): %x, Ptr: %x\n", module->type, module->size, module->ptr);
-        load_elf(module->ptr);
+        load_elf(module->ptr, 0);
+        mlog(MODULE_NAME, "Loaded module of type %x\n", MLOG_PRINT, module->type);
         module = module->link;
+        // module->type |= 0x8000;//set present flag in type
+        module->type |= MODULE_PRESENT;
     }
 }

src/kernel/system/modules.h

@@ -1,4 +1,7 @@
 #pragma once
 #include <stdint.h>
 #include "../shared/kstdlib.h"
+
+#define MODULE_PRESENT 0x8000
+
 void init_modules(kernel_info_t *kernel_info);

src/kmodules/disk_driver.c

@@ -3,4 +3,8 @@
 void main(){
     uint16_t *t = (void *)0xb8000;
     *t = 0x0f41;
+    for(int i = 0; i < 1000; i++){
+        (*t)++;
+        asm volatile( " " );
+    }
 }