Initial work on disk caching

heimskr · heimskr · commit 08115e54e1df · 2024-04-27T20:08:36.000-07:00
diff --git a/include/Cache.h b/include/Cache.h
@@ -0,0 +1,106 @@
+#pragma once
+
+#include <functional>
+#include <list>
+#include <map>
+
+#include "Assert.h"
+
+namespace Thorn {
+	template <typename K, typename V, template <typename...> typename M, typename E>
+	class Cache {
+		private:
+			size_t maxSize{};
+
+			// The void pointer here is actually a list iterator...
+			// I'm sorry.
+			M<K, std::pair<void *, V>, E> map;
+			using MapIterator = decltype(map)::iterator;
+
+			std::list<MapIterator> list;
+			using ListIterator = decltype(list)::iterator;
+
+			static_assert(sizeof(void *) == sizeof(ListIterator));
+
+			void ensureSpace(size_t count) {
+				while (map.size() + count > maxSize) {
+					map.erase(list.back());
+					list.pop_back();
+				}
+			}
+
+			void moveFront(auto map_iter) {
+				auto &list_iter = *reinterpret_cast<ListIterator *>(&map_iter->second.first);
+				list.erase(list_iter);
+				list.push_front(map_iter);
+				list_iter = list.begin();
+			}
+
+		public:
+			using Key = K;
+			using Value = V;
+
+			Cache(size_t max_size): maxSize(max_size) {
+				assert(max_size != 0);
+			}
+
+			std::pair<MapIterator, bool> emplace(const K &key, V value) {
+				if (auto iter = map.find(key); iter != map.end()) {
+					moveFront(iter);
+					iter->second.second = std::move(value);
+					return {iter, false};
+				}
+
+				ensureSpace(1);
+				auto [iter, inserted] = map.try_emplace(key, std::bit_cast<void *>(list.end()), std::move(value));
+				assert(inserted);
+				list.push_front(iter);
+				iter->second.first = std::bit_cast<void *>(list.begin());
+				return {iter, true};
+			}
+
+			V & at(const K &key) {
+				if (auto iter = map.find(key); iter != map.end()) {
+					moveFront(iter);
+					return iter->second.second;
+				}
+
+				assert(!"Key is present in Cache");
+			}
+
+			const V & at(const K &key) const {
+				return map.at(key);
+			}
+
+			/** The bool in the returned pair indicates whether a new entry was created. */
+			std::pair<std::reference_wrapper<V>, bool> operator[](const K &key) {
+				if (auto iter = map.find(key); iter != map.end()) {
+					moveFront(iter);
+					return {std::ref(iter->second.second), false};
+				}
+
+				auto [iter, inserted] = emplace(key, V());
+				return {std::ref(iter->second.second), true};
+			}
+
+			void erase(const K &key) {
+				auto iter = map.find(key);
+				if (iter == map.end())
+					return;
+
+				list.erase(iter->second.first);
+				map.erase(iter);
+			}
+
+			auto begin() { return map.begin(); }
+			auto end() { return map.end(); }
+			auto begin() const { return map.begin(); }
+			auto end() const { return map.end(); }
+	};
+
+	template <typename K, typename V, typename C = std::less<K>>
+	using TreeCache = Cache<K, V, std::map, C>;
+
+	template <typename K, typename V, typename H = std::hash<K>>
+	using HashCache = Cache<K, V, std::unordered_map, H>;
+}
diff --git a/include/Kernel.h b/include/Kernel.h
@@ -15,7 +15,7 @@ namespace Thorn {
 	using PageFrameNumber = uint64_t;
 
 	struct StorageController;
-	struct StorageDevice;
+	struct StorageDeviceBase;
 
 	class Kernel {
 		private:
@@ -26,7 +26,7 @@ namespace Thorn {
 			std::unique_ptr<Locked<ProcessMap, RecursiveMutex>> processes;
 			std::unique_ptr<Locked<std::map<PageFrameNumber, PID>>> pageFrameProcesses;
 			std::unique_ptr<Locked<std::vector<std::unique_ptr<StorageController>>>> storageControllers;
-			std::unique_ptr<Locked<std::vector<std::unique_ptr<StorageDevice>>>> storageDevices;
+			std::unique_ptr<Locked<std::vector<std::unique_ptr<StorageDeviceBase>>>> storageDevices;
 
 			PID lastPID = 1;
 
diff --git a/include/Test.h b/include/Test.h
@@ -37,7 +37,7 @@ namespace Thorn {
 		AHCI::Port *port = nullptr;
 		bool ahci = true;
 		int idePort = -1;
-		StorageDevice *device = nullptr;
+		StorageDeviceBase *device = nullptr;
 		FS::Partition *partition = nullptr;
 		FS::ThornFAT::ThornFATDriver *driver = nullptr;
 		std::string path = "/";
diff --git a/include/device/AHCIDevice.h b/include/device/AHCIDevice.h
@@ -4,15 +4,22 @@
 #include "hardware/AHCI.h"
 
 namespace Thorn {
-	struct AHCIDevice: public StorageDevice {
-		AHCI::Port *port;
-		AHCIDevice() = delete;
-		AHCIDevice(AHCI::Port *port_): port(port_) {}
-		virtual ~AHCIDevice() {}
+	class AHCIDevice: public StorageDevice<AHCI::Port::BLOCKSIZE> {
+		public:
+			AHCI::Port *port;
 
-		virtual int read(void *buffer, size_t size, size_t offset) override;
-		virtual int write(const void *buffer, size_t size, size_t offset) override;
-		virtual int clear(size_t offset, size_t size) override;
-		virtual std::string getName() const override;
+			AHCIDevice(AHCI::Port *port_):
+				port(port_) {}
+
+			int read(void *buffer, size_t size, size_t offset) final;
+			int write(const void *buffer, size_t size, size_t offset) final;
+			int clear(size_t offset, size_t size) final;
+			void flush() final;
+			void flush(StorageCacheEntry<BlockSize> &, uint64_t block) final;
+			std::string getName() const final;
+
+		private:
+			int readCache(void *buffer, size_t size, size_t offset);
+			int writeCache(const void *buffer, size_t size, size_t offset);
 	};
 }
diff --git a/include/device/IDEDevice.h b/include/device/IDEDevice.h
@@ -1,16 +1,19 @@
 #pragma once
 
 #include "device/Storage.h"
+#include "hardware/IDE.h"
 
 namespace Thorn {
-	struct IDEDevice: public StorageDevice {
+	struct IDEDevice: StorageDevice<IDE::SECTOR_SIZE> {
 		uint8_t ideID;
 		IDEDevice() = delete;
 		IDEDevice(uint8_t ide_id): ideID(ide_id) {}
 
-		virtual int read(void *buffer, size_t size, size_t offset) override;
-		virtual int write(const void *buffer, size_t size, size_t offset) override;
-		virtual int clear(size_t offset, size_t size) override;
-		virtual std::string getName() const override;
+		int read(void *buffer, size_t size, size_t offset) final;
+		int write(const void *buffer, size_t size, size_t offset) final;
+		int clear(size_t offset, size_t size) final;
+		void flush() final {}
+		void flush(StorageCacheEntry<BlockSize> &, uint64_t) final {}
+		std::string getName() const final;
 	};
 }
diff --git a/include/device/Storage.h b/include/device/Storage.h
@@ -1,16 +1,46 @@
 #pragma once
 
+#include <cstdint>
 #include <string>
 
+#include "Cache.h"
 #include "Defs.h"
 
 namespace Thorn {
-	struct StorageDevice {
+	template <size_t Size>
+	struct StorageCacheEntry {
+		uint8_t data[Size];
+		bool flushed = false;
+
+		StorageCacheEntry() = default;
+	};
+
+	template <size_t CacheLength, size_t BlockSize>
+	struct StorageCache: TreeCache<uint64_t, StorageCacheEntry<BlockSize>> {
+		StorageCache():
+			TreeCache<uint64_t, StorageCacheEntry<BlockSize>>(CacheLength) {}
+	};
+
+	struct StorageDeviceBase {
+		virtual ~StorageDeviceBase() = default;
+
 		virtual int read(void *buffer, size_t size, size_t offset) = 0;
 		virtual int write(const void *buffer, size_t size, size_t offset) = 0;
 		virtual int clear(size_t offset, size_t size) = 0;
+		virtual void flush() = 0;
 		virtual std::string getName() const = 0;
-		virtual ~StorageDevice() = default;
+	};
+
+	template <size_t BS>
+	struct StorageDevice: StorageDeviceBase {
+		constexpr static size_t BlockSize = BS;
+
+		StorageCache<(1 << 20 >> 3), BlockSize> cache;
+
+		StorageDevice() = default;
+
+		using StorageDeviceBase::flush;
+		virtual void flush(StorageCacheEntry<BlockSize> &, uint64_t block) = 0;
 	};
 
 	struct StorageController {
diff --git a/include/fs/Partition.h b/include/fs/Partition.h
@@ -4,7 +4,7 @@
 #include <vector>
 
 namespace Thorn {
-	struct StorageDevice;
+	struct StorageDeviceBase;
 }
 
 namespace Thorn::FS {
@@ -18,13 +18,13 @@ namespace Thorn::FS {
 
 	struct Partition {
 		std::vector<Record> writeRecords, readRecords;
-		StorageDevice *parent;
+		StorageDeviceBase *parent;
 		/** Number of bytes after the start of the disk. */
 		size_t offset;
 		/** Length of the partition in bytes. */
 		size_t length;
 
-		Partition(StorageDevice *parent_, size_t offset_, size_t length_):
+		Partition(StorageDeviceBase *parent_, size_t offset_, size_t length_):
 			parent(parent_), offset(offset_), length(length_) {}
 
 		int read(void *buffer, size_t size, size_t byte_offset);
diff --git a/src/device/AHCIDevice.cpp b/src/device/AHCIDevice.cpp
@@ -1,5 +1,6 @@
 #include "device/AHCIDevice.h"
 #include "memory/Memory.h"
+#include "Kernel.h"
 
 namespace Thorn {
 	int AHCIDevice::read(void *buffer, size_t size, size_t offset) {
@@ -9,9 +10,10 @@ namespace Thorn {
 	}
 
 	int AHCIDevice::write(const void *buffer, size_t size, size_t offset) {
-		if (offset % AHCI::Port::BLOCKSIZE == 0 && size % AHCI::Port::BLOCKSIZE == 0)
-			return static_cast<int>(port->write(offset / AHCI::Port::BLOCKSIZE, size, buffer));
-		return static_cast<int>(port->writeBytes(size, offset, buffer));
+		// if (offset % AHCI::Port::BLOCKSIZE == 0 && size % AHCI::Port::BLOCKSIZE == 0)
+		// 	return static_cast<int>(port->write(offset / AHCI::Port::BLOCKSIZE, size, buffer));
+		// return static_cast<int>(port->writeBytes(size, offset, buffer));
+		return writeCache(buffer, size, offset);
 	}
 
 	int AHCIDevice::clear(size_t offset, size_t size) {
@@ -61,4 +63,76 @@ namespace Thorn {
 		port->getInfo().copyModel(model);
 		return model;
 	}
+
+	void AHCIDevice::flush() {
+		for (auto &[block, pair]: cache) {
+			flush(pair.second, block);
+		}
+	}
+
+	void AHCIDevice::flush(StorageCacheEntry<BlockSize> &entry, uint64_t block) {
+		if (entry.flushed)
+			return;
+
+		const auto status = static_cast<int>(port->write(block, BlockSize, entry.data));
+
+		if (!status) {
+			printf("Failed to flush AHCI block %ld\n", block);
+			Kernel::perish();
+		}
+
+		entry.flushed = true;
+	}
+
+	int AHCIDevice::writeCache(const void *buffer, size_t size, size_t offset) {
+		int status{};
+
+		auto advance = [&](size_t amount) {
+			offset += amount;
+			buffer = reinterpret_cast<const 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;
+			} else {
+				entry.flushed = false;
+			}
+
+			size_t affected = std::min(size, BlockSize - rem);
+			std::memmove(&entry.data[rem], buffer, 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(entry.data, buffer, 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;
+		} else {
+			entry.flushed = false;
+		}
+
+		std::memmove(entry.data, buffer, size);
+		return 0;
+	}
 }
diff --git a/src/device/IDEDevice.cpp b/src/device/IDEDevice.cpp
@@ -1,6 +1,5 @@
 #include "device/IDEDevice.h"
 #include "memory/Memory.h"
-#include "hardware/IDE.h"
 
 namespace Thorn {
 	int IDEDevice::read(void *buffer, size_t size, size_t offset) {
