From 411b468f71d65d43ad767db386072bb504e00283 Mon Sep 17 00:00:00 2001 From: Alex Date: Tue, 11 Apr 2023 12:06:32 +0300 Subject: [PATCH] Optimize memory usage --- Core/Crash/CrashHandler.cpp | 7 ++++-- Core/Disk.cpp | 6 ++--- Core/Driver/Driver.cpp | 43 ++++++++++++++++++++-------------- Execute/Elf/BaseLoad.cpp | 1 - GUI/GraphicalUserInterface.cpp | 4 ++-- KernelThread.cpp | 2 +- Network/NetworkController.cpp | 35 +++++++++++++++------------ Recovery/RecoveryMain.cpp | 15 +++++------- include/driver.hpp | 9 +++++++ include/net/nc.hpp | 3 --- 10 files changed, 71 insertions(+), 54 deletions(-) diff --git a/Core/Crash/CrashHandler.cpp b/Core/Crash/CrashHandler.cpp index 7b59c71..e065591 100644 --- a/Core/Crash/CrashHandler.cpp +++ b/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)"); + } } } diff --git a/Core/Disk.cpp b/Core/Disk.cpp index 0c74f1f..0a734ad 100644 --- a/Core/Disk.cpp +++ b/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++) { diff --git a/Core/Driver/Driver.cpp b/Core/Driver/Driver.cpp index 2de3815..063476b 100644 --- a/Core/Driver/Driver.cpp +++ b/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, (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]) 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) diff --git a/Execute/Elf/BaseLoad.cpp b/Execute/Elf/BaseLoad.cpp index 1d8771e..8007701 100644 --- a/Execute/Elf/BaseLoad.cpp +++ b/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) diff --git a/GUI/GraphicalUserInterface.cpp b/GUI/GraphicalUserInterface.cpp index fc09197..1b1c937 100644 --- a/GUI/GraphicalUserInterface.cpp +++ b/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; diff --git a/KernelThread.cpp b/KernelThread.cpp index dec51aa..3e37cb1 100644 --- a/KernelThread.cpp +++ b/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) { diff --git a/Network/NetworkController.cpp b/Network/NetworkController.cpp index 67c1219..4ecaa5a 100644 --- a/Network/NetworkController.cpp +++ b/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)); - memset(cb, 0, sizeof(KernelCallback)); - cb->Reason = FetchReason; - DriverManager->IOCB(DriverUID, (void *)cb); + KernelCallback cb{}; + cb.Reason = FetchReason; + DriverManager->IOCB(DriverUID, &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->DriverCallBackAddress = cb; + Iface->MAC.FromHex(cb.NetworkCallback.Fetch.MAC); 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; - - memset(cb, 0, sizeof(KernelCallback)); - cb->Reason = SendReason; - cb->NetworkCallback.Send.Data = (uint8_t *)DataToBeSent; - cb->NetworkCallback.Send.Length = Length; - DriverManager->IOCB(Interface->DriverID, (void *)cb); + KernelCallback cb{}; + cb.Reason = SendReason; + cb.NetworkCallback.Send.Data = (uint8_t *)DataToBeSent; + cb.NetworkCallback.Send.Length = Length; + DriverManager->IOCB(Interface->DriverID, &cb); mem->FreePages(DataToBeSent, TO_PAGES(Length + 1)); foreach (auto var in RegisteredEvents) diff --git a/Recovery/RecoveryMain.cpp b/Recovery/RecoveryMain.cpp index 1be973c..833e5a3 100644 --- a/Recovery/RecoveryMain.cpp +++ b/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; - memset(&callback, 0, sizeof(KernelCallback)); + KernelCallback callback{}; 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; - memset(&callback, 0, sizeof(KernelCallback)); + KernelCallback callback{}; 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; - memset(&callback, 0, sizeof(KernelCallback)); + KernelCallback callback{}; 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); } diff --git a/include/driver.hpp b/include/driver.hpp index f639fb2..d75cfb5 100644 --- a/include/driver.hpp +++ b/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; }; diff --git a/include/net/nc.hpp b/include/net/nc.hpp index 3433c56..aa3d51c 100644 --- a/include/net/nc.hpp +++ b/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; };