kernel: Refactor AHCI I/O path, enhance memory allocators, and cleanup obsolete script

- Removed unused `build_gcc.sh` script.
- Namespaced CPU feature flags under `NeOS` and transitioned from enum to unnamed enum for scoping.
- Renamed `drv_std_input_output` to `drv_std_input_output_ahci` for clarity.
- Improved AHCI driver documentation and added zeroing for read buffers.
- Added optional `pad` parameter to memory allocators: `mm_alloc_bitmap`, `mm_new_heap`, `PageMgr::Request`, etc.
- Updated bitmap allocator to correctly handle and align with padded sizes.
- Added `fPad` field to memory header block.
- Fixed `ATA-DMA` mode comment, corrected PRD usage and logic.
- Improved code documentation and formatting in `UserProcessScheduler`, `PageMgr`, and related components.
- Enhanced safety in process memory cleanup (e.g., `StackReserve` cleanup).

Signed-off-by: Amlal El Mahrouss <amlal@nekernel.org>

5 files changed, 63 insertions, 38 deletions

diff --git a/dev/kernel/src/BitMapMgr.cc b/dev/kernel/src/BitMapMgr.cc
index 18b1a156..f65df8c6 100644
--- a/dev/kernel/src/BitMapMgr.cc
+++ b/dev/kernel/src/BitMapMgr.cc
@@ -28,7 +28,9 @@ namespace NeOS
 	{
 		namespace Detail
 		{
-			/// \brief Proxy Interface to allocate a bitmap.
+			/***********************************************************************************/
+			/// \brief Proxy Interface to manage a bitmap allocator.
+			/***********************************************************************************/
 			class IBitMapProxy final
 			{
 			public:
@@ -79,27 +81,36 @@ namespace NeOS
 					return flags;
 				}
 
-				/// @brief Iterate over availables pages for a free one.
-				/// @return The new address which was found.
-				auto FindBitMap(VoidPtr base_ptr, SizeT size, Bool wr, Bool user) -> VoidPtr
+				/***********************************************************************************/
+				/// @brief Iterate over availables bitmap, until we find a free entry.
+				/// @param base_ptr base pointer to look on.
+				/// @param size the size of the requested data structure.
+				/// @param wr is writable flag?
+				/// @param user is user flag?
+				/// @param pad additional padding added to **size**
+				/// @return The new free address, or nullptr.
+				/***********************************************************************************/
+				auto FindBitMap(VoidPtr base_ptr, const SizeT size, const Bool wr, const Bool user, const SizeT pad) -> VoidPtr
 				{
 					if (!size)
 						return nullptr;
 
-					VoidPtr base = reinterpret_cast<VoidPtr>(((UIntPtr)base_ptr) + kPageSize);
+					constexpr const UInt32 kStartOffset = 0x1000;
 
-					static SizeT biggest_block = 0UL;
+					VoidPtr base = reinterpret_cast<VoidPtr>(((UIntPtr)base_ptr) + kStartOffset);
+
+					static SizeT biggest = 0UL;
 
 					while (YES)
 					{
 						UIntPtr* ptr_bit_set = reinterpret_cast<UIntPtr*>(base);
 
 						if (ptr_bit_set[kBitMapMagIdx] == kBitMapMagic &&
-							ptr_bit_set[kBitMapSizeIdx] == size)
+							ptr_bit_set[kBitMapSizeIdx] == (size + pad))
 						{
 							if (ptr_bit_set[kBitMapUsedIdx] == No)
 							{
-								ptr_bit_set[kBitMapSizeIdx] = size;
+								ptr_bit_set[kBitMapSizeIdx] = size + pad;
 								ptr_bit_set[kBitMapUsedIdx] = Yes;
 
 								this->GetBitMapStatus(ptr_bit_set);
@@ -107,8 +118,8 @@ namespace NeOS
 								UInt32 flags = this->MakeMMFlags(wr, user);
 								mm_map_page(ptr_bit_set, ptr_bit_set, flags);
 
-								if (biggest_block < size)
-									biggest_block = size;
+								if (biggest < (size + pad))
+									biggest = size + pad;
 
 								return (VoidPtr)ptr_bit_set;
 							}
@@ -116,7 +127,7 @@ namespace NeOS
 						else if (ptr_bit_set[kBitMapMagIdx] != kBitMapMagic)
 						{
 							ptr_bit_set[kBitMapMagIdx]	= kBitMapMagic;
-							ptr_bit_set[kBitMapSizeIdx] = size;
+							ptr_bit_set[kBitMapSizeIdx] = (size + pad);
 							ptr_bit_set[kBitMapUsedIdx] = Yes;
 
 							this->GetBitMapStatus(ptr_bit_set);
@@ -124,13 +135,13 @@ namespace NeOS
 							UInt32 flags = this->MakeMMFlags(wr, user);
 							mm_map_page(ptr_bit_set, ptr_bit_set, flags);
 
-							if (biggest_block < size)
-								biggest_block = size;
+							if (biggest < (size + pad))
+								biggest = (size + pad);
 
 							return (VoidPtr)ptr_bit_set;
 						}
 
-						base = reinterpret_cast<VoidPtr>(reinterpret_cast<UIntPtr>(base) + ((ptr_bit_set[kBitMapMagIdx] != kBitMapMagic) ? (size) : ptr_bit_set[kBitMapSizeIdx]));
+						base = reinterpret_cast<VoidPtr>(reinterpret_cast<UIntPtr>(base) + ((ptr_bit_set[kBitMapMagIdx] != kBitMapMagic) ? (size + pad) : ptr_bit_set[kBitMapSizeIdx]));
 					}
 
 					return nullptr;
@@ -145,42 +156,46 @@ namespace NeOS
 						return;
 					}
 
-					kout << "Magic Number: " << hex_number(ptr_bit_set[kBitMapMagIdx]) << kendl;
-					kout << "Is Allocated: " << (ptr_bit_set[kBitMapUsedIdx] ? "Yes" : "No") << kendl;
+					kout << "Magic: " << hex_number(ptr_bit_set[kBitMapMagIdx]) << kendl;
+					kout << "Is Allocated? " << (ptr_bit_set[kBitMapUsedIdx] ? "YES" : "NO") << kendl;
 					kout << "Size of BitMap (B): " << number(ptr_bit_set[kBitMapSizeIdx]) << kendl;
 					kout << "Size of BitMap (KIB): " << number(KIB(ptr_bit_set[kBitMapSizeIdx])) << kendl;
 					kout << "Size of BitMap (MIB): " << number(MIB(ptr_bit_set[kBitMapSizeIdx])) << kendl;
 					kout << "Size of BitMap (GIB): " << number(GIB(ptr_bit_set[kBitMapSizeIdx])) << kendl;
 					kout << "Size of BitMap (TIB): " << number(TIB(ptr_bit_set[kBitMapSizeIdx])) << kendl;
-					kout << "Address Of BitMap Header: " << hex_number((UIntPtr)ptr_bit_set) << kendl;
+					kout << "BitMap Address: " << hex_number((UIntPtr)ptr_bit_set) << kendl;
 				}
 			};
 		} // namespace Detail
 
