Fennix/Kernel
1
0
Fork 0
mirror of https://github.com/Fennix-Project/Kernel.git synced 2025-05-28 15:34:33 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Update driver loading procedure

Browse Source
This commit is contained in:
Alex 2023-03-23 20:49:13 +02:00
parent 7b2137bf4d
commit 76f8477712
Signed by untrusted user who does not match committer: enderice2
GPG Key ID: EACC3AD603BAB4DD
4 changed files with 254 additions and 144 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

74
Core/Driver/Driver.cpp
View File

@ -104,6 +104,11 @@ namespace Driver
((KernelAPI *)KAPIAddress)->Info.Offset = (unsigned long)fex; ((KernelAPI *)KAPIAddress)->Info.Offset = (unsigned long)fex;
((KernelAPI *)KAPIAddress)->Info.DriverUID = DriverUIDs++; ((KernelAPI *)KAPIAddress)->Info.DriverUID = DriverUIDs++;
#ifdef DEBUG
FexExtended *fexExtended = (FexExtended *)((uintptr_t)fex + EXTENDED_SECTION_ADDRESS);
debug("DRIVER: %s HAS DRIVER ID %ld", fexExtended->Driver.Name, ((KernelAPI *)KAPIAddress)->Info.DriverUID);
#endif
debug("Calling driver entry point ( %#lx %ld )", (unsigned long)fex, ((KernelAPI *)KAPIAddress)->Info.DriverUID); debug("Calling driver entry point ( %#lx %ld )", (unsigned long)fex, ((KernelAPI *)KAPIAddress)->Info.DriverUID);
int ret = ((int (*)(KernelAPI *))((uintptr_t)((Fex *)fex)->EntryPoint + (uintptr_t)fex))(((KernelAPI *)KAPIAddress)); int ret = ((int (*)(KernelAPI *))((uintptr_t)((Fex *)fex)->EntryPoint + (uintptr_t)fex))(((KernelAPI *)KAPIAddress));
@ -227,15 +232,72 @@ namespace Driver
SafeFunction void DriverInterruptHook::OnInterruptReceived(void *Frame) SafeFunction void DriverInterruptHook::OnInterruptReceived(void *Frame)
#endif #endif
{ {
SmartLock(DriverInterruptLock); SmartLock(DriverInterruptLock); /* Lock in case of multiple interrupts firing at the same time */
((int (*)(void *))(Handle))(Data); if (!Handle->InterruptCallback)
{
#if defined(a64) || defined(a32)
int IntNum = Frame->InterruptNumber - 32;
#elif defined(aa64)
int IntNum = Frame->InterruptNumber;
#endif
warn("Interrupt callback for %ld is not set for driver %ld!", IntNum, Handle->DriverUID);
return;
}
CPURegisters regs;
#if defined(a64)
regs.r15 = Frame->r15;
regs.r14 = Frame->r14;
regs.r13 = Frame->r13;
regs.r12 = Frame->r12;
regs.r11 = Frame->r11;
regs.r10 = Frame->r10;
regs.r9 = Frame->r9;
regs.r8 = Frame->r8;
regs.rbp = Frame->rbp;
regs.rdi = Frame->rdi;
regs.rsi = Frame->rsi;
regs.rdx = Frame->rdx;
regs.rcx = Frame->rcx;
regs.rbx = Frame->rbx;
regs.rax = Frame->rax;
regs.InterruptNumber = Frame->InterruptNumber;
regs.ErrorCode = Frame->ErrorCode;
regs.rip = Frame->rip;
regs.cs = Frame->cs;
regs.rflags = Frame->rflags.raw;
regs.rsp = Frame->rsp;
regs.ss = Frame->ss;
#elif defined(a32)
regs.ebp = Frame->ebp;
regs.edi = Frame->edi;
regs.esi = Frame->esi;
regs.edx = Frame->edx;
regs.ecx = Frame->ecx;
regs.ebx = Frame->ebx;
regs.eax = Frame->eax;
regs.InterruptNumber = Frame->InterruptNumber;
regs.ErrorCode = Frame->ErrorCode;
regs.eip = Frame->eip;
regs.cs = Frame->cs;
regs.eflags = Frame->eflags.raw;
regs.esp = Frame->esp;
regs.ss = Frame->ss;
#elif defined(aa64)
#endif
((int (*)(void *))(Handle->InterruptCallback))(&regs);
UNUSED(Frame); UNUSED(Frame);
} }
DriverInterruptHook::DriverInterruptHook(int Interrupt, void *Address, void *ParamData) : Interrupts::Handler(Interrupt) DriverInterruptHook::DriverInterruptHook(int Interrupt, DriverFile *Handle) : Interrupts::Handler(Interrupt)
{ {
trace("Interrupt %d Hooked", Interrupt - 32); // x86 this->Handle = Handle;
Handle = Address; #if defined(a64) || defined(a32)
Data = ParamData; trace("Interrupt %d hooked to driver %ld", Interrupt, Handle->DriverUID);
#elif defined(aa64)
trace("Interrupt %d hooked to driver %ld", Interrupt, Handle->DriverUID);
#endif
} }
} }

