Kind of awful, really

Author: heimskr

include/Cache.h

@@ -52,7 +52,7 @@ namespace Thorn {
 				}
 
 				ensureSpace(1);
-				auto [iter, inserted] = map.try_emplace(key, std::bit_cast<void *>(list.end()), std::move(value));
+				auto [iter, inserted] = map.try_emplace(key, nullptr, std::move(value));
 				assert(inserted);
 				list.push_front(iter);
 				iter->second.first = std::bit_cast<void *>(list.begin());

include/hardware/AHCI.h

@@ -365,11 +365,11 @@ namespace Thorn::AHCI {
 		public:
 			constexpr static size_t BLOCKSIZE = 512;
 
+			Controller *parent = nullptr;
 			volatile HBAPort *registers = nullptr;
 			volatile HBAMemory *abar = nullptr;
 			volatile HBACommandHeader *commandList = nullptr;
 			volatile HBAFIS *fis = nullptr;
-			Controller *parent = nullptr;
 			volatile HBACommandTable *commandTables[8];
 			void *physicalBuffers[8];
 			Status status = Status::Uninitialized;

include/hardware/PCIIDs.h

@@ -1,4 +1,6 @@
-#include <stdint.h>
+#pragma once
+
+#include <cstdint>
 
 namespace Thorn::PCI::ID {
 	static constexpr const char *vendor_0001 = "SafeNet (wrong ID)";

src/arch/x86_64/Interrupts.cpp

@@ -2,8 +2,6 @@
 #include "arch/x86_64/control_register.h"
 #include "arch/x86_64/CPU.h"
 #include "arch/x86_64/Interrupts.h"
-#include "arch/x86_64/PageMeta.h"
-#include "arch/x86_64/PageTableWrapper.h"
 #include "arch/x86_64/PIC.h"
 #include "hardware/Ports.h"
 #include "hardware/PS2Keyboard.h"
@@ -17,6 +15,11 @@
 // #define DEBUG_PAGE_FAULTS
 #define DEADLY_PAGE_FAULTS
 
+#ifdef DEBUG_PAGE_FAULTS
+#include "arch/x86_64/PageMeta.h"
+#include "arch/x86_64/PageTableWrapper.h"
+#endif
+
 extern bool irqInvoked;
 
 bool abouttodie = false;

src/device/AHCIDevice.cpp

@@ -4,9 +4,10 @@
 
 namespace Thorn {
 	int AHCIDevice::read(void *buffer, size_t size, size_t offset) {
-		if (offset % AHCI::Port::BLOCKSIZE == 0 && size % AHCI::Port::BLOCKSIZE == 0)
-			return static_cast<int>(port->read(offset / AHCI::Port::BLOCKSIZE, size, buffer));
-		return static_cast<int>(port->readBytes(size, offset, buffer));
+		// if (offset % AHCI::Port::BLOCKSIZE == 0 && size % AHCI::Port::BLOCKSIZE == 0)
+		// 	return static_cast<int>(port->read(offset / AHCI::Port::BLOCKSIZE, size, buffer));
+		// return static_cast<int>(port->readBytes(size, offset, buffer));
+		return readCache(buffer, size, offset);
 	}
 
 	int AHCIDevice::write(const void *buffer, size_t size, size_t offset) {
@@ -17,45 +18,17 @@ namespace Thorn {
 	}
 
 	int AHCIDevice::clear(size_t offset, size_t size) {
-		if (offset % AHCI::Port::BLOCKSIZE == 0 && size % AHCI::Port::BLOCKSIZE == 0) {
-			char buffer[AHCI::Port::BLOCKSIZE] = {0};
-			AHCI::Port::AccessStatus status = AHCI::Port::AccessStatus::Success;
-			size_t last_pct = 0;
-			printf("0%%\n");
-			for (size_t i = 0, max = size / AHCI::Port::BLOCKSIZE; i < max; ++i) {
-				status = port->write(offset / AHCI::Port::BLOCKSIZE + i, AHCI::Port::BLOCKSIZE, buffer);
-				if (status != AHCI::Port::AccessStatus::Success) {
-					printf("[%d] Whoops: %d\n", __LINE__, status);
-					return static_cast<int>(status);
-				}
-
-				if (size_t new_pct = i * 100 / max; new_pct != last_pct) {
-					last_pct = new_pct;
-					serprintf("\e[F");
-					printf("%lu%%\n", new_pct);
-				}
-			}
-			printf("[%d] Whoops: %d\n", __LINE__, status);
-			return static_cast<int>(status);
-		}
-
-		size_t size_copy = size;
-		size_t chunk_size = 1;
-		while ((size_copy & 1) == 0 && chunk_size < AHCI::Port::BLOCKSIZE) {
-			size_copy /= 2;
-			chunk_size *= 2;
-		}
+		int status{};
+		char zeroes[BlockSize];
 
-		auto buffer = std::make_unique<char[]>(chunk_size);
-		for (size_t i = 0, max = size / chunk_size; i < max; ++i) {
-			AHCI::Port::AccessStatus status = port->writeBytes(chunk_size, offset + chunk_size * i, buffer.get());
-			if (status != AHCI::Port::AccessStatus::Success) {
-				printf("[%d] Whoops: %d\n", __LINE__, status);
-				return static_cast<int>(status);
-			}
+		while (size > BlockSize) {
+			if (0 != (status = write(zeroes, BlockSize, offset)))
+				return status;
+			offset += BlockSize;
+			size -= BlockSize;
 		}
 
-		return 0;
+		return write(zeroes, size, offset);
 	}
 
 	std::string AHCIDevice::getName() const {
@@ -84,6 +57,56 @@ namespace Thorn {
 		entry.flushed = true;
 	}
 
+	int AHCIDevice::readCache(void *buffer, size_t size, size_t offset) {
+		int status{};
+
+		auto advance = [&](size_t amount) {
+			offset += amount;
+			buffer = reinterpret_cast<char *>(buffer) + amount;
+			size -= amount;
+			return size == 0;
+		};
+
+		if (size_t rem = offset % BlockSize; rem != 0) {
+			auto [ref, created] = cache[offset / BlockSize];
+			StorageCacheEntry<BlockSize> &entry = ref.get();
+
+			if (created) {
+				if (0 != (status = read(entry.data, BlockSize, offset - rem)))
+					return status;
+				entry.flushed = true;
+			}
+
+			size_t affected = std::min(size, BlockSize - rem);
+			std::memmove(buffer, &entry.data[rem], affected);
+			if (advance(affected))
+				return 0;
+		}
+
+		while (size >= BlockSize) {
+			auto [ref, created] = cache[offset / BlockSize];
+			StorageCacheEntry<BlockSize> &entry = ref.get();
+			entry.flushed = false;
+			std::memmove(buffer, entry.data, BlockSize);
+			if (advance(BlockSize))
+				return 0;
+		}
+
+		assert(size > 0);
+
+		auto [ref, created] = cache[offset / BlockSize];
+		StorageCacheEntry<BlockSize> &entry = ref.get();
+
+		if (created) {
+			if (0 != (status = read(entry.data, size, offset)))
+				return status;
+			entry.flushed = true;
+		}
+
+		std::memmove(buffer, entry.data, size);
+		return 0;
+	}
+
 	int AHCIDevice::writeCache(const void *buffer, size_t size, size_t offset) {
 		int status{};
 

src/hardware/AHCI.cpp

@@ -179,7 +179,8 @@ namespace Thorn::AHCI {
 		cfis->lba3 = 0;
 		cfis->lba4 = 0;
 		cfis->lba5 = 0;
-		cfis->countLow = cfis->countHigh = 0;
+		cfis->countLow = 0;
+		cfis->countHigh = 0;
 		cfis->control = 0;
 
 		spin = SPIN_COUNT;
@@ -679,7 +680,7 @@ namespace Thorn::AHCI {
 				return status;
 			const size_t to_write = (BLOCKSIZE - offset) < count? BLOCKSIZE - offset : count;
 			memcpy(write_buffer + offset, cbuffer, to_write);
-			if ((status = write(lba, BLOCKSIZE, write_buffer) ) != AccessStatus::Success)
+			if ((status = write(lba, BLOCKSIZE, write_buffer)) != AccessStatus::Success)
 				return status;
 			count -= to_write;
 			++lba;

src/hardware/PCI.cpp

@@ -265,7 +265,7 @@ namespace Thorn::PCI {
 
 		if (vector & static_cast<uint8_t>(Vector::Legacy)) {
 			const uint8_t irq = getInterruptLine();
-			if (irq == 0xff) { 
+			if (irq == 0xff) {
 				printf("[PCI::Device::allocateVector] Legacy interrupts aren't supported by device.\n");
 				return 0xff;
 			} else {
@@ -387,6 +387,7 @@ namespace Thorn::PCI {
 					else
 						printf("%lu %x:%x:%x Vendor: %x, device: %x, class: %x, subclass: %x ",
 							device_count++, bus, device, function, vendor, device_id, baseclass, subclass);
+
 					if (Serial::ready)
 						Serial::write('\n');
 

src/memory/Memory.cpp

@@ -46,17 +46,19 @@ namespace Thorn {
 #ifdef DEBUG_ALLOCATION
 		printf("requestSpace(0x%lx, %lu)\n", last, size);
 #endif
-		BlockMeta *block = (BlockMeta *) realign((uintptr_t) end);
+		BlockMeta *block = reinterpret_cast<BlockMeta *>(realign(uintptr_t(end)));
 
 		if (last)
 			last->next = block;
 
+		end = reinterpret_cast<char *>(block) + size + sizeof(BlockMeta) + 1;
+
 #ifdef PROACTIVE_PAGING
 		{
 			Lock<Mutex> pager_lock;
 			auto &pager = Kernel::getPager(pager_lock);
 			auto &wrapper = Kernel::instance->kernelPML4;
-			while (highestAllocated <= (uintptr_t) block + size) {
+			while (highestAllocated <= uintptr_t(end)) {
 				pager.assignAddress(wrapper, highestAllocated);
 				highestAllocated += PAGE_LENGTH;
 			}
@@ -65,9 +67,8 @@ namespace Thorn {
 
 		block->size = size;
 		block->next = nullptr;
-		block->free = 0;
+		block->free = false;
 
-		end = reinterpret_cast<char *>(block) + block->size + sizeof(BlockMeta) + 1;
 		return block;
 	}