Optimize memory usage

Core/Crash/CrashHandler.cpp

@@ -836,9 +836,12 @@ namespace CrashHandler
             CPUData *data = GetCurrentCPU();
             if (data)
             {
-                if (!data->CurrentThread->Security.IsCritical)
+                if (data->CurrentThread)
                 {
-                    fixme("Exception in non-critical thread (kernel mode)");
+                    if (!data->CurrentThread->Security.IsCritical)
+                    {
+                        fixme("Exception in non-critical thread (kernel mode)");
+                    }
                 }
             }
 

Core/Disk.cpp

@@ -30,7 +30,7 @@ namespace Disk
     {
         KernelCallback callback{};
         callback.Reason = FetchReason;
-        DriverManager->IOCB(DriverUID, (void *)&callback);
+        DriverManager->IOCB(DriverUID, &callback);
         this->AvailablePorts = callback.DiskCallback.Fetch.Ports;
         this->BytesPerSector = callback.DiskCallback.Fetch.BytesPerSector;
         debug("AvailablePorts:%ld BytesPerSector:%ld", this->AvailablePorts, this->BytesPerSector);
@@ -57,7 +57,7 @@ namespace Disk
                 .Buffer = RWBuffer,
                 .Write = false,
             };
-            DriverManager->IOCB(DriverUID, (void *)&callback);
+            DriverManager->IOCB(DriverUID, &callback);
             memcpy(&drive.Table, RWBuffer, sizeof(PartitionTable));
 
             /*
@@ -80,7 +80,7 @@ namespace Disk
                         .Buffer = RWBuffer,
                         .Write = false,
                     };
-                    DriverManager->IOCB(DriverUID, (void *)&callback);
+                    DriverManager->IOCB(DriverUID, &callback);
 
                     for (uint32_t e = 0; e < Entries; e++)
                     {

Core/Driver/Driver.cpp

@@ -48,74 +48,78 @@ namespace Driver
 
     void Driver::Panic()
     {
+#ifdef DEBUG
         size_t DriversNum = Drivers.size();
         debug("%ld drivers loaded, [DUIDs: %ld]", DriversNum, DriverUIDs);
         debug("driver size %ld", DriversNum);
-        for (size_t i = 0; i < DriversNum; i++)
+#endif
+
+        foreach (auto drv in Drivers)
         {
-            DriverFile drv = Drivers[i];
+            KernelCallback callback{};
-            KernelCallback callback;
             callback.Reason = StopReason;
-            debug("Removing interrupt hook for %ld [%#lx]", drv.DriverUID, drv.Address);
+            DriverManager->IOCB(drv.DriverUID, &callback);
-            DriverManager->IOCB(drv.DriverUID, (void *)&callback);
 
             for (size_t j = 0; j < sizeof(drv.InterruptHook) / sizeof(drv.InterruptHook[0]); j++)
             {
                 if (!drv.InterruptHook[j])
                     continue;
-                delete drv.InterruptHook[j], drv.InterruptHook[j] = nullptr;
+                drv.InterruptHook[j]->Disable();
+                debug("Interrupt hook %#lx disabled", drv.InterruptHook[j]);
             }
         }
     }
 
     void Driver::UnloadAllDrivers()
     {
+#ifdef DEBUG
         size_t DriversNum = Drivers.size();
         debug("%ld drivers loaded, [DUIDs: %ld]", DriversNum, DriverUIDs);
         debug("driver size %ld", DriversNum);
-        for (size_t i = 0; i < DriversNum; i++)
+#endif
+
+        foreach (auto drv in Drivers)
         {
-            DriverFile drv = Drivers[i];
+            KernelCallback callback{};
-            KernelCallback callback;
             callback.Reason = StopReason;
             debug("Stopping & unloading driver %ld [%#lx]", drv.DriverUID, drv.Address);
-            DriverManager->IOCB(drv.DriverUID, (void *)&callback);
+            DriverManager->IOCB(drv.DriverUID, &callback);
 
             for (size_t j = 0; j < sizeof(drv.InterruptHook) / sizeof(drv.InterruptHook[0]); j++)
             {
                 if (!drv.InterruptHook[j])
-                    break;
+                    continue;
                 debug("Interrupt hook %#lx", drv.InterruptHook[j]);
                 delete drv.InterruptHook[j], drv.InterruptHook[j] = nullptr;
             }
             if (drv.MemTrk)
                 delete drv.MemTrk, drv.MemTrk = nullptr;
-            Drivers.remove(i);
+            Drivers.remove(drv);
         }
     }
 
     bool Driver::UnloadDriver(unsigned long DUID)
     {
         debug("Searching for driver %ld", DUID);
-        for (size_t i = 0; i < Drivers.size(); i++)
+
+        foreach (auto drv in Drivers)
         {
-            DriverFile drv = Drivers[i];
             if (drv.DriverUID == DUID)
             {
-                KernelCallback callback;
+                KernelCallback callback{};
                 callback.Reason = StopReason;
                 debug("Stopping and unloading driver %ld [%#lx]", drv.DriverUID, drv.Address);
-                this->IOCB(drv.DriverUID, (void *)&callback);
+                this->IOCB(drv.DriverUID, &callback);
 
                 for (size_t j = 0; j < sizeof(drv.InterruptHook) / sizeof(drv.InterruptHook[0]); j++)
                 {
                     if (!drv.InterruptHook[j])
-                        break;
+                        continue;
                     debug("Interrupt hook %#lx", drv.InterruptHook[j]);
                     delete drv.InterruptHook[j], drv.InterruptHook[j] = nullptr;
                 }
                 delete drv.MemTrk, drv.MemTrk = nullptr;
-                Drivers.remove(i);
+                Drivers.remove(drv);
                 return true;
             }
         }
@@ -274,6 +278,9 @@ namespace Driver
 #endif
     {
         SmartLock(DriverInterruptLock); /* Lock in case of multiple interrupts firing at the same time */
