:boom: Breaking changes, disk API improvemenets and bringing support for

more drivers...

Signed-off-by: Amlal El Mahrouss <amlal@el-mahrouss-logic.com>

53 files changed, 380 insertions, 405 deletions

diff --git a/Private/Builtins/ACPI/ACPIFactoryInterface.hxx b/Private/Builtins/ACPI/ACPIFactoryInterface.hxx
index 6d2325fe..1f75ad2f 100644
--- a/Private/Builtins/ACPI/ACPIFactoryInterface.hxx
+++ b/Private/Builtins/ACPI/ACPIFactoryInterface.hxx
@@ -43,8 +43,8 @@ class ACPIFactoryInterface final {
   }
 
  private:
-  VoidPtr m_Rsdp;    // pointer to root descriptor.
-  SSizeT m_Entries;  // number of entries, -1 tells that no invalid entries were
+  VoidPtr fRsdp;    // pointer to root descriptor.
+  SSizeT fEntries;  // number of entries, -1 tells that no invalid entries were
                      // found.
 };
 }  // namespace NewOS
diff --git a/Private/Builtins/AHCI/Defines.hxx b/Private/Builtins/AHCI/Defines.hxx
index 44a19f38..afec2778 100644
--- a/Private/Builtins/AHCI/Defines.hxx
+++ b/Private/Builtins/AHCI/Defines.hxx
@@ -315,7 +315,7 @@ typedef struct HbaCmdTbl final {
 
 /* EOF */
 
-#ifdef __KERNEL__
+#if defined(__AHCI__)
 
 /// @brief Initializes an AHCI disk.
 /// @param PortsImplemented the amount of port that have been detected.
@@ -324,10 +324,22 @@ NewOS::Boolean drv_std_init(NewOS::UInt16& PortsImplemented);
 
 NewOS::Boolean drv_std_detected(NewOS::Void);
 
-NewOS::Void drv_std_read(NewOS::UInt64 Lba, NewOS::UInt16 IO, NewOS::UInt8 Master, NewOS::Char* Buf,
+/// @brief Read from disk.
+/// @param Lba 
+/// @param Buf 
+/// @param SectorSz 
+/// @param Size 
+/// @return 
+NewOS::Void drv_std_read(NewOS::UInt64 Lba, NewOS::Char* Buf,
                    NewOS::SizeT SectorSz, NewOS::SizeT Size);
 
-NewOS::Void drv_std_write(NewOS::UInt64 Lba, NewOS::UInt16 IO, NewOS::UInt8 Master, NewOS::Char* Buf,
+/// @brief Write to disk.
+/// @param Lba 
+/// @param Buf 
+/// @param SectorSz 
+/// @param Size 
+/// @return 
+NewOS::Void drv_std_write(NewOS::UInt64 Lba, NewOS::Char* Buf,
                     NewOS::SizeT SectorSz, NewOS::SizeT Size);
 
 #endif // ifdef __KERNEL__
diff --git a/Private/Builtins/ATA/Defines.hxx b/Private/Builtins/ATA/Defines.hxx
index c8a87384..9eed6039 100644
--- a/Private/Builtins/ATA/Defines.hxx
+++ b/Private/Builtins/ATA/Defines.hxx
@@ -118,7 +118,7 @@
 ///! ATA command register.
 #define ATA_COMMAND(x)  (x + 7)
 
-#define kATASectorSize 512
+#define kATASectorSize (512U)
 
 enum {
   kATADevicePATA,
@@ -128,7 +128,7 @@ enum {
   kATADeviceCount,
 };
 
-#ifdef __KERNEL__
+#if defined(__ATA_PIO__) || defined(__ATA_DMA__)
 
 NewOS::Boolean drv_std_init(NewOS::UInt16 Bus, NewOS::UInt8 Drive, NewOS::UInt16& OutBus,
                       NewOS::UInt8& OutMaster);
diff --git a/Private/CFKit/GUIDWrapper.hpp b/Private/CFKit/GUIDWrapper.hpp
index 8a71c614..62bc6d73 100644
--- a/Private/CFKit/GUIDWrapper.hpp
+++ b/Private/CFKit/GUIDWrapper.hpp
@@ -23,10 +23,10 @@ union GUIDSequence {
   alignas(8) ULong u64[2];
 
   struct {
-    alignas(8) UInt m_Ms1;
-    UShort m_Ms2;
-    UShort m_Ms3;
-    UChar m_Ms4[8];
+    alignas(8) UInt fMs1;
+    UShort fMs2;
+    UShort fMs3;
+    UChar fMs4[8];
   };
 };
 
@@ -40,10 +40,10 @@ class GUID final {
   GUID(const GUID &) = default;
 
  public:
-  GUIDSequence &operator->() noexcept { return m_UUID; }
-  GUIDSequence &Leak() noexcept { return m_UUID; }
+  GUIDSequence &operator->() noexcept { return fUUID; }
+  GUIDSequence &Leak() noexcept { return fUUID; }
 
  private:
-  GUIDSequence m_UUID;
+  GUIDSequence fUUID;
 };
 }  // namespace NewOS::XRN
diff --git a/Private/CFKit/Property.hpp b/Private/CFKit/Property.hpp
index 84b4ed64..243580fc 100644
--- a/Private/CFKit/Property.hpp
+++ b/Private/CFKit/Property.hpp
@@ -17,7 +17,7 @@ using PropertyId = Int;
 
 class Property {
  public:
-  explicit Property(const StringView &sw) : m_sName(sw) {}
+  explicit Property(const StringView &sw) : fsName(sw) {}
 
   virtual ~Property() = default;
 
@@ -29,8 +29,8 @@ class Property {
   const PropertyId &GetPropertyById();
 
  private:
-  Ref<StringView> m_sName;
-  PropertyId m_Action;
+  Ref<StringView> fsName;
+  PropertyId fAction;
 };
 
 template <SSizeT N>
diff --git a/Private/CFKit/URL.hpp b/Private/CFKit/URL.hpp
index 4131247c..748b3cf0 100644
--- a/Private/CFKit/URL.hpp
+++ b/Private/CFKit/URL.hpp
@@ -21,7 +21,7 @@ class Url final {
   Ref<ErrorOr<StringView>> Protocol() noexcept;
 
  private:
-  Ref<StringView> m_urlView;
+  Ref<StringView> fUrlView;
 };
 
 ErrorOr<StringView> url_extract_location(const char *url);
diff --git a/Private/HALKit/AMD64/HalACPIFactoryInterface.cxx b/Private/HALKit/AMD64/HalACPIFactoryInterface.cxx
index 4d1844d9..983c7219 100644
--- a/Private/HALKit/AMD64/HalACPIFactoryInterface.cxx
+++ b/Private/HALKit/AMD64/HalACPIFactoryInterface.cxx
@@ -21,8 +21,8 @@ void rt_shutdown_acpi_virtualbox(void) { HAL::Out16(0x4004, 0x3400); }
 /// You have to parse the MADT!
 
 ACPIFactoryInterface::ACPIFactoryInterface(voidPtr rsdPtr)
-    : m_Rsdp(rsdPtr), m_Entries(0) {
-  volatile RSDP *_rsdPtr = reinterpret_cast<volatile RSDP *>(this->m_Rsdp);
+    : fRsdp(rsdPtr), fEntries(0) {
+  volatile RSDP *_rsdPtr = reinterpret_cast<volatile RSDP *>(this->fRsdp);
 
   MUST_PASS(_rsdPtr);
   MUST_PASS(_rsdPtr->Revision >= 2);
@@ -48,13 +48,13 @@ Void ACPIFactoryInterface::Reboot() {
 
 /// @brief Finds a descriptor table inside ACPI XSDT.
 ErrorOr<voidPtr> ACPIFactoryInterface::Find(const char *signature) {
-  MUST_PASS(m_Rsdp);
+  MUST_PASS(fRsdp);
 
   if (!signature) return ErrorOr<voidPtr>{-2};
 
   if (*signature == 0) return ErrorOr<voidPtr>{-3};
 
-  RSDP *rsdPtr = reinterpret_cast<RSDP *>(this->m_Rsdp);
+  RSDP *rsdPtr = reinterpret_cast<RSDP *>(this->fRsdp);
 
   if (rsdPtr->Revision <= 1) {
     return ErrorOr<voidPtr>{-4};
diff --git a/Private/HALKit/AMD64/PCI/Device.cxx b/Private/HALKit/AMD64/PCI/Device.cxx
index f5f1d602..f6bf75da 100644
--- a/Private/HALKit/AMD64/PCI/Device.cxx
+++ b/Private/HALKit/AMD64/PCI/Device.cxx
@@ -31,59 +31,59 @@ void NewOSPCISetCfgTarget(NewOS::UInt bar, NewOS::UShort bus, NewOS::UShort dev,
 
 namespace NewOS::PCI {
 Device::Device(UShort bus, UShort device, UShort func, UShort bar)
-    : m_Bus(bus), m_Device(device), m_Function(func), m_Bar(bar) {}
+    : fBus(bus), fDevice(device), fFunction(func), fBar(bar) {}
 
 Device::~Device() {}
 
 UInt Device::Read(UInt bar, Size sz) {
-  NewOSPCISetCfgTarget(bar, m_Bus, m_Device, m_Function);
+  NewOSPCISetCfgTarget(bar, fBus, fDevice, fFunction);
 
   if (sz == 4)
-    return HAL::In32((UShort)PciConfigKind::ConfigData + (m_Bar & 3));
+    return HAL::In32((UShort)PciConfigKind::ConfigData + (fBar & 3));
   if (sz == 2)
-    return HAL::In16((UShort)PciConfigKind::ConfigData + (m_Bar & 3));
-  if (sz == 1) return HAL::In8((UShort)PciConfigKind::ConfigData + (m_Bar & 3));
+    return HAL::In16((UShort)PciConfigKind::ConfigData + (fBar & 3));
+  if (sz == 1) return HAL::In8((UShort)PciConfigKind::ConfigData + (fBar & 3));
 
   return 0xFFFF;
 }
 
 void Device::Write(UInt bar, UIntPtr data, Size sz) {
-  NewOSPCISetCfgTarget(bar, m_Bus, m_Device, m_Function);
+  NewOSPCISetCfgTarget(bar, fBus, fDevice, fFunction);
 
   if (sz == 4)
-    HAL::Out32((UShort)PciConfigKind::ConfigData + (m_Bar & 3), (UInt)data);
+    HAL::Out32((UShort)PciConfigKind::ConfigData + (fBar & 3), (UInt)data);
   if (sz == 2)
-    HAL::Out16((UShort)PciConfigKind::ConfigData + (m_Bar & 3), (UShort)data);
+    HAL::Out16((UShort)PciConfigKind::ConfigData + (fBar & 3), (UShort)data);
   if (sz == 1)
-    HAL::Out8((UShort)PciConfigKind::ConfigData + (m_Bar & 3), (UChar)data);
+    HAL::Out8((UShort)PciConfigKind::ConfigData + (fBar & 3), (UChar)data);
 }
 
 UShort Device::DeviceId() {
-  return (UShort)(NewOSPCIReadRaw(0x0 >> 16, m_Bus, m_Device, m_Function));
+  return (UShort)(NewOSPCIReadRaw(0x0 >> 16, fBus, fDevice, fFunction));
 }
 
 UShort Device::VendorId() {
-  return (UShort)(NewOSPCIReadRaw(0x0, m_Bus, m_Device, m_Function) >> 16);
+  return (UShort)(NewOSPCIReadRaw(0x0, fBus, fDevice, fFunction) >> 16);
 }
 
 UShort Device::InterfaceId() {
-  return (UShort)(NewOSPCIReadRaw(0x0, m_Bus, m_Device, m_Function) >> 16);
+  return (UShort)(NewOSPCIReadRaw(0x0, fBus, fDevice, fFunction) >> 16);
 }
 
 UChar Device::Class() {
-  return (UChar)(NewOSPCIReadRaw(0x08, m_Bus, m_Device, m_Function) >> 24);
+  return (UChar)(NewOSPCIReadRaw(0x08, fBus, fDevice, fFunction) >> 24);
 }
 
 UChar Device::Subclass() {
-  return (UChar)(NewOSPCIReadRaw(0x08, m_Bus, m_Device, m_Function) >> 16);
+  return (UChar)(NewOSPCIReadRaw(0x08, fBus, fDevice, fFunction) >> 16);
 }
 
 UChar Device::ProgIf() {
-  return (UChar)(NewOSPCIReadRaw(0x08, m_Bus, m_Device, m_Function) >> 8);
+  return (UChar)(NewOSPCIReadRaw(0x08, fBus, fDevice, fFunction) >> 8);
 }
 
 UChar Device::HeaderType() {
-  return (UChar)(NewOSPCIReadRaw(0xC, m_Bus, m_Device, m_Function) >> 16);
+  return (UChar)(NewOSPCIReadRaw(0xC, fBus, fDevice, fFunction) >> 16);
 }
 
 void Device::EnableMmio() {
@@ -100,9 +100,9 @@ UShort Device::Vendor() {
   UShort vendor = VendorId();
 
   if (vendor != (UShort)PciConfigKind::Invalid)
-    m_Device = (UShort)Read(0x0, sizeof(UShort));
+    fDevice = (UShort)Read(0x0, sizeof(UShort));
 
-  return m_Device;
+  return fDevice;
 }
 
 Device::operator bool() { return VendorId() != (UShort)PciConfigKind::Invalid; }
diff --git a/Private/HALKit/AMD64/PCI/Dma.cxx b/Private/HALKit/AMD64/PCI/Dma.cxx
index 1efef53b..f0a10eb9 100644
--- a/Private/HALKit/AMD64/PCI/Dma.cxx
+++ b/Private/HALKit/AMD64/PCI/Dma.cxx
@@ -7,36 +7,36 @@
 #include <KernelKit/PCI/Dma.hpp>
 
 namespace NewOS {
-DMAWrapper::operator bool() { return m_Address; }
+DMAWrapper::operator bool() { return fAddress; }
 
-bool DMAWrapper::operator!() { return !m_Address; }
+bool DMAWrapper::operator!() { return !fAddress; }
 
 Boolean DMAWrapper::Check(UIntPtr offset) const {
-  if (!m_Address) return false;
+  if (!fAddress) return false;
   if (offset == 0) return true;
 
   kcout << "[DMAWrapper::IsIn] Checking offset..\n";
-  return reinterpret_cast<UIntPtr>(m_Address) >= offset;
+  return reinterpret_cast<UIntPtr>(fAddress) >= offset;
 }
 
 bool DMAWrapper::Write(const UIntPtr &bit, const UIntPtr &offset) {
-  if (!m_Address) return false;
+  if (!fAddress) return false;
 
   kcout << "[DMAWrapper::Write] Writing at address..\n";
 
   auto addr =
-      (volatile UIntPtr *)(reinterpret_cast<UIntPtr>(m_Address) + offset);
+      (volatile UIntPtr *)(reinterpret_cast<UIntPtr>(fAddress) + offset);
   *addr = bit;
 
   return true;
 }
 
 UIntPtr DMAWrapper::Read(const UIntPtr &offset) {
-  kcout << "[DMAWrapper::Read] checking m_Address..\n";
-  if (!m_Address) return 0;
+  kcout << "[DMAWrapper::Read] checking fAddress..\n";
+  if (!fAddress) return 0;
 
-  kcout << "[DMAWrapper::Read] Reading m_Address..\n";
-  return *(volatile UIntPtr *)(reinterpret_cast<UIntPtr>(m_Address) + offset);
+  kcout << "[DMAWrapper::Read] Reading fAddress..\n";
+  return *(volatile UIntPtr *)(reinterpret_cast<UIntPtr>(fAddress) + offset);
   ;
 }
 
@@ -48,7 +48,7 @@ OwnPtr<IOBuf<Char *>> DMAFactory::Construct(OwnPtr<DMAWrapper> &dma) {
   if (!dma) return {};
 
   OwnPtr<IOBuf<Char *>> dmaOwnPtr =
-      make_ptr<IOBuf<Char *>, char *>(reinterpret_cast<char *>(dma->m_Address));
+      make_ptr<IOBuf<Char *>, char *>(reinterpret_cast<char *>(dma->fAddress));
 
   if (!dmaOwnPtr) return {};
 
@@ -57,7 +57,7 @@ OwnPtr<IOBuf<Char *>> DMAFactory::Construct(OwnPtr<DMAWrapper> &dma) {
 }
 
 DMAWrapper &DMAWrapper::operator=(voidPtr Ptr) {
-  m_Address = Ptr;
+  fAddress = Ptr;
   return *this;
 }
 }  // namespace NewOS
diff --git a/Private/HALKit/AMD64/PCI/Iterator.cxx b/Private/HALKit/AMD64/PCI/Iterator.cxx
index 151d8780..25e83ada 100644
--- a/Private/HALKit/AMD64/PCI/Iterator.cxx
+++ b/Private/HALKit/AMD64/PCI/Iterator.cxx
@@ -18,7 +18,7 @@ Iterator::Iterator(const Types::PciDeviceKind &type) {
         Device dev(bus, device, function, 0);
 
         if (dev.Class() == (UChar)type) {
-          m_Devices[bus].Leak().Leak() = dev;
+          fDevices[bus].Leak().Leak() = dev;
         }
       }
     }
@@ -28,7 +28,7 @@ Iterator::Iterator(const Types::PciDeviceKind &type) {
 Iterator::~Iterator() {}
 
 Ref<PCI::Device> Iterator::operator[](const Size &sz) {
-  PCI_ITERATOR_FIND_AND_UNWRAP(m_Devices[sz], sz);
+  PCI_ITERATOR_FIND_AND_UNWRAP(fDevices[sz], sz);
   return {};
 }
 }  // namespace NewOS::PCI
diff --git a/Private/HALKit/AMD64/Processor.hpp b/Private/HALKit/AMD64/Processor.hpp
index 472fd6df..a2aaf8f7 100644
--- a/Private/HALKit/AMD64/Processor.hpp
+++ b/Private/HALKit/AMD64/Processor.hpp
@@ -172,7 +172,6 @@ struct PACKED ALIGN(0x1000) NewOSGDT final {
 }  // namespace Detail
 }  // namespace NewOS::HAL
 
-EXTERN_C void idt_handle_system_call(NewOS::UIntPtr rsp);
 EXTERN_C void idt_handle_generic(NewOS::UIntPtr rsp);
 EXTERN_C void idt_handle_gpf(NewOS::UIntPtr rsp);
 EXTERN_C void idt_handle_math(NewOS::UIntPtr rsp);
diff --git a/Private/HALKit/AMD64/Storage/AHCI.cxx b/Private/HALKit/AMD64/Storage/AHCI.cxx
index 35308582..2b58b744 100644
--- a/Private/HALKit/AMD64/Storage/AHCI.cxx
+++ b/Private/HALKit/AMD64/Storage/AHCI.cxx
@@ -49,11 +49,9 @@ NewOS::Boolean drv_std_detected(NewOS::Void) {
   return kAhciDevice.DeviceId() != 0xFFFF;
 }
 
-NewOS::Void drv_std_read(NewOS::UInt64 Lba, NewOS::UInt16 IO,
-                          NewOS::UInt8 Master, NewOS::Char* Buf,
+NewOS::Void drv_std_read(NewOS::UInt64 Lba, NewOS::Char* Buf,
                           NewOS::SizeT SectorSz, NewOS::SizeT Size) {}
 
-NewOS::Void drv_std_write(NewOS::UInt64 Lba, NewOS::UInt16 IO,
-                           NewOS::UInt8 Master, NewOS::Char* Buf,
+NewOS::Void drv_std_write(NewOS::UInt64 Lba, NewOS::Char* Buf,
                            NewOS::SizeT SectorSz, NewOS::SizeT Size) {}
 #endif  // __AHCI__
\ No newline at end of file
diff --git a/Private/HALKit/AMD64/Storage/ATA-DMA.cxx b/Private/HALKit/AMD64/Storage/ATA-DMA.cxx
index d3e90f67..523c7e17 100644
--- a/Private/HALKit/AMD64/Storage/ATA-DMA.cxx
+++ b/Private/HALKit/AMD64/Storage/ATA-DMA.cxx
@@ -23,6 +23,7 @@
 using namespace NewOS;
 
 EXTERN_C Int32 kPRDTTransferStatus;
+STATIC PRDT kPRDT;
 
 #ifdef __ATA_DMA__
 
diff --git a/Private/KernelKit/DeviceManager.hpp b/Private/KernelKit/DeviceManager.hpp
index 0935c5b3..490ebc71 100644
--- a/Private/KernelKit/DeviceManager.hpp
+++ b/Private/KernelKit/DeviceManager.hpp
@@ -34,7 +34,7 @@ template <typename T>
 class DeviceInterface {
  public:
   explicit DeviceInterface(void (*Out)(T), void (*In)(T))
-      : m_Out(Out), m_In(In) {}
+      : fOut(Out), fIn(In) {}
 
   virtual ~DeviceInterface() = default;
 
@@ -44,23 +44,23 @@ class DeviceInterface {
 
  public:
   virtual DeviceInterface<T> &operator<<(T Data) {
-    m_Out(Data);
+    fOut(Data);
     return *this;
   }
 
   virtual DeviceInterface<T> &operator>>(T Data) {
-    m_In(Data);
+    fIn(Data);
     return *this;
   }
 
   virtual const char *Name() const { return "DeviceInterface"; }
 
-  operator bool() { return m_Out && m_In; }
-  bool operator!() { return !m_Out && !m_In; }
+  operator bool() { return fOut && fIn; }
+  bool operator!() { return !fOut && !fIn; }
 
  private:
-  void (*m_Out)(T Data);
-  void (*m_In)(T Data);
+  void (*fOut)(T Data);
+  void (*fIn)(T Data);
 };
 
 ///
@@ -70,7 +70,7 @@ class DeviceInterface {
 template <typename T>
 class IOBuf final {
  public:
-  explicit IOBuf(T Dat) : m_Data(Dat) {
+  explicit IOBuf(T Dat) : fData(Dat) {
     // at least pass something valid when instancating this struct.
     MUST_PASS(Dat);
   }
@@ -83,16 +83,16 @@ class IOBuf final {
  public:
   template <typename R>
   R operator->() const {
-    return m_Data;
+    return fData;
   }
 
   template <typename R>
   R &operator[](Size index) const {
-    return m_Data[index];
+    return fData[index];
   }
 
  private:
-  T m_Data;
+  T fData;
 };
 
 ///! @brief Device enum types.
diff --git a/Private/KernelKit/Framebuffer.hpp b/Private/KernelKit/Framebuffer.hpp
index 91b4e8fd..39b1eb5e 100644
--- a/Private/KernelKit/Framebuffer.hpp
+++ b/Private/KernelKit/Framebuffer.hpp
@@ -20,16 +20,16 @@ enum class FramebufferColorKind : UChar {
 
 class FramebufferContext final {
  public:
-  UIntPtr m_Base;
-  UIntPtr m_Bpp;
-  UInt m_Width;
-  UInt m_Height;
+  UIntPtr fBase;
+  UIntPtr fBpp;
+  UInt fWidth;
+  UInt fHeight;
 };
 
 class Framebuffer final {
  public:
   explicit Framebuffer(Ref<FramebufferContext *> &addr)
-      : m_FrameBufferAddr(addr) {}
+      : fFrameBufferAddr(addr) {}
   ~Framebuffer() {}
 
   Framebuffer &operator=(const Framebuffer &) = delete;
@@ -62,8 +62,8 @@ class Framebuffer final {
   Framebuffer &PutPixel(SizeT x, SizeT y, UInt32 color);
 
  private:
-  Ref<FramebufferContext *> m_FrameBufferAddr;
-  FramebufferColorKind m_Colour;
+  Ref<FramebufferContext *> fFrameBufferAddr;
+  FramebufferColorKind fColour;
 };
 
 /***********************************************************************************/
diff --git a/Private/KernelKit/LockDelegate.hpp b/Private/KernelKit/LockDelegate.hpp
index 07f492a8..3b4889c9 100644
--- a/Private/KernelKit/LockDelegate.hpp
+++ b/Private/KernelKit/LockDelegate.hpp
@@ -34,13 +34,13 @@ class LockDelegate final
         {
             if (*expr)
             {
-                m_LockStatus | kLockDone;
+                fLockStatus | kLockDone;
                 break;
             }
         }
 
         if (spin == N)
-            m_LockStatus | kLockTimedOut;
+            fLockStatus | kLockTimedOut;
     }
 
     ~LockDelegate() = default;
@@ -50,15 +50,15 @@ class LockDelegate final
 
     bool Done()
     {
-        return m_LockStatus[kLockDone] == kLockDone;
+        return fLockStatus[kLockDone] == kLockDone;
     }
 
     bool HasTimedOut()
     {
-        return m_LockStatus[kLockTimedOut] != kLockTimedOut;
+        return fLockStatus[kLockTimedOut] != kLockTimedOut;
     }
 
   private:
-    Atom<UInt> m_LockStatus;
+    Atom<UInt> fLockStatus;
 };
 } // namespace NewOS
diff --git a/Private/KernelKit/PCI/Device.hpp b/Private/KernelKit/PCI/Device.hpp
index 9bb22cb2..ea11e327 100644
--- a/Private/KernelKit/PCI/Device.hpp
+++ b/Private/KernelKit/PCI/Device.hpp
@@ -68,10 +68,10 @@ namespace NewOS::PCI
         UShort Vendor();
 
     private:
-        UShort m_Bus;
-        UShort m_Device;
-        UShort m_Function;
-        UShort m_Bar;
+        UShort fBus;
+        UShort fDevice;
+        UShort fFunction;
+        UShort fBar;
 
     };
 } // namespace NewOS::PCI
diff --git a/Private/KernelKit/PCI/Dma.hpp b/Private/KernelKit/PCI/Dma.hpp
index 1e1b5036..392aeee3 100644
--- a/Private/KernelKit/PCI/Dma.hpp
+++ b/Private/KernelKit/PCI/Dma.hpp
@@ -28,7 +28,7 @@ class DMAWrapper final {
  public:
   explicit DMAWrapper(nullPtr) = delete;
   explicit DMAWrapper(voidPtr Ptr, DmaKind Kind = DmaKind::PCI)
-      : m_Address(Ptr), m_Kind(Kind) {}
+      : fAddress(Ptr), fKind(Kind) {}
 
  public:
   DMAWrapper &operator=(voidPtr Ptr);
@@ -59,8 +59,8 @@ class DMAWrapper final {
   UIntPtr operator[](const UIntPtr &offset);
 
  private:
-  voidPtr m_Address{nullptr};
-  DmaKind m_Kind{DmaKind::Invalid};
+  voidPtr fAddress{nullptr};
+  DmaKind fKind{DmaKind::Invalid};
 
  private:
   friend class DMAFactory;
diff --git a/Private/KernelKit/PCI/Dma.inl b/Private/KernelKit/PCI/Dma.inl
index 5f7e1379..846785a1 100644
--- a/Private/KernelKit/PCI/Dma.inl
+++ b/Private/KernelKit/PCI/Dma.inl
@@ -9,12 +9,12 @@ namespace NewOS
     template<class T>
     T* DMAWrapper::operator->()
     {
-        return m_Address;
+        return fAddress;
     }
 
     template<class T>
     T* DMAWrapper::Get(const UIntPtr offset)
     {
-        return reinterpret_cast<T*>((UIntPtr) m_Address + offset);
+        return reinterpret_cast<T*>((UIntPtr) fAddress + offset);
     }
 }
diff --git a/Private/KernelKit/PCI/IO-Impl-AMD64.inl b/Private/KernelKit/PCI/IO-Impl-AMD64.inl
index 195ebca1..bf7b98d4 100644
--- a/Private/KernelKit/PCI/IO-Impl-AMD64.inl
+++ b/Private/KernelKit/PCI/IO-Impl-AMD64.inl
@@ -18,11 +18,11 @@ template <typename T>
 T IOArray<Sz>::In(SizeT index) {
   switch (sizeof(T)) {
     case 4:
-      return HAL::In32(m_Ports[index].Leak());
+      return HAL::In32(fPorts[index].Leak());
     case 2:
-      return HAL::In16(m_Ports[index].Leak());
+      return HAL::In16(fPorts[index].Leak());
     case 1:
-      return HAL::In8(m_Ports[index].Leak());
+      return HAL::In8(fPorts[index].Leak());
     default:
       return 0xFFFF;
   }
@@ -34,11 +34,11 @@ void IOArray<Sz>::Out(SizeT index, T value) {
   switch (sizeof(T)) {
 #ifdef __x86_64__
     case 4:
-      HAL::Out32(m_Ports[index].Leak(), value);
+      HAL::Out32(fPorts[index].Leak(), value);
     case 2:
-      HAL::Out16(m_Ports[index].Leak(), value);
+      HAL::Out16(fPorts[index].Leak(), value);
     case 1:
-      HAL::Out8(m_Ports[index].Leak(), value);
+      HAL::Out8(fPorts[index].Leak(), value);
 #endif
     default:
       break;
diff --git a/Private/KernelKit/PCI/IO.hpp b/Private/KernelKit/PCI/IO.hpp
index 87a29b78..a0ee51dc 100644
--- a/Private/KernelKit/PCI/IO.hpp
+++ b/Private/KernelKit/PCI/IO.hpp
@@ -19,14 +19,14 @@ class IOArray final {
 
   IOArray(nullPtr) = delete;
 
-  explicit IOArray(Array<UShort, Sz> &ports) : m_Ports(ports) {}
+  explicit IOArray(Array<UShort, Sz> &ports) : fPorts(ports) {}
   ~IOArray() {}
 
   IOArray &operator=(const IOArray &) = default;
 
   IOArray(const IOArray &) = default;
 
-  operator bool() { return !m_Ports.Empty(); }
+  operator bool() { return !fPorts.Empty(); }
 
  public:
   template <typename T>
@@ -36,7 +36,7 @@ class IOArray final {
   void Out(SizeT index, T value);
 
  private:
-  Array<UShort, Sz> m_Ports;
+  Array<UShort, Sz> fPorts;
 };
 
 using IOArray16 = IOArray<16>;
diff --git a/Private/KernelKit/PCI/Iterator.hpp b/Private/KernelKit/PCI/Iterator.hpp
index 7f17263d..b81aae74 100644
--- a/Private/KernelKit/PCI/Iterator.hpp
+++ b/Private/KernelKit/PCI/Iterator.hpp
@@ -29,7 +29,7 @@ namespace NewOS::PCI {
         Ref<PCI::Device> operator[](const Size &sz);
 
     private:
-        Array<PCI::Device, NEWOS_BUS_COUNT> m_Devices;
+        Array<PCI::Device, NEWOS_BUS_COUNT> fDevices;
     };
 } // namespace NewOS::PCI
 
diff --git a/Private/KernelKit/SMPManager.hpp b/Private/KernelKit/SMPManager.hpp
index 42cd572e..631b29ea 100644
--- a/Private/KernelKit/SMPManager.hpp
+++ b/Private/KernelKit/SMPManager.hpp
@@ -60,12 +60,12 @@ class HardwareThread final {
   const ThreadID& ID() noexcept;
 
  private:
-  HAL::StackFrame* m_Stack;
-  ThreadKind m_Kind;
-  ThreadID m_ID;
-  bool m_Wakeup;
-  bool m_Busy;
-  Int64 m_PID;
+  HAL::StackFrame* fStack;
+  ThreadKind fKind;
+  ThreadID fID;
+  bool fWakeup;
+  bool fBusy;
+  Int64 fPID;
 
  private:
   friend class SMPManager;
@@ -106,8 +106,8 @@ class SMPManager final {
   SizeT Count() noexcept;
 
  private:
-  Array<HardwareThread, kMaxHarts> m_ThreadList;
-  ThreadID m_CurrentThread{0};
+  Array<HardwareThread, kMaxHarts> fThreadList;
+  ThreadID fCurrentThread{0};
 };
 
 /// @brief wakes up thread.
diff --git a/Private/NetworkKit/IP.hpp b/Private/NetworkKit/IP.hpp
index 3d7119da..b8876aaa 100644
--- a/Private/NetworkKit/IP.hpp
+++ b/Private/NetworkKit/IP.hpp
@@ -33,7 +33,7 @@ class RawIPAddress final {
   bool operator!=(const RawIPAddress &ipv6);
 
  private:
-  char m_Addr[4];
+  char fAddr[4];
 
   friend IPFactory;  // it is the one creating these addresses, thus this
                      // is why the constructors are private.
@@ -51,7 +51,7 @@ class RawIPAddress6 final {
   RawIPAddress6(const RawIPAddress6 &) = default;
 
  public:
-  char *Address() { return m_Addr; }
+  char *Address() { return fAddr; }
 
   char &operator[](const Size &index);
 
@@ -59,7 +59,7 @@ class RawIPAddress6 final {
   bool operator!=(const RawIPAddress6 &ipv6);
 
  private:
-  char m_Addr[8];
+  char fAddr[8];
 
   friend IPFactory;
 };
diff --git a/Private/NewBoot/Source/HEL/AMD64/BootEPM.cxx b/Private/NewBoot/Source/HEL/AMD64/BootEPM.cxx
index 133429c5..0d678dc1 100644
--- a/Private/NewBoot/Source/HEL/AMD64/BootEPM.cxx
+++ b/Private/NewBoot/Source/HEL/AMD64/BootEPM.cxx
@@ -7,8 +7,9 @@
 #include <BootKit/BootKit.hxx>
 #include <FSKit/NewFS.hxx>
 
+#define kEPMSectorSize kATASectorSize
 #define kEPMSwapSize MIB(16)
-#define kEPMGPTStartLba 30
+#define kEPMGPTStartLba (30)
 
 // {310E1FC7-2060-425D-BE7B-75A37CC679BC}
 STATIC const BlockGUID kEPMGuid = {
@@ -28,19 +29,19 @@ EXTERN_C Boolean boot_write_epm_partition(const Char* namePart, SizeT namePartLe
   if (!bootDev) return No;
 
   bootDev->Leak().mBase = kEPMGPTStartLba;
-  bootDev->Leak().mSize = kATASectorSize;
+  bootDev->Leak().mSize = kEPMSectorSize;
 
-  Char buf[kATASectorSize] = {0};
+  Char buf[kEPMSectorSize] = {0};
 
   bootDev->Read(buf, 1);
 
   BTextWriter writer;
 
-  writer.Write(L"NewOS: Checking for a NewFS partition...\r\n");
+  writer.Write(L"NewOS: Checking for a EPM partition...\r\n");
 
   for (SizeT index = 0; index < kEPMMagicLength; ++index) {
     if (buf[index] != kEPMMagic[index]) {
-      writer.Write(L"NewOS: Writing a NewFS partition...\r\n");
+      writer.Write(L"NewOS: Writing a EPM partition...\r\n");
 
       BootBlockType* bootBlock = (BootBlockType*)buf;
 
@@ -58,7 +59,7 @@ EXTERN_C Boolean boot_write_epm_partition(const Char* namePart, SizeT namePartLe
       bootBlock->LbaStart =
           sizeof(BootBlockType) + (sizeof(PartitionBlockType) * kEPMMaxBlks);
 
-      bootBlock->SectorSz = kATASectorSize;
+      bootBlock->SectorSz = kEPMSectorSize;
 
       bootBlock->Uuid = kEPMGuid;
 
@@ -80,7 +81,7 @@ EXTERN_C Boolean boot_write_epm_partition(const Char* namePart, SizeT namePartLe
         partBlock->Name[i] = partNameSystem[i];
       }
 
-      partBlock->SectorSz = kATASectorSize;
+      partBlock->SectorSz = kEPMSectorSize;
       partBlock->LbaStart = kEPMStartPartitionBlk + kEPMSwapSize;
       partBlock->Version = kNewFSVersionInteger;
       partBlock->Kind = kNewFSPartitionTypeStandard;
@@ -101,7 +102,7 @@ EXTERN_C Boolean boot_write_epm_partition(const Char* namePart, SizeT namePartLe
         swapBlock->Name[i] = partNameSwap[i];
       }
 
-      swapBlock->SectorSz = kATASectorSize;
+      swapBlock->SectorSz = kEPMSectorSize;
       swapBlock->LbaStart = kEPMStartPartitionBlk;
       swapBlock->Version = kNewFSVersionInteger;
       swapBlock->Kind = kNewFSPartitionTypePage;
diff --git a/Private/NewBoot/Source/HEL/PowerPC/BootEPM.cxx b/Private/NewBoot/Source/HEL/PowerPC/BootEPM.cxx
index 2e35b0dc..f088d73c 100644
--- a/Private/NewBoot/Source/HEL/PowerPC/BootEPM.cxx
+++ b/Private/NewBoot/Source/HEL/PowerPC/BootEPM.cxx
@@ -7,8 +7,7 @@
 #include <BootKit/BootKit.hxx>
 #include <FSKit/NewFS.hxx>
 
-#define kEPMSectorSize 1024
-
+#define kEPMSectorSize (1024U)
 #define kEPMSwapSize MIB(16)
 
 // {310E1FC7-2060-425D-BE7B-75A37CC679BC}
@@ -37,11 +36,11 @@ EXTERN_C Boolean boot_write_epm_partition(const Char* namePart, SizeT namePartLe
 
   BTextWriter writer;
 
-  writer.Write(L"NewOS: Checking for a NewFS partition...\r\n");
+  writer.Write(L"NewOS: Checking for a EPM partition...\r\n");
 
   for (SizeT index = 0; index < kEPMMagicLength; ++index) {
     if (buf[index] != kEPMMagic[index]) {
-      writer.Write(L"NewOS: Writing a NewFS partition...\r\n");
+      writer.Write(L"NewOS: Writing a EPM partition...\r\n");
 
       BootBlockType* bootBlock = (BootBlockType*)buf;
 
diff --git a/Private/NewKit/Array.hpp b/Private/NewKit/Array.hpp
index a892f1a7..6724d8a9 100644
--- a/Private/NewKit/Array.hpp
+++ b/Private/NewKit/Array.hpp
@@ -27,12 +27,12 @@ public:
             return {};
 
         kcout << "Returning element\r\n";
-        return ErrorOr<T>(m_Array[At]);
+        return ErrorOr<T>(fArray[At]);
     }
 
     Boolean Empty() const
     {
-        for (auto Val : m_Array)
+        for (auto Val : fArray)
         {
             if (Val)
                 return false;
@@ -44,7 +44,7 @@ public:
     SizeT Count() const
     {
         SizeT cntElems = 0UL;
-        for (auto Val : m_Array)
+        for (auto Val : fArray)
         {
             if (Val)
                 ++cntElems;
@@ -55,7 +55,7 @@ public:
 
     const T *CData()
     {
-        return m_Array;
+        return fArray;
     }
 
     operator bool()
@@ -64,7 +64,7 @@ public:
     }
 
 private:
-    T m_Array[N];
+    T fArray[N];
     
 };
 } // namespace NewOS
diff --git a/Private/NewKit/ArrayList.hpp b/Private/NewKit/ArrayList.hpp
index ef6889ea..b7ab50cf 100644
--- a/Private/NewKit/ArrayList.hpp
+++ b/Private/NewKit/ArrayList.hpp
@@ -15,7 +15,7 @@ namespace NewOS
     {
     public:
         explicit ArrayList(T *list)
-            : m_List(reinterpret_cast<T>(list))
+            : fList(reinterpret_cast<T>(list))
         {}
 
         ~ArrayList() = default;
@@ -25,26 +25,26 @@ namespace NewOS
 
         T *Data()
         {
-            return m_List;
+            return fList;
         }
 
         const T *CData()
         {
-            return m_List;
+            return fList;
         }
 
         T &operator[](int index) const
         {
-            return m_List[index];
+            return fList[index];
         }
 
         operator bool()
         {
-            return m_List;
+            return fList;
         }
 
     private:
-        T *m_List;
+        T *fList;
 
         friend class InitHelpers;
 
diff --git a/Private/NewKit/Atom.hpp b/Private/NewKit/Atom.hpp
index 34cbea51..648302fc 100644
--- a/Private/NewKit/Atom.hpp
+++ b/Private/NewKit/Atom.hpp
@@ -22,11 +22,11 @@ template <typename T> class Atom final
   public:
     T operator[](Size sz)
     {
-        return (m_ArrayOfAtoms & sz);
+        return (fArrayOfAtoms & sz);
     }
     void operator|(Size sz)
     {
-        m_ArrayOfAtoms |= sz;
+        fArrayOfAtoms |= sz;
     }
 
     friend Boolean operator==(Atom<T> &atomic, const T &idx)
@@ -40,6 +40,6 @@ template <typename T> class Atom final
     }
 
   private:
-    T m_ArrayOfAtoms;
+    T fArrayOfAtoms;
 };
 } // namespace NewOS
diff --git a/Private/NewKit/Function.hpp b/Private/NewKit/Function.hpp
index 63bc31dc..79d33a3b 100644
--- a/Private/NewKit/Function.hpp
+++ b/Private/NewKit/Function.hpp
@@ -10,7 +10,7 @@ class Function final {
   Function() = default;
 
  public:
-  explicit Function(T (*Fn)(Args... args)) : m_Fn(Fn) {}
+  explicit Function(T (*Fn)(Args... args)) : fFn(Fn) {}
 
   ~Function() = default;
 
@@ -19,20 +19,20 @@ class Function final {
 
   template <typename... XArgs>
   T operator()(Args... args) {
-    return m_Fn(args...);
+    return fFn(args...);
   }
 
   template <typename... XArgs>
   T Call(Args... args) {
-    return m_Fn(args...);
+    return fFn(args...);
   }
 
-  operator bool() { return m_Fn; }
+  operator bool() { return fFn; }
 
-  bool operator!() { return !m_Fn; }
+  bool operator!() { return !fFn; }
 
  private:
-  T (*m_Fn)(Args... args);
+  T (*fFn)(Args... args);
 };
 }  // namespace NewOS
 
diff --git a/Private/NewKit/MutableArray.hpp b/Private/NewKit/MutableArray.hpp
index bdedb97f..b46f1bc7 100644
--- a/Private/NewKit/MutableArray.hpp
+++ b/Private/NewKit/MutableArray.hpp
@@ -13,9 +13,9 @@
     auto *NAME = NODE;                                                         \
     while (NAME)                                                               \
     {                                                                          \
-        if (NAME->m_Index == Index)                                            \
-            return NAME->m_Val;                                                \
-        NAME = NAME->m_Next;                                                   \
+        if (NAME->fIndex == Index)                                            \
+            return NAME->fVal;                                                \
+        NAME = NAME->fNext;                                                   \
     }
 
 
@@ -24,18 +24,18 @@
     auto *NAME = NODE;                                                         \
     while (NAME)                                                               \
     {                                                                          \
-        if (NAME->m_Index == Index)                                            \
-            return Ref<T>{NAME->m_Val};                                        \
-        NAME = NAME->m_Next;                                                   \
+        if (NAME->fIndex == Index)                                            \
+            return Ref<T>{NAME->fVal};                                        \
+        NAME = NAME->fNext;                                                   \
     }
 
 
 
 #define TRY_REMOVE_NODE(NODE)                                                  \
-    if (NODE && NODE->m_Index == Index)                                        \
+    if (NODE && NODE->fIndex == Index)                                        \
     {                                                                          \
-        NODE->m_Used = false;                                                  \
-        NODE->m_Index = 0;                                                     \
+        NODE->fUsed = false;                                                  \
+        NODE->fIndex = 0;                                                     \
                                                                                \
         return true;                                                           \
     }
@@ -53,19 +53,19 @@ template <typename T, T _PlaceHolderValue> class NullableMutableArray;
 template <typename T> class MutableLinkedList
 {
   public:
-    T m_Val;
-    SizeT m_Index{0};
-    Boolean m_Used{false};
+    T fVal;
+    SizeT fIndex{0};
+    Boolean fUsed{false};
 
-    MutableLinkedList *m_Prev{nullptr};
-    MutableLinkedList *m_Next{nullptr};
+    MutableLinkedList *fPrev{nullptr};
+    MutableLinkedList *fNext{nullptr};
 };
 
 template <typename T, T _PlaceHolderValue> class NullableMutableArray
 {
   public:
     // explicit this.
-    explicit NullableMutableArray() : m_FirstNode(new MutableLinkedList<T>()) {}
+    explicit NullableMutableArray() : fFirstNode(new MutableLinkedList<T>()) {}
 
     /*
      * We free all the nodes allocated by the array
@@ -74,12 +74,12 @@ template <typename T, T _PlaceHolderValue> class NullableMutableArray
 
     virtual ~NullableMutableArray()
     {
-        auto *It = m_FirstNode;
+        auto *It = fFirstNode;
         MutableLinkedList<T> *NextIt = nullptr;
 
         while (It)
         {
-            NextIt = It->m_Next;
+            NextIt = It->fNext;
             delete It;
 
             It = NextIt;
@@ -94,43 +94,43 @@ template <typename T, T _PlaceHolderValue> class NullableMutableArray
   public:
     T operator[](const SizeT &Index) const
     {
-        TRY_FIND_NODE(first, m_FirstNode);
-        TRY_FIND_NODE(last, m_LastNode);
+        TRY_FIND_NODE(first, fFirstNode);
+        TRY_FIND_NODE(last, fLastNode);
 
         return _PlaceHolderValue;
     }
 
-    SizeT Count() const { return m_NodeCount; }
+    SizeT Count() const { return fNodeCount; }
 
   public:
     Boolean Remove(const SizeT &Index)
     {
-        TRY_REMOVE_NODE(m_FirstNode);
-        TRY_REMOVE_NODE(m_LastNode);
+        TRY_REMOVE_NODE(fFirstNode);
+        TRY_REMOVE_NODE(fLastNode);
 
         return false;
     }
 
     Boolean Add(const T val)
     {
-        auto *iterationNode = m_FirstNode;
+        auto *iterationNode = fFirstNode;
         MUST_PASS(iterationNode);
 
         while (iterationNode)
         {
-            if (!iterationNode->m_Used)
+            if (!iterationNode->fUsed)
             {
-                iterationNode->m_Val = val;
-                iterationNode->m_Index = 0;
+                iterationNode->fVal = val;
+                iterationNode->fIndex = 0;
 
-                iterationNode->m_Used = true;
+                iterationNode->fUsed = true;
 
-                ++m_NodeCount;
+                ++fNodeCount;
 
                 return true;
             }
 
-            iterationNode = iterationNode->m_Next;
+            iterationNode = iterationNode->fNext;
         }
 
         return false;
@@ -138,11 +138,11 @@ template <typename T, T _PlaceHolderValue> class NullableMutableArray
 
   private:
     /* Avoid useless lookups */
-    MutableLinkedList<T> *m_LastNode{nullptr};
-    MutableLinkedList<T> *m_FirstNode{nullptr};
+    MutableLinkedList<T> *fLastNode{nullptr};
+    MutableLinkedList<T> *fFirstNode{nullptr};
 
     /* Number of nodes inside of this dynamic array. */
-    NewOS::SizeT m_NodeCount{0};
+    NewOS::SizeT fNodeCount{0};
 
   private:
     // don't remove that
@@ -162,24 +162,24 @@ class MutableArray : public NullableMutableArray<voidPtr, nullptr>
   public:
     Boolean Add(const T val)
     {
-        auto *iterationNode = m_FirstNode;
+        auto *iterationNode = fFirstNode;
         MUST_PASS(iterationNode);
 
         while (iterationNode)
         {
-            if (!iterationNode->m_Used)
+            if (!iterationNode->fUsed)
             {
-                iterationNode->m_Val = val;
-                iterationNode->m_Index = 0;
+                iterationNode->fVal = val;
+                iterationNode->fIndex = 0;
 
-                iterationNode->m_Used = true;
+                iterationNode->fUsed = true;
 
-                ++m_NodeCount;
+                ++fNodeCount;
 
                 return true;
             }
 
-            iterationNode = iterationNode->m_Next;
+            iterationNode = iterationNode->fNext;
         }
 
         return false;
@@ -188,24 +188,24 @@ class MutableArray : public NullableMutableArray<voidPtr, nullptr>
   public:
     Ref<T> operator[](const SizeT &Index) const
     {
-        TRY_FIND_NODE2(first, m_FirstNode);
-        TRY_FIND_NODE2(last, m_LastNode);
+        TRY_FIND_NODE2(first, fFirstNode);
+        TRY_FIND_NODE2(last, fLastNode);
 
         return {};
     }
 
-    SizeT Count() const { return m_NodeCount; }
+    SizeT Count() const { return fNodeCount; }
 
     bool Contains(T &value) noexcept
     {
-        MutableLinkedList<T> *first = m_FirstNode;
+        MutableLinkedList<T> *first = fFirstNode;
 
         while (first)
         {
-            if (first->m_Val == value && first->m_Used)
+            if (first->fVal == value && first->fUsed)
                 return true;
 
-            first = first->m_Next;
+            first = first->fNext;
         }
 
         return false;
@@ -213,10 +213,10 @@ class MutableArray : public NullableMutableArray<voidPtr, nullptr>
 
   private:
     /* Avoid useless lookups */
-    MutableLinkedList<T> *m_LastNode{nullptr};
-    MutableLinkedList<T> *m_FirstNode{nullptr};
+    MutableLinkedList<T> *fLastNode{nullptr};
+    MutableLinkedList<T> *fFirstNode{nullptr};
 
     /* Number of nodes inside of this dynamic array. */
-    NewOS::SizeT m_NodeCount{0};
+    NewOS::SizeT fNodeCount{0};
 };
 } // namespace NewOS
diff --git a/Private/NewKit/OwnPtr.hpp b/Private/NewKit/OwnPtr.hpp
index e6d006ed..ff2b59e1 100644
--- a/Private/NewKit/OwnPtr.hpp
+++ b/Private/NewKit/OwnPtr.hpp
@@ -30,30 +30,30 @@ class OwnPtr final {
  public:
   template <typename... Args>
   bool New(Args &&...arg) {
-    if (m_Cls) {
+    if (fCls) {
       return false;
     }
 
-    m_Cls = new T(arg...);
-    return m_Cls;
+    fCls = new T(arg...);
+    return fCls;
   }
 
   void Delete() {
-    if (m_Cls) delete m_Cls;
+    if (fCls) delete fCls;
 
-    m_Cls = nullptr;
+    fCls = nullptr;
   }
 
-  T *operator->() const { return m_Cls; };
-  T *Raw() { return m_Cls; }
+  T *operator->() const { return fCls; };
+  T *Raw() { return fCls; }
 
-  Ref<T> AsRef() { return Ref<T>(m_Cls); }
+  Ref<T> AsRef() { return Ref<T>(fCls); }
 
-  operator bool() { return m_Cls; }
-  bool operator!() { return !m_Cls; }
+  operator bool() { return fCls; }
+  bool operator!() { return !fCls; }
 
  private:
-  T *m_Cls;
+  T *fCls;
 };
 
 template <typename T, typename... Args>
diff --git a/Private/NewKit/PageManager.hpp b/Private/NewKit/PageManager.hpp
index 9aba5a6c..c8806c90 100644
--- a/Private/NewKit/PageManager.hpp
+++ b/Private/NewKit/PageManager.hpp
@@ -42,15 +42,15 @@ class PTEWrapper final {
   bool Access();
 
  private:
-  Boolean m_Rw;
-  Boolean m_User;
-  Boolean m_ExecDisable;
-  UIntPtr m_VirtAddr;
-  Boolean m_Cache;
-  Boolean m_Shareable;
-  Boolean m_Wt;
-  Boolean m_Present;
-  Boolean m_Accessed;
+  Boolean fRw;
+  Boolean fUser;
+  Boolean fExecDisable;
+  UIntPtr fVirtAddr;
+  Boolean fCache;
+  Boolean fShareable;
+  Boolean fWt;
+  Boolean fPresent;
+  Boolean fAccessed;
 
  private:
   friend class PageManager;
diff --git a/Private/NewKit/Pmm.hpp b/Private/NewKit/Pmm.hpp
index ed43a03c..2ed8b753 100644
--- a/Private/NewKit/Pmm.hpp
+++ b/Private/NewKit/Pmm.hpp
@@ -31,9 +31,9 @@ class Pmm final {
   Boolean ToggleShare(Ref<PTEWrapper> refPage, Boolean enable = true);
 
   /// @brief Get the page manager of this.
-  Ref<PageManager> &Leak() { return m_PageManager; }
+  Ref<PageManager> &Leak() { return fPageManager; }
 
  private:
-  Ref<PageManager> m_PageManager;
+  Ref<PageManager> fPageManager;
 };
 }  // namespace NewOS
diff --git a/Private/NewKit/Ref.hpp b/Private/NewKit/Ref.hpp
index 4327081b..30e65e2f 100644
--- a/Private/NewKit/Ref.hpp
+++ b/Private/NewKit/Ref.hpp
@@ -18,27 +18,27 @@ class Ref final {
   ~Ref() = default;
 
  public:
-  Ref(T cls, const bool &strong = false) : m_Class(cls), m_Strong(strong) {}
+  Ref(T cls, const bool &strong = false) : fClass(cls), fStrong(strong) {}
 
   Ref &operator=(T ref) {
-    m_Class = ref;
+    fClass = ref;
     return *this;
   }
 
  public:
-  T operator->() const { return m_Class; }
+  T operator->() const { return fClass; }
 
-  T &Leak() { return m_Class; }
+  T &Leak() { return fClass; }
 
-  T operator*() { return m_Class; }
+  T operator*() { return fClass; }
 
-  bool IsStrong() const { return m_Strong; }
+  bool IsStrong() const { return fStrong; }
 
-  operator bool() { return m_Strong; }
+  operator bool() { return fStrong; }
 
  private:
-  T m_Class;
-  bool m_Strong{false};
+  T fClass;
+  bool fStrong{false};
 };
 
 template <typename T>
@@ -47,17 +47,17 @@ class NonNullRef final {
   NonNullRef() = delete;
   NonNullRef(nullPtr) = delete;
 
-  NonNullRef(T *ref) : m_Ref(ref, true) {}
+  NonNullRef(T *ref) : fRef(ref, true) {}
 
   Ref<T> &operator->() {
-    MUST_PASS(m_Ref);
-    return m_Ref;
+    MUST_PASS(fRef);
+    return fRef;
   }
 
   NonNullRef &operator=(const NonNullRef<T> &ref) = delete;
   NonNullRef(const NonNullRef<T> &ref) = default;
 
  private:
-  Ref<T> m_Ref{nullptr};
+  Ref<T> fRef{nullptr};
 };
 }  // namespace NewOS
diff --git a/Private/NewKit/Stream.hpp b/Private/NewKit/Stream.hpp
index 30e60939..67288191 100644
--- a/Private/NewKit/Stream.hpp
+++ b/Private/NewKit/Stream.hpp
@@ -17,7 +17,7 @@ namespace NewOS
     {
     public:
         explicit Stream(Ref<Stream> ref)
-            : m_Stream(ref)
+            : fStream(ref)
         {}
 
         ~Stream() = default;
@@ -28,31 +28,31 @@ namespace NewOS
         template <typename Data>
         friend Stream<StreamTrait, Kind> &operator>>(Stream<StreamTrait, Kind> &Ks, Ref<Data>& Buf)
         {
-            Ks.m_Kind = Ks.m_Stream->In(Buf);
+            Ks.fKind = Ks.fStream->In(Buf);
             return *Ks;
         }
 
         template <typename Data>
         friend Stream<StreamTrait, Kind> &operator<<(Stream<StreamTrait, Kind> &Ks, Ref<Data>& Buf)
         {
-            Ks.m_Kind = Buf;
-            Ks.m_Stream->Out(Buf.Leak());
+            Ks.fKind = Buf;
+            Ks.fStream->Out(Buf.Leak());
             return *Ks;
         }
 
         Ref<StreamTrait> &AsStreamTrait()
         {
-            return m_Stream;
+            return fStream;
         }
         
         Ref<Kind>& AsType()
         {
-            return m_Kind;
+            return fKind;
         }
 
       private:
-        Ref<StreamTrait> m_Stream;
-        Ref<Kind> m_Kind;
+        Ref<StreamTrait> fStream;
+        Ref<Kind> fKind;
 
     };
 } // namespace NewOS
diff --git a/Private/NewKit/String.hpp b/Private/NewKit/String.hpp
index 1806c32a..93dfc584 100644
--- a/Private/NewKit/String.hpp
+++ b/Private/NewKit/String.hpp
@@ -15,14 +15,14 @@ class StringView final {
  public:
   explicit StringView() = default;
 
-  explicit StringView(Size Sz) : m_Sz(Sz) {
+  explicit StringView(Size Sz) : fSz(Sz) {
     MUST_PASS(Sz > 1);
-    m_Data = new Char[Sz];
-    MUST_PASS(m_Data);
+    fData = new Char[Sz];
+    MUST_PASS(fData);
   }
 
   ~StringView() {
-    if (m_Data) delete[] m_Data;
+    if (fData) delete[] fData;
   }
 
   StringView &operator=(const StringView &) = default;
@@ -41,14 +41,14 @@ class StringView final {
   StringView &operator+=(const Char *rhs);
   StringView &operator+=(const StringView &rhs);
 
-  operator bool() { return m_Data; }
+  operator bool() { return fData; }
 
-  bool operator!() { return m_Data; }
+  bool operator!() { return fData; }
 
  private:
-  Char *m_Data{nullptr};
-  Size m_Sz{0};
-  Size m_Cur{0};
+  Char *fData{nullptr};
+  Size fSz{0};
+  Size fCur{0};
 
   friend class StringBuilder;
 };
diff --git a/Private/NewKit/Utils.hpp b/Private/NewKit/Utils.hpp
index 67ecaf22..749e15ba 100644
--- a/Private/NewKit/Utils.hpp
+++ b/Private/NewKit/Utils.hpp
@@ -24,5 +24,5 @@ Boolean is_space(Char chr);
 Int rt_to_uppercase(Int c);
 Int rt_to_lower(Int c);
 voidPtr rt_string_in_string(const char *in, const char *needle);
-char *rt_string_from_char(char *str, const char chr);
+char *rt_string_frofchar(char *str, const char chr);
 }  // namespace NewOS
diff --git a/Private/NewKit/Variant.hpp b/Private/NewKit/Variant.hpp
index 109acbbe..c0738de2 100644
--- a/Private/NewKit/Variant.hpp
+++ b/Private/NewKit/Variant.hpp
@@ -25,15 +25,15 @@ class Variant final {
 
  public:
   explicit Variant(StringView *stringView)
-      : m_Ptr((voidPtr)stringView), m_Kind(VariantKind::kString) {}
-  explicit Variant(nullPtr) : m_Ptr(nullptr), m_Kind(VariantKind::kUndefined) {}
-  explicit Variant(voidPtr ptr) : m_Ptr(ptr), m_Kind(VariantKind::kPointer) {}
+      : fPtr((voidPtr)stringView), fKind(VariantKind::kString) {}
+  explicit Variant(nullPtr) : fPtr(nullptr), fKind(VariantKind::kUndefined) {}
+  explicit Variant(voidPtr ptr) : fPtr(ptr), fKind(VariantKind::kPointer) {}
 
  public:
   const Char *ToString();
 
  private:
-  voidPtr m_Ptr{nullptr};
-  VariantKind m_Kind{VariantKind::kUndefined};
+  voidPtr fPtr{nullptr};
+  VariantKind fKind{VariantKind::kUndefined};
 };
 }  // namespace NewOS
diff --git a/Private/Source/DriveManager.cxx b/Private/Source/DriveManager.cxx
index d04faa68..b468ebae 100644
--- a/Private/Source/DriveManager.cxx
+++ b/Private/Source/DriveManager.cxx
@@ -25,7 +25,12 @@ Void ke_drv_input(DriveTrait::DrivePacket* pckt) {
     
     pckt->fPacketGood = false;
 
+#ifndef __AHCI__
     drv_std_read(pckt->fLba, kATAIO, kATAMaster, (Char*)pckt->fPacketContent, 1, pckt->fPacketSize);
+#else
+    drv_std_read(pckt->fLba, (Char*)pckt->fPacketContent, 1, pckt->fPacketSize);
+#endif
+
 
     pckt->fPacketGood = true;
 }
@@ -40,7 +45,11 @@ Void ke_drv_output(DriveTrait::DrivePacket* pckt) {
     
     pckt->fPacketGood = false;
 
+#ifndef __AHCI__
     drv_std_write(pckt->fLba, kATAIO, kATAMaster, (Char*)pckt->fPacketContent, 1, pckt->fPacketSize);
+#else
+    drv_std_write(pckt->fLba,(Char*)pckt->fPacketContent, 1, pckt->fPacketSize);
+#endif
 
     pckt->fPacketGood = true;
 }
@@ -68,7 +77,7 @@ const Char* ke_drive_kind(Void) { return "ATA-DMA"; }
 #endif
 
 #ifdef __AHCI__ 
-const Char* ke_drive_kind(Void) { return "AHCO"; }
+const Char* ke_drive_kind(Void) { return "AHCI"; }
 #endif
 
 /// @brief Unimplemented drive.
diff --git a/Private/Source/Framebuffer.cxx b/Private/Source/Framebuffer.cxx
index d0be2a13..5dc54c81 100644
--- a/Private/Source/Framebuffer.cxx
+++ b/Private/Source/Framebuffer.cxx
@@ -36,14 +36,14 @@ const UInt32 kRgbWhite = 0xFFFFFFFF;
  * @return volatile*
  */
 volatile UIntPtr *Framebuffer::operator[](const UIntPtr &pos) {
-  return (UIntPtr *)(m_FrameBufferAddr->m_Base * pos);
+  return (UIntPtr *)(fFrameBufferAddr->fBase * pos);
 }
 
 /// @brief Boolean operator.
 Framebuffer::operator bool() {
-  return m_FrameBufferAddr.Leak()->m_Base != 0 &&
-         m_Colour != FramebufferColorKind::INVALID &&
-         m_FrameBufferAddr.Leak()->m_Base != kBadPtr;
+  return fFrameBufferAddr.Leak()->fBase != 0 &&
+         fColour != FramebufferColorKind::INVALID &&
+         fFrameBufferAddr.Leak()->fBase != kBadPtr;
 }
 
 /// @brief Set color kind of framebuffer.
@@ -51,26 +51,26 @@ Framebuffer::operator bool() {
 /// @return
 const FramebufferColorKind &Framebuffer::Color(
     const FramebufferColorKind &colour) {
-  if (m_Colour != FramebufferColorKind::INVALID &&
+  if (fColour != FramebufferColorKind::INVALID &&
       colour != FramebufferColorKind::INVALID) {
-    m_Colour = colour;
+    fColour = colour;
   }
 
-  return m_Colour;
+  return fColour;
 }
 
 /// @brief Leak framebuffer context.
 /// @return The reference of the framebuffer context.
 Ref<FramebufferContext *> &Framebuffer::Leak() {
-  return this->m_FrameBufferAddr;
+  return this->fFrameBufferAddr;
 }
 
 Framebuffer &Framebuffer::DrawRect(SizeT width, SizeT height, SizeT x, SizeT y,
                                    UInt32 color) {
   for (NewOS::SizeT i = x; i < width + x; ++i) {
     for (NewOS::SizeT u = y; u < height + y; ++u) {
-      *(((volatile NewOS::UInt32 *)(m_FrameBufferAddr.Leak()->m_Base +
-                                    4 * m_FrameBufferAddr.Leak()->m_Bpp * i +
+      *(((volatile NewOS::UInt32 *)(fFrameBufferAddr.Leak()->fBase +
+                                    4 * fFrameBufferAddr.Leak()->fBpp * i +
                                     4 * u))) = color;
     }
   }
@@ -79,8 +79,8 @@ Framebuffer &Framebuffer::DrawRect(SizeT width, SizeT height, SizeT x, SizeT y,
 }
 
 Framebuffer &Framebuffer::PutPixel(SizeT x, SizeT y, UInt32 color) {
-  *(((volatile NewOS::UInt32 *)(m_FrameBufferAddr.Leak()->m_Base +
-                                4 * m_FrameBufferAddr.Leak()->m_Bpp * x +
+  *(((volatile NewOS::UInt32 *)(fFrameBufferAddr.Leak()->fBase +
+                                4 * fFrameBufferAddr.Leak()->fBpp * x +
                                 4 * y))) = color;
                                 
   return *this;
diff --git a/Private/Source/GUIDWizard.cxx b/Private/Source/GUIDWizard.cxx
index 90903979..9d0d4f35 100644
--- a/Private/Source/GUIDWizard.cxx
+++ b/Private/Source/GUIDWizard.cxx
@@ -24,10 +24,10 @@ auto make_sequence(const ArrayList<UShort>& uuidSeq) -> Ref<GUIDSequence*> {
 
   Ref<GUIDSequence*> sequenceReference{seq, true};
 
-  sequenceReference->m_Ms1 |= uuidSeq[0];
-  sequenceReference->m_Ms2 |= uuidSeq[1];
-  sequenceReference->m_Ms3 |= uuidSeq[2];
-  sequenceReference->m_Ms3 |= uuidSeq[3];
+  sequenceReference->fMs1 |= uuidSeq[0];
+  sequenceReference->fMs2 |= uuidSeq[1];
+  sequenceReference->fMs3 |= uuidSeq[2];
+  sequenceReference->fMs3 |= uuidSeq[3];
 
   return sequenceReference;
 }
diff --git a/Private/Source/Network/IP.cxx b/Private/Source/Network/IP.cxx
index 04e5247d..06421c21 100644
--- a/Private/Source/Network/IP.cxx
+++ b/Private/Source/Network/IP.cxx
@@ -8,13 +8,13 @@
 #include <NewKit/Utils.hpp>
 
 namespace NewOS {
-char* RawIPAddress::Address() { return m_Addr; }
+char* RawIPAddress::Address() { return fAddr; }
 
-RawIPAddress::RawIPAddress(char bytes[4]) { rt_copy_memory(bytes, m_Addr, 4); }
+RawIPAddress::RawIPAddress(char bytes[4]) { rt_copy_memory(bytes, fAddr, 4); }
 
 bool RawIPAddress::operator==(const RawIPAddress& ipv4) {
   for (Size index = 0; index < 4; ++index) {
-    if (ipv4.m_Addr[index] != m_Addr[index]) return false;
+    if (ipv4.fAddr[index] != fAddr[index]) return false;
   }
 
   return true;
@@ -22,7 +22,7 @@ bool RawIPAddress::operator==(const RawIPAddress& ipv4) {
 
 bool RawIPAddress::operator!=(const RawIPAddress& ipv4) {
   for (Size index = 0; index < 4; ++index) {
-    if (ipv4.m_Addr[index] == m_Addr[index]) return false;
+    if (ipv4.fAddr[index] == fAddr[index]) return false;
   }
 
   return true;
@@ -34,11 +34,11 @@ char& RawIPAddress::operator[](const Size& index) {
   static char IP_PLACEHOLDER = '0';
   if (index > 4) return IP_PLACEHOLDER;
 
-  return m_Addr[index];
+  return fAddr[index];
 }
 
 RawIPAddress6::RawIPAddress6(char bytes[8]) {
-  rt_copy_memory(bytes, m_Addr, 8);
+  rt_copy_memory(bytes, fAddr, 8);
 }
 
 char& RawIPAddress6::operator[](const Size& index) {
@@ -47,12 +47,12 @@ char& RawIPAddress6::operator[](const Size& index) {
   static char IP_PLACEHOLDER = '0';
   if (index > 8) return IP_PLACEHOLDER;
 
-  return m_Addr[index];
+  return fAddr[index];
 }
 
 bool RawIPAddress6::operator==(const RawIPAddress6& ipv6) {
   for (SizeT index = 0; index < 8; ++index) {
-    if (ipv6.m_Addr[index] != m_Addr[index]) return false;
+    if (ipv6.fAddr[index] != fAddr[index]) return false;
   }
 
   return true;
@@ -60,7 +60,7 @@ bool RawIPAddress6::operator==(const RawIPAddress6& ipv6) {
 
 bool RawIPAddress6::operator!=(const RawIPAddress6& ipv6) {
   for (SizeT index = 0; index < 8; ++index) {
-    if (ipv6.m_Addr[index] == m_Addr[index]) return false;
+    if (ipv6.fAddr[index] == fAddr[index]) return false;
   }
 
   return true;
diff --git a/Private/Source/PRDT.cxx b/Private/Source/PRDT.cxx
index f999dfd6..42808a43 100644
--- a/Private/Source/PRDT.cxx
+++ b/Private/Source/PRDT.cxx
@@ -8,25 +8,4 @@
 #include <NewKit/String.hpp>
 #include <StorageKit/PRDT.hpp>
 
-namespace NewOS {
-PRDT::PRDT(const UIntPtr& physAddr) : m_PrdtAddr(physAddr) {
-  MUST_PASS(physAddr);
-  kcout << "PRDT::PRDT() {}\r\n";
-}
-
-PRDT::~PRDT() {
-  kcout << "PRDT::~PRDT() {}\r\n";
-  m_PrdtAddr = 0;
-}
-
-const UInt& PRDT::Low() { return m_Low; }
-
-const UShort& PRDT::High() { return m_High; }
-
-const UIntPtr& PRDT::PhysicalAddress() { return m_PrdtAddr; }
-
-PRDT& PRDT::operator=(const UIntPtr& prdtAddress) {
-  m_PrdtAddr = prdtAddress;
-  return *this;
-}
-}  // namespace NewOS
+namespace NewOS {}  // namespace NewOS
diff --git a/Private/Source/PageManager.cxx b/Private/Source/PageManager.cxx
index 4c4524cd..0704734c 100644
--- a/Private/Source/PageManager.cxx
+++ b/Private/Source/PageManager.cxx
@@ -17,15 +17,15 @@
 namespace NewOS {
 PTEWrapper::PTEWrapper(Boolean Rw, Boolean User, Boolean ExecDisable,
                        UIntPtr VirtAddr)
-    : m_Rw(Rw),
-      m_User(User),
-      m_ExecDisable(ExecDisable),
-      m_VirtAddr(VirtAddr),
-      m_Cache(false),
-      m_Shareable(false),
-      m_Wt(false),
-      m_Present(true),
-      m_Accessed(false) {}
+    : fRw(Rw),
+      fUser(User),
+      fExecDisable(ExecDisable),
+      fVirtAddr(VirtAddr),
+      fCache(false),
+      fShareable(false),
+      fWt(false),
+      fPresent(true),
+      fAccessed(false) {}
 
 PTEWrapper::~PTEWrapper() {}
 
@@ -36,8 +36,8 @@ void PageManager::FlushTLB(UIntPtr VirtAddr) {
 }
 
 bool PTEWrapper::Reclaim() {
-  if (!this->m_Present) {
-    this->m_Present = true;
+  if (!this->fPresent) {
+    this->fPresent = true;
     return true;
   }
 
@@ -61,16 +61,16 @@ bool PageManager::Free(Ref<PTEWrapper *> &wrapper) {
 }
 
 const UIntPtr PTEWrapper::VirtualAddress() {
-  return (m_VirtAddr + sizeof(PTE) + sizeof(PTEWrapper));
+  return (fVirtAddr + sizeof(PTE) + sizeof(PTEWrapper));
 }
 
-bool PTEWrapper::Shareable() { return m_Shareable; }
+bool PTEWrapper::Shareable() { return fShareable; }
 
-bool PTEWrapper::Present() { return m_Present; }
+bool PTEWrapper::Present() { return fPresent; }
 
-bool PTEWrapper::Access() { return m_Accessed; }
+bool PTEWrapper::Access() { return fAccessed; }
 
-void PTEWrapper::NoExecute(const bool enable) { this->m_ExecDisable = enable; }
+void PTEWrapper::NoExecute(const bool enable) { this->fExecDisable = enable; }
 
-const bool &PTEWrapper::NoExecute() { return this->m_ExecDisable; }
+const bool &PTEWrapper::NoExecute() { return this->fExecDisable; }
 }  // namespace NewOS
diff --git a/Private/Source/Pmm.cxx b/Private/Source/Pmm.cxx
index ba5f62e8..7c331c65 100644
--- a/Private/Source/Pmm.cxx
+++ b/Private/Source/Pmm.cxx
@@ -8,15 +8,15 @@
 #include <NewKit/Pmm.hpp>
 
 namespace NewOS {
-Pmm::Pmm() : m_PageManager() { kcout << "[PMM] Allocate PageMemoryManager"; }
+Pmm::Pmm() : fPageManager() { kcout << "[PMM] Allocate PageMemoryManager"; }
 
 Pmm::~Pmm() = default;
 
 /* If this returns Null pointer, enter emergency mode */
 Ref<PTEWrapper> Pmm::RequestPage(Boolean user, Boolean readWrite) {
-  PTEWrapper pt = m_PageManager.Leak().Request(user, readWrite, false);
+  PTEWrapper pt = fPageManager.Leak().Request(user, readWrite, false);
 
-  if (pt.m_Present) {
+  if (pt.fPresent) {
     kcout << "[PMM]: Allocation was successful.";
     return Ref<PTEWrapper>(pt);
   }
@@ -29,7 +29,7 @@ Ref<PTEWrapper> Pmm::RequestPage(Boolean user, Boolean readWrite) {
 Boolean Pmm::FreePage(Ref<PTEWrapper> PageRef) {
   if (!PageRef) return false;
 
-  PageRef.Leak().m_Present = false;
+  PageRef.Leak().fPresent = false;
 
   return true;
 }
@@ -37,7 +37,7 @@ Boolean Pmm::FreePage(Ref<PTEWrapper> PageRef) {
 Boolean Pmm::TogglePresent(Ref<PTEWrapper> PageRef, Boolean Enable) {
   if (!PageRef) return false;
 
-  PageRef.Leak().m_Present = Enable;
+  PageRef.Leak().fPresent = Enable;
 
   return true;
 }
@@ -45,7 +45,7 @@ Boolean Pmm::TogglePresent(Ref<PTEWrapper> PageRef, Boolean Enable) {
 Boolean Pmm::ToggleUser(Ref<PTEWrapper> PageRef, Boolean Enable) {
   if (!PageRef) return false;
 
-  PageRef.Leak().m_Rw = Enable;
+  PageRef.Leak().fRw = Enable;
 
   return true;
 }
@@ -53,7 +53,7 @@ Boolean Pmm::ToggleUser(Ref<PTEWrapper> PageRef, Boolean Enable) {
 Boolean Pmm::ToggleRw(Ref<PTEWrapper> PageRef, Boolean Enable) {
   if (!PageRef) return false;
 
-  PageRef.Leak().m_Rw = Enable;
+  PageRef.Leak().fRw = Enable;
 
   return true;
 }
@@ -61,7 +61,7 @@ Boolean Pmm::ToggleRw(Ref<PTEWrapper> PageRef, Boolean Enable) {
 Boolean Pmm::ToggleShare(Ref<PTEWrapper> PageRef, Boolean Enable) {
   if (!PageRef) return false;
 
-  PageRef.Leak().m_Shareable = Enable;
+  PageRef.Leak().fShareable = Enable;
 
   return true;
 }
diff --git a/Private/Source/Property.cxx b/Private/Source/Property.cxx
index 81cf430a..c9e20df8 100644
--- a/Private/Source/Property.cxx
+++ b/Private/Source/Property.cxx
@@ -8,8 +8,8 @@
 
 namespace NewOS {
 bool Property::StringEquals(StringView& name) {
-  return m_sName && this->m_sName == name;
+  return fsName && this->fsName == name;
 }
 
-const PropertyId& Property::GetPropertyById() { return m_Action; }
+const PropertyId& Property::GetPropertyById() { return fAction; }
 }  // namespace NewOS
diff --git a/Private/Source/SMPManager.cxx b/Private/Source/SMPManager.cxx
index 18625cc5..3c342e16 100644
--- a/Private/Source/SMPManager.cxx
+++ b/Private/Source/SMPManager.cxx
@@ -26,36 +26,36 @@ HardwareThread::~HardwareThread() = default;
 
 //! @brief returns the id
 
-const ThreadID& HardwareThread::ID() noexcept { return m_ID; }
+const ThreadID& HardwareThread::ID() noexcept { return fID; }
 
 //! @brief returns the kind
 
-const ThreadKind& HardwareThread::Kind() noexcept { return m_Kind; }
+const ThreadKind& HardwareThread::Kind() noexcept { return fKind; }
 
 //! @brief is the core busy?
 
-bool HardwareThread::IsBusy() noexcept { return m_Busy; }
+bool HardwareThread::IsBusy() noexcept { return fBusy; }
 
 /// @brief Get processor stack frame.
 
 HAL::StackFramePtr HardwareThread::StackFrame() noexcept {
-  MUST_PASS(m_Stack);
-  return m_Stack;
+  MUST_PASS(fStack);
+  return fStack;
 }
 
-void HardwareThread::Busy(const bool busy) noexcept { m_Busy = busy; }
+void HardwareThread::Busy(const bool busy) noexcept { fBusy = busy; }
 
-HardwareThread::operator bool() { return m_Stack; }
+HardwareThread::operator bool() { return fStack; }
 
 /// @brief Wakeup the processor.
 
 void HardwareThread::Wake(const bool wakeup) noexcept {
-  m_Wakeup = wakeup;
+  fWakeup = wakeup;
 
-  if (!m_Wakeup)
-    rt_hang_thread(m_Stack);
+  if (!fWakeup)
+    rt_hang_thread(fStack);
   else
-    rt_wakeup_thread(m_Stack);
+    rt_wakeup_thread(fStack);
 }
 
 extern bool rt_check_stack(HAL::StackFramePtr stackPtr);
@@ -63,14 +63,14 @@ extern bool rt_check_stack(HAL::StackFramePtr stackPtr);
 bool HardwareThread::Switch(HAL::StackFramePtr stack) {
   if (!rt_check_stack(stack)) return false;
 
-  m_Stack = stack;
+  fStack = stack;
 
-  rt_do_context_switch(m_Stack);
+  rt_do_context_switch(fStack);
   return true;
 }
 
 ///! @brief Tells if processor is waked up.
-bool HardwareThread::IsWakeup() noexcept { return m_Wakeup; }
+bool HardwareThread::IsWakeup() noexcept { return fWakeup; }
 
 //! @brief Constructor and destructor
 
@@ -88,10 +88,10 @@ Ref<SMPManager> SMPManager::Shared() {
 
 /// @brief Get Stack Frame of Core
 HAL::StackFramePtr SMPManager::GetStackFrame() noexcept {
-  if (m_ThreadList[m_CurrentThread].Leak() &&
+  if (fThreadList[fCurrentThread].Leak() &&
       ProcessHelper::GetCurrentPID() ==
-          m_ThreadList[m_CurrentThread].Leak().Leak().m_PID)
-    return m_ThreadList[m_CurrentThread].Leak().Leak().m_Stack;
+          fThreadList[fCurrentThread].Leak().Leak().fPID)
+    return fThreadList[fCurrentThread].Leak().Leak().fStack;
 
   return nullptr;
 }
@@ -102,31 +102,31 @@ bool SMPManager::Switch(HAL::StackFramePtr stack) {
 
   for (SizeT idx = 0; idx < kMaxHarts; ++idx) {
     // stack != nullptr -> if core is used, then continue.
-    if (!m_ThreadList[idx].Leak() ||
-        !m_ThreadList[idx].Leak().Leak().IsWakeup() ||
-        m_ThreadList[idx].Leak().Leak().IsBusy())
+    if (!fThreadList[idx].Leak() ||
+        !fThreadList[idx].Leak().Leak().IsWakeup() ||
+        fThreadList[idx].Leak().Leak().IsBusy())
       continue;
 
     // to avoid any null deref.
-    if (!m_ThreadList[idx].Leak().Leak().m_Stack) continue;
-    if (m_ThreadList[idx].Leak().Leak().m_Stack->Rsp == 0) continue;
-    if (m_ThreadList[idx].Leak().Leak().m_Stack->Rbp == 0) continue;
+    if (!fThreadList[idx].Leak().Leak().fStack) continue;
+    if (fThreadList[idx].Leak().Leak().fStack->Rsp == 0) continue;
+    if (fThreadList[idx].Leak().Leak().fStack->Rbp == 0) continue;
 
-    m_ThreadList[idx].Leak().Leak().Busy(true);
+    fThreadList[idx].Leak().Leak().Busy(true);
 
-    m_ThreadList[idx].Leak().Leak().m_ID = idx;
+    fThreadList[idx].Leak().Leak().fID = idx;
 
     /// I figured out this:
     /// Allocate stack
     /// Set APIC base to stack
     /// Do stuff and relocate stack based on this code.
     /// - Amlel
-    rt_copy_memory(stack, m_ThreadList[idx].Leak().Leak().m_Stack,
+    rt_copy_memory(stack, fThreadList[idx].Leak().Leak().fStack,
                    sizeof(HAL::StackFrame));
 
-    m_ThreadList[idx].Leak().Leak().m_PID = ProcessHelper::GetCurrentPID();
+    fThreadList[idx].Leak().Leak().fPID = ProcessHelper::GetCurrentPID();
 
-    m_ThreadList[idx].Leak().Leak().Busy(false);
+    fThreadList[idx].Leak().Leak().Busy(false);
 
     return true;
   }
@@ -141,32 +141,32 @@ bool SMPManager::Switch(HAL::StackFramePtr stack) {
  */
 Ref<HardwareThread> SMPManager::operator[](const SizeT& idx) {
   if (idx == 0) {
-    if (m_ThreadList[idx].Leak().Leak().Kind() != kHartSystemReserved) {
-      m_ThreadList[idx].Leak().Leak().m_Kind = kHartBoot;
+    if (fThreadList[idx].Leak().Leak().Kind() != kHartSystemReserved) {
+      fThreadList[idx].Leak().Leak().fKind = kHartBoot;
     }
   } else if (idx >= kMaxHarts) {
     HardwareThread fakeThread;
-    fakeThread.m_Kind = kInvalidHart;
+    fakeThread.fKind = kInvalidHart;
 
     return {fakeThread};
   }
 
-  return m_ThreadList[idx].Leak();
+  return fThreadList[idx].Leak();
 }
 
 /**
  * Check if thread pool isn't empty.
  * @return
  */
-SMPManager::operator bool() noexcept { return !m_ThreadList.Empty(); }
+SMPManager::operator bool() noexcept { return !fThreadList.Empty(); }
 
 /**
  * Reverse operator bool
  * @return
  */
-bool SMPManager::operator!() noexcept { return m_ThreadList.Empty(); }
+bool SMPManager::operator!() noexcept { return fThreadList.Empty(); }
 
 /// @brief Returns the amount of core present.
 /// @return the number of cores.
-SizeT SMPManager::Count() noexcept { return m_ThreadList.Count(); }
+SizeT SMPManager::Count() noexcept { return fThreadList.Count(); }
 }  // namespace NewOS
diff --git a/Private/Source/String.cxx b/Private/Source/String.cxx
index a204777d..8f571f34 100644
--- a/Private/Source/String.cxx
+++ b/Private/Source/String.cxx
@@ -9,17 +9,17 @@
 #include <KernelKit/DebugOutput.hpp>
 
 namespace NewOS {
-Char *StringView::Data() { return m_Data; }
+Char *StringView::Data() { return fData; }
 
-const Char *StringView::CData() { return m_Data; }
+const Char *StringView::CData() { return fData; }
 
-Size StringView::Length() const { return rt_string_len(m_Data); }
+Size StringView::Length() const { return rt_string_len(fData); }
 
 bool StringView::operator==(const StringView &rhs) const {
   if (rhs.Length() != this->Length()) return false;
 
   for (Size index = 0; index < this->Length(); ++index) {
-    if (rhs.m_Data[index] != m_Data[index]) return false;
+    if (rhs.fData[index] != fData[index]) return false;
   }
 
   return true;
@@ -29,7 +29,7 @@ bool StringView::operator==(const Char *rhs) const {
   if (rt_string_len(rhs) != this->Length()) return false;
 
   for (Size index = 0; index < rt_string_len(rhs); ++index) {
-    if (rhs[index] != m_Data[index]) return false;
+    if (rhs[index] != fData[index]) return false;
   }
 
   return true;
@@ -39,7 +39,7 @@ bool StringView::operator!=(const StringView &rhs) const {
   if (rhs.Length() != this->Length()) return false;
 
   for (Size index = 0; index < rhs.Length(); ++index) {
-    if (rhs.m_Data[index] == m_Data[index]) return false;
+    if (rhs.fData[index] == fData[index]) return false;
   }
 
   return true;
@@ -49,7 +49,7 @@ bool StringView::operator!=(const Char *rhs) const {
   if (rt_string_len(rhs) != this->Length()) return false;
 
   for (Size index = 0; index < rt_string_len(rhs); ++index) {
-    if (rhs[index] == m_Data[index]) return false;
+    if (rhs[index] == fData[index]) return false;
   }
 
   return true;
@@ -174,17 +174,17 @@ static void string_append(char *lhs, char *rhs, int cur) {
 }
 
 StringView &StringView::operator+=(const Char *rhs) {
-  string_append(this->m_Data, const_cast<char *>(rhs), this->m_Cur);
-  this->m_Cur += rt_string_len(rhs);
+  string_append(this->fData, const_cast<char *>(rhs), this->fCur);
+  this->fCur += rt_string_len(rhs);
 
   return *this;
 }
 
 StringView &StringView::operator+=(const StringView &rhs) {
-  if (rt_string_len(rhs.m_Data) > rt_string_len(this->m_Data)) return *this;
+  if (rt_string_len(rhs.fData) > rt_string_len(this->fData)) return *this;
 
-  string_append(this->m_Data, const_cast<char *>(rhs.m_Data), this->m_Cur);
-  this->m_Cur += rt_string_len(const_cast<char *>(rhs.m_Data));
+  string_append(this->fData, const_cast<char *>(rhs.fData), this->fCur);
+  this->fCur += rt_string_len(const_cast<char *>(rhs.fData));
 
   return *this;
 }
diff --git a/Private/Source/URL.cxx b/Private/Source/URL.cxx
index c384c378..ebb325c1 100644
--- a/Private/Source/URL.cxx
+++ b/Private/Source/URL.cxx
@@ -11,7 +11,7 @@
 /// BUGS: 0
 
 namespace NewOS {
-Url::Url(StringView &strUrl) : m_urlView(strUrl, false) {}
+Url::Url(StringView &strUrl) : fUrlView(strUrl, false) {}
 
 Url::~Url() = default;
 
@@ -63,7 +63,7 @@ ErrorOr<StringView> url_extract_protocol(const char *url) {
 }
 
 Ref<ErrorOr<StringView>> Url::Location() noexcept {
-  const char *src = m_urlView.Leak().CData();
+  const char *src = fUrlView.Leak().CData();
   auto loc = url_extract_location(src);
 
   if (!loc) return {};
@@ -72,7 +72,7 @@ Ref<ErrorOr<StringView>> Url::Location() noexcept {
 }
 
 Ref<ErrorOr<StringView>> Url::Protocol() noexcept {
-  const char *src = m_urlView.Leak().CData();
+  const char *src = fUrlView.Leak().CData();
   auto loc = url_extract_protocol(src);
 
   if (!loc) return {};
diff --git a/Private/Source/Utils.cxx b/Private/Source/Utils.cxx
index 9072ead9..75e158a0 100644
--- a/Private/Source/Utils.cxx
+++ b/Private/Source/Utils.cxx
@@ -157,7 +157,7 @@ voidPtr rt_string_in_string(const char *in, const char *needle) {
 
 // @brief Checks for a string start at the character.
 
-char *rt_string_from_char(char *str, const char chr) {
+char *rt_string_frofchar(char *str, const char chr) {
   while (*str != chr) {
     ++str;
 
diff --git a/Private/Source/Variant.cxx b/Private/Source/Variant.cxx
index 065d562e..fbea1768 100644
--- a/Private/Source/Variant.cxx
+++ b/Private/Source/Variant.cxx
@@ -8,11 +8,11 @@
 
 namespace NewOS {
 const Char* Variant::ToString() {
-  if (m_Ptr == nullptr) {
+  if (fPtr == nullptr) {
     return ("Memory:{Nullptr}");
   }
 
-  switch (m_Kind) {
+  switch (fKind) {
     case VariantKind::kString:
       return ("Class:{String}");
     case VariantKind::kPointer:
diff --git a/Private/StorageKit/PRDT.hpp b/Private/StorageKit/PRDT.hpp
index 9163a8bf..d83f2a56 100644
--- a/Private/StorageKit/PRDT.hpp
+++ b/Private/StorageKit/PRDT.hpp
@@ -19,33 +19,10 @@ enum kPRDTTransfer {
   kPRDTTransferCount,
 };
 
-class PRDT final {
- public:
-  explicit PRDT() = delete;
-  explicit PRDT(const UIntPtr &physAddr);
-  ~PRDT();
-
-  PRDT &operator=(const PRDT &) = default;
-  PRDT(const PRDT &) = default;
-
- public:
-  const UInt &Low();
-  const UShort &High();
-  const UIntPtr &PhysicalAddress();
-
- public:
-  PRDT &operator=(const UIntPtr &prdtAddress);
-
- public:
-  operator bool() { return m_PrdtAddr != 0; }
-
- private:
-  union {
-    UInt m_Low;
-    UShort m_High;
-  };
-
-  UIntPtr m_PrdtAddr;
+struct PRDT {
+  UInt32 fPhysAddress;
+  UInt32 fSectorCount;
+  UInt8  fEndBit;
 };
 
 EXTERN_C Int32 kPRDTTransferStatus;