156
Core/Driver/DriverLoading/BindInterrupt.cpp
View File

@ -25,9 +25,11 @@ namespace Driver
{ {
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS)); FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
if (fe->Driver.OverrideOnConflict) if (fe->Driver.OverrideOnConflict)
{
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
return DriverCode::DRIVER_CONFLICT; return DriverCode::DRIVER_CONFLICT;
}
DriversToRemove.push_back(Drv->DriverUID); DriversToRemove.push_back(Drv->DriverUID);
} }
@ -47,9 +49,11 @@ namespace Driver
{ {
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS)); FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
if (fe->Driver.OverrideOnConflict) if (fe->Driver.OverrideOnConflict)
{
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
return DriverCode::DRIVER_CONFLICT; return DriverCode::DRIVER_CONFLICT;
}
} }
} }
@ -58,6 +62,7 @@ namespace Driver
DrvFile->Enabled = true; DrvFile->Enabled = true;
DrvFile->DriverUID = this->DriverUIDs - 1; DrvFile->DriverUID = this->DriverUIDs - 1;
DrvFile->Address = (void *)fex; DrvFile->Address = (void *)fex;
DrvFile->InterruptCallback = (void *)((uintptr_t)fex + (uintptr_t)fexExtended->Driver.InterruptCallback);
DrvFile->MemTrk = mem; DrvFile->MemTrk = mem;
Drivers.push_back(DrvFile); Drivers.push_back(DrvFile);
return DriverCode::OK; return DriverCode::OK;
@ -74,9 +79,11 @@ namespace Driver
{ {
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS)); FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
if (fe->Driver.OverrideOnConflict) if (fe->Driver.OverrideOnConflict)
{
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
return DriverCode::DRIVER_CONFLICT; return DriverCode::DRIVER_CONFLICT;
}
DriversToRemove.push_back(Drv->DriverUID); DriversToRemove.push_back(Drv->DriverUID);
} }
@ -96,9 +103,11 @@ namespace Driver
{ {
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS)); FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
if (fe->Driver.OverrideOnConflict) if (fe->Driver.OverrideOnConflict)
{
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
return DriverCode::DRIVER_CONFLICT; return DriverCode::DRIVER_CONFLICT;
}
} }
} }
@ -118,9 +127,11 @@ namespace Driver
{ {
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS)); FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
if (fe->Driver.OverrideOnConflict) if (fe->Driver.OverrideOnConflict)
{
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
return DriverCode::DRIVER_CONFLICT; return DriverCode::DRIVER_CONFLICT;
}
DriversToRemove.push_back(Drv->DriverUID); DriversToRemove.push_back(Drv->DriverUID);
} }
@ -140,9 +151,11 @@ namespace Driver
{ {
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS)); FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
if (fe->Driver.OverrideOnConflict) if (fe->Driver.OverrideOnConflict)
{
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
return DriverCode::DRIVER_CONFLICT; return DriverCode::DRIVER_CONFLICT;
}
} }
} }
@ -154,7 +167,6 @@ namespace Driver
DriverCode Driver::BindInterruptStorage(Memory::MemMgr *mem, void *fex) DriverCode Driver::BindInterruptStorage(Memory::MemMgr *mem, void *fex)
{ {
return DriverCode::NOT_IMPLEMENTED; // FIXME return DriverCode::NOT_IMPLEMENTED; // FIXME
FexExtended *fexExtended = (FexExtended *)((uintptr_t)fex + EXTENDED_SECTION_ADDRESS); FexExtended *fexExtended = (FexExtended *)((uintptr_t)fex + EXTENDED_SECTION_ADDRESS);
if (fexExtended->Driver.OverrideOnConflict) if (fexExtended->Driver.OverrideOnConflict)
@ -164,9 +176,11 @@ namespace Driver
{ {
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS)); FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
if (fe->Driver.OverrideOnConflict) if (fe->Driver.OverrideOnConflict)
{
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
return DriverCode::DRIVER_CONFLICT; return DriverCode::DRIVER_CONFLICT;
}
DriversToRemove.push_back(Drv->DriverUID); DriversToRemove.push_back(Drv->DriverUID);
} }
@ -186,43 +200,50 @@ namespace Driver
{ {
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS)); FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
if (fe->Driver.OverrideOnConflict) if (fe->Driver.OverrideOnConflict)
{
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
return DriverCode::DRIVER_CONFLICT; return DriverCode::DRIVER_CONFLICT;
}
} }
} }
KernelCallback *KCallback = (KernelCallback *)mem->RequestPages(TO_PAGES(sizeof(KernelCallback)));
UNUSED(KCallback); // Shut up clang
for (unsigned long i = 0; i < sizeof(fexExtended->Driver.Bind.Interrupt.Vector) / sizeof(fexExtended->Driver.Bind.Interrupt.Vector[0]); i++)
{
if (fexExtended->Driver.Bind.Interrupt.Vector[i] == 0)
break;
fixme("TODO: MULTIPLE BIND INTERRUPT VECTORS %d", fexExtended->Driver.Bind.Interrupt.Vector[i]);
}
KCallback->RawPtr = nullptr;
KCallback->Reason = CallbackReason::ConfigurationReason;
int CallbackRet = ((int (*)(KernelCallback *))((uintptr_t)fexExtended->Driver.Callback + (uintptr_t)fex))(KCallback);
if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED)
{
error("Driver %s is not implemented", fexExtended->Driver.Name);
delete mem, mem = nullptr;
return DriverCode::NOT_IMPLEMENTED;
}
else if (CallbackRet != DriverReturnCode::OK)
{
error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet);
delete mem, mem = nullptr;
return DriverCode::DRIVER_RETURNED_ERROR;
}
DriverFile *DrvFile = new DriverFile; DriverFile *DrvFile = new DriverFile;
DrvFile->Enabled = true; DrvFile->Enabled = true;
DrvFile->DriverUID = this->DriverUIDs - 1; DrvFile->DriverUID = this->DriverUIDs - 1;
DrvFile->Address = (void *)fex; DrvFile->Address = (void *)fex;
DrvFile->InterruptCallback = (void *)((uintptr_t)fex + (uintptr_t)fexExtended->Driver.InterruptCallback);
DrvFile->MemTrk = mem; DrvFile->MemTrk = mem;
if (fexExtended->Driver.InterruptCallback)
{
for (unsigned long i = 0; i < sizeof(fexExtended->Driver.Bind.Interrupt.Vector) / sizeof(fexExtended->Driver.Bind.Interrupt.Vector[0]); i++)
{
if (fexExtended->Driver.Bind.Interrupt.Vector[i] == 0)
break;
DrvFile->InterruptHook[i] = new DriverInterruptHook(fexExtended->Driver.Bind.Interrupt.Vector[i], DrvFile);
}
}
KernelCallback KCallback = {.raw = 0};
KCallback.RawPtr = nullptr;
KCallback.Reason = CallbackReason::ConfigurationReason;
int CallbackRet = ((int (*)(KernelCallback *))((uintptr_t)fexExtended->Driver.Callback + (uintptr_t)fex))(&KCallback);
if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED)
{
error("Driver %s is not implemented", fexExtended->Driver.Name);
delete DrvFile, DrvFile = nullptr;
delete mem, mem = nullptr;
return DriverCode::NOT_IMPLEMENTED;
}
else if (CallbackRet != DriverReturnCode::OK)
{
error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet);
delete DrvFile, DrvFile = nullptr;
delete mem, mem = nullptr;
return DriverCode::DRIVER_RETURNED_ERROR;
}
Drivers.push_back(DrvFile); Drivers.push_back(DrvFile);
return DriverCode::OK; return DriverCode::OK;
} }
@ -238,9 +259,11 @@ namespace Driver
{ {
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS)); FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
if (fe->Driver.OverrideOnConflict) if (fe->Driver.OverrideOnConflict)
{
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
return DriverCode::DRIVER_CONFLICT; return DriverCode::DRIVER_CONFLICT;
}
DriversToRemove.push_back(Drv->DriverUID); DriversToRemove.push_back(Drv->DriverUID);
} }
@ -260,9 +283,11 @@ namespace Driver
{ {
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS)); FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
if (fe->Driver.OverrideOnConflict) if (fe->Driver.OverrideOnConflict)
{
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
return DriverCode::DRIVER_CONFLICT; return DriverCode::DRIVER_CONFLICT;
}
} }
} }
@ -323,51 +348,42 @@ namespace Driver
} }
} }
KernelCallback *KCallback = (KernelCallback *)mem->RequestPages(TO_PAGES(sizeof(KernelCallback))); DriverFile *DrvFile = new DriverFile;
DrvFile->Enabled = true;
DriverInterruptHook *InterruptHook = nullptr; DrvFile->DriverUID = this->DriverUIDs - 1;
if (fexExtended->Driver.Bind.Interrupt.Vector[0] != 0) DrvFile->Address = (void *)fex;
InterruptHook = new DriverInterruptHook(fexExtended->Driver.Bind.Interrupt.Vector[0] + 32, // x86 DrvFile->InterruptCallback = (void *)((uintptr_t)fex + (uintptr_t)fexExtended->Driver.InterruptCallback);
(void *)((uintptr_t)fexExtended->Driver.Callback + (uintptr_t)fex), DrvFile->MemTrk = mem;
KCallback); if (fexExtended->Driver.InterruptCallback)
for (unsigned long i = 0; i < sizeof(fexExtended->Driver.Bind.Interrupt.Vector) / sizeof(fexExtended->Driver.Bind.Interrupt.Vector[0]); i++)
{ {
if (fexExtended->Driver.Bind.Interrupt.Vector[i] == 0) for (unsigned long i = 0; i < sizeof(fexExtended->Driver.Bind.Interrupt.Vector) / sizeof(fexExtended->Driver.Bind.Interrupt.Vector[0]); i++)
break; {
// InterruptHook = new DriverInterruptHook((fexExtended->Driver.Bind.Interrupt.Vector[i] + 32, // x86 if (fexExtended->Driver.Bind.Interrupt.Vector[i] == 0)
// (void *)((uintptr_t)fexExtended->Driver.Callback + (uintptr_t)fex), break;
// KCallback); DrvFile->InterruptHook[i] = new DriverInterruptHook(fexExtended->Driver.Bind.Interrupt.Vector[i], DrvFile);
fixme("TODO: MULTIPLE BIND INTERRUPT VECTORS %d", fexExtended->Driver.Bind.Interrupt.Vector[i]); }
} }
KCallback->RawPtr = nullptr; KernelCallback KCallback = {.raw = 0};
KCallback->Reason = CallbackReason::ConfigurationReason; KCallback.RawPtr = nullptr;
int CallbackRet = ((int (*)(KernelCallback *))((uintptr_t)fexExtended->Driver.Callback + (uintptr_t)fex))(KCallback); KCallback.Reason = CallbackReason::ConfigurationReason;
int CallbackRet = ((int (*)(KernelCallback *))((uintptr_t)fexExtended->Driver.Callback + (uintptr_t)fex))(&KCallback);
if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED) if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED)
{ {
error("Driver %s is not implemented", fexExtended->Driver.Name); error("Driver %s is not implemented", fexExtended->Driver.Name);
delete InterruptHook, InterruptHook = nullptr; delete DrvFile, DrvFile = nullptr;
delete mem, mem = nullptr; delete mem, mem = nullptr;
return DriverCode::NOT_IMPLEMENTED; return DriverCode::NOT_IMPLEMENTED;
} }
else if (CallbackRet != DriverReturnCode::OK) else if (CallbackRet != DriverReturnCode::OK)
{ {
error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet); error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet);
delete InterruptHook, InterruptHook = nullptr; delete DrvFile, DrvFile = nullptr;
delete mem, mem = nullptr; delete mem, mem = nullptr;
return DriverCode::DRIVER_RETURNED_ERROR; return DriverCode::DRIVER_RETURNED_ERROR;
} }
memset(KCallback, 0, sizeof(KernelCallback));
KCallback->Reason = CallbackReason::InterruptReason;
DriverFile *DrvFile = new DriverFile;
DrvFile->Enabled = true;
DrvFile->DriverUID = this->DriverUIDs - 1;
DrvFile->Address = (void *)fex;
DrvFile->MemTrk = mem;
DrvFile->InterruptHook[0] = InterruptHook;
Drivers.push_back(DrvFile); Drivers.push_back(DrvFile);
return DriverCode::OK; return DriverCode::OK;
} }
@ -383,9 +399,11 @@ namespace Driver
{ {
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS)); FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
if (fe->Driver.OverrideOnConflict) if (fe->Driver.OverrideOnConflict)
{
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
return DriverCode::DRIVER_CONFLICT; return DriverCode::DRIVER_CONFLICT;
}
DriversToRemove.push_back(Drv->DriverUID); DriversToRemove.push_back(Drv->DriverUID);
} }
@ -405,9 +423,11 @@ namespace Driver
{ {
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS)); FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
if (fe->Driver.OverrideOnConflict) if (fe->Driver.OverrideOnConflict)
{
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
return DriverCode::DRIVER_CONFLICT; return DriverCode::DRIVER_CONFLICT;
}
} }
} }