-		auto mm_is_bitmap(VoidPtr ptr) -> Bool
+		auto mm_is_bitmap(VoidPtr ptr) -> BOOL
 		{
 			Detail::IBitMapProxy bitmp;
 			return bitmp.IsBitMap(ptr);
 		}
 
+		/***********************************************************************************/
 		/// @brief Allocate a new page to be used by the OS.
 		/// @param wr read/write bit.
 		/// @param user user bit.
 		/// @return a new bitmap allocated pointer.
-		auto mm_alloc_bitmap(Boolean wr, Boolean user, SizeT size, Bool is_page) -> VoidPtr
+		/***********************************************************************************/
+		auto mm_alloc_bitmap(Boolean wr, Boolean user, SizeT size, Bool is_page, const SizeT pad) -> VoidPtr
 		{
 			VoidPtr				 ptr_new = nullptr;
 			Detail::IBitMapProxy bitmp;
 
-			ptr_new = bitmp.FindBitMap(kKernelBitMpStart, size, wr, user);
+			ptr_new = bitmp.FindBitMap(kKernelBitMpStart, size, wr, user, pad);
 
 			MUST_PASS(ptr_new);
 
 			return (UIntPtr*)ptr_new;
 		}
 
+		/***********************************************************************************/
 		/// @brief Free Bitmap, and mark it as absent.
 		/// @param ptr the pointer to free.
