Update driver loading procedure

Core/Driver/Driver.cpp

@@ -104,6 +104,11 @@ namespace Driver
         ((KernelAPI *)KAPIAddress)->Info.Offset = (unsigned long)fex;
         ((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);
         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)
 #endif
     {
-        SmartLock(DriverInterruptLock);
-        ((int (*)(void *))(Handle))(Data);
+        SmartLock(DriverInterruptLock); /* Lock in case of multiple interrupts firing at the same time */
+        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);
     }
 
-    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
-        Handle = Address;
-        Data = ParamData;
+        this->Handle = Handle;
+#if defined(a64) || defined(a32)
+        trace("Interrupt %d hooked to driver %ld", Interrupt, Handle->DriverUID);
+#elif defined(aa64)
+        trace("Interrupt %d hooked to driver %ld", Interrupt, Handle->DriverUID);
+#endif
     }
 }

Core/Driver/DriverLoading/BindInterrupt.cpp

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

Core/Driver/DriverLoading/BindPCI.cpp

@@ -138,9 +138,11 @@ namespace Driver
             {
                 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)
+                {
+                    debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
                     return DriverCode::DRIVER_CONFLICT;
+                }
 
                 DriversToRemove.push_back(Drv->DriverUID);
             }
@@ -160,9 +162,11 @@ namespace Driver
             {
                 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)
+                {
+                    debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
                     return DriverCode::DRIVER_CONFLICT;
+                }
             }
         }
 
@@ -182,9 +186,11 @@ namespace Driver
             {
                 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)
+                {
+                    debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
                     return DriverCode::DRIVER_CONFLICT;
+                }
 
                 DriversToRemove.push_back(Drv->DriverUID);
             }
@@ -204,9 +210,11 @@ namespace Driver
             {
                 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)
+                {
+                    debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
                     return DriverCode::DRIVER_CONFLICT;
+                }
             }
         }
 
@@ -226,9 +234,11 @@ namespace Driver
             {
                 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)
+                {
+                    debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
                     return DriverCode::DRIVER_CONFLICT;
+                }
 
                 DriversToRemove.push_back(Drv->DriverUID);
             }
@@ -248,26 +258,33 @@ namespace Driver
             {
                 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)
+                {
+                    debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
                     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
-                                                                     (void *)((uintptr_t)fexExtended->Driver.Callback + (uintptr_t)fex),
-                                                                     KCallback);
+        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)
         {
             error("Driver %s is not implemented", fexExtended->Driver.Name);
+            delete DrvFile, DrvFile = nullptr;
             delete mem, mem = nullptr;
-            delete InterruptHook, InterruptHook = nullptr;
             return DriverCode::NOT_IMPLEMENTED;
         }
         else if (CallbackRet == DriverReturnCode::OK)
@@ -275,20 +292,11 @@ namespace Driver
         else
         {
             error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet);
+            delete DrvFile, DrvFile = nullptr;
             delete mem, mem = nullptr;
-            delete InterruptHook, InterruptHook = nullptr;
             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);
         return DriverCode::OK;
     }
@@ -304,9 +312,11 @@ namespace Driver
             {
                 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)
+                {
+                    debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
                     return DriverCode::DRIVER_CONFLICT;
+                }
 
                 DriversToRemove.push_back(Drv->DriverUID);
             }
@@ -326,20 +336,32 @@ namespace Driver
             {
                 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)
+                {
+                    debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
                     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)
         {
             error("Driver %s is not implemented", fexExtended->Driver.Name);
+            delete DrvFile, DrvFile = nullptr;
             delete mem, mem = nullptr;
             return DriverCode::NOT_IMPLEMENTED;
         }
@@ -348,16 +370,11 @@ namespace Driver
         else
         {
             error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet);
+            delete DrvFile, DrvFile = nullptr;
             delete mem, mem = nullptr;
             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);
         return DriverCode::OK;
     }
@@ -373,9 +390,11 @@ namespace Driver
             {
                 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)
+                {
+                    debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
                     return DriverCode::DRIVER_CONFLICT;
+                }
 
                 DriversToRemove.push_back(Drv->DriverUID);
             }
@@ -395,9 +414,11 @@ namespace Driver
             {
                 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)
+                {
+                    debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
                     return DriverCode::DRIVER_CONFLICT;
+                }
             }
         }
 
@@ -417,9 +438,11 @@ namespace Driver
             {
                 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)
+                {
+                    debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
                     return DriverCode::DRIVER_CONFLICT;
+                }
 
                 DriversToRemove.push_back(Drv->DriverUID);
             }
@@ -439,9 +462,11 @@ namespace Driver
             {
                 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)
+                {
+                    debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
                     return DriverCode::DRIVER_CONFLICT;
+                }
             }
         }
 
@@ -461,9 +486,11 @@ namespace Driver
             {
                 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)
+                {
+                    debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
                     return DriverCode::DRIVER_CONFLICT;
+                }
 
                 DriversToRemove.push_back(Drv->DriverUID);
             }
@@ -483,24 +510,32 @@ namespace Driver
             {
                 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)
+                {
+                    debug("Driver %s is conflicting with %s", fe->Driver.Name, fexExtended->Driver.Name);
                     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
-                                                                     (void *)((uintptr_t)fexExtended->Driver.Callback + (uintptr_t)fex),
-                                                                     KCallback);
+        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)
         {
             error("Driver %s is not implemented", fexExtended->Driver.Name);
+            delete DrvFile, DrvFile = nullptr;
             delete mem, mem = nullptr;
             return DriverCode::NOT_IMPLEMENTED;
         }
@@ -509,19 +544,11 @@ namespace Driver
         else
         {
             error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet);
+            delete DrvFile, DrvFile = nullptr;
             delete mem, mem = nullptr;
             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);
         return DriverCode::OK;
     }

include/driver.hpp

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