+        if (!this->Enabled)
+            return;
+
         if (!Handle.InterruptCallback)
         {
 #if defined(a86)

Execute/Elf/BaseLoad.cpp

@@ -122,7 +122,6 @@ namespace Execute
     {
         ELFInterpreterIPCThread(InterpreterTargetProcess, (char *)InterpreterTargetPath->c_str(), InterpreterMemoryImage, InterpreterElfFile, InterpreterNeededLibraries);
         delete InterpreterTargetPath, InterpreterTargetPath = nullptr;
-        return;
     }
 
     ELFBaseLoad ELFLoad(char *Path, const char **argv, const char **envp, Tasking::TaskCompatibility Compatibility)

GUI/GraphicalUserInterface.cpp

@@ -51,9 +51,9 @@ namespace GraphicalUserInterface
                     if (!once++)
                         debug("Found mouse driver %ld", Driver.DriverUID);
 #endif
-                    KernelCallback callback;
+                    KernelCallback callback{};
                     callback.Reason = FetchReason;
-                    DriverManager->IOCB(Driver.DriverUID, (void *)&callback);
+                    DriverManager->IOCB(Driver.DriverUID, &callback);
                     Mouse.X = callback.InputCallback.Mouse.X;
                     Mouse.Y = callback.InputCallback.Mouse.Y;
                     Mouse.Z = callback.InputCallback.Mouse.Z;

KernelThread.cpp

@@ -332,7 +332,7 @@ void KernelMainThread()
 
     KPrint("Loading Drivers...");
     DriverManager = new Driver::Driver;
-KST_Shutdown();
+
     KPrint("Fetching Disks...");
     if (DriverManager->GetDrivers().size() > 0)
     {

Network/NetworkController.cpp

@@ -62,22 +62,29 @@ namespace NetworkInterfaceManager
         for (size_t i = 0; i < RegisteredEvents.size(); i++)
             RegisteredEvents.remove(i);
 
+        foreach (auto inf in Interfaces)
+        {
+            if (inf)
+            {
+                Interfaces.remove(inf);
+                delete inf, inf = nullptr;
+            }
+        }
+
         // Delete all interfaces and their callbacks and free the memory
         delete mem, mem = nullptr;
     }
 
     void NetworkInterface::FetchNetworkCards(unsigned long DriverUID)
     {
-        KernelCallback *cb = (KernelCallback *)mem->RequestPages(TO_PAGES(sizeof(KernelCallback) + 1));
+        KernelCallback cb{};
-        memset(cb, 0, sizeof(KernelCallback));
+        cb.Reason = FetchReason;
-        cb->Reason = FetchReason;
+        DriverManager->IOCB(DriverUID, &cb);
-        DriverManager->IOCB(DriverUID, (void *)cb);
 
         DeviceInterface *Iface = (DeviceInterface *)mem->RequestPages(TO_PAGES(sizeof(DeviceInterface) + 1));
-        strcpy(Iface->Name, cb->NetworkCallback.Fetch.Name);
+        strcpy(Iface->Name, cb.NetworkCallback.Fetch.Name);
         Iface->ID = this->CardIDs++;
-        Iface->MAC.FromHex(cb->NetworkCallback.Fetch.MAC);
+        Iface->MAC.FromHex(cb.NetworkCallback.Fetch.MAC);
-        Iface->DriverCallBackAddress = cb;
         Iface->DriverID = DriverUID;
         Interfaces.push_back(Iface);
 
@@ -98,7 +105,7 @@ namespace NetworkInterfaceManager
         TaskManager->GetCurrentThread()->SetPriority(Tasking::TaskPriority::Critical);
         DeviceInterface *DefaultDevice = nullptr;
         foreach (auto inf in Interfaces)
-            if (inf && inf->DriverCallBackAddress)
+            if (inf)
             {
                 DefaultDevice = inf;
                 break;
@@ -201,13 +208,11 @@ namespace NetworkInterfaceManager
         void *DataToBeSent = mem->RequestPages(TO_PAGES(Length + 1));
         memcpy(DataToBeSent, Data, Length);
 
-        KernelCallback *cb = (KernelCallback *)Interface->DriverCallBackAddress;
+        KernelCallback cb{};
-
+        cb.Reason = SendReason;
-        memset(cb, 0, sizeof(KernelCallback));
+        cb.NetworkCallback.Send.Data = (uint8_t *)DataToBeSent;
-        cb->Reason = SendReason;
+        cb.NetworkCallback.Send.Length = Length;
-        cb->NetworkCallback.Send.Data = (uint8_t *)DataToBeSent;
+        DriverManager->IOCB(Interface->DriverID, &cb);
-        cb->NetworkCallback.Send.Length = Length;
-        DriverManager->IOCB(Interface->DriverID, (void *)cb);
 
         mem->FreePages(DataToBeSent, TO_PAGES(Length + 1));
         foreach (auto var in RegisteredEvents)

Recovery/RecoveryMain.cpp

@@ -81,13 +81,12 @@ namespace Recovery
         void *PCMRaw = KernelAllocator.RequestPages(TO_PAGES(pcm->node->Length + 1));
         memcpy(PCMRaw, (void *)pcm->node->Address, pcm->node->Length);
 
-        KernelCallback callback;
+        KernelCallback callback{};
-        memset(&callback, 0, sizeof(KernelCallback));
         callback.Reason = SendReason;
         callback.AudioCallback.Send.Data = (uint8_t *)PCMRaw;
         callback.AudioCallback.Send.Length = pcm->node->Length;
         debug("Playing audio...");
-        int status = DriverManager->IOCB(AudioDrv.DriverUID, (void *)&callback);
+        int status = DriverManager->IOCB(AudioDrv.DriverUID, &callback);
         debug("Audio played! %d", status);
         KernelAllocator.FreePages((void *)PCMRaw, TO_PAGES(pcm->node->Length + 1));
         vfs->Close(pcm);
@@ -115,12 +114,11 @@ namespace Recovery
             return;
         }
 
-        KernelCallback callback;
+        KernelCallback callback{};
-        memset(&callback, 0, sizeof(KernelCallback));
         callback.Reason = AdjustReason;
         callback.AudioCallback.Adjust._SampleRate = true;
         callback.AudioCallback.Adjust.SampleRate = SR;
-        int status = DriverManager->IOCB(AudioDrv.DriverUID, (void *)&callback);
+        int status = DriverManager->IOCB(AudioDrv.DriverUID, &callback);
         debug("Sample rate changed! %d", status);
     }
 
@@ -153,12 +151,11 @@ namespace Recovery
             return;
         }
 
