From d33a812703922145b14d9778cba130b66610e2f8 Mon Sep 17 00:00:00 2001 From: Alex Date: Fri, 16 Dec 2022 03:08:31 +0200 Subject: [PATCH] Updated driver loading code --- Core/Driver/Driver.cpp | 428 +++----------------- Core/Driver/DriverLoading/BindInput.cpp | 82 ++++ Core/Driver/DriverLoading/BindInterrupt.cpp | 165 ++++++++ Core/Driver/DriverLoading/BindPCI.cpp | 185 +++++++++ Core/Driver/DriverLoading/BindProcess.cpp | 22 + Execute/Spawn.cpp | 2 +- include/driver.hpp | 5 + 7 files changed, 506 insertions(+), 383 deletions(-) create mode 100644 Core/Driver/DriverLoading/BindInput.cpp create mode 100644 Core/Driver/DriverLoading/BindInterrupt.cpp create mode 100644 Core/Driver/DriverLoading/BindPCI.cpp create mode 100644 Core/Driver/DriverLoading/BindProcess.cpp diff --git a/Core/Driver/Driver.cpp b/Core/Driver/Driver.cpp index 8ff440b..602bef2 100644 --- a/Core/Driver/Driver.cpp +++ b/Core/Driver/Driver.cpp @@ -47,7 +47,8 @@ namespace Driver API->Info.Offset = (unsigned long)fex; API->Info.DriverUID = DriverUIDs++; - int ret = ((int (*)(KernelAPI *))((uint64_t)((Fex *)fex)->Pointer + (uint64_t)fex))(API); + debug("Calling driver entry point ( %#lx %ld )", (unsigned long)fex, API->Info.DriverUID); + int ret = ((int (*)(KernelAPI *))((uint64_t)((Fex *)fex)->EntryPoint + (uint64_t)fex))(API); if (DriverReturnCode::OK != ret) return DriverCode::DRIVER_RETURNED_ERROR; @@ -58,8 +59,40 @@ namespace Driver { Fex *DrvHdr = (Fex *)DriverAddress; if (DrvHdr->Magic[0] != 'F' || DrvHdr->Magic[1] != 'E' || DrvHdr->Magic[2] != 'X' || DrvHdr->Magic[3] != '\0') - return DriverCode::INVALID_FEX_HEADER; - debug("Fex Magic: \"%s\"; Type: %d; OS: %d; Pointer: %#lx", DrvHdr->Magic, DrvHdr->Type, DrvHdr->OS, DrvHdr->Pointer); + { + if (Size > 0x1000) + { + Fex *ElfDrvHdr = (Fex *)(DriverAddress + 0x1000); + if (ElfDrvHdr->Magic[0] != 'F' || ElfDrvHdr->Magic[1] != 'E' || ElfDrvHdr->Magic[2] != 'X' || ElfDrvHdr->Magic[3] != '\0') + return DriverCode::INVALID_FEX_HEADER; + else + { + debug("Fex Magic: \"%s\"; Type: %d; OS: %d; EntryPoint: %#lx", ElfDrvHdr->Magic, ElfDrvHdr->Type, ElfDrvHdr->OS, ElfDrvHdr->EntryPoint); + + if (ElfDrvHdr->Type == FexFormatType::FexFormatType_Driver) + { + FexExtended *ElfDrvExtHdr = (FexExtended *)((uint64_t)ElfDrvHdr + EXTENDED_SECTION_ADDRESS); + debug("Name: \"%s\"; Type: %d; Callback: %#lx", ElfDrvExtHdr->Driver.Name, ElfDrvExtHdr->Driver.Type, ElfDrvExtHdr->Driver.Callback); + + if (ElfDrvExtHdr->Driver.Bind.Type == DriverBindType::BIND_PCI) + return this->DriverLoadBindPCI(ElfDrvExtHdr, DriverAddress, Size, true); + else if (ElfDrvExtHdr->Driver.Bind.Type == DriverBindType::BIND_INTERRUPT) + return this->DriverLoadBindInterrupt(ElfDrvExtHdr, DriverAddress, Size, true); + else if (ElfDrvExtHdr->Driver.Bind.Type == DriverBindType::BIND_PROCESS) + return this->DriverLoadBindProcess(ElfDrvExtHdr, DriverAddress, Size, true); + else if (ElfDrvExtHdr->Driver.Bind.Type == DriverBindType::BIND_INPUT) + return this->DriverLoadBindInput(ElfDrvExtHdr, DriverAddress, Size, true); + else + error("Unknown driver bind type: %d", ElfDrvExtHdr->Driver.Bind.Type); + } + else + return DriverCode::NOT_DRIVER; + } + } + else + return DriverCode::INVALID_FEX_HEADER; + } + debug("Fex Magic: \"%s\"; Type: %d; OS: %d; EntryPoint: %#lx", DrvHdr->Magic, DrvHdr->Type, DrvHdr->OS, DrvHdr->EntryPoint); if (DrvHdr->Type == FexFormatType::FexFormatType_Driver) { @@ -67,388 +100,19 @@ namespace Driver debug("Name: \"%s\"; Type: %d; Callback: %#lx", DrvExtHdr->Driver.Name, DrvExtHdr->Driver.Type, DrvExtHdr->Driver.Callback); if (DrvExtHdr->Driver.Bind.Type == DriverBindType::BIND_PCI) - { - for (unsigned long Vidx = 0; Vidx < sizeof(DrvExtHdr->Driver.Bind.PCI.VendorID) / sizeof(DrvExtHdr->Driver.Bind.PCI.VendorID[0]); Vidx++) - for (unsigned long Didx = 0; Didx < sizeof(DrvExtHdr->Driver.Bind.PCI.DeviceID) / sizeof(DrvExtHdr->Driver.Bind.PCI.DeviceID[0]); Didx++) - { - if (Vidx >= sizeof(DrvExtHdr->Driver.Bind.PCI.VendorID) && Didx >= sizeof(DrvExtHdr->Driver.Bind.PCI.DeviceID)) - break; - - if (DrvExtHdr->Driver.Bind.PCI.VendorID[Vidx] == 0 || DrvExtHdr->Driver.Bind.PCI.DeviceID[Didx] == 0) - continue; - - Vector devices = PCIManager->FindPCIDevice(DrvExtHdr->Driver.Bind.PCI.VendorID[Vidx], DrvExtHdr->Driver.Bind.PCI.DeviceID[Didx]); - if (devices.size() == 0) - continue; - foreach (auto PCIDevice in devices) - { - debug("[%ld] VendorID: %#x; DeviceID: %#x", devices.size(), PCIDevice->VendorID, PCIDevice->DeviceID); - Fex *fex = (Fex *)KernelAllocator.RequestPages(TO_PAGES(Size)); - memcpy(fex, (void *)DriverAddress, Size); - FexExtended *fexExtended = (FexExtended *)((uint64_t)fex + EXTENDED_SECTION_ADDRESS); - debug("Driver allocated at %#lx-%#lx", fex, (uint64_t)fex + Size); -#ifdef DEBUG - uint8_t *result = md5File((uint8_t *)fex, Size); - debug("MD5: %02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x", - result[0], result[1], result[2], result[3], result[4], result[5], result[6], result[7], - result[8], result[9], result[10], result[11], result[12], result[13], result[14], result[15]); - kfree(result); -#endif - if (CallDriverEntryPoint(fex) != DriverCode::OK) - { - KernelAllocator.FreePages(fex, TO_PAGES(Size)); - return DriverCode::DRIVER_RETURNED_ERROR; - } - debug("Starting driver %s", fexExtended->Driver.Name); - - KernelCallback *KCallback = (KernelCallback *)KernelAllocator.RequestPages(TO_PAGES(sizeof(KernelCallback))); - - debug("Type: %d; IOBase: %#x; MemoryBase: %#x", - ((PCI::PCIHeader0 *)PCIDevice)->BAR0 & 1, - ((PCI::PCIHeader0 *)PCIDevice)->BAR1 & (~3), - ((PCI::PCIHeader0 *)PCIDevice)->BAR0 & (~15)); - - if ((((PCI::PCIHeader0 *)PCIDevice)->BAR0 & 1) != 0) - if (!Memory::Virtual().Check((void *)(uint64_t)(((PCI::PCIHeader0 *)PCIDevice)->BAR1 & (~3)))) - { - debug("IO base (BAR1 & ~3) is not mapped"); - Memory::Virtual().Map((void *)(uint64_t)(((PCI::PCIHeader0 *)PCIDevice)->BAR1 & (~3)), (void *)(uint64_t)(((PCI::PCIHeader0 *)PCIDevice)->BAR1 & (~3)), Memory::PTFlag::RW); - } - - if ((((PCI::PCIHeader0 *)PCIDevice)->BAR0 & 1) == 0) - if (!Memory::Virtual().Check((void *)(uint64_t)(((PCI::PCIHeader0 *)PCIDevice)->BAR0 & (~15)))) - { - debug("Memory base (BAR0 & ~15) is not mapped"); - Memory::Virtual().Map((void *)(uint64_t)(((PCI::PCIHeader0 *)PCIDevice)->BAR0 & (~15)), (void *)(uint64_t)(((PCI::PCIHeader0 *)PCIDevice)->BAR0 & (~15)), Memory::PTFlag::RW); - - uint64_t original = ((PCI::PCIHeader0 *)PCIDevice)->BAR0; - ((PCI::PCIHeader0 *)PCIDevice)->BAR0 = 0xFFFFFFFF; - uint64_t size = ((PCI::PCIHeader0 *)PCIDevice)->BAR0 & 0xFFFFFFF0; - ((PCI::PCIHeader0 *)PCIDevice)->BAR0 = original; - debug("Size: %#lx (%ld pages)", size, TO_PAGES(size)); - fixme("TODO: [BUG] Mapping is broken!!!!!!"); - } - - switch (fexExtended->Driver.Type) - { - case FexDriverType::FexDriverType_Generic: - { - fixme("Generic driver: %s", fexExtended->Driver.Name); - break; - } - case FexDriverType::FexDriverType_Display: - { - fixme("Display driver: %s", fexExtended->Driver.Name); - break; - } - case FexDriverType::FexDriverType_Network: - { - DriverInterruptHook *InterruptHook = new DriverInterruptHook(((int)((PCI::PCIHeader0 *)devices[0])->InterruptLine) + 32, // x86 - (void *)((uint64_t)fexExtended->Driver.Callback + (uint64_t)fex), - KCallback); - - KCallback->RawPtr = PCIDevice; - KCallback->Reason = CallbackReason::ConfigurationReason; - int CallbackRet = ((int (*)(KernelCallback *))((uint64_t)fexExtended->Driver.Callback + (uint64_t)fex))(KCallback); - if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED) - { - KernelAllocator.FreePages(fex, TO_PAGES(Size)); - KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback))); - delete InterruptHook; - error("Driver %s does not implement the configuration callback", fexExtended->Driver.Name); - continue; - } - else if (CallbackRet == DriverReturnCode::OK) - trace("Device found for driver: %s", fexExtended->Driver.Name); - else - { - KernelAllocator.FreePages(fex, TO_PAGES(Size)); - KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback))); - delete InterruptHook; - error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet); - continue; - } - - memset(KCallback, 0, sizeof(KernelCallback)); - KCallback->Reason = CallbackReason::InterruptReason; - - DriverFile *DrvFile = new DriverFile; - DrvFile->DriverUID = KAPI.Info.DriverUID; - DrvFile->Address = (void *)fex; - DrvFile->InterruptHook[0] = InterruptHook; - Drivers.push_back(DrvFile); - break; - } - case FexDriverType::FexDriverType_Storage: - { - KCallback->RawPtr = PCIDevice; - KCallback->Reason = CallbackReason::ConfigurationReason; - int CallbackRet = ((int (*)(KernelCallback *))((uint64_t)fexExtended->Driver.Callback + (uint64_t)fex))(KCallback); - if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED) - { - KernelAllocator.FreePages(fex, TO_PAGES(Size)); - KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback))); - error("Driver %s does not implement the configuration callback", fexExtended->Driver.Name); - continue; - } - else if (CallbackRet == DriverReturnCode::OK) - trace("Device found for driver: %s", fexExtended->Driver.Name); - else - { - KernelAllocator.FreePages(fex, TO_PAGES(Size)); - KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback))); - error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet); - continue; - } - - DriverFile *DrvFile = new DriverFile; - DrvFile->DriverUID = KAPI.Info.DriverUID; - DrvFile->Address = (void *)fex; - DrvFile->InterruptHook[0] = nullptr; - Drivers.push_back(DrvFile); - break; - } - case FexDriverType::FexDriverType_FileSystem: - { - fixme("Filesystem driver: %s", fexExtended->Driver.Name); - break; - } - case FexDriverType::FexDriverType_Input: - { - fixme("Input driver: %s", fexExtended->Driver.Name); - break; - } - case FexDriverType::FexDriverType_Audio: - { - fixme("Audio driver: %s", fexExtended->Driver.Name); - break; - } - default: - { - warn("Unknown driver type: %d", fexExtended->Driver.Type); - break; - } - } - } - } - } + return this->DriverLoadBindPCI(DrvExtHdr, DriverAddress, Size); else if (DrvExtHdr->Driver.Bind.Type == DriverBindType::BIND_INTERRUPT) - { - Fex *fex = (Fex *)KernelAllocator.RequestPages(TO_PAGES(Size)); - memcpy(fex, (void *)DriverAddress, Size); - FexExtended *fexExtended = (FexExtended *)((uint64_t)fex + EXTENDED_SECTION_ADDRESS); - debug("Driver allocated at %#lx-%#lx", fex, (uint64_t)fex + Size); -#ifdef DEBUG - uint8_t *result = md5File((uint8_t *)fex, Size); - debug("MD5: %02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x", - result[0], result[1], result[2], result[3], result[4], result[5], result[6], result[7], - result[8], result[9], result[10], result[11], result[12], result[13], result[14], result[15]); - kfree(result); -#endif - if (CallDriverEntryPoint(fex) != DriverCode::OK) - { - KernelAllocator.FreePages(fex, TO_PAGES(Size)); - return DriverCode::DRIVER_RETURNED_ERROR; - } - debug("Starting driver %s (offset: %#lx)", fexExtended->Driver.Name, fex); - - KernelCallback *KCallback = (KernelCallback *)KernelAllocator.RequestPages(TO_PAGES(sizeof(KernelCallback))); - - switch (fexExtended->Driver.Type) - { - case FexDriverType::FexDriverType_Generic: - { - fixme("Generic driver: %s", fexExtended->Driver.Name); - break; - } - case FexDriverType::FexDriverType_Display: - { - fixme("Display driver: %s", fexExtended->Driver.Name); - break; - } - case FexDriverType::FexDriverType_Network: - { - fixme("Network driver: %s", fexExtended->Driver.Name); - break; - } - case FexDriverType::FexDriverType_Storage: - { - for (unsigned long i = 0; i < sizeof(DrvExtHdr->Driver.Bind.Interrupt.Vector) / sizeof(DrvExtHdr->Driver.Bind.Interrupt.Vector[0]); i++) - { - if (DrvExtHdr->Driver.Bind.Interrupt.Vector[i] == 0) - break; - - fixme("TODO: MULTIPLE BIND INTERRUPT VECTORS %d", DrvExtHdr->Driver.Bind.Interrupt.Vector[i]); - } - - fixme("Not implemented"); - KernelAllocator.FreePages(fex, TO_PAGES(Size)); - KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback))); - break; - - KCallback->RawPtr = nullptr; - KCallback->Reason = CallbackReason::ConfigurationReason; - int CallbackRet = ((int (*)(KernelCallback *))((uint64_t)fexExtended->Driver.Callback + (uint64_t)fex))(KCallback); - if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED) - { - KernelAllocator.FreePages(fex, TO_PAGES(Size)); - KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback))); - error("Driver %s does not implement the configuration callback", fexExtended->Driver.Name); - break; - } - else if (CallbackRet != DriverReturnCode::OK) - { - KernelAllocator.FreePages(fex, TO_PAGES(Size)); - KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback))); - error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet); - break; - } - - KernelAllocator.FreePages(fex, TO_PAGES(Size)); - KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback))); - - // DriverFile *DrvFile = new DriverFile; - // Drivers.push_back(DrvFile); - break; - } - case FexDriverType::FexDriverType_FileSystem: - { - fixme("Filesystem driver: %s", fexExtended->Driver.Name); - break; - } - case FexDriverType::FexDriverType_Input: - { - DriverInterruptHook *InterruptHook = nullptr; - if (DrvExtHdr->Driver.Bind.Interrupt.Vector[0] != 0) - InterruptHook = new DriverInterruptHook(DrvExtHdr->Driver.Bind.Interrupt.Vector[0] + 32, // x86 - (void *)((uint64_t)fexExtended->Driver.Callback + (uint64_t)fex), - KCallback); - - for (unsigned long i = 0; i < sizeof(DrvExtHdr->Driver.Bind.Interrupt.Vector) / sizeof(DrvExtHdr->Driver.Bind.Interrupt.Vector[0]); i++) - { - if (DrvExtHdr->Driver.Bind.Interrupt.Vector[i] == 0) - break; - // InterruptHook = new DriverInterruptHook(DrvExtHdr->Driver.Bind.Interrupt.Vector[i] + 32, // x86 - // (void *)((uint64_t)fexExtended->Driver.Callback + (uint64_t)fex), - // KCallback); - fixme("TODO: MULTIPLE BIND INTERRUPT VECTORS %d", DrvExtHdr->Driver.Bind.Interrupt.Vector[i]); - } - - KCallback->RawPtr = nullptr; - KCallback->Reason = CallbackReason::ConfigurationReason; - int CallbackRet = ((int (*)(KernelCallback *))((uint64_t)fexExtended->Driver.Callback + (uint64_t)fex))(KCallback); - if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED) - { - KernelAllocator.FreePages(fex, TO_PAGES(Size)); - KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback))); - error("Driver %s does not implement the configuration callback", fexExtended->Driver.Name); - break; - } - else if (CallbackRet != DriverReturnCode::OK) - { - KernelAllocator.FreePages(fex, TO_PAGES(Size)); - KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback))); - error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet); - break; - } - - memset(KCallback, 0, sizeof(KernelCallback)); - KCallback->Reason = CallbackReason::InterruptReason; - - DriverFile *DrvFile = new DriverFile; - DrvFile->DriverUID = KAPI.Info.DriverUID; - DrvFile->Address = (void *)fex; - DrvFile->InterruptHook[0] = InterruptHook; - Drivers.push_back(DrvFile); - break; - } - case FexDriverType::FexDriverType_Audio: - { - fixme("Audio driver: %s", fexExtended->Driver.Name); - break; - } - default: - { - warn("Unknown driver type: %d", fexExtended->Driver.Type); - break; - } - } - } + return this->DriverLoadBindInterrupt(DrvExtHdr, DriverAddress, Size); else if (DrvExtHdr->Driver.Bind.Type == DriverBindType::BIND_PROCESS) - { - fixme("Process driver: %s", DrvExtHdr->Driver.Name); - } + return this->DriverLoadBindProcess(DrvExtHdr, DriverAddress, Size); else if (DrvExtHdr->Driver.Bind.Type == DriverBindType::BIND_INPUT) - { - Fex *fex = (Fex *)KernelAllocator.RequestPages(TO_PAGES(Size)); - memcpy(fex, (void *)DriverAddress, Size); - FexExtended *fexExtended = (FexExtended *)((uint64_t)fex + EXTENDED_SECTION_ADDRESS); - debug("Driver allocated at %#lx-%#lx", fex, (uint64_t)fex + Size); -#ifdef DEBUG - uint8_t *result = md5File((uint8_t *)fex, Size); - debug("MD5: %02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x", - result[0], result[1], result[2], result[3], result[4], result[5], result[6], result[7], - result[8], result[9], result[10], result[11], result[12], result[13], result[14], result[15]); - kfree(result); -#endif - if (CallDriverEntryPoint(fex) != DriverCode::OK) - { - KernelAllocator.FreePages(fex, TO_PAGES(Size)); - return DriverCode::DRIVER_RETURNED_ERROR; - } - debug("Starting driver %s (offset: %#lx)", fexExtended->Driver.Name, fex); - - KernelCallback *KCallback = (KernelCallback *)KernelAllocator.RequestPages(TO_PAGES(sizeof(KernelCallback))); - - switch (fexExtended->Driver.Type) - { - case FexDriverType::FexDriverType_Input: - { - fixme("Input driver: %s", fexExtended->Driver.Name); - KCallback->RawPtr = nullptr; - break; - KCallback->Reason = CallbackReason::ConfigurationReason; - int CallbackRet = ((int (*)(KernelCallback *))((uint64_t)fexExtended->Driver.Callback + (uint64_t)fex))(KCallback); - if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED) - { - KernelAllocator.FreePages(fex, TO_PAGES(Size)); - KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback))); - error("Driver %s does not implement the configuration callback", fexExtended->Driver.Name); - break; - } - else if (CallbackRet != DriverReturnCode::OK) - { - KernelAllocator.FreePages(fex, TO_PAGES(Size)); - KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback))); - error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet); - break; - } - - KernelAllocator.FreePages(fex, TO_PAGES(Size)); - KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback))); - - DriverFile *DrvFile = new DriverFile; - DrvFile->DriverUID = KAPI.Info.DriverUID; - DrvFile->Address = (void *)fex; - DrvFile->InterruptHook[0] = nullptr; - Drivers.push_back(DrvFile); - break; - } - default: - { - warn("Unknown driver type: %d", fexExtended->Driver.Type); - break; - } - } - } + return this->DriverLoadBindInput(DrvExtHdr, DriverAddress, Size); else - { error("Unknown driver bind type: %d", DrvExtHdr->Driver.Bind.Type); - } } else return DriverCode::NOT_DRIVER; - return DriverCode::OK; + return DriverCode::ERROR; } Driver::Driver() @@ -462,15 +126,15 @@ namespace Driver { const char *extension; cwk_path_get_extension(driver->Name, &extension, nullptr); - if (!strcmp(extension, ".fex")) + if (!strcmp(extension, ".fex") || !strcmp(extension, ".elf")) { uint64_t ret = this->LoadDriver(driver->Address, driver->Length); - char retstring[128]; + char RetString[128]; if (ret == DriverCode::OK) - strncpy(retstring, "\e058C19OK", 64); + strncpy(RetString, "\e058C19OK", 64); else - sprintf_(retstring, "\eE85230FAILED (%#lx)", ret); - KPrint("%s %s", driver->Name, retstring); + sprintf_(RetString, "\eE85230FAILED (%#lx)", ret); + KPrint("%s %s", driver->Name, RetString); } } vfs->Close(DriverDirectory); diff --git a/Core/Driver/DriverLoading/BindInput.cpp b/Core/Driver/DriverLoading/BindInput.cpp new file mode 100644 index 0000000..412fd4b --- /dev/null +++ b/Core/Driver/DriverLoading/BindInput.cpp @@ -0,0 +1,82 @@ +#include "../api.hpp" + +#include +#include +#include +#include +#include +#include +#include + +#include "../../../kernel.h" +#include "../../../DAPI.hpp" +#include "../../../Fex.hpp" + +namespace Driver +{ + DriverCode Driver::DriverLoadBindInput(void *DrvExtHdr, uint64_t DriverAddress, uint64_t Size, bool IsElf) + { + Fex *fex = (Fex *)KernelAllocator.RequestPages(TO_PAGES(Size)); + memcpy(fex, (void *)DriverAddress, Size); + FexExtended *fexExtended = (FexExtended *)((uint64_t)fex + EXTENDED_SECTION_ADDRESS); + debug("Driver allocated at %#lx-%#lx", fex, (uint64_t)fex + Size); +#ifdef DEBUG + uint8_t *result = md5File((uint8_t *)fex, Size); + debug("MD5: %02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x", + result[0], result[1], result[2], result[3], result[4], result[5], result[6], result[7], + result[8], result[9], result[10], result[11], result[12], result[13], result[14], result[15]); + kfree(result); +#endif + if (CallDriverEntryPoint(fex) != DriverCode::OK) + { + KernelAllocator.FreePages(fex, TO_PAGES(Size)); + return DriverCode::DRIVER_RETURNED_ERROR; + } + debug("Starting driver %s (offset: %#lx)", fexExtended->Driver.Name, fex); + + KernelCallback *KCallback = (KernelCallback *)KernelAllocator.RequestPages(TO_PAGES(sizeof(KernelCallback))); + + switch (fexExtended->Driver.Type) + { + case FexDriverType::FexDriverType_Input: + { + fixme("Input driver: %s", fexExtended->Driver.Name); + KCallback->RawPtr = nullptr; + break; + KCallback->Reason = CallbackReason::ConfigurationReason; + int CallbackRet = ((int (*)(KernelCallback *))((uint64_t)fexExtended->Driver.Callback + (uint64_t)fex))(KCallback); + if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED) + { + KernelAllocator.FreePages(fex, TO_PAGES(Size)); + KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback))); + error("Driver %s does not implement the configuration callback", fexExtended->Driver.Name); + break; + } + else if (CallbackRet != DriverReturnCode::OK) + { + KernelAllocator.FreePages(fex, TO_PAGES(Size)); + KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback))); + error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet); + break; + } + + KernelAllocator.FreePages(fex, TO_PAGES(Size)); + KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback))); + + DriverFile *DrvFile = new DriverFile; + DrvFile->DriverUID = KAPI.Info.DriverUID; + DrvFile->Address = (void *)fex; + DrvFile->InterruptHook[0] = nullptr; + Drivers.push_back(DrvFile); + break; + } + default: + { + warn("Unknown driver type: %d", fexExtended->Driver.Type); + break; + } + } + + return DriverCode::OK; + } +} diff --git a/Core/Driver/DriverLoading/BindInterrupt.cpp b/Core/Driver/DriverLoading/BindInterrupt.cpp new file mode 100644 index 0000000..3c5df78 --- /dev/null +++ b/Core/Driver/DriverLoading/BindInterrupt.cpp @@ -0,0 +1,165 @@ +#include "../api.hpp" + +#include +#include +#include +#include +#include +#include +#include + +#include "../../../kernel.h" +#include "../../../DAPI.hpp" +#include "../../../Fex.hpp" + +namespace Driver +{ + DriverCode Driver::DriverLoadBindInterrupt(void *DrvExtHdr, uint64_t DriverAddress, uint64_t Size, bool IsElf) + { + Fex *fex = (Fex *)KernelAllocator.RequestPages(TO_PAGES(Size)); + memcpy(fex, (void *)DriverAddress, Size); + FexExtended *fexExtended = (FexExtended *)((uint64_t)fex + EXTENDED_SECTION_ADDRESS); + debug("Driver allocated at %#lx-%#lx", fex, (uint64_t)fex + Size); +#ifdef DEBUG + uint8_t *result = md5File((uint8_t *)fex, Size); + debug("MD5: %02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x", + result[0], result[1], result[2], result[3], result[4], result[5], result[6], result[7], + result[8], result[9], result[10], result[11], result[12], result[13], result[14], result[15]); + kfree(result); +#endif + if (CallDriverEntryPoint(fex) != DriverCode::OK) + { + KernelAllocator.FreePages(fex, TO_PAGES(Size)); + return DriverCode::DRIVER_RETURNED_ERROR; + } + debug("Starting driver %s (offset: %#lx)", fexExtended->Driver.Name, fex); + + KernelCallback *KCallback = (KernelCallback *)KernelAllocator.RequestPages(TO_PAGES(sizeof(KernelCallback))); + + switch (fexExtended->Driver.Type) + { + case FexDriverType::FexDriverType_Generic: + { + fixme("Generic driver: %s", fexExtended->Driver.Name); + DriverFile *DrvFile = new DriverFile; + DrvFile->DriverUID = KAPI.Info.DriverUID; + DrvFile->Address = (void *)fex; + Drivers.push_back(DrvFile); + break; + } + case FexDriverType::FexDriverType_Display: + { + fixme("Display driver: %s", fexExtended->Driver.Name); + break; + } + case FexDriverType::FexDriverType_Network: + { + fixme("Network driver: %s", fexExtended->Driver.Name); + break; + } + case FexDriverType::FexDriverType_Storage: + { + for (unsigned long i = 0; i < sizeof(((FexExtended *)DrvExtHdr)->Driver.Bind.Interrupt.Vector) / sizeof(((FexExtended *)DrvExtHdr)->Driver.Bind.Interrupt.Vector[0]); i++) + { + if (((FexExtended *)DrvExtHdr)->Driver.Bind.Interrupt.Vector[i] == 0) + break; + + fixme("TODO: MULTIPLE BIND INTERRUPT VECTORS %d", ((FexExtended *)DrvExtHdr)->Driver.Bind.Interrupt.Vector[i]); + } + + fixme("Not implemented"); + KernelAllocator.FreePages(fex, TO_PAGES(Size)); + KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback))); + break; + + KCallback->RawPtr = nullptr; + KCallback->Reason = CallbackReason::ConfigurationReason; + int CallbackRet = ((int (*)(KernelCallback *))((uint64_t)fexExtended->Driver.Callback + (uint64_t)fex))(KCallback); + if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED) + { + KernelAllocator.FreePages(fex, TO_PAGES(Size)); + KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback))); + error("Driver %s does not implement the configuration callback", fexExtended->Driver.Name); + break; + } + else if (CallbackRet != DriverReturnCode::OK) + { + KernelAllocator.FreePages(fex, TO_PAGES(Size)); + KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback))); + error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet); + break; + } + + KernelAllocator.FreePages(fex, TO_PAGES(Size)); + KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback))); + + // DriverFile *DrvFile = new DriverFile; + // Drivers.push_back(DrvFile); + break; + } + case FexDriverType::FexDriverType_FileSystem: + { + fixme("Filesystem driver: %s", fexExtended->Driver.Name); + break; + } + case FexDriverType::FexDriverType_Input: + { + DriverInterruptHook *InterruptHook = nullptr; + if (((FexExtended *)DrvExtHdr)->Driver.Bind.Interrupt.Vector[0] != 0) + InterruptHook = new DriverInterruptHook(((FexExtended *)DrvExtHdr)->Driver.Bind.Interrupt.Vector[0] + 32, // x86 + (void *)((uint64_t)fexExtended->Driver.Callback + (uint64_t)fex), + KCallback); + + for (unsigned long i = 0; i < sizeof(((FexExtended *)DrvExtHdr)->Driver.Bind.Interrupt.Vector) / sizeof(((FexExtended *)DrvExtHdr)->Driver.Bind.Interrupt.Vector[0]); i++) + { + if (((FexExtended *)DrvExtHdr)->Driver.Bind.Interrupt.Vector[i] == 0) + break; + // InterruptHook = new DriverInterruptHook(((FexExtended *)DrvExtHdr)->Driver.Bind.Interrupt.Vector[i] + 32, // x86 + // (void *)((uint64_t)fexExtended->Driver.Callback + (uint64_t)fex), + // KCallback); + fixme("TODO: MULTIPLE BIND INTERRUPT VECTORS %d", ((FexExtended *)DrvExtHdr)->Driver.Bind.Interrupt.Vector[i]); + } + + KCallback->RawPtr = nullptr; + KCallback->Reason = CallbackReason::ConfigurationReason; + int CallbackRet = ((int (*)(KernelCallback *))((uint64_t)fexExtended->Driver.Callback + (uint64_t)fex))(KCallback); + if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED) + { + KernelAllocator.FreePages(fex, TO_PAGES(Size)); + KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback))); + error("Driver %s does not implement the configuration callback", fexExtended->Driver.Name); + break; + } + else if (CallbackRet != DriverReturnCode::OK) + { + KernelAllocator.FreePages(fex, TO_PAGES(Size)); + KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback))); + error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet); + break; + } + + memset(KCallback, 0, sizeof(KernelCallback)); + KCallback->Reason = CallbackReason::InterruptReason; + + DriverFile *DrvFile = new DriverFile; + DrvFile->DriverUID = KAPI.Info.DriverUID; + DrvFile->Address = (void *)fex; + DrvFile->InterruptHook[0] = InterruptHook; + Drivers.push_back(DrvFile); + break; + } + case FexDriverType::FexDriverType_Audio: + { + fixme("Audio driver: %s", fexExtended->Driver.Name); + break; + } + default: + { + warn("Unknown driver type: %d", fexExtended->Driver.Type); + break; + } + } + + return DriverCode::OK; + } +} diff --git a/Core/Driver/DriverLoading/BindPCI.cpp b/Core/Driver/DriverLoading/BindPCI.cpp new file mode 100644 index 0000000..4272736 --- /dev/null +++ b/Core/Driver/DriverLoading/BindPCI.cpp @@ -0,0 +1,185 @@ +#include "../api.hpp" + +#include +#include +#include +#include +#include +#include +#include + +#include "../../../kernel.h" +#include "../../../DAPI.hpp" +#include "../../../Fex.hpp" + +namespace Driver +{ + DriverCode Driver::DriverLoadBindPCI(void *DrvExtHdr, uint64_t DriverAddress, uint64_t Size, bool IsElf) + { + for (unsigned long Vidx = 0; Vidx < sizeof(((FexExtended *)DrvExtHdr)->Driver.Bind.PCI.VendorID) / sizeof(((FexExtended *)DrvExtHdr)->Driver.Bind.PCI.VendorID[0]); Vidx++) + for (unsigned long Didx = 0; Didx < sizeof(((FexExtended *)DrvExtHdr)->Driver.Bind.PCI.DeviceID) / sizeof(((FexExtended *)DrvExtHdr)->Driver.Bind.PCI.DeviceID[0]); Didx++) + { + if (Vidx >= sizeof(((FexExtended *)DrvExtHdr)->Driver.Bind.PCI.VendorID) && Didx >= sizeof(((FexExtended *)DrvExtHdr)->Driver.Bind.PCI.DeviceID)) + break; + + if (((FexExtended *)DrvExtHdr)->Driver.Bind.PCI.VendorID[Vidx] == 0 || ((FexExtended *)DrvExtHdr)->Driver.Bind.PCI.DeviceID[Didx] == 0) + continue; + + Vector devices = PCIManager->FindPCIDevice(((FexExtended *)DrvExtHdr)->Driver.Bind.PCI.VendorID[Vidx], ((FexExtended *)DrvExtHdr)->Driver.Bind.PCI.DeviceID[Didx]); + if (devices.size() == 0) + continue; + foreach (auto PCIDevice in devices) + { + debug("[%ld] VendorID: %#x; DeviceID: %#x", devices.size(), PCIDevice->VendorID, PCIDevice->DeviceID); + Fex *fex = (Fex *)KernelAllocator.RequestPages(TO_PAGES(Size)); + memcpy(fex, (void *)DriverAddress, Size); + FexExtended *fexExtended = (FexExtended *)((uint64_t)fex + EXTENDED_SECTION_ADDRESS); + debug("Driver allocated at %#lx-%#lx", fex, (uint64_t)fex + Size); +#ifdef DEBUG + uint8_t *result = md5File((uint8_t *)fex, Size); + debug("MD5: %02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x", + result[0], result[1], result[2], result[3], result[4], result[5], result[6], result[7], + result[8], result[9], result[10], result[11], result[12], result[13], result[14], result[15]); + kfree(result); +#endif + if (CallDriverEntryPoint(fex) != DriverCode::OK) + { + KernelAllocator.FreePages(fex, TO_PAGES(Size)); + return DriverCode::DRIVER_RETURNED_ERROR; + } + debug("Starting driver %s", fexExtended->Driver.Name); + + KernelCallback *KCallback = (KernelCallback *)KernelAllocator.RequestPages(TO_PAGES(sizeof(KernelCallback))); + + debug("Type: %d; IOBase: %#x; MemoryBase: %#x", + ((PCI::PCIHeader0 *)PCIDevice)->BAR0 & 1, + ((PCI::PCIHeader0 *)PCIDevice)->BAR1 & (~3), + ((PCI::PCIHeader0 *)PCIDevice)->BAR0 & (~15)); + + if ((((PCI::PCIHeader0 *)PCIDevice)->BAR0 & 1) != 0) + if (!Memory::Virtual().Check((void *)(uint64_t)(((PCI::PCIHeader0 *)PCIDevice)->BAR1 & (~3)))) + { + debug("IO base (BAR1 & ~3) is not mapped"); + Memory::Virtual().Map((void *)(uint64_t)(((PCI::PCIHeader0 *)PCIDevice)->BAR1 & (~3)), (void *)(uint64_t)(((PCI::PCIHeader0 *)PCIDevice)->BAR1 & (~3)), Memory::PTFlag::RW); + } + + if ((((PCI::PCIHeader0 *)PCIDevice)->BAR0 & 1) == 0) + if (!Memory::Virtual().Check((void *)(uint64_t)(((PCI::PCIHeader0 *)PCIDevice)->BAR0 & (~15)))) + { + debug("Memory base (BAR0 & ~15) is not mapped"); + Memory::Virtual().Map((void *)(uint64_t)(((PCI::PCIHeader0 *)PCIDevice)->BAR0 & (~15)), (void *)(uint64_t)(((PCI::PCIHeader0 *)PCIDevice)->BAR0 & (~15)), Memory::PTFlag::RW); + + uint64_t original = ((PCI::PCIHeader0 *)PCIDevice)->BAR0; + ((PCI::PCIHeader0 *)PCIDevice)->BAR0 = 0xFFFFFFFF; + uint64_t size = ((PCI::PCIHeader0 *)PCIDevice)->BAR0 & 0xFFFFFFF0; + ((PCI::PCIHeader0 *)PCIDevice)->BAR0 = original; + debug("Size: %#lx (%ld pages)", size, TO_PAGES(size)); + fixme("TODO: [BUG] Mapping is broken!!!!!!"); + } + + switch (fexExtended->Driver.Type) + { + case FexDriverType::FexDriverType_Generic: + { + fixme("Generic driver: %s", fexExtended->Driver.Name); + break; + } + case FexDriverType::FexDriverType_Display: + { + fixme("Display driver: %s", fexExtended->Driver.Name); + break; + } + case FexDriverType::FexDriverType_Network: + { + DriverInterruptHook *InterruptHook = new DriverInterruptHook(((int)((PCI::PCIHeader0 *)devices[0])->InterruptLine) + 32, // x86 + (void *)((uint64_t)fexExtended->Driver.Callback + (uint64_t)fex), + KCallback); + + KCallback->RawPtr = PCIDevice; + KCallback->Reason = CallbackReason::ConfigurationReason; + int CallbackRet = ((int (*)(KernelCallback *))((uint64_t)fexExtended->Driver.Callback + (uint64_t)fex))(KCallback); + if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED) + { + KernelAllocator.FreePages(fex, TO_PAGES(Size)); + KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback))); + delete InterruptHook; + error("Driver %s does not implement the configuration callback", fexExtended->Driver.Name); + continue; + } + else if (CallbackRet == DriverReturnCode::OK) + trace("Device found for driver: %s", fexExtended->Driver.Name); + else + { + KernelAllocator.FreePages(fex, TO_PAGES(Size)); + KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback))); + delete InterruptHook; + error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet); + continue; + } + + memset(KCallback, 0, sizeof(KernelCallback)); + KCallback->Reason = CallbackReason::InterruptReason; + + DriverFile *DrvFile = new DriverFile; + DrvFile->DriverUID = KAPI.Info.DriverUID; + DrvFile->Address = (void *)fex; + DrvFile->InterruptHook[0] = InterruptHook; + Drivers.push_back(DrvFile); + break; + } + case FexDriverType::FexDriverType_Storage: + { + KCallback->RawPtr = PCIDevice; + KCallback->Reason = CallbackReason::ConfigurationReason; + int CallbackRet = ((int (*)(KernelCallback *))((uint64_t)fexExtended->Driver.Callback + (uint64_t)fex))(KCallback); + if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED) + { + KernelAllocator.FreePages(fex, TO_PAGES(Size)); + KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback))); + error("Driver %s does not implement the configuration callback", fexExtended->Driver.Name); + continue; + } + else if (CallbackRet == DriverReturnCode::OK) + trace("Device found for driver: %s", fexExtended->Driver.Name); + else + { + KernelAllocator.FreePages(fex, TO_PAGES(Size)); + KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback))); + error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet); + continue; + } + + DriverFile *DrvFile = new DriverFile; + DrvFile->DriverUID = KAPI.Info.DriverUID; + DrvFile->Address = (void *)fex; + DrvFile->InterruptHook[0] = nullptr; + Drivers.push_back(DrvFile); + break; + } + case FexDriverType::FexDriverType_FileSystem: + { + fixme("Filesystem driver: %s", fexExtended->Driver.Name); + break; + } + case FexDriverType::FexDriverType_Input: + { + fixme("Input driver: %s", fexExtended->Driver.Name); + break; + } + case FexDriverType::FexDriverType_Audio: + { + fixme("Audio driver: %s", fexExtended->Driver.Name); + break; + } + default: + { + warn("Unknown driver type: %d", fexExtended->Driver.Type); + break; + } + } + } + } + + return DriverCode::OK; + } +} diff --git a/Core/Driver/DriverLoading/BindProcess.cpp b/Core/Driver/DriverLoading/BindProcess.cpp new file mode 100644 index 0000000..9d72d84 --- /dev/null +++ b/Core/Driver/DriverLoading/BindProcess.cpp @@ -0,0 +1,22 @@ +#include "../api.hpp" + +#include +#include +#include +#include +#include +#include +#include + +#include "../../../kernel.h" +#include "../../../DAPI.hpp" +#include "../../../Fex.hpp" + +namespace Driver +{ + DriverCode Driver::DriverLoadBindProcess(void *DrvExtHdr, uint64_t DriverAddress, uint64_t Size, bool IsElf) + { + fixme("Process driver: %s", ((FexExtended *)DrvExtHdr)->Driver.Name); + return DriverCode::NOT_IMPLEMENTED; + } +} diff --git a/Execute/Spawn.cpp b/Execute/Spawn.cpp index befdf53..1c1a705 100644 --- a/Execute/Spawn.cpp +++ b/Execute/Spawn.cpp @@ -48,7 +48,7 @@ namespace Execute Vector auxv; // TODO! TCB *Thread = TaskManager->CreateThread(Process, - (IP)FexHdr->Pointer, + (IP)FexHdr->EntryPoint, argv, envp, auxv, (IPOffset)BaseImage, TaskArchitecture::x64, diff --git a/include/driver.hpp b/include/driver.hpp index 61a30c7..e710c13 100644 --- a/include/driver.hpp +++ b/include/driver.hpp @@ -17,6 +17,7 @@ namespace Driver INVALID_FEX_HEADER, INVALID_DRIVER_DATA, NOT_DRIVER, + NOT_IMPLEMENTED, DRIVER_RETURNED_ERROR, UNKNOWN_DRIVER_TYPE, PCI_DEVICE_NOT_FOUND @@ -55,6 +56,10 @@ namespace Driver unsigned long DriverUIDs = 0; DriverCode CallDriverEntryPoint(void *fex); + DriverCode DriverLoadBindPCI(void *DrvExtHdr, uint64_t DriverAddress, uint64_t Size, bool IsElf = false); + DriverCode DriverLoadBindInterrupt(void *DrvExtHdr, uint64_t DriverAddress, uint64_t Size, bool IsElf = false); + DriverCode DriverLoadBindInput(void *DrvExtHdr, uint64_t DriverAddress, uint64_t Size, bool IsElf = false); + DriverCode DriverLoadBindProcess(void *DrvExtHdr, uint64_t DriverAddress, uint64_t Size, bool IsElf = false); public: Vector GetDrivers() { return Drivers; }