ADD: Important refactors regarding NeKernel.

Signed-off-by: Amlal El Mahrouss <amlal.elmahrouss@icloud.com>

11 files changed, 104 insertions, 93 deletions

diff --git a/dev/Kernel/HALKit/AMD64/HalApplicationProcessor.cc b/dev/Kernel/HALKit/AMD64/HalApplicationProcessor.cc
index 42f2a147..602cafdd 100644
--- a/dev/Kernel/HALKit/AMD64/HalApplicationProcessor.cc
+++ b/dev/Kernel/HALKit/AMD64/HalApplicationProcessor.cc
@@ -217,7 +217,7 @@ namespace Kernel::HAL
 			kSMPInterrupt = 0;
 			kSMPCount	  = 0;
 
-			kcout << "SMP: Starting APs...\r";
+			kout << "SMP: Starting APs...\r";
 
 			UInt32 eax, edx;
 			kApicBaseAddress = kMADTBlock->Address;
@@ -235,7 +235,7 @@ namespace Kernel::HAL
 						break;
 
 					kAPICLocales[kSMPCount] = kMADTBlock->List[kSMPCount].LAPIC.ProcessorID;
-					kcout << "SMP: APIC ID: " << number(kAPICLocales[kSMPCount]) << endl;
+					kout << "SMP: APIC ID: " << number(kAPICLocales[kSMPCount]) << endl;
 
 					// I'll just make the AP start from scratch here.
 
@@ -258,7 +258,7 @@ namespace Kernel::HAL
 				++index;
 			}
 
-			kcout << "SMP: number of APs: " << number(kSMPCount) << endl;
+			kout << "SMP: number of APs: " << number(kSMPCount) << endl;
 
 			// Kernel is now SMP aware.
 			// That means that the scheduler is now available (on MP Kernels)
diff --git a/dev/Kernel/HALKit/AMD64/HalCoreInterruptHandlerAMD64.cc b/dev/Kernel/HALKit/AMD64/HalCoreInterruptHandlerAMD64.cc
index b9498d7e..c64a3e41 100644
--- a/dev/Kernel/HALKit/AMD64/HalCoreInterruptHandlerAMD64.cc
+++ b/dev/Kernel/HALKit/AMD64/HalCoreInterruptHandlerAMD64.cc
@@ -22,13 +22,13 @@ EXTERN_C void idt_handle_gpf(Kernel::UIntPtr rsp)
 
 	kIsScheduling = NO;
 
-	kcout << "Kernel: General Protection Fault.\r";
+	kout << "Kernel: General Protection Fault.\r";
 
 	process.Leak().ProcessSignal.SignalArg		= rsp;
 	process.Leak().ProcessSignal.SignalID		= SIGKILL;
 	process.Leak().ProcessSignal.PreviousStatus = process.Leak().Status;
 
-	kcout << "Kernel: SIGKILL status.\r";
+	kout << "Kernel: SIGKILL status.\r";
 
 	process.Leak().Status = Kernel::ProcessStatusKind::kKilled;
 
@@ -46,8 +46,8 @@ EXTERN_C void idt_handle_pf(Kernel::UIntPtr rsp)
 
 	kIsScheduling = NO;
 
-	kcout << "Kernel: Page Fault.\r";
-	kcout << "Kernel: SIGKILL\r";
+	kout << "Kernel: Page Fault.\r";
+	kout << "Kernel: SIGKILL\r";
 
 	process.Leak().ProcessSignal.SignalArg		= rsp;
 	process.Leak().ProcessSignal.SignalID		= SIGKILL;
@@ -74,7 +74,7 @@ EXTERN_C void idt_handle_scheduler(Kernel::UIntPtr rsp)
 	try_count_before_brute = 100000UL;
 	kIsScheduling		   = YES;
 