-        KernelCallback callback;
+        KernelCallback callback{};
-        memset(&callback, 0, sizeof(KernelCallback));
         callback.Reason = AdjustReason;
         callback.AudioCallback.Adjust._Volume = true;
         callback.AudioCallback.Adjust.Volume = percentage;
-        int status = DriverManager->IOCB(AudioDrv.DriverUID, (void *)&callback);
+        int status = DriverManager->IOCB(AudioDrv.DriverUID, &callback);
         debug("Volume changed! %d", status);
     }
 

include/driver.hpp

@@ -53,12 +53,18 @@ namespace Driver
         void *InterruptCallback = nullptr;
         Memory::MemMgr *MemTrk = nullptr;
         DriverInterruptHook *InterruptHook[16]{};
+
+        bool operator==(const DriverFile &Other) const
+        {
+            return DriverUID == Other.DriverUID;
+        }
     };
 
     class DriverInterruptHook : public Interrupts::Handler
     {
     private:
         DriverFile Handle;
+        bool Enabled = true;
 
 #if defined(a64)
         void OnInterruptReceived(CPU::x64::TrapFrame *Frame);
@@ -69,6 +75,9 @@ namespace Driver
 #endif
 
     public:
+        void Enable() { Enabled = true; }
+        void Disable() { Enabled = false; }
+        bool IsEnabled() { return Enabled; }
         DriverInterruptHook(int Interrupt, DriverFile Handle);
         virtual ~DriverInterruptHook() = default;
     };

include/net/nc.hpp

@@ -41,9 +41,6 @@ namespace NetworkInterfaceManager
         /** @brief Device interface IP address (Big-endian) */
         InternetProtocol IP;
 
-        /** @brief Reserved */
-        void *DriverCallBackAddress;
-
         /** @brief Reserved */
         unsigned long DriverID;
     };