Added software vector operations

makefile

@@ -1,6 +1,6 @@
 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:=-g -c -m32 -fno-pie -mno-sse -O3 -D __bits__=32 -Wall -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
 LDFLAGS_MODULE:=-melf_i386 -e init --no-dynamic-linker -static -nostdlib
@@ -31,6 +31,7 @@ kernel:
 	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 -pie bin/modules/disk_driver.o -o idm.elf -melf_i386 -e init --no-dynamic-linker -static -nostdlib
+# 	ld bin/modules/fs_driver.o -o ifsm.elf -melf_i386
 	ld -pie bin/modules/fs_driver.o -o ifsm.elf -melf_i386 -e init --no-dynamic-linker -static -nostdlib
 # %.o: $(SRCS)
 # 	mkdir -p bin/kernel/$(shell dirname $@)

src/bootloader/main.s

@@ -887,11 +887,13 @@ disk_module_struct:
     .ptr: dd 0
     .size: dd 0
     .type:  dd 1
+    .flags: db 0
     .next_entry: dd fs_module_struct
 fs_module_struct:
     .ptr: dd 0
     .size: dd 0
     .type: dd 2
+    .flags: db 0
     .next_entry: dd 0
 kernel_file: db "kernel", 0, 0, "elf"
 disk_module_file: db "idm", 0, 0, 0, 0, 0, "elf"

src/kernel/drivers/serial.c

@@ -77,6 +77,12 @@ void vprintf(char *string, va_list vars){
                     string++;
                     ptr = va_arg(vars, char *);
                     printf(ptr);
+                    continue;
+                case 'c':
+                    string++;
+                    num = va_arg(vars, int32_t);
+                    printf((char[]){num, 0});
+                    continue;
             }
         }
         outb(com_ports[0], *string);

src/kernel/shared/kstdlib.c

@@ -1,5 +1,6 @@
 #include "kstdlib.h"
 #include <stdarg.h>
+#include "memory.h"
 
 char* log_info_types[] = {
     "\b",
@@ -17,4 +18,56 @@ void mlog(char *module, char *str, uint32_t type, ...){
     }
     printf("[ %s %s ]", module, log_info_types[type]);
     vprintf(str, vars);
+}
+
+//set initializer to 0 to create an uninitialized vector of size elements
+vector_t *init_vector(void *vecptr, uint32_t sizeof_elements, uint32_t elements, void *initializer){
+    vector_t *ret = vecptr;
+    if (vecptr == 0){
+        ret = kmalloc(1);
+    }
+    ret->sizeof_elements = sizeof_elements;
+    ret->size = elements;
+    uint32_t pages = (elements * sizeof_elements)/4096 + 1;
+    if(elements > 0) ret->ptr = kmalloc(pages);
+    if(initializer == 0) return ret;
+    for(uint8_t i = 0; i < elements * sizeof_elements; i++){
+        ((uint8_t *)(ret->ptr))[i] = ((uint8_t *)initializer)[i];
+    }
+    return ret;
+}
+
+void *vector_get(uint32_t pos, vector_t *vector){
+    if(pos > vector->size){
+        return 0;
+    }
+    return vector->ptr + (pos*vector->sizeof_elements);
+}
+
+//pos MUST be within vector bounds;
+void vector_set(uint32_t pos, vector_t *vector, void *new_element){
+    if(pos > vector->size){
+        return;
+    }
+    for(uint32_t i = 0; i < vector->sizeof_elements; i++){
+        ((uint8_t *)(vector->ptr))[i] = ((uint8_t *)new_element)[i];
+    }
+}
+void vector_push(vector_t *vector, void *new_element){
+    if((vector->size * vector->sizeof_elements)/4096 + 1> ((vector->size + 1) * vector->sizeof_elements)/4096 + 1){
+        vector->size++;
+        void *newptr = kmalloc((vector->size * vector->sizeof_elements)/4096);
+        for(uint8_t i = 0; i < (vector->size - 1) * vector->sizeof_elements; i++){
+            ((uint8_t *)(newptr))[i] = ((uint8_t *)vector->ptr)[i * vector->size];
+        }
+    }
+    for(uint32_t i = 0; i < vector->sizeof_elements; i++){
+        ((uint8_t *)(vector->ptr))[vector->size + i] = ((uint8_t *)new_element)[vector->size + i];
+    }
+}
+void vector_pop(uint32_t pos, vector_t *vector, void *element){
+    for(uint32_t i = 0; i < vector->sizeof_elements; i++){
+        ((uint8_t *)element)[i] = ((uint8_t *)(vector->ptr))[i];
+    }
+    vector->size--;
 }

src/kernel/shared/kstdlib.h

@@ -12,10 +12,23 @@
 typedef struct module_linked_list{
     void *ptr;
     uint32_t size;
-    uint32_t type;
+    uint32_t id;
+    uint8_t flags;
     struct module_linked_list *link;
 }__attribute__((packed)) kernel_module_t;
 
+typedef struct vector{
+    void *ptr;
+    uint32_t size;
+    uint32_t sizeof_elements;
+}vector_t;
+
+vector_t *init_vector(void *vecptr, uint32_t sizeof_elements, uint32_t elements, void *initializer);
+void *vector_get(uint32_t pos, vector_t *vector);
+void vector_set(uint32_t pos, vector_t *vector, void *new_element);
+void vector_push(vector_t *vector, void *new_element);
+void vector_pop(uint32_t pos, vector_t *vector, void *element);
+
 typedef struct kernel_info{
     void *mmap_ptr;
     uint16_t mmap_entry_count;

src/kernel/system/elf.c

@@ -9,10 +9,9 @@ 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.paddr, entry.data_offset, entry.msize, entry.alignment);
+    // printf("Type: %x, Flags: %s, Vaddr: %x, Offset: %x, Size: %x, Align: %x\n", entry.type, flags[entry.flags], entry.paddr, 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);
-    printf("Base: %x\n", base_segment);
     if(entry.type == 1){
         if(((elf_header_t *)(file_data))->type == ELF_TYPE_SHARED){
             if(base_segment == 0){
@@ -24,23 +23,28 @@ void *load_segment(program_entry_t entry, void *file_data, void *base_segment, u
                 uint32_t count = 1;
                 count += ((entry.vaddr+entry.msize) - entry.vaddr) ? 1 : 0;
                 count += entry.msize/4096 + 1;
-                // printf("count: %x\n", count);
-                // for (;;);
                 for(uint32_t i = 0; i < count; i++){
                     map(segment + (i << 12)/4, (void *)pm_alloc(), PT_PRESENT | map_flags);
-                    // printf("Mapping : %x\n", segment + (i << 12)/4);
                 }
             }
             for(uint32_t i = 0; i < entry.fsize/sizeof(uint32_t) + 1; i++){
                 segment[i] = ((uint32_t *)(file_data))[i + entry.data_offset/sizeof(uint32_t)];
-                // printf("Writing to %x\n", (uint32_t)base_segment+i+entry.vaddr);
             }
         }
+        else if(((elf_header_t *)(file_data))->type == ELF_TYPE_EXE){
+            //This is where Not shared objects and drivers will be loaded
+            // I'll do this when I stop hyperfixating on the other parts of my operating system
+        }
     }
-    printf("data_offset: %x\n", data_offset);
+    if (entry.type == 2){
+        //What is this for?
+        //TODO: Find out how to handle Dynamic sections
+    }
+    // printf("data_offset: %x\n", data_offset);
     return base_segment;
 }
 
+//returns entry address of elf file
 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){
@@ -50,27 +54,8 @@ void *load_elf(void *file_data, uint32_t map_flags){
     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;
+    return base_segment + header->entry_offset;
-    void (*vt)(uint32_t) = base_segment + header->entry_offset;
-    // printf("%x", *vt);
-    (*vt)(0);
-    // printf("%x\n", i);
-    // for(;;);
-    // (*vt)();
-    printf(":D\n");
-    return 0;
 }

src/kernel/system/modules.c

@@ -2,22 +2,32 @@
 #include "../shared/kstdlib.h"
 #include "elf.h"
 #include "../shared/memory.h"
+#include <stdarg.h>
+
 
 #define MODULE_NAME "MLOADER"
 
+vector_t *modules;
+vector_t *module_deps;
+
+uint32_t module_api(uint32_t func, ...){
+    
+}
+
 void init_modules(kernel_info_t *kernel_info){
     mlog(MODULE_NAME, "Initializing Boot-Time Modules\n", MLOG_PRINT);
     kernel_module_t *module = kernel_info->loaded_modules;
-    uint32_t i = 0;
+    // uint32_t i = 0;
+    modules = init_vector(0, sizeof(module_t), 0, 0);
     while(module){
         if(!module->ptr){
             continue;
         }
-        // printf("Module Type: %x, Module Size (Bytes): %x, Ptr: %x\n", module->type, module->size, module->ptr);
+        void (*entry)(void* api) = load_elf(module->ptr, PT_SYS);
-        load_elf(module->ptr, 0);
+        mlog(MODULE_NAME, "Loaded module with ID %x\n", MLOG_PRINT, module->id);
-        mlog(MODULE_NAME, "Loaded module of type %x\n", MLOG_PRINT, module->type);
         // module->type |= 0x8000;//set present flag in type
-        module->type |= MODULE_PRESENT;
+        module->flags |= MODULE_PRESENT;
         module = module->link;
+        (*entry)(0);
     }
 }

src/kernel/system/modules.h

@@ -2,6 +2,13 @@
 #include <stdint.h>
 #include "../shared/kstdlib.h"
 
-#define MODULE_PRESENT 0x8000
+#define MODULE_PRESENT 0x80
+
+typedef struct module{
+    void *init_entry;
+    uint32_t id;
+    char name[16];
+    uint8_t flags;
+}module_t;
 
 void init_modules(kernel_info_t *kernel_info);

src/kmodules/disk_driver.c

@@ -5,11 +5,6 @@ KOS_MAPI_FP api;
 
 void init(KOS_MAPI_FP module_api){
     uint16_t *t = (void *)0xb8000;
-    *t = 0x0f41;
+    *t = 0xf000;
-    api = module_api;
-    // for(int i = 0; i < 1000; i++){
-    //     (*t)++;
-    //     // asm volatile( " " );
-    // }
     return;
 }

src/kmodules/fs_driver.c

@@ -5,12 +5,6 @@ KOS_MAPI_FP api;
 
 void init(KOS_MAPI_FP module_api){
     uint16_t *t = (void *)0xb8002;
-    *t = 0x0f41;
+    *t = 0xf000;
-    // for(int i = 0; i < 1000; i++){
-    //     (*t)++;
-    //     // asm volatile( " " );
-    // }
-    // t = 0x50000000;
-    // *t = 1;
     return;
 }