-	kcout << "Kernel: Timer IRQ (Scheduler Notification).\r";
+	kout << "Kernel: Timer IRQ (Scheduler Notification).\r";
 	Kernel::UserProcessHelper::StartScheduling();
 
 	kIsScheduling = NO;
@@ -91,13 +91,13 @@ EXTERN_C void idt_handle_math(Kernel::UIntPtr rsp)
 
 	kIsScheduling = NO;
 
-	kcout << "Kernel: Math error (division by zero?).\r";
+	kout << "Kernel: Math error (division by zero?).\r";
 
 	process.Leak().ProcessSignal.SignalArg		= rsp;
 	process.Leak().ProcessSignal.SignalID		= SIGKILL;
 	process.Leak().ProcessSignal.PreviousStatus = process.Leak().Status;
 
-	kcout << "Kernel: SIGKILL status.\r";
+	kout << "Kernel: SIGKILL status.\r";
 
 	process.Leak().Status = Kernel::ProcessStatusKind::kKilled;
 
@@ -115,13 +115,13 @@ EXTERN_C void idt_handle_generic(Kernel::UIntPtr rsp)
 
 	kIsScheduling = NO;
 
-	kcout << "Kernel: Generic Process Fault.\r";
+	kout << "Kernel: Generic Process Fault.\r";
 
 	process.Leak().ProcessSignal.SignalArg		= rsp;
 	process.Leak().ProcessSignal.SignalID		= SIGKILL;
 	process.Leak().ProcessSignal.PreviousStatus = process.Leak().Status;
 
-	kcout << "Kernel: SIGKILL status.\r";
+	kout << "Kernel: SIGKILL status.\r";
 
 	process.Leak().Status = Kernel::ProcessStatusKind::kKilled;
 
@@ -137,15 +137,15 @@ EXTERN_C Kernel::Void idt_handle_breakpoint(Kernel::UIntPtr rip)
 
 	kIsScheduling = NO;
 
-	kcout << "Kernel: Process RIP: " << Kernel::hex_number(rip) << endl;
-	kcout << "Kernel: SIGTRAP\r";
+	kout << "Kernel: Process RIP: " << Kernel::hex_number(rip) << endl;
+	kout << "Kernel: SIGTRAP\r";
 
 	process.Leak().ProcessSignal.SignalArg = rip;
 	process.Leak().ProcessSignal.SignalID  = SIGTRAP;
 
 	process.Leak().ProcessSignal.PreviousStatus = process.Leak().Status;
 
-	kcout << "Kernel: SIGKILL status.\r";
+	kout << "Kernel: SIGKILL status.\r";
 
 	process.Leak().Status = Kernel::ProcessStatusKind::kFrozen;
 }
@@ -161,13 +161,13 @@ EXTERN_C void idt_handle_ud(Kernel::UIntPtr rsp)
 
 	kIsScheduling = NO;
 
-	kcout << "Kernel: Undefined Opcode.\r";
+	kout << "Kernel: Undefined Opcode.\r";
 
 	process.Leak().ProcessSignal.SignalArg		= rsp;
 	process.Leak().ProcessSignal.SignalID		= SIGKILL;
 	process.Leak().ProcessSignal.PreviousStatus = process.Leak().Status;
 
-	kcout << "Kernel: SIGKILL status.\r";
+	kout << "Kernel: SIGKILL status.\r";
 
 	process.Leak().Status = Kernel::ProcessStatusKind::kKilled;
 
@@ -181,7 +181,7 @@ EXTERN_C Kernel::Void hal_system_call_enter(Kernel::UIntPtr rcx_syscall_index, K
 {
 	if (rcx_syscall_index < kSyscalls.Count())
 	{
-		kcout << "syscall: Enter Syscall.\r";
+		kout << "syscall: Enter Syscall.\r";
 
 		if (kSyscalls[rcx_syscall_index].fHooked)
 		{
@@ -191,15 +191,15 @@ EXTERN_C Kernel::Void hal_system_call_enter(Kernel::UIntPtr rcx_syscall_index, K
 			}
 			else
 			{
-				kcout << "syscall: syscall isn't valid at all! (is nullptr)\r";
+				kout << "syscall: syscall isn't valid at all! (is nullptr)\r";
 			}
 		}
 		else
 		{
-			kcout << "syscall: syscall isn't hooked at all! (is set to false)\r";
+			kout << "syscall: syscall isn't hooked at all! (is set to false)\r";
 		}
 
-		kcout << "syscall: Exit Syscall.\r";
+		kout << "syscall: Exit Syscall.\r";
 	}
 }
 
@@ -210,7 +210,7 @@ EXTERN_C Kernel::Void hal_kernel_call_enter(Kernel::UIntPtr rcx_kerncall_index,
 {
 	if (rcx_kerncall_index < kKerncalls.Count())
 	{
-		kcout << "kerncall: Enter Kernel Call List.\r";
+		kout << "kerncall: Enter Kernel Call List.\r";
 
 		if (kKerncalls[rcx_kerncall_index].fHooked)
 		{
@@ -220,14 +220,14 @@ EXTERN_C Kernel::Void hal_kernel_call_enter(Kernel::UIntPtr rcx_kerncall_index,
 			}
 			else
 			{
-				kcout << "kerncall: Kernel call isn't valid at all! (is nullptr)\r";
+				kout << "kerncall: Kernel call isn't valid at all! (is nullptr)\r";
 			}
 		}
 		else
 		{
-			kcout << "kerncall: Kernel call isn't hooked at all! (is set to false)\r";
+			kout << "kerncall: Kernel call isn't hooked at all! (is set to false)\r";
 		}
 
-		kcout << "kerncall: Exit Kernel Call List.\r";
+		kout << "kerncall: Exit Kernel Call List.\r";
 	}
 }
diff --git a/dev/Kernel/HALKit/AMD64/HalKernelPanic.cc b/dev/Kernel/HALKit/AMD64/HalKernelPanic.cc
index 9debd114..9ff19744 100644
--- a/dev/Kernel/HALKit/AMD64/HalKernelPanic.cc
+++ b/dev/Kernel/HALKit/AMD64/HalKernelPanic.cc
@@ -81,8 +81,8 @@ namespace Kernel
 	{
 		if (!expr)
 		{
-			kcout << "FAILED: FILE: " << file << endl;
-			kcout << "FAILED: LINE: " << line << endl;
+			kout << "FAILED: FILE: " << file << endl;
+			kout << "FAILED: LINE: " << line << endl;
 
 			ke_panic(RUNTIME_CHECK_FAILED, file); // Runtime Check failed
 		}
diff --git a/dev/Kernel/HALKit/AMD64/HalPagingMgrAMD64.cc b/dev/Kernel/HALKit/AMD64/HalPagingMgrAMD64.cc
index dcc563ae..5c9d221c 100644
--- a/dev/Kernel/HALKit/AMD64/HalPagingMgrAMD64.cc
+++ b/dev/Kernel/HALKit/AMD64/HalPagingMgrAMD64.cc
@@ -56,10 +56,10 @@ namespace Kernel::HAL
 	/***********************************************************************************/
 	STATIC Void mmi_page_status(PTE* pte)
 	{
-		kcout << (pte->Present ? "Present" : "Not Present") << endl;
-		kcout << (pte->Wr ? "W/R" : "Not W/R") << endl;
-		kcout << (pte->ExecDisable ? "NX" : "Not NX") << endl;
-		kcout << (pte->User ? "User" : "Not User") << endl;
+		kout << (pte->Present ? "Present" : "Not Present") << endl;
+		kout << (pte->Wr ? "W/R" : "Not W/R") << endl;
+		kout << (pte->ExecDisable ? "NX" : "Not NX") << endl;
+		kout << (pte->User ? "User" : "Not User") << endl;
 	}
 
 	STATIC Int32 mmi_map_page_table_entry(VoidPtr virtual_address, UInt32 flags, NE_PTE* pt_entry, NE_PDE* pd_entry);
diff --git a/dev/Kernel/HALKit/AMD64/PCI/DMA.cc b/dev/Kernel/HALKit/AMD64/PCI/DMA.cc
index 6e944aad..1b54ad30 100644
--- a/dev/Kernel/HALKit/AMD64/PCI/DMA.cc
+++ b/dev/Kernel/HALKit/AMD64/PCI/DMA.cc
@@ -25,7 +25,7 @@ namespace Kernel
 		if (offset == 0)
 			return true;
 
-		kcout << "[DMAWrapper::IsIn] Checking offset..\n";
+		kout << "[DMAWrapper::IsIn] Checking offset..\n";
 		return reinterpret_cast<UIntPtr>(fAddress) >= offset;
 	}
 
@@ -34,7 +34,7 @@ namespace Kernel
 		if (!fAddress)
 			return false;
 
-		kcout << "[DMAWrapper::Write] Writing at address..\n";
+		kout << "[DMAWrapper::Write] Writing at address..\n";
 
 		auto addr =
 			(volatile UIntPtr*)(reinterpret_cast<UIntPtr>(fAddress) + offset);
@@ -45,11 +45,11 @@ namespace Kernel
 
 	UIntPtr DMAWrapper::Read(const UIntPtr& offset)
 	{
-		kcout << "[DMAWrapper::Read] checking fAddress..\n";
+		kout << "[DMAWrapper::Read] checking fAddress..\n";
 		if (!fAddress)
 			return 0;
 
-		kcout << "[DMAWrapper::Read] Reading fAddress..\n";
+		kout << "[DMAWrapper::Read] Reading fAddress..\n";
 		return *(volatile UIntPtr*)(reinterpret_cast<UIntPtr>(fAddress) + offset);
 		;
 	}
@@ -70,7 +70,7 @@ namespace Kernel
 		if (!dmaOwnPtr)
 			return {};
 
-		kcout << "Returning the new OwnPtr<IOBuf<Char*>>!\r";
+		kout << "Returning the new OwnPtr<IOBuf<Char*>>!\r";
 		return dmaOwnPtr;
 	}
 
diff --git a/dev/Kernel/HALKit/AMD64/Storage/ATA.cc b/dev/Kernel/HALKit/AMD64/Storage/ATA.cc
index 697d08e9..dcb6d816 100644
--- a/dev/Kernel/HALKit/AMD64/Storage/ATA.cc
+++ b/dev/Kernel/HALKit/AMD64/Storage/ATA.cc
@@ -75,7 +75,7 @@ Boolean drv_std_init(UInt16 Bus, UInt8 Drive, UInt16& OutBus, UInt8& OutMaster)
 		;
 	if (!timeout)
 	{
-		kcout << "Timeout waiting for drive to become ready...\r";
+		kout << "Timeout waiting for drive to become ready...\r";
 		return false;
 	}
 
@@ -89,7 +89,7 @@ Boolean drv_std_init(UInt16 Bus, UInt8 Drive, UInt16& OutBus, UInt8& OutMaster)
 	UInt8 status = rt_in8(IO + ATA_REG_STATUS);
 	if (status & ATA_SR_ERR)
 	{
-		kcout << "ATA Error, aborting...\r";
+		kout << "ATA Error, aborting...\r";
 		return false;
 	}
 
@@ -107,7 +107,7 @@ Boolean drv_std_init(UInt16 Bus, UInt8 Drive, UInt16& OutBus, UInt8& OutMaster)
 	// Step 7: Check if the drive supports DMA
 	if (!(kATAData[63] & (1 << 8)) || !(kATAData[88] & 0xFF))
 	{
-		kcout << "No DMA support...\r";
+		kout << "No DMA support...\r";
 		ke_panic(RUNTIME_CHECK_BOOTSTRAP, "No DMA support on necessary disk driver.");
 
 		return false;
@@ -123,7 +123,7 @@ Boolean drv_std_init(UInt16 Bus, UInt8 Drive, UInt16& OutBus, UInt8& OutMaster)
 		;
 	if (!timeout)
 	{
-		kcout << "DMA Initialization Timeout...\r";
+		kout << "DMA Initialization Timeout...\r";
 		return false;
 	}
 #endif // __ATA_DMA__
diff --git a/dev/Kernel/HALKit/AMD64/Storage/SATA.cc b/dev/Kernel/HALKit/AMD64/Storage/SATA.cc
index 42d33783..16aef2e2 100644
--- a/dev/Kernel/HALKit/AMD64/Storage/SATA.cc
+++ b/dev/Kernel/HALKit/AMD64/Storage/SATA.cc
@@ -15,6 +15,7 @@
  *
  */
 
+#include "NewKit/Defines.h"
 #include <KernelKit/UserProcessScheduler.h>
 #include <KernelKit/LPC.h>
 
@@ -37,14 +38,11 @@
 #define kAhciSRBsy (0x80)
 #define kAhciSRDrq (0x08)
 
-#define kAhciPortCnt 32
+#define kAhciPortCnt (0x20)
 
-enum
-{
-	kSATAProgIfAHCI = 0x01,
-	kSATASubClass	= 0x06,
-	kSATABar5		= 0x24,
-};
+#define kSATAProgIfAHCI (0x01)
+#define kSATASubClass	(0x06)
+#define kSATABar5		(0x24)
 
 STATIC Kernel::PCI::Device kPCIDevice;
 STATIC HbaMem* kSATAPort				   = nullptr;
@@ -68,8 +66,8 @@ static Kernel::Void drv_calculate_disk_geometry() noexcept
 
 	kCurrentDiskSectorCount = (identify_data[61] << 16) | identify_data[60];
 
-	kcout << "Disk Size: " << Kernel::number(drv_get_size()) << endl;
-	kcout << "Highest Disk LBA: " << Kernel::number(kCurrentDiskSectorCount) << endl;
+	kout << "Disk Size: " << Kernel::number(drv_get_size()) << endl;
+	kout << "Highest Disk LBA: " << Kernel::number(kCurrentDiskSectorCount) << endl;
 }
 
 /// @brief Initializes an AHCI disk.
@@ -108,14 +106,14 @@ Kernel::Boolean drv_std_init(Kernel::UInt16& PortsImplemented)
 			{
 				if (ports_implemented)
 				{
-					kcout << "Port is implemented.\r";
+					kout << "Port is implemented.\r";
 
 					Kernel::UInt8 ipm = (mem_ahci->Ports[ahci_index].Ssts >> 8) & 0x0F;
 					Kernel::UInt8 det = mem_ahci->Ports[ahci_index].Ssts & 0x0F;
 
 					if (mem_ahci->Ports[ahci_index].Sig == kSATASignature && det == 3 && ipm == 1)
 					{
-						kcout << "Port is implemented as SATA.\r";
+						kout << "Port is implemented as SATA.\r";
 
 						kSATAPortIdx = ahci_index;
 						kSATAPort	 = mem_ahci;
@@ -219,11 +217,6 @@ static Kernel::Int32 drv_find_cmd_slot(HbaPort* port) noexcept
 template <BOOL Write, BOOL CommandOrCTRL, BOOL Identify>
 static Kernel::Void drv_std_input_output(Kernel::UInt64 lba, Kernel::UInt8* buffer, Kernel::SizeT sector_sz, Kernel::SizeT size_buffer) noexcept
 {
-	if (!CommandOrCTRL)
-		return;
-
-	kSATAPort->Ports[kSATAPortIdx].Is = -1;
-
 	auto slot = 0L;
 
 	slot = drv_find_cmd_slot(&kSATAPort->Ports[kSATAPortIdx]);
@@ -231,46 +224,50 @@ static Kernel::Void drv_std_input_output(Kernel::UInt64 lba, Kernel::UInt8* buff
 	if (slot == -1)
 		return;
 
-	volatile HbaCmdHeader* command_header = ((volatile HbaCmdHeader*)((Kernel::UInt64)kSATAPort->Ports[kSATAPortIdx].Clb + kSATAPort->Ports[kSATAPortIdx].Clbu));
+	HbaCmdHeader* command_header = ((HbaCmdHeader*)((Kernel::UInt64)kSATAPort->Ports[kSATAPortIdx].Clb + kSATAPort->Ports[kSATAPortIdx].Clbu));
 
-	command_header += slot;
+	Kernel::rt_set_memory(reinterpret_cast<Kernel::VoidPtr>(command_header), 0, sizeof(HbaCmdHeader));
 
 	MUST_PASS(command_header);
 
 	command_header->Cfl	  = sizeof(FisRegH2D) / sizeof(Kernel::UInt32);
 	command_header->Write = Write;
-	command_header->Prdtl = (Kernel::UInt16)((size_buffer - 1) >> 4) + 1;
+	command_header->Prdtl = 1;
+
+	HbaCmdTbl* command_table = new HbaCmdTbl();
 
-	volatile HbaCmdTbl* command_table = (volatile HbaCmdTbl*)((Kernel::UInt64)command_header->Ctba + command_header->Ctbau);
+	Kernel::rt_set_memory(reinterpret_cast<Kernel::VoidPtr>(command_table), 0, sizeof(HbaCmdTbl));
 
 	MUST_PASS(command_table);
 
-	for (Kernel::SizeT i = 0; i < (command_header->Prdtl - 1); i++)
-	{
-		command_table->PrdtEntries[i].Dba		   = ((Kernel::UInt32)(Kernel::UInt64)buffer & 0xFFFFFFFF);
-		command_table->PrdtEntries[i].Dbau		   = (((Kernel::UInt64)buffer >> 32) & 0xFFFFFFFF);
-		command_table->PrdtEntries[i].Dbc		   = (size_buffer - 1);
-		command_table->PrdtEntries[i].InterruptBit = YES;
+	command_table->Prdt[0].Dba			= ((Kernel::UInt32)(Kernel::UInt64)buffer);
+	command_table->Prdt[0].Dbau			= (((Kernel::UInt64)buffer >> 32));
+	command_table->Prdt[0].Dbc			= ((size_buffer)-1);
+	command_table->Prdt[0].InterruptBit = 1;
 
-		size_buffer -= 16;
-		buffer += kib_cast(4);
-	}
+	command_header->Ctba  = ((Kernel::UInt32)(Kernel::UInt64)command_table);
+	command_header->Ctbau = ((Kernel::UInt32)((Kernel::UInt64)command_table >> 32));
 
-	volatile FisRegH2D* h2d_fis = (volatile FisRegH2D*)((Kernel::UInt64)command_table->Cfis);
+	FisRegH2D* h2d_fis = (FisRegH2D*)((Kernel::UInt64)command_table->Cfis);
 
-	h2d_fis->FisType = kFISTypeRegH2D;
+	Kernel::rt_set_memory(reinterpret_cast<Kernel::VoidPtr>(h2d_fis), 0, sizeof(FisRegH2D));
 
+	h2d_fis->FisType   = kFISTypeRegH2D;
 	h2d_fis->CmdOrCtrl = CommandOrCTRL;
-
-	h2d_fis->Command = Write ? kAHCICmdWriteDmaEx : kAHCICmdReadDmaEx;
+	h2d_fis->Command   = Write ? kAHCICmdWriteDmaEx : kAHCICmdReadDmaEx;
 
 	if (Identify)
 		h2d_fis->Command = kAHCICmdIdentify;
 
-	h2d_fis->Lba0 = lba;
-	h2d_fis->Lba1 = lba >> 8;
-	h2d_fis->Lba2 = lba >> 16;
-	h2d_fis->Lba3 = lba >> 24;
+	h2d_fis->FeatureLow = h2d_fis->FeatureLow | 1;
+	h2d_fis->FeatureLow = h2d_fis->FeatureLow | (1 << 2);
+
+	h2d_fis->Lba0 = (lba & 0xFF);
+	h2d_fis->Lba1 = (lba >> 8) & 0xFF;
+	h2d_fis->Lba2 = (lba >> 16) & 0xFF;
+	h2d_fis->Lba3 = (lba >> 24) & 0xFF;
+	h2d_fis->Lba4 = (lba >> 32) & 0xFF;
+	h2d_fis->Lba5 = (lba >> 40) & 0xFF;
 
 	h2d_fis->Device = kSataLBAMode;
 
@@ -281,25 +278,39 @@ static Kernel::Void drv_std_input_output(Kernel::UInt64 lba, Kernel::UInt8* buff
 
 	while ((kSATAPort->Ports[kSATAPortIdx].Tfd & (kAhciSRBsy | kAhciSRDrq)))
 	{
-		kcout << "Waiting for slot to be ready...\r\n";
+		kout << "Waiting for the tfd to be ready...\r";
 	}
 
 	if (kSATAPort->Is & kHBAErrTaskFile)
 		Kernel::ke_panic(RUNTIME_CHECK_BAD_BEHAVIOR, "AHCI Read disk failure, faulty component.");
 
-	// send fis/cmdtbl/cmdhdr.
-	kSATAPort->Ports[kSATAPortIdx].Ci = 1 << slot;
+	FisRegD2H* d2h_fis = new FisRegD2H();
 
-	while (kSATAPort->Ports[kSATAPortIdx].Ci & (1 << slot))
-		;
+	kSATAPort->Ports[kSATAPortIdx].Fb = (Kernel::UInt32)((Kernel::UInt64)d2h_fis);
+	kSATAPort->Ports[kSATAPortIdx].Fbu = (Kernel::UInt32)((Kernel::UInt64)d2h_fis >> 32);
+
+	kSATAPort->Ports[kSATAPortIdx].Ci = (1 << slot);
+
+	while (YES)
+	{
+		if ((kSATAPort->Ports[kSATAPortIdx].Ci & (1 << slot)) == 0)
+			break;
+
+		if (kSATAPort->Is & kHBAErrTaskFile)
+			Kernel::ke_panic(RUNTIME_CHECK_BAD_BEHAVIOR, "AHCI Read disk failure, faulty component.");
+
+		kout << "Waiting for the slot to be ready...\r";
+		kout << "CI: " << Kernel::hex_number(kSATAPort->Ports[kSATAPortIdx].Ci) << endl;
+		kout << "TFD: " << Kernel::hex_number(kSATAPort->Ports[kSATAPortIdx].Tfd) << endl;
+	}
 
 	while ((kSATAPort->Ports[kSATAPortIdx].Tfd & (kAhciSRBsy | kAhciSRDrq)))
 	{
-		kcout << "Waiting for slot to be ready...\r\n";
+		kout << "Waiting for the tfd to be ready...\r";
 	}
 
-	if (kSATAPort->Is & kHBAErrTaskFile)
-		Kernel::ke_panic(RUNTIME_CHECK_BAD_BEHAVIOR, "AHCI Read disk failure, faulty component.");
+	delete command_table;
+	command_table = nullptr;
 }
 
 /***
diff --git a/dev/Kernel/HALKit/ARM64/HalApplicationProcessor.cc b/dev/Kernel/HALKit/ARM64/HalApplicationProcessor.cc
index c176d36a..c2bea7e3 100644
--- a/dev/Kernel/HALKit/ARM64/HalApplicationProcessor.cc
+++ b/dev/Kernel/HALKit/ARM64/HalApplicationProcessor.cc
@@ -78,7 +78,7 @@ namespace Kernel
 			// Enable interrupt 32 for AP.

 			HAL::hal_mmio_write(GICD_BASE + GICD_ISENABLER + (32 / 32) * 4, 0x01 << (32 % 32));

 

-			kcout << "AP's GIC configured in ISR 32." << endl;

+			kout << "AP's GIC configured in ISR 32." << endl;

 		}

 

 		BOOL mp_handle_gic_interrupt_el0(Void)

@@ -89,7 +89,7 @@ namespace Kernel
 			// Check if it's a valid interrupt (not spurious)

 			if ((interrupt_id & 0x3FF) < 1020)

 			{

-				kcout << "Handling interrupt for AP: " << (interrupt_id & 0x3FF) << endl;

+				kout << "Handling interrupt for AP: " << (interrupt_id & 0x3FF) << endl;

 

 				// TODO: Handle code here.

 

diff --git a/dev/Kernel/HALKit/ARM64/HalKernelPanic.cc b/dev/Kernel/HALKit/ARM64/HalKernelPanic.cc
index a2ab0628..d7884682 100644
--- a/dev/Kernel/HALKit/ARM64/HalKernelPanic.cc
+++ b/dev/Kernel/HALKit/ARM64/HalKernelPanic.cc
@@ -71,8 +71,8 @@ namespace Kernel
 	{
 		if (!expr)
 		{
-			kcout << "FAILED: FILE: " << file << endl;
-			kcout << "FAILED: LINE: " << line << endl;
+			kout << "FAILED: FILE: " << file << endl;
+			kout << "FAILED: LINE: " << line << endl;
 
 			ke_panic(RUNTIME_CHECK_FAILED, file); // Runtime Check failed
 		}
diff --git a/dev/Kernel/HALKit/ARM64/Storage/MFlash+IO.cc b/dev/Kernel/HALKit/ARM64/Storage/MFlash+IO.cc
index 30e7cef0..2abf04b5 100644
--- a/dev/Kernel/HALKit/ARM64/Storage/MFlash+IO.cc
+++ b/dev/Kernel/HALKit/ARM64/Storage/MFlash+IO.cc
@@ -62,7 +62,7 @@ namespace Kernel
 
 		kFlashMetaPackets[slot]->InterruptEnable = YES;
 
-		kcout << "Enabled hardware slot at: " << number(slot) << endl;
+		kout << "Enabled hardware slot at: " << number(slot) << endl;
 
 		return YES;
 	}
@@ -75,7 +75,7 @@ namespace Kernel
 
 		kFlashMetaPackets[slot]->InterruptEnable = NO;
 
-		kcout << "Disabled hardware slot at: " << number(slot) << endl;
+		kout << "Disabled hardware slot at: " << number(slot) << endl;
 
 		return YES;
 	}
diff --git a/dev/Kernel/HALKit/AXP/CoreSyscallHandlerDEC.cpp b/dev/Kernel/HALKit/AXP/CoreSyscallHandlerDEC.cpp
index f9b67177..233bc5e0 100644
--- a/dev/Kernel/HALKit/AXP/CoreSyscallHandlerDEC.cpp
+++ b/dev/Kernel/HALKit/AXP/CoreSyscallHandlerDEC.cpp
@@ -14,11 +14,11 @@ EXTERN_C void rt_syscall_handle(Kernel::HAL::StackFrame* stack)
 {
 	if (stack->Rcx <= (kSyscalls.Count() - 1))
 	{
-		kcout << "syscall: enter.\r";
+		kout << "syscall: enter.\r";
 
 		if (kSyscalls[stack->Rcx].Leak().Leak().fHooked)
 			(kSyscalls[stack->Rcx].Leak().Leak().fProc)(stack);
 
-		kcout << "syscall: exit.\r";
+		kout << "syscall: exit.\r";
 	}
 }