Make naming more consistent, work on VFS

src/kernel/arch_i386/interrupts.c

@@ -120,7 +120,7 @@ void install_irq_handler(void (*handler)(), uint8_t irqno){
     interrupt_handlers[irqno] = handler;
 }
 
-void init_idt(){
+void idt_load(){
     // for(uint32_t i = 0; i < 32; i++){
     //     set_idt_entry(i, (_isr0 + ((_isr1 - _isr0) * i)), IDT_GATE_INT, 0x10);
     //     // printf("int %d: address: %x\n", i, _isr0 + (_isr1 - _isr0) * i);

src/kernel/drivers/cpuio.h

@@ -19,4 +19,14 @@ inline uint16_t inw(uint16_t port){
     uint16_t word = 0;
     asm volatile ("inw %1, %0" : "=a"(word) : "Nd"(port));
     return word;
-}
+}
+
+inline void outl(uint16_t port, uint32_t data){
+    asm volatile ("outl %0, %1" :: "a"(data), "Nd"(port));
+}
+
+inline uint32_t inl(uint16_t port){
+    uint32_t byte = 0;
+    asm volatile ("inl %1, %0" : "=a"(byte) : "Nd"(port));
+    return byte;
+}

src/kernel/drivers/pci.c

@@ -0,0 +1,36 @@
+#include "pci.h"
+#include "../shared/kstdlib.h"
+#include "cpuio.h"
+
+#define MODULE_NAME "PCI"
+
+uint16_t pci_read_config(uint32_t bus, uint32_t slot, uint32_t func, uint8_t offset){
+    uint32_t address = (uint32_t)((bus << 16) | (slot << 11) | (func << 8) | (offset & 0xfc) | ((uint32_t)0x80000000));
+    outl(0xcf8, address);
+    uint16_t tmp = (uint16_t)((inl(0xcfc) >> ((offset & 2) * 8)) & 0xffff);
+    return tmp;
+}
+
+uint16_t pci_get_vendor(uint8_t bus, uint8_t slot){
+    uint16_t vendor = 0, device = 0;
+    vendor = pci_read_config(bus, slot, 0, 0);
+    if(vendor != 0xffff){
+        device = pci_read_config(bus, slot, 0, 2);
+        uint16_t class = pci_read_config(bus, slot, 0, 0xa);
+        mlog(MODULE_NAME, "Device found! Vendor: %x, Device: %x, Class: %x\n", MLOG_PRINT, vendor, device, class);
+    }
+    return vendor;
+}
+
+void pci_enumerate_bus(uint8_t bus){
+    for(uint32_t i = 0; i < 32; i++){
+        uint32_t vendor = pci_get_vendor(bus, i);
+    }
+}
+
+void pci_init(){
+    mlog(MODULE_NAME, "Enumerating PCI Buses\n", MLOG_PRINT);
+    for(uint32_t i = 0 ; i < 256; i++){
+        pci_enumerate_bus(i);
+    }
+}

src/kernel/drivers/pci.h

@@ -0,0 +1,4 @@
+#pragma once
+#include <stdint.h>
+
+void pci_init();

src/kernel/drivers/pic.c

@@ -1,7 +1,7 @@
 #include "pic.h"
 #include "cpuio.h"
 
-void init_pic(uint8_t idt_index){
+void pic_init(uint8_t idt_index){
     uint8_t a1 = inb(PIC1_DATA);
     uint8_t a2 = inb(PIC2_DATA);
     

src/kernel/drivers/pic.h

@@ -20,7 +20,7 @@
 #define PIC_ICW4_BUF_M  0x0c
 #define PIC_ICW4_SFNM   0x10
 
-void init_pic(uint8_t idt_index);
+void pic_init(uint8_t idt_index);
 void pic_disable();
 void pic_setmask(uint8_t mask, uint16_t pic);
 uint8_t pic_getmask(uint16_t pic);

src/kernel/drivers/serial.c

@@ -10,7 +10,7 @@ uint16_t com_ports[8];
 uint8_t com_buffer[8][128];
 uint8_t com_buffer_index[8] = {0};
 
-void init_serial(){
+void serial_init(){
     bda_t *bda = (void*)0x400;
     for(int i = 0; i < 4; i++){
         com_ports[i] = bda->com_ports[i];

src/kernel/drivers/serial.h

@@ -1,7 +1,7 @@
 #pragma once
 #include <stdint.h>
 #include <stdarg.h>
-void init_serial();
+void serial_init();
 void serial_writeb(uint8_t port, uint8_t data);
 void serial_writereg(uint8_t port, uint8_t reg, uint8_t data);
 uint8_t serial_readreg(uint8_t port, uint8_t reg);

src/kernel/entry.s

@@ -3,6 +3,7 @@ bits 32
 extern kmain
 section .text
 global _start
+;TODO: re-write stub to be compatible with any bootloader
 _start:
     cld
     mov esp, stack_top

src/kernel/kmain.c

@@ -5,9 +5,11 @@
 #include "drivers/serial.h"
 #include "drivers/pic.h"
 #include "drivers/cpuio.h"
+#include "drivers/pci.h"
 #include "system/scheduler.h"
 #include "system/modules.h"
 #include "system/elf.h"
+#include "system/vfs.h"
 
 kernel_info_t *boot_info = 0;
 
@@ -16,26 +18,28 @@ void pid0(){
 }
 void sysinit(){
     mlog("KERNEL", "PID 1 Started\n", MLOG_PRINT);
-    init_modules(boot_info);
+    pci_init();
+    modules_init(boot_info);
     for(;;);
 }
 extern void kmain(kernel_info_t *kernel_info){
-    init_serial();
+    serial_init();
     pm_init(kernel_info);
     mlog("KERNEL", "Initializing IDT\n", MLOG_PRINT);
-    init_idt();
-    init_pic(32);
+    idt_load();
+    pic_init(32);
     pic_disable();
     pic_setmask(0xfe, PIC1_DATA);
+    vfs_init();
     //TODO: Map and load filesystem and disk modules
     //TODO: Start Initial Process
     mlog("KERNEL", "Initializing Scheduler & starting PID 1\n", MLOG_PRINT);
     boot_info = kernel_info;
-    init_scheduler();
+    scheduler_init();
     //scheduler doesn't work if there is no PID0, and I don't know why.
     thread_start(pid0);
     thread_start(sysinit);
     enable_interrupts();
-    for(;;);
+    for(;;);//we actually **shouldn't** return, like, ever. That's bad.
     return;
 }

src/kernel/shared/interrupts.h

@@ -1,7 +1,7 @@
 #pragma once
 #include <stdint.h>
 
-void init_idt();
+void idt_load();
 typedef struct cpu_registers{
     uint32_t gs, fs, es, ds;
     uint32_t edi, esi, ebp, esp, ebx, edx, ecx, eax; 

src/kernel/system/modules.c

@@ -63,18 +63,26 @@ uint32_t module_api(uint32_t func, ...){
         case MODULE_API_UNMAP:
             return_value = -1;
             break;
+        case MODULE_API_PADDR:
+            void *addr = va_arg(vars, void *);
+            return_value = get_paddr(addr);
+            break;
         case MODULE_API_MALLOC: 
-            return_value = -1;
+            uint32_t size_pgs = va_arg(vars, uint32_t);
+            return_value = (uint32_t)kmalloc(size_pgs);
             break;
         case MODULE_API_FREE:
-            return_value = -1;
+            void *ptr = va_arg(vars, void *);
+            kfree(ptr);
+            return_value = 0;
             break;
+        
     }
     va_end(vars);
     return return_value;
 }
 
-void init_modules(kernel_info_t *kernel_info){
+void modules_init(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;

src/kernel/system/modules.h

@@ -9,20 +9,21 @@
 //no patch number
 #define MODULE_API_VERSION 0x0100
 
-#define MODULE_API_REGISTER 0
-#define MODULE_API_ADDFUNC 1
-#define MODULE_API_DELFUNC 2
-#define MODULE_API_ADDINT 3
-#define MODULE_API_DELINT 4
-#define MODULE_API_PRINT 5
+#define MODULE_API_REGISTER 0 //registers the module as active using information provided from the module
+#define MODULE_API_ADDFUNC 1 //adds function to kernel API handler
+#define MODULE_API_DELFUNC 2 //delete function from kernel API handler
+#define MODULE_API_ADDINT 3 //set interrupt handler
+#define MODULE_API_DELINT 4 //delete interrupt handler
+#define MODULE_API_PRINT 5 //print to terminal
 #define MODULE_API_READ 6 //read from virtual file
 #define MODULE_API_WRITE 7 //write to virtual file
 #define MODULE_API_CREAT 8 //create a virtual file and assigns it to the the proper module (requires having a read and write function passed)
-#define MODULE_API_DELET 9
-#define MODULE_API_MAP 10
-#define MODULE_API_UNMAP 11
-#define MODULE_API_MALLOC 12
-#define MODULE_API_FREE 13
+#define MODULE_API_DELET 9 //delete a virtual file
+#define MODULE_API_MAP 10 //map physical address to virtual address
+#define MODULE_API_UNMAP 11 //unmap physical address to virtual address
+#define MODULE_API_PADDR 12 //get physical address of memory
+#define MODULE_API_MALLOC 13 //allocate memory in 4kb blocks
+#define MODULE_API_FREE 14 //free memory allocated by malloc
 
 typedef struct module{
     void *init_entry;
@@ -32,4 +33,4 @@ typedef struct module{
     void (*fini)(void);
 }module_t;
 
-void init_modules(kernel_info_t *kernel_info);
+void modules_init(kernel_info_t *kernel_info);

src/kernel/system/scheduler.c

@@ -10,7 +10,7 @@ uint32_t volatile active_processes;
 uint32_t volatile current_pid;
 uint32_t volatile queue_length;
 uint32_t volatile current_queue_index;
-void init_scheduler(){
+void scheduler_init(){
     // printf("?");
     // process_queue = kmalloc((PROCESS_COUNT * sizeof(uint32_t)) / 4096);
     processes = kmalloc((PROCESS_COUNT * sizeof(process_t)) / 4096);

src/kernel/system/scheduler.h

@@ -24,7 +24,7 @@ typedef struct{
 #define PROCESS_COUNT 0x10000
 
 cpu_registers_t* schedule(cpu_registers_t *regs);
-void init_scheduler();
+void scheduler_init();
 uint32_t thread_start(void (*function)());
 void thread_join(uint32_t thread_id, uint32_t *exit_code);
 void thread_exit(uint32_t exit_code);

src/kernel/system/vfs.c

@@ -0,0 +1,15 @@
+#include "vfs.h"
+
+vfile_t root_dir = {"/", VFILE_DIRECTORY};
+
+void vfs_init(){
+    root_dir.access.data.ptr = kmalloc(1);
+    root_dir.access.data.size_pgs = 1;
+    printf("Sizeof: %d", sizeof(vfile_t));
+}
+
+void fcreate();
+void fdelete();
+uint32_t fwrite();
+uint32_t fread();
+void fopen();

src/kernel/system/vfs.h

@@ -0,0 +1,34 @@
+#pragma once
+#include <stdint.h>
+
+typedef enum vfile_type{
+    VFILE_POINTER,
+    VFILE_DEVICE,
+    VFILE_MOUNT,
+    VFILE_DIRECTORY,
+    VFILE_FILE,
+}VFILE_TYPE; 
+
+//this code is gonna be ***really*** unsafe
+typedef struct virtual_file_t{
+    char name[20];
+    VFILE_TYPE type;
+    union{
+        struct{
+            void (*read)(void *data, uint32_t offset, uint32_t count);
+            void (*write)(void *data, uint32_t offset, uint32_t count);
+        }funcs;
+        struct{
+            void *ptr;
+            uint16_t size_pgs;
+            uint16_t free_bytes;
+        }__attribute__((packed))data;
+    }access;
+}vfile_t;
+
+void vfs_init();
+void fcreate();
+void fdelete();
+uint32_t fwrite();
+uint32_t fread();
+void fopen();

src/kmodules/disk_driver.c

@@ -1,29 +1,30 @@
 #include<stdint.h>
 #include "modlib.h"
+#include "../kernel/drivers/cpuio.h"
 
 #define MODULE_NAME "KIDM"
 
 KOS_MAPI_FP api;
 
-inline void outb(uint16_t port, uint8_t data){
-    asm volatile ("outb %0, %1" :: "a"(data), "Nd"(port));
-}
+// inline void outb(uint16_t port, uint8_t data){
+//     asm volatile ("outb %0, %1" :: "a"(data), "Nd"(port));
+// }
 
-inline void outw(uint16_t port, uint16_t data){
-    asm volatile ("outw %0, %1" :: "a"(data), "Nd"(port));
-}
+// inline void outw(uint16_t port, uint16_t data){
+//     asm volatile ("outw %0, %1" :: "a"(data), "Nd"(port));
+// }
 
-inline uint8_t inb(uint16_t port){
-    uint8_t byte = 0;
-    asm volatile ("inb %1, %0" : "=a"(byte) : "Nd"(port));
-    return byte;
-}
+// inline uint8_t inb(uint16_t port){
+//     uint8_t byte = 0;
+//     asm volatile ("inb %1, %0" : "=a"(byte) : "Nd"(port));
+//     return byte;
+// }
 
-inline uint16_t inw(uint16_t port){
-    uint16_t word = 0;
-    asm volatile ("inw %1, %0" : "=a"(word) : "Nd"(port));
-    return word;
-}
+// inline uint16_t inw(uint16_t port){
+//     uint16_t word = 0;
+//     asm volatile ("inw %1, %0" : "=a"(word) : "Nd"(port));
+//     return word;
+// }
 /*
 TODO:
 Register module 

src/kmodules/modlib.h

@@ -13,8 +13,9 @@
 #define MODULE_API_DELET 9 //delete a virtual file
 #define MODULE_API_MAP 10 //map physical address to virtual address
 #define MODULE_API_UNMAP 11 //unmap physical address to virtual address
-#define MODULE_API_MALLOC 12 //allocate memory in 4kb blocks
-#define MODULE_API_FREE 13 //free memory allocated by malloc
+#define MODULE_API_PADDR 12 //get physical address of memory
+#define MODULE_API_MALLOC 13 //allocate memory in 4kb blocks
+#define MODULE_API_FREE 14 //free memory allocated by malloc
 
 typedef uint32_t (*KOS_MAPI_FP)(unsigned int function, ...);
 typedef struct module{