diff options
31 files changed, 303 insertions, 253 deletions
diff --git a/Private/ArchKit/ArchKit.hpp b/Private/ArchKit/ArchKit.hpp index d7c52108..f4654012 100644 --- a/Private/ArchKit/ArchKit.hpp +++ b/Private/ArchKit/ArchKit.hpp @@ -44,9 +44,4 @@ extern NewOS::Array<rt_syscall_proc, EXTERN_C NewOS::HAL::StackFramePtr rt_get_current_context(); EXTERN_C NewOS::Void rt_do_context_switch(NewOS::HAL::StackFramePtr stackFrame); -inline NewOS::VoidPtr kKernelVirtualStart; -inline NewOS::UIntPtr kKernelVirtualSize; - -inline NewOS::VoidPtr kKernelPhysicalStart; - #include <FirmwareKit/Handover.hxx> diff --git a/Private/FSKit/NewFS.hxx b/Private/FSKit/NewFS.hxx index f66d7afb..1f27089d 100644 --- a/Private/FSKit/NewFS.hxx +++ b/Private/FSKit/NewFS.hxx @@ -187,7 +187,7 @@ enum { kNewFSRsrcForkKind = 0, kNewFSDataForkKind = 1 }; /// forks...) Designed like the DOM, detects the filesystem automatically. /// -class NewFSParser { +class NewFSParser final { public: explicit NewFSParser() = default; ~NewFSParser() = default; @@ -210,32 +210,32 @@ class NewFSParser { _Output NewFork* FindFork(_Input NewCatalog* catalog, _Input const Char* name, Boolean dataOrRsrc); - virtual _Output Void RemoveFork(_Input NewFork* fork) = 0; + _Output Void RemoveFork(_Input NewFork* fork); - virtual _Output Void CloseFork(_Input NewFork* fork) = 0; + _Output Void CloseFork(_Input NewFork* fork); - virtual _Output NewCatalog* FindCatalog(_Input const char* catalogName) = 0; + _Output NewCatalog* FindCatalog(_Input const char* catalogName); - virtual _Output NewCatalog* GetCatalog(_Input const char* name) = 0; + _Output NewCatalog* GetCatalog(_Input const char* name); - virtual _Output NewCatalog* CreateCatalog(_Input const char* name, + _Output NewCatalog* CreateCatalog(_Input const char* name, _Input const Int32& flags, _Input const Int32& kind); - virtual _Output NewCatalog* CreateCatalog(_Input const char* name); + _Output NewCatalog* CreateCatalog(_Input const char* name); - virtual bool WriteCatalog(_Input _Output NewCatalog* catalog, voidPtr data); + bool WriteCatalog(_Input _Output NewCatalog* catalog, voidPtr data); - virtual VoidPtr ReadCatalog(_Input _Output NewCatalog* catalog, - SizeT dataSz) = 0; + VoidPtr ReadCatalog(_Input _Output NewCatalog* catalog, + SizeT dataSz); - virtual bool Seek(_Input _Output NewCatalog* catalog, SizeT off) = 0; + bool Seek(_Input _Output NewCatalog* catalog, SizeT off); - virtual SizeT Tell(_Input _Output NewCatalog* catalog) = 0; + SizeT Tell(_Input _Output NewCatalog* catalog); - virtual bool RemoveCatalog(_Input _Output NewCatalog* catalog) = 0; + bool RemoveCatalog(_Input _Output NewCatalog* catalog); - virtual bool CloseCatalog(_InOut NewCatalog* catalog) = 0; + bool CloseCatalog(_InOut NewCatalog* catalog); /// @brief Make a EPM+NewFS drive out of the disk. /// @param drive The drive to write on. diff --git a/Private/FirmwareKit/Handover.hxx b/Private/FirmwareKit/Handover.hxx index afec440d..da9a3bbf 100644 --- a/Private/FirmwareKit/Handover.hxx +++ b/Private/FirmwareKit/Handover.hxx @@ -25,6 +25,7 @@ #define kHandoverVersion 0x1011 #define kHandoverStructSz sizeof(HEL::HandoverHeader) +#define kHandoverHeapStart (0xfffffff80000000) namespace NewOS::HEL { /** @@ -81,6 +82,8 @@ struct HandoverInformationHeader { UInt64 f_FirmwareSpecific[8]; }; +enum { kHandoverSpecificKind, kHandoverSpecificAttrib, }; + /// @brief Bootloader main type. typedef void (*BootMainKind)(NewOS::HEL::HandoverInformationHeader* handoverInfo); diff --git a/Private/HALKit/AMD64/HalACPIFactoryInterface.cxx b/Private/HALKit/AMD64/HalACPIFactoryInterface.cxx index d20bf222..91e0eeb6 100644 --- a/Private/HALKit/AMD64/HalACPIFactoryInterface.cxx +++ b/Private/HALKit/AMD64/HalACPIFactoryInterface.cxx @@ -22,10 +22,6 @@ void rt_shutdown_acpi_virtualbox(void) { HAL::Out16(0x4004, 0x3400); } ACPIFactoryInterface::ACPIFactoryInterface(voidPtr rsdPtr) : fRsdp(rsdPtr), fEntries(0) { - volatile RSDP *_rsdPtr = reinterpret_cast<volatile RSDP *>(this->fRsdp); - - MUST_PASS(_rsdPtr); - MUST_PASS(_rsdPtr->Revision >= 2); } Void ACPIFactoryInterface::Shutdown() { @@ -60,9 +56,12 @@ ErrorOr<voidPtr> ACPIFactoryInterface::Find(const char *signature) { return ErrorOr<voidPtr>{-4}; } - SDT* xsdt = (SDT*)(rsdPtr->RsdtAddress + rsdPtr->XsdtAddress); + SDT* xsdt = (SDT*)(rsdPtr->XsdtAddress >> (rsdPtr->XsdtAddress & 0xFFF)); + SizeT num = xsdt->Length + sizeof(SDT) / 8; + this->fEntries = num; + kcout << "ACPI: Number of entries: " << number(num) << endl; kcout << "ACPI: Address of XSDT: " << hex_number((UIntPtr)xsdt) << endl; diff --git a/Private/HALKit/AMD64/HalKernelMain.cxx b/Private/HALKit/AMD64/HalKernelMain.cxx index 82b80d34..d6b4ab76 100644 --- a/Private/HALKit/AMD64/HalKernelMain.cxx +++ b/Private/HALKit/AMD64/HalKernelMain.cxx @@ -74,7 +74,5 @@ EXTERN_C void hal_init_platform( AppMain(); - hal_flush_tlb(); - NewOS::ke_stop(RUNTIME_CHECK_BOOTSTRAP); } diff --git a/Private/HALKit/AMD64/HalPageAlloc.cpp b/Private/HALKit/AMD64/HalPageAlloc.cpp index 3a8d3047..9ba0ea4d 100644 --- a/Private/HALKit/AMD64/HalPageAlloc.cpp +++ b/Private/HALKit/AMD64/HalPageAlloc.cpp @@ -10,28 +10,31 @@ #include <NewKit/KernelCheck.hpp> STATIC NewOS::Boolean kAllocationInProgress = false; + namespace NewOS { namespace HAL { namespace Detail { struct VirtualMemoryHeader { - Boolean Present : 1; - Boolean ReadWrite : 1; - Boolean User : 1; + UInt32 Magic; + Boolean Present; + Boolean ReadWrite; + Boolean User; + SizeT PageSize; }; struct VirtualMemoryHeaderTraits { /// @brief Get next header. - /// @param current - /// @return + /// @param current + /// @return VirtualMemoryHeader* Next(VirtualMemoryHeader* current) { - return current + sizeof(PTE); + return current + sizeof(PTE) + current->PageSize; } /// @brief Get previous header. - /// @param current - /// @return + /// @param current + /// @return VirtualMemoryHeader* Prev(VirtualMemoryHeader* current) { - return current - sizeof(PTE); + return current - sizeof(PTE) - current->PageSize; } }; } @@ -41,22 +44,27 @@ struct VirtualMemoryHeaderTraits { /// @param rw read/write flag. /// @param user user flag. /// @return the page table of it. -STATIC auto hal_try_alloc_new_page(Boolean rw, Boolean user) -> VoidPtr { +STATIC auto hal_try_alloc_new_page(Boolean rw, Boolean user, SizeT size) -> VoidPtr { if (kAllocationInProgress) return nullptr; kAllocationInProgress = true; + constexpr auto cVMTMagic = 0xDEEFD00D; + ///! fetch from the start. Detail::VirtualMemoryHeader* vmHeader = reinterpret_cast<Detail::VirtualMemoryHeader*>(kKernelVirtualStart); Detail::VirtualMemoryHeaderTraits traits; - while (vmHeader->Present) { + while (vmHeader->Present && + vmHeader->Magic != cVMTMagic) { vmHeader = traits.Next(vmHeader); } + vmHeader->Magic = cVMTMagic; vmHeader->Present = true; vmHeader->ReadWrite = rw; vmHeader->User = user; + vmHeader->PageSize = size; kAllocationInProgress = false; @@ -67,14 +75,16 @@ STATIC auto hal_try_alloc_new_page(Boolean rw, Boolean user) -> VoidPtr { /// @param rw read/write bit. /// @param user user bit. /// @return -auto hal_alloc_page(Boolean rw, Boolean user) -> VoidPtr { +auto hal_alloc_page(Boolean rw, Boolean user, SizeT size) -> VoidPtr { /// Wait for a ongoing allocation to complete. while (kAllocationInProgress) { ; } + if (size == 0) ++size; + /// allocate new page. - return hal_try_alloc_new_page(rw, user); + return hal_try_alloc_new_page(rw, user, size); } } // namespace HAL } // namespace NewOS diff --git a/Private/HALKit/AMD64/HalPageAlloc.hpp b/Private/HALKit/AMD64/HalPageAlloc.hpp index 553f136e..94956329 100644 --- a/Private/HALKit/AMD64/HalPageAlloc.hpp +++ b/Private/HALKit/AMD64/HalPageAlloc.hpp @@ -72,7 +72,7 @@ struct PageDirectory64 final { PageTable64 ALIGN(kPTEAlign) Pte[kPTEMax]; }; -VoidPtr hal_alloc_page(Boolean rw, Boolean user); +VoidPtr hal_alloc_page(Boolean rw, Boolean user, SizeT size); } // namespace NewOS::HAL namespace NewOS { diff --git a/Private/HALKit/AMD64/Processor.hpp b/Private/HALKit/AMD64/Processor.hpp index 70452d1d..efe773da 100644 --- a/Private/HALKit/AMD64/Processor.hpp +++ b/Private/HALKit/AMD64/Processor.hpp @@ -16,6 +16,7 @@ #include <NewKit/Array.hpp> #include <NewKit/Defines.hpp> #include <NewKit/Utils.hpp> +#include <FirmwareKit/Handover.hxx> #ifdef kCPUBackendName #undef kCPUBackendName @@ -30,7 +31,7 @@ #define kTrapGate (0xEF) #define kTaskGate (0b10001100) #define kGdtCodeSelector (0x08) -#define kVirtualAddressStartOffset (0x100) +#define kVirtualAddressStartOffset (0x10000000) namespace NewOS { namespace Detail::AMD64 { @@ -183,3 +184,8 @@ EXTERN_C void hal_load_gdt(NewOS::HAL::RegisterGDT ptr); /// @brief Maximum size of the IDT. #define kKernelIdtSize 0x100 #define kKernelInterruptId 0x32 + +inline NewOS::VoidPtr kKernelVirtualStart = (NewOS::VoidPtr)kVirtualAddressStartOffset; +inline NewOS::UIntPtr kKernelVirtualSize = 0UL; + +inline NewOS::VoidPtr kKernelPhysicalStart = nullptr; diff --git a/Private/HALKit/AMD64/Storage/AHCI.cxx b/Private/HALKit/AMD64/Storage/AHCI.cxx index c9db540a..80224d89 100644 --- a/Private/HALKit/AMD64/Storage/AHCI.cxx +++ b/Private/HALKit/AMD64/Storage/AHCI.cxx @@ -36,7 +36,7 @@ NewOS::Boolean drv_std_init(NewOS::UInt16& PortsImplemented) { iterator[devIndex].Leak().EnableMmio(); /// enable the memory i/o for this ahci device. kAhciDevice = iterator[devIndex].Leak(); /// and then leak the reference. - kcout << "NewKernel: [PCI] Found AHCI controller.\r\n"; + kcout << "New Kernel: [PCI] Found AHCI controller.\r\n"; return true; } diff --git a/Private/HALKit/AMD64/Storage/ATA-PIO.cxx b/Private/HALKit/AMD64/Storage/ATA-PIO.cxx index 7f1cc11a..e72999ca 100644 --- a/Private/HALKit/AMD64/Storage/ATA-PIO.cxx +++ b/Private/HALKit/AMD64/Storage/ATA-PIO.cxx @@ -32,21 +32,21 @@ static Int32 kATADeviceType = kATADeviceCount; static Char kATAData[kATADataLen] = {0}; Boolean drv_std_wait_io(UInt16 IO) { - for (int i = 0; i < 4; i++) In8(IO + ATA_REG_STATUS); + for (int i = 0; i < 4; i++) In8(IO + ATA_REG_STATUS); -ATAWaitForIO_Retry: - auto statRdy = In8(IO + ATA_REG_STATUS); + ATAWaitForIO_Retry: + auto statRdy = In8(IO + ATA_REG_STATUS); - if ((statRdy & ATA_SR_BSY)) goto ATAWaitForIO_Retry; + if ((statRdy & ATA_SR_BSY)) goto ATAWaitForIO_Retry; -ATAWaitForIO_Retry2: - statRdy = In8(IO + ATA_REG_STATUS); + ATAWaitForIO_Retry2: + statRdy = In8(IO + ATA_REG_STATUS); - if (statRdy & ATA_SR_ERR) return false; + if (statRdy & ATA_SR_ERR) return false; - if (!(statRdy & ATA_SR_DRDY)) goto ATAWaitForIO_Retry2; + if (!(statRdy & ATA_SR_DRDY)) goto ATAWaitForIO_Retry2; - return true; + return true; } Void drv_std_select(UInt16 Bus) { @@ -58,76 +58,41 @@ Void drv_std_select(UInt16 Bus) { Boolean drv_std_init(UInt16 Bus, UInt8 Drive, UInt16& OutBus, UInt8& OutMaster) { - if (drv_std_detected()) return true; + if (drv_std_detected()) return true; - UInt16 IO = Bus; + UInt16 IO = Bus; - drv_std_select(IO); + drv_std_select(IO); - // Bus init, NEIN bit. - Out8(IO + ATA_REG_NEIN, 1); + // Bus init, NEIN bit. + Out8(IO + ATA_REG_NEIN, 1); - // identify until it's good. + // identify until it's good. ATAInit_Retry: - auto statRdy = In8(IO + ATA_REG_STATUS); - - if (statRdy & ATA_SR_ERR) { - kcout << "New OS: ATA: Select error, not an IDE based hard-drive.\r\n"; - - return false; - } - - if ((statRdy & ATA_SR_BSY)) goto ATAInit_Retry; - - Out8(IO + ATA_REG_COMMAND, ATA_CMD_IDENTIFY); - - rt_set_memory(kATAData, 0, kATADataLen); + auto statRdy = In8(IO + ATA_REG_STATUS); - /// fetch serial info - /// model, speed, number of sectors... + if (statRdy & ATA_SR_ERR) { + return false; + } - drv_std_wait_io(IO); - - for (SizeT indexData = 0ul; indexData < kATADataLen; ++indexData) { - kATAData[indexData] = In16(IO + ATA_REG_DATA); - } - - OutBus = Bus; - OutMaster = (OutBus == ATA_PRIMARY_IO) ? ATA_MASTER : ATA_SLAVE; + if ((statRdy & ATA_SR_BSY)) goto ATAInit_Retry; - Out8(Bus + ATA_REG_HDDEVSEL, 0xA0 | ATA_MASTER << 4); + Out8(IO + ATA_REG_COMMAND, ATA_CMD_IDENTIFY); - In8(Bus + ATA_REG_CONTROL); - In8(Bus + ATA_REG_CONTROL); - In8(Bus + ATA_REG_CONTROL); - In8(Bus + ATA_REG_CONTROL); + /// fetch serial info + /// model, speed, number of sectors... - unsigned cl = In8(Bus + ATA_CYL_LOW); /* get the "signature bytes" */ - unsigned ch = In8(Bus + ATA_CYL_HIGH); - - /* differentiate ATA, ATAPI, SATA and SATAPI */ - if (cl == 0x14 && ch == 0xEB) { - kcout << "New OS: PATAPI drive detected.\r\n"; - kATADeviceType = kATADevicePATA_PI; - } - if (cl == 0x69 && ch == 0x96) { - kcout << "New OS: SATAPI drive detected.\r\n"; - kATADeviceType = kATADeviceSATA_PI; - } + drv_std_wait_io(IO); - if (cl == 0x0 && ch == 0x0) { - kcout << "New OS: PATA drive detected.\r\n"; - kATADeviceType = kATADevicePATA; - } + for (SizeT indexData = 0ul; indexData < kATADataLen; ++indexData) { + kATAData[indexData] = In16(IO + ATA_REG_DATA); + } - if (cl == 0x3c && ch == 0xc3) { - kcout << "New OS: SATA drive detected.\r\n"; - kATADeviceType = kATADeviceSATA; - } + OutBus = (Bus == ATA_PRIMARY_IO) ? ATA_PRIMARY_IO : ATA_SECONDARY_IO; - Out8(IO + ATA_REG_CONTROL, 0x02); + OutMaster = (Bus == ATA_PRIMARY_IO) ? ATA_MASTER : ATA_SLAVE; - return true; + return true; } Void drv_std_read(UInt64 Lba, UInt16 IO, UInt8 Master, Char* Buf, @@ -136,6 +101,9 @@ Void drv_std_read(UInt64 Lba, UInt16 IO, UInt8 Master, Char* Buf, Lba /= SectorSz; + drv_std_wait_io(IO); + drv_std_select(IO); + Out8(IO + ATA_REG_HDDEVSEL, (Command) | (((Lba) >> 24) & 0x0F)); Out8(IO + ATA_REG_SEC_COUNT0, 1); @@ -146,12 +114,9 @@ Void drv_std_read(UInt64 Lba, UInt16 IO, UInt8 Master, Char* Buf, Out8(IO + ATA_REG_COMMAND, ATA_CMD_READ_PIO); - drv_std_wait_io(IO); - for (SizeT IndexOff = 0; IndexOff < Size; ++IndexOff) { - WideChar chr = In16(IO + ATA_REG_DATA); - - Buf[IndexOff] = chr; + drv_std_wait_io(IO); + Buf[IndexOff] = In16(IO + ATA_REG_DATA); } } @@ -161,6 +126,9 @@ Void drv_std_write(UInt64 Lba, UInt16 IO, UInt8 Master, Char* Buf, Lba /= SectorSz; + drv_std_wait_io(IO); + drv_std_select(IO); + Out8(IO + ATA_REG_HDDEVSEL, (Command) | (((Lba) >> 24) & 0x0F)); Out8(IO + ATA_REG_SEC_COUNT0, 1); @@ -171,11 +139,9 @@ Void drv_std_write(UInt64 Lba, UInt16 IO, UInt8 Master, Char* Buf, Out8(IO + ATA_REG_COMMAND, ATA_CMD_WRITE_PIO); - drv_std_wait_io(IO); - for (SizeT IndexOff = 0; IndexOff < Size; ++IndexOff) { Out16(IO + ATA_REG_DATA, Buf[IndexOff]); - + drv_std_wait_io(IO); } } diff --git a/Private/KernelKit/DriveManager.hxx b/Private/KernelKit/DriveManager.hxx index c3d7c484..0fd8a0d4 100644 --- a/Private/KernelKit/DriveManager.hxx +++ b/Private/KernelKit/DriveManager.hxx @@ -73,12 +73,12 @@ class MountpointInterface final { NEWOS_COPY_DEFAULT(MountpointInterface); public: - DriveTraitPtr A() { return mA; } - DriveTraitPtr B() { return mB; } - DriveTraitPtr C() { return mC; } - DriveTraitPtr D() { return mD; } + DriveTrait& A() { return mA; } + DriveTrait& B() { return mB; } + DriveTrait& C() { return mC; } + DriveTrait& D() { return mD; } - DriveTraitPtr* GetAddressOf(Int32 index) { + DriveTraitPtr GetAddressOf(Int32 index) { DbgLastError() = kErrorSuccess; switch (index) { @@ -102,7 +102,7 @@ class MountpointInterface final { } private: - DriveTraitPtr mA, mB, mC, mD = nullptr; + DriveTrait mA, mB, mC, mD; }; /// @brief Unimplemented drive. diff --git a/Private/NewBoot/BootKit/BootKit.hxx b/Private/NewBoot/BootKit/BootKit.hxx index a1eb9d76..4b9eecfd 100644 --- a/Private/NewBoot/BootKit/BootKit.hxx +++ b/Private/NewBoot/BootKit/BootKit.hxx @@ -38,9 +38,6 @@ class BFileReader; class BFileRunner; class BVersionString; -///! @note This address is reserved to NewKernel. -#define kBootVirtualAddress (0xfffffff80000000) - using namespace NewOS; typedef Char *PEFImagePtr; @@ -264,8 +261,12 @@ private: if (blobCounter > blobCount) break; ++blobCounter; - NewCatalog* catalogKind = new NewCatalog(); - memset(catalogKind, 0, sizeof(NewCatalog)); + Char bufCatalog[sizeof(NewCatalog)] = { 0 }; + Char bufFork[sizeof(NewFork)] = { 0 }; + + NewCatalog* catalogKind = (NewCatalog*)bufFork; + + catalogKind->PrevSibling = startLba; /// Fill catalog kind. catalogKind->Kind = blob->fKind; @@ -277,8 +278,7 @@ private: catalogKind->ResourceFork = (startLba + sizeof(NewCatalog)); } - NewFork* forkKind = new NewFork(); - memset(forkKind, 0, sizeof(NewFork)); + NewFork* forkKind = (NewFork*)bufFork; memcpy(forkKind->Name, blob->fForkName, strlen(blob->fForkName)); forkKind->Kind = (forkKind->Name[0] == kNewFSDataFork[0]) ? kNewFSDataForkKind : kNewFSRsrcForkKind; @@ -322,13 +322,8 @@ private: catalogKind->Kind = blob->fKind; catalogKind->Flags |= kNewFSFlagCreated; - Lba catalogLba = (sizeof(NewCatalog) - startLba); - //// Now write catalog as well.. - catalogKind->PrevSibling = startLba; - catalogKind->NextSibling = (sizeof(NewCatalog) + blob->fBlobSz); - /// this mime only applies to file. if (catalogKind->Kind == kNewFSCatalogKindFile) { memcpy(catalogKind->Mime, kBKBootFileMime, strlen(kBKBootFileMime)); @@ -338,6 +333,8 @@ private: memcpy(catalogKind->Name, blob->fFileName, strlen(blob->fFileName)); + catalogKind->NextSibling = startLba + (sizeof(NewCatalog) + sizeof(NewFork) + blob->fBlobSz); + fDiskDev.Leak().mBase = startLba; fDiskDev.Leak().mSize = sizeof(NewCatalog); @@ -348,9 +345,6 @@ private: --partBlock.FreeCatalog; --partBlock.FreeSectors; - delete forkKind; - delete catalogKind; - blob = blob->fNext; } @@ -387,14 +381,14 @@ inline Boolean BDiskFormatFactory<BootDev>::Format(const char* partName, partBlock->CatalogCount = blobCount; partBlock->Kind = kNewFSHardDrive; partBlock->SectorSize = sectorSz; - partBlock->FreeCatalog = fDiskDev.GetSectorsCount() - partBlock->CatalogCount; + partBlock->FreeCatalog = fDiskDev.GetSectorsCount(); partBlock->SectorCount = fDiskDev.GetSectorsCount(); - partBlock->FreeSectors = fDiskDev.GetSectorsCount() - partBlock->CatalogCount; + partBlock->FreeSectors = fDiskDev.GetSectorsCount(); partBlock->StartCatalog = kNewFSCatalogStartAddress; partBlock->DiskSize = fDiskDev.GetDiskSize(); if (this->FormatCatalog(fileBlobs, blobCount, *partBlock)) { - fDiskDev.Leak().mBase = (kNewFSAddressAsLba); + fDiskDev.Leak().mBase = kNewFSAddressAsLba; fDiskDev.Leak().mSize = sectorSz; fDiskDev.Write(buf, sectorSz); diff --git a/Private/NewBoot/Source/HEL/AMD64/BootATA.cxx b/Private/NewBoot/Source/HEL/AMD64/BootATA.cxx index 8ab7dc20..5be1e977 100644 --- a/Private/NewBoot/Source/HEL/AMD64/BootATA.cxx +++ b/Private/NewBoot/Source/HEL/AMD64/BootATA.cxx @@ -88,7 +88,7 @@ ATAInit_Retry: boot_ata_wait_io(IO); for (SizeT indexData = 0ul; indexData < kATADataLen; ++indexData) { - kATAData[indexData] = In8(IO + ATA_REG_DATA); + kATAData[indexData] = In16(IO + ATA_REG_DATA); } OutBus = diff --git a/Private/NewBoot/Source/HEL/AMD64/BootMain.cxx b/Private/NewBoot/Source/HEL/AMD64/BootMain.cxx index 226d5bff..36dc47d3 100644 --- a/Private/NewBoot/Source/HEL/AMD64/BootMain.cxx +++ b/Private/NewBoot/Source/HEL/AMD64/BootMain.cxx @@ -12,6 +12,7 @@ #include <NewKit/Macros.hpp> #include <BootKit/BootKit.hxx> #include <NewKit/Ref.hpp> +#include <FirmwareKit/Handover.hxx> #include <cstring> /// make the compiler shut up. @@ -21,13 +22,11 @@ /** Graphics related. */ -EXTERN_C Void hal_init_platform(HEL::HandoverInformationHeader* HIH); - STATIC EfiGraphicsOutputProtocol* kGop = nullptr; STATIC UInt16 kStride = 0U; STATIC EfiGUID kGopGuid; -EXTERN_C Void rt_jump_to_address(VoidPtr blob); +EXTERN_C Void hal_init_platform(HEL::HandoverInformationHeader* HIH); /** @brief Finds and stores the GOP. @@ -66,7 +65,7 @@ EFI_EXTERN_C EFI_API Int Main(EfiHandlePtr ImageHandle, writer.Write(L"Mahrouss-Logic (R) New Boot: ") .Write(BVersionString::Shared()); - writer.Write(L"\r\nNewBoot: Firmware Vendor: ") + writer.Write(L"\r\nNew Boot: Firmware Vendor: ") .Write(SystemTable->FirmwareVendor) .Write(L"\r\n"); @@ -76,6 +75,7 @@ EFI_EXTERN_C EFI_API Int Main(EfiHandlePtr ImageHandle, UInt32* SzDesc = new UInt32(); UInt32* RevDesc = new UInt32(); + *MapKey = 0; *SizePtr = sizeof(EfiMemoryDescriptor); HEL::HandoverInformationHeader* handoverHdrPtr = new HEL::HandoverInformationHeader(); @@ -125,19 +125,12 @@ EFI_EXTERN_C EFI_API Int Main(EfiHandlePtr ImageHandle, ToolboxClearRsrc(); - EfiPhysicalAddress* whereAddress = - reinterpret_cast<EfiPhysicalAddress*>(kBootVirtualAddress); - BS->GetMemoryMap(SizePtr, Descriptor, MapKey, SzDesc, RevDesc); handoverHdrPtr->f_PhysicalStart = (VoidPtr)Descriptor->PhysicalStart; - handoverHdrPtr->f_FirmwareSpecific[0] = Descriptor->Attribute; - handoverHdrPtr->f_FirmwareSpecific[1] = Descriptor->Kind; - - - BS->AllocatePages(EfiAllocateType::AllocateAnyPages, - EfiMemoryType::EfiConventionalMemory, 1, whereAddress); + handoverHdrPtr->f_FirmwareSpecific[HEL::kHandoverSpecificAttrib] = Descriptor->Attribute; + handoverHdrPtr->f_FirmwareSpecific[HEL::kHandoverSpecificKind] = Descriptor->Kind; handoverHdrPtr->f_VirtualStart = (VoidPtr)Descriptor->VirtualStart; handoverHdrPtr->f_VirtualSize = Descriptor->NumberOfPages; /* # of pages */ @@ -231,7 +224,7 @@ EFI_EXTERN_C EFI_API Int Main(EfiHandlePtr ImageHandle, EFI::ExitBootServices(*MapKey, ImageHandle); - hal_init_platform(kHandoverHeader); + hal_init_platform(handoverHdrPtr); EFI::Stop(); diff --git a/Private/NewBoot/Source/HEL/AMD64/BootPlatform.cxx b/Private/NewBoot/Source/HEL/AMD64/BootPlatform.cxx index 2ac90dd8..fa735142 100644 --- a/Private/NewBoot/Source/HEL/AMD64/BootPlatform.cxx +++ b/Private/NewBoot/Source/HEL/AMD64/BootPlatform.cxx @@ -9,7 +9,7 @@ #include <BootKit/BootKit.hxx> #include "HALKit/AMD64/Processor.hpp" -#if 0 +#ifdef __STANDALONE__ EXTERN_C void rt_hlt() { asm volatile("hlt"); } diff --git a/Private/NewBoot/Source/HEL/AMD64/New+Delete.cxx b/Private/NewBoot/Source/HEL/AMD64/New+Delete.cxx index 909ccca6..8d811bd9 100644 --- a/Private/NewBoot/Source/HEL/AMD64/New+Delete.cxx +++ b/Private/NewBoot/Source/HEL/AMD64/New+Delete.cxx @@ -9,7 +9,7 @@ #include <BootKit/BootKit.hxx> #include <cstddef> /* Since we're using GCC for this EFI program. */ -#if 0 +#ifdef __STANDALONE__ /// @brief Allocates a new object. /// @param sz the size. diff --git a/Private/NewBoot/Source/HEL/AMD64/Support.cxx b/Private/NewBoot/Source/HEL/AMD64/Support.cxx index a8e2c275..686f4811 100644 --- a/Private/NewBoot/Source/HEL/AMD64/Support.cxx +++ b/Private/NewBoot/Source/HEL/AMD64/Support.cxx @@ -8,7 +8,7 @@ #include <FirmwareKit/Handover.hxx> #include <BootKit/Vendor/Support.hxx> -#if 0 +#ifdef __STANDALONE__ /// @brief memset definition in C++. /// @param dst destination pointer. diff --git a/Private/NewKit/PageAllocator.hpp b/Private/NewKit/PageAllocator.hpp index 6d9478cb..0d8377b0 100644 --- a/Private/NewKit/PageAllocator.hpp +++ b/Private/NewKit/PageAllocator.hpp @@ -12,7 +12,7 @@ namespace NewOS { namespace Detail { -VoidPtr create_page_wrapper(Boolean rw, Boolean user); +VoidPtr create_page_wrapper(Boolean rw, Boolean user, SizeT pageSz); void exec_disable(UIntPtr addr); bool page_disable(UIntPtr addr); } // namespace Detail diff --git a/Private/NewKit/PageManager.hpp b/Private/NewKit/PageManager.hpp index c8806c90..05965306 100644 --- a/Private/NewKit/PageManager.hpp +++ b/Private/NewKit/PageManager.hpp @@ -66,7 +66,7 @@ struct PageManager final { PageManager(const PageManager &) = default; public: - PTEWrapper Request(Boolean Rw, Boolean User, Boolean ExecDisable); + PTEWrapper Request(Boolean Rw, Boolean User, Boolean ExecDisable, SizeT Sz); bool Free(Ref<PTEWrapper *> &wrapper); private: diff --git a/Private/Source/AppMain.cxx b/Private/Source/AppMain.cxx index 87705393..6dd78496 100644 --- a/Private/Source/AppMain.cxx +++ b/Private/Source/AppMain.cxx @@ -20,12 +20,18 @@ EXTERN_C NewOS::Void AppMain(NewOS::Void) { ///! Mounts a NewFS block. NewOS::NewFilesystemManager* newFS = new NewOS::NewFilesystemManager(); - NewOS::ke_protect_ke_heap(newFS); NewOS::FilesystemManagerInterface::Mount(newFS); + if (newFS->GetImpl()) { + auto catalog = newFS->GetImpl()->GetCatalog("/"); + if (catalog) { + NewOS::kcout << "Catalog-Path-Name: " << catalog->Name << NewOS::endl; + delete catalog; + } + } + while (NewOS::ProcessScheduler::Shared().Leak().Run() > 0); - ///! we're done, unmount. delete newFS; } diff --git a/Private/Source/DriveManager.cxx b/Private/Source/DriveManager.cxx index 86478831..41f4f4ab 100644 --- a/Private/Source/DriveManager.cxx +++ b/Private/Source/DriveManager.cxx @@ -18,73 +18,82 @@ static UInt16 kATAIO = 0U; static UInt8 kATAMaster = 0U; /// @brief reads from an ATA drive. -/// @param pckt -/// @return +/// @param pckt +/// @return Void ke_drv_input(DriveTrait::DrivePacket* pckt) { if (!pckt) { return; } - + pckt->fPacketGood = false; #ifdef __AHCI__ - drv_std_read(pckt->fLba, (Char*)pckt->fPacketContent, 1, pckt->fPacketSize); + drv_std_read(pckt->fLba, (Char*)pckt->fPacketContent, kAHCISectorSize, pckt->fPacketSize); #elif defined(__ATA_PIO__) || defined(__ATA_DMA__) - drv_std_read(pckt->fLba, kATAIO, kATAMaster, (Char*)pckt->fPacketContent, 1, pckt->fPacketSize); + drv_std_read(pckt->fLba, kATAIO, kATAMaster, (Char*)pckt->fPacketContent, kATASectorSize, pckt->fPacketSize); #endif - pckt->fPacketGood = true; } /// @brief Writes to an ATA drive. -/// @param pckt -/// @return +/// @param pckt +/// @return Void ke_drv_output(DriveTrait::DrivePacket* pckt) { if (!pckt) { return; } - + pckt->fPacketGood = false; #ifdef __AHCI__ - drv_std_write(pckt->fLba,(Char*)pckt->fPacketContent, 1, pckt->fPacketSize); + drv_std_write(pckt->fLba,(Char*)pckt->fPacketContent, kATASectorSize, pckt->fPacketSize); #elif defined(__ATA_PIO__) || defined(__ATA_DMA__) - drv_std_write(pckt->fLba, kATAIO, kATAMaster, (Char*)pckt->fPacketContent, 1, pckt->fPacketSize); + drv_std_write(pckt->fLba, kATAIO, kATAMaster, (Char*)pckt->fPacketContent, kATASectorSize, pckt->fPacketSize); #endif pckt->fPacketGood = true; } /// @brief Executes a disk check on the ATA drive. -/// @param pckt -/// @return +/// @param pckt +/// @return Void ke_drv_check_disk(DriveTrait::DrivePacket* pckt) { if (!pckt) { return; } - + pckt->fPacketGood = false; + + +#if defined(__ATA_PIO__) || defined (__ATA_DMA__) + kATAMaster = true; + kATAIO = ATA_PRIMARY_IO; + + MUST_PASS(drv_std_init(kATAIO, kATAMaster, kATAIO, kATAMaster)); +#endif // if defined(__ATA_PIO__) || defined (__ATA_DMA__) + + pckt->fPacketGood = true; } /// @brief Gets the drive kind (ATA, SCSI, AHCI...) -/// @param -/// @return -#ifdef __ATA_PIO__ +/// @param +/// @return +#ifdef __ATA_PIO__ const Char* ke_drive_kind(Void) { return "ATA-PIO"; } #endif -#ifdef __ATA_DMA__ +#ifdef __ATA_DMA__ const Char* ke_drive_kind(Void) { return "ATA-DMA"; } #endif -#ifdef __AHCI__ +#ifdef __AHCI__ const Char* ke_drive_kind(Void) { return "AHCI"; } #endif /// @brief Unimplemented drive. -/// @param pckt -/// @return +/// @param pckt +/// @return Void ke_drv_unimplemented(DriveTrait::DrivePacket* pckt) {} /// @brief Makes a new drive. @@ -98,6 +107,7 @@ DriveTrait construct_drive() noexcept { trait.fInput = ke_drv_unimplemented; trait.fOutput = ke_drv_unimplemented; trait.fVerify = ke_drv_unimplemented; + trait.fDriveKind = ke_drive_kind; return trait; } @@ -107,12 +117,13 @@ DriveTrait construct_drive() noexcept { DriveTrait construct_main_drive() noexcept { DriveTrait trait; - rt_copy_memory((VoidPtr)"/Mount/Disk/0", trait.fName, rt_string_len("/Mount/Disk/0")); + rt_copy_memory((VoidPtr)"/Mount/MainDisk/", trait.fName, rt_string_len("/Mount/MainDisk/")); trait.fKind = kMassStorage | kEPMDrive; trait.fInput = ke_drv_input; trait.fOutput = ke_drv_output; trait.fVerify = ke_drv_check_disk; + trait.fDriveKind = ke_drive_kind; return trait; } diff --git a/Private/Source/FS/NewFS.cxx b/Private/Source/FS/NewFS.cxx index 9dbb32e0..a5dfe45b 100644 --- a/Private/Source/FS/NewFS.cxx +++ b/Private/Source/FS/NewFS.cxx @@ -10,7 +10,7 @@ #include <KernelKit/HError.hpp> #include <NewKit/Crc32.hpp> #include <NewKit/Utils.hpp> - +#include <NewKit/String.hpp> #include <Builtins/ATA/ATA.hxx> #include <Builtins/AHCI/AHCI.hxx> @@ -59,11 +59,10 @@ _Output NewFork* NewFSParser::CreateFork(_Input NewCatalog* catalog, } } - if (!sMountpointInterface.GetAddressOf(this->fDriveIndex) || - !*sMountpointInterface.GetAddressOf(this->fDriveIndex)) + if (!sMountpointInterface.GetAddressOf(this->fDriveIndex)) return nullptr; - auto drv = *sMountpointInterface.GetAddressOf(this->fDriveIndex); + auto drv = sMountpointInterface.GetAddressOf(this->fDriveIndex); drv->fPacket.fLba = whereFork; drv->fPacket.fPacketSize = theFork.DataSize; @@ -105,7 +104,7 @@ _Output NewFork* NewFSParser::CreateFork(_Input NewCatalog* catalog, /// @return the fork. _Output NewFork* NewFSParser::FindFork(_Input NewCatalog* catalog, _Input const Char* name, Boolean isDataFork) { - auto drv = *sMountpointInterface.GetAddressOf(this->fDriveIndex); + auto drv = sMountpointInterface.GetAddressOf(this->fDriveIndex); NewFork* theFork = nullptr; Lba lba = isDataFork ? catalog->DataFork : catalog->ResourceFork; @@ -177,7 +176,7 @@ bool NewFSParser::Format(_Input _Output DriveTrait* drive) { return false; } - Char sectorBuf[kNewFSMinimumSectorSz] = {0}; + UInt16 sectorBuf[kNewFSMinimumSectorSz] = {0}; drive->fPacket.fPacketContent = sectorBuf; drive->fPacket.fPacketSize = kNewFSMinimumSectorSz; @@ -241,7 +240,58 @@ bool NewFSParser::WriteCatalog(_Input _Output NewCatalog* catalog, /// @param catalogName /// @return _Output NewCatalog* NewFSParser::FindCatalog(_Input const char* catalogName) { - return nullptr; + if (!sMountpointInterface.GetAddressOf(this->fDriveIndex)) return nullptr; + + Char* sectorBuf = new Char[sizeof(NewPartitionBlock)]; + auto drive = sMountpointInterface.GetAddressOf(this->fDriveIndex); + + drive->fPacket.fPacketContent = sectorBuf; + drive->fPacket.fPacketSize = sizeof(NewPartitionBlock); + drive->fPacket.fLba = kNewFSAddressAsLba; + + drive->fInput(&drive->fPacket); + + NewPartitionBlock* part = (NewPartitionBlock*)sectorBuf; + + kcout << "Drive-Kind: " << drive->fDriveKind() << endl; + + kcout << "Partition-Name: " << part->PartitionName << endl; + kcout << "Start-Catalog: " << number(part->StartCatalog) << endl; + kcout << "Catalog-Count: " << number(part->CatalogCount) << endl; + kcout << "Free-Catalog: " << number(part->FreeCatalog) << endl; + kcout << "Free-Sectors: " << number(part->FreeSectors) << endl; + kcout << "Sector-Size: " << number(part->SectorSize) << endl; + + auto start = part->StartCatalog; + + drive->fPacket.fLba = start; + drive->fPacket.fPacketContent = sectorBuf; + drive->fPacket.fPacketSize = sizeof(NewCatalog); + + drive->fInput(&drive->fPacket); + + while (drive->fPacket.fPacketGood) { + NewCatalog* catalog = (NewCatalog*)sectorBuf; + + if (StringBuilder::Equals(catalogName, catalog->Name)) { + NewCatalog* catalogPtr = new NewCatalog(); + rt_copy_memory(catalog, catalogPtr, sizeof(NewCatalog)); + + delete[] sectorBuf; + return catalogPtr; + } + + if (catalog->NextSibling == 0) + break; + + drive->fPacket.fLba = catalog->NextSibling; + drive->fPacket.fPacketSize = kNewFSMinimumSectorSz; + drive->fInput(&drive->fPacket); + } + + delete[] sectorBuf; + + return nullptr; } /// @brief @@ -295,8 +345,6 @@ VoidPtr NewFSParser::ReadCatalog(_Input _Output NewCatalog* catalog, return nullptr; } - - return nullptr; } @@ -329,9 +377,10 @@ SizeT NewFSParser::Tell(_Input _Output NewCatalog* catalog) { /// @param sz the size of the fork to set. /// @return the valid lba. STATIC Lba ke_find_free_fork(SizeT sz, Int32 drv, NewCatalog* catalog, Boolean isDataFork) { - auto drive = *sMountpointInterface.GetAddressOf(drv); - if (drive) { + if (sMountpointInterface.GetAddressOf(drv)) { + auto drive = *sMountpointInterface.GetAddressOf(drv); + /// prepare packet. bool done = false; bool error = false; @@ -339,18 +388,18 @@ STATIC Lba ke_find_free_fork(SizeT sz, Int32 drv, NewCatalog* catalog, Boolean i Lba lba = isDataFork ? catalog->DataFork : catalog->ResourceFork; while (!done) { - Char sectorBuf[kNewFSMinimumSectorSz] = {0}; + UInt16 sectorBuf[kNewFSMinimumSectorSz] = {0}; - drive->fPacket.fPacketContent = sectorBuf; - drive->fPacket.fPacketSize = kNewFSMinimumSectorSz; - drive->fPacket.fLba = lba; + drive.fPacket.fPacketContent = sectorBuf; + drive.fPacket.fPacketSize = kNewFSMinimumSectorSz; + drive.fPacket.fLba = lba; - drive->fInput(&drive->fPacket); + drive.fInput(&drive.fPacket); - if (!drive->fPacket.fPacketGood) { + if (!drive.fPacket.fPacketGood) { ///! not a lot of choices, disk has become unreliable. - if (ke_calculate_crc32(sectorBuf, kNewFSMinimumSectorSz) != - drive->fPacket.fPacketCRC32) { + if (ke_calculate_crc32((Char*)sectorBuf, kNewFSMinimumSectorSz) != + drive.fPacket.fPacketCRC32) { DbgLastError() = kErrorDiskIsCorrupted; } @@ -366,10 +415,10 @@ STATIC Lba ke_find_free_fork(SizeT sz, Int32 drv, NewCatalog* catalog, Boolean i fork->DataSize = sz; fork->Flags |= kNewFSFlagCreated; - drive->fOutput(&drive->fPacket); + drive.fOutput(&drive.fPacket); /// here it's either a read-only filesystem or something bad happened.' - if (!drive->fPacket.fPacketGood) { + if (!drive.fPacket.fPacketGood) { DbgLastError() = kErrorDiskReadOnly; return 0; @@ -394,18 +443,18 @@ STATIC Lba ke_find_free_fork(SizeT sz, Int32 drv, NewCatalog* catalog, Boolean i /// @param kind the catalog kind. /// @return the valid lba. STATIC Lba ke_find_free_catalog(SizeT kind, Int32 drv) { - auto drive = *sMountpointInterface.GetAddressOf(drv); - if (drive) { - Char sectorBuf[kNewFSMinimumSectorSz] = {0}; + if (sMountpointInterface.GetAddressOf(drv)) { + auto drive = *sMountpointInterface.GetAddressOf(drv); + UInt16 sectorBuf[kNewFSMinimumSectorSz] = {0}; /// prepare packet. - drive->fPacket.fPacketContent = sectorBuf; - drive->fPacket.fPacketSize = kNewFSMinimumSectorSz; - drive->fPacket.fLba = kNewFSAddressAsLba; + drive.fPacket.fPacketContent = sectorBuf; + drive.fPacket.fPacketSize = kNewFSMinimumSectorSz; + drive.fPacket.fLba = kNewFSAddressAsLba; - drive->fInput(&drive->fPacket); + drive.fInput(&drive.fPacket); NewPartitionBlock* partBlock = (NewPartitionBlock*)sectorBuf; @@ -419,11 +468,11 @@ STATIC Lba ke_find_free_catalog(SizeT kind, Int32 drv) { return 1; } else { while (startLba != 0) { - drive->fPacket.fPacketContent = sectorBuf; - drive->fPacket.fPacketSize = kNewFSMinimumSectorSz; - drive->fPacket.fLba = startLba; + drive.fPacket.fPacketContent = sectorBuf; + drive.fPacket.fPacketSize = kNewFSMinimumSectorSz; + drive.fPacket.fLba = startLba; - drive->fInput(&drive->fPacket); + drive.fInput(&drive.fPacket); NewCatalog* catalog = (NewCatalog*)sectorBuf; @@ -447,7 +496,16 @@ STATIC Lba ke_find_free_catalog(SizeT kind, Int32 drv) { } namespace NewOS::Detail { -Boolean fs_init_newfs(Void) noexcept { return true; } +Boolean fs_init_newfs(Void) noexcept { + sMountpointInterface.A() = construct_main_drive(); + sMountpointInterface.B() = construct_drive(); + sMountpointInterface.C() = construct_drive(); + sMountpointInterface.D() = construct_drive(); + + sMountpointInterface.A().fVerify(&sMountpointInterface.A().fPacket); + + return true; +} } // namespace NewOS::Detail #endif // ifdef __FSKIT_NEWFS__ diff --git a/Private/Source/KernelCheck.cxx b/Private/Source/KernelCheck.cxx index 5f617f06..d649ef35 100644 --- a/Private/Source/KernelCheck.cxx +++ b/Private/Source/KernelCheck.cxx @@ -91,8 +91,8 @@ void ke_stop(const NewOS::Int &id) { void ke_runtime_check(bool expr, const char *file, const char *line) { if (!expr) { #ifdef __DEBUG__ - kcout << "NewKernel: File: " << file << "\r\n"; - kcout << "NewKernel: Line: " << line << "\r\n"; + kcout << "New Kernel: File: " << file << "\r\n"; + kcout << "New Kernel: Line: " << line << "\r\n"; #endif // __DEBUG__ diff --git a/Private/Source/KernelHeap.cxx b/Private/Source/KernelHeap.cxx index 3b77ebb6..52b9bafb 100644 --- a/Private/Source/KernelHeap.cxx +++ b/Private/Source/KernelHeap.cxx @@ -49,7 +49,7 @@ typedef HeapInformationBlock *HeapInformationBlockPtr; VoidPtr ke_new_ke_heap(SizeT sz, const bool rw, const bool user) { if (sz == 0) ++sz; - auto wrapper = kHeapPageManager.Request(rw, user, false); + auto wrapper = kHeapPageManager.Request(rw, user, false, sz); Detail::HeapInformationBlockPtr heapInfo = reinterpret_cast<Detail::HeapInformationBlockPtr>( @@ -62,6 +62,9 @@ VoidPtr ke_new_ke_heap(SizeT sz, const bool rw, const bool user) { ++kHeapCount; + NewOS::kcout << "New OS: Allocate: " << hex_number((IntPtr)wrapper.VirtualAddress() + + sizeof(Detail::HeapInformationBlock)) << endl; + return reinterpret_cast<VoidPtr>(wrapper.VirtualAddress() + sizeof(Detail::HeapInformationBlock)); } @@ -71,11 +74,15 @@ VoidPtr ke_new_ke_heap(SizeT sz, const bool rw, const bool user) { /// @return Int32 ke_delete_ke_heap(VoidPtr heapPtr) { if (kHeapCount < 1) return -kErrorInternal; + if (((IntPtr)heapPtr - sizeof(Detail::HeapInformationBlock)) <= 0) return -kErrorInternal; + if (((IntPtr)heapPtr - kBadPtr) < 0) return -kErrorInternal; Detail::HeapInformationBlockPtr virtualAddress = reinterpret_cast<Detail::HeapInformationBlockPtr>( (UIntPtr)heapPtr - sizeof(Detail::HeapInformationBlock)); + NewOS::kcout << "New OS: Freeing: " << hex_number((UIntPtr)virtualAddress) << endl; + if (virtualAddress && virtualAddress->fMagic == kKernelHeapMagic) { if (!virtualAddress->fPresent) { return -kErrorHeapNotPresent; diff --git a/Private/Source/NewFS+FileManager.cxx b/Private/Source/NewFS+FileManager.cxx index 7227c2e2..910ec841 100644 --- a/Private/Source/NewFS+FileManager.cxx +++ b/Private/Source/NewFS+FileManager.cxx @@ -5,6 +5,7 @@ ------------------------------------------- */ #include <KernelKit/FileManager.hpp> +#include <KernelKit/KernelHeap.hpp> #ifdef __FSKIT_NEWFS__ @@ -15,9 +16,14 @@ namespace NewOS { /// @brief C++ constructor NewFilesystemManager::NewFilesystemManager() { MUST_PASS(Detail::fs_init_newfs()); + fImpl = new NewFSParser(); } -NewFilesystemManager::~NewFilesystemManager() = default; +NewFilesystemManager::~NewFilesystemManager() { + if (fImpl) { + delete fImpl; + } +} /// @brief Removes a node from the filesystem. /// @param fileName The filename @@ -53,15 +59,15 @@ NodePtr NewFilesystemManager::CreateAlias(const char* path) { } /// @brief Gets the root directory. -/// @return +/// @return const char* NewFilesystemHelper::Root() { return kNewFSRoot; } /// @brief Gets the up-dir directory. -/// @return +/// @return const char* NewFilesystemHelper::UpDir() { return kNewFSUpDir; } /// @brief Gets the separator character. -/// @return +/// @return const char NewFilesystemHelper::Separator() { return kNewFSSeparator; } } // namespace NewOS diff --git a/Private/Source/NewFS+IO.cxx b/Private/Source/NewFS+IO.cxx index a7acb63b..c78a0793 100644 --- a/Private/Source/NewFS+IO.cxx +++ b/Private/Source/NewFS+IO.cxx @@ -8,13 +8,13 @@ #include <KernelKit/FileManager.hpp> /************************************************************* - * - * File: NewFS+IO.cxx + * + * File: NewFS+IO.cxx * Purpose: Filesystem to mountpoint interface. * Date: 3/26/24 - * + * * Copyright Mahrouss Logic, all rights reserved. - * + * *************************************************************/ @@ -24,8 +24,8 @@ /// Useful macros. -#define NEWFS_WRITE(DRV, TRAITS, MP) (*MP->DRV()).fOutput(&TRAITS) -#define NEWFS_READ(DRV, TRAITS, MP) (*MP->DRV()).fInput(&TRAITS) +#define NEWFS_WRITE(DRV, TRAITS, MP) (MP->DRV()).fOutput(&TRAITS) +#define NEWFS_READ(DRV, TRAITS, MP) (MP->DRV()).fInput(&TRAITS) using namespace NewOS; @@ -33,12 +33,12 @@ using namespace NewOS; /// @param Mnt mounted interface. /// @param DrvTrait drive info /// @param DrvIndex drive index. -/// @return +/// @return Int32 fs_newfs_read(MountpointInterface* Mnt, DriveTrait& DrvTrait, Int32 DrvIndex) { if (!Mnt) return -1; DrvTrait.fPacket.fPacketGood = false; - + switch (DrvIndex) { case kNewFSSubDriveA: { NEWFS_READ(A, DrvTrait.fPacket, Mnt); @@ -62,10 +62,10 @@ Int32 fs_newfs_read(MountpointInterface* Mnt, DriveTrait& DrvTrait, Int32 DrvInd } /// @brief Write to newfs disk. -/// @param Mnt mounted interface. -/// @param DrvTrait drive info +/// @param Mnt mounted interface. +/// @param DrvTrait drive info /// @param DrvIndex drive index. -/// @return +/// @return Int32 fs_newfs_write(MountpointInterface* Mnt, DriveTrait& DrvTrait, Int32 DrvIndex) { if (!Mnt) return -1; diff --git a/Private/Source/PageAllocator.cxx b/Private/Source/PageAllocator.cxx index d7635e99..510fa0ee 100644 --- a/Private/Source/PageAllocator.cxx +++ b/Private/Source/PageAllocator.cxx @@ -10,8 +10,8 @@ /// @brief Internal namespace, used internally by kernel. namespace NewOS::Detail { -VoidPtr create_page_wrapper(Boolean rw, Boolean user) { - auto addr = HAL::hal_alloc_page(rw, user); +VoidPtr create_page_wrapper(Boolean rw, Boolean user, SizeT pageSz) { + auto addr = HAL::hal_alloc_page(rw, user, pageSz); if (addr == kBadAddress) { kcout << "[create_page_wrapper] kBadAddress returned\n"; @@ -34,7 +34,6 @@ bool page_disable(UIntPtr VirtualAddr) { auto VirtualAddrTable = (PTE *)(VirtualAddr); MUST_PASS(!VirtualAddrTable->Accessed); - if (VirtualAddrTable->Accessed) return false; VirtualAddrTable->Present = false; hal_flush_tlb(); diff --git a/Private/Source/PageManager.cxx b/Private/Source/PageManager.cxx index 368f2974..0f7ae78a 100644 --- a/Private/Source/PageManager.cxx +++ b/Private/Source/PageManager.cxx @@ -53,9 +53,9 @@ bool PTEWrapper::Reclaim() { /// @param User user mode? /// @param ExecDisable disable execution on page? /// @return -PTEWrapper PageManager::Request(Boolean Rw, Boolean User, Boolean ExecDisable) { +PTEWrapper PageManager::Request(Boolean Rw, Boolean User, Boolean ExecDisable, SizeT Sz) { // Store PTE wrapper right after PTE. - VoidPtr ptr = NewOS::HAL::hal_alloc_page(Rw, User); + VoidPtr ptr = NewOS::HAL::hal_alloc_page(Rw, User, Sz); return PTEWrapper{Rw, User, ExecDisable, reinterpret_cast<UIntPtr>(ptr)}; } diff --git a/Private/Source/Pmm.cxx b/Private/Source/Pmm.cxx index 7c331c65..bbd7e6f6 100644 --- a/Private/Source/Pmm.cxx +++ b/Private/Source/Pmm.cxx @@ -14,7 +14,7 @@ Pmm::~Pmm() = default; /* If this returns Null pointer, enter emergency mode */ Ref<PTEWrapper> Pmm::RequestPage(Boolean user, Boolean readWrite) { - PTEWrapper pt = fPageManager.Leak().Request(user, readWrite, false); + PTEWrapper pt = fPageManager.Leak().Request(user, readWrite, false, kPTESize); if (pt.fPresent) { kcout << "[PMM]: Allocation was successful."; diff --git a/Private/Source/Storage/ATADeviceInterface.cxx b/Private/Source/Storage/ATADeviceInterface.cxx index 89f11f5d..d70a03f0 100644 --- a/Private/Source/Storage/ATADeviceInterface.cxx +++ b/Private/Source/Storage/ATADeviceInterface.cxx @@ -28,17 +28,17 @@ ATADeviceInterface::~ATADeviceInterface() { const char* ATADeviceInterface::Name() const { return "ATADeviceInterface"; } /// @brief Output operator. -/// @param Data -/// @return +/// @param Data +/// @return ATADeviceInterface& ATADeviceInterface::operator<<(MountpointInterface* Data) { if (!Data) return *this; for (SizeT driveCount = 0; driveCount < kDriveManagerCount; ++driveCount) { auto interface = Data->GetAddressOf(driveCount); - if ((*interface) && rt_string_cmp((*interface)->fDriveKind(), "ATA-", 5) == 0) { + if ((interface) && rt_string_cmp((interface)->fDriveKind(), "ATA-", 5) == 0) { continue; - } else if ((*interface) && - rt_string_cmp((*interface)->fDriveKind(), "ATA-", 5) != 0) { + } else if ((interface) && + rt_string_cmp((interface)->fDriveKind(), "ATA-", 5) != 0) { return *this; } } @@ -48,21 +48,21 @@ ATADeviceInterface& ATADeviceInterface::operator<<(MountpointInterface* Data) { } /// @brief Input operator. -/// @param Data -/// @return +/// @param Data +/// @return ATADeviceInterface& ATADeviceInterface::operator>>(MountpointInterface* Data) { if (!Data) return *this; for (SizeT driveCount = 0; driveCount < kDriveManagerCount; ++driveCount) { auto interface = Data->GetAddressOf(driveCount); - if ((*interface) && rt_string_cmp((*interface)->fDriveKind(), "ATA-", 5) == 0) { + if ((interface) && rt_string_cmp((interface)->fDriveKind(), "ATA-", 5) == 0) { continue; - } else if ((*interface) && - rt_string_cmp((*interface)->fDriveKind(), "ATA-", 5) != 0) { + } else if ((interface) && + rt_string_cmp((interface)->fDriveKind(), "ATA-", 5) != 0) { return *this; } } return (ATADeviceInterface&)DeviceInterface<MountpointInterface*>::operator>>( Data); -}
\ No newline at end of file +} diff --git a/Private/Source/Utils.cxx b/Private/Source/Utils.cxx index fcdddc4a..11b7129a 100644 --- a/Private/Source/Utils.cxx +++ b/Private/Source/Utils.cxx @@ -94,8 +94,6 @@ Int rt_copy_memory(const voidPtr src, voidPtr dst, Size len) { ++index; } - dstChar[index] = 0; - return index; } @@ -108,6 +106,7 @@ const Char *alloc_string(const Char *text) { voidPtr vText = reinterpret_cast<voidPtr>(const_cast<char *>(text)); voidPtr vStr = reinterpret_cast<voidPtr>(const_cast<char *>(string)); rt_copy_memory(vText, vStr, rt_string_len(text)); + return string; } |