+		/***********************************************************************************/
 		auto mm_free_bitmap(VoidPtr ptr) -> Bool
 		{
 			if (!ptr)
diff --git a/dev/kernel/src/MemoryMgr.cc b/dev/kernel/src/MemoryMgr.cc
index 7a79b906..271dfa23 100644
--- a/dev/kernel/src/MemoryMgr.cc
+++ b/dev/kernel/src/MemoryMgr.cc
@@ -67,6 +67,9 @@ namespace NeOS
 			/// @brief 64-bit target offset pointer.
 			UIntPtr fOffset;
 
+			/// @brief Padding.
+			UInt32 fPad;
+
 			/// @brief Padding bytes for header.
 			UInt8 fPadding[kMemoryMgrAlignSz];
 		};
@@ -116,7 +119,7 @@ namespace NeOS
 	/// @param wr Read Write bit.
 	/// @param user User enable bit.
 	/// @return The newly allocated pointer.
-	_Output VoidPtr mm_new_heap(const SizeT sz, const bool wr, const bool user)
+	_Output VoidPtr mm_new_heap(const SizeT sz, const Bool wr, const Bool user, const SizeT pad_amount)
 	{
 		auto sz_fix = sz;
 
@@ -126,7 +129,7 @@ namespace NeOS
 		sz_fix += sizeof(Detail::MM_INFORMATION_BLOCK);
 
 		PageMgr heap_mgr;
-		auto	wrapper = heap_mgr.Request(wr, user, No, sz_fix);
+		auto	wrapper = heap_mgr.Request(wr, user, No, sz_fix, pad_amount);
 
 		Detail::MM_INFORMATION_BLOCK_PTR heap_info_ptr =
 			reinterpret_cast<Detail::MM_INFORMATION_BLOCK_PTR>(
@@ -140,6 +143,7 @@ namespace NeOS
 		heap_info_ptr->fWriteRead = wr;
 		heap_info_ptr->fUser	  = user;
 		heap_info_ptr->fPresent	  = Yes;
+		heap_info_ptr->fPad		  = pad_amount;
 
 		rt_set_memory(heap_info_ptr->fPadding, 0, kMemoryMgrAlignSz);
 
@@ -232,6 +236,7 @@ namespace NeOS
 			heap_info_ptr->fWriteRead = No;
 			heap_info_ptr->fUser	  = No;
 			heap_info_ptr->fMagic	  = 0;
+			heap_info_ptr->fPad		  = 0;
 
 			kout << "Address has been successfully freed: " << hex_number((UIntPtr)heap_info_ptr) << kendl;
 
diff --git a/dev/kernel/src/PageMgr.cc b/dev/kernel/src/PageMgr.cc
index eb7c7e03..6a8622ed 100644
--- a/dev/kernel/src/PageMgr.cc
+++ b/dev/kernel/src/PageMgr.cc
@@ -57,10 +57,10 @@ namespace NeOS
 	/// @param User user mode?
 	/// @param ExecDisable disable execution on page?
 	/// @return
-	PTEWrapper PageMgr::Request(Boolean Rw, Boolean User, Boolean ExecDisable, SizeT Sz)
+	PTEWrapper PageMgr::Request(Boolean Rw, Boolean User, Boolean ExecDisable, SizeT Sz, SizeT Pad)
 	{
 		// Store PTE wrapper right after PTE.
-		VoidPtr ptr = NeOS::HAL::mm_alloc_bitmap(Rw, User, Sz, false);
+		VoidPtr ptr = NeOS::HAL::mm_alloc_bitmap(Rw, User, Sz, NO, Pad);
 
 		return PTEWrapper{Rw, User, ExecDisable, reinterpret_cast<UIntPtr>(ptr)};
 	}
diff --git a/dev/kernel/src/Pmm.cc b/dev/kernel/src/Pmm.cc
index b3d5e79e..a5ba0dcd 100644
--- a/dev/kernel/src/Pmm.cc
+++ b/dev/kernel/src/Pmm.cc
@@ -23,7 +23,7 @@ namespace NeOS
 	Pmm::Pmm()
 		: fPageMgr()
 	{
-		kout << "[PMM] Allocate PageMemoryMgr";
+		kout << "[PMM] Allocate PageMemoryMgr.\r";
 	}
 
 	Pmm::~Pmm() = default;
@@ -35,7 +35,7 @@ namespace NeOS
 	/***********************************************************************************/
 	Ref<PTEWrapper> Pmm::RequestPage(Boolean user, Boolean readWrite)
 	{
-		PTEWrapper pt = fPageMgr.Leak().Request(user, readWrite, false, kPageSize);
+		PTEWrapper pt = fPageMgr.Leak().Request(user, readWrite, false, kPageSize, 0);
 
 		if (pt.fPresent)
 		{
diff --git a/dev/kernel/src/UserProcessScheduler.cc b/dev/kernel/src/UserProcessScheduler.cc
index 19861dbe..98abe13c 100644
--- a/dev/kernel/src/UserProcessScheduler.cc
+++ b/dev/kernel/src/UserProcessScheduler.cc
@@ -111,11 +111,11 @@ namespace NeOS
 		auto vm_register = hal_read_cr3();
 		hal_write_cr3(this->VMRegister);
 
-		auto ptr = mm_new_heap(sz + pad_amount, Yes, Yes);
+		auto ptr = mm_new_heap(sz, Yes, Yes, pad_amount);
 
 		hal_write_cr3(vm_register);
 #else
-		auto ptr = mm_new_heap(sz + pad_amount, Yes, Yes);
+		auto ptr = mm_new_heap(sz, Yes, Yes, pad_amount);
 #endif
 
 		if (!this->ProcessMemoryHeap)
@@ -238,15 +238,23 @@ namespace NeOS
 		if (this->Image.fCode && mm_is_valid_heap(this->Image.fCode))
 			mm_delete_heap(this->Image.fCode);
 
+		//! Delete blob too.
 		if (this->Image.fBlob && mm_is_valid_heap(this->Image.fBlob))
 			mm_delete_heap(this->Image.fBlob);
 
+		//! Delete stack frame.
 		if (this->StackFrame && mm_is_valid_heap(this->StackFrame))
 			mm_delete_heap((VoidPtr)this->StackFrame);
 
-		this->Image.fBlob = nullptr;
-		this->Image.fCode = nullptr;
-		this->StackFrame  = nullptr;
+		//! Delete stack reserve.
+		if (this->StackReserve && mm_is_valid_heap(this->StackReserve))
+			mm_delete_heap(reinterpret_cast<VoidPtr>(this->StackReserve));
+
+		//! Avoid use after free.
+		this->Image.fBlob  = nullptr;
+		this->Image.fCode  = nullptr;
+		this->StackFrame   = nullptr;
+		this->StackReserve = nullptr;
 
 		if (this->Kind == kExectuableDylibKind)
 		{
@@ -262,10 +270,7 @@ namespace NeOS
 			this->DylibDelegate = nullptr;
 		}
 
-		if (this->StackReserve)
-			mm_delete_heap(reinterpret_cast<VoidPtr>(this->StackReserve));
-
-		this->ProcessId = 0;
+		this->ProcessId = 0UL;
 		this->Status	= ProcessStatusKind::kFinished;
 
 		--this->ProcessParentTeam->mProcessCount;
@@ -311,7 +316,7 @@ namespace NeOS
 		flags |= HAL::kMMFlagsUser;
 
 		HAL::mm_map_page((VoidPtr)process.VMRegister, process.VMRegister, flags);
-#endif // __NE_VIRTUAL_MEMORY_SUPPORT__
+#endif // ifdef __NE_VIRTUAL_MEMORY_SUPPORT__
 
 		process.StackFrame = new HAL::StackFrame();
 
@@ -327,7 +332,7 @@ namespace NeOS
 		flags |= HAL::kMMFlagsUser;
 
 		HAL::mm_map_page((VoidPtr)process.StackFrame, process.StackFrame, flags);
-#endif // __NE_VIRTUAL_MEMORY_SUPPORT__
+#endif // ifdef __NE_VIRTUAL_MEMORY_SUPPORT__
 
 		// React according to process kind.
 		switch (process.Kind)
@@ -357,7 +362,7 @@ namespace NeOS
 		flags |= HAL::kMMFlagsUser;
 
 		HAL::mm_map_page((VoidPtr)process.StackReserve, process.StackReserve, flags);
-#endif // __NE_VIRTUAL_MEMORY_SUPPORT__
+#endif // ifdef __NE_VIRTUAL_MEMORY_SUPPORT__
 
 		process.ProcessParentTeam = &mTeam;