143
Core/Driver/DriverLoading/BindPCI.cpp
View File

@ -138,9 +138,11 @@ namespace Driver
{ {
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS)); FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
if (fe->Driver.OverrideOnConflict) if (fe->Driver.OverrideOnConflict)
{
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
return DriverCode::DRIVER_CONFLICT; return DriverCode::DRIVER_CONFLICT;
}
DriversToRemove.push_back(Drv->DriverUID); DriversToRemove.push_back(Drv->DriverUID);
} }
@ -160,9 +162,11 @@ namespace Driver
{ {
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS)); FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
if (fe->Driver.OverrideOnConflict) if (fe->Driver.OverrideOnConflict)
{
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
return DriverCode::DRIVER_CONFLICT; return DriverCode::DRIVER_CONFLICT;
}
} }
} }
@ -182,9 +186,11 @@ namespace Driver
{ {
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS)); FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
if (fe->Driver.OverrideOnConflict) if (fe->Driver.OverrideOnConflict)
{
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
return DriverCode::DRIVER_CONFLICT; return DriverCode::DRIVER_CONFLICT;
}
DriversToRemove.push_back(Drv->DriverUID); DriversToRemove.push_back(Drv->DriverUID);
} }
@ -204,9 +210,11 @@ namespace Driver
{ {
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS)); FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
if (fe->Driver.OverrideOnConflict) if (fe->Driver.OverrideOnConflict)
{
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
return DriverCode::DRIVER_CONFLICT; return DriverCode::DRIVER_CONFLICT;
}
} }
} }
@ -226,9 +234,11 @@ namespace Driver
{ {
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS)); FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
if (fe->Driver.OverrideOnConflict) if (fe->Driver.OverrideOnConflict)
{
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
return DriverCode::DRIVER_CONFLICT; return DriverCode::DRIVER_CONFLICT;
}
DriversToRemove.push_back(Drv->DriverUID); DriversToRemove.push_back(Drv->DriverUID);
} }
@ -248,26 +258,33 @@ namespace Driver
{ {
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS)); FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
if (fe->Driver.OverrideOnConflict) if (fe->Driver.OverrideOnConflict)
{
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
return DriverCode::DRIVER_CONFLICT; return DriverCode::DRIVER_CONFLICT;
}
} }
} }
KernelCallback *KCallback = (KernelCallback *)mem->RequestPages(TO_PAGES(sizeof(KernelCallback))); DriverFile *DrvFile = new DriverFile;
DrvFile->Enabled = true;
DrvFile->DriverUID = this->DriverUIDs - 1;
DrvFile->Address = (void *)fex;
DrvFile->InterruptCallback = (void *)((uintptr_t)fex + (uintptr_t)fexExtended->Driver.InterruptCallback);
DrvFile->MemTrk = mem;
if (fexExtended->Driver.InterruptCallback)
DrvFile->InterruptHook[0] = new DriverInterruptHook(((int)((PCI::PCIHeader0 *)PCIDevice)->InterruptLine), DrvFile);
DriverInterruptHook *InterruptHook = new DriverInterruptHook(((int)((PCI::PCIHeader0 *)PCIDevice)->InterruptLine) + 32, // x86 KernelCallback KCallback = {.raw = 0};
(void *)((uintptr_t)fexExtended->Driver.Callback + (uintptr_t)fex), KCallback.RawPtr = PCIDevice;
KCallback); KCallback.Reason = CallbackReason::ConfigurationReason;
int CallbackRet = ((int (*)(KernelCallback *))((uintptr_t)fexExtended->Driver.Callback + (uintptr_t)fex))(&KCallback);
KCallback->RawPtr = PCIDevice;
KCallback->Reason = CallbackReason::ConfigurationReason;
int CallbackRet = ((int (*)(KernelCallback *))((uintptr_t)fexExtended->Driver.Callback + (uintptr_t)fex))(KCallback);
if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED) if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED)
{ {
error("Driver %s is not implemented", fexExtended->Driver.Name); error("Driver %s is not implemented", fexExtended->Driver.Name);
delete DrvFile, DrvFile = nullptr;
delete mem, mem = nullptr; delete mem, mem = nullptr;
delete InterruptHook, InterruptHook = nullptr;
return DriverCode::NOT_IMPLEMENTED; return DriverCode::NOT_IMPLEMENTED;
} }
else if (CallbackRet == DriverReturnCode::OK) else if (CallbackRet == DriverReturnCode::OK)
@ -275,20 +292,11 @@ namespace Driver
else else
{ {
error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet); error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet);
delete DrvFile, DrvFile = nullptr;
delete mem, mem = nullptr; delete mem, mem = nullptr;
delete InterruptHook, InterruptHook = nullptr;
return DriverCode::DRIVER_RETURNED_ERROR; return DriverCode::DRIVER_RETURNED_ERROR;
} }
memset(KCallback, 0, sizeof(KernelCallback));
KCallback->Reason = CallbackReason::InterruptReason;
DriverFile *DrvFile = new DriverFile;
DrvFile->Enabled = true;
DrvFile->DriverUID = this->DriverUIDs - 1;
DrvFile->Address = (void *)fex;
DrvFile->MemTrk = mem;
DrvFile->InterruptHook[0] = InterruptHook;
Drivers.push_back(DrvFile); Drivers.push_back(DrvFile);
return DriverCode::OK; return DriverCode::OK;
} }
@ -304,9 +312,11 @@ namespace Driver
{ {
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS)); FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
if (fe->Driver.OverrideOnConflict) if (fe->Driver.OverrideOnConflict)
{
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
return DriverCode::DRIVER_CONFLICT; return DriverCode::DRIVER_CONFLICT;
}
DriversToRemove.push_back(Drv->DriverUID); DriversToRemove.push_back(Drv->DriverUID);
} }
@ -326,20 +336,32 @@ namespace Driver
{ {
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS)); FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
if (fe->Driver.OverrideOnConflict) if (fe->Driver.OverrideOnConflict)
{
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
return DriverCode::DRIVER_CONFLICT; return DriverCode::DRIVER_CONFLICT;
}
} }
} }
KernelCallback *KCallback = (KernelCallback *)mem->RequestPages(TO_PAGES(sizeof(KernelCallback))); DriverFile *DrvFile = new DriverFile;
DrvFile->Enabled = true;
DrvFile->DriverUID = this->DriverUIDs - 1;
DrvFile->Address = (void *)fex;
DrvFile->InterruptCallback = (void *)((uintptr_t)fex + (uintptr_t)fexExtended->Driver.InterruptCallback);
DrvFile->MemTrk = mem;
if (fexExtended->Driver.InterruptCallback)
DrvFile->InterruptHook[0] = new DriverInterruptHook(((int)((PCI::PCIHeader0 *)PCIDevice)->InterruptLine), DrvFile);
KernelCallback KCallback = {.raw = 0};
KCallback.RawPtr = PCIDevice;
KCallback.Reason = CallbackReason::ConfigurationReason;
int CallbackRet = ((int (*)(KernelCallback *))((uintptr_t)fexExtended->Driver.Callback + (uintptr_t)fex))(&KCallback);
KCallback->RawPtr = PCIDevice;
KCallback->Reason = CallbackReason::ConfigurationReason;
int CallbackRet = ((int (*)(KernelCallback *))((uintptr_t)fexExtended->Driver.Callback + (uintptr_t)fex))(KCallback);
if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED) if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED)
{ {
error("Driver %s is not implemented", fexExtended->Driver.Name); error("Driver %s is not implemented", fexExtended->Driver.Name);
delete DrvFile, DrvFile = nullptr;
delete mem, mem = nullptr; delete mem, mem = nullptr;
return DriverCode::NOT_IMPLEMENTED; return DriverCode::NOT_IMPLEMENTED;
} }
@ -348,16 +370,11 @@ namespace Driver
else else
{ {
error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet); error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet);
delete DrvFile, DrvFile = nullptr;
delete mem, mem = nullptr; delete mem, mem = nullptr;
return DriverCode::DRIVER_RETURNED_ERROR; return DriverCode::DRIVER_RETURNED_ERROR;
} }
DriverFile *DrvFile = new DriverFile;
DrvFile->Enabled = true;
DrvFile->DriverUID = this->DriverUIDs - 1;
DrvFile->Address = (void *)fex;
DrvFile->MemTrk = mem;
DrvFile->InterruptHook[0] = nullptr;
Drivers.push_back(DrvFile); Drivers.push_back(DrvFile);
return DriverCode::OK; return DriverCode::OK;
} }
@ -373,9 +390,11 @@ namespace Driver
{ {
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS)); FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
if (fe->Driver.OverrideOnConflict) if (fe->Driver.OverrideOnConflict)
{
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
return DriverCode::DRIVER_CONFLICT; return DriverCode::DRIVER_CONFLICT;
}
DriversToRemove.push_back(Drv->DriverUID); DriversToRemove.push_back(Drv->DriverUID);
} }
@ -395,9 +414,11 @@ namespace Driver
{ {
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS)); FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
if (fe->Driver.OverrideOnConflict) if (fe->Driver.OverrideOnConflict)
{
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
return DriverCode::DRIVER_CONFLICT; return DriverCode::DRIVER_CONFLICT;
}
} }
} }
@ -417,9 +438,11 @@ namespace Driver
{ {
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS)); FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
if (fe->Driver.OverrideOnConflict) if (fe->Driver.OverrideOnConflict)
{
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
return DriverCode::DRIVER_CONFLICT; return DriverCode::DRIVER_CONFLICT;
}
DriversToRemove.push_back(Drv->DriverUID); DriversToRemove.push_back(Drv->DriverUID);
} }
@ -439,9 +462,11 @@ namespace Driver
{ {
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS)); FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
if (fe->Driver.OverrideOnConflict) if (fe->Driver.OverrideOnConflict)
{
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
return DriverCode::DRIVER_CONFLICT; return DriverCode::DRIVER_CONFLICT;
}
} }
} }
@ -461,9 +486,11 @@ namespace Driver
{ {
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS)); FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
if (fe->Driver.OverrideOnConflict) if (fe->Driver.OverrideOnConflict)
{
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
return DriverCode::DRIVER_CONFLICT; return DriverCode::DRIVER_CONFLICT;
}
DriversToRemove.push_back(Drv->DriverUID); DriversToRemove.push_back(Drv->DriverUID);
} }
@ -483,24 +510,32 @@ namespace Driver
{ {
FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS)); FexExtended *fe = ((FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS));
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
if (fe->Driver.OverrideOnConflict) if (fe->Driver.OverrideOnConflict)
{
debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
return DriverCode::DRIVER_CONFLICT; return DriverCode::DRIVER_CONFLICT;
}
} }
} }
KernelCallback *KCallback = (KernelCallback *)mem->RequestPages(TO_PAGES(sizeof(KernelCallback))); DriverFile *DrvFile = new DriverFile;
DrvFile->Enabled = true;
DrvFile->DriverUID = this->DriverUIDs - 1;
DrvFile->Address = (void *)fex;
DrvFile->InterruptCallback = (void *)((uintptr_t)fex + (uintptr_t)fexExtended->Driver.InterruptCallback);
DrvFile->MemTrk = mem;
if (fexExtended->Driver.InterruptCallback)
DrvFile->InterruptHook[0] = new DriverInterruptHook(((int)((PCI::PCIHeader0 *)PCIDevice)->InterruptLine), DrvFile);
DriverInterruptHook *InterruptHook = new DriverInterruptHook(((int)((PCI::PCIHeader0 *)PCIDevice)->InterruptLine) + 32, // x86 KernelCallback KCallback = {.raw = 0};
(void *)((uintptr_t)fexExtended->Driver.Callback + (uintptr_t)fex), KCallback.RawPtr = PCIDevice;
KCallback); KCallback.Reason = CallbackReason::ConfigurationReason;
int CallbackRet = ((int (*)(KernelCallback *))((uintptr_t)fexExtended->Driver.Callback + (uintptr_t)fex))(&KCallback);
KCallback->RawPtr = PCIDevice;
KCallback->Reason = CallbackReason::ConfigurationReason;
int CallbackRet = ((int (*)(KernelCallback *))((uintptr_t)fexExtended->Driver.Callback + (uintptr_t)fex))(KCallback);
if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED) if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED)
{ {
error("Driver %s is not implemented", fexExtended->Driver.Name); error("Driver %s is not implemented", fexExtended->Driver.Name);
delete DrvFile, DrvFile = nullptr;
delete mem, mem = nullptr; delete mem, mem = nullptr;
return DriverCode::NOT_IMPLEMENTED; return DriverCode::NOT_IMPLEMENTED;
} }
@ -509,19 +544,11 @@ namespace Driver
else else
{ {
error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet); error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet);
delete DrvFile, DrvFile = nullptr;
delete mem, mem = nullptr; delete mem, mem = nullptr;
return DriverCode::DRIVER_RETURNED_ERROR; return DriverCode::DRIVER_RETURNED_ERROR;
} }
memset(KCallback, 0, sizeof(KernelCallback));
KCallback->Reason = CallbackReason::InterruptReason;
DriverFile *DrvFile = new DriverFile;
DrvFile->Enabled = true;
DrvFile->DriverUID = this->DriverUIDs - 1;
DrvFile->Address = (void *)fex;
DrvFile->MemTrk = mem;
DrvFile->InterruptHook[0] = InterruptHook;
Drivers.push_back(DrvFile); Drivers.push_back(DrvFile);
return DriverCode::OK; return DriverCode::OK;
} }

25
include/driver.hpp
View File

@ -27,11 +27,21 @@ namespace Driver
DRIVER_CONFLICT DRIVER_CONFLICT
}; };
class DriverInterruptHook;
struct DriverFile
{
bool Enabled;
unsigned long DriverUID;
void *Address;
void *InterruptCallback;
Memory::MemMgr *MemTrk;
DriverInterruptHook *InterruptHook[16];
};
class DriverInterruptHook : public Interrupts::Handler class DriverInterruptHook : public Interrupts::Handler
{ {
private: private:
void *Handle; DriverFile *Handle;
void *Data;
#if defined(a64) #if defined(a64)
void OnInterruptReceived(CPU::x64::TrapFrame *Frame); void OnInterruptReceived(CPU::x64::TrapFrame *Frame);
@ -42,19 +52,10 @@ namespace Driver
#endif #endif
public: public:
DriverInterruptHook(int Interrupt, void *Address, void *ParamData); DriverInterruptHook(int Interrupt, DriverFile *Handle);
virtual ~DriverInterruptHook() = default; virtual ~DriverInterruptHook() = default;
}; };
struct DriverFile
{
bool Enabled;
unsigned long DriverUID;
void *Address;
Memory::MemMgr *MemTrk;
DriverInterruptHook *InterruptHook[16];
};
class Driver class Driver
{ {